How to multiply vector by scalar in material nodes?

You should think more about the data types. If you want vector*scalar, use MixRGB set to Multiply (an RGB color has three components, like a vector), and not a simple scalar math node. See my answer to this question for an example of vector*scalar: Scale Texture with a Value-/Math-Node

Also your selector seems to be a Mix Shader (I didn't download your file, but it has shader inputs and outputs), and you should not put scalars into a node that expects shaders.

EDIT Just for completeness: There are also other ways of doing vector*scalar, like using a vector Mapping node and setting the same X, Y, Z Scale, or separating the vector components with a Separate XYZ and multiplying the three scalar coordinates individually, and merging them again with Combine XYZ.


How to select vertices on the left side of a plane using python?

You need to somehow define what is 'on the left side'. Is it global space, is it local, which way you are looking from?.. Anyway, you can compare the coordinates to something. Let's say you are looking from the top as in the screenshot and left is the most negative X point of the object in global space plus 0.5 units:

import bpy

obj = bpy.context.object
data = obj.data

the_matrix = obj.matrix_world

on_the_left_side = (the_matrix @ obj.data.vertices[0].co).x # have to start somewhere

for v in data.vertices:
    co = the_matrix @ v.co #Let's say "on the left" is in global space
    if co.x < on_the_left_side:
        on_the_left_side = co.x

offset = 0.5

#Element selection is a bit weird in bpy - you can select faces,
#but not vertices for example like user cannot, so let's deselect
for e in data.edges:
    e.select = False
for f in data.polygons:
    f.select = False

for v in data.vertices:
    co = the_matrix @ v.co
    if co.x < on_the_left_side + offset:
        v.select = True
    else:
        v.select = False


BGE: Can a rigged rigid body interact with BGE physics?

An armature rigged mesh cannot interact with other rigidbody objects, as the mesh deformation by the bones are not sent to the physics engine. (They are actually done on the GPU as of Blender 2.71 [source])

Your only option is to parent a bunch of collision proxies to the armature and use those instead of the actual rigged mesh, like this.


Baking

Baking is a process to generate textures. The texture is build from different camera views. To be more specific a camera gets placed above a face, renders the image and applies the result to a new texture.

This way you get render effects into your texture. E.g. you do not need dynamic shadows, so you can "bake" them into the final texture. It looks like there are shadows, but they are not. This saves a lot of processing power.

Situation

While you can use baked textures it does not apply to your situation. You have textures already.

The problem you have is that your materials are not completely set up. GLSL uses the material and texture settings (see the according tabs in the property view). Multi-texture uses whatever texture you assigned in UV-Editor.

This means when you want to see your scene in GLSL, you need to apply the textures via texture tab. The Multitexture mode likes it as well.


Bevel modifier artefact on a single vertex

I think there’s nothing bad with your topology, EXCEPT that it can’t fill your needs, meaning it can’t properly bevel with the Bevel modifier:

You've created a vertex group to designate all the edges that are supposed to be bevelled by your Bevel modifier. At the top of your mesh you've selected all the border vertices because you want all the border edges to be bevelled.

The problem is that vertex groups don't include only the vertices, it also include all the edges between vertices. Therefore your modifier will also affect all these edges:

You can verify it, if you select all the vertex group, you'll see these edges included:

So, as you're using a Bevel modifier with Vertex Group method it will also bevel all these edges and it will give a mess of intertwining edges. Yes by chance it kind of works better on the right side but I don't think it's satisfying either:

If you create additional topology to make sure that the inner edges are not affected by the bevel, in my opinion it still won't work properly and it will make you loose the roundness you want:

So I may be wrong (edit: actually it looks like the topology proposed by Metaphor_set works with modifier) for the result you wanted) but the solution is probably to do it manually and to bring some manual corrections at the end with some join vertices and dissolve edges. The Bevel modifier can't always do everything properly:


Thanks for response.

Ok, now everything works..

Is there cleaner way for doing this or I need always register new icon ?

import os
import bpy

bl_info = {
    "name": "IPG Selection",
    "author": "InvisibleParrot",
    "version": (0, 0, 1),
    "blender": (2, 77, 0),
    "location": "View3D > Edit Mode",
    "description": "IPG tools of trade",
    "warning": "",
    "wiki_url": "",
    "category": "IPG Tools"}

preview_collections = {}

class PreviewsExamplePanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = 'Selection'
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_category = 'IPG Tools'

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

        col = layout.column(align = True)
        this_icon = preview_collections["custom_icons"]["custom_icon"].icon_id
        col.operator("render.render", text="Unwrap", icon_value=this_icon)
        this_icon = preview_collections["custom_icons"]["custom_icon2"].icon_id
        col.operator("render.render", text="Unwrap2", icon_value=this_icon)
        this_icon = preview_collections["custom_icons"]["custom_icon3"].icon_id
        col.operator("render.render", text="Unwrap3", icon_value=this_icon)
        this_icon = preview_collections["custom_icons"]["custom_icon4"].icon_id
        col.operator("render.render", text="Unwrap4", icon_value=this_icon)

def register():

    # Note that preview collections returned by bpy.utils.previews
    # are regular py objects - you can use them to store custom data.
    import bpy.utils.previews
    pcoll = bpy.utils.previews.new()

    # path to the folder where the icon is
    # the path is calculated relative to this py file inside the addon folder
    my_icons_dir = os.path.join(os.path.dirname(__file__), "icons")

    # load a preview thumbnail of a file and store in the previews collection
    pcoll.load("custom_icon", os.path.join(my_icons_dir, "C_Black.png"), 'IMAGE')
    pcoll.load("custom_icon2", os.path.join(my_icons_dir, "C_Blue.png"), 'IMAGE')
    pcoll.load("custom_icon3", os.path.join(my_icons_dir, "C_Yellow.png"), 'IMAGE')
    pcoll.load("custom_icon4", os.path.join(my_icons_dir, "C_Red.png"), 'IMAGE')

    preview_collections["custom_icons"] = pcoll

    bpy.utils.register_class(PreviewsExamplePanel)

    bpy.utils.register_module(__name__)

def unregister():

    for pcoll in preview_collections.values():
        bpy.utils.previews.remove(pcoll)
    preview_collections.clear()

    bpy.utils.unregister_class(PreviewsExamplePanel)

    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


Why does cube UV unwrap at an angle? The mesh is square but the UV is skew, at an angle

I've checked out your seams placement and you're right- it doesn't unwrap in the right way (don't know why). To solve it you may snap the cursor (2D Cursor mode) to the very bottom vertex with Shift+S-->Cursor to Selected, select the nearest one and rotate them to create a straight line (you may then scale the vertices by Y axis- S,Y,0 to make sure the edge in a perfect horizontal position). Then pin the vertices with P. Finally unwrap the mesh again (U-->Unwrap) and get rid of pinning (Alt+P).

You may also try to place  the seams in a different way e.g. as pictured below. As you can see it unwraps well now.


How to Download Blender Pose Library ? As well as like in Maya Studio Library (Facial Expression)

Stored poses have to correspond to the armature that you are using - so any library of poses that could be applied woudl have to be rig specific. If you are using the existing empty pose library with your rig, you can pose the rig and then add the current pose to the library, and name each pose as you go. Then you can call up those poses when working in the dopesheet to set your main pose to pose action.


UV unwrapping mesh with radial array modifier

Enable UV snap and change it to Vertex, then move one island till it snaps to one of the connecting vertices.

Select the connecting vertex and snap 2D cursor to its location using Shift+S Shortcut and change Pivot Point to 2D Cursor

Select one UV island and rotate it till it snaps to the other side of second UV island.


I got an answer off of Packtpub.com.  If any of you want to check out the course, it's called "Blender 2.8 Game Character Creation."

His method for being able to draw the face in a window at the same angle was to create a camera that was positioned face on at the head of the figure, and then to parent it to the head bone.

It's at that moment when you think: "Why didn't I think of that?"  You just have to look outside the box, I guess.


Why 80 % of my model is missing when exported from blender and imported into unreal engine 4?

The problem seems to be that the missing objects dont have a bone assosiated with them. Try assigning a bone to every object.


blender automatically closes while rendering

Maybe this helps

In 2.8, Blender crashes while rendering trees

Start Blender with debug options to log what is Happening


The bones connected to the Spline IK do not follow the whole armature - Still need help

Image above Showing a bone chain controlled by a Spline IK Constraint

Consider using the Chain Offset feature as enabled .  This is indicated by the yellow arrow.

Please know there is a technique in modeling with regular IK constraint where there are 3 models. Model 1 tweens or has a linear interpolation of the other two models. Bones capture rotation, so rotation can be interpolated. Depending on your level of experience and patience this technique can be appropriate or in appropriate.
Bones can have a copy rotation constraint.


Selecting items in Outliner using hotkey (B)?

Ctrl + P for parenting only works in the 3D view As far as I know, not in the outliner, so pressing Ctrl + P in the outliner will not work only directly in the viewport.

There are other ways to do this if you want to do it directly from the outliner though, you could use B for selecting as you already do, then click and drag&drop to parent by clicking on the object's icon to the left and dragging from there over to another object you want to parent the selection to.

Would this work for you?

Edit I was just made aware that it only parents one object at a time though, so it may not suit your needs entirely.


How do I rotate a Multilayer EXR file in Blender's compositor?

About cryptomattes
The issue is not due to the rotation but to the alpha over node:

which results in plain color image.
If you change the node group by this:

That allows to keep the image size from the mask, without considering it (multiplied by 0) but adds the rotated cryptomatte values.
A simple test case file:


Strange artifacts in material transparency (viewport)

Realtime renderer alpha artifacts

I think is related to the way polygons are drawn from the viewport engine.

To make the viewport render faster, the algorithm doesn't take into account whether a face is in front of another, leading to such artifacts. It happens quite the same in other realtime engine like Sketchfab viewer (see Why order matters section). This is pefectly understandable: the software should perform much more calculations if it should not takes into account only the face visibility but also the alpha depth.

See in the image sequence below how till I'm stacking the quads one above the other in order (latest on top) all works well, while switching their position leds to wrong results:

