Create a race track on a landcape with banked corners

Duplicate the curve, then use the Follow Path constraint with Follow Curve Checked.

With the constraint, the banking is influence by the curves tilt. CtrlT in curve edit mode.


How do I get a constant Background Image?

Go to the file --> user preferences --> add ons --> type images --> import images as planes --> check the checkbox

Then you can go to file --> import --> images as planes. Or in the 3D view SHIFT + A --> mesh --> images as plane


mask not showing completely when rendering

I found a temporary solution but if somebody knows how to fix it definitely would be awesome.
I copied the splines of the frame 147, created a new mask and paste to render frame 148 and it works.
Once the mask is created go on the node compositer and change the name of the previos mask for the new one. As it is copied for the previous frame you may need to do minimal position changes.

It doesn't work by just changing the mask. It is necesary to unplug the mask node, change the name of the mask and then plug it again.

Save the rendered image as a PNG file, separated from the rest and add it later to the image sequence to create the video clip.


Is it possible to edit images programmatically with the Blender API?

Within blender's image class you can access the raw pixel data at image.pixels as an array of floats, 4 floats per pixel (RGBA). image.size[0] is the width in pixels image.size[1] for height.

This answer shows how to crop an image, while this one about performance might be useful.


Problems with vehicle weight painting - some blue parts

Select your car, enter edit mode, select all vertices belonging to the chassis, go to properties/vertex tab, select the appropriate vertex group, which has the same name of the controlling bone, click assign.

Then do the same for the wheel.


How to select all objects of a certain viewport draw type in blender 2.8?

Quick little script

The following script changes all objects in the context scene  displayed as bounds to wire.

import bpy
context = bpy.context
scene = context.scene
bounds = [o for o in scene.objects if o.display_type == 'BOUNDS']

for o in bounds:
    o.display_type = 'WIRE'

It is often more useful to use the selection, replace scene.objects with context.selected_objects to only change only those in selection that match the criteria.


How to specify number of subdivide sections in Blender 2.8x?

Sure thing.

Subdivision always splits 1 face into 4. No way around it.
But you can make uneven subdivision manually using Loop Cuts.


Use python.

from bpy import ops
from glob import glob
from os import chdir, path

directory = "C:\\Windows\\Fonts"

chdir(directory)
for file in glob("*.ttf") + glob("*.otf"):
    ops.font.open(filepath = path.join(directory, file), relative_path=False)

Replace the directory variable with the folder path, which contains your font files. Escape \ with \.

Paste the script in the text editor and press Run Script.


Blender Game Engine Particles and Force field?

As you already discovered there is no special "particle" object in the BGE.

You can use ordinary objects (typically mesh objects).

Emitter

As you want to get multiple copies of it, you place the original in an inactive layer.

Have one object (the emitter) in an active layer constantly add copies of the original (e.g. via edit object actuator). You can give the added objects an initial velocity when the original is a physics object (e.g. rigid body).

Alternative/variation

The particles copy the logic of the original too. So the particles can setup themselves e.g. they can play an animation or initiate a random motion.

Force field

Constantly find particle objects within the desired range (e.g. via a near sensors). To focus on particles you can filter the objects by a property (e.g. all particles have the property "particle").

Then you apply forces to all the found objects. You need to create a custom brick (python controller) to read the sensor and apply the according force/velocity/location change.

move_up (simple example)

import bge

sensor = bge.logic.getCurrentController().sensors["Near"]
for particle in sensor.hitObjectList:
    particle.applyForce((0,0,50))

Result

The sample result looks like that:

To pull the particles near the force field center you need to calculate the according forces to do that.


How can I get some of the metallic (gold) colors on a piece of paper?

You can just mix between two shaders. Turn your wings into a all black image to use as a mask as I have below.

EDIT:
This is a cleaner solution thanks to CEGATON:

These were the two images I used.


Would it be possible to create a new constraint "type" with python?

Currently we don't support Python constraints (though they were supported at one point in Blender 2.4x).


Can't use displacement modifier to create low poly water

The "new texture" is still on the defaults, which just aren't very interesting, yet. It just has too little noise to do anything on the displacement.

Click on the button all the way to the right of the texture's name in the displacement modifier. This will take you to the settings for this texture. You'll need to reduce the scale of the texture so that the portion mapped to the plane has some variation, instead of being mostly the same color.

EDIT: Or Zak might be right, there might just not be an actual texture associated with it, yet.


How to duplicate an Archimesh generated object in blender 2.8

You could select the empty in the outliner and right click on it and choose select hierarchy. In this example the separate objects are parented to the empty. This is done by dragging the object into the empty in the outliner and holding the shift key.

In the object window (not the outliner) press shift + d and a copy will be made


how to render emission of light of a transparent background

Note : this answer is obsolete due to the comments. I don't delete it as it still produces a result.

Use the compositor.

The setup can be like this :

On the left, the rendered input (here, all is black around, because the world has no material or light set to 0).

The color ramp is here to convert eventual colored parts of your scene to black and white.

Alpha over puts a transparency (the first image slot) over the rendered image, depending on the B&W chanel.


Grayed out object in the Scene Collection

Click this little Funnel icon in your browser to open the Filter setting,

see if this Icon is on or off. You probably set the light to be Invisible in the viewport, i.e. the Monitor Symbol, and then reset the filters to just show the icons for visibility, i.e. the Eye.


Init object every time file new is called

A persistent onload handler

Application handlers.

Code taken directly from Persistent Handler Example

import bpy
from bpy.app.handlers import persistent

@persistent
def load_handler(dummy):
    print("Load Handler:", bpy.data.filepath)

bpy.app.handlers.load_post.append(load_handler)

Other things to consider re comment for revert and new is look at

bpy.data.is_dirty

for toggle from True to False. Wont matter if  a clean file is reverted.


How to apply freestyle on only one mesh?

In the freestyle settings, check the "collection" option for selection by, then you can add your one object to a collection, and choose that collection in the settings menu below.


Baking Normals from a Shader that gets its Normals from a Bump Node

There really shouldn't be anything too it. A little checklist
-is the output/Bake texture in your active node?
-is your bake object selected and active?


Part of rigged mesh doesn't move with the rig

If some vertices are not influenced by the movement of the deformation bone probably the don't have enough weight assigned. In Object Mode select the bone first than the mesh, change to Weight Paint and add more weight to the vertices (blue is completly unbiased).


How does the Cloth Stiffness Scaling option work?

Cloth Stiffness Scaling

Q: How does Cloth Stiffness Scaling work?

A: Basically, you just (1) Create a Vector Group from the Plane, (2) Weight Paint each half of the Plane red/blue, (3) Then set the min&max values for Bending stiffness to 0.0001&1000.0. You can test it with a cloth falling over a collision sphere. The following post aims to elaborate on this explanation.

Feature Functionality

According to the Documentation for Blender 2.4, the Stiffness Scaling feature allows a vertex group to have a different bending/structural stiffness value for each vertex within the vertex group (as opposed to the same bending/structural stiffness value for each vertex). This requires working with "Vertex Groups" and "Weight Paint" features.

Blender 2.4 Docs:
http://wiki.blender.org/index.php/Doc:2.4/Reference/Panels/Object/Physics/Cloth#Stiffness_Scaling

Same Stiffness Values

The usual way to apply (bending/structural) stiffness values to a vertex group (or a plane mesh), is to apply a "Cloth" Modifier to a Plane Mesh (hopefully, well subdivided) via the "Modifiers > Add Modifier" Panel. Once the Cloth Modifier is applied to the Plane Mesh, then you can set the "Structural" and "Bending" stiffness values via the "Physics > Cloth" Panel. For example, you can set "Bending" to 0.0001 to be very silky, or you can set "Bending" to 1000.00 to be very leathery. Now all of the vertices within the Plane Mesh will have the same stiffness values.

Different Stiffness Values

Now, let's say that we want each of the vertices (of the Plane Mesh) to have a different structural/bending stiffness value. In this example, we want the left half of the cloth to have 1000.0 "Bending" stiffness and the right half of the cloth to have 0.0001 "Bending" stiffness (aka, leathery on the left and silky on the right). To do this, we will need to work with the "Vertex Groups", "Weight Paint", and "Cloth Stiffness Scaling" features.

First, we want to group all of the vertices from the Plane Mesh into a Vertex Group. To do this, we "add a new vertex group to the active object" via the "Data > Vertex Groups" panel (in this case, the active object should be the Plane Mesh). Once the new Vertex Group is created, it should have a default name of "Group". Feel free to re-name it to anything you want -- I will rename it to "Cloth_Group_001". Now, we've created our Vertex Group! Great Job!

Second, we need to Weight Paint the Vertex Group of the Plane Mesh (aka, "Cloth_Group_001"). Weight Paint controls can be accessed by changing "Object Mode" (or "Edit Mode") to "Weight Paint". Now, you will be controlling an interactive brush with a "Weight" between 0.000 to 1.000, a "Radius" between 1 to 200 pixels, and a "Strength" between 0.000 and 1.000. Paint the left half of the Plane Mesh to Red (aka, Weight=1.0), and paint the right half of the Plane Mesh to Blue (aka, Weight=0.0). ((I suggest using a Strength of 1.0, and choosing an Radius Size that is comfortable for you)). Now, you should see the left half colored Red and the right half colored Blue. You've just Weight Painted the vertices in your Vertex Group (of the Plane Mesh)! Great job!

Finally, we can go back to our "Physics > Cloth" and "Physics > Cloth Stiffness Scaling" panels. Using these Cloth panels, we are going to set the minimum value for "Stiffness Scaling" and we are going to set the maximum value for "Stiffness Scaling". We first need to enable "Cloth Stiffness Scaling" via "Physics > Cloth Stiffness Scaling" panel. Now that stiffness scaling is enabled, we want to set a minimum and maximum value for our "Bending" stiffness values for "Cloth_Group_001" (note: we can do the same thing for our "Structural" stiffness values, but this example will only demonstrate the min and max for "Bending" stiffness values). To set the maximum value for our "Bending" stiffness, we need to select "Cloth_Group_001" from the dropdown-menu under "Physics > Cloth Stiffness Scaling > Bending Stiffness:" and then set the max-value for the "Bending Stiffness" to be 1000.0 (you can set this to anything you want, we will use 1000.0 in this example). At this point, be sure that you did both: set the Vertex Group and set the Bending Stiffness "Max:". The last thing you need to do in this section is set the minimum value. To do this, we need go to the "Physics > Cloth" panel and set "Bending:" to 0.0001 (this will serve as the minimum bending value, whenever "Cloth Stiffness Scaling" is enabled --  which you already enabled earlier). You have now set the min and max values for the Vertex Group's Bending Stiffness (Remember that the Vertex Group of your Plane Mesh is re-named to "Cloth_Group_001" for this example). Great job!

