Retopo: Can we apply shrink-wrap to multires subdivisions?

After a few months I decided to revisit this and... I've got the answer!

It was right under my nose the whole time, right there in the interface - a button called 'Reshape'.

Reshape will... okay, I'll let the Blender Manual do the talking:

  Reshape - Copies vertex coordinates from another mesh. To use, first select a different mesh object with matching topology and vertex indexes,
  then Shift select the object you wish to copy vertex coordinates to
  and click Reshape.

So what's so exciting about this button and how does it further humanity's progress?

You can enjoy the flexibility of DynTopo and get great topology easily.

Here is the workflow:


Baking camera property drivers to keyframe

Quick script to bake camera data.

Bake a bpy.types.Camera object's drivers to keyframes.

Bakes all driven properties of scene.camera.data from scene.frame_start to scene.frame_end in frame_step steps.
Assumes there are no array type properties on camera
Leaves drivers intact, will need to be removed. (Currently code used to remove camera drivers crashes my version of 2.8, and doesn't work on 2.79) Keyframes trump drivers.  Remove manually if happy with result.

Test script

import bpy
context = bpy.context
scene = context.scene
cam_ob = scene.camera
cam = cam_ob.data
frame_step = 1
ad = cam.animation_data

f = scene.frame_start
if ad:
    while f <= scene.frame_end:
        scene.frame_set(f)
        for d in cam.animation_data.drivers:
            cam.keyframe_insert(d.data_path)
        f += frame_step


To my knowledge there isn't really a good way to do this from a single Blender process. But I will give a few suggestions how it can be done.

Option 1: Render in a subprocess

This can be done using render farm or net rendering software. The idea is that your master will then create the scene that needs to be rendered, save the scene to disk and use python to start a sub process to do the actual rendering.

Option 2: Construct the scene in a subprocess

A variant of the previous version where the master will create a python script with how to construct the scene and perform the rendering. You can then start blender as a subprocess to the the scene constructing + actual rendering. The subprocess can be stopped by python script.

Option 3: Sample Batch Rendering

With sample batch rendering you will render a number of samples. (15 for example) and after 15 samples when you want to continue you offset the seed and render the next 15 samples. and do that until all the samples have been rendered. During the rendering you can combine the renders using the compositor, python script or external image tool. You could also do that from a master blender process.

The open movie spring was rendered this way so at an early stage of rendering you could check if all textures could be found.


2.8 how to restore timeline cursor jump to left click

If you're in left click mode then Shift + right click will get the playhead to move the position you click.


PythonScript to load data as colored point-cloud

Updated:

This script will add the pointcloud data as mesh vertices, then create a low-poly icosphere as an instanced object on each vert (using mesh.from_pydata instead of bmesh as advised by BatFINGER).

Currently this does not use the UV data in the latter two columns in the data file. I've also scaled the coordiantes by a factor of 25 (can be changed in the script) to make everything more visible and easier to manipulate in the viewport. This script takes ~0.075 seconds on my laptop for the 10,001 verts in this file.

import bpy
import numpy as np
from mathutils import Vector
from time import time

t = time()
C = bpy.context

scale = 25

# Open textfile to numpy array and scale
pointcloudfilepath = '/Users/username/Downloads/point_data.txt'
with open( pointcloudfilepath ) as fh:
    data = np.loadtxt( fh ) * scale

print( f'vertcount = {len(data)}')

# Create and arrange mesh data
verts = [ Vector( data[i,:3] ) for i in range(data.shape[0]) ]
m     = bpy.data.meshes.new('pc')
m.from_pydata(verts, [], [])

# Create mesh object and link to scene collection
o = bpy.data.objects.new( 'pc', m )
C.scene.collection.objects.link( o )

# Add minimal icosphere
bpy.ops.mesh.primitive_ico_sphere_add( subdivisions = 1, radius = 0.05 )
isobj = bpy.data.objects[ C.object.name ]

# Set instancing props
for ob in [ isobj, o ]:
    ob.instance_type               = 'VERTS'
    ob.show_instancer_for_viewport = False
    ob.show_instancer_for_render   = False

# Set instance parenting (parent icosphere to verts)
o.select_set(True)
C.view_layer.objects.active = o

bpy.ops.object.parent_set( type = 'VERTEX', keep_transform = True )

print( f'Total time = {time() - t} seconds' )

I've used each sphere's location as material color in a simple shader, you can apply any other logic that fits your requirements better. Here's the node setup:

And final result:


I believe this is intentional. Other actions can trigger this behavior as well, such as switching to object mode and back instead of using undo.

I'm no developer, but I think I may know why this is the way it is.

First, the point of wireframe view is (usually) to be able to see through your mesh. It can also be quite handy to observe the structure of your mesh as well. However, the wireframe view can get very complex very quickly, especially when dealing with complex models. To help simplify this, Blender hides certain edges from display that it determines aren't adding much to the overall wireframe view. In object mode, this occurs as well. It's not too extreme usually, and there is an option to force Blender to draw all edges in Object mode, which can be found in the display panel of the Object tab in the properties panel.

It appears that this process of hiding certain edges is executed for certain operations only. Some of these include using undo, or switching modes. When adding new geometry, such as wit the loop tool or subdivide, it displays all the new edges.

The reason that the edge is determined to be 'not necessary to show' is that it doesn't really add anything to the wireframe view, since it could technically be removed and the resulting mesh object would be the same when viewed with solid shading. Another way to understand when an edge will be drawn or not is to view your object in solid view. If you cannot see your edge, such as in your case, it won't be drawn in wireframe view. If you make the edge meaningful in terms of it's contribution to the structure of you mesh, such as by moving the edge up along the Z axis, the next time you update the mesh, such as by switching modes, it will be displayed.

So to directly answer your question, it isn't a bug. I don't really know why you would need the edge to be visible in edit mode when using the mirror modifier though. If you do really need the edge to be visible for some reason, you can always click the little 3 vertex button at the top of the modifier, and that will draw all of the edges/vertices/faces like the rest of the mesh, as well as allow you to select them.


Setting keyframes with default linear interpolation

I also prefer Linear interpolation for my initial keyframes, and set is as the default for new keyframe points through User Preferences > New F-Curve Defaults > Interpolation:


Empty for a group instance is far away from the group

No need to apply scale and location of your objects, nor recreate the groups.

You need to manually set the center of your group, which by default if unspecified will be the world coordinate [0,0,0].

You can check this by selecting any object belonging to a group original (not one of its instances) and under the Properties Window > Object > Group see the coordinates there.

To manually set it to a desired location either introduce coordinates manually, or place the 3D cursor at the point in the scene where the center should be, press the small arrow at the desired group and choose Set Offset from Cursor


bpy.types.TOPBAR_HT_upper_bar.draw expects a draw function. Here is an example for how to replace the built-in draw function with your own:

import bpy

def draw_function(self):
    self.layout.label(text="New Custom Menu")

bpy.types.TOPBAR_HT_upper_bar.draw = draw_function


Centralizing properties updates in one function?

Make a generic function to create your update method.
There is another answer very similar to this by @pinkvertex could not find it.
Instead using one function as the update method, create a method factory to pass properties to.
Example code, and example run (pretty self-explanatory),
import bpy
from bpy.props import FloatProperty
from bpy.types import Scene

def update(prop):
    def update(self, context):
        print(f"Update {prop} of {self}")
        return None
    return update

for prop in ("prop_this", "prop_that", "prop_another"):
    setattr(
        Scene,
        prop,
        FloatProperty(
            default=1.0,
            name="Prop",
            update=update(prop)
            )
        )

Sample run.
>>> C.scene.prop_this
1.0

>>> C.scene.prop_this = 4
Update prop_this of <bpy_struct, Scene("Scene") at 0x7fc97bff8008>

>>>

Two things re question code,

The properties are assigned to the type, not as an annotation. Use
annotations in a class definition.
Cannot create a private variable prefixed with underscore.
 >>> bpy.types.Scene._prop = bpy.props.FloatProperty()
 Traceback (most recent call last):
 File "<blender_console>", line 1, in <module>
 ValueError: bpy_struct "Scene" registration error: _prop could not register because the property starts with an '_'


You need to reverse the curve's normals direction: select it, go in Edit mode, then right click > Switch Direction.
To display the normals, go into the Viewport Overlays and enable Normals:


Adding a vertex with control-LMB does not work on OSX - how can I fix that or work around?

I too had the same problem. I noticed that I had was using face select instead of vertex select. Changing that might help you. Good luck!


You need to install the latest Nvidia Driver for you graphics card. You can download them from  the nvidia website here: Mac Nvidia Drivers. After you have done this you need to restart blender and the CUDA option should be available under the System Tab in you User preferences.


Prevent arm from twisting when moving it foward

In Properties editor ‣ Bone there is a special section named Inverse Kinematics. You could adjust this on the bone you want to fix instead of adding a constraint.

https://docs.blender.org/manual/ja/dev/rigging/armatures/posing/bone_constraints/inverse_kinematics/introduction.html


Rigify, Model detaches from rig when animating

This has happened to me a few times. It is likely because vertex groups in the mesh are misnamed (wrong bones connect to certain areas), particularly left and right being mixed up.
The shrinking thing is strange. Did you make this animation yourself? Is it possible you animated the mesh's scale by accident?
There is a possibility that some physics simulation is also set up on the robot and is conflicting with the armature.
If none of this helps, please share the blend file, then someone will look at it and be able to tell you exactly what's going on.


Is it possible to drive the contents of an existing text object with a text file?

you will need 2 text data blocks.

a script
the text

some_text_body.txt

Commodi. Do laboriosam. Veniam aliqua modi, aperiam quo so velit. Duis
elit but consequat yet aspernatur. Anim quam incidunt and do. Irure.
Laboris modi and nequeporro aute. Ipsam laboris but minima, and amet
veniam.

Quo eu. Vel. Beatae sed magna yet perspiciatis. Aliquam nesciunt,
quam, and iste, minim, quaerat. Aute natus, or explicabo and odit
eaque but aliquam. Autem. Et dolores eos, laudantium, so ab,
molestiae.

script.py

import bpy
text_object = bpy.data.objects['Text']
text_object.data.body = bpy.data.texts['some_text_body.txt'].as_string()

to get this:

Some gotchas (Texts with sparse line breaks, how to reflow / wrap ? )

With the some_text_body.txt example above I manually added newlines by hitting enter where I wanted the text to drop to the next line. Hitting Enter puts an invisible character called newline (\n). Prior to that the text was one line per paragraph. The hidden newline character is often only present at the end of a paragraph or as a single character on a line to denote a line of only white-space.

The difference looks like this:

Same text different reflows:

Unfortunately the reflow / text wrapping isn't done automatically for any of the proposed methods. see:

You can set the width of text box to automatically reflow to the next line. This is found in the Font object data panel.

And that's probably fine for most stuff, but it doesn't appear to do hyphenation on words. In that case you'd look at the Python utility module called textwrap to help reformat text with a given line length measured in characters.

import textwrap
import bpy

text_object = bpy.data.objects['Text']
text_str = bpy.data.texts['some_text_body.txt'].as_string()
new_body = "\n".join(textwrap.wrap(text_str, width=80))
text_object.data.body = new_body

But sadly this doesn't deal with the drop line in the middle..see:

then you use something like this:

import textwrap
import bpy

text_object = bpy.data.objects['Text']
text_str = bpy.data.texts['some_text_body.txt'].as_string()
text_array = text_str.splitlines()

final_list = []
for paragraph in text_array:
    final_list.append("\n".join(textwrap.wrap(paragraph, width=80)))
    final_list.append('\n')
text_object.data.body = ''.join(final_list)


How do I change the name of an Armature using Python?

bpy.data.armatures["Armature.001"].name = "Armature" should do the trick, but keep in mind that the ".001" was added because of an existing data-block that already had the name "Armature".
If the command is executed and the original data-block with the name "Armature" still exists, then that one will get the suffix so that the names are still unique.


How to map a pose to the restpose of another rig with same topology?

This requires a lot of matrix math which is complicated by the fact that the mathematical relationship between the various python-accessible matrices and fields is almost undocumented.

Here is an excerpt from http://web.purplefrog.com/~thoth/blender/python-cookbook/pose-match.html that should accomplish your mission:

import bpy
from mathutils import *

def matrix_scale(scale_vec):
    return Matrix([[scale_vec[0],0,0,0],
                   [0,scale_vec[1],0,0],
                   [0,0,scale_vec[2],0],
                   [0,0,0,1]
    ])

def matrix_for_bone_from_parent(bone, ao):
    eb1 = ao.data.bones[bone.name]
    E = eb1.matrix_local # * Matrix.Scale(eb1.length,4)
    ebp = ao.data.bones[bone.name].parent
    E_p = ebp.matrix_local # * Matrix.Scale(ebp.length,4)
    return E_p.inverted() * E

def matrix_the_hard_way(pose_bone, ao):
    if pose_bone.rotation_mode == 'QUATERNION':
        mr = pose_bone.rotation_quaternion.to_matrix().to_4x4()
    else:
        mr = pose_bone.rotation_euler.to_matrix().to_4x4()
    m1 = Matrix.Translation(pose_bone.location) * mr * matrix_scale(pose_bone.scale)

    E = ao.data.bones[pose_bone.name].matrix_local
    if pose_bone.parent is None:
        return E * m1
    else:
        m2 = matrix_the_hard_way(pose_bone.parent, ao)
        E_p = ao.data.bones[pose_bone.parent.name].matrix_local
        return m2 * E_p.inverted() * E * m1

def pose_to_match(arm, goal):
    """
    pose arm so that its bones line up with the REST pose of goal
    """

    matrix_os= {}
    for to_match in goal.data.bones:
        matrix_os[to_match.name] = to_match.matrix_local
        #print([ "matrix", to_match.name, matrix_os[to_match.name] ] )

    #xyz' = s * m * m(parent) * xyz

    for to_pose in arm.pose.bones:
        if to_pose.parent is None:
            len2 = arm.data.bones[to_pose.name].length
            len1 = goal.data.bones[to_pose.name].length
            to_pose.matrix = matrix_os[to_pose.name] * Matrix.Scale(len1/len2, 4)
        else:
            # we can not set .matrix, because a lot of stuff behind the scenes has not yet
            # caught up with our alterations, and it ends up doing math on outdated numbers
            mp = matrix_the_hard_way(to_pose.parent, arm) * matrix_for_bone_from_parent(to_pose, arm)
            m2 = mp.inverted()* matrix_os[to_pose.name] * Matrix.Scale(goal.data.bones[to_pose.name].length, 4)
            loc,rot,scale = m2.decompose()
            to_pose.location = loc
            if 'QUATERNION' == to_pose.rotation_mode:
                to_pose.rotation_quaternion = rot
            else:
                to_pose.rotation_euler = rot.to_euler(to_pose.rotation_mode)
            to_pose.scale = scale / arm.data.bones[to_pose.name].length

#
#
#

pose_to_match(bpy.data.objects['gamma'], bpy.data.objects['beta'])


how can i add backgrounds and animate them in blender 2.80 2d animation?

If you added it in as a reference image, that might be problem. Try adding a plane in the back and add the background on that. You can do that in the material options.


I recommend you for using bake animation. The follow step :

First, you set the object to follow the path by adding it on the "Add Object Constraint"
Then, you set the thing, like control the speed (actually just control the frame), direction etc
Bake animation
The switch to another path using dope sheet.

How to bake steps you could check this link :
How can a path animation be used as an action in the game engine?

Hope this help :)


