In your scene it looks like the origins of the object might be messed up. When using the Array and Curve Modifier it is important to note that the origin of the curve and the origin of the mesh must be at the same spot. Also the mesh should have it origin at it geometry not somewhere else.

Here is how to fix it:

First let's make sure that your objects are not rotated or scaled by applying the transforms:
Ctrl A -> Rotation & Scale
Select the curve item in object mode
Place the 3d cursor at the curves origin, Shift S -> Cursor to selected
Select the mesh in object mode
Set the origin of the mesh to the geometry, Ctrl Shift Alt C -> Origin to geometry
With the mesh still selected move the mesh to the 3d cursor, Shift S -> Selected to Cursor

blend file


Imported fbx with armature behaves weird in blender

Have you tried Makehuman (http://makehumancommunity.org) or Manuel Bastioni Lab (http://www.manuelbastioni.com) these plugins are both free and Manuel Bastioni is fully integrated inside Blender, is really worth to check it out.

I had a similar issue importing FBX poses from Mixamo, the bones came all wrong, so what I did was:

1- import the pose without skin from mixamo into blender.

2- export that same pose as a BVH file from blender. (Can you export BVH from DAZ Studio?)

3- import a character from Makehuman into blender then apply the BVH to this character.

Hope it helps.


The contour lines are genuine mesh edges auto-generated by a Blender/Python script as described in the following blog post:

Blenderyard: Contour Lines as in Maps

The script implements a new operator named 'Slices'.  Put the script into a text datablock in Blender and run it by pressing the 'Run Script' button, and the operator will be registered.  If you have an active mesh object, then running the script for the first time will apply the operator to the mesh object.  Then the operator can be invoked using the spacebar search menu and looking up the 'Slices' operator.  The operator allows you to change the vertical interval of contour lines.


How to move baked curves in graph editior?

I do a lot of sound baking, and always bake at frame 1 then use the NLA editor to change start frame, simply and quickly.  You don't want to be baking large sound files again to move a frame to the left 8^).

If you are going to use the NLA, it  also pays to create an empty action (how you want it to be with silence) and add that to the stack.


Solidify Modifier

You can do this by adding a Solidify modifier to your planes:


How do I add a constraint to an object with Python?

import bpy

o = bpy.context.object
constraint = o.constraints.new('COPY_LOCATION')

#constraint properties
constraint.show_expanded = False
constraint.mute = True

https://www.blender.org/api/blender_python_api_2_77_release/bpy.types.ObjectConstraints.html?highlight=constraints#bpy.types.ObjectConstraints

https://www.blender.org/api/blender_python_api_2_77_release/bpy.types.CopyLocationConstraint.html?highlight=constraints


First I created this profile shape and extruded it to create the vertical pipes (CTRL + E) in Edit Mode.

Then added some loop cuts and joined them for the top, middle and bottom cross sections. Added a Subserf Modifier and some additional loop cuts to clean up some edges.

Then added an Array Modifier above the Subserf Modifier and applied it.

Then extruded the feet on the two ends and modeled the pipe to the floor.


I was a noob last year, so don't worry about it.  We are all learning here.
Here is how I achieve a light projection effect in Cycles.  I use a spot light with the following settings.  Hope it helps.


When I render my animation my main light source is not rendered. How can I get the light to show up in the final render?

Your light is in a different layer. Bring your light to layer number one. First, find where is light located in layers then select the light and press m to move to layer number one.


I'm just setting up a Mac and aren't too familiar but having just downloaded the latest LuxRender1.5 and installed LuxBlend, I see the API choice is not called API2.x, rather it is called LuxCore API (experimental) so I am assuming this is the 2.x
Here is a screenshot:

EDIT: But be aware that there may be performance issues when using the viewport. This post mentions and gives some explanation:
https://groups.google.com/forum/#!topic/appleseed-dev/YZ5dR9qvUV0


How do I know which faces correspond to which area of a UV image?

I try to answer in generic terms. Where texture mapping is concerned: there are no pixels!

The U and V coordinates are relative. They do not point to a pixel, they point to a position between 0 and 1. So if your texture has a resolution of 1024x1024 the coordinates 0.5, 0.5 would not point to a pixel, but to the interpolated color at the center. And this would be in that example right between the 4 pixels in the center of the texture resulting in a color value where all 4 pixels of the texture get mixed together in one.

If you UV map a 3D model, it is not guaranteed, that a texture coordinate lands right in the middle of exactly one pixel of your texture, it could land two thirds on one pixel, and one third on another, etc, etc.

When you export a uv map from blender so you can photoshop your texture over it, it is important to know that it does not matter where the edge is drawn. Just think of the edge as infinitly thin. There is no belonging to one specific face, if both share the edge.

However if you really want a "sharp" edge, one that is really separate from its neighbouring face, you can insert a seam in edit mode, unwrap the UVs again. Now there are two edges in the UV map. If you keep an eye on your vertex count you will see, that by making that seam, your vertex count goes up, since all vertices along the seam gets duplicated. They still occupy the same space and blender treats them as one, but the underlying renderer sees them separate.

I hope this answers you question.


Why is there no save confirmation when closing a file?

Currently Blender does not have a 'Do You want To Save?' warning before opening a new or previous file. There is a dialog box that pops up of course, but it definitely could be a lot clearer as to what will happen when you confirm.

Blender does have several ways to recover lost files though.

First is the 'Recover Last Session' option in the file menu which you already know about based on your question. From my experience this usually doesn't do a great job of recovering in a case like yours as it goes back too far.

Blender also auto saves files. In the user preferences in the file tab you can set it to auto save more frequently (down to every 1 minute). Autosaves can be recovered from the file menu. Do note that Sculpt and Edit Mode changes won't be saved by Auto Save though (and I'm not exactly sure why that wasn't implemented, my guess would be a full save takes too long).

Finally blender created backup versions of your files. These are the .blend1 and .blend2 files that get automatically created after a while. You can open these versions using the default open menu and adjusting the filter settings at the top to display .blend1 and .blend2 files.


How to set an uv map, from an multiple uv, as primary one?

You can rename a UVMap in the UVMaps panel, either double-click or ⎈ Ctrl-click the name to edit it.

The little camera to the right of the name specifies the default map for blender, that is the one that is used if you do not select a specific UVMap.


Is a "Blender Game Engine" game built into native code or something higher level like python?

The binary that executes the game (i.e. Blenderplayer) is native code compiled from a combination of C and C++. I don't think there are any Python based Blender operators that run when you play a game. So yes it's completely 'native'.

If you choose to extend the game with Python script, which will be interpreted at runtime with a Python 3.3 (as of Blender 2.70) interpreter, then it will be a mix of 'native' component and interpreted scripts.

Unless you are doing some serious Python coding, the performance overhead of Python is very small.


Subdivision while keeping Volume for Level of Detail

With Blender 2.82 out, there is a good enough method to keep the volume while subdividing the whole mesh without actually using the subdivision modifier.

It's the Bevel modifier.
Select the percent method and set the value to 50%.
uncheck the clamp overlap option and now, you might notice there are now duplicate vertices.

But there is a new modifier: weld; and its job is to get rid of those in a non-destructive manner, so you can keep your bevel modifier.
you can then add as many segments and tweak the profile as much as you want.
Make sure to set the outer Milter to "patch" for concave meshes.

As you may notice, the subdivision isn't as perfect as the subdivision modifier,
so you might encounter problems like
In that case, buff the distance of the weld modifier juuust until it fixes everything.

After that, you can add a subdivision modifier for a better edge flow and tweak the profile of the bevel (even the custom profile works) if it looses too much volume to your taste.


how to make 2 cloths collide with each other?

You can either merge the two objects into one object with self-collision cloth physiscs, or you can have two separate objects, each with its own cloth physics, but then both need to also have collision physics enabled.

For more explanation see the answer to this question: How can I make sure that simulated cloth doesn't go through other objects?


Applying opencv distortion parameters to camera or setting custom projection matrix for render

The tangential distortion can not be modeled in the current version.

The radial distortion with three parameters can be entered in the Movie Clip Editor (Shift F2) in the 'Track' panel under 'Lens'. Then they can be applied with the Movie Distortion node in the Compositor (Shift F3).

The same question was asked by me here and also asked here. Check the answers to those questions for more details.

Regarding the projection matrix: 6 years ago, it was not possible to set a custom projection matrix, but a workaround using orthographic projection was suggested: see here. However, I don't know if this has changed since 2014.


Transform Vertices by Matrix around Custom Point

Actually there are two steps, (1) scaling the vectors w.r.t to normalized normal, then (2) translating them w.r.t to normalized vector, so you have to do it separately.

You are doing correctly and only one step is remaining. After the transformation of vectors (vert * mat_out), you have to translate them w.r.t to the origin.

import bpy
import bmesh
import mathutils

obj = bpy.context.edit_object
me = obj.data
bm = bmesh.from_edit_mesh(me)

verts_sel = [v for v in bm.verts if v.select is True]
verts_co = [v.co for v in verts_sel]
verts_nor = [v.normal for v in verts_sel]

axis = mathutils.Vector(sum(verts_nor, mathutils.Vector()) / len(verts_sel))
axis = axis.normalized()

origin = mathutils.Matrix.Translation(sum(verts_co, mathutils.Vector()) / len(verts_sel))
mat_sca = mathutils.Matrix.Scale(0.0, 4, axis)

mat_out = mat_sca  # Do not combine transformations

for v in verts_sel:
    vert = mathutils.Vector(v.co)
    # you have translate the "transferred vectors (vert * mat_out)" w.r.t origin
    v.co = origin * (vert * mat_out)

bmesh.update_edit_mesh(me, True)

But you can also achieve same result without script,


In the Info editor, the line in the menu bar to the right of the controls lists some stats about the view. This includes a count of how many objects are selected, out of the total number of objects in the scene.

Here's a sample screen shot of this info bar:

It lists "Objects:2/4" meaning that there are 4 objects in the scene and 2 are selected.


How to paint a texture on top of a repeated texture?

you can mix both textures with a MixRGB, create a new image in the image editor and then paint a black and white mask in texture paint mode to be used in in the fac input, you can set everything and go into the LookDev or Material Preview to see the efect while painting.


Can I Create a Linked Duplicate Consisting of Only Those Mesh Parts Defined by a Vertex Group Owned by the Duplicated Object?

You can "Duplicate Linked" the object with Alt+D.
Then, on the duplicate, add a Mask modifier, and select the Vertex Group you want to keep.
(You can also select the vertex group you want to hide, if you tick "Invert" (double arrow icon) next to the Vertex group field)


I tried that tutorial now, but in the tut it uses softbodies, not rigidbodies! I didn't "apply bevel"  or convert the rope to mesh, and it works well to me. That said:

I dont' get the wider side, during simulation, there must be something that you did differently, perhaps?
If you want to avoid that, you can try to just increase the "outer" softbody collision to the cylinder, I get good results with around 0.05 (default was 0.02 and with that I could "see" the rope inside the cylinder).


BGE - Model is white instead of it's given textures

I can guess only, but maybe the 3D view is in solid shading mode. Try to switch to textured mode, you should see textures then.

So, change the mode from

which results in:

to:

which results in:

EDIT: After seeing your file, I think the behavior you described comes from another few problems:

The ground material's Emit setting is set to 2, which makes the material emissive and therefore it's not interacting with lamps.
There are no lamps in the scene.
The texture on the ground plane is just plain white, you can just use the material color for that. The player object has that texture too.


UV Mapping (Unwrapping for Image Textures)

Go to Object mode and ctrl A > Apply Scale, then unwrap again


Cycles Fake Absorption Setup Explanation

The way the node setup you are referencing works is by coloring the inside wall of a material based on how far the ray has traveled within the material.

The backfacing output gives 1 if the ray is hitting the side opposite the normal (the "front" of the face), and 0 if the ray is hitting the side with the normal (the "front" of the face).  So the output of the first multiply node (from the left) will be ray_length * 1 = ray_length if the ray is hitting the backside of a face (meaning it is inside the object) and ray_length * 0 = 0 when the ray is hitting the front of a face (meaning it is outside of the object).

The rest of the nodes just convert the linear falloff to exponential and use that result to mix the base color with the absorption color.


Blender has an add-on for Combining multiple UV maps into one. Texture Atlas.

The addon Documentation has some tutorial Videos on how to do that.
https://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/UV/TextureAtlas


Why do even samples give less noise than odd samples?

Sometimes it so happens that if the renderer has to sample N discrete things, and the number of samples is a multiple of N, then it can be that each thing gets exactly the same number of samples, which gives less noise.

With path tracing, each AA sample picks one light at random. If you have 2 lights with 2 AA samples then each light can be picked once, but if you have 3 AA samples then one light must necessarily get more samples than the other, which results in noise.

If Cycles used pure random sampling to pick the light for each AA sample this effect would not happen, with 2 AA samples a light might then get 0, 1 or 2 samples and it would still be noisy. However the Sobol and Correlated Multi-Jitter sampling distributions used by Cycles are such that each light does get exactly the same number of samples. For Sobol this works if the number of lights is a power of two, for Correlated Multi-Jitter it works for any number of lights.

For SSS it's more difficult to explain. We use ray tracing to find nearby points on the surface, where 50% of the rays are distributed along the direction of the normal, and 25% along two tangent directions. For flat surfaces only the rays along the direction of the normal will find points on the surface, and the sample distributions are such that an even number of AA samples will cause each pixel to hit the surface the same number of times.


Can Blender in sculpt mode apply a stroke 360° around an axis?

Radial symmetry will allow you to do exactly that, just increase or decrease the number of steps and change the axis to suit your need.


It looks like you try to make your mesh look smooth by adding more mesh subdivisions instead of setting its shading to smooth.

Unless you're on an insane project and you have all the power of the world to be able to spend hundreds of polygons on the slightest prop, this isn't the right way.
Adding mesh should be needed only if you need those extra polygons to form volume. The smooth appearance should be before all managed through shading.

Since normal baking calculates your faces' normal as is, if you're using flat shading, the baked normals will be flat as well, hence this weird patterns.

See this Blender 2.79 manual page to learn more about normals.

In short, to fix this:

In the 3D Viewport, select your mesh
In the tools panel (toggle it with T), click the Smooth button in the Edit panel:

Then your baking should be correct.


How to use Animation nodes expression to call numpy.lcm?

You have to change the modules name math to numpy in the advanced node settings of the Expression Node which is located in the N-panel.


Finding a specific face/vertex/edge based on position value, not indices value

Some methods to do this, in my preferred order. All Scripts below will select the closest face to the scene cursor.

BVH Tree

The module mathutils.bvhtree

  BVH tree structures for proximity searches and ray casts on geometry.

Make a lookup tree directly from the bmesh and use its find_nearest(location) method to return index of element closest to that location.

Test script run in edit mode

import bpy
import bmesh
from mathutils.bvhtree import BVHTree
context = bpy.context
ob = context.object
scene = context.scene
mwi = ob.matrix_world.inverted()

loc = mwi @ scene.cursor.location

me = ob.data
bm = bmesh.from_edit_mesh(me)
bvhtree = BVHTree.FromBMesh(bm)

pos, norm, idx, d = bvhtree.find_nearest(loc)
if pos is not None: # is zero vector boolean False?
    for f in bm.faces:
        f.select = f.index == idx

    bmesh.update_edit_mesh(me)

Sort the faces

If the mesh is pretty small then sorting the faces based on distance from location to face centre, could suffice.

faces = sorted(bm.faces,
        key=lambda f: (f.calc_center_median() - loc).length)
closest = faces[0]

Closest point on mesh.

Object.closest_point_on_mesh(...)   Uses object or local coordinates

returns valid, location of closest point, face normal, face index.

The closest point on mesh must be run in object mode.  Remember that switching modes will most likely trash any existing edit mode bmesh.

mesh version

Toggle to object mode, select then switch to edit mode,

import bpy
import bmesh
# from mathutils import Vector
bpy.ops.object.mode_set()
context = bpy.context
ob = context.object
scene = context.scene
mwi = ob.matrix_world.inverted()

loc = mwi @ scene.cursor.location

hit, loc, norm, idx = ob.closest_point_on_mesh(loc)

if hit:
    me = ob.data
    me.polygons.foreach_set("select",
            [p.index == idx for p in me.polygons])
    bpy.ops.object.mode_set(mode='EDIT')

bmesh version

import bpy
import bmesh
# from mathutils import Vector
bpy.ops.object.mode_set()
context = bpy.context
ob = context.object
scene = context.scene
mwi = ob.matrix_world.inverted()

loc = mwi @ scene.cursor.location

hit, loc, norm, idx = ob.closest_point_on_mesh(loc)

if hit:
    bpy.ops.object.mode_set(mode='EDIT')
    me = ob.data
    bm = bmesh.from_edit_mesh(me)
    for f in bm.faces:
        f.select = f.index == idx

    bmesh.update_edit_mesh(me, True)

Note: v2.80 Test Script(s) Substitute loc = mwi * scene.cursor_location to make them 2.7x compato


Removing a few unwanted triangles and ngons/tsplines - is it necessary?

Here are some ideas to try, since I don't know what the parts of the mesh outside the viewport look like.

For the first one:
1. Add the green edge via the knife tool
2. Delete the red edge (or merge the verts so it's effectively gone)
3. Combine the triangles in the bluish triangle.

This will leave you with one triangle but the rest will be quads.  If you want to eliminate the triangle, you could try adding the yellow edge and then combining the resulting triangles and you'll have all quads.

For the T-spline, I'd try to remove it if it were me.  If not, you're basically trusting Blender to deal with it because at some point it'll triangulate it internally to render, and it might not choose the edges ideally.  In this case there are many options, and any of the ones in this image would probably work ok.  Personally I'd probably go with the light blue one.

The green one is ok, but it will give you a triangle, if that matters.  The orange one would just give you a tiny triangle, but it might be small enough to not look bad.

Modeling is definitely an art and these might not be the perfect answers for your situation. I doubt it would affect your unwrapping even if you left it as-is, but your shading might be odd in the problem areas.  Hope this is helpful!


How to disable Auto - Keyframing in Blender 2.8

You need to deactivate the Automatic Keyframe Insertion button:


How do I remove a cloth pinning at some point of the animation?

So it looks impossible to directly animate the Cloth Pinning. The question has been asked here and here, but I'm not sure to understand everyhting.
I've found an other solution, a rather simple one, with the Vertex Weight Mix modifier, but there must be others:

Create your object, give it 2 vertex groups, one for the pinning, the second one must be empty. Give it the Cloth physics.

Create a Force Field > Force next to your object. Animate it: give it Strength of 0 until frame 49 for example, keyframe it at frame 49, at frame 50 give it a Strength of 30.

Give your object a Vertex Weight Mix modifier, put it above the Cloth in the modifiers stack. Choose Vertex Group A > the pinning group, Vertex Group B > the empty group, Mix Set > VGroup A or B. Keyframe the Default Weight A and Default Weight B values: A will be 0 from frame 1 to 49, then 1 at frame 50, B will be 1 from frame 1 to 49, then 0 at frame 50.

It seems to work as planned, from frame 1 to 49, the object collapse with the pinning hanging it, at frame 50 it is blown away by the force field.


As noted by @DuarteFarrajotaRamos you have a node in the compositing that is altering the result.

You have a Hue Saturation Value Node changing your color.


Select the loop cut, press X , and select Dissolve Edges.


ahh... my bad.. the use node check box was not ticked.


how to make selected vertices rotate/scale/transform around themselves, not the cursor

okay, it turns out it was just changing the pivot point


Is it possible for individual faces to have separate materials from the rest of a mesh?

You can assign multiple materials to the same mesh, and then in edit mode select faces and in the material tab assign those faces to whichever material you want.


Generate an image from 3d model (server side)

Yes, independed from the web technology stack you're using on the server side you can invoke Blender from the command line.

Something like:

blender -b file.blend -a -x 1 --render-output <path>

should do the job. See the link above for a complete description of all available parameters. Note that Blender itself doesn't provide a HTTP server therefore you would need to make the rendered image available to your server (probably by simply copying the file or direct rendering into the web server's image resources directory).


Actuators always operate on the object they belong to.

That means you need to activate the actuator at the main menu rather than the one at the button.

In your situation it might be worth to send a message (when the button gets clicked). The main menu should listen to that message to play the action. Use a unique subject to allow other messages with other purposes.

I hope it helps


How can I parent objects so that only position and not scale is applied to the children when scaling the parent?

You can actually parent to a vertex to achieve something like this.
I would probably parent empties to the vertices where you want to add a child object and you can then use constraints (such as 'Copy Location', 'Copy Rotation') or make that empty a parent of your child object to link your child object to there.
To achieve this, create the empty and move it to the location of the vertex. Select the empty, hold Shift and select the 'parent' object. Hit Tab to go into Edit mode (you should now be in Edit mode with both the 'parent' object and the empty selected). Select just the vertex and press Ctrl+P to Make Vertex Parent. The empty should now be linked to that vertex.
Next simply add a 'Copy Location' constraint to the 'child' object to copy the Empty's location (this is similar to parenting) and a 'Copy Rotation' to the 'child' to copy the rotation of the 'parent' object. This way it will stay at the location of the vertex but with the rotation of the parent object, ignoring all scale.
I hope this makes sense - only limited time to submit this answer. I can add more detail if this seems helpful (unless someone else wants to add a more detailed answer along similar lines).


How to display a projected texture on a mesh?

The example project seems to be a bit outdated, I took it and added a shader with a checkerboard texture, that works fine - all other settings do indeed work in that file. Just add this shader network to the monkey:

Then you can change the mapping by moving the projector, which in this project is the lamp.


How to save Denoising Data and the noisy image of Cycles Render

A little late but maybe someone needs the solution:
To render images and export also their denoising information, create a group of compositor nodes, link them and just render the image as usual.

Example of what worked for me:

def use_compositor_extra_information(noisy=True, albedo=False, normal=False, dir="D:/Renderings/"):

    bpy.context.scene.view_layers['View Layer'].cycles.denoising_store_passes = True
    bpy.context.scene.use_nodes = True

    tree = bpy.context.scene.node_tree
    # clear all nodes which were there before
    for node in tree.nodes:
        tree.nodes.remove(node)

    # create input node with all rendering layers
    render_layer_node = tree.nodes.new(type='CompositorNodeRLayers')
    composite_node = tree.nodes.new(type='CompositorNodeComposite')
    links = tree.links

    if noisy is True:
        # output of the noisy image
        noisy_image_node = tree.nodes.new(type='CompositorNodeOutputFile')
        noisy_image_node.base_path = os.path.normpath(dir)

        link_noisy = links.new(render_layer_node.outputs['Image'], noisy_image_node.inputs[0])

    if normal is True:
        # output of the normal image
        normal_image_node = tree.nodes.new(type='CompositorNodeOutputFile')
        normal_image_node.base_path = os.path.join(dir ,"normal")
        link_normal = links.new(render_layer_node.outputs['Denoising Normal'], normal_image_node.inputs[0])

    if albedo is True:
        # output of the albedo image
        albedo_image_node = tree.nodes.new(type='CompositorNodeOutputFile')
        albedo_image_node.base_path = os.path.join(dir , "albedo")
        link_albedo = links.new(render_layer_node.outputs['Denoising Albedo'], albedo_image_node.inputs[0])

When now rendering an image with:

bpy.ops.render.render(animation=False, write_still=True)

The noisy and albedo images should be now in the given path.


Why is my Rigid Body simulation giving weird results?

Make sure the objects are not scaled (Object>Apply>Scale shortcut Ctrl+A) because that can cause issues. Very small objects (about 0.01 blender units) may require tweaked settings.


How can I use Edge Creasing with OpenSubdiv?

OpenSubdiv has not been completely implemented into Blender. It is currently only used for viewport playback speed for animators.

Official Document about it's implementation

Limitations
There are number of limitations which are not resolvable with the current OpenSubdiv release and current OpenGL profile of Blender itself:

Smooth normals aren't currently correct. This goes into limitations of GLSL level we can currently use in Blender and what OpenSubdiv can provide us. It's being worked on though with high priority.
No OSX support, Historically Blender is using rather old OpenGL API and OpenSubdiv is using OpenGL 4. This makes it impossible to make Blender working with OpenSubdiv on OSX due to policy from Apple which forces everyone to drop older OpenGL code if newer API is used in application.
No UV maps support in viewport. This limitation is caused by OpenSubdiv which currently doesn't have nice support of UV mapping evaluation on GPU and has no way to calculate UVs on CPU as well.
No generated coordinates support. Generated coordinates in blender requires calculation of undeformed mesh on CPU which makes it rather really complicated to use OpenSubdiv in such configuration because all it's data is on GPU.
Tools which requires having mesh on CPU (for example snap tools) will fail for OpenSubdiv mesh. This also includes areas like geometry primitive counter in the Info header.
Currently shading is limited to a single material only. This is easy to resolve from Blender side and will happen sooner than later.
Loose edges and vertices are not supported.
Auto split is not working yet
Loop normals are not supported yet as well


How do I change strength of emission at Principled BSDF

Blender 2.92 + :
In the newer versions the principled BSDF shader actually has a field for emission strength, right below the emission color field. You can use it much like the simpler Emission Shader.
You can still input color values superior to 1, but there is no need anymore with the new strength field.

Older Versions :
You can manually input values higher than 1 in the red,green,blue fields of the emission color of the principled shader. Keep in mind that this is a workaround and will not mimic exactly how a classic emission shader works when you tweak its strength.

For ease of use you can use such a setup : Add an rgb node in order to input the exact color you want the emission to be, a value node for the strength of the emission, and link both of them to the color inputs of a mix rgb node set to multiply with a factor of 1, then set the output of the mix rgb to the emission input of the bsdf.


Cannot save customized blender interface theme .xml

of course i found the solution right after posting a question...
it's in the configuration file or directory apparently
you have to go to:
C:/Users/Your User Name/AppData/Roaming/Blender Foundation/Blender/2.xx/scripts/presets/interface_theme
and the .xml files for your created themes will be there


Disable double sided faces in Blender 3D View

In Properties panel N find section "Shading" -> "Backface culling":


You can pull from another .blend with File > Append.


There's a built-in feature to show mesh element indices, but the option isn't shown in the user interface by default.

Blender 2.7 and older:

The option only shows if the debug mode is enabled.

Start Blender in debug mode, or simply go to Python Console (Shift-F4) and type bpy.app.debug = True
Go to N-panel > Mesh Display
A checkbox Indices will now show
The colors are controlled by the interface theme

There's also an updated version of the Index Visulizer script:
space_view3d_index_visualiser_bmesh.py

Blender 2.8:

It only shows if the developer UI option is turned on.

Run Blender normally
Click Edit > Preferences...
In the Display panel of the Interface tab, tick Developer Extras
or type bpy.context.preferences.view.show_developer_ui = True into the Python console.
Open the Overlays popover in the 3D View
Look for the label Developer and tick the checkbox Indices


Zooming in to a selection of vertices with the period key does not work as expected

It looks like you accidentally locked the view to an object or to the 3d cursor.

To unlock the view from object:

Press the N hotkey to open the properties panel on the right of the 3D view.
In the View section remove the object in the Lock to Object setting. If it is active, the Object name to which the view is locked will be listed in that field.
Click the X to the right of the object name to remove it.

To unlock the view from cursor:

Same as above, open the properties panel scroll down to the View section.
Uncheck the option "Lock to Cursor".

After unlocking the view, zooming to selection should work as expected.

In the image bellow you can see the correct settings for zooming to start working as expected.


Why are my brush strokes in sculpting not smooth but leaves dents

go to stroke > an change to space and set spacing lower then what it is. (5% or lower)
also it might help to set spacing distance to view.


How to correct surface normal for translated object

There are two problems in the script, the location and the rotation of the cone objects aren't correct.

The location is incorrect because the script currently sets it to the position of the randomly chosen point, not the location of the closest point on the surface. These coordinates can be retrieved through the return values of closest_point_on_mesh():

(result, location, normal, index) = emitter.closest_point_on_mesh(point)

The global coordinates are therefore:

emitter.matrix_world * location

If the goal is to align an arbitrarily chosen axis of an object with the normal, then the problem that needs to be solved is to find a rotation matrix. This matrix has to rotate the vector of the local axis to match the normal vector exactly, assuming that the vector is normalized.

One way of determining the rotation matrix is through the Rodrigues' rotation formula. It requires an angle and an axis of rotation. The angle $\theta$ between two vectors can be determined through the dot product, which is defined as:

$$a \cdot b =  \|a\| \|b\| \cos(\theta)$$

It follows

$$\theta = \arccos\left(\frac{a \cdot b}{\|a\| \|b\|}\right) $$

Any rotation angle in range $[0, \pi)$ radians or $[0°, 180°)$ can be used unambiguously. If $a$ and $b$ are unit vectors, then their magnitude is one and the division isn't necessary.

In order to rotate the vector, an axis for the rotation is required. Two vectors that a linearly independent define a plane and the cross product $a \times b$ is the normal to that plane, which is perpendicular to the two vectors.

Blender already implements the Rodrigues' formula in mathutils.Matrix.Rotation(angle, size, axis). Assuming we have a normalized vector $a$ that we want to align to vector $b$, the rotation matrix can be determined by the following code:

cross_prod = a.cross(b) # Axis used for rotation
dot_prod = np.arccos(a.dot(b)) # Angle in radians (ambiguous if >= pi)
rotation_matrix = mathutils.Matrix.Rotation(dot_prod, 4, cross_prod)

This could actually be optimized and not use arccos altogether as explained by Kevin Moran.

You can chose an arbitrary vector for $a$ as long as it isn't linearly dependent to $b$. For your specific application it makes sense that $a$ is either one of the global axis or one of the local axis of the cone object in the global coordinate system. For the latter you will have to decompose the world matrix of the cone object in order to determine it's rotation matrix and multiply with the desired axis.

# Determine the vector that will be aligned with the surface normal
if axis == 'X':
    axis_vector = mathutils.Vector((1.0, 0.0, 0.0))
elif axis == 'Y':
    axis_vector = mathutils.Vector((0.0, 1.0, 0.0))
else:
    axis_vector = mathutils.Vector((0.0, 0.0, 1.0))

# Apply the existing rotation of the object when the local axis is used
if use_local_axis:
    (old_location, old_rotation, old_scale) = new_obj.matrix_world.decompose()
    axis_vector = old_rotation * axis_vector

The adjustment of both rotation and location can be combined by creating a new world matrix for the target object.

new_obj.matrix_world = (mathutils.Matrix.Translation(emitter.matrix_world * location) * mathutils.Matrix.Rotation(angle, 4, rotation_axis) * mathutils.Matrix.Scale(1.0, 4))

Below you can find an implementation of the described solution as an add-on for Blender 2.79.

bl_info = {
    "name": "Create and Align Objects with Surface Normal",
    "author": "Robert Guetzkow",
    "version": (1, 0),
    "blender": (2, 79, 0),
    "location": "3D View > Tools > Create and Align",
    "description": "Create objects that are aligned with the surface normal of another object",
    "warning": "",
    "wiki_url": "",
    "category": "3D View"}

import bpy
import bpy_extras
import mathutils
import numpy as np
from bpy_extras import mesh_utils

class CreateAlignSettings(bpy.types.PropertyGroup):
    emitter = bpy.props.PointerProperty(type=bpy.types.Object,
                                        name="Emitter",
                                        description="The emitters surface is used to create"
                                                    " and align objects on it, according to its surface normal")

    dupli_object = bpy.props.PointerProperty(type=bpy.types.Object,
                                             name="Dupli Object",
                                             description="The object duplicated along the emitters surface")

    axis = bpy.props.EnumProperty(name="Axis",
                                  description="The axis of the duplicated object that will be aligned with the surface "
                                              "normal",
                                  items=[('X', 'X', 'X-axis', 0),
                                         ('Y', 'Y', 'Y-axis', 1),
                                         ('Z', 'Z', 'Z-axis', 2)],
                                  default='Z')

    use_local_axis = bpy.props.BoolProperty(name="Local Axis",
                                            description="Use the possibly rotated local coordinate system of the "
                                                        "duplicated object, to determine the axis orientation in "
                                                        "global space. If disable the global axis is used and the "
                                                        "object's rotation is ignored.")

    number_duplicates = bpy.props.IntProperty(name="Number of Duplicates",
                                              default=0)

class CreateAlign:
    @staticmethod
    def create(emitter, dupli_object, axis, use_local_axis, number_duplicates):
        # Remove previously created duplicate objects
        CreateAlign.remove_dupli_objects(emitter, dupli_object)

        emitter.data.calc_tessface()
        surface_points = bpy_extras.mesh_utils.face_random_points(1, emitter.data.tessfaces)

        for idx, point in enumerate(surface_points):
            if idx == number_duplicates:
                break

            CreateAlign.duplicate_and_align(emitter, dupli_object, axis, use_local_axis, point)

    @staticmethod
    def duplicate_and_align(emitter, dupli_object, axis, use_local_axis, point):
        new_obj = dupli_object.copy()
        new_obj.data = dupli_object.data.copy()
        bpy.context.scene.objects.link(new_obj)
        new_obj.animation_data_clear()
        new_obj.parent = emitter

        (result, location, normal, index) = emitter.closest_point_on_mesh(point)

        # Determine the vector that will be aligned with the surface normal
        if axis == 'X':
            axis_vector = mathutils.Vector((1.0, 0.0, 0.0))
        elif axis == 'Y':
            axis_vector = mathutils.Vector((0.0, 1.0, 0.0))
        else:
            axis_vector = mathutils.Vector((0.0, 0.0, 1.0))

        # Apply the existing rotation of the object when the local axis is used
        if use_local_axis:
            (old_location, old_rotation, old_scale) = new_obj.matrix_world.decompose()
            axis_vector = old_rotation * axis_vector

        normalized_axis_vector = axis_vector.normalized()
        rotation_axis = normalized_axis_vector.cross(normal)
        angle = np.arccos(normalized_axis_vector.dot(normal))

        # Create a new world matrix with the position of the closests surface point
        # and the rotation to align with the surface normal
        new_obj.matrix_world = (mathutils.Matrix.Translation(emitter.matrix_world * location) *
                                mathutils.Matrix.Rotation(angle, 4, rotation_axis) *
                                mathutils.Matrix.Scale(1.0, 4))

    @staticmethod
    def remove_dupli_objects(emitter, dupli_object):
        children = emitter.children

        for child in children:
            if child.name.startswith(dupli_object.name):
                bpy.data.objects.remove(child, True)

class CREATE_ALIGN_OT_create_and_align(bpy.types.Operator):
    bl_idname = "create_align.create_and_align"
    bl_label = "Create"
    bl_description = "Create duplicated objects that are aligned with the surface normal of the emitter"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        settings = context.scene.create_align_settings
        CreateAlign.create(settings.emitter,
                           settings.dupli_object,
                           settings.axis,
                           settings.use_local_axis,
                           settings.number_duplicates)
        return {'FINISHED'}

class CREATE_ALIGN_OT_remove(bpy.types.Operator):
    bl_idname = "create_align.remove"
    bl_label = "Remove"
    bl_description = "Remove duplicated objects"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        settings = context.scene.create_align_settings
        CreateAlign.remove_dupli_objects(settings.emitter, settings.dupli_object)
        return {'FINISHED'}

class CREATE_ALIGN_PT_surface_normal(bpy.types.Panel):
    bl_label = "Create and Align with Surface Normal"
    bl_category = "Create and Align"
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"

    def draw(self, context):
        layout = self.layout
        layout.prop(context.scene.create_align_settings, "emitter")
        layout.prop(context.scene.create_align_settings, "dupli_object")
        layout.prop(context.scene.create_align_settings, "axis")
        layout.prop(context.scene.create_align_settings, "use_local_axis")
        layout.prop(context.scene.create_align_settings, "number_duplicates")
        layout.separator()
        layout.operator(CREATE_ALIGN_OT_create_and_align.bl_idname)
        layout.operator(CREATE_ALIGN_OT_remove.bl_idname)

classes = (CreateAlignSettings,
           CREATE_ALIGN_OT_create_and_align,
           CREATE_ALIGN_OT_remove,
           CREATE_ALIGN_PT_surface_normal)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.create_align_settings = bpy.props.PointerProperty(type=CreateAlignSettings)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)
    del bpy.types.Scene.create_align_settings