To conclude, let's try to understand what we just did. We basically set the Red-Painted vertices to 1000.0 and the Blue-Painted to 0.0001. This is because 1000.0 (maximum) maps to the "Weight"=1.0 from the "Weight Paint" earlier; similarly, 0.0001 (minimum) maps to the "Weight"=0.0. Note that anything that is painted between Red or Blue (e.g., Green/Yellow/Orange) has a Weight in between 0.0 and 1.0; this means that Green/Yellow/Orange will have a Bending Stiffness between 0.0001 (minimum) and 1000.0 (maximum). In our case, we should only have the left half of the vertices painted Red and the right half of the vertices painted Blue; this means that the left half of the vertices have a Bending Stiffness of 1000.0 and the right half of the vertices have a Bending Stiffness of 0.0001.

That's it! Now you have each vertex with a different stiffness value.

(Note: If you want to change the stiffness for every single vertex in your cloth, just use a different Weight value for each vertex while "Weight Painting".)

Testing

You can take my word that this works, but I'm sure you're eager to see it work for yourself. I would add a Sphere under the Cloth, and add a Collision Modifier to it. Have the Cloth (aka, Plane Mesh) above the Sphere so that when you begin Simulating/Animating it will fall under the force of Gravity and drape the Sphere. Remember to have "Cloth Collision" enabled via the "Physics > Cloth Collision" panel (optional: feel free to enable "Self Collision" as well).

Now, you can press the "Play Animation" button (towards the bottom of the Blender UI) and see the results of the Cloth falling over a Sphere and draping it. You will notice two (2) things:

The right half of the cloth will want to hug/engulf/fit the sphere, since the right half of the Vertex Group is silkier ("Bending"=0.0001).
The left half of the cloth will want to try to "spring" back into a planar shape and definitely NOT hug/engulf/fit the sphere as tightly as the other half. (Aka, the cloth will be very stiff in this half; "Bending"=1000.0).

