How to render static and animated objects separately to save render time?

So.. You should use 'View Layers' (https://docs.blender.org/manual/en/latest/render/layers/layers.html).
As said above in the comments by @Bruno you should render the still as an image, on the other view layer render the animation with shadow catcher and in the video editor (VSE) add them together to a video.

(to be honest you can probably just render them separately and attach them together later in the VSE just as long as you keep original scene.)

I am attaching link to a demo scene, hope it helps. (https://drive.google.com/file/d/10fXBH4o2sz4b0ceBPyRouquxhjgi_8gZ/view?usp=sharing)


Combine Texture Paint With Normal Map From MultiRes Bake

Turns out you simply need to make sure you apply a few options under the texture tab for the normal map image. With your normal map highlighted under "Texture," in "Image Sampling" make sure you check "Normal Map" and select "Tangent." Under "Influence" make sure "Color" is deselected and "Normal" is checked.


Mirrored object scale in weird positions

It's not covers all cases, but you can use Shrink/Flatten (Alt+S) instead of regular Scale. It uses normals for transformation, so for circles it should work fine.
The Problem, that you have is about center of objects. When you use mirror, transform tool use center of vertexes, instead center of symmetry. So for make it work as you expect, you should use 3D-cursor to define center of transformation. See here:
how to scale an object that uses a mirror modifier?
Scale about true center with Mirror modifier


I'm having trouble making my model look good with a small amount of faces

You probably need to learn about working with Subdivision Surface based meshes and adding control loops to control subdivision.

Try working with a lower poly version of your model as base mesh and add details only as needed dynamically with a Subsurf modifier on top.

That not only make modeling a lot easier and manageable, because there are a lot less vertex around to control, but also reduce polygons considerably.

You can control the number of subdivisions dynamically before exporting, without having to rebuild your model from scratch.

See tutorials about Blender Subsurface Modifier


How to set Output path correctly for a Single Image render?

If you are Rendering single image Image using the Render> Render Image menu or f12, Blender will not save the image automatically.

You have to save it manually, by clicking Image option located at the left of Render Result dropdown and select Save as (or press Shift+s while in the image editor).

A new window will open where you can choose where to save the file.

If you want to save the image automatically you can render as animation.

Set the frame range to a single frame.

Then render using the Render animation option or F12.

Note that 2.8 has different panel for output.

Dimensions and frame range can be set there as well.


Why is a purple light/texture appearing in rendered view?

It was because I had moved the textures to a new folder. Oops.
and you have to link it back......find the texture location


Shoelaces are typically a work for curves in my opinion. You just need to bevel your curve in the Properties panel > Object Data > Geometry > Bevel. If your lace is a bit more complicated than just a simple tube, create a mesh that will be your segment, duplicate it with an Array modifier and make it follow the curve with a Curve modifier.


Changing default text value in file dialogue

It's actually a feature of the ExportHelper mixin:

class ExportHelper:
    filepath = StringProperty(
            name="File Path",
            description="Filepath used for exporting the file",
            maxlen=1024,
            subtype='FILE_PATH',
            )
    #...
    # subclasses can override with decorator
    # True == use ext, False == no ext, None == do nothing.
    check_extension = True

    def invoke(self, context, event):
        import os
        if not self.filepath:
            blend_filepath = context.blend_data.filepath
            if not blend_filepath:
                blend_filepath = "untitled"
            else:
                blend_filepath = os.path.splitext(blend_filepath)[0]

            self.filepath = blend_filepath + self.filename_ext

        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

    def check(self, context):
        # code that uses check_extension and adds it if True
        # ...

Add this to your export operator to overwrite the invoke() method:

    def invoke(self, context, event):
        self.filepath = ""
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

It won't use a default name for the export, clears the filepath from a previous run of the operator (so always starts empty), but still adds the file extension if you enter a file name (you can disable it if you want).


Noise reduction blur / postprocess in blender

Blender Compositor work only in 2D too..

"using some extended info that Blender has?" - You show a Photo.. What Info should Blender have that PS doesn't? ;-)

What you have in your Image here is actually not Noise, but Compression Artefacts.

I found this solution with Bilateral Blur works quite ok on your Sample:

I doubt that any Noise Reduction on Images(not rendered) in Blender is much better than dedicated ones in Gimp or elsewhere. While Blenders Compositor allows some neat things, it does not give direct access to Pixels, which i think is needed for any decent Noise reduction. (Of course Node do access Pixels, but you have no way of access Pixels in you Node Setup)


I found the reason. This could be a silly Q&A, but I think someone could do a similar mistake. I was trying to move the object (where it has 'rigid body' physics) in the middle of an animation. Set the frame number to the first frame and then adjusting the transform solved the problem.

I accidentally found this while suspecting all the possible causes. When I removed 'rigid body' physics from the object, it worked as I intended. That was because it is not affected by rigid body animation anymore and therefore free from frame numbers.


How do I make the cursor reset to the middle of the object?

Right-click on the object, then select 'Set Origin.'  Set origin to Geometry, and it sh/b in the center of the object.


Use Insert as a shortcut for Insert keyframe?

You can use autohotkey to make the insert key function as the "i" key when Blender is open.

https://autohotkey.com/


Camera rotates around object at awkward angle

To fix this, I applied a camera actuator to the camera instead of parenting the camera to the car. The camera actuator allows the camera to track an object and choose how precisely it tracks it using damping (e.g. if the car goes over a pothole it won't shake the camera, but if it goes over a big hill, the camera will follow it). Here is a picture of the actuator settings:

You can learn more about camera actuators here.


How to repeat texture across surface (must work in SceneKit/iOS/OS X)

You could subdivide (W / Subdivide) in Edit Mode your face to 10x10 tiles and unwrap U. The texture is automatically repeated along the uv coordinates.

As pointed out by @someonewithpc this works also with a single plane:

Related:
Unwanted patterns in texture from repeated, seamless image


Unwanted lines showing up on rendered cube

Every quad is treated as 2 triangles, this is what is causing the problem. You need smooth shading for the edges inside the quads and sharp for the corners of the cube.

To do this set the smoothing to smooth and in the mesh properties check the auto-smooth option and set the angle for cca. 70° (depends on the twisting).

This way faces with angle with more than 70° will keep sharp shading between them.

You should also densify the geometry so it follows the ideal curved/bended surface closer.


In order to have the particles act as a brush, you need to set the emitter to be a brush. Then change the type to a particle system.

This tells the dynamic paint to use the particles as the brushes, not the actual object.
The particles will then paint the canvas as expected.


What settings affect the final number of samples in Cycles?

The reason your samples are so high is because you are using Square Samples. So instead of 12 you are using 144 (12x12) samples.

The square samples feature allows you to increase the sample numbers very fast.

This is how the author of this feature describes it on blenderartists.org

Basically brings Cycles more in line with Arnold. Noise in a path tracer takes longer to clear the longer a render goes on, which maps fairly closely to a n^2 curve. So basically, using squared samples allows every increase of 1 to equal a meaningful amount of noise reduction, and it allows an artist to have a very simple table of values stored in their head to clear noise for various common scene types


How do I do I unwrap from a point of view?

You can try this:

Select your objects and go to edit mode
Select all faces of the both objects and switch to Top view
From the menu select UV -> Project From View
Switch to object mode and create a material for one of the objects
Add your texture to the material
Make sure you create a Texture Coordinate node and connect the UV slot to the Vector slot of your image texture.
Apply the same material to the other object.

Edit:

This was added to the question:
"I don't want to affect the plane UV map"

In this case you can use the Data Transfer modifier on your Cube to transfer the UVs form the Plane to the Cube (I used a Torus instead, it's a bit more visible)

Position the Cube somewhere above the Plane
Use Data Transfer modifier on the Cube
In the modifier settings as the Source select your Plane
Check Face Corner Data with Nearest Face Interpolated settings
Click on UVs
You might need to click Generate Data Layers

For the Data Transfer modifier to work properly you will need more edges/subdivision on your Plane.
If you don't apply the modifier you can move your Cube and the UV data will adapt to the new position.


You can join all objects into one, go to edit mode, top ortographic view, select all, press U and choose "Project from view".

Load your image into an UV editor window, adjust the scale until it fits.

Then assigne a material with the image as texture.
You can select all bottom zones (walls) and assign another material to avoid stretching.

Then you can separate all by loose parts (P) if you need to.


Cycles render on combination of AMD & Nvidia GPUs in one system

Blend file: 2.7x Cycles benchmark (Updated BMW)

Forum post

Testing Methodology:

Load up the .blend file.
Set the "Compute Device" to "OpenCL".
Render twice on AMD R9 290. Record the lowest value.
Set the "Compute Device" to "CUDA".
Render twice on NVidia GTX 460. Record the lowest value.

Results:

AMD R9 290 (OpenCL): 1:43:57
NVidia GTX 460 (CUDA): 3:33:95

Blender cannot use both OpenCL and CUDA simultaneously.


My blur node does not affect a shadow between rendernodes

Fake way to do it is increase the size of the light, a lot.

Another fake way to do it is by mixing a transparent node with your shader and use facing layer weight for factor

(sorry for self hosting, imgur declined my request)

And now the real way: volumetrics

Plug a volume scatter shader to the volume output and control it's density with a spherical gradient. Probably can be modified for non spherical objects too.


Not sure if this is what you are asking, but you can try this. Switch to the Dope Sheet so you can see all your keyframes. Select the one you want to duplicate, hit SHIFT+D and the drag the mouse to where you want it to go. You can also SHIFT+select to duplicate multiple keyframes.

In your case, just move move the duplicated keyframe to the end of the timeline.

NOTE: I think the best option for you would be to type in a number instead of dragging your mouse. EG: typing "10" will move the keyframe 10 frames ahead. Subtract the target frame (the one you want to move the duplicated keyframe to) by the start frame (the frame you are duplicating it from).


In Render Properties, under Shadow, you can pump up Cube Size to attenuate those artifacts.
Also, those artifacts may appear in the Viewport, but be less visible while Rendered. This is beacause Viewport and Render don't necessarily have the same Sampling (in Render Properties / Sampling).


To resume a drawn line you can select Stroke under the Stroke Placement option in the Blender 2.8 viewport, and choose All points, First point or Endpoints for attachment.


How can I use an existing text block as a data source?

In as much as you can get all the texts in a blend file with [text for text in bpy.data.texts] and the filepath is text.filepath.  If a file is pasted into the text editor then it will have filepath = "".  I recommend using the text editor current text as your csv data.  A simple panel is added to the text editor properties, which ensures that the current csv file is

current_csv_file = context.edit_text

Firstly, a simple operator that prints out the csv data, split by "," line for line.

import bpy

def main(context):
    text = context.edit_text
    for line in text.lines:
        split = line.body.split(",")
        print(split)

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "text.import_csv"
    bl_label = "Import CSV"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        main(context)
        return {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

Can make a panel in the text editor UI like so

import bpy

class TextPTImportCSV(bpy.types.Panel):
    """Creates a Panel in the scene context of the properties editor"""
    bl_label = "Import CSV"
    bl_idname = "TEXT_PT_import_csv"
    bl_space_type = 'TEXT_EDITOR'
    bl_region_type = 'UI'

    @classmethod
    def poll(cls, context):
        text = context.edit_text
        return text.name[-4:].lower() == ".csv"

    def draw(self, context):
        layout = self.layout
        layout.label(context.edit_text.name)
        layout.operator("text.import_csv")

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

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

if __name__ == "__main__":
    register()

which running on the simple test file prints

['1', ' 1', ' 1', ' 1', ' 1', ' 1']
['2', ' 2', ' 2', ' 2', ' 2', ' 2']
['3', ' 3', ' 3', ' 3', ' 3', ' 3']

to the console.

EDIT: as a side note, split above will be a list of strings, and will need to be converted if they are other. Here is a basic way to make a key for your csv file.  Consider a file that has 4 columns, the first is an integer for frame, the next three a location.  Quite likely there is a way to use the text.lines as input to csv.reader (simple workaround would be to save to tmp file)

# key of csv file, [property name,  column(s), type]
key = [["frame", 0, int], # frame in col 1
       ["location", [1, 2, 3], float] # loc x, y, z in cols 1, 2, 3.
       ]
'''
data in csv like
1, 1.0, 1.0, 1.0
'''
split = ['1', ' 1.0', ' 1.0', '1.0']

for prop, cols, prop_type in key:
    if isinstance(cols, list):
        val = [prop_type(split[col]) for col in cols]
    elif isinstance(cols, int):
        val = prop_type(split[cols])

    print(prop, " = ", val)


Mixing image texture makes everything transparent

The last mix shader on your node tree is just making your shader a 50% mix of two other shaders, but not using any transparency to control the mix.

Get rid of the extra mix shader and mix the two shapes together directly:

(click on the image to enlarge)

I'll break it in pieces so that is clearer:

When you are using an alpha channel you are using a black and white image to control how two things mix. White is used as opacity, black as transparency. Anything in between will be semitransparent.

If you use the Alpha channel to mix shaders, the white portion of the image will be using whatever shader is connected to the bottom socket. The black portions will use the other shader connected to the top socket. In this case Black will become transparent and white a Diffuse shader.

(click on the image to enlarge)

To mix the other image you use the same approach:
Using the alpha channel you just select to use a diffuse shader over a material that has areas that are already transparent.

(click on the image to enlarge)


Material question - how to make this reflective?

The problem is the emissive shader doesn't really work well with the glossy. What I think is happening is the emissive texture is taking all of the light that is reflecting into the camera. It is basically bleaching out the ability for the light to reflect and is making it difficult if not impossible to see the small amounts of light reflecting off. to fix this, I recommend that you basically reduce the amount of emissive compared to the glossy so that it's not for the lack of a better word overshadowed. I did a test render here. It appears to work but it might not be exactly what we're looking for


Blender Object Visibility Controls at version 2.80+

The visibility options are still available in the Overview window and operate as before, but are hidden by default. They can be re-enabled via the 'Filter' drop-down which provides various toggle buttons for the various additional controls :


How to scale unconnected edges using individual origins in python?

You might do something like:

import bpy
import bmesh

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

# current selection
edges = [e for e in bm.edges if e.select]

for e in edges:
    v1 = e.verts[0].co
    v2 = e.verts[1].co
    origin = (v1+v2) * 0.5  # edge origin
    bmv1 = bm.verts.new(((v1-origin) * 2) + origin)
    bmv2 = bm.verts.new(((v2-origin) * 2) + origin)
    bme = bm.edges.new([bmv1, bmv2])

bmesh.update_edit_mesh(obj.data, True)

I may be mistaken but I don't think at present the pivot point has any influence on bmesh.ops. So a slight modification of your original code gives a matrix to each new edge to scale: https://gist.github.com/zeffii/71862f5b1cad1bf1d2c1


When I use an overlay scene I use this method:

The level scene adds the overlay scene as overlay.
The overlay scene adds the level scene as background.

The BGE does not add an already loaded scene. Therefore you always get both scenes regardless what scene was the first one.

Attention: this will not work when you want to use the overlay scene with another level scene.


Emission does not show light haze with Cycles

Haze will not appear by magic, you have to put it there. It is not a quality of the object, but one of the environment where the lights are.
Even though we live in very polluted world, where there are so many suspended particles floating in the air, in the world of blender the air is totally clean and transparent.
Light in the air is only visible if you make it travel in an environment that simulates small particles floating. Such simulation is done by creating an environment with volume scattering.
In the world settings you can add volume scatter as volume material for the whole scene, or you have to create a large mesh that uses volume scatter as volume.
For more details read:
Atmospheric lighting in cycles
and
How do volume shaders interact with light?


How to copy nodes and their links from one node tree/material to another - in python?

After some experimenting, I couldn't find any way of doing this with bpy.data or with the operator for making a group, so I decided to write my own:
This operator takes in the name of the node group that should be created and then moves all selected nodes from the actives object active material in a node group with that name. It also copies all the links between the nodes and the property values. It doesn't just copy the input values but also dropdowns and similar options.

Here's the code:

class NODE_OT_MakeGroup(bpy.types.Operator):
    bl_idname = "node.group_make_no_context"
    bl_label = "Make Context Free Group"
    bl_description = "Make group from selected nodes without context"
    bl_options = { "REGISTER", "UNDO" }

    name: bpy.props.StringProperty( default="NodeGroup" )

    @classmethod
    def poll( cls, context ):
        """run operator only if an active object with an active material exists"""

        if context.active_object:
            if context.active_object.active_material:
                if context.active_object.active_material.use_nodes:
                    return True
        return False

    def get_selected_nodes(self,context):
        """returns a list of the selected nodes from the active objects active material"""

        nodes = []
        for node in context.active_object.active_material.node_tree.nodes:
            if node.select:
                nodes.append(node)
        return nodes

    def copy_attributes(self, attributes, old_prop, new_prop):
        """copies the list of attributes from the old to the new prop if the attribute exists"""

        #check if the attribute exists and copy it
        for attr in attributes:
            if hasattr( new_prop, attr ):
                setattr( new_prop, attr, getattr( old_prop, attr ) )

    def get_node_attributes(self, node):
        """returns a list of all propertie identifiers if they shoulnd't be ignored"""

        #all attributes that shouldn't be copied
        ignore_attributes = ( "rna_type", "type", "dimensions", "inputs", "outputs", "internal_links", "select")

        attributes = []
        for attr in node.bl_rna.properties:
            #check if the attribute should be copied and add it to the list of attributes to copy
            if not attr.identifier in ignore_attributes and not attr.identifier.split("_")[0] == "bl":
                attributes.append(attr.identifier)

        return attributes

    def copy_nodes(self, nodes, group):
        """copies all nodes from the given list into the group with their attributes"""

        #the attributes that should be copied for every link
        input_attributes = ( "default_value", "name" )
        output_attributes = ( "default_value", "name" )

        for node in nodes:
            #create a new node in the group and find and copy its attributes
            new_node = group.nodes.new( node.bl_idname )
            node_attributes = self.get_node_attributes( node )
            self.copy_attributes( node_attributes, node, new_node )

            #copy the attributes for all inputs
            for i, inp in enumerate(node.inputs):
                self.copy_attributes( input_attributes, inp, new_node.inputs[i] )

            #copy the attributes for all outputs
            for i, out in enumerate(node.outputs):
                self.copy_attributes( output_attributes, out, new_node.outputs[i] )

    def copy_links(self, context, nodes, group):
        """copies all links between the nodes in the list to the nodes in the group"""

        for node in nodes:
            #find the corresponding node in the created group
            new_node = group.nodes[ node.name ]

            #enumerate over every link in the nodes inputs
            for i, inp in enumerate( node.inputs ):
                for link in inp.links:
                    #find the connected node for the link in the group
                    connected_node = group.nodes[ link.from_node.name ]
                    #connect the group nodes
                    group.links.new( connected_node.outputs[ link.from_socket.name ], new_node.inputs[i] )

    def add_group_nodes(self, group):
        """adds the group input and output node and positions them correctly"""

        #add group input and output
        group_input = group.nodes.new("NodeGroupInput")
        group_output = group.nodes.new("NodeGroupOutput")

        #if there are any nodes in the group, find the mini and maxi x position of all nodes and position the group nodes
        if len(group.nodes) > 0:
            min_pos = 9999999
            max_pos = -9999999

            for node in group.nodes:
                if node.location[0] < min_pos:
                    min_pos = node.location[0]
                elif node.location[0] + node.width > max_pos:
                    max_pos = node.location[0]

            group_input.location = (min_pos - 250, 0)
            group_output.location = (max_pos + 250, 0)

    def execute( self, context ):
        """creates the node group, copies all attributes and links and adds the group input and output"""

        #create new node group
        group = bpy.data.node_groups.new( name=self.name, type="ShaderNodeTree" )
        #get the list of all selected nodes from the active objects active material
        nodes = self.get_selected_nodes(context)

        #copy all nodes from the list to the created group with all their attributes
        self.copy_nodes( nodes, group )
        #copy the links between the nodes to the created groups nodes
        self.copy_links( context, nodes, group )

        #add the group input and output node to the created group
        self.add_group_nodes(group)

        return { "FINISHED" }

I'm sure there are some improvements that could be done to this and of course, it's not a perfect solution because that operator basically already exists, but I think it's the best option while these are not working. I tried it with 2.83 and it seems to work fine for all cases I tested.

EDIT:
Here's a version that was better suited for my personal case. It has an additional parameter to specify a specific material. If it doesn't get a value for that parameter it defaults to the active objects active material. Otherwise, it's the same as the one above:

class NODE_OT_MakeGroup(bpy.types.Operator):
    bl_idname = "node.group_make_no_context"
    bl_label = "Make Context Free Group"
    bl_description = "Make group from selected nodes without context"
    bl_options = { "REGISTER", "UNDO" }

    name: bpy.props.StringProperty( default="NodeGroup" )
    material: bpy.props.StringProperty( default="")

    def get_selected_nodes(self,context):
        """returns a list of the selected nodes from the material"""

        nodes = []
        for node in bpy.data.materials[self.material].node_tree.nodes:
            if node.select:
                nodes.append(node)
        return nodes

    def copy_attributes(self, attributes, old_prop, new_prop):
        """copies the list of attributes from the old to the new prop if the attribute exists"""

        #check if the attribute exists and copy it
        for attr in attributes:
            if hasattr( new_prop, attr ):
                setattr( new_prop, attr, getattr( old_prop, attr ) )

    def get_node_attributes(self, node):
        """returns a list of all propertie identifiers if they shoulnd't be ignored"""

        #all attributes that shouldn't be copied
        ignore_attributes = ( "rna_type", "type", "dimensions", "inputs", "outputs", "internal_links", "select")

        attributes = []
        for attr in node.bl_rna.properties:
            #check if the attribute should be copied and add it to the list of attributes to copy
            if not attr.identifier in ignore_attributes and not attr.identifier.split("_")[0] == "bl":
                attributes.append(attr.identifier)

        return attributes

    def copy_nodes(self, nodes, group):
        """copies all nodes from the given list into the group with their attributes"""

        #the attributes that should be copied for every link
        input_attributes = ( "default_value", "name" )
        output_attributes = ( "default_value", "name" )

        for node in nodes:
            #create a new node in the group and find and copy its attributes
            new_node = group.nodes.new( node.bl_idname )
            node_attributes = self.get_node_attributes( node )
            self.copy_attributes( node_attributes, node, new_node )

            #copy the attributes for all inputs
            for i, inp in enumerate(node.inputs):
                self.copy_attributes( input_attributes, inp, new_node.inputs[i] )

            #copy the attributes for all outputs
            for i, out in enumerate(node.outputs):
                self.copy_attributes( output_attributes, out, new_node.outputs[i] )

    def copy_links(self, context, nodes, group):
        """copies all links between the nodes in the list to the nodes in the group"""

        for node in nodes:
            #find the corresponding node in the created group
            new_node = group.nodes[ node.name ]

            #enumerate over every link in the nodes inputs
            for i, inp in enumerate( node.inputs ):
                for link in inp.links:
                    #find the connected node for the link in the group
                    connected_node = group.nodes[ link.from_node.name ]
                    #connect the group nodes
                    group.links.new( connected_node.outputs[ link.from_socket.name ], new_node.inputs[i] )

    def add_group_nodes(self, group):
        """adds the group input and output node and positions them correctly"""

        #add group input and output
        group_input = group.nodes.new("NodeGroupInput")
        group_output = group.nodes.new("NodeGroupOutput")

        #if there are any nodes in the group, find the min and maxi x position of all nodes and position the group nodes
        if len(group.nodes) > 0:
            min_pos = 9999999
            max_pos = -9999999

            for node in group.nodes:
                if node.location[0] < min_pos:
                    min_pos = node.location[0]
                elif node.location[0] + node.width > max_pos:
                    max_pos = node.location[0]

            group_input.location = (min_pos - 250, 0)
            group_output.location = (max_pos + 250, 0)

    def execute( self, context ):
        """creates the node group, copies all attributes and links and adds the group input and output"""

        #set material if not given
        if not self.material:
            self.material = bpy.context.active_object.active_material.name

        #create new node group
        group = bpy.data.node_groups.new( name=self.name, type="ShaderNodeTree" )
        #get the list of all selected nodes from the active objects active material
        nodes = self.get_selected_nodes(context)

        #copy all nodes from the list to the created group with all their attributes
        self.copy_nodes( nodes, group )
        #copy the links between the nodes to the created groups nodes
        self.copy_links( context, nodes, group )

        #add the group input and output node to the created group
        self.add_group_nodes(group)

        return { "FINISHED" }


TL;DR: Yes, you can use the AMD Radeon Pro 5300M for GPU rendering with the AMD Radeon™ ProRender, if you're using macOS 10.13.3 or later.

There are two relevant requirements:

The minimum requirements for running Blender
The minimum requirements for AMD Radeon™ ProRender for Blender

Minimum requirements for running Blender (2020-08-07)
You will need macOS 10.12 or later for starting Blender 2.8x and macOS 10.13 or later for Blender 2.90. Additionally a GPU is needed that is GCN first generation or later, which is the case for your GPU from the Radeon Pro 5000M series.

Minimum requirements for AMD Radeon™ ProRender for Blender (2020-08-07)
According to AMDs website the following requirements have to be met:

Blender® 2.80, 2.81, 2.82, and 2.83 (experimental builds not supported) for Microsoft Windows®, macOS®, and Linux®

macOS® High Sierra 10.13.3 and up (10.13.4 required for external GPU support)

Runs on both GPUs and CPUs. OpenCL™ 1.2 support required for GPUs on Windows® and Linux®. Metal® 2 support required for GPUs on macOS®

Compatible Apple® Mac® Hardware:

MacBook® (Early 2015 or newer), MacBook Pro® (Mid 2012 or newer), MacBook Air® (Mid 2012 or newer), Mac mini® (Late 2012 or newer), iMac® (Late 2012 or newer), iMac Pro™ (Late 2017 or newer), Mac Pro® (Late 2013 or newer) (Models without discrete AMD Radeon™, Radeon™ Pro, or AMD FirePro™ graphics will be limited to CPU rendering with Radeon™ ProRender)

In summary, if you fulfill the following requirements, you're able to GPU render with the AMD Radeon™ ProRender:

MacBook Pro is from mid 2012 or later
Operating system is macOS 10.13.3 or later
Blender version is 2.80 or later, but not 2.9x yet


Let's say, you want to add an image to Cube. Select Texture Tab -> Base Color -> Image Texture

Now select Open an Image required. Image will apply to Object.


What are the keyboard shortcuts on Mac OS for blender?

Keyboard shortcuts can be found and edited in menu File -> User Preferences -> Input tab:

PS. don't forget to press Save User Settings, after making changes here.


Why does an object with a particle system not appear in the render?

Your wolf is emiting particles, but you have to check "Emitter" in particles render settings to make it renderable.


how do i fill a blank keyframe with the keyframe that precedes it(note there are thousands of blank frames)?

answer based on previous question

import bpy
import math
bpy.ops.object.mode_set(mode = 'OBJECT')
bpy.ops.object.select_all(action='SELECT')

# get keyframes of object list
def get_keyframes(obj_list):
    keyframes = []
    for obj in obj_list:
        anim = obj.animation_data
        if anim is not None and anim.action is not None:
            for fcu in anim.action.fcurves:
                for keyframe in fcu.keyframe_points:
                    x, y = keyframe.co
                    if x not in keyframes:
                        keyframes.append((math.ceil(x)))
    return keyframes

def get_without_keyframes(frames):
    s = bpy.context.scene.frame_start
    e = bpy.context.scene.frame_end

    k =[]

    while s <=e:
        if s not in frames:
            k.append(s)

        s+=1

    return k

# get all selected objects
selection = bpy.context.selected_objects

# check if selection is not empty
if selection:

    # get all frames with assigned keyframes
    keys = get_keyframes(selection)

    # print all keyframes
    print ("WHIT: ",keys.sort())
    print ("WHITout: ",get_without_keyframes(keys))

    # print first and last keyframe
    print ("{} {}".format("first keyframe:", keys[0]))
    print ("{} {}".format("last keyframe:", keys[-1]))

else:
    print ('nothing selected')


It looks like you may have something selected that isn't a mesh. Try deselecting by pressing A until nothing is selected, then select the meshes you want to join.


Spherical / Custom projection at code level

I am not sure if it can be down in Python. But definitely possible in C.

Blender Cycles support non-planar lenses ala fisheye. You can find the user documentation for it on the wiki.

A walkthrough (and patch) from the developer who implemented this feature can be found on Dalai Felinto's website.


Just to illustrate moonboots's comment.

Use Noise texture with a Bump node.
Set Bump node Distance to around 0,001 or less (1 milimeter)
Done.


You have overlapping vertices and edges in your example.
The easiest way to fix this would be to select every vertex in your mesh, press m, and then select merge by distance.


Default settings, just changed stiffness has indicated below:


How to hide an object in front of a mask instead of behind it?

You can enable the X-Ray option of the Cube and the green mesh, so they will be visible infront of the red mesh as shown below:

As shown below I made a scene with a red monkey and a green cube where the monkey is in-front of the cube.

This is the result of the rendering:

To avoid the red monkey from appearing while rendering then you un-click the render button of this object as shown below:

This will be the result of rendering:


How can I show the GLSL code generate by node?

The easiest way to insert your own data into a node shader is to use vertex or object color (max of 3 floats each = 6 floats). Other than that you can either:

Use an image as an input, using a specific UV
lookup, and then using python to set a pixels colour.
use your own GLSL shader (which means you have to do all the lighting
yourself, and real time shadows become hard),
create your own node (which involves recompiling blender itself).

I wish there were a better way than the three above, but if there are, I am unaware of them.


Move selected faces/verts towards 3D cursor without scaling

You can snap it to the cursor using Shift + S and select "Selection to cursor (offset)".


Local View with background images in2.8?

As of today, there are no ways to do that.

I posted a request on the Empty Images topic, asking the devs to add an option for that.
Hopefully, this will be done, in which case I'll update my answer accordingly.


Add a sphere, copy it, scale it down in edit mode

Select the big sphere, go to the Object panel, under Duplication select Verts

Select the small sphere, hold shift, then select the big sphere. Hit CTRL+P and set the paren to Vertex

Result should look like that

You can now go select the big sphere again and go to edit mode, select all vertices. Use the "Randomize" option, I used a setting of 0.06.

You can use the Object info -> Random input together with a Math node to give them different colors.

This isn't an accurate representation of an atom I guess, but you said it's about simplicity and the visualisation aspect.

P.S.: If you are worried about the top / bottom of the result, as there are more spheres, you can try another type of sphere for the big sphere, e.g. the icosphere, that has an even distribution of vertices.


Shape keys are for when the modeling is done. Don't start adding shape keys and then expect to be able to add verts, edges or faces later. You may still move verts around a little, but results are sometimes unpredictable.

https://blenderartists.org/forum/showthread.php?303554-Editing-the-Basis-shape-key-after-making-shapekeys

Can I fix broken shape keys after editing basis?


It appears you might have unintentionally set your sampling settings really low. Go to: Properties>Sampling>Settings>Clamp Dir: and set it to 0 (off) or a much higher setting than 0.01.

Please see this answer for more details: What is Clamp Direct/Indirect?


Objects are scaling along global axes instead of local (even after setting Transformation Orientation to “Local”)

To do local scaling push S and then the axis you want to scale on twice.
So to scale along the local X you push S XX.


Is it possible to scale and rotate the 'image for clone tool'?

The answer is "no", you cannot rotate the clone source in the Image Editor. But an alternate is available that DOES allow you to rotate and scale your image source, and that is by loading the clone source instead as a Brush Texture in the properties panel while using the TexDraw brush (default texture paint).

The Texture then needs to be set to 'Stencil' in the tool bar Texture panel. Zoom out, and then move the stencil with RMB, scale it with Shift-RMB, and with Ctrl-RMB you can rotate it. The same thing can be done with the Texture Mask set to Stencil, but use Alt-RMB to move, Alt-Shift-RMB to scale and Alt-Ctrl-RMB to rotate.

This same set up works in the 3d view for painting directly on your 3d textured object. Have some fun!

edit: Also you can use the Stencil Widget by Kgeogeo that allows to use a lot of controls on the stencil texture/texture mask


Coordinate XYZ limitation of 10,000 - Workaround questions

The limitation is on size of objects, not actual vertex location.
And according to this answer, there's no way around it.
The limit is actually ±10 000, so the maximum size of objects is 20 000 BU.

Workaround

Move your origin point.
Since the zero point for this limitation is object's origin point, you can make a mountain 20 000 m high, by moving the origin point higher.

Funny sidenote:
It's actually 10 000 Blender units (which correspond to meters), so for Imperial units, the limit is 32808.4 ft.


Found the solution. In Blender 2.7x there was a separate Drivers section in the Graph Editor, but in Blender 2.8 it has been decoupled from the Graph Editor and now has its own dedicated Drivers editor.


3D Cursor appears to be invisible while 2D animation mode / 2.82

You mean the window on the left? You need to turn on overlays first, the cursor should be enabled by default, but check the box if it isn't. This works the same in other viewports as well, but overlays are usually enabled by default.


In Blender Render engine you may achieve it using the material nodes.

Being in Edit Mode unwrap your mesh (press U-->Project From View).

Create some materials- basic Orange and Pink materials (the ones you want to blend), Transition (this material'll be used for blending the ones above using material nodes) and Gradient (this'll be used to create a gradient texture for blending materials).

With Gradient material selected go to the Texture header, set the texture type to Blend, check the Ramp checkbox in Colors panel, then press the Linear and Vertical buttons in Blend panel. Also set the Mapping coordinates to UV. Your gradient texture is now ready.

Now select the Transition material and press Use Shader Nodes button.

Go to Node Editor and set up nodes as pictured below. First add two Material nodes- the Orange one and Pink one (Shift+A-->Input-->Material) and mix it using MixRGB node (Shift+A-->Color-->MixRGB). Use the Texture node (previously created Gradient texture) as a factor for blending. Plug in the UV output of the Geometry node (Shift+A-->Input-->Geometry) to the Vector input of the Texture node as shown below.

Now you may manipulate the transition between materials (go to the Texture header of the Gradient material and play with the sliders in Colors panel for different results).


Cycles noise no matter what I do, and the denoiser makes it look cloudy

Denoising works well only at high resolutions, in my experience from 4k. Try putting more samples, or increasing the resolution and using denoising. I rendered a scene with different light sources on 512 samples.
In addition, you can see examples of different samples and noise effect here Will increasing samples reduce fireflies?

1000:1000px; 128 samples and denoising.

1500:1500px; 256 samples and desoising on compositing tab.
As far as I know, sometimes denoising in the compositing tab, for some reason, works differently than in setting the view layers :)


How to ensure that two objects do not intersect before collision?

Short Answer: Switch the collision shape on each object to Box, and you're good to go.

Long Answer:

Poor collisions are generally due to a combination of a few things:

First is the precision of the simulation. Increasing the quality of the simulation should help, but this will slow down the simulation considerably. Usually you can get away without increasing the simulation precision.

Second is the density of the colliding meshes. A subdivided plane has more geometry to work with, and will collide better than a plane. In your file, adding 3 edge loops on the X and Y axes of the floor object gave the simulation enough geometry to run perfectly. This isn't always the best solution of course, as often times dense meshes are undesirable.

Final thing is how the collisions are being calculated. Blender has a number of different collision shapes that can be used. The geometric shapes (box, sphere, etc.) will always be the most stable as they are the most simple. In your case, both your objects are boxes of some form, so using box collisions will be best. Testing this confirms this, as switching both to Box fixes the collisions and the simulation is very stable as well.

The other types of collisions can work as well, and using the Mesh option (which uses the actual shape of the mesh as the collision object) on each object did give decent collisions, but they were far from perfect. Adding some more geometry to the floor object did help significantly though when using Mesh. Convex Hull (which uses a collision object that is always convex while still fitting the object as best it can) doesn't appear to work at all in your case, as it seems to do a poor job of determining a good collision shape for a box like object. Adding a bit of geometry and changing the shape to be slightly rounded made it work great though.

More information on the collision types can be found here (about halfway down).

It is almost always the best case to keep the simulation as simple as possible, and to use the simplest collision shapes possible so that Blender has to do the fewest calculations, which will also keep your simulation nice and fast.


Animation Nodes -> splines generated and how have a random material color for each spline?

There are several methods:

In blender 2.82, In geometry node there is a socket "random per island", that will generate color for separated meshes within the same object. Be aware, currently this socket can only work for cycles, not possible in eevee.

while using "curve object output" node, it's preferred in a loop, and input an object list. Since you are making them multiple objects, you can use "object info - random". This method allows you work in eevee, and transform different splines separately.

Must a method over the other? I don't think so.

Edit:
Specifically in particle tracing, it's exactly the same principle. You are outputing multiple splines, before you curve object output anything, simply generate a loop that input iterators of object list and spline list. and it will solve the problem.


Select boundaries of uv islands in 3d viewport

as a workaround found this option, not a perfect solution if you already have edges marked as seams and you need them. hope to see the proper answer


How to assign different materials to different colors in a texture?

You can make a mask texture. This kind of map is black and white, where black means 0, and white means 1. So if you plug it into a Mix Shader node with your blood and steel materials like so:

The black areas of the mask texture will indicate steel material, and white will indicate the blood material. So paint the steel portion of your mesh black and paint the blood portion white, and they will have separate materials.


yes then maybe drag it to the location by hand to where you want it at..

or try to read the code... i mean the following line seems to be pretty much self explanatory and the author of the article mentioned above (duplicate) also tells you that you can easily offset the position to your liking using his code ;)

bpy.ops.object.text_add(location=(0,idx*2,0), rotation=(0,0,0))


How do I align particles to the center of the object?

I found the answer to my own question... lol

So here it is, it can be of help to any of you, or so I hope.

In short, you have to rotate the object (particles) in the X-axis -90º so it looks as it’s shown in the following image.

Then you just go Control+A, Apply Rotation and then you have it!


Creating a Curved/concave shape from a flat surface

Seeing your reference, the TV tube s not so "spherical", so I won't start from a sphere. I tried to get something like that:

in a very simple way.

I created a vertical plane, and subdivided it about 40 times.
then I added a lattice object all around the plane
adjusted lattice subdivision settings: U:1, V:5, W:3
applied a lattice modifier to the plane mesh, targeting lattice object of course
then pulled some "front" lattice vertices outwards, obtaining a soft, uniform deform to the plane
built a rough tv set box around the deformed plane

I can't detail more all steps now, I'm in a hurry, but I provide a sample .blend below, so you can see the setup. Let me know if you need more detail.


Why does Blender not save multichannel OpenEXR?

I found this very useful answer on stackoverflow, worked like a charm for me..

The clue is to include write_still = True explicitly in the render command.
Also, unlinke for 1-channel openEXR, the filename is not determined by the name of the terminal of the file output node. Now that I come to think of it, this is in fact logic since the terminals should determine the keys that are included in the exr file header. For 1-channel exr there is only 1 channel, thus only in that case the key can also specify the file name.

My last two lines now look like this:

bpy.data.scenes["Scene"].render.filepath = '//Rendered images/Test/im_%s' % index
bpy.ops.render.render(write_still=True)


Constraint camera to move with object's bone

A ChildOf constraint allows you to parent an object to another with the ability to turn off some of the transformations that are copied.

To have the camera move with the character and allow the head/shoulders to rotate within the camera view, you turn off the rotation options in the constraint. You just need to pick a bone that you want to follow, maybe the shoulders or hips depending on how much of the character you want to move in front of the camera.

When you first choose the bone, the camera may jump out of place, click the Set Inverse button to fix this. You can also move the camera into position after you add the child of constraint

Here the camera has a ChidOf constrained set to the selected bone, you can see it follows the bottom point of the bone but doesn't rotate with it.


Cryptomatte - What Crypto00, Crypto01, Crypto02 means?

In order to explain to sockets and their numbering I'll have to explain how Cryptomatte and some aspects of path tracing work.

The Idea
Cryptomatte generates ID mattes which try to preserve for each pixel of the rendered image what elements of the 3D scene contributed
to it. For instance in a render with motion blur, pixels where the moving object and background object blend into each other are
influenced by both objects. In order to understand how Cryptomatte identifies and stores this information, we have to take a look at
how the rendered image is created.
Rendering using a path tracer such as Cycles works roughly in the following way:
In order to create the rendered image we sample multiple paths per pixel at subpixel location from the camera into the scene. The sampling is
quasi-random using either the Sobol sequences or correlated multi-jitter. For each path we check if it intersects with an object, if it does,
we remember the hit point. Next we chose a random point on one of the light source and try to connect
it to the hit point. This is an optimization known as Next-event prediction. If a direct path from the hit point to a light source is
possible we can evaluate the shaders along the path to the camera and we receive an RGBA value. In case a connection to a light source isn't possible, we bounce with
a new path segment from the hit point in a quasi-random direction and repeat the process until we either hit a light source or exceeded the maximum
bounces. Cycles therefore uses Quasi-Monte-Carlo integration. In order to fuse the multiple samples per pixel in the camera plane into a final RGBA value
we use a pixel filter which weights and sums the subpixel samples. Cycles uses either a Blackman-Harris, Gaussian or Box filter.
This is a very simplified and shortened explanation, for a more detailed introduction I recommend watching Lukas Stockner's talk
from the Blender Conference 2019. The important part for Cryptomatte is that there are multiple samples per pixel,
that may hit different objects and which therefore contribute to the final pixel.
The idea behind Cryptomatte is that we can leverage the scene and path tracing information to create ID and coverage pairs per pixel,
where the ID references the element that contributed to the pixel and the coverage tells how much. This allows us later on to determine
which pixel and by what amount was caused by a certain object or material.
There are three elements Cryptomatte can store ID mattes for: Objects, materials and namespaces (hierarchical groups of objects, which is the Assets option in Blender).
IDs are generated by hashing the object/material/namespace's name and are stored per sample in so called arbitrary output variables (AOV).

Filtering and Encoding
Each pixel in the render is the result of the weighted sum of its samples, where each sample belongs to an ID.
The weights are given by the pixel filter, such as Blackman-Harris or Gaussian filter. There can be several samples per pixel
that belong to the same ID.
The weight of the samples that belong to the same ID are accumulated per pixel.
Normalizing the value gives the coverage of the ID-coverage pair for that pixel. For every pixel the pairs get ranked by their coverage,
rank 0 is for the highest coverage. They are then assigned to the corresponding pixel in the layer that contains said rank.
Note: Each rank is essentially a matrix that contains an ID-coverage pair for every pixel. Since the assignment of ID-coverage pairs to ranks is done per pixel, IDs for a specific object may be found across several ranks for different pixels.
Multi-layer OpenEXR files are used as data structure for storing the files. Each of the AOVs is stored in a separate file.
IDs and coverages are stored each in their own channel. Since
OpenEXR has RGBA channels there are two ranks per layer.
Layer 1

CryptoObject00.r - ID rank 0
CryptoObject00.g - Coverage for ID rank 0
CryptoObject00.b = ID rank 1
CryptoObject00.a = Coverage for ID rank 1

Layer 2

CryptoObject01.r - ID rank 2
CryptoObject01.g - Coverage for ID rank 2
CryptoObject01.b = ID rank 3
CryptoObject01.a = Coverage for ID rank 3

Layer 3

CryptoObject02.r - ID rank 4
CryptoObject02.g - Coverage for ID rank 4
CryptoObject02.b = ID rank 5
CryptoObject02.a = Coverage for ID rank 5

Metadata in the file stores the original name of the elements and the hash method used along other information.

Matte
Given a name of an object/material/namespace we can compute the ID using the hash function documented in the metadata.
All that is necessary to create the matte is to iterate through the ID coverage pairs and retrieve the coverage per pixel.
If a single matte for multiple IDs is requested the coverage of the IDs is summed.

Answering your questions
What are levels?
Levels are the number of ID-coverage pairs per pixel. Therefore the levels determine how many unique objects can be differentiated per pixel. It should be a multiple of two, since levels divided by two is the number of layers in the Multi-layer OpenEXR.

Why are there three input sockets on the Cryptomatte node?
The three sockets are for the recommended three layers to store the six ID-coverage pairs per pixel. You can add additional layers in the sidebar
in the Item tab in the Properties panel.

Why are the output sockets of the Render Layers named like that?
I believe this is an error, since they get properly named internally in BlenderSync::sync_render_passes() (blender_sync.cpp) however
register_passes() (engine.py) does an increment by two. This is correct in regards to the number of render passes, since there are two ranks per layer. However the names should still use consecutive numbers and match the ones of the Cryptomatte node.
I've created a post on DevTalk to discuss this with the developers.
Update: The numbering has been fixed by commit rB3f3d1ad4800c6d5e9d1a45912841b118cbac9f39

Why should I connect more than the first render pass and why does it work when only connecting the first?
It depends how many unique objects you'd like to differentiate per pixel. If you connect the first render pass, then the cryptomatte node can only create a matte which contains the coverage of two objects per pixel at most, since you pass two ranks into it. This will likely be enough for most simple compositing tasks. For more challenging scenes with multiple objects that have motion blur and cross paths which each other, you'll want to use the additional passes as well.

References
Cryptomatte Specification Version 1.2.0
Friedman, Jonah, and Andrew C. Jones. "Fully automatic id mattes with support for motion blur and transparency." ACM SIGGRAPH 2015 Posters. ACM, 2015.


Bump map is not affected only my unwrapped faces

I fixed a little bit by duplicate the rubber's material, added only on the second one the bump map and assigned this to selected faces, but in this way if then I will change some settings of the rubber's material (the first one) I have to copy every single new setting to the bumped material.


Split row inside of pop up panel while keeping formatting

use colum_flow(x) and col.label("for the text")
(colum must be equal to get a nice look)

else:
            #C/S Sharpen Split Option
            layout = self.layout
            row = layout.row(align=False)
            split = row.split(percentage=0.5)
            col = split.colum_flow(2)

            Ssharpen = icons.get("Ssharpen")
            CSharpen = icons.get("CSharpen")

            col.operator("ssharpen.objects", text = "(S)", icon_value=Ssharpen.icon_id)
            col.operator("csharpen.objects", text = "(C)", icon_value=CSharpen.icon_id)

it is not exactly what you want, but near...

import bpy

class SimpleCustomMenu(bpy.types.Menu):
    bl_label = "Simple Custom Menu"
    bl_idname = "OBJECT_MT_simple_custom_menu"

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

        layout.operator("object.duplicate_move", text="Duplicate")
        layout.label("1. use for text")
        layout.label("2. use for text")
        layout.label("3. use for text")

        layout.operator("object.duplicate_move_linked", text="Duplicate Linked")
        layout.operator("object.duplicate_move_linked", text="Duplicate Linked")
        layout.operator("object.duplicate_move_linked", text="Duplicate Linked")
        layout.operator("object.duplicate_move_linked", text="Duplicate Linked")

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

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

if __name__ == "__main__":
    register()

    # The menu can also be called from scripts
    bpy.ops.wm.call_menu(name=SimpleCustomMenu.bl_idname)


The Subdivision Modifier Keeps Causing My Models To Warp Inside Of Itself

The topology of your model is not suitable for subdivision surface. Subsurf works best with quads, and the entire side of your gun model is made up of ngons.

If you are looking for a quick way to chamfer the edge of the model, consider using a bevel modifier, which works nicely with ngons.

(Excuse the ridiculous model, hacked it together on a laptop in 30 seconds.)


Is there a "copy on a support" function in Blender

Use Dupliverts

From the blender manual:

  Duplication Vertices or DupliVerts is the duplication of a base object at the location of the vertices of a mesh. In other words, when using DupliVerts on a mesh, an instance of the base object is placed on every vertex of the mesh.

Alternatively use DupliFaces:

  Duplication Faces or DupliFaces is the capability to replicate an object on each face of a parent object.


What happens if I chose CPU, but with a GPU specified in settings?

The option in the preferences controls which OpenCL/CUDA compute device will be used when the GPU option is chosen in Properties > Render.

Why this is arranged so confusingly is due to history. Originally cycles only had CUDA support, and so was a natural assumption that the "compute device" chosen in the preferences was a GPU (or GPUs). Since OpenCL can work on CPUs, it's possible you could end up using OpenCL on your CPU when GPU is selected in Properties > Render.


Blender scripting: Subdivided vertices with Catmull-Clark

It seems this question already answers how to apply a modifier; if you still get the parameters of a modifier, here's how:

import bpy

for ob in bpy.context.selected_objects:
    for mod in ob.modifiers:
        if mod.type == 'SUBSURF':
           print("Subsurface modifier (\"%s\") in object \"%s\", with view level %s and render level %s." % (ob.name, mod.levels, mod.render_levels))
           bpy.ops.object.modifier_apply(apply_as='DATA', modifier=mod.name)

The above script will print to the console the level of all Subsurface modifiers in all selected objects, and their names.
Then it will apply the modifiers, so that you can get the coordinates of each vertex.


Place a plane on the axis you want (for instance x, z).

Add a shrinkwrap modifier to your mesh and set this plane as target object (mode = 'nearest surface point').

Of course you can also scale to zero along an axis... but the shrinkwrap allows to do it in a none destructive way and to project to any plane.


Object fade out while going from point A to B in animation

Add a Mix shader connected to

your material
a 100% white Transparent BSDF shader

Then keyframe the Mix factor ("Fac:"):

set it to 0.00 when you want the fading effect to start. Then, having your pointer over the value input, hit I (the box becomes yellow)
then move to the frame where you want the fading out effect to be completed. Set the value to 1.00 and hit I again.

If you want to make the "Fac:" dependent on the distance from another object (an Empty representing point "B"), you can use drivers as in the answer to this question: Cycles Node to tell Distance from an Empty


Is seems that you accidentaly found a bug report on the addon you want to download. There is no download button. To browse available addons go to the Scripts Catalog. In case of the sapling addon it wouldn't be neccesary (see @cegaton's answer).

On the addon's page you find a download link:

For installation see:

http://wiki.blender.org/index.php/Doc:2.6/Manual/Extensions/Python/Add-Ons
Installing an addon


Python 2.8 - forcing the correct instance of the image/uv editor

You do not need to mess around with the UI or change the layout at all if all you want to do is update a piece of data within an object.

You can dig down into any variable's type interactively in the scripting console without even having to look up the documentation. Autocomplete via ctrl-space, or calling dir(obj) and type(foo) describes just about anything.

So all you need to do is dig down to find where the UV coordinates are stored, and multiply them directly.

Here's how that would look for your script.

import bpy

bpy.ops.mesh.primitive_cylinder_add(vertices=32, radius=0.2, depth=30, enter_editmode=False, location=(0,0,0))
TextureFolder = 'G:\\Blender\\Textures\\'
TextureFilename = 'wildtextures-zinc-galvanized-metal-sheet.jpg'

def obj_material_texture_UVscale(objname, filename, Xscale, Yscale, Zscale):
    path = TextureFolder+filename
    materials = bpy.data.materials
    material = materials.get('mat')
    if not material:
        material = materials.new('mat')
    material.use_nodes = True
    if material.node_tree:
        material.node_tree.links.clear()
        material.node_tree.nodes.clear()
    nodes = material.node_tree.nodes
    links = material.node_tree.links
    output = nodes.new(type = 'ShaderNodeOutputMaterial' )
    diffuse = nodes.new(type = 'ShaderNodeBsdfDiffuse' )
    imgTex = bpy.data.images.load(path)
    node_texture = nodes.new(type='ShaderNodeTexImage')
    node_texture.image = imgTex
    node_texture.location = 0,200
    tex_coord = nodes.new(type = 'ShaderNodeTexCoord')#NEW
    links = material.node_tree.links
    link = links.new(tex_coord.outputs["UV"], node_texture.inputs["Vector"]) #NEW
    link = links.new(node_texture.outputs[0], nodes.get('Diffuse BSDF').inputs[0])
    link = links.new( diffuse.outputs['BSDF'], output.inputs['Surface'] )
    obj = bpy.data.objects[objname]
    obj.active_material = material
    bpy.ops.object.select_all(action='DESELECT')
    bpy.data.objects[objname].select_set(True)
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.uv.smart_project()
    bpy.ops.object.mode_set(mode='OBJECT')

    # Just directly scale the UVs!
    cyluvs = obj.data.uv_layers[0].data
    for cuv in cyluvs: # each is a bpy.types.MeshUVLoop
        cuv.uv[0] *= Xscale
        cuv.uv[1] *= Yscale

# len(o.data.uv_layers['UVMap'].data) -> 192
# Each of these is a bpy.types.MeshUVLoop
# which has .uv, .select, .select_edge, .pin_uv.
# item.uv is a Vector. We can just scale its Y 30 times!

obj_material_texture_UVscale('Cylinder',TextureFilename,1,30,1)


don't worry, with training you can do much better. try to see how others model or what they use. I'm not a hardsurface modeler but here is my solution to this shape using box modeling:

use bevel when you can. or other modifiers.

other method includes but not limited to:
modeling with boolean (for easier workflow try hard-ops or booltool addons) then retopology it.


With current blender versions, you can create multi-dimensional custom property fields.
These will look this:
You create them by setting the value on your custom property to this format:
[0.2, 0.4, 0.3]

Be sure to set your color value to the correct type, the default is "linear", for RGB values "gamma-corrected" is usually what you would want.
You can then draw this property anywhere in the blender UI, if you wish. This is a short breakdown on the naming conventions

If you want to use this to drive a material color on an object, so the color picker actually influences the color of a part of a model, you should set up a RGB-node in the Shader-Node-Tree (the Shader Editor).
Open the input field for the color and then add a driver to each color channel.

To access the channels as driver input variables, use the following pattern:
["NameOfCustomProperty"][NumberOfChannel]

or in an example
["color_ball"][0]

this would give the red channel.
["color_ball"][1]

this would give the green channel.
["color_ball"][2]

this would give the blue channel.


In the World section of the Material nodes add a Texture Coordinate node and a mapping node to control the placement of the Environment texture. By changing the rotation on the mapping node you can place the HDR where you need it.

As of Blender 2.8x, the World section is part of the new Shader Editor:


How do I print something to the console when using the game engine?

You need to import GameLogic before you can use it, print statement has been replaced by a function in python3 print( arg ).
This works:
import bge
import GameLogic
cont = GameLogic.getCurrentController()
print(dir(cont))

or alternatively
cont = bge.logic.getCurrentController() # bge.logic is automatically imported
print(dir(cont))

Note that the script wouldn't work in the python console (Editor Type) only when wired in the logic editor.

The output goes to console opened via main menu: Window / Toggle System Console
Related:

Is it possible to dump an Objects Properties and Methods?


When Animating, how do we only move the parent of an object without the children moving along its parent?

Need the parenting to rotate multiple sphere and also move it around to create another formation while animating. Something like the picture below


selecting and moving lamp using right mouse button

The selection behavior in the user interface has changed significantly between versions 2.79 and 2.80 of Blender (as well as many other changes to the user interface).
Use the Help/Tutorials menu option within Blender to like to official online tutorials
and resources that will be suitable for the appropriate version of Blender.


Depending on the situation, which is sadly not possible to see here (it could help if you attach a picture of your view), i would recommend to press Numpad Decimal or go in the "View" Menu and click on "Frame Selected".

If you zoom in enough on a small detail, the amount of movement with the mouse seems to get drastically reduced.

Once you use "Frame Selected" Numpad Decimal or even "Frame all" with Home, you should have a normal responsiveness of your mouse navigation in the 3D Viewport.


Your mesh is super messy, you have a lot of inner faces + you need to join vertices to make nice quads and edge loops all around the legs.


Modelling one irregular surface to fit against another

Use the Shrinkwrap modifier with vertex groups.
Select the cushion you want to deform add a shrink wrap modifier, in the target option select the second cushion, change the order of the modifier to make sure the shrinkwrap modifier is below the subsurf modifier, then in edit mode (for the first cushion) select the vertices thats touching the second cushion and add them to a vertex group(go to object data properties, select the plus sign under vertex group, rename the group if you want, then with the desired vertices selected in edit mode click on assign), deselect everything and click the select button under the vertex group option to make sure only the desired vertices are part of the vertex group, then in the shrinkwrap modifier, under the vertex group options select the vertex group you just created.
And you should be good. Just make sure not to move the second cushion cause it is using it as a reference, if you do the first cushion would get distorted.


Why does the outside of my glass of coffee look strange?

Did you do the part where you slightly scaled up the liquid so it overlapped the glass a little bit?  That's what it looks like to me.


How can I hide all the animation controls?

Either change the view type

or just combine one view with another by right clicking the edge between them


In properties window, go to "Output" tab.
Find "Output" heading within that tab.
Check the "File Extensions" box (which is below the Output save path entry).


Retopology and baking normals for double-sided (thick) clothes from Marvellous Designer workflow

This works to some extent:

Flip the normal of the inner faces
Bake the Object Space normal
Connect it in your material shader graph, even though your normal is in Object Space, use Tangent Space in your Normal Map node.
Create a new image, select it and now bake the normal map, but this time use Tangent Space.

If anyone knows the better workflow, please share it :)


Keyboard shortcuts 1,2, and 3 not working in edit mode

Oops. I read the question wrong, I don't know any way to change between modes without doing it manually. Select between the circled things to switch between Vertex select, Line select, and face select. I don't think you can use 1, 2, 3 keys to switch them.


Is it possible to render other materials besides volumes using a procidural texture to define "density"?

BSDF surface shaders only works on 'real surfaces', i.e. faces that are part of a mesh.  Surfaces inside a volume created by change in density will not be treated or rendered with a BSDF surface shader.

This image might be able to show you what I mean. The geometry has a volume shader and a glossy shader, driven by a checkered texture. Notice the shiny material is correctly applied only to the outside surface of the mesh. Interior surface boundaries remain non-glossy.


how to drag , move , elongate object in blender on mac

On a Mac Book Pro in the Blender “Outliner” move your cursor with the scratch pad over an object and while pressing “Command” and then clicking the scratch pad will open a drop down menu with options including “Delete”.

With your cursor in the 3D Viewport pressing “N” will toggle on and off transform options. In “Object Mode” move your cursor to an object in the 3D viewport and then while pressing the “Command” key click the object with the scratch pad to select it. Then hover your cursor over the appropriate Transform input field and click in it with the scratch pad. You can then enter numeric values to make changes in your object.


From Blender Manual: https://docs.blender.org/manual/en/2.92/editors/3dview/navigate/regions.html#render-region
Render Border is rendering part of your scene when you're in rendered shading mode. If you want a rendered result you'll have to set up a camera for that view.


Procedural wrinkled paper lamp cycles material

Ok, so here's what I could come up with. This is what I could achieve with materials only. Not good enough for closeups, but perhaps enough for far-off objects or to save resources.

With modelling I got to this. It's not perfect, couldn't figure out a way to automatically make them not intersect, but its a reasonable time/effort/fidelity ratio.

Star of with an Icosphere, subdivide it enough, for the desired level of detail, then add a Decimate modifier.

Apply the decimate modifier, enter Edit Mode and in Edge Selection Mode with the Random Select operator select any number of edges around 50% to 60%.

Bevel those edges, then extrude them outwards with Alt + E > Region (Vertex Normals).

Add a Subsurf modifier on top, and you are good to go. Material is the same as above without all the texture work.

Additionally you may use Proportional Edit with a Random falloff type, to scale all vertex outwards, and/or rotate them slightly, and give it a more irregular look. Use a fake loose vertex, placed at the center of the sphere, selected for scaling, then use the 3D Cursor as center of transform and increase the influence radius as necessary.


How do I set a texture as the world background in the game engine?

You could do this with a sky box, or a sky dome - the process is basically the same. In my opinion, sky domes look better than sky boxes, so I'll tell how to do that.

First step - add a sphere. Enter edit mode, and make it big. really big. (about as big as the sky) Select all faces, and click "flip normals". This will make it so you  see the faces from the inside of the sphere, not the outside. Then, add a material. name it something like, "sky dome," or, if your like me and usually don't bother renaming things, keep it as "Material," "Material.001," "Material.002," (Etc.)

Now we need a texture. It shouldn't be hard to find a skydome texture, the one I use often I got from textures.com (back when it was still cgtextures). You should be able to select the sphere, and UV unwrap it with the default sphere projection. Depending on what texture you find, you may want to delete the bottom half of the sphere before  trying to unwrap it)

Most people will tell you to set the material to "Shadeless." However, you get more control over the brightness by moving the "emission" value up and down. 0 is normal material. 1 is pretty close to what shadeless would look like, and 2 is much brighter. Plus, when using the Emission setting, lamps will effect the sky, (which you may, or may not want, actually, depending on your specific case)

The same method would apply to a cube, only you'd need a different texture, and you'd be using a cube instead of a sphere.


How do I use the node editor for material?

You can't use material nodes in Blender Internal. Try changing your mode to "Cycles" in the drop down that has "Blender Render" in it right now.


I want one object to "chase" another object

Chase:

View from top - Ortho view

An empty is placed at the center of the red circle's intended orbit and rotates. The circle is parented to this
so it rotates around the empty.

A narrow and invisible plane is added and has it's pivot point set to it's upper end.  This is then located at the red circle's center (SH-S)  and will act a leash.

The leash is scaled in length and rotated so it's other end is at the stationary blue circle.

The blue circle is then parented to the leash choosing the "Vertex" option. (child = blue circle)

The leash's two end-vertices (at the blue circle) are then shapekeyed to shrink the leash over the same number of frames (minus a few) as it takes the red circle to make one orbit.  You can have this happen (the intercept) much sooner or over several orbits if you wish.

When played the red circle does it's orbit and the leash is forced to follow and rotate with it.
At the same time shapekeys are shrinking it's length, automatically making it close in on the red circle.

By adjusting the leash's shape key F curves in the Graph editor, the nature of the intercept can be varied to suit.


Is it possible to toggle child viewport visibility from the parent in the outliner?

Hold Ctrl (makes the command recursive) when toggling the visibility of the parent and it will also apply to all the children in the hierarchy. The same goes for all the other toggle operations.

Additionally, you can drag over multiple icons and toggle these.


Rubber cloth preset looks wrinkled on character mesh

One thing is - less vertices = more solid.
I would say your topology in that place self collides. Current self-collision distance cause overlapping a space of several faces in their Normal direction.
Try to lower Physics Properties > Cloth > Collision > Self Collisions > Distance

Default Sphere with 0.004

... but lower value probably make it easier to penetrate.
Or you can try to use a Vertex Group (use vertices without "frame" part so it would be excluded from self-collision), but that is probably that you don't want to ... it defence own situation.
BTW There isn't a reason for Shape > Pin Group, when set zero - pinning doesn't take any effect.


UPDATED

Partially true, it is somehow not very straight forward or obvious, but here is a work around:

remove - disable all of your lights from your scene (as you do for the rest of your bakes if you dont want to affect the baked textures)
Bake Glossy (only Direct Enabled)

As has been mentioned in the comments it seems that there is no color bleeding on the faces, but instead if any face is occluded will be affected by shadows (which is not wanted of course) as it happens on my example (see bellow)

So far I didnt find a proper way to get rid of it, in fact what I had to do was to remove the plane in order to get the appropriate result, which is a bad thing.

Nevertheless, this should do the job for now ;)