if __name__ == "__main__":
    register()

Porting to Blender 2.80:
Note that I haven't ported this to 2.80, because calc_tessface and related functions have been removed and I didn't know whether you had special requirements for the point selection. You would need to use a different approach to determine random face points.

Other necessary changes include:

Matrix multiplication is @ instead of *.
Annotation would be used instead of assignment for the properties.
The tool sidebar doesn't exist anymore, therefore the panel should have bl_region_type = "UI"

Instead of sending me the offered money, please consider donating it to either one of these organisations:

Médecins Sans Frontières / Doctors Without Borders
Blender Foundation


How to add custom icon to EnumProperty in add-on

For each enum item an icon can be specified. You just need to edit this part of your code:

# defined globally
easingItems = [
    ("EASE_IN", "Ease In", "", customIcon["MY_EASEIN"].icon_id, 0),
    ("EASE_OUT", "Ease Out", "", customIcon["MY_EASEOUT"].icon_id, 1),
    ("EASE_IN_OUT", "Ease In-Out", "", customIcon["MY_EASEINOUT"].icon_id, 2)]


so after @batFINGER `s examples, I wrote my example. The code is 'Ugly' but in the other hand, it's working

import bpy
import csv

csvfile = "yourfiledirectory\file.csv"
suffix = '.fbx'
with open(csvfile) as csvfile:
    csvread = csv.reader(csvfile)
    for i, row in enumerate (csvread):
        if i==0: continue
        filename = row[0]
        loc_x = row[1]
        loc_y = row[2]
        loc_z = row[3]
        scale_x  = row[4]
        scale_y  = row[5]
        scale_z  = row[6]
        rot_x = row[7]
        rot_y = row[8]
        rot_z = row[9]
        rot_z = float(rot_z)*-1
        rot_w = row[10]
        dir = "directory where your files are"
        bpy.ops.import_scene.fbx( filepath = dir )
        bpy.ops.transform.translate(value=(float(loc_x), float(loc_y), float(loc_z)))
        bpy.ops.transform.resize(value=(float(scale_x), float(scale_y), float(scale_z)))
        for obj in bpy.context.selected_objects:
            a = obj.name
            print(a)
            bpy.context.scene.objects.active = bpy.data.objects[a]
            bpy.context.object.rotation_mode = 'QUATERNION'
            bpy.context.object.rotation_mode = 'QUATERNION'
            bpy.context.object.rotation_quaternion[0] = float(rot_w)
            bpy.context.object.rotation_quaternion[1] = float(rot_x)
            bpy.context.object.rotation_quaternion[2] = float(rot_y)
            bpy.context.object.rotation_quaternion[3] = float(rot_z)


How to toggle Xray in viewport with Python?

Often the UI code gives clues

Turn on developer extras in user preferences and can right click and view source of most UI elements.

Do this over toggle xray button and It takes us to the draw code, in text editor,  of the operator button in 3d view.

In space_view3d.py

    row.operator(
        "view3d.toggle_xray",
        text="",
        icon='XRAY',
        depress=getattr(
            shading,
            "show_xray_wireframe" if shading.type == 'WIREFRAME' else
            "show_xray"
        ),

Trecking up we see  shading is a pointer property of the SpaceView3d  This is context.space_data in the 3d view, but not in text editor or console.  A reason for the failed context error.

-- remnder: post like to codemanx's override context answer, or easier still See Merlin's answer --

We could simply find the area and space and other required members and pass as an override dictionary to the operator, however we may be able to simply toggle a property of the space.. much easier.. off to the python console to investigate

get all the 3d view areas in the context screen

>>> views3d = [a for a in C.screen.areas if a.type == 'VIEW_3D']

iterate over them and see what the values are using code above as clue. The space from an area is area.spaces.active

>>> for a in views3d:
...     shading = a.spaces.active.shading
...     shading.type
...     shading.show_xray
...     shading.show_xray_wireframe
...
'SOLID'
True
True

Hmm ok let's see

>>> shading.show_xray = False
>>>

and bingo, toggles shading. I'll leave you to decide on how to handle show_xray_wireframe based on shading.type


How to animate an object to revolve around a fixed point in blender?

As example I have a cube that revolves around an empty

Add empty and add cube

Select the cube and then select the empty and press ctrlp and select Object, the cube is parented to the empty

Select empty and press I and select rotation, so the empty has a rotation keyframe

the timeline you can use to pick another frame and enter 360 in highlight and press I to insert a keyframe:


What is the technical difference between conformal and angle-based unwrapping?

Conformal
Uses LSCM (Least Squared Conformal Mapping). This usually gives a less accurate UV mapping than Angle Based, but works better for simpler objects.
(As describled by blender user manual)

Attached is the link to the White paper on LSCM

http://www.cs.jhu.edu/~misha/Fall09/Levy02.pdf
http://alice.loria.fr/publications/papers/2002/lscm/lscm.pdf


What does obj_now_BVHtree.overlap(obj1,obj2) return?

mathutils.bvhtree.BVHTree.overlap returns a list of unique tuples, where each tuple represents the overlap between two elements of the two trees. The first entry of each tuple is the index from one tree and the second entry is from the other tree.

  overlap(other_tree)

  Find overlapping indices between 2 trees.

  Parameters: other_tree(BVHTree) – Other tree to perform overlap test on.
  Returns: Returns a list of unique index pairs, the first index referencing this tree, the second referencing the other_tree.
  Return type: list


"Map Range" node equivalent for Material nodes?

Use a Math node set to multiply:

on top put 1.0 / max age  <-- this you can precalculate
in the second socket connect age

=  0....1

or, Use two Math nodes. Useful for if your max age is the same as lifetime of the particle. This way you can also deal with a dynamically changing particle lifetime.


Aligning/joining two objects (Head/Body) with matching edge list

This is my workflow for aligning objects that are accuratelly separated but  rotated randomly. The tutorial seems to be complicated but it is actually quite quick method (if you remember how to do it :) and accurate. Unfortunately I don't know about any addon that would do that automatically.

I will demonstrate it on an example with Suzanne model so warning - this tutorial contains drastical images.

The whole idea is to rotate the model gradually by using 3 common vertices.

Rotate & align both objects so they fit to each other roughly

No we need to find common vertex pair and snap objects there

Detailed steps:

set Snap target to Active (remember, the active vertex / edge / face is the one selected the last)
set Snap Element to Vertex CtrlShiftTab
select the object you are going to fiddle with (it is the top part in our example), switch into Edit mode Tab, then Select All A and select the vertex you are going to use for the snap (now it is the active one)
enable Snapping ShiftTab or you can always hold Ctrl while grabbing instead
grab G the mesh while holding Ctrl and move it / snap it to the same positioned vertex in the second model

Use the previously aligned vertex as a pivot point, then snap the model's rotation to the vertex on the other end of the same edge. This needs to be done for each axe separately

set Pivot point to 3D cursor .
make sure you have the common vertex selected and move Cursor to Active ShiftS
select whole model and then a vertex on the same edge as previously snapped vertex (so it is active now)
press R and then X to rotate around X and snap it to corresponding vertex on the second model, repeat this for Y & Z axes (after that, double-check the mesh doesn't rotate anymore on any of these axes so it is aligned perfectly)

When we have the common edge, we can rotate model around it to make the fit complete

Pivot Point to Active Element
Transform Orientation to Normal
Snap Target to Closest
turn off snapping ShiftTab
select whole mesh A and ...
select the edge between our previously aligned vertices as last (so it is active)
rotate the mesh around normal Y axe by pressing RYY so it roughly fits the other model

turn on snapping ShiftTab and use the same rotation method as in the previous step, now it will (hopefully) snap perfectly

If you are about to join the objects (by selecting them and pressing CtrlJ), don't forget to go into Edit Mode Tab, select all A and Remove Doubles by W > Remove Doubles to merge the common vertices.


Use a mesh as a path with correct tilt information for use with "duplicate frames"

First create a loop cut in the middle of your Path,

Then press CtrlI while the loop cut is selected to select everything appart from this exact edge and delete. Or if you want to keep the path you have to just duplicate this loop cut and Separate it by Selection, using P key,

After that you have to convert this edge into a Curve, to do that press AltC > Curve from Mesh/Text.

Now you have to get your model of the planch,

Give it an Array Modifier, and set the spacing between each planch as well as the number of the planches to fit the Curve.

Finally apply the Aray Modifier and add a Curve Modifier, then choose the Curve (it is propably going to be under the name of PLANE)

The Result


Wrong shape of the inserted face the insert in circle

Try to go to object mode and hit Ctrl + A  and select To All Transforms and now try to insert face.


How to optimize nodes and view layers created with motion tracking "set scene"

OK I figured out what is going on, the file started with one layer and when I used the camera motion tracking to set the background and tracking scene it created a new layer so Blender rendered both layers, the shadow catching plane was put in a background layer.

the simplified version on top does the same thing as the one with the extra layers , the camera tracking works all the same it just renders faster.


How can I add control points to a NURBS surface

"Extrude Curve and Move" or "Subdivide"

You can add control points to a NURB surface object by running the command Extrude that you can find in the modeling section of the Tool bar in the Tool shelf and then move le vertex away with grab. Or you can do all at once with the operator of the title (shortcut E).

The operation is very similar to the one you can perform with meshes, but this is for surfaces only (UV coordinates only).

If you want to increase the resolution while keeping a similar shape of the grid, you can use the Subdivide operator (you can find it in the Toolshelf too). Subdivision cannot break the NURBS's laws, so you should select a whole U (or V, or both) stripe to make it work.

Remember that NURBS modeling tools in Blender are not currently (2.76) as advanced as the Mesh counterparts, so some functionalities you expect may be missing.


First of all, you should prepare two images A and B such that A flipped horizontally has the same contour (the same alpha channel) as B. Otherwise, you will see that the character changes pose when flipping.
If you do that, then your problem will probably be solved: if you have a a very thin (0.001 m) cube with one big face depicting the front of an astronaut, and the other big face depicting the back of the astronaut, you won't be able to see the wrong side, as the right side will cover the other completely (because the alpha channels match).
Without doing the above, you can enable Backface culling to not display insides of an object:

Also, you don't need a cube and a single plane is enough - just use the Geometry > Backfacing to determine which side you're displaying:

Of course for a single plane, the Backface Culling has to be disabled.


Keeping array objects straight when duplicated along a twisted curve

I finally have an answer to this. I wanted to make pillars for my roller coaster track, and I needed them to be vertical as well and after a lot of search found the solution. Here is how it looks

The way is to NOT use Array Modifier/Curve Modifer but instead parent the object (fence posts) to your curve ( Ctrl P), and then use DupliFrames (after disabling speed). This way, it treats each of your posts as separate objects and then you can use Limit Rotation to zero degrees on all axes. This will keep them vertical.

I just implemented this and it totally worked. Let me know if you need more details. I think the idea is that modifiers treat the set of fence posts as a single object and thus you cannot Limit Rotation on them separately. Using DupliFrames treats them as separate objects and thus you can limit their rotations afterwards. Sorry for the wordy reply without any images. Other blender experts can comment if this should work.


After hitting I key, continue with the B key to turn off/on boundary feature.


How does blender really save a blendfile?

According to the Blender wiki provided by lemon:

Saving and loading complex scenes in Blender is done within seconds. Blender achieves this by saving data in memory to disk without any transformations or translations. Blender only adds file-block-headers to this data.
A file-block-header contains clues on how to interpret the data. After the data, all internally Blender structures are stored. These structures act as blue-prints when Blender loads the file.

If I read this correctly, it means that blender just performs something like a memory dump and writes that to a file and just adds some meta data to it. This is a quick way to write big chunks of data to the harddrive, but makes for a though job when re-loading the .blend file.
This is because during load you must check for changes in platform, blender version,... as described in the wiki article as well.
All in all I think the answer to you question is yes: Blender does indeed write the full 1GB file to your harddrive. It is a lot faster than writing (for instance) a 1GB Word document because blender just 'dumps' the data rather than exporting it in a document format that is fairly easy to interpret on reload.


All those islands should be in the 0-1 space. There are some reasons to move things out of that area, as an example, if you want the texture to repeat or if you want to exclude part of a model from a texture bake operation.

For what you are doing there, I think it's best that you do what is shown in the following image.  While in Edit mode, move all the UV islands into the light grey area that is displayed with the grid.

The dark grey zone is out of bounds.


Hair particles breaks in half - blender cycles

To see if we are on the same page, here is my broken hair:

If that is what you are seeing -- and it looks similar -- here are ideas/options:

Have you tried using the B-spline checkbox under the Particle System's Render  area? Also choose a higher "Steps" settings -- although doing so increases render time... But see if that addresses the issue.

In the same vein, see if using Curve Segments as primitives (this is under the Particle Systems "Cycles Rendering" area) helps. Turn on cull back-faces and  turn curve subdivisions to 4 or 5 or 6.

For comparison:

The image above is without B Splines and with primitives set to Line segments. My hairs break at the first crinkle... perhaps that is what you are seeing?

Above: Same as first image, but with B Splines on and Steps set to 5.

Above: Same as first image, but with (B splines not on) and Primitives set to Curve segments.


How to edit my second object only?(instead of edit the first and second objects together)

A way to do its is to use bmesh.ops with mirror.
import bpy
import bmesh

# Get the object and its mesh
obj = bpy.context.object
mesh = obj.data

# Give the mesh to a bmesh
bm = bmesh.new()
bm.from_mesh(mesh)

# Call the mirror operation with Z axis
bmesh.ops.mirror(bm, geom = bm.faces[:], axis='Z')

# Back to mesh
bm.to_mesh(mesh)

# Force update (if not the screen won't refresh immediatly)
mesh.update()


Separate reflection based on object index cycles

Starting with two objects with the same glossy material.

Give the objects different Pass Index.

Enable Object Index in the render layer

In the compsitor use an Id Mask node and select the pass index of your object and use that to mix the blurred image with the non blurred one:


How to rig a folding laptop with a hinge?

I take it that the screen will always remain at the same angle relative to the hinge? If that's the case, move the origin of the hinge to the desired pivot point and parent the screen to the hinge. Then, you can parent the hinge to the keyboard.

By doing so, moving the keyboard will move the hinge, and rotating the hinge will rotate the screen. However, you won't be able to rotate the hinge+screen by grabbing the screen in this case, that will just detach the screen. This is Rig 1 in the included blend file.

If you don't want to move the hinge's origin, you can add an Empty Axis at the pivot point. Parent the hinge and screen to the empty, and the empty to the keyboard.
In this case, the screen and hinge are controlled by the empty, and the empty, screen and hinge will be moved around if you move the keyboard. This is Rig 2.


Is it possible to apply a texture so that it looks like it is actually ON the mesh and not PROJECTED on?

I guess you need a Hight Map node in your shader, I've seen people use the same image as both the hightmap and the texture itself, but they say it will not always work correctly.

You should and connect it to the displacement entry of the output, study a little about how to make height map images to use alongside the texture maybe.


It sounds like the "Import Image as plane" add-on did not UV map it correctly. If that is the case, then you can fix it by hand.

For fixing it, scale the UV map in the UV/image Editor while in Edit mode with the desired image in the editor. Or by going into top orthographic view and using the "Project From View (Bounds)" function by pressing "U".


Add a new edge snapping to a vertex and with an angle constraint?

In edit mode press K, that will start the knife tool. Simply LMB  click on the vertex you want the cut to start from, and left click again on the other edge. Snapping for the cut is enabled by default. If you want the new edge to be straight then activate angle constrain by pressing C.  Once you like how the new cut is press Enter to finish the cut and exit the knife tool.
If you look at the 3d view header, you will see all the options for the knife tool and what button to press.
(click on image for full size)


How to render an object as a transparent wireframe?

One way you could do this is by using freestyle:

Create a transparent material and assign it to your objects:

Enable freestyle in Render settings:

In Render layers, set the line visibility to QI range and set the end to 1:

Think of the QI range like a sort of depth index; faces directly visible to the camera are 0, faces behind those faces are 1, faces behind those faces are 2, etc.

By only rendering lines on faces between 0 and 1 (inclusive), you can get a result like in your example image.

Or you could use wireframe materials:

See this question for details.


You don't say enough about your final purpose, for example is it supposed to be animated, is the texture supposed to be exactly the same or about the same, etc?

If you're animating it with shape keys you could use the Texture Coordinate's Object output socket. The texture won't deform:


Solved. Reduced problem to four rectangles and noted vertex count in status bar. The two inner rectangles each have an extra vertex.

This also shows that the location of the normal is not the centroid of the area, but the centroid of the vertices.

Blend uploaded to .


"Vertex paint" or Cycles "Mix node" problem?

Having such problems with mask created by Vertex Paint:

First check whether there are double vertices (W >
Remove doubles).
Recalculate normals with Ctrl + N. The result
is better but still weird, something like:

Continue using Vertex Paint, simply drawing over these gaps and
smoothing boundaries and it's done.


Can I create a timer overlay for a video file to use in the VSE? How?

You could make a counter with the wonderful Randomiser addon http://bensimonds.com/2014/04/02/randomiser-add-on/ it has a count function.


How to have different object info for post-separated objects?

First method (answer to the question)

The object index references the object pass which can be used either in the shader editor to pass information to your material relative to each or different groups of objects, or in the compositor with light passes.

But its purpose is not to get automatically incremented each time you create an object.
Thus, you can either manually change their number or use a very simple script to do it automatically.

Open a new workspace of type "Text editor", create a new script with Text > New. Write this (important : You must respect the 4 spaces offset or add a tabulation on the third line else the python interpreter will complain) :

import bpy
for i, obj in enumerate(bpy.context.selected_objects):
    obj.pass_index = i

Then, select all of your plane objects in object mode, and click "Run Script" in the top right corner of your text editor. Voilà !
This method seems to remember the order in which each item of an array has been created so your node network should work.

Important : The mapping node works with radians, so you either have to add a math node set to "To radians" (V2.81+) or type "pi/2" (without the quotation marks and in lower caps) in place of "90"

Second method (exploring the node network)

If what you are trying to achieve is simply to have a plane with regularly places 90° rotated squares, you can achieve that with a single object and a bit of node magic.

Add a "Texture Coordinate" node
Add a "Vector Math" node set to "Absolute", and connect the object output of the Texture Coordinate node to its input
Connect this node to a "Vector Math" node set to "Modulo", and set the second vector to 1,1,1. This will create repeating squares of size 1 in x and y directions.
Connect it to a 'Vector Math' node set to 'Add' and set the second vector to '-0.5,-0.5,-0.5'
Connect it to a 'Mapping' node's 'Vector' input
Add a 'Vector Math' node set to 'Floor' and connect the texture coordinate's object output to its input
Connect it to a 'separate XYZ' node
Add a 'Math' node set to 'add' and connect both the x and y outputs
Connect it to a 'Math' node set to 'Multiply' and write "pi/2" in the second field.
Connect it to the 'Z' input of 'Combine XYZ' and connect it to the rotation input of the mapping node.

Voilà ! Scale your plane way up in edit mode. You now have a repeating pattern along X and Y, which rotates with every new square.
Example with a "Gradient Texture" set to 'Linear' :

No reference to an infamous 4-armed shape intended

Let's go deeper. Let's capitalize on the node flexibility to add a value node which will make the square pattern tweakable.

Add a value node
Connect it to the bottom socket of the "Divide" node
Connect it to bottom socket of the "Modulo" node
Connect it to new "Math" node set to  'Divide' by 2
Connect this to the second field of a "Math" node set to 'Subtract', with the first one set to 0
Finally, connect it to the bottom half of the "Vector Add" node

Result :


Is it possible/how to separate several "objects" imported from an stl file?

Select the object, enter edit mode with Tab key, select all with A and press P to separate, then choose whatever option suits your needs best. I am guessing you will probably want the loose parts one.


There is!:

Ctrl+Z is Undo

Ctrl+Shift+Z is Redo.

And Ctrl+Alt+Z is to show and select Undo History.


Image is fuzzy or noisy when rendered in cycles

Increase the number of samples for rendering.

With a higher the number of samples rendered images will be less noisy and more accurate (read this for more info)
Make sure that you are rendering at 100% resolution.

Resolutions lower than 100% might be pixelated

Set emission shaders to Multiple Importance Sampling.

For more info read this post When should MIS be used and when should it be disabled?

If you are using an image as environment, set it to Multiple Importance Sampling as well.

For a finer control on noise, switch from Path Tracing to Branched Path Tracing

  The branched path tracing integrator [...] will split the path for different surface components and will take all lights into account for shading instead of just one. This makes each sample slower, but will reduce noise, especially in scenes dominated by direct or one-bounce lighting.

For additional info please read this post: What is branched path tracing and how is it useful?
Check that the samples settings for the render layers are set correctly.

For more info on this settings read: Cycles render, noisy even when using a high number of samples

Besides the noise, your image shows also a common limitation on cycles default color management settings, in which bright lights desaturate in an unrealistic way. See this post: Render with a wider dynamic range in cycles to produce photorealistic looking images


There is a request over "Rightclickselect" website for the Blender team to take under consideration for something like this. for now, there are some add-ons like simple lattice that you could check
https://github.com/BenjaminSauder/SimpleLattice


You could import your externally created models into separate .blend files and link them into a master .blend file containing the scene instead of directly importing them. This way the linked files can be refreshed.

The basic idea:

I uploaded a working sample here

WARNING: The script should not be started from your scene file it first deletes all content. You would need to invoke it from command line see:
Put the following command in a batch file conv.bat

"C:\Program Files\Blender Foundation\Blender\blender.exe"  --background --python batch_convert.py
pause

Save the python script in batch_convert.py

import os
import bpy

# put the location to the folder where the objs are located here in this fashion
path_to_obj_dir = os.path.join('C:\\', 'OBJ')

# get list of all files in directory
file_list = os.listdir(path_to_obj_dir)

# get a list of files ending in 'obj'
obj_list = [item for item in file_list if item[-3:] == 'obj']

# loop through the strings in obj_list
for item in obj_list:
    # select all object
    bpy.ops.object.select_all(action='SELECT')
    # delete selected
    bpy.ops.object.delete(use_global=True)
    # import obj
    path_to_import = os.path.join(path_to_obj_dir, item)
    bpy.ops.import_scene.obj(filepath = path_to_import)
    # rename
    for obj in bpy.context.selected_objects:
        obj.name = item[:-4]
        print(dir(obj))

    # write blend
    path_to_export = os.path.join(path_to_obj_dir, item[:-4] + ".blend")
    print(path_to_export)
    bpy.ops.wm.save_as_mainfile(filepath=path_to_export, check_existing=False )

After exporting an .obj you would only run the batch file and the linked .blend files will be updated.

Related:

How do I reload a linked blender file?
Video Tutorial on appending and linking
Wiki Linked_Libraries


No Collada (.dae) Import option on Ubuntu 2.76b

Found a fix (by complete coincidence) on this Github page: https://github.com/dnschneid/crouton/wiki/Chromebook-Pixel

sudo apt-get update && sudo apt-get install python-software-properties
sudo apt-get install software-properties-common
sudo add-apt-repository ppa:thomas-schiex/blender
sudo apt update && sudo apt install blender


Why settings for IK-Constraint are different for mirrored bones?

One big influence on this issue is bone roll. You can check the roll of a bone by selecting it in edit mode, pressing "N" to open the shelf and looking under "Transform."

If your pole target bones (knee bones) don't have the same roll as your leg bones, it can get wonky. You can reset the roll of your bones by selecting them and pressing CTRL+N . Recalculating along the global Z axis can work well in this case.


How to set object at a specific depth from the camera, at a certain pixel

I think, next must be works:
Sets empty objects to every corner of image - pinLT, pinRT, pin_BL, pinBR. Then calculate rays from camera base to those pins:
eye = camera.matrix_world @ Vector((0,0,0))
rayLT =  (pinLT.location @ pinLT.matrix_world) - eye
rayRT =  (pinRT.location @ pinRT.matrix_world) - eye
rayLB =  (pinLT.location @ pinLB.matrix_world) - eye
#rayRB =  (pinRT.location @ pinRB.matrix_world) - eye

then make interpolation to find correspond ray to the pixel
h = (rayRT - rayLT) * pixels.x / pixels.wide
v = (rayLB - rayLT) * pixels.y / pixels.height

ray = pinLT + v + h

# calc result in world coorinates
resultOnImage = eye + ray
resultInWorld = resultOnImage + ray.normalized() * desired_distance


How to move a Cut Loop and Slide using a measure

Add the Edge Loop and place it as you did before. Without deselecting it, press N to bring up the sidebar and select the Item tab. Here, you can view and edit the exact location of the selected loop cut. Just click on the X, Y or Z values.

An easy method to get an exact value from the left edge is to snap the loop cut onto the left edge of the plane (before left-clicking to apply the loop cut). Then, apply the loop cut and add 6cm to the Y value in the sidebar.


If you don't want to use BMesh, the following will work:

import bpy

data = bpy.context.scene.objects.active.data
edges = data.edges     # collection of all edges
verts = data.vertices  # collection of all vertices

# must be in object mode of course
bpy.ops.object.mode_set(mode = 'OBJECT')

# the indices given by MeshEdge.vertices correspond to the collection of vertices
verts[edges[0].vertices[0]].select = True

# go back into edit mode to see the new selection
bpy.ops.object.mode_set(mode = 'EDIT')

BMesh can be a bit simpler though...

import bpy
import bmesh

data = bpy.context.scene.objects.active.data

bm = bmesh.from_edit_mesh(data)
bm.edges[0].verts[0].select = True


Can also do this straight from the curves bezier points.

Test script, select the curve in object mode.  Note for cyclic curves cannot create a circular parent structure for bones, eg the first bone can't have the last bone as a parent. AFAIK.

import bpy
context = bpy.context
scene = context.scene
curve_obj = context.object
curve = curve_obj.data

arm = bpy.data.armatures.new("BezArmature")
arm_obj = bpy.data.objects.new("BezArmature", arm)
scene.objects.link(arm_obj)

scene.objects.active = arm_obj
bpy.ops.object.mode_set(mode='EDIT')
mw = curve_obj.matrix_world
arm_obj.matrix_world = mw
for spline in curve.splines:
    points = [bp.co for bp in spline.bezier_points]
    if spline.use_cyclic_u:
        points.append(points[0])
    parent = None
    for i in range(len(points)-1):
        bone = arm.edit_bones.new("Bone")
        bone.head = points[i]
        bone.tail = points[i+1]
        bone.parent = parent
        bone.use_connect = True
        parent = bone
bpy.ops.object.mode_set(mode='OBJECT')


SOLVED: I toggled the viewport shading and it was fixed. Not sure what it was, but that did the trick.


I guess your Mac Viewer shows only faces, oriented to camera, while Blender (by default) shows both sides
For viewing what is the back side and what is front, you should turn face orientation overlay

You can recalculate face orientations using Shift+N, but your object should be manifold.
You can also use Alt+N to flip orientation face by face


It's simply that some of your normals that are wrong...

Select all faces CtrlA, press CtrlN to recalculate the normals (or from the 3d view header use Mesh > Normals > Recalculate Outside).

This can happen when creating faces and selecting vertices in a different order than blender expects.


Is it possible to auto generate and superimpose Frame# over images imported into video edit?

Yes it's possible.

You just have to open the Metadata section in Render Tab of Properties panel, check Stamp output, adjust the size and colors, and check the Seq. strip box (uncheck all other if not needed), and it will print the filename of the current rendered image on the top right corner of the output.


Can I use Blender on Intel HD 530 dedicating an Nvidia GPU to Cycles?

You can definitely do this. My son has an Ubuntu Desktop:
$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=20.04
DISTRIB_CODENAME=focal
DISTRIB_DESCRIPTION="Ubuntu 20.04.2 LTS"

And this graphics card specifically:
$ lshw -c video
  *-display
       description: VGA compatible controller
       product: HD Graphics 530
       vendor: Intel Corporation
       physical id: 2
       bus info: pci@0000:00:02.0
       version: 06
       width: 64 bits
       clock: 33MHz
       capabilities: pciexpress msi pm vga_controller bus_master cap_list rom
       configuration: driver=i915 latency=0
       resources: irq:134 memory:f6000000-f6ffffff memory:e0000000-efffffff ioport:f000(size=64) memory:c0000-dffff

He's able to render cars for NR2003 using this setup.

NOTE: The render times can be long he constantly lets me know that they can take 1-2hrs but it is doable.
CPU Info
Here's his CPU info too just in case.
$ lscpu
Architecture:                    x86_64
CPU op-mode(s):                  32-bit, 64-bit
Byte Order:                      Little Endian
Address sizes:                   39 bits physical, 48 bits virtual
CPU(s):                          4
On-line CPU(s) list:             0-3
Thread(s) per core:              2
Core(s) per socket:              2
Socket(s):                       1
NUMA node(s):                    1
Vendor ID:                       GenuineIntel
CPU family:                      6
Model:                           94
Model name:                      Intel(R) Core(TM) i3-6100 CPU @ 3.70GHz
Stepping:                        3
CPU MHz:                         800.052
CPU max MHz:                     3700.0000
CPU min MHz:                     800.0000
BogoMIPS:                        7399.70
Virtualization:                  VT-x
L1d cache:                       64 KiB
L1i cache:                       64 KiB
L2 cache:                        512 KiB
L3 cache:                        3 MiB
NUMA node0 CPU(s):               0-3


To learn more about importing from subdirs, you should be reading Stackoverflow and googling stuff like 'how to import from sub directories in Python` : python-import-a-file-from-a-subdirectory , this is a general Python question and has many good answers and links.

