On the ones with all the mushroom clouds, it looks like you need more resolution in your smoke domain. This will allow it to use a lot more detail.

(Also, this won't change the look, but to make it calculate faster, you can enable Smoke Adaptive Domain in the domain settings.)


PitchiPoy Rigify missing finger controls

It's easy enough to switch.

First you need to select the Pitchiboy metarig and go into Pose mode. Select the root of the finger (3rd from the tip) and go to the Bone properties view. Under the Rigify Type view it shows that the bone is set to create a "pitchiboy.simple_tentacle".

Click the Rig type field and select "finger". You need to do this to each finger you want to change.

Now when you generate the rig, you'll have the default finger controls. The Rigify system is pretty flexible, allowing you to mish and mash rig controls any way you need.


What is happening is the blur node is using the render result size to determine the blur. What you need to do is set the render size to the same size as the footage:

Once this setting is set it should render correctly.


My textures are rendering transparent and strange

I deleted all of the nodes, and simplified it. Use Alpha over instead of Add.


I would use a different colored smoke for each smell. You could use a mist effect and change the atmosphere color as you get closer to a smell, or you could use something like in this question How to create volumetric/smoke material in blender game engine?.


Blender - solve this shading difference?

Those look like two entirely separate objects with geometry overlapping. There is no way to fix non-continuous shading between different objects except for overly-elaborate normal maps. If they're part of the same object, hover over one mesh and press L in edit mode. If only whichever part of the body you've hovered over lights up orange (it's then selected), that means you can't fix it until all of the vertex points where the meshes intersect are joined, at which point you'll be able to smooth the normals.


Error in exported animation position/size. (Blender to Unreal)

By checking the option circled in pink in the image below, I solved the position and size problem:

Only thing to report is that the parent bone was distorted, as if it had been lengthened:

But I didn't notice any difference in the animation.


Is it possible to add a loop cut and slide like this

I see that you have a triangular face there.

Just make it quadratic and the edge loop would work.


How to I get light to not affect the rest of the scene

This is - as far as i know - not really possible at the moment. The feature is called "light linking" https://developer.blender.org/T68915

In Eevee you could try to work with light -> custom distance

Or work with layers, meaning to seperate your renders per object/ fore-/background and combining them again in the compositor.


Does Blender have an equivalent of Rhino's Curvature Graph?

https://gist.github.com/10eb529d7de33a70aa1c3febcf609127
please, copy link and try to import this in sverchok


Exporting a shape made with modifier:boolean-difference

You need to apply the modifier first. Then you will have 1 shape. To do so you can either click Apply on the right in the Properties Tab or if you want to use python you can use bpy.ops.object.modifier_apply(apply_as='DATA', modifier='newTray'). But you need the object having the modifier selected for it to work. tray.select = True should do the trick. After that you'll still have to delete the object you subtracted from the other one (in your case trayCutout). To use python it's bpy.ops.object.delete(). Again, for it to work you need to select it first: trayCutout.select = True and deselect the other one tray.select = False.

So we have (if you want to delete trayCutout, otherwise you'll have to leave the last three lines out):

tray.select = True
bpy.ops.object.modifier_apply(apply_as='DATA', modifier='newTray')
trayCutout.select = True
tray.select = False
bpy.ops.object.delete()


How can I do glowing halo particles/special effects in Cycles?

I was working on this clock anyway... Now it glows.

I moved the clocks “Bells” to layer 4 (It could be any other layer than the layer the clock mesh is on. In my case layer 1). I gave the bells mesh a material with “Emission”.

Then in the “Render Layers” panel I added a render layer and selected layer 4 and named it “Glow”. Although you don’t need to rename it.

Here's the node set up in the Compositor.


Pixelated render output, what am I doing wrong?

From what I see and understand from your description, you are seeing something pretty common when using the Cycles renderer: Noise. (The bright pixels are sometimes referred to as "fireflies")

There are several ways of reducing this effect:
1) Try a higher sample count in the "render" setting

2) Use one of the denoise options, for example this one:

3) Switch to Eevee Render Engine:


How to make lamp visible to camera in cycles?

As others have said, Cycles doesn't do that, but you can work around it with proxy objects that are only visible to the camera.  Create a small sphere, parented to the lamp, with a node setup like this:

This will make the sphere directly visible to the camera, but it won't affect your scene in any other way.

This works nicely for point lamps.  Other lamp types could be a bit more involved, depending on the look you're going for, but the same principle holds.

Sun lamps are especially tricky because the proxy needs to be handled in the world shader setup, and can't be parented to the lamp.  Set up your world shader nodes like this:

You can replace the sky texture here with whatever you want the rest of the sky to look like.

You can see from the purple highlighted elements that I'm using drivers to effectively parent to the sun, and to mimic its actual size.  You don't necessarily need to do that, but it's handy.  Full details would be out of scope for this post, since you didn't specify sun lamps, but the setup is available on Blend Swap if you're interested.


Why does ambient occlusion make a black area above emission object?

You're using the image as a factor, so that heavily white area is getting AO applied to it with massive influence.  Use a viewer node to look at the output of your AO node.


If you have no animation or want all particles to show at all times tick the options Unborn and Died in the Properties Window > Partices > Render panel

This will make it so that particles are visible at all times, before being emitted, and after dying or spending their life cycle.


How to get data and edit it on UV map edges?

Make a "UV" bmesh

Given the mesh object above with UV, make a bmesh from the uv's

loop faces
loop face loops add a vert to new bmesh at uv.x, uv.y, 0
create a face from verts
remove doubles
(optionally) dissolve non boundary edges
(optionally) remove faces.
added an integer layer to both verts and faces with the index of the orignal verts and faces.

Test script, run in object mode

import bpy
import bmesh

context = bpy.context
ob = context.object
me = ob.data
bm = bmesh.new()
bm.from_mesh(me)
uvbm = bmesh.new()

uv_layer = bm.loops.layers.uv.verify()
vert_index = uvbm.verts.layers.int.new("index")
face_index = uvbm.faces.layers.int.new("index")
# adjust uv coordinates
for face in bm.faces:
    fverts = []
    for loop in face.loops:
        uv = loop[uv_layer].uv
        v = uvbm.verts.new((uv.x, uv.y, 0))
        v[vert_index] = loop.vert.index
        fverts.append(v)
    f = bmesh.ops.contextual_create(uvbm, geom=fverts)["faces"].pop()
    f[face_index] = face.index

# remove doubles

bmesh.ops.remove_doubles(uvbm, verts=uvbm.verts, dist=1e-7)

'''

# ignore face indices of original if using any option here
# optionally disolve non boundary edges

bmesh.ops.dissolve_edges(uvbm,
        edges=[e for e in uvbm.edges if not e.is_boundary],
        )

# optionally remove faces

faces = uvbm.faces[:]
while faces:
    uvbm.faces.remove(faces.pop())
'''
#make an object to see it
me = bpy.data.meshes.new("UVEdgeMesh")
uvbm.to_mesh(me)
ob = bpy.data.objects.new("UVEdgeMesh", me)
bpy.context.collection.objects.link(ob)
ob.show_wire = True

# make a LUT based on verts of original
from collections import defaultdict

edge_pairs = defaultdict(list)
boundary_edges = [e for e in uvbm.edges if e.is_boundary]

for e in boundary_edges:
    key = tuple(sorted(v[vert_index] for v in e.verts))
    edge_pairs[key].append(e)

# print result, add text object to show matching edges

uvbm.verts.ensure_lookup_table()
for key, edges in edge_pairs.items():

    print(key, [e.index for e in edges])

    for e in edges:
        if not e.is_boundary:
            continue
        f = e.link_faces[0]
        p = (e.verts[0].co + e.verts[1].co) / 2
        p += (f.calc_center_median() - p) / 4
        bpy.ops.object.text_add(radius=0.04, location=p)
        bpy.context.object.data.body = f"{key}"

Creates a bmesh, here it is converted to a mesh

The xy coordinates of the "UV" bmesh are UV coordinates.  The only edges are uv boundary edges.  Convert to pixel coordinates using the data.

Uses the method here to associate  verts with  original using the method here https://blender.stackexchange.com/a/70729/15543 to store the indices of original verts / edges in a data layer of "UV" bmesh.

Output on example above.  First row, the two edges that are made from vertices 0 and 1 from original mesh are edges 0 and 14 in "UV" bmesh.

(0, 1) [0, 14]
(0, 2) [1, 17]
(2, 3) [2, 4]
(1, 3) [3, 22]
(2, 6) [5, 16]
(6, 7) [6, 8]
(3, 7) [7, 23]
(4, 6) [9, 19]
(4, 5) [10, 12]
(5, 7) [11, 20]
(0, 4) [13, 18]
(1, 5) [15, 21]

EDIT: To visualize this further, added a text object to each face from each edge. Eg see where the edge made of vertices (i, j) is matched on two faces.   Each text object is located inset one quarter of the way from edge centre to face centre.

Alternatively could have simply printed original vert indices at verts

Remember the uvbmesh is in UV coordinates mapped in the real number range [0, 1] in U and V.  The pixel coordinates is simply mapping this into discrete integer range based on image dimension.


How to save an image without antialiasing in cycles?

In 2.67 and 2.68a (I haven't checked 2.69+), the amount of AA present in the cycles render is controlled by the size of the Gaussian sample on the film.

The gaussian for the film is the amount of jitter that rays leaving the camera receive. If this is high, the pixel effectively samples a little circle of incoming light in the scene, and you get anti-aliasing. If this is small, then all the rays are almost the same, and you are sampling one single point on the film.

So to reduce or remove anti-aliasing in Cycles, turn down the Gaussian width in the Film section of the Render settings. Turning it to 0 will reset it to its minimum (currently 0.01 on my version, the default is 1.50), and rendering will give essentially a non AA image.

If you just want to avoid an aliased outline, then this isn't the right setting, do it in the compositor as per PeterT's answer.


Make sure you have the object that you keyframed, selected. By default the graph editor only shows keyframs from the selected object(s).

Or if you need to work on it with the object deselected, you can show all object's keyframes in the graph editor by disabling the Show Only Selected as part of the View controls in the header.


How to separate environment in Compositor without black cutouts

I was just curious :)
Because render View Layers doubles rendering if I'm right.

You can use existing setup, just ...

