Create missing point of a rectangle from right-angled triangle

Edit mode script.

Select face in face select mode and run script.
Finds longest edge (hypotenuse) doesn't test for right angle.
Creates a new vertex at location of other vert.
Rotates it 180 degrees about the hypotenuse.
Creates a new face from new vert and hypotenuse edge.
Uncomment (remove #) from #bmesh.ops.dissolve_edges(bm,
edges=[le]) to dissolve the hypotenuse edge, if you want the
resultant quad.

import bpy
import bmesh
from mathutils import Matrix
from math import pi

context = bpy.context
ob = context.edit_object
me = ob.data

bm = bmesh.from_edit_mesh(me)

f = bm.select_history.active
if isinstance(f, bmesh.types.BMFace) and len(f.verts) == 3:
    # longest edge
    le = sorted(f.edges, key=lambda e: e.calc_length()).pop()
    v = (set(f.verts) - set(le.verts)).pop()
    nv = bm.verts.new(v.co)
    bmesh.ops.rotate(bm,
            cent=le.verts[0].co,
            matrix=Matrix.Rotation(pi, 3, le.verts[0].co - le.verts[1].co),
            verts = [nv],
            )
    bm.faces.new([nv] + le.verts[:]).select = True
    #bmesh.ops.dissolve_edges(bm, edges=[le])
    bm.normal_update()
    bmesh.update_edit_mesh(me)


Is there a way to quickly switch Themes?

You can use Only Rendered and Wold Background to achieve the same result.


Mesh deforms when parenting to the armature

9 out of 10 times, rigging problems are caused by problems in scaling.
make sure that figure feet are at world center and the armature fits in it.
Before you autorig, apply scale(and other transforms) to the mesh and
apply scale (and transforms) to the bone system


So here is a method to make a non-sliding walk cycle. This is the Dopsheet part, once you have finished, when you'll move the character through the scene from point A to point B, you'll need to adjust the speed so that the walk doesn't slide, but it's another topic.

In the Dopesheet, put your cursor at frame 0, switch your armature to Pose mode, don't move the root bone for the moment, just create a pose with spread legs and hip a little bit down, align the heel of the front foot (let say left foot) with the tail of the root, select all the bones and create a LocRotScale keyframe.

Copy the whole pose, go to frame 20, paste the flipped pose, create a keyframe for all the bones. In the Dopesheet press T and choose Interpolation > Linear to make the Graph Editor curve linear.

Stay at frame 20, move the whole armature (with the bone) until the left foot is aligned with its position at frame 0 (which is now the position of right foot as the pose as been symmetrized). You can create an empty as a marker if it helps. Create a keyframe.

At frame 10 create the intermediary position: lift the right foot and move up the hip. Select all the bones and create a keyframe.

At frame 40, put the root bone at a position on Y axis that is twice its position at frame 20. Use the Location value in the N panel and keyframe it.

Now, copy the bones at frame 0 (except root) and paste them at frame 40. Insert a keyframe. Copy the bones at frame 10 poses (except root) and paste flipped at frame 30.

Disable the root animation so that the character walks but always stay at its position.


How to make a bump map from a texture paint?

I use an rgb image with 0.5 value (gray) and then plug that into a bump node, and then plug that into the Normal socket of the shader node. I paint in black to sink, white to raise but that can be inverted on the bump node.


It is currently not possible to directly keyframe the emission of particles in Blender.

But you can use a collision object that completely surrounds the emitter object. Make sure that you check the "Kill Particles"-checkbox and then keyframe the Permeability-setting to let particles through the collision object when you want them to "escape".

You can find more info on Collisions in the Blender manual.


Bump mapping vs Displacement (plus displacement nodes in Cycles)?

Question 1: How does the Displacement input of the Material Output node work?

Depends what feature set you are using for rendering:

In Supported feature set it does Bump mapping, same as plugging Bump node into all your shaders.
In Experimental feature set is follows what you set in the Material properties:

So for True Displacement you need to set the feature set to Experimental, and set a setting for the Material. More on this here:

Blender Cycles True Displacement

  Question 2: In the documentation (2.79) two nodes are expected to be connected to the Material Output node: Displacement and Vector Displacement.

The documentation is continuous work in progress and does not adhere to any specific Blender version. There might be sections outdated or put beforehand of features that will come in future, like in this case Vector displacement.


How do I organise and save separate animations in blender?

I think I found what you need. If you go to the animation timeline and change the type to dope sheet, you should see an option next to it that lets you change the type to action editor. This will let you add new actions and save multiple different animations in one rig.
Not entirely sure how you would do it but I think that you may be able to make only certain bones animate for certain actions so if you are running you can have multiple animations only for the arms, and then have variations with holding different guns and shooting as well. Same with the legs too. So you could try and split the rig into those two parts with seperate animations.


Could be this?

# Select all vertices in Edit Mode
bpy.ops.mesh.select_all(action='SELECT')

# Do intersect
bpy.ops.mesh.intersect()
bpy.ops.mesh.intersect(mode='SELECT')


How can I pause a render in progress and then resume it at a later time?

On Mac OS it is not necessary to have started Blender from the command line.  You may use the "kill" command to send a stop and continue signal...

$ ps -ax | grep Blender
3554 ??       750:42.18 /.../.../Contents/MacOS/Blender
$ kill -s SIGSTOP 3554
$ kill -s SIGCONT 3554

There is a way to 'pause' Blender (or any software for that matter), but it relies on the operating system rather than Blender itself.

Mac OS X and Linux:

You must start Blender from the command line or terminal.
At any time, you can completely suspend Blender by pressing Ctrl+Z from the terminal window.
The terminal should say something like:

^Z
[1]+  Stopped                 /Applications/blender.app/Contents/MacOS/blender

You cannot interact with it until you you type fg in the terminal. Which will bring Blender back to the foreground.

Windows:

Have the console window open (Window > Toggle System Console)
Use the cursor to highlight any of the text in this window will freeze the console and pause Blender. This is a super hacky way to actually pause Blender, but it works in a pinch. See https://stackoverflow.com/questions/30418886/how-and-why-does-quickedit-mode-in-command-prompt-freeze-applications for detailed explanation of why this happens.


Enable cycles render and add a new Principled BSDF material for your object.
Set metallic to 1.
Find the correct base color for your metal.
Adjust roughness based on how sharp or blurry you need the reflections to be.


How to deform multiple mesh objects with one manipulator?

You should be able to do this with an armature.

Here a simple Rubik's cube like mesh object parented to an armature.

The second cube is a linked duplicate.

The cube blocks on the face that rotate have been assigned to a vertex group, as we can verify in Weight Paint Mode.

After creating your armature make sure the bone is in the right place and has no rotation issues. You can lock the transforms so it doesn't rotate in undesired ways.

When parenting the cube to the armature Set Parent to "Armature Deform with Empty Groups".

Ensure that the groups and bones have matching names.

Here's the .blend from the screen shots in case I forgot to explain anything:


How to create a submenu especific shortcut?

Open any menu you would like to have assigned a shortcut to. Right click on the menu item to assign a shortcut.


Why isn't the modifier icon appearing when an object is selected?

Metaball objects cannot have modifiers applied to them. Once an object that can have a modifier applied to it (like a mesh or a curve) is selected the wrench icon will appear.

Objects that can have modifiers added to them are:

Meshes
Curves
Surfaces
Text
Lattices


subdivision surface modifier wrinkles mesh

It may not be apparent in some views, but if you check face orientation your normals are inverted on half the mesh in a striped pattern.

A recalculate outside with everything selected should fix this.


How to pull sequencer data from the top left corner and to the right lower corner

Python's sorted() can use a custom function that defines the key to use when sorting a list and it also has a reverse option.

def start(strip):
    return strip.frame_start

def end(strip):
    return strip.frame_start + strip.frame_final_duration

Then you can sort by start or end frame with

seq_strips = bpy.context.scene.sequence_editor.sequences

strips_by_start = sorted(seq_strips, key=start)

strips_reversed = sorted(seq_strips, key=end, reverse=True)


How To Smooth Shade Newly Added Mesh To an Already Smooth Shaded Object

Okay so I found the answer after playing around with it for a little bit.

What you need to do is select the new rough mesh you want to smooth in edit
mode and press P to separate "Selection" as suggested by @Jagredom .

Then with the mesh selected click on the smooth shading button from Object mode.

After this you have to switch to edit mode with the mesh still selected and click on the recalculate normals button under the Shading/UV Tab. This will get the mesh smooth and uniform with the full object.

Then you can rejoin the two objects by clicking on both of them while holding shift and then pressing ctrl + J


I found a way !!!

return len(bpy.context.selected_objects) == 0

This works just fine :)


It looks like your boots are parented to bones that they are not supposed to. The simplest way to fix it is to select them in Edit mode, then in the Properties panel > Data > Vertex Groups > on the right of the vertex groups list, click on Remove from All Groups so that this part of the mesh won't be controlled by any bone. Now, keep your armature in Pose mode, select your object, go in Weight Paint mode, select the bone to which the boot is supposed to be linked and paint the boot with a brush in Blend > Mix mode.


The BGE runs on

Windows,
MacOS,
Linux.

Nintendo, PS2, Mobile phones do not run that platforms. So you can't use the BGE there even if there is a matching OpenGL support. (OpenGL is another requirement, not the only requirement)

  I want to create a game that can possibly be ported to Kivy or Unity which can be ported to other systems

I'm not sure how you interpret porting a game to another platform or to use different frameworks. You basically develop a completely new application that feels like the original one. So the "business" stays the same while the application is completely different.

It is nothing ...

  for learning how to script or create games

If the question in your mind is meant to be:

can I create BGE games on my mobile phone? the answer is no.
can I run my BGE game in my mobile phone? The answer is no.
can I transfer my BGE skills to other game engines that run on mobile phones? The answer is ... some of them:

concepts of game development.
scripting?

general concepts - yes
specific code - no
specific methods - not likely

[Edit]

  Can I create an OpenGL 1.1 game on Blender 2.78 32-bit Game Engine?

I can't tell. Accoring to this question Blender 2.77+ needs OpenGL 2.1. I have no idea if that is compatible with OpenGL 1.1.

The supported OSes remain the same as mentioned above (WinOs, MacOs, Linux).

You might try it out by setting up a Linux with OpenGL 1.1 only.


Reference image moves "around" objects instead of sliding through them