I'll answer the Blender specifics (reduced version) of this code. no pie, no keymaps. We can test if a class/Operator was correctly imported and registered by using the spacebar menu and search for the operator's bl_label ( here Boolean 2D Union ) , and launch it from there.

That operator has a poll to test if at least two faces are selected before showing up in the menu or spacebar search. Here you can see we successfully imported that class and registered it.

Importing from sub directories

I've prepared a small zip at this repostory : https://github.com/zeffii/some_test_addon , which you can Install from File.

if your add-on's folder structure is like this.

addon_name     <-- avoid spaces in the add-on folder names
|
+ __init__.py
+ included_addons   <-- avoid folders named just 'addons'
  |
  + __init__.py   <---  (often empty) tells Python that this folder is a module.
  + boolean_2d_union.py

it should work this way, from the top level __init__.py

bl_info = {
    "name": "Some Test Addon",
    "author": "----",
    "version": (0, 1),
    "blender": (2, 76, 0),
    "category": "User Interface",
}

import bpy

from .included_addons import boolean_2d_union

def register():
    # this line will throw an exception if you press F8 and don't
    # have any classes defined in this __init__.py file, but usually
    # this file has at least some classes either for a property collection
    # or addon preferences.. or a menu drawing function.
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)

Registration

When boolean_2d_union.py is imported, Boolean2DUnion is registered for you by bpy.utils.register_module(__name__).