(Note: I've tested Cloth Stiffness Scaling with Blender 2.74, and it works perfectly.)

Conclusion

In conclusion, you will have a very stiff left half (due to the RED paint) and an extremely low stiffness on the right half (due to the BLUE paint).

Does this make sense? Any questions, comments, or feedback are welcome.

References

This link explains one user's struggle and eventual understanding of the Stiffness Scaling feature: https://developer.blender.org/T39371 . Feel free to open the "ClothStiffness2.blend" file referenced in the link, so that you can see a Blender Scene similar to the one example referred to above.


What you want to achieve is coupling, where two physics simulations interact with each other. Unfortunately, Blender does not support this and can only, like you have said, run the individual simulations. You could try this, but note that the results won't be accurate:

Run the cloth simulation, maybe with some settings that make it look like it is floating in water (lower gravity, more air resistance)
After baking the cloth simulation (this is important), give the cloth object fluid physics and set to effector.
Run the fluid simulation.

Though this may produce some realistic results, it will look fake after closer analysis. This is because the fluid reacts to the movement of the cloth, but the cloth does not react to the fluid. There are some simulation programs that do support these physics interactions, most notably Houdini FX. Unfortunately, nearly all of those softwares will cost money.


Use Python to Teleport Mouse in Blender Window (like when scaling)

Your operator should include the following in the bl_options:

GRAB_CURSOR to allow it to grab the mouse focus and
BLOCKING to prevent anything else from using the cursor

Like this:

bl_options = {'GRAB_CURSOR', 'BLOCKING'}

More info in the API documents.

As an example, you may see this in action in blender/2.79/scripts/addons/mesh_extra_tools.py


How can I align the 3D cursor to a face / polygon with python

So, an important thing to know here is that a normal is only a vector, so it, in a way, represents a single axis of the rotation. The script below pretty much guesses an x and y heading and uses the z direction as the up axis for the cursor. Here, I'm finding the location and normal of the selected face and assigning it to the location and up axis of the cursor. I've simplified this script a lot. It doesn't use the bmesh data, which means you may need to make your face selection in edit mode, and switch back to object mode and then back into edit mode before you run the script.

import bpy
import mathutils

C = bpy.context
cursor = C.scene.cursor
obj = C.active_object
p = obj.data.polygons

#get the normal and center of the selected face
normal = obj.data.polygons[p.active].normal
center = obj.data.polygons[p.active].center

#generate a quaternion rotation from the normal vector
up = normal.to_track_quat('X', 'Y')

#set the cursor to the center location and rotate it to match the up vector
cursor.location = center
cursor.rotation_quaternion = up

And then back in object mode again carry on with getting the cursor location and rotation and creating the primative like in your example above:

#get the object world matrix
mat = obj.matrix_world

#generate the location and rotation
rot = cursor.rotation_euler.copy()
loc = mat @ cursor.location.copy()

bpy.ops.object.mode_set(mode='OBJECT')
bpy.ops.mesh.primitive_plane_add(location = loc, rotation = rot)

You have to get the object world matrix and use it to offset the center location because any vertex, edge, or face location will be based on a distance from the object center, not the world center. Of course, you don't have to use the cursor as a step in between and can just apply the rotation and location of the face directly using:

rot = up
loc = mat @ center


Display and data windows are not implemented in Blender.

For those wondering about them, read page 5 of the OpenEXR introduction.


Is there a way to sort shape keys by name?

On the "Object Data" tab in the "Shape Keys" panel; click the tiny + symbol at the lower left of the shape key list.

This will enable the filtering and sorting options

Clicking the AZ button sorts the list alphabetically.

(The tooltip lists the relevant python command as MESH_UL_shape_keys.use_filter_sort_alpha)

These filtering options/sorting options are hidden away in all (most?) of these lists.


How to duplicate selected vertices using python script?


Set transform of a child object to an arbitrary point using a script

Use Vector maths.
One of the fundamentals of 3D programming is Vectors. If have two location vectors A and B,
A vector C describing the shortest distance from A to B
C = B - A

distance from A to B
C.length

there is almost never a need to calculate this using the Euclidean distance formula.
Making a small adjustment to answer to Calculating and exporting global rotation of faces created from splitting an isosphere
Instead of choosing the single face find the poly that matches the criteria of the question.

Average the face centers
Sort by distance from face center to calculated average
Use the closest

Since this is returning a face, there is no way (without weird ngons) this can be "outside the faces"
Note this will favour small tightly clumped faces.  Consider perhaps weighting by the face areas How to compute the centroid of a mesh with triangular faces without using Blender's built-in functions?
Also a point on another face may be closer to the median of face center medians.  Aside from raycast, Object.closest_point_on_mesh(...) will also return the face.
hit, loc, norm, index = ob.closest_point_on_mesh(o)

if hit:
    f = ob.data.polygons[index]

Test script: Run in object mode, sets origin to each selected object based on criteria above.
import bpy
from mathutils import Quaternion, Vector

context = bpy.context

z = Quaternion()

def closest_poly_to_centers_avg(polys):
    o = sum((p.center for p in polys), Vector()) / len(polys)
    return(sorted(polys, key=lambda p: (p.center - o).length).pop(0))

for ob in context.selected_objects:
    print(ob)
    me = ob.data
    if not me.polygons:
        continue
    mw = ob.matrix_world
    mwi = mw.inverted()
    f = closest_poly_to_centers_avg(me.polygons)
    c = mw @ f.center
    n = mw @ f.normal

    q = z.rotation_difference(n.to_track_quat())
    M =  q.to_matrix().to_4x4()
    M.translation = c
    me.transform(mwi @ M.inverted())
    ob.matrix_world = M

FWIW I  really loathe this
for everyObject in objects:

having a variable named every object that is one of each, may "read well"  but really? Equally with someObject, somePolygon opposed to simply ob and f


I'm not sure how your mesh is set up but you can try going into Edit mode and selecting the bone that you want to be separated. Then, go into the Bone panel and under the Relations section, remove the parent and uncheck Connected.


How to save a denoised image in composting

Go to Image Editor ( The Paint Bucket icon )
Click on the Mountain Icon thingy ( See Below, far left ) and from the drop-down menu click on Viewer Node

Click on 'Image' then click Save As - it's near the Bucket Icon from before

Rejoice.


Firts you must select in "Mesch of Bsurface" the plane,after in Bsurface go to curve (guide stoke) and select your curve....Select like in the tuto,edit mode and add surface. Check the menu of add surface for the cross and follow setting.
Work in Blender 2.81a.


Green color wash over render output when rendered on server

This is not caused by the remote server, amazon, the CPU, the GPU, 1394, or some weird vudu curse. Any computer that is not your local machine will render the images green, because the file has not been been saved correctly to render in a different computer.

Your file is using images as textures, but the images are not packed into the file, or are stored in a place that is not available in the remote computer.

Images used as textures are not stored as part of the blend file unless you explicitly pack them.

Missing textures will render pink.

So where is the green coming from?

The texture you are using for the world is using a hue/saturation/value node that turns the missing texture's pink texture to cyan-green.

You need to pack the images so that they become part of the file. Else the blender project will have no access to them on a remote computer. As an alternative you need to create a folder that holds the images using the same path as in the original computer, so that blender can load them.

Read: Why are all the textures in my file pink?

And: Why is that when I open up my file in blender, the reference picture is gone


Blender Game Engine FPS slows down when encounters a specific object

Switch on Menu/Game/Show Frame Rate and Profile.

It will show you what part of the BGE eats most of the time.

With that information you can do further investigations and focus on the problematic area.


There are several ways to do it, here is one:

Create your tunnel section, create an empty close to it, give your tunnel a Mirror modifier with the empty as Mirror Object, enable Axis, Bisect and Flip on the right axis (here X):

Rotate your empty 45° on the Z axis and move it so that the tunnel and its mirrored version cross each other:

Apply the modifier, go in Edit mode, select all, in the header menu > Mesh > Symmetrize, and in the Operator box choose the right axis:

Symmetrize in the other axis:


This slider decides if IK will move the arms, or FK (and it can be animated).


How do I make spikes show wherever you would see solidify lines with flipped normals?

This seems like a task for the compositor, but you explicitly stated that you don't want to render multiple times. That means only AOVs remain an option for compositing. After trying it I discarded the idea, because it will cause artifacts. Instead I found a solution using only the shader and some Custom Normals.
First you need to redo the spikes. You need a spike geometry with Custom Normals pointing along the spike direction. You can do that in Editmode of the spike by using Mesh > Normals > Point to Target or using Alt+L. Then you can use instancing to put the spikes at the vertices of your model. Then you need to disable ray visibility for any other ray than a camera ray in the object settings of your spikes.
After this setup you can make this shader:

The result looks like this:

You are also free to change your material in any way you want, which could have been difficult with the compositor approach.
Here is the Blend File:


Bug separating an array of cubes in blender 2.90?

I too downloaded the new version and there is no more apply button. Instead, there is a drop down next to the camera icon and you can select apply or press Ctrl +  A it seems.
I was able to separate pets in edit mode then.


Is there a way to get rid of this square artifact coming from lens distortion?

This is not a bug.  It is simply how the the image manipulation algorithm works.  This must be fairly common since Corel seems to use a similar algorithm in Paint Shop Pro:

It's worth noting that the square pattern only appears close to the center... outside the center it becomes more like a concentric circular pattern radiating out.

The reason for these artifacts is that you are distorting an image made up of square pixels.  Ideally, this is what would happen to the pixel array:

However, you obviously cannot distort the pixels themselves and still have a proper 2D array that can be read by typical image software. So you must do some sort of combination of deleting and averaging of pixels.  Because that can't be done on a pixel level (there are no fractions of pixels), the image must be subdivided into sections in order to deal with each subset.  In the center, it makes sense to do this in square sections (since the distortion is minimal), but on the edges it should be concentric sections (since the distortion is circular in nature).

A uniformly noisy image (with large, flat, mono-chromatic planes) is pretty much the worst case scenario for this algorithm because of the contrast between individual pixels on sections that would otherwise have little variation.  You probably wouldn't even notice the artifacts on a smooth image unless you were really pixel-peeping. Here's the same distortion applied to an image rendered at 500 samples:

In short, this is to be expected.  The only way I know to reduce the effect is to apply noise reduction before distortion in your Composite node chain, or start with a less noisy image.  Essentially, the lower the contrast between individual pixels, the less visible the artifacts will be.


How can I thicken the walls of my model for a more sturdy 3D printing?

The quick solution to make a Blender model of this is to export it as an stl then import it in Blender. Blender can read stl files. That's the quick, though often dirty, solution. It works most of the time, though you often have to check the model and redo some stuff.

I believe that the inner geometry of the piece is unnecessarily complex, thus why it generates so much problem. The gif, while fast, seems to show some problem arising when the model is sliced and it seems that there are missing layers and holes when I compare the end of the gif to the picture of the 3D model you provided.

That being said, my main concern, if I interpret your gif right, is the insane movements of the printer head! If I'm not mistaken, the thin red lines on the gif must represent the movements of the printhead, and they're all over the place! With such a geometric pattern inside, I would expect the printhead to follow the lines, but yours seems to jump all around.

That would also explain why your print fails: the printhead has to do too many retractions.

I would suggest to simply the inner geometry, and you can thicken the walls of an object using the 'Solidify' modifiers in Blender.

Although, I think it would be best to just rebuild it from scratch in Blender and make the walls thicker from the start.


https://youtu.be/UMGRXU2k40Y
I got it to work for producing new NLA track/strip by playing through the animation, setting the auto keying, and then moving the cube. It tends to create them when keyframing around the end and start frame.


How to highlight areas of a desktop recording in video sequence editor

Making the shape in a 2 paint program like GIMP or drawing program like Illustrator is quickest. But with Blender you can animate and iterate more quickly.
You can use a mask from the UV image editor.

First press F12 to render the present frame into the Image editor.
then change to Mask Mode and create a new mask (name it)

In the VSE add the mask as a strip in the place that you want it to appear

Select the new mask strip and add a Gaussian Blur, set blur in properties panel (N key) to 10 or more (depending on render resolution).

With Blur effect selected add a curve modifier and make a sharp peak.

Now add a color correction modifier. Set the Gain value to a nice bright color.

Change the mask strip's Blend type (in the properties panel again) to add.

Now you should see a colourful box outline around your region of interest.

What is cool about this approach is that you can animate the shape, color and thickness of the curve during the edit.


The answer that you link to is a good solution, you can even use an object offset in two arrays to get the result you are after.

Start with one simple piece.

Add a solidify and array with object offset, rotate the empty to fit.

Add a second array also with object offset, move this empty up and rotate to offset the notches.

You can look at the sample blend here


Like this:
import bpy
def simplify_fcurves():
    C=bpy.context
    old_area_type = C.area.type
    C.area.type='GRAPH_EDITOR'
    bpy.ops.graph.decimate(mode='ERROR', remove_ratio=0.698113, remove_error_margin=0.5)
    C.area.type=old_area_type
simplify_fcurves()


You could give one or more faces of a sphere a different material (to make the faces smaller subdivide the sphere). Then you could render the scene and press the left mouse button make the coordinates show up.

First add a sphere and two materials with different colors. Then switch to edit mode and change the selection mode to faces.

Now select one or more faces and the second (in this case red) material. Press Assign to assing this material to the selected face. To see the selected material in the 3D view select the shading mode Material.

Render the scene and press the left mouse button on one of the colored points. The (image) coordinates are shown at the bottom left corner of the image view.

Here is an animation of the whole process.


images with transparency return to black when bunched

In the Render tab > Light Paths > Max Bounces, you may need to increase the Transparency value.


You can select the bone using a right click (as selection is working like that in most Blender's function).

It is sometimes easier to select them using the properties panel.

For instance, when you are in selection masking modes, right click allows to select the model faces or vertices and not the bones:


Background colour in cycles render turning pink

You might have changed the directory of the background image or the image file. While rendering do not move files around.


How to fix strange dimensions to real dimensions

I don't know how you managed to do that, but here's how to fix it:
Go into edit mode. Set the view mode to wireframe. Use box select to select the visible vertices, the ones that belong to the arc and you want to keep.
Press CTRL I to invert your selection
Press X and delete vertices.


Why does my textured object appear black in the viewport in 2.8?

Check the alpha of the material. If it's on opaque but with alpha value 0, it appears black.
This happened to me when imported models with materials already applied.
Another possibility is trying to delete the material and create a new one again.


The "Render Emitter" check box must be checked in the particle panel. If not, only the particles emitted are rendered.


You can do this as a post process in the composite nodes, after all the baking is done, with a Separate and then a Combine RGB nodes.


How to set up a single driver so that it moves a shape key from 0 to 1 and then another one from 0 to 1

By adding your own function to the driver space you can customise a driver to suit your needs. The following function returns a value between 0.0 and 1.0 based off an input value and and offset.

import bpy

def multi_driver(var, offset):
    val = var - offset
    if val < 0.0:
        return 0.0
    elif val > 1.0:
        return 1.0
    else:
        return val

bpy.app.driver_namespace["multi_driver"] = multi_driver

The last line adds the function to the driver namespace so you can use it as multi_driver(x, y) in any driver you setup.

In this example I am using a custom property as the value input, you can change this for a bone or object location etc. The first shapekey uses an offset of 0, the second an offset of 1, the third an offset of 2 ...


How does the program decide what indices to assign to vertices?

new vertexes are appended to the end of the vertex list
duplicating vertexes adds them also to the end and their order is maintained
.. list too long..

It would be very time consuming to analyze every mesh operation/modifier and how it handles vertex indices and make a list for you (it will be like the above though in most cases if not in all). Instead you can reverse engineer this yourself:

Type bpy.app.debug = True into the Python Console

This will enable super top secret mode with next option available in Properties panel:

Now you can see the indices and how they change for what you are interested in:

  Can anything be done to control which get re-assigned?

Nope, blender handles it internally.

  Are there any ways to recalculate, re-assign, or copy vertex indices?

Sure, with python you can do anything to meshes, you can reorder the vertices. Just by building a new mesh with different vertex order from old one and then switching them.


How to set off background color reflection?

You Don't have to use chroma,You can just render the video in alpha channel.

Cycles:

To do so,You just have to check transparent  film panel:

This will render the background as Alpha but the reflections will be still here.

To remove the colored reflection,Uncheck use Environment in render layer:

Blender Internal:

You just have to Uncheck Sky in render layers:


Is it possible to quit blender from the command line?

I think you could try with wmctrl instead of kill. However it's behavior may be application and windows manager dependant.

wmctrl -xc <WIN>

By default, <WIN> is treated as string to be searched in window title (wmctrl -c blender will close any window containing "blender" in the title). With -x, it will be interpreted as window class, so this invocation:

wmctrl -xc blender

... only closes any window having "blender" as its class name, which is usually Blender itself.


how to isolate and texture a certain area of a mesh

If you don't want to use any image texture you can do it with Vertex Paint:

Switch to Vertex Paint mode, open the Tool panel, choose a black color, select the Blend > Mix mode, paint around the eyes. The vertex paint only uses the vertices, so its smoothness and precision will depend on your mesh density:

As you can see it has created a Vertex Colors group:

In your Shade Editor, create a Input > Attribute node. In the Name field, type the name of the vertex color group you've just created. Now you can use it as a factor in a Mix Shader:


Blender only render one frame of animation

I deselected these two options and I can render the correct animation:


Weight painter - no weight paint but section affected by an unconnected bone

I'm fairly new as well... did you apply automatic weights? The automatic weights seems to be hit or miss with me, and I have to go in and manually change it.


How would you approach simulating garbage being compacted?

I guess the solution depends on your purpose: What is your storyboard, what is the degree of realism, etc... For example you don't say if we're supposed to see a compactor machine, it would partially hide the process.

But what you could do is create a group of objects (cans, boxes and whatever...), and prepare 2 shapekeys for each object: the basis and the contracted version. NB: To give various colors to the same object, use the Object Info node, Random output socket > ColorRamp (Constant mode) > Diffuse...

Then create a cube, give it a particle system > Hair (Advanced mode). In Particles > Render, enable Group and choose the group you've created. Enable the Rotation option and find the right orientation. Now you can animate the objects shapekeys.

Instead of particles, to avoid any objects overlapping, you could simply link-duplicate your objects.

And here was my try for the result only:

Find a frontal image of compacted garbage.
Create a normal (or bump) map of this picture with a software like CrazyBump.
Open those 2 pictures in the UV Editor.
Create a cube, subdivide it, bevel the edges, mark the 6 faces seams.
Unwrap it, in the UV Editor place each face on the garbage image.
Give your object a material, mix a Diffuse with a Glossy, plug the normal map into the Normal sockets.
Deform the cube a bit so that it doesn't look too square.


For those looking at this later, per the comment section:  the nodes I had used in Cycles were causing trouble.  When I open a new default scene ProRender worked.


How can I combine two materials in Cycles?

That part you've labeled "wood" - group those nodes.
Then you can drop the group into each material: 1, 2, 3.
A group is a shared datablock, so changing its contents inside of one material changes it for all instances.


Can't get a transparent background for glass

Set Blend Mode in material to Alpha Blend and Shadow Mode to Alpha Hashed.

or try this:


Is it possible to pin distinct Bones of a Model to a Plane while posing?

A meta-rig created by Rigify is set to forward kinematics by default. With the settings shown in the n-panel on rig-foot.ik.L/R it possible to move the body with the foot on floor by only moving the rig torso (shown in 2nd img).


Animating blood dripping down surface of mesh

I think it depends by the style you are looking for. In my old Tarantella animation (the very last scene), I used a mesh deformed by a shape key. https://www.youtube.com/watch?v=C_R3QssuG9g


Boolean intersect two 2d extruded bezier curves (non destructive)

Well I found some time to try and code an add-on that will do what I think you are talking about. It is found here, or on this thread. To use:

Install

Add Curve, and Bevel

Add a mesh object like a cube

Go to the modifiers tab and select the curve's name under the Curve Conversion part

Click Update Mesh

What it does is automatically converts the curve to a mesh and replaces the current objects data. It will respect any materials or modifiers added before you press Update Mesh. The Respect Scale option copies the scale from the curve. So if you scale the curve up the mesh object does the same.
Let me know if this is what you were talking about.
EDIT: Check Blender Artist thread to get updated instructions as they come


I think textured area lights are not fully supported yet. So currently one of the workarounds is to add another mesh under the lamp and add a transparent material on it with transparency controlled by the mask image (as seen below).

Another way is to add Texture Coordinates node to your existing area lamp material and connect the Reflection output to the Image Texture Vector input, however, that looks kinda strange and not very correct.


The functions assigned to bpy.app.handlers need to accept one parameter, even if they don't use it. While you can ignore the scene parameter I would suggest using it, rather than directly accessing global data (not that you are making use of the object variable you set).

import bpy

def object_update(scn):
    object = scn.objects['Cube']
    bpy.ops.object.explode_refresh(modifier="Explode")

bpy.app.handlers.render_pre.append(object_update)

Note that the explode_refresh operator will only work on the active object if it has an explode modifier named "Explode", so I'm not sure what you want to achieve will work, or that it is really necessary.


Syntax for operator Make Single User using the mesh data block

The default options for bpy.ops.object.make_single_user() are all false so you need to specify at least one True option when you call the operator. When calling an operator directly you can just include the optional values in the call -

bpy.ops.object.make_single_user(type='SELECTED_OBJECTS', object=True, obdata=True)

When using layout.operator() in a panel or menu,  you can't pass options this way but there are two methods you can use. When you only have one option to set you can add the property to the operator line -

layout.operator("object.make_single_user", text="Object").object = True

When you need to define multiple options you need to keep the operator item that is created and then adjust it's properties. As shown from the make single user menu -

props = layout.operator("object.make_single_user", text="Object")
props.object = True
props.obdata = props.material = props.texture = props.animation = False

props = layout.operator("object.make_single_user", text="Object & Data")
props.object = props.obdata = True
props.material = props.texture = props.animation = False


Exporting a posed armature as a mesh to another blender

First convert the model to a mesh, which will remove all modifiers, parenting, and such, then export the mesh.

Select the mesh.
Press alt+c.
Select 'Mesh from curve/meta/surf/text'.
Click 'File' -> 'Export'.


Insert keyframe for active material slot with python

If you cannot keyframe the property from UI, you cannot from python either.

The solution is to have a material assigned to all the object behaving in such a way that its color is not constant but dynamic based on something else. It can be:

vertex colors
place in UV space
object index pass
... (with drivers almost anything, but they don't update always nicely)

Let's use the object index pass, because it is just a single property you can animate, it is unique to each object and you have access to it from the material nodes:

Now if you change it for single object the material on that object will behave differently:

activeObject.pass_index = 1
activeObject.keyframe_insert("pass_index")

For Blender Internal the node setup is very similar (switch the material into node material):

There is also another solution available - you can set unique color for every object that is multiplied with the material (to get exactly the color have white material):

You set the color in python this way:

activeObject.color = (1.0, 0.0, 0.0, 1.0)   #RGBA red


If I followed your question correctly: In edit mode, the default scale method is "Individual Elements" which means the scale occurs centered on the selected, connected faces. In the following example, I cut a Suzanne in half and added a mirror modifier:
 You can see her eyeballs popped out and she gets strangely wide. I assume this is what your question is about... To "fix" this, set the 3D cursor to the center of the object (in this example, I left it at the default world origin) and set the scale method to "3D Cursor". This makes scale behave more like it intuitively should
I didn't highlight the thing that changed... Look in the top center next to the word "Global"


Un-weighted painted vertices moving with bone

Try checking to see if any child bones (bones which move when you move the "parent" bone) of the bone you are moving have weight on the problem area.


Script for Placing Mesh on Sphere with Provided Latitude and Longitude

If I have understood your video well, the difficulties (I am learning Python) here are linked to several points :

Copy of objects and materials as I have seen no way to change the pictures and colors keeping original pin and card materials
Placement of the pin and card

Copy of objects and materials

Copy of objects is base on this function that creates a new mesh and a new object based on this mesh and link it to the scene. The object is tagged 'CivicCollage' as this will be useful for a cleanup of the generated object, if needed.

def Duplicate( name, obj ):
    newMesh = obj.data.copy()
    newObj = bpy.data.objects.new( name, newMesh )
    newObj.isCivicCollage = True
    bpy.context.scene.objects.link( newObj )
    return newObj

Copy of the materials needs to preserve all the object materials and replace only the needed one (either the texture for the card, or the color for the pin). The trick here is to link these materials at the object level, as if not, this will interact badly with the original objects.

def AssignDuplicateMat( obj, copyObj, mat ):
    newMat = mat.copy()
    newMat.isCivicCollage = True

    for i in range(len(obj.material_slots)):
        copyObj.material_slots[i].link = 'OBJECT'
        if obj.material_slots[i].material.name == mat.name:
            copyObj.material_slots[i].material = newMat
        else:
            copyObj.material_slots[i].material = obj.material_slots[i].material

    return newMat

Once done, using the previous function for both card and pin, we can change either the texture of the card or the color of the pin. This is based on the name of one node of the Cycles configuration :

def AssignColorToMat( mat, nodeName, color ):
    node = mat.node_tree.nodes.get( nodeName )
    if node != None:
        node.inputs['Color'].default_value = (color.r, color.g, color.b, 1)

def AssignTextureToMat( mat, nodeName, image ):
    if image:
        node = mat.node_tree.nodes.get( nodeName )
        node.image = image

The image is previously loaded from a file. We first check if this image is already known, and if not we load it using the combination of a root path and a file name to have the full image path :

def LoadImage( imagePath, fileName ):
    try:
        return bpy.data.images[fileName]
    except:
        try:
            fullFileName = bpy.path.abspath( imagePath + fileName )
            return bpy.data.images.load( fullFileName, check_existing = False )
        except:
            return None

Objects placement

We need some conventions here :

Pin and card are Z up (we see the pin top and the card face from top view)
World sphere is orientated so that 0° in latitude and longitude is at positive X axis

From that, we convert the parameters in radians, then calculate the position and finally the needed rotation (surely that could be shorter, but...). Note that the rotation needs to be assigned in the mode of the object rotation display (here I kept the conventional Euler, but if you are not using it, this code may fail, assigning the values but with no visible results).

def PlacePin( worldLocation, radius, latDeg, lonDeg, scale, pin, card ):

    latRad, lonRad = radians( latDeg ), radians( lonDeg )

    x = cos( latRad ) * cos( lonRad )
    y = cos( latRad ) * sin( lonRad )
    z = sin( latRad )

    location = Vector( (x, y, z) ) * radius
    locationFromWorld = location + worldLocation
    scale3D = (scale, scale, scale)

    aroundZ = Quaternion( (0, 0, 1), lonRad )
    aroundY = Vector( (0, -1, 0) )
    aroundY.rotate( aroundZ )
    aroundX = Quaternion( aroundY, latRad )

    rotation = Quaternion( baseRotationQuat )
    rotation.rotate( aroundZ )
    rotation.rotate( aroundX )

    pin.scale = scale3D
    pin.location = locationFromWorld
    pin.rotation_euler = rotation.to_euler( 'XYZ' )

    card.scale = scale3D
    card.location = locationFromWorld
    card.rotation_euler = rotation.to_euler( 'XYZ' )

Other aspects

I can't detail all the script parts here.

The addon is based on a GUI with two modes.

A manual mode

These parameters are self explanatory, except maybe the nodes : you have to set here the nodes names (as they appear in the node information panel 'N').

A "from file" mode

This mode allows you to generate several pins from a file.

This file is indicated in the first parameter and the last parameter corresponds to the images folder.

For instance, I have used this text file, with fields separated by ';' and with the following columns:

Latitude
Longitude
Scale
R color component of the pin
G color component
B color component
Location name
Image file name

48.8534100;2.3488000;0.05;255;0;0;Paris;paris.jpg

51.500152;-0.126236;0.05;255;0;0;London;london.jpg

40.440624;-79.995888;0.2;0;255;0;Pittsburgh;pittsburgh.jpg

35.6895000;139.6917100;0.1;0;255;0;Tokyo;tokyo.jpg

-22.9027800;-43.2075000;0.1;0;255;0;Rio;brazil.jpg

6.465422;3.406448;0.1;0;255;0;Lagos;lagos.jpg

39.9075000;116.3972300;0.1;0;255;0;Pekin;pekin.jpg

-35.2834600;149.1280700;0.1;0;255;255;Canberra;sydney.jpg

Note about the file data : I needed to add a carriage return for the presentation of the answer, but for the real file keep the lines consecutive (the real file is packed into the blend).

Cleaning the generated objects

Last, the "clean" button allows to delete generated objects and to mark unlinked materials and textures.
This can be useful also because the script may fail if some parameters are not as expected...

Addon

To have an addon from the blend file below, simply save the Python code into a file.py. Or simply run the script directly from Blender.

Note that I have tested all that... but if you encounter some problem, please tell...


I think beveling is a good option. Select the edges as pictured below, press Ctrl+B and drag the cursor in opposite direction to the edges' location. Use Mouse Scroll to add some divisions. Finally change the rest of the mesh topology to easily add a Subsurf and edge creases.

Here's the final result with a changed topology.

And here's the .blend with improved topology:


Why does the smooth brush create holes in my model?

Those are the result of unconnected geometry forming the mesh.

Some of edges forming faces are extruded and placed atop of another edges. Thus those vertices meet in nearly the same place, but they do not share the same edges:

Once you sculpt, those will reveal themselves because geometry is not connected and one edge will be moved more than another. However these aren't double vertices so you won't be able to fix this by deleting duplicating geometry as vertices do not share the same place.

To quickly fix it use Remesh modidifer. The example mesh has quite bad topology with a lot of Ngons, interrupted loopcuts (and several double vertices, remove them with W > Remove Doubles). With Remesh modifier you will be able to quickly generate new topology:

You can also fix that manually.

Delete vertices which aren't connected (see the first screenshot),
Select the resulting hole and fill a face.

From there on you will be able to edit that geometry as closed, so adding more edge loops, cutting where needed etc.

This is quite related question:

Why do gaps appear in my mesh when I animate it?

Do note - for good sculpt you'll want even topology (kind of one resulting from the Remesh modifier), so avoid Ngons unless working on completely flat surfaces (which aren't the case in your example) and even then they might be undesirable.


What's the meaning of color of rhombus in keyframe?

Yellow means active (selected). White is inactive.
While a keyframe is selected, you can move, scale and do whatever to the keyframe. You can also select multiple keyframes by holding shift.


Select collider object (sphere) and under Physics Properties enable Collision

Select cloth object (plane), switch to Sculpt mode, take Cloth Filter brush and go to
3Dview editor > Properties panel (N) > Tool tab > Active Tool > Use Collision

or with Cloth brush go to
3Dview editor > Properties panel (N) > Tool tab > Brush Settings > Enable Collision

In video is also for Grab type used smaller Radius and big Simulation Limit.

To get gravity behaviour as seen in video ... go to same Tool properties tab and increase
Options > Gravity > Factor like 0.1


Does Blender keep a log when it's rendering?

Here's a quick script you can use to output some simple frame times:

import bpy
from bpy.app import handlers
from datetime import datetime

def render_init_handler(dummy):

    global LASTFRAME
    global STARTTIME

    STARTTIME = datetime.now()
    LASTFRAME = datetime.now()

def render_post_handler(dummy):

    global LASTFRAME
    global STARTTIME

    ELAPSEDTIME = datetime.now() - STARTTIME
    FRAMELENGTH = datetime.now() - LASTFRAME
    frameNum = bpy.context.scene.frame_current
    blendName = bpy.path.basename(bpy.context.blend_data.filepath)[:-6]

    f = open(bpy.path.abspath("//") + blendName + '-renderlog.txt','a')
    f.write("Frame %d - Length: %s - Elapsed: %s\n" % (frameNum,FRAMELENGTH, ELAPSEDTIME))
    f.close()

    LASTFRAME = datetime.now()

handlers.render_init.append(render_init_handler)
handlers.render_post.append(render_post_handler)

You should generate a text file that looks like this inside:

Frame 1 - Length: 0:00:00.139432 - Elapsed: 0:00:00.139441
Frame 2 - Length: 0:00:00.232712 - Elapsed: 0:00:00.372586
Frame 3 - Length: 0:00:00.257580 - Elapsed: 0:00:00.630437
Frame 4 - Length: 0:00:00.265303 - Elapsed: 0:00:00.895999
Frame 5 - Length: 0:00:00.259570 - Elapsed: 0:00:01.155840
Frame 6 - Length: 0:00:00.266500 - Elapsed: 0:00:01.422597
Frame 7 - Length: 0:00:00.260504 - Elapsed: 0:00:01.683389
Frame 8 - Length: 0:00:00.259319 - Elapsed: 0:00:01.942971
Frame 9 - Length: 0:00:00.258627 - Elapsed: 0:00:02.201868
Frame 10 - Length: 0:00:00.260319 - Elapsed: 0:00:02.462535
Frame 11 - Length: 0:00:00.257915 - Elapsed: 0:00:02.720720
Frame 12 - Length: 0:00:00.261301 - Elapsed: 0:00:02.982309
Frame 13 - Length: 0:00:00.262327 - Elapsed: 0:00:03.244906


keep body mesh from poking through clothes mesh when posing with armature

You can hide/delete the mesh which is not visible due to clothes or you can adjust the clothes by going into edit mode such that body isn't visible


The reason for this shading is due to your lighting. The sun lamp you have is casting light rays straight down. If you look closely, the light areas are the areas that receive light, and the dark areas are shadowed.

If you want more even light, try a hemi lamp (I find these to be great for quick, even lighting) or rotate your sun lamp a bit and add a floor plane so the light can reflect and bounce around some more, which will also give some better lighting.


This script will generate a 2D Mandelbrot set in Blender using OSL.

#include <stdosl.h>

shader node_fractal(
        float CenterX = 0.0,
        float CenterY = 0.0,
        point Vector = P,
        float Zoom = 1.0,
        int MaxIterations = 50,
        color Foreground = color(1.0),
        color Background = color(0.0),
        output float Fac = 0.0,
        output color Color = 0.0)
{
    point p = Vector / (2* Zoom);
    float auxiliar = 0.0;

    p[0] += CenterX;
    p[1] += CenterY;

    point pa = p;
    point pb = point(0.0);
    int i = 0;
    for(i=1; i<MaxIterations; i++)
    {
        pb[0] = pa[0]*pa[0] - pa[1]*pa[1];
        pb[1] = pa[0]*pa[1] + pa[1]*pa[0];
        pa = pb + p;
    }

    auxiliar = sqrt((pa[0]*pa[0]) + (pa[1]*pa[1]));

    Fac = clamp(auxiliar,0.0,1.0);

    if (Fac == 0.0)
        Color = Background;
    else
        Color = mix(Foreground, Background, Fac);
}

Result:

Source: http://elbrujodelatribu.blogspot.fr/2013/04/blender-cycles-osl-mandelbrot-fractal.html


can the bone become a 'child of' a parent object?

I don't understand your words when you say your object "is not fully merged together" and so you can't use a Child Of constraint, because that is exactly what I would do. Only I wouldn't make the hand the parent of anything (see below). I don't know what exactly it is that you are saying isn't fully merged, but given what you have described so far, I don't see why Child Of constraints wouldn't work.

I would create two empties that are parented directly to the handle in the position where each respective hand needs to grasp it. I would (G)rab and position the IK targets of each arm IK chain so as to be very close to each of these empties. Then I would create two Child Of constraints, one for each IK target, and point them to the empties, making these empties the target of the Child Of constraints. After clearing the inverse on each of these constraints, you should have hands that follow the handle.

Beyond that, you may also need to create two Copy Rotation constraints, one for each hand, and point them to the handle itself (not the empties) as their target, so that they will remain oriented to the handle whenever it tilts.

If you don't want to create empties, you could create a bone chain specifically for the handle itself. But if you do this, it should still be part of the original armature (add the bones in Edit Mode for the armature to ensure that these bones will become part of it), or else you won't be able to select this new bone chain in Pose Mode along with all your other rig's bones (you would have to switch rigs to select it in that case, which would be a pain). The new chain doesn't need to be parented to anything else in the existing rig, but you might want it parented to your root bone, depending on your needs for movement. Make it four bones in a line, and lock all their rotation values. This way, you can Child Of constrain your hands (IK targets) to the two bones in the middle of this chain, which will represent the positions of the handle where it needs to be grasped.


'fac' is a percent of the edge length, considered from the vertex indicated in the call.

For instance, if you run the code below on an edge suite, you'll see the growing percents applied on a length of 2 meters:

import bpy, bmesh

obj = bpy.context.object

if obj is not None:

    prevMode = obj.mode

    try:
        bpy.ops.object.mode_set(mode='EDIT', toggle=False)

        bm = bmesh.from_edit_mesh( obj.data )

        edgeCount = len(bm.edges)

        for i, e in zip( range(edgeCount), sorted( bm.edges, key=lambda e: e.verts[0].co[2] ) ): #Indexes and sorted edges from bottom to top
            fac = (i+1) / 10
            print(fac)
            ne, nv = bmesh.utils.edge_split( e, e.verts[0], fac)
            print(ne,nv)

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


Global time is basically just the frame number. As far as I know, Blender can't render in between frames, so there isn't a way to slow down global time.

(I may be wrong about that though. Maybe turbulence is computed as a current_frame / total_frames? In that case, you could try increasing/decreasing the number of frames. I don't have time to do a test case, at the moment.)

Instead, you should use "particle age" for the influence. To modify slow down the turbulence, you'll need to select the particles option when you first generate the cloud. This will let you edit the particle system associated with the point cloud texture. Longer particle lifetime = slower; shorter particle lifetime = faster.

See the Blender Wiki for the Point Density Texture

Edit:
Oh, you could also just render it at slow speed, then speed it up using a "speed control" effect in the video sequencer. 'Tis a hack, but may suit your situation.


Unfortunately there is no way to do this entirely procedurally at the moment, as far as I know. You have to apply most modifiers and preform some Edit Mode operations.

Create a base mesh with whatever starting shape you want.
Ass a Subdivision modifier set to Simple to said object
Adjust the number of subdivisions as desired to obtain a mesh density that suits your needs
Now add a Decimate modifier and turn on the Triangulate option
Adjust the ratio until you obtain a desirable pattern
Add one more Subdivision modifier set to Catmull-Clark with only one subdivision
Once satisfied with the results apply all modifiers
Now in edit mode you will have to preform a repeated sequence of actions to delete all undesirable vertex

Select one "central vertex" from the generated "cells" pattern with more than 4 connecting edges, press Shift + G to select similar and choose Amount of connecting edges option. Erase all selected with the option Dissolve Vertex
Repeat this process until you end up with "clean" voronoi cells leaving the vertex with four connecting edges for last

As last step select all "side vertex" that are only connected to two edges and dissolve them as well so you end up with "simple voronoi cells".

Now in face selection mode inset them all using the Individual option, adjust amount as desired. You can at this point optionally add a Wireframe modifier instead of insetting, if you don't care about adding a solid thickness or if different your wires will have a circular section.
Once done exit edit mode and add modifiers like Solidify to add thickness and a Subdivision modifier set to Catmull-Clark for a smooth appearence. Adjust order to achieve desired effect

These last two modifiers can be left "live" so you can control thickess and smoothness procedurally.


cant select any object in blender (not even in a new file)

sounds like a strange keybind or something.  Maybe restore to defaults and try again w/ a new project?


Simulating LCD display angle effect (duplicating millions of realistic pixels)

Thanks to the suggestion from user lemon in the comments the solution I ended up with was to use the dot product between the geometry normal and the incoming ray vector in order to control the strength of the shader emission (divided the dot product by the length of the incoming ray to normalise the value).

The emission is cut off completely when the sine of the angle is below the value in the 'Greater than' node. And increases smoothly above that angle until reaching full strength when parallel with the normal.


When editing the walkcycle action alone (file has the same issue as in this question) you haven't properly keyframed the IK-arms. In the timeline set the VisualLocRot as keying-set:

Go to the keyframes in IK mode and place the hands where you want them to be. Thereafter you can switch seamlessly between IK and FK mode.


Visualizing 3D voxel data in Blender 2.8

As of Blender 2.83 OpenVDB is now supported as a volume object.


If they have the same preset, they will share the properties. Hit on the little + near the Settings preset to create a new slot for the second one.


How to add green screened footage to this scene?

Integration of CG and shot footage is tricky: it has to be done carefully and with the end goal clearly defined.

When you shoot your green screen element, add enough markers on it so that you can track it later. Plan the placement of your trackers so that you get a good idea of the actual geometry of the location used. Pay special attention at the places where the tracking marks might overlap with the foreground elements, try to avoid placing markers that are going to be blocked, or that might create probrems with the key.

No you don't need a massive green screen to pull this off, you just need a green screen large enough to cover the edges of the person you want to superimpose on the scene. The rest you can take away with masks (creating what is called a garbage-matte)

Keep accurate notes of what camera was used, the sensor size, lens, camera height, distance to the subject and do include some element on the shot that will help you determine the scale. For example if you set tracking points and measure the distance between them you can later have blender use that scale. To set the scale properly you need to have at least one known distance in the scene.

Do not use a zoom in the shot (as blender cannot deal with variable focal lengths yet). Shoot a distortion chart with the same lens used for the shot to determine lens distortion.

After the shoot bring the elements to blender, track them and reconstruct the scene. and combine the elements using the compositor.

Keep in mind that for a better integration your 3D scene needs to be in a scale that matches the real world.

The whole procedure and workflow is not within the scope of this site but there are plenty of videos out there that can help you. Sebastian Koenig's "Match, Track, Blend 2" series should give you enough information.

Before you do anything please read: How can I get better results when doing camera motion tracking?

If you get stuck please ask specific questions in different posts.


Creating and packing a 32-bit float image

It would seem that to control the image format that gets packed into a blend file, you will need to save the image to disk and then re-open it.

To get control of the file format an image is saved to disk with, you can use save_render(). The render settings from the scene parameter holds the ImageFormatSettings which allow you to adjust the settings. If you don't want to use the render settings from the current scene you can create a new one just for this.

scn = bpy.data.scenes.new('img_settings')
scn.render.image_settings.file_format = 'OPEN_EXR_MULTILAYER'
scn.render.image_settings.color_mode = 'RGBA'
scn.render.image_settings.color_depth = '32'
img_path = bpy.path.abspath('//')
img_file = image.name+'.exr'
image.save_render(img_path+img_file, scene=scn)
bpy.data.scenes.remove(scn, do_unlink=True)

But this still leaves you with an edited image that doesn't respond to pack(). To get around this, remove the image block and open it from the file.

bpy.data.images.remove(image)
bpy.ops.image.open(filepath=img_path+img_file)
image = bpy.data.images[img_file]
image.pack()
os.remove(img_path+img_file)


First, if it isn't already, set your normal map texture to "non-color data." It doesn't work properly if it is set to color data.

If attaching the normal output to the normal input of the diffuse shader doesn't work, this node setup (courtesy of @david) will invert the normal map.


Why do I have a black background in cycles render?

Under properties, got to World settings>Surface and change to color to the one you want.


Try creating another group, containing your linked-in groups. Then set your Freestyle options to that "outer group". If that works, you (or someone else) could write some Python code to automatically create those groups based on the linked-in group names.


Bring up your snap menu with Shift+S.
Hover your mouse over 'cursor to selected', and then click on it with the RMB . You will see an option to either add or change the keyboard shortcut.
Hover your mouse over the box that appears, (it should tell you to press a key), and then press the desired shortcut one key at a time while still holding them down to create your new shortcut.
Make sure to save your new shortcut as defaults by going to user preferences by pressing Ctrl+Alt+U,  and then save user settings.

In 2.8 and later, you can add a new shortcut to Quick Favorites which will give you a small menu with the keyboard shortcut Q
Simply RMB  and select Add to Quick Favorites from the choices that appear.


I am no specialist for exporting other formats (like .fbx), but in general it's like this:

To add a texture only to the side you will need a second material.

Click the material tab and click + to add a new material.
Then click + New.

Get into Edit-Mode and select the face you want to apply the material to.
With it selected click Assign under the materials.

This will assign the new Material only to that specific face.

Keep the new material selected in the material tab.
Then click the texture tab and add your texture to it by clicking + New, selecting Image or Movie(should be default) and sroll down to Image and Open your Image Texture.

Positioning of the texture can be performed by the options below the Image part.


Wave Texture: How can I have even bands proportions and distributions?

Use a gradient texture in Radial Mode.

Same idea with the wave texture:


There is one operator that allows you to what you did in the video in one single step and with greater control over the distance.

You can select all desired faces and use the Inset operator, i key by default. Do change the settings and tick the Individual option so each face is inset by itself.

That will however lead to "quad corner" based topology which while still being predominantly quad based is not great for subdivision, and doesn't work well with adding control edge loops.

What you can do in your case is use the Bevel operator instead, with the right settings it will give a quad dominant topology, and continuously flowing loops along the fuselage that will lead to less "rounded faces".

Make sure you select the whole edgeloops around the ship, set the number of segments to 2 and the Profile value to 1 to it keeps the original angle


Enable all these options while you import:

Import User Properties
Import Enums As Strings
Ignore Leaf Bones
Automatic Bone Orientation


Interlace frame numbers with file output node

I'm maybe wrong but it seems there is no way to avoid Blender (2.8) to remove the frame number and the extension of the filename with CompositorNodeOutputFile object, as I'm rendering by a python script I finally fixed it by renaming the files with os.rename combined with a regular expression just after render.


When animating a character they may need to pick up objects and move them around. The ChildOf constraint is useful for this. The advantage of using the ChildOf constraint is that you can animate the influence to allow the character to pick up and put down the object.

As you can specify an armature and bone to parent to you can also parent different object bones to different character bones, allowing you to have the character hold a piece in each hand and stretch them, or hold the doll body in one hand and lift the doll arm in the other.


How can I rotate an object smoothly using sin or cos?

Following solution might work for you (if I understand the requirement correctly) ...

Create a maxRot (int) property on the object.
Create an always sensor on the object that points to following python code

import bge
from bge import logic

cont = logic.getCurrentController()
own = cont.owner

if (own['maxRot']>0):
    own.applyRotation ((0, 0, 0.0174533), True)
    own['maxRot'] -= 1

Create an keyboard sensor (right arrow) on the object that points to following python code ...

import bge
from bge import logic

cont = logic.getCurrentController()
own = cont.owner
own['maxRot'] += 36

Run play and click the right arrow.

[0.0174533 = 1 deg in radians]


Object won't show in render. None of the suggested solves I've found have helped

Your book armature has "Instances" in Face mode activated, that is causing the "invisible Object"
First change that to None.
second thing, your Cover has "Shadow Catcher " ON inside the visibility tab.
Uncheck that too.


How can I make the Bishop's hat in the chess piece?

First close the top of the mesh, then put the Boolean modifier above the Subdivision Surface and use a shape like this one and it seems to work fine.  When you're glad apply the modifier and bring some corrections so that the mesh is clean: Quads instead of ngons, bevels to sharp the edges, etc...


How to add a submenu to "Object" -> "Set Origin"?

Adding a new op and / or overriding the old.
It is not a menu you can append to using method shown in linked answer. It is a menu created from the enum items available for type property of origin set operator.
layout.operator_menu_enum("object.origin_set", "type")

Not impossible, would need to overwrite (rewrite) set origin operator, or blenders UI code, both options I would not recommend. (Altering UI code is IMO a very slippery slope to go down) Writing a new operator with same bl_idname is a lesser of two evils. Low level versions of most options for origin type have been used as answers here. Do you want to go down this road?

In case that it is not that hacky, please show me an example to add a
menu there by creating a new operator with the same name

Ok let's go down that road. Overriding an operator is as simple as registering a new one with the same bl_idname

Ran the code first with bl_idname = "object.simple_operator" and the next time with origin set.  Simple is prepended atop menu, the latter replaces the enums of original in menu
The example below uses the simple operator template.  The options for the type property of the original are used to build the items of the new.
Have only added code to change origin for bottom center (using code from https://blender.stackexchange.com/a/42110/15543 )
NOTE: test code below overrides the origin set operator.  Will most likely need to restart blender to get the old one back.
import bpy
from bpy.props import EnumProperty
from mathutils import Vector, Matrix

def origin_to_bottom(ob, matrix=Matrix()):
    me = ob.data
    mw = ob.matrix_world
    local_verts = [matrix @ Vector(v[:]) for v in ob.bound_box]
    o = sum(local_verts, Vector()) / 8
    o.z = min(v.z for v in local_verts)
    o = matrix.inverted() @ o
    me.transform(Matrix.Translation(-o))

    mw.translation = mw @ o

def main(context, origin_type):
    ob = context.object
    if origin_type == 'BOTTOM_CENTER':
        origin_to_bottom(ob)
    else:
        print(f"Add code for {origin_type}")

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    #bl_idname = "object.simple_operator"
    bl_idname = "object.origin_set"  # override the old one
    bl_label = "Simple Object Operator"

    def items():
        items = []
        rna = bpy.ops.object.origin_set.get_rna_type()
        for i in rna.properties['type'].enum_items:
            items.append((i.identifier, i.name, i.description))
        items.append(('BOTTOM_CENTER', "Bottom Center", "Set origin to Bottom Center"))
        return items

    type : EnumProperty(
        items=items(),
        default=rna.properties['type'].default)

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

    def execute(self, context):
        main(context, self.type)
        return {'FINISHED'}

def draw_menu(self, context):
    self.layout.operator_menu_enum("object.simple_operator", "type")

def register():
    #bpy.types.VIEW3D_MT_object.prepend(draw_menu)
    bpy.utils.register_class(SimpleOperator)

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

if __name__ == "__main__":
    register()

Prepend another or overwrite the old?
Leaving the choice up to you. Not currently aware of a way to copy the execute method of a built in operator hence will need to rewrite each of the other origin types.  Some are covered in the links below.
My suggestion would be to not override, instead make a new operator that uses the bounding box as a coordinate system.  The origin (arbitrarily the) front bottom left corner and all other corners scaled such that opposite corner to origin is (1, 1, 1).  In this case bottom center would be (0.5, 0.5, 0)
The user could be given the option of choosing from predefined list (that sets the offset) or a custom option with popup to set the offset themselves. eg origin a third along bottom front edge of bbox set offset to  (1/ 3, 0, 0)
Related
How to compute the centroid of a mesh with triangular faces without using Blender's built-in functions?
Get center of geometry of an object
https://blender.stackexchange.com/questions/161823/origins-to-the-down-of-the-object-by-default/163258?r=SearchResults&s=6|8.6222#163258
Setting mesh's origin in python (2.8)


How to sculpt and move that figure around

In Sculpt Mode there's a relatively recent addition called the Pose Brush.  It attempts to move parts of your model as though you had rigged it with a skeleton.


Well I dunno how you got into this situation, but @cegaton is right, "Remove Doubles" will help.  In this case I had to bump up the Merge Distance to .06 to remove what looks like all of the doubles, although it's hard to be certain.  And then I had to recalculate the normals.


How to make procedural textures to follow geometry?

Using UV mapping, This is often the most straightforward method since you can edit UV's directly and preview the changes realtime, However you only get 2D coordinates, but you have the advantage that the coordinates are editable and are stored per face-corner (they dont have to be contiguous). UV's are also well supported by many formats, game-engines and render-engines.

if your mesh has primarily a grid topology, then try the Follow-Active-Quads tool from the unwrap menu.

Using Generated mapping, this works when you deform a mesh by a modifier (ShapeKey, Lattice or Armature for example), the un-deformed mesh is used for texture coordinates.
Using TexMesh, see Mesh Data properties, This allows you to select another mesh to use for texture coordinates, this gives a lot of control but the vertex indices must match up. These have the advantage of allowing you to set XYZ coordinates, but you have to take care not to add/remove vertices from the mesh. While useful, this is a Blender specific feature.


Divide a face into multiple vertical edges

I figured it out.

Ctrl+Tab to select Edge mode.

Select the two horizontal edges and choose to Subdivide under Mesh tools. Number of Cuts will dictate the vertical edges.


How to round a plane to a sphere surface

I guess the easiest way is to extrude and bevel. You can tweak the shape in the Operator box, or scale later on the Z axis:

You can also customize the profile of the bevel in the Operator box:

To illustrate John Eason solution, you can inset your top face (i):

Then bevel (CtrlB) to create additional edges:

Enable Proportional Editing (Sphere mode) and move up the central face:

Tweak the parameters in the Operator box if necessary:


You can achieve this usign math nodes:
Click for full size

Edit:
I have just seen you can even leave out the modulo operation. I thought it would make the coordinates repeat between 0 and 1 but it just does nothing.

Here is the .blend file for you.

What this node setup does is basically flip the UV coordinates when the image border is reached.

Result (with multiple flips):


Cloth simulation doesn't work with collision

I have made some changes. Also cranked up the quality settings a bit so if your pc can't handle it, just pull those back a little.
I have pinned the top and some other simple settings. I also changed the shape of the legs very slightly so the pants wouldn't pass through on some places.
The edited blend file


You may do it by increasing the Curved Bones segments number or using the Spline IK bone constraint.

In the Armature Data header change the bone display type to B-Bone. Then in the Deform panel of the Bone header increase the segments number for each bone. Play with Ease In and Ease Out values to control the smoothnes of a bend.


addon_utils

  Blender has a module it uses for addon management called addon_utils,
  this isn't in the API docs and is only for internal usage. But its a
  fairly straightforward
  module.

Disable all addons

Will call unregister on all registered addons.

from addon_utils import disable_all
disable_all()

Reset all addons

from addon_utils import reset_all
reset_all()

both two liners can be run from text editor, or python console.


The rendering process gets stuck, or sometimes I get a black screen

The file renders fine. But you are needlessly taxing your machine with too many subdivisions on the subsurf modifier:

BE CAREFUL! In my experience going over 3 is not necessary and does have a huge impact on the computer's performance. Keep in mind that for every subdivision the number of polygons at render time increases exponentially.
Form the manual

Great levels of Subsurf demands more video memory, and a faster graphics card. Blender could potentially crash if your level of Subsurf surpasses your system memory.
Note about potential crashes: Be aware that the Subsurf Modifier will need more and more memory at higher levels of subsurf, and the more dense your base mesh, the more memory you will need. In 32 bit systems, Blender could potentially crash with malloc errors, when you surpass 2~3 GiB of memory used. This is not a Blender bug. Blender, when paired with a 64 bit system, could use 64 GiB of memory, thus reducing the chances of malloc() errors.

Same scene with 3 levels of subsurf

And with only 2

click on image to enlarge


Particle Effect Hair - Grows randomly during animation

You can use a lower Stiffness value in the hair dynamics settings (less than 2) for short hair.


How to keyframe the image sequence offset using Python?

In general, set the property's value and THEN insert the keyframe with that value (mentioning the frame number). The value needs to match the property type. In your case:
Step 1 -
bpy.data.materials["Testing"].node_tree.nodes["ShaderNodeTexImage"].image_user.frame_offset = 1

Step 2 -
bpy.data.materials["Testing"].node_tree.nodes["ShaderNodeTexImage"].image_user.keyframe_insert("frame_offset", frame=1)

Which sets the frame offset to 1 for ShaderNodeTexImage at frame 1, for Testing material.
For objects, it's a bit different, but the concept is the same -
bpy.data.objects["obj_name"].hide_render = True
bpy.data.objects["obj_name"].keyframe_insert("hide_render", frame = 100)

which hides the object in render, at frame 100
The API documentation is not explicit about all this, but you have to connect the dots by understanding how Blender API is structured and how Python works. Refer:
https://docs.blender.org/api/current/bpy.types.ImageUser.html?highlight=frame_offset#bpy.types.ImageUser.frame_offset
https://docs.blender.org/api/current/bpy.types.bpy_struct.html?highlight=keyframe_insert#bpy.types.bpy_struct.keyframe_insert
This module is used for all Blender/Python access:
https://docs.blender.org/api/current/bpy.data.html
Play around and practice, self learning is best learning :)


A noise texture which fac is clamped by a less than reduces the influence of the second input of the add rgb.

More generally:

A noise texture is kind of random pixels, specially at high scale. From that, if we clamp its result by a less than or greater than (or colorramp), then you will pick a partial amount of this randomness.

In particular here, that gives us less stars.


I finally solved the issue. The solution is to split the normals, which I assume means telling Blender to stop the 'connection' between the two types of normals, face and vertex:

Enable 'Custom Normal Tools' in Add-Ons
Create an inverted sphere
Enable 'Auto Smooth' in Object Data
Add the 'Normal Edit' modifier to the inverted sphere
Add an empty object in the center of the sphere
Use Empty object as target in the Normal Edit Modifier with the following settings:

Radial
Mix Mode: Subtract
Mix Factor: 1.000

Source: Custom Split Normals (Blender wiki)


Animate a Bezier curve deforming a mesh, without the mesh awkwardly rotating

It is doable as scripting, probably using to_track_quat way.

but an easier way is to use Animation Nodes ad on.
That is a visual / nodal scripting tool really.

There you have a set of spline tools to deal with bezier from creating  to extracting data in any way. More than usual Blender tools.

Specifically for this orient/twist situations, there is a Direction to rotation Node that turns 2 vectors into rotation. Unlike the Blender "Z up" to track quat , it provides a second "guide" direction that can be related to anything.
(I redesigned that node precisely for these problems)

In the example file, one orientation (Z) is the tangents, the other (Y) is controlled by the empty in the back.

-

Here's a file with a possible setup do do what you need.
spline deform AN

You need Animation Nodes to make it work.

A very basic setup, cause you can further combine or animate those too. Or, for example may deform only the points closer to spline, not the far away (as xy here) or vary the second rotation along the spline etc.


use pin.

in uv editor get 2 connected vert and make them aligned on an axis
then press p to pin the 2 vert.
unwrap model
un pin with alt + p
scale acordingly


How can I make a line of vertices round?

If you don't mind not using the original vertices, I would add a circle (ShiftA >Add circle) in edit mode, so that it's added straight into the current object.

If you want to keep the existing verts, you could try using the To sphere operator (AltShiftS), or the circle operator in the bundled loop tools addon (you will have to enable in User prefs > Addons).

In the above example I first rotated one of the end verts with proportional editing enabled (O), to give it a semi-circular shape. This makes it easier for the circle operator


having trouble getting rid of unwanted vertices

If they're close to useful vertices you can try remove doubles, if not you can select an useful vertex, then press Ctrl L (select linked) then press H to hide them; if the mesh has more useful parts go on and hide all useful vertices, then A to select all (unuseful) and X to delete.


So there might be a number of things that are happening. Firstly, I would just create a folder and set it as the location where it saves all the rendered images. I personally don't like using the temp folder because there might be other stuff in there. Then you need to go to the Video Sequence Editor and select "open" and select all the images you rendered and the play it.

Here is a Tutorial

The other thing that is unlikely is maybe something is in front of the camera that is hidden to the viewport but isn't hidden in the render check this in the Outliner. If you want to do a test animation to see how things look just lower the settings and samples and then put it together and see how it looks or you can just play the animation in the viewport. Hope this helped, best of luck to you.


I think you might have hit Extrude once, and not moved the mouse and now there are duplicates of every vertex. You can remove doubles and Extrude again, should work fine.

This is what you're seeing:

Select everything, press W -> Remove doubles. Then try to extrude again:

This is what you want to see


Creating a tapered pattern in shader nodes

Depending on the direction of your UV mapping, you might have to switch X and Y in this kind of set-up, which follows your modulo + color-ramp method as far as possible:

Any other method which makes the Less-Than threshold depend on a  dimension orthogonal to the one whose modulo is taken will do the same.

This tree also makes the period, base, and amplitude of the triangle-wave adjustable.


Why won't the compositor backdrop show the current composite result?

The issue stems from having rendered the animation as a series of .pngs, then loading the .pngs into the video sequence editor to test how the finished work looked.

If Blender has a video/image strip loaded into the VSE, it will not render an image to the Render Layers as it knows that the VSE strip will ultimately overwrite this information.

Instead, the Render Layers node in the compositor will appear empty or blank, as in the image at the bottom of my question.

Hiding the strip in the VSE will not solve this problem. Either
1) in the Render tab of the Properties Editor, open the Post Performance panel and untick 'sequencer' or
2) delete the image strip in the Video Sequence Editor.

Hitting render should now cause your Render Layer to show your expected image.

Annoying, and not especially evident to the user, but it makes sense. =)

