You want to keep the Info Editor at the top of your window.

You can resize it so that only the header is visible as most times that is all you will use.

Start by opening a new file.
move the cursor to the bottom of the info header until you get a double arrowed cursor, then drag up until only the header is visible.

Select File->Save Startup File. This is why you want to start with a new file, saving the startup file will keep this screen layout every time you start blender.

Note that any files you saved with the altered screen layout can be opened with that layout, disable the Load UI option to use your saved default layout. you can change the default Load UI option in your preferences.


Want to undo a step but it is not in undo history

There are several options.

Check in the folder where you have your .blend if there are several files with the same name, but with the extensions .blend1, .blend2 and so on. When you save a .blend, the previous version of the file gets renamed to .blend1, and if there already exists a .blend1, it gets renamed to .blend2. This is a setting in Blender, but if I remember correctly, it's enabled by default. CtrlAltU to open up user preferences, then click File and check the rightmost column to find out whether you have it enabled.

There may also be previous versions of the file lingering in your temporary folder. These could have either the same name as your original file, or they could be named by the process ID of the Blender instance that last had it opened. The temporary folder is usually /tmp on Linux and other Unix like systems. On Windows I'm not 100% certain, but C:\Temp or C:\Windows\Temp may be good places to start searching. On MacOS I have no idea.

You may also try the Decimate modifier, set to Un-Subdivide. On a complex mesh, it probably will not exactly reverse the subsurf, but it might be worth a try.


How I can find the the 3D location of the vertex Groups in Mixamo character?

Considering you want the coordinates for a animated character, you can use the bmesh module and the dependency graph to do that.
bmesh will provide mesh information and the dependency graph is used to retreive this information considering the mesh transformations.
From that, we can get access to vertices that correspond to the vertex group you want.
The principle is to use the active deform layer (vertex groups) of the bmesh and use it over the vertices to have vertex information about this layer.
This access provides a map containing the weights per group index. Here we just need to keep vertices that have the information for the group index we want.
Here is a full commented code (but feel free to ask if anything is not clear enough):
import bpy
import bmesh

# Get the object
obj = bpy.context.collection.all_objects["Beta_Surface"] #Your object name here

# Get the vertex group
vertex_group = obj.vertex_groups["mixamorig:LeftHand"] #Your vertex group name here

# And its index
vg_index = vertex_group.index

# Get the dependency graph (used to have mesh information with animation applied)
depsgraph = bpy.context.evaluated_depsgraph_get()

# Create a bmesh object
bm = bmesh.new()
# Get the information considering the dependency graph
bm.from_object( obj, depsgraph )

# Get the deform (vertex groups) active layer (assuming there is one here)
deform = bm.verts.layers.deform.active

# The object world matrix
world_matrix = obj.matrix_world

# Loop over the vertices keeping only the one attached to the group
# v[deform] gets vertex group information as (group index, vertex weight) map
for vert in [v for v in bm.verts if vg_index in v[deform]]:
    # vertex coordinate in object space
    co = vert.co
    # vertex coordinate in world space
    world_co = world_matrix @ co
    print(co, world_co)


Array modifier makes wrong offset - rotation (it has parent)

Reposition the 3d cursor (center) using the 3d cursor tool. Also press SHIFT+S, and select "Cursor to world origin".


To make the roof transparent (or semi-transparent as you have it) but opaque in the shadows you can use the Ray Depth output of the Light Path node.
But, this gives you a value of 0 or 1 which in your case means your roof will be completely invisible but have a shadow, because for the camera the Mix Shader is using a factor of 0 (fully transparent) and for the shadow 1, so the Toon BSDF is only used to create the shadow.
So in order to keep it semi-transparent when the Ray Depth is 0, you can take a Math node to add the desired mix factor to this result, for example 0.6 as you are using here. Then to the camera the Mix Shader is set to 0.6 (semi-transparent) and 1.6 for the shadow (a value larger 1 is fully opaque). To avoid out-of-range values you could enable Clamp in the Math node but it's not necessary in this case.
My example (I just used a simple Diffuse instead of Toon):


Texturing an object with array and curve modifiers

One of the most common problems with tileable textures is that it's not only the color variations but also the patterns that create the repetitive look.