There are many subtleties attached to multi-file addons regarding reload code and I think this is outside of the scope of your question, but further reading is suggested.

See more information about the reload event here: Blender ignores changes to python scripts
See the mesh_tinyCAD add-on's structure for a multi-file example with load / reload code that I think you can get your head around.

some insight

Does this work if I hit F8 (accidentally or intentionally). You might temporarily add some print events into __init__.py to get a sense of what's happening during that reload event, and get an idea of what has been loaded when.

bl_info = {
    "name": "Some Test Addon",
    "author": "----",
    "version": (0, 1),
    "blender": (2, 76, 0),
    "category": "User Interface",
}

import bpy

if 'boolean_2d_union' in locals():
    print('1 -- RELOAD EVENT (f8)')
    print("don't need to reload an unchanged file")
else:
    from .included_addons import boolean_2d_union
    print('2')

def register():
    print('3')
    bpy.utils.register_module(__name__)
    if 'bpt' in dir(bpy.ops):
        print(dir(bpy.ops.bpt))  # will show   ['boolean_2d_union']
        print('4')
    print('5')

def unregister():
    print('6')
    bpy.utils.unregister_module(__name__)

Read the source of any of the multifile add-ons to see how they deal (or don't deal) with the F8 reload event. As a developer it's handy to have reload handling code so you don't have to keep closing/reopening Blender. Sometimes it is inevitable to have to close/reload, but get F8 working first and then if the reload didn't pick up your changes

either fix the reload to take new files into account
or restart


Blender's 2.7 Texture View in Blender 2.8 - How do I remove all the shadows?

You can use the Workbench engine for this purpose. In the render tab set lighting to Flat and color to Texture.


Textures changing in render but not in 3D View

The textured view is a shortcut to see the texture mapping of the image in the UV editor window. I suppose your texture is applied to the material of your model: select the model, Tab into edit mode, select all vertices, open an UV editor window, close the image of the window (if present), load your texture.
In this way the texture is "attached" to the actual UV map and will be displayed in the 3D view.


Why doesn't my unwrapped model appear in the UV Editor?

To unwrap UV's, you mark any seams you want, select the faces you want to unwrap, press U and select one of the unwrap options while in edit mode.

Only selected faces (or those surrounded by selected vertices/edges) will be unwrapped. Only selected faces will show up in the UV editor.

Also UV's aren't displayed in the UV/image editor if the Render Result is displayed in the UV/Image Editor. You need to select an image or click the X to close the render result to see UV's.


You can use the "(Object) Keep Transform" variant of parenting when you hit Ctrl+P.  Then just zero the locations/rotations of the child object.


I got the same error today. I traced it down to one image texture. Once, I used a different for testing. The problem didnt occur again


This behaviour is absolutely fine: the bones move vertices only, which have some weight related to their respective vertex group (with the same name). The object (its origin) stays still. If you move the object in object mode you will have weird issues unless you move the rig accordingly.

The usual way to animate is setting both object and rig at the center of the world in object mode, then in pose mode use the root bone to grab your character where he needs to be, and start the animation from there. The root bone can stay still while the rest of the bones are animating the mesh, or can be moved along a path in case of walk cycles or similar.


How do I display the Stereo Interlace effect in the viewport

I figured it out，I need to click the top left "window" menu "set stereo system 3D" instead of the stereoscopy in the "output", it's working now


Well i dont think i'll get an answer what i did wrong but maybe this will help someone else in future....
I still havent found the reason for this behavior but I think I finally found a workaround that works and you dont have to do much for it.
while the first workaround was using the origional bones as deform bones and renaming the vertex groups whick caused trouble with some weights and the tail looked messed up, because the origional bones move differently than the deform bones I noticed that i could exchange some Origional bones within the spine with their deform bones without getting the twitching again.
so i tried to exchange only the parent of all spinebones (the bone at the end of the tail) and it worked for me. no more twitching in unity.

so the detailed steps where (my way):

find the rootbone of the evil twitching (first spine bone in my case)
rename the prefix of the deformbone (i used fill-spine..),clear the deform checkbox and move it to another layer (not neccessary)
take the Origional- bone (ORG-...) counterpart of that bone, move it to the deform layer, tick the Deform checkbox and rename its prefix to DEF-...
Parent the rest of your def rig to your new bone.
maybe you need to rename the vertexgroup for that bone, because it automatically changes in step 2. (in my case change Fill-... back to DEF)

Let me know if there is a better way :)