Composite interior and exterior separately

With the help of Cegaton I've found the solution. The main problem was that the window is in the way so it has to be rendered separately. This way there's a hole in the first layer without the background so later on the Alpha Over node can be used.

So, in this case, four render layers are necessary:

Layer 1:

In this layer is the foreground, just the spaceship but without the Window, masking the rest so that there's a transparent hole in the window.

Layer 2:

In this layer it's the Earth without the Atmosphere.

Layer 3:

Just the atmosphere in layer three.

Layer 4:

Here is the Window:

And finally, here's the compositor node setup:


Wrong loop cuts position offered by blender by default

The loop cuts not going all the way around would be the result of the loop cut running into a face that has more or less than 4 sides; an n-gon.

To make a loop cut go in the direction you want, make sure to place your cursor on an edge perpendicular to the direction of the loopcut (cursor is where 3D Cursor is):

These are the basic principles for all loop cut making.


Cloth hanging over a cube but the cloth is floating

Unfortunately Blender's Physics are optimized for mid-scale simulations. Meaning it gets into troubles, when using simulations on a scale < 1m. Roughly.
There is a Thickness outer in the physics tab of your collider, I think that one's default is one of the reasons, but decreasing the value also didn't change much.

If you set your objects to their original scale, the animation works. If 30cm is the exact size you were going for, you'll need to work around that. There are several ways, but too long to explain here.