add Set Alpha node and plug inverted Alpha to create transparency in BG
and use InPaint node to recreate missing environment

Note:
because of alpha antialiased edge, I added Delete/Erode node with value -1 to get rid of one pixel that did InPaint node job slightly darker


Blender Python Console Commands not completing before next one is interpreted?

Ditch the operators and use the API

Example script, rotates object 90 degrees about z axis. Inserts all keyframes of active keying set at frame 30.  Not using any operators or changing the frame, simply set a property and call keyframe_insert.

import bpy
from mathutils import Matrix
from math import radians
context = bpy.context
ob = context.object
scene = context.scene
# emulate rotation op
R = Matrix.Rotation(radians(90), 4, 'Z') # rotate 90 about z axis
ob.matrix_world *= R

#emulate ops.anim.keyframe_insert
ks = scene.keying_sets.active
if ks:
    ks.refresh()
    for p in ks.paths:
        # check for entire array (index=-1)
        index = -1 if p.use_entire_array else p.array_index
        # insert keyframe
        ob.keyframe_insert(
                p.data_path,
                index=index,
                frame=30)

A method could be made using methods above that is passed the arguments object angle, axis and frame.

def rot_and_keyframe(ob, angle, axis, frame):
    ...

rot_and_keyframe(ob, radians(90), 'X', 30)
rot_and_keyframe(ob, radians(-90), 'Y', 60)


I personally prefer post processing dust,  for a still image you would normally just find some free dust particles online and add them in via the compositor. But as for animated particles, I would Google some free dust asset animation packs and add them in the compositor using an image sequence node.

If can't find any online, you can always make your own!

Build a cube and icosphere
Put icosphere on layer 2
Add a particle system to cube and

set emission from volume
change start and end values to 0
set it to emit the icosphere
disable emitter
mess with size and amount

add an emission shader to the icosphere
set the background to black
Set gravity to a really low value
Add a couple of weak turbulence forces to push the particles around
After you animate this, you will have generated your own image sequence that you can composite onto any animation

Side note: if you really want to get fancy, you can use a noise texture set to camera mapping to control the strength of the emission node shader, then animate the x and y values on the mapping node to animate light going thorough the dust.


First you need to put the curve origin at the point where you want the object animation to begin, so do it in Edit mode with some shiftS and shiftctrlaltC.
You also need to be sure, in Edit mode, that the curve normals go in the right direction. If it's not the case, press W > Switch Direction.
And at last, you have to keep in mind that the position of the object with the Follow Path constraint, relatively to the curve origin point, will be its position relatively to the center of the scene (i.e. Location). If the object is far from the scene center then, when you'll give it the constraint, it will jump as far from the curve origin as it's far from the scene center. If you press altG it will bring back the object to the 000 location, and therefore at the origin point of the curve.


How to change shape keys with the same name in different objects at the same time

Yes, you can do it without a rig, but those shape_keys are on different objects and shape_keys from different objects can not be mixed, only transferred if the objects have the same vertex count. Choice one, joining objects:
So considering the pure shape_key blend/mix way, the function is found right to the shape_key list when you click on the "v" button.
If you join the objects, i would suggest to rename the shape_keys to reflect which part they belong to (face, eyebrows) beforehand, as that combines the shape_keys from both objects in one list. That allows then to adjust all keys and you can set face_angry_left and eyebrow_angry_left (just an example for the names) to 1.0, after which you click on that mentioned "v" button and select "+ New Shape From Mix". That will create a new key with the effect of both previous set to 1 keys, means you get a shape_key adjusting both values at the same time.
In the picture you see the button mentioned and the functions.

Choice 2: Using a driver, which you can set up as a new shape_key on your head for example or a custom property value under your head. It does not really matter, as long as you have a value that you right click on, and choose "Copy As New Driver" function (see below, in second picture right click on any value really you get the second last option in the popup menu). After that you go in your eyebrows and select the shape_key for angry_left for example and right click over the value to then select the "Paste Driver" function. That will color the value purple and connects the previously used value (New Driver) to the now colored value. You can do the same with the face where you select the angry_left value of the shape_keys and right click once again to also "Paste Driver" here. Well, you now have both objects essentially remotecontrolled with the "New Driver", only problem with this solution is that you can't change the values separately anymore. To work around that you could copy the shape_keys before pasting the driver on them, but if you ask me, i would consider to consider choice 1.
To not leave it out, copying a shape_key goes by setting only the value of the to be copied key to 1 and then click on the "v" button and use the "+ New Shape From Mix" function, generating a clone.


Clone Stamp affecting opposite side of model?

User Moonboots Had the (rather simple) answer, I had some flipped normals affecting where the clone tool was cloning!


Can only select one metaball any others are only conneteced to the first

Meta-objects, like many other objects, have an edit mode. In edit mode you can create more meta-objects that are part of the first, and will be transformed all together when they are transformed in object mode.

Meta-objects will still stick together regardless of the whether they have been created in object or edit mode


How do I make a pure white plane that receives shadows?

There is multiple way,but I see you dont want complex node trees so I will tell you the easiest one.

Add a plane and make the following material:

It basically say that the plane the actual material is diffuse but the camera see it as a white color.
Now we have a pure white color.

Render tour image with :

Shadow pass.
AO pass.
Object index pass.

Now we come to the post production,we multiply your shadows and AO to the image but we have to make sure we are applying only on the plane.

So we do as follow:

While The mask is the object.


Curve fill is clipping from Illustrator SVG export

The answer ended up being that I needed to change the "decimal" input to a value of 1 in the SVG export options in Illustrator.


Cannot see scene strip over video in VSE

The quick fix is to set the Trim duration (hard) start = 1083 on the strip for the 3D.

The root of the problem is that by default an action strip pulls its data from the start of the animation.  You animated your text timed to line up with the start of the action strip, not the beginning of the scene.

The current Best Practice is to keep your VSE and your 3D separate.  The VSE scene should only have action strips and no 3D objects.  You can create a separate scene for the 3d animation that has no VSE strips in it.  Then the VSE scene has strips that refer to the separate 3D scene.

If you're not in a hurry, you can duplicate the scene using the + button at the top and choose Link Objects.  This action does not actually copy all the VSE strips, but it does copy all the 3D objects, so you can use it for the source of the action strip.


You might start by reading through the Templates available.

TextEditor -> Python -> BMesh Simple Edit Mode.

The following snippet is a small modification of the template, but is by no means a particularly efficient way to find the faces within a certain radius of a given coordinate. Merely to illustrate one step, here the coordinate i'm searching around is the active face.

# This example assumes we have a mesh object in edit-mode

import bpy
import bmesh
# from mathutils import Vector

# Get the active mesh
obj = bpy.context.edit_object
me = obj.data

# Get a BMesh representation
bm = bmesh.from_edit_mesh(me)

# this is a coordinate like Vector((0,0,0))
active_median = bm.faces.active.calc_center_median()

# Modify the BMesh, can do anything here...
for f in bm.faces:
    f.select = False
    if (f.calc_center_median()-active_median).length <= 3:
        f.select = True

# Show the updates in the viewport
# and recalculate n-gon tessellation.
bmesh.update_edit_mesh(me, True)