How do I fix these mesh deformations I get when exporting from Blender to 3DS Max?

It is probably because you haven't defined the deformation in the node editor. I have a problem also getting the deformations in logicTrees/node-editor, but I am quite sure this is it. hf


Rigify error "NoneType" "Bones" when trying to Generate Rig

The problem is that for one reason or another the "Rig Type" is missing from your spine. Sometimes that happens due to a bug in Blender itself.
The fix is easy. In your MetaRig select the bone I have highlighted in the image. Make sure you're in Pose Mode! Go to Bone tab and under Rigify Type choose spines.basic_spine
Make sure your generated rig is visible and press Generate Rig. That should fix the non type error.

If you're interested, the error itself comes from the head/neck, because it has the "connect chain" option ON. This requires it to be snapped to another chain of bones. But since the Rig Type was missing, Rigify just ignores the Spine bone chain. And that produces the error.


Windows:
https://mirror.clarkson.edu/blender/release/Blender2.81/blender-2.81a-windows64.msi

Windows - Portable (.zip): https://mirror.clarkson.edu/blender/release/Blender2.81/blender-2.81a-windows64.zip

macOS:
https://mirror.clarkson.edu/blender/release/Blender2.81/blender-2.81a-macOS.dmg

Linux:
https://mirror.clarkson.edu/blender/release/Blender2.81/blender-2.81a-linux-glibc217-x86_64.tar.bz2

