BakeTool addon can handle it !

There is a mode that i haven't try yet, which is the Atlas mode (default is individual).
The support of baketool answer me :

  There’s a “Target” option in the Atlas Mode. It works as the “Selected
  to active”. On this mode all the objects in the Object List are used
  as sources and the target is the “actived” one to be baked. See that
  in this case the target need a valid non overlapped UV.

I definitively love this addon, anyone who use blender and make realtime 3d should have it :)


Although I am not 100% sure which things you are envisioning going on which axes, one way to render a sort of "nest" using a strand object is to create curves (e.g. bezier curves) that define where the strands will lie.  Then create a mesh object that is a cross-section of the strand and give it your material.  Make sure to apply location and rotation (but not scale) to your curve objects.  Then, starting with the first curve:

create a duplicate of your cross-section object.
give it an Array modifier, check "Merge", Relative Offset X:1, Y:0, Z:0, fit type: Fit Curve, and specify the first curve object.
then give it a Curve modifier, again specifying the first curve object.

If all has gone according to plan, your curve is now "stroked" with your cross-section object.  Then repeat for each additional curve in your nest.

Nest with Vertical Strands:

Nest with Horizontal Strands:

It will be easier if you duplicate the last cross-section mesh you modified, because it will already have the modifiers applied, you just need to update the curve objects the modifiers are using.

The nice thing about this is you can modify your curves to create a "weave" effect, which can be considerably handier than trying to smoothly deform the meshes.

When things are to your liking, you can apply the modifiers (and remove doubles, there will be a LOT of doubles) and the resulting mesh objects can be further modified . . . for example you can join the strands into a single weave object deform it along a curve with another Curve modifier, which might come in handy in making something like the image you provided.

A different technique would be to simply bevel your curves with a curve that represents the cross-section of your strand.


Easy peasy...that's just Anisotropic glossiness.  Just set Anisotropic to 1.0, and then play with the Roughness value to get the look you want.  No tutorial needed!

EDIT:

Use a Tangent node to control the axis of the anisotropy:


Bmesh script.

Script to bisect each selected mesh globally 3  units above its bounding box lower corner.
Edit height = 3 to adjust.
Test script, select any or all of the objects to bisect, in OBJECT mode and press run script.
import bpy
from bpy import context
from mathutils import Vector
import bmesh

# global coordinates
height = 3
plane_no = (0, 0, 1)

meshes = set()
bm = bmesh.new()
for ob in context.selected_objects:
    if ob.type != 'MESH':
        continue
    me = ob.data
    if me in meshes:
        continue
    meshes.add(me)
    bm.from_mesh(me)
    mw = ob.matrix_world
    bbox = [mw @ Vector(b) for b in ob.bound_box]
    h = (bbox[1] - bbox[0])
    if h.length > height:
        print(f"Cutting {ob.name}")
        print(h, h.normalized(), bbox[0])
        mwi = mw.inverted()
        bbox[0].z += height
        bmesh.ops.bisect_plane(
                bm,
                geom=sum((bm.faces[:], bm.edges[:]), []),
                plane_no=plane_no,
                plane_co=mwi @ bbox[0],
                )
        bm.to_mesh(me)
        me.update()
        bm.clear()
bm.free()


The material provided by your importer may need a small adjustment to display the 'vertex_colors' layer when you switch over to Cycles Render engine.
Ideally you should be able to import the .wrl while already in Cycles Render engine and let the importer set up the material correctly -- but at present this is not the case.
A solution is to add an Attribute Node to the Cycles material Node Tree and write Col into the name field. This won't display properly in texture mode, you must set the viewport shading to Rendered, or currently you will only see black.
steps

Import the .wrl as normal

Create a node material for the object,
2a. With the object selected, open a Node Editor
2b. set the Node Tree view type to Material
2c. Tick the box labelled Use Nodes

Add an attribute node, and write 'Col' (without quotes) into it as in the picture.

Hook up the output of the Attribute node, to the colour input of the Diffuse BSDF  node.


"L" select connected selection tool doesn't work

There is a cursor proximity thereshold in the "Select Linked".

If you are in vertex mode, the cursor must be near a vertex to catch the vertex. It won't work if none of the object's vertices fall into the cursor's radius (e.g. if it is in the middle of a big face)


Particle system and controlling the collision on surface on/off dependent on the emitting geometry?

Final:

Overview:

You can use Collision Groups to choose which Emitter will collide with which surface.

In this example I've created 3 Groups.

Blue Emitter with blue Collision plane.
Red Emitter with red Collision plane.
Green Emitter with green Collision plane.

Last thing to do is to choose in respective Emitter under Particles tab > Physics section desired Group.


It is a plane that defines where the most of environment light will come into the scene, so the renderer can sample light more efficiently.

Usually speeds up indoor rendering. The sample takes longer time but the noise will clear out after fewer samples.

Multiple light portals can be used, but it's only good to place them on the main light sources - like windows (or a TV if it's the main source of light in a night scene).


How do the AV-sync, Frame Dropping and No sync in Timeline work?

They come in help when the animation is too heavy to handle realtime reproduction, affecting only the 3D viewport, not the renders.

No sync means that every frame in the viewport is showed as soon as possible, and a number in the upper left corner of the 3D view tells you the frame rate actually being reproduced: if white everything is OK (I.E. 24 FPS - default), if Red is slower (Maybe 4.67 FPS).

Frame Dropping means that the FPS is always the choosen one (24 - default), and blender jumps from a frame to another trying to remain in sync, actually not displaying (dropping) all the frames between.

AV Sync is used in combination with the VSE, assuring corrispondence between the 3D frame and the VSE frame.


How to create a mesh with two shapekeys using extrude and bevel modifier?

Animate the modifier props.
To elaborate on @Gorgeous' comment.
Make your mesh, for example sake added a default circle, then grid filled. Note to self,  rotate after grid fill to match axes before adding shape keys in future,
Create your shape key from this. Super fast hacked together example, showing my lack of modelling with bevel modifier, however shows proof of concept.

Now add your modifiers to this object. Solidify and bevel.

any of the modifier properties can also be keyframed or driven.

Ugly example, but you get the concept,  with solidify thickness being driven directly by shapekey value, and some bevel modifier properties too.


Use a Geometry Node to control the Mix factor between two shaders in a Mix Shader node. Use the Backfacing socket to set one shader to the backface of the plane, and the other is set to the front face.


Is it possible to reload an image directly in the 3d view?

An ugly method (but possibly enough for your needs)
If you just have a few images and they aren't giant. You can reload all images, (The update becomes visible after moving 3dview around a little)

import bpy

bl_info = {
    "name": "Refresh Images",
    "version": (0, 1),
    "blender": (2, 76, 0),
    "description": "Refresh images",
    "category": "3D View"
}