controlling speed of an action by driver or scripting

The NLA editor.

Action Strip Scale.

Halving or Doubling, (for instance),  the strip scale, doubles or halves the action speed.

Animated Strip Time.

The frame at which the fcurve is evaluated can be animated here, with keyframes, AFAIK not with drivers.

Some examples from python console on how to access with script

>>> strip = C.object.animation_data.nla_tracks['NlaTrack'].strips['CubeAction']
>>> strip.use_animated_time
True
>>> strip.strip_time = 100
>>> strip.keyframe_insert('strip_time', frame=200)
True


It looks like you have smooth shading enabled. To switch to flat shading, select the mesh and on the left side menu, go to the tools panel and choose flat shading.


How to texture - Repeating patterns of cylindrical meshes

Maybe you just have to make an unwrap reset in this case ?


You can't modify the bone envelope's scale at individual axis, separately.

A bone's envelope distance is stored as a single attribute envelope_distance, without any way to modify it for a single axis. This is unlike b-bone scale which is stored separately in bbone_x and bbone_z, thus can be scaled separately.

Your only choice here is through weight painting, already elaborated in the other answers posted before mine.


Why am I getting rounded faces when combining Edge Split and Subsurf?

Edge splitting doubles the vertices and edges, effectively creating to separate parts, which then get subsurfed individually. If you need sharp edges, adjusting the Mean Crease is likely a better way. It's under Transform in the Properties panel while in Edit mode.
Here I have all the edges of the Icosphere selected, so they all get the same Crease value. You can, of course, adjust the crease for each edge individually. It applies to the currently selected edge(s).