I found my solution on this page: http://blenderartists.org/forum/showthread.php?274922-Camera-Tracking-render-layers-blank-source

Happy Blending!

--Rev


How to display F-stop limits in viewport?

Depth of Field Utilities Addon

This Add-on allows to visualize the Depth of Field limits (near limit & far limit) in the viewport:

Once the Add-on is enabled, select the camera, open up the Properties region of any 3d View (N), scroll all the way down to the bottom and enable the visualization. From there you can fine tune all relevant properties of the selected camera:

Notice that you can disable the instructions to hit Esc in the Add-on Preferences if needed.

In addition to that, you can also set the focus distance by using the 3d Cursor:

Further reading: How do I set focus range?


How to use camera distance to mix textures?

You can use the camera data node to control the mixture of two nodes (color mix or shader mix).

Mix nodes expect information on the 0 to 1 scale, so the distance information will need to be scaled somehow or you need to define a threshold for the transition.

As an example: With a math node in "Less Than" or "More Than" mode you can create a distance threshold for the transition.

For a more subtle transition you can use a gradient texture:

Notice that you can usel Z depth as well and use a multiply node to control the transition point.

And for more control a color ramp.

For more info read : Using the Camera Data Node


I just started doing research on this subject. I would try a program like "Gopher360" you can do custom keyboard and mouse binds with a Xbox controller. It's not through Blender but it should get the job done in theory.


