How do I achieve more control over Fairy Wing Meshes?

Mesh Deform Modifier is Well Suited to the Task

A simple armature controls a simple box cage mesh. The cage mesh controls the final wing shape.

I will write more. But we hope to give you immediate tools for your work.

Bind Simple and Near vertices. Depicted in the image above. Then enlarge the shape with extrusion/scaling in [edit mode].  Click and Zoom to see larger image.  Edge lines are difficult to see in a small image.

simple to model
simple to armature weight

The cage is different than the wings.  The simple
cage can control your wings.  This cage is easy to roll/spiral and thus
rolls the wing through the Mesh Deform Modifier.

The image above show the lousy wing inside the cage. I am sure your wing will be very artistic. The mesh deform modifier is displayed on right.
This is a quick mock up slightly tailored to your question.  Please excuse the simplicity.  Note the vertex density of the cage and wing must be adequate and appropriate for your goals.  This is echoed in the video link below.  Please inspect and improve the process for your goals.

Lets pretend the image above was newly created as fairy wings for your question and not just another modifier.

On a humorous note or not.

Moonboots wrote an answer to your question 3 or so hours after my answer.  A short excerpt is reproduced here.

I wish I were flattered.

It is interesting to note the graduated weight similar to proportional editing with smooth falloff in the last picture of his answer.  The mesh is deformed/beformed with greater intensity near the bone itself. The difference is subtle.  This may or not be of interest to the OP.

The technique in this answer it to avoid such smooth falloff.

From the famous video website is  a tutorial!

https://www.youtube.com/watch?v=V2CqQUXraeY

The topic is Mesh Deform modifier. ... To save us both time.

From the minimal documentation.

https://docs.blender.org/manual/en/dev/modeling/modifiers/deform/mesh_deform.html

The image above shows the desired weights for one bone. No manual weight painting.  Extrusion preserves the previous weights.
The circular ring mesh is displayed below.  We display folding rather than rolling. Replace the example mesh with your Wing mesh.  This is not a tutorial on Mesh Deform Modifier.  This proposed answer has the goal to give you immediate steps in the right direction.

Mesh Deform can work with the technique above

This is an example of desired weight [stripe]. Done through modifiers.  The stripe exists or is red in a small portion near the bone.  Face connectivity is [not] considered.

Another Alternative Not Recommended

Place multiple armature spines parallel to each other so that every vertex is controlled by a near by bone.  Experiment at your own risk.

Python Script Success Results

The OP can ignore this in the near future.  Some future readers might benefit.  The above material is simpler.

Stripe in XY Plane or ||. Python.
Because there is little edge alignment with X or Y axis. We think this is more difficult to manually weight paint when a large, inconvenient number of weight stripes are needed.
The large stripe is for easy visibility. Color gradient along Y axis.   Concrete Python improvements are possible.
Read Python at your own risk.  Python subject to massive cleansing and refactoring.  Minimally tested. Please inspect and improve.

A comparison of Armature Placement and Mesh Modifier.  They are similar for this simple test.  Testing remains. Arrow indicates only the Armature Modifier is active.


Animation Nodes Replicate Object Dynamic Paint

You can output the dynamic paint data to a vertex group and use its weight in your node tree. In the following example, we add a vertex group dp_weight and use its weight to control the amount of translation in each instance:


It seems you have extruded several times but did not moved the extruded vertices.

In this particular case, to remove that:

Select the top extruded face (CtrlTab then choose 'face' and right click to select the face)
Use CtrlNumpad+ to extend the selection. Do that several times. You know you are ok when the selection come to the surrounding parts, when it is deselect twice using CtrlNumpad-
X to delete the selected vertices
CtrlTab then choose 'edge' this time
AltRMB to select the edges surrounding the hole
F to remake the face


Diffuse material that doesn't throw shades in cycles engine

To prevent an object from casting shadows uncheck the shadow option in  Object_Tab--> Ray_Visibility--> Shadow :


Nested particle systems are not allowed.

However, you can get the same basic effect by pressing the Convert button on the modifier to Make Duplicates Real.

Then you can tick these options in the Operator Panel:

And press CtrlJ to Join the converted particles to their parent particle object.


Here is a simple example for using Shadow pass in your case:

I personally prefer combining shadow with other passes like AO, for better result.


Seams are something Blender uses internally to let it know where you want to cut. They cannot be exchanged between different programms. In fact internally they don't exist at all and those vertices are actully duplicated, since no vertex can have more than 1 position in UV Space.
I'm not sure why you would need them though, since your mesh is already unwrapped.


Search for the keymap

Go to Edit > Preferences > Keymaps and search for any keymap using 1
Will notice that in object mode it is set to hide  collection.
See How to show collections in blender 2.8


Strange subdivision in Multires modifier

I've solved it. I had several redundant vertexes on the right "arm". I've removed them and it works fine.


Well, I found out that Reset Vectors in the Normals menu (Alt-N) seems to be the answer (you need to select all your vertices):

The result:

I don't know what I'm doing in my export/import code (that I mentioned above) but that's another story.


Script to get the type (hold, breakdown, extreme) of active key

There doesn't seem to be a direct way to determine the keyframe by frame number. However you can iterate through the keyframes of a given object and check if the x-coordinate of the keyframe matches the current frame. Once you have retrieved the keyframe you can access the type.

  type

  Type of keyframe (for visual purposes only)

  KEYFRAME Keyframe, Normal keyframe - e.g. for key poses.
  BREAKDOWN Breakdown, A breakdown pose - e.g. for transitions between key poses.
  MOVING_HOLD Moving Hold, A keyframe that is part of a moving hold.
  EXTREME Extreme, An ‘extreme’ pose, or some other purpose as needed.
  JITTER Jitter, A filler or baked keyframe for keying on ones, or some
  other purpose as needed.

import bpy

obj = bpy.data.objects["Cube"]
fcurves = obj.animation_data.action.fcurves
current_frame = bpy.context.scene.frame_current + bpy.context.scene.frame_subframe

for fcurve in fcurves:
    for keyframe in fcurve.keyframe_points:
        if keyframe.co[0] == current_frame:
            print(f"{keyframe.co}: {keyframe.type}")


Why can I not subtract objects from each other?

Your problem is likely coinciding faces.
Boolean operations do not work well on mesh objects with overlapping, co-planar or almost parallel faces.

My advice is to make it so that the "wireframe object" is slightly bigger than the "solid one", making it protrude a little to the outside, while maintaining whatever precise measurement is indented, so that the outer faces are not exactly overlapping the larger ones.

Optionally go to the Properties Window > Object > Display > Maximum Draw Type and change it from Textured to Wire for the "edges object" you are trying to subtract, so that you can more clearly see the finished operation in the viewport.


Mesh is not rendering, I can only see a background image (or nothing)

Turn off sequencer:

Once you have a movie clip in your VSE it will override rendering. If you want to composit your render on top of the footage, you need to use the compositor. Don't ask me why it's not off by default.


Non-native:

http://blenderartists.org/forum/showthread.php?282824-SVG-output-script

Install via File->Preferences->Addons->Install From File...

Couldn't find any menu additions trying to add this to recent blender versions, but pretty sure I had it working in the past.
https://github.com/hvfrancesco/freestylesvg

Check Freestyle in the Render tab of the Properties window (bottom right). In the Render Layers tab, change Frestyle->Control Mode to Python Scripting Mode and load one of the scripts from the link. The blender file must be saved for this to work and then the SVG just appears in the output directory (or maybe the same dir as .blend, I've forgotten) after rendering.

Native:

https://developer.blender.org/D785

The latest blender in fedora 21 doesn't have this addon, it's pretty new. Rather than find a recent binary build I just compiled from the source. Checking out the blender repository also gets the addon scripts. The one in question is release/scripts/addons/render_freestyle_svg.py. Hopefully this'll make it into the stable releases soon.

This addon needs to be enabled via File->Preferences->Addons (search for and check "Render: Freestyle SVG Exporter"). With this enabled, an additional section appears below Freestyle called Freestyle SVG Export in the Render tab of Properties (bottom left). Check this, and next time you render, a file will simply appear in the output directory. By default the output directory is /tmp/ and my render was /tmp/0001.svg.


Ok, here is my attempt at a "tight grass green" shader. However, I worked on this for a while, before realizing that I should have looked at the reference photo more, because mine doesn't look as similar as I thought it did. Mine looks more "mossy". However, I'm not sure how much closer I could have gotten in the time I had even if I was trying to be more true-to-the-picture. The point of this is that I show how I would (start) going about making a shader of this sort.
Instead of uploading dozens of photos with lengthy descriptions, I will post my whole .blend file so you can see/play with it yourself. It is not perfect - obviously, it does not look exactly like the grass you showed in the picture - now that I think about it, no reputable golf course would allow their greens to fall into such a state of disrepair. The "wear and tear" can be fixed relatively easily I think by just adjusting the brightness of the colors.
Just a couple of things to note - There are 2 sets of musgrave textures in each group. The reason I do this is that musgrave is good at creating a fine grit, but it comes with the cost of large dark blobs among it. Fortunately, with a little tweaking, you can isolate those dark blotches and subtract them from the main image to leave just the grit. That's why I did that.
Secondly, the texture might not have as much relief (height) as you might want, however, the "tightness" of the height information is such that too strong a normal strength just makes things too noisy. I know this can be mitigated by isolating the texture that goes to the normal map and "blurring" it slightly, however I do not have unlimited time to play with it.
Lastly, because of this "noisy normal", this shader can be a bit of a performance hog. Again, this can be mitigated by the same method I mentioned above.
Have a look, play with the values, and I hope you at least find SOMETHING helpful.
The setup and the final product looks like this:

File is here -
Cheers


In Blender 2.79:
For your backface cull object, go to Object settings and at least disable shadow:

This material node setup is all you need for pure black:

Both shift-Z and F12 render work:

In Blender 2.80 (as of February 27, 2019):
Use the same material node setup as shown above for 2.79. Then go to Material tab and change Blend Mode to Alpha Clip (or something similar):

Cheers!


How to distribute points along a single edge with geometry nodes

you can use this setup:

and keyframe the count, then you will get:
https://youtu.be/8Ftlse3fn2Y


Does anyone know how to fix this weird Faces in Blender?

Enter edit mode (Vertex) press 1 on top of your keyboard to filter by vertices. You´ll notice you have double vertices on the corners. Since they're together, select the corner with weird normals and hit ALT+M (merge at the middle). This will join those vertices and correct the normals.

Else, you have more vertices on the faces that you need to delete. Select a vertex, press "X and D" in that sequence.
If you find this is the answer, thank you for your consideration to vote me as the answer by clicking to the left :the icon with a check mark and upvote this answer.

BFCT_Schiller


How to unwrap a cylinder to rectangles instead of a circle?

For this you need to create so called seams.
Seams define where an objects uv layout is interrupted.

Imagine like you cut that object at those seam lines to then lay it flat on the ground.

In a cylinder you need 1 vertical seam in your case. This will allow it to be a rectangle since it can be layed out flat.

To do so press alt+(optional shift)+rigth click (or left click). This will select the whole edge loop. Now that you have done that you can press ctrl+e and go to "mark seam". It should be highlighted in red now. If the cylinder has a face on top and bottom you need the whole circle to be marked as seam too.

Now press U and select unwrap

Alternatively but not recommended you can press automatic unwrap when pressing u. This will automatically set seams where the angle of faces is over a threshold. I highly advise to not use this but do it manually as this will, not just can but will create odd at best and horrible at worst uv maps. It does not know structure and logic but only knows angles. It's OK for dead simple things like cubes but there it ends.


Is it possible for a single object to have more than one mesh?

No, you can't give one object two mesh datablocks at once.

However, if you need to do something like packing UVs of two meshes together you can assign a vertex group to all the vertices in the active mesh. Then you should join the meshes (CtrlJ), do the unwrap or whatever you needed to do, deselect everything, select the vertices in the group, and separate them (P > Selection). That way you have your original object back, but unwrapped together. The Texture Atlas addon can also do this.

If you need to move two meshes together, parent them both to an Empty ( CtrlP).


How to merge a bunch of objects into one?

There are several possible problems that cause the faces to disappear in Unity. The way Unity calculates normal is usually by hiding all of the weird angled faces and flipped normals. So try to:

Select every vertices in Edit Mode and hit 'W' to bring up Special Menu. Choose Remove Doubles to merge every overlapping vertices at the same position.
In Edit Mode, this time with nothing selected, you hit 'Spacebar' and then type in 'Select faces by sides', hit enter. Then hit F6 on keyboard to edit the Properties. Choose 'Number of Vertices = 4', 'Type = Not Equal To'. Now you'll see the Ngons (faces that have more than 4 edges) and probably some Tris (triangle faces) selected. You can now delete them or go and fix them one by one. Repeat this step until you can't see any Tris or Ngons selected.

Now you can try exporting your model into Unity. Hopefully this help :) otherwise, comment below and maybe post your Blend file online so I can check if anything is missing. Goodluck!