Disable the Snap option (magnet icon on the top menu bar), if you enable it, it will make the object you move stick to the selected mode.


Vertex Groups assignment from Makehuman mesh

Selection

You could assign the vertex groups (VGs) starting from a hand make sure that you name the groups with suffixes e.g ForeArm.L, ForeArm.R (this is required to let Blender know which vertex groups correspond).

Invert the selection Ctrl-I

Deselect (MMB while in Select Mode) all vertices which should not belong to the ForeArm VG. Note that you can also use already assigned VGs to help exact deselecting (especially for the head and upper body parts).

Repeat this process for all VG assignments on one side.

Mirroring (using Mirror Modifier)

Finally use Mirror Vertex Group to copy the VG data from one side to the other, Note that empty VGs with matching names are required.

The mirror isn't very intuitive due to its prerequisites, therefore I suggest first to watch the video and first try it with a single VG:

Video Mirror Vertex Groups (Spanish)

From the docs of Mirror Modifier

  Vertex Groups
  When this button is enabled, the Mirror modifier will
  try to mirror existing vertex groups. A very nice feature, but that
  has quite specific prerequisites. First, the vertex groups you want to
  mirror must be named following the usual left/right pattern (i.e.
  suffixed by something like “.R”, “.right”, “.L”, et cetera). Next, you
  must have the “mirrored” groups already existing (i.e. same names
  suffixed by the “other side”) and completely empty (no vertex assigned
  to it), else it won’t work. Usually, the mirrored copies of the
  vertices of a group remain in this group. Once this option is
  activated, all groups following the rules described above will only be
  valid on the original object – the mirrored copy will put these same
  vertices into the “mirror” group. Very handy with armatures, for
  example: you just model half of your object, carefully rig it with
  half of your armature, and just let the Mirror modifier build the
  other half. Just be sure to put your Armature modifier(s) after the
  Mirror one. A final word about multi-axes mirror: in these cases, the
  “direct”, “first level” copies get the mirrored groups, the copies of
  copies (“second level”) get the original groups, et cetera.


There is two things to consider. First, API changes have been made, and one of the decisions was to remove the register_module() and unregister_module() convenience functions. The code below is an excerpt from the more detailed Release Notes of Blender 2.80 (https://wiki.blender.org/wiki/Reference/Release_Notes/2.80/Python_API/Addons#Registration):

classes = (
    FooClass,
    BarClass,
    BazClass,
)

def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)

def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)

Second, the INFO_MT_file_export has been moved to TOPBAR_MT_file_export. So your code should be this in the end:

__classes__ = (
    list_of_classes_you_have
)

def register():
    for c in __classes__:
        bpy.utils.register_class(c)
    bpy.types.TOPBAR_MT_file_export.append(menu_func_export)
def unregister():
    for c in reversed(__classes__):
        bpy.utils.unregister_class(c)
    bpy.types.TOPBAR_MT_file_export.remove(menu_func_export)
if __name__ == "__main__":
    register()


You need to plug the texture color into the height, and not the normal input of the displacement node.
You can play with the scale field if the displacement seems too high.


I suffered from this same problem, When you select TexDraw as your brush it automatically selects a texture to draw with, in which case is usually the new black texture you made to paint on so everything is black and will never be anything but.  Just clear the texture from the TexDraw brush and you're in business.


Principled Volume not showing up in Cycles Render

Looking at your material nodes, you are mixing a Surface Shader (Transparent BSDF) in with the volumetric - this may be the cause of your problems as the preview may behave differently to the actual render (especially with versions that support Eevee since the material preview will use Eevee to render while the actual render is using Cycles).
Generally you do not need to mix in 'transparency' with volumetric shaders - simply control the Density instead; ie, zero density is 100% transparent.
Try connecting the Principled Volume directly into the Volume socket of the Material Output and use the Noise Texture to vary the Density of the volume rather than to vary a mix shader.


Here's a video explaining how:
https://www.youtube.com/watch?v=KgPDe2GoiRY

What you want to do is open the graph editor, and select the keyframes that you wish to loop over (over their respective time period), press Shift + E, and select "Make Cyclic (F-modifier)".


How to get Z-distance (not depth) from camera to object for every pixel in the frame?

The Camera Data node will give you a shader which will return the values you are looking for in the pixels of an image.

Here's a calibration scene. The camera is at World (0,0,1), the planes are at Z = 0, 1, 2, 3.

With this shader set-up, the pixel-value will be Z-component of the vector from the camera to the shading-point. ( You could also have shaded the planes using the Texture Coordinate node, in the Object space of the camera, and taken the Z component of that)

The nodes in the 'Illustration Only' frame are there to bring the lengths into a 0-1 range.. you wouldn't use those. Ensure the render output is linear, (set the Color Management to 'Raw'), and save to a floating-point format, probably, as you say, EXR, (in which case, as @susu has commented, color transforms will be bypassed.)


I use the exact same script you linked to and I works fine.
You don't have to get rid of the 'x" in the end as this is only a suffix Gildor, the creator of umodel, introduced because his tool adds some additional values useful to modders. The downside is that a PSKX file cannot be opened inside the UDK. The 'x' simply tells the user that this is psk has been modified.


NLA Editor: select specific NLA track in python

Set the NLATrack.select property to true.

Sample script, selects all tracks, on context object, which have a name beginning with "Nla" The zeroth position track is set to active.

import bpy
from bpy import context

ob = context.object
ad = ob.animation_data
if ad:
    for i, track in enumerate(ad.nla_tracks):
        # select all whose name starts with "Nla"
        track.select = track.name.startswith("Nla")
        # make active track if in pos 0
        if track.select and not i:
            ad.nla_tracks.active = track


How can I change the order of workspaces tabs?

Decide which order you want your workspaces in.
Right-click the first (leftmost) and select Reorder to Back.
Continue the same with the next (second leftmost) workspace and so forth.

When you're done Reorder to Back on every workspace, they'll appear in the order you wanted.
Tip: Instead of having to redo this whole process when you want to insert a new workspace: Right-click on the workspace you want to precede your new workspace and choose Duplicate.


Is there a way to separate colors from chained mix rgb nodes?

Here is a way that can help :

I dont consider here the way you are using this kind of ramp, but I have just focused on a way to obtain the ramp. So I did not wanted here to reproduce the way you are using the shader (only the ramp).

This "pseudoRamp" node group is a thread of several "rampMix" nodes groups (this node group can be reused to have more or less colors as inputs) :

And the role of each of them is to give a color between two (the previous color and the tested color) depending if the value is in between the values margins.

Here is the "rampMix" :

And the "rampMix" itself uses a "between" node group :

This last "between" node group needs to handle the limits of "lesser than", as it is strict ("<" and not "<="). So we cannot use "lesser than" with a "greater than" or we will miss the limit value.

Here is the blend file

Note : this is not perfect at the limit, as you cannot downgrade the amount of colors (the last will stay last, but previous ones can overlap each other). So a little enhancement is needed for that.

Complement for the criss crossed aspect

The nodes described above can be mixed in order to make crossed color lines :

The first nodes on the left are here to modulate the amount of strips and are based only on the X, Y values in order to cross these axis only.


Randomizing crowd scenes with instanced models