At the end, it seems more important the order in wich faces are "stored" in the file than the alpha&camera-distance factor. The artifacts in the picture comes from a that. Some faces are drawn in front of other even if they are behind.

There are some freshly implemented viewport alpha options for cycles, like BGE's ones, but despite their promising names, they don't work (yet).

Here's a reel of the options in BGE:

While in Cycles you can only see a difference when "Add" is enabled

I personally think developers are "working on it".


Should i animate the Color Setting of a lamp or its Strength?

Changing the color setting will change the emitted color while changing the strength will only change how powerfull the emission is. The difference might not be visible in the render, but AFAIK it will make a difference if you do compositing on your render or export exr/hdr pictures for editing on other softwares.


Switch from Armature Weight Paint to Hair Weight Paint?

Weight paint mode doesn't paint "armatures" or "hairs". It paints "vertex groups" which are used in any way, may it be an armature, particles, objects relationships, modifiers influences, ...

So, to make it simple: you just have to choose which vertex group you want to work on, from the vertex group panel in your object data tab:


How to apply compositing after stopped rendering?

You can save the result of progressive rendering as an image file (exr for maximum information) then do the compositing in an external .blend-file.
See also: What advantages in using progressive rendering?


How do I adjust the resolution of my render accurately? The resolution is off

By default the resolution percentage is set to 50%. To fix just change to 100%. Setting is located under the resolution settings.


PyQt and Tkinter seem to not work with Blender 2.8

Both are intentionally disabled since they may cause problems with Blender in certain situations (don't ask what situations, because I haven't run into an issue yet). You can install Anaconda on your system and then delete the contents of the "python" directory in your Blender install directory. And replace it with the contents of the "C:\Anaconda3\envs\py3" folder. This completely replaces the python version that runs Blender, so be careful to download the correct version that is compatible with your version of Blender:

Python 3.6 for Blender 2.79
Python 3.7 for Blender 2.80

You may still need to install TK and PyQT separately (I can't remember what is included with Anaconda), but they should work now.


how to generate square pyramids from the faces of a uv sphere

Is this what you mean?

Start with the entire UV sphere selected A A
Poke the faces with AltP
Select just one of the new vertices. Press ShiftG > "Amount of connecting edges"  or from the 3D view header Select > Select Similar > "Amount of connecting edges". That will select the center vertex of each face.
Make sure the pivot point is set to Median Point, then scale S out.

Animated gif showing the above process.

Or maybe DupliFaces is more like what you want?

Model the prism object.
Now parent that to a UV sphere.
With the UV sphere selected. In the Object tab of the Properties window, scroll down to the Duplication section. Click on the Faces button.


Changing default bake output format and quality

When saving baking image as an external one, go to UV/Image Editor menu > Save As Image (F3), pay attention to the left hand tab, there is the place to choose the format you need.

As for the Collada export issue, I think it's because you didn't choose to use other format for saving images before that, or didn't even save to an external file. :)


Anisotropic material no longer appears radial?

Try defining an axis for the tangent input with a tangent node:

In other words, for the effect in your first screenshot, it should be the axis perpendicular with the flat front of the object.

Note that the tangent node uses local coordinates.

It probably was working fine until you applied the scale to the objects. By default the tangent uses the object's local Z axis. When the scale is applied, the object's local Z was aligned with the global Z (which is not perpendicular to the "front" of your object).

For example, if you rotate the object -90° in edit mode then rotate it back 90° in object mode so that the object's local Z points out from the center of the disk:

Then it will work with the default tangent:


How to know the ON / OFF state of eyes in outliner

import bpy

obj =  bpy.data.objects['Cube.002']
#obj.hide_set(1)
obj.hide_get()

See the documentation


try clicking r (with your object selected) and press z,y, or x to rotate on that axis also the question seem a bit hard to understand can you upload a picture or try explaining you problem a bit better, hope you have success.


You can use the Light Falloff node to adjust how light falls-off with distance. See associated answer Custom light falloff in Cycles. Switching to Linear falloff may get the effect you're looking for.
Alternatively, (also as described in the linked answer) you can use the Ray Length to manipulate the lamp emission strength directly - in order to get finer control of light strength over distance.


Lights not casting shadows/UV mapped images dark

It sounds like you need more/better lighting in your scene. Without light sources in the scene, the only lighting is the very dark world background which doesn't emit much light so everything looks very dark.
Additionally, shadows are very weak as what little light there is is coming evenly from all directions. Background shaders actually emit light (as you want the background to do, it simulates light coming from things outside your scene) which is why that makes the objects brighter, but I am guessing you don't really want all the objects in your scene to be emitting lights.
Try adding lamps (or emission materials on appropriate objects) in logical places in your scene.  If you could include some screenshots of your setup then we would be able to help your case more specifically.


How to obtain accurate depth maps using nodes and visualize them?

To visualize the Z depth just use the Normalize node. Normalize will take the lowest and highest values of the image and scale them to be 0 (black) and 1 (white) respectively. All values in between will be scaled linearly as well.
And maybe also enable transparency...


How can I UV Unwrap a Minecraft box model?

You have to mark seams to create the unwrap like this. Select the edges you want to place seams on, then press Ctrl+E-->Mark Seam. For more tips about how to place seams right see: How to Place the Right Seams for UV Unwrapping. After placing seams to one side of your mesh apply the Mirror modifier. Alternatively you may start from appying it and then mark seams.

Next select the whole mesh (A) and press U-->Unwrap. As you can see you get the result similar to the one you provided. If you want to make it identical you have to experiment with seams placement.

Here's the .blend with my seams placement example:


I didn't exactly understand what bone part is not following what instead of what, but I checked your file and R and L gloves are weighted completely different... if one glove behaves well, you should apply the same weights (eg see How can I mirror weight painting? or Is there any way to copy the weight of one bone over to another(forgot to use x-mirror)?)

Here is the comparison I did (I had to open twice your file in two different blender instances aside)


Using the box-select tool [b] in edit mode adds to the selection. That unwanted point was part of your previous selection. You can remove this by simply holding down [shift] and right clicking the unwanted vertex.

Whenever you want to make a new selection using the box-select, remember to first de-select everything by pressing the [a] key. The box-select tool shouldn't make any selections outside of its influence area.


It renders all edges, even the ones that are made by automatic triangulation during rendering. Maybe you marked the faces instead of edges. You should only mark the edges and also set the render settings to render only marked:


How to display my reference image in Wireframe mode


For orthographic view or camera rays from flat surfaces located at same angle lead to just one pixel of environment texture for both background and reflection.


Graph Editor does not show any keyframes

ok if fcurves are missing, click the little ghost icon at the bottom of the graph editor pane. apparently if that is off your curves wont show...why would they design it like that though?


Why am I missing the UV Map option on certain Normal Map Vectors in Blender 2.8?

Your UV map is probably missing, check in the Properties panel > Object Data > UV Maps. If you don't see any UV map, you need to unwrap your object again so that Blender knows how to project the image on your object.


What Are The Disadvantages Of Using JPEG Image For Texturing

It depends on what you want to achieve.
Basically, JPEGs are not all bad, especially for photographed image textures they work just fine.
Typical disadvantages of the JPEG format are:

Compression artifacts (should only be a problem if you have low quality or need very high detail)
No transparency channel (can be a problem if you want multiple overlaid textures or stencils)
Limited colordepth (for height- or bumpmaps or environment textures, the number of colors and/or brightness levels can be insufficient)

As advantages, I'd name the following:

It's usually the most readily available format for images (if you take or download a photo in JPEG format, you won't gain anything by converting it into another format)
For typical photographic images, it uses comparatively little space on your hard drive


Why do some selected objects have a yellow outline and others have an orange outline?

3D Viewport:
One way to select objects is clicking on them in the 3D Viewport in Object Mode.
Objects with an orange outline are sleceted, but the one object with a yellow outline is the active object. There can only be one object with a yellow outline (but there can be multiple with an orange outline). When holding Shift down (that is the default key), you can select multiple objects. The object you select last is the yellow and active object. This is important if you want to do operations on multiple selected objects.
For instance, if you select two cube objects in Object Mode, "Cube" and "Cube.001" in that order, and then press Ctrl + J, then "Cube" will become part of "Cube.001". Since "Cube.001" was the active object. "Cube" will be gone and the "Cube.001" object will have a mesh consisting of two cubes.
If you select two cube objects, then select a sphere object and then de-select the sphere object, you are left with two cubes with an orange outline. Now joining the objects with Ctrl + J will not work, because Blender does not know which object to make part of the other and which one to keep as the remaining object.
Also, if you add geometry in Edit Mode, for instance add a cube to a cube and then select it in Object mode, both cubes have a yellow outline. It may seem you have two objects with the same color outline, but it is one object. So not a new object was added, but geometry was added to the mesh of the object, and in Object Mode the cubes will move as one.
(If you have multiple meshes in one object, but you want to separate them into multiple objects, you can select the object in Edit Mode an press P and choose for instance By Loose Parts.)
EDIT:
Outliner:
If you select objects in the Outliner window however, it can be different.
In the Outliner there is a square with rounded edges around the active object. There is always an active object. So there is always such a square somewhere in the Outliner, even if no object is selected.
If you select an object in the Outliner by clicking on it, it turns yellow in the Outliner and it gets a yellow outline in the 3D Viewport. Shift select other objects and they will turn orange and have an orange outline. So in the Outliner the first selected object is, and remains (while selecting in the Outliner), the active object.
If you select an object in the Outliner, other than the active object (whether the active object is selected or not), by right clicking on it and choosing Select from the menu, it will turn orange in the Outliner and have an orange outline in the 3D Viewport. So if the active object is not selected, you can select multiple objects this way without any of them being yellow or having a yellow outline.
If you select an object and then go into Edit Mode, you cannot select other objects (or their corresponding meshes) in the 3D Viewport. You can select other objects in the Outliner, but in this case the object you are editing is and remains the active object. Also the meshes of subsequently selected objects do not become editable, even though it is possible to edit the meshes of multiple objects at the same time. In order to do this you will have to select multiple objects before going into edit mode.
EDIT 2:
Outdated graphic card drivers:
It is also possible you select a single object and the outline is orange (even though it should be yellow). And when you try to move it, only the origin (the small dot) is affected. Also the origin can be moved away form cameras and lights. This should not happen and is likely caused the 3D Viewport not updating. Updating you video card drivers should resolve this issue.


