Replacing part of an object's name with object.name.replace?

Replace is a string function that comes from python's string object.
Since an object's name is a string property class, that inherits some props and methods from python's built in string class, it also gets the replace method.

The string replace method doesn't replace in place, but returns a string with the replacement applied. Which means that what you actually need to do is:

bpy.context.object.name = bpy.context.object.name.replace("_HP", "_LP")


The render audio button combines all of the audio tracks that have been created in the video sequence editor into one audio file. This is useful if, say you had an animation that had multiple sounds in it but you rendered it as an image sequence and plan to put the output sequence in another project as part of a compilation. Say you forgot that you were going to create all the audio in the compilation. Instead of putting in the numerous audio tracks in again trying to put them in the perfect place again, you could render the audio from the first project and put it in the second project parallel to the matching image sequence. Also, it probably works appropriately with the speaker object, but I'm not sure at all. I've never tried. ;)

There's a simple example. I probably could have thought of something more realistic, but I hope that helps!


If you duplicated your mesh and mirrored it, you have two halves that are still unconnected.

The Subsurf modifier stops at the places where when you have unconnected vertices:

To fix this, enter edit mode, select all of your vertices (kbd>A,), press CtrlV and select remove doubles


You can do this by selecting the object that you want to apply the scale to,  press  Ctrl  +  A  and select Scale


You can use the Inset tool. That way you can keep the topology as quads.

Select the faces where you need the cut, press I to activate the inset tool, and then by dragging the mouse you can determine the size of the hole.

After just extrude (E) and delete the faces as needed.


How do you move the 3d cursor along an edge?

Bmesh helper script

For those interested in a scripting solution, here is a little helper script to place the cursor on an edge.

Test run on default cube

Test script.

Run in edit mode
Have an edge as active element.
Place the 3d cursor close to one end, this will be the zero location
Edit the pc variable to how far in percent along edge from one end to another. 0 will snap the cursor to closest end. One third will move it one third of the way to other end.
The global length of the edge is written to system console.

Test script.

import bpy
import bmesh

pc = 1 / 3

context = bpy.context
scene = context.scene
ob = context.edit_object
mw = ob.matrix_world
me = ob.data
bm = bmesh.from_edit_mesh(me)
e = bm.select_history.active
assert(type(e) == bmesh.types.BMEdge)

v1, v2 = sorted((v.co for v in e.verts), key=lambda o: (scene.cursor_location - o).length)
scene.cursor_location = v1 + pc * (v2 - v1)
print("Global Edge Length: ", (v2 - v1).length)

Notes:

Could extend this to have a UI by making an operator.


Opening a file from Version 2.83 in Version 2.49

Version 2.8 is not backwards compatible with previous versions.
Even if you could bring the meshes, none of the materials would work in 2.49
You might want to try using 2.79 and the internal blender render with simple materials. No nodes. Maybe those would work on 2.49


Unexpected result from "bm.faces.new(verts)"

The contextual create operator.

Rather than calculate the winding order to create face with bm.faces.new(verts) let the operator do it for you.

bmesh.ops.contextual_create

  Contextual Create.

  This is basically F-key, it creates new faces from vertices, makes
  stuff from edge nets, makes wire edges, etc. It also dissolves faces.

  Three verts become a triangle, four become a quad. Two become a wire
  edge.

import bpy
import bmesh

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

verts = [v for v in bm.verts if v.select]
bmesh.ops.contextual_create(bm, geom=verts)

bmesh.update_edit_mesh(me)


How to make beveled 90 degree corners on a curve better?