Can't animate location of characters in text individually

All the letters have strips in the NLA Editor which share the same action:

But this action contains nothing so it looks like the letters aren't animated. For this same reason you can use Remove Emtpy Animation Data option to remove all the empty strips:


How to use actuator as sensor to play animation of my character?

What I would do is give each person a status property.

A sensor tests the status and while it is 0 have them play an idle action.

A message sensor then receives an evacuate message and sets the status to 1.

When the status is 1 play an evacuate action or use steering to seek the evacuation point.


How to Cache Frames Faster in Movie Clip Editor?

Don't worry, I'll just split the video into two parts.

Thanks anyway.


Animating car wheels, Separating object, Splitting a UV map

If you rotate the wheel in edit mode the coordinates of the verticies with respect to the UV are going to be rotated. I think you should be able to separate the wheels into a new mesh, then [TAB] out of edit mode and rotate the wheel. Just going by your pictures.


The Orthographic Scale factor represent the maximum dimension (in scene units) of the portion of space captured from the camera.

So a scale of 1, means that a square plane whose size is 1, would perfectly fit the camera's view in the mayor dimension (for the default 1920x1080, the wideness).

If you double the scale, you'll get half dimension (1:2 scale) because the way it's mean to work like the traditional scale map. Maybe it's even easier to think in these therms:

  The scale of a map is the ratio of a distance on the map to the corresponding distance on the ground.