In the screenshot it looks to me that you have to scroll up in the material window to view the contents, which for some reason is a bit higher up than what is currently shown.


How do I change the interpolation of multiple keyframes in the graph editor (f-curve)?

While can't see how you do it, here is how i do it:

You frame all the wanted keyframes including their handles
Either go in the menu on top or use the context menu with RMB to change the
interpolation.

Here also a visual step by step:

Should this not work with your version, please explain where it differs from this.


Directional Offset of an noise wave texture

I found a way to wrap a noise texture using a brick texture. Actually, with at least three:

To create diferent brick textures I use very different location value on each node.

[Edit: you can use only one brick texture with black and white values, the 'difference' blend mode works well with the texture coordinate for example]

Next step is mix the texture coordinate with the result, you can play with the blend mode and the factor to get the result you want. then use this as normal input for the noise texture:

Then play around to get the desire result:


You have to use a higher resolution texture (256X256 is really small) and hide the seams using texture paint brushes. Here's the result which uses the higher resolution texture and corrective brushes.

To get rid of the seam use a Clone brush in a Texture Paint mode. Press Ctrl+LMB to place the cursor in the area you want to clone and then LMB to paint.

Use a Smear brush to blur the texture and hide the seams/imperfections.

NOTE: Don't forget to save your painted texture in the UV Editor!