I got these links using the tool Wayback Machine (https://web.archive.org/). It has a saved Blender download page from few days ago (https://web.archive.org/web/20200125185852/https://www.blender.org/download/). When you click on download it appears to you a "thank you" page, then there is a link on a text on the bottom of that page ("Your download should begin automatically. If it doesn't, click here to retry."), which leads to an official mirror download. You click on it and the download will start.


Can I merge objects without messing up their modifiers?

Although some modifiers can be applied to specific parts of a mesh via vertex groups, when you join them you will find that the active object's modifiers always overwrites the others.

You will need to apply the modifiers before joining the meshes, or add them afterwards using vertex grouping. Sadly you will not be able to edit the modifiers after applying, but they will not be messed up by joining.


The video author is using Blender 2.77a, you are using 2.79. This is important since Blender got a few tweaks on importing Collada files.

I am using 2.79b and tried to replicate your problem. I don't get the same problem but I do get issues when importing Collada if I do it the way its done in the video. I was able to solve it with this setting:

This fixed my issues, I hope it fixes yours.

Steps taken:

Exported character from MakeHuman as Collada file with Mocap skeleton
Imported Collada file in Blender with the "Auto Connect" setting
Selected the skeleton. Made sure its in Object Mode
In the MakeWalk v1.1.0 panel, pressed Load and Retarget and selected the Mocap file
Played the animation

It is also worth noting that I downloaded the "Daz friendly" version of the Mocap Files.


Texturing each object separately VS all in the same texture file

For re-usability sake I would advise texturing and unwrapping each object separately and independently.

That would make it easier to recycle assets for future projects without bringing useless information attached.

You could then reuse only say the Fan and Statue asset in another project easily without bringing the Normal and Specular data of say the Extinguisher and TV and every other object with it, needlessly being loaded into memory and possibly ruining performance of your scene.

It will also make it a lot easier to edit each object separately without having to worry about overlapping the UV space reserved of any other asset, and recalculating UV, or Normals or baking data without having to bake all of them.

If you are absolutely sure this is the final version of your assets, you won't be editing or improving them more in the future, or you plan on always using all or most of the assets at once in all projects then it might be worth the hassle.

If performance or available memory is really a strong concern (say mobile platforms, low end devices, etc.) it may also be worth the trouble of joining them all.

I am not in the game making industry, and this may of course be a bit of a subjective matter, so opinions may vary.

EDIT: An additional concern may be object variations, or like if you want to modify only one single object.

Say you have a red extinguisher, but now you want a yellow one, or worse want to used both in your scene simultaneously. Now you have to edit the texture with all objects lying around; and if you want to keep both colors you now have two huge duplicated textures, which will have to be loaded entirely into memory just for a small part of one of them.


Why does the difference modifier not work on objects with many vertices, but will on a subset of those vertices?

I solved my problem by simply subsurfing the cylinders I used to make the larger object.

Explanation:

In the original design, you can see that the circular faces are whole (not subdivided into quads or triangles). In search of another solution using the knife projection tool, I discovered that it does not work well on whole faces, and subdividing the face was the solution there. It then occurred to me that subdividing faces might help the boolean modifier approach. In fact it did work: the only other caveat was that the top surface of the cylinders aren't subdivided by the Subdivide command - you have to use the Subdivide Surface command first.


How does the texture know exactly where its supposed to be applied?

Do a google search for "UV mapping."  "UV"s are texture coordinates that Blender or other software uses to know where to apply the texture.  That texture you have happens to coincide with the UV coordinates of the cake.  Try another texture and you'll see it doesn't match at all.

Here are a few links to get you started:
https://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/UV_Map_Basics
https://en.wikipedia.org/wiki/UV_mapping
https://www.creativebloq.com/features/uv-mapping-for-beginners


You installed the wrong file; you need to install fSpy-Blender-1.0.3.zip
 (or newer) from the Releases page.

The file you're using, fspy-Blender-master.zip is likely the source code and doesn't work as addon.

It's not very clearly stated on the page and it's easy to download the wrong file(I had the same issue :)


Will a character work well with animation if it wasn't made with t-pose?

I would not stick to a concept if it doesn't fit your needs. If your character's limbs can't even reach t-pose it's moot anyways. The main issue you might run into is axis alignment. It is a good idea to stick to 1 axis for bone directions, but it can't ever be possible in a complex character.
If your character's rest pose is different from the t-pose, use the one that's closest to what the char. does most of times. But note that IK constraints are easier to set up in t-pose.
I would suggest using none-t-pose and pose a few extremes, if there's no problem, there likely won't be one in the future.


How to prevent inside faces and non-looping edges when mirroring?

The inside faces are probably due to the vertical edge at the far corner of your base model. Deleting that edge (and associated faces) should help. You don't need that geometry in your model, anyway.

For the surface vertices, did you try "remove doubles" with a sufficient margin to collapse the unwanted doubles, while keeping all others. It helps if your edge vertices are exactly on the XZ or YZ plane.


This setting should do:

So "pi/2" or "-pi/2" for the roll. And "Roll angle" for the roll angle source.


Actually, it doesn't require python. It requires the ... servo motion actuator:

Use the LinearVelocity to set the maximum speed, and the force limits to set the maximum acceleration.

For anything more complex than this, yes, you will need python.


Project plane normal in z direction onto plane.

Here is a test script. Adds a randomly (random 0 to 1 radian rotation on x, y, z) rotated unit circle ngon at cursor, and places an empty on global edge low point.

The normal of the plane is its local z axis.
Global -z axis is considered down.
Find The vector intersection of the line from tip of normal in -z
direction to the plane. Used mathutils.geometry.intersect_line_plane(...)
Result is the "downhill" vector.

lowest point on circle edge will be
centre plus the normalized (unit length) downhill vector.

Test script:

import bpy
from random import random
from mathutils import Vector
from mathutils.geometry import intersect_line_plane as ipp

bpy.ops.mesh.primitive_circle_add(fill_type='NGON')
ob = bpy.context.object
ob.rotation_euler = Vector(random() for axis in 'xyz')
z = Vector((0, 0, 1))
bpy.context.scene.update()
mw = ob.matrix_world

n = (mw.to_3x3() @ z).normalized()
p = mw.translation
v = ipp(p + n, p + n - z, p, n)
bpy.ops.object.empty_add(location=p + (v - p).normalized())


How to generate a cylinder with a hole except by knife tool and Boolean methods

For instance :

Starting from a circle :

Add a circle
In edit mode (Tab) extrude E and stay in place (Esc or RMB)
Scale S
Select all and extrude again E

Or from a cylinder :

Add it
Remove top and bottom the faces
Then same principles as above

Or using curves :

Add a plane
Keep only the edges X the 'only faces'
Back to object mode convert it to a curve Alt+C then curve from mesh
Add a bezier circle curve
Set the previous plane as bevel object
Tuning : move the plane vertices (or scale or other) to make the hole appear (here in edit mode, select all then grab along X)

Another one !! Using spin tool :

Add a plane
Keep only the edges
In edit mode offset it (and eventually scale it)
Go in front view (viewing the plane on its side)
Then spin tool Alt+R, set the rotation, the amount of steps
Remove double (for the last step which overlaps)

Or with 2D curves (but not only quads here):

Add a bezier circle
Set it to 2D
Duplicate, scale
Convert to mesh
Extrude

Modifiers and "non destructive way" :

An eccentric plane
Solidify
Array
Simple deform with 'bend'


Complete list of facial shape keys to make?

There is no checklist. It depends on what you do and what you need. You can rig things in different ways and may not even use shape keys at all or there can be hundreds of them. "Good" is a very abstract thing without any context. No matter what you do, the context of your situation should always dictate what you need. Just imagine how many different faces there can be in CG - aliens, animals, stylised faces, even inanimate objects can have faces in CG. Even if you are asking only about human faces they can vary greatly in detail, forms, age, artistic style and lots of other criteria and on top of that your animating needs may differ even more. There can be no checklist like you describe for all possible scenarios.


Volume absorption boosts light levels of scene and messes with shadows

I raised the max volume light bounces to 64 and that has solved the issue


2.8 - Is it possible to assign (override) a material to a whole collection?

You can override the materials from linked sources that are part of the same collection, just the same way you can override not linked ones.
In the scene context section you can find the options for override, you can select a single material and that will be used for all objects.

From the blender manual:

Material Override
Overrides all material settings to use the Material chosen here.
Examples of where this might be used:
To check lighting by using a plain diffuse material on all objects.
Render a wireframe of the scene.
Create a custom render pass such as an anti-aliased matte or global coordinates.


I don't know what is wrong with my python script

For global coordinates, multiply local coordinates by world matrix of object.

Data (obj.data) coordinates are in local space.  The global scene coordinates have an origin at (0, 0, 0) with no rotation or scale. An object's origin is its local coordinate (0, 0, 0).  An object's location is the location of its origin.

Latitude and longitude on earth could be considered a local coordinate system, with origin (0, 0) ... It's just some arbitrary point on the equator.. It tells us nothing about where we are in the universe, that the axis is tilted towards the sun...

Can calculate a global coordinate from any local coordinate by pre-multiplying the vector by the object's matrix world (obj.matrix_world) This accounts for any translation, rotation and scale on the object in global space.

When an object has no transformation, no rotation and unity scale, its world matrix is the Identity matrix.  Multiplying by the identity matrix is the scalar equivalent of multiplying by one.  In this case, and only this case, all global and local coordinates will be the same.  Will find a number of answers on here that don't take this into account.

Applying location, rotation and scale has the effect of making an objects matrix world identity, by converting all local coordinates to their global equivalent.

import bpy
obj = bpy.context.object
mw = obj.matrix_world
scene = bpy.context.scene
obj_mesh = obj.to_mesh(scene, True, 'PREVIEW')
local_coords = [v.co for v in obj_mesh.vertices]
print("total numbers of vertices generated = %d" % len(local_coords))
for local_coord in local_coords:
    global_coord = mw * local_coord
    bpy.ops.mesh.primitive_uv_sphere_add(size=0.05,
            location=global_coord)
bpy.data.meshes.remove(obj_mesh)

In case you missed it, the link provided by @tet_li in comments provides a detailed explanation of coordinates in blender.


Text does not stay center aligned in game engine

One obvious thing would be to convert it to a mesh. I recommend you keep a copy of the original object. Select your text in object mode, then hit Alt+C, and convert the text to a curve, then hit Alt+C again to convert the curve to a mesh.


Selecting the camera with Numberpad 0 brings up a strange box?

I'm not sure what you mean, by "Camera is looking at this box" - the box is the camera view - just zoomed out and offset because it is "locked" in it's viewing position. If you want to adjust your view relative to the camera view, you have
to disable "Lock Camera to View":


You're going to have to abandon the method used in that tutorial if you want a bent spring that looks natural. Using a lattice will not preserve its volume. Just the same, using a curve deformer on the final spring will also not preserve the volume — even if you try to get smart and use nothing but curves. I tried it! It doesn't work.

Here's the 5-minute walk-through of my method:

Make an 8-sided circle.

Select one vertex. Press V to rip it from the rest of the circle. Right click or press Esc to cancel the transform. You should now have a "belt loop" that looks like a circle, but is disconnected at one point.

Select one of the ends, turn on proportional editing in the "connected" mode, and set the falloff curve to "linear".  Press G to grab, press Z to lock it in the upward direction and viola! You are now stretching your spring! (Note: you need to scroll up until the proportion is greater than the circumference of the octagon. You want the bottom point to leave the floor. This is good because it means you linearly affected all the points.)

Add an Array modifier with "Merge" turned on, and "1" unit in the Z of the Relative Offset section.

Add a Subsurf modifier with the setting at 1. This turns the octagon shape into a circle shape.

Add your bezier curve and the curve modifier to the spring. For smoothest results, I set my modifier to affect "Z". Of course make sure that the spring object and curve object share the same location and that the first point in the bezier curve is at its center point.

Fatten the line of points up with the new Skin modifier! While we could have used a Bevel on a 3D curve, this method ensures that the spring has no volume until after the deformation takes place resulting in perfectly uniform wire. Set the shading on the modifier to "smooth"

Lastly, smooth the whole thing out with one last Subsurf. I like mine at a setting of 2 or higher.


The principle outlined in the video is the following:

Create a plane (shift+a mesh > plane) with default size/radius 1 and place it at 0, 0, 0
Create an empty (shift+a empty) and change its coordinates to -1, 0, 1
Select the plane
Add an array modifier
In the modifier settings, select Object offset and in the field below select the Empty (just like in the video)
Increase the count of the modifier to 4 and voilà
If you want to move your mesh around, either move it with the empty or hit Apply in the array modifier and the mesh will be independent from the empty but also you cannot modify the array modifier anymore.

Now there is a mirror modifier for some reason there. So before Step 3, add a mirror modifier and you will see no change. You have to go in edit mode and move the vertices to the right (or left), then you will see the mirror double. I didn't follow the tutorial so I don't know why he's doing this.

Simple technique, but it's really far from being intuitive ! Thank you for the video, I learnt what this object offset is all about. You can make all sorts of patterned shapes like cogwheels with this.


Why is my vault's bevel unevenly applied?

How do you get to Killarney?  Well, sir, I wouldn't start from here if
  I were you....

Just teasing.. I think some of this may have been be easier if executed before the array was applied. (Making an array out of arch-peak-to-arch-peak sections may still speed things up when adding detail?) This is a fix, rather than a solution, I'd like to know why the Bevel works the way it does.. whether the algorithm could be improved.

Make a copy of your existing path-curves (you can CtrlJ join them into one curve object to save time later) call it, say 'Miter Path'
Make a copy of your existing profile curve, and delete all but its flat base .. 'Molding Base'
Use the Molding Base as a the Bevel Object for your Miter Path. You now have a set of ribbons
With the ribbons anywhere you like in Z, select them, and then the Vault object. Put the (active) Vault into Edit Mode
From an orthogonal view down Z, hit 'Knife Project' in the Tool region. This will cut a set of edges into the vault where you would have liked the bevels to be.
There will be some extraneous vertices.. there are various ways of tidying them up ..  I selected one of them , then used Select > Similar > Number of Connecting Edges to find the rest, and then X > Limited Dissolve to get rid of them.
I also selected the penultimate vertices around the pole of the vault in order, hit J to make a ring of edges, and deleted the faces at the pole, assuming there will be some kind of boss or rosette there in the end.
Now you can delete the faces between the knife-projected edges and CtrlE > Bridge Edge loops creating the flat bevel to accommodate the molding. CtrlR cut a loop down the middle of each bevel.
ShiftD Duplicate the central loops of the bevel,
P separate to a new object, and AltC convert to a curve - U resolution 1 - this will be your new path for the molding profile
Move the origin of your molding profile to the center of its base - (this point will lie on the path). Use the molding profile as the Bevel Object for your new Molding Path. You may need to rotate it in Z in Edit Mode to get the molding to face the right way.

I apologize  for the lack of step-by step illustrations - everything important is done by step 5.

Alterations on Layer 11.


Blender cycles normal map not generated correctly

Add some ray distance to your baking, it will use the "inside" of your mesh.


How to change the colors of a two-color texture?

Set up the nodes as pictured below. Add a RGB to BW node to make your texture work as a mask for two Diffuse shaders. Set up the colors for Diffuse shaders.

Flip the input sockets of the Mix Shader for a reverse result.


Can't use "L" Key to select an object, selects vertices instead.

It could be that you have double vertices; multiple disconnected vertices in the same location.

If each face in the left foot is separate, it would result in symptoms like these. Try removing doubles by selecting everything (A) and pressing W> Remove Doubles.


In your mirror modifier, turn on "Clipping";

When you do, any virt that touches the center won't go beyond it (through the bound of the middle of the model, determined by the origin of the object), and those verts will also "stick" to the center (so you don't rip your model apart when moving or scaling)