class SimpleImageUpdater(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "view3d.refresh_images"
    bl_label = "Image Refresher"

    def execute(self, context):
        for img in bpy.data.images:
            img.reload()
        return {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

Auto updating version of the execute function

def execute(self, context):
    for img in bpy.data.images:
        img.reload()
    bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
    return {'FINISHED'}

it should look like this: https://gist.github.com/zeffii/6189c3be154ad67f1592


When I bake a specular map out from Blender they always contain the glossy colors?

Bake the Specularity data, not the light interaction

According to the Wikipedia, specular maps contains the valuest that:

  represents the amount of reflectivity a surface has.

These maps are used in order to give to the rendering engine the information about how the light should interact when hitting that particular pixel of the surface.

What you should bake is the data about where a surface is capable of reflecting light and where is not, and not how the light interact with the surface (Glossy color, Glossy Direct, Glossy indirect, Combined....) because these are the result of the render engine.

Let's consider a simple material made of a Diffuse and Glossy shader mixed with a musgrave texture:

In this case it's easy to understand that the amount of Specularity is equal to the values that go into te mix shader factor. Where is black is Diffuse (no Specularity), where is white is Glossy (Specularity).

To bake that data just use an emission shader picking the color from the cable that is going into the mix shader's input socket

Here's the counter-prove. The baked map is now controlling the specularity of the surface as the musgrave was doing before.

For complex shaders things becomes harder, you'll have to build a custom nodetree capable of exctracting the Specularity data on each passage (e.g. if you are using multiple mix shaders).


Thanks!
I ended up emailing every Render Farm I could find. Render Street was the only one that got back to me with a 100% yes.
If I get any more positives, I'll add them to this thread, just in case.


Blender - How can I create proper lighting using Radeon ProRender?

I guess you should refer to Radeon ProRender user guide, for a start...

The RPR EMISSIVE material should be what you are looking for...

To get RBR support, I suggest to refer to the specific RBR for Blender support page


I fixed this by duplicating the mesh i wanted to create the map for, deleting the armature modifier altogether, and applying the subsurface modifier, and then the map baked perfectly. I... don't know why this worked. If anyone knows the reason this happens it would be much appreciated.


How to use a constraint to make a roller paint animation?

You can make the stick movement control the rotation of the roller:

Create your object, parent the roller to the stick:

Give your roller a Transformation constraint with this kind of setup: Stick as Target, Extrapolation on, Target and Owner > Local Space, Map From > Location with the stick local movement orientation as axis (choose for example -1 and 1 as value, anyway it will be extrapolated), Map To > Rotation with the roller rotation movement axis as destination axis, don't forget to select the target location axis as Source (and choose the rotation value that will match):

Move the stick, the roller should rotate according to the stick speed:


The manatee model has no UV map. So Blender does not know how to use the texture image.

You can either create a UV map, or change the vector input of the image texture node.

Below, add a 'texture coordinates' node and plug object or generated output to the image texture node.

Then change projection method to 'box'.


My mesh is partly hidden in the viewport

You've accidentally pressed AltB, press again to cancel. AltB (Cliping Border) allows you to see only a part of your 3D view.


Particle's material color only changes in Material View mode, and not when rendered

The problem you are facing is mentioned on the manual page for the particle info node:

  This node currently only supports parent particles, info from child
  particles is not available.

Because you are only rendering child particles rather than the parents, you encounter this issue. If you Shift+Ctrl click this node to see all of its outputs, you will see that they all show up black in the rendered mode of the viewport. IDK why exactly it is showing up correctly in the viewport in material mode...

To fix it, you obviously just switch to only using parent particles in the particle system, or find some alternate way to achieve the effect you are seeking.


I agree, it seems counterintuitive, how SX-1 or ⎈ CtrlM work in this case.

You can always apply a mirror matrix to the object matrix. Simply select the object and execute the following script.

import bpy
import mathutils

ob = bpy.context.object

mat_mirror = mathutils.Matrix.Scale(-1, 4, (1.0, 0.0, 0.0))
ob.matrix_world = mat_mirror @ ob.matrix_world

# For Blender 2.79 and previous, use the * symbol for matrix multiplication.
#ob.matrix_world = mat_mirror * ob.matrix_world

With mathutils.Matrix.Scale(-1, 4, (1.0, 0.0, 0.0)) we construct a matrix scaled -1 along X.


Blender (2.8) won't retain child/parent relationships when linking / duplicating between scenes

One way is to select both the Parent and the children, so the relationship is kept.

But Blender also remembers the relationship, so you can move parented items one by one.

It works reliably in the Outliner (Collections and Scenes) and also simple copy/paste in the 3D Viewport.


blender2ogre 0.5.8 export error - ReferenceError: StructRNA of type Mesh has been removed

It could perhaps help to update your version of the Orge3D exporter from 0.58 to 0.60 from  the bitbucket page. It seems the version you use (0.5.8) is written for blender 2.65 and the latest 0.6.0 version supports blender 2.66. Failing that I suggest taking steps to contact the guy who currently maintains the addon for advice.


Coordinate UV option is missing under Mapping

Check under what context you are adding your texture into, you can only add UV mapped options to textures added to a material.

You are probably adding a texture to the world or brush context


How to key frame a clear action parent/child and change pivot point

A "Child Of" constraint will let you do what you want, if I've understood your question rightly.
In the constraint settings is a slider for Influence which can be key-framed (by right-clicking in the influence slider and choosing "insert keyframe"). A setting of 0 influence means the child will not follow the parent, and 1 means the parent affects it 100%.  You can have two constraints on the child so it has 2 parents - one with influence set to zero until you need it to take over influencing the child.
This constraint has location, rotation and scale axes which can be keyed by right-clicking in the box and selecting Insert Keyframe.

Edit: where it says "to to" in the picture, it should have said "go to"

Then click on those arrow heads next to there where Add Object Constraint is written, and you'll find the Child Of constraint.


You need to change this line. You declared your time variable with a capital T.

float timeOffset = time / 15.0;

You should change it to this

float timeOffset = Time / 15.0;

To animate the the time value in your script node and press I to insert a keyframe.  The field should turn yellow.


Update mesh after using bmesh in object mode

Try:

# need to update here
bm.to_mesh(me)

But then you'll need to switch to edit mode to see the selection.

As an alternative, you can do the selection entirely in edit mode with the following:

mesh = bpy.context.object.data
bm = bmesh.from_edit_mesh(mesh)

bm.edges.ensure_lookup_table()
bm.edges[2].select = True

bmesh.update_edit_mesh(mesh)


Crl+F3 is the shortcut to save images from any screen.

Alternatively, in the preview window you can press the camera button to render the active viewport. The rendered image will then be available in the UV/Image viewer, where you can then click View->Save As Image (or Crl+F3)


I think you might have a duplicate ground plane in your scene that is hidden in your viewport (which is why it does not show up in the viewport rendering). If that is the case, it will still be rendered because the F12-rendering does not ignore hidden objects.

If the plane has a white material and is in exactly the same z position, it will be in conflict with the textured one. As a result, faces will show pretty much randomly from either of the two objects, creating the pattern that you can see in your rendering.

You can unhide all hidden objects with Alt+H in the 3D View.


How to use the new render pass API for an external renderer?

Thanks to brecht's explanation in IRC I can now answer my own question:

Custom passes in compositor

update_render_passes is called by the compositor to display the custom passes as output sockets. In this method, register_pass should be used.

Example:

def update_render_passes(self, scene=None, renderlayer=None):
    self.register_pass(scene, renderlayer, "Combined", 4, "RGBA", 'COLOR')

    aovs = scene.luxcore.aovs

    if aovs.samplecount:
        self.register_pass(scene, renderlayer, "Samplecount", 1, "X", 'VALUE')
    if aovs.shading_normal:
        self.register_pass(scene, renderlayer, "Shading_Normal", 3, "XYZ", 'VECTOR')

Custom passes in image editor

add_pass on the other hand should be called at the start of the render method to add custom passes (before writing data into a render_result).

Example:

# Note: the Depth pass is already added by Blender
# If you add it again, it won't be displayed correctly
# in the "Depth" view mode of the "Combined" pass
# in the image editor.

aovs = scene.luxcore.aovs

if aovs.samplecount:
    self.add_pass("Samplecount", 1, "X")
if aovs.shading_normal:
    self.add_pass("Shading_Normal", 3, "XYZ")

I hope this helps other developers of addons for external render engines.


How to animate the disappearance of a mesh

To get the cleanest result I suggest animated booleans. Since you have flat shading you wont get any shading artifacts, this is probably the textbook example for them. If you have some subsurf and displacement apply them or put the booleans after the displacement.

There will be 2 boolean objects.
- First one is static and will create the hole in the ground (highlighted). Put some edgeloops in the ground object around the trench so this boolean wont segment the whole thing.
- Second one can be just an animated cube and will intersect with first boolean object and the concrete wall inside trench. The bigger the intersection the more ground will be removed and more concrete wall will be shown.


Solidify a complex hollow object in Blender

Solid is a relative term : ) especially in 3D computer graphics. Everything that looks solid in (almost) any 3D environment on a computer is made up out of points(or vertices) in space with lines(or edges) between them, with planes(or faces) filling up the space between the lines. But nothing visually fills up the space between these elements, and it is essentially a shell. Even though properties like volume and mass are used in physics simulation, this shell is (partly) used to derive values for such properties. So there is no need for "solidifying the inside".
The Solidify modifier is a modeling tool and can be used to create such a shell around a mesh that might otherwise not be considered solid, like a plane with no thickness. The Solidify modifier can give a plane the appearance of a box which has thickness, and if it has no holes anywhere in its shell, is considered solid.


It looks like an inverted normal to me. Go into edit mode, hit A to select everything then hit Shift+N to recalculate the normals.


How to edit gaming videos for youtube with blender?

Blender has a VERY steep learning curve when it comes to video editing. You should have some basic knowledge of blender before editing videos. But I have found this good tutorial, it should be easy for beginners, and it's up-to-date.

https://www.youtube.com/watch?v=42AQ_EtRVq4

If blender is too difficult I would recommend Kdenlive.


Weird shading effects when rendering at long distance

If you change the start clip distance on the camera to a higher number the black edges disappear.

The reason for this has to do with how blender approximates the calculations for the Z-Depth within the clipping distance.

It's very well explained here: http://blendermama.com/black-faces-error-from-camera-clipping.html

In this other link: https://discoverylinux.wordpress.com/2011/10/08/guida-eliminare-il-flickering-in-blender-2-5/ the author recommends keeping the start and end clip distances to contain only the geometry in the scene for better precision.


Is there a hot key for switching between 3D Object and Sculpt modes?

You can drag the mouse in the direction of the option of the pie menu while holding Ctrl+Tab and once you release it with the mouse moved in the direction of the option you want it will get chosen. That might be more convenient.


In blender cycles, you have to use attributes in the node editor to make flames and/or smoke visible.

This Image shows is an example of how you need to set up your smoke.
To add flames and make them look good, you can follow this video tutorial.

https://www.blenderguru.com/tutorials/make-fire-cycles/

Much fun!


How to make an object stay inside another object?

This is a perfect case for Parenting objects.
Set your drawer as a parent to the jewels, and they'll move with it.

How to
Select the jewels, then select the drawer an set it as a parent.
Object > Parent > Object
Shortcut: Ctrl + P > Object

Objects with and without parenting.

Further reading:
Parenting objects in Blender Manual


Render Smoke split in background and foreground for composite with a recorded image

is the character moving or is it only a still ?
Maybe you can create something like a card as a holdout for smoke in the back ?


How do you find nodes in the animation workspace if scroll past them?

Just answered my own question, can't seem to find a way to get an individual node but selecting all then 'numpad .' works.


What is the simplest way of extracting the depth values of the scene?

I'm not sure I understood the request.
In case you intend to as depth values: values of the z-buffer of the camera
then the answer is easy.

you have to use this simple code:

#first import the libraries
import bpy
from bpy_extras.object_utils import world_to_camera_view

context = bpy.context
scene = bpy.context.scene

#create the def for take the z-buffer
def checkCameraView(cam, obj):
    for v in obj.data.vertices:
        x, y, z = world_to_camera_view(context.scene, cam, obj.matrix_world * v.co)
        print(z)

#select the camera
cam = scene.camera
#check every mesh type objects in the scene
for obj in scene.objects:
    if obj.type == 'MESH' :
        checkCameraView(cam, obj)

z is the depth of the vertex
x and y are the coordinates on the Cartesian coordinate plane (2D) of the chamber
x = horizontal
y = vertical

api link: world_to_camera_view

This was the question?


Here is one way: switch to vertex mode, select the vertex you want to move, and then edge slide (GKEY GKEY) it until it is adjacent to the node.  You now have a doubled vertex.  Select both vertices and merge them (ALT-M -> merge at center).  Alternately you can enable Auto merge before you edge slide.


Why importing transparent images as plane looks like an opaque plane?

If you have downloaded a texture make sure you have an opacity map downloaded along with the texture and then you can follow this node setup:(Make sure to delete the default node setup of the image plane)

this is an example for opacity map:
the area marked black will appear transparent
(WILL ONLY WORK IN CYCLES ENGINE)


BMesh: How to get a list of faces and edges, given the vectors (and delete them)?

I think that parameter geom is wrong.
geom (list of (bmesh.types.BMVert, bmesh.types.BMEdge, bmesh.types.BMFace))

import bpy
import bmesh

if bpy.context.mode != 'OBJECT':
    bpy.ops.object.mode_set()

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16)
bpy.ops.object.mode_set(mode='EDIT')

bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.mesh.select_random(percent=50.0, seed=0, action='SELECT')

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

list = [v for v in bm.verts if v.select]
list += [e for e in bm.edges if e.select]
list += [f for f in bm.faces if f.select]

bmesh.ops.delete(bm, geom=list, context=4)

bmesh.update_edit_mesh(me)


How to remove reflected light from glass? [Blender 2.92]

You can disable the direct light reflections by un-checking the Glossy Ray visibility in the Object Properties of the light (you will need to do this for each light you don't want reflected):


Is there a way to restrict the operation of a driver or even record the action of the driver in Blender

In pose mode go to Menu: Pose-Animation-Bake action. Check the visual keying option. Then you can use the newly created action on a copy of the armature without any costraint or driver.


Mirroring is a pretty simple operation-- you just take the absolute value of your coordinates-- but any transformations like this occur about the "0" point of the coordinate system.
For generated coordinates, the center of your coordinate system is at the lower, left, front corner of your object's bounding box.  If you just mirror about the generated texture origin, you'll only be affecting samples outside the bounding box-- it won't affect the visible model!  Likely, the point across which you want to mirror the gradient is the midpoint of your model, which is located at 0.5,0.5,0.5 in the generated texture coordinate space.
But you can change the origin point of transformations like this by moving the texture coordinates, applying the transformation, and then moving the coordinates back, like on the middle Suzanne:

Notice where it leaves the mirror line: in the middle of the gradient.  This can be addressed, if desired, by changing our mapping, such that we're mapping the center of the model to 0 and the outer edge of the bounding box to 1, as with the third Suzanne.
Similar techniques--translate, transform, untranslate-- can also be used to rotate or scale about different origins.


How to apply a uv map texture to a mesh when looking from the side, rather than for the whole mesh

I think what you're looking for is "Project From View". First, pick the angle you want to capture it from - in your case, the sides. I find the best way is to use an orthographic side view using Numpad 1 or 3 keys.
Then, in edit mode, select all the faces on the side of the "airplane" (you can use circle select to get them all quickly since you are in side orthographic - However, if there are un-viewable sides/crevices, make sure to manually inspect to make sure they're all selected - as you can see in my second image, I was lazy and only circle selected so there are some pieces missing.). Once you have the angle, and the faces selected, press U and select "Project from view". Do the same thing for the other side if desired (to quickly switch view to the other side, press Numpad 9).

On your UV map, you will have both sides selected (there will be other pieces too, but the sides will be captured "intact"). Move the other pieces as necessary (or give them a different material). You will then be free to align your "sides" with your image.

Note that if there is significant curvature in the selection you unwrap together, some areas could come out warped. If this is the case, you can select the whole section, while keeping a rectangle (or square) shape as the "active" selection, then pressing U to unwrap again, but this time select "Follow Active Quads". this will straighten out the section according to the shape of the quad you had active. Do this in the 3D viewport, not the UV viewport. The closer to a rectangle shape that is aligned both vertically and horizontally (ie ideally a perfect rectangle with 0 rotation - this is not always a realistic expectation), the better the results of this operation.


I can not have environmental map and volume lighting at the same time?

The light coming from environment map is infinitely far away, so it get's absorbed by any amount of volume.

Build a sky dome - sphere big enough with inverted normals. Assign and emission shader with environment texture node plugged into it with the hdr.

Set your volumetric environment like you want.

Tadaa! And yes, expect your render times to be infinite, hope you don't have any glass or glossy in the scene.)


3D slicing using Dynamic Paint leaves holes where there shouldnt be any

You could simplified file to make it smaller ... just a Plane and one problematic stone, like that you could notice it works. So why it is not working in group? I would say for its overlapping geometry.
I can imagine that hole in place of crossing stones , but it happens just it is crossed somewhere. If you move stone behind it is fine.
You can try Remesh Modifier > Voxel > 0.001 m, before DP, but it would be very intensive calculation, but it worked ...

Or Separate stones by Loose parts set them Rigid Body (create a collision box) and let simulate for a few frames just to solve overlapping. Than merge them back into one object for DP.


You can’t remove the last two edges. Removing them would leave a face with a hole in it, which Blender doesn’t support. Removing just one of them would leave a face that shares an edge with itself, which Blender also doesn’t support.


Is it possible to export as USD using python?

bpy.ops.wm.usd_export() operator

Blender 2.83 adds USD support but is still in beta so you won't find anything in the current API. However, there is a development version of the API called master which is mostly up to date.

Highly recommend using blenders python console to figure out the operator call as well as all possible arguments:

>>> bpy.ops.wm.usd_export(
                          filepath="",
                          check_existing=True,
                          filter_blender=False,
                          filter_backup=False,
                          ....
                          )


In Material Tab change Volume to Surface.


When the Glass Shader is applied to a whole, solid object like that, it will treat the entire object as very thick, solid cube of pure glass.

Although it looks odd, what you are seeing is physically correct, if you had a big thick piece of glass like that and a dark gray environment a gray plane as the only source of reflections. It looks odd because you never see glass like that in the real world.

If you add a solidify modifier to your cube, it might look more like what you were expecting. This will make the glass look like a hollow cube (like a fish tank).

If you add more lights or an environment texture, it will start to look more realistic still.


Trouble locking an object to an axis while moving them!

You have to disable the Snap option. Right now it must be set to Increment, which means that the object will snap to the 3D view grid.


Texture painting only working in UV/Image editor

I had the exact same problem. I know it's been 3 years, so I guess you find a way to fix this, but if someone has the same issue, try deactivating the Backface Culling option in the brush options.


I want to use the light probe as a fisheye or spherical camera in Eevee. How can I directly access image data produced by the lightprobe?

The light probe/reflection cubemap is created with 6 image planes in a specialised image format like DDS. It's not spherical.

It is however possible to convert a cross image (composed of 6 renders from each axis into a cross) to a longitude/latitude image using CMFTStudio or Knald Lys.


Normal baking in cycles is painfully slow

The file you provided uses 13GB of RAM at its peak when baking, which is obviously more than  your entire system has. It is taking a long time because your system is hitting the swap HDD/SSD hard. For comparison, a Ryzen 7 with enough ram can bake the scene in 4 minutes.

You can try to lower the multires level on the highres mesh and see if that helps lower the memory usage.

Alternatively, you can use Blender Render's Bake from Multires function to directly bake the normal map.

Transfer the UV map from the low-poly model to the high-poly model, by select the target(hipoly), then the source(lowpoly), then Ctrl+L, and select Transfer UV.
Assign an empty image to the high-poly model
Switch to Blender Render and select the Hi-poly model (we don't need the low poly model)
Bake with 'Bake from Multires' turned on.

This is actually even faster than using Cycles baking, and much less setup.


Rope material stretching along long faces

Scale your UVs where it is stretched, you can do this by selecting the stretched faces and then seeing what vertices are highlighted int he UV view, you then press 's' to scale and then 'x' or 'y' to scale on the axis you need, in your case it looks like the 'y' axis.
That should fix it though not a real fix as you have to do it each time you edit the mesh, you have an issue where you have marked all your edges as seams, it's supposed to be like Origami, this is why a cube unfolds to a T shape rather than four squares (UV islands as they call them). Seams are essentially cuts that you would add to the flat paper to turn them into a 3D shape (remember textures are 2D and models are 3D,it's just turning that 3D shape back into a 2D one). Try removing some seams to make less islands. I would say that you need a maximum of three. One for each end of the rope and one for the length of the rope spanning all the way around.
Like seen here:

This one I actually made it one UV island by removing two edges from being marked as a seam in that example (You see how we are back to that T shape? Even though it is upside down):

I highly suggest watching this playlist, it goes into the UV unwrapping too! I know it says intermediate but don't let that put you off... https://www.youtube.com/watch?v=7tdUxzhEy_E&list=PLjEaoINr3zgHJVJF3T3CFUAZ6z11jKg6a&index=1


Here is the setup for a frame by frame animation.

Check Continuous Draw and Onion Skin.

After you draw something, move to the next frame and hit  D , then  B . This will create an Empty Frame where you can draw something else.


Using unity tree editor with blender trees

Every object in Blender has a center point or origin for it's local coordinates in the 3D view

It is generally represented by a large orange dot by default. You have to have this into consideration when modeling.

Your tree's origin point is likely placed a the center or the tree instead of the trunk base.

Change this either by moving it's gemetry in edit mode so the center is at the bottom of the trunk, or place the 3D cursor where you want the center to be (for example select a face press Shift + S Cursor to Selection) and then exit Edit Mode and press Shift + Ctrl + Alt + C and choose Origin to 3D Cursor


TL;DR: use wireframe modifier and a subdivision modifier.
Blender 2.9 instructions
Step 1: particle system

Step 2: Cell fracture
Enable the add-on cell fracture

Hit okay

Step 3: Joining
select new pieces

Join

In edit mode, merge nearby verts:

Step 4: Wireframe
Add wireframe modifier (disable Even Thickness)

Add remesh modifier with voxels in order to repair broken geometry from wireframe modifier

Step 5: smoothen
Add decimate modifier to simplify geometry

Add subdivision modifier to smooth the surface


What is this line in the middle of my blender screen?

(from the manual)

"The Origin of an Object is shown in the 3D view by a small orange circle.
While the Origin is equivalent to the center of the Object, it does not have to be located in the center of the Mesh. This means that an Object can have its center located on one end of the mesh or even completely outside the mesh."

That dotted line means that an object is parented to other object.

"Moving, rotating or scaling the parent will also usually move/rotate/scale the child/children. However moving/rotating/scaling the child/children of the parent will not result in the parent moving/rotating/scaling. In other words, the direction of influence is from parent to child and not child to parent."

Read this: https://www.blender.org/manual/modeling/objects/groups_and_parenting.html


Sounds don't play at right time when playing in vse

Try enabling AV sync in Timeline > Playback:

This will tell blender to keep playback in sync with the audio, at the expense of dropping frames if the playback isn't fast enough.

By the way, 2.69 is quite an old version of blender at this point. I'd recommend using the latest version, 2.77a at the time of writing. If you wish to install blender from a repo (for automatic updates), see this question.


Rotate bmesh vertices around a vector defined by two selected verts.

Test script, rotates 45 degrees around the vector defined by two selected verts.  Select two vertices and run script. Running 8 times should rotate the full sweep.

import bpy
import bmesh
context = bpy.context
from mathutils import Matrix
from math import radians

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

# have 2 verts selected.
v1, v2, *_ = (v for v in bm.verts if v.select)
axis = (v2.co - v1.co).normalized()
rot = Matrix.Rotation(radians(45), 4, axis)
bmesh.ops.rotate(bm, cent=v2.co, matrix=rot, verts=bm.verts)

me.update()

Note: because our rotation matrix is using an axis and both v1 and v2 are on the axis,  either (or any point on) can be used for cent property of operator .  The centre point would be calculated via v1.co + axis / 2 or (v1.co + v2.co) / 2


When I render my model in blender the only thing that appears is the blue color i have for the backround

There is an Object in your scene which is set to Wireframe Display mode in the viewport, but when rendered it is being shaded solid. It encompasses all your objects, so basically it hides everything. The object in question is called CloudBounds, and is highlighted in this screenshot:

The camera however is clearly outside of this box:

Probably you have tried to generate clouds using an Add-on which targets Blender Internal render engine? It would explain why there are no nodes on the cycles shader (it still has the button labeled use nodes):

Anyways, if you move that object to a separate layer which is not set as a RenderLayer, or simply hide or delete it, the scene renders again:


It's often wise to set up your material and open up a material or rendered preview viewport.  You can have multiple viewports open.

You can paint in either window.  For alpha in a material preview, you'll need to set an appropriate alpha blend mode for your material, and to set that, you'll have to temporarily switch to the Eevee renderer-- material preview is just an Eevee render.


Why are nodes not showing when I add a texture

Make sure you have all theese three elements present in your shading window.


switch off overlays (3d viewport - top right)


How could I animate a plane into a pipe and then a pipe into a torus?

I would probably do this with 2 'Simple Deform' modifiers set to 'Bend' and animate the 'Angle' value for both:

I start off with a subdivided plane (with it's scale and rotation applied: Ctrl+A):

I add a 'Simple Deform' modifier, set it to 'Bend' and set the 'Angle' to '360'. Because the bend isn't going in the right direction I use an empty (Shift+A> Empty), placed at the object's origin, and give it a rotation of 90 degrees on it's 'x' axis. Setting this empty as the 'Simple Deform' 'Origin' corrects the bend orientation:

I then repeat the previous step so the plane now has 2 'Simple Deform' modifiers, and again, add an empty. This time I rotate the empty '90' degrees on it's 'x' axis and '90' on it's 'z' axis.

You can then animate the 'Angle' properties of both 'Simple Deform' modifiers to create the animation by pressing I over the 'Angle' properties at values between '0' and 360', animating the first modifier and then the second.

I also checked 'double sided' on the object data properties for the plane, otherwise the shading will look odd as essentially the mesh is bending into an 'inside-out' position:

If you want to change where the 'seam' of the roll up is you can edit the position of the plane in edit mode relative to the object origin.

Here is the blend file:


Unwanted patterns in texture from repeated, seamless image

You could try something like this:

With undistorted coordinates:

With distorted coordinates:

And with a checkered texture:


Scopes & Mask Tabs disappeared from UV/Viewer screen

I figured it out.  I looked in space_image.py and found the following code.

class ImageScopesPanel:
    @classmethod
    def poll(cls, context):
        sima = context.space_data
        if not (sima and sima.image):
            return False
        # scopes are not updated in paint modes, hide
        if sima.mode == 'PAINT':
            return False
        ob = context.active_object
        if ob and ob.mode in {'TEXTURE_PAINT', 'EDIT'}:
            return False
        return True

I could not quickly figure out the meaning of each of the variables, but decided to take a look at what could turn off the "scopes" tab.  As soon as I turned the "3D View" from "Edit Mode" to "Object Mode", the "Scopes" tab re-appeared on the "UV/Image Editor".


Missing msvcr120.dll during installation

Are you using Windows 7 sp1?
The links below are from posts I found with similar errors in different apps.

Using the Microsoft C Runtime with User-Mode Drivers and Desktop ...
https://msdn.microsoft.com/en-us/library/windows/hardware/dn448963%28v=vs.85%29.aspx

http://answers.microsoft.com/en-us/windows/forum/windows_8-hardware/missing-msvcr120ddll/28b03b3b-1d15-4e47-ba31-8ace6920b9ba

Installing the run-time and/or making sure you have the latest Windows Updates might help you.


Yes you can do this easily by going into edit mode, selecting the vertex you want to animate, and pressing Ctrl+H > Hook to New Object. You can now animate the new Empty and that vertice will follow it's position exactly.


How Do You Select Edge Loops In Weight Paint Mode

Select your edge loop in edit mode

make sure face masking or vertex masking is active to only paint on previously selected face loop.


You probably don't need all those subdivisions on the edges that run across the curve:

Aside from that, there are several ways you could go about doing this:
Spin
You could use the spin tool (⎇ AltR):

Position the 3D cursor ( LMB)

Spin (⎇ AltR)

Subdivide
Subdividing can work well if you only subdivide the edges that follow around the curve:

Unfortunately subdivide smooth doesn't seem to work in this case, so you'll still need to move the vertices manually.
Curves
You could also use a curve, then convert it to a mesh later with ⎇ AltC.

Add a curve

Add a straight curve as a bevel object

Extrude curve (E or ⎈ Ctrl LMB)

You should also be able to use bevel, but currently there seems to be a bug with beveling 2D planes in 2.72..


Transfer data between nodetrees in Animation Nodes

You can just store/get data from any node tree in memory as described in this answer. Alternatively, you can use the Data Interface node to pass data between node trees.

In a node tree, you can export some data using the Data Interface node, then, in another node tree, you can access that data by referencing the node tree name and the Data Interface node name using the following expression:

bpy.data.node_groups[nodeTreeName].nodes[nodeName].value

Where nodeTreeName is your node tree name and nodeName is the Data Interface node name. Here is an example:

As for the Go to parent nodetree operator, this has nothing to do with Animation Nodes. It is a native operator that allows one to exit a node group when using cycles or the compositor (Pressing Tab).


Automatic weight paint error when trying to rig a bow

This warning usually appears when there is a bone that doesn't have anything near it.

The bone that is supposed to pull the string is the likely culprit.

I suggest applying with envelope weights, (which I was able to do after ridding myself of the pesky draw bone) and getting on your thinking shoes for some intensive weight painting time. Sometimes you just need to weight paint because the computer's automatic isn't 'human' enough. This can take forever, so don't do it before a mid-day appointment.

Also, your string is just kinda stuck into the bow; you might want to separate it from the bows shaft and then join them using a boolean modifier set to union.


How to move the points of a Curve in Python while in Edit Mode

bpy.data.Curves don't currently have a secondary representation, like bpy.data.Mesh does. Meshes can be represented as a bmesh, and they can be manipulated by Python while the Mesh is in Edit Mode. Curves on the other hand (Spline, Bezier, NURBS) don't have an additional representation that lets you modify their data via script while in Edit Mode.

A solution is to switch the Edit Mode to Object Mode, then do your manipulation, then switch back to Edit Mode if you need.

in short

bpy.ops.object.mode_set(mode='OBJECT')
for p in bpy.context.object.data.splines.active.bezier_points:
    p.co.z = 0
bpy.ops.object.mode_set(mode='EDIT')

You won't notice it switching in and out of OBJECT mode, but the bezier_points will be updated, and it will be placed back in EDIT mode.

Ideasman42 states: "changes to bpy.context.object.data are not displayed, and they will be overwritten when exiting editmode."


How do I scale in, and then extrude a smaller square column up

Have you tried using (g) on your keyboard to grab the face and move it?

you can also extrude in any direction by pressing (e) to extrude, and then the direction you wish to extrude in.

e, x - this will extrude in the direction of X. You can also use (g) after you extrude to fine tune your extrusion

g, x

If this is not what you want, please be a little more descriptive with your question.


How to get rid of an object's reflection?

In cycles you can disable the reflection of the selected object. In the properties window go to Cycles Settings and disable Ray Visibility for glossy.

Here's example of how you can make the text objects disappear from the reflection of the cube:


Armor disassociated from the mesh, how to associate again correctly?

The answer you've found is misleading: start with a previous version of your file (the one which worked well in Blender but not in UE4).

Delete the two keyframes that are causing the sliding of the rig in object mode: it's better to have all your animation performed by bones only, not bones movements and object mode movements; expecially for exporting purposes.

Then set the dopesheet window as "action editor", press the "F" button to save the animation even if not used, and click the "X" button to disable the animation.

Select the mesh, delete the armature modifier and apply the multires modifier.

Now you should have both the mesh and the armature in the centre of the scene, in T pose; if not, move them manually to have their locations matching well in the center of the scene.

Select the mesh and use Ctrl A to apply loc, rot and scale of the character, then do the same for the rig.

In edit mode add a new bone, call it "root", set it in the center of the rig, under the feets, in any z and y location you want (it doesn't matter), uncheck its "deforming" property.

Here is the misleading part of the answer: you have to set child of the root bone every other bone which hasn't already a parent, probably you will want to set the two shoulders bones as child of the hip bone, and the hip and the two ankles child of the root bone.

Check in the outliner: the root bone should result parent of every other chain of bones.

Now add an armature modifier to the mesh, setting the armature in its "object" field; in the action editor select your animation: the character will "walk in place"; use the root bone to set two keyframes to have the walking mesh sliding.

Every animation maden with this setup should be imported by UE4 without problems (maybe you will have to unparent again the mesh from the rig, for avoiding crashes) so, if the old animation doesn't work you should redo it with this new rig.


Can Cycles nodes use "object coordinates" like blender internal? (or: how can hair-mesh-objects inherit their emitter's texture)?

I have managed to answer my own specific question, but not the more general question. I will explain, but I hope that someone may be able to answer the general form.

To specifically answer my question, deriving the color of a particle hair MESH from its underlying emitter object (in this case, a feather mesh being colored by the bird's texture) in CYCLES (not Blender Internal), I found resolution in Blender Cookie/Kent Trammel's "Piero" tutorial series (video: body feathers #3), with clarification from a previous Blender developer bug-fix request (found here: https://developer.blender.org/T40712).

To derive a particle mesh's diffuse texture from an underlying emitter in Cycles, in the hair's material nodes, add a Texture Coordinate (add > input ) menu, and then an Image texture, as per normal.

However, the key difference is on the Texture Coordinate tab, you have to click "From Dupli", and as the texture image itself, you must select the texture from the underlying emitter. This info is from Kent Trammel's tutorial.

BUT! There is one more issue that can drive someone crazy. Due to some ambiguity in the underlying code in the past few incarnations of Blender (I am using 2.7), the results of "From Dupli" will NOT show up in a preview render. To see the results, a "real" F12 render must be performed!

So, this is the specific answer to the above question.

However, the general question of "object coordinates" remains open, and that is an issue that goes far beyond particles and emitters, toward texturing objects with other objects, or, for instances, controlling texture placement with an Empty.


How can I set "Dimensions" on multiple objects? (Alt+Enter doesn't seem to work)

You could change multiple objects dimension if you select all of them go to edit mode (Tab) and hit S


Here is a (destructive) way to do it:

Create a 8 vertex square, array it (Constant Offset mode) and make it follow a curve:

Apply the modifiers, select each square and round it more and more with AltShiftS (To Sphere) and playing with the Operator box factor:

Switch to Edge Select mode, select all and right click > Bridge Edge Loops:

In the Operator box, play with the Number of Cuts value:


Rendering multiple layers separately causes weird black artifacts (2.79b, Cycles)

In each layer, I toggled the other in the "Exclude bitfield", which is in the "Render Layers" tab.

Still slightly confused as to why this fixed the problem, but it works.


Using Mix Shaders for Texture Paint Layers, Black Colours Do Not Show

After messing around with it for a bit, I figured it out. The Alpha of the second layer needs to go into the Factor of the Mix RGB node.


A couple strange things to note here...

the Viewport has its own field of view

[N] to match "View" Lens (70.00) to your Camera's Focal Length
It won't be perfect, but it will lessen the difference.

Through the Camera View, you can maximize the look at it with
[Shift]+[Home]

That let's most any view occupy all available space in whatever window the keystrokes apply to.
[Home] (alone) will comfortably fit the view without taking all available space, and

Enable Border in the Dimensions dropdown under the Render Tab

[Ctrl]+[B] left-click drag around the Camera's dotted border to Preview only THAT in Render Mode; it makes things happen faster.

You should be set in your workflow for the most part if I understand what you wanted.


Why does the top displace modifier always switch to the active texture?

When selecting the texture to edit, you are actually setting the texture to be used by the displace modifier(s) and anything else that was using the texture that was there before you set it.

It's the same with materials:

Say I want to edit the blue material. If I select the blue material with the orange object selected, I'll turn the orange object blue:

Instead, I should select the blue object:

I have to select the blue object.

To "select" a texture being used by a displace modifier, either click the button next to the texture slot in the modifier:

Or in the texture panel, select which modifier you want to edit, instead of which texture:

If you want to be able to edit a specific datablock regardless of the object selection, you can Pin a panel by clicking the pin:

This will prevent that panel from displaying another object's datablocks until it is unlocked again.


Empty Image renders in front of transparent object

I was trying to make the mesh transparent, but it seems the easier way is to make the images transparent. In the image's object data panel, click the "Use Alpha" checkbox, and adjust the transparency value. To get the desired effect, this needs to be set on the image and you need to set an alpha on the mesh's material's "viewport display" like I showed in the question.


Updating curve handles by location of other objects

Assumption: If your graph has approx 50k junctions, I will assume you will import/generate such graph with python in blender.

If I were you, I would do all the animating also with python. If you do that, you also don't need to set all the hooks with python (yay!).

When you'll be building the graph, store junctions and connections into some list. You should use some nice classes for them and remember inside them what belongs to what and also remember data paths to each connection ends and handles vertices.
Then you create a function that will receive such list via a global variable and that will edit all junction positions and connections vertices and handles according to current frame. The function only takes 1 parameter - the scene.

def update_fce(scene):
    # get data
    global list

    # get frame
    frame = scene.frame_current

    # here move stuff to where it is supposed to be at frame
    return

The last step is to add this function into frame change callback list so it is called everytime the frame is changed:

bpy.app.handlers.frame_change_pre.append(update_fce)


Nevermind, I finally found the entries in User preferences.

Into 'Input' tab, then into 3D view > View3D Walk Modal, all keys bindings are listed here.

Oddly, we can not find it using the search tool at the top...


Oscurart tools  are included in the  addons_contrib folder with blender distro 2.75, which going by your screenie, is the one you are using.

I'm using 2.76.1 RC and have v3.2 not sure if that's the one with 2.75.

Version 3.2 (and the whole addon_contrib) is here
https://git.blender.org/gitweb/gitweb.cgi/blender-addons-contrib.git/tree/HEAD:/oscurart_tools

Notice that you have to enable the "Testing" category to see them in the list.

They're in the toolbar of the 3Dview, press T in the 3D view, then click the Oscurart tools tab.

http://blenderartists.org/forum/showthread.php?294671-Oscurart-Tools-Update-(rig-model-render-setting-amp-more)


No settings appearing in the Properties Editor

I fixed the problem. In fact I had somehow changed the menu to horizontal.

Right-clicking on the Properties panel and changing it from Horizontal to Vertical fixed this problem.


How to change a ui color from within the console?

Here's an example script:

import bpy

ui = bpy.context.user_preferences.themes[0].user_interface

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.inner[:]
wcol_radio_inner = (0.275, 0.275, 0.275, 1.0)

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.inner_sel[:]
wcol_radio_inner_sel = (0.33, 0.5, 0.76, 1.0)

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.show_shaded
wcol_radio_show_shaded = True

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.shadetop
wcol_radio_shadetop = 15

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.shadedown
wcol_radio_shadedown = -15

#>>> C.user_preferences.themes[0].user_interface.wcol_radio.text
wcol_radio_text = (1, 1, 1)

ui.wcol_regular.inner = wcol_radio_inner
ui.wcol_regular.inner_sel = wcol_radio_inner_sel
ui.wcol_regular.show_shaded = wcol_radio_show_shaded
ui.wcol_regular.shadetop = wcol_radio_shadetop
ui.wcol_regular.shadedown = wcol_radio_shadedown
ui.wcol_regular.text = wcol_radio_text

ui.wcol_toggle.inner = wcol_radio_inner
ui.wcol_toggle.inner_sel = wcol_radio_inner_sel
ui.wcol_toggle.show_shaded = wcol_radio_show_shaded
ui.wcol_toggle.shadetop = wcol_radio_shadetop
ui.wcol_toggle.shadedown = wcol_radio_shadedown
ui.wcol_toggle.text = wcol_radio_text

Note that you need to run this from the text editor, this wouldn't really work as addon - at the time of registration, we are not allowed to access the context.

BTW, with the above theme, the toggle buttons in the text editor sidebar for wrapping etc. look really odd.

Looking at the 2.69 testbuild 1, the transform manipulators in the View3D header appear like props:

But it's odd that the enable/disable button draws not the same. For selection mode, it's arguable whether this should look like a property set, as it actually changes something (mesh selection, e.g. verts+edges selected, go to face mode, nothing selected).


Which is more efficient for performing simple actions, Python, or Logic bricks?

Since BGE is written in C in the blender sources it will most likely be a few micro seconds faster than scripting in python that needs to be parsed.

You can test your timings with the "timeit" python module.

in the python console just type:

import timeit
help("timeit")

for the pydoc in blender.


The problem is that although the head and head bands are assigned to the same vertexgroup they are not connected together, which results in giving them different "visual" effect when rotating the parent bone even though they have the same weight.

To fix this you will connect them. To do so, go to the Head Vertex Group, then select it. Then switch to Vertex Selection instead of Face selection. Then go to Mesh menu -> Vertices -> Connect Vertices. And voila it's done.

Steps:

Result:

Updated Blend file:


Cycles Procedural Square using Polar Coordinates

I'm not sure what you've actually got wrong with your setup but I've tried to replicate it by entering your math into a Node Expressions expression (see https://baldingwizard.wixsite.com/blog/node-expressions) - which builds the nodes directly from the text.

This produces the following result :

The generated 'inner' nodes for the 'f' function are :

And here's the Blend file (Blender 2.8) for reference

EDIT: Actually, I think I've spotted the error. Your nodes actually perform the calculation :

f = cos(floor(a * 0.636+0.5)*(1.57-a)) * dist

ie, Instead of multiplying by 1.57 and then subtracting 'a', you're nodes subtract a from 1.57 and then multiply - note the brackets I added around '1.57-a'). Here's the amended (wrong) calculation, replicating your result :


Rendered image in eevee is not displaying shadows

EEVEE fakes pretty much everything in the scene when rendering. This includes Ambient Occlusion (which creates more realistic shading in EEVEE), reflections, refractions, etc. If you want a better result in EEVEE, I would recommend you use an HDRI map, and enable the checkbox for "Ambient Occlusion" in the render properties panel.
You can download high quality HDRs and HDRIs for free here.
More about Ambient Occlusion (AO) in the Blender Manual here.


Can Blender be used to create a physics based game without programming?

Blender's game engine uses a node concept for "wiring" game functionality which are called logic bricks. You can get more advanced functionality with programming in Python, but the logic bricks can do what you want if you want to avoid the programming. So yes, you can create a game without programming knowledge using Blender's game engine.

The Intro to BGE on the BlenderWiki ( http://wiki.blender.org/index.php/User:Sculptorjim/Game_Engine ) is pretty detailed on how to work with BGE and logic bricks. Blendswap also has an example with physics that you could start off with: http://www.blendswap.com/blends/view/73536

I know of one person, SolarLune, that has been working with the BGE for quite a while, and he's got quite a few videos up concerning it if you want some tips and tricks. He just did a recent video on why he uses BGE:
youtube.com/watch?v=8ZJEupWdf30

Unity would require programming in C# (or Javascript).


Pose Position & Rest Position are Different Though Character Not Posing

My problem ended up having to do with me accidentally parenting the eyelid bones to the wrong bones. Once I parented everything exactly how the tutorial I'm watching said, I got the same exact result and things are working properly and now I can continue rigging the eyelids. Since I’ve done rigging before, I guess I got a little overconfident and skipped some parts of the video lol A good lesson to always be humble, learn, and take things one step at a time haha Thanks again!


How to load UDIM images which sequence number does not start with "1001"?

So far I have come up with three solutions, but none of which are sufficient.

Assign all materials to tile '1001'. It's better to assign to a mesh that is hard to find.
Create an empty image file for each texture set that does not have a '1001' file.

e.g.: If 'eyes_BaseColor_1002.png' exists, but 'eyes_BaseColor_1001.png' does not, you should create 'eyes_BaseColor_1001.png' (2*2 px blank image).
If you use this method frequently, it's better to write a program for it.

Create individual materials only for texture that were not recognized as UDIM.

(I know, this is the worst solution)


Inconsequent shading problem. Tipps for a Beginner

Enter edit mode. Press "3" to filter to FACES. Press "A" to select all faces, click SHIFT+N (recalculate normals) and this will make all your faces coplanar to the average facing normals.
Second thing to check: Are all of your polygonal faces connected? Because they look like they don´t. Join each vertex by selecting 2 or more vertex and press ALT+M, select "center" and this will join the vertices for your poly face.


I just tested the Bsurfaces addon (version 1.5) with blender version 2.75a and it is completely functional (with a bug that disables Global Undo).

However there are a few things you need to be sure of to get it to work.

Set the grease pencil source to Object (this is your problem)

The tool tip even says that it is needed for Bsurfaces to work.

For best results draw the strokes in Object mode.
However if you drew in edit mode and it looks like this:

You can click on the Enable Editing button in the Grease Pencil tab of the tool shelf.
Or you can click the Edit Strokes button. It is in the Tools tab of the tool shelf.

I prefer the latter because you can simple delete the bad points, and not bother with trying to reposition them.
Save often, as in before you start Bsurfaces and after you create every piece you are happy with. You will still find bugs.

Last I would refer you to my answer on resources for Bsurfaces, there is a great PDF, that is still very useful.


Is there an easy way to swap a rigged character for an updated one?

Okay, say you have a main character file complete with rig and extra shapes for your bones. Save your rig and character as a group, and then close.

Open your Scene file, and choose Link from the File menu. Browse to your character file, go to Groups, and choose the group that represents your character.
Once in scene, while selected, choose Object>Make Proxy and then choose your rig name from the menu. This will allow you to then use your rig in pose mode and key frame the bones, while protecting your character mesh from changes. Make your changes upstream in your character file and reopening your scene file will pull the changes in.


Convert object to mesh > edit mode-edges > ALT + double click on the border to select all > shift+D to duplicate > P-separate by selection. You have the border without insides.


This is the result of mismatch in normals orientation.

Smooth shading averages normals of the vertices which compose the faces. On the surface where each face is connected to the neighbour face this will work as they share vertices and hence normals have the same orientation.
On the other hand when surface ends the normal of the vertex which is on the boundary loop won't be the same as above because it won't have neighbours to have the same average result of the normal vector orientation. Here's an example of a sphere with a segment cut out and left as part of the same object:

Blue lines show vertices normals' orientation. They are doubled and mismatch a bit where double vertices meet. And shading has visible artifacts there.

Often you will be advised to remove doubles to workaround that. If you need these as different meshes the easiest way is to split meshes into different objects in order to use modifier to transfer normals from one object to another, this is Data Transfer modifier.

After seperating segment into another object enter Edit mode, select boundary loop edge (Ctrl + E > Select Boundary Loop) and add it to a vertex group.

So that if you enter Weight Paint mode you will see red in the corners (weights of 1):

Do the same for the sphere itself:

Then add Data Transfer modifiers for both objects. Choose Sphere as source object for the segment and Sphere-segment for the Sphere object in its settings. Enable Face Corner Data checkbox to tell modifier what to transfer. Choose Custom Normals below. In the Vertex Group field choose groups created above. Set Mix Mode for the modifier on the sphere to Add, leave default Replace for the one on the segment. Enable AutoSmooth in the Object Data tab to make both modifiers work.

Now the cut out segment won't be seen as separate mesh.


Need this type of sine wave animation without the cuts as like it is a wire. How to make?

The curve you are trying to create can be described by the following parametric equation:

$$
\begin{bmatrix}
p\\
\alpha p \sin({\beta t + p})
\end{bmatrix}
$$

Where $\beta$ and $\alpha$ are arbitrary constants, $t$ is the time, and $p$ is the parameter. We can implement this in Animation Nodes as follows:


How does a normal map contain more information than a heigh map?

The maps do not achieve different things; they both turn into normals to be read by the shader or raytracer.  But you're not wrong: you can make a typical tangent space normal map from a bump map and a UV-mapped mesh*, but you can't make a bump map from a tangent space normal map**.  If anybody is saying that a normal map contains more information than a bump map, they're mistaken.
But there's a difference between having more information and having more precision.  And when talking about typical formats-- 8 bit per channel, RGB(A) images-- a normal map has more precision than a bump map, because it uses more channels to store that information.  The normal map is using 16 bits per texel to store its normal.  (Alpha is unused, and one of the color channels is redundant.  Well, almost redundant.)  The bump map is only using 8 bits per texel.
There is one, tiny way in which a normal map contains more information than a bump map, but it's not a way that anybody cares about: a normal map can actually flip the normals, by using a blue channel less than 0.5.  Of course, nobody ever does that.  If they did, it would be more appropriate to say that the normal map uses 17 bits per texel to store its normal (because then, the redundant channel's sign, less than or greater than 0.5, matters.)
What would happen if you were using 16 bpc images?  The difference in precision between the normal map and the bump map would no longer be noticeable.  Does that mean that a bump map would be indistinguishable from a normal map?  No, you could distinguish them, because of the different ways that they interact with texture lookups and filtering.
*You can make an object space normal map from just a bump and a mesh.  But PS is assuming a default plane mesh-- you can't make a normal map of any kind without a mesh.
**You can approximate it.


splitting of screen areas and retrieving the active area with python

Your sample code is not actually changing any area to a text editor. At the end of your code you are comparing to the string 'TEXT_EDITOR' not assigning. While you go through the areas you won't find a match to final_width as you are setting final_width to 1/3 of the width of the active area after the split, you would need to calculate the width before the split to have a chance of matching it.

When splitting an area we don't actually get a reference to the new area. One solution I can think of is to copy the list of areas, split the current area and then find the area that didn't exist to start with, this leads to the following demo operator to split the view and change the new area to a text editor.

class SplitArea(bpy.types.Operator):
    """Split area to include a text editor"""
    bl_idname = "screen.split_area"
    bl_label = "Split area"

    def execute(self, context):
        start_areas = context.screen.areas[:]
        bpy.ops.screen.area_split(direction='VERTICAL', factor=0.3)
        for area in context.screen.areas:
            if area not in start_areas:
                area.type = 'TEXT_EDITOR'
        return {'FINISHED'}


Fluid simulation not working after parenting to animated object

The blob is a cube. It look like a blob because the subdivision surface modfier. The domain is not a fluid source or a fluid object. The domain is the border of your simulation. So you have to increase the domain's size to include the jars and add a fluid object inside it instead your current domain object. Don't move the domain. Add fluid>>obstacle to the jars.

https://docs.blender.org/manual/en/latest/physics/fluid/types/index.html


Often, when you make a model for a computer game, you start out by making a high poly model. Then, from this, you make a lowpoly model that is going to be used inside the game. This is almost always a manual process and it is called retopology. After that you can bake both diffuse texture, ambient occlusion and normals from the highpoly to the lowpoly texture. You will find many many tutorials on this.

In your case, you already have the highpoly model. So do a lowpoly version and start baking.

There are numerous ways to create the lowpoly version.

Create the lowpoly mesh from scratch, extrude new vertices and snap them to the faces of the highpoly version. Fill with faces.
Create a grid of new vertices, and use the shrinkwrap modified to make them fit the highpoly model.
CGCookie have a plugin for this, Retopoflow (previous contours-retopology): https://cgcookiemarkets.com/all-products/retopoflow/
BSurfaces allows you to paint with strokes to create the lowpoly model.
The decimate modifier can automaticly reduce the complexity of a highpoly model. But almost always it must be manually corrected with one of the other methods.
more...

A quick youtube search found this (looks ok):
http://www.youtube.com/watch?v=eaqYqkjimD8

Blender cookie have many tutorials on this subject, but not all are free:
http://cgcookie.com/blender/page/2/?s=retopology&s_type=tutorials

A super fast tutorial on making a highpoly model super lowpoly:

Step 1. Make your lowpoly model match the outline of the highpoly. Like this:

Step 2. Simple UV-unwrap of the lowpoly (go into edit mode, select all faces and hit U). Mark appropriate edges as seams with Ctrl-E to cut it up. Assign a new image to it.

Step 3. Bake normals to the lowpoly texture like this. Select highpoly, also select lowpoly (select the lowpoly last). Set settings like in the screenshot and hit bake. Save the image as the normal map.

Step 4. Change Bake mode to AO and hit bake again. Save out image.

Final result when combining these two maps into one material in blender. Of course, this will require a shader with a normal texture, but I am pretty certain that JME has it.

This mini-tutorial is very short but it should make you search for more help (or ask questions) on more specific topics (like: how to UV-unwrap a model).

As for your other question. I don't know of any technique to make this more automated.

The dolphin submarine is of my making.


That's a big question. I don't have a complete answer, but I can answer for some parameters. I've made this answer a Community Wiki, so maybe others can fill in more.

Index of Refraction

The index of refraction (IOR) of Water doesn't vary much. It's approximately 1.333. This scubageek article references a table from "L. W. Tilton and J. K. Taylor, J. Res. Nat. Bur. Stand., 20, 419 (RP1085) 1938.":

Table 1: Index of refraction of water as a
function of wave length and water temperature.
----------------------------------------------
  Wave Length
   (Angstroms)   T=10 C   T=20 C   T=30 C

      7065      1.3307   1.3300   1.3290
      5893      1.3337   1.3330   1.3319
      5016      1.3371   1.3364   1.3353
      4047      1.3435   1.3427   1.3417

It also references a table from "E. Dorsey, "Properties of Ordinary Water-Substance", (Reinhold Publishing Corporation 1940)." to show that the Index of Refraction doesn't change too much based on salinity. In the table below, they refer to the index of refraction as n(w):

Table 2. Changes in index of refraction due to salinity
--------------------------------------------------------
salinity
(gm/kg)     increase in n(w)          example
--------------------------------------------------------
   5            0.00097           northern Baltic Sea
  10            0.00194
  15            0.00290
  20            0.00386           bight of Biafra
  25            0.00482
  30            0.00577
  35            0.00673           Atlantic surface
  40            0.00769           northern Red Sea

Since our base value is ~1.33, an increase of 0.007 is a relatively small change. I suspect it would be noticeable if high-salinity water was in the process of mixing with low-salinity water, but it's probably too small to notice a difference if all the water has the same salinity.

Scattering

The appearance of an underwater environment is significantly affected by how light reflects off tiny particles in the water. Light tends to hit these particles and scatter off in different directions. If light scattered evenly in all directions, that would be referred to as isotropic scattering. However, light in water doesn't scatter evenly in all directions, so the term for that is anisotropic scattering.

Principled Volume Shaders, added in Blender 2.80, use Henyey-Greenstein scattering anisotropy. The Henyey-Greenstein function basically describes what proportion of light goes in each direction. It gives you a parameter you can adjust to make it kinda match different materials. -1 would be back-scattering, 0 would be isotropic scattering, and 1 would be forward scattering. As oceanoptics describes, the Henyey-Greenstein is an imperfect approximation for water scattering, especially at very large or very small angles, but a value of 0.924 looks reasonable.

This does vary based on what's in the water. There's also a question as to what color this should be.

Absorption

I'm not sure how to translate this into density / color, but this graph from p.454 of "Optical propagation in linear media: atmospheric gases and particles, solid-state components, and water" (2006) by Michael E. Thomas on light penetration of seawater illustrates the absorption of various wavelengths of light. It can be handy to view with a map of wavelength to color beside it, so I grabbed a copy of the Linear Visible Spectrum from Wikipedia.


Instead of using wind etc. to blow the particles upwards, try disabling gravity for just the particles:

In this case the emitter plane's normal is facing upwards, so the particles start with a initial upwards motion.

I've also added a turbulence force field along with some random initial and brownian velocity, to give it a bit of randomness.


Difference Between Armature and Bone Layers?

So...You could be referring to a few things, but I'm just going to run through all of them real quick.

Armature Scene Layer: The layer in which the armature is in the scene.  This matters for rendering and viewport filtering.

Armature Layers: The Bone Layers in an Armature.  Activating a Layer makes it visible in the editor.

Armature Protected Layers: Runs parallel to the Armature layers, activating this layer makes the corresponding Armature Layer write-protected.  Users will be unable to edit bones that are in this layer.

Bone layers: Armature Layers from the perspective of bones.  Determines which armature layer(s) a bone resides in.


Gap between land and sky in world background (cycles)

This is a deficiency of your ocean surface not curving away from you "to infinity" the way a real ocean would. Since it's instead a finite plane, it's possible to get above it and see through the area where an infinite plane should've occupied. Some possible workarounds:

1) Make the plane bigger and lower the camera angle. You may be able to minimize the gap to the point that it's not an issue.

2) If you're committed to the higher camera angle, you can use the mist pass as suggested by cegaton to cover up the horizon. You can use a mask or gradient texture in the compositor to cancel the mist pass effect in the upper part of the frame, and thus expose the sky above the gap


How do you fix opacity to a reference image in blender 2.81

With Image selected : Image Properties panel > enable Alpha and adjust Transparency.


Load camera track from an external file (by Python script)

Something similar to this works for me, didn't test if this code runs without errors, but it may help you

import bpy
import numpy as np
dirPath = "C:/Users/examplepath/examplepath/examplepath/camera.blend/Object/"
nameList = ['Camera0','Camera1','Camera2','Camera3']

# [euler0, euler1, euler2, x, y, z]
cam0 = [77.487, -0.000244, 91.4015, 13.6156, 0.094522, 2.19869]
cam1 = [70.2677, -0.000819, 173.623, 1.1328, 11.1731, 3.33687]
cam2 = [85.5084, 0.000169, -90.6852, -12.8706, 0.355527, 1.29131]
cam3 = [74.6794, -0.002039, 11.1926, 3.2923, -15.5643, 4.444]

camList = [cam0, cam1, cam2, cam3]

def setupCamera(scene, c):
    pi = np.pi

    scene.camera.rotation_euler[0] = c[0] * (pi / 180.0)
    scene.camera.rotation_euler[1] = c[1] * (pi / 180.0)
    scene.camera.rotation_euler[2] = c[2] * (pi / 180.0)

    scene.camera.location.x = c[3]
    scene.camera.location.y = c[4]
    scene.camera.location.z = c[5]

    return

# Append cameras to the scene
for i in range(nameList.__len__()):
    bpy.ops.wm.append(filename=nameList[i], directory=dirPath)

scene = bpy.data.scenes["Scene"]

for i in range(camList.__len__()):
    bpy.ops.object.camera_add()
    newCamera = bpy.data.objects['Camera']
    newCamera.name = 'c' + str(i)

    newCamera.rotation_mode = 'XYZ'
    scene.camera = newCamera

    config = camList[i]
    setupCamera(scene=scene, c=config)


Hair Particle Objects change size and angle when parent object's bones are rotated

After a lot of searching the web I found the root cause of the problem: I have to apply Ctrl +  A Scale, Rotation, Size. This fixes the problem.
Frankly, I don't really understand what Ctrl +  A does, but it works.


How to free hand draw curve object with drawing tablet? 2.8

Create a Curve > Bezier, go in Edit mode, and choose the Draw tool:


If you give an array an Object Offset, then whatever transform there is between array-element 0 and the offset-object, will be applied recursively to each subsequent element, in the object-space of the previous element.
So, for example, if the array is in X, and the offset-object is scaled down in X, each element will be smaller than the last, and closer to it, in X. This way, you can achieve geometric progressions in intervals between elements. There are 2 obvious drawbacks.

The elements themselves are scaled down, along with the intervals between them.
Intervals limited to geometric progressions, or, by giving the array a Constant offset, too, a 'Multiply Add' relation between each interval and the next.

You can overcome drawback 1 by making an array of a single vertex, setting its 'Instancing' Object Property to 'Vertices', and parenting the desired array element to the vertex array:

The Empty, 'Array_Xform', is scaled down in its X, so each X interval is .882 times the size of the last. A constant has been added to those intervals by the Constant offset in the array modifier.
To overcome drawback 2, I think you would have to deform the vertex array using another modifier, for example, Displace.
However, in 2.93+, a Geometry Nodes modifier below the Array will give you complete control over the distribution of elements, in all axes, using anything you can express mathematically, or by texture, or proximity of another object, or... well... anything.

Above, that's just a random amount added to each interval of the array. The only nodes out of shot are the Group Input and Output.


You can use edge creases to sharpen edges when using the subdivision surface modifier, and simple bevelling and scaling to generate this effect.

Start with a subdivided capsule with a topology like this:

Select an edge where you'd like to create a segment in the bee's abdomen:

Bevel the edge using the shortcut CtrlB, then move the cursor slightly to create a small bevel.

Select the rear edge.

Scale it down.

Select the front edge, open the options panel with the shortcut N, then crank up the crease to around 0.75.

Finally, you can play with the scale and position of the edges of each segment, and repeat this process to create the segmented abdomen.


Isolate or hide specific parts of an object in edit mode

You can hide parts of a mesh in edit mode and you can hide whole objects in object mode:

press H to hide the selection
press SHIFTH to hide the elements which are not selected
press ALTH to unhide everything

You can also access these functions in the viewport in the menu via Mesh->Show/Hide.


This setup is a bit fiddly but it gets the job done :-P

The particle system needs to be set to render a UV unwrapped object, in this case it's a simple plane.

(The billboard particle sadly doesn't work in cycles 2.79b. In Blender Internal there is already functionality to randomise with tiles in the billboard particle settings.)

I am using the object random input in the material to get a normalised random scalar (0 - 1). I can then use this to scale and offset the uvmap to select one of 4 images in a texture.

The input value (2) is the number of horizontal and vertical tiles and can be changed if needed.


For your specific example Subdivide Smooth seems to be the answer.

For everything else there is Smooth Vertex that you already know or perhaps Laplacian Smooth, if you need finer control over mesh volume.


Motion Tracking objects that go out of frame and re-enter later

When an object disappears momentarily form the scene (either it goes out of frame and comes back later, or is occluded by other objects) you can track up to the point where it becomes untrackable or it disappears from the frame.

When it re-appears track it with new tracker.

Then select both trackers (using Shift select)

and Join them using Join Track (or press CtrlJ)

That way blender will know that is dealing with the same element and not a new one.

Doing this will allow you to have a more accurate camera/object solve or better motion stabilization, depending on what your goals are for tracking.


Tissue add-on: How to use the Advanced Settings for animation?

The Tessellate Tool's Advanced Settings are grayed out unless the "base object" has a Vertex Group (with vertices assigned to it).

So that answers the original question. But let's see what these Advanced Settings might actually be used for in practice, and go through the steps.

A few more points that aren't obvious:

The Active Shape Key is the one that will be used.
Shape Key slider values will not be taken into account.
If "Map Vertex Group" is not enabled, the "Use Shape Keys" option will fail.
Shape Key data is not preserved as such. The tessellation result is just a mesh in that single shape.
To get the animation back we need to create multiple tessellations and use the Join As Shapes operation to recombine them as one mesh.

Here's an animated mini-tutorial:

And a sample result:

Go nuts...


Why some of my objects suddenly start to move together?

I had proportional editing accidentally checked.

As Chebhou mentioned in the comments, this can be disabled by pressing O.


How to make a 2D balance weighting scale?

The simplest way to get the job done is create a three bones armature, setting their heads in every pivot point needed, then parent left and right to main bone (keep offset), then unceck the "inherit rotation" option for both arms.

Then parent every 2D object to the respective bone (Ctrl P - Bone).

After the programming of the animation you can add some noise generator to the f-curves in the graph editor, where you need some random movements.


Why are all my edges darker when using texture paint

Since it goes away with a subsurf it is a problem with too little geometry - too few edge loops to get a good interpolation across the edge.
You can

Use manual loops along the discs
Use edge split modifier to not interpolate across the sharp edges
Use the Bevel Modifier (if it doesn't work, google how to use it, or
send me a screenshot of your settings)

EIDT: I just realized, the subsurf modifier you mentioned might also mess with your UVs, try toggling split UVs in the settings.


Aliased edge around light source in cycles

This is not a rendering artifact, everything is behaving exactly as designed.
First an explanation of why these edges appear aliased, but if all you want is to solve this issue and don't care about the background info, scroll down to the Solution.

Why it occurs
Cycles works by randomly shooting rays from the camera into the scene. It does this many times per pixel, and gets the resulting color of the pixel from the average color of samples in that pixel.
Take for example three adjacent pixels, rendered with 20 samples:

The green shape is some surface, the white part is a light source, and the red dots are the sampled points.
If the white light source has an intensity of 1.0:

The left pixel will be completely white (RGB: 1.0, 1.0, 1.0) because all the samples are also white
The middle pixel had 4 green samples and 16 white samples, meaning the resulting color will be more white than green.
The right pixel had 10 green samples and 10 white samples and so should be exactly halfway between white and green.

So because the final pixel color is the average color of the samples, what happens when we have a light source with an intensity greater than 1.0? Say, 4.0:

The left pixel will still appear white on our screens, but the actual RGB value stored there is 4.0, 4.0, 4.0.
The middle pixel will be much lighter now, because the white samples have 4x more effect on the average.
The right pixel, will also be much lighter than before for the same reason.

So if our light source is very bright (as it often has to be due to the natural quadratic falloff), the pixels on and immediately around the light will be very bright as well, since the average sample color is bright.
That's the theory, and here's proof:
A (zoomed) render of some rotated planes with varying intensity of Emission shaders:

The intensity starts from 0.5 and doubles until the second last plane (intensity of 16), then jumps to 1000.0 to show an exaggerated effect.
Below the horizontal line the intensity has been divided by 4 - so starting from 0.125, reaching 4.0 and jumping to 250.0.
Notice that the more the intensity increases, the more aliased it appears.

Solution
There's an easy way to solve this issue: Simply get the light source to appear as regular white (RGB: 1.0, 1.0, 1.0) to the camera, but still let it be brighter to non-camera rays so that it can light the scene properly.
To do this, use the Is Camera Ray output of the Light Path node as the Fac for a MixRGB node where two values are connected to the colors (the top input being the actual light intensity, and the bottom input being the intensity the camera will see):

Which results in:

But as you can see, because our light was colored it now looks a bit dull.
To fix this, we just need to use a similar light path trick for the color input to make the light appear white to the camera, but the original color to the scene:
click for full size

Note: The Light Color node in the screenshots is simply a node group containing some nodes which only allow light to be emitted from the front side of the mesh.
So there ya go! Nice anti-aliased light sources :)
The only down side of this method is if you are relying on those brighter-than-white values for compositing glare/glow - but usually the glare/glow itself will hide those nasty aliased edges.


Trying to make a plane follow a bezier curve

You can create a plane, add Array modifier to it for repeating and Curve modifier - for curvature:

But why if it's possible to go with curves and avoid any "origin points matching for Curve modifier"? Create 2 curves, 1 - main one (shown above), another one - default curve from Shift+A > Curve menu, but just scaled down by one axis (in this case by Y axis) so it's flat.

Then set that curve as bevel object for the main one and in Edit mode scale simple curve to adjust thickness of the main one.

Adjust curve resolution in the Shape rollout, Preview U for the simple curve to in-/decrease amount of loopcuts by X axis and Preview U for the main curve to in-/decrease amount of loopcuts by Y axis in the example above.


It looks like your bone hierarchy is messed up. It's ok that the thumb is a sibling of the index finger and they are parented to palm.01. But palm.01.L should be parented to hand.L, and the hand should be parented to forearm.L and so on.
It's basically spine > shoulder > arm > hand > palm > fingers.
For the chin and jaw bones, it's like: spine > face > jaw > chin
For testing, I've created a human meta rig and cleared the parent of palm.01.L. It's now a sibling of the spine.
This is wrong and Rigify complains about it with the same error message you posted.
To fix it you need to select the bones (in Edit mode), child first, parent last, and parent them (Ctrl+P) with Keep Offset. Select the whole bone, not only the head or tail. With Alt+P you can separate them if needed.


Where to start dissecting this racing track?

You can use a bezier curve for the track.

Create the track as a bezier curve
Create a track segment with an Array modifier > Fit Curve and target the track
Add a Curve modifier to the segment and target the track


These settings are render engine dependent, that means the options available depend on which rendering engine you are currently using, like Cycles or Blender Internal (Also called Blender Render).

On the info window you can change the render engine:

Transparency and emission options are material properties and the addon must be able to create a material with those properties for rendering system currently in use, so some options are only available for Blender Internal materials others for Cycles, since they use completely different and independent material definitions.

To see the options for each render engine read this post:

Long story short, decide which render engine you are going to use, then if the desired options aren't immediately available from the importer adjust you material manually afterwards.


drivers and custom properties for buttons

Not sure drivers and custom properties are a good solution for that.

Lucky for you, I have run across similar strugglers these years when rigging and collected some python scripts which you can run to fix all that. Simply copy-paste them into the text editor, and click the run button when you need them. You have to be in Pose mode though.

First one : reset every "stretch to" constraints of an armature :

import bpy

for b in bpy.context.selected_pose_bones:
    for c in b.constraints:
        if c.name == "Stretch To":
            c.rest_length = 0

Second one, same use as the previous, but to set inverse of every "child of" constraints of the armature :

import bpy

ob = bpy.context.active_object

# Take a copy of current layers
org_layers = ob.data.layers[:]

# Show all layers
for i in range(len(org_layers)):
    ob.data.layers[i] = True

for b in ob.pose.bones:
    for c in b.constraints:
        if c.type == "CHILD_OF":
            context_py = bpy.context.copy()
            context_py["constraint"] = c
            ob.data.bones.active = b.bone
            bpy.ops.constraint.childof_set_inverse(context_py, constraint="Child Of", owner='BONE')

# Reset back to orginal layer state
for i in range(len(org_layers)):
    ob.data.layers[i] = org_layers[i]

I'll be working on making those scripts more easy to use, as add-ons with accessible buttons right in the viewport's UI. You can follow the advancements on my github.


To link objects after you created them, simply select all the objects, with the original object as the active one. and press Ctrl + L, then choose what properties you want to link.


How Do You Start Animation At A Specific Frame?

Setting the Render Range

What you need to do is to start your render 5 seconds into your animation. You can accomplish this by setting the start frame to 5 seconds worth of frames into your animation.

To determine how many frames are in 5 seconds of your animation, look at the Frame Rate setting in the Dimensions section of the Render tab:

Here we see that the animation's is set to have 25 frames per second (fps). So, to determine how many frames are in 5 seconds, simply multiply 25fps x 5 seconds = 125 frames.

Then, just set your Start Frame to 125:

Another way to specify the Start and End Frames for your animation are in the Timeline window:

For a detailed description of how to set the Start Frame and End Frame for your animation, see the answer here.

You can also read more about render output settings in the Blender Manual.


I panicked too early. When I stripped down the file to upload it here, I saw that I had two ground planes ontop of eachother. One of them was invisible for camera view, but was considered for glossy and diffuse bounces. This produced the banding artifacts.


It seems that to do this you need to be looking from the Camera View and adjust the Camera settings.

Set your Camera to Orthographic Mode

The clipping Start and End will be controlled from these Camera settings, not the Viewport clipping settings.

Align Camera to View

CtrlAltNum 0

Rotating the view

Enable "Lock Camera to View"

(It's in your Properties Panel)

This lets you look around without popping out of Camera View.

Zooming the view

To zoom in and out you will probably need to move the Camera along its local Z axis by grabbing it. [If anyone knows a better way, please chime in in the comments] To do this, select the Camera, Grab G, then press ZZ and adjust using your mouse. Left Click to accept the position.

Note: Your Camera must be on a selected Layer in order for it to be grabbed.

Demonstration:

Some thoughts on workflow

If you will be spending a lot of time working like this you might want to keep an Outliner window up that always shows your "Camera" object so you can select it again any time you need to. You can do this by simply typing "Camera" into the search field and leaving it that way. You can still use the Outliner for other tasks in a separate window space.

If you find selecting and grabbing the Camera cumbersome, it may be worth considering whether you can see what you need to see by using another approach, such as hiding objects or masking part of objects using the Mask Modifier.


Light comes out much brighter when rendering?

I had a hidden light source where the fire is, that was the problem.


Navigation gizmo missing after loading a file

The viewport nagivation gizmo can be activated in the Viewport Gizmos options by ticking the checkbox with the Navigate label.

If you don't want to load the UI layout and settings from an existing project, disable Load UI in the file browser as shown in this answer.