My hammer is python, and your problem looks like a nail.  I would develop python that can instantiate copies of the bodies and hairpieces at the proper locations (http://web.purplefrog.com/~thoth/blender/python-cookbook/link-mesh-array.html illustrates the basics of this technique).

Linking meshes with armatures is done with modifiers like in http://web.purplefrog.com/~thoth/blender/python-cookbook/bone-orientation-demo.html (which also includes examples of adjusting the orientation of bones).

A python solution to your problem is somewhat involved, but I am optimistic that there are examples of all the techniques you need somewhere on stackexchange or google.


How to let a cable hang so that it look realistic

A cloth simulation can give the general movement and can be pined to the ceiling.

But we need a rigid shape for the cable and a curve is good for that.

To make the link between cloth mesh and the curve, we can use empties:

Empties are parented to the cloth mesh vertices
And curve vertices are hooked to the empties

Concerning the lamp: empties parented to the mesh vertices won't rotate but simply follow the movement.

So we add a bone:

The bone has two constraints: one to follow an empty (the rightmost one), the second to track to an empty (the one just before on the right)
And the lamp mesh is parented to the bone

The cloth mesh

It is a subdivided segment, with a cloth simulation modifier.
The leftmost (or more if you need) is in a "pin" vertex group and this group is used as pin group is the cloth simulation.

Mesh extremity / position of the lamp

Add two empty at a position corresponding to the right extremity, where the lamp will be placed.
Select one empty, shift select active the mesh
Enter edit mode
Select the vertex corresponding to the empty
Then CtrlP to vertex parent the empty
Do the same for the second empty

Add a bone and align it to the position of these two last empties
Then add two pose mode constraints, so that the bone will follow the empty (copy location) and the bone's tail will target to the other empty (damped track)

At this step, you should already obtain this:

Creating the curve cable

The curve is obtained from the cloth mesh by copying it and convert it to 'curve', so that the curve has the same amount of vertices than the mesh (we'll just remove the rightmost as it corresponds to the lamp).

Now we hook this curve vertices to new empties: CtrlH to hook and ShiftR to repeat on each vertex to the right.

Now link the empties to the mesh/cloth, with the same step we did at the beginning with the empties used for the bone (vertex parenting).

At the beginning below we just scale down the empties and hide the curve in order to facilitate further selections.

Last steps

Add a bevel to the curve to make it look like a cable
Add a subdivision surface to the curve to make it smoother
Tune the mass of the mesh/cloth (maybe around 1kg) to simulate the lamp weight


When using the 2D tools is it possible to copy drawings into the next frame?

In the dope sheet, just select the keyframe and duplicate it(shift-d) to wherever you want.

I would also like to mention that you don't have to slide your objects to pan the camera(assuming your using 2.80, which you definitely should, especially for 2D animation because there is major improvements.)  This is part of the beauty of using a 3d program for 2d animation.  you can animate the camera itself.

please comment if you need more information.


Is it possible to interactively control/manipulate objects in Blender Internal/Cycles to have more realistic physics simulations?

You are confusing physics, rendering and interaction, which are three different worlds in a 3d package like blender. If you want interaction then you need to use any game engine like unreal, optimized to calculate simulations (based on assumptions) as well as additional interactions in real-time.

However, with that benefit of having a real-time simulation, you obviously forfeit simulation quality and especially image quality. Notice that even in a game engine, the simulation of physics only means object interaction and is another thing as how all the meshes are calculated to a final image.


How do I render a shiny metallic or chromed material?

Your HDRI doesn't have enough contrast.

Use default Principled BSDF shader with Metallic = 1, and Roughness = 0.1
Add a contrasty HDRI
Done.


Is it possible to generate similar animation show in the video with AN in 2.9

Yes it is possible in newer version of Animation nodes. Before doing this type of animation we have to prepare our objects. Make sure that the objects have loose parts(we can't do this on a single mesh). Each objects should have appropriate orgin for better looking animation.
Let's look at this example, I have a cycle object which is composed of multiple objects. So i put everything into a collection 'cycle' for ease of use.
Next step is storing the current transforms(location,rotation,scale) of every objects into a ID Key. This is important because when using nodes like Object Transform Output or Object Matrix Output will set objects transforms to a default value.
We can create ID key by:

The ID key can be accessed inside nodetree by:

Next step is driving the scale and rotation of objects with a falloff. There are different types of falloffs are available in animation nodes. Here i used Delay falloff for demonstration.

See Animation nodes Documentation for more info


How do I make a bone active using Python?

Understood how in edit mode.
bpy.ops.object.mode_set(mode='EDIT')
arm = bpy.data.armatures['Armature']
bone = arm.edit_bones["Bone"]
arm.edit_bones.active = bone


A Disabled User in need of Suggestions/Help (UI Question)

You might want to look at programs like Stroke Plus. It allows you to add multi-key keyboard shortcuts to mouse gestures,without having to take up more shortcut keys on a already crowded keyboard.
Really almost anything you can do with a keyboard such as type in commands or strings like an email address. You can assign gestures globally or per-program.
See the video on the home page for a quick explanation.
I have used this for years to speed up programming.


How to go about modelling this roof shape in Blender?

I guess you need to switch to another way of modeling in Blender (compared to some other 3D softwares), you could start from the shape you show but maybe the best is to start from scratch.
Create a cube, subdivide, pull the top edge:

Create an additional edge loop on the left:

Extrude the side walls:

Cut an horizontal edge:

Pull the vertex:

Rework a bit (the knife tool is useful, K to activate, W to cut through, C to cut perpendicularly, also bevel for the top, CtrlB):

Since latest versions you have the Extrude Manifold tool (AltE) that allows to work a bit like Sketchup or others, but you often need to give some corrections afterwards to keep a good topology (good doesn't meaning a lot, it all depends on your needs of course):


How to convert selected polygons to their boundary edges?

There's a menu item for this: Header > Select > Select Loops > Select Boundary Loop. Candidate for a shortcut, if you use it a lot.


Is it possible to animate the speed of a strip?

In the VSE with your video strip selected add a speed control effect strip. With the speed control strip selected, in the properties sidebar N under Effect Strip is an option 'Stretch to input strip length', this needs to be off, when it is off you will get a speed factor setting. The speed factor can be keyframed to alter the speed as you want.


Why are the control points/inner lines on the inside of cup leaking out when I zoom out?

Set the clip end distance to a smaller value (it's in the view tab,
  press N if you can't find it)

Thanks @sacrish


Fluid going through a surface even though it is an obstacle

For your Obstacle object, under Properties panel> Physics > Fluid > Volume Initialization:, select Shell.


glTF: How to optimize exported glb file from blender having more number of loop-cuts?

If your goal is a smooth appearance, you can use smooth normals to give the effect of a smooth surface with fewer loopcuts. If you are sure you need the loopcuts, your options are:

Disable export of normals, tangents, UVs, and any other per-vertex data you aren't using in the exporter settings.
The glTF format supports compression, but you'll have to apply it to the model after exporting from Blender. Use glTF-Pipeline to compress the model with the -d flag and you should see a file size reduction of 90-95% for models that contain primarily geometry.


Why does this cycles render have grainy edges?

As suggested in the comments, this is an artifact from anti-aliasing.

In the Film section of the Render tab in the Properties panel, set the Width of the Pixel Filter all the way down (0.01). That in essence turns off the anti-aliasing.

If you are using a shadeless material (Emission shader) so noise is not a problem, then there is another way to remove the anti-aliasing.
Set the samples to one.
With only one sample there are not enough samples for the anti-aliasing algorithms to work, because there is only one.


Change start and end frame of rigid physics simulation with python

Just figured this out, hopefully this helps someone else. If you access the point cache within the rigid body world, this has a frame start and frame end which you can change with, for example:
scene.rigidbody_world.point_cache.frame_start = 1
scene.rigidbody_world.point_cache.frame_end = 1000


I think it's a know bug, but no solution has been found yet. Not much you can do but wait for a solution.

See here https://developer.blender.org/T45093


Data visualization using Dynamic Paint /Particle System

From description it's quite hard for me to understand if your question is a goal of your needs or only if your question covers your vision - to get something you know about it.

  Is it possible to convert my datacloud into a Particle System?

Yes.

Create "New" particle system with your point cloud (brush) object selected
Setup the number of particles same as vertices of your "brush" object
Set Emit from "Verts" (uncheck "Random")
"Physics" set to "No"
In "Render" panel of particles properties check on "Unborn" and "Died"

From how many vertices point cloud consist? Just select object and see header of blender window (next to the logo - "Vert:").

From your screen it looks like vertices represents some volume. For
that you can visualized vertices with new "Point Density" node. Check
this part of video https://youtu.be/GhwzIQ6qZO8?t=464
If you'r looking for a way to convert your point cloud into a mesh
search for remesh  or point cloud skinning.


Depth of field in EEVEE not focusing on selected object, works fine in cycles

This is a mix of unwanted settings and a precision issue. First, as p2or already pointed out in the comments, there is a max size setting in the Depth Of Field area of the render settings in Eevee:

This size defines the maximum size of the bokeh shape. Effectively that means it can limit the amount of blur that is added to the rendering in Eevee. Your setting was around 4.3, which was a bit on the low side. Raising it to 10 already gives more visible DOF blur. The default is even 100.

Second, when setting a Focus object, keep in mind that the Origin of that object is used for calculating the DOF distance. On your letter F, the origin is somewhat inside the geometry:

Now, Cycles is very precise when tracing the scene, while Eevee takes its shortcuts. As a result, in Cycles the F looks ok (when in fact it is also a little blurry), while in Eevee it quickly drops out of focus. For your scene to keep the letter F in focus, it is necessary to set the focal point exactly on the front face of the F. I did this here using an empty:

The resulting image will then be like this:

Move the empty slightly forward and backwards, and you will see the blurred region flicker and jump. The result will still not be the latest and greatest, as there is that light wrap effect on the now in focus letter. Testing further, I noticed that this might be an inaccuracy of the blur calculation again. It kind of wraps into the edge area of the Alpha channel. If you turn on Transparent in the film settings and render, the image looks like this:

But in the Alpha channel, now we see that strange post processing blur. Look at the edges of the F:

That edge blur is what makes the F look blurry, even though it is in focus. So unfortunately, I believe for the scene you're working on, Eevee might not be sufficient for a final render in the end. One thing you could consider is rendering without blur in Eevee, and applying the DOF in post using the Z-Depth pass.

This would be the node setup required (remember to turn off Depth of Field in the Camera before rendering):

And this is the resulting image:

This gives you post-pro DOF adjustment ability as a bonus.


How do I display a mesh with curved lines?

In Blender, this is the result of checking 'Wire' and 'Show All Edges' in the Object tab > Display panel, while also checking 'Optimal Display' in a Subdivision Surface modifier.


Can Pixar USDZ files imported into Blender?

Yes. Donwload the latest version from here: https://github.com/robmcrosby/BlenderUSDZ
In Blender: Edit > Preferences > Addons > Install > Select the zip and make sure the add-on is enabled.
Related: How to download and install an add-on hosted on github properly?


It depends on the render engine you are using:

Blender Internal:
Properties > World Tab > Horizon Color

Cycles: Properties > World Tab > Surface > Color


How to Export proportional UV Layout in blender?

Not sure I am understanding your question exactly as default Blender UV export size is 1024 x 1024 or about 27cm on the x and y.

When exporting UVs from Blender, after going to UVs > Export UV Layout there is a little panel in the bottom left where you can modify the output size.

The exporter only takes values in pixels, if you want definite values you can just simply use a converter like this one. translatorscafe.com, just put your desired centimeter value in and it will give you the equivalent in pixels.

As per brecht's comment below, conversion among such units is not as simple as it seems, one key factor involved is the dots per inch (DPI) of your current display. To take that into account, you can use this converter.


Scaling on X axis changes XY axis angles

As Mr Zak has said: if you scale a trapezoid board lengthwise, the angle of the skew end is modified. Would it perhaps be possible to use the Boolean modifier to cut the ends exactly?


What physics make an object not pass through another, if it's the "Child Of"?

If you need physics for the project you're working on. You'll want to set the origin of each of your arm pieces to their joints. Parent the arm to the body. Then use a limit location constraint to keep the arm attached to the body. To do this copy the location coordinates to the maximum and minimum values for each axis, activate all the check boxes, and change the convert value to local space.

To unattach and reattach the arms you will probably need to write a script that will remove the parent relationship and the constraint between the arm and the body when a certain event occures and then set up the relationship and constraint again for the new arm.

As for picking stuff up, a similar limit location and parenting set up should work in conjunction with another script.


How to do a bezier interpolation mode animation along a path?

When you parent an object to a curve with Follow Path to control its motion,

In the curve editor you'll be presented with a straight line for the evaluation time with no keyframes or any way to control the interpolation. To fix that press N to access the properties for the curve, look for the modifiers section and erase the generator for the curve.

Now you can manually animate the motion of the object by animating the evaluation time on the curve using keyframes, those keyframes will default to bezier interpolation.


Scene raycast
Having recently answered https://blender.stackexchange.com/a/192827/15543 it appears this is another good contender for scene raycast.
Given two global points in the scene raycast from one in direction of other as far as the distance between them Repeat until there are no more obstacles to hit.
import bpy
from bpy import context

from mathutils import Vector

a = Vector((-5, 0, 0))
b = Vector((5, 0, 0))

scene = context.scene

hit, loc, norm, idx, ob, M = scene.ray_cast(
        context.view_layer,
        a,
        (b - a),
        distance=(b - a).length,
        )
if hit:
    print(f"Hit, removing {ob.name}")
    bpy.data.objects.remove(ob)


In single image render trail of moving objects

It is possible by using Animation nodes.

Here is a setup for duplicating and distributing objects on every frame:

  there are multiple markers that I would like to render the trails of.
  Furthermore it seems impossible to set a maximum lengh of how far the
  trail goes into the past.

For more control nodes are more complex. This node-setup gets objects from group and arranges markers between selected frames:

I provide blend-file (note, AN must be enabled):


You can't do precisely what you want, but SHIFT-ALT-L will bring up a dialog that allows you to quickly modify the label
(Not sure if this requires Node Wrangler or not. If it does, simply enable Node Wrangler in user preference -> Add Ons.)


Apply Auto Smooth and its angles in a script

Maybe use something like this which first selects all the objects that you have listed in 'new_objects', and sets autosmooth to 1 on them, then once they're all selected it sets smooth shading on all of them

import bpy
import math

for obj in bpy.data.objects:
    obj.select = False  # safe to un-select first, all objects.

    ''' if you have a 'new_objects' list , then skip objects not on the list: '''
    # if not (obj in new_objects): continue

    if obj.type == 'MESH':
        obj.select = True
        obj.data.use_auto_smooth = 1
        obj.data.auto_smooth_angle = math.pi/4  # 45 degrees
        # ob.data.auto_smooth_angle = math.radians(40)  # 40 degrees as radians

bpy.ops.object.shade_smooth()


You could:

Make a flat plane, and create UVs.
It should automatically adjust to the texture you have.
Duplicate it, and then move it to each side, so that you create that checker board pattern you want.
Then, you could simply create a cylinder and use it in a boolean operation to cut the flat planes into the circular shape you want.
You'll need to do some extra cleanup, but it should work.


If you want to add a text-object, switch to object mode.

Then press Shift+a and select the "Text"-option, to add a new text-object.

Because the new text-object is rotated by default, you may not see it from your perspective, so rotate it on the x-Axis by 90°. (r+x+90)

The text can be altered if you have it selected and press Tab, to enter edit mode, then change your text as in any text editor. Press tab again, to exit edit mode. Other text settings like the font can be found in the right side panel.


I would just go for some retopo scheme.  If you overlap and align them both you can then build up a new mesh using conventional methods for generating clean meshes from ones that are not so clean.

The problem you are facing is very similar to the issues facing Dynatopo sculpts so the solutions you have are pretty much the same as well.

Once they are aligned properly with each other, you can select them both and merge them into one object, Ctrl-J.  Next you can use the CG Cookie Contours tool to rough out most of the new mesh that will be based on these two as one base.

There are also other methods that you can employ without using Contours.  You can just start with a point in edit mode and extrude it out along the surface of the scanned models and by using the Magnet tool you can keep the points moving along the surface of the base mesh.

Also, if you model a low-poly, rough hand shaped model, you can use the Shrink Wrap modifier to project the new mesh onto the scanned models.


Particle Info Node in a Different Object

I don't know a exacly soution for your question. But there is a way to do something like that... Instead of using the Particle Livetime you can use the heat Attribute, a Math noder and the ColorRamp.

Rename the Attribute "color" in "heat" (or add a blank Attribute node)
Add a Math node, change to multiply
Enter a colorramp
Connect the Colorramp with the color input of Volume Scatter and Volume Absortion.
Play with the value of the Multiply Node and the Positions inside the Colorramp
If you want thicker Smoke increase the Multiply Value of the density
also play with the temperature settings of the Domain, and Flow

If you know a better way, let me know....


How to get Blender Internal-like specularity in Cycles?

A specular highlight in real life is in fact a reflection of a light source, so to get a physically accurate highlight, the glossy shader is what you want.

However, another way to get such a highlight is the Toon shader:

This shader gives you more control over the exact size and smoothness of the highlight.


This may still involve too much hand-editing for you..

Create your profiled curve to produce a deliberate overlap with its reflection - (you're looking for a good  clean cut down the Y axis) .. here the mirror modifier is only there to vizualise the result

Having converted to mesh, in an orthographic view, Use the knife tool, constrained, to cut through the mesh (K),(C),(Z) Rip the selected edges(V, select the excess faces, (mouse over, L), and delete them.

Add a mirror modifier with merge and clip, and in edit mode, bring the halves together until they just snap, and draw them apart again slightly.

There may still be a few editing decisions on the seam, after applying the mirror modifier, removing tris, bringing some vertices together, but not many, if your mesh is not too dense...

and the result is quite clean.


Export/list the control points of a NURBS

OBJ Format supports nurbs, but Blender writes them as edges by default (since many applications don't support them).

File -> Export -> Wavefront OBJ

Then in the options, enable Write Nurbs. This currently only supports Nurbs splines (not surfaces).

If for some reason you need to access different kinds of curve data, writing nurbs to a text file from Python isn't all that complicated.


Creating a Goldberg polyhedron in Blender

Yes in fact, there is an addon for unusual geometric Objects.

Enable the Geodesic Domes2 Addon in the Preferences.

Add a Geodesic Object

Configure the Geodesic Object as shown. (class2 increses the "subdivision")

If you create those shapes often, just add a preset. You won't have to specify all parameters every time

The nomrals are flipped, so go in EditMode and press [shift + N] to recalculate them.


Is there any down side to creating objects from reusable parts?

I don't think this will be a problem anywhere. As long as you make sure the objects are properly parented to one another, or even better (at least inside Blender), to an empty, you should be fine. Your game engine will, of course, need to be able to deal with object parenting properly, but if it doesn't... you probably don't want to use it.

@metaphor_set raises a good point in his answer. You can check this Unity question where they discuss this; however, I still believe that reusing objects will lead to a better workflow. That said, you should really think (aka, benchmark) whether this could become a problem, and, if so, you could, before exporting or, possibly, before applying materials merge the various objects into one, to counter this problem.


How do I fill a room with mist (smoke) in blender cycles?

Add a big cube that surrounds the room (there is no need to set it as domain of a smoke simulation) and use a Volume Scatter node connected to the Volume output of the Material output Node. Unplug anything that is connected to the surface socket.

like in this example:

and this post:

Low lying fog bounding object rendering as solid


Ok, this should do the trick. Set the glare node's Mix
 value to 1. This will cause it to only output the glare, not the mixed image. Then, simply use an Add node to mix the glare onto the original image, using your black and white Mask imagein the Add node's Fac to Mask out where you want no glare. In the example below, black would be no glare and white would be full glare.


animating a body and having it effect cloth

You could try pinning the mesh and make a parent relation to your main body, it will then follow the body you modeled, take a look at this explanation on how it works:

https://docs.blender.org/manual/en/dev/physics/cloth/settings/cloth_settings.html#cloth

Have a nice day.


bpy - how to select an image running blender in -background mode so an operator can use it?

(Edit) Deleted 1. Solution
2. Solution
This code inverts, the color of a picture. Maybe a bit slower than the Operator but not by much.
It's use bpy.data so you have to input the name of the picture to get it.
import bpy

def invert(image, invert_r = True, invert_g = True, invert_b = True, invert_a = True):
    pixels = list(image.pixels)
    if invert_r:
        for i in range(0, len(pixels), 4): # R
            pixels[i] = 1 - pixels[i]
    if invert_g:
        for i in range(1, len(pixels), 4): # G
            pixels[i] = 1 - pixels[i]
    if invert_b:
        for i in range(2, len(pixels), 4): # B
            pixels[i] = 1 - pixels[i]
    if invert_a:
        for i in range(3, len(pixels), 4): # A
            pixels[i] = 1 - pixels[i]
    image.pixels = pixels

#Example
image = bpy.data.images['Untitled']
invert(image, invert_a = False)

You could also use this code to input a sequence of images
(exchange this with the code after #Example).
images = ['Untitled', 'Untitled.001']
for image in images:
    invert(image, invert_a = False)


Texture aspect ratio independant of scene aspect ratio

You can divide the perspective out of a perspective camera's texture-space like this:

.. and scale it to the desired size in the texture, a Mapping node, or multiplication.


It displays the bone names background on the left in the Color Set select in the Bone Groups
settings.


3D window renders, but Image Render doesn't?

Okay, I figured out what I was doing wrong.  To reduce the clutter in the scene I had turned off visibility of some of the panels (red below). BUT...I did NOT turn off rendering (blue). Inadvertently I had backed the camera behind an invisible plane that had no illumination. When I turned off rendering for the hidden plane things worked fine. So in the preview rendering of the 3d window, what you see is what you get.  But in the full render, what you don't see can get you too!


Paint circle with Python in 3D view direction

Okay guys got it, sorry to again answer my own question:-)

rv3d      = context.space_data.region_3d
view_rot  = rv3d.view_rotation

segments = 32
mul = (1.0 / (segments - 1)) * (pi * 2)
points = [(sin(i * mul) * self._radius, cos(i * mul) * self._radius, 0)
for i in range(segments)]

self._vertices = [view_rot @ mathutils.Vector(point) +
                  self._center for point in points]


Rigging question about Spline IK and having all controls on one armature

It's possible, here is a flow chart of the dependencies:

You want all your bones in your Control rig (deform and non-deform), except your Spline IK bones.
The control rig will control Curve vertices with Hook modifiers.
The Curve controls IK Splines in deform rig. You want to copy all the deform bones from Control rig to Deform rig and copy transforms from Control.
The Deform rig now should have all the bones to deform character. Bind the mesh to this armature.
Parent everything to Control rig. You can hide the Curve and Deform rig from view and render.


It is there in 2.70a for me.
In your question there is very little to go on;
However my guess would be that you have "Keep UV and Edit Mode mesh selection in Sync" active, this changes the selection modes that are available.
Sync selection off:

Sync selection on:


unknown problem with my file, not possible to 3dprint in DXF or STL

Not watertight mesh

One thing that may prevent a mesh from being printed, as you already pointed out, is the presence of "holes", which sholud be intended as parts of the mesh that create a discontinuity in the surface.

If you run the Select Boundary loop operator on the mesh:

You'll see that two main edge loops are not connected:

All the rideged surface on the top it's on its own. Being close to each other is not sufficient, you must join the two edgeloops.

A quick and dirty workaround could be to use the new Voxel Remesher tool to fix all the topology issues.

With a low cell size (something like 0.003 for example) you should be able to get an almost identical mesh.


Blender 2.8 - how do I make a texture reflect light?

Diffuse shader is just what the name suggests, diffuse. Try using a principled shader or combining a diffuse with a glossy shader through a mix shader node.:)


How can I copy animation from an object while it was attached as a child and then paste that animation to it after detaching it?

If this is for a video production, is of lengthy footage and further animation or constraint(s) are needed for models after the medal presentation, baking and/or the Child-of' constraint could prove troublesome.
or even impractical.

A quite simple and straightforward solution could be to split the project between two Blend files.  The 2nd with a different parent to the 1st.
The video clip above was done that way and required a different parent for the man's hands after he'd presented the medal.
The medal and it's cord also needed a change.  They were parentless in the first but needed the girl for a parent after the presentation.
Both Blend files were rendered out as lossless video and the clips joined later in the Video Sequence Editor.
For this method a straight out parentage using CTL-P,  and for the 2nd file,  ALT-P to remove it would be a much cleaner and trouble-free way to deal with the switch.
IMPORTANT -
The only trick to keep in mind when removing or changing parentage, constraints or physics, is to immediately purge the model(s) of all constraints, physics, and keyframes (clear animation in the Outliner)  --> BEFORE  <--  moving the timeline cursor.


Blender 2.82 - How to get Cycles' motion vector from current-to-next frame, in addition to current-to-previous?

In order to "see" the Alpha channel populated, you need to turn on the Use Alpha check box of the composite or viewer output.

See this for further details:

Incorrect Vector Pass output (No Alpha & Zero Values)


having problems using Texture Paint and Clone Stencil

Saving the image once solves the painting problem. Also, using the stencil in brush tool instead of clone tool seems to serve the same purpose so I'll be using that instead.


HDRI / Spherical Images display in view port?

The exact same can be accomplished by selecting the world tab in the properties editor, clicking use nodes, and setting the color to environment map. You will still need to open the file location.


Baked normal map showing seams at uv island boundaries

Looks like I needed to set my texture node's color-space field to -non-color data'.  After that it worked.


Based upon this balloon tutorial:

Create a string
Create a bone as the "handle" (which you can then move around as you please)
Use the cloth simulator to simulate the string and use weight painting to select the part of the string you want to use.


Difference between Shadow pass and Diffuse Direct?

The Shadow Pass is not as interested in the gradient intensity of the reflected light (like DiffDir) as it is in where the emitted light is not directly reflected back to the camera.  This probably involves a threshold, even though I haven't looked at the code.  From my tests, it seems that once the reflected light falls below a certain point, only then does it become non-white on the shadow pass.  Whereas the purpose of the diffuse pass is to show the gradient direct light intensity:

Also, when you add another type of shader into the scene, the similarities between DiffDir and Shadow continue to diverge since the shadow pass is affected by them as well.  An interesting phenomenon occurs when the Glossy Shader is at 0.0 roughness... it becomes totally black.  This is because of what I said earlier about direct light reflection.  As you probably know, when glossy is perfectly reflective, no off-axis light will be reflected back to the camera.  Therefore, you get nothing on the shadow pass.  But if you give it some roughness, it shows up.  That's because it's reflecting enough directly emitted light to breach the threshold.  The center cube below has a glossy shader applied:


Is there an established procedure for programmatically creating a Cycles material to match a physical one?

CrazyBump comes very close.  Just open a photograph and it'll make a pretty good guess at the bump/normal map as well as the specularity map and occlusion map.  There is some manual tuning available, but the initial guess is quite good.


Transform mesh to line up with empties, based on other child empties

In the end I decided to just learn how Blender's scripting works and wrote a script. I know there would be simpler ways to calculate the transformations but I'm no maths expert and I wanted to spend my time debugging my logic errors rather my maths errors.

Basically what this script does is take 3 input points (in the form of empties) relative to the photogrammetry mesh and 3 input points in the same position relative to the tracking data, then attempts to line them up with each other, bringing the photogrammetry mesh along with it. This actually works pretty well in my testing. It's obviously not the fastest workflow but it does work and that's the important part.

import bpy
import bmesh
from mathutils import Matrix

#####################################
# TO USE:
#
# 1) create empties at three easily-identified positions in tracking data, called ea1, ea2 and ea3
# 2) create empties at the same three positions but in photogrammetry data, called eb1, eb2 and eb3
#    NOTE: eb1, eb2 and eb3 must be positioned IN THE SAME ORDER as ea1, ea2 and ea3!
# 3) name the photogrammetry mesh "photogrammetry"
# 4) run the script and be amazed
#
#####################################

# from https://blender.stackexchange.com/a/118783/41192
def createLookRotation(forward, up):
    rot = Matrix.Identity(3)
    rot[0] = up                 # x
    rot[1] = forward.cross(up)  # y
    rot[2] = forward            # z
    rot = rot.transposed()
    return rot.to_quaternion()

def doMeshThing(obj, mesh, empty1, empty2, empty3):
    bm = bmesh.new()
    bm.verts.new(empty1.location)
    bm.verts.new(empty2.location)
    bm.verts.new(empty3.location)
    bm.verts.ensure_lookup_table()
    bm.faces.new([bm.verts[0], bm.verts[1], bm.verts[2]])
    bm.normal_update()
    bm.to_mesh(mesh)
    bpy.ops.object.select_all(action='DESELECT')
    obj.select = True
    bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY')
    bm.faces.ensure_lookup_table()
    normal = bm.faces[0].normal
    guide = empty2.location - empty1.location
    quatRot = createLookRotation(normal, guide)
    obj.rotation_mode = 'QUATERNION'
    obj.rotation_quaternion = quatRot.inverted()
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)
    obj.rotation_quaternion = quatRot
    bm.free()

ea1 = bpy.data.objects['ea1']
ea2 = bpy.data.objects['ea2']
ea3 = bpy.data.objects['ea3']
eb1 = bpy.data.objects['eb1']
eb2 = bpy.data.objects['eb2']
eb3 = bpy.data.objects['eb3']

mesha = bpy.data.meshes.new('mesha')
meshb = bpy.data.meshes.new('meshb')

obja = bpy.data.objects.new('obja', mesha)
objb = bpy.data.objects.new('objb', meshb)

scene = bpy.context.scene
scene.objects.link(obja)
scene.objects.link(objb)

doMeshThing(obja, mesha, ea1, ea2, ea3)
doMeshThing(objb, meshb, eb1, eb2, eb3)

bpy.context.scene.update()

# position and rotate objb (photogrammetry) to match position and rotation of obja (tracking)
photogrammetryMesh = bpy.data.objects['photogrammetry']
photogrammetryMesh.parent = objb
photogrammetryMesh.matrix_parent_inverse = objb.matrix_world.inverted()

objb.location = obja.location
objb.rotation_quaternion = obja.rotation_quaternion

# calculate average dimension difference here and scale
scaleDiffX = obja.dimensions.x / objb.dimensions.x
scaleDiffY = obja.dimensions.y / objb.dimensions.y
scaleDiffZ = obja.dimensions.z / objb.dimensions.z
#averageScaleDiff = (scaleDiffX + scaleDiffY + scaleDiffZ) / 3
averageScaleDiff = (scaleDiffX + scaleDiffY) / 2 # seems to be in local space, so z is useless
objb.scale.x = averageScaleDiff
objb.scale.y = averageScaleDiff
objb.scale.z = averageScaleDiff

bpy.context.scene.update()

parented_wm = photogrammetryMesh.matrix_world.copy()
photogrammetryMesh.parent = None
photogrammetryMesh.matrix_world = parented_wm

bpy.ops.object.select_all(action='DESELECT')
obja.select = True
bpy.ops.object.delete()
bpy.ops.object.select_all(action='DESELECT')
objb.select = True
bpy.ops.object.delete()


Undo and redo not working after changing the hotkey

Well, I found out that that F1 key was already attached to "View Online Manual" and so i had to remove it first, which i did and it fixed the undo and simultaneously the f2/redo also worked ( since before there was nothing to redo).


You maybe looking for a render plugin called Crowdrender  https://www.crowd-render.com/
snippet...
Making 3d rendering faster
Render Farms use lots of computers to accelerate rendering 3d animation or still images. You can use our software to build a render farm from your own hardware and reduce your render times. If you've never built a render farm before, read our article on what you can expect in terms of performance and cost.
Building a render farm is simple
All you need is two (or more) computers connected to the same wifi or ethernet network and you can be rendering faster, that's it. We designed our software to install in one click and not require technical know how to use or have complicated setups.
Supports Free and Open Source 3d tools
Our software supports rendering in Blender using the cycles engine, EEVEE rendering is also possible. Our add-on for is tightly integrated with Blender's latest 2.8x versions, allowing you to render and post process the results easily.


How to remove bevel artifacts on an unusual edge?

Your topology is a bit messy but you can do that:

First apply the scale of your object, otherwise it won't bevel correctly
Select the big face, extrude:

Bevel, choose the amount of segments in the Operator box (bottom left of your 3D view once you've beveled):

Shade Smooth if needed.


How do I properly fit this tail with IK?

This is the perfect time to use a pole target! Essentially its another bone that the IKed bones will bend toward. Also if you make its parent the IK target, its especially easy to use.


Change spacing when using ctrl to move specific amount of units

While moving/rotating/scaling press Ctrl+Shift to transform by 0.1 of blender unit.

You may do the same thing as above but without holding Ctrl button enabling the Snapping Tool (just click on the magnet icon and set the snap element type to Increment). Hold down the Shift button while moving/rotating/scaling to transform by 0.1 of blender unit.


Bridge Edge Loops should work here.

Join both planes into one object through Object > Join, Ctrl+J
Use edge selection and go Select > All by Trait > Non Manifold (to select the loops)
Then Edge > Bridge Edge Loops

Edit:
In your case, the mesh has two forgotten edges in one of it's corners (one on each plane). Just delete them an it will work no problem.
After all that you can recalculate normals so they're all pointing the right way


Particle emitter is still visible when rendered even when "Emitter" option is already disabled

I downloaded your .blend file and solved it. The trick is the following:

Add a new vertex group, and assign every vertex to it.

Put a mask modifier at the end of your modifier stack and make it use the new vertex group, you should turn on the small double arrow button next to the vertex group input field to invert the mask selection. It will hide the original mesh.

like this:


First set up your doors with the origin on the hinge edge, or us an empty. See this question for more info How do I create a hinged door?
Next Parent the little doors to the main water wheel.

In the above gif I have added an empty that is also parented to the water wheel. That empty is used to control the rotation of all the doors with a Copy Rotation constraint on each of the doors.


Suppress output of Python operators (bpy.ops.*)

Python can temporarily redirect the stdout, this is ideal since you may not want to suppress output for _all_ scripts, just selectively silence some operations.

eg:

import bpy

import io
from contextlib import redirect_stdout

stdout = io.StringIO()
with redirect_stdout(stdout):
    bpy.ops.mesh.remove_doubles()

If you want you can read the output back out or use it however you like.

stdout.seek(0)
output = stdout.read()
print("Report was %r" % output)

If you want to redirect both stdout and stderr.

import bpy

import io
from contextlib import redirect_stdout, redirect_stderr

output = io.StringIO()
with redirect_stdout(output), redirect_stderr(output):
    bpy.ops.some.operator_that_may_print_text()


Is there a way to split a face in cubes (but remaining as one mesh) ? (explode modifier ?)

The frontmost image has used inset, extrude, and some faces between extrusions have been deleted.

Select, Inset, Extrude Individual Faces which can create faces targeted for deletion if you like. Blue sphere shows inset before any extrusion.  Yellow edit mode is the extrusion. Image above.

Inset skipped.  Image Above

In Edit Mode

Face Mode
Make a selection of faces
Inset Faces with the individual option ... See the tools keystrokes listed in the UI. Press I for individual inset [ON]
Menu ... Extrude Individual Faces .  Be careful to use the new selection provided by the tool.  If you loose the selection then use [undo] to recover the selection
Set the pivot for scaling to individual origins .. with the upper tool bar ... yellow arrow
Scale ... to scale the selected faces to the center of each face
Improve these steps

Delete Faces if you like to create islands
Know that you in edit mode you can add another shape such as a cube et cetera
You can always join two different meshes into one mesh


How to create a pole to follow and empty with arbitrary origin

I'm not sure that's what you want because it's not clear to me but I give a try with this:

Create Bone1 and his child Bone2. Create Bone3 and his child Bone4. Give Bone2 an IK Constraint with Bone4 as Target. Now Bone2 sticks to Bone4.

For the rotation of Bone3: In the 3D View right panel (displayed with N), choose XYZ Euler instead of Quaternion. Create a keyframe at angle 0°, rotate the bone 180° and create a second keyframe, then in the Dopesheet press T > Linear and shiftE Linear Extrapolation to make the rotation perpetual.


bpy.ops.mesh.select_face_by_sides allows to select faces which are matching an amount of sides (border edges). It also needs named arguments:

Examples:

#Selects faces bordered by 3 edges
bpy.ops.mesh.select_face_by_sides(number=3)

#Selects faces bordered by more than 3 edges
bpy.ops.mesh.select_face_by_sides(number=3, type='GREATER')

The object's faces are stored in polygons (obj.data.polygons).

So for instance, for top, bottom and side faces you can use:

import bpy
from mathutils import Vector

def NormalInDirection( normal, direction, limit = 0.5 ):
    return direction.dot( normal ) > limit

def GoingUp( normal, limit = 0.5 ):
    return NormalInDirection( normal, Vector( (0, 0, 1 ) ), limit )

def GoingDown( normal, limit = 0.5 ):
    return NormalInDirection( normal, Vector( (0, 0, -1 ) ), limit )

def GoingSide( normal, limit = 0.5 ):
    return GoingUp( normal, limit ) == False and GoingDown( normal, limit ) == False

obj = bpy.context.object

prevMode = obj.mode

bpy.ops.object.mode_set(mode='OBJECT', toggle=False)

#Selects faces going side
for face in obj.data.polygons:
    face.select = GoingSide( face.normal )

bpy.ops.object.mode_set(mode=prevMode, toggle=False)


Hexagonal Tiling
Updated. See Edit at bottom of this answer..
You can't map the centers of tiled hexagons onto one rectangular grid, but you can map them onto two overlapping rectangular grids, and use a Voronoi-like distance-to-closest-point test to decide which grid a shading point belongs to.
Preparation
Unfortunately, Blender's node implementation of modulo goes into the negative for negative bases, and we would like a plain regular sawtooth, not jumping as input crosses 0. So we can make a group implementing an alternative mod(): x - y * floor(x/y):

which, for convenience, we can use in a group 'Vector Modulus', applying it element-wise to a vector:

Rectangular Grids
We can use the Vector Modulus group to divide a given UV space into rectangular cells, width 1, height sqrt(3). The centers of these rectangular cells are at the centers of successive tessellated  hexagons in a column, and adjacent tessellated  hexagons in a row.
We move (0,0) to the centers of the cells by subtracting (0.5, sqrt(3)/2) from (Cell U, Cell V):

.. and call it 'Grid A'.
We create another grid, 'Grid B', by offsetting Grid A by half its dimensions in both directions, so the corners of A  at the centers of B, and vice-versa.
To Hexagons:
Now, by selecting the shorter of the Grid A UV and the Grid B UV vectors, i.e. the the UV in the space of the closest cell from either grid, the result falls into tessellated hexagons. (Surprising, until you think about it)
We haven't scaled or distorted the original Input UV in this conversion, just renumbered chunks of it. The rate of change in X and Y is the same, so if we subtract the Cell UV from the Input UV, the result will be constant in any cell, and different for each cell, so can be used to index the cells:

The 'Hexagonal Grid' group in the download has the outputs:

Grid ID, a 2D unique ID for each cell
The cell's internal UV, (-.5 to .5)
The  2 distances of the shading point: from the center and the edges of its cell.

Thanks to The Art of Code, aka  BigWings on ShaderToy, for this method.
Edit:
Since answering, and with newer nodes, Wannes Malfait has pointed out a much snappier way of constructing the offset grids, with just 9 nodes:


Thank you for the help. Instead of working with the UVs in the loops (which is probably the proper way of doing things) I used the below code. It changes the context to allow bpy.ops.transform.mirror to work.
original_area = bpy.context.area.type
bpy.context.view_layer.objects.active = unreal_mesh

bpy.context.area.type = 'IMAGE_EDITOR'
bpy.ops.object.mode_set(mode='EDIT', toggle=False)

bpy.ops.mesh.reveal()
bpy.ops.mesh.select_all(action='SELECT')
#+ select the uvs
bpy.ops.uv.select_all(action='SELECT')

bpy.ops.transform.mirror(orient_type='GLOBAL', orient_matrix=((1, 0, 0), (0, 1, 0), (0, 0, 1)), orient_matrix_type='GLOBAL', constraint_axis=(True, False, False), use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1, use_proportional_connected=False, use_proportional_projected=False)

#+ return to the original mode where the script was run
bpy.context.area.type = original_area
bpy.ops.object.mode_set(mode='OBJECT', toggle=False)


Video preview disappears after adding a color balance node

Your video needs to be added to the composite in the form of a Movie Clip node or as frames in an image sequence node, and then add a Viewer node as output to see the feedback in the backdrop.
Right now, you have a renderlayer node from your scene which probably only gets you the default cube.


You need to turn on the Screen Space Refraction both in the Render panel

and in the Material settings


You won't get any help using the Autodesk converter here, but if you are asking whether you can use blender to do the conversions, then the answer might be yes. Blender is able to import and export both obj and fbx files, you will need to do some tests to see if the models you have are handled correctly.

Blender has a python interpreter built into it, you can use blender's python console to enter python commands to do your conversion. You can also open a text file in blender's text editor and run it as a python script.

You could also start blender in the terminal and have it act as an interactive python console in the terminal without using blender's gui.

The commands you want to use to convert your models are bpy.ops.import_scene.obj() and bpy.ops.export_scene.fbx()

You could start with a script like

import bpy
import os

src_dir = '/Users/name/Desktop/obj_files'
dest_dir = '/Users/name/Desktop/fbx_files'

for f in os.listdir(src_dir):
    # delete all existing objects
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()
    bpy.ops.import_scene.obj(filepath=os.path.join(src_dir,f))
    bpy.ops.export_scene.fbx(filepath=os.path.join(dest_dir,f))


No. It is not possible.

Multitexture is a fixed-function pipeline which can do multiple layers of diffuse textures, but lighting information is calculated per-vertex. This means that maps that contain information that should influence lighting have no effect (eg specular hardness, specular intensity, normal, height).
In GLSL mode, lighting is calculated per-pixel, and so these maps can be used.

In short: In multitexture, the only maps supported are emit, diffuse (with some trickery) and transparency.

I highly recommend GLSL. Most hardware made in the last decade or so supports it. If you are concerned about the performance of GLSL, I will point out that it depends mainly on the complexity of your shaders. If you simply use diffuse, emit and transparency maps, the performance is virtually the same as multitexture. GLSL offers more functionality, allowing more effects, and it is these extra effects that cause performance loss.

That said, I used multitexture for many years because my hardware didn't support it. You can do some great looking stuff in multitexture mode if you are clever.

EDIT:
Apparently if you have old enough hardware, the performance difference between GLSL and multitexture is noticeable, even on simple scenes.


How to stack/multiply objects or meshes in blender

I think you need to create a mesh, which looks like the 'pile' object. And then on the surface of the mesh, you apply the particles, as a single or grouped rice meshes. Using some randomness in the parameters.


How do I separate objects using the mirror modifier in Blender 2.82?

Go into the modifiers tab, and press Apply, on the Mirror Modifier. That will convert it to actual geometry.

Then, in Edit Mode, select one half of the object, and press P  > Selection. This will make it into a separate object.


This is a terible explanation. So sorry for that.
My problem is bind block A to the movement of four different rods.
The pivots are yellow dots.


"Cycles shoots one ray per pixel and sample from the camera where it
  bounces off from geometry until it hits a light source or gets killed
  by the Light paths settings"

This is what happens in principle. In practice there are all kinds of tricks and optimizations that make path-tracing much faster than the naive implementation described by you. For example shadow rays are shot from the surfaces in the direction of light sources, and a trick assures that the image converges towards the same image as without shadow rays, but much faster. These shadow rays allow us to collect the "direct" and "indirect" lighting information separately. They are always collected separately, the passes just expose this internal information to you. This shadow rays/direct sampling trick is called "next event estimation" in the CG literature, if you want to learn more about it.

  Shadow, AO - How do they affect the final image?

They don't. The information in the shadow pass is already contained in the other passes, and AO is just some kind of fake global illumination, which is not necessary, as path tracing provides physically based GI.

About your other questions: I guess the answer is also in the Cycles implementation details. Note that (according to the Cycles roadmap) in the future Cycles will have AOVs (Arbitrary Output Variables) instead of hardcoded passes.


Press button N  while hovering your mouse over the graph editor or click (or drag) this little left-direction arrow here:


Fading and animating objects without materials

Ok so I figured out a solution thanks to @Carlo's comment. Hopefully this will help anyone else who's trying to do something similar.

I create one node group per object type that has a default color, and accepts one input: transparency. The node group itself is basically a mixer between Diffuse bsdf and transparent bsdf shaders.

Each object of that type has it's own material which basically links the node group with the material output. I can then keyframe the opacity on each material independently, but still maintain the ability to change the color collectively for the type by changing the node group color.

Since I am scripting this, I am not worried about having to keyframe 5000+ objects. I came up with the following functions:

# create_node_group - Creates a node group
# for a particle type with a default color.
def create_node_group(name, color):
    group = bpy.data.node_groups.new(name, 'ShaderNodeTree')

    # Create node group input.
    inputs = group.nodes.new('NodeGroupInput')
    inputs.location = (-300, 0)

    # Create diffuse shader.
    diffuse = group.nodes.new('ShaderNodeBsdfDiffuse')
    diffuse.location = (0, -200)
    diffuse.inputs[0].default_value = (color[0], color[1], color[2], 1)

    # Create transparent shader.
    transparent = group.nodes.new('ShaderNodeBsdfTransparent')
    transparent.location = (0, -400)

    # Create shader mixer.
    mixer = group.nodes.new('ShaderNodeMixShader')
    mixer.location = (200, 0)

    # Create node group output.
    outputs = group.nodes.new('NodeGroupOutput')
    outputs.location = (350, 0)

    # Create input and output sockets.
    group.inputs.new('NodeSocketFloat', 'Transparency')
    group.outputs.new('NodeSocketShader', 'Shader')

    # Link everything together.
    group.links.new(inputs.outputs[0], mixer.inputs[0])
    group.links.new(diffuse.outputs[0], mixer.inputs[1])
    group.links.new(transparent.outputs[0], mixer.inputs[2])
    group.links.new(mixer.outputs[0], outputs.inputs[0])

    return group

The above function creates the node group and returns a reference to it. I then use the function below to create a material for each object in my scene, which calls the function above.

# create_material - Creates a material with a color
# for the group (if not created already). Name and
# group name should typically be the same.
def create_material(name, group_name, color):
    group = bpy.data.node_groups.get(group_name)
    if group is None:
        group = create_node_group(group_name, color)

    mat = bpy.data.materials.new(name)
    mat.use_nodes = True

    for node in mat.node_tree.nodes:
        mat.node_tree.nodes.remove(node)

    mgroup = mat.node_tree.nodes.new('ShaderNodeGroup')
    mgroup.node_tree = group

    outmat = mat.node_tree.nodes.new('ShaderNodeOutputMaterial')
    outmat.location = (200, 0)

    mat.node_tree.links.new(mgroup.outputs[0], outmat.inputs[0])
    return mat

Finally, if I want to change the opacity of an object, I simply call this small function:

# set_transparency - Set the transparency of an object.
def set_transparency(ob, val):
    mat = ob.data.materials[0]
    mat.node_tree.nodes["Group"].inputs[0].default_value = val

This may not be the best solution, but it works for me, and hopefully it will help others in a similar situation.

Thanks!


Ok what he is doing in 3ds max is doubling the edge loops (chamfer tool in max), then scaling the faces to make them flat.
We can do the exact same thing in blender.
Take this mesh. It is just a curved plane with some loop cuts. This will be our starting point to make some stairs/stadium seating.

Select every loop going up the stairs. Easy way to do that is with the Mesh Select Mode set to Edge select the bottom one, and then select edge rings. From the 3D view header Select > Edge Rings.
Bevel the selected edges CtrlB. You want to start the bevel operator then type in a very small number, such as ".0000001" now press Enter. That will have "doubled" all the edges in the middle.
Now switch to face selection, and press CtrlI. That will invert the selection, giving us the selection we want. The bevel operator selects the newly created faces, so in this case the inverse is perfect.
Simply set the Pivot Point to Individual Origins and scale along the Z axis to 0. That will make the rows flat, thus making stairs.


Where is "Absolute Grid Snap" option in latest 2.8 release?


If using v2.68 (revision 57577+), you can do the following:

Press B,
Use LMB and drag to form the (de)selection rectangle,
hold down Shift while releasing LMB.


In Blender 2.80, how to set a custom transform orientation programmatically?

Here's a working solution/snippet, with a description below:

        orthonormal_basis_matrix = mathutils.Matrix(
            [
                [vcross[0], vnorm[0], vdest[0]],
                [vcross[1], vnorm[1], vdest[1]],
                [vcross[2], vnorm[2], vdest[2]]
            ]
        )
        bpy.ops.transform.create_orientation(
            name='MAPlus',
            use=active_item.apl_use_custom_orientation,
            overwrite=True
        )
        orient_slot = [
            slot for slot in
            bpy.context.scene.transform_orientation_slots
            if slot.custom_orientation
               and slot.custom_orientation.name == 'MAPlus'
        ]
        if orient_slot:
            orient_slot[0].custom_orientation.matrix = orthonormal_basis_matrix
        else:
            print('Error: Could not find MAPlus transform orientation...')

Call create_transformation to add a named transformation
Use a list comprehension to search through the available bpy.context.scene.transform_orientation_slots for a slot having a custom_orientation (TransformOrientation object) with the name you provided
Test whether the list comprehension/search came up with any results, then use the discovered object and set its matrix


How to control inner and outer edge of curve modifier separately?

You can do it without the curve modifier, with the screw modifier and a displace modifier :


First, select an object and add quick smoke. Now go to the physics tab of the flow object
-> settings -> Flow source -> change flow source from mesh to particle system then choose your particle system

1> Add particle system

2> change flow source

3> bake all under cache


Is there a shortcut to switch between Add and Subtract brushes, in Sculpt mode?

You can press and hold Ctrl to toggle between sculpt modes. While pressed you will be in the opposite mode to what is selected in the toolshelf; i.e. if you have selected Add, then while pressing Ctrl you will be in Subtract Mode.

A list of all keyboard shortcuts available in Sculpt Mode.


The tutor used an operator in the delete menu delete only faces.


Although there are many ways to do so, you CAN create a quarter cylinder from a cube:

Select the cube object, Go to Edit mode;
Ctrl + B to bevel the selected edge, roll the mouse wheel to adjust segements;
A + A to select all vertices, then W -> Remove Doubles.

Tip:

To ensure the maximum bevel extent on that edge, you can consider either one of the following ways:

After pressing Ctrl + B, you can see the available operations on the 3D View header (with shortcuts). So, you can then press M three times to switch bevel mode to Percent, then type 100 for a maximum Offset percent.

You can also do it after confirming the bevel operation, from either the lowerleft of the Tooblar (T) or a seperate popup menu(F6):


BGE: Can a cube copy the rotation of another cube in game?

This is possible with a simple python script:

import bge

def main():
    scene = bge.logic.getCurrentScene()

    cube1 = scene.objects["realCube"]
    cube2 = scene.objects["secondCube"]

    cube2.worldOrientation = cube1.worldOrientation

where realCube and secondCube are the names of the actual cube objects in blender.

To attach this script to secondCube, you can use a python controller with an always sensor. Note that the script name must end in a .py extension for the script to be recognized as a module, and that the python controller is given a method (.main) defined as a function inside the script:


How can I make a shape follow a profile without it following the profile normals?

In this example I use two objects "Pillar" and "Bevel" ...

select "Pillar" curve and search for Set Origin to Geometry
search Convert to Curve (both objects should be a curve)
Search Spline type >  Bezier and set handle types (V) > Automatic
under Properties Editor > Object Data > Bevel assign a curve "Bevel"
with curve "Bevel" selected go to edit mode (TAB) and rotate vertices in X -90° (so curve goes in Y axis) and move all control points to bring bottom vertex to origin position

Note:

always good to Apply Transformations (Ctrl+A) like Scale in here
switch curves to 2D (Properties Editor > Curve Data)
I had to scale up the Pillar shape (in edit mode) up to 3 to get result where Bevel curve doesn't generates weird in thinner curvature

Edit: just from what I see on your reference image, you should probably start with five circles object, because when you bevel on final floor shape you get wrong intersections of small circles with big one. Step by step is the same. Except for Bevel Curve move control points a bit far from origin. Here is the result.


How do you convert Weight paint to new mesh layer in blender?

I'm not exactly sure what you are after, but if you want to get a new, separate mesh of the teeth weight painted red, there's a simple way to do it.

In edit mode, you could Circle select (press C, mouse wheel changes brush size) and then "paint" the faces you want to select.

Then Shift-D to duplicate the selection.  Then, P will Separate the selection into a new object.

Hope that helps.


Cycles - Baking to image problem (looks like seams on the image, but not sure)

Your face is non-planar.
Go in Edit Mode (Tab), enter face selection mode (Ctrl+Tab, Face), select your face (RMB). Open the Mesh menu, Cleanup, Make Planar Faces.

This should fix it, but can make surrounding faces non-planar...


Resuming rendering image sequence after blender crash

Blender actually can do this already; if you disable Overwrite in Render settings > Output, Blender will skip rendering frames where the output file already exists.

See Does Blender resume rendering after returning from hibernation in Windows 7?

On linux you could write a short shell script to restart the render in case of a crash, e.g.

#!/usr/bin/env bash
while true; do
    blender $@ # $@ contains all the arguments passed to the shell script
done

Save it in a file (e.g. persistent_blender.sh), give it execute permissions and run it like so:

./persistent_blender.sh -b '/path/to/file.blend' -a

Where the arguments tell blender to render the animation of the specified file.

Of course you could make something much nicer and handle all sorts of things (such as stopping when all the output files exist and have a size > 0).


You probably need to manually redefine the T-Pose for your target rig.
MW seems to be mostly doing its trick by copying rotation differences between the defined rig t-pose and whatever happens to be the current animation pose. An incorrect T-Pose will result in the bones looking in the wrong direction, which you can correct by rotating them such that the end result is correct in the pose mode, and then telling MW to use that as the T-Pose for the retarget.
You can do the latter by using the "Define T-Pose" button in the utilities section of the MakeWalk tool panel:

Note that you may have to also untick any automatic options on the target before doing that. If you have ran automatic bone detection earlier, you can save that as a target definition which you will later be able to specify manually.
Note that the bones you have to rotate to get the model into the T-Pose also have to be the ones that that are matched on your target rig. You can inspect that by opening the target armature section and scrolling to "FK Bones". All bones not listed here are ignored by MW.


Is there a way to avoid a Smooth modifier interfering with a bump-map?

I would suggest a different method to get the same results. Here's what's happening with what you have right now:

The bevel modifier is adding a small bevel on each edge of the cube, which adds some extra vertices. The array modifier duplicates this object along a set axes, and then the smooth modifier smooths out all of the geometry.

The smooth modifier doesn't create any new geometry. Instead, the relatively high strength you are using is smoothing the object so much that the originally small bevels are now much larger. Essentially, the vertices created by the bevel modifier are getting pushed towards the center of the cube.

This is all fine, but you're noticing an issue that this method causes.

Materials are applied to the object before certain modifiers. Thus, the texture is applied to the bevel created by the bevel modifier, but then that bevel is stretched (smoothed) by the smooth modifier, and thus you get the stretched texture.

Instead, remove the bevel modifier and the smooth modifier, and use a subdivision surface modifier set to simple. This will add some extra vertices that will allow the curve to bend it smoothly.


Overview

To effectively make use of the Vector Transform node, you first need to appreciate the differences between the various coordinate spaces - World Space, Object Space, and Camera Space.

You can get a feel for the different coordinate spaces by using the different modes of the Transform Orientation control in the 3D View.

Available 'modes' are Global, Local, Normal, Gimbal, and View.

Starting from the default scene, select the default Cube and press R, R and rotate it so it is no longer flat to the plane and click to accept the new orientation. With the Transform Orientation set to 'Global' you'll see that the control handles (the red, green, blue arrows) remain aligned with the world grid (the red and green lines on the grid)

This demonstrates World coordinates. If you use the Grab handles (the red, green, blue arrows) to manipulate the object it will move in World space - ie, the red arrow will move it in the X direction, green in the Y direction and blue in the Z direction.

Now change the Transform Orientation to 'Local'. The Grab handles (arrows) will swap to be aligned with the object's own orientation.

This demonstrates Object coordinates. If you now use the Grab handles to manipulate the object it will move in its own local (Object) space. ie, the Blue handle will move it 'up' in relation to its own axis rather than the world.

Now change the Transform Orientation to 'View'. The handles will swap to be aligned with the screen (you'll no longer see the blue one as it points directly away from the view - unless you move the objects away from the centre of the view - in which case it will point along the perspective line into the distance at the centre of the view).

This demonstrates Camera coordinates. Using the handles to move the Cube will move it parallel to the dimensions of the current view. Moving in the Z direction will move it closer and further from the view.

The above examples are useful to demonstrate the coordinate spaces for Location and Rotation. For World and Camera coordinates the scale is always the same - with 1 unit of World coordinate space equating 1 unit of Camera coordinate space. However, for Object coordinates, the object's Scale is also taken into account - if the object is scaled at a factor not equal to 1.0 then the Object coordinates will be similarly scaled - so for a scale of 2.0, one unit in Object space will be the equivalent of 2 units in World or Camera space.

The Vector Transform node is used to transform a Vector - whether it represents a Point, a Vector, or a Normal - from one space to another. The different 'modes' (Point, Vector, Normal) control which aspects of the space are used - useful when transforming to/from Object or Camera coordinates and the Location or Scale should be ignored - needs to be set appropriate for the type of vector being manipulated. Similarly, care must be taken to ensure the Convert From and Convert To options are set appropriately or the result will not be meaningful.

Here are some commonly available vectors :

Location - any object's Location is measured in World space, with (0,0,0) being the world origin. The Location is visible in the properties panel (N) and can be accessed via Drivers using the Transform Channel variable type or directly by using the material Object Info node.

Object Coordinates - the Object coordinates of the Texture Coordinates node returns the sample point on the surface (or in a volume) of the object in Object space. The origin of Object space is the origin of the object itself - so the vector describes the path from the object origin to the surface or volume point being considered in the shader.

The other nodes of the Texture Coordinates node aren't compatible with the Vector Transform node as they use subtly different coordinate spaces. In particular, the Camera socket should not be confused with Camera space coordinates used in the Vector Transform node as it is significantly different (the origin and scaling are different). Attempting to use those vectors with the Vector Transform will produce confusing results.

Normals are a bit tricky as their 'space' depends on which particular version of Normal you use - it's available on both the Texture Coordinate and Geometry nodes - with one being in Object coordinates (Texture Coordinate) and the other in World coordinates (Geometry). However, the Vector Transform can be used to translate these between the spaces (so you can use, say, the Texture Coordinate one where you'd normally use the Geometry one by passing it through a Vector Transform).

Two other interesting sockets of the Geometry node are the Position - which represents the point on the surface/volume - and Incoming, which represents the path of the incoming ray, both in World coordinates.

Vector Transform

To demonstrate the use of the Vector Transform, start with the default scene, rotate the cube some random amount and create the following material. The colours of the cube will effectively show the World Space coordinates - note that they aren't aligned with the cube and are, instead, aligned with the 'world'.

Now repeat the same but this time using Object coordinates from the Texture Coordinate node. You should be able to see the difference since the colours of the cube will remain aligned with the cube rather than the world.

To demonstrate the use of the Vector Transform node we can take the Object coordinates and transform them into World coordinates as shown (note the Vector Transform node settings Point, Object, World) :

The results should be identical to using the Position world coordinates directly. The Vector Transform has translated the Object coordinates into World coordinates.

One potential use of this is to shade an object based on the proximity of another object (or empty). By using Drivers we can get the World coordinates of an object into a material (using Transform Channel), then transform them into Object coordinates, then perform some calculation (such as calculate distance).

For example, the following material uses a driver to capture the Torus location and populate the input coordinates via the Combine XYZ node. This is converted from World coordinates into Object coordinates (which includes the translation for Location, Rotation and Scale of the object) and the Dot Product used to calculate the distance from the centre of the Torus (actually distance squared) and set the color accordingly.

As the Torus moves the surface of the cube changes color based on the proximity to the centre of the Torus.

Taking this a step further, we can affect the surface based on the proximity in Camera space - and can use that to affect a material based on how objects overlap in the camera view :

The material of the cube is such that when it's lined up with the magnifying glass (from the point of view of the camera) it becomes transparent. It works by converting the coordinates of the magnifying glass, and the point on the surface, into Camera coordinates. and calculates the distance between them. This allow it to determine whether the point lies within the diameter of the magn ifying glass lens and, if so, shade it as transparent. Note that the Z coordinate in Camera space indicates the distance from the camera. In this case the ratio of the distances is used to adjust the X/Y coordinates to scale based on distance. This makes the transparent region larger the closer the magnifying glass is to the camera.

So far the 'mode' has always been set to 'Point'. When used in this way the transform is assuming that the incoming Vector represents a point in space - in relation to the associated origin - and this means that the Object's location, rotation, and scale are all used in the calculation. If the Vector actually represents a vector that is independent of the location of the object (eg, a Normal) then you may need to ignore the object's location and/or scale. The 'Vector' mode ignores the object's location while the 'Normal' mode ignores both the object's location and the object's scale.

One example of how this can be used is to convert the Normal into Camera space and to use this to create a Toon-style shader based purely on the angle with the camera.

By passing a known fixed vector into the Vector Transform we effectively probe the properties of the object (eg, its orientation and/or scale) since the vector can be transformed into its Object space.

For example, this answer - https://blender.stackexchange.com/a/76237/29586 - uses the following material to determine how much an object is rotated away from a particular direction vector.

Using a similar technique we can extract the X, Y, Z scales from an object.

This material passes fixed unit-length vectors (one along each axis) into Vector Transform nodes set to Vector (so that the Location is ignored but Rotation and Scale are preserved) set to convert from Object space to World space and then measures the length of each resultant vector. The length of each vector will be a direct measure of how long that dimension is in the object once it is converted to World space coordinates - ie, it's scale in that direction.

EDIT : A further use is to determine the distance from the camera. For example, in this answer the vector transform is used to convert the distance into a color.


First, make sure that your Render Engine is to Cycles and that you are in the Shader node editor, not the compositor.

The Script node is there..

The changes in the Render panel were more than likely made in the space of time from 2.65 to 2.67.


Mesh shrinks when trying to bend after rigging?

You have to play with weight paint to find the right weight.

When your intention is a like organic mesh, you have to make it as square as possible. this will make the deformations look smoother.

See the image below.


Ok, I figured it out. The black is actually Alpha. So the quickest way to fix it is to patch it up with white.

Also, I notice the final result used the composite feature! It was not enabled by default. And that's why it looked different.


Texture Painting: brush wants to be dragged from a site to another

Looks like you enabled Smooth Stroke option:

The smoothness of the brush is driven instead by its shape.

It can be customized by defining points (or choosing one of the six a presets) in the editor of the Curve panel:

On the right, the different result you can get by using each preset.


Shrink/Fatten, weird edges. How to get uniform scale?

After extruding the face loop, with the loop selected.

Short answer:

  Select the edge loops and scale them with their individual origins.

Hide all other faces. ⇧ ShiftH
Switch to edge mode. ⎈ Ctrl↹ Tab > Edge E
Deselect all. A
Select the two edge loops. ⎇ Alt RMB, ⇧ Shift⎇ Alt RMB
Set the Pivot center for rotating/scaling to Individual Origins. ⎈ Ctrl.
Scale with S.

Outset Even

You can't outset in Blender without geometry outside. This means we'll have to add some geometry.

Make a face for both edge loops.
Duplicate the faces and hide everything else.
Extrude the edge only and scale them with individual centers.
Select the faces we want to outset.
Inset I, with outsetO.

Delete the helper edge loops.
Delete the extra faces.
Bridge the unconnected edge loops.
Remove doubles.


Bridging the geometry of two parts of an object that were created separately

@LukeD is right.
You could in edit mode use select edge loop and dissolve edges(ctrl X) to decrease the number of edges of the armchair. Subdivide the lower edged parts to get more edges to work on. Try to conect these vertices now.


Dome with smokestack - how to clean mesh after boolean modifier?

blender loop tools addon >>  circle > extrude > edge bevel