The way to do this is to add a transparent shader to the emission shader.  This means that the surface will emit light and allow light to pass through it, so further emission materials behind it will add to the brightness.

Adding some randomized color produces this result.  Note how the overlapping portions do indeed add up brightness as desired.


I went into edit mode

You should scale the lattice only in Object mode to encompass your object.

And yes - it doesn't need to be a cube. When you're ready with x/y/z scaling do not Apply object transform (scale) to the lattice at all. It will result in the same outcome.

Scaling it in edit mode is applying deformation on the object as expected, in your case - scaling it up/down.


I checked the file and I think that every font - if viewed in a "too small" bitmap image - shows pixels.

If there is too much info and too few pixels, it's normal that if you zoom in you'll see a not perfect smooth shape (with antialias you can smooth a little bit the result).

In summary, if you want to represent a vector images (svg, font) into a bitmap image, you need to have enough resolution on the target image if you don't want pixelated results.

Check this post about the same problem:
How to get smooth edges on text object?


It can happen somethimes that the tool to correct the normals (Ctrl+N, normals_make_consistent)  puts all the normal inside. It is usually linked to a bad topology.

A quick way to fix that is to flip all the normals (they are consistent, but all in the wrong direction).

To do that

go to edit mode
select all vertices
press space and search for "Flip normals" Or hit ctrl+f and chose Flip Normals