About your specific problem, I think I would suggest the following workflow:

Match the camera's and reference image proportions and import as background image
Align the view
Tweak the scale factor till you are satisfied


There is a missing part at my object when I render in cycles

I don't entirely understand what you were doing with the troubleshooting, but the problem may be the camera clipping.

In the Properties Panel (N while cursor is in 3D view) you can change the viewport clipping.
By selecting the camera and going to the camera properties you can change the camera clipping.

Increasing these values will allow more of the scene to be rendered.


Increase the contrast of shadows like you would using a color ramp

You can use this setup to control the contrast of the shadows. In the image I provide, I mix the shadows with a texture, but you can use a color just the same. Also, because my example is for toon shading, I have the ColorRamp set to "constant", you probably want something more like "Linear", "B-spline", or "Ease". Lastly, the reason I multiplied it twice was to darken the shadows even further because they didn't turn out well in screenshots. Use as needed.


Someone will tell if I'm wrong but it looks like there's no easy way to do it. In this question they talk about an Offset Tool but I don't find it.

You could do it this way, but at the end you will need to convert your curve to mesh:

Select your curve, go in the Properties panel > Geometry.
Play with the Extrude value.
Duplicate your curve with shift D and Enter.
Play with the Offset value of your second curve.
Convert your curve to mesh with alt C.
If you decide to come back to curve, again alt C. As you will have a lot of vertices you can use the Simplify Curves addon (play with the values on the bottom of the T panel).