Duplicating an armature with ShiftD only works while in object mode and it will only create a duplicate armature in the same file. Also CtrlC only copies the armature object in object mode, in pose mode it will copy the bone locations allowing you to copy the pose.

In your case, with two models in a separate files, you could also open the second blend file then Select Append from the file menu. Link will use the same armature while append will copy the armature into the current file.

When you select a blend file it will show the following list -

First go into object and select the armature you want. Then append again and go into Action and select the actions you want to import into the new file.

As for shape keys, they are part of the mesh object data. If the two mesh objects have similar topology you may be able to copy the shape keys between models. You could append the first mesh object and then try to copy the shapekeys then delete the first object.

I think you may find it easier to append the second object to the same file as the first one, duplicate the armature, copy shapekeys etc. Then save a duplicate copy of the blend and remove one model from each file.


Orientation towards an other object with Animation Nodes

You can use the outer icosphere's vertex normals, same as you have used their vertex locations, to make the lipids face the center. Simply replace the node connection to the loops normal list output from the current vector list to the vertex normals provided by the object mesh data node.

If you want to reverse the direction you can do this in the direction to rotation node you've already added:


Recommended settings for the magic unicorn primitive?

Here is a nail polish shader you can use. I am no make-up artist but I believe it should looks something like this. It does not use SSS but it does render on the GPU.

Node Setup


Your problem was solved, but I would like to mention that the Audio Device that works can differ because I couldn't hear anything in the sequencer with OpenAL but when I changed it to SDL it worked for me. So if it's not working for you I think you should just try all Audio Devices.
Note: I'm on Linux Mint so it could have to do with your OS.


Modeling question - flatten part of the cylinder

I didn't know this Bool Tool addon before. Did some research in Google, found out this addon is included in v2.78

Enable this addon under File > User Preferences > Add-ons > Bool Tool

Select the rectangle first, then select the cylinder, use the Difference operation and got the below result.


You can try cutting the model in half, then delete the bottom part. Then use Mirror modifier. Apply it, and if you don't need the cut at the center, just select it by loop select and press X + dissolve. This is, of course, the case when both sides should be similar. It's a column, so I think they should. Let me know if it's not the case - I will update my answer.


Define position by 3 Euler Angles and Radius

3 euler angles and a radius is not enough values to accomplish what you want. If you added an AXIS, than that may help, but then you also need the axis. If you say X axis, well that really means (1,0,0). After rotation with your euler angles will transform that (1,0,0) to something else. Then you can multiply by scaler distance to get the point you are looking for.

import mathutils
from math import radians

vec = mathutils.Vector(0.0, 0.0, 1.0))
eul = mathutils.Euler((0.0, math.radians(45.0), 0.0), 'XYZ').to_matrix()
scalar = 10.0

vec = vec * eul
position_of_object = vec * scalar


Is there any way to snap a face of object to other face of other object without addon?

You can do it using an empty:

Create an 'arrows' empty (arrows will show objects orientation)
Set snapping option to face, this way:

Snap the empty to the red surface:

Parent the cylinder to the empty (select the cylinder then select the empty and use CtrlP
Move the empty to the blue surface:

Orientation of the cylinder is inverted, so rotate the empty using local coordinates around Y with 180°: RY180

Select the cylinder
Clear parent using AltP and choose "clear and keep transformation"


Install pip and packages from within Blender OS independently

Not satisfied with this, but a somehow hack-ish way:

import subprocess
import sys
from pathlib import Path  # Object-oriented filesystem paths since Python 3.4
# sys.prefix points on Windows to: 'D:\\*blender path*\\2.80\\python'
# Windows only: subprocess.call([str(Path(sys.prefix) / "bin" / "python.exe"), "-m", "ensurepip"])

# OS independent (Windows: bin\python.exe; Linux: bin/python3.7m)
py_path = Path(sys.prefix) / "bin"
py_exec = next(py_path.glob("python*"))  # first file that starts with "python" in "bin" dir
subprocess.call([str(py_exec), "-m", "ensurepip"])

You should see a blue 0 in your console in Blender.

Edit

If subprocess.call([str(py_exec), "-m", "ensurepip"]) results in a Permission Denied error (console shows 1):

Windows: Close Blender, right-click blender.exe and select Run as administrator. Then run the code again.
Linux (untested): Start Blender with the sudo command and run the code again.

Edit Blender 2.81:

Pip is now enabled by default from 2.81, so no need for this solution anymore: https://developer.blender.org/T71856

Installing a library in Blender with pip now works like this:

import subprocess
import ensurepip
ensurepip.bootstrap()
pybin = bpy.app.binary_path_python
subprocess.check_call([pybin, '-m', 'pip', 'install', 'your_package'])

Edit 2: Added pybin, '-m', otherwise it can install the package in a Python environment which is not Blender's one.

Edit 3: You first have to link pip with Blender (added ensurepip)


Export UV Layout in proportion to object size, not UV map

Unwrap both meshes together. (If they are 2 separate Objects then Join them temporarily.)

When both are unwrapped to the same UV space then you will have to do a little editing to get them both aligned.


How can i render the reflections i see in the Look Dev viewport in Blender 2.8

You would need to apply the same HDRI to your world as background. The scene lights in Look Dev are only meant to give you a good preview and not an actual representation of the lighting in your scene. If you want to use the exact same file, you can find it in your Blender installation under 2.80\datafiles\studiolights\world\forest.exr. Otherwise I'd recommend HDRIs from hdrihaven and/or setup a three-point lighting using Blender's lights (Add > Light).

The image below shows how to setup a background texture for your world.


When joining objects, can blender make a vertex group which contains the vertices of each object that was joined?

Pre-op script
Testing shows that uniquely named vertex groups are retained when joining mesh objects.  Instead of doing this manually (boring) can speed it up with a script.
Running script below will give each mesh object in selected objects a vertex group named after the object containing all verts with weight set to 1.
Have commented out the join operator, uncommenting will do it all in one, by running script when selection matches that for join. (ie adds selected to active)
import bpy

context = bpy.context

obs = [o for o in context.selected_objects if o.type == 'MESH']

for o in obs:
    vg = o.vertex_groups.new(name=o.name)
    vg.add(range(len(o.data.vertices)), 1.0, 'REPLACE')

# run the operator
#bpy.ops.object.join()

It occurs that as well as adding vert group, renaming existing groups by for example prefixing object name would stop groups of same name merging
Add this in loop before making new group.
for vg in o.vertex_groups:
    vg.name = f"{o.name}_{vg.name}"

Deja Vu
Creating a batch version of a script that renames Vertex Groups


3-bone IK chain not rotating properly, why?

As it turns out, the severity of the rotation in the chain directly effects how well the IK will work. A subtle rotation isn't enough, but as soon as I bend the chain a bit more in edit mode, the IK picks up quite a bit of rotation.


Blender to Unity, Animations are exporting 2x

Okay so the only way I know of doing this is putting al of your animations in the NLA window. Like so.

After that you can export the Armature + Model.

Deselect - All actions

Select - NLA Strips ( in which you put the animations )

That way, when you import it into unity you will only get the animations that were pushed down on the NLA strip.


Why Always sensor is not sending pulse consistently?

The problem is that the Always sensor is going True and staying there. This works fine for the Motion actuator which will continue to do whatever you want it to as long as its input is True. This doesn't work however for the Property actuator. It only gets triggered when ever the input goes from False to True. This can be seen by hooking up a keyboard sensor to it instead. If you set it to a key and hold that key, the motion will happen continuously, while the property will only have one added to it when the key is first pressed. To get around this you need to set the Always sensor to True level triggering, which means that it will go False then True then False and so forth at the pace defined by the Freq slider.


How can I "zero" an object's orientation in blender?

The simplest ways to do this are to either rotate the mesh in Edit Mode or to rotate it in Object mode and then applying the rotation.

So you can either enter Edit mode, by pressing Tab, and then rotating the mesh with R; the reason this works is that, when transforms are applied in edit mode, the object's origin is not affected.

The other possible solution is to press Ctrl + A>Rotation, which will, essentially do the same as above, by rotating the mesh, but not the object, and thus not the origin, and then resseting the origin's roattion.


Making an object fall with cell fracture

To touch on why your object your object is exploding at the beginning of the animation, check the Collision Margin in the properties panel>physics>rigid body>rigid body tools tab.If it has been changed at all, this can affect how the simulation works.

If the collision margin sensitivity is ticked on and too high, (1 is the maximum) the fractures are literally pushing away from each other, thus the object explodes right away. Creating the effect you're looking for will take just a few steps:

Step one is of course to fracture your object, in my example .gif below I used a sphere.
Step two is to add rigid body physics. Delete the object on layer
one, and move the fractured object from layer two to layer one, or
just work on layer two. Select one fracture, go to the tool
panel>physics tab and click on add active.

Next, select all of the fractures and click on copy from active.

Now you need to add a collision object, so that the fractured
object has something to shatter against. Add a plane and go to the physics settings in the tool panel again, and click add passive.

Now, drag the fractured object to the height you want it to fall
   from, and press Alt+A, and something like this
   should happen:


Why does part of my model disappear when I zoom in on it in the 3D Viewport?

Clipping in the 3D Viewport:

It sounds like you have your camera's Start Clipping Distance set too high in the 3D Viewport Properties. Clipping distances define the range (in distance units) within which objects are visible. If your distances are set incorrectly, your view gets "clipped" when you cross the clipping threshold, as you describe. To change the 3D Viewport clipping settings:

Properties panel (N) -> View section -> set the Clip Start distance lower

(NOTE: These settings only effect display when NOT in Camera view)

You can read more about clipping in the 3D Viewport here.

Camera Clipping Settings

Just so you know, there is also the option to adjust the clipping range of a camera. This effects the scene when viewed through the camera, such as in Camera View or when rendering. To change these properties:

Select camera -> Object Properties window -> Camera tab -> Lens section -> adjust the Clipping Start and End values

To visualize the camera clip distance, select the camera and enable Display > Limits.

You can read more about camera clipping distance here.


The Wiggle Falloff node can be used to introduced the wiggling. The output falloff can then be multiplied with a Point Distance Falloff or an Object Controller Falloff to limit the wiggling to a certain field only:


Is Dynamic shutter speed in Sampled Motion Blur possible?

Since this property cannot be animated or driven, the only thing left is to control it with script:

import bpy
import math

def function(frame):
    # modify this function if you want
    return math.pow(4.75, (frame-30)/50) - 0.75

def my_handler(scene):
    # this code will be run on every frame change
    scene.render.motion_blur_shutter = function(scene.frame_current)

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

Run this in the Text editor, render the animation normally.
If you want to make changes after you ran the code, remove the handler first with typing this into the console: bpy.app.handlers.frame_change_pre.clear()

If you would like to animate the value, create a custom ID property for the scene which you can animate (name the property "shutter"):

And use this code (it copies the value into the shutter speed):

import bpy

def my_handler(scene):
    scene.render.motion_blur_shutter = scene["shutter"]

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


How could I place objects (buildings) on a flat surface in the BGE?

Warning: this is a long answer. It may take a while for some of the images to load. For those of you who don't like reading: The working .blend files are at the bottom of this answer.
Basic Mechanics
You first need an empty (named Arrow) to follow the mouse. This empty will add the buildings.
You will need a script like this.
from bge import logic

def main():
    scene = logic.getCurrentScene()
    cont = logic.getCurrentController()

    mouse_over = cont.sensors["MouseOver"]

    if mouse_over.positive and scene.objects["Arrow"]['ActiveYesNo?'] :
        tracker = scene.objects["Arrow"]
        tracker.worldPosition = mouse_over.hitPosition
        tracker.worldPosition.z += 1

And use this on your empty.

That way your empty will always track to your mouse.
Now all you need to do is make it add the buildings when you click and it is in a valid position. You can do this by adding some more simple logic on your empty.

Now when the Boolean property OkSpot? is true, and the left mouse button is pressed, it will add your building object. however this doesn't help us much if there is nothing to toggle that property when the placement spot is valid.

Now when the arrow receives the message GoodSpot it will set the Boolean OkSpot? to true and, when the arrow receives the message BadSpot it will set the Boolean OkSpot? to false. Now we are done with the empty (named Arrow), but we now need something to send those messages.
We obviously need some sort of collision detector. In this case, a simple cube will work. Add a cube and parent it to your empty (named Arrow).
We need to edit the cube so that it is slightly above the ground.

Now when it is on the slightest slope, it will be colliding with the ground.
It is also important that you change your Collision object's collision type from static to sensor, because static objects can't detect collisions with other static objects and, I assume that your ground will be a static object. You also should set it's collision bounds to Box.

Now that we have our collision object detecting collisions properly, we still need it to send that information to the arrow. We can do this by using this logic setup.

Now we can test it. Everything should be working so far. the building we will be adding is just a cube for now.

The basic mechanics should be working now to place the buildings. skip to the end if you don't care about how your game looks.
If you want to be make it much more complicated, you can have two other no-collision duplicates of the building that will be added, one transparent green, and the other transparent red. (to show when the selection is valid.) Then you can make the arrow directly connected to the red and green objects telling it when the selection is or is not valid.  TO make this simpler, first we should set the maximum draw type on your collision detector to wire. we also need to make it invisible.

Now if we look at the viewport, it should look like this.

Now we can add the red and green cubes. These are just graphics to make it look pretty and are actually irrelevant for the basic mechanics. The system already works fine (skip to the end if you don't need it to look good).
Now, both your red and green cubes should be no-collision and both parented to the main empty (still named Arrow).

Now all we need to do is make them toggle their visibility depending on whether or not the selection is valid. we can do this by adding two visibility actuators to both Cube Red and Cube Green then we need to add another property sensor on the empty (yes, it is still named Arrow) to detect when the Boolean OkSpot? is false.
If you don't like reading but are ok with pictures, skip this part.
we already have a property sensor to detect when it is true, so we can re-use that one. If we connect them to the appropriate visibility actuators on both cubes, it should change color accordingly. I have named the and controllers ok and not to make connecting them simpler. The and controller that is connected to the property sensor that detects when OkSpot? is true, receives a positive pulse when the arrow is in a valid spot. because we are going to use the green cube to show when the selection is valid, it should be visible when the selection is valid. the red cube should not be visible when the selection is valid. connect the other *and * controller to the visibility actuators that are still unused.

Now that everything is working, we can test it again.

Everything seems to be working fine.
We are now going to add the button to toggle on/off the build system. If you only want it to work and look cool, skip to the very end where the blend files are. Doing this will make a big mess of the logic, and I recommend also downloading the simplified blend so you can get an idea of how this works without the messy logic of the working one.
We can now add the button to turn on/off the arrow.
We need an overlay scene with a camera and a button. the button can be something fancy, or just a plane with logic.

Now we can go back to the main scene and add a scene actuator to one of the objects to add the HUD scene. It is true that you could put it on any one of your objects, But I usually add an empty and put it somewhere where it is easily accessible. This empty holds all of the Game start/end and Scene add/remove logic.

We also need the mouse to display. In newer versions, this is much easier than before.

Now we need to modify the logic on the original empty (still named Arrow). When logic starts to get this messy, you can un-check the check boxes to make editing easier.
Note that doing this also disables the logic bricks so be sure to re-enable them before testing.

From the newly added logic on the Arrow, now when you place a building, it will deactivate the arrow.
We need to add a way so that clicking the Build button on the HUD will activate it add a new one.

We should test it now to see if this part is working.
Don't forget to re-enable the logic that we un-checked

This part is working. However, we can still see the arrow if it isn't active. This can be fixed easily enough.
You need to significantly change the logic on your arrow to match this.
(Simplified)

(Expanded)

There are two blend files below. One is without that mess, one has it working.
We must test it again.

If you had any trouble following that, you can always look at, take apart, and/or  modify the blend files.
Blend file without button to build (always has arrow active) - Logic is simple.

Blend file with button to build (Click button to activate arrow, click to place cube, clicking also deactivates arrow so you must click build button for each cube you want to add again) - full working demo. Logic is harder to understand.


Translate texture from outer bounds to center

You could manipulate texture space coordinates. You would need to make one go from the center outwards and then animate a value added to it. Gradient texture could be used:


Typing Ctrl+J should work. It is a shortcut that joins meshes. If there are any modifiers that are not applied yet, apply them then hit Ctrl+J.


The bl_idname is not allowed to contain more than one dot. The error message is:
Traceback (most recent call last):
  File "\Text", line 52, in <module>
  File "\Text", line 44, in register
RuntimeError: Error: Registering operator class: 'OBJECT_OT_applymodifiersinselected', invalid bl_idname 'object.apply.modifiersinselected', must contain 1 '.' character

This message can be seen when starting Blender from the terminal on Linux, macOS and Windows. On Windows you can also use Window > Toggle System Console.
In order to fix this pick a different bl_idname, for example:
 bl_idname = "object.apply_modifiers_in_selected"


Local anchor for group master (move/translate/offset of group master moves group instances)?

Creating a group-instance is a different thing from creating a linked duplicate.
When you create a linked duplicate, the object data is shared between the two objects, but each object can be transformed or changed with modifiers without affecting the other.

group instances, on the other hand inherit all of the geometry and data characteristics of their defining group of objects and also inherit their transforms with respect to the scene origin, not the group objects center.
The empty of the group instance acts as an additional displacement gizmo so that you can transform the instance, but moving the parent objects in the global coordinate system will propagate that change to the group instances.

Unfortunately, there's no such thing as a group origin-even a temporary one, so you can't produce a group instance that doesn't behave this way.  Programs like AutoCAD have what are called 'blocks' which are collections of entities with a local coordinate system so that you can instance and transform them.  AutoCAD stores block data in a non-graphical part of its and replaces the defining geoemtry with an instance of the block.

You acheive this same effect in blender by creating a group in a seperate blend file and then instancing it in your scene.
It's not always convenient to have a file link between a group definition and an instance of the group, so what I've generally done is assign my grouped objects to a layer that's turned off or create them in a new scene and then use instances everywhere in the layout scene.


Continuous walk animation - Mixamo to Blender 2.8x

There are 2 sorts of walk cycles, a dynamic one and a static one (well, these are my own words):

The dynamic one makes the character go forwards in Pose mode:

With this kind of animation, if you want the character to move in your 3D scene you need to duplicate the bones keyframes and make the second cycle begin at the end of the first one and so on. There are 2 ways to do it, either in the animation itself, in Pose mode, you need to duplicate the cycle and move the copy a bit further on the right axis, and so on. Or you can do it with the armature object itself, using keyframes and making it jump from position A to B when it needs to begin its second cycle, and then from position B to C, and so on...

The static walk cycle makes the character walk like on a treadmill, by default it doesn't make your character move forwards in your 3D scene:

In that case you need to repeat the action in the NLA Editor and you need to make your character go forward in Object mode. Either you create 2 keyframes to make him go from point A to point B, or you use a Follow Path constraint so that he follows a curve. In both case you need to syncrhonize his speed in the 3D scene with the speed of his walk cycle, otherwise the feet will slide. You can also vary the NLA strip speed to fix the issue.
For small walks, or walks with some changes in its course, it's probably better to use the first solution. For long walks through a large 3D scene, it's generally better to use the second solution.
According to @Gorgious, there is an option when importing from mixamo to choose between "actual" movement or "treadmill" movement with animations


Blender only masks the outline of what I'm trying to mask

Ok, so it turns out that the direction of the mask was flipped. Selecting the mask and switching the direction fixed the problem.
For some reason I had this problem again and this didn't work. Maybe there are different ways to solve different problems with the same look or something, I don't know, its weird.


When texture painting, there is an option to restrict painting to faces that have been selected in edit mode.

If this is something you want to use, you need to go into edit mode and alter your selection to adjust the areas you can paint on.


Constrain armature movement based on child bone position

To get a curved armature result, the splineIK constraint is very helpful. It allows you to use a curve object that the armature follows. You may also want to try using curved bones, which you need to enable B-Bone display for the armature.

As the curve defines the "shape" of the bones you animate the curve to move the armature. To achieve this go into edit mode for the curve and for each control point add a hook by pressing ⎈ CtrlH->Hook to new object which will create an empty for the point. Now when you animate the position of the empty, the corresponding point in the curve will follow and the armature will bend to match.

For the animation you are trying to do I would reverse the direction of the armature. I'm not sure if this will make the rest of your animation easier or not.

Here is an example with curved bones enabled


Show metadata from photos (image sequence)?

You can use Python and getctime to get your desired data.

try:
    mtime = os.path.getctime(file_name)
except OSError:
    mtime = 0
last_modified_date = datetime.fromtimestamp(mtime)


in Preferences, check "add mesh: extra objects"

then you can tap shift-a in 3d view and choose add single vert


Is it possible to move grease pencil drawings in 3D?

Click on enable editing and you will be able to grab and move them like any vertex.


How to turn up light bounces to infinity

Increase Transparency Bounces and Glossy Bounces in the Light paths

More info: Simulate Infinity mirror effect


Instead of array and curve on a plane, you could use a "straight" simple curve as a bevel object of your main curve, as shown below:

to animate the "shape" to follow the "curve", with all straight angles, you could just animate the start/end bevel factors, es:

subdividing the "path" curve more, in particular near the corners, will give more control on how the tip/end of the shape will follow it.


New vertices snap to wrong position, can't change the snapping distance

Ok, after a long search and a break I found the solution.


how i can disable motion blur for specified objects in BGE?

Short answer is you can't. The motion blur 3D filter in the BGE is accomplished by accumulating the previous frames together with the current frame, therefore it can't single out a specific object.


Material which is not rendered but interacts with light

In the object properties tab of the properties window, there is a section titled "Cycles Settings". If you uncheck the box "camera" under "Ray Visibility", that object will disappear from the render but still reflect light and cast shadows.


How do I rotate an object with a image on it?

From what I understand your image is actually not part of the T-shirt material, it is an image plane that is shrinkwrapped around your T-shirt. So if you want to keep this solution, you need this plane to follow the T-shirt object. To do so, the simplest way is to parent the image to the T-shirt. If it doesn't give you satisfaction you should consider using the image as an Image Texture within the T-shirt material.


How do you cut a clean hole into an object that has been subdivided?

When 'they' say subdivision surface works best with quads, they mean that if you can get your pre-subdiv model to only use quad faces, you get a better result. Generally you would want to make the hole before applying the subdivision modifier.

To avoid 'cutting circles', you need to add supporting geometry around edges that you want to 'harden'. There are many ways to go about this. You can do it manually by simply adding additional edge loops and sliding them into place.

You could also use a bevel modifier above your subdivision modifier in the stack.


Easy approach is to use texture mask inside material.

Here I'm using local Z axis to separate sides of an object. Then plug it as factor to control textures visibility.

Why Z, because in my case it is facing texures (see gizmo in Local mode).


Can I use UV project modifier for a specific face?

The simplest way to get a clean separation in texturing between the faces is to set up two materials, one for the single face, and one for the rest of the mesh. Then you can set up a UV map for each material and they won't conflict with each other due to the face assignment of the materials.

In my example, I'm actually UV projecting textures for both materials even though you don't need to do that. Just set up the UV projection for the top face in order to achieve the result you want.

STEP ONE

Create 2 UV Maps (you can unwrap the whole mesh into both maps, as we are differentiating between the textures via face material assignment)

STEP TWO

Create 2 Materials Similar to the screenshot

STEP THREE

Apply the materials to the desired faces in Edit mode.

STEP FOUR

Set up the UV Projection modifier like this (you can just do 1 projection even though I've done 2). You'll also need a separate camera for projection (you can use the main camera but it's generally more convenient to use a separate camera)

STEP FIVE

Now you should have a different material and a texture that is UV projection on your mesh surfaces.


How do I change the default color of a new object?

I discovered I had MatCap Shading enabled, so all I had to do was turn off MatCap here:

3D View -> Properties (N) -> Shading -> turn off Matcap


Light-bulb Filaments: Brightness and Internal Reflections in Cycles

A few things you might try:

The color of your background will make significant difference when trying to see the internal reflections. I recommend making the background color the same color as the photo. With a light background like you have now, any light reflecting inside the bulb will be greatly diminished in terms of visibility. Here's an example:

The shape of the bulb will play a very important role in the amount of reflection you get inside the bulb. For example:

So, if you can model your lightbulb to have the exact same shape as the one in the photo, you should get similar reflections.
In addition, the IOR (Index Of Refraction) setting plays a large role in how much reflection is shown inside the bulb:

With an IOR of 1.0:

The same bulb with IOR of 3.0:

Yet another factor that can influence the amount of reflection is the thickness of the glass. If the bulb is a simple lightbulb-shaped mesh with a Glass material, then Blender will consider it a solid piece of glass, like a crystal ball, and this will significantly influence how light passes through it. In addition, if the bulb is a solid piece of glass, that could be one reason why there is no reflection inside the glass -- there is no inside face for the light to reflect off of. Ironically, in order to make the bulb hollow, the solution here is to add a Solidify modifier (as described below) to the bulb -- this will give the bulb mesh a very thin thickness and leave the rest hollow, thus allowing light to pass through the glass like a normal lightbulb rather than as a solid piece of glass:

The camera angle in relation to the faces of the bulb will also play a significant role in how much light reflects into the camera:

In the end, I found the following settings to give a significant improvement in the internal reflections:

Add a Solidify modifier to the bulb and set the Thickness to 0.01 or something similar:
Select bulb  → Object Properties panel → Modifiers tab → Solidify  → Thickness  → 0.01
Then setting the IOR on the glass bulb to 5.0 or so:
Select bulb  → Object Properties panel → Materials tab → IOR → 5.0
Setting the filament's emission Strength to 3000
Select filament  → Object Properties panel → Materials tab → Surface section → Strength   → 3000
Changing the filament's color to something like the following RGB and HSV values:
Select filament  → Object Properties panel → Materials tab → Color

This resulted in the following render:

The fact that the shape of the glass and also the thickness of the glass play significant roles in creating more realistic reflections made me think that in order to achieve photo-realistic results, the physical properties of the mesh models should be physically accurate representations of the objects being modeled. I'm no expert on photo-realism at all, but this just occurred to me and might help in your quest for realism.

In this regard, you might explore setting the filament's color based on it's temperature in Kelvin with the Blackbody node in the Node Editor:

I'm not sure this is necessary, though, but you might consider it.


2.80: Pie menus and Quick Favorite menu - conflict?

Pie Menus are enabled by default in blender 2.8, so you no longer need to enable the addon.  So now the q key will work as quick favorites.

But how do you get the view pie menu that the addon previously provided with key q?  Well, that's now the backtick key (`).  You can see all the pie menu key mappings under the user_preferences->keymap and filtering on pie:


transparent background for volumetric smoke? Bug?

Short answer: You want to use the volume scatter shader for this, not absorption. (or use the post-pro workaround in the other answer).

Ok, let's back up a bit and I'll try to explain why Cycles produces the values it does with the absorption shader: First of all, the volume absorption shader does not add energy to the ray or add contributions for a light in any way, it can only remove them. This is because absorption does not alter a ray's path, it merely removes energy from it. With transparent film, it's subtracting from the already black background, thus leaving you with a black smoke plume. "But wait!" you're probably saying, "my background isn't black, it's white!"

Oh boy. What a fun can of worms we got into here. So when you're rendering with a transparent background, you need to make the RGBA color of the background black. The reason for this is how the alpha over operation (or "normal" blend mode in Photoshop parlance) works. You can read the formula here: https://en.wikipedia.org/wiki/Alpha_compositing If you look closely, you can see what it does is multiply one layer by the alpha (blacking out the transparent portions) and multiply the other by the inverse of the alpha (blacking out opaque portions) then sums the results. So the function of the alpha channel in this case is to tell the software what part of the existing background to remove to allow the new background to be added.

This works just fine for 100% transparent sections no matter what else you mess up along the way (like writing the RGB channels as non-zero). It's partially transparent areas where the problems start. The non-zero RGB values in the background represent incoming energy from the background, which you do not actually want. You're providing different energy values later by way of comping in your final backplate. When you have a partially transparent region though, you want to preserve some energy (the energy reflected by the occluding object), so rays returning the value of the occluding object have non-zero RGB and an alpha value of 1. (ok, they might have RGB=0 if the occluder is black, but let's just assume it's not). Rays that continue to the background have an alpha of 0, thus the average alpha provides the proper scaling factor so the right amount of composited backplate energy is left on the pixels.

But what if those backplate rays came back with a non-zero RGB? The alpha channel does not distinguish between colors from the occluded object and colors from the backplate, it just represents how much energy is supposed to pass through the occluder. Thus, you get an unnatural glow as you are stacking the energy of the render background and final composited backplate, where this wasn't supposed to happen. Oh yeah, and because of antialiasing all objects get a partially transparent region around their edges, so even opaque objects get a halo if you don't black out this background.

And all this glowy mess isn't fixable in post either, at least using just the main beauty pass. If you have an occluded environment AOV (like cycles' environment pass) you can subtract that from the beauty pass and straighten things out, but no messing with a "convert premultiplied" switch will do the job.

This is all fairly arcane, so to make it easier on the user when you enable transparent film Cycles just stops all camera-ray contributions of the world background, forcing it to return RGB=0 in all cases. Your volume absorption shader tries to remove energy (especially red and blue energy) from a ray that has no energy to begin with, thus your smoke is black. Using the scatter shader instead causes it to REFLECT green light, thus remaining visible on its own. If you'd rather have the glowy green look, you can also specify that directly using the emission shader instead of, or in addition to, the absorption shader.


Python: convert collections to empty-parents with hierarchy (problem with location of instanced collection)

I could get it to work like I need it.
I had to select the above parent-collection and found some example code to implement and now it works.
I use the STEP-importer Plugin STEPper from ambi to import CAD-data and I need the correct hierarchy in the exported GLB-File and collections are exported without hierarchy.
I try to animate and show assembly groups with babylon.js.
Here is the working code:
import bpy

print()
print()
print("---------START------------")
bpy.ops.object.select_all(action='DESELECT')

def traverse_tree(t):
    yield t
    for child in t.children:
        yield from traverse_tree(child)

def parent_lookup(coll):
    parent_lookup = {}
    for coll in traverse_tree(coll):
        for c in coll.children.keys():
            parent_lookup.setdefault(c, coll.name)
    return parent_lookup

#Recursivly transverse layer_collection for a particular name
def recurLayerCollection(layerColl, collName):
    found = None
    if (layerColl.name == collName):
        return layerColl

    for layer in layerColl.children:
        found = recurLayerCollection(layer, collName)
        if found:
           return found

C = bpy.context
coll_all = bpy.context.scene.collection
liste =[]
counter = 0

for c in traverse_tree(coll_all):
    liste.append(c.name)

liste.remove('Collection')
liste.remove('Master Collection')
#liste.pop(0)
#iste.pop(0)
liste.reverse()

for entity in liste:
    counter = counter +1
    print("Verarbeite: " + entity)

    source_collection = bpy.data.collections[entity]
    instance_obj = bpy.data.objects.new(name=entity, object_data=None)
    instance_obj.instance_collection = source_collection
    instance_obj.instance_type = 'COLLECTION'
#   print(instance_obj)

    # Get all collections of the scene and their parents in a dict
    coll_scene = C.scene.collection
    coll_parents = parent_lookup(coll_scene)

    # Get active collection reference
    active_coll = source_collection
#    print (coll_parents.get(active_coll.name))

    # Set parent collection as active
    layer_collection = bpy.context.view_layer.layer_collection
    layerColl = recurLayerCollection(layer_collection, coll_parents.get(active_coll.name))
    bpy.context.view_layer.active_layer_collection = layerColl
#    print(layerColl)

    # create / link instances
    parent_collection = bpy.context.view_layer.active_layer_collection
    parent_collection.collection.objects.link(instance_obj)

    # convert instances to real objects (with hierarchy)
    bpy.data.objects[entity].select_set(True)
    bpy.ops.object.duplicates_make_real(use_base_parent=True, use_hierarchy=True)

    # delete original collection
    bpy.data.collections.remove(source_collection) #delete collection

print(counter,  " Collections verarbeitet")
print("------ ENDE--------")


Wave-Modified Collision Object Not Changing

Enable 'Deforming' in the Rigid Body Collisions panel should do it.


How can i edit both video and animation in blender 2.9?

Open your model.
Add a new scene.
In the new scene open VSE, hit Shift+A and import your video.
Add a Scene strip using the name of the scene containing your model.
Make the two strips overlap where you want the crossfade.
Then add a crossfade.


Two different objects at first then merge them, but keep them seperate on the former frames

There are a couple of techniques that could be used:

make a new Empty object E that is a child of object A that represents the position of object B after B and A lock together.  Give B a Copy Transforms constraint from Empty E, but keyframe its influence so it is 0 before they lock together and 1 after they lock together.
Keyframe A and B independently for the beginning, and after they lock together, you only have to keyframe A because B will copy its transform from empty E which moves with A because E is a child of A

Make 3 objects: A, B, and C.  C is a combination of a copy of A and a copy of B.  A and B are animated and renderable (the camera icon of the outliner) for the first part of the animation, but C is not renderable.  Then at the point where they combine A and B are keyframed to stop being renderable, and C is keyframed to become renderable, and then C is keyframed to move through the second part of the animation.
To create C you will need to make copies of A and B (shift-d duplicates, not linked duplicates) and then combine those copies without altering the original A and B.


How to position light source so it reflects off gold Celtic knot on the sword guard, into the camera?

I realized after exploring that if I placed a point light close to the object I wanted to light up, (gold Celtic Knot) that it would light up nicely. What I couldn't wrap my head around is that the light source itself never shows up in a render so it can be placed in the visual field of the camera. Duh! This way it can be relatively small and of low intensity, which for some reason I think is better that having some light source a mile away at 100,000 intensity and sized at 1000. I found that I could place the light source right on the object for instance and it worked well.


BI: is background (CLI) rendering faster?

Yes, it doesn't update GUI, so it's faster. I personally always render in cli with -b key anything that takes longer then 20-30 minutes. Additionally it's more reliable and stable than the GUI, especially using an RDP or VNC connection. Sometimes GUI crashes or just hangs on window minimize or monitor goinng off or on screensaver launch. But in background it never happens.


Rigorous procedure followed by shape keys to merge models

Let's take an example. A plane projected onto some steps using shrinkwrap modifier:

We apply as shape keys.
And now, here is how the plane moves for several values for the shape key:

As you can see, this is linear.
If a vertex goes from X when shape key is 0 to Y when 1, then its position is:
X + <shape key value> * (Y - X)

Note that we take here shrinkwrap example, but shape keys go the same whatever the way they are produced from.


Export - Internal render vs Cycles render

Blender 2.8 (currently in beta) can export directly to glTF (.glb, .gltf), including the key properties of Principled BSDF materials (base color, metalness, roughness).


Can an imported .STL file be broken down into individual parts (rigged) and animated in Blender?

Yes it should be possible, since importing means to convert it into Blender internal format. You can use all tools provided by Blender to work on you model.

It could be that you need to split the window and the window frame into two objects.
In Edit Mode select the part of the mesh you want so separate into to another object and press P this opens the Separate popup and choose Selection.


How to merge a leg inside a shoe? (physically not connected)

Well here is a conundrum. You want two objects that in the real world are separate to be connected as one. Think about modeling objects like they are in the real world, your shoe is not part of your leg.

I'd recommend you not try to connect the leg and shoe. There is no problem with them being the same object. The issue comes when you try to make everything have the same edge flow.
The leg should be one mesh and the shoe is one mesh (even if in the same object).

What you should do to bridge the gap is extrude the edge of the shoe inwards so that it is inside the leg. (edge is selected in left half of the image below)


Dark artifacts when rendering CAD-type model

Thanks Denis! (I can't comment cause I'm new.)

I think I've got a good solution going:

With the object selected, I went to the the Object Data tab of the Properties Panel, and unchecked Auto Smooth.

Then, like Denis suggested, I added an Edge Split modifier. I checked Edge Angle and set it to 180 degrees.

This will work for me. Does anybody have any other suggestions for future reference?


Is it normal to have these reflections when full global illumination on?

Yes

Where are that reflections coming from?

Not from the chocolate material. While in your modeling there is actually a small gap between the mousse and the glass cup (this mess up IOR calculation, but that's another story...) that would surely create additional reflections, those are not caused by that.

If you make the chocolate object completely diffusive (or delete it), you'll se that the effect is still there.

Let's erase the object, leaving only the cup and put a small red ring near the base of the cup.

We see that on each stripe (reflectons) is coloured by the red ring. This means that the light travel through the glass object with the path (more or less, I'm not an expert of optics) that is highlited in the image below.

Notice how cutting away the half of the ring that is behind the glass make the red stripes disappear. This is because the reflex is just what the faces (opposite to the camera) of the glass cup base are pointing to.

Let's put a small object:

On the right, inside the black circles there is a small green spot. By maginifing the image we'll see...

...Suzanne!

I'm quite sure it is upside down, as when you look yourself in a spoon... we can run another test by pushing the lower faces of the base behind the plane surface. So the ray will hit a diffuse shader and should reflect nothing:

Why there are so many?

Because for each camera ray the light path is slightely different due to the different incident starting angle. At the end of the path they are probably "diverging", so in a small portion you'll be able to see (distorted) the whole surrounding.

Is this a physically based effect?

Yes it is. You can see it in glasses with a thick base.

Here's a comparison between two different angles.

Why choosing "Limited Global illumination" instead of "Full Global Illumination" don't show them?

Because Limited Global Illumination has lower number of "Max" & "Glossy" samples. That factor is ruling after of many light bounces the simulation is stopped. If they are set to a value lower than the noumber of bounces that the light need to travel to get out of the glass, you'll not see any full reflex from that ray. There would maybe some light path that would be able to get out of the glass even with few bounces, but increasing the values, would give higher chances, so it is more likely to se lot of reflexs.

Conclusion:

The effect is phisically based. Full Global Illumination's setting  as espected helps in making the scene to look more  realistic, as it takes in account more bounces.

Suggestions:

There are some materials who use the "Add Shader" node that isn't energy conservative, so it can lead to non stichtly-physically based behaviours.

When a fluid is stiched to the walls of a glass container, it is better to deal with interfaces as the link in my comment shows to get a "true" IOR effect. Notice that with that method, you'll also will get rid of the reflections, as the light is reflected (as in real life) towards the mousse, instead of bouncing all around trought the glass volume:


How to get objects to show up as one of 3 colors or more

Input -> Particle Info -> Random socket.

You can move colorramp slider to adjust presence of the color


You can restore the default key maps if you go to User Preferences(ctrl+alt+u), Input tab and choose Restore for the Outliner:

You may have conflicting settings in other key maps as well. You could also try searching for everything assigned to mouse buttons.

If all fails, you could restore all key maps to default. If that fails, there might be an add-on that is causing the trouble, you would need to disable all enabled add-ons one by one to find the one causing issues.

You could rename or delete(maybe backup first) %appdata%\Blender Foundation\Blender\[your version] (on Windows) folder to restore everything to default, but that would disable all installed add-ons as well as your UI color theme.


Sculpt mode, Symmetry, and the 'H' hotkey

Dyntopo has a symmetrize button which will symmetrize your geometry on any axis.

If you pick the wrong direction you can undo and choose another.

While you don't need to do any sculpting in dyntopo to use this, you do need to enable it, which means you can loose UV's and vertex colours that can normally be lost when enabling dyntopo.


Is there a way to do a J-Cut or L-Cut in the video editor?

Yes, it's just a matter of cutting (K) between the video and audio strips at separate frames. For example, here's an L cut:


After pressing I (I like independence) to inset faces hold the Ctrl button (and move the cursor upwards) to add some depth to the faces and achieve the result you want.


Scaling/extruding snaps vertices when no snap enabled

Might have something to do with Auto-merge.


Is it possible to use different object interaction display modes on different objects in the same scene?

In the "Display" tab of the properties panel you can choose, for each object, the maximum draw Type: textured, solid, wireframe.
This can help.


How can I move an object along a path without it falling through?

Okay, here is what I did.

First I deleted the Rigid Body world and the curve you created and unused Empty's.

Then I selected your ground (and re-named it Ground). in Object Mode I applied Scale and Rotation press CTRL + A. In 'EDIT Mode' I selected the center Edge Loop and De-Selected the few vertices the fell over the edge of the road.

Then I duplicated the the selection 'SHIFT + D' and separated it from the mesh press "P" > Selection.

Then selected just the first vertex of what was the selection and pressed 'SHIFT + S' > Cursor to selection. Tabbed into Object mode and set the Origin to the 3d Cursor.

Then selected the new mesh that was duplicated earlier applied rotation and scale just out of habit. Tabbed into Edit Mode and Then selected just the first vertex of what was the selection and pressed 'SHIFT + S' > Cursor to selection. Tabbed into Object mode and set the Origin to the 3d Cursor. Next convert the mesh to a curve. I re-named it Curve.Path.

Then pressed SHIFT + C to send the cursor to the center. Next select The Ground mesh and the Curve.Path and press SHIFT + S > Selection to Cursor.

Now select just the Curve.Path and Tab int Edit Mode. select the first vertex and press "W" > Switch Direction to flip the Normals. Also, 'SHIFT + S' > Cursor to selection. Tab into Object Mode and de-Select everything.

Then add an Empty 'SHIFT + A' > Empty. Add an Object Constraint > Follow Path. Choose the Curve.Path as the Target.

Select the Curve.Path and in it's Data you can animate it's Evaluation Time.

EDIT:

Check off 'Follow Path' to have the empty stay perpendicular to the path.

*I'm not sure all the steps here are necessary but I was being conservative and new it would work.

**This .blend contains only the Curve.Path and the Empty to keep it small. You can append them to your file if you choose and of course you'd need to parent R2D2 to the Empty.


Calling bpy.ops.object.bake_image() gives error "No valid images found to bake to"

There were a few apparent issues.

The first is that the I needed to use the function

ob.data.uv_textures['SmartProject'].data[0].image = bpy.data.images[currentImageName]

to select the correct image. This wasn't enough though, since if the object 'ob' was in edit mode, data would have no elements, returning an index error for data[0].

The next issue was that data has many elements, so I had to actually loop through them setting them all to the current image. The correct code block is now:

# Create new image
bpy.ops.image.new(name=currentImageName, width=1024, height=1024)

# Set bake margins
bpy.context.scene.render.bake_margin = 2

# Set the UV coordinates
ob.data.uv_textures['SmartProject'].active = True

# Specify the bake type
bpy.data.scenes["Scene"].render.bake_type = "TEXTURE"

# Exit edit mode
bpy.ops.object.mode_set(mode='OBJECT')

# Set the target image
for d in ob.data.uv_textures['SmartProject'].data:
    d.image = bpy.data.images[currentImageName]

# Enter edit mode
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='SELECT')

#Bake the image
bpy.ops.object.bake_image()


It's on the right in the big section called the Properties Editor:


How can I round this inward-pointing corner?

Thanks guys. I tried working on the topology after bevelling and that helped :) It was just a little tedious because I had to drag each new point out separately. Maybe there is an easier way, but at least it looks right now! I attached my blender file with the topology corrected on one side, for reference.
https://drive.google.com/file/d/1OGWpEg9oAY9P-EcaTFzprBgO84Xu9gLH/view?usp=sharing


Got two connected BVerts, how to get the BEdge?

Looks like I've figured it out:

edge = self.bm.edges.get([v1, v2])


UV Map Distorts when I add bevel to model's edges

When you change the topology of your object with the bevel, it changes its UV. I don't know how it works with Houdini but in Blender you need to make sure that the seams are still ok, unwrap again, and align again with the image texture in the UV editor.


Deselect objects that do not have UVMap?

obj.data.uv_textures is a list of uvmaps. Each item in the list has a name property that you can test -

import bpy

for obj in bpy.context.selected_objects:
    uvt = obj.data.uv_textures
    for m in uvt:
        if m.name == "UVMap":
            obj.data.uv_textures.remove(m)


How to copy weights from one bone to another?

Nevermind, I'm silly.

The way to copy bone weights to other bones is by making a copy of a vertex group that belongs to the bone you wish to mirror. Let's say "Hand.L" and then clicking on the black arrow in the vertex group panel and selecting "Mirror Vertex Group", then change the name to "Hand.R" and if you now move that bone that is "Hand.R" it will deform the mesh just like on the left side.


Using the loop cut and adding additional loops

ALT + C does not make ZOOM this only centers the model on the 3D viewPort

on the other hand perhaps what you are looking for is the following

unless you refer to

ALT + SHIFT + C


Blender game character is not responding to game logic

The BGE can't handle the Mirror Modifier when you apply it and change the order of the modifiers:

Some notes:

For performance and to avoid issues it would be better to apply the subsurf also
80 Frames is a bit long for this walk cycle
Loop Stop / End should be used in the action actuators
Related: How should an animated character be moved while repeating a walk cycle?

Result (reduced to 20 frames and adjusted movement):


I can think of a few possibilities, however it almost looks like option 2:

Video encoding:

Resolution (or % thereof)

Sampling

Actually check all of the Output and Render properties.
Are you are doing any post processing in Composition?


How to animate object target positions while respecting rigid body collisions?

The solution, indicated by Rich Sedman (thank you!), is to use Rigid Body Constraints with Generic Springs.

Create 3 cubes
Add Rigid Body to each cube
Create 3 spheres (will act as targets)
Add Rigid Body (passive) to each sphere. Mark it as animated and place it in Collections 2 to avoid colliding with the boxes.
Add Rigid Body Constraint to each sphere, type Generic Spring. Activate Linear limits in all 3 axes. For Objects set First to the sphere itself, Second to the corresponding cube. Set Stiffness and Damping for Springs > Angular and Linear according to taste.
Put each sphere centered in a cube. If you place the cube under the sphere, it will be hanging. When you animate the sphere position the cube will follow, hanging under it. I wanted to avoid that, so it doesn't feel like marionettes.
Animate the sphere positions so they pass near other spheres. The Cubes will collide and avoid each other.
Disable gravity (optional).

What's missing for me is to figure out the right values for the constraints so the motion feels right.


Panning with Shift + middle mouse button stopped working

I've had this happen a few times to me, and not pressed anything I shouldn't.

I found going to object mode and pressing the home key fixes it. (View All).

I seem to get this problem when I've zoomed in too close, or am using the UV view.


Try the Knife (K) tool: press K select a point of an edge, clic on another point in another edge, confirm the cut with enter key. Check in face mode the new faces created.


Is there a better way to rotate the order of vertices of currently selected faces in edit mode?

The UI isn't updating because the script does not call

bmesh.update_edit_mesh(mesh)

(I got this from how to use BMesh to add verts, faces, and edges to existing geometry )


frame_change_pre handler only works once

As pointed out by zeffi - camera_lens = bpy.data.cameras['Camera'].lens assigns the current value of the camera lens to the variable. That is camera_lens is set to 16.0 when you run the script to insert the handler, this value is then used to set the text every time the handler is run. Only the code within recalculate_text() is run on frame change, not the code before it. What you want is to hold the camera object in a variable and then read the current camera lens setting each time you update the text contents, or to use the full data path within the function.

The off by one issue is the order that things happen. The frame_change_pre handlers are run before frame_current is changed while frame_change_post handlers are run after. frame_current needs to change so that things like a value controlled by an fcurve can be calculated, which allows you to read the keyed value that applies to the current frame.

import bpy

def recalculate_text(scene):
    text_obj = scene.objects['Lens']
    my_camera = bpy.data.cameras['Camera']
    text_obj.data.body = ('{0:.1f} mm' .format(my_camera.lens))

bpy.app.handlers.frame_change_post.append(recalculate_text)


Controlling animation speed for different elements

OK I found myself a solution to this problem!

Everything is OK, it is just necessary to edit some properties under Animation window (Screen Layout).

Steps:

Edit animation.
Under ''Dope Sheet'' press T and change ''Interpolation Mode'' to ''Linear''.
Under ''Dope Sheet'' press T again and change ''Easing (by strenght)'' to ''Sinusoidal''.
Select all objects that are participating in animation and under ''Graph editor'' press Ctrl+E and change ''Easing Type'' to ''Ease In and Out''.

It works perfectly for my need and I hope it helped someone get the answer of how to move objects with same speed, but that it still looks natural.

Cheers!


The issue is your topology. In Blender, everything must be one piece, and your fin and teeth are separate from the body even though they appear to be together. To prove this, select one vertex of the body mesh, key Ctrl + L, then G and move your cursor. Watch as it separates.

Normally, W > Remove Doubles would help, but your mesh is too fragmented.

A noticeable seam that is too big for Remove Doubles:

What I have done is deleted several faces around the pieces in question and joined manually using F to create faces. I have also used Alt + M > At Center to join some suspicious vertices. Lastly, I touched up the weight painting. It's not perfect, especially in the mouth area, but it's a lot better.


How to make a whiff of steam rising off a mug of coffee?

I did it by using an Emission shader for the volume.  I mixed with the given quick smoke setup that uses Volume Scatter and Volume Absorption, but the mix is so low for them I suspect that I could leave them out.  I also animated the density from 1 to 0. (Stuff is grayed out in the domain's settings because I baked it.)  I changed things like the Vorticity and Dissolve time, and Noise Method and Strength. My problem was getting the steam to be white instead of gray. Maybe if I got rid of the Volume Absorption I wouldn't need the Emission?  It doesn't look quite right since the steam is lighting up the inside of the cup.

animation (it's still rendering and needs about 30 more frames for the full 70 frames.)


Blender 2.78a force field not affecting particles

If you want your particle system to be affected by a force field, add a separate force field object (or alternatively enable force field physics on any other object), and also check its strength setting in its physics panel as the default strength of 1 is a rather subtle effect. Also in the case of a "Wind" force, check its direction, because by default it might be vertical, and the effect might look like gravity. Simply rotate the object with the wind physics to change the direction.

If you enable the force field settings on the particle system itself, it will not have the effect you want: these are used if you want your particles to affect other dynamic objects, such as other particle systems. You can check "Self Affect" to affect itself, but this is still not what you want.


Why are the normals of this primitive circle pointing upwards, and how to reset them?

It seems, in the absence of any faces from whose Face-Normals the Vertex-Normals can be derived, they resort to a spherical projection from the Object Origin.


How to add dirt on a direction of the object

If you need to give your dirt a direction, other than the object-Z illustrated in Andrew Price's tutorial, you can 'shine' the dirt onto the surface from any point in the object's space.

If you take the normalized Dot Product of the Normal at the shading point with a vector (which you can visualize as a point in the object's local space), then the resulting 0-1 value looks much the same as if the object was illuminated from that point. You could also put the Normal Texture coordinate through a 'Normal'node, but that doesn't take numerical entries, and isn't quite as controllable.

... You can use the value as the factor in a mix between your clean and dirt shaders.

You also have the option of using a Geometry node > 'Pointiness' attribute as a component in the mask, to add dirt in crevices.


Why is my animation being broken up into several files when i export it from blender and import into unreal engine 4?

This is likely a result of exporting everything on one level. What I can make out from the screen shots you might not be working in NLA strips and the action editor. If you're exporting your mesh along with your animation, you're including superfluous information that Unreal is importing for you.
Here is a UE4 thread going into NLA strips. First thing you should do is switch from Default mode to Animation. This will give you a better layout. Change the dopesheet on the left to Action Editor from the drop down menu. The window under that will be the graph editor, change that to NLA editor. Here is a thread that goes into NLA animations: https://forums.unrealengine.com/showthread.php?67714-blender-digital-fbx-not-include-all-animations


At least 3 ways to approach this.

fully procedural
fully textured
mix procedural and texture.

My interests lie mainly with procedural. An approach involves literally stacking piles of noise textures ontop of eachother and masking out parts using other noise textures with large scale to get the patchy-ness. Then if it's too cloudy and wishy washy use a contrast node to get sharper edges.

As a starter get your head around a small setup like this

Step 1:

Really analyse what you like about the real-life roof top, what makes it pop for you. Write down the keywords, think about why those features are there and are they related to the surrounding architectural features? like drainage, seepage, repair work, shelter from the elements..

You can use the Position socket of the Geometry node, to push the Noise Texture along in space by a given Vector until it matches up with something that appeals to you.

Step 2, patchier!

RGB Curves node allows you to weave in and out of a colour gradient. I'm leaving the colours visible to show where they come from.

Step 3 details

mixing and masking,

Here the Color Ramp node is also used to flip colour ranges, to give the effect of dried up puddles of gunk with residue on the edges.

more noise layers.. Using the Vector Combine node lets you cycle through the 3d space of the node texture, and you will see many crazy shapes but occasionally a few features that seem to somehow fit with the geometry. If you have a lot of distortion going on in one section of the noise texture, shift the x,y,z until it gives more appealing visuals. There's no science to this, just experimentation.

Masking

So far all 4 or 5 noise textures get piped into one node (the Difference node) before it hits the shader. From here on it gets complex and you might start to experiment with node groups to keep the various layers separate (conceptually), and mix them together using large scale Noise textures to allow for big sections of one texture and more abrupt transitions to the output of a different node group.

Here I've gone back to creating a mask using a Noise Texture node, it shows how one might mix two colours as a function of Noise. In the example I picked flat RGB colours to show what effect the mixing has on blanket colours, but if you stick elaborate grungy "color ends points" in there it will start to approach what you are looking for. Making the mask is arguably easier to do manually, but keeping it procedural avoids the headache of raster resolution.

And here the many layered noise (converted to a Node Group with a colour output) is inserted as one of the colour sources. The other is still blue, but you can probably imagine that another Node group could be created to do the colouring of that section.

It's possible to get very creative with masking, and various Texture types to arrive at local features which seem to be caused by the architecture.

Keep masking out Textural features until you feel you could be spending your time doing something more productive :)

Hopefully this gives some ideas, it wasn't intended to be a tutorial. And this doesn't even get into the 3d aspect of texturing..  the gritty-ness of the surface, the bumpyness of certain parts, the faint depressions, the interuptions in materials. If a roof is done with two different batches of roofing there can be big colour differences.


Here's one way. Assuming you are using a texture file like this with transparency (alpha) for the ripped texture.

Select the banner vertices on your model. In UV Editing: open your texture file with the ripped banner, U Unwrap, position your faces atop the image, Set this vertex group as a UV Map.

With our banner selected, in the shader editor set up a texture for our banner like this, add a new texture, Shit+A to add nodes. Calling the image file with an Image Texture and specifying your UV Map in the UV Map or Texture Coordinate node. Don't forget to connect the alpha to make the ripped and tattered area transparent.

You'll probably want to add more geometry to the banner so it hangs more naturally. Note the banner in this method has no thickness only flat geometry.
Hope that helps.


Help with smoke simulation scaling and appending

You need to adjust the density for how much you scale the smoke. If the original scale was 1.0, the new density is:
$$
density' = density / scale
$$
If you want exactly same render result (from scaled camera closer/further from smoke), you will also need to adjust the Volume Sampling Step Size under Properties > Render Tab > Geometry:
$$
stepsize' = stepsize * scale
$$

The density can be adjusted by a driver from the material node tree. I added extra node, so the user still has the option to manually adjust:

The driver looks like this, I chose the Z axis as input:

The others can be locked from user input and their value copied from Z axis with drivers:


Setting the DPI value in rendered images

May be this addon is the one you need.

Wiki page about this addon.


how to report missing files in a list, usable in python script?

You could try a variation of the following code:

import bpy
import os

def list_missing_blend_libs():
    return [bpy.path.abspath(lib.filepath) for lib in bpy.data.libraries
            if not os.path.exists(bpy.path.abspath(lib.filepath))]

Using bpy.path.abspath, it only lists absolute path of missing libraries in bpy.data.libraries.


Limit "prop_search" to Specific Types of Objects

Since blender 2.79 this is possible using the poll parameter of the bpy.props.PointerProperty.

import bpy

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

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        layout.prop(scene, "mychosenObject")

def scene_mychosenobject_poll(self, object):
    return object.type == 'CURVE'

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.mychosenObject = bpy.props.PointerProperty(
        type=bpy.types.Object,
        poll=scene_mychosenobject_poll
    )

def unregister():
    bpy.utils.unregister_module(__name__)
    del bpy.types.Scene.mychosenObject

if __name__ == "__main__":
    register()

See the documentation 1

bpy.props.PointerProperty(type=None, name="", description="", options={'ANIMATABLE'}, poll=None, update=None)

Returns a new pointer property definition.
Parameters:

type (class) – A subclass of bpy.types.PropertyGroup or bpy.types.ID.
name (string) – Name used in the user interface.
description (string) – Text used for the tooltip and api documentation.
options (set) – Enumerator in [‘HIDDEN’, ‘SKIP_SAVE’, ‘ANIMATABLE’, ‘LIBRARY_EDITABLE’, ‘PROPORTIONAL’,’TEXTEDIT_UPDATE’].
poll (function) – function to be called to determine whether an item is valid for this property. The function must take 2 values (self,object) and return Bool.
update (function) – Function to be called when this value is modified, This function must take 2 values (self, context) and return None. Warning there are no safety checks to avoid infinite recursion.


How to set a value for FloatVectorProperty from a function?

Elaborate From brockmann comment and Blender API:

bpy.props.FloatVectorProperty(
min=sys.float_info.min,
max=sys.float_info.max,
soft_min=sys.float_info.min,
soft_max=sys.float_info.max)

  min (float) – Hard minimum, trying to assign a value below will silently assign this minimum instead.
  max (float) – Hard maximum, trying to assign a value above will silently assign this maximum instead.
  soft_min (float) – Soft minimum (>= min), user won’t be able to drag the widget below this value in the UI.
  soft_max (float) – Soft maximum (<= max), user won’t be able to drag the widget above this value in the UI.

You need to set min = 0.0 and max=1.0 (or soft min/max) for the color subtype property.
So it will look like this:

a_color : bpy.props.FloatVectorProperty(name='Color',subtype='COLOR_GAMMA',size=4,default=(0.5,0.5,0.9,1.0),min = 0.0, max = 1.0)

b_color : bpy.props.FloatVectorProperty(name='Color',subtype='COLOR',min = 0.0, max = 1.0)

It seems like color also support by light system. So the min max wasn't set by default, causing the silder getting a ridiculous range and break the panel

Operator based on this answer:

import bpy

class SimplePropConfirmOperator(bpy.types.Operator):
    """Really?"""
    bl_idname = "my_category.custom_confirm_dialog"
    bl_label = "Do you really want to do that?"
    bl_options = {'REGISTER', 'INTERNAL'}

    def update_func(self, context):
        #print("my test function", self)
        self.my_color = (0.5,0.5,0.9, 1.0) # Alpha

    my_enum : bpy.props.EnumProperty(
        items = (("RND", "Randomize", ""),("SET", "Set", "")),
        update = update_func)

    my_color : bpy.props.FloatVectorProperty(
        subtype='COLOR',
        min=0.0,
        max=1.0,
        size=4) # Alpha

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        self.report({'INFO'}, "YES!")
        return {'FINISHED'}

    '''
    def check(self, context):
        return True
    '''

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        row = self.layout
        row.prop(self, "my_enum", text="Property A")
        if self.my_enum == "SET":
            row.prop(self, "my_color", text="Property B")

class OBJECT_PT_CustomPanel(bpy.types.Panel):
    bl_label = "My Panel"
    bl_idname = "OBJECT_PT_custom_panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Tools"
    bl_context = "objectmode"

    def draw(self, context):
        layout = self.layout
        layout.operator(SimplePropConfirmOperator.bl_idname)

def register():
    bpy.utils.register_class(OBJECT_PT_CustomPanel)
    bpy.utils.register_class(SimplePropConfirmOperator)

def unregister():
    bpy.utils.unregister_class(SimplePropConfirmOperator)
    bpy.utils.unregister_class(OBJECT_PT_CustomPanel)

if __name__ == "__main__":
    register()


Multiple problems: Rigged arm & hand with elbow corrective shape key

ORG-forearm.L is not rotating anymore simply because its rotation values are locked (picture n. 1)

In your actual setup the rotation of this bone on his local Z axis has a negative value, so you can get your corrective shape key work with a negative expression (multiplied by 0.5 for having maximum effect roughly at full rotation; picure n. 2).


The use of the Cross Product in that example doesn't make much sense - in fact, I don't seem to be able to get that setup to work. The Value output of the Cross Product gives the average of the individual (X,Y,Z) elements of the vector. This could be argued to make sense if the X, Y, Z all have the same sign (ie, all positive or all negative) but as soon as you get a mix of different signs the result becomes effectively meaningless.

My own take on the 'Laser Line' issue would be to use a Point lamp with a small size (eg, 0.01) with the following nodes :

The 'Size' of the lamp will affect the width of the laser line, as will the value in the Less Than node.

Here a 'seed' vector is used to control the direction of the laser, adjustable via the Mapping node. This allows the vector to be easily rotated. The Dot Product compared the direction of the ray with the direction vector - if they are close enough (within the Less Than threshold) then the lamp emits light, otherwise it does not. The Ray Length is used to effectively tighten threshold the further the ray falls from the source - this ensures the ray doesn't 'spread' as it gets further from the source. Similarly, the Light Falloff node ensures the strength of the lamp remains constant regardless of distance.

This can produce the following result :


To control the softness of the source move the Lamp Size value.

The larger the light source the softer the shadows (read: How to minimize/soften the shadows?).

(Click on the image to enlarge)

To change the radius of the light change the Spot Shape Size (in degrees).

(Click on the image to enlarge)

To have volumetrics add volume scatter on the world or create a domain.

read: Atmospheric lighting in cycles


3D Stereo - Saving both Left and Right render images

If you want to save the render result you can simply use the keyword argument write_still = True.

The saved image will conform to your view format settings in the render options panel. If you set the view format to Individual, the following lines will save two images named render_L.png and render_R.png.

bpy.data.scenes['Scene'].render.filepath = 'D:\\render.png'
bpy.ops.render.render(write_still=True)


Applying lots of shape keys with blends using Python not working? also, is there another way?

Got this working:

import bpy

obj = bpy.context.object
spIndex = obj.active_shape_key_index
i = 0

### EDITABLE VARIABLES ###
last = "fullbody"       # Last shapekey to save
add =  "_applied"       # Add this to new blendshape's name

shapekeysList = []
shapekeyValues = []

for sp in obj.data.shape_keys.key_blocks:
    if last in sp.name:
        break
    shapekeysList.append(sp)
    shapekeyValues.append(sp.value)
    sp.value = 0
    print (shapekeysList[i].name + " | Value saved: " +  str(shapekeyValues[i]))
    i += 1

print ('\nFinished saving shape keys\n')
i = spIndex

while i < len(shapekeysList):
    shapekeysList[i].value = 1                                  # enable shapekey before copying
    print (shapekeysList[i].name + " | " + str(shapekeysList[i].value))

    obj.active_shape_key_index = i                    # select shape key to mix

    obj.shape_key_add(name=str(obj.active_shape_key.name) + add, from_mix=True)   #apply shapekey
    obj.active_shape_key_index = i                    # select original selection
    #bpy.ops.object.shape_key_remove()                           # delete blended shape key
    shapekeysList[i].value = 0
    #obj.active_shape_key_index += 1                             # select next in list
    i += 1


is there a way to move the 3D Cursor on top of anything?

Set Stroke Placement to Cursor. Then left-click on an object to set the 3D cursor location and the Grease Pencil will be drawn in the plane of the 3D cursor.

If you don't want the 3D cursor to be placed on a surface, you can manually adjust its location in the N panel of the 3D View:


How to block custom properties from being edited by the user?

You might create a custom property and pass only a get method:

import bpy

#default getter
def get_my_prop(self):
    return self['my_prop']

#omit the setter with a given getter to make it read-only
bpy.types.Object.my_prop = bpy.props.StringProperty(get=get_my_prop)

for obj in bpy.context.selected_objects:
    #assign the value directly
    obj['my_prop'] = "My Value"

It looks like this in the properties panel in blender 2.71:


duplicated objects dont show up in render

I can resolve it for you - but I don't really know why?

If you run your animation (before deleting the keyframes) all three objects are instantly moved on top of each other. So it is probably rendering all duplicates, it is just that they are on top of each other. I wonder if it has something to do with Blender effectively starting the frame 1 animation prior to rendering an image? Someone smarter may be able to help here.

Anyhow, for the duplicated objects remove the associated keyframes (in the Animation workspace) and now the duplicates are now rendered.

Here is a rendered output example.


What is the pixel error in motion tracking?

The re-projection error is the difference in pixels between where the tracker is placing a point in the image, and where it is being re-projected in the geometry when the scene is Solved.
In the perfect world there should be no error, but in the real world there is usually some degree of discrepancy, given the nature of trackers, optics, and user error.
Usually tracking is considered accurate when the re-projection error is less than 1/3 of a pixel (0.3 pixels).

The number is always an average.
You can see the average per tracker (for however many frames the tracker is active) in the dopesheet

Or you get a report of the average of all bundled tracks for the whole scene at the bottom of the page.

How to see bundles and back projecting points of different colors?
and
Single track with bundle should be selected to define axis
Motion Tracking. What do the graphs represent and how are they useful?


Shouldn't it have thousands or millions of colors available?

There is a difference between how the compositor deals with imagery, versus the VSE. The majority of the VSE code paths use unique to the VSE code, and are designed for 8 bit per channel paths, or 256 discrete steps from 0.0 to 1.0. The compositor on the other hand, uses 32 bit float per channel, which is a decimal format and provides much larger granularity in between values.

  Have you any guess why it's sooo ugly when rendered in a video?

The issue is quantisation.

When you apply your mask to an 8 bit image, which all motion pictures encoded in codecs are loaded as in the VSE, you are already constraining your work.

A vignette is a constriction of light, which is a simple multiplication operation. 8 bit imagery is encoded using integers, or whole numbers. This means that if your mask is trying to set a value between 24 and 25, it can't. It is forced to quantise the value to 24 or 25. So the first problem is working in the VSE which is hammering your effort with quantisation artifacts long before you get to encoding it into a video codec.

  What causes the loss of quality?

The second portion of the problem is a codec. Codecs are designed for a number of different needs. Many times, that need is to conserve bandwidth. This means trade offs at the quantisation level as well as compression artifacts. In this case, the motion picture signal is complexly scaled to less than 8 bits per channel, and then further compressed temporally and spatially. While it might not seem like much, that scaling, when placed on top of already sub-optimal 8 bit manipulations, results in a significant degradation in quality. Now stack compression on top of that and you can begin to see where the image begins to fall apart.

Worse still is that at the lower level values your demonstration has, the sRGB OETF is not terribly efficient at encoding. This means that there are very few code values allocated at the lower end, and they must be crafted well or they will exhibit posterization.

In the end, it is a four pronged destruction:

VSE 8 bit quantisation.
Codec signal scaling.
Codec compression.
Inefficiency of the sRGB OETF transfer function.

Solutions may include:

Use the compositor for all work.
Use lower compression levels in output encodes for codecs.
Avoid output / input encoding to file formats, especially codecs, while working on a project. If files must be saved, save individual frames as EXRs. Doing otherwise stacks repeated degradation on the work.