rotation_euler is displayed correctly in "n" panel but not in python

They are the same, but in UI the values are displayed in degrees, in Python it gives you radians.

$ degrees = radians * 180°/π $

$ radians = degrees * π/180° $

The Blender python API gives you radians because the Python trigonometric functions sin, cos, tan, etc. expect radians as input, so it's more convenient in programming.

For humans it's easier to read angles in degrees, so that's why UI uses it.


Why does the order of the editor type entries flip upside down?

The reason would be considered consistency. As menus are intended to be a mouse driven UI element, having the same option two steps from the mouse click is considered consistent. This changes when a user uses keyboard navigation as the direction to move changes depending on the location the menu starts.

The use_directional_menus option defines which order menus are drawn. When disabled menu items will always be in the same order, top to bottom.

This option isn't made visible to the user, so it needs to be set manually. Using blender's Python Console type in

C.user_preferences.view.use_directional_menus = False

If you want this option to always be set, set the option and then in preferences click Save User Settings


How can multiple people work on the same file?

Sadly there is no built in way to do this. So far the popular method has been to use git or svn which, while not built for this, can be made to work. (although keeping track of who uses what file is a complicated, I personally use a google sheet, but people forget to update it)

The down side with git and svn is that they can require some technical knowledge, such as command line usage. There are GUI apps (Github Desktop,Source Tree) that help; however I always find myself having to resort to using the command line.