Dimensions changed cube (prism) is still a cube when UV unwrapped

UV unwrap is here applied on an uniformly scaled object.

If the scale is non uniform (for instance X=1, Y=1, Z=2), the unwrap will be applied on a non scaled version of the mesh.

This can be seen if you stretch the information panel a bit (on top of this picture) :

So as a solution :

Use Ctrl + A
And select scale
Then unwrap again

Concerning the reason (as you asked in the comments of your question), I presume this is due to the fact UVs are part of the mesh data and scale is relative to the object data. So this allow to have uniform UV for several objects sharing the same mesh data, but having different scales.


Origin of selected group of vertices is in odd position, why?

From your screenshot I see that you have selected 147 vertexes.

But it's looks like your circle has 32 vertexes. So I conclude that some of vertexes are off screen. But if it's not so, I think some vertexes are "doubles", that means you have several vertexes on same position. In this case you can:

Remove double vertexes (menu W -> Remove Doubles)
Or use Bounding Box center instead of Median point as a center of transformation (,):


Object Organization - Hierarchies, collections, groups, empties?

I would suggest using collections for grouping objects together.  It's flexible, and very orginizable.

also, there is no reason for selecting a different shaped empty except for personal preference on shape, (or for selecting a shape that fits the object like you mentioned in the question.)

and groups are now obsolete.  They were used in 2.79 and backwards.  Collections are the new and improved thing.


How to draw straight lines of a given length

Since all your measures are integers and all your angles are 45 degrees, you can use Precision control.

Once you have started an extrusion (E) the displacement is displayed at the bottom of the 3D Viewport:

(image from here)

Keeping an eye on it, before accepting the new position, you can hold down Ctrl (while moving the pointer) for "snapping" the transform to an integer number of grid units, or 10 grid units: it depends on your current zoom level. If you need a 10 times finer precision, hold Ctrl and Shift together.

For 45 degrees displacements, make sure that Dx and Dy are the same value, apart from the sign.

Once you have done, you can measure distances and angles using the MeasureIt addon.


Adjusting Freestyle in the Blender compositor

Yes, it's possible. I mostly render my freestyle stuff on a separate Freestyle-Renderlayer and recombine it with the ordinary one in the Compositor. If you just want to rerender your FreeStyle strokes you can just render the Freestyle Renderlayer.

I've only done it in Cycles so far, so the following is only for Cycles.

To separate it:

Activate Freestyle in Render Settings > Freestyle.
Tick "Transparent" in Render Settings > Film to have the background transparent.
Create a new Renderlayer (eg. "FreestyleLayer").
Create the Freestyle settings you want.
Override samples with 1 (for example).
Turn off "Use Environment", "Use Surfaces" and "Use Hair" in the Layer panel. That way basically nothing gets rendered except the Freestyle strokes.

In the ordinary RenderLayer:

Delete the Freestyle LineSet so you don't get any strokes here.
Activate the "Environment" pass, so we can readd the background if we want to (because we just made it transparent above).

So far for separating. We now have a renderlayer that's transparent and only the Freestyle stroke will be visible.

To recombine it, do it like this in the Compositor:

Note that the Environment Pass is also readded here. This can just be left out if one doesn't want it.

Hope this helps.


You need to go to the "Properties" panel, "Render" tab, subsection "Film" and check "Transparent".

Also, keep in mind that animations should first be rendered to individual images, to avoid file corruption, and joined using something like Blender's Video Sequence Editor.
This is demonstrated in this video.


How do I avoid rendering glitches from overlapping faces?

As a general rule of thumb you should never have overlapping faces as you'll almost always get the artifacts you're seeing.. You're better off removing the overlap.


Alrighty! Looks like somewhere the amdgpu-pro drivers were breaking. I uninstalled them, ran 'apt-get autoremove' then rebooted the system. Blender's working again on the built-in drivers.


How to keyframe changes to assigned materials in Cycles

It is not possible to keyframe changes to structure (eg adding/removing nodes or links).

You can achieve the same effect by using mix nodes/mix shaders and keyframe there factor. Or create many different materials and keyframe the material slot.


Opening a blender file during python script execution without changing context

Found a WM hack based on this answer that seems to work. Some operators still complain about "PyContext 'blend_data' not found", but this doesn't seem to result in problems so far. Still feels a bit hacky though.

def fix_context():
    """Fix bpy.context if some command (like .blend import) changed/emptied it"""
    for window in bpy.context.window_manager.windows:
        screen = window.screen
        for area in screen.areas:
            if area.type == 'VIEW_3D':
                for region in area.regions:
                    if region.type == 'WINDOW':
                        override = {'window': window, 'screen': screen, 'area': area, 'region': region}
                        bpy.ops.screen.screen_full_area(override)
                        break

Edit: this works (with --background) but only if there's running an X server for the current user. Feels like there's some gui hacking going around when Blender python scripts are running background... Running on an X-less server gives a segfault.


How to rotate/translate a part of body without afecting the rest of it?

You must have activated the Proportional Editing option on the bottom horizontal menu bar. It allows you to influence the closest vertices/edges/faces.


How to scale the edges along a curved surface

Creating custom orientations will help you in many situations where you have to move or scale many faces/edges/vertices along directions that are off the usual orientations.
However, if you only have one face like the one in your screenshot it is a bit easier. And if you have multiple ones pointing in different directions, creating a custom orientation for each of them might be very uncomfortable.
Instead you can select the face and set the orientation to Normal (which would also be used if you created a custom orientation) and then scale along the face normal's X or Y axis with simply using S > X (or Y). You don't have to press the key for the axis twice - that will use Global orientation.
It's only important that you use the face selection instead of only selecting the opposing edges you want to scale, because this might result in an unwanted orientation (see picture on the left).


Why do my faces look as if normals are inconsistent when they are consistent?

Some of your faces are shaded "smooth" and others "flat", select your mesh and hit either flat or smooth under the Tool-Menu -> Shading


There's no officially prescribed way that I'm aware of, but this is a quick way to do it;

In these example, I have one object with a lot of loose parts that are all, themselves, manifold.

To modify a single object with multiple meshes

Enter edit mode on the object with Tab;

Change your pivot point to "Individual Origins";

Scale the meshes down to the desired separation;

Set the pivot point back to "Median Point"

Scale the meshes back up to the desired display size;

To use separate objects, one mesh each

I hit space (or F3, or whatever your search key is set to) and search for "Separate";

Then, I select "loose parts";

Now, search for, and select, "Set Origin"

Then select "To Geometry";

Each mesh will have it's own object. Now change your pivot point to "Individual origins";

Now, with all the objects selected, scale them down to a desired spacing;

Change your pivot point back to "Median Point", then scale up to the desired final size;


Selecting parts of mesh for UV with mirror modifier?

You can select those parts if you apply the modifier in object mode as shown below:

If you need the modifier and want to keep it, whatever you do in the UV Editor will be mirrored.


Extracting vertices data after transformations

Please search here at BSE for

matrix_world

as in

worldc = o1.matrix_world * vertex.co


How to turn off transparency on mesh, cycles render

It looks like you set the Maximum Draw Type to Wire on that mesh. Set it to Solid or Textured (the latter is the default).

I can't be absolutely certain that this is it, as your screenshot doesn't show that part of the UI, but since you're not in wireframe viewport shading, I'm guessing that this is the problem.


Projection texture painting, is it possible to swap images after applying brush?

I would suggest using 3 uv maps, on for front projection, one for side projection, and one for regular unwrap with seams to avoid stretch. Here each texture is set to a different slot, and a black image is set as stencil and intensity between them, and that one is painted with white to reveal the image below. In this case, you can then replace the texture use for the front view or the side view and the stencil will affect it the same way.


How to bend into a circle a series of columns rotated at 45 degrees

If I understand correctly, your difficulty is in finding the correct axis and origin point for the bend deformation.
If that's the case, I would create an empty and use it as the origin of the simple deform modifier:

Then you can just move and rotate the empty until you find the correct position for the deformation you want.


Rigging two-handed weapon in Blender 2.8

Create a root bone for your gun, create 2 children bones, one for handle 1, one for handle 2:

In Pose mode, give each of your hand controller a Child Of constraint, with the handle 1 and handle 2 as Target, click on Set Inverse:

Move each controller close to the handle, move the fingers so that it looks like they are grabbing the handles, keyframe:

Move your gun, the hands should follow:


I'm not entirely sure I'm clear on what your issue is. But any time you want to create a custom transform orientation, you can follow the instructions given by Carlo in the link to the Blender manual above easily enough. However, if you also want that custom transform orientation to be aligned with a face normal, you can press ⇧ ShiftNUMPAD7 to force your current camera view to instantly snap to a facing that views the currently selected polygon face head-on, allowing you to look straight down its normal's z-axis. Once this camera orientation is achieved, you can create a new custom transform orientation based on it. Then you can transform along that face's normal z axis, no matter how the object it belongs to is oriented in space.


You probably need to switch preview modes. Press Z in the 3D viewport and pick either "Material Preview" or "Rendered" from the pie menu.  The Preview Modes and Viewport Shading Options can also be accessed from the 4 circles and the little down arrow, respectively, at the top right of the viewport:


Blend4web has a tool called Normal Editor. It has a feature, that may help.

It makes custom vertex normals based on nearest vertexes:

After this operation blender creates custom vertex normals, and if you change something in geometry normals will not update, until you not delete custom normals. To delete them goto mesh settings and click this button:


Adding a 'SUN' via lamp_add() actually adds a 'HEMI'. Bug?

Update method on renderman.renderman_type

Setting renderman_type to SKY sets the lamp type to 'HEMI' See renderman code

    if light_type in ['SKY', 'ENV']:
        lamp.type = 'HEMI'

This is not a bug.  bpy.ops.object.lamp_add(type='SUN') adds a lamp object of type 'SUN' named "Sun",  which is pretty easy to test.


Affect explode modifier with force field

The explode modifier uses the particle system to guide the shards. To have the shards remain in place, set everything under Velocity and the Gravity influence under Field Weights in the particle system to zero.

Now the particles won't fall due to gravity, and they will have no initial velocity, but they can still be affected by other force fields.


Edgeloops are made of quads

If the tool doesn't suggest an edge is becuase those faces are not part of the edgeloop.

Cutting the faces with a boolean operation to create the hole transformed some of the quads in n-gon, that is currently breaking the quads flow around the section.


Moving of an mirrored object does not give the desired outcome

In object mode, blender considers objects with mirror modifier a whole/complete object, just like a normal object. Therefore when you move it, you're moving the whole thing. However when you switch into edit mode, your mirror modifier start working as you edit, using the origin of the object as mirroring center pivot. Beware that the modifier will take object rotation into account, meaning it does not uses global axis as its mirroring pivot.


python : bpy.context.object vs bpy.context.active_object

Some side cases.
There are some side cases.  If we add
print(context.object, context.active_object)

Edited draw method
    def draw(self, context):
        print(context.object, context.active_object)
        layout = self.layout

        obj = context.object

        row = layout.row()
        row.label(text="Hello world!", icon='WORLD_DATA')

        row = layout.row()
        row.label(text="Active object is: " + obj.name)
        row = layout.row()
        row.prop(obj, "name")

        row = layout.row()
        row.operator("mesh.primitive_cube_add")

to the draw method of the Text Editor > Templates > Python > UI Panel Simple run the script, mouse over the panel and add or select sphere, it will spurt
<bpy_struct, Object("Sphere") at 0x7f05669b3c08> <bpy_struct, Object("Sphere") at 0x7f05669b3c08>

into the system console.
If we pin the sphere to the properties area, and add or select the Cone

will become
<bpy_struct, Object("Sphere") at 0x7f05669b3c08> <bpy_struct, Object("Cone") at 0x7f05669b6008>

ie in the context of the properties space, pinned to the sphere, that is the context object.  The Cone is the context active object.
Also applies to an operator invoked from the pinned panel.


How to set frame range independently for each camera

Property getter and setter.

Quick test script.  Wires up a property on the scene, that using uses a get and set method to retrieve data from scene camera if set. The frame start and end properties of the scene are set within the getter.

Ultimately would recommend a corresponding boolean property to turn behaviour off or on.  Changing the output folder based on camera. This will avoid overwriting overlapping camera frames.

import bpy
from bpy.props import IntVectorProperty
context = bpy.context
scene = context.scene
'''
# set defaults test code
cam_objs = [c for c in scene.objects if c.type == 'CAMERA']
for c in cam_objs:
    c["cam_range"] = [1, 250]
'''
def get_res(self):
    if self.camera:
        fr = self.camera.get("cam_range", (1, 250))
        self.frame_start, self.frame_end = fr

        return fr
    return (0, 0) # no scene camera

def set_res(self, value):
    print("setting", value)
    self.camera['cam_range'] = value

bpy.types.Scene.cam_frame_range = IntVectorProperty(
        name="Camera Frame Range",
        size=2,
        get=get_res,
        set=set_res,
        )

def draw_cam_range(self, context):

    scene = context.scene
    if scene.camera:
        layout = self.layout
        '''
        if scene.get("cam_range"):
            row = layout.row()
            row.prop(scene.camera, '["cam_range"]')
        '''
        row = layout.row()
        row.prop(scene, "cam_frame_range")

bpy.types.SCENE_PT_scene.prepend(draw_cam_range)

Note using this method fires off a lot of depsgraph events while displaying the panel.

On the possible duplicate How can I make a camera the active one?  the logic here is counter. Setting frame range from active camera as opposed to setting active camera from frame (marker).


Using Plane Mesh as LightSource/Hide in Render?

You tell Blender not to render any camera rays, meaning rays that go from the camera straight to the object. To do so you have to mix an emission shader with a transparent shader. Then you need the light path node. If a ray is a camera ray you'll want to use the transparent shader. If it isn't you'll want to use the emission shader. So you have to use the "Is Camera Ray" as the mix node's factor.

Node setup:

Example render without node setup:

Example render with node setup:


Tris can be a solution if it doesn't cause any problem when you bend the object, you need to test it, here is another solution to go from 3 faces to 1:


Access new objects location after separation of mesh?

After you separate the meshes their origins are still the same as when they were together. This is normal behaviour. After you separate the meshes into its parts you need to set origin to geometry for every newly created mesh.

import bpy

for object in bpy.context.selected_objects:
    bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY')  # set origin to geometry

After you do this you will be able to successfully query the new locations.


Is there a way to animate a material differently for object that has it? I want these blossoms to turn pink one after another

If you just want to stagger when the blossoms start changing colors, you can use a node set up like this one:

The value node is keyframed to 0 at frame 1 and 2 at the frame when you want them to have finished changing colors.
This is what that would look like over 60 frames @ 15fps.
The random input generates a number between 0 and 1. That is our offset for when the object's color starts changing. The color ramp takes an input between 0 and 1 (if the input is greater than 1, then it is treated as 1) and outputs a color based on that. If you didn't stagger the color changes, then you could just animate the color ramp input from 0 to 1. The subtract node is used so that the random number from the object info node delays when the animated value (which is animated from 0 to 2, so that even if the random value is 1, at the end of the animation, its input to the color ramp is 1) reaches 1, which is the final color on the color ramp.
Also, I would recommend going into the dope sheet, selecting the key frames for the material, and setting the interpolation to linear.
That said, I'm not sure how to ensure that the blossoms change colors only one at a time without using multiple materials.


Blender 2.8 Subsurf Modifier really weird

Most 3D Lego parts use one of two methods to get sharp corners and distinct lines. Mecabricks and LDraw .dat parts usually have an edge split (generally at 30 degrees). In addition to this, if a surface is too flat for the edge split to affect it (or if it is the general way the parts are constructed), a lot of times, Lego parts will be made up of individual components (whether they are individual objects or just disconnected meshes in one object seems to depend on where the part is from):

This was a from an LDraw .dat file (which generally have each of the components as a separet object):

If it's an edge split doing it, all you have to do is go into your modifiers and turn it off. If you are dealing with a bunch of disconnected meshes/objects, you may want to merge objects and remove your doubles (since the part you're showing is really simplistic, I think any quality loss from the doubles' removal is negligible.) After doing this, try using loop cuts, bevelling, or insets so your edges don't get curved.

As a side note, I feel I should mention, pretty much all the 3D Lego parts I've seen use tris which don't subsurf well as shown below, so you may want to either use smooth shading and no subsurf at all or do some retopology before applying the subsurf.


How to get rid of this circle looking from the render?

The problem has resolved. It is because of the texture image is 1k 8bit. So I used a 32bit 3K image to make the texture for rendering. During this problem, I also discovered Photoshop 3D filter makes pretty good bump and normal textures.
These two articles explained it very well.
How to get rid of the odd lines shown in the image?
Why does my displacement look jagged - Cycles?
Keep blending, be safe and peace.


How to make puddles with the Principled BSDF?

In Cycles displacement is handled independently of the surface shader, so the workflow is the same whether you're using the principled bsdf or not. You simply connect the displacement/height map to the "displacement" socket on the material output node. See Blender Cycles True Displacement

As for puddles, an easy way to do with just a texture is to manipulate the base color and roughness channels. Puddles are generally darker and shinier than the dry areas of the surface. Here's an example using a simple noise texture to define what is and is not a puddle. A ramp is added to make a sharper transition between the light and dark areas of the noise:

(please excuse the "roughness" label on the basecolor texture node, it was an oversight in building this nodesetup. It's a different image and being used as the basecolor texture)

The lower the roughness and make the surface darker, we can simply multiply the roughness and basecolor channels by our noise map. To make the puddle surface smooth, we also use our puddle noise map to be blend a blank normal map node and the actual normal map node, removing the normal effect where the puddle water would cover it.

This is just one way to do it. There are other options, such as mixing multiple principled bsdf nodes, or using the clearcoat function. This is just a way I feel is simple and efficient.


To restrict parts of a mesh from rendering
You can make use of the Mask Modifier for this.

The Mask modifier allows certain parts of an object's mesh to be hidden from view (masked off), in effect making the parts of the mesh that are masked act as if they were no longer there.

This is probably the best way to go about this, any shader trick that selectively hides a mesh could cause problems depending on usage as transparent geometry is still outlined with Freestyle Line renderer for one. The mask modifier gets rid of it completely visually, but preserves physics etc.
To restrict an object from rendering
You can restrict entire objects from rendering by pressing the camera icon in the Outliner or by selecting the objects that you do want to render and using CtrlW > Restrict Render Unselected to restrict any unselected objects from rendering.
Alternatively you can exclude whole layers of objects via the render layer settings.


Is it possible to make an object with the follow path constraint stay at the end of the path even if the path moves?

I suspect that you are selecting both when you only should move the curve. Select curve only when moving. Otherwise you will get something called double transformation, essentially moving it twice getting all kinds of weirdness.


Probably because you have a Mirror Modifier active. Your figure only has that one side until you Apply the Mirror to it. Click the eye symbol on your Mirror Modifier and you will se what I mean. Hope that helps.


How do I move the pivot point of an object?

For people who don't want to watch a 5-minute YouTube video for a question that should take five seconds to answer:

Go to the Options dropdown in the upper right
Select the "Origin" checkbox
Use the move tool to move the crosshair that appears at the pivot


What voxel format is used by blender to store smoke data?

When baking smoke Blender can save the cache as OpenVDB.  Select the smoke domain, go to the physics panel, and go into the smoke cache settings.  Change the file format from "Point Cache" to "OpenVDB".  You can then choose your compression and data depth.


Crash report. Cycles shader graph connect: can only connect closure to closure

If the crash is reporting an issue with shaders then investigate into how the materials are created. Are you connecting a bump map to an add shader node? Nodes have colors that determine what kind of information should be plugged: purple should connect to purple, yellow with yellow and grey with grey... A green input is expecting a green output.

Read: What is the meaning of the color of the node sockets in the node editor?


Anti-Aliasing in GPU shader Module(OpenGL)

You don't actually need any code to make the edges curved or smooth. Go to edit mode and select all the edges of the cube. Then select bevel, which is this option

And then you will see a yellow line with a circle on top of it. Pull it to the extent you want. You may see it becoming flat. But there's an easy solution. At the bottom left, there would be a bevel option with a dropbox. Click on the triangle near it and select segments and set it to ten. Below's the image of how the bevel segment looks like. Make sure to be in edges and not vertices.


How do I navigate to external drives using the file browser?

It's in the left panel.

View > Source List
Shortcut: T

Or just drag that little arrow on the left...


How do I fill the space in the centre of my circuit in 2.79?

If I understand correctly, what you could do:

First clean your mesh a bit, make W > Remove Doubles to remove the doubles and merge vertices, and untriangulate with AltJ.

Now as you have merged the vertices you can select the rim with a simple Alt left click, fill the face with F and join some vertices so that its more blender friendly. It is still a ngon though, do you need a quad grid?


Subdivision/decimation is not working as expected

It's not a problem with your code, but rather with your base objects. You have several overlapping vertices and edges in there.
Take a look at this screenshot:

See how there is no orange line indicating connected edges to the left?
If I pull the vertex point to the right, this happens:

This kind of 'malformed' model will play havoc with expected outputs.
There are quite a few vertices like that in your model. Fixing them by hand can be tedious, so it's a good idea to start with using Blender's 'Merge vertices by distance' functionality. In newer versions of Blender (I'm using 2.91, don't have a 2.8 install to check right now), this can be accessed by selecting two ore more vertices (using A to select all will do in your case), then pressing M -> By Distance:

Just repeat this for each object, then run your script again:

I assume that looks like what you expected.
I've attached a .blend file with the fix I did:


A mix RGB node will work fine:

Use the alpha from the image on top for the fac input. You may need to try reversing which image is on top for best results.


I have figured it out.

In object mode you can create an "Empty" and put all the other layers inside the Empty, Unity3D will use the pivot point of the Empty because it is the outermost layer.

All you have to do is position the pivot point in the Empty.


Be in Front Ortho (Press Numpad 5 and Numpad 1)

Go to Edit Mode

Extrude all the faces. Select the top and bottom faces

Press U -> select -> Project from view (Bounds)

Now jump to UV Editor and hope you get a good UV.


To save, you only need to:

Get the object's attributes
Store them in a dictionary
Convert this dictionary to string
Write the resulting data to disk

To load this data, you only need to:

Read this saved data
Convert the loaded string to dictionary
Set the object's attributes

Here's a working script (below) and a example blend file. Press 1 to load and 2 to save on the example blend file.

import bge
from ast import literal_eval

def save(cont):

    # Objects
    own = cont.owner

    # Sensors
    sensor = cont.sensors[0]

    # Properties
    path = bge.logic.expandPath('//')
    savedata = {
        'position' : list(own.worldPosition),
        'rotation' : list(own.localOrientation.to_euler())
    }

    ### PROCESS ###
    if sensor.positive:

        # Creates/overwrites savedata file
        with open(path + 'savedata.sav', 'w') as openedfile:

            # Write savedata dict as str
            openedfile.write(str(savedata))
            print('Data saved to ' + openedfile.name)

def load(cont):

    # Objects
    own = cont.owner

    # Sensors
    sensor = cont.sensors[0]

    # Properties
    path = bge.logic.expandPath('//')
    savedata = None

    ### PROCESS ###
    if sensor.positive:

        try:
            # Try to open savedata file
            with open(path + 'savedata.sav', 'r') as openedfile:

                # Reads savedata and evaluates it from str to dict
                savedata = literal_eval(openedfile.read())
                print('Loaded data from ' + openedfile.name)

            # Set object attributes from loaded data
            own.worldPosition = savedata['position']
            own.localOrientation = savedata['rotation']

        except FileNotFoundError:
            print('Save data not found')


SSS works just like the 3 other "light type" sets do, so you add SSS direct and SSS indirect, multiply the result by SSS color, and sum that result with the other sets.

Shadow is not an image component per-se, since if you rendered your lamps with shadows enabled, they will already be embedded in your lighting passes. (the shadow pass already existed at the time that graphic was created, btw).

So to answer "what is the master routing?", it's just that with the SSS set tacked on the bottom, working the same way.

There are currently no volume passes, so volume shaders cannot be re-assembled in this way. What you can do, however, is use a handful of passes subtractively. For example, let's say you just need to edit glossy indirect to brighten reflections and clear some fireflies, you don't care about any of the other passes.

Rather than render EVERY pass and recombine them all, you can just render the passes you need, subtract the unaltered from the master, edit it, and add it back. For the light passes, you need to do the add+multiply to get the full lighting pass, rather than the split raw passes:

This will work with any shaders, including volumes.


When I render something, there's an indent in the model, but when It's not rendered there is no indent. how do I fix this?

There are some problems with your topology. Also, if you want to stay low-poly without any Subdivision Surface, you have to use the Auto Smooth, otherwise the twisted planes of your object will always create artifacts.

First of all, you have unwanted faces. If you go in Edit / Face Select mode, you can see some faces squeezed between faces. It has nothing to do with the problem you're talking about but anyway you need to correct that because it's not good to keep this kind of topology. It must have been created by some accidental extrusions. So select all your vertices with A and click W > Remove Double, it will merge all overlayed vertices and remove all these unwanted faces. It's not the only problem of your topology but it's the most obvious.

Now, about your problem: Your object is made of several planes that are not flat but twisted like chips, so, as you didn't smooth your object with Smooth Shading and Subdivision Surface modifier, which would have helped to smooth these surfaces, they do appear like triangles and not like planes.

If you want to avoid these artifacts you have several solutions, you can either:

Use the Smooth Shading (in the 3D view Tool panel displayed with T > Tools tab > Edit > Shading). But it will give non very aesthetic gradients as your object doesn't have enough polygons.
Keep this Smooth Shading but add a Subdivision Surface modifier so that your object has virtually more polygons.

But these solutions are interesting only if you want to give your object a smooth and high-poly appearance. If you want to keep it low-poly you should use this trick:

Keep your object Flat and with no Subdivision Surface modifier.
Go to the Properties panel > Data > Normals and enable Auto Smooth. The Auto Smooth option is supposed to determine the angle below which the Smooth Shading will happen, but in Flat Shading it will also make your twisted plane look flat and uniform.


Don't worry, learning to read an API is a skillset unto itself, and a non-trivial endeavor at that, so it's okay for it to feel daunting. Unfortunately, it's usually necessary.

To answer your first question, ArmatureBones is a member of armature. It is a container, but it's not a built in Python container like list or tuple. It's a Blender container of type bpy_prop_collection, and this instance of that type of container contains Bones.

This would be roughly equivalent to saying "Encyclopedia is list of Books."

To answer your second question, there are a number of different types of context. Without knowing which one you're referencing it's hard to guess. However, there is a screen context, and it makes sense that a screen doesn't have an armature. So if you're referencing one of those other contexts, it'd make sense for it to has no attribute 'armature'.

Furthermore, the context that does have an armature is the buttons context, which means it's probably not the armature you're looking for. I suspect that you're actually after bpy.data.objects["name_of_your_rig"].data as referenced in this answer over here.

I hope that helps!


Use the beam builder

Then in edit mode, select all and correct the normal CtrlN.

Now select one of the edges you want to bevel.

ShiftG to select similar and choose "length".

Your wanted edges are now selected.

Use CtrlB to bevel (use Numpad + or Numpad - to set the bevel depth).

Note: if you want to smooth it, click on smooth, but the result is weird, so, add an 'edge split' modifier.


Select FFmpeg Video from the File Format dropdown menu, then the encoding panel will be available.

For more detail read the following link:

I only get four video output options


Using an Emission shader with textures without affecting the color of the mesh?

You can mix an emission shader with emission value 1 with an emission shader with a higher value based on the is camera ray output of the light path node.  This way the camera will get the actual value with everything else getting the higher value.


So with the tip from @batFINGER I was able to build a solution using scene raycast.
for obj in bpy.data.objects:

            if 'wall_' in obj.name:
                bpy.context.view_layer.objects.active = obj

                mesh = obj.data
                bm = bmesh.new()
                bm.from_mesh(mesh)
                bm.faces.ensure_lookup_table()

                for i in range(len(bm.faces)):
                    mesh.polygons[i].select = False
                    face_location = bm.faces[i].calc_center_median()

                    # side face
                    if face_location[2] != self.wall_height and face_location[2] != 0:
                        hit, loc, norm, idx, ob, M = bpy.context.scene.ray_cast(
                            bpy.context.view_layer,
                            face_location + mesh.polygons[i].normal,
                            mesh.polygons[i].normal
                        )

                        if hit:
                            mesh.polygons[i].select = True

                # toggle to edit mode
                bpy.ops.object.mode_set(mode='EDIT')

                # make sure face select mode is enabled
                bpy.context.tool_settings.mesh_select_mode = [False, False, True]

                # use second material slot
                obj.active_material_index = 2

                # assign the material
                bpy.ops.object.material_slot_assign()

                # toggle to object mode
                bpy.ops.object.mode_set(mode='OBJECT')


How to get the dimension of multiple objects?

As Chebhou already pointed out in his comment, what people usually do when transforming a disjoint model is have an EMPTY at the centre or wherever you want it (you can use it as a pivot), and then PARENT all objects with the empty. Then you would simply transform the empty and everything should stay in the same position relative to it.
You can have a hierarchy of empties if you want to be able to move some objects separately (say wheels, doors, etc.)
I am not sure how getting the dimensions of all objects would help you solve your problem, but if that is what you want you will have to write a simple script (something like that):
for each object in selected
  print object.getDimensions()

But then you will have to go through them manually unless you don't attach it to some other script.


Is there any way to move/deform procedural work along a mesh as a normal texture would?

It was the lattice!

As you probably know, procedurals need some coordinate space to originate, and it can be something's origin or the world's point zero. In this case the nodes setup could generate a perfectly fine texture that could move along with the mesh as a UV, but since procedurals aren't really a texture but a "projection" (can't think of a better definition) they move with the mesh's coordinates, but not with the vertexes. And this means that as long there's no deformation on the mesh everything is fine... But the lattice was deforming the mesh...