First make sure your Bezier Curve type  is set to 2D (if you don't need a 3D curve that is), that will automatically reduce deformation on tight corners.

It is a known limitation of the current system and there is no way around it at time moment. This was planned to be improved as part of 2016 GSOC Bezier Curve Improvements, but never actually made it.

Secondly in edit mode make sure your Spline Type is set to Bezier, it seems to be set to Poly which doesn't allow curved segments.

Thirdly erase the corner vertex and, as Paul Gonet mentioned turn the two contiguous handles to Aligned. If you still need actual 3D curves this technique will also reduce deformation considerably.

Lastly if you need to bevel curves this frequently the Curve Fillet addon from the Blender Market may help and simplify things in the long run. Disclaimer: Its a commercial paid addon, I am not the author nor affiliated with it in any way, though I did purchase it and use it regularly


Get the total time spent working on a file

There's an addon that keeps track of the actual time you spent working on the project.

http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/System/Project_Timer

  The time spent working in the blend file is recorded, and stored in
  the blend to continue from the next time it is opened.

  If you stop work for longer than 30 seconds, the timer stops counting
  and reverts back to the time of your last action, minimizing idle
  time.

Edit: Download link seems to no longer work, here's the last version of the add-on I could find: Download (unzip, install py file).


Its not the GPU's Fault. More like Apple's support for OpenGL/CL.

the RX 580s run very well under Windows and Linux. You can either use dualboot or a Virtualmachine using HW Passtthru to use blender thru for example Linux with direct Hardware access to the gpu.

Regarding the second Question: You should mostly never render to Video directly. You may try a newer 2.8 Build or a different codec.


Blender doesn't render the cloth-simulation

It is caused by previous cache baking. You can press Free All Bakes in the Cloth Cache panel, then give it a try.


In my opinion, you should sculpt it, but if you want to model it here is an example:


TLDR; create a camera with the settings you need and duplicate it when you need a new camera, so you'll have the right setting already there.

LONGER ANSWER AND PROCESS:

You can create a template .blend file where you have a set of cameras with the configuration you want to use (the same for objects).

Set this blend file as the default one (FILE > DEFAULT > SAVE STARTUP FILE). When you need to have a new camera, don't create it by scratch, but copy the one you have already in the blend file (main one, or another one hidden one in some collection you use as repository of different settings).

does it make sense to you?


To elaborate on what gandalf3 commented, the answer is check out Blender: Noob to Pro here http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro

I suggest while you go through the tutorials you should freely test out any ideas you might have like "Hey what happens when I do this?",
Also you may want to take a look and get familiar with Blender's shortcut keys.


How to create reflective puddles from noise texture?

I would use a Principles BSDF shader in combination with a texture such that:

Low intensity of the texture corresponds to high specularity and low roughness (puddles)
High intensity of the texture corresponds to low specularity and high roughness (ground)
The color is not affected by the texture (i.e. the puddles are very shallow)

This is my setup:


Hopefully your 2D cursor is at the bottom left of your UV layout image area - if not, position it there.

In toolbar area, choose "2D Cursor" as Rotation/Scaling Pivot.

In the UVs menu --> select "Constrain to Image Bounds"

Now select all of the vertices in your UV.

If the island is not flush with the bottom left: grab (G) and move so the edges are flush with the bottom left (the constraint will ensure that you cannot drag the island past the bounds)

Now, scale (S) - you should be able to scale to the image bounds.


Press R to rotate it and then type in the number of degrees want to rotate it (in this case either: 90, or -90). I would also press Shift+C to center your 3D Cursor and then press Shift+S and select: offset to 3D cursor, to center your object.


Is there a path finding solution for dynamic maps?

If you have some programming skill, patfinding with random maps or evolving maps is possible but not easy.

Here is my Blender artists thread with experiments on patfinding with random terrain (as well as other RTS topics).

As an RTS usually takes place on a 2D landscape you can use quite simple pathfinding techniques. I got data from a mesh to use as obstacles and then used mathutils.geometry functions to help generate a graph of connections between random points. In this case instead of a walk mesh, I generated an no-walk mesh and used it to cull a graph of connected points.

If your maps are fixed, but they are evolving, like with player placed buildings, you can just make the buildings in to obstacles.


Why are these rendered surfaces reflecting two different colors?

In your node setup for the Chrome material, you need to change the Normal Map node type from Tangent to Object. Then you will get the same response on both objects.


Where can I find the custom bone in version 2.8?

It looks like the Collection 11, the one with your bones, was hidden, I don’t know why as I don't know a lot yet about how the switch from 2.79 layers to 2.8 collections works, but anyway unhide it:

About custom bones, how to create custom bones:

In Object mode, create the object that is supposed to be used as the bone's custom shape, for example a sphere.
Select your armature, switch to Pose mode, select the bone you want to custom.
In the Properties panel > Bone > Viewport Display, enable Wireframe so that your custom bone will be displayed as a wireframe, and choose your sphere as Custom Object.
Now your bone is displayed as a sphere in Pose and Object mode.
You can modify the original sphere object (edit, rotate, scale...), it will be directly replicated on the custom bone. But you can scale in the same Viewport Display menu.


Using spline-IK for bones but keeping control over individual bones

The key is to have the hook modifiers before the soft-body on the curve, so the soft-body will take the hook-deformed curve as an input:

I also subdivided the curve to add it more control points that can be hooked (but subdivision affects the soft-body sim). Without the subdivison you could control only the end-point. The hook-Empties are parented to the head. This works like this:

So you can control the curve shape with hooks now. But you can't control the same bone-chain with IK-spline and FK at the same time without dependency issues. You would have to build 3 sets of bones - IK, FK and a final set to blend between the two. Look up IK/FK blending.

Here is the blend:

Another approach that I would prefer is to rig the character the usual way without any soft-body curves etc. and to put a soft-body after the armature modifier. With the Soft-body Goal vertex group you can control which parts of model will be giggly and which not. For good performance this should be done on a low-poly skinned Mesh-deform mesh controlling the high-poly character.


How can I add emission node to volume scatter to create cloud light using point density texture node?

Have 2 different set of volumes (one very short of emission particles) and the other one to occlude it with a much denser but scattered point cloud. Might work after some texture maths (substract, divide)


What causes the wrong value read-out in a Pie menu value slider?

Those numbers are really, unless i'm mistaken, the menu indices. The 7 isn't from the normal_size, but from the index of that pie-item. It's drawing the slider rather awkwardly close to the index. Leading me to believe pie menu's weren't intended to be used for drawing sliders, else it would be a common use case, and have a nice obvious solution. Maybe it does? someone will correct me if there is.

In any case it looks like the pie menus could be more thoroughly documented. I don't think it's a bug rather a misunderstanding of how to use it. It seems mostly geared towards toggling and executing operators.

The only way I know how to suppress the index is by making a row out of the slider.

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

    mesh = context.active_object.data
    scene = context.scene

    pie = layout.menu_pie()

    row = pie.row()
    row.prop(scene.tool_settings, "normal_size")
    pie.prop(mesh, "show_normal_face")
    pie.prop(mesh, "show_normal_loop")
    pie.prop(mesh, "show_normal_vertex")
    pie.prop(mesh, "show_faces")
    pie.prop(mesh, "show_edges")

All kinds of crazy things can be done with piemenus

Columns

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

    mesh = context.active_object.data
    scene = context.scene

    pie = layout.menu_pie()
    col = pie.column()
    col.prop(scene.tool_settings, "normal_size")
    col.prop(mesh, "show_normal_face")

Rows

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

    mesh = context.active_object.data
    scene = context.scene

    pie = layout.menu_pie()
    row = pie.row()
    row.prop(scene.tool_settings, "normal_size")
    row = pie.row()
    row.prop(mesh, "show_normal_face")

box

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

    mesh = context.active_object.data
    scene = context.scene

    pie = layout.menu_pie()

    # option 1
    box = pie.box()
    col = box.column()
    col.prop(scene.tool_settings, "normal_size")
    col.prop(mesh, "show_normal_face")
    col.prop(mesh, "show_normal_loop")
    col.prop(mesh, "show_normal_vertex")

    # option 2
    box = pie.box()
    col = box.column()
    col.prop(mesh, "show_faces")
    col.prop(mesh, "show_edges")


How to remove these wrinkles/stress lines


Have you tried to follow the installation instruction here?

Below the main instructions there is a link to a development builds repository where you can get a .zip file which also contains Python files. But you have to follow instructions for that package, too.


Either remap your UVs with smart UV project and set island margin to an appropriate value (Experiment, 0.02 works for me), or manually increase the size of the margin around each island by a few pixels. You can easily do this by hand with a photo-editing tool.

The black lines are from the mipmapping used in realtime graphics pipelines, including Blender's editor and Unity. The mipmapping works fine at full resolution (eg: when close to the model) but when the camera is far away, adjacent colours tend to blend together. On your texture, coloured islands are adjacent to black areas, so you have black lines.

This Gamedev.SE answer is wonderful and explains the mipmap bleed effect very well.


What is the difference between items listed in bpy.ops bpy.data and bpy.context

Short Version

bpy.data - all data in your blend file.
bpy.context - data in the current active view.
bpy.ops - tools which typically operate on bpy.context

Longer Explanation

bpy.data

gives you access to all data in the blend file, every object, material, compositing node etc. in every scene (also the scenes themselves) can be accessed through bpy.data.

Generally, you would either loop over all datablocks, or get a specific item by name.

bpy.context

is context sensitive, it depends on the area your mouse is over, the selections you make and so on. It lists only a subset of data such as the current scene, the active object etc. This is an easy way to have a script work on whatever object is selected rather than having to know it's name beforehand (bpy.context.object refers to the active object, or is None if there is no active object, bpy.context.selected_objects is a list of the selected objects).

bpy.ops

is where you can access tools (operators) organized in categories, e.g. bpy.ops.object.select_all() (object is the category for object-related operations, together with select_all it is the operator name and () calls it). These perform the actions typically accessed in the user interface, referenced by menu items and key shortcuts. When you search through the spacebar menu, you are seeing a list of all operators, which are available in the current context.

These three prefixes are the most common but there are others. bpy.types contains all the types or "classes" used within Blender. You will also use bpy.utils if you write an addon (mainly to register and unregister classes derived from bpy.types, e.g. to create own operators, menus, panels...). There are also some other modules available that aren't prefixed with bpy such as mathutils and bmesh.

For a list of all items available in Python you should look at Blenders Python API documentation.


I can't find object control in fluid simulation blender 2.82

You should set it to an effector object within the physics tab


Bake a texture from a geometric property of the faces in a mesh?

This script will generate a vertex color map, where each face's color is represented by a grayscale value matching the normalized distance of that face's center from the cursor, inverted (closer is brighter, farther is darker).

You can run this, then bake the vertex color to a texture file to get the image texture based on the distance. You can of course also use another object instead of the 3D cursor as your distance reference.

import bpy

o = bpy.context.object
d = o.data

if not d.vertex_colors:
    d.vertex_colors.new()

color_layer = d.vertex_colors["Col"]
curloc = bpy.context.scene.cursor_location

distances = [ ( p.center - curloc ).length for p in d.polygons ]

# Normalize distances
normalize      = lambda x, minX, maxX: round( ( x - minX ) / ( maxX - minX ), 2 )
minD, maxD     = min( distances ), max( distances )
distNormalized = [ 1 - normalize( v, minD, maxD ) for v in distances ]

for i, poly in enumerate( d.polygons ):
    for li in poly.loop_indices:
        color_layer.data[li].color = [ distNormalized[i] for c in 'rgb' ]


Rendering Cycles and Internal in the same scene without compositing

If you mean without using the compositor at all, then I don't think it can be done in one go, but it should be easy to render one scene and then the other.

If you mean just without combining the Cycles BI renders, then it is possible:

File output node:

This can be done with the File output node.

Setup your 3rd scene's composite nodes like this:

Select the File output node and set the output format to Multilayer EXR. You can add inputs (layers) with the Add input button in the Properties region (N):

So if you wanted you could even put both the BI and cycles renders in one EXR sequence:

When you want to composite you can open the multilayer EXR in an Image node and get all your layers:


Blender 2.8 Animation: How to select keyframes from inside the UI like in 2.79

As commented, the default setup in 2.80 is to use ⇧ Shift RMB in the middle of the animation related editors to change the current frame.

If you want to change this, you can adjust the keymap settings in the User Preferences.

You can find the frame change under animation.

And the selection settings are under Dopesheet -> Dopesheet(Global)

By changing the selection settings to use ⇧ Shift RMB and the frame change to use  LMB you can continue working the way you remember.


Why does my rendered movie clip have no audio?

Have you selected a audio codec before rendering ?
By default it's on "none"
(Properties panel -> render -> encoding)


It all depends on where you click. Click on the edge that is perpendicular to the direction you want to select. As you can see, if you click closer to the middle of a face, Blender will go with whichever edge it is closer to, so you will get "random" directions.


Solidify Modifier going in all directions

The problem with this mesh is it's mb its topology in order to fix that,  first go into edit mode and select all faces and then press shift+N to calculate normals, then try pressing alt+M and selecting merge by distance for removing double, if that still doesn't solve the problem then apply a remedy modifier above solidify (you even remedy manually or by some other add-on).  Try these one by one or all at the same time.


What exactly does edge loop selection do?

An Edge Loop is a chain of connected edges where each edges shares a vertex with the previous edge, and that vertex has exactly 4 edges attached to it (except on the borders of a non-manifold (not "water-tight") mesh, where there will be only 3 edges, 2 of which have just one face connected).

An edge loop is terminated where the vertex has more than 4 edges (poles) or meets a non-manifold edge (an edge with only one face) or an Ngon (face with more than 4 verts). The latitudinal loops (rings) of a UV sphere are perfect non-terminating loops, but the longitudinal loops (segments) all end at two points (the North and South poles)

Here are some examples of edge loops (see where they change direction or terminate and why)

Details on the algorithm from the wiki:

  First check to see if the selected element connects to only 3 other edges.
  If the edge in question has already been added to the list, the selection ends.
  Of the 3 edges that connect to the current edge, the ones that share a face with the current edge are eliminated and the remaining edge is added to the list and is made the current edge.


How to add roughness to a surface using modifiers?

Yes, though you'll probably want to use two for maximum effect; I recommend applying a Subdivision surface modifier ('Simple', not 'Catmull-Clark'), and then applying a Displace modifier. If your geometry is sufficiently complex it should work fine.

The Subdivision Surface modifier adds vertices to your mesh, then the Displace modifier uses those vertices to add the roughness you're looking for.

Before Modifiers

After Modifiers

You can, of course, use different settings for the Displace texture if you want to achieve different kinds of roughness.


Is it ok to remove NGons with triangulation in order to import a model in a game engine?

It depends. The potential problem you can run into with n-gons is that different programs break them up into triangles in different ways. Depending on how you've configured your mesh's shading, this can alter the way smooth shading is averaged across the face.
If your n-gons are flat-shaded and planar, you shouldn't encounter problems. If you're using smooth shading, or weighted normals, and are relying on a normal map to get your final shading result, it can potentially look different in different programs.
If you bake you bake your normal map in a program that triangulates ngons one way, and then move it into a program that does it a different way, you will get a bad result.
Generally you can't go wrong triangulating your mesh before baking normals. It removes the potential for error.


Ok, I just installed this particular addon to make certain of the correct process. The issue is the way the addon was packaged (blender's "install from file" is looking for the files to be in a set hierarchy and order). You can delete any files you have from previous attempts at installing the addon, as blender will never even look for them.
However getting the addon to run is not hard.

Manually unzip the download (which you already have), found on the wiki page or on the releases page, into a folder called exactly "space_view3d_transform_utils" without the quotes. (windows will by default unzip to a new folder with this name.)
Copy that new folder "space_view3d_transform_utils" into blender's addon directory. Here is the correct path to the user addon folder on windows and linux.

Windows:

  %APPDATA%\Blender Foundation\Blender\2.76\scripts\addons

Linux:

  $HOME/.config/blender/2.76/scripts/addons

Open up blender and go to the Addons tab of the User Preferences. Search for "batch" and enable the addon called "3D View: Batch Transforms (Transform Utils)."

This question elaborates on why some zipped addons do not install.


The shortcut for rotate view can be changed in user preferences. Assuming you are using 2.8 keymap, see the gif below:

Open user preferences.
Go to keymap section and search for rotate view to middle mouse in key binding.
Then you may simply change the shortcut for Ctrl + MMB from the default
MMB


Woah there! that subdivision you did is what is holding you back at the moment.

You'll want to change the edge flow in order to be able to fix the curvature in the way you said.

It should look more like this:

However, there is a way to give this mesh the shape you want, even in its current state.

Step 1: select all the faces that will be starting the edge.

Step 2: hit E, right click and then Alt+S then drag your mouse until you like how it looks, then left click.

Step 3: select the angular edges that you want to get rid of.

Step 4: hit X and select dissolve edges.

Here is an image explaining the process:


Child changes position, rotation upon import in Unity

Alright,
I got a hunch and it worked. Here's what I did:
Joined the eyes into the cat model and then separated them back into single objects.


How to change inflow velocity attributes randomly while animation

You can do this with F-Curves

Insert keyframe for inflow (press I hovering over the attribute).
Open Graph editor.
Add the F-Curve Modifier: Noise (Shift+Ctrl+M).

Or a little more complicated with a Driver

Add a Driver to the Attribute (Ctrl+D hovering over the attribute ‣ Add Driver ‣ Manualy Create Later)
Open Graph editor
Go to Drivers Mode
Select the Curve of the Attribute you want to Animate
Go to Drivers Tab in Toolshelf
Set the Driver to noise.random()


For this...

...you can animate the Visibility of three Copy Transform Constraints (Multiple Child Of constraints will not work) on your Boulder, one for each crane and cart:

The only trick is, at the end, you must keyframe the transforms by performing a Copy All To Selected on the Boulder.  This will keep it at it's final resting spot.  Then simply remove visibility of all constraints:


Can unofficial Blender addons be included in a project as a text block and automatically register on load?

Yes, if the addon is a single file (rather then a python package containing an __init__.py file).

At the end of the script, remove these two lines:

if __name__ == "__main__":
    register()

And add this line:

register()

In Python __name__ refers to the module name, which in this case is the name of the textblock (without .py, however if you run the script directly __name__ will be "__main__").

Removing this check before calling the register() function will run no matter how its executed.

Note, if you do this - The script won't be listed in the preferences as an addon, this wont cause problems, but a user has no way to disable besides restarting blender.


VSE not playing in realtime (not caching)?

While you're playing your sequence, you should see a little fps counter in one corner of the preview. If it's red and below your frame rate you set beforehand, than your computer can't handle the preview rendering in real time. This can be related to memory, but (at least from my experience) it more likely depend on your CPU.

What you can do to improve the playback, is setting up proxy files. They're typically smaller so playback is easier.


Can I use a panoramic rendered Blender scene as environment texture?

This should definitely be possible. Pre-rendered backgrounds are a pretty common technique for speeding up rendering times.

The only issue to be aware of with static backgrounds is that you need to be careful with camera movement as you will not get the parallax effect. I suspect that this is likely to be more obvious in VR scenes due to independent head movement/viewing angle (you can just get away with panning a few layers over each other at different rates). How noticeable this effect is will depend on the distance between the camera and the nearest object in the background, the variation of object distances in the background and the amount of camera movement.


You need to shear the vertices / edge loops.

Select the edges/vertices in edit mode.

Press CtrlShiftAltS to go into the shear operation.During the operation you can press X or Y to constrain it to the respective axes. In my example I enter the number -1:

CtrlShiftAltS, Y, 1, -

After that simply extrude in the X direction then scale it to zero along the x axis.


Objects material strange behavior when rendered

It looks like you have more than one bench, occupying the same point in space. And this can destroy reality. Try to grab your bench with RMB in any direction. If there is another one, just kill it. Maybe it's hidden from the viewport, so first press Alt+H to reveal your hidden stuff.


I used the compositor to add blur effects but they are not showing up in my final render image?

Make sure you are sending the final image to a Composite node. The Viewer node only displays in the backdrop of the node editor.


a) First, create a grid mesh object then add a WireFrame modifier.

b) Then adjust thickness as you like at step (1), uncheck the "Replace Original" option at step (2), and change the "Material Offset" to 1 at step (3), this will automatical assign the second material to the edges in the material slot.