What is this noisy shadow overlay that stays with the camera?

That looks to me like "regular noise" (I assume by regular noise you mean noise caused by an insufficient number of samples in cycles).

By default cycles uses a consistent pattern for sampling, and so the pattern of noise will stay the same, producing an effect like this:

On the dark side the noise is more chaotic, but on the illuminated side of Suzanne's face you should see that the noise pattern remains mostly the same across frames.

To fix this, change the Seed of the noise pattern so that it's different every frame (or every few frames), and/or increase then number of samples. To do this, type #frame into the Seed setting in Render settings > Sampling:

This will create a driver which will set the Seed based on the expression typed into the field, where #frame is equal to the frame number.

Note that you may have to allow the driver and reload your .blend (save before reloading!) in order for the driver to work. See After updating to Blender 2.68 Driver Scripts are no longer automatically excecuted for details.

Optionally add some math to the expression, e.g. #frame/10 to change the seed only on every tenth frame.

This will break up this noise and make all the noise chaotic, which makes the noise less likely to be preserved by lossily compressed video formats.

Click the image above to see a compressed video version.

On more recent versions of blender there is a button to change the Seed automatically:

The small clock icon highlighted in yellow here, when pressed will automatically adjust the seed each frame.


How to render in cycles like when you use backface culling in eevee