Hope you find it useful if you're started on procedurals. For this, coordinate spaces are really important. I came up with a metaphor about it:

Think of procedurals as a beam of light made of x-rays that need something else's origin as it's emitter. As it reaches the mesh's surface, it illuminate the surface the way it wants then go right through the object and keep going, because it's x-ray. Changing the surface won't change the beam of light


You can complete your code with the following, considering mat.use_nodes = True creates automatically a principled BSDF node.

import bpy

def add_texture(texture_path, obj):
    mat = bpy.data.materials.new(name='texture')
    mat.use_nodes = True
    nodes = mat.node_tree.nodes

    texImage = nodes.new('ShaderNodeTexImage')
    texImage.image = bpy.data.images.load(texture_path)

    principled = nodes['Principled BSDF']

    # What to link here?
    # mat.node_tree.links.new()
    mat.node_tree.links.new( texImage.outputs[0], principled.inputs[0] )

    # Assign it to object
    if obj.data.materials:
        obj.data.materials[0] = mat
    else:
        obj.data.materials.append(mat)

obj = bpy.context.object

add_texture( "your path to texture file", obj )


What is the difference between the 'Symmetry Mirror' and 'X Mirror' options when weight painting?

I can get you part of the way there, but I have the same question as you with regard to the ones I don't know. Any further input is therefore very welcome.

The Weight is the setting which controls the degree of influence that your brush will have in assigning vertex weight values. Setting to .5, say, would mean that you want the vertex weight values that will be added via weight painting to be able to reach a value as high as .5, but never go higher. It sets the upper-most limit for the weight values, so that you will never get higher ones from  painting.

The Radius setting is simply the size of your brush.

The Strength is the setting which determines the rate at which an applied brush stroke will have whatever affect it will have, as determined by other settings. The higher it is, the less duration is needed (and less pressure if you use a tablet) before its full effect can be finally realized.

The Falloff: Cursor has to do with how the brush's effect will evaluate in space. There is the ability to have a brush which only affects the surface of an object, in a kind of 2D painted-on way, or alternatively, it can affect the object as if the brush itself were a 3D sphere, affecting anything within its zone of influence. As to which of these two behaviors comes along with the Cursor option, I'm not sure.

The Mirror option under the Symmetry section is one I definitely know about, as it caused me grief in the beginning. What it does is mirror painted weights. However, it doesn't copy vertex weight data to any other vertex groups. Instead, it copies vertex weight data to the other side of the mesh, but that data will still be part of the currently targeted vertex group. Meaning that you will get influence from whatever bone corresponds to the vertex group you are currently targeting not only on this side of the mesh, where you want it, but on the other side of the mesh also, where you almost certainly don't want it. I don't use this option, and I don't know why anyone would.

Auto-Normalize, I have to guess about a bit. I think it is possible to have all your vertex weights add up to a value of 1, meaning that any changes in weight painting are only possible by altering the ratios of all weights, such that they will all still add up to one in total, no matter how they are changed. My guess is that this setting allows normalization to be an "always on" feature. But I'm not an expert on this. I don't yet know why normalization is even used, nor why it is useful. I'm still trying to wrap my head around it. Sorry I can't tell you more.

Now, X-Mirror is almost certainly what you actually wanted when you first selected Mirror under the Symmetry section. It does what you usually want from symmetry. It copies the vertex weight data from the currently targeted vertex group and adds it to the corresponding vertex group on the other side of the mesh. This is a real time saver, as it means you can mostly only weight paint one side of your mesh, and get mirrored weight values automatically. It only works if you have corresponding vertex groups already in existence, of course. But you likely will, since most folks always bind their meshes using the With Automatic Weights option.

Topology Mirror is the one setting that I have absolutely no clue about. Nothing I have read, stumbled upon, or actively researched has helped me get any idea what it is, or when I would use it. I feel like I should at least have a word or two on the subject by now. But I don't. Not even after reading the Blender manual. So I'm hoping someone can help us both out here.

That's all I know. Hope it helps.


I'm afraid it isn't possible to set rotation directly to the 3D cursor but you can achieve a similar effect with a number of steps.

First, add an Empty to the scene - this will, by default, be added at the location of the 3D cursor.

Add a Track To constraint to the object you're trying to orient. Set the Target to the newly added Empty. Configure the constraint To and Up settings to set the required orientation.

In the 3D window press Ctrl+A to bring up the Apply menu. Select Visual Transform - this will set the object's rotation, location, etc. to the current 'visual' orientation (ie, that including any constraints).

You can now remove the constraint and delete the Empty and the object should retain its orientation, pointing at the location defined by the 3D cursor's location.


Can I export as .obj without losing unconnected vertices?

A quick experiment gave the answer to this question, which in short can be solved by changing the OBJ importer settings rather and toggle "Lines" off (since the exporter is fine and does export isolated vertices).

For this test I generated this geometry and exported it to OBJ:

Since an OBJ file is a simple text file, it was possible to open the file and see that the isolated vertex was indeed exported and does exist in the file:

# Blender v2.74 (sub 0) OBJ File: ''
# www.blender.org
mtllib exportToObj_detached_verts.mtl
o Cube
v -1.000000 -1.000000 1.000000
v -1.000000 1.000000 1.000000
v -1.000000 -1.000000 -1.000000
v -1.000000 1.000000 -1.000000
v 1.000000 -1.000000 1.000000
v 1.000000 1.000000 1.000000
v 1.000000 -1.000000 -1.000000
v 1.000000 1.000000 -1.000000
v -1.000000 1.000000 -2.031537
v -1.000000 1.000000 -4.031537
v 1.000000 1.000000 -4.031537
v -1.000000 1.000000 3.735121
v -1.000000 1.000000 1.735121
v -1.000000 1.000000 4.733686   # <<< THIS IS OUR ISOLATED VERTEX
vn -1.000000 0.000000 0.000000
vn 0.000000 0.000000 -1.000000
vn 1.000000 0.000000 0.000000
vn 0.000000 0.000000 1.000000
vn 0.000000 -1.000000 0.000000
vn 0.000000 1.000000 0.000000
usemtl None
s off
f 4//1 3//1 1//1
f 8//2 7//2 3//2
f 6//3 5//3 7//3
f 2//4 1//4 5//4
f 3//5 7//5 5//5
f 8//6 4//6 2//6
f 11//6 10//6 9//6
f 2//1 4//1 1//1
f 4//2 8//2 3//2
f 8//3 6//3 7//3
f 6//4 2//4 5//4
f 1//5 3//5 5//5
f 6//6 8//6 2//6
l 12 13

So this hinted that the problem is not with exporting, but with what happens when you import your exported OBJ file back into Blender. When I imported with the default values the isolated vertex was indeed gone.

To solve this, you can change the importer settings by setting the "Lines" toggle off. This option means that if you have edges that aren't part of faces ("lines" in OBJ jargon), they will still be imported as edges, but isolated vertices that are not part of edges are discarded.

If you toggle if off, it will import the isolated vertices and edge verts, but will not create edges:

Bottom line, the OBJ exporter works fine, the importer is the one causing you trouble.


Heres one way of doing it, but It envolves recreating the topology.

Set the snapping mode to face.
create a new mesh, and delete all except one vertice.
press g and move the vertice, the vertice will automatically snap to your character mesh!
now, extrude the vertice to create edges and faces, (using the poly to poly method of modeling) and whenever you extrude or move the vertice, it will snap to the mesh.

I realize this is time consuming, and I suggest you plan your topology flow with the grease pencil, setting the stroke placement to surface.

With your current mesh, I don't see any fixing it, I think this is the only way to get a mesh suitable for rigging.

hope this helps, and please comment if you need more detail.

P.S, I like your model, and It's really good for a beginner!  I'm a beginner at sculpting too, and I'm not sure I could create that model.


More info is needed, such as is that armature posed(has it been transformed) ?? What are your settings for the C/R constraint ? What axis are you copying ? What are the Bones axis ? Have they got 'roll' compared to the 'owner'?
I can tell by that black dashed line that the bone with the 'Cube' is a child of the last bone in that chain - that means it automatically inherits rotation from its parent (unless it was un-checked). So adding a C/R set to 'World' space, copying all 3 axis should have left it looking just like the bone it was copying. , using 'Local' space on both (Target & Owner) would leave it maybe looking like it is now, depending on the actual rest position. ALWAYS turn on 'axis' display in the 'Armature' display panel, it makes working on stuff much easier to see and understand.


Bump Maps and how to get more details in them

I would use a software like CrazyBump, Knald, or SmartNormal to create a normal map based on the image you have and add that to your material.

If you are using cycles you can run the normal map through a normal map node and plug that into your shaders.

Here's the result I got with SmartNormal.  You could improve a lot by spending more time tweaking the settings, but it's a start.


How is this icon called and how can it be used for an operator?

I know these to be 'relationship lines'. In this case it looks like blender is showing what origin your cursor is scaling around.