here I hardcoded the 'epicenter' of the search sphere using the median location of the active face, but you could change that to the location of the 3d cursor. (if the object's origin isn't at (0,0,0) or has unapplied Transforms you will also need to take the object's Transform matrix into account )

A great module for spatial searches is KDTree , and it has adequate examples on the API page.


You need to be aware that Blender, when changing such custom properties, internally runs an undo step, and then re-executes the script. The trouble with your script is that you define the content of the variable cube right in the __main__ area of your script. This means it is only run once when the script registers. When the undo->redo happens, this can get lost. In fact, when I just copy-paste your code into a new file, run the script, run the operator and toggle the property, the pasted script disappears (pasting it is also undone in the undo step).

To fix it, get the cube while executing. It could also make sense to get it in the invoke() function, but let's keep it simple for now. So try this modified script instead:

import bpy
from bpy.props import BoolProperty

class HelloError(bpy.types.Operator):
    bl_idname = "object.hello_error"
    bl_label = "HelloError"
    bl_options={'REGISTER','UNDO'}

    my_property= BoolProperty(name="my_property", default=True)
    def execute(self, context):
        print("--------------------------------")
        if self.my_property:
            print("do something......")

        # get desired object within execute() function instead!!
        # also, retrieve it from the current scene objects,
        # this ensures it exists within the scene and can be set active
        cube = context.scene.objects.get("Cube")

        #set the active object as a existed cube
        context.scene.objects.active =cube
        print("objects:", context.scene.objects)
        print("cur_active:", context.scene.objects.active.name)
        return {'FINISHED'}

def register():
    bpy.utils.register_class(HelloError)

def unregister():
    bpy.utils.unregister_class(HelloError)

if __name__ == "__main__":
    register()

I've done a few other style modifications to it, namely using the context variable that is passed into the execute() method instead of constantly grabbing it from bpy.context, and using context.blend_data instead of bpy.data (a call which I removed later on, see next paragraph).

Finally, batFINGER pointed out in a comment that it is recommended to pull the cube object from context.scene.objects instead of context.blend_data.objects, as this will make sure the cube is already linked to the scene, and later on can be set as active object. Using the get() method, the variable will be set to None if there is no object named Cube, instead of throwing an error immediately. You could later on use a sanity check like:

        if not cube:
            return{'CANCELLED'}


How to assign PointerProperty in Operator through UI?

Aafter continuing researching, apparently operators can only take basic properties (e.g. string, bool, int, float), and PointerProperties only work if they’re stored within at the scene level (e.g. bpy.types.Scene) or inside a PropertyGroup.

So, short answer, it doesn't seem possible at this point (2.81a).

Anyways, my current workaround is making an EnumProperty on the panel that switches between the different instances of layers. Since the enum is stored at the scene level, all my operators can reference it freely and easily. It’s not as contained as I’d like, but it works.


Why do curves get thinner at 90° angles?

If you are beveling a curve in Blender, currently it will happen with the 3D mode because of the algorithm. You have to switch to 2D mode to solve that:


You need to get the space you want to change. If you run it from the Text Editor or Python Console, context will point to the Text Editor's or Python Console's spaces. You can loop through all areas and their spaces and change all the ones of type VIEW_3D:

import bpy

for area in bpy.context.screen.areas:
    if area.type == 'VIEW_3D':
        for space in area.spaces:
            if space.type == 'VIEW_3D':
                space.shading.type = 'MATERIAL'

Or if you write an operator and execute it when the mouse is over the 3d viewport you should be able to get the current space from the context:

import bpy

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        context.space_data.shading.type = "MATERIAL"
        return {'FINISHED'}

def register():
    bpy.utils.register_class(SimpleOperator)

def unregister():
    bpy.utils.unregister_class(SimpleOperator)

if __name__ == "__main__":
    register()

    # test call
#    bpy.ops.object.simple_operator()


Controlling a text object through python. Hooking it to an internal variable

When trying to execute your code, I get the error:

KX_GameObject, key "x" does not exist

Replace all your T['x'] with another objects property such as:

T.localPosition.x

If this isn't the property you want, you can search the objects fields with:

print(dir(T))

You have to parse/cast the int to a string with the python str() method.
The last line compiles fine as:

if T.localPosition.x  == 3:
    T.text = str(T.localPosition.x)


Simple bmesh script to create z grid from list of lists..

From what I can see assume: The data is n lists of m members, which can be layed out in an (n - 1) x (m - 1) grid.

Simple test script, paste into blank text, and "run script". Note made no effort to scale this, can be done after running from dimensions / scale properties.

import bpy
import bmesh
from mathutils import Vector
context = bpy.context
me = bpy.data.meshes.new("Surface")
bm = bmesh.new()

# rows x cols list of lists.
data = [[1, 2, 3, 3],
        [0, 1, 2, 3],
        [0, 0, 1, 2],
        [0, 0, 0, 1]]

rows = len(data)
cols = len(data[0])
# make a grid for easy skinning
bmesh.ops.create_grid(bm,
        x_segments = cols,
        y_segments = rows)
# assign list coords to grid.
bm.verts.ensure_lookup_table()
for row in range(rows):
    i = row * rows
    for col in range(cols):
        index = i + col
        vert = bm.verts[index]
        vert.co = Vector((row, col, data[row][col]))
bm.to_mesh(me)
# add an object to the scene.
ob = bpy.data.objects.new("Surface", me)
scene = context.scene
scene.objects.link(ob)
scene.objects.active = ob


The blocky shadows are either caused by a low resolution shadow buffer or your object doesn't have enough geometry for the shadow to disperse and appear smooth.

Go to the lamp and under Shadow, increase the size value of the lamp. While you are there, try tweaking the other setting as well to get even better results (hover over the tooltips to see what they do). If not, try subdividing the model a bit, notice the shadow the heads casts on the flat chair shape behind is smooth.
Size: 128

Size: 1024


Rigging character, mesh not following bones

It looks like your ears are very dense and make the parenting fail, so you should simplify them. More genarally your whole mesh is way too dense, especially ears, eyes and hands. You should avoid that, high-poly meshes make any edit and animation very tedious, and if you use a Subdivision Surface modifier it makes it even more useless. So rework your mesh before parenting.
Also you have 2 Subdivision Surface modifiers, keep one only, give it a level of 2 but disable it until you have a good mesh.
And don't forget to apply the scale of the armature and mesh.


How do i make an object visible behind a specific object?

Here is how to do it with render layers and compositor :

Set Suzanne, Eyebrows, and hair on 3 different layers.

Create 3 render layers with these different objects on them (here a single example, just do the same for the others) :

Then you do to the compositor, press "use node", and set up the following nodes :

Also, don't forget to set the film transparency :

Then, select all the involved layers, and render your scene.


I'm assuming you sent the real texture.

Your texture is a png in a particular case: it is an index image.

The index image has a short Color Table, only 256 colors.

You have a pink gradient using a too limited number of colors.

I'm sending an image showing the problem when I changed the Color Table. Note the stripes are only affecting the pink colors.

To solve it, use the original file in RGB mode.

You cannot use the index file to conver to RGB, because you cannot bring back the colors you lost when you converted it to Index Mode.

Extra info:

This particular case was caused by converting from Illustrator to PNG.
Illustrator does not render gradients properly when exported.
It's a good practice using a raster-based program to make gradients.


How to extrude an SVG on a cylinder but not have it solid

There is no need to convert the curve to mesh.
Start with the curve you imported.

Extrusion can be done in the curve's geometry section. To add some thickness use some bevel as well

Create a lattice object, make it so the resolution on the w axis is only one segment.

Use the lattice modifier on the curve, and have the lattice be the deforming object.

and then shrinkwrap the lattice to the cylinder.


To see the keyframes in the Graph editor select the object that has the keyframes.

To make a loop:

Press N to access the modifiers tab int he Graph editor. Then create a cycle.

That will create a loop for the keyframes automatically.

If you want to interrupt the cycle or make it start at a particular frame, play with the values for the Before and Ater.

A different way to do the same is using the Channel Extrapolation mode and set it to cycle.


you can animated the value of Exposure if you want to brighten all the scene


Extrude equally along faces, not normals

Apply the scale, before you extrude.
In object mode press ⌃ Ctrl + A while the desired object is selected and than click on scale.


Welcome to Blender Stack Exchange!

I believe Python is the easiest way to achieve what you are looking for.

If I understand you correctly, you only need to switch the value once, not back and forth, which is quite easy to do. Simply write these two lines in the text editor and save it somewhere:

import bge
bge.constraints.setGravity(0, 0, 9.8)

Note that by default, gravity is set to negative 9.8, so positive 9.8 is actually inverted.

Then, go to whatever object you want, for example the player if you have one, and add a Keyboard sensor connected to a python controller. Choose the script you just wrote, and you should be good to go.

EDIT: While the code above will invert gravity, it can't switch it back. This will explain how to make gravity switchable as many times as you like.

This is my initial setup. As far as I am aware, Python is the only way to mess around with the value of Gravity, so that's what we'll use. Make a new text file in the text editor and call it whatever you want. Since it's python code, you can end it with .py to indicate that, but it's not necessary.

In the logic editor I added two sensors connected to a python controller. The script will only have access to the sensors and actuators connected to the python controller. Then I selected the script (which is currently blank) in the menu there.

On the always controller, enable the 3 raised dots icon. This will run the script every time the game updates (I think it's 60 times per second by default). For the keyboard sensor, make sure you know what it's named.  I called it "switch" since when that key is pressed gravity will switch directions. The reason the name is important is we'll have to reference this sensor by name later on. Also enable Tap, as this will prevent weird behavior when holding the button.

I also set the cube to be a rigid body, so that it would obey gravity and we can see whats going on.

Here's the script that we can now use to invert the gravity. Note that to work the keyboard sensor needs to be called "switch", or you have to change the name in line 4 to the name of your sensor. Either works just fine. Anything with a # symbol in front is a comment, and is only there to explain what's going on.

#Tell Python to get access to all the BGE commands that are built into Blender
import bge
#Tell Python to access the controller that is running the script.
cont = bge.logic.getCurrentController()

#Tell Python to look for a connected sensor named "switch"
switch = cont.sensors["switch"]

#If the "switch" sensor is activated, run the code after the colon.
if switch.positive:
    #Tell Python to get the current gravity values.
    grav = bge.logic.getCurrentScene().gravity
    #Tell Python to set the gravity to the same values that it just got
    #but make the z axis the negative of whatever it was.
    bge.constraints.setGravity(grav[0], grav[1], -grav[2])

You can stop here, but I explained how the script works a bit so you can figure out how to change gravity further in the future if you like.

This script waits for the space bar to be pressed. When the space bar is pressed, the bge.logic.getCurrentScene().gravity gets the current gravity values on all axes and stores it in the grav variable as an array. An array is simply a list. It would look something like this:

[0, 0, -9.8]

This means gravity will not move things on the x or y axes, but will on the z axis. Since we assigned this to a variable, whenever we now use this variable, it uses the array that we assigned to it instead.

Now all we have to do is set the gravity, but invert the z axis value. The bge.constraint.setGravity() lets us do this. We just need to tell it what values to use. We can tell python to use a value from a certain place in an array by giving it the array, then the index (the first number is at position 0).

We can plug these into the command above. grav[0] is the x value of gravity (0), grav[1] is the y value (also 0), and grav[2] is the z value (-9.8). Since we want to flip the gravity, we just tell Python to set the gravity to the opposite of what it currently is.


How can you make a texture not being affected by blender lights?

If you're using Cycles then I would go for Emission shader with IsCameraRay linked to it Strength. This will make it act as shadeless flat material that doesn't receive shadows and doesnt emit lighting.


In actual anatomy, the humerus (upper arm) would naturally rotate about 60-90 degrees, and the remaining 90-120 degrees would be performed at the distal end of the radius/ulna (essentially the wrist). To model this in a blender armature, I would rotate the upper arm bone ~70 degrees, and the forearm bone ~110 degrees.

Of course, this may introduce problems with skinning. You may want to break your upper and lower arms into 2 or 3 sub-bones each, with constraints that keep them from doing anything other than an axial rotation with respect to each other. Then you can weight paint the surrounding mesh in a gradual fashion so the mesh smoothly rotates just like in reality.


The glass shader by itself won't let light pass through it the way you want.
You need to modify the material by adding some transparency controlled with a light path node.

For more detail please read: How to illuminate the darkness inside glass objects in Cycles?

The volumetric light you can do just by adding some volume scattering to the world.

click on the image to enlarge


In the 3D View properties region N key, to the right of the screen, you ticked the option Only Render (visible in your screenshot).

This makes only visible objects with actual renderable geometry visible in the viewport. The camera object, being an abstraction of a virtual object not visible in a final image, becomes hidden away.


Non-manifold mesh

The issue is caused by subdividing a non-manifold mesh. Here's a pic showing some of the possible situations:

Source: autodesk's maya guide

Your geometry fall in the first case, the "T" shape. With this kind of ambiguous edgeflow, the subdivision surface modifier can brings to unespected results for the user.

You have a bunch of interior faces in coorrispondence with the artifacts:

You should get rid of them to achieve the expected result. As there are just two, I'll suggest to select them manually in edit mode while in wireframe view and delete them (X).


After hours of research and trial I managed to get colors right. According to this topic on blender dev tracker blender renders video with BT601 conversion in YUV colorspace. That's why I had correct colors with RGB colorspace codecs (avi raw, FFmpeg codec #1 and png) and wrong colors with codecs using YUV colorspace (h264,vp9). BT601 conversion is used on SD videos, while BT709 is used on HD videos (my video has 4k resolution). So I figured a workaround:

Render video in blender in any lossless format that uses RGB color space (like AVI RAW, FFmpeg codec #1, png).
Use FFmpeg CLI to compress the raw video with any other codec, like h264 or vp9 using following parametr -vf colormatrix=bt601:bt709.

Here is an example of covertion from raw avi to webm with color conversion correction:

ffmpeg -i input.avi -c:v libvpx-vp9 -lossless 1 -vf colormatrix=bt601:bt709 output.webm

As you can see below, colors are almost identical (input on left, output on right). Output has slightly brighter color, but you won't notice it unless you are on really good IPS monitor.


Make sure to leave some space (a few pixels at least) between your UV pieces. Then turn on bleed in texture paint mode and when you bake things, so your texture extends beyond the boundaries of your model's UV coordinates. Doing both these things will avoid interpolation issues at the seams. There may be more issues in your case, but this is the first thing I would do to get rid of the seams.

*Bleed for texture painting is located in the Tool shelf > Options > Project Paint > Bleed. Increase the value to say 8.
For baking, the same thing is called Margin. But again, for either of these to be effective, you must first add some space between your UV pieces.


Instance of my rocket and original model both displaying in render

If you mask an object from the viewport, it will relly mask it only from the viewport.

In order to mask it from the render, open the Filter menu in the outliner, then enable the camera icon.

This way in the outliner, you will be able to toggle the visibility of any object from the render:


What do new bpy class naming conventions in Blender 2.80 actually mean?

It seems bl_idname of operators is an exception to this new convention

Looking through Python scripts that come with Blender 2.80 I can see that the convention is followed in bl_idname and class name as described with:

headers( _HT_ )
menus( _MT_ )
panels ( _PT_ )
UI lists ( _UL_ )

but not with operators since that is not possible. Operators sometimes follow this convention in their class names, but never in bl_idname, where they follow the usual categorization with the dot, like bl_idname = "object.randomize_transform".

That was the confusing part to me since OBJECT_OT_fancy_tool was given as an example without clarification and it would definitely not work as a bl_idname for an operator.


Blender with Python - Freestyle Linesets

It is an API design bug that the collection of line sets does not have a .new() and .remove() method.
I will address this problem as soon as possible, preferably in the next Blender 2.71 release.


Keep in mind, that if your hook object is animated, you need to place it in rest/initial position before attaching new vertices (for example switch to frame, where hook is located originaly). Otherwise they could behave incorrectly.

Once did it, enter Edit mode (TAB) and Hook modifier will provide additional options. Select button will show vertices that are already used for hooking. With those selected you should just select new vertices and click Assign. Done.


How can I separate a single object file into multiple objects based on closed geometry?

You could use Separate P (in Edit Mode) and select By loose parts.

The reverse operation would be Join Ctrl-J (in Object Mode) this would require all objects selected that you need to join to a single object.

In a script you could select the object by name and invoke the operator:

import bpy
object = bpy.data.objects['ObjectsName']
object.select = True
bpy.ops.mesh.separate(type='LOOSE')

After this you could set an individual origin to each separated object.

This can be accessed from the toolbar or from the menu:

Object -> Transform -> Origin to Geometry

To set the origin in a script you can select all objects and run:

bpy.ops.object.origin_set(type='GEOMETRY_ORIGIN', center='MEDIAN')


How to know which object is using a material

The outliner is a great place to find things. Entering a string in search field located in the header not only finds items containing the string but highlights them for easy access. The search menu also offers choices for case sensitive and complete matches.

Many things can be found in the outliner - from objects and meshes to materials, textures, modifiers, vertex groups, constraints, bones and actions.

While image names used by blender internal textures can be searched, currently images used in nodes (internal or cycles) can't.


All objects are just black lines in 3D view?

You are looking at the "Bounding Box" shading mode.

Simply press Z twice and it will return back to the normal "Solid" shaded view.
Or you could just click on the Viewport Shading button in the 3D view's header, and then choose "Solid".


You can drag your cursor to both slider to get the correct aspect ratio:


How to animate textures / how to read animation clips at an offset

First of all you can bake your animation of the baked sound f-curve, so that it becomes editable.

Then you can use that f-curve value to modify any other value using drivers.

In my example the Y loc of the bone is driving the Y mapping of the texture, so the checker is moving up and down (on Y axis) following the music.

Check also the "stepped interpolation" f-curve modifier, to simplify the sound curve and have more punchy movements.


Combining denoise node with other nodes in compositor?

Instead of using Render Layers' Image output, use the output of Denoise Image in the add node. Remember, the denoised output substitutes for the standard render layer output.


Weird red dotted rectangle appearing in blender, how do I delete it?

You tapped on CTRL+B.
Try tapping CTRL+ALT+B to clear the region.
Preferences > Keymap > 3d View:

For more info see Borders


There is no "out of the box"-solution for this right now in Blender.

However, you could use some Python scripting to export the cuts. Don't forget, that depending on your Frame distribution (IBP-Frames) and GOP you might not be able to cut frame-precise with Avidemux.

There are some related questions where you can get some help of how to access the frame ranges:

How can I drive the Switch nodes True/False value?
Why is "Copy Data Path" path different from the tooltip's path?
How to replace an orphaned external file by an existing one? (all instances)
How to snap the right edge of a strip to the playhead instead of the left in video editor


W cycles the mode of the 'Select' tool (the topmost icon in the toolshelf). Available modes are Select Box, Select Circle, Select Lasso, Tweak. In your screenshot you can see that it's set to 'Select Circle' as you can also see the 'Radius' setting that lets you control how large the selection region is.
Simply press W again until you get back to 'Select Box' mode.


In your properties panel, it looks like its a cube, not a plane. I can also tell because in your UV, there are more than 2 faces. There's actually 6.
To fix it, just edit your UVs. It won't take long at all. Or you can completely restart your UV job if you wish. I recommend doing so with one of the following methods.
Regular Unwrapping
Go into edit mode, sleect the faces you want to be in your UV, and hit U and then click on unwrap. You can edit the UVs further from the UV editor, as I am sure you are aware.
Project From View
If you don't already know how to project from view, I suggest reading up on it as it is quite useful and I use it a lot. In your case, it should get the job done instantly.


Select your armature, shift select the mesh, switch to Weight Paint mode, select the arm bones, you'll see that the hand is part of the vertex group that they are supposed to control, which should not be the case:

To correct that, you can either do it with a brush (set to Subtract), or in Edit mode, select the hand vertices, remove them from all groups, and reassign to the hand group only:


How to make particles emit from certain parts of a 3D object?

Use Vertex Groups.

In edit mode
Use Vertex Groups in the Particle System Settings ... Sub Panel Vertex Groups.

In [edit mode] a vertex group was created
The same group was used in the Particles System Panel ...  Density.
Quick Tutorial https://www.youtube.com/watch?v=yzRS2cCiBnc


Since Blender 2.81 the transformation can be limited to affect only the parents. The setting can be found in the header of the 3D View inside the drop down labelled Options. Once activated you can move, rotate and scale the parent object without affecting its children.


Moving an f-curve from an object to a bone

Yes you can. The workflow would be:

Append the action;
Switch to Dope Sheet Editor (shortcut is ShiftF12), then change Editor Mode to Action Editor;
Select the appended action from the dropdown list in the header, select keys you want, then CtrlC (or click the second last button at the right-end of the header);
Select the target bone in Pose Mode, add necessary channels by keying if there isn't any yet. Make sure the cursor is at the expected position, select channels you want to add action on, then CtrlV to paste (or click the last button at the right-end of the header). You can also do this step in Graph Editor.

PS:

The action can be transformed between objects and bones, as long as they got same channel types. However, the result may be not always as expected as you really want.
One thing that you should be aware of is the consistency of the rotation mode. For example, if the action for the appended action uses rotation mode as XYZ Euler, and the bone uses Quaternion (WXYZ), then it will fail, either.


How to interpret output position values of Geometry node

You're turning a vector into a float. So float=(v[0]+v[1]+v[2])/3.

this will give the correct result:

shader Inspector(float xcomp=0, float ycomp=0, float zcomp=0, output color debug=0)
{
  debug = (xcomp+ycomp+zcomp)/3;
  printf("\n");
  printf("%f,%f,%f >> %f" , xcomp, ycomp, zcomp, debug);
}

Use the SeparateXYZ and connect each components to the script.


When a render dies on Freestyle, it's usually a RAM issue. Freestyle takes a LOT of RAM (significantly more than Cycles for the same scene.) Once it runs out of your regular RAM, it will go into pagefile/virtual memory. This will slow your computer down to a crawl, because it's using your hard drive as memory. If it also runs out of pagefile space, it will crash. This is likely your issue.

The work around, if you were to attempt to still use freestyle, is to cut the scene down into more layers. Technically you can increase pagefile to give it more to work with, but even with a solid state drive this will be so slow as to be pointless.


How can faces be rotated around their individual normals?

You need to press a key to specify the axis. (i.e. X, Y or Z)

Setting the Transform orientation aligns the XYZ coordinates to something, e.g.:

Global aligns the axes to the world
Local aligns the axes to the selected object(s) rotation
Normal aligns the axes to the selected element(s) normal

etc.

Note that pressing the axis key once always snaps to the Global orientation, regardless of the setting in 3D view > Header. To use the orientation specified in 3D view > Header, press the axis key twice. (e.g. GZZ)

With your settings, (Individual origins, Normal, Face) to rotate each face around its normal we should rotate around the Z, see the wiki:

  The z-axis of the manipulator will match the normal vector of the selected [element]

So by pressing RZZ:


How To Divide A Mesh Into Circular Pattern with Perfect Squares

Just to illustrate @Alex's comment. You can simply subdivide the inner edges.

Select the inner edges
Go Edge > Subdivide
Adjust to your liking


This can be done by selecting the bottom two vertices, pressing O, and moving them in the desired direction (be sure to put it on the Sharp falloff type and make the radius large enough using Scroll):

Although you can do this, I would recommend making the switch as if it was in between the two states, so it is symmetrical. You can then easily rotate it.

Start by forming the switch profile. Add a circle with 12 vertices, and in edit mode select all and press S-Y-2, then press Enter to finish. Now select all except the bottom vertices and delete them.

Now you can extrude downwards using E, Z. When scale the new vertices to zero along the zed axis by pressing S-Z-0. Now scale along the Y axis as desired (S-Y).

Now extrude the outline to the desired width using E.

Now you can delete half of the vertices.

And add a Mirror Modifier:

Make sure you select the right Axis, either X, Y or Z. In this case it is Y.

Now any changes you make to the one half are exactly mirrored to the other half. Also, this piece can be rotated easily to animate the switch if ever necessary.

Things you might want to consider:

Bevel modifier/Sub-Division modifier
Re-calculate Normals (Edit mode Ctrl+N)

This should get you a good base mesh to work with, from which you can add specific details.


Automatic Weights Different on one side than the other

This seems to related to the fact that you have multiple disconnected parts (meshes) inside a mesh object. It always gives Blender trouble to auto-weight multiple-part meshes.

Two solutions, as far as I can see it:

Separate each sub-object within the object (Edit mode - Select - Ctrl+P - By loose parts).  Then apply automating weighted-painted solution to each part separately. (Of course, before doing that, delete the armature modifier, weight painting, and the existing vertex groups on the original mesh)
Even easier - if your mesh is 100% symmetrical, simply delete half of it, apply the weight painting, THEN mirror. The mirror side will have the exact same w.p. as the other one. Of course, it will still retain the potential w.p. errors due to disconnected meshes, but at least both sides will be identical.


Blender has a very flexible workflow, and you can do things in virtually any order and get away with it without too much extra work. I don't think it is industry standard to sculpt twice, but that should not stop you from doing it if you have to.

This really does not matter, you can either bake the normals first or rig the model. None depends on the other.
I don't really see the need for sculpting again after a pose. The only reason I could imagine (assuming you are talking about character modeling here) going back to bake a new normal map is if you modeled in a stiff T-pose and then decide you need some more details in areas that were stretched in the unrigged model. It would thus make sense to sculpt over those areas again after the pose is changed.
Shape keys can be used to animate the shape of a model in addition to bones. These would surely be made by the sculptor. Again, in blender the order of doing the rig and adding shape keys is irrelevant. You just need a retopoed model to work with.

Hope that helped!


Duplicate along path with uniform spacing

There are generally three possibilities to cause such problem in this particular case:

The resolution of the curve path, which is the least possible factor here;
It seems that you are using Dupliface, it will also be curved by the Curve modifier see Figure 1;
The edge of per panel should better coincide with the joint, in order to minimize the disjoint look. See Figure 2.

I think the most accurate way is to use rigid body constraints, but that would be way too complicated comparing to this way. Hope it helps.


This looks like camera clipping, but that's adjusted, so is it something else?

The issue is indeed with the camera clip point, but you are moving the settings for the wrong camera!

You have several cameras in your scene, but only one of them can be the active camera. In your particular scene the active one called "camera".

You are moving the clip setting for camera.001, which is not the active one...

Set the clip settings for the Active Camera and everything will be fine!


Like @stphnl329 says apply the scale of all particle objects, then go to the render settings of your particle system. For some reason the default scale is  0.05, change that to 1


How to remove a keyboard shortcut for sculp mode?

Go to File→User Preferences→Input→3D View→Object Non-Modal and delete the key for sculpting by pressing the 'x' beside it.


is it possible to keep the texture attached to my project?

To make sure that all the images you use are part of your blend file you can go into the File menu > External Data > Automatically Pack Into .Blend. If you don't want to make it automatic but just want to pack the current images, choose Pack All Into .Blend.

If you want to do it for just one or several images, you can go in the UV Editor or Image Editor, select the image you want, and Image menu > Pack.


Ctrl+Shift+B, subdivides bevel instead of smoothing bevel. How do I smooth it?

I'll present you method based purely on quad topology.

It's a little bit manual work, but nothing is worth more then nice quad base topology.

Make sure you have enabled F2 addon in User Preferences as it will speed up last step. You certainly don't need it. It will be just easier.

Delete 3 bottom vertices.
Add a Circle and set Vertices to 8/12/16/20/24... and so on. Just to have straight horizontal vertices along Circle. I have used 16 in this example.
Scale it down approximately between existing shape then scale it up with Vertex Snap and hover closest vertex. I've done it holding CTRL while scaling.
Remove top part of the Circle.
W > Remove Doubles to "merge" Circle with existing shape.
Select 2 vertices on one chosen side right before empty face, move mouse cursor to the other side and hold F (F2 addon).

I have two other methods on my mind but this seems to be the cleanest one so far.


bone.transform() also didn't work very well for me, so I used a method I found in a blenderartists post to extract the roll and tail from a matrix:

def vec_roll_to_mat3(vec, roll):
    target = Vector((0, 0.1, 0))
    nor = vec.normalized()
    axis = target.cross(nor)
    if axis.dot(axis) > 0.0000000001: # this seems to be the problem for some bones, no idea how to fix
        axis.normalize()
        theta = target.angle(nor)
        bMatrix = Matrix.Rotation(theta, 3, axis)
    else:
        updown = 1 if target.dot(nor) > 0 else -1
        bMatrix = Matrix.Scale(updown, 3)

        # C code:
        #bMatrix[0][0]=updown; bMatrix[1][0]=0.0;    bMatrix[2][0]=0.0;
        #bMatrix[0][1]=0.0;    bMatrix[1][1]=updown; bMatrix[2][1]=0.0;
        #bMatrix[0][2]=0.0;    bMatrix[1][2]=0.0;    bMatrix[2][2]=1.0;
        bMatrix[2][2] = 1.0

    rMatrix = Matrix.Rotation(roll, 3, nor)
    mat = rMatrix * bMatrix
    return mat

def mat3_to_vec_roll(mat):
    vec = mat.col[1]
    vecmat = vec_roll_to_mat3(mat.col[1], 0)
    vecmatinv = vecmat.inverted()
    rollmat = vecmatinv * mat
    roll = math.atan2(rollmat[0][2], rollmat[2][2])
    return vec, roll

Then, to set it:

tail, roll = mat3_to_vec_roll(matrix)
bone.head = matrix.to_translation()
bone.tail = tail*boneLength + bone.head
bone.roll = roll


What do various property highlight color overlays mean?

Button colors reflect their respective property situation in relation to animation state.

Grey/Theme Colored - Unchanged, non animated value
Green - Property is animated but not keyframed at the current frame (notice the diamond outline decorator to the right)
Yellow - Property is animated and keyframed at the current frame (notice the filled diamond decorator to the right)
Orange - Value is changed but doesn't currently match the evaluated/keyframed animation for this frame. This happens when you changed the property but haven't yet keyframed the new value, it will jump back to the keyframed/evaluated value stored in the file if a new keyframed is not inserted, leading to potential data loss. The stronger orange color should warn the user of its unsaved state.
Blue - Property is overridden. This is only for libraries, or linked data from other external blend files. It means the value differs from the predefined default stored in the remote library, and has a new locally set data override (notice the overridden arrow decorator to the right).
Purple - Property has a Driver, an expression or simple math function that automatically controls its value according to input calculated from other properties/objects (notice the driven arrow decorator to the right).
Red - Error state (used more frequently in modifiers or constrains). The property either has an invalid value, is disabled or producing no visible effect. In the example below a Subdivision modifier has zero subdivisions both for viewport and rendered output and is thus effectively disabled for all intents and purposes. Despite no harmful errors occurring its name is shown red warning of its currently ineffective output.

Have in mind that all these colors are editable though, so while most themes try to stay close to these defaults, nothing stops them from using something completely different.


How do you change opacity of grease pencil strokes in blender 2.8?

Okay I guess I am going to answer my own question. Because grease pencil is its own object now the color palette is no longer there, each grease pencil object will have its own material. If you want to lower the opacity you have to go Materials and under stroke click on color and lower the alpha channel. As for making new layers, you can just make new keyframes.

Edited: I was mistaken there is another way to decrease the opacity, if you click on the grease pencil icon on the left side of the material tab you can also see the old layer opacity.


Some examples of shape key sculpting vs lattice?

Shape keys and lattice are 2 completely different things in my opinion, generally you should think about shape keys (or bones) when you want to animate small details of your mesh, and Lattice (or Mesh Deform or Surface Deform modifiers) when you want to deform the whole mesh or a large part of your mesh.
Also, lattice is particular as it deforms only the part of the mesh that it contains, here is the kind of thing that you can do with Lattice that you couldn't do with shapekeys or Mesh Deform or Surface Deform:

Here is what it would give to have a boolean object that is latticed:


Setting blender context for uv editing issue

Running this script from the cli, I can unwrap an object in the background (no gui window).
I think the key point is setting the active object not just selecting it. I also create a uvmap layer if one doesn't exist and use mode_set rather that editmode_toggle.
import bpy

# Deselect all
bpy.ops.object.select_all(action='DESELECT')

for obj in bpy.context.scene.objects:
    if obj.type == 'MESH':
        obj.select_set(state=True)
        bpy.context.view_layer.objects.active = obj
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.select_all(action='SELECT')
        if len(obj.data.uv_layers) == 0:
            obj.data.uv_layers.new()
        bpy.ops.uv.smart_project()
        bpy.ops.object.mode_set(mode='OBJECT')
        bpy.ops.wm.save_mainfile()

I saved it as uvproject.py and used the cli command
blender -b test.blend -P uvproject.py


The trouble with this is that you need light to "bend" in a continuous arc around the black hole.
The reason why this bending is problematic is that cycles assumes light always travels in straight lines. Light does travel only in straight lines, but it can be bent by gravity.
Gravity is a distortion of spacetime around objects. The more massive the object, the more distortion.
So light is always going straight (from it's point of view), but to us it appears to bend as it follows the "straight lines" of distorted space.
Normally these distortions are very small, even with such big and massive objects like the sun. However with such a ridiculously massive object as a black hole, this effect can be quite extreme.
I don't know of any render engines which take into account such corner-case complications like the bending of spacetime near gravitational bodies :P
This is why a special render engine had to be written to render the effects in Interstellar.

TL;DR:  Light is bent around black holes the same way the paths of planets around the sun are bent. Cycles doesn't have any support for simulating this kind of phenomenon.
So, how can we render it with cycles anyway?
In cycles the only way we can "bend" light is via refraction, which occurs when light exits one medium and/or enters another. It should be noted that refraction a completely different phenomenon from gravitational lensing.
This is really the same problem as Is it possible to change the IOR inside a volume?.
can only bend light at a surface, via the refraction shader.
We need to make light bend continuously, sort of as if it's in a medium with a changing IOR. However we can only change it's direction at a surface.
To visualize the difference, take this example image.

The inner circle represents the event horizon, from which no light can escape (i.e. the black part).

The outer circle represents the approximate distance at which the bending of light becomes noticeable. In the version on the left this circle represents a refracting sphere as described by Nightshade.

The lines represent the paths of light rays as they travel near the black hole.

Note: While thinking of how to set up some kind of material or effect, it's often useful to think of the scene in the same way that the render engine does. Cycles is a backwards path tracer, meaning it traces rays from the camera out into the scene. So try thinking of these rays in the same way.
See How is Cycles different from Blender Internal? for more info on the workings of cycles.

Example is only a rough hand made visualization, not accurate.
As you can see, rays which hit the refracting sphere are bent all at once at a single point, then continue going straight. It's more like a "direction change" than a curve.
One way to get around this problem is to use a lot of refracting surfaces (black lines) which change the direction the ray (yellow line) a little bit at a time, resulting in an approximation of a smooth curve:

To procedurally create such an object:

Create a single edge.

Add a plane (⇧ ShiftA > Mesh > Plane), then switch to edit mode (↹ Tab), rotate it 90° around the X axis (RX90), and scale it to 0 on the Z (SZ0). Remove doubles by pressing W> Remove Doubles(R).

In object mode (↹ Tab), add an empty (⇧ ShiftA> Empty) and rotate it a small amount around the Z (I rotated mine by -2°).

Add an Array modifier to the line object:

The number for the array modifier Count can be determined like this:
360 / absolute_value(empty_rotation) / 4 + 1
Which gives 46 when empty_rotation = 3.
To add more surfaces and increase the accuracy (and rendertimes!) of the approximation, rotate the empty less and adjust the array count accordingly.

Add a Screw modifier:

It should look like a strange sort of half-sphere.

Add the hole itself by adding a sphere at the center of the front most surface of the half-sphere (⇧ ShiftA> Sphere):

For the material, give it a diffuse shader set to black. This will totally absorb any light which hits it, so zero light will be reflected off of it, making it completely black.

Add a material to the half-sphere.

I've used a spherical gradient texture to control the IOR in order to make light bend more when closer to the center, and less when farther from the center.
This is a very approximate and artistic approach, not very accurate by any means.
If the scale of your object is (1,1,1), the Scale of the mapping node should be set to the diameter of the half-sphere object in BU. This way the gradient texture just fades to black before the edge of the half-sphere object:

To quickly preview nodes in a material, enable the Node Wrangler addon in User preferences > Add-ons, then ⎈ Ctrl⇧ Shift LMB on any node to quickly connect it to a "preview" emission shader.
In my case the diameter is 5 BU, as can be seen with Length enabled in 3D view > Properties region (N) > Mesh display while in edit mode:

The Map Range node is a node-group which I created based on the implementation in the compositor:

The To Max and To Min values can be adjusted to control the maximum and minimum amounts of refraction. Setting To Max to a higher value will result in more distortion.
Remember to set the color of the refraction node to pure white, so light doesn't get absorbed while bending through the refraction object.

As each ray will have to go through many surfaces, make sure the maximum bounces is set high enough in Render settings > Light paths.

You may want to disable the effects of the refraction object on other objects, as they won't be correct. Light is only bent the way we want it when it enters through the front (thinking in terms of backwards tracing). If a ray bounces off another object and then hits the refraction object from the side, it won't bend anywhere near how it should.

Of course, it's not any more correct to just disable it, but this should help with rendertimes a bit if there are lots of other objects in your scene.

See the manual for more detail on ray types.

Make the black hole always face the camera.

Now our light bending setup is almost complete, but for it to work properly it must rotate so only the front is visible to the camera.
To do this, add another empty (⇧ ShiftA> Empty > Sphere) and parent the refraction object, array empty, and diffuse sphere to it with ⎈ CtrlP:

Add a Copy Rotation constraint to the empty, with your camera object as the target. You may need to enable Offset and rotate the empty in order to get the flat side of the half-sphere face the camera:

If you're wondering why we're not using a Track To constraint, see Planes rotating to face the camera, but only along one axis
Result:

Note that this only covers the lensing part of the black hole. I'll leave the high-energy matter and the accretion disk to you, as I wouldn't want to take all the fun away ;)


I found a workaround:
Open the ply model im MeshLab.

Go to Filters->Textures->Convert PerVertex UV into PerWedges UV
(it may say it is missing the texture. If it does, copy the texture file into the
MeshLab program directory. May be a bug or I am too stupid :P )
Then go to Filters->Texture->Transfer: Texture to Vertex Color....
The standard values were enough for me.
Afterwards go to File->Export Mesh as... and export it as a *.ply. Make sure the vertex colors are checked in the following dialog and hit export.

In Blender import your freshly exported *.ply-file and change the view to "Vertex Paint". Et voila.


This is the method I've used to solve my issue, select the object you want to array, hit Shift + S to snap the 3D cursor to the selected object, create an empty on said object (make sure rotation and scale are ticked for an even and proportional array), select the object add the array modifier, untick relative offset instead use object offset using the empty just placed and apply how many counts you need.
To evenly space the array I selected the empty hit R Y = 360/8, which divided 360 degrees into 8 parts (which was my array count) on the Y axis.
To make small adjustments I selected the object in edit mode and positioned it slightly as well as making minor adjustments to the empty.


Disclaimer: I'm not a graphic card expert. The following is from personal experience and what I've extrapolated partially from my own benchmarks and research. I actually do have a quadro 2000 card but I rarely use it and have never used it for Blender specifically. Please feel free to comment below if you disagree with any points and I may correct them.
This is all conjecture without actual benchmark results
Forget the Quadro. It's pretty pointless after the first year it's out. After that it gets obsolete and any newer GT or GTX is better. The main benefit of Quadro cards are the ECC which is fancy but not helpful. Another really good benefit of the Quadro is cuda cores but that doesn't always directly translate to better performance compared to newer consumer grade cards that support newer tech like Direct X 12. (note: Direct X is not yet supported in Blender. Open GL 4.4 is supported on both of these cards however and that is what Blender utilizes.
You'll be better off with more VRAM.
NVIDIA GeForce GT 730 4GB GDDR3 128 at $89.99 + Shipping.
You'll have to convert that to your currency.
It's definitely more worth it in the long run.
There's pros and cons to both but the GT 730 is better in the end.
The specific GT 730 I showed you has 96 Cuda cores. The Quadro 4000 has 192 Cuda cores
(unless someone wants to benchmark this for me I can't tell you for sure which card will be faster but my hunch says the newer GT 730 is going to be faster)
However, the GT 730 supports newer technology and higher resolutions.
Plus twice the VRAM.
The ram and higher resolutions will help a lot.

Check these out click on specifications and compare them.
http://www.nvidia.com/object/product-quadro-2000-us.html
and
https://www.nvidia.in/object/geforce-gt-730-in.html#pdpContent=2

EDIT: Originally I claimed and cited that Nvidia's Cuda core programming has higher support and faster speeds. However, I've been informed that as of Blender Version 2.79 OpenCL has made significant improvements. While OpenCL still is undergoing active development it appears to beat NVidia in the benchmarks, at least in tests comparing a midrange ~$200 graphics cards
As far as high end cards are concerned blenders official manual still recommends Nvidia. However, this may be subject to change in the future when more benchmarks are released and as the OpenCL code improves.


Mesh At Knee Does Not Bend With IK Rigging

The bones can effect only the vertices position, it looks like your leg has only 4+4 vertices. Try subdividing it (in three different ways):

Add a subsurf modifier (upper in the modifier stack than the armature modifier)
Using the loop ring tool (shortcut Ctrl+R)
Selecting the mesh in edit mode then hitting W> Subdivide

Search the internet for typical mesh geometry for a good deforming leg and copy the topology.


How to merge vertices without disfiguring mesh?

There are a couple ways you can solve problems like this. To fix those verts that are breaking the curvature of your mesh, here's what I would do:

Set the pivot point to 3D cursor, and move your 3D cursor to the center of your teacup.
Duplicate one of the vertices that is part of the same edge loop as the distorted vertex.
Turn on snap, making sure that it's set to Vertex, Active, and Rotation is enabled.
Rotate the duplicated vertices while snapping to one of the other vertices in line with where the distorted vertex should be.
Snap the distorted vertex to your new vertex.
Select everything and remove duplicate vertices.

You can basically use the same technique to patch gaps in this kind of radial geometry. Duplicate geometry that matches the hole you need to plug, and rotate it into place using vertex snap. I deselect and reselect a vertex here to make it the active vertex, and use that to help guide my snapped rotation about the z-axis.


Animation Nodes : Use Previous output of a Loop in calculation of the next iteration

You can do this by using 'reassign'.

This is an option accessible from the 'loop subprogram' and which allow to obtain a node from which you can reassign an input parameter from some calculated result inside the subprogram.

Select the subprogram.
Go into the properties on the right, in the node tab, then click 'reassign' for the input you want.
That generates a reassign node, place it in the grid.

Now you can connect its input from the calculation you want (here probably the loop result).


What's the difference between camera mapping and UV unwrapping?

Regular uv-unwrapping:

Camera mapping:

Camera mapping is basically a type of uv-unwrapping.
In general you use regular uv-unwrapping if you want to apply a texture directly to a face, and camera mapping if you want to apply an image taken from the perspective of the (viewport) camera to an entire mesh.


The next background image is not updated when I press on the button to go to the next frame

Not sure how many images are in your folder but you selected to just show 2 of them. Try bump up the number and see if it works. Your file did not have any images so could only test with my own samples but it works as advertised...


Unknown option removing background In render

There are a couple of different problems with your scene that are causing black materials.

The ground for example is missing a shader. You have the image texture directly connected to the shader output, and there should be a shader in there, like a Diffuse, or Glossy or Toon.
The glass color is a bit dark, though that may be the look you are aiming for.
In the Light Path settings of the render panel you have all bounces set to zero, which will make most transparent or reflective materials return black

General tip, watch for the socket colors in the material node editor, under most circumstances connected socket colors should match (green with green, blue with blue, etc).


My Cloth Sim with Pressure is Acting very Unusually

i got a "good result" by changing this:

change back gravity on "F" to 1 and applied scale for your cloth object

change gravity speed z on world settings to 10

changed pressure to .1

then i tapped delete all bakes, and bake

got this:


I hope that this script may help you, just pick the curve that has the "guide" color and run the script.

import bpy
import mathutils

#set custom color

#color = mathutils.Color((1,0,0))

#or

#use active's object diffuse color

color = bpy.context.active_object.active_material.diffuse_color

for obj in bpy.data.objects:
    if obj.type == 'CURVE':
        curve = obj
        if curve.active_material.diffuse_color == color:
            curve.select = True
        else:
            curve.select = False

if (bpy.ops.object.join.poll()):
    bpy.ops.object.join()


.obj exportation is not working properly

Nvm I found the answer, it is pretty easy actually. You need to go to the "show overlays" tab (the 3'rd one)

Then press the drop-down and enable "Face Orientation"

After that, all of the faces should blue on the outside and red on the inside.
To inverse them u need to select the wrong ones and go to "Mesh" then "Normals" and "Flip".
(Or Alt+N and Flip)

Also, u can apply a solidify modifier so that u completely hide the red part.
Easy


If you are attempting to use simple "fake" displacement (basically bumpiness that is affected by lighting, but is not visible in silhouette), you've already got it working. If you are attempting to use "true" displacement from the displacement node in the material, this will not work in Evee. Use Cycles or the displacement modifier.

Also, even in Cycles, the results of true displacement from the material displacement node do not affect the mesh in edit mode view: it is computed at render time.


How to *efficiently* find all lights within a scene?

Put them in a collection
IMO the simplest way to do this is, as suggested
scene_lights = [ob for ob in scene.objects if ob.type == 'LIGHT']

One light object could have the same light data as any or all of the lights in a scene.  Even if there are few lights, checking that the data belongs to an object in the scene could prove less efficient than above.
If you feel that there are so many objects in the scene that iterating over them is inefficient, consider linking them to a collection(s) using name or ID property to tag the collection as being for light objects.
lightcol = bpy.data.collections.get("Lights")

if not lightcol:
    lightcol =  bpy.data.collections.new("Lights")
    scene.collection.children.link(lightcol) # or wherever
# populate it.
for lt in scene_lights:
    lightcol.objects.link(lt)

Could make collections within this collection to further categorize by light type
Polled PointerProperty
As mentioned by @brockmann can also consider using a polled pointer property, an example for materials
Custom search data to UILayout.prop_search
whereas in the case of lights the pointer property type would be bpy.types.Object, and the poll method would test against type. Could easily be extended to light type


TV titles: Split a list into text from a CSV document using Animation Nodes

Double Line

To make the text be formatted on two lines, you can replace the , with a line break special character as follows:

Different Sized lines

Blender doesn't allow various sizes for the same text object, what you need to do is separate each of the lines as follows:

Column Location

First, I would make a classifier loop that classify each column, For instance, I classified this text into names and titles.

Then we join names and titles using a line break (Or possibly make them different object if you want them to have different sizes), and then output the text to a text object as follows:


How do I change the UV Mapping algorithm, for example LSCM to Angle Based?

You can switch between Angle Based (ABF) and Conformal (LSCM) algorithm.
It's in the pop-up menu after you unwrap.
And if you want to dig deeper, here is a Blender DevSource page explaining both algorithms.


First apply rotation using ctrl + a then move your 3d cursor to right edge of the cabin and set the cabin's origin as the 3d cursor(object -> set origin -> origin to 3d cursor).Also move up your boolean modifier above the mirror modifier.


In node compositing, how do I delay a movie clip by any given number of seconds

In Movie Clip Editor open N-Panel, go to the bottom and find Footage Settings. Here you can control Start/Offset frame, these values can be animated.


Splitting an addon in modules vs having everything in one file?

It's better to split it into separate files. The reasons for this are:

Separation of concerns: It's easier to separate UI from state and logic when they are in separate files. Keeping everything in one file also results in low cohesion which is not desirable.
Maintainability: Keeping everything in a single file will likely result in tight coupling, which makes refactoring a lot harder.
Understandability The interaction between classes is difficult to grasp when everything is in a single file. Finding a function or class is challenging when you don't know exactly what it's named and with only a vague idea what it does. This is especially a concern if other developers try to contribute to your project or if you take a break then continue the development in couple a days/weeks/months/years. If for instance the functions for scatter distribution are in a separate file called scatter_distribution.py, then it's easy to find because you already know what's in the file based on its name.
Extensibility: Given that your add-on already reached approx. 7000 LoC, it's clear that new versions with additional features will increase the complexity further. This will impact the previous points negatively. If your code uses separate files you can easily extend it with another file for a specific set of features.
Reusability: Having separate files or modules allows to reuse code more easily in the development of future add-ons that require some of the features you've already implemented in the current add-on.

The add-on can be distributed as .zip which is the standard way of installing it through the preferences, therefore users don't have to deal with the individual files.

In conclusion there are plenty benefits of writing modular code. It may take more work at the beginning, however it can significantly reduce the effort of maintaining the software.

This answer is not a complete and definitive list of reasons, however it should highlight some of the most serious issues that occur when keeping the entire code in one file.


Click the faces which have that problem and subdivide those.
Or

Use a subdivision surface modifier(would increase the poly count


How do I merge 2 Grease Pencil vertices?

In edit mode, select the first stroke and select the vertex you want to join.
Shift select the second stroke and select the next vertex to join.
Use Stroke > Join (or the shortcut ⎈ Ctrl+J)

Note that you cannot connect vertices that are not on the edges of a stroke.


How do I get objects to follow another mesh?

You can parent your balls to a vertex or to some vertices of your plane: Select a ball, shift select the plane, go in Edit mode, select a vertex or some vertices and press CtrlP > Make Vertex Parent.


How big should i make my assets for a game

Well, that could be ok if the only thing you're going to do in your game is showing this tree alone... and some engines would probably break the same...
A basic character (human mesh + clothes) for vg is good at, lets' say, 15K polys on low-end mobile devices...
To keep a 4M model high quality you need to create a low poly model, then bake all the maps your game engine needs to use the low poly like an high poly, saving processing power in your game engine.

This is called baking and is better explained on Polycount here.
Blender-wise, you could try to use the AssetGen addon, for instance, to test the process...


The texture is just a small section of a piece of cloth, so the UV map of the cloth should be a lot larger than the image. In the UV Editor window on the left scale the shirt UV by pressing S and dragging the mouse, hit Return to set the scale.
It also looks like the orientation of the fabric is perpendicular to your UVs. Press R to rotate, enter "90" for rotating 90° and hit Return to set the rotation.
The JPEG file should be a tileable texture so that repetition is not so obvious.


I see that it is not something you can do in blender. I will have to use OpenCV feature recognition for such a purpose. Thanks for responses.


A sequence of 90-degree rotations with Python

To do this with matrix multiplication & globally.  As for the "wobbling" do  you mean the interpolation?

import bpy
from math import radians
from mathutils import Matrix

mat_rot_x = Matrix.Rotation(radians(90.0), 4, 'X')
mat_rot_mx = Matrix.Rotation(radians(-90.0), 4, 'X')
mat_rot_y = Matrix.Rotation(radians(90.0), 4, 'Y')

obj = bpy.data.objects["Sphere"]
obj.animation_data_clear()

obj.rotation_euler = [0, 0, 0]
bpy.context.scene.frame_set(1)
obj.keyframe_insert(data_path="rotation_euler", frame=1)

obj.matrix_world *= mat_rot_x
obj.rotation_euler = obj.matrix_world.to_euler()
obj.keyframe_insert(data_path="rotation_euler", frame=20)

obj.matrix_world *= mat_rot_y
obj.keyframe_insert(data_path="rotation_euler", frame=40)

obj.matrix_world *= mat_rot_mx
obj.rotation_euler = obj.matrix_world.to_euler()
obj.keyframe_insert(data_path="rotation_euler", frame=60)


Help I can't figure out why this won't unwrap correctly

There's a face within your mesh which shouldn't be there and the edges don't connect properly.


Problem with armature with automatic weight

If automatic weight doesn't work, you need to adjust the weight paint of the bones manually https://www.youtube.com/watch?v=l9S-jhBIEiU


Make sure the properties of light source is set properly and the light source is allowed to render in outliner


Rigged Shape Keys on Models With Mirror Modifier?

man, as far as I know you can't even apply the mirror modification, with shape keys ... what you can do is finish your model! then make the shape keys on one side and duplicate and use mirror shape keys.


I would use Proportional Editing with a linear falloff.  Proportional editing applies any transform you use to neighbouring vertices with some sort of interpolated falloff.

You can enable Proportional Editing by pressing O.  While transforming you can scroll the mouse wheel up and down to adjust the falloff distance.  You can change the falloff gradient in the footer of the 3D view, to the left of the snapping controls.


The icons can be hidden and shown with the "filter" dropdown.
@rjg linked to an answer to this effect. This question is a duplicate.


How to rotate collection instance with reference point

The first job is to get the origin of the Collection Instance in the right location and orientation with respect to its component objects.

When a Collection Instance is created, all its component objects retain their World Transforms, with respect to the collection's origin (represented by an Empty). While you can move the origin of a collection using the Header > Object > Set Origin menu, it's probably least confusing to keep the Collection origin at the world origin while assembling. You can hide the source collection, and still work with its instances.

Once that's done, you can align the instance as you would any other object. (You can search for various ways besides this to do that, here on BSE)

Here, the original collection is shown at the origin, as created. In this example..

A Custom Orientation was created from the sloping target face. (The '+' in the Orientation dropdown)
The 3D Cursor was snapped to the face (ShiftS)
The (wireframe) Instance was snapped to the cursor (ShiftS)
With the instance selected, and the Custom Orientation active, Header > Object > Transform menu, 'Align to Transform Orientation'

You can align multiple instances in one move.

The Instance's local axes are shown in the gizmo.


Assuming that you are using a release of Blender that is at least 2.77 or newer, then you can use the edit mode boolean tools and save a couple steps.

First select one element of the object in edit mode by linked geometry by
selecting a face, edge, or vertex, and then press L with
your mouse hovering over it.
Press Spacebar and type Boolean and select Mesh: Intersect (Boolean) from the menu, or press Enter when the
option appears in the menu.
Next, press F6 to bring up the options for the tool (or
go to the operator panel in the toolshelf) and change the mode to union.


Is it possible in Blender to create a animated png vertical strip?

Spritify add-on

Spritify is an add-on for making sprite sheets and even animated gifs. It has one external dependency: ImageMagick, a command-line tool for editing and creating images.


Adding Named Objects in Blender with Python API

When you use bpy.ops.object.add() the newly created object becomes the active object, so right after creating the object you can alter it's name with

bpy.context.active_object.name = 'new_name'

It is also possible to create objects without using operators. This approach will create the objects without altering the existing selection or active object.

import bpy

x = (1.1,2.2,3.3,4.4)
y = (1.1,2.2,3.3,4.4)
z = (1.1,2.2,3.3,4.4)

for index,val in enumerate(x):
    new_obj = bpy.data.objects.new('new_obj', None)
    new_obj.location = (x[index],y[index],z[index])
    bpy.context.scene.objects.link(new_obj)

Here 'new_obj' will be the name of the new object, if it is non-unique it will also get a numeric extension.


duplicate the video strip on a new channel, add the overlay effect to it and delete the unnecessary parts at the beginning.


When your importing .fbx files you have a scale option in the file folder just before you import it. Scaling that upward will increase the imports size. Fbx does not preserve object size, location, and rotation from the export. If you are looking to preserve and exact location, rotation, and scale of an object, you must import as an .obj.


How can I merge these two spherical objects into a single smooth mesh?

To simple ways, to help keep track of the UV mesh:

In edit mode in the 3D view press Shift+L to select an island of linked vertices. Then hide all other parts with Shift+H. Only the previously selected connected vertices are shown in both 3D and image editor.
When trying to identify meshparts in the uv / image editor, this button may help.

If your game engine is struggling, deleting additional vertices, which aren't shown anyways, can increase performance. (This also depends on the game engine.) Otherwise, leaving the mesh in whatever state is best maintainable. If joining them is the last step before exporting, I would suggest keeping your work blend file intact and doing mesh joining step separately.

If your performance is fine, hidden faces are no problem.

If you wanted to merge two spheres into a single object and remove the hidden vertices, do the following.

  Add a Boolean Modifier to one of the spheres.
  Set the other sphere under the Object in the Modifier Tab.
  Set the Operation to Union
  Apply the modifier.

  Delete the other sphere.

This will cause problem with smooth shading. (Triangles)

With spheres there is an easy fix. We can use the topological features of the spheres to get rid of topology problems. Do the following steps before the boolean operation.

  Select one of the spheres and add a Damped Track Modifier, with the other sphere as the Target.
  Do the same vice versa (with the other sphere).
  Set one of the Damped Track Contraints to To: Z and the other to To: -Z.

  Select both spheres and Apply Visual Transform (Ctrl+A > V). (Optional)

  You can now delete the constraints.

  Do the Boolean operation and delete the unused sphere as explained above.

  In edit mode, select all A then remove doubles W > R

Smooth shading now looks fine, add edge loops to sharpen the crease.

With different objects, you will have to use different approaches to get clean topology with boolean operations.


Is there a way to select the children of a parent object?

Method 1:
Select the parent object, then Shift G > Children.

Note : To keep the parent selected, immediately after calling the operator, press F9 or click on the foldout in the lower-left of the 3D viewport and check "Extend". This setting will be remembered the next time you call the operator, until you close Blender.

Or, if you want to select all children at the same level, you can first select one child, then choose Slibings in the same menu.

Method 2:
Go to Outliner,  Ctrl LMB on the parent object icon, which will select all children and itself, then Shift LMB on it again to deselect the parent.

Method 3:
First Select parent, then press ] to select object in the next level. Shift + ] one or more times will select more levels.


Compositor:
This can be done with the Flip Node within the compositor: Add> Distort> Flip.
The node should look like this:

Video-Sequence Editor:
This can be easliy don with the flip options in your Properties Panel N. The options should look like this:

For your other question I'm pretty sure you need to re-open your video, essentially your not editing the video but making a mask which can be accesed with the Mask Node so it doesn't really matter as long your using the same footage.


Both methods are provided by Blender API.
A way to list all installed localisation
>>> bpy.app.translations.locales
('en_US', 'es', 'ja_JP', 'sk_SK', 'vi_VN', 'zh_CN', 'ar_EG', 'de_DE', 'fr_FR', 'it_IT', 'ko_KR', 'pt_BR', 'pt_PT', 'ru_RU', 'uk_UA', 'zh_TW', 'ab', 'ca_AD', 'cs_CZ', 'eo', 'eu_EU', 'fa_IR', 'ha', 'he_IL', 'hi_IN', 'hr_HR', 'hu_HU', 'id_ID', 'ky_KG', 'nl_NL', 'pl_PL', 'sr_RS', 'sr_RS@latin', 'sv_SE', 'th_TH', 'tr_TR')

A way to check for the chosen localisation
>>> bpy.context.preferences.view.language
'de_DE'

>>> bpy.context.preferences.view.use_translate_interface
True

>>> bpy.context.preferences.view.use_translate_new_dataname
True

>>> bpy.context.preferences.view.use_translate_tooltips
True


How to render over the previous frame to create trails

The answer posted by Rich Sedman is the answer:
motion trail effect on video in VSE
Rather than doing this in the VSE you can create this effect using a feedback technique similar to How to do this type of trailing effects where the previous frame is held over to include in the current frame. The only real difference is in masking out the current frame so as to overwrite all but the background each time.
The setup of the scene is the same (ie, a camera pointing at the plane) with the following material on the plane :

material
Here the feedback is handled by the bottom branch - with the Image Texture pointing at the location of the render result, offset by 1 frame to pickup the previous frame. The top branch injects the video (filed infront of a black background) with the Subtract used to darken the image (this was used as a crude way to remove background artifacts since my video background wasn't perfect) with the Less Than used to detect the 'foreground' so that the feedback can be cut out wherever the new image is above a certain threshold. The images are combined and the Emission with a value less than 1 effects the fade out as the trail ages.
This produces the following result :


The outline you worry about just caused by setting Bake Margin to 16 px.

As said in manual for Render Baking:

Margin
Baked result is extended this many pixels beyond the border of each UV “island”, to soften seams in the texture.

This value should depend on margin of unwrapped UV map - not be more.


It is possible to check if a particle is within a face?

Using the particles location vector, and the closest_point_on_mesh method.  The particle location is  in global coords.  We can see this by moving the emitter in the UI, the particles remain in their world position and need to be re(bake)calculated.

As pointed out in https://blender.stackexchange.com/a/40979/15543 you need to put the location passed to closest_point_on_mesh into the objects local space, otherwise it will give unexpected results once the object's matrix_world is no longer the identity matrix.

The particle location is multiplied by the inverse matrix world of the emmitter object, to put it into that objects local coordinates.

I'm using a build of 2.76.4 and it appears closest_point_on_mesh has a new return value,

>>> C.object.closest_point_on_mesh((0,0,0))
(True, Vector((0.9999996423721313, -2.980232238769531e-07, 0.0)), Vector((1.0, 0.0, 3.2782557468635787e-07)), 2)

The first being success of operation, the others: location vector of closest point; normal vector; and face index.

The script below prints how many particles are closest to each face.

import bpy
context = bpy.context
obj = context.object

mwi = obj.matrix_world.inverted()

ps = obj.particle_systems.active
facelist = []
new_version = bpy.app.version == (2, 76, 4)

print("-" * 72)
print("Obj: %s Particle System: %s" % (obj.name, ps.name))
print("-" * 72)

for i, p in enumerate(ps.particles):
    v1 = p.location # global particle location
    localPos = mwi * v1  # particle in obj local space
    if new_version:
        (found, loc, norm, face_index) = obj.closest_point_on_mesh(localPos)
        if not found:
            continue
    else:
        (loc, norm, face_index) = obj.closest_point_on_mesh(localPos)

    facelist.append(face_index)

mesh = obj.data
for fi in set(facelist):
    vertstr = str([v for v in mesh.polygons[fi].vertices])
    print("face %d,  verts: %s particle count:%d" % (fi, vertstr, facelist.count(fi)))

Sample result default cube, default particle system

------------------------------------------------------------------------
Obj: Cube Particle System: ParticleSystem
------------------------------------------------------------------------
face 0,  verts: [0, 1, 2, 3] particle count:180
face 1,  verts: [4, 7, 6, 5] particle count:168
face 2,  verts: [0, 4, 5, 1] particle count:161
face 3,  verts: [1, 5, 6, 2] particle count:169
face 4,  verts: [2, 6, 7, 3] particle count:150
face 5,  verts: [4, 0, 3, 7] particle count:172


How do I batch render the render layers that I have set up?

You were right the first time; all renderlayers are rendered when you press F12. You can view them independently in the image viewer:

Typically the compositor is used to combine renderlayers into a final image.

To make the background transparent on one renderlayer and include the sky on another, you must use passes.

Only settings located in the renderlayer panel can actually be set independently per-renderlayer, so enabling Film > Transparent will make the background transparent in all renderlayers. To get the background, there are two approaches, both using the Environment pass:

Create a separate renderlayer that doesn't render any objects, but with the Environment pass enabled. Then alpha over the desired renderlayers using the compositor:

This is the simpler of the two, but it requires the slight overhead of rendering the sky separately (you can set the samples to 1 on just the sky renderlayer to mitigate this)
Mix the environment passes of all the other renderlayers to get a all the background/sky you need to cover the areas not obscured by objects in both other renderlayers:

Potentially slightly faster, but you're not guaranteed to get the entire sky.

Note that there are a lot of different "layer" settings surrounding renderlayers, which can be rather confusing. See my answer here for more detail.

I've written this answer from the perspective of cycles. For BI it's a little different.


I don't know of a way to do exactly that. For distorting a whole drawing there is the lattice modifier for grease pencil:  https://www.youtube.com/watch?v=tLZ6F9mQAdk


Actually just remove parenting of every object.


You can fix this by positioning the bone at the start of the path, where you want the object too start. I know, seems to simple, but that will fix it.