Here is a setup I use

WARNING* WITH SOLID MESH YOU MAY HAVE TO TURN OFF SHADOWS

If you don't want to turn off shadows use this setup here:


If you select 2 vertices and press F, a new edge between the vertices is created.
If you right click on it and choose subdivide you can add 1 or more vertices to that edge.
If you select 4 vertices and press F, a face will be created.


The biggest advantage of linking is that it makes files easier for Blender to compute. It also makes it easier for you to manage - provided you have a coherent structure. The Linked Library Addon can be considered essential for workflow.

Setting the background in one file that you linked in, should give no problem, and you will probably wish you did it sooner.

Where things can get a bit more challenging is linking in files with animation, especially if they have to react with objects in another file. In such case you might leave empties to mark placement but that is not always ideal.

I highly recommend keeping your files consistent. In particular I have run into trouble in the past with textures that are saved relatively in some files and absolute in others. Because I have the auto-save on my linked library, Blender would create a new folders with Textures and not reference the original texture folder that I had with the original file.

As a resource: there is an excellent explanation on - Jason's Blog


Should I model my animation assets to real-world scale?

I would say: stick to real world scale. At the end, in very very small scale there will be rounding errors when placing vertices.

And for your navigation difficulties in large scale: In Preferences > Interface, check Auto Depth and Zoom To Mouse Position - this really helps. And when editing an object, place it in an empty layer and switch off all others, this also improves pan and view functionality.