Here's the corrected .blend:


How do I get particles to change color over time?

Two Techniques to Have Particles Change Color Over Time

I discovered two ways to have particles change color over time, but they both start the same way:

First, create an object to be the particles for the particle system. I used a sphere in the videos below.
Create an object (I used a plane) and add a particle system to it with these settings:

In the Emission section for the videos below, I have:
Number = 1000
Start = 1
End = 200
Lifetime = 200
In the Velocity section, set Normal to a desired value. I used 7.0 in the videos below.
In the Render section, select Object and then for Dupli Object select the object you made for the particles in step 1.

Now add a material to the particle object. Here is where I discovered two different node tree configurations to create two different effects:

Effect #1: Each particle is a different color & stays that color over it's entire lifetime

For this technique the node tree for the particle object's material is made like this:

NOTE: For this effects, the Divide node's Value must be set to the number of particles in the particle system (here, it's 1000)

This technique was developed by kubo on BlenderArtists.org.

Effect #2: All particles change color over the course of their lifetime

This is the node tree for this technique:

NOTE: For this effects, the Divide node's Value is set to a low number (here, it's 50), not to the number of particles

This technique was developed by Vader and Greg Zaal here on StackExchange.

Previewing the Effect

If you want to see the colors changing in the 3D Viewport, the display mode must be set to Rendered