You could also directly convert your curve to mesh, then extrude your mesh on the Z axis, and alt S (shrink) the shape. Then convert back to curve if you need, and again, use the Simplify Curves addon if you want to limit the amount of vertices.


If you are asking for backlight - ambient light behing a TV lightning a wall ...

add Area light between TV and wall that works for Eevee and Cycles

Cycles

Eevee

Using emission material require Light Probe - Irradiance Volume for eevee engine that seems to be too short distance between emiter and receiver, so probably harder to setup.


Problem understanding how to UV unwrap for bump and color material

You can add up to 8 UVMaps in the Object Data Properties panel and use them independently in the Shader Editor. As you can read in the manual, each UVMap contains every face of the model, so if you wont unwrap any of them they will be at the bottom left corner in the UV Editor, so those whole faces will get the value of the bottom left pixel of the texture image. So I don't think this would be the optimal way for you. May be it would be better if you create a mask for the bump map.


After fiddling with this issue, I found out this is a bug. I uninstalled Luxrender, removed the add-on from Blender, restarted my machine and installed a different version. Using Luxrender 1.6 test version No OpenCL, I have the Light Groups available in Render Layers panel. The Materials Panel preview is still black. I couldn't find a Group Node (maybe just because I'm unfamiliar with Lux), but if I don't use Nodes, I can create Light Groups in Render Layers panel and assign light materials to the Light Groups.