Update for Blender 2.82: These settings are now to be found by clicking Edit > Preferences > Navigation.


Why those hexagons appears in sculpting mode

I ran I to the exact same issue when following BlenderGuru's beginners' tutorial. I was confused and reloaded an old save. It turns out Andrew unhides his vertices at one point and forgets to show it. Try Alt + H before applying the modifiers and it should work

If you've already applied the modifiers go to sculpting and  press'Grab' (yellow one) and press shift while clicking the holes until they are all gone.

If that doesn't work then select the vertices with the hexagon holes and then click f (to create a face there) however this is really inefficient and makes your donut look bad


Properties Editor : Scene : Color Management

The color management is in the properties panel. If you don't know where the properties panel is, its over here:

Now, go to the scene panel, its the third one:

over here you will find colour management

If its closed, open it up by pressing the arrow

 if you still can't find it please post your .blend file over here
http://blend-exchange.giantcowfilms.com/


Well guys, I found the problem. I changed this at the very beginning when I watched a tutorial and of course, forgot about it:

The invisible object was a particle emitter. And I unchecked the "Emitter" box under Particles > Render!


If you want to add this feature to Quick Favorites you can follow these steps:

Press F3 to search for commands and type "active camera"
Right-click RMB on Align active Camera to View and select Add to Quick Favorites
Press Q to get the list of favorite commands and you can quickly select the Align Command from that list

Otherwise you can also follow these steps to quickly enable lock of the camera view:
Step 1
Press N in the 3d View to open up the right sidebar and go to View:

Step 2
Right-click RMB on Camera to view and Select Add to Quick Favorites:

Now you can enable Camera to View by pressing Q:


How to hook a vertex of a curve to a certain object?

If you know the objects by name (names are unique), you can get them by global data access:
curve = bpy.data.objects["BezierCurve"]
hook = bpy.data.objects["Empty"]

Or even better per scene in context if you'd like to turn this into an operator later on:
curve = bpy.context.scene.objects.get("BezierCurve")
hook = bpy.context.scene.objects.get("Empty")

To add a modifier to an object, with its name and type:
modifier = curve.modifiers.new("Hook", 'HOOK')

Then the modifier has its own specific attributes and methods
For hook, as described here:
The target object:
modifier.object = hook

And the hooked vertices. a bezier curve handle has 3 points, so you can set indices with:
handle_index = 0
index_from = 3 * handle_index
index_to = index_from + 3
modifier.vertex_indices_set( range(index_from, index_to) )

All together:
import bpy

curve = bpy.data.objects["BezierCurve"]
hook = bpy.data.objects["Empty"]

modifier = curve.modifiers.new("Hook", 'HOOK')
modifier.object = hook

handle_index = 0
index_from = 3 * handle_index
index_to = index_from + 3
modifier.vertex_indices_set( range(index_from, index_to) )


These are the things to check -

naming/paths - try to put the images in a path without gaps, or non-standard characters. First try something like C:\test.jpg, where nothing should go wrong.
path of your blender file, same as above.
image format - open the images in an image editor, resave them
if these don't work, it might be some kind of a bug, specific to your operating system.


Emission shader color saturation clipping

Easiest to explain it with an example. Let's take fully saturated blue. At power 1.0, that is RGB 0.0, 0,0, 1.0. Let's boost power up to 2.0. We now have 0.0, 0.0, 2.0. This can't be display on our monitor, so it clips to 0.0, 0.0, 1.0. Essentially negating the power increase. We have the same blue we started with.

Now let's try 85% saturation, but still at full brightness, emitter power=1.0. That's RGB 0.15, 0.15, 1.0. Let's put the emitter up to 2.0. We now have RGB 0.3, 0.3, 2.0. That clips to 0.3, 0.3, 1.0. See what happened? We raised all the channels, but only R and G had room to go up, so they increase relative to blue, leaving you with a desaturated blue. This doesn't happen with 100% saturation, because R and G are 0 in that case and don't get scaled up when you boost the power.

Btw, on the subject of the glare node, it doesn't clip linearly. I've never looked into what it does exactly, but it does some sort of scaling or clamping to avoid changing saturation or outputting superwhite values. (usually that's done by scaling down all the 3 channels by some identical value that will leave you with brightest channel=1.0)


How to make an object automatically take the same height as another object?

Maybe the Shrinkwrap Modifier can help you out. (I think i unlikely but i though I'd propose the idea anyway, just in case.)

Both cities have to be one object each though (Separate > By Loose Parts could be done later)

And in this example (Mode: Project, On Surface) the blocks with the right height slightly overlap the map blocks so the map blocks vertices have a surface right above them to snap on to.

Edit:
I suspected the top faced wouldn't turn out flat. But you can use LoopTools to fix that if needed.
Go to Blender Preferences > Add-ons. Search for "looptools", and check the box next to Mesh:LoopTools.
Go to the 3D Viewport and in a sideview (Numpad 1 or 3) you should be able to easily select all the top faces of the buildings (select the top vertices in Vertex Select and then switch to Face Select is best i think).
With all the top faces selected, press N to open the 3D Viewport Sidebar Panel (if it isn't op en already) and click the Edit tab. Extent the LoopTools menu. Extent the menu under the Flatten button. Choose Plane:View. Press Numpad 7 to go to topview and press the Flatten button.
All the faces should now be flattened while still being at their own respective heights.


How to fix clipping knee joint with ik bones?

I've tried the following things and it seems to work:

Enable the Armature modifier's Preserve Volume option

I've added an edge loop above the joint:

I've segmented the small bone:

I've extended a bit its influence upwards in Weight Paint mode, use Mix, Substract, use also the Blur brush:

And I've extended a bit the influence of the top leg downwards:

A try with 2.79, I 've added a Pole Target to make it bend correctly:


Objects tracked to camera track to the viewport camera at current frame instead of camera location at the frame it should be rendering

I've found a solution to get the text to show up correctly with relatively little effort. By going to correct frame, and using Object > Rigid Body > Apply Transformation like so:

After doing that I could remove the problematic constraints but keep most of the effect I wanted, it did mean that for one shot the text doesn't follow the camera, but at least it wasn't completely reversed anymore, so I counted that as a win.
Since this doesn't actually solve the constraints not updating properly whilst rendering the animation I won't accept this answer, but as a temporary fix I thought it worth mentioning.


What is the easiest method for making an image plane half-transparent?

If you add material, it's a principled shader. Just turn down the alpha

And also 'Alpha blend' from the settings of that material:

And you may need to be in Material Preview or Display Render mode:


Is there a way to symmetrize a mesh without messing up the armature underneath?

Alright so I figured it out so I figure I'll update just in case anyone ever finds themselves stuck in my situation. Turns out the fix was very obvious and simple after all. :)
The thing that fixes the symmetry in a way that isn't destructive is actually 'mesh > snap to symmetry' rather than using symmetrize. This will preserve not just the armature but all of the weight painting, too. You can either select the entire mesh or just the opposing areas on each side of the mesh that you want symmetrical and you will get this wonderful popup.

I guess prevention is always best but I'm really relieved that it's not the end of the world (and all of my weight painting) if the mesh accidentally loses symmetry.


Is it possible to have true transparency (without ghost shadows)?

What is probably happening here is a "Z-fight" between the surface of the transparent wall and that of the opaque one, meaning that since they are overlapping exactly along one of their faces, the render engine is confused as to which one to use for shading calculations.

One may think that a fully white transparent surface wouldn't Z-fight, ...but it does.

As a solution: remove the overlap! Move the surface a tiny bit away (or inside) the opaque wall.


Build a smooth low poly foot stool with lower than 15K Tris / Faces

As suggested by Rob, use Normals. Also, your material will count to fake the texture (put a bit of noise and glossy in it) but it's not the topic here.

Create a low-poly object, give it a Subdivision Surface modifier and Smooth Shade it.

You could duplicate your object to sculpt a high-poly version, but an even simpler technic is to keep one object and to fake the high-poly version with the Multires modifier. So give your object a Multires modifier and click Subdivide several times (5 times here).

In Sculpt mode, begin to sculpt all your wrinkles and details.

In the UV/Image Editor, create a new black image. Unwrap your object with the Smart UV Project mode. Create a material with an Image Texture, load the previously created image, but for the moment don't plug the Image Texture into the Diffuse. Go in the Properties panel > Render > Bake, Bake Type > Normal, click on the Bake button, the normal map will appear on the UV/Image Editor.

Now duplicate your object with its modifier and keep a copy somewhere. Delete the Multires modifier on the original. Plug the Image Texture (Non-Color Data mode) into a Normal Map, plug it into the Normal socket of the Diffuse. Boom the wrinkles appear on your object as if they were in 3D.


grow selected edged limited to a loop and/or ring

I'm not sure, if I understood you right. Is this, what you are looking for:
You may select an edge-loop by holding down Alt while selecting an edge.
You may select an edge-ring by holding down Ctrl-Alt while selecting an edge.
The same works for face-loops in face selection mode.


Distribute object instances at every vertex

Get rid of the Point Distribute node. Just use the Point Instance Node.


My blender file will not print; any suggestions?

It's a curious model. I have 2.83 and the file opened fine, no obvious problems. Export to STL appeared to go well. Meshmixer is also happy with the structure.
The model appears to export at 0.11 mm diameter. My first move was to increase scale to 2540, a common number for inches to millimeter or the reverse, I can't recall. Still too tiny, but when using a scale factor of 25400, the model becomes 29 mm in diameter and 5 mm high.