You have the wrong shortcut, it just Alt+Left click. It will select all the vertice lying along its path.

All the best!


How to overdrop a video with black backgroud in the video editor?

To perform a Luma key in the VSE you need to use the Strip modifiers.

However you want to use the source or foreground strip as a key or Mask, and Blender doesn't like making loops (as you are modifying the source with the source which becomes modified etc.).

So you need to duplicate the strip then turn it of with the H key (hide strip). This becomes the Key source strip. You could then Group this pair so that they stay in sync if you move them or trim them on the timeline. In my example I have not done that just so you can see the steps required.

You can better define the value to key by adding a curve modifier to the Key source strip, and make it more contrasty (steeper curve).

For best results you will have to reduce the color of the original strip to make an accurate key. Use the Key source's Saturation slider, reduced to 0.0

For more control you could add a blur effect to the Key source strip then Hide it Alt-H and define the Blur strip as the mask on the foreground strip modifier.

You can also use a curve modifier on the Key source strip to invert the key.

Again I strongly recommend grouping all of these strips together and muting the ones that are used as keys, this saves them accidentally appearing in the composite.


Does your sphere/disk have UVs?

Also, if you have UVs and move them by x-0.5, y-0.5, the gradient gets pushed outside of the UV space. If it's there it might be very faint.