While your idea to change the hue and saturation values might work on a model that uses real bricks instead of textures, it would probably disturb the seamless look of your model. You would change the values for the whole segment which (depending on your model's mesh) would most likely produce vertical lines between them.

Depending on how much effort you like to invest in that particular task there are two approaches.

The first one is obviously to choose a different texture that is still tileable but hasn't the distinct features that make the repetition so obvious.

The second one needs a significant amount of work but then you might re-use the resulting textures for a different project. You would have to create three or four tileable textures yourself and they should be each tileable to all the others.

There are some tutorials about creating tileable textures in Blender, some really good ones can be found on stym's youtube channel.

The trick would then involve changing only the inner area of the texture while the outer area stays the same. You should also avoid putting too prominent features over the edges, since they would ruin the randomness again.

The next step would be creating several materials for your model, then  apply the modifiers, then select random segments and change the material to a different one.


Putting the texture on the object / Displace Modifier

On top view UV select all of the faces  of your road object and do unwrap form view, so that the mapping is even and has the same scale.

Another thing worth trying is not using UVs for mapping on the modifier but an Empty.

Re-sizing and moving the empty might give you more control on the placement of the texture.

To make the displace modifier work smoother you might need to add a subsurf modifier before the displace modifier.

If you are not going to see the pavement texture very close on your image, you might want to consider using it as a bump map, instead of a real 3D displacement, that would require much denser geometry.


How to apply UV map texture while keeping node shaders?

You would add a texture (image texture) node, and wire the color output of the image texture node into the color input on the diffuse node only. And leave the glossy color white.


Maybe you've chosen the wrong option from the Merge menu?
Make sure, of the selected vertices, the ones you want to be merged are closer to one another than to any others, and Merge > By Distance

Or, if that's too fiddly, (and you want the merged loop to be centered to the ones above and below) select the edge-loops you want to be merged, and Ctrl E Edge Menu > Bridge Edge Loops, with 'Merge' checked in its options.


check the bottom of the frame you captured, he is not editing the Composition nodes, he is just adding the noise texture to the material so the strands would have color variation.


How to eliminate black stripe on the horizon from HDRI textures?

If you are learning to use HDR, use a proper HDR image that is meant to be used for a 3D rendering.

You need an image that covers a range of 360 degrees preferably in equirectangular projection or Quadrilateralized spherical cube

In other words: a panoramic image that you can use as the world. Think of it as a large sphere that surrounds and lights your scene. It has to contain the information of the ground and the sky all around.

See: http://blog.gregzaal.com/tag/equirectangular/


the one that you posted shows that you created a vertex group, the next step is to assign the hair particles in that vertex group.

particles -> vertex groups -> density -> and then scroll down to select the vertex group that you created


How can I select only external edges in this mesh?

Select one of the candidate edges in edge select mode. Then Select similar -> Amount of Faces Around en edge.


How to load a big number of maps and assign them to variations of a material?

Working with you having some structure setup with your naming, let's say you have an object called "book1" and you have images "book1_diffuse.png" and "book1_roughness.png" you can create a material called "book1" that uses both images and then assign the material to the object.

import bpy
from glob import glob
import os

# adjust this to point to your texture directory
# can start with // to refer to the current blend file dir
texture_dir = '//textures'

os.chdir(bpy.path.abspath(texture_dir))
diffuse_imgs = glob('*_diffuse.png')
for img in diffuse_imgs:
    mat_name = img.split('_')[0]
    mat = bpy.data.materials.new(mat_name)
    mat.use_nodes = True
    m_nodes = mat.node_tree.nodes
    m_links = mat.node_tree.links
    diff_node = m_nodes['Diffuse BSDF']

    imgnode = m_nodes.new('ShaderNodeTexImage')
    imgnode.location.x = diff_node.location.x - 200
    imgnode.location.y = diff_node.location.y
    bpy.ops.image.open(filepath=img)
    imgnode.image = bpy.data.images[img]
    m_links.new( diff_node.inputs['Color'], imgnode.outputs['Color'] )

    roughnode = m_nodes.new('ShaderNodeTexImage')
    roughnode.location.x = imgnode.location.x - 200
    roughnode.location.y = imgnode.location.y - 50
    roughimg = mat_name+'_roughness.png'
    bpy.ops.image.open(filepath=roughimg)
    roughnode.image = bpy.data.images[roughimg]
    m_links.new( diff_node.inputs['Roughness'], roughnode.outputs['Color'] )

    uvnode = m_nodes.new('ShaderNodeUVMap')
    uvnode.location.x = roughnode.location.x - 200
    uvnode.location.y = roughnode.location.y - 100
    uvnode.uv_map = 'UVMap'
    m_links.new(imgnode.inputs['Vector'], uvnode.outputs['UV'])
    m_links.new(roughnode.inputs['Vector'], uvnode.outputs['UV'])

    bpy.data.objects[mat_name].active_material = mat

You can easily expand that to include any number of image textures for each material and add in a mix and glossy node if you wanted. You can find the node types you can use listed here.

If you have a random number of book objects, you could create the materials and add them to a list as you go, then go through the list of objects and pick a random material to assign to each.


When choosing rig as target object, typically you can select desired bone.

Be sure your 'rig' object is of 'ARMATURE' type.


Blender comes bundled with numpy. Image references have a property called .pixels which you can turn into a numpy array of the same dimensions. Numpy does use overloaded operators for array math. The initial setup aside, you'll see it is quite close to what you were trying.

import math
import numpy as np

import bpy

def np_array_from_image(img_name):
    img = bpy.data.images[img_name]
    return np.array(img.pixels[:])

pixelsA = np_array_from_image('A')
pixelsB = np_array_from_image('B')
pixelsC = np_array_from_image('C')
pixelsD = (pixelsA + pixelsB + pixelsC) / 3

image_D = bpy.data.images['D']
image_D.pixels = pixelsD.tolist()

# then click in the UV editor / to update the view..to see the pixels of `D` updated

Maybe this will give enough insight, and push towards learning some numpy.

This does 'mix' btw..

I'm not sure about the algorithm for add.. (below shown using material rgb mix nodes)

it's not as simple as a+b+c.  maybe something like adding the smallest value of each array:

# add smallest element values
interim_1 = np.minimum(pixelsA, pixelsB)
pixelsD = np.minimum(interim_1, pixelsC)

producing this:


Why don't my tracking markers stay in position?

I found the solution myself.
For some reason, the frame numbers of my video file didn't stay in synch with the frame numbers of the track markers: when I would scroll to frame n in the timeline, it would sometimes show frame n+1 of the video, making it look like the marker had shifted.
I solved the issue by converting the video to separate image files before importing it in Blender.


Imported FBX animation looks strange on action editor

The "keyframe for every single frame in the animation" part of your question "is a feature, not a bug": That is how Blender outputs an FBX.

In object mode, select your armature. I imagine you may not be able to see it unless you turn on Xray.

Now go into pose mode and Blender's Animation screen set up.... or, I find this easier, anyway:

Your dope sheet will show you which bones in the armature have actions keyframed to them. Although Blender creates a keyframe for each frame, it does not create one for each bone -- only those bones that have actions associated with them.

In the NLA editor, you can turn this set of keyframes into an action strip, and you can B box select and simplify.... but it is still less elegant than what you undoubtedly had in your original Blender file.

Regarding names and axis... does your file look like this?

If that's what you are seeing, you can turn them off under the Armature panel.... but I have seen weird issues with some FBXes (more often scaling and orientation than naming)... and frankly I typically just hack at them until I get what I want... That is not really an answer... just what I do.

best
rg


Blender 2.8 Texture Painting weird brush behaivior

I found a workaround for this issue. While playing around with some settings i figured out that this is only when i activate symmetrie. However if i turn of the symmetrie, the lines are solid again.

Now the workaround is to draw like that with symmetrie on, so you have your drawing applied and its mirrored even with the weird brush and then you turn off symmetrie, increase the radius of the brush a little bit and draw on top of the weird lines. Its a bit extra work, but the best solution i found so far.


Inherit color on hair particles emitted from vertices (Cycles)

I found a pretty stable/flexible solution to this and made a tutorial about it.
Try it and give your feedback on it !


How do I make only a portion of my shader to be bumpy?

You should be able to invert the output of your Color Ramp and plug it into the Strength input of your Bump node.


texturing 2.8 cant see proportions and profile

As Jackdaw has already suggested in the Overlays menu lower the Texture paint Opacity value.

Note: In the image below the viewport shading is in Solid mode.


How do I access the glTF Metallic roughness shader node with Python?

Find your node group:

group = bpy.data.node_groups.get('glTF Metallic Roughness')

Assign it to the node:

GLTF = matnodes.new("ShaderNodeGroup")
GLTF.node_tree = group


Snap to face problem: object is flipped 180 degrees and snapped to inside faces

Snapping works with Z+ orientation, so just flip the origin point upside down.
To keep the parented objects in place, you can choose to only affect the parent.

Select your object
Go View > Affect Only > Origins and Parents
Rotate the Origin by 180°


How do you grab the cylinder's mesh data using python?

Here is the code that made everything work

Getting the mesh data from the model:

ob = bpy.data.objects['Cylinder']
verts = [verts.co for vert in ob.data.vertices]

Getting the location and rotation data from camera:

camera_location = np.round( list( bpy.data.objects['Camera'].location ), 3)
camera_rotation = np.round( list( bpy.data.objects['Camera'].rotation_euler ), 3)

I had to use numpy "np" to round down the outputs, I did the same thing for verts.


I finally found a solution in the documentation:

scn = bpy.context.scene

with bpy.data.libraries.load(blendfile) as (data_from, data_to):
    for attr in dir(data_to):
        setattr(data_to, attr, getattr(data_from, attr))

for obj in data_to.objects:
    if obj is not None:
        scn.objects.link(obj)

EDIT.

I edit my post to add a complement to my answer:

To import only chosen object and group, i finally write this code:

with bpy.data.libraries.load(blendfile) as (data_from, data_to):
    data_to.objects = [obj for obj in data_from.objects if obj in list_obj]
    data_to.groups = [gp for gp in data_from.groups if gp in list_gp]

    for obj in data_to.objects:
        if obj is not None:
            scn.objects.link(obj)


Exporting multiple meshes individually at once

Save your blend file in the directory you want the objects to be in.
Head over to the Scripting workspace
In the editor window: Templates -> Python -> Batch Export
Select all objects that you want to export
Run the script with the Play button


Enable experimental features Blender 2.72

The reason it's not appearing is because this option is only available in the Cycles render engine.

To switch to Cycles, go to the Info header (in the default layout, it's at the top) and change the engine to Cycles.


You can use curve bevel it is not an automatic one-click-solve-all solution, it will lead to artifacts in narrower zones and cause artifacts in pointy tips.

In fonts or curves with width variations it will never yield a perfectly triangular bevel like the Gibson logo.

You can tweak it locally, but that will always require manual adjustment and modeling.

For these types of complex shapes you best bet is really converting to mesh with a proper topology and manually modeling it. Triangulated mesh from raw curve to mesh conversion will not do.


How to use AN struct from a script node? (Animation Nodes)

Looks like you can use ANStruct() in place of a normal dictionary and add to it with the usual commands. So instead of dict = {}, do dict = ANStruct().

But there is a big caveat that doesn't seem to be documented anywhere. When working with a regular dict, you'd add to it with: dict['key'] = value. But ANStruct actually has a 2 part key, with the first part of the key being the Animation Nodes Type (ie, Text, Integer, Text List, etc). So you actually need dict[('Type', 'key')] = value

If you don't have the two part key, you'll get errors when trying to use the outputted Struct with the various Struct nodes, or when trying to Print it.


How to make edges of adjacent objects be visible?

Your question is very imprecise, but if you want to see the grooves on the hull you could do it this way:

Join all your objects into one, merge the vertices by distance.
Select the edges that are supposed to become grooves.
Bevel them.
Give some correction in order to have nice grooves (my version needs to be re-worked in order to have a proper topology because it will mess up once you'll give it a Subdivision Surface modifier.
Extrude.


Do you usually work on Two screens? (Two monitors or a monitor and a laptop).
I have found that if i use blender on the second monitor and then unplug it blender will not automatically come over onto the primary screen.

you might need to plug in your second monitor,(if you have one) and see if it is there.

Hope this works for you!


automate keyframes group to non-linear position

Here I've added a dummy action to give me 10 equally spaced keyframes, frames 1 to 10.

import bpy

obj = bpy.context.object
for x in range(10):
    obj.keyframe_insert('location', frame=x+1)

Now running this script gives me the result you are after

import bpy
obj = bpy.context.object
action = obj.animation_data.action

x, y = action.frame_range
for fcurve in action.fcurves:
    i = 1
    L = (y - x)
    # preserve the first and last kfps
    print(fcurve.data_path, fcurve.array_index)
    while i < len(fcurve.keyframe_points) - 1:
        p = fcurve.keyframe_points[i-1].co.x
        fcurve.keyframe_points[i].co.x = p + L / 2
        print(i, p + L / 2)
        L /= 2
        i += 1


Faces are generally shaded better if the quads are less distorted. They are also better for subsurf and animation. Best practise would be avoiding distortion (parallelogram shape) but not rotation.

Take a look at "face topology". I find it very helpful to get an idea how to approximate a surface with quads best as possible.


For what it looks like you're trying to do, it would probably be best to use Freestyle, which detects edges in your scene and outlines them. That way you can forget about the wireframe and let Freestyle handle that.

You turn on Freestyle from the Render settings, the leftmost tab of the Properties panel.

It has one option in the Render tab, whether line thickness is absolute (pixels) or relative to image size, and all the  rest  are in the  Render Layers tab, one to the right. Here you can tweak everything about Freestyle—the color and thickness of the lines, which edges are drawn over, and a whole lot more.


Depending on the complexity of the scene the animation won't necessarily run at full frame rate when viewed in the viewport even with EEVEE but will be the correct frame rate when rendered to a movie file and played back.


Draw text with Python in 3d coordinate system

Thx, I found an example in the MeasureIt addon and here is some code from my Fast Carve addon to draw 2d text:

rv3d = self._view_context.region_3d
region = self._view_context.region
pos_text = location_3d_to_region_2d(region, rv3d, self._center)

blf.position(2, pos_text[0], pos_text[1], 0)
blf.draw(2, "r: {0:.3f}".format(self._radius))


Coordinates of non-animated object in frames with python [v.2.77]

Replace

bpy.context.scene.frame_current = i
bpy.context.scene.update()

with

bpy.context.scene.frame_set(i)

scene.frame_current = x might appear to work as expected in the python console, but in scripts like in you q, which demonstrates why not to use it, as its value not used in the scripts execution.


background clip not rendered in cycles anymore

I suggest going over the tutorial again in very precise detail. I did the tutorial a few months back (i think still november) and it worked fine. You have probably caused the problem to occur somehow.


My imported STL file has WAY too many tri's in it to edit effectively. How can I reduce it and keep the detail?

As Sazerac suggests (not sure why it's not an answer instead of a comment) the Decimate modifier is what you should be investigating first.

I'd start with the Planar setting, because that typically removes the least amount of detail, and you can tweak the angle limit down to keep quite a lot.  That said, it works best with inorganic forms or meshes with inconsistent levels of detail as it looks for places it can make the mesh simpler and planar.

If the form is more organic and smooth with sculpted detail, but overall has the same sort of density all over, then the Collapse setting is probably going to be more useful.  It just collapses a percentage of faces, biased towards ones that make the smallest possible change to the mesh.   If you need extra control over this, you can use a vertex group and weight painting to suggest where it should remove this detail from, and that's probably going to be the best option on any complex sculpted form - you'll need to tell it areas it can simplify heavily and areas you care about using weight painting and vertex groups.

Here's some rubbish I sculpted out of a cylinder to show the sort of difference in faces generated.  I've left flat shading on so you can see the faces better.

16k faces base object:

~3k faces using Decimate set to Collapse:

~3k faces using Decimate set to Planar (angle limit was 5 degrees)

You may wish to Apply the modifier, which will destructively edit the geometry and thus make it much easier to edit.  Once you do that you can't get back to the original mesh, so save a copy elsewhere if it seems likely you'll want it.


Merging is the way to go, although differently.
First you want to select two vertices you want to merge to a single vertex of the final model.

After that hit ALT + M to merge and select At center.

Repeat this process for each vertex. Done.


The glare node works based on a threshold value. Meaning only the pixels that have values larger than the set value will be affected by glare/bloom/glow.
Use a lower value until you get what you need.
Also, keep the mix at $0$. If you set it to $-1$ you are actually cancelling the effect completely.

Mix
Value to control how much of the effect is added on to the image. A value of -1 would give just the original image, $0$ gives a $50/50$ mix, and $1$ gives just the effect.
Threshold
Pixels brighter than this value will be affected by the glare filter.

(Form the blender manual)
Read Control light halos in the compositor based on emission level


How do I texture paint into a UV-unwrapped model?

It was just silly of me to not think of this earlier. I just created a new material and assigned the un-textured area into it and then used the same texture map.


Cycles weird baking behavior: changes to another image texture mid-bake

Alright, after some hours of needless research I figured it out on my own.

My model was using 3 separate materials: one for main mesh, one for camera details (painted and baked textures) and one for cable ribbon details (also painted and baked textures). I had placed two image nodes - one for final diffuse texture and one for final normal map - only in the main material. I had to copy the two nodes also to the remaining two materials I used for detailing. Now baking worked as it should.

I imagine previously when I hadn't specified the bake targets for the remaining two materials Cycles was just picking a random texture node already present in the node tree and baking on top of that - and in this case it was my ambient occlusion map which was shared among all the three materials.

Hope this helps others struggling with trying to bake multiple materials into one final texture.


It looks to me like you’ve got the glare affect set to low. Turn it up. If that doesn’t work, separate the glare effect from the main image, brighten the glare, and then mix them back together, instead of using the glare effect’s automatic mixing.


You have a blur node in your compositing view. Removing this removes the blur.


Is there a way to analyze what's using frametime or view all simulated meshes at once?

Alright, turns out using simplify solved the issue. I didn't know that the subD modifieres are such a frame eater for nonanimated objects.


How to Link or Append objects from another file?

Found the issue.  I was selecting the item to link/append from the list of Meshes, but needed to select the item from the list of Objects.


How to render ultra-realistic looking models and textures in Blender?

If you want to create realistic humans you should first study anatomy. Really study it, learn the bones, the muscles, etc. Learn to draw the human figure.
Then learn the sculpting tools in Blender (or another sculpting software like Zbrush, obviously, but this is a Blender forum so I'll stick to blender).
If you want to work in real productions, also learn retopology. Learn modeling fundamentals. Learning hard surface modeling would be good too.
Learn how to open UVs in an efficient way. Learn how to texture the models. Study how real light behaves and how it bounces off different materials. Understand subsurface scattering (really important for humans).
Learn to create and groom realistic hair and fur.
Learn how to create good lighting, like a photographer or cinematographer would. You also need to learn the render settings and what each setting does.
So basically:

Anatomy and figure drawing
Sculpting in 3D software
3D Modeling fundamentals (organic and hard surface)
Retopology
Opening UVs
Optics (how light behaves and interacts with different materials)
Editing physically based shaders
Hair and fur
Lighting and Render

I think that's about it.
I recommend this series of videos to start studying anatomy: https://youtu.be/pDgyQjNFVQk


Issue with exporting .STL after shade smoothing

Shade smooth is only shading done in software and doesn't change the geometry of your model.  If you want it smoother you need to add a subdivision surface modifier which will add the "smoothness" to your geometry.
As you have imported this as an STL, the topology will be pretty bad and the subdivision surface modifier may not work well (which may be why meshmixer is giving you trouble too). Ideally, you want to remesh it first.  Decimate might work depending on the model and then add subdivision surface modifier afterwards to smooth it.
Remember when modelling for 3d printing, model with shade flat, not shade smooth.


Chroma Key Render isn't the same as viewer

You'll have to re-think your keying process.
Focus first on producing a proper matte from the greenscreen. In that stage, leave the RGB pixels alone and focus on the "matte" output of the keying node.

When you're done with that, connect another instance of the unmatted plate to a spill supressor and do all the colour correction and adjustments you need.
Avoid doing a massive colour grading at this stage, the only color correction needed is to fix background spill and take the foreground color closer to the background, adjusting levels and neutralizing undesired casts. The creative part of colour correction doesn't have to be performed at this point, but after it's composited over the background.

Once you have a proper alpha channel and a corrected image, next step is setting the alpha channel to the corrected RGB. That's done with the "Set Alpha" node.

The result will be an "unassociated" (usually called "straight") alpha image.

In Blender's compositor you need it to be associated (often called "premultiplied), so you'll have to add an "Alpha Convert" node after the Set Alpha, from Key to Premultiplied.

The result will be an RGBA image ready to be composited over a background with a simple "alpha over" node (without marking the "Convert Premul" checkbox as it's already associated).

If you intend to composite it over the background using a different software and not Blender's compositor, then you just have to save the result to a format that supports alpha transparency (EXR would be ideal, but there are other formats).

There's an important thing to keep in mind: Blender's viewer is broken for associated alpha images, so don't trust how the viewer renders images with transparent background. Place a temporary solid background with an alpha over node and inspect the edges instead.


How to delete a mask in the movie clip editor?

Hold down Shift and click on the X button right beside the mask dropdown.

This will unlink the 'mask data-block' from your file. To get rid of the mask's data, you can either save and re-open your blend-file or just click the Purge All button in the Outliner:


You can achieve this with two dynamic enum properties if you are fine with selecting an armature and a bone. If you want to select an armature object, things become more complicated. Below code updates the list of armature objects as the first enum property is changed - which is really ugly. Another way would be to place a button for the user to update the collection:

import bpy

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        layout = self.layout
        sce = context.scene

        col = layout.column()
        col.prop(sce, "arma")
        col.prop(sce, "bone")

        col.prop_search(sce, "arma_name", bpy.data, "armatures")
        arma = bpy.data.armatures.get(sce.arma_name)
        if arma is not None:
            col.prop_search(sce, "bone_name", arma, "bones")

        col.prop_search(sce, "arma_name", sce, "arma_coll", icon='OBJECT_DATA')

def arma_items(self, context):
    obs = []
    for ob in context.scene.objects:
        if ob.type == 'ARMATURE':
            obs.append((ob.name, ob.name, ""))
    return obs

def arma_upd(self, context):
    self.arma_coll.clear()
    for ob in context.scene.objects:
        if ob.type == 'ARMATURE':
            item = self.arma_coll.add()
            item.name = ob.name

def bone_items(self, context):
    arma = context.scene.objects.get(self.arma)
    if arma is None:
        return
    return [(bone.name, bone.name, "") for bone in arma.data.bones]

def register():
    bpy.utils.register_class(HelloWorldPanel)
    bpy.types.Scene.arma = bpy.props.EnumProperty(items=arma_items, update=arma_upd)
    bpy.types.Scene.bone = bpy.props.EnumProperty(items=bone_items)
    bpy.types.Scene.arma_coll = bpy.props.CollectionProperty(type=bpy.types.PropertyGroup)
    bpy.types.Scene.arma_name = bpy.props.StringProperty()
    bpy.types.Scene.bone_name = bpy.props.StringProperty()

def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
    del bpy.types.Scene.arma
    del bpy.types.Scene.bone
    del bpy.types.Scene.arma_name
    del bpy.types.Scene.bone_name
    del bpy.types.Scene.arma_coll

if __name__ == "__main__":
    register()


MakeWalk fails to retarget an animation with the rigify armature PitchiPoy Version

I had a similar issue with a ManuelbastionLab rig. The problem is due to the armature having bones that cannot be mapped by MakeWalk.

To solve it I moved the extra bones (in this case the breast bones) onto another layer.
To do this go into edit mode select the bones to move, pressM and select a layer that is invisible (this can be checked in the data tab).

The light grey layer with the dot will not be visible.

Then I imported the BVH without any trouble.


Ahah you are dragging the corners of the panels, actually increasing their number.
Quick dirty mode: see that long row of tabs up in the screen? Click one of those and you will have a cleaner view.
But you should learn to manage panels: so to remove panels, just click a corner again, one in between two panels that you want to unify, and move the mouse on the panel that you want to REMOVE. The other panel will take its place, and you will have one panel less.
Do this with all the panels that you don't want.
All those horizontal panels down there at the bottom of the GUI can be removed this way.
You have also activated the QUAD VIEW in the topmost panel. To deactivate it, go with the mouse cursor over that panel and press CTRL + ALT + Q.


define the prop of a driver with a script?

Firstly, quite possibly, the issue re viewport via render is you need to drive the hide property as well.  Simply right click copy on view_render driver, and right-click paste driver into the hide field to emulate hide_render behaviour.

A driver can only return a float (decimal) or integer (or bool (True, False)) type, therefore you can't return object references or name strings.  What you can do though, is pass the name of an object to a driver expression.

To get a property from a parent using a driver.

def get_parent_property(name, property, default):
    object = bpy.data.objects.get(name)
    parent = object.parent
    return getattr(parent, property, default)

#add to driver namespace
bpy.app.driver_namespace["get_parent_property"] = get_parent_property

The driver expression get_parent_property("Cube", "hide_render", True) will return the hide_render property of "Cube"'s parent object, or the default value True in the case there is no parent.


How to make a material with texture in Blender 2.8?

Here is the node setup to achieve the result:

And here is the .blend file:

LINK


a simple script not working in blender 2.8

The problem was not with the naming conventions (or at least, that wasn't the only problem, I don't know if Blender does enforce this). I also had 'TABERROR' object has no attribute 'msg' and I didn't have any classes in my script.

I finally found out what the problem was. The file failed to parse (hence no line number information) because there was an invisible error in the indentation. In particular, some lines were indented with tabs, others with spaces. In my case this was caused by me using tabs for indentation in my own editor, then editing the script in Blender's text editor, which automatically inserts spaces instead.

Opening it back up in my text editor and making all indentation consistent fixed the problem.


Normals are vectors that are Orthogonal to the Tangent plane of a curved surface; Or simply orthogonal to a face.

The Normals are usually used to determine a surface's orientation toward a light source for shading. Most common examples:

Flat, Goraud, Phong shading

Fresnel, Refraction, Reflection effects
Bump, Normal, Displacement mapping

Normals are generally normalized to length 1 (in arbitrary units), otherwise calculation errors, and thus artifacts, may arise. Since they only point one way they are also used for back visibility culling (when double-sided is off).

That's why it is important for the normals to be consistent and coherent (i.e. point in the correct way - outwards of a model).


Hair particle system moves position when loading

I believe I found the answer to my problems.  In my subdivision surface modifier I had view and render at different values.


I found the answer to the question myself.
I had drawn the first mask in a counter-clockwise direction, and the second one in a clockwise direction. That caused the second one to look different (feathering at the inside instead of the outside).
The solution was to right-click the mask and choose "Switch Direction".


How to set the default fill type to NOTHING (Cone, Cylinder), once and for all?

You can see the property names by hovering mouse above the field.

Note that you need to match this name in the first part of the script file before the =. The latter needs to define property in blender operator format. For the dropdown menu it's in fact enumerator type, not string. You can't really specify default value for enumerator but I found that this has the desired effect nonetheless. So the file should look like this (note you need to import EnumProperty in the beginning as well):

from bpy.props import IntProperty
from bpy.props import EnumProperty
from bpy.types import (
    MESH_OT_primitive_circle_add,
    MESH_OT_primitive_cone_add,
    MESH_OT_primitive_cylinder_add,
    MESH_OT_primitive_uv_sphere_add,
)

MESH_OT_primitive_circle_add.vertices = IntProperty(name="Vertices", default=12)
MESH_OT_primitive_circle_add.fill_type = EnumProperty(items=[('NOTHING', 'Nothing', 'Tooltip'), ('NGON', 'Ngon', 'Tooltip'), ('TRIFAN', 'Triangle Fan', 'Tooltip')], name="Fill Type")
MESH_OT_primitive_cone_add.end_fill_type = EnumProperty(items=[('NOTHING', 'Nothing', 'Tooltip'), ('NGON', 'Ngon', 'Tooltip'), ('TRIFAN', 'Triangle Fan', 'Tooltip')], name="Fill Type")
MESH_OT_primitive_cylinder_add.end_fill_type = EnumProperty(items=[('NOTHING', 'Nothing', 'Tooltip'), ('NGON', 'Ngon', 'Tooltip'), ('TRIFAN', 'Triangle Fan', 'Tooltip')], name="Fill Type")
MESH_OT_primitive_cone_add.vertices = IntProperty(name="Vertices", default=12)
MESH_OT_primitive_cylinder_add.vertices = IntProperty(name="Vertices", default=12)

If you need to create certain type of geometry often you might as well copy the operator that creates it and store it in script file or python console where you can execute it. You can store all the properties you can edit in the side panel.

Drag the top info bar down and right click to select and CTRL-C to copy the lines for quickly using them later. You can even make them their own operators, add them to menus or add keybinds to them.


How to avoid tube overlap in rigid body simulation

Don't set Margin to zero, use as much as you can (to result with good looking sim). To simulate thick objects is always problem. Low margin value increase possibility of objects penetration (like that you see with your setup - they hook each other and rotate as crazy).

Anyway ... Margin didn't solve the issue here. Result was hysteric as in your case.

I had to start with defaults.
In this example - add Curve object, set Depth, Convert to Mesh, add Rigid Body / Active / Shape>Mesh / Margine 0.01, add Solidify modifier (Thickness 0.02) ... copy object few times and run sim.
What definitely helped here ... use tubes thickness as modifier not as real geometry.
Solidify modifier > Thickness 0.02

Note: Margin 0.01 is from some angle view visible so you can use also 0.001, but sim can became jumpy.
General rules for successful sim - Apply Scale, Origin to Geometry (it is not your case).

So the issue is caused by inner faces of a tube (when real geometry). That is weird for me since margin is low so there is not even a possibility collision margin crossing from inside tube through to outside (to create effect like switched Normal direction). So I don't have an explanation for that.
Increasing Solidify modifier Thickness to 0.06 and Apply Modifiers make the sim possible.
Solidify modifier > Thickness 0.06 ... Apply modifier (make real geometry)

Note: In a middle of anim it exploded because of collision penetration so I enabled Margin for floor object 0.04 that make it stabilised.


Extending lemon's commented.

An object can be restricted to a lower display mode.

In 2.79 it is set in the Properties Panel in the Object tab under the
Display section.

  The Maximum shading mode to display in the 3D View. This can be useful if you have a high-poly object that is slowing down performance.

In 2.8 the term is Display As.


Enabling Vertex Only in the properties of the bevel tool allows you to bevel the edge. You can also enable it in the Adjust Last Operation panel. The shortcut is SHIFT+CTRL+B.


ShiftA Mesh > UV Sphere
3D View header Add > Mesh > UV Sphere
Toolshelf in the 3D View Create tab then the UV Sphere button.

And those are just the normal simple ways to add a sphere.

This question probably could be of some help, at least you'll have a cube...


How to batch import images as brush textures?

There is an addon just for this, Import BrushSet. You can download the addon from here.

After you have it installed, simply click on File > Import > Brush Set.

You have to choose a folder (don't pick any images, just the folder) and the addon will import all the images in that folder and set them up as brush textures. (It would be a good idea to make a separate folder with only the images you want to import)

It's as simple as that.


Create smooth vertical gradient with Emission shader and Diffuse shader

Better method would be to use Separate XYZ node as a factor between Diffuse/Emission shader.

It basically take Z height of your mesh and assign material based on it.

You can control factor by Color Ramp node.

Edit:

First of all, issue is from Mapping Node. You need to switch it to Point, set Scale to 1, 1, 1, and lower Z Location value. This will be our 'starting' position. Also set Color Ramp to default state (black to the left, white to the right):

Now if you want to control gradient falloff we will use the simplest (I think) method for it by changing only Scale and Location Z values in Mapping Node.

Scale Z value will control gradient falloff - lower value smoother gradient.

Location Z value will move it up and down.

Look at some of these examples (Location Z and Scale Z noted on pictures):

And going further if you want smooth falloff (top left corner) and hard emission on top of it, you can move white value in Color Ramp node to the left a bit to tweak it.

Blend file:

Here are some of the examples, and little extra fun with Color Ramp node.


Array modifier to achieve a partial object (ie. non-integer objects)?

you can achieve this with a little overhead:

you created your array of e.g. a cube

you double that cube (before you add the array modifier)

you shorten the cube in edit mode as you need

you add that edited cube as cap end in the array modifier like here:


Above are 10 separate objects plus a red square.  10 duplicator objects have [Curve Modifier].  The 10 numbers are parented separately to a duplicator objects.  Duplicators 1-9 have one child.  The 0 duplicator has 2 children the zero and the red square.  For this small example the benefits of repeating elements is not very strong. Carefully planned object heirachy duplication or small Python scripts can make the creation more efficient.

The zero and red square are parented to the same object which are meant to represent a small child parent one level hierarchy.Further hierarchy has not been explored.

The jump is a mistake in the GIF production by GIMP.  The gray ring shows scale.  The gray square indicated movement in the x direction.

The yellow child cylinders have been duplicated by the parent object, the light blue planes.  The circular curve is a simple track.  The yellow cylinders have retained original shape, no deformation.  Click to see larger image above.  Note that some of the info has been pinned locked with the push pin icon, to achieve more information on one screen capture.

Typically a composed train object has parent object.  The train parent object can be parented to a plane duplicator.  You have included no images in your question so it has an mysterious quality to it. Lets guess that a train hierarchy has many cars and a car has many component Blender Objects.  Each duplicator face can control a train car indirectly via parenting. A small Python script may help in this regard.  One suggestion is to use many duplicator objects on the same curve.

Consider the

[Array Modifier] shown above and known in the original question
[Curve Modifier] shown above
[Duplication Panel] shown above ... see https://www.blender.org/manual/editors/3dview/transform/duplication/duplifaces.html
[Path Constraint] not shown

The curve modifier introduces shape changes, or deformation, so you must use another technique to control that if desired.  This can be viewed as good or bad. The light blue planes and red cylinder both have [Array Modifier] and [Curve Modifier].  The [PlaneDuplicator] modifiers are show above. The red cylinders look like seeds as the [Curve Modifier] deformation was intentionally shown to a large degree to emphasize a potential problem. Note the blue [PlaneDuplictor] objects have been deformed to a lesser degree into trapezoids.

Parent Child relationship plays the major role in Duplicator panel.  The parent duplicates the children.  The reverse might seem odd.

The duplication panel for the [PlaneDuplicator] is shown which indicates to duplicate the children objects on [Faces], in this case only a single face is present.

The Yellow Cylinder is parented to the [PlaneDuplicator].  This can be seen in image above.  The [PlaneDuplicator] is not rendered, this is the standard behavior.

Note the parent is deformed.  The duplicated children are not deformed.

Constraints can be copied by menu. Press [space] in the 3DView Window and type [copy] to begin matching.  The regular menu has this option.

By searching here at BSE you can see many questions about the

[Follow Path Constraint]

Note that there is not necessarily 100% coordination between the offset value in the [Follow Path Constraint] and the spacing you may need.


Mesh with full weight moves less than bone, and moves another mesh with no weight

In edit mode, if you select a vertex you can read - in the "N" panel - all the weighted bones, so to understand why the vertex is moving that way: if you want the vertex to move exactly with a bone it should be weighted to that bone only (even if the weight is not full 1.0).
If this does not resolve the problem I think you should upload the file.


Why when I render an image does it work, but a weird render result comes up?

The render is being overwritten by something in the compositor or the sequencer. Un-tic "Compositing," and "Sequencer" in the "Post Processing section of the Render settings, and you should see what you expect.

You might also undo whatever sequencing and/or compositing you have going on in those panes.


Have you tried to use the texture atlas feature? Basically you select all of your objects, create a new atlas, then chose "No_Unwrap" and "StartManualUnwrap".

Manual unwrap should present you each model's UV map with correct aspect ratio. After you're done moving the UVs on the map, don't forget to hit FinishManualUnwrap.


How to tell if an add on is present. Using Python

import addon_utils

addon_name = 'some_addon'

success = addon_utils.enable('some_addon')
if success:
    print("enabled", success.bl_info['name'])
else:
    print(addon_name, "is not found")

addon_utils.enable returns None if it failed to enable the addon, but returns a module reference (which evaluates to True) if it did manage to enable it.

The precise name of the addon is either:

the .py name if it's a single python file addon,
the directory name if it's directory based

Sometimes, especially prevalent with github .zips, the addon name is suffixed with -master. The addon name would then be 'some_addon-master'.

over the top, addon seeking

bpy.utils.script_paths() returns a list of directories where Blender looks for add-ons. With a bit of python-fu you can iterate through them and find any .py or sub-directories that contain part of an add-on name -- Then try to enable it :)


How to make something similar to rigid body joint in Cycles?

The game engine rigid body joints do not work outside the game engine. For similar behaviour in Cycles you should use Rigid Body Constraints - these can be created by selecting two or more rigid bodies and clicking Connect in the Physics Toolbox panel (T). When a rigid body constraint is first added it defaults to ‘Disable Collision’ - to enable collision between linked objects you should untick the checkbox in the Rigid Body Constraint physics properties.


Changing only one linked group Original File

I hope I understand correctly.

If it's not the file itself you need to change but the content I think it would be easiest to simply select group and copy+paste selection to the file replacing the group/objects there.


Fade in an image in an animation in blender 2.9

(NOTE: You need to have the "Import images to planes" addon enabled to do this).
Step 1 (Import the image):

Step 2 (Open the shader editor):

Step 3 (Add a mix shader in between the principled shader and the material output (Change the factor to 0), then add a transparent shader to the bottom shader input):

Step 4 (Go to the frame you want the image to start fading out (For me it's frame 1)):

Step 5 (Add a keyframe to the factor):

Step 6 (Go to the frame you want the image to fully fade out, and change the factor value to 1):

Step 7 (Add a keyframe to the factor of 1):

And you're done!
When you render it, it should look like this:

(Sorry for the image, it was the last thing in my downloads folder).


Based on the fact that the hole is not open inside (comment), it means there are faces connecting the front and back of the hole, you need to delete the faces on the 3 sides of the hole, then in "Edge Mode" select the back side 3 edges and press F and repeat the same with the 3 edges in the front.

Here visual explanation:


Save PSD (or TIFF) with passes as layers?

Wow! I think I figured it out. You need to use OpenEXR Multilayer file type when saving and install EXR-IO plugin (free) for Photoshop (https://www.exr-io.com/features/).


Animation Nodes Combining lists generated after several loop iterations

Use "reassign" from the advanced settings:

Set the final list as parameter.
Select the loop node.
Go to the "node" tab, "advanced node setting".
Check "output" to have the result as output.
Click on the "reassign" button: that will create an reassign output node that you can drag and place in the node tree.


Animate the World's material

You could create several world shaders and then mix them with a Mix Shader right before the output node. Mix Shader has an field named Factor that allow control of the percentage of each one coming out from the node and that can be animate.


Drag the edge of the column of tool icons to the right.


I found a working solution. I just removed the vertices from OFF which did not correspond with any face. That leads to correct bounding box dimensions. To find the correct bounding box position of the part I used the following:

# create a cube for the bounding box
bpy.ops.mesh.primitive_cube_add()
bound_box = bpy.context.active_object

# copy transforms
ob = bpy.data.objects['off_object_name']
bound_box.dimensions = ob.dimensions
bound_box.rotation_euler = ob.rotation_euler

# calculate part center
centre = sum((Vector(b) for b in ob.bound_box), Vector())
centre /= 8

# set location using world matrix transformation
bound_box.location = (centre[0], centre[1], centre[2])
bound_box.location = ob.matrix_world * bound_box.location


Can't open recently downloaded textures: "Cannot read...no such file or directory"

MS Windows includes limitations on the maximum file path to any accessible file - it appears that you have exceeded that limit.

See docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file - in particular the following section :

Maximum Path Length Limitation
In the Windows API (with some exceptions discussed in the following paragraphs), the maximum length for a path is MAX_PATH, which is defined as 260 characters. A local path is structured in the following order: drive letter, colon, backslash, name components separated by backslashes, and a terminating null character. For example, the maximum path on drive D is "D:\some 256-character path string<NUL>" where "<NUL>" represents the invisible terminating null character for the current system codepage.

Your path (including the assumed 'c:\users\' prefix not shown) exceeds the 260 character limit. This means that when Blender (and other programs) attempt to access the files the file is effectively unreadable.

Since this is a limitation of the operating system (rather than a limitation of Blender) the only option is to relocate the files to a more O/S-friendly directory.


How to move multiple objects into another collection?

You just have to .unlink(object) each object from all linked collections and then .link(object) each object to your target collection.

Example on how to move all objects in selection to MyCollection:

import bpy

C = bpy.context

# List of object references
objs = C.selected_objects

# Set target collection to a known collection
coll_target = C.scene.collection.children.get("MyCollection")

# Set target collection based on the collection in context (selected)
#coll_target = C.collection

# If target found and object list not empty
if coll_target and objs:

    # Loop through all objects
    for ob in objs:
        # Loop through all collections the obj is linked to
        for coll in ob.users_collection:
            # Unlink the object
            coll.objects.unlink(ob)

        # Link each object to the target collection
        coll_target.objects.link(ob)


There are several effects here. For the light rings effect, you can create a curve circle, give it depth in the Properties panel > Object Data > Geometry > Bevel, then give it a material with this node setup: Texture Coordinate (Object output) > Mapping (stretched on the correct axis) > Noise Texture (play with the Scale value) > ColorRamp as a factor in a Mix Shader between an Emission and a Transparent node. You can make it rotate with the Mapping rotation values.


How does Blender know whether to use compositor output or 3D scene output

1. How does Blender know which to use? Are they separate outputs or are they one output?
They are separated thing. You can choose whether Blender to use Compositor and sequencer:

When you render, Blender save a bunch of information for camera (called render layers). Cameras are specified scene catchers in concept. Those information can be retrieved in Compositor interface for readable value, and for extra manipulate. Finally, compositor node can link to a final output (Composite), which is what you see in rendering window. (You can also choose what you see in view panel)

2. Is it possible to chroma key the scene?
Yes, totally possible to do that in Compositor. There is a node called keying, you can try it yourself.

(Notice that Blender knows about the original color of surface. Those hole in violin does not treat as black-like color in Keying, You can't do that in plain video)


Problem with the weight paint mode when there are a lot of geometry on the mesh

in Weight Paint mode press M or V to enable Face or Vertice selection masking (you will notice one of the button at the bottom of 3D View will get pressed). after this you can either use simplified selection tools in Weight Paint mode itself or go to Edit mode to use a full specter of selection tools there and then return back to Weight Paint mode with your selection preserved between modes.


How to create a voronoi texture with different color in every tile and black lines in between?

To make all the tiles different color you could just take the color output of the voronoi texture and play with that. It's already quite close to what you want. If you want the black lines you need to add more nodes to mix it with.

Update
Here are two different results. This one has uniform lines and the last one has little distortion added so it closer to the original picture.


Strength of Force Fields can be keyframed, like the value of most properties in Blender.

To set a keyframe, go to the frame where you want to assign a Force value and set the value. Then, with your mouse over that field, press I. Now you can move to another frame, change the value and repeat.


Can I use the distance between two objects to animate a property?

Yes, with Drivers

You can animate a property with a combination of values of other chosen properties.

To set up a Driver, just right click in the parameter field and choose "Add Driver"->"Manually create later" from the pop up menù. In the following example I added a "value" node and linked and added a driver to control it's value (the purple one), but I might have directly controlled the Size parameter of the Blur node itself:

In the Graph editor, under the Driver editor type, you can easily set up a Distance Driver Type and pick the two objects (camera and cube in the following example):

Here's the result:


Refections on transparent object - renderd view diffrent to render

This is an old bug in blender. You are doing nothing wrong. The information is there, but the render window is not displaying it correctly. It cannot display pixels that are transparent and luminous at the same time. Glares, glows, reflections. and fire don't display correctly.
View your image just as color (not color and alpha)

Your information should be there. To save it use a format like OpenEXR
For more info read:
How do I get the Glare node to output transparent instead of Black background


Python Script To Rename Bones In Armature

This will replace "Skel123:", etc. with just "Skel:" in the names of bones (edit: and their armature, and their armature's object). Select the armature you want to do it to and make sure you are in Object mode before running it.
import bpy, re
ob = bpy.context.active_object
assert ob.type == "ARMATURE"
assert bpy.context.mode == 'OBJECT'
for thing in [ob, ob.data, *ob.data.bones]:
    thing.name = re.sub(r'Skel[0-9]+:', 'Skel:', thing.name)

If you want to remove all numbers instead of just the ones from the "Skel:" part, you can use re.sub(r'[0-9]', '', thing.name) instead.


How can I quickly generate / create a large city without modeling it all by hand?

City Generation

Suicidator "City Generator" (SCG)
This is a very robust Blender addon that can create amazingly detailed & complex cities:

Generate random terrains (including bodies of water) for your city, or use your own bump maps to create the landscape of your choice
SCG automatically generates all the textures for your buildings, roads, grass, water, etc.
(NOTE: Currently, SCG only generates textures in Blender Internal, not yet for Cycles)
Specify if it's day or night in your city

NOTE: As of City Generator v0.5.7, textures will ONLY be generated in Blender Render, NOT yet in Cycles. So, make sure you are in Blender Render BEFORE you click the Build City button:

You can read the City Generator online manual on their website and see many more examples.

NOTE: There is another addon listed on the Blender Wiki called  "City Block Generator". However, this addon only works with Blender versions 2.4x - 2.5x, so it's not an option for any versions later than 2.5

Adding Special Building Details for Close-Up Shots

If you ever want to have a close-up shot of a particular part of your city and want to add specific building details, you can use these add-ons:

Block Wall Builder: Block Wall Builder allows you to build your own custom walls. It has a lot of functionality, including the ability to add holes in the wall for windows, doors, etc.:

Window Generator 2: Add custom windows. Download it here and read more about it here. Here are some samples:

Jamb Generator: This addon from Seyit Ali YAPRAKCI makes custom door frames/jambs:

Archimesh: Archimesh gives you the ability to add great detail to your buildings: add rooms, house structure (walls), doors (one and two leafs), columns, stairs (strait and curved), tile roofs, cabinets, shelves, windows, books, lamps, curtains, etc. It can also UV unwrap rooms! You can download it here and you can get more information on how to use it here. Here is a sample of the cabinets with shelves:

Balcony Generator: This addon, also from Seyit Ali YAPRAKCI makes balconies:

Chimneys: This addon, again from Seyit Ali YAPRAKCI, makes chimneys:

Flat Board Generator: This addon allows you to make hardwood floors:

Add Pipe Joint: You can read about this built-in addon here and here are some sample joints:

NOTE: If you want to extrude pipes from these joints, see this question and answer for details on how to do it.

Add Snow and Icicles

If it's winter in your city, you can add piles of snow to your meshes with the technique described here and with the Icicle Generator you can add icicles:

Adding Terrain for your City

If you don't want your city to be on flat ground and aren't using Suicidator City Generator, you can make unique landscapes easily with the built-in addon ANT Landscape:

The Blender manual describes how to use this built-in addon.

NOTE: Previously, these landscapes all had the normals flipped the wrong way, which makes the underside of the mesh be considered the top. This has been fixed in an update, but if you have an older version and you're finding this is a problem for you, you can fix it simply by flipping all the normals:

Select landscape → TAB → select all (A) → W → Flip Normals

Add Trees

"Sapling" is a built-in addon that allows you to make trees:

This addon is amazingly robust, capable of making a huge array of different kinds of trees and bushes:

This addon is much easier to use if you watch a tutorial about it.

For more detailed information about making trees, see this page.

Add Scattered Debris, Litter or Plants

If you want to have litter around your city, or debris & weeds in an abandoned lot, you can do that using a Hair Particle System, which you can learn how to make on this page.

Add Rocks

The Add Rocks addon allows you to quickly add randomly generated mesh rocks, thus making it much quicker to add detail & practicality to your outdoor settings, urban or otherwise. Here you can read about & download this addon (note: the Add Rock addon is part of the bundle described in that post.) Here are some examples of the 5 rock presets:

For lots more details on making Add Rocks, see this page.

NOTE: One thing to be aware of is that each rock has many modifiers on it, and these slow down render time. See this page (at the bottom) to get details on how to solve this issue.

Add Ivy

Blender's built-in "Ivy Gen" addon is very good at creating realistic looking ivy:


How to make a rigid body system a static mesh?

After you have run your rigid body simulation, you have to options for how to apply the sim to the mesh.

Your first option is to simply apply the visual transform of the object(s).
Move to the frame where the object is at the location you want to keep, then select the rigid body object and press CtrlA > "Visual Transform".

Your other option is to bake the rigid body simulation to key frames.
Select the rigid body object, then press the "Bake To Keyframes" button in the physics tab of the tool shelf. Set the range of frames you want, leave the "Frame Step" at 1, then press the OK button.


Changing bone size changes Envelope instead

Press Ctrl + Alt + S  to change the size of a bendy bone.


In my Blender 2.82a the snap function is not working

While in Edit Mode for any object, open the Properties Shelf if it isn't already open (n key while hovering mouse in the 3D View), and click on the Tools Tab. Under the Options section, there is a feature called Auto Merge. Make sure it is not checked if you don't want vertices automatically merging with other vertices when they get close.


Blender random packing animation (reactor cylinder type catalyst random packing)

Make your Steps Per Second high enough. This is in Scene tab under Rigid Body World and Settings. Default is 60 and seems to be too low in some cases. High value will slow down calculations but will be more accurate.

Next make sure your collision Shape is Mesh for you funnel. This is important for complex objects. For your pellets I think Capsule should be fine. Also make Sensitivity Margin small enough. Accurate shape will slow down calculations but will be more realistic.

Last make sure your walls are thick enough. If your wall are too thin then your particles can make through before next step happens.


Turn Off Tree Reflections For Glass And Gloss BSDF?

Let me just propose another solution:

1) Switch to your World lighting
This will use your environment texture for lighting.
If there's no HDRi set, no image texture will be reflected.
You're done.

No texture is reflected, only homogenous light

2) Enable your scene lights
This will give you a better preview of your render.
You can combine it with your World lighting.

No image texture is reflected, plus your scene lights are enabled.

Why not just turn lighting strength to zero.

It makes all materials look the same (black).
While this works for getting rid of texture reflections, it is not often desired.
Simply switching to you World settings is usually more convenient.

Scene looks with lighting strength set to zero.


Rotate using the 3D cursor as a pivot

With Shift+S you can snap the cursor to the geometry. Than set the Pivot to 3D cursor and rotate on the wanted axis.


Point 1, You can join seams.

Simply select the two vertices you would like to combine.

Then press W, then "Weld". This will "join" those two vertices.

Point 2, You NEED seams!

Unwrapping requires cutting the model up into pieces (for it to work properly). Imagine it like you have a paper (3D) figure and you have to let it lay out flat. You must cut it enough times to do this. If you mark a seam, that will be a split. If you have marked all the seams you want and press U, then "unwrap", it should unwrap with only your given seams, but after you mark a new seam, you must re-unwrap for it to take effect.

Point 3, Smart UV Project will automatically add new seams.

Smart UV Project is very automatic. It adds new seams where it deems best. This can be a problem if you are working with detailed unwraps. It is often easier to manually unwrap than welding seems left by Smart UV Project.

Point 4, You can do this for a whole seam.

Simply align the seams as best you can, then select them. (Tip, use proportional editing on "connected mode" to drag an edge closer to another while smoothly transforming the geometry in between.)

Then press W, then "Align Auto" to line up the two seams.

Now press W again (with both seams still selected) and click "Remove Double UVs". This will remove the UVs that are next to each other. If you succeeded, this should merge your seams.

Note: If the vertices were too far apart after aligning, this will not work. You can do any necessary clean up using weld.

Here is a more complex join.


Why are instances of duplicated groups linked

An object can be a member of more than one group, they are more like tags or lists of objects than "groups" in the more traditional sense. So if I'm understanding your post correctly, you can make a group for the first table/chair set, then another one for the second set. Any objects you want in both sets, just add them to both groups.


You need to setup a vertex group for pinned vertices under the cloth modifier, and then assign hooks to the same vertices which go to the respective bones. (May need to move the hooks above cloth in the modifier stack so they take precedence.) That should keep the cloth attached to the rig.

Keep in mind pinning is used for attachment points, so a few around the edges should do it, and the tension in the cloth sim should take care of the rest.


How can I multiply a quaternion and a list of vectors that represent xyz vertices of an object


removing intersecting geometry in blender 2.9

You could use a boolean modifier, with "difference" or "union" to join them

it also worked in 2.9


Multiplying mesh multiple times in Blender

To create a "matrix" of objects, just use the Array modifier twice with the Relative Offset set to x=0 y=1 z=0 and x=1 y=0 z=0 as shown in the screenshot:


How to avoid n-gons while using the knife tool?

Tap K to use the knife tool.
Click 2 or more lines, then Enter to complete your cut.

If you end up w/ unwanted n-gons, do the same operation, but cut across diagonal corners.

Another method is tap Alt-P to poke faces.

Alternatively, use the triangulate modifier.


How to stop the model from deforming while it rotates?

All seems to work as it should. Don't rotate your mesh directly after applying an armature - after this point, only the armature is responsible for the moving.

In pose mode, you can move and rotate all bones to modify your mesh. If you want to rotate the entire armature (and your mesh with it), leave the pose mode and rotate the armature in object mode.


I think that the "smooth" look of the corner is just a matter of shading (and shaders).

I suggest to simply model it as a cloister vault's corner. Any distortion of the profiles in my opinion would lead to a worse result.

If your boundary profiles are round, you can use the Bevel operator on the two top edge (shortcut Ctrl+B). Then add two (flattened) loopcuts near the corner and Remove Doubles.

Then control the shading (set it to smooth) by marking sharp edges  and adding an Edge split modifier as you can see in the first picture.


Is running cloth physics without animation, or an endless non-looping animation possible?

Unfortunately, this is not possible. The simulation is geared towards having a 'start' point and moving on frame by frame, storing the result in the Cloth Cache so that it can be replayed at a later point in time - there is no facility for a 'continuous' simulation. Even if there was, you would have the difficulty of stopping the simulation at the desired point in time and capturing the 'state' - currently this is achieved by simply scrubbing back through the frames until you get to the desired point and then 'applying' the cloth modifier to capture that frame from the cache and apply it to the mesh (or as a Shape Key).

So, yes, your best way forward is to increase the length of the simulation to give you enough time to tinker with the pinned vertices to get to the desired state before pausing the simulation to capture your 'frame'.

However, that said, once your cloth simulation has been baked you can use the Particle Edit mode to manipulate the mesh manually - this could be a way of achieving your goal. ie, run the simulation to get it 'almost there' and then use the Particle Edit to 'comb' the cloth (and the paths each vertex takes) into shape (as you would with Hair).


One material fades into another on model?

If cycle it would be something like this

You use the the gradient as a factor between the 2 shaders.


Is there a better way than dupliverts to make these scripted monkeys always face "out"?

Instead of dupliverts, we can create it all in one mesh using bmesh.ops.create_monkey().

import bpy
import bmesh
import mathutils

loco_f, loco_v = (-5, 0, 5), (+5, 0, 5)

bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)

bpy.ops.mesh.primitive_ico_sphere_add(location=loco_v, size=4, subdivisions=2)
shape_mesh_v = bpy.context.active_object

bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.mesh.delete(type='EDGE_FACE')
bpy.ops.object.mode_set(mode='OBJECT')

bm = bmesh.new()
bm.from_mesh(shape_mesh_v.data)

src = [v for v in bm.verts]

for v in src:
    loc = mathutils.Matrix.Translation(v.co)
    rot = v.normal.to_track_quat('-Y','Z')
    mat = mathutils.Matrix.Identity(3)
    mat.rotate(rot)
    mat = loc * mat.to_4x4()
    bmesh.ops.create_monkey(bm, matrix=mat)

bm.to_mesh(shape_mesh_v.data)
bm.free()

So the key point you are looking for is v.normal.to_track_quat('-Y','Z') to get a quaternion rotation matrix from the vertex normal.

For another way to approach this, you could try animation nodes.

Here we make a list of the location and normal of each vert in an icosphere, we use that list to replicate the suzanne mesh.

EDIT:
After some experimenting with the aim of creating your final goal, I found creating one orbital plane at a time as a unique object seems to be the fastest way, seems to find a balance between object and vertex count. Once they are all created they can all be merged into one mesh for simplicity. While creating each plane, an armature bone can be added and aligned with each orbit allowing easy animation. This is the script I came up with, a simple proof of concept that needs better positioning and timing to be complete.


Is rendering supposed to take this long with these specs? (40 sec per frame)

Rendertimes depend heavily on what you render.
For example smoke takes ages to render.

For your render settings, crank the tilesize up to 512x512.

Your graphics card also isnt THAT fast. And 40 seconds per frame isnt really much ;)
In most of my projects, render takes up to several minutes per frame on my machine. Thats why renderfarms excist. For example, i had some smoke/fire sim to be rendered. It took about 15 minutes per frame.

So, again, it depends on what you render.

What do you render? Maybe you can optimize?


How to make a particle slide across a mesh?

On the surface you want the drop to stick, enable physics collision. Then increase the stickiness value to keep it on the surface, a value of 1.0 will stop it bouncing off the surface as it hits.

You may also want to increase the friction factor to slow down the particle as it slides along the surface.


I think you are rotating using the local axis in the top one, and the global axis in the bottom one.

To solve your problem, use the local axis when keyframing

So in order to rotate around say, the x aixs, instead of RXmove mouse, use RXXmove mouse


You can delete an object's physics and physic related strips still remain in the Dopesheet.
Delete these and often quirky behavior returns to normal.

Try purging orphaned data in the Outliner's menu.
Select 'Orphaned Data' (think that's what it's called). That will list several items as a rule. Scroll the Outliner's header strip to the right until you see 'Purge'. Keep selecting this until all that's left is 'Brushes'


By using the CLI on Linux, can I make a running blender instance save its current scene to file?

No. Blender accepts cli options when starting that can include a python script to automate tasks but once started it no longer accepts commands from the cli.

The autosave, if is hasn't been disabled, should save a temporary copy, even the unmodified startup file will regularly autosave a temporary copy. If your autosave file is old then it may indicate that the copy of blender is no longer running.

If you can't get back to the machine (or get someone else) to close it properly then the only option I can think of trying is x11vnc that can connect to an existing xorg desktop. See if you can download a copy to your home folder and run it without admin permissions.


Was given the solution by @batFINGER, in another post.

add driver to Scene.current_frame?

by using app handlers.


In Cycles the most basic way would be to use a mix shader to mix transparent and diffuse. The Mix factor determines the amount of transparency.

If you use an image that has an alpha channel, then you can use the alpha as factor to mix transparent and diffuse.


A data transfer of vertex groups, all on its own, will do nothing to deform a mesh.  For good or ill.

Please forgive me if I'm telling you something you already know, but it's necessary to parent the shirt to the armature after applying the data transfer.  (With the armature modifier.  Use ctrl-p armature deform.)

If the shirt has any other deforming modifiers limited by vertex groups, data transfers can affect those as well.

It's common for armatures to have slightly different positions in pose as opposed to resting, even without any explicit pose, just from constraints.  Remember that your data transfer modifier will transfer from its target's final, modified position.  It's very easy to data transfer from a model that is slightly deformed from its own armature modifier, and this is not usually what you want.  Consider carefully your target before applying the data transfer, consider which modifiers you want visible for purposes of the data transfer.  You can always disable them temporarily, then re-enable them after the modifier.

You usually want an applied data transfer for this purpose, unless you have an unparented copy of the model somewhere, because you don't want to transfer from a posed character, you want to transfer from an unposed character and only then pose both the character and the clothes.

Finally, even though you didn't ask, unless your shirt mirrors the topology of the data transfer target, you probably don't want to transfer from nearest vertex.  Transferring from nearest face interpolated is likely to give better results.

Edit: I'll try to answer your questions.

When you select a mesh, then select an armature, then hit ctrl-P and use one of the armature deform techniques, it does at least two things: it parents your mesh to your armature, with a child/parent relationship exactly the same as if you parent a mesh to an empty; and it creates an armature modifier.  Parenting alone is not-quite necessary for armatures to work, but the armature modifier is essential.  So when I wrote,

  (With the armature modifier. Use ctrl-p armature deform.)

I was clarifying that parenting alone was not sufficient to get deformation from an armature; the armature modifier has to exist as well.

  Also I'm not supposed to do ctrl-p armature deform with empty groups? Everywhere else I've ever seen people do it they use empty groups.

I'm afraid I don't understand this question.  When you use ctrl-p to parent an armature to a mesh, you get a few armature specific options.

If you choose only "Armature deform," the action will not change any vertex groups on the model.  Any deforming bones that happen to have the same name as existing vertex groups will function fine, because you already have vertex groups created for them.  I consider this the correct way to parent a mesh that is already weighted.

If you choose "armature deform with empty weights", it will create vertex groups for any deforming bones in the armature that do not already exist.  No vertices will be assigned to any of these groups, but any already assigned will remain assigned.  If a vertex group already exists, it won't be changed.  Using this to parent an already weighted mesh to an armature is fine.  But its more typical use is simply to prepare an unweighted model for manual weighting.

If you choose "armature deform with automatic weights" or "envelope weights", it will create any vertex groups it needs (deforming bones) and it will write values into those groups.  If those groups already exist, any values in them will be overwritten.  So you shouldn't use this method to parent a model that already has weights that you want to keep-- like weights from a data transfer.

  defaulted they come in T-Pose mode. Would this be considered a pose even though its defaulted like that?

If the model with only an armature modifier is in any way different from its edit mode position, it is posed.  If it is not, it is not posed.  As I said, sometimes posing is subtle, and sometimes it is generated by constraints on an armature rather than due to any manual animation.  The safest thing to do is to disable any armature modifiers on the target of a data transfer modifier before applying that data transfer, and then re-enabling it afterwards.  An alternative would be to select your armature, and in the armature tab of the properties view, set the armature to rest position.


Object Info Node

As mentioned by @Gorgeous can use an object info node.
Control object emission strength (not material)
Using Object.color

Object color,
same as Color in the
Properties Editor ‣ Object ‣ Viewport Display

For the example below am creating two new nodes, an object info node, separating the RGB via a separate RGB node and feeding this into the mix node factor.
Unfortunately I am not aware of how to use the Alpha channel, so am keyframing and using the Red channel.
This way the action is created on and belongs to the object using the material.
Minor adjustment to your code to add only one material with  the new nodes and links, and keyframe the object's red color in the loop.
import bpy

fade_objects = bpy.context.selected_objects

frame_dif = 10
frame_length = 40
frame_start = 0

fade_frame_start = frame_start
fade_frame_end = fade_frame_start + frame_length

# Create Material Object and Apply to character curve
mat = bpy.data.materials.new('Fade')

mat.use_nodes = True
mat.blend_method = 'BLEND'

nodes = mat.node_tree.nodes
links = mat.node_tree.links

#Creating New Nodes
node_transparent = nodes.new('ShaderNodeBsdfTransparent')
node_mixshader = mat.node_tree.nodes.new('ShaderNodeMixShader')
node_bsdf = nodes['Principled BSDF']
node_matout = nodes['Material Output']

objinput = nodes.new("ShaderNodeObjectInfo")
seprgb = nodes.new("ShaderNodeSeparateRGB")

#Linking Nodes
links.new(node_transparent.outputs['BSDF'], node_mixshader.inputs[1])
links.new(node_bsdf.outputs['BSDF'], node_mixshader.inputs[2])
links.new(node_mixshader.outputs['Shader'], node_matout.inputs['Surface'])
links.new(objinput.outputs['Color'], seprgb.inputs['Image'])
links.new(seprgb.outputs[0], node_mixshader.inputs['Fac'])

for fade_object in fade_objects:
    fade_object.animation_data_create()
    fade_object.animation_data_clear()
    fade_object.data.materials.clear()
    fade_object.data.materials.append(mat)
    fade_object.color[0] = 0
    fade_object.keyframe_insert("color", index=0, frame=fade_frame_start)
    fade_object.color[0] = 1
    fade_object.keyframe_insert("color", index=0, frame=fade_frame_end)
    #Add frame difference for next character for sliding effect
    fade_frame_start += frame_dif
    fade_frame_end += frame_dif

Other things to consider would be using drivers on the color field based on the current frame, or by using a single action that is attached to each object and offset via the NLA


Is there any way I can make a curve and/or a mesh from a wavefile?

I've done this myself in the past, but the way I did it was fairly indirect. I loaded the file into Audacity, and took a screenshot of the audio visualization. Then I opened that file in Inkscape and cropped the screenshot to just the part of the audio that I wanted. I traced the image and saved the file as an SVG. I then imported this SVG into blender. Here's what that looked like when finished.

If you need help with the intermediary steps, let me know. None of the steps are overly difficult, but using an unfamiliar program can always be a challenge. :)


Frame-Duplicated Metaballs not rendering in Blender 2.79

I don't know whether it's a bug or not, but if you ALT+D duplicate metaball on the same layer, dupliframed metaballs start rendering fine. To hide this copied metaball, clear relation to parent object (ALT+P) and put it outside view area or parent to camera and move behind it.


Circuit board (technical elements) with particles

Animation Nodes can be used here. First, read my answer here to create the trace visualization. Then, we are going to alter the node tree to limit the computed directions to multiples of 45 degrees. To do that, the Snap Vector operator would be used. Take the following node tree for example:

The snap operator snaps the vector to the nearest point in a grid with uniform spacing, the spacing is defined by the snap vector. Since the origin point of the space is also a possible point for snapping, and since we don't want to snap to it, we normalize the vector first, consequently, the vector will never be closer to the origin, except for the case of a zero vector, which is practically impossible to happen in a curl field, so we don't have to worry about it.

Now, all you have to do is quantize the output vector of the curl subprogram using the snap node as shown above.


One approach to this might be to use Dynamic Paint and Vertex Colors to create a proximity map between your surface, and a smoothed version of it. I imagine this will be for visualization and illustrative purposes, there's nothing calibrated about it. The method assumes quite high vertex density.

Derive a base surface, from which, heights will influence color

In this example, I used AltS to scale the original mesh down along its surface normals, and a Smooth Modifier. (The smoothed object you can see in the illustration is a copy; the one actually used is inside the original mesh. If you make your copy an instance using Alt D, the you'll be able to adjust it conveniently, while viewing its effect.)

Under the physics tab of the properties panel > Dynamic Paint, make the original mesh a Canvas, with settings as shown:

(.. you have to click the '+' next to the 'Paintmap Layer', to create a Vertex Color layer in the object)

Under the physics tab of the properties panel > Dynamic Paint, make the smoothed mesh a Brush, with settings as shown:

(You will have to tweak the 'Paint Distance' parameter, in particular, to get a good range of tones.)

Give the original mesh a material whose color is influenced by the tones in the Vertex Color layer, here left with its default name of 'dp_paintmap' (As you can see I haven't set the range of tones up perfectly, here)

and this is the sort of result:

Other options include combining this map with Sharpness as suggested by Duarte, or inverted normal Ambient Occlusion, to emphasise higher frequency (sharper) surface details, or thinner protrusions.


Result not visible when using Blender Render

Blender Cycles expects Cycles Materials.
Blender Render expects Blender Materials.
They are not shareable across render engines.

If you replace your materials with Blender Materials then you can use Blender Render.  You can try a test by replacing one or two materials.  You might want to archive your file or create a different scene to keep the original intact.


My first time upgrading, I didn't realise I had to re-enable add-ons.
The issue was resolved by edit > preferences > add-ons then reactivating Bool-Tool.


Possible to use Pointiness in GLSL Viewport?

As of today, the pointiness function doesn't do anything in the OpenGL modes. You need to use rendered mode or bake it.


How do I extrude all faces a random amount through a python script?

You can extrude individual faces quite efficiently with the bmesh module:

import bpy
import bmesh
from mathutils import Vector
from random import random

bpy.ops.mesh.primitive_grid_add(x_subdivisions=10, y_subdivisions=10, radius=5)
ob = bpy.context.object
me = ob.data

bm = bmesh.new()
bm.from_mesh(me)
faces = bm.faces[:]

for face in faces:
    r = bmesh.ops.extrude_discrete_faces(bm, faces=[face])
    bmesh.ops.translate(bm, vec=Vector((0,0,random()*2)), verts=r['faces'][0].verts)

bm.to_mesh(me)
me.update()

If you used the standard API, a lot of mode changes would be required (select face in object mode, switch to edit mode, extrude face, switch back to object mode and so on). Mode switching is time and memory intense, thus it should be avoided as much as possible.


Setting a normal map for only part of a material (single Principled shader)

It's probably easier to use separate Principled BSDF nodes for the wood and metal, or have the "clean" region over the metal in the normal map itself. (depends on how you're painting this normal map).

However, if you want to use the setup in your example, it can work. You just need to use the geometry node to set the alternate normal to the default mesh normal instead of 1 (which is what the unconnected white socket does):


This is what I get from your file, cycles render, after a few seconds.

Maybe some driver/graphic card problem?

Hope it can help your troubleshooting.


Workflow question and advice [uv-mapping, modular or singular build?]

I think you ask mainly what is answered on this post which is relevant because it describes when you need different textures and uvs :

Texturing each object separately VS all in the same texture file

generally there is no any rule but it is a common practice to keep things separated depending again on their final usage (gaming, archviz, animation etc), it is more a combination of scale, complexity and purpose.


How do you move a vertex a specific amount in one axis in 2.8?

You can use the Grab function (G), then press the key of the axis you want to move on (e.g. X for the X axis). Then you can type in the amount you want to move (e.g. 0.75 = move 0.75 BU).


This one is driven by the knob rotation, so you animate the knob and the lights are good.

Let's assume you are looking at your knob from top view.

For convenience, you model a led and you parent led and knob to an empty. Knob must have first rotation applied and rotation mode must be set to xyz euler, if you set it in quaternion or axis angle it will lit only on 180°. Add a material to the led, a simple diffuse one, it will be modified later.
Then you switch to 3D cursor pivot mode and you snap the cursor to the center of your knob.
The idea is to duplicate linked the led, then rotate to a determined amount around the 3D cursor, then add a custom property or as I have done here, use the pass index in the object tab and increment it for each duplicata.
I am not a great coder, you will find the script (poor one) I did in the blend file.

import bpy
from math import radians

# range covered (in degrees)
rangecovering = 270

# number of leds
leds = 20

##############################"
# step calculated
steprad = radians(rangecovering/leds)

#the override comes from http://blender.stackexchange.com/questions/6969/rotate-object-around-cursor-with-python

def get_override(area_type, region_type):
    for area in bpy.context.screen.areas:
        if area.type == area_type:
            for region in area.regions:
                if region.type == region_type:
                    override = {'area': area, 'region': region}
                    return override
    #error message if the area or region wasn't found
    raise RuntimeError("Wasn't able to find", region_type," in area ", area_type,
                        "\n Make sure it's open while executing script.")

#we need to override the context of our operator
override = get_override( 'VIEW_3D', 'WINDOW' )

for N in range(0,leds) :

    # do a duplicate link
    bpy.ops.object.duplicate_move_linked(OBJECT_OT_duplicate={"linked":True, "mode":'TRANSLATION'}, TRANSFORM_OT_translate={"value":(0, 0, 0)})

    # rotation of the duplicate
    bpy.ops.transform.rotate(override, value=steprad, axis=(-0, -0, -1), constraint_axis=(False, False, False), constraint_orientation='GLOBAL')

    # change pass index obj
    bpy.context.object.pass_index = N+1

You just have to change the range in degree, the number of leds you want, and it will create the strip with the correct number of leds around the 3D cursor. If you want to change the shape of the leds (in edit mode), you can and they will be all modified at the same time as they are linked duplicate. You can also modify the mesh data of one led and link the object data to the others quickly.

Then you create a material with a value driven by the rotation of the knob

When you create the driver, use the name var in Scripted Expression, and local z axis in order to rotate the whole thing using the empty without breaking the driver.

I chose to keep the default driver curve and to manage the values directly in the material, so you have a few parameters to adjust to make it work there : range of strip leds, and number of leds as in the script.

If you want to rotate the knob, use the empty so that you will be able to center it at your taste.

If you use the same led material for the knob, and you put an indexpass = 0 it will light up at the same time than the first led.


Perfectly snaping and aligning two objects by face center using the least possible steps?

Here's one way (to get the ball rolling) :).

Poke faces on the target face (to get a center)
Enable Vertex snapping > Median and Allow rotation (to snap origin point)
Flip the mesh upside down (since Blender keeps the Z orientation)


How do I overlay a photo of a face over a character on a video?

Track the element over which you want to overlay the image.

With the tracker selected got to the Solve tab and in the Geometry dropdown, click on Link Empty to Track.

That will create an empty that is parented to the camera and moves with the movement of the tracked element.

Add the picture of you want to overlay one using Import Images as Planes

Parent it to the empty: select the plane with the image and then while pressing Shift select also the empty and press Ctrl P.

Now your image will move with the empty.

You might want to enable the video clip as background image at this point to see the have a reference of the movement.

For elements that change size or perspective you create a Plane Track tracking four points of the video. The instructions on how to do that are here:

http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.69/Motion_Tracker

and an excellent tutorial by Sebastian König here

When you are done adding all the elements you want, you can render the scene using a node setup like this where you add your scene to the background video.

I'm just going to deal with the tracking part. The texturing should be a different post since it is a different question, and there is enough information  here and here on how to pull that off.


How to export Alembic Mesh Sequence Cache to FBX?

Humm. If we take into account that alembic is a cache format, similar to a dmm or pc2, what should be done is to export the first frame as .obj, and then create a dmm / pc2 of that sequence. I do not know if it works well ... The fact is that alembic separates the different meshes, so you must make a "key shape" for each component, not as a cache. This you can see if in the timeline, each frame is marked, which does not happen with alembic. That's where things go ... (I'm not very expert in Blender, but that will generate a considerable size in Mb ..) Besides, each software company has "its peculiarities" when it comes to interpreting a FBX.


How to copy F-Curve Modifier(s) from one object to multiple objects in Blender 2.8x

If you're still wondering about this, here is a way that can speed things up hopefully.

Copy the modifier, select all the other objects and filter to show the curves you want to paste to, then select all the curves and hit paste. Now make sure the "Only Active" option is deselected and you're done.


Painting with predefined materials in 2.79?

Here I am using a black image and painting white into it using a brush mask set to rake and random, and that is plugged into the mix factor of the mix shader between a Principled shader and a diffuse shader.

The diffuse is a brown to represent the rust and the principled is only slightly metallic for the outside paint/metal layer. The bump node helps sell the difference between the two shaders, and if you go about painting a color image for the rust and a color for the paint, you can get some really nice effects.

I made some brushes that are on Blendswap for this actual process. To simplify it, you can use the same process but run the texture into a color mix node, using the mix factor to determine the difference between the two color inputs (images) and plug that into a single shader, still using a bump node into the vector of the shader.