Is there any way to get a quick render, like OpenGL for cycles and fisheye camera?

override all the materials from the layer tab :

to add wireframe to all objects :

import bpy

for obj in bpy.data.objects:
    if obj.type == 'MESH':
        obj.modifiers.new("temp_mod", 'WIREFRAME')

run this and all the objects will be in wireframe render then use this script to remove it :

import bpy
for obj in bpy.data.objects:
    if obj.type == 'MESH':
        obj.modifiers.remove(obj.modifiers['temp_mod'])


Because I was having the exact same problem, and I mean exact same, I tried lowering my specularity to just .3 and here's the result. While the liquid looks amazing and I think the cup looks ok (too thin now, I'll have to scale the liquid down) there's a large reflection of the plate from the other side. How can I prevent the light reflecting off the plate from also going through the liquid? I would like for light to be diffused inside of the liquid.

I changed the lighting angle and it helped, haha. But there's still an odd reflection.


With Vertex Paint you are directly coloring model's mesh - so this technique doesn't use UV mapping to apply any kind of texture.

If you want to paint a texture (image), you need to switch to Texture Paint mode insted of Vertex Paint.


Can PBR be "faked" in Blender Internal or the Game Engine?

I found this video & post really helpful for PBR for non-cycles renders: https://cgcookie.com/2015/05/20/pbr-in-blenders-viewport/

He uses 2 environment maps, one blurry and one sharp, and blends them in way that the sharp one is reflected on the edges and the blurry one is reflected in the front, the way fresnel reflections work. He uses a normal node to do the fresnel reflections in a clever way.

It works with environment maps, not specular (phong) shading, though personally I prefer the environment map look. Note that if you add a light the hilights you get won't match the reflections.

So it's a bit of a hack - 2 reflection maps needed, lights don't reflect right - but it works.


when I move an object it permanently moving in 1.0000 increments

Welcome to Blender stack Exchange!

That's because of an option called 'Snap During Transform'. It's a little magnet icon in the toolbar at the bottom of the 3D view (in Blender 2.79b and earlier) or at the top center of the 3D view (Blender 2.80 and later). The keyboard shortcut is Shift+_Tab. I find those keys very easy to accidentally bump because of the other shortcuts Blender uses. Disable it and you should be good to go.


How can I view the reference image behind a cube?


You probably created this faces after enabling smooth shading and they are not updated yet. Go to object mode, enable Flat shading and then Smooth shading again and this faces will start looking as they should.


How to create a superior mirage in blender

I kinda figured out how to fake a passable mirage effect:

I don't think it's even possible to reproduce this phenomenon in Blender at the moment, so I went for a physically realistic depiction of it, not a physically accurate one. Any approach will need to use some tricks to fake it—smoke and mirrors. Well... mirror and mirror:

I did it with two planes, one behind the camera to capture what it's seeing, another behind everything to reflect the reflection of the first plane back to the camera.

If you set them up with the right constraints you can make them always face each other and lock positions and rotations with the camera so you don't have to do this manually. But making sure they don't fall out of sync with the camera is just the start.

Simply placing two reflective planes facing each other won't work because you'd see the back of the scene in the second one. You need to reposition the reflection in a way the real one gets occluded by the scene and only the reflection of the reflection appears. This can be done with normals.

I was most successful using the Incoming output of the Geometry node for this task. Here's what the manual has to say about it:

  Incoming: Vector pointing towards the point the shading point is
  being viewed from.

Once you have a vector input always pointing to the camera it gets easier. A Mapping node can be used to reposition it, even rotate it and flip it so it shows what you need.

The shader of the plane receiving this reflection is more complex. Superior mirages seems to always display at least an upside-down reflection over the object, often appearing as an inverted projection underneath a not inverted second projection. They're also pretty dynamic, being made of heated air.

To do this I blended a regular and an inverted reflection and used a noise node to create the air distortion.

The ending result is pretty convincing, and may be more than enough depending on your needs. There are a couple of limitations though I simply don't have the energy to sort out. The first one is the deformation caused by the Incoming normal:

Depending on the angle it's possible to straighten that arc with changing the rotation in the Mapping of the camera plane. It'll, however, deform any reflections far from the center of the image. Another limitation is not being able to compress and stretch parts of the reflection at will to better reproduce the distortions seen in a real mirage. The faked mirage may also seen a bit faded out under some circumstances, but that can be fixed  by using an array modifier to duplicate the plane.

Another serious limitation is accidentally catching the reflection of everything above the "horizon line", so setup your scene with this in mind; and the final one is about HDRIs: if you're not careful things get weird!

Here is the demo above (minus the HDRI) so you can play with the nodes:

Let me know if you find solutions to some of the limitations.


White outlines around characters from sun lighting

Consider changing the alpha representation for a texture with transparency.
Try both choices

Straight or Premultiplied

Located in the texture settings image panel.


A couple of things

You are not freeing your bmesh s with

bm.free

you need to call the free method

bm_now.free()
bm_next.free()

Also consider replacing bpy.ops.object.duplicate(linked=False) with either:

newobj = bpy.context.object.copy()
newobj.data = newobj.data.copy()
bpy.context.scene.objects.link(newobj) # link it to scene
bpy.context.scene.objects.active = newobj # make it context.active_object

or quite simply

mesh = bpy.context.object.data

to not have subdivided dupes.

Not using operators will avoid adding the state to the undo stack, and running out of memory.

Making these changes lets me get to 8 on default cube, (9  crashes my blender), which is passable  given 6 is the max for modifier.


If you have multiple files, you simply have to distribute all of them. They are not packed into the exe, but are still required.

Relative paths must be maintained.
This means that you must distribute your project as a zip file, with the executable and the required files.

If you have a game with two files:

menu.blend
game.blend

And then export menu.blend into menu.exe

Then you need to put in your game's folder:

game.blend
menu.exe
2.78 (or whatever the folder number is)
???.dll (all the .dll files)

These can all be put into a zip file for distribution.

One of my projects recently looked like this:

Hiding in there you can see the blend 'Game.blend'
This blend file is then exported to an executable, and to distrubute the game, all of these files must be kept together. The easiest way is to export into the same folder as the blend and zip everything. (And when you're making the game make sure all file paths are inside a project folder)


Why am I unable to color my volumetric clouds white?

After replicating your node network I found reducing the anisitropy value on the principled volume node makes the clouds whiter


Restrict objects motion when using curve modifier

Maybe your problem is that you didn't put the curve origin at its beginning point?

About the speed, you can change it as much as you want if you create some new keyframes for the curve and play with their position or with the curve handles in the Graph Editor.

Another simple way to do what you want is tu use a Lattice modifier:

Create a Lattice object.
Stay in Object mode, give it the size and proportion you need, of course it needs to be bigger than your fish.
In the Properties panel > Data, give your lattice some edge loops in the U axis (or in the V axis, depending on its orientation). You can even reduce the V and W values to 1.
In Edit mode, deform your lattice, use the Proportional Editing option to make it smooth.
Select your fish, give it a Lattice modifier, choose the lattice as Object.
Move your fish or move your lattice to make the fish bend.


How can I export multiple animations into one .x file?

Blender has a DirectX exporter. Go to Addons in User Preferences and look under Import/Export.

Check Export Animations, this should export all the animations in your file. I would recommend playing with the other animation options as well. You can read up on each setting on its wiki page.

Test 1: I enabled it and made a simple scene with two animations. I exported the file to .x and opened it in a text editor and I saw the animations in there clearly labeled and with the transform locations I had used.

Test 2: I also downloaded a .x viewer called 3dmodelviewer, exported a file from Blender with over 6 animations and it loaded and played them all so the exporter works with multiple animations.

NB: In my tests, I parented primitives to several different bones. I also noticed that I had to be in pose mode when I was animating the objects, if not it doesn't work, not sure why.


Why do the cubes in my Rubiks cube move into each other?

You have nine separate objects selected, and "Add Keyframe" made animation curves for each object. Because they are separate, each goes it's own way, on separate lines. You can see the orange dots moving on their own straight lines, instead of a circular path.

To fix this:

Clear the current curves.
Bind the objects to a shared parent while keeping their offsets.
Animate the parent only.

EDIT: You say in your comment that you will be animating more rotations. For that case I have two ideas:

Easy mode: move the object centers to the cube center, so all orange dots will be in the same global position. Then rotation along the three axes will move the meshes along a circular path.
Advanced mode: Python script as driver for object position and rotation. This is harder to set up for beginners, but it can result in a shared controller for all 26 objects.


Why does Emission shader dilute colors? EEVEE

added a comment but I think it's an complete answer.
So, here's what you can do.
Turn off bloom settings in eevee and use emmision strength of just 1.
Now,render the thing. After that,go into the compositing tab and click on use nodes. Add in a flare node just before output node. Now you can use bloom effect without changing the mesh's colour.
You can watch this video if you had any problem using glare node-
https://youtu.be/SN8nJXn7CqI


Add a Cylinder ShiftA > Mesh > Cylinder, set the Cap Fill Type to Nothing.
Select half of it and delete with X or Delete
Select the four vertices along the edge
Extrude to make the long sides

Fill the back, top and bottom to get this.

Note the top and bottom are Ngons, witch in many cases are undesirable. To get a quads all over the top use grid fill.


VSE/Compositor - Something similar to Turbulence Displacement effect in After Effects

Try a Displace node with a Clouds procedural texture (in the compositor):

The nodes in the "X Y scale" frame are just for convenience, you can also set the scale directly on the texture node.
The mix node in the "Recenter" frame subtracts .5 gray to keep the result in place; the displace node moves pixels up/right for positive numbers and down/left for negative numbers. To move pixels both ways, the 0..1 range of the texture needs to be shifted to -.5..+.5.

The scale inputs on the displace node itself set the distance (in pixels) a value of 1 in the vector input will move the corresponding pixel of the image input. In this example I set the vertical scale to 0 to mimic your reference image.


The traceback is part of the programmer's tool kit which can be generated when the program has an abnormal termination. The traceback error documents exactly what problem was encountered, how the program got to that point, and exactly what the computer had been doing when the problem occurred. For the developer, it is an invaluable tool in tracking down a bug. For someone who is unfamiliar with the code and architecture of Blender and addons to Blender, it seems so much gobbledygook.

If you run into this type of traceback, and decide to file a bug report, making a screenshot of the traceback and including it with the bug report can be useful to someone who is going to try to fix the bug.


Dopesheet - What is the difference between Select methods Border Axis Range and Border select?

Old question, but the answer might be useful to someone:

Border Select: Selects the elements inside of a given rectangle.
Border Axis Range: Selects the elements between the left and right sides of the rectangle, regardless of their vertical position.

Example:

In other wordes, Border Axis Range is a range selection tool, while Border Select is a box selection tool.

Border Axis Range is useful for armatures with a large number of bones: If you cannot fit all the rows in one window, you can still select over a range without having to scroll up or down.


Moving all keyframes forward/backwards in time, including bones?

Dopesheet is your friend, just check the settings of its two visibility buttons, one will let you edit only selected objects, the other will let you edit hidden objects also.

In my example, editing will affect the cube as object, the armature as bone keyframed in pose mode, and a hidden bezier curve (again as object).


Spinning gears, need object to spin about 3.5x faster

Use a Generator Modifier for your driven smaller wheel.

Select the smaller wheel, go to the driver's properties shelf (N) and add the modifier. Increase the value pictured below. Now the wheels are spining with a different speed.


There are three distinct ways to do this.

Either use Bezier Curve objects. They have the advantage of being simple to edit for tubular structures, can easily bend and make curves, and can have custom sections

Use a mesh with a Wireframe modifier. It is fast to process and is a mesh, so can have a lot more modifiers on top than a bezier curve

Use a skin modifier. It is slower to process and computationally heavy to handle, but will generate cleaner topology and have proper intersections at the joints.


How to create a CLOWN PASS for material selection in photoshop?

Dedicate render layer with material override

For this task I usually set up a dedicated render layer.

I render only the emission pass of the surfaces using a material that transform a given random number, one for each object, into a color of the color ramp.

To render all the objects with the same material without touching your original scene, you can use the Material box in the Layer panel of the Render Layers tab.

Here's a possible setup:

Note (1): you need just 1 sample to achieve the final look, so it should not affect much your rendering time.

Note (2): this works "per object", not "per materials". For materials, I would use the Material ID pass, but that's not automated.


Detect holes on a not flat surface at a set circumference

You can take advantage of the fact that holes are also non-manifold to easily identify hole vertices that lie within a given radius from the selected face.

Here's the code:

import bpy, bmesh

radius = 0.5

# Assumes your object is selected and is in edit mode
o  = bpy.data.objects[ bpy.context.object.name ]
bm = bmesh.from_edit_mesh( o.data )

# Assumes you have a single face selected
fCo = bm.select_history[0].calc_center_median() # Location of face center

bpy.ops.mesh.select_all( action = 'DESELECT' )
bpy.ops.mesh.select_mode( type = 'VERT' )
bpy.ops.mesh.select_non_manifold() # Holes are also non-manifold

# Find all hole verts that are closer to the selected face than the radius
verts = [ v for v in bm.verts if v.select and ( fCo - o.matrix_world * v.co ).length < radius ]

if len( verts ) > 0:
    print( "%s hole verts within radius of %s blender units" % ( len( verts ), radius ) )

bpy.ops.mesh.select_all( action = 'DESELECT' )
for v in verts:
    v.select = True

bm.select_flush( True )


You can find a plethora of articles all over the place dealing with the subject. Like this one, or that one.

TL;DR:

  Use whatever works. Quads are the default. But feel free to use triangles when you need to use them. There’s no hard and fast reason to say that you should never use a triangle. Sometimes it’s just easier!


If all your windows are identical you can link their UV maps and materials. Better yet, you can link all the object data if you want them to be perfect clones of one another.

You can do this by selecting all your windows (make sure the last one selected/highlighted in yellow is the one with the proper material data) then press CtrlL and selecting Object Data, Materials, and/or Transfer UV Maps.


Ink on Porous Paper or Water Bleed Effect

After messing with settings.

Basics:

To achieve 'ink drop on paper' effect we will be using Fluid System and Dynamic Paint. Fluid gives us nice control over drop shape. Blender units are used in this answer.

Set up:

Plane with dimensions 8x8 - this is our 'paper' - it must be subdivided number of times (higher is better) I'm using 2 Subsfurf modifiers, first set to 6 and second to 2 both set as Simple, they need to be over the Dynamic Paint modifier.
Sphere (16 segments, 8 rings, 0.3 size), moved by 3 units over Z axis (G > Z > 3) - this is our drop.
With selected Sphere hit Space search for Quick Fluid and apply.
Select Domain and Scale/Position it to cover whole plane.

Fluid:

Select 'paper' (plane) and in Properties tab choose Physics then select Fluid and set Type to Obstacle. Decrease Slip Type Amount to 0.1
Select Domain and under Fluid World > Viscosity Presets set Base to 2 and Exponent to 3. Under Fluid Boundry set Slip Type > Amount to 0.03

Exponent is very important here, if you want to preserve shape of your fluid you will need to set it to 0, and if you want to have random splatter set it higher.

Another important thing in Fluid Domain is Resolution, we will be using here 65 for preview but higher will give much better results

Dynamic Paint:

Brush

With selected Domain add Dynamic Paint (Physics tab).
Set Dynamic Paint to Brush and then Add Brush.
Change color if you want.
Under Dynamic Paint Source set Paint Source to Proximity, Falloff to Color Ramp and set Color Ramp as in the picture below:

Canvas

Select our 'paper' (plane) go to Physics tab and add Dynamic Paint > Canvas > Add Canvas.
Under Dynamic Paint Advanced set Dry Time to 25.
Under Dynamic Paint Initial Color choose Color and set it as you like.
Under Dynamic Paint Effects check Use Spread and set it to 0.5 then go to Drip and check it as well (it will give us control over the splatter by force fields).

Force field:

Add Force Field > Turbulence and set it to Strenght 10 and Flow 1.
Bake your fluid and play animation.

Domain and Fluid are hidden here.

Fluid resolution - 128 and some other sligt changes. This is from .blend file.

Final thoughts:

There are many things to play with in order to get higher resolution/better looking effect as I mentioned it above. Fluid resolution, mesh (paper) subdivision, substeps in Canvas. You could change Influance Scale and Radius Scale under Canvas > Dynamic Paint Advanced to have 'lighter look' of ink. It's all up to you. Now when you know the method it will be fun to mess with it.

Blend file:


If you link in an object from an external file you can't move it by default, even if you parent it to a local object. In this case the selected object should be highlighted in blue unless you alter the theme colours. You can make a proxy or make a local copy to move it, or move it in the original file.

A linked object will have a small file icon next to it in the outliner. This icon will also be seen in a few other places like the object properties. All values will also be greyed out.

The only other thing that should prevent a child moving with it's parent is a constraint.

Similar constraints are available for rotation and scale. Clicking the X in the corner will delete them or you can turn off the limit that is bothering you.

Something that can stop an object being moved by itself (but should still move with a parent) is locking the transform channels. Available in both the object properties and the properties sidebar, clicking these "padlocks" will prevent the related transform channel from being altered in the 3DView. You can actually alter the values displayed to move objects while they are locked, just not with g,s,r in the viewport.

Simply click the locks to unlock them.

The values may also have drivers attached to them. When a value is being driven it is highlighted in purple.

Right click on the value and select Delete Drivers.


Why does copy rotation constraint invert after 180 degrees

Maybe you can alternatively do it with drivers instead.

Rather than add constrains use a driver on the rotation properties of the hour hand by right clicking them and choosing Add Driver > Manually Create Later

Then proceed to the Graph Editor, change to Drivers from the header, and choose the desired channel (Z in this case).
From there open the Properties Panel (N Key), Drivers tab choose the option Scripted Expression and add a new variable.
Use the Transform Chanel option, pick the other hand and choose its $Z$ Rotation. The scripted expression should read something along the lines of $var/12$ so it rotates at one twelfth of the angular speed.


How to create a `files`-parameter for the bpy.ops.sequencer.image_strip_add()-operator?

Don't use operators to do this; they aren't intended to be called from Python.

The regular data/function API is much simpler to use:

import bpy

se = bpy.context.scene.sequence_editor_create()
seq = se.sequences.new_image('hey', 'C:/temp/hey.png', 1, 1)


How to add PNG image as texture with transparency on a plane and export as obj?

OBJ files do not store textures, hardly anything does - you have to export OBJ, import it to whatever you need it in. Then you need to import textures, create material/shader using the texture and apply it on the OBJ.

Clarifying with some more details:

Applying texture inside blender will only stay in blender. OBJ only has geometry information, mtl has some material data, but no texture information of any sort.
What you usually do is:

Make object with UV maps,
Make material,
Export Object,
Bake materials into textures,
Export baked textures.

Then you import it in target environment, be it other 3d software, 3d engine, or anything, and there you re-create material using baked textures and tools available in the environment. Then you apply it onto imported obj.


How to enable GPU rendering with my Radeon card in Linux?

AHA!

So it turns out that I needed the ocl-icd-opencl-dev  package installed. Once I installed that package...

\o/


It looks like the "blurred" part is mostly volume shader, surface is tranparent.
If you don't want to change your shader, you can try to use a bevel on the edges to catch the light and make it look real somehow.


What Non-Color Data means
Choosing Color Data vs Non-Color Data determines whether or not Blender will color manage your image.
Gamma Correction is a way of compressing color data and is commonly used in many image formats, such as PNG and JPEG. Without getting in to the mathematical nitty-gritty, Gamma Correction raises the intensity of a pixel to a certain power (or gamma value) to encode it, then raises it to the reciprocal power to decode it. Why would we want to do this? Here's a helpful table from Wikipedia:

Source
The bottom row, Linear intensity represents the non-gamma corrected values. You will observe that there is a large jump in intensity between 0.0 and 0.1 stops. In the top row, Linear encoding (meaning it is gamma-corrected), you will see that the difference in intensity between the stops is much more even.
What this means is that a basic linear scale does not equally distribute intensity as our eyes see it across the range [0, 1]. Referencing back to our image, between stops 0.0 and 0.1 on the bottom row, that whole range of color has to be squeezed into one tenth of the available range. On the other end of the spectrum, the range between 0.8 and 1.0 on the bottom only needs 0.9 to 1.0 on the top. This way, the colors that we can see are given more "space", and the colors we can't really distinguish from one another receive less.
Most common image formats (and video displays) use sRGB (standard Red Green Blue) as their chosen encoding. This actually has a non-linear gamma (don't worry about it) that can be approximated by 2.2.
When you select Color Data, Blender will gamma correct your image (based on the image encoding). When you select Non-Color Data, Blender will not alter the RGB values of the image, leaving them in a linear scale.
When you should use it
Color Data should be used for image textures being used to color a model, like Diffuse and Albedo textures. This way, they will be color managed to display their intended color values.
Non-Color Data should be used for image textures being used to store other data. For example, Normal Maps store the normal vector data of a given point on a mesh. Vectors (in this case) are linear and have no need to be gamma corrected. The same goes for other maps like Bump maps or Specular maps. These images had values stored to them on a linear scale, so they should be read on a linear scale.
Hope that all made sense. I'm happy to clarify anything.
Example:

Left - Color Data:
How the image is intended to look.
Center - Non-Color Data:
The image with no gamma correction. Note how there are lots of lighter values and very few dark values, making it look "washed-out."
Right - Non-Color Data with Gamma node:
This looks very similar to the Color Data image. It isn't exactly identical, though, since the image was encoded with sRGB, while I decoded it with a normal Gamma of 2.2.


What is needed to load/reload an addon during development?

Why does the addon not get loaded?

The path should be ~/.config/blender/2.76/scripts/addons/, not addon.

  How do I best get addon changes into the running blender process?

F8 can be used to reload the addons.


How to make a holographic reticle shader in cycles

Pure Shader Solution!

Hey look, high-school maths does have a purpose......

From what I could understand with a little research, holographic/reticle sights display a holograph that appears (when looking through the sights glass) to be fixed to a spatial position a certain distance (d) from the glass. Basically, we need to work out the x,y coordinates of the point d distance down the camera ray for each point we render on our sight. We can then use that to map our texture.

This would be a piece of cake if we had matrices in cycles nodes (in particular, the transform matrices of the sight object and the camera, as well as the projection matrix). We don't, so lets improvise.

The camera data node (which is where you'd expect to find the view and projection matrices) is a good starting place. While we don't see any juicy matrices, we do get one vector.

The View Vector

Location: Camera Data Node
Age... No idea when it was added
Height: ....Dude, this is a node
Weakness: Its normalized

The view vector provides a vector representing the ray that was shot out to hit that point of our mesh. This direction is in camera space. Therefore Z is always forwards, x is always left/right, and y is always up down. Each vector is normalized, so they always have a length of one.

Lets visualize this a bit. We'll do this in 2D because I can't draw this in 3D it will be easier for you to understand.

Looking at our camera top down in camera space, z is forwards (now up relative to our view), and x is left to right. This is drawn with the dark colored axis. If we look at our ray (in yellow) which has a length of 1, you will see that it can be broken up into an x and a z component (light colored axis). This is the ratio of x to z movement needed to travel down the ray.

I am available to illustrate geometry textbooks.

Do you remember when I said

  Basically, we need to work out the x,y coordinates of the point d distance down the camera ray for each point we render on our sight.

If we multiply the View Vector by d, we will get the x,y coordinates of a point d distance from the camera in that direction. Progress!

However, our sight is now fixed to the camera. We can improve this, using the vector transform node.

Vector Transform

Strength: Secret sauce that makes everything work
Weakness: Doesn't seem to understand the idea of location

Obviously, our hologram should not always be d distance infront of the camera. It should be d distance in front of our sight. To do this, we will need to go from camera space to object space. The vector transform does exactly this:

To explain exactly how this space conversion works, we will need to understand object space. Object space is where the origin of our space is the origin of the object, and all the axis (plural) line up with the objects local axis (plural). Pretty simple. Our sight just needs to be d distance down the z axis is object space.

So how does this space conversion work?

If you will direct your eyes to my next graphic (again drawn looking top down), you will see that a plane as been added (our sight), and the camera has been rotated. In light colors are the axis of the object space, and in dark the axis of the camera space.

If we ignore position for a moment, and overlay the two spaces, we can see how the axis don't align:

If we line the axis up as such:

We can see that the ray, which is in camera space, is pointing the wrong way. If we apply the inverse of the camera's rotation to the data, the ray will go back to pointing the correct direction.

This is what the vector transform does.

However, this space transformation does not take the relative positions of the camera and the object into account. Therefore, if we move the camera, our sight slips:

To fix this, we need to take position into account.

Object Texture Coordinate

Location: Texture Coordinate node
Weakness: Weird positions for object origins

The object texture coordinate give the object space location of the ray/mesh intersection. Since our rays are traveling at the right angle, all they need is to start at the right place. If we take the object space coordinate, and travel d distance along the ray direct (in object space), we will get our desired x,y coordinates. This can be achieve simply be Adding the two vectors together (using the vector math node).

Now it works:

Lets re-cap.

We take the view vector, transform it to object space, multiply it by the distance d (scalar multiplication). We then add it to the object texture coordinate.

Since we sample textures in 0,1 space, and our xy coordinates range between --25 and + 25, we then divide by d, and add .5 to the xy coordinates, Clamp to avoid the texture repeating, then sample it. The whole setup looks like this:

I created my own vector clamp and scalar multiply node groups. Those can be obtained in the provided blend file.

Denormalizing the View Vector

The view vector travels out from the camera, which is a point in space. We adjust the position, transforming it to the origin of the object. Because the vector is normalize, our "projection" plane is actually a sphere d distance from the origin of the object.

In the examples, we view a very small slice of the sphere, so the curvature is not very noticeable

However, if we were to place a camera with a very wide FOV very close to the glass, we would see a much greater amount of curvature:

Which would produce very visible distortion (clamping is turned off because the repeating pattern makes to distortion more visible):

To fix this we need project the point represented by the normalize view vector (Yellow) onto a abstract plane (Teal) that is one unit away from the camera along the z (depth) axis.

The target point is in magenta. RGB lines represent components of the view vector. Also, 2.8 grease pencil improvements are awesome.

This diagram is a little confusing, a top down view provides some more clarity:

If we scale the vector's components by the ratio of the distance to the plane and the z components 1.0/z (big purple bracket divided by little purple bracket) We can extend the vector to the plane.

Implemented in nodes:

And now the warping is gone:

The center target is still roughly the same size. They appear to have shrunk since the spherical projection was moving the outer targets closer.

Author's Notes

This is a pretty robust shader. It handles object rotation, scaling moving, and zooming (focal length changes) in stride. The scope texture will always be centered around the object origin, and be visible when looking down the z axis of the object. Because the output of view vector is normalized, the output x,y coordinates used to map the texture will be projected along a sphere d distance from the objects origin, rather than a plane. This shouldn't be too noticeable. Pity they don't let the user decide whether it should be normalized.


Smart UV project unmapping outside of UV space

The only way to do this with smart unwrap it to pack the islands after the are created. CTRL P


The fastest way to recreate buildings from real world cities in Blender

Go to OpenStreetMap, and make sure you are using the default layer on the right-side menu.

Use the Share Option, then on the lower part use the SVG (or PDF) option to export the visible area. Adjust the scale before exporting if you want any semblance of metric precision or accurate measurements

Either import it directly into Blender, or if you wish do some cleanup in Inkscape and remove unwanted or unneeded parts.

You can then easily extrude buildings directly as curve or convert to mesh for more complex or detailed modelling.

Have in mind that it still requires the desired area to be mapped and have actual building information.


Not sure if you mean this, but I think you clicked the 'Render' button in the properties panel (which is the same as pressing F12). But if you click the small 'render' button in the compositor (Node Editor) it will only render that scene.


Surface shown in Eevee but not in Cycles

Thanks Nathan, your comment gave me the courage to dig deeper. Eventually, I found 2 issues.

Because the wood surface was actually generated as the ground when I used 'Setup Tracking Scene', it was set as 'Shadow catcher' in the Visibility section of the object properties.
When I added the cylinder, I added it to the 'background' collection, which was marked as 'holdout' in the same section.

Again, thanks Nathan for your tip, I added a cube above the surface, made it glossy and it rendered fine, which led me to that extra investigation.


The issue is that you are not using any coordinates to control the mapping of the texture. In this case you have not defined a UV map.

When you create a single object that contains the meshes for all of the bolts you are enlarging the bounding box of the object. And, since you are not using any UVs, then the bounding box happens to be the key element in defining the anisotropic qualities of the surface.

Quote from the blender manual

  The Anisotropic BSDF node is used to add a glossy reflection, with separate control over U and V direction roughness. The tangents used for shading are derived from the active UV map. If no UV map is available, they are automatically generated using a sphere mapping based on the mesh bounding box.

A single mesh:

Several copies of the same mesh:

The bounding box:

To make all of the elements have the effect you are after, you need to unwraop the mesh to define the UV coordinates for the original object.

And have the anisotropic BSDF node use the UV coordinates as tangent. Note that the UVs should be unwrapped as 'Project from View' in isometric view (rather than perspective view - Numpad-5), viewed in the direction of the desired anisotropy, and moved to be centred on the UV origin (as that is where the centre of anisotropy will be located).

Then every copy of the original mesh will be using the same mapping, regardless of the bounding box of the object.

NOTE : This will produce a slightly skewed anisotropy due to the raw UV coordinated being used for the Tangent rather than an actual tangent. This can be adjusted using the Anisotropic Shader 'Rotation' property, but a better fix is to use a Cross Product node to generate the tangent from the UV coordinate and a fixed (0,0,1) vector (which is perpendicular to the UV plane) using the following nodes :

The alternative to this is not to merge all of the meshes into a single object, but to make a single bolt, then use instances with Alt+D, that way each copy will be a single object, but will share the same mesh and material. If you want to edit the original, then all other instances will be editied as well


Trivial case with bpy.ops.mesh.primitive_plane_add()

import bpy
context = bpy.context

b = 10
bpy.ops.mesh.primitive_plane_add(radius=b)
g_o = context.object
g_o.name = "GroundO"
g_d = g_o.data
g_d.name = "GroundM"

Use bmesh
Strongly recommend getting familiar with bmesh as soon as possible. Trying to use the mesh methods (esp. to create), other than from_pydata(..) as pointed out in answer from @atomicbezierslinger, will drive you nuts.

import bpy
import bmesh
scene = bpy.context.scene
g_d = bpy.data.meshes.new(name="GroundM")
g_o = bpy.data.objects.new(name="GroundO", object_data = g_d)
scene.objects.link(g_o)
g_o.location = (0,0,0)
g_o.select = True
scene.objects.active = g_o

bm = bmesh.new()
bm.from_mesh(g_d)
# Fill in the data for the mesh
b = 10
v1 = (-b,b,0)
v2 = (b,b,0)
v3 = (b,-b,0)
v4 = (-b,-b,0)
verts = [v1, v2, v3, v4]
bmverts = [bm.verts.new(co) for co in verts]

bm.faces.new(bmverts)
bm.to_mesh(g_d)
scene.update()

or easier still with bmesh.ops.create_grid(...)

import bpy
import bmesh
scene = bpy.context.scene
g_d = bpy.data.meshes.new(name="GroundM")
g_o = bpy.data.objects.new(name="GroundO", object_data = g_d)
scene.objects.link(g_o)
g_o.location = (0,0,0)
g_o.select = True
scene.objects.active = g_o

bm = bmesh.new()
bm.from_mesh(g_d)
# Fill in the data for the mesh
b = 10
bmesh.ops.create_grid(bm, x_segments=1, y_segments=1, size=b)
bm.to_mesh(g_d)
scene.update()


How to child a control point of a Bezier curve to an object

I found the solution in a YouTube video:

Suppose you want to make Object A the parent of a control point in a Bezier curve (Object B).

select Object A, then shift-select Object B (so both objects are selected)
click edit mode. Object B will open edit mode.
select the control point you want to "attach" to Object A. click ctrl+H.
choose "selected object"

When you now move Object A, the control point will move accordingly, while the other control points of Object B won't, hence deforming the Bezier curve.

PS: you can also use this method when Object B is a simple mesh object (i.e. vertices instead of control points).


How can I preserve both materials from two meshes that undergo boolean union?

I've posted this question elsewhere and got this answer "The object with the boolean modifier needs to have both materials in its material list"

I tried exactly that, first when I make my two objects with separate materials, I make sure the second mesh also lists the material of the other object, even though it is not in use:

then when I request that second mesh to be boolean unified to the other mesh, the result is multicolor:

That object in the screenshot is definitely a single mesh with two materials. So that seems the way to do it.


It is very easy. Go to the object data properties panel (The one that has an upside down triangle with three verticies) and under normals, click auto smooth. to get the desired result you can change the angle of the auto smooth.


A mix shader with a dark ambient occlusion node, colored to fit your object, factored mostly toward the diffuse might help depending on what results you're looking for.

Otherwise I would suggest moving the light farther away, that will at least soften out the white highlights


I found a software called AutoHotkey which send keystrokes to other programs and WORKS WITH BLENDER. Just restored my KeyTweak changes to default and restarted the PC, then I installed AutoHotkey and created the following script:

#NoEnv
SendMode Input
SetWorkingDir %A_ScriptDir%
Capslock::Shift
Shift::Ctrl
Ctrl::Capslock

Saved and ran the script as administrator. Works perfectly.


New window without creating a new Screen object

I have two monitors but I only have one blender window open. I expand the window to fill both monitors and then alter the screen layouts so that there is a split on the edge of the physical monitors. By setting the window size then saving the startup file, it always opens to this size, and includes my layouts, I also disable Load UI so that I keep my layouts with other files.

You may notice that the two monitors are different resolutions, I have a python console filling the off-monitor part that is not visible.


How to cut a mesh outline on another plane

I assume that the half-gun has a flat face on the side it's cut.

You can extrude that face out so that it goes through the plane and then subtract the gun from the plane.

Here's an example with a half-suzanne. With a bit of imagination, it looks a bit like a gun :-)

And here's the final result


Normals shows up as single while they should be double

Auto smooth is required to display individual normals.


First off, particle systems are responsible for emitting particles, they have nothing to do with any smoke or fire simulations; on the other hand, smoke simulation is used for emitting smoke, not for particles. Particle system can be used as emitter for smoke (instead of actual mesh), - but their data is different and you can't bake smoke simulation from particle system panel (unless baking everything, see below).

Hence there is Bake button for baking in their options. It will work per each physics simulation - each smoke / fire sim will be baked from its domain, particle systems - from their options per each particle system, same for dynamic paint etc. With this way you'll bake them one by one.

The only way which is independant on these options is to bake all physics at once - with Bake All Dynamics button which will bake everything you have to bake in scene:

  Bake All Dynamics
      Bake all physics systems in the scene, even those of different types. Useful for baking complex setups involving interactions between different physics types.

Note that it may last longer than you expected (because of amount of data to compute).


Create Liquid shooting from bottle in Blender 2.91

You need to change the cache bake type to all:
This is what you have:

You need to change the type to all instead of modular:

Then you bake.
(I would also suggest you change the resolution to something in between 64 and 256 (Depending on how good your PC is))
Let me know if it works
Daniel


Why is my mesh inversed when Imported to Unity?

One possible reason for this could be that the normals actually were inverted in Blender but if you have Backface Culling disabled then the mesh could look right even though it's not.  The lighting may look weird but the polygons will look like they are facing outwards.

Backface culling is an optimization that disables shading on polygons that are not supposed to ever be seen.

When in Edit Mode, you can activate a tool that will show you which direction the normals are pointing in.  Just make sure that the size is adjusted appropriately for the model's scale otherwise you may not see them.

To correct the normals, you can use Ctrl+n which is also shown in the following image as a toolbar button labeled Recalculate.

You can also selectively flip the direction of faces using the button labeled Flip Direction which can also be located in the Faces Menu Ctrl+f with the alternate name Flip Faces

(The different names are a mistake, both use bpy.ops.mesh.flip_normals())


using python to find object with the pixel information from the render

This is no complete answer, but I suggest using the 2D to 3D script you linked.

The script and some other simple methods provide the following information:

Every vertex and its coordinates in 3D (scene) and 2D (rendered image)
Every face (list of vertices)
The object to which a vertice belongs

Given a 2D coordinate, we can find the closest vertices  by calculating the eulcidean distance.

Now we can find the 3D coordinates of those vertices and get the Objects they belong to.

There might be multiple possible objects so we can either calculate the closest view-intersecting-face  or if we have a simple scene just take the vertice that is closest to the camera (3D euclidean distance)


My instance of Blender mysteriously stopped working on Win 10 64-bit.  The Visual Studio debugger said, "unhandled exception 0xc0000904."

I uninstalled Blender 2.75, re-installed the MS Visual Studio redistributable (msvcr120.dll), installed Blender 2.77, went through the usual windows service troubleshooting steps starting from a clean boot.  All no help.

I finally ran the Program Compatibility troubleshooter, the diagnostics log in %appdata%/temp said "python incompatible".

So I deleted the PYTHONPATH environment variable.  Voila! Now Blender starts fine.


How to remove unintentional distortion from geometry?

So, this turned out to be much easier than I anticipated. It is all about flipped normals where some faces have their normal vectors pointing inside the mesh instead of outside. It can be shown in Edit mode (face mode) with face dots and face orientation enabled in the Overlays like this:

It turns out all you need to do is select all the faces on the mesh and recalculate the normals (you want blue facing outward; blue is facing toward you and red is facing away from you). Another way to see the direction of the face normals (instead of turning on Face Orientation) is by showing their vectors:

Big thanks to Chris Kohl (ckhol_art) over at https://blenderartists.org/t/how-to-remove-unintentional-distortion-from-geometry/1241104/3 for providing me with this fantastic answer and explanation.


Finally, here is my solution.

cut one object's edge by bisect tool at position very close to another object, keep a gap between the two objects.
join the two objects into one.
enter edit mode
select the two edges at the sides of the gap
use edge bridge tool.


Play 3 sounds with aud and wait between them

You can play multiple files with the same device, what you need are multiple factories and handles. Use a class, put the device as a global variable or as a class attribute and the handle and factory as instance attributes.

To knwo when the file ends check in a low frquency loop (Always sensor with skip > 10) if the status of the handle is false, if it is, it means that the file has ended and that you can play the next one.


The result without calling operators.

import bpy

from bpy import context
# all mesh objects
meshobs = [o for o in context.selected_objects if o.type == 'MESH']
# black material (or None)
black = bpy.data.materials.get('BLACK')
# copy layer
copy_layer = 19
copy_layers = [i == copy_layer for i in range(20)]
if black is None:
    print("WARNING: no black material")

scene = context.scene

for o in meshobs:
    # linked copy
    copy = o.copy()
    # new copy transforms constraint
    ct = copy.constraints.new('COPY_TRANSFORMS')
    # set target to original
    ct.target = o
    # loop thru material slots
    for slot in copy.material_slots:
        # object link
        slot.link = 'OBJECT'
        # set to black material
        if slot.material is None:
            slot.material = black

    # link to scene
    scene.objects.link(copy)
    # move to copy_layer (after linking to scene)
    copy.layers = copy_layers

It only sets existing slots with empty (slot.material is None) material to black.


You can get a similar result with a Boolean modifier

Create your slicing planes (you can array them using Array modifier)
Add a Boolean Modifier > Intersect to your object
Target the slicing planes

I hid the slicing planes in the gif, so the result is better visible

For more detail refer to the following links:
How can I slice an object horizontally into equal pieces?
Model as multiple unique thin sheets
How do I create slices of a topographical mesh?


Black artifacts in some rendered images of a text

It looks like a topology problem.  You can convert the text to a mesh (Alt +C) and try the following.
 - Recalculating the normals (enter edit mode, select all, Ctrl+N)
 - Check for non-manifold geometry (edit mode - vertex mode, make sure nothing is selected then Ctrl+Alt+Shift+M)
 - Remove double vertices (edit mode, W - remove doubles)

If you would prefer to keep the text object, go to the object modifiers tab in the properties window, then try the following:

add a decimate modifier
set the type to planar


Bevel modifier limited by Weight doesn't work when it's after Boolean Modifier in the modifier stack.
This applies to all edges, not only the new ones.

To bevel edges made by Boolean, you can use Angle limit.


What's the shortcut key for snapping pie menu in blender 2.8

If you mean this menu:

the shortcut is Shift+S

And for the other pie menus see this answer.


While both "Transformation Orientation" options have the same tool-tip, they are used at different times.

The left one you marked, is used for gizmos and only when you grab the gizmo and use it, overwrites the "globally" used one to the right.

While the right one is used when you use the G,R and S keys to move, rotate, scale respectively as well as other functions like E for extrude etc.

Only if you use gizmos, will the left one be used, as it also only becomes available when the gizmo is activated. It can be seen as giving the tool it's own specific orientation option.

The documentation is sadly referring to the same link/explanation for both menus.
After looking through the key-mapping, and checking in the console regarding what is reported when changing the selection for either of the two transformation orientation options, i found, that both set the exact same variable:

bpy.context.scene.type = 'LOCAL'

So using , you only get the pie menu to change the right "globally" used "Transformation Orientation", and it seems to me that there is no key for the tool specific options on the left, neither for a pie menu to change them. And adding a shortcut for those tool specific transformation orientations is not possible either.

That sadly means, that there is no solution i can offer you aside the explanation.


Turn an object according the normal of a selected face from second mesh

Made a couple of changes to this script, the main one is using the Vector.rotation_difference method instead of the angle method. This one calculates rotation in all 3 axes.

import bpy
import bmesh
from mathutils import Vector
from math import degrees # Added for more readable printing of rotation angles

class TestPanel(bpy.types.Panel):
    bl_idname = "object.test_panel"
    bl_label = "Test Panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'

    def draw(self, context):
        layout = self.layout
        layout.operator("object.clone_object", text="Add Suzanne")

class AddCloneObject(bpy.types.Operator):
    bl_idname = "object.clone_object"
    bl_label = "Clone object"

    def execute(self, context):

        if context.object.mode == 'EDIT':
           bpy.ops.object.mode_set(mode='OBJECT')
           obj = bpy.context.active_object

           bm = bmesh.new()
           bm.from_mesh(obj.data)

           selected_faces = [f for f in bm.faces if f.select]

           for face in selected_faces:

               face_location = face.calc_center_median()
               loc_world_space = obj.matrix_world * Vector(face_location)
               z = Vector((0,0,1))

               # Changes start here
               rot = z.rotation_difference( face.normal ).to_euler()
               bpy.context.scene.cursor_location = loc_world_space

               bpy.ops.mesh.primitive_monkey_add(radius=0.5)

               bpy.context.object.rotatation_euler = rot

               print("face location = ", loc_world_space)
               print("rotation = ", [degrees(a) for a in rot] )
               print("Suzanne = ", context.active_object.matrix_world)
               # And End here

           bm.to_mesh(obj.data)
           bm.free()

           return {'FINISHED'}

       else:
           self.report({'INFO'}, "Need to be in edit_mode")

           return {'FINISHED'}

def register():
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()


With the new affine/perspective tracking you can get much better tracking by having a marker that has some features within it. Here's a brief hierarchy of how I think about what makes a good tracking marker:

Bare Minimum:
Some kind of point you can track the position of. Vulnerable to being lost due to noise. Can't track scale or rotation very well.

Better:
A corner gives you more to track, and is less likely to get lost, but can disappear it the camera moves too much around the object, and you probably can't track it's scale.

Best:
Some kind of small pattern or grouping of features. This gives you something with high contrast that you can also keep track of the rotation and scaling of with the Perspective motion model. This should give you a more robust track and thus a better camera solution.


How to remove the "deleting object" while i'm on certain distance

Just increase the end clipping the camera option when yuo select the camera


How to get the pitch of a point relative to the camera's plane of rotation with Python API

Compute the distance between the camera and the point projected onto the plane, i.e. d = point_in_local_coords.xz.length. Then compute the angle using a = atan(d, point_in_local_coords.y).

For bonus points: where you went wrong is the assumption that the angle you want to compute is unaffected by the point's local x and z coordinates.

PS: I'm typing this on my phone, without Blender to test, so I might have a typo in my math somewhere.


Your Problem is labour if I understand you correctly. So you are searching for a workflow that will make your job less labour intensive. I just tried a few things and found something that works at least for me. It comes with restrictions but at least it works.

First you need to prepare your Mesh. For that I recommend duplicating it with Shift+D and moving it to a different layer (with M)

To prepare you need to follow these steps:

Go into Weight Paint Mode of your Mesh (Ctrl+TAB)
press Space and search for "Quantize Vertex Weights", then press F6 and make sure the Subset Combobox spells "All Groups"
press Space and search for "Clean Vertex Group", then press F6 and make sure the Subset Combobox spells "All Groups" again and set the Limit to 0.1 just to be sure
test your bones and look out for vertices that are not anymore in any group. Add them to one that makes sense (you can use weight paint for that but then you have to repeat this whole preparation step from the start. You should instead add them in Edit Mode)

You can find the described functions also in the Weight Tools section of the Tools Panel to the left.

If you are finished you are prepared for the splitting part.

Go into Edit Mode and make sure everything is selected (A).
Subdivide your Mesh (W -> Subdivide) with one division (default).
Then repeat the following process over and over again, until you are finished.

deselect everything (A)
select (the next) Vertex Group in the list and press the select button (found in the Properties Menu in the Object Data tab (little Triangle))
press P to separate the selection

You can use this script to do it for you in one click (just copy it into a Text Editor in Blender and press "Run Script"

import bpy
bpy.ops.mesh.select_all(action="DESELECT")
for i in range(0, len(bpy.context.selected_objects[0].vertex_groups) - 1):
    bpy.ops.object.vertex_group_set_active(group=bpy.context.selected_objects[0].vertex_groups[i].name)
    bpy.ops.object.vertex_group_select()
    bpy.ops.mesh.separate(type='SELECTED')
    bpy.ops.mesh.select_all(action="DESELECT")

To use the script go into Edit Mode of your Model
This should leave you with something like this:

I hope this helps you with your problem.


How to make a bind to Ctrl Key for toggling snapping on/off

Unfortunately, you can't use solely a modifier for a shortcut, plus there already is a shortcut to toggle this: Shift + Tab.

If you still want to, you can change this in the User Preferences.

If you open the user preferences with Ctrl + Alt + U, and switch to the Input tab, you can search by shortcut (Click the dropdown next to the search box and select Key-Binding) to find entries containing "shift tab":

Now, find the entry under 3D view:

And press where it says Shift Tab and press the keys you want to bind.


Match certain parts of a mesh to the body?

You need to assign the appropriate parts of the mesh to the appropriate bones like you would normally. Use the weight paint tool, or vertex grouping.

For those side plates I would definitely recommend assigning them their own bones if they are not strapped into the leg, and would, for instance, hang downward if the character leaned to one side.


How to make grease pencil stroke full opacity?

Ugh. So I had been messing with this for an hour. But after posting, I tried to do it from scratch and discovered the "strength" slider.

So the solution is - at the top of the screen, move the "strength" slider from the default 0.6 to 1.0. And you've got full-opacity lines!


Is there a way to clear sharp edges using bmesh in python?

You can set use_edge_sharp flag per edge on MeshData.edges in Object Mode:

import bpy

obj = bpy.context.object

# Clear sharp state for all edges
for edge in obj.data.edges:
    edge.use_edge_sharp = False

If there is no way around Bmesh for whatever reason, you can set the smooth state of all edges to True in Edit Mode:

import bpy
import bmesh

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

# Clear sharp state for all edges
for edge in bm.edges:
    edge.smooth = True

# Update the mesh
bmesh.update_edit_mesh(me, False, False)

Related: Is there a way to select edges marked as sharp via python?


Automatically smooth bevel faces on apply

Never mind, I found an easy way. Set a material for the bevel modifier, thankfully Blender keeps the material assignment after applying. So it's easy to select and set faces to smooth.


Python select empty action line in NLA Editor for Blender 2.8 API

Use the API methods.

This can be done via low level calls.  Test script below, adds a new track "Foo", adds the action strip, starting at frame 1, using and named after object action.

When adding the track can specify the previous track to insert or append in different orders.

Only requirement is to  have reference to  an object with an action. Note adds empty animation data if none exists. Test against None to bypass

import bpy

context = bpy.context
ob = context.object

ad = ob.animation_data_create()

action =  ob.animation_data.action

if action:
    track = ad.nla_tracks.new()
    track.name = "Foo"
    strip = track.strips.new(action.name, 1, action)


Trying to use array with mesh going from big to small. Meshes are alternately flipping

In an Object-Offset array, whatever transform would take the original array element to the Object will be repeated for each subsequent element.

So if (top row) the controlling Empty is offset in Y, and scaled by -1, then subsequent elements will have the offset from the previous element scaled by 1, -1, 1, .... . The scale multiplies.
To get shrinking elements, scale the Empty to a positive fraction of 1. (0.8 in the bottom row, with no Y offset, giving 0.8, 0.64, 0.512....)


How to assign multi colors on a screw modifier

Materials are assigned at the face/polygon level. The screwed edges in your question have initially no materials. So I think you should extrude/scale down the initial half circle. Assign materials to the wanted parts and use the screw.

Something like that:

Though, geometry will be non manifold and this will be visible.

To correct that, you can use a mask modifier:

Do exactly as previously but do not scale down after extruding, just stay in place. Now with these newly selected vertices create a vertex group.

Color the faces, as before (even if faces are not visible).

Then add a mask modifier after the screw, using the created vertex group:


You could enable edge or face infos in Edit Mode it would display the measures for the selected edges/faces since only one object is active in Edit Mode you can only pick one.

Although you can set Viewport Shading to bounding box there is no option to display the length.

Related:

How to model effectively using exact measurements?
Display bounding box around objects


Texturing problem distorted and messed up

It looks like you have a lot of vertices along your vertical edges, you should try to delete them with a X > Dissolve vertices and see what happens.


How to get length of specific ray type and use that as color?

Wow, I'm happy you thought of doing this.  Baking AO using Cycles is problematic since none of the available scripts bake properly.

I still have not thought of a way to use the Ray Length node to adjust the results of the Reflection Ray but this basic setup looks good enough to suit my needs.

On the left is the Reflection Node used to control two shaders(or use 2 colors for 1 shader).  On the right is a default Diffuse shader.

Beautiful, thanks!

EDIT:  Here is a modified setup that may or may not be attenuating based on ray length.(I'm not totally sure that the setup isn't just behaving like a Color Ramp and squashing brightness/brightness)

The colors values for the Diffuse node and the Sky are all (1.0, 1.0, 1.0).

UPDATE: using direct lighting should give the darkest effect without any color mix node setup.  Otherwise, what was done here cancels global illumination bounces to exaggerate the AO which is normally washed out from bounced lighting.


Path curve: spline to pass through control points

To my best understanding NURBS curves do not precisely support what you wish to achieve and I could not find any options that would 100% bring the solution you wish for.
Option 1
if it's necessary that the spline must cross the vertices, you may want to try Bezier curves instead of NURBS curves. While you will lose the convenience of the NURBS curves (Bezier curves being a bit more tedious to edit), you can be sure that the curve crosses the vertex.
Option 2
If you don't want to use Beziers, but want to stay in NURBS curves instead, you can select the curve and navigate to "Active Spline" settings. From there you can reduce "Order U" to 2 and increase "Resolution U" to 12 or above, which will push the curve closer towards its control points. The trade-off is that you also lose the curvature from the curve itself, but you will have the curve following the control points.


If you assign a Screw modifier in Z to a circle in the XY plane, you should get an object in the form of your openscad reference.

The circle is at helix-radius from the world origin.. by moving it there in Edit mode, you ensure its Object Origin (and therefore the center of rotation of the helix,) is left at World 0.
Any XY slice through the helix will show a circular profile.


Here is a gross way to do it. Unfortunately I couldn't use the NLA with the node actions which would have made it simpler, either I miss something or Blender doesn't manage node actions like other actions:

Create 4 spheres within one single object, unwrap with Project From View, build the following node setup, basically a ColorRamp is used to manage a transition between a blue emission and transparency, I made the setup a bit more complex as I wanted a bit of Layer Weight. At frame 0 set the Mapping Location value in order to make the object completely transparent, keyframe the value:

At frame X, change the Location value so that the sphere are now completely lit:

select the object and press AltD to link-duplicate, move the duplication, rotate it, duplicate it again to create a whole triangle. Also duplicate the material and change the Mapping Location values in order to delay the light:


To make it LOOK smooth, select the object, hit 'W' and select 'Shade Smooth'

To ADD POLYGONS, you can optionally select all faces (in face select mode) and hit 'W' then 'Subdivide' This will quadruple your face count. Once that's done, you might want to hit 'W' then 'Smooth' (which actually moves vertices to achieve a smoother mesh).

Or, you can go add a Subdivision Surface Object Modifier, adjust the 'view' and 'render' values until you like the mesh. Apply the modifier to get back to a fully editable mesh again.


Creating clear gel pill having translucency issues

Apologies for what will now be a question others may not have, my issue was that I had a mirror modifier on both halves of the pill so I am assuming the problem is similar to the Z-Fighting @haarigertroll shared but not positive. I removed the mirror modifier and the issue is gone. Thanks to all who gave input.


I think the only way to do that is to use a python script to adjust and render each frame.

import bpy

res_landscape = [1920,1080]
res_portrait = [1080,1920]

frame_res = {
    1: res_landscape,
    2: res_landscape,
    3: res_portrait,
    4: res_portrait,
    5: res_landscape,
    }

scn = bpy.context.scene

for f,r in frame_res.items():
    scn.frame_set(f)
    scn.render.resolution_x = r[0]
    scn.render.resolution_y = r[1]
    scn.render.filepath = '//renders/image{:03}.jpg'.format(f)
    bpy.ops.render.render('INVOKE_DEFAULT', write_still=True)


The rays in that image are actually most likely diffraction spikes caused by the aperture in the lens. To simulate that, you might try using the glare node:

Note that it helps if you have a very bright light source for the glare node to pick up on. Sun lamps are pretty good for this, but won't show up in the render directly. In the above example I made a refractive plane for the sun lamp's light to pass through, allowing it to be seen by the camera.


Scale not centred on selection or origin

Your scale is always relative to the location of the 3D cursor when you have it set as the pivot point. Place your cursor in the center of the selected section and try again. Type [SHIFT-S] and use "Cursor to Selected". Make sure your pivot point is set to 3D cursor. Then the selected vertexes will scale as you are expecting them to.


There is no keyframe at frame 26. Because you seem to have imported a 30 fps animation into a 24 fps project, a lot of keys are not on full frames.

The strange movement is the result of interpolation of the root bone, the hip.

The curves of the hip bone show the sudden change.

You can take any of the adjacent keys and move them onto the interpolated frame.


How can I make a Voronoi fracture in Blender?

The Voronoi texture node can be set to output 'Position', (The position of the feature-point of the cell, in the space the texture is given,) and 'Color', (a random color per cell). These numbers let you make switches, in a similar way to this answer.
First, the Kintsugi cracks, as described by @Chris:

The 'Scale' input gives a general size of the fragments
The 'Thickness' input gives the thickness of the cracks
The fiddling about with division-by-thickness, etc. gives a 0-1 range of distacnce inside the crack-mask, so it can be put through a color-ramp to give the profile of the gold-bump.
The straight Black/White mask is sent off to be the factor between the gold, and background material.

The Texture Coordinate and Scale are branched off to keep a second, parallel Voronoi node in sync. with the above, distance-to-edge one...

The second Voronoi node generates the same pattern, but with different information. (Distance from feature-point, Position of feature-point, and random Color per cell.)
Here, we've tapped out the Red channel of the random color, which gives us a random number between 0 and 1 per cell. The 'Multiply Add' makes a crude sort of seed, to change the random options; keep the Multiply much larger than the number of choices. The result is a randomish number between 0 and 10 per cell.
The number can be used as a switch by cascading Mixes, between shaders, or colors, or anything else...

Above are a couple of entries. If the random number is less than 3, the output is the result of the mix so far. Otherwise, the new color. Then the mix is handed on down the chain. In this example, the switch is between image textures. The overall result is a random-image-per-cell.
The whole tree looks like this:

This is the sort of result:

A simplified version, mixing 5 colors..


Are mining systems suitable for use as a render farm?

Judging from Blenchmark, yes. I realize that it has been closed down for a while so its results should be taken with a grain of salt, but I don't think they're completely irrelevant.

The mobo you posted should work fine if you don't intend on using anything too powerful/modern. The PCI-E 2.0 slots may bottleneck the GPUs connected to it if you connect them to GPUs that have been designed with higher bandwidth PCI-e slots in mind.

As far as the smaller PCIe slots and connecting cables go, I don't think you'll get 16 GPUs hooked up to that. What is most likely going on is that multiple slots are connected to a single GPU using those cables. I'd also be wary of potential hardware/driver issues when doing so. However, I'm not familiar with that subject, so keep that in mind.


Light source automatically fitting to object

This solution is different to what you asked, but I think it gets the intended result.

The sun light itself will impact 'every' object without needing to be attached to every object. The sun has constant direction parallel rays regardless of where it is placed, unlike the other light sources that are relative to their position.  So for example, in the following three images, the sun is above, moved just right and then moved far below and yet they produce the same constant result for the object. For every other object I add in the scene, the same sun light properties will be applied.

Adding a light per object is most likely an overkill.

Above:

To the right:

Well below:


How would I approach creating "fall damage" in the game engine?

I don't know if you're accepting logic bricks answer, but you can simply have a property on the floor that the player can detect (or in some cases just sense for any collision at all). When the Collision sensor reads false, you can just make the player enter the "fall" state. You should be doing this anyway, so it won't be too hard to add a timer to sense how long the player has been airborne. You want to set it high enough so that the normal jump, or a jump slightly downhill doesn't activate it.

Next, remember, it's not falling that hurts people, but the ground. So when the player hits the ground, before wiping the timer, check the value. If it was over your fall limit, damage the player by a multiple of the remainder. (ie.falls 4 sec. limit was 2.5, multiplier was 3: damage the player by 7 health.) This is reliable, and the more you fall, the more you get damaged. Realistically, you would use an exponential function, but no-one likes falling 10 meters in a game and dying.

In the .blend, practice dropping the man from different heights.


It's working, make sure you have the latest 2.80.


can someone look at this blend file for a sec and tell me why its rendering black?

Yes.  In your collection Cabinets you have an object Cabinets that is a huge mess:

remove that object and the scene renders fine.


How change text of text node in animation node at different frame?

I can think of two ways to do it -

the manual way is to add an Integer List node and type in the length or offset you want to use for each string. The advantage is you can adjust the timing to taste for each string.

The automatic way is to use a Text Length node to use the length of the string to calculate the offset.