c) Now open the material panel, add two the materials to the grid mesh object. The second material automatical will assign to edges or wires due Material Offset option which we set 1 previously in WireFrame modifier.


I first created my bone chain and the path I wanted my bone chain to follow.

Then I added another bezier curve with the same length than the armature and one vertex for each bone head or tail. By pressing "V", I turned the handle type first to "Automatic" and then to "Vector".

Next, I selected the last bone of the chain and added under the bone constraint panel a "Spline IK" constraint, targeting the second curve (Length 3, Y Stretch).
At last, I added a "Curve" modifier to the second curve, targeting the first one as shown on the picture.

Don't forget to select the right deformation axis (in my example "Z") and to check "Apply this and all preceding deformation modifiers on splines' points rather than on filled curve/surface".

Now, by moving the curve along the Z-axis, the bone chain moves along the curve.

This is not a perfect solution since the Spline IK is deforming the first bone (don't know why) and since the curve modifier is also modifying a bit the length of the second curve, but it worked pretty well for what I needed, and I hope this will help.


Is there a way to do math operations on weight groups?

Not directly - but you can easily convert the vertex weights into vertex colors (which are available in the material using the Attribute node) and use maths nodes to combine them.

Start by selecting your Vertex Group in the Mesh properties and create a matching Vertex Color set - it's probably a good idea to give them the same name.

Select the Vertex Weight and corresponding Vertex Color set that you want to copy over.

Bring up the operator window (Space in Blender versions before 2.8, F3 in 2.8+) and start typing “Vertex Color from Weight” (note that you need to be in Vertex Paint or Weight Paint mode for that operator to be available) and run it to copy the weights to the colors.

You can now access the colors (which contain a copy of the weights) using the Attribute node by simply specifying the name of the color set to use. So, to combine them as A-B and mix based on the result you could use :


It's definitely possible. You will want to look into Python scripting to accomplish this. The general workflow might look like this:

Build a Blender scene that kind of resembles what you want.
Write python script to ingest your data, and apply the data onto the scene you already built. Do you want your data to drive the location/position/size of objects? Or something more complicated?
Render.


Why are my PitchiPoy Knee and Elbow Directions wrong?

I'm using rigify/pitchipoy in 2.79, if you click on the cog shape at the top of the legs or the arms an extra option shows up under rig main properties called pole_vector.

It's bascially a boolean (set it to 0 or 1), set it to 1 and you'll see normal pole targets again.


Add a Subsurf Modifier, then the curvature will be the same for Eevee and Cycles, but in Cycles less visible because of different texture mapping.

Mapping differs because Eevee doesn't support the Panoramic camera type (set for Cycles). Eevee is using Perspective instead. Should be probably reported as a UI inconsistency.


Vertex parent an empty to a single vertex somewhere near the center of the cloth object. Then put a Damped Track constraint on the camera and point it to the empty. It would appear that physics simulations respect vertex parenting relationships. You don't even have to bake the simulation first to see the results.


Equally extrude these vertices inside the shape

The way I do this is by selecting all the vertices and making a NGon by pressing F. Then
I use inset and delete the innermost face.


How to avoid transparency behind the volumetric world shader?

Check in "Render Properties > Film" and make sure Transparent is unchecked.

If you want to add a background color, but not have it affect the lighting of the scene you can hookup "Camera Ray" from the Light Path node to a mix shader.


Straighten UV Vertices Maintaining Relative Distance

You could try to start with a long rectangle in the 3D view (imagine your shape made flat), then use a curve modifier to make it similar to your picture. Doing that the shape stays straight and allows you to make the UV part straight too (as long as the modifier is not applied).


Using gate/sensor dimensions and the field of view to adjust the way camera shots warp?

There's nothing weird about the perspective warping. The blender camera behaves just like a real life camera. From the camera presets you can even choose some common cameras, but you can set the blender camera to mimic any camera. Just look up the sensor size of any real world camera and enter those values for the blender camera. In addition, if you'd want to match a particular shot, you could look up the meta data of the picture to see what focal length and which f-stop was used for the shot and enter those values too.

You're going for a wide angle, which means a focal length of about 20mm which translates to a filed of view of about 60º. Any distortion resulting from this setting is perfectly normal for such a camera. However, if you want to adjust the distortion, then - depending on what you're going for - you can use the shift property in the camera settings, or you can use the Lens Distortion node in compositing to manipulate lens distortion.


Boolean + Subdivision Modifier: How to cut a perfect round hole?

It looks from the screenshot that you don't have an object selected. This, in and of itself, is an odd behavior, as nothing at all should be happening, but it may possibly fix itself as you continue. Click on the orange cube in the Boolean Modifier (a list should pop down) and select the other object, or click on the eyedropper and select the other object that way.

As a note, no aspersion intended on rob, I'm certain it was a mistake, when applying modifiers, you apply from the bottom of the list upwards.
CLARIFICATION: Whatever order modifiers appear, they should be applied in the order they're affecting the object. First in, first out.


here the "long story short" - so i assume you have some experience with BLender.

make a text

convert to mesh

remesh modifier

add particles, tweak some settings

add plane with collision, tweak some settings

rotate text mesh so that is lies horizontal on the plane

animate the plane with location movement to positive z axis and some rotation on x axis

enjoy your rice challenge animation

Result: https://youtu.be/wAtmM0UhLQo
Video tutorial: https://youtu.be/sz-6LapA_yk


Particles of a particle system react not as an own object

Remove gravity from the emission simulation:


Black stripes all over the model after texture painting

I fixed it, with the help of cycles render. Just created a material (diffuse) node and joined the uv image texture to it.


There isn't a direct way of doing this. An indirect way is to add a multiplied glow effect under the text with a black color.

Create a text strip, then "Add" -> "Effect Strip" -> "Glow" and move it under the strip.

In the Glow's "Strip" tab set "Threshold" to minimum, "Clamp" to maximum, "Blur distance" to your desired size, "Quality" to 1 (personal preference), "Blend" to alpha over, and "multiply" to maximum.

In the Glow's "Modifiers" tab "add strip modifier" -> "color balance"

In the color balance set "gain" to minimum


You are in edge select mode, this is why you can not select single vertices:

Click the leftmost of the marked buttons, then you can select vertices again.


This worked for me:

Go to face mode, and select one face.

On the UV map side, the texture disappeared, this is fine.

Hit the A key to select all the faces

select the uv map

Texture showed after I did that


Consider a path constraint.  You may want a script for placement of objects.

Consider a rigid body constraint.

Neither of these are trivial to do from starting point zero.

Curve Modifier by comparison is less work.


Functions of the Texutre Coordinate Node

Each socket represent a different mapping function that maps surface coordinates to the texture coordinates. What you get from the socket is 3D vector array which can be manipulated with vector or math nodes to alter the mapping (usually using the Mapping node).

The different mapping options are explained here:

How do texture coordinates work?

How the vectors itself and math works and what you can do with it is explained here:

How do I create repeating patterns with cycles' procedural textures


bpy.context.space_data is the current space, if you need a certain one, iterate over all areas in the current screen and test for the .type:

for area in bpy.context.screen.areas:
    if area.type == 'VIEW_3D':
        area.spaces.active.region_3d.view_matrix
        # you may want to break here

To figure out which region / quadview the mouse is over in a modal operator, compare the mouse coordinates with the region rectangle:

import bpy
import math

def get_view_orientation(space, view):

    if view.view_perspective == 'CAMERA':
        if space.camera.type == 'CAMERA':
            view_orientation = "Camera " + space.camera.data.type.capitalize()
        else:
            view_orientation = "Object as Camera"

    else:
        r = lambda x: round(x, 2)
        view_rot = view.view_matrix.to_euler()

        orientation_dict = {(0.0, 0.0, 0.0) : 'TOP',
                            (r(math.pi), 0.0, 0.0) : 'BOTTOM',
                            (r(-math.pi/2), 0.0, 0.0) : 'FRONT',
                            (r(math.pi/2), 0.0, r(-math.pi)) : 'BACK',
                            (r(-math.pi/2), r(math.pi/2), 0.0) : 'LEFT',
                            (r(-math.pi/2), r(-math.pi/2), 0.0) : 'RIGHT'}

        view_orientation =  orientation_dict.get(tuple(map(r, view_rot)), 'USER').capitalize()
        view_orientation += " " + view.view_perspective.capitalize()

    if space.local_view is not None:
        view_orientation += " (Local)"

    return view_orientation

def get_quadview_index(context, x, y):
    for area in context.screen.areas:
        if area.type != 'VIEW_3D':
            continue
        is_quadview = len(area.spaces.active.region_quadviews) == 0
        i = -1
        for region in area.regions:
            if region.type == 'WINDOW':
                i += 1
                if (x >= region.x and
                    y >= region.y and
                    x < region.width + region.x and
                    y < region.height + region.y):

                    return (area.spaces.active, None if is_quadview else i)
    return (None, None)

class ModalTimerOperator(bpy.types.Operator):
    """Operator which runs its self from a timer"""
    bl_idname = "wm.modal_timer_operator"
    bl_label = "Modal Timer Operator"

    _timer = None

    def modal(self, context, event):
        if event.type in {'RIGHTMOUSE', 'ESC'}:
            return self.cancel(context)

        if event.type == 'TIMER':
            space, i = get_quadview_index(context, event.mouse_x, event.mouse_y)
            if space is not None:
                if i is None:
                    view = space.region_3d
                else:
                    view = space.region_quadviews[i]
                print(get_view_orientation(space, view))

        return {'PASS_THROUGH'}

    def execute(self, context):
        wm = context.window_manager
        self._timer = wm.event_timer_add(0.5, context.window)
        wm.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def cancel(self, context):
        wm = context.window_manager
        wm.event_timer_remove(self._timer)
        return {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.wm.modal_timer_operator()


Background image not showing up in any 3-D view

Found the problem: The files had somehow become corrupted and wouldn't actually open in anything except for the Preview app provided by apple, so if this happens to you, recheck the pictures in your browser to make sure that they work and everything. If they don't, just open them in a editing or viewing program and copy paste them to a new project.


How to visualize reflection of a beam or ray

If I understood, you are looking for a representation of a single ray, without the use of render engines.

You can create geometry with python, which is raycasted. I modified the script from this laser question to create an object, which contains the laser as geometry.

Start with the first "hit" point at (0, 0, 0) and the casting direction (0, 0, 1) in the objects orientation. The following steps are

Use the scenes ray_cast method to cast a ray. Get the hit position and the normal of the hit face.
If the normal is on the side of the incoming ray, reverse it. The resulting angle between direction and normal ray will be < 90°.
Get the difference between direction and normal ray. Rotate the direction ray twice by this difference. The direction ray is now "mirrored" along the inversed normal ray.
Inverse the direction ray. This is the new direction ray in which direction we cast from the hit position.

import bpy
import bmesh
import mathutils

EPSILON = 0.00001
MAXIMUM_ITERATIONS = 50
OBJECT_NAME = 'light_plane'

def get_create_object(scene):
    ob = scene.objects.get(OBJECT_NAME)
    if ob == None:
        me = bpy.data.meshes.new("me")
        ob = bpy.data.objects.new(OBJECT_NAME, me)
        scene.collection.objects.link(ob)
    return ob

def do_raycast(scene):
    object = get_create_object(scene)
    points = [object.location]

    _, rot, _ = object.matrix_world.decompose()
    direction = mathutils.Vector((0, 0, 1))
    direction.rotate(rot)

    for i in range(MAXIMUM_ITERATIONS):
        origin = points[-1] + direction * EPSILON
        result = scene.ray_cast(scene.view_layers[0], origin=origin, direction = direction)
        hit, location, normal, index, ob, matrix = result
        if not hit:
            break

        if normal.dot(direction) < 0:
            normal *= -1

        rot_dif = direction.rotation_difference(normal)
        direction.rotate(rot_dif)
        direction.rotate(rot_dif)
        direction *= -1
        points.append(location)

    points.append(points[-1] + direction*10)
    bm = bmesh.new()
    [bm.verts.new(pt) for pt in points]
    bm.verts.ensure_lookup_table()
    for i in range(len(bm.verts) - 1):
        bm.edges.new((bm.verts[i], bm.verts[i + 1]))

    bmesh.ops.transform(bm, matrix = object.matrix_world.inverted(), verts = bm.verts)
    bm.to_mesh(object.data)
    bm.free()

for h in bpy.app.handlers.depsgraph_update_post:
    bpy.app.handlers.depsgraph_update_post.remove(h)
bpy.app.handlers.depsgraph_update_post.append(do_raycast)


Addon Only Works on Mac if Blender Started from Terminal

One approach is to add a preference panel to configure the PATH to each of the external programs.

A second approach is to add a preference allowing the use of a custom path and use that as an override when you call the program:

import os
import subprocess

PREFERENCE_PATH_OVERRIDE = '/usr/local/bin:/Users/myname/bin'

local_env = os.environ.copy()
if PREFERENCE_PATH_OVERRIDE:
    local_env['PATH'] = (
        PREFERENCE_PATH_OVERRIDE + os.pathsep + local_env['PATH'])

subprocess.call(
    ['magick', '--help'],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    env=local_env)

where PREFERENCE_PATH_OVERRIDE comes from the add-on's preferences.

I believe these two approaches are the best.

You could also use an add-on I just made that changes the PATH environment globally inside Blender: https://github.com/semond/system_path.

If you insist on forcing the user to modify the path at the OS level, it's a little complex on OS X. You can find a number of techniques on the web, some non-functional on the latest OS X.

On the latest OS X, the simplest method is probably to use this command:

sudo launchctl config user path <path>

You then have to reboot for it to take effect. The path will be set for all users on the system.

Another technique involves creating a bash script, and then register it to be executed when the user signs in.

Since I do not believe these are the most interesting approaches, I won't detail them. You could search for “how to set path for finder-launched applications” on Google.


Flat shaded mesh - missing separate colours/normals for connected vertices?

You’ll want to use “split normals”.

Set your faces to 'smooth' shading, and enable use_auto_smooth mesh option).
Compute the normals (mesh.calc_normals_split()).
Access them from loops (mesh.loops[0].normal).
Don’t forget to free them once you do not need them anymore (mesh.free_normals_split()).


disable "traceable" in material options to prevent the object from casting a shadow and let light pass though it.


Convert particle system to animated meshes

I think the only way to do it is with some Python scripting. First select the object you want to show in place of the particles (dupli object) and then select the object with the particle system. Then run the following script. But be aware, it can get quite slow if you have lots of particles (for 5000 particles and Suzanne as dupli object, it took almost 4 minutes on my computer).

import bpy

# Set these to False if you don't want to key that property.
KEYFRAME_LOCATION = True
KEYFRAME_ROTATION = True
KEYFRAME_SCALE = True
KEYFRAME_VISIBILITY = True  # Viewport and render visibility.

def create_objects_for_particles(ps, obj):
    # Duplicate the given object for every particle and return the duplicates.
    # Use instances instead of full copies.
    obj_list = []
    mesh = obj.data
    for i, _ in enumerate(ps.particles):
        dupli = bpy.data.objects.new(
                    name="particle.{:03d}".format(i),
                    object_data=mesh)
        bpy.context.scene.objects.link(dupli)
        obj_list.append(dupli)
    return obj_list

def match_and_keyframe_objects(ps, obj_list, start_frame, end_frame):
    # Match and keyframe the objects to the particles for every frame in the
    # given range.
    for frame in range(start_frame, end_frame + 1):
        bpy.context.scene.frame_set(frame)
        for p, obj in zip(ps.particles, obj_list):
            match_object_to_particle(p, obj)
            keyframe_obj(obj)

def match_object_to_particle(p, obj):
    # Match the location, rotation, scale and visibility of the object to
    # the particle.
    loc = p.location
    rot = p.rotation
    size = p.size
    if p.alive_state == 'ALIVE':
        vis = True
    else:
        vis = False
    obj.location = loc
    # Set rotation mode to quaternion to match particle rotation.
    obj.rotation_mode = 'QUATERNION'
    obj.rotation_quaternion = rot
    obj.scale = (size, size, size)
    obj.hide = not(vis)
    obj.hide_render = not(vis)

def keyframe_obj(obj):
    # Keyframe location, rotation, scale and visibility if specified.
    if KEYFRAME_LOCATION:
        obj.keyframe_insert("location")
    if KEYFRAME_ROTATION:
        obj.keyframe_insert("rotation_quaternion")
    if KEYFRAME_SCALE:
        obj.keyframe_insert("scale")
    if KEYFRAME_VISIBILITY:
        obj.keyframe_insert("hide")
        obj.keyframe_insert("hide_render")

def main():
    # Assume only 2 objects are selected.
    # The active object should be the one with the particle system.
    ps_obj = bpy.context.object
    obj = [obj for obj in bpy.context.selected_objects if obj != ps_obj][0]
    ps = ps_obj.particle_systems[0]  # Assume only 1 particle system is present.
    start_frame = bpy.context.scene.frame_start
    end_frame = bpy.context.scene.frame_end
    obj_list = create_objects_for_particles(ps, obj)
    match_and_keyframe_objects(ps, obj_list, start_frame, end_frame)

if __name__ == '__main__':
    main()


At the bottom of the 3D viewport, there are these buttons.

You probably don't see the manipulator wigit type buttons, so click on the button that's got the axies icon. Then, you can see the others, and choose which one you want.


Morph Text from Horizontal to Curve above

Shape Keys!

I discovered the Shape Keys for the Curve and used them to animate my Curve.

Here is a more complete answer: How to animate A curve segment?


Press 1 (not in the numpad)
At some point you pressed 2.
1, 2, 3 change the way you see and act on the mesh
1 = vertices
2 = edges
3 = faces


Is it possible to select only the faces that form the first "level"?

Select few unwanted faces (one in each X, Y direction)
Search for Select Similar > Normal
Separate P by Selection and hide newly generated object
For faces oriented Z use type Co-Plannar because type Normal takes into acount too many top faces

Tips:

you can delete them directly, but it is better to check if in this separation isnt a face you want to join back
use Face Orientation overlay to see better unwanted faces

This technique is not a perfect, but does some job.

I don't know what is the purpose of this model, but if you don't care about UV Map and some loose of "accuracy", some cleaning can be done also witm Merge by Distance like 0.2 (in Vertices select mode) and search for Fill Holes operator to close some gaps. In this case you don't have to boder with separation of unwanted faces. They will be removed anyway.


Array / fit curve modifier doesn't produce a long enough array to fit entire curve

If you make a default cube, and a default circle, the default cube is 2 units wide and the default circle has a circumference of 2pi (2 * radius * pi).  How do you evenly array something 2 units wide into something 6.28... units longs?  You can't.  2 doesn't go into 2pi evenly.  So Blender makes 4 of the cubes.  (Differences in yours may be due to unapplied scale, but it doesn't matter; you're not going to get any array to fit any curve exactly.)
As for things failing to follow the curve after its end-- there is no curve after the end.  If you want it to continue to curve, create more curve.  Which you can do by entering edit on your curve, selecting a control, and 'e' to extrude it.
Now, you might find it useful to enable "stretch" and "bounds clamp" on your curves, in properties/object data/shape.  If you do this, any curve modifiers you use will stretch the modified mesh to fit the curve-- so those 4 cubes, 8 units long, 2 units each, will turn into 4 cubes, 6.28... units long, pi/2 units long each.


How does the compositor interact with the 3d viewer? (Chroma keying movies as planes)

The 3D Viewport is the place where you can manipulate your models, and modify the way they look. You can use different shading techniques to see how your objects react in different scenarios.
It has a few "views" :

Wireframe mode - Where you can see only the edges of your mesh, and can see through the faces
Solid mode - The shading is simplified to help you focus on the geometry for example
Lookdev mode - Where you can see an approximation of the final textured result thanks to the real-time render engine Eeevee
Rendered mode - Where you see the scene as it will be rendered when you choose to output an image out of it. It is supposed to be slower so it is not recommended to use this mode when modifying your geometry

When you are happy with your rendered look, you can choose to render an image or a video of your scene. You need to add a camera and position it so that the parts you want to be in the final images are inside its field of view. You can see what will be rendered by pressing  numpad 0 . When you are content with it, you then can render the image by pressing  F12  for a still image or CTRL  +  F12  for an animation (or go the render menu on top of the blender window).

Then the image is rendered, and you can add post-processing compositing effects, for example changing certain colors, adding flares or adding a vignette effect. This is a one-way process and can only be applied to rendered images. It cannot be used to then be applied back into the 3D viewport.

If you want a real-time chroma key you will have to build a custom shader for that, because the compositor will only affect the output of your rendered images.


The units don't change when I am zooming

The measurement indication on the upper left is in reference to the grid.

If you are in perspektive view or rotated (custom) orthogonal view, then the grid is going to remain the same size, and hence the displayed text will say meters. (The grid is space in meters.)

In orthographic top, side, bottom, front and back view, the grid updates according to the zoom level.


I want to increase the number of vertices in a cylinder

When doing most actions in 2.8+, and in the case of adding an object Shift+A there will be a menu popup, by default in the lower left portion of the screen, edit the top box, labelled vertices, to your preference.

Alternatively, in edit mode, select the top and bottom loops with alt, then use the vertex context menu by right clicking, and select subdivide on the loops.
Or with cursor in middle of cylinder press Ctrl+R move a bit with cursor until first yellow ring appears, then you can add more loops by scroll wheel or pressing number.  Enter.

Or if you just need to make cylinder look smooth, you dont have to add vertices - change shading to Smooth and in Properties Editor, Mesh Data, Normals, Auto Smooth.


Weight Paint Disappears When I Select a Bone

Instead of trying to have all of the bones and the object selected together, just select the bone you want to weight paint in pose mode, and then select the object Player or the object you want to weight paint. You do not need to have both objects selected together to weight paint.


Multiple similar functions mapped to one hotkey?

Blender has a quick favorites menu, hotkey = q. To add operations to the quick favorites menu, simply right click on the operation and choose add to quick favorites.
For example, let's say I want the add mesh operation to be in my quick favorites menu:
Now when I hit q this is what I see.


Origin to 3D cursor not working for one mesh

As moonboots said, if I apply the scale the origin moves to 3D cursor.


How to assign a color value to face (object) using python

Set Material.use_object_color to True

From code in this answer which demonstrates use of object colour

# get mat create.
mat = bpy.data.materials.get("randobjcol")
if not mat:
    mat = bpy.data.materials.new("randobjcol")
    mat.use_object_color = True

# assign to object
ob.active_material = mat


Blender I Hotkey not doing what it is supposed to

Blender uses several different 'modes' - the same keys sometimes work differently depending on the current mode. The mode menu is normally shown at the bottom of the 3DView.

Pressing I while in object mode will bring up the insert keyframe menu, unless you have specified a keying set for it to use automatically. When a keyframe is inserted you also get feedback in several areas - the timeline will show a yellow line on the frame that has a keyframe and numerical values will have a yellow background (this changes to green when you change frames)

If you are in edit mode of a mesh object then I will perform an inset on the selected part of the mesh.

CtrlI will invert the selection - both in object and edit mode.

Also blender uses "focus follows mouse" which is a bit different than most Mac and Windows users are used to, you need to have the mouse cursor over the part of the blender window that you want to perform the action, which for insert keyframe would be the 3DView.


Collection of objects added as particle to a Plane not getting projected within the Plane

The problem has to do with the way you created your letters. I'm guessing you added a Text object, converted to a mesh and then separated by loose parts. The problem with this is the whole text object is considered to have one origin point that stays the same for all the individual letters after they have been separated.
In the image below, you can see that no matter what letter object I pick, the origin point is still the same. Also notice how the offset of the particles corresponds somewhat to the offset of the each letter from the origin point.

The solution then, is to reset the origins for each letter back to the center of the object. Select a letter and pick Object > Set Origin > Origin To Geometry. Do this for each letter. To make it faster, you can do it for one letter, and repeat for the rest, by selecting them one by one and pressing Shift + R.

If you want to make sure the origin is at the bottom of the letters (so the particles don't appear "halfway through" the plane), you can be a bit more specific and (in edit mode) select a bottom face (or combination of faces) and press Shift+S and select "Cursor to Selected". This will place the 3D cursor in the middle of the face(s) you selected.

From here, go back to Object mode, and select  Object > Set Origin > Origin To 3D Cursor. This is a more involved process though, as you will have to do this manually for each letter.


How to "simplify" an entire project in order to import it in another?

As you're a beginner (it seems) you can:
- Save your .blend fila with another name - select your model - got to the modifiers tab in the properties window and press the "apply" button on all the modifiers you don't need (armature, cloth, etc.) Start applying the modifiers from the upper (first calculated) to the lower (last).
Then delete the armature and everything you don't need, save the new file, close it and then reopen. - Import you model from this new file.


How to populate UIlist with certain collections?

Go get the UIList for materials for 2.8x from Create an interface which is similar to the material list box

Set the type of the PointerProperty to bpy.types.Collection in order to store a pointer to the collection per item added to the PropertyGroup. No matter if the user adds new objects, changes the name of the collection or anything else, it always returns the reference added to the list:

class CUSTOM_objectCollection(PropertyGroup):
    #name: StringProperty() -> Instantiated by default
    coll_ptr: PointerProperty(
        name="Collection",
        type=bpy.types.Collection)

Edit the draw_item method to display the items properly (you can use a label too):

def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
    split = layout.split(factor=0.3)
    split.label(text="Index: %d" % (index))
    split.prop(item.coll_ptr, "name", text="", emboss=False, icon="COLLECTION_NEW")

The last tiny bit you have to implement is a new operator to append the collections to your UIList. To get the idea I modified CUSTOM_OT_actionsoperator to add the active collection to the list. Just add a new item and assign the collection object to the coll_ptr variable declared before:

if self.action == 'ADD':
    act_coll = context.view_layer.active_layer_collection.collection
    if act_coll.name in [c[1].name for c in scn.custom.items()]:
        info = '"%s" already in the list' % (act_coll.name)
    else:
        item = scn.custom.add()
        item.coll_ptr = act_coll
        item.name = item.coll_ptr.name
        scn.custom_index = (len(scn.custom)-1)
        info = '%s added to list' % (item.name)

    self.report({'INFO'}, info)

Once a few items have been added to the list, you can use the console to make sure all is working. You can easily print the names of the collections, the objects per collection or whatever...

>>> for coll in C.scene.custom:
...     print (coll.coll_ptr.name)
...
Collection
Collection 2

>>> for coll in C.scene.custom:
...     for ob in coll.coll_ptr.objects:
...         print (ob)
...
<bpy_struct, Object("Cube")>
<bpy_struct, Object("Light")>
<bpy_struct, Object("Camera")>

To set the selected collection of the list as active collection in the Outliner, you can use a callback for custom_index property see: https://docs.blender.org/api/current/bpy.props.html#update-example

Note: You don't need that extra bool, just add the collection to the list when adding a new one to the scene.


You can use Relax function that comes with LoopTools add-on. The add-on comes with Blender so you just need to activate it in the User Preferences (ctrl+alt+u). The function is then accessible from Specials menu (w), LoopTools submenu. It can be used with edge loops selected. Note all the options in the t panel that you can change.

Space function might also be useful:


Each bone in an armature deforms only a part of the mesh - so each vertex of the mesh has to know how much each bone influences it. They are just vertex groups with the names of the bones, but are called bone weights because of what they represent:

They are created automatically when binding (Set Parent CtrlP) the mesh to the armature with automatic bone weights:

The vertex groups will be generated only for bones that have Deform enabled in their properties. If you later add bones to the armature you can re-generate the groups again with binding the mesh again with the same parenting action.

But usually you can get better deformation if you edit the weights manually. That's done in Weight Paint mode. You can view the bone weights and paint them with brushes - and thus control precisely what and how each bone deforms:

You can select them from the vertex groups list or better select some bone in pose mode, then shift-select the mesh and go into Weight Paint mode. You will see the weight group for that bone. You can also move, rotate and scale the bone with G,R and S keys to see how it deforms while you are painting. You can also select a different bone without leaving Weight Paint mode with ctrl-selecting another bone.

There are also tools to specifically help with weight-painting under the Weight tools in the Tool Shelf.

The Weight Gradient tool is very good for making linear weigh transitions - to linearly blend the influence between two bones, something that will make nice weights for the twisting if you wouldn't be happy with the automatic weights.


In animation nodes, Groups are a kind of subprogram, like Loops or Scripts. To add one, press Shift + A > Subprograms > Group. Then, you can name your group and connect up your grouped nodes to the inputs and outputs of the Group. Here is a gif of this from the Animation Nodes Docs:

You can invoke your group with an Add Subprogram node.


Fluid simulation does not follow animation

I found a way how you can solve this in a "relative" quickly way.

Add a plane to your scene, subdivide length in 2 then subdivide it 10 times or so. Then Shrink wrap this plane, on your animated object.

Remove the fluidsim obstacle from your animated mesh.

For the Shrink wrapped plane, Add fluidsim (trough add modifiers!!!)
Then you get a non specific fuidsim control below it, it has a small properties icon, click it, set it to Fluid obstacle and animated mesh.

Below i add this working solution, note that I tuned the plane a bit.
Because shrink wrap had to fit in both open and close position.
Therefore i bended it, also I added another plane width fluid collision against leaking at the bottom.

Here is my final solution for this problem... btw it was a nice puzzle !!!

The only thing left todo is give those planes invisible materials, so you wont see them in final render.


Are bpy_extras.object_utils.object_data_add created mesh objects relative to the global origin or cursor location?

Simple test in python console
Run a simple test. Put the cursor at some known scene location, and add an object using the bpy_extras.object_utils.object_data_add method. (Simply pinched a mesh from the active object cube)
>>> C.object
bpy.data.objects['Cube']

>>> me = C.object.data
>>> C.scene.cursor.location = (10, 10, 10)
>>> import bpy_extras
>>> ob = bpy_extras.object_utils.object_data_add(C, me)

>>> ob.location
Vector((10.0, 10.0, 10.0))

Hence without any operator passed, uses the scene cursor. btw the python source is readily available, and could check thru scripts/modules/bpy_extras/object_utils.py to confirm
To make it zero location, rotation and unit scale
>>> ob.matrix_world = Matrix()
>>> ob.location
Vector((0.0, 0.0, 0.0))

Check the docstring
For a quick run down check the docstring in the python console
>>> bpy_extras.object_utils.object_data_add(
object_data_add(context, obdata, operator=None, name=None)
Add an object using the view context and preference to initialize the
location, rotation and layer.
:arg context: The context to use.
:type context: :class:`bpy.types.Context`
:arg obdata: the data used for the new object.
:type obdata: valid object data type or None.
:arg operator: The operator, checked for location and rotation properties.
:type operator: :class:`bpy.types.Operator`
:arg name: Optional name
:type name: string
:return: the newly created object in the scene.
:rtype: :class:`bpy.types.Object`

Use in conjunction with an operator
is designed to be used in conjunction with an add object operator in which case transform settings are taken from the instance of the operator.  Often also used with AddObjectHelper class, as demonstrated in Text Editor > Python > Templates > Add Object  and in this example https://blender.stackexchange.com/a/160995
Using a decorator
An example of wrapping a decorator around the imported method to set the new object created to a transform of our choosing.
import bpy
from bpy_extras.object_utils import object_data_add
from mathutils import Matrix

def location_decorator(matrix=Matrix()):
    def decorator(f):
        def g(*args, **kwargs):
            ob = f(*args, **kwargs)
            ob.matrix_world = matrix
            return ob
        return g
    return decorator

object_data_add = location_decorator()(object_data_add)

me = bpy.data.meshes.new("Foo")

ob = object_data_add(bpy.context, me)

or if using with an operator that has a location property, but we wish to make it default to scene origin (or another transform) when not set then
def location_decorator(matrix=Matrix()):
    def decorator(f):
        def g(*args, **kwargs):
            op = kwargs.get("operator")

            if op and not op.properties.is_property_set("location"):
                op.location = matrix.translation
            return f(*args, **kwargs)
        return g
    return decorator


How to run a piece of code when addon is just activated

This is an example addon that will execute the function "load_fonts" when blender starts,  it use the handlers to run a function at blender start :

import os
import bpy
from bpy.app.handlers import persistent

@persistent
def load_fonts(scene):
    font_dir = bpy.context.user_preferences.filepaths.font_directory
    for file in os.listdir(font_dir):
        if file.endswith(".ttf"):
            bpy.data.fonts.load(font_dir+file)

def register():
    bpy.app.handlers.load_post.append(load_fonts)

def unregister():
    bpy.app.handlers.load_post.remove(load_fonts)

if __name__ == "__main__":
    register()

you can call the function  you want inside the register() function, but you can't get access to the scene :

def load_fonts(scene):
    print("addon activated ")

def register():
    load_fonts()

if __name__ == "__main__":
    register()

to overcome this problem you can use handlers to access the scene as @CoDEmanX shows in this thread :  example

import os
import bpy
from bpy.app.handlers import persistent

@persistent
def load_fonts(scene):
    bpy.app.handlers.scene_update_pre.remove(load_fonts)
    font_dir = bpy.context.user_preferences.filepaths.font_directory
    for file in os.listdir(font_dir):
        if file.endswith(".ttf"):
            bpy.data.fonts.load(font_dir+file)

def register():
    bpy.app.handlers.scene_update_pre.append(load_fonts)

def unregister():
    pass

if __name__ == "__main__":
    register()


I have a rigged object that I want to cut in half and be able to move around, but the armature deforms it

One possible solution is animate your rig until you get to the point where you need it to split in two. When you get to that point, go into Object Mode, select the rig, Shift + select the character mesh that is bound to it, and then duplicate them both (Shift + d). You will have a copy of both armature and character mesh, which means all vertex weights will be inherited, as well as all keyframes, up to that point. Put an invisible material on the half of the new character mesh that you don't want to be rendered, and also put one on the opposite half of the old character mesh. When you add new keyframes to the new rig, it can look as if the character is splitting in two.


How to parent or constrain baked particles to an object so they follow the object's animation?

The Particle Instance modifier seems to do the trick.
Basically any object with the particle instance modifier draws the result of the simulation you point it to. but the object itself can be animated and does not actually influence the result of the simulation.


How to completely remove all loaded data from Blender?

2.79 or newer

Note, to avoid having to remove this extra data, you can start a new file with blank scene, objects..., eg:

bpy.ops.wm.read_factory_settings(use_empty=True)

Or...

bpy.ops.wm.read_homefile(use_empty=True)

Old Answer (useful for partially clearing)

This can be done by running 'Reset Factory Settings' operator (then clear the data).

The advantage with doing this is we only need to clear the default Cube, Camera & Lamp. Since 'Reset Factory Settings' will clear everything else each time (images, packed data, curves.. etc).

import bpy

def reset_blend():
    bpy.ops.wm.read_factory_settings()

    for scene in bpy.data.scenes:
        for obj in scene.objects:
            scene.objects.unlink(obj)

    # only worry about data in the startup scene
    for bpy_data_iter in (
            bpy.data.objects,
            bpy.data.meshes,
            bpy.data.lamps,
            bpy.data.cameras,
    ):
        for id_data in bpy_data_iter:
            bpy_data_iter.remove(id_data)

reset_blend()

If you wanted to you could skip calling bpy.ops.wm.read_factory_settings(), but theres a possibility some other data was loaded (curves or lattice for eg) that you don't know about. The clearing function could be extended to test for all possible data, but loading factory settings is an easier way to ensure you didn't miss some.


Tapering a tentacle mesh with uniformly scaled suction discs

Duplication on Faces

Consider Proportional Editing manually or by modifier.  Curve guide with [no] radius adjustment.

Above Detail view. Blue Tentacle Curved Form Tapered.  Discs Not Tapered. I used a semi torus as a disc for this discussion.

Above the Duplication Settings for the tentacle highlighted above. Scaling is uniform for this feature.  No ellipse forms are introduced.  This feature renders duplicates and does [not] render the two original meshes.  Surprising but useful.  For the question above you need one mesh for visual rendering and one for placement of duplicated discs.  Total 2 Meshes for final render.  One mesh visible. One not visible.

The disc is parented to the other mesh, this is a requirement .

Above larger view.  Curve Highlighted.  Second set of Discs not placed on any other mesh.  This is just to show versatility of placement.  Original straight Cylinder form with no modifiers.  The two gray cubes used as the tapering objects for a Warp Modifier. I used the warp modifier, as one option, because I wanted visual interaction. You need [not] use the warp modifier. You may [proportional edit] by hand.  You may also use [shape keys].

Above show 2 (two) blue tapered meshes.  The highlighted blue mesh has the curve modifier disabled so we can see both blue meshes easily. The highlighted mesh was copied from the other and then Duplication on Faces was turned off. One blue mesh is rendered and has [no] duplication on faces.  The other other blue mesh is for placement of discs and is not rendered.  This separation of placement and render is a feature.  It is highly likely you need to use 2 meshes in the same fashion.

Above rendered image showing custom placement of discs by deletion of faces, not vertices, of the duplicator.  The viewable mesh was not changed.  2 Meshes are used as stated above.

Above the deleted faces of duplicator.

Above rendered image smoothed and using subdivision surface modifier.

Secondary

You can consider [Make Duplicates Real] on the duplicator to create multiple meshes and turning off face duplication on the duplicator.


Two possible scenarios:

Did you select every single vertices on the bottom ring? If so, stop. Just select one vertex when using the proportional editing tool for this. Use the scroll wheel to increase the fall off of the proportional editing tool.

Do you have the subsurface modifier enabled? If not, the random function will make it jagged.


Why are there non-visible objects in my final render?

If you look at the outliner, some eye-icons are faded out to indicate that certain objects are hidden.

But there's hidden and there's hidden: hidden in the viewport (eye-icon), and hidden for rendering (camera-icon).

You may paste the following code line to the Python Console (at the bottom of the Scripting view) and hit return, to make the render visibility match the viewport visibility automatically:

for ob in bpy.context.scene.objects: ob.hide_render = ob.hide


How to convert a normal map into a curvature map (per pixel curvature)

Generate a curvature map from a normal map

Here are two node setups you can use to generate a curvature or cavity map from a normal map, they use the same amount of nodes and give the same result. You can download all the node setups here: https://drive.google.com/file/d/1bixkxs6cSes-J9GVwDeIP7pW2OnGNhYd/view?usp=sharing

Link of the image used: https://drive.google.com/file/d/0B1wP1Y8dmh8aVmN6VUpYMU02Q28/view?usp=sharing (it is from the Unity Store "Rock and Boulders 2" free pack: https://assetstore.unity.com/packages/3d/props/exterior/rock-and-boulders-2-6947).

First node setup (easier to understand):

Second node setup:

You can also use this Emboss node setup to generate the curvature map: https://blender.stackexchange.com/a/102727/23134

You must set your normal map as Linear in the "n" menu to make the value nodes works properly. To export your curvature to another software like Photoshop add a gamma node at 2.2, don't use it to work on it in Blender.

I have written in the frame +R X- meaning that the red channel must use a -0.5 translate in X and it's the opposite with a positive direction the image must be inverted.

The Pixel width determine the thickness of the lines, it is then divided by 2 and inverted one time for each channel so it moves in X +0.5 and -0.5 for the red channel and Y +0.5 and -0.5 for the green channel.

How does it works?

The color channels of the normal maps create a lighting effect, for example the red channel gives the impression that the textures is lighten from the right and the green from the top. By moving the texture in the direction of the shadows, so for the red channel with the lighting coming from the right we move the texture to the left and by inverting the image to invert the lighting direction we move it to the right, then the images are both combined to create a black contour from the expanded shadows. Three Linear Light node at 0.5 are added, one to combine the red channels, one for the blue channels then one for both color channels.

Then the gamma node converts the image from sRGB to Linear.
Blender works with sRGB images, when you set an image to Linear in the "n" menu this tells Blender that the image imported is in Linear mode and must be converted in sRGB to work with it.

Things you can do with the curvature:

you can overlay it with a smooth curvature map, see how to generate it here: https://blender.stackexchange.com/a/100637/23134
you can multiply it with an ambient occlusion map for a diffuse grayscale (in PBR do not multiply it).
you can fake an hand painted effect by adding a color ramp node: https://blender.stackexchange.com/a/90153/23134
See how to create a Dota asset with this texture: https://blender.stackexchange.com/a/101830/23134
you can bake the normal map in 32 bit Float exported in OpenEXR Float Full to improve the curvature map, you can then export your curvature map in 8 bits TGA.
you can bake the normal map in an high resolution then generate the curvature map and scale the image down to get an anti-aliasing effect.
if the normal map is baked in DirectX instead of OpenGL you will need to use a Converter > Separated RGBA and invert the green channel then plug everything to a Converter > Combine RGBA.


How Do I Use Armatures , I cannot get them to work with my meshes

The easiest way is to parent the mesh to the armature with Automatic Weights, and then adjust the weights later on:

Select the mesh (Object Mode), and then select the armature
CtrlP, and then select 'Automatic weights'. Now Blender assigned weights to the mesh and parented them to the bones of the armature, depending on how the bones and mesh are relatively located.

To modify the weights:

You could select the armature and enter 'pose mode', by CtrlTab
Then you select the mesh and enter 'Weight paint mode', by CtrlTab. Now you can select a bone, while you can edit the weight paints of the mesh using the brush


Will rendering on linux decrese rendertime?

The latest answer is probably pretty different: https://www.youtube.com/watch?v=cpE2B2QSsa0 - their results show that Linux averages out to be twice as fast as Windows 10. I haven't tested this myself.


Connecting a texture node to a material node via the Blender Python API for Blender 2.82

The script works, however you don't assign the newly created material to any object. Therefore you're seeing the old material, that was previously assigned to the active object, in the Material Properties or the Shader Editor.

If you want to assign the material to the currently active material slot of the active object, you can use

bpy.context.view_layer.objects.active.active_material = mat

where mat is the material you've created in your script. Alternatively you can also assign the material to a specific material slot, e.g. the first one in the following example:

bpy.context.view_layer.objects.active.material_slots[0].material = mat

When you're performing multiple operations with the active object, you can store it in a variable. It's not necessary to access it through bpy.context all the time.

One problem with your script is that it creates a node setup which doesn't properly use displacement. Usually you'd want to add a Displacement node and control the height through the texture. You may also want to add a Texture Coordinate node to use the active UV map for the displacement texture.

import bpy

# Create a material
material = bpy.data.materials.new(name="Example_Material")
material.use_nodes = True
nodes = material.node_tree.nodes
links = material.node_tree.links

# Reuse the material output node that is created by default
material_output = nodes.get("Material Output")

# Create Image Texture node and load the displacement texture.
# You need to add the actual path to the texture.
displacement_tex = nodes.new("ShaderNodeTexImage")
displacement_tex.image = bpy.data.images.load("/path/to/your/texture")
displacement_tex.image.colorspace_settings.name = "Non-Color"

# Create the Displacement node
displacement = nodes.new("ShaderNodeDisplacement")

# Create the Texture Coordinate node
tex_coordinate = nodes.new("ShaderNodeTexCoord")

# Connect the Texture Coordinate node to the displacement texture.
# This uses the active UV map of the object.
links.new(displacement_tex.inputs["Vector"], tex_coordinate.outputs["UV"])

# Connect the displacement texture to the Displacement node
links.new(displacement.inputs["Height"], displacement_tex.outputs["Color"])

# Connect the Displacement node to the Material Output node
links.new(material_output.inputs["Displacement"], displacement.outputs["Displacement"])

# Get the active object
active_obj = bpy.context.view_layer.objects.active

# Check if the active object has a material slot, create one if it doesn't.
# Assign the material to the first slot for the active object.
if active_obj.material_slots:
    active_obj.material_slots[0].material = material
else:
    active_obj.material_slots.append(material)

For Adaptive Displacement you will also have to set the Feature Set to experimental

bpy.context.scene.cycles.feature_set = 'EXPERIMENTAL'

and enable the Adaptive option in the Subdivision Surface modifier. You may have to adjust the Subdivision options in the Render Properties as well, in order to get the desired amount detail for the displacement.


how i split this uv maps in the uv maps panel?

i found the solution i had to separate the mesh of the uv map that i wanted to separate and then rename the uv map layouts to not get confuse with them and then delete the uv layout of the uv map that i dont want to keep in both meshes and then i re joined the two meshes again and it fortunately works!!!.


Organic yet accurate modeling with the golden spiral

How about a fully math based approach, here's an interesting paper on scipress.org called Growth in Plants: A Study in Numbers by Jay Kappraff.
from the paper:

Keywords: Phyllotaxis, Fibonacci Numbers, Golden Mean, Continued Fractions, Farey
Series, Wythoff’s Game, Zeckendorf Notation

Blender Addon(s)
There is an addon called Add 3d Function Surface which can be coerced into producing many interesting shapes. It is included in the Extra Objects addon as "Math Functions"

If the purely function based approach fails you then you still have a variety of options. Some of which are a bit more interactive.
Modifiers and Scripting
You could model one part of the object and use a script to rotate it around and scale it up/down according to whatever algorithm you can imagine. For example a 2d version of a plant  on geometry daily, it's simplicity is deceptive. I tend to use live coding tools like tributary.io to figure out the math using .js with immediate feedback. Usually if I can figure something out in 2D, the move to Blender and adding a third dimension isn't that much extra work.
An Array Modifier and an empty can give very similar results to the broccoli.

This is a cone, tilted slightly and shifted away from its origin, then added an Array modifier and used a tilted (rotated) and slightly scaled empty as an array object.
The fractal nature of the brocolli calls for daisy-chained array modifiers, each building on the complexity of the previous.

Elaboration
perhaps a short walk-through script might better convey what otherwise would become a wordy explanation. This script is merely intended to show what daisy-chained Array Modifiers can do, and shouldn't be perceived as nice python or nice code. The script should result in something like the sunflower. Run the code in an empty blend file with the 3D cursor at the centre of the scene.
import bpy
import math
import mathutils
from mathutils import Euler
# make sure 3d cursor is at the center of the scene

num_items_in_spiral = 13
num_spiral_arms = 29
z_rotation = 2.0 * math.pi / num_spiral_arms

# add cone, modify the mesh,
bpy.ops.mesh.primitive_cone_add(vertices=12, radius1=0.354406, depth=0.901211)
obj = bpy.context.active_object
obj.data.transform(mathutils.Matrix.Translation((-0.5, 0, 0)))

# add empty for spiral arm
bpy.ops.object.empty_add()
obj = bpy.context.active_object
obj.name = "Empty_spiral"
obj.location = (-0.8, 0, 0)
obj.rotation_euler = Euler((0, 0, 0.179609), 'XYZ')

# add empty for radial array
bpy.ops.object.empty_add()
obj = bpy.context.active_object
obj.name = "Empty_radial_array"
obj.rotation_euler = Euler((0, 0, z_rotation), 'XYZ')

# add modifiers to the cone
obj = bpy.data.objects["Cone"]

mod = obj.modifiers.new(name="Array_1", type='ARRAY')
mod.use_relative_offset = False
mod.use_object_offset = True
mod.offset_object = bpy.data.objects["Empty_spiral"]
mod.count = num_items_in_spiral

mod = obj.modifiers.new(name="Array_2", type='ARRAY')
mod.use_relative_offset = False
mod.use_object_offset = True
mod.offset_object = bpy.data.objects["Empty_radial_array"]
mod.count = num_spiral_arms

The red cone is the primary object, the curve/spiral coming off it is the result of one array modifier on a translated and rotated Empty. The rest of the spirals are an extra array modifier on a different Empty (rotated around the scene origin by 2*math.pi / num_spiral_arms)
Whatever object/picture you choose to replicate, you can figure a lot out by drawing on top of the pictures and counting, but mostly experimenting. I think it's more accurate to consider these nice geometric objects as 3D fractals rather than the 3D embodiment of a golden ratio.


zoom and pan are not working on the mouse

after restarting Blender many times over 2 days, and loading factory settings, finally decided to try changing orbit turntable to trackball instead, everything worked normally again once I did that. Changed back to turntable and saved to test it, things still working normally. problem solved.(so far). i`ll update this if status changes again.


My texture is washed out in the render, bit not in the preview

The viewport renderer and seems to evaluate overlapping faces differently. In your scene, three faces from different objects are at the same position. Simply moving your textured object in front of the others will solve the problem.

On a side note, did you intend to connect a Normap Map output with a color input?


Where are objects if you add them when nothing is selected?

Turns out blender has new feature that allows you to disable objects in viewport. For some reason all my collections except one object were disabled in viewport. Turning them back on made the objects visible once again.


Can't manipulate linked or appended objects that were made with 2.79 inside 2.8

The symbols resembling a chain link in front of an Object stand for linked objects.
They definitely only appear if you link to an object instead of appending it.

If you append an object, you create a local copy of an object from another .blend file, which can be manipulated like any other object. If you link to an object in another .blend file, you can't manipulate this linked object, instead you have to manipulate it in the original file.

To create a local copy of a linked object, click on the object with the chain link symbol, click on "Object" in the "Properties" panel, then hit the chain link symbol on the right side of the Object selector dropdown.


When I go to the Node Editor to look at my object's material I can't find any nodes

The cube you find when you start Blender has a default material called "Material". Check the "use nodes" checkbox to see them.


UV Map doesn't show when the Render Result is selected in the UV/Image Editor. So, please, try clicking on the X button. As shown below:

For deleting face of individual cubes you have to first Apply the Array Modifier. However, note, that it will convert all cubes to single mesh, so they won't be affected by the Curve Modifier after that.


How can I see matcap when I play a game?

Matcaps are a viewport shading feature that doesn't exist in the game engine. Note that matcaps are applied the same to every object in the scene which is normally not what you want in a game.

You can however use the matcap images used by blender (or from other sources) in your textures which can then be used in the game engine. This question shows the settings needed for both Blender Internal and Cycles.


Fluid Simulation, make the fluid to be absorbed

Changing the Dynamic Paint Canvas type to "Displacement" and setting the "Displace Factor" to negative 1 (-1) gives this effect.

(*make sure the plane/canvas has enough subdivisions)


Bake textures including light / shadows from camera's perspective

Here’s what the Blender documentation on Render Baking says about the Combined bake mode:

Bakes all materials, textures, and lighting except specularity.

Emphasis mine. The disparity you are seeing in your baked textures is the lack of specular reflections.
This should not be surprising, because specular reflections cannot be baked. This is because they are fundamentally dependent on viewing angle, even with completely static lighting. If you were to bake specularity from the perspective of the camera, it would look quite bad whenever the view changes.
The purpose of the Combined bake mode is to bake everything that can be baked in a viewpoint-independent way. It is not, however, a replacement for all further shading. What you should probably do instead is combine the baked texture with a glossy shader to provide viewpoint-dependent specular reflections. For example, you can bake a Combined pass including everything except the Glossy layer, then combine the result with a Glossy BSDF to add specular reflections on top:

You would want to create a similar setup in whatever game engine you are using (making sure to replicate the same lighting!). This is a totally standard workflow, and it’s still relatively cheap to compute.


Camera flips 180 degress when moving around object

Locked Track

You should use Locked Track Constraint instead of Track To Constraint .

As stated in the manual's page:

  Basically, it is a Track To constraint, but with a locked axis, i.e. an axis that cannot rotate (change its orientation).

While the for the Track To it is said:

  ... it always points a given “To” axis towards its target, with another “Up” axis permanently maintained as much aligned with the global Z axis (by default) as possible.

That said, using this kind of constraint will allow you to avoid the flipping of the camera. Here's an example of usage:


I have problems running Blender on my Windows 10 notebook. It's an old machine, can't support OpenGL 3.3 (which, as far as I know, is required for running Blender 2.8). I believe you are facing the same issue, VirtualBox can't run OpenGL 3.3, you'll need to run Blender on real hardware - that is, if your PC is at least newer than mine. I would also give you a suggestion, on Win 10 I can't run Blender 2.8, but it runs quite well on my machine when I use Linux - it might be worth a shot.


Addon object using PropertyGroup object attribute

Using annotations rather than class properties
It is now defined as an annotation. They are added to a key value dictionary __annotations__ on the class on which they are defined. Try something like
TestProp.__annotations__["my_float_prop"]

There is a generic Namespace class where can
from argparse import Namespace
props = Namespace(**TestProp.__annotations__)

and then access them via
props.test_float_prop

Consider too using math.pi.


How do I unlock navigation from the origin of an object?

Hit delete on the numpad, it should reset your viewport to focus around whatever object is selected.


Using a video from the Video Sequence Editor in the Movie clip editor?

Blender uses a fixed pipeline for rendering the VSE is part of this process. The movie clip editor let you track movies that can be used for modeling, compositing or sequence editing. Movie clip editor is an input for the rendering process.
It is a common mistake people want to do this the other way around, but that isn't possible. Another analogy is the chicken and egg problem. Which of the two came first. For blender (and any other render engine) this is solved by having a hard  cut-over moment. Everything after pressing the F12 cannot be used by something before the F12 button in the same scene.
The render pipeline consist out of Render an scene => Render Compositor => Render VSE => Write image. This is a simplistic version of what really happens but suits the question.
If you want to track a video that is rendered you need to create a second scene where you load the rendered result in the movie clip editor and start tracking.


Display object only in certain animation

In pose mode scale to zero bone that controls object

Just insert keyframe for scale with zero value.

But if you perform switching between actions, bones will inherit values from previous action (true only for non-animated values). To override zero values, you have to insert keyframe with value 1 in all actions, where object is present.


If you want the saddle to be "stuck" to the back of the character, you could parent it to 3 vertices of the face you want the saddle to be stuck to.

Select the saddle (RMB)
Add the horse to the selection (SHIFT + RMB)
Toggle Edit Mode
Select 3 vertices
Make Vertex Parent (CTRL + P)


Trying to make a sphere fall trough an animated opening hole in mesh. Help?

After setting Rigid Body Collisions to Mesh you need to check Deforming. See my settings below.


Use animation to change position of an object

With selected object hit space and type "bake to keyframes", open Graph editor (at the left down corner of application), delete everything before and after interesting moment, then clear all keyframes - it will "freeze" the moment of simulation.


The area where the mesh should be displayed is missing

On bottom this is the timeline. Just above the uv map area. On bottom
  left of it there is a button looking like an image. Click on it and
  choose '3D View'. – lemon

You can see what lemon described in the image below.


How to get transform values that would be set from inserting visual key-frame for pose bones?

The page of PoseBone.matrix says

  Final 4x4 matrix after constraints and drivers are applied (object space)

You can convert the matrix from object space to local space calling Object.convert_space

Edit

The comment of convert_space explicitly states that this can not be used for visual keyframing. For the simplest options with

Inherit Rotation
Inherit Scale

enabled. You can get the local transform for the bone like this

def get_mat_offset(pose_bone):
    """ calculate the (local) rest matrix of the bone
        needs to be multiplied with the parent's pose matrix
        to get the rest matrix in armature space """
    bone = pose_bone.bone
    mat_offset = bone.matrix.to_4x4()
    mat_offset.translation = bone.head.copy()
    mat_offset.translation.y += bone.parent.length
    return mat_offset

pb = obj.pose.bones['Bone.001']

if pb.parent:
    mat_offset = get_mat_offset(pb)
    mat_pose_parent = pb.parent.matrix

    mat_rest_inv = mat_pose_parent * mat_offset
    mat_rest_inv.invert()

    matrix_basis = mat_rest_inv * pb.matrix

else:
    matrix_basis = pb.bone.matrix_local.inverted() * pb.matrix

Further you can decompose the matrix calling mathutils.Matrix.decompose

loc, rot, scale = mat_basis.decompose()


First time baker having issues with a normal map

Apply the scale of the low-poly object and it will work fine:


Try to bake action. With selected all objects, that you need to be animated (so without empties) go to Tool Shelf>Animation>Bake Action, choose Only selected, Visual Keying, Clear Constraints, Clear Parents and Overwrite Current Action. For Bake Data select Object and for End Frame and Start Frame appropriate frames on which your animation starts and ends.Animation, that will be effect of that should be easy exportable to Unity.


What does it mean when a property is highlighted in green?

Green means a property has a keyframe applied, but not on the current frame. (yellow means the key is on the current frame). Your changes aren't sticking because it's reverting to the keyed values. You can set a new key if you'd like by right-clicking the field and hitting "insert keyframe", adjust the key values in the graph editor, or just clear them all by right-clicking the prop and hitting "clear keyframes"

Also, for the sake of completeness, a purple property is one that has a driver set.


Can't use Gizmo's in any view but camera view

It just happened to me (not first time) and I've found the issue.

I don't know why, but you only have to uncheck Lock to Cursor on 3D View's Properties Tab. You may accidentally checked it.


Use the Object Instancer Node to create a number of empty objects, fill a random list of the required source objects, copy the mesh data from the random object list to the empty objects, then position them as you want.


I finished a blender project, how do I export it with all the features?

You should first ask for which software you are exporting. It can be very different if you target 3d printing, VR or an animation short.

Maybe your colleagues are using 3DS Max (there is a .3ds export) or Unity3D (you can use Blender files). However some features like particles for example might not be supported. You should be able to find workarounds (convert the particles to mesh: see here or create particles in the targeted software, Unity3D has a lot of options for example).


I would probably just sculpt that detail in sculpt mode with dyntopo enabled and detail size set to 3 - 5. I'd probably make the hat of the mushroom a separate object in order not to mess up the nice topology of the rest of the model. Also, if you keep a copy of the hat as it is now, you could then later use the high-res sculpted hat to bake displacement and/or normal maps to the low-res hat, if you're concerned about performance or render times for your final scene.


Consider a

Curve modifier with a NURBS Circle.
Simple Deform modifier with Bend Selected


Avoid rerendering noise texture on every frame of an animation

Noise is a completly random Texture which is not necesserely equal for the same texture coordinate, each time you evaluate it. Use Clouds with very small size instead