I merge 2 vertex and become weird ,How can i fix?

To me, it looks like you have not cleared one side of your mesh before setting up the mirror modifier.
So if you still have both sides of the mesh and you're trying to merge things from both sides, the result is quite straightforward.

The mirror modifier is meant to literally duplicate symmetrically your mesh. Its purpose is for you to handle only a fraction of the mesh. But you have to cut out the part you want to let to the mirror modifier first.

So, if that's the issue:

In edit mode, Numpad 1 for front view, use Z to set the wireframe mode (it will allow you to select hidden geometry).
Select one side of your mesh up to the center with B and delete it.


How do I choose the next item after using Autocomplete in the Python Console?

The autocomplete functionality relies on uniqueness.

So bpy.ctrl+space
lists all the objects in the bpy name space.

And bpy.octrl+space
results in the single value ops as nothing else starts with o

When the match is ambiguous e.g. bpy.pctrl+space
you get two results

ath
rops

(for path and props)

There is no way to use keyboard shortcuts to select the correct entry, but if you double click on the item you want the entire item will be selected and then you can copy and paste ctrl+c, ctrl+v.

Remember Blender is open source, so in theory you could submit a patch that would add additional functionality to the Python console.


You should be able to achieve this by using a custom transform orientation.

With your object selected, tab into Edit Mode. Select an edge that you want to scale along.

For example:

Then, still in Edit Mode, click the [+] symbol under Transform Orientations.

This adds the selected edge as a new Orientation.

It is handy to give it a name under the tool shelf on the left side.

Now you will see this:

 and

Finally, select all, hit S to scale and then TWICE the axis the points in the same direction as the edge you selected and -1 on your keyboard.

In my case it is the y-Axis.

So I would hit S,y,y,-,1.

Before:

After:

On the bottom left you'll see:

Unfortunately, that will mess with your Normals. To solve that, simply hit Ctrl + N. In my case, I had to manually select and flip the Normals inside the B's arcs.

Not a big problem, but if anyone knows how to get around this, please comment.

Result:


Ok, So I found a solution, Normals > Autosmooth > ON
the problem is now non-existent...


To make the pond shape, start by subdividing a plane (the less the better - you will see why later). Make your rough "splat" shape by selecting the faces that won't be part of it and deleting them.

Because the plane is subdivided, it will become "blocky looking" if and when we add a Subdivision Surface Modifier, so the first step is to reduce the subdivisions with a Decimate Modifier set to Planar. (This is also why it is better to have less subdivisions, because the points around the edge contribute to the interpolation of the edge (or lack thereof) and will also cause unwanted blocky-ness - fewer points means smoother curvature )

Next add a Subdivision Surface modifier to smooth out the edges as just discussed:

For the material, I suggest using this setup for your water surface. The "depth" of the water can largely be altered by changing the IOR of the Refraction Shader. Don't forget to change your Blend Mode if you're using EEVEE. I also notice after I uploaded the image, the top Node that serves as the Mix Factor between the Diffuse and Glossy shader is cut off - it is a Fresnel Node.
You can see as well that I made the surface by using a Noise Texture, with it's effects softened by being mixed with white using a MixRGB Node_ before connected to a Bump Node and then a Displacement Node. The settings for the Noise Texture I left largely at the default, but play around and see what kind of surface looks best.

If you want a more "real " extruded look to the surface, you can actually select the whole plane and extrude it downwards slightly if you don't mind the extra geometry.

Here is a final result (lit with an HDRI). In this example, I increased the mix factor with white on the displacement to further soften the surface to create a more realistic look. (This can also be achieved by changing the Detail and Roughness on the Noise Texture, as well as controlled somewhat by adjusting the strength or the distance of the Bump Node - play around and see what looks best for you).