The reason why you are having issues is because your spine isn't a single unified chain. Normally, the spine bones start at the hips and move up the back and ends in the head. Legs and arms can then be placed relative to those bones.
Add in a bone on the ground below the neck and extend it up so it ends in between the spine and head. This will be your root bone. Parent the spine bone, the arm bones, and the neck bone to the root bone. Be sure to uncheck the deform option in the bone tab on the root bone.


cycles transparency not 100% transparent

Raise TRANSMISSION and transparency samples:

Also don´t forget to check the ALPHA on Photoshop or GIMP, by placing a full black fill on your image as a lower layer. Delete (clean, CLAMP) your white alpha as white as it can get. Then, reload your image in Blender. This should cover it.


Texture Changes When Object Position Changes

The problem you are having is that the two inputs to the Wood Rings Texture are two world-space points that the "core" of the wood passes through.

You are currently supplying a world-space point (the object location, aka center), and a normal vector. However, the normal vector is being used as a point, not a vector. As a result, you are defining a line which passes through the object-center and a point within 1 unit of the global origin.

One part of the solution is to convert the calculations into object space, making these two core endpoints object space coordinates. This can be done by going into the distance node and replacing Geometry->Position with TextureCoordinate->Object. This supplies the object-space position of the texel to the distance calculation.

Then we need to remove the object position, because the core-definition points are now in object space. We can define core-origin as an arbitrary x,y,z point in object space. Further, the normal node (aka core orientation) needs to be added to the core-origin to create the second core-endpoint.

Here is a fixed blend file.

This solution is a bit limited, in that it has only one core orientation per shader, and we'd prefer to have one per object instance.

One alternative is to use script nodes to read the object positions of empties, which can be created per object instance.

Another alternative is to randomly generate core orientations per object.


Need to scale a ring without changing thickness via animation

The Array modifier can automatically adjust to the size.
Just choose Fit Curve and select your Bezier circle.


How to 2D-stabilize and enlarge canvas to preserve outside pixels?

Well... I found the answer and it's in fact quite simple.
Setting the rendering to a large resolution with scale 100%  is enough to do the job!

I used the nodes though, to connect Movie > Stabilize > Compositor.


Try setting Display Device to 'None'(because you do not want it to be an image viewd on any display device, but only pure unchanged values) in the scene's color management settings:

Seems to work:

Obviously the output needs to be a 32bit full float EXR image in this case as well if you want to save it.


Whats the best way to render a 360 video in blender?

Terrible in what way? You probably need to up the resolution? For 360 you need at least 4096x2048 if you are rendering equirectangular. Problem with this resolution is that it takes forever to render an animation, so a lot of optimization will be necessary to keep your render times in check.


How can I move the roots of hair particles?

Uncheck the 'Root' option in the left hand tool panel, then re-check it when you want to anchor the roots in place again.

Note that you can also select and translate points with 'G', as in normal mesh editing. You can enable snapping and use it to put your roots back onto your mesh if needed.


How to fix an artifact affecting a bevel modifier

The artefacts occur because you have a beveled edge adjacent to an unbeveled one. You are not creating topology at the bottom of your mesh so you have an area where faces with different number of vertices meet. You could give all effected edges a tiny bit of bevel, instead of none, that would mask the problem. Otherwise it's going to take manual refinement.


How can I fill up my toilet model with water?

In Edit Mode select an Edge Loop at a location where you want the top of the water to be.

Duplicate it SHFT+D Then separate it by pressing P > Selection.

TAB into Object Mode and select the object you just created (I hid the other objects).

TAB  into Edit Mode and Extrude these vertices inward as in the imageE  SSHFTZ

Select all of the vertices except the outer edge and move them down a bit G Z This creates the "meniscus".

You will want a Subsurf Modifier and Smooth Shading.

Here is my Node Setup for the material.


Yeah, i found out a solution. If someone has a problem like this, what it i did is; I joined smooth shade problem mesh to non smooth shade mesh(This mesh has smooth shade working). And as i joined it fixed ! Then i separate the mesh i joined. That's all i hope this might help someone.


How can I rotate multiple objects in their LOCAL axis?

There's a simple method for that in Blender.Here The couple of Cubes represent your Multiple Objects.

Select one of the  object in your scene. (The nearby objects to the selection will have more influence of Random Rotation).

Change the Pivot Point to Individual.(So cubes will be rotated on their Local Axis)

Press 'O' in keyboard (To turn on Proportional Editing) & set it to Random.

More Info while pressing R for rotate a circle will appear that represents the effective Radius for the Random Rotation that can be changed by (Mouse Wheel) or (Page Up or Page Down)


This is exactly what the Locked Track constraint is for.

First you need to set up your camera objects. Parent the lens to the mount. Then the mount to the base. This hierarchy will enable you to get the motion you are looking for in all the pieces.

Add a Locked Track constraint to the lens object.  Notice the axis the lens is pointing on (you may want to turn on axis display in the object tab of the properties window) in my example it is looking down the Y axis. So it is tracking along the Y, and rotation is locked to only the X axis.

Add another Locked Track constraint, this time to the mount object. It has similar settings, except that the rotation is locked to only the Z axis.

Blend File

As a bonus step add a Limit Rotation constraint to the lens object, to stop it from rotating through the base. If your camera is looking along the same axis as mine, then you only need to limit the X axis.


Image will not show through transparent object

It's because the import images as planes tool sets the blend mode for the material to Alpha Blend, and you're using Eevee.

Your options are to switch to Cycles or change the Blend Mode to Opaque.


If you're using the script editor, you can do it like this:

import bpy

v3d = [x for x in bpy.context.screen.areas if x.type == 'VIEW_3D']

if v3d:
    # you need to decide what to do if there are more than one 3D Views present
    # you could either set the orientation on the first one, or on a specific one

    # to set it on all views:
    for v in v3d:
        v.spaces[0].transform_orientation = 'GIMBAL'

    # to set it only on the first one found
    v3d[0].spaces[0].transform_orientation = 'GIMBAL'

From an add-on, it should be:

# from within an Add-on, it's a lot easier, as you have a proper context
def execute(self, context):
    v = context.space_data
    v.transform_orientation = 'GIMBAL'


Two ways:

Press ALT + .
Select it in the menu:


Navigating viewports in Blender for beginner

If you like:
1. Download this file

open blender. Press CTRL+ALT+U (File>User preferences>Input)
At the bottom of the window there's a button: "Import Key Configuration".
Point to the file you downloaded on (1).

Alternatively: Customize your mouse PAN, ZOOM, DOLLY. Go to CTRL+ALT+U (File-User Preferences)
Go to Input tab. Unfold "3D view", find "zoom view" - mouse - Wheel In. If there is not such command create a new one using those options:

To use the Middle Mouse button (MMB) to Rotate around the view and move (drag) etc... check this out;

The cursor is deactivated. It will TOTALLY get in your way now that you´re beginning to use the software.


Is there a timeout/max capacity in blender's phyton scripts?

Your srcipt is fine, and blender is not timing out, but rather you have found a limitation of blender. Blender is not good at displaying many objects, 250,000 different cubes will crash blender.
Try adding 3 array modifiers to a cube, to generate 250,00 cubes, then go into edit mode and separate by Loose Parts (blender will crash.)

Instead of adding a cube at each coordinate, create a mesh with all the coordinates as  vertices. So each coordinate is represented as a vertex.

import bpy
fh = open('coordinates.txt')

# A list of the locations of the cubes
vertices = []

for line in fh:
    coo = line.split()
    x = float(coo[0])
    y = float(coo[1])
    z = float(coo[2])

    # Instead of adding a cube, append the location of the cube to vertices
    vertices.append((x, y, z))

# Make a new mesh and set its vertices
mesh = bpy.data.meshes.new('verts')
mesh.from_pydata(vertices, [], [])

# Make an object for the mesh
object = bpy.data.objects.new('verts', mesh)
bpy.context.scene.objects.link(object)

Then parent a default cube to the newly generated mesh, and use dupliverts to add a cube at each vertex.

From the excerpt of your coordinates, in top view, it produces this:


How can I create procedural tiles with uniquely seeded textures for each one? [Updated]

I wonder how much computational difference there actually is,between using the Voronoi node for tiling, and doing the maths yourself, especially after you've introduced a couple of Noise nodes to do your randomness for you.. ?
Anyway, you certainly get lot out for not much in, in the way of nodes, with this kind of tree..

(I've made a group of it, here) .. You get UV-per-Cell, by subtracting the Position output from the texture-space, which lets you tile any texture you like into each cell:

You get 3 random numbers (a color) per cell, which you can use to randomise any of the cell's attributes (here, used to randomly rotate a texture, per cell):

And from the parallel Voronoi in the tree, you can get the distance to the cell's edges, which you can use to make a grouting mask, as here, or you can map ranges of it to other ranges to bevel tile edges:

And you can use the Randomness setting in the Voronoi nodes to take you from square tiles..

.. to Voronoi tiles, without any further adjustment.

(Just the group.. the other trees are a bit of a rushed mess :) )


How can I rotate the rigged child leg with whole body?

You could give your bones a root bone that would be the main parent of your bones (so it would be the parent of the current parent, that is probably the spone bone) and put the foot over this root when you'll want to make your rotation. Or create a bone under the foot and give your current main parent (first spine bone probably) a Child Of constraint that you activate (by keyframing the Influence value) only when you want the rotation to happen:


why is the display modifier button in blender 2.8 purple?

Purple indicates a driver.

For the most part, (unless you are using some whaky theme) purple in a field indicates a driver has been added.

To remove, right click over field and choose delete driver. (adding driver is most likely how you got there in the first place)

Oops added driver to diff prop from Q, same deal though

Note

In Q screenshot you have the apply all and viewport vis buttons etc above modifiers, which I assume is from an addon.  Possibly this is using a driver on the modifier visibility switch


Blender is just rendering a png I added as a plane instead of what the camera sees

You have selected the png file to be the source for the output (composite)

Select the rendered result.


Give your lowpoly a Subdivision Surface modifier. As your highpoly goes a bit beyond the surface of your lowpoly, you need to increase the bake Ray Distance value up to 2m, it seems to work fine:


Why are the size and shape are different in edit and object mode?

Make sure that before you do automatic weigthing, that you apply the scaling to both your mesh model, and you rigifie armature  [CTRL + A]

once all scales are applied it shouldnt deform, i see this happen often with people who begin with this.