An easy setup to control this can be the following:

Note the Empty in the Texture Coordinate Node! - You can move, rotate and scale it to position the gradient. Keep it in the center of your object as a starting point. (My mapping node looks different because I'm using a build of 2.81 at the moment. But it works the same way.)

Another tip: Use the NodeWrangler Addon that comes bundled with Blender to look at the Outputs of the Texture Coordinates or the Mapping Node while you make changes. (Just Ctrl + Click the Node a few times) That way you can see what you're affecting.


Displace modifier - undesired artifacts in texture

For displacement to work well all the faces should be equal size squares.


nla editor - meta strips on multiple object base?

I think this add-on may help you to achieve what your are trying to do. Please see the link for a video download and an explanation by "coyhot" the author.

Animation Joiner

Description of the content (from the link above):

  Join them all !

  So, I'm proud to present my Animation Joiner. I designed it with
  dynamic simulation in mind, but I found it could be usefull for
  character animation, too. My goal was to merge animated objects into
  only one mesh, animated by a MeshCache modifier and a PC2 file.

  Why a PC2 file ?

  PC2 is a binary cache file format, wildly use in production. It can be
  nativaly streamed in 3DS Max and Blender, but can also be used in
  Maya, Lightwave, Houdini, and many others. Because Blender doesn't
  have Alembic support yet, PC2 is for me the best to way to interchange
  animated object between 3D packages.

  But when I wrote this addon, I wasn't thinking of interchange format.
  I was thinking of dynamic simulation, and more precisly Rigid Bodies.
  I work a lot with rigid bodies in Blender. And the most difficult part
  of the job is to manage cache files, specialy when you have thousands
  of debris. I dreamed about a technic where you can manage multiple
  debris as easy as only one mesh. And that's the goal of my addon.

  Reducing the complexity of the scene

  Select your debris, set the path to the PC2 file and click on Join
  Animated Objects. After few seconds, on the next layer, you will find
  only one animated mesh using a MeshCache modifier, streaming a PC2
  file. Now, you can duplicate (linked) the mesh and multiply the number
  of debris without rising the usage of the memory. And you can even
  offset the animation ! If you generate two PC2 files for the same
  debris, you can also crossfade from one Meshcache to another by using
  the Influence parameter.

  Because you now have only one object, you can add any modifier on it,
  like a Bevel for instance. But you can also emit particles from all
  the debris really easily. You can even duplicate (linked) this object
  and add a Collision modifier on it. By this way, particles will be
  emitted by the debris, but they also bounce on them ! Try to do that
  when you have hundred of debris ... not so easy.

  Same thing for the smoke : you can try to emit smoke from the debris,
  with a duplicated object set as a collider. With only two objects, you
  can see the smoke flowing through every holes in a falling wall !

  Reshaping and retiming dynamic simulation

  Because you have only one object, you can deform it during the
  animation by using a lattice of even shape keys. In the demonstration
  video bellow, you can see that I tweak the position of only one debris
  because it intersect with another one. You can also emit particles and
  use an Explode modifier, followed by a Solidify to generate more
  smaller debris.

  MeshCache can be animated using different options. One of my favorite
  is the one named "Custom". Because, you can timeremap you simulation
  by only creating keyframes, slow it down (the position of each point
  will be interpolated !) if you want to create a slowmotion shot of a
  falling building, without the need to simulate it at an higher
  framerate !

  Maybe I'm wrong, but I think it's easier for Blender to manage fewer
  objects with an high polygons number than a lot of objects with fewer
  polygons. I think it's because of the dependancy graph. So, if you
  take a look at the first image of this post, 4 millions polygons are
  used to generate debris of all the buildings. But I can run the
  animation at 3 FPS and it only take 500 Mb in RAM, because of the
  instances used in the scene. And last but not the least, Cycles start
  almost immediatly when I launch an interactive rendering !


How can I make a specific color on my model emit?

The weight factor of the red component is used for mix shader. The weight of the red component my be unsuitable. It may be too  small. If the red image has only red components keep this in mind for the math.  If red highlight image were actually bright white and black with maximum white values in some areas that would be desirable.  Multiply the weight of the red by 3 with a math node.  When red is normalized RGB->BW it may have been divided by three.  What you may have intended was ... to use the red color only as a basis for brightness and do not consider green and blue.  A single red color can only have 1/3 the brightness of bright white. Some mathematical liberties taken. It would be best if your red highlight image has very bright red areas.  Scaling by a value greater than 1, ... 3 or 4 for example,  will help to bring the brightness in the range you desire.  The highlight image may exist as black and white, rather than red, and be recolored to any other color in the Compositor.
Assuming you are using materials with emission shader. Increase the strength of emission for blinding brightness.
Your color curve may be unsuitable. All brightness may have been wiped out. Remedy. Make everything too bright.  Bring bright side to the middle.  Then reduce artistically.  My compositor color ramp may serve as an example.  Notice how the white color dominates most of the color ramp.
Know that the compositor can user Alpha Over node to lay images with transparency on top of one another.
Use an EMISSION shader and diffuse shader to the mix shader, if you continue to use the materials approach.  You clearly have a better chance of getting a bright color with the emission shader.
Compositor, compositing pixels, compositing nodes, with a color ramp can threshold colors and produce bright colors.  Next blur the edges.  Materials are a different approach.
Below is a compositor image of your original images.  I have used a color ramp to threshold the brightest color and dilated them to white.  White is easier to see then red. The border has not been removed.  This is an illustrative technique example not artistic for a single picture.

Make sure you texture coordinates are correct for UV


How to make interface for add-on with mutipule colorpickers

import bpy

class ColorItem(bpy.types.PropertyGroup):
    color = bpy.props.FloatVectorProperty(
                 name = "Color Picker",
                 subtype = "COLOR",
                 size = 4,
                 min = 0.0,
                 max = 1.0,
                 default = (0.75,0.0,0.8,1.0)
                 )

class ColorPanel(bpy.types.Panel):
    """Creates a Panel in the Scene properties window"""
    bl_label = "Colors"
    bl_idname = "SCENE_PT_colors"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

    def draw(self, context):
        for i in range(5):
            row = self.layout.row()
            row.prop(context.scene.colors[i], "color", text=str(i))

def register():
    bpy.utils.register_class(ColorPanel)
    bpy.utils.register_class(ColorItem)
    bpy.types.Scene.colors = \
        bpy.props.CollectionProperty(type=ColorItem)

    for i in range(5):
        bpy.context.scene.colors.add()

def unregister():
    bpy.utils.unregister_class(ColorPanel)
    bpy.utils.unregister_class(ColorItem)
    del bpy.types.Scene.colors

if __name__ == "__main__":
    register()

Adapted the SimplePanel Template to show 5 color pickers. Access and set their values via

bpy.context.scene.colors[index].color = (0.0, 0.0, 0.0, 1.0)

Additional infos:

Here is the link to the official  api documentation. In the section quickstart introduction you will find an example of an operator.

You can find a template in the text editor -> Templates -> Python -> SimpleOperator.

In your case you simply wrap your code in a function which will be called from the operators execute method:

def main(context):
    context.scene.color_prop.h += 0.125
    context.scene.color_prop.h %= 1.0
    #...

Define an operator (see the SimpleOperator template), and extend the panel's draw method:

def draw(self, context):
    #...
    row = self.layout.row()
    row.operator("object.simple_operator")

Here is a full listing copy & pasted together.

These sections #1, #2 from the docs might be helpful.