Change Diffuse shader to emission shader without affecting shader color

This script from http://web.purplefrog.com/~thoth/blender/python-cookbook/change-diffuse-to-emission-node.html should work

import bpy

def replace_with_emission(node, node_tree):
    new_node = node_tree.nodes.new('ShaderNodeEmission')
    connected_sockets_out = []
    sock = node.inputs[0]
    if len(sock.links)>0:
        color_link = sock.links[0].from_socket
    else:
        color_link=None
    defaults_in = sock.default_value[:]

    for sock in node.outputs:
        if len(sock.links)>0:
            connected_sockets_out.append( sock.links[0].to_socket)
        else:
            connected_sockets_out.append(None)

    #print( defaults_in )

    new_node.location = (node.location.x, node.location.y)

    if color_link is not None:
        node_tree.links.new(new_node.inputs[0], color_link)
    new_node.inputs[0].default_value = defaults_in

    if connected_sockets_out[0] is not None:
        node_tree.links.new(connected_sockets_out[0], new_node.outputs[0])

def material_diffuse_to_emission(mat):

    doomed=[]
    for node in mat.node_tree.nodes:
        if node.type=='BSDF_DIFFUSE':
            replace_with_emission(node, mat.node_tree)
            doomed.append(node)

    # wait until we are done iterating and adding before we start wrecking things
    for node in doomed:
        mat.node_tree.nodes.remove(node)

def replace_on_selected_objects():
    mats = set()
    for obj in bpy.context.scene.objects:
        if obj.select:
            for slot in obj.material_slots:
                mats.add(slot.material)

    for mat in mats:
        material_diffuse_to_emission(mat)

def replace_in_all_materials():
    for mat in bpy.data.materials:
        material_diffuse_to_emission(mat)

if True:
    replace_on_selected_objects()
else:
    replace_in_all_materials()

Just paste a copy into a blender Text Editor, select the objects you want adjusted, and click the Run Script button.  If you want to rework all the materials, just change the tail end of the script to run the replace_in_all_materials() function.


How to make a Particle System follow a Cloth Simulation?

Final:

Overview:

If you want to keep Particles over the Cloth surface you will need to turn off any Particles Physics simulation (choose No) and also to prevent Particles from rotating like crazy after collision you will need to set Emitter Geometry > Normal under Velocity tab to 0, like so:

Edit:

You also need to pay attention to Modifier Stack as this is very important thing in many operation based on modifiers. You have got Cloth simulation as a last modifier so Blender first started Particle Systems and after them Cloth. So as a solution you will need to move Cloth to the first position in the Stack:


Use a color ramp to control the mix between different shaders.

To mix more shaders use other ramps with different values.


Should I make my model into 1 whole or multiple parts?

I would say model all separate objects as separate meshes and group all objects that form a single continuous surface.

In the case of the human model it should probably be a single mesh object, since it is a "continuous single skin surface", that way you won't get discontinuities, artifacts or seams while rendering.

Edit: I am not into character modeling so my view here is bound to be inaccurate, as suggested below, a clothed character can optimally be subdivided into the several visible patches of skin, like say head, hands, legs, etc.

As for the background scene divide it sensibly as much as possible.
Take advantage of cloning and instances whenever possible for scene optimization. It can save a lot in file size, memory management while rendering and a lot of manual work updating different objects.
Terrain can be one single big mesh, each individual tree and vegetation should be single objects, etc.


I need to simulate the interference of two sinewaves

If you'd like to visualize interference in 3D, that can also be done. The animation below illustrates 5 sine waves interacting with each other in 3D. The coloring is done by taking a slice through the combined waves and assigning colors to the intensity of the wave. Using shaders is fast enough that the images can be generated in real time. This solution is based on an an antenna/radar example here,

Details for visualizing 2 interfering waves on a surface  - (Tested on Blender 2.92)

To visualize 2 waves with interference, some simple geometry is setup for the visualization. The key is using the wave texture. A plane is used to visualize the waves, and 2 spheres are used to visualize and control the origin of the waves.

Shaders are used to generate the visualization of the interference. The wave node texture performs the math for each wave and a math node sums the waves together to see the interference. The full shader for 2 interfering waves is shown below. This shader is named 'wave'

The nodes in the red frame calculate the sine waves and when summed together generate the interference patterns in 3D.
The nodes in white are used to specify the origin of the waves. To help with the visualization, this is done using the two spheres in the geometry that were called Wave Source 1 and Wave Source 2. The text Coordinate node is used to get their origin and then use that to set the origin of the waves.
The nodes in the two blue frames are used to set the wavelength and phase of the waves. The wavelength in blender defaults to 1mm, so it is scaled to meters. The phasing is defined in radians so it is scaled to degrees. If the phasing is animated, the sign will control the direction of travel of the wave.
The nodes in the green frame control how the calculated wave intensity is visualized. This node scales the wave intensity to a value between 0 and 1, then uses a color ramp to make it red where positive and blue where negative. Transparency is used to set the color emissivity to zero where there the intensity is near zero.
Note this shader defines the intensity everywhere. When it is applied to an object, it will show the wave intensity there.

In this example, the shader called 'wave' is applied to a plane called 'surface'. This will show the wave intensity on that plane.

Additional slices can be visualized by adding more planes to the scenes.

The blender 2.92 model for this example is available here -

Extension #1 - Visualizing as a 3D wave

Add a volume for visualizing the waves.

Copy and modify the previous surface shader. The turquoise frame shows the changes for volume rendering.

The math block on the left scales the input to 0..1 so it will work with a color ramp. The color is applied to a 'Principled Volume' color input. This sets to color of the location in the volume.
The math node connected to the alpha is used to scale the density which sets the opacity of the volume.

Adjust light and setting to get desired look.

The blender 2.92 model for this example is available here -
References - See creating mesh on an isosurface

Extension #2 - Visualizing the interference as a surface wave

Turn on experimental features for rendering.

Add a subdivision multiplier to the visualization plane. Use simple subdivision. Set adaptive.

Add a displacement node to the shader.

The blender model for this example is available here -
References

2.8 Adaptive Subdivision

Extension #3 - Multiple wave sources
By adding more wave sources, these kinds very complex wave interactions can be visualized.

This Blend file contains the model used to generate the animation -
This blend file was generated in Blender 2.90

References
References - See http://exnumerus.blogspot.com/2021/02/visualizing-3d-sine-wave-using-blender.html This shows an application in Blender to illustrate how phased array radars and antennas work.


In Blender 2.8 the W key to open the Context menu has been replaced by the Right Mouse Button. As it is a Context menu you have to be in Edge select mode to have the Bridge Edge Loops option available.

Edge select mode.
Select the two edges.
RMB to open the Context menu.
Choose the Bridge Edge Loop.

Another way which works in both vertex or edge select mode is to open the Edge menu and select the Bridge Edge Loop option from there.


Merge materials in 3 easy steps.

This is your materials list:

RED
GREEN
BLUE

If you want to make all that's BLUE to be RED.
1) Select the BLUE material.
2) Use the up arrow till the BLUE is under the RED.
3) Delete the BLUE by using the minus button.
Done!
Now all that was BLUE is now RED.

The way Blender behaves if you delete a material all the material that used that slot will inherit the slot above unless it is the top slot then it will inherit the one below.


The camera can only see the geometry that is within a range defined by the clipping distance.

Anything that that closer of further away from that distance range will be ignored.

With the camera object selected, increase its End clipping distance in Properties > Camera settings > Lens:

For 2.79 and earlier versions

For 2.8

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

For 2.8 enable Viewport Display> Limits


How to make modifiers not auto-apply or update live while changing parameters?

Set modifier on a simple object and then transfer it to a more complex one

Use an "host" object to set up your modifier with the wanted
   parameters (e.g. a simple plane/a cube/a vertex..).

Once the modifier is added, switch its 3D vieport visibility off to prevent calculations.

Once satisfied with the settings, select both objects, make the "host" object the active object and then Link the modifier to the other by pressing Ctrl+L and choosing Modifiers from the pop up menu.

The modifier will be transferred with all his settings, even its "non visbility", to the selected objects, so you'll just have to apply it and wait for the end of the calculations.


Dynamic Paint and Cycles and Fire Simulation

The mesh emitting flames is both a dynamic canvas and a smoke flow, it needs to use the same vertex group for painting and smoke flow.


How do I keyframe transform and rotation values whilst moving and object on a path using 'Follow path' contraint

You can create an empty, set a copy loc constraint on the camera targeting the empty, set a copy rot using "Add" mix instead of default "replace", set the empty to follow the curve path.
When everything works as expected, select the camera, in the 3D window, object mode, go to Object menu, choose animation, bake action, enabling the preferences in the image below.
Now you can delete the curve and the empty, animation is baked as camera keyframes.


Changes to sculpt appear on both sides of the mesh?

First check in toolbar (T) panel if you have turned on mirroring. It's under symmetry. Glitches during mirroring occur when object is rotated or has non-uniform scale which comes from scaling in object mode. Ctrl - A apply scale to fix that if this is the problem.


Nope, you're not doing anything wrong, that's the way Solidify works.  You can make it solidify in the other direction by specifying a negative Thickness or by adjusting the Offset.


In windows OS you can open the console form the menu:

Window->Toggle System Console:

There you should be able to find information on your error.

In your case you have a duplicated addon. This error can happen when you have two versions of the same addon as well.

The duplicate could be in two places:

On the programs folder in your system drive:

C:\Program Files\Blender Foundation\Blender\ version number \scripts\addons

or on the App data folder:

C:\Users\ your user \AppData\Roaming\Blender Foundation\Blender\ version number \scripts\addons

Open both folders, find the duplicate and remove it from the folder.

Then restart blender.


Object.ray_cast changed in 2.77 to include a "hit" return value giving the success of the hit.

You need to replace lines 108 to 111 with

        hit, hit_location, hit_normal, hit_index = tmp_ground.ray_cast(lowest_world_co, lowest_world_co + down)
        if not hit:
            print(ob.name, 'didn\'t hit the ground')
            continue

Full edit here https://gist.github.com/batFINGER/820d385839a222e5a10c1b7f5cdbd0b7


how to display overall dimensions for furniture

In your specific case, the MeasureIt addon makes sense.
However, there are also different ways to measure stuff inside Blender UI.

Measure Tool (length and angles, set by mouse drag)
Measurement Overlay (measurement of selected geometry, like bounding boxes)


A common way to get the animation data is to loop over the scene's frame range and read the matrices for every single frame. This is okay most of the time, and way easier to do than reading the F-Curve data directly (which won't include F-Curve modifiers and Drivers AFAIK).

Assume the Armature object is currently active:

import bpy

sce = bpy.context.scene
ob = bpy.context.object

for f in range(sce.frame_start, sce.frame_end+1):
    sce.frame_set(f)
    print("Frame %i" % f)

    for pbone in ob.pose.bones:
        print(pbone.name, pbone.matrix) # bone in object space

bpy.types.PoseBone.matrix

You may use the utility function convert_space to avoid fancy matrix math.


texture projection paint settings in blender

It is the angle between the surface's normal and the vector from the surface to the camera (an orthographic view vector).

Top view.

This means the angle is small for faces pointing directly at us and larger for face viewed at an angle.

If you wish to exclude surfaces which are not viewed directly from the from, decrease the normal angle value.

I think the inaccuracy is due to the large brush and the bleed settings, but the idea should be clear.

While texturing from a camera projection you usually want a low normal angle. From the camera view the faces oriented away from the camera, will have less pixels per surface and the texture will be more distorted. Use a low normal value to avoid painting on the, then paint on them from a more perpendicular viewing angle with a different reference image.


Your 2 objects are sharing the same material, and the faces of the big objects are overlapping in the UV Editor, you could see it in the UV Editor if you select all in Edit mode, you need to unwrap with another method, like Unwrap > Smart UV Project or mark some seams then Unwrap > Unwrap.


How to define customized property in Material?

I believe all you need are bpy.props properties. The first example even demonstrates it for bpy.types.Material. Here's an extended example, that uses some additional options for a FloatProperty and adds it above the Material list in Material tab, so you can try it out:

import bpy

def draw_func(self, context):
    layout = self.layout
    ob = context.object
    layout.prop(ob.active_material, "my_material")

def register():
    bpy.types.Material.my_material = bpy.props.FloatProperty(
        name="My Material Property",
        min=0.0,
        max=10.0,
        default=5.0,
        subtype='FACTOR'
    )
    bpy.types.MATERIAL_PT_context_material.prepend(draw_func)

def unregister():
    del bpy.types.Material.my_material
    bpy.types.MATERIAL_PT_context_material.remove(draw_func)

if __name__ == "__main__":
    register()

You can add your custom properties to a full, custom panel too of course.

If you need to add plenty of properties, use a property group and a PointerProperty to organize them better (and avoid name conflicts with existing properties).

If you need a varying number of a group of properties, use a PropertyGroup to define the properties per occurrence and supply it to a CollectionProperty as type.


H.264 encoding settings for High Quality HD (1080p) and High Quality UHD (4K)

Unfortunately H264 is never going to give you brilliant quality video. It was designed to be efficient on storage and network bandwidth. Take a look at mjpeg or similar for higher quality video.

GOP stands for Group of pictures. And basically means how many frames between I frames. Generally you would have 1 I frame to 24 p frames so the GOP would be 25. The more I frames you have the higher quality picture but the higher storage and network cost too.

I frame is an interframe and is a complete picture. P frames are predicted frames and made up of the predicted changes between the last I frame and the next frame.

Limiting the max bitrate will cause Blender to over compress the image and movement or dark areas will look worse.  I can't see any benefit in setting the minimum bitrate


Premise
If you are using your current method (without spinning the blade), weight paint it to "parent" it to the axle bone like this so that it turns correctly.

Method 1
One (easy, almost cheating) way to animate it would be to make it a separate object. If the armature is already working correctly with the rest of the mesh, it is normally tough to go back and add more details. Even if I was building this from scratch, I would definitely make a part such as that a separate object.
The Blender Foundation had a problem similar to this when working on Cosmos Laundromat last year.

And guess what? Hjalti added a pocket! Since it’s too late to update
the rig (see the Alien Victor image above), Hjalti created a patch of
cloth with a rig and added it frame by frame to the animation. You’ll
find this animation on the Cloud as well.

Your problem will be much easier. Just parent the (separate) blade to a bone along the axle that it rotates on, and animate it as an object. I will not go into any more detail except to say that it can be done quite easily.

Method 2
Add a "blade_control" bone that is parented to the axle control bone, add the needed vertex group, and then weight paint the blade onto the bone.

Be sure to set the "center" of the blade control bone correctly (I set the cursor to the base of the axle control bone in the Gif)
Parent the control bone with offset
Make sure the weights for all of the other vertex groups are cleared for the blade
Make sure the control bone only touches the blade (everything else is blue for it's weighted vertex group). To do this I used face select mode and hit L while hovering over the blade.

I had to split this into 2 Gifs:
Part 1

Part 2

As for animating at this point, you animate the rotation of the blade control bone with keyframes as you would with any other object.


2 x 1080Ti vs 1 x 2080Ti. So much difference?

The reason why his viewport rendered preview mode is so much closer to the final result is that BlenderGuru has set his Viewport Sampling to be much higher. Higher samples means less noise and lighting artifacts. Since he essentially has twice the computing power, he can afford to crank up the samples in the viewport much higher without dealing with too much lag.

You could probably also increase yours since you still have a 2080ti. In the second screenshot on the right-hand side, under Sampling, increase the value next to Viewport. Turn it up as high as you like, just take care not to crank it up so high such that the preview becomes too laggy.


Importing Photoshop Brushes for Grease Pencil and Texture Mapping?

There is a way around this. You can convert photoshop custom brushes (ABR files) into PNG files using the free OpenSource programme ABRViewer. Alternatively just save a masked PNG that you want to use as a brush.

Using Grease Pencil in Blender 2.8 make sure you're in Draw mode. Then click on the Active tool tab. Change brush name and make other changes to settings you might want.

Then add a new material (in material tab). Under the checked Stroke section change Style to Texture.

Under this will appear an Open box. Click this to browse for the brush PNG you want to use.

I change Mode Type to Dots.
If you want to use your own colour, rather than the colour of the brush, check Use As Stencil Mask and then change Color.

Perhaps these tutorials can help:

How to Use Photoshop Brushes in Other Programs (specifically exporting them as PNG files)

Grease Pencil Textured Brushes - Blender 2.80 Beta

Creating your own custom Grease Pencil brushes (Blender 2.8) (using PNG files with mask)


You can slice the object in two by using the Boolean modifier.

Here's how to use it do to this:
Step 1-Add a cube and scale it down on the Y axis until it bisects your object in the middle where you want two objects.

Step 2-Add a Boolean modifier to the object you are splitting, and make sure that the operation is set to difference.

Step 3-Make the object that modifier affects to your cube. Now you should notice in wireframe view that the object looks like it has a small breakage on both sides of the cube.

Step 4-apply the boolean modifier and delete the cube.
There should be a break in the object that separates it into two parts.

Now, select the object and go into edit mode.
Press 'P' on your computer keyboard, and select the option "separate by loose parts".

Blender has now separated the object into two individual meshes, and that should solve your problem.


Does anyone know how to make the plastic part of a blister pack used in the medical packaging?

Create a plane
Subdivide it 3 times

Select the vertices in the center ring and do mesh > tranform > "to sphere" and move the mouse to create an octagon.

Extrude the center

Add a subsurf modifier

set the shading to smooth

To have sharper edges add a  couple of loop cuts

Select the outer edges and then select Edge > Crease and set the crease to 1.0 to make the outer edges sharp.

Add a couple of array modifiers


Can my unwrapped UV be scaled outside of the UV grid?

If you extend the UV grid the size of the texture will change inverse proportionally. If you make the UVs larger the texture will get smaller and start repeating itself.


Object created by joining several objects doesn't rotate uniformly consistently

Your problem is with the precision of your model, you should improve your modeling skills and take care of your mesh.

You model needs some serious clean up, there are quite a few misplaced vertex, inverted normals, non manifold faces, overlapping geometry, etc.

There is also one unused Copy Rotation constraint, probably a leftover from when there were several objects

Now to the problem at hand, what you are seeing is probably an optical illusion, your model seems to be rotating at different speeds because the center is not accurately placed relative to the geometry, making the center part "wobble" in relation to the rotation center.

Now your geometry is really uneven and you should probably model it cleanly from scratch, but if you don't want to, just enter edit mode, select the central vertex, move the cursor to selected, exit edit mode and align objects center to the cursor position.

Do this for all objects, although they are all slightly skewed and wont easily be totally perfectly aligned


Does something like a Join Modifier exist?

This answer comes from a post by the asker on a different forum.
By using the Array modifier with the count set to $1$ (and, optionally, each Offset option disabled), you can use the Caps field to join up to two additional objects.
You may need to fiddle with their positions in order to achieve the ideal effect. If you want to merge overlapping vertices, make sure that Merge is also checked.


Rig only generating root but I can't use Human(metarig)

You can use the Simple Human metarig, which has no fingers and no facial bones, edit it accordingly to your character, then generate the Rigify rig, which has complex and sophisticated mechanisms that lets you animate easier.

For further infos relate to Blender manual:
https://docs.blender.org/manual/en/2.81/addons/rigging/rigify.html


How To Change Camera Field Of View From Python Script

bpy.data.cameras gives access to the camera data. And camera data is not renamed (stays 'camera.xxx') when you set the object name.
So, access the camera via objects and use its data:
import bpy
import math

a = 'hello'
bpy.ops.object.camera_add(enter_editmode=False, align='VIEW', location=(50,0,0), rotation=(1.57057,0.00174533,1.57057))
bpy.data.objects["Camera"].name = a
bpy.data.objects[a].data.lens_unit = 'FOV' #Access it by its object name
bpy.data.objects[a].data.angle= math.radians(10)

Additionally, you should not rely on the fact the created object is named "Camera" (because it won't if such a camera already exists).
You can:
import bpy
import math
from mathutils import Euler

a = 'hello'
camera_data = bpy.data.cameras.new(a)
camera = bpy.data.objects.new(a, camera_data)
bpy.context.collection.objects.link(camera)
camera.location = (50,0,0)
camera.rotation_euler = Euler((1.57057,0.00174533,1.57057))
camera.data.lens_unit = 'FOV'
camera.data.angle = math.radians(10)


How to arrange objects around the center of a circle?

You're most of the way there.

When you use the Array modifier with an object offset, the offset between the first array element and the controlling object will be added to each subsequent element. The offset in translation is the move between the pivot point of the controlling object and the pivot point of first element.

The elements are not rotating around the empty. Each element is rotating around the previous element, (by as much as the first element is rotated with respect to the empty). Each element is to the previous element as the first element is to the empty.

You don't want any translation. You only want rotation. so the pivot point of the cone must be where the Empty is. Hit CtrlA >  to apply the location: put the pivot point of the cone where the empty is, at the world origin.

Now to change the radius of the circle of cones .. don't move the pivot point of the cone - move its mesh, by selecting all its vertices in Edit Mode, and moving them.

To move the circular array of cones without screwing them up, you have to maintain the relationship between the first element and the empty.

The easiest way to do this is: select the cone, then the empty, and hit CtrlP > 'Object' to make the empty the parent of the cone (array). Now when you move the empty, the circle of cones moves too. You can still screw the array my moving the cone, so to be safe, lock all its transforms with the little padlocks in the Transform panel of the N properties region on the right of the 3D view.


Cycles standalone Render Layers and Composite nodes

Cycles is a renderer. It provides the data that a compositor can use to combine the data to a final image. Blender's compositor is written inside blender and cannot be run outside Blender as it is tight related to other parts of Blender's pipeline.

So basically the answer to your question is no, you cannot do it via the XML API of Cycles as it does not know anything about compositing; except producing the combined pass, which cannot be influenced.

You can always modify Blender as it is open source, but there are other channels that are better to ask these development questions, like IRC or https://devtalk.blender.org/


All optional arguments now require keywords in 2.80.

event_timer_add(1/100, context.window)

becomes

event_timer_add(1/100, window=context.window)


You would have to modify Blender on the source-code level to inject custom screenspace shaders to the viewport. Something that requires a decent knowledge of C/C++ and Blender's codebase.

But the latest build of Blender (since 2.73) actually has SSAO and DoF built into the viewport. You can try it out by downloading the daily build from http://builder.blender.org


Its created by vector-displacing pixels in post-production. The game engine does this with pixel shaders in post-production too.
Check this its related: How to make a heat distortion effect?
You just don't need a particle simulation for the trail but a single texture behind the bullet will do.
This will create a spherical ball-like distorsion:

Smear it and adjust it in your favourite 2D application to create some water-like wave effect.

Red channel affects the X position
Green channel affects the Y position
Pixel value of 0.5 is no change, brighter is positive direction, darker is negative
Leave blue channel black

You can also sculpt the effect on a plane and bake it into a normal map. Then erase the blue channel from that map.


How do I add in a octagon shape from a plane mesh?

To have an octagon out of a square (4 vertices) add a subsurf modifier

To make a real octagon add a mesh>Circle and make it 8 vertices:


Why won't Lasso or Box Select select all of the faces in the region?

There are several ways to select every vertice of the mesh not changing view angle in the scene.

Limit Selection to Visible

Uncheck Limit selection to visible.

If it's checked, it won't be possible to select vertices which aren't pointed to the viewer (like in your case).
If it isn't checked, when selecting either with Box select or with RMB (doesn't matter how) vertices on the other side of the mesh will be added to selection.

Wireframe viewport shading

Use Wireframe shading mode, accessible via shortcut Z while in 3D Viewport.

Selecting connected geometry

  Select parts of a mesh connected to already selected elements.

Use Ctrl+L shortcut for that or from menu Select > Linked.

  You can also select linked data directly under the cursor.

Press L to select linked data and Shift+L to deselect data which is located under cursor.
Read more about selecting linked in the wiki page.


i know that the tutorial says use the flatten brush, but he is using an older version of Blender and the newer versions got a lot updates especially regarding sculpting.

I tried the flatten brush myself and could not get the same results as shown in the tutorial. Me using the new 2.82.7 version.

BUT i managed to find a brush that surprisingly resulted in the same look, the scrape brush.

Here the little visual help:

Sorry about the dithering, the matcap is not very gif-friendly.

Also regarding the blurriness, i would guess it comes from either to low details (actually means to big value for the dynatopo details) and maybe even not smoothed surface which seems to be a bit buggy. With fine geometry and not smoothed surface you get a blurry effect.

It could help if you would show the setup of the dynatopo that resulted in the blurry effect. Something that really seems to be tripping up the sculpting is if your object has a UV Map or some modifiers, dyntopo tends to bother you as it did show in the tutorial as well. And undo can then easy deactivate dyntopo. If you sculpt then without dyntopo on, the result may also add to the blurry factor. Just a possibility, so if you try again and it becomes blurry, look if dyntopo is active.

Here a little visual to prove my point regarding the older version of Blender (here 2.79b) and sculpting brushes:

As it should be visible, the flatten and scrape brush did the same thing in 2.79b, while in the newer version 2.82.7 the flatten brush sure does it's own thing, means scrape it is.


Why is my scene rendered repeatedly when I press F12?

If your scene has more than one render layer, blender will render each one successively. Finishing one and starting over with the next one until the information of all layers is complete.


If you downloaded a zip file from here: https://docs.blender.org/manual/en/dev/ , then you can open it with your browser but you don't need internet for display the pages. So you can read it offline.
You can see the web address in the browser's address bar is pointing to your harddrive, not web.


You can not directly assign the color depth on the image. However, you can make a scene and set its render.image_settings.color_depth. Then use save_render() with that scene to save the image with the color depth.

import bpy

# Create new scene to set color depth on it
scene = bpy.data.scenes.new('scene name')
settings = scene.render.image_settings
settings.color_depth = '16'
settings.file_format = 'PNG'

# Create new image and save with scene
img = bpy.data.images.new('name', width, height)
img.save_render('filepath', scene)


How can I call the individual parts of the position attribute vector (X, Y, and Z) as values in geometry nodes?

Instead of Attribute Vector Math multiplying position with [1,0,0], to get the X component alone, you could take the Attribute Vector Math dot-product of position and [1,0,0]. (Likewise for Y and Z)
However, I think you'd be a lot better off using 2.93 alpha, to get into Geometry Nodes.. you can see what you're doing a lot more easily:


How to make object translations in the UV Editor (Scripting, Blender Python API 2.8)

The following is a response I received from Testure on Blender DevTalk:

It’s not only possible to do using bmesh, it is the correct way to do it.

In Blender, UVs are stored in loops, and loops can only be accessed through bmfaces. It’s super weird, but here’s a really rough breakdown of how it works:

First of all, when I talk about “loops” i’m not talking about edgeloops. In Bmesh, each face has N loops (where N is the number of edges in the face. Think of a loop as being a vert with a pointer to the next and previous verts that make up the face’s boundary. A loop is also like Bmesh’s attic. Any type of data that is not raw geometry coordinates gets crammed in there and you have to spend a lot of time digging through crap to find what you need (I could go on a pretty good rant about this but I digress). Anyway, that’s oversimplifying it a bit, but that should help you understand what I’m talking about.

OK so once you have a loop, you have to specify what loop layer you want data from. In your case, you want UVs- so you have to get and verify the UV layer using bm.loops.layers.uv.verify(). You’ll need that to manipulate UVs on any given loop.

Another tip- BMesh has no concept of UV islands or UV boundaries, or anything like that. If you have two quad faces joined by one edge, you might think that there are 6 verts, and thus- 6 UVs. You would be incorrect, there are two quads, so there are FOUR loops per face, and therefore 8 loops (thus, 8 UVs). If you want to “weld” two Uvs together, you simply give them the same coordinate, as long as they share a vertex Blender will treat them like they’re welded when a user goes to click on it in the UV editor. This is important to note- because if you’re trying to transform a vert’s UVs, it likely has around 4 UVs that all need to be transformed with it, or you’ve effectively “unwelded” the UVs and created a new split in the uv island.

I threw this simple script together, it should help you understand the nuance a bit better:

import bpy
import bmesh

from mathutils import Vector

def main():
    me = bpy.context.edit_object.data
    bm = bmesh.from_edit_mesh(me)

    uv_layer = bm.loops.layers.uv.verify()

    # it's useful to organize your UVs into a dictionary if you're manipulating a lot of stuff all at once,
    # otherwise you're going to be looping through bmface.loops a LOT.
    uv_verts = {}

    for face in bm.faces:
        print(f"Face #{face.index}")
        for loop in face.loops:
            print(f"\tv{loop.vert.index}: {loop[uv_layer].uv}")
            if loop.vert not in uv_verts:
                uv_verts[loop.vert] = [ loop[uv_layer] ]
            else:
                uv_verts[loop.vert].append( loop[uv_layer] )

    # now that we have a dictionary of UV verts, it's fairly simple to do transformations on the UVs on a per vertex basis
    # here we take all of the selected UV verts and move them up and to the right by .1
    for vert in uv_verts:
        for uv_loop in uv_verts[vert]:
            if uv_loop.select:
                uv_loop.uv += Vector( (10.0, 10.0) )

    bmesh.update_edit_mesh(me, False, False)

if bpy.context.object.mode == "EDIT" and bpy.context.object.type == "MESH":
    main()

Also, this is a really old doc so some of the info might be out of date/incorrect, but it was useful for me when I was trying to understanding how BMesh actually works.


How to make solid torus knot (sverchok nodes)

If it is what you need, maybe. SNL used for sorting.

import gist:
https://gist.github.com/423c6ca03363c7f4aa2408f8d59df8d4


how to set musgrave to get something periodic?

The reason for the 'join' in the resultant texture is due to the discontinuities (edges) in the mapping into texture space and the solution is to change your mapping to join the edges to make the musgrave continuous. In order to visualise this, consider how the polar coordinates are currently being mapped into texture space.
The polar mapping can be considered as having the following marked boundaries (ABCD) :

In 'texture space' the marked boundaries map to the edges of a square (or rectangular) region as follows :

Note how the point A in the radial texture maps to the edge A in texture space - effectively compressing the texture down to a point in the centre. Edge B is stretched around the circumference while C and D are at the discontinuity of the texture and correspond to opposite edges of the plane in texture space.
The discontinuity is caused by edges C and D not corresponding to the same region in texture space. Therefore, the solution is to change the mapping to wrap those edges around so that they do coincide - ie, change the mapping in texture space to a cylinder rather than a plane :

Now, crosing the C-D boundary in polar coordinates does not produce a discontinuity since the C-D boundary in texture space correspond to the same region.
To achieve this was can use the following nodes :

This takes the output from the Radial texture (which varies from 0.0 to 1.0 as the coordinate moves around the centre) and converts it to Y/Z coordinates around the circumference of the cylinder in texture space shown in the above diagram. Note that since 0.0 and 1.0 map to the same location the mapping becomes cyclic, thereby hiding the join.
To make this more versatile we can add in two offsets - one to offset along the axis of the cylinder (to allow the texture to be animated into/out-of the centre) and one to offset the 'rotation' - and one to adjust the radius of the cylinder, controlling the density of the texure around the centre point to produce the following material :

One limitation of using a Gradient texture is that the output is always between the range 0.0 and 1.0 - beyond a certain distance the output does not change. To address this we can simply replace the Gradient with maths nodes to calculate the distance directly (ie, sqrt(x^2 + y^2)).

This can produce the following result :

Blend file included


Tie camera location/view to texture appearance?

It seems that you are looking for a channel which describes the angle of a surface with respect to the camera view. This is achieved by the Layer Weight and Fesnel nodes, found in the Input node category. The mixing can be controlled using the facing or IOR values of the Layer Weight and Fresnel nodes as well as a Color Ramp or Map Range node further tweaking/contrast. See the following node setup:


How to transfer attributes from source mesh to distributed points?

The Geometry Nodes does not delete any attribute e.g., Vertex Weight (Group), however, it can override it or create a new one.
For Blender 2.93: In your example, to control the scale of the points you have to control the radius attribute of the points. So, you can assign the weight from the Group attribute to the radius attribute with the help of the Attribute Math node,


make sure your add-on is specifically written for 2.8, Blenders API had been drastically changed and most add-ons if not all are behind re written to be compatible. it seems your add-on is using a function that had been replaced or merged. correct me if I'm wrong.


Move object relative to camera instead of moving camera relative to object

You can do that by copying and manipulating the F-Curves in the Graph Editor.
Essentially, you need to copy the f-curves relating to Location (you can do this with Ctrl+C when you have selected them) and paste them into the F-Curves for the object (using Ctrl+V) (you'll need to add a keyframe first to create the curves for the object).
Once you've copied the f-curves you can add a Generator modifier with a 1st order polynomial in the format y = c + mx, setting m to '-1' (so as to 'flip' the curve) and 'c' equal to an offset matching the difference between the coordinate of the Camera and your object at the start of the animation.
Once you've done this you should get the same (but opposite) motion between your camera and object - so all that's left is to remove the keyframes from the camera so that it remains static while the object moves in the opposite way to which the camera previously animated.


If you press N in the 3D viewport, a tool menu pops up in the top right corner. This menu has categories, separated by tabs running vertically on the side. Have a look and see if it added anything here (look in both edit mode and object mode):

I am basing this off the image that appears on the add-on's website - you can see all the "action" seems to happen from the same menu. The site says it has support for 2.8, but if it's not there, perhaps it isn't ready for 2.9 yet.


Best way to separate arrays of objects made of multiple loose objects?

Assuming you don't have Merge turned on in your array modifier settings, seperating them should be a breeze! L P
Hover your mouse over one of the arches, hit L then hit P repeat


Modify a blend file via console outside of GUI

You can also build bpy as a standalone module using cmake, and use it in a python script with import bpy
This is pretty similar to doing blender -b -P customscript.py


Multiple GPU limitations with OpenCL and cycles?

TL;DR There is no official limit of GPU's on cycles but setups bigger than 10 GPU's were never tested so far.

After not so extensive research I've contacted one of the blender developers. According to him in this thread: Blender dev forum there is no official limit on cycles. However blender 2.80 is still under development and such a huge setup was never tested before by no one. At this moment I am unable to check it myself on 20 GPU's but I've done my best with what I had.

Natively(without my software, just pure blender) I was able to render on 10 NVidia GPU's both on CUDA and OpenCL concurrently.(commit 191b8951f7af, NVidia driver 398.11, Win10). Further commits were fine for CUDA but I was unable to run OpenCL so I had to checkout from the most recent to this particular one(no idea why, but it's beta so everything is possible). That is the maximum amount of GPU's I had on one node.

Non-natively(using my software to connect to GPU's via tcp/ip) I was able to render on 13 NVidia GPU's on OpenCL(no way to render on CUDA that way) concurrently.(commit 191b8951f7af, NVidia driver 398.11, Win10). All 20 GPU's were visible though. At this point(and in the closest future as well as I have to focus on the other project for now) I cannot conduct any other tests to check whether it's blender or my software.

When I will be back on this project I will provide more information both here and on blender thread, but for now that is all I know.


Is it possible to change the axes/part that the vortex forcefield is attracting?

Well, there is 2 ways to do this.
In the particle settings, go to rotation and uncheck dynamic. This means they all point in one direction.
But I doubt this will give you what you want, its just a quick fix.
The way I find works best is to just take your instance object, enter edit mode, and mess with the rotation and location until you find something that is decent. Rotation works better than location. For it to work, you have to be in edit mode when editing transforms.


Flipping an array of planes in random order using Animation Nodes

Instead of a Falloff you could use Compose Matrix. Math Nodes are there just to make a single plane rotate and you can feed it 100 random numbers to make them all rotate. Clamp node is there to restrict rotation.

One at a time
To make the planes rotate one at a time you need to replace the random numbers with a list of integers (One step is the time it takes for one rotation) and suffle them.


Planes rendered into two triangles of different colors?

For future readers: (TL;DR) This triangle effects can be removed by enabling Auto Smooth under mesh settings.

Credits to @DuarteFarrajotaRamos:

  Is your mesh smooth shaded? It looks like it is flat shaded ,so non
  planar quads will inevitably show visible sharp edge. Make your mesh
  smooth shaded, check Auto Smooth under Mesh Data in the Properties
  Window or add an Edge Split modifier. You may need to manually mark
  some edges as Sharp in Edit Mode if you have a mix of Smooth and Flat
  shaded areas in the same object


The problem with Boolean operations is that they create quite the mess in your topology. This messy topology results in shading artifacts. Because subsurf results in so much geometry, it makes this mess nearly impossible to fix.
Put your current mesh in an archive somewhere in case you mess something up. Duplicate it and work on the duplicate.
Now, select the duplicate, apply all boolean modifiers but not the subsurf modifier. This will make the topology easier to handle. Go into Edit Mode and try to fix the topology.
After doing that, there's one problem. Your Booleans are going to be subsurfed as well. To avoid that, there's two options:

Select all the edges of your booleans and set their edge crease to 1. The edge creases tell the subsurf modifier not to smooth those edges.

Add supporting geometry to your booleans so they don't get smoothed as much.

If both of those don't work, try turning on Auto Smooth and adjust the angle. This cuts off the smoothing on corners at an angle greater than the Auto Smooth angle.

Your mesh should now not have the shading problems you had before.


I would recommend bmesh for this.

No face selection required, no toggling mode, no bpy.ops.mesh... operators.

Because a recent answer used an edit mode bmesh, here is an edit mode version

Translates all vertices 0.1 locally in the direction of their normal for each face.

Example scripts, move all faces along their normals.

import bpy

context = bpy.context

import bmesh

ob = context.object
me = ob.data
bm = bmesh.from_edit_mesh(me)
for f in bm.faces:
    bmesh.ops.translate(bm,
            verts=f.verts,
            vec=0.1 * f.normal)

bmesh.update_edit_mesh(me)

Or in object mode

import bpy
import bmesh

context = bpy.context

ob = context.object
me = ob.data
bm = bmesh.new()
bm.from_mesh(me)
for f in bm.faces:
    bmesh.ops.translate(bm,
            verts=f.verts,
            vec=0.1 * f.normal)

bm.to_mesh(me)
me.update()

Could have also simply

for f in bm.faces:
    vec = 0.1 * f.normal
    for v in bm.verts:
        v.co += vec

Notice this is going to give dreadful results, as each vertex can be a member of multiple faces.  Running scripts above on a uv sphere  will spike the poles. On the cone make the apex grow (appear to scale more in Z)

A good indicator of what we are trying to do here when using all faces would be to split the edges, so each face is free to move on its normal without affecting the normals of adjacent faces.  Here is an example using default cone

bmesh.ops.split_edges(bm,
        edges=bm.edges,
        )
for f in bm.faces:
    bmesh.ops.translate(bm,
            verts=f.verts,
            vec=0.1 * f.normal)

This shows where each face would be if we extruded individual faces along their normal.

Instead we could  move all the vertices along their normals.  This will give the impression of a 0.1 local scale on convex objects like the spheres and cube, but will "fatten" Suzanne.

import bpy
import bmesh

context = bpy.context

ob = context.object
me = ob.data
bm = bmesh.new()
bm.from_mesh(me)

for v in bm.verts:
    v.co += 0.1 * v.normal

bm.to_mesh(me)
me.update()

Putting it together.

Here we move each selected face along its normal, by finding all the verts that belong to selected faces, then for each vert move along average of the normals of connected and selected faces

Run in edit mode with faces selected.

import bpy
import bmesh
from mathutils import Vector

context = bpy.context

ob = context.object
me = ob.data
bm = bmesh.from_edit_mesh(me)

verts = set(v for f in bm.faces if f.select for v in f.verts)
for v in verts:
    norms  = [f.normal for f in v.link_faces if f.select]
    n = sum(norms, Vector()) / len(norms)
    v.co += 0.1 * n

bmesh.update_edit_mesh(me)


View Port Guide/Grid Broke? Front, Back and Side Cameras

Use Alt + B to clear the clipping region, or use the menu View > View Region > Clipping Region.


how to hide particle emitter but not particles

In the Particle systems > Render tab, uncheck Emitter.


How to animate the fill colors of a 2D drawing?

This might suit your needs:
In the Timeline window or Graph Editor window set the Playhead (the blue marker) on frame 1.
Go to the Material Properties of your object and select a material you want to have change color. In the same panel go to Surface > Fill and hover your mouse cursor over the color. Press I. You've now created a keyframe for animating this color, and it should show up as a diamond icon on the Timeline and as a point in the Graph Editor.
Now set the Playhead (blue marker) on frame 2 and go back to the the fill color of your material and change it to another color(. Mouse hover over it again and press I again.
Now set the Playhead (blue marker) on frame 3. Go back to the the fill color of your material and change it back to the first initial color (or possibly to another third color). Mouse hover over it again and press I again. (a third keyframe is needed because the next step does not seem to work with only two)
When you have a nice cycle of color change that you want to repeat, you could repeat this process manually, but less labor intensive is to do it using the Graph Editor.
Select all the keyframes in the Graph Editor, press Shift + E and choose Make Cyclic (F-Modifier). You've now added a modifier that can be found (or also could have been added) in the Modifier tab of the Graph Editor N-Panel. (you can extend or collapse it by pressing N in the graph Editor)

Now if you hit Play Animation on the Timeline the material will rapidly change color, giving a flashing effect.
If you want if to change color slower, select al the keyframes in the Graph Editor, press S (and then X) to scale the distance in time between them. That might look something like this:

Alternatively, if you would want a material to be one color for (for instance) 20 frames, and then instantly change to another color and remain that color for 20 frames. you can use two keyframes per color to indicate a length of time on the Timeline. That would look like this, with the keyframes of one color on the left side (of frame 21) and the keyframes of another on the right.

Hope that helps : )


BoolTool add-on

I'm not sure on what you mean by saying polyverts, but I'm am assuming that is something similar to parenting+vertex duplication...

So starting from a similar situation, after make the duplicate real, we have a plenty of different objects.

Download and install the BoolTool add-on that will allow us to merge all the objects with boolean operation.

Select all the objects, make the base mesh the active object (the biggest one: it's important that this object has at least a piece of volume in common with every sphere object) and choose from BoolTool tool tab the Direct Union tool.

It will take a while (depending on the number of spheres,their resolution and your hardware...for me about 15 minutes), but the result is quite good, clean and, above all, watertight.

Below a view of the insight. Notice how there is only a shell. The internal faces do not exist anymore.


Is there a quick way to move a keyframe to a specific frame?

I think that the best you can do is type the preferred frame into the Timeline 'Current frame' field then apply a Snap to (ShiftS) frame function on the selected Keyframe.

It would be neat to have another snap to function as you suggest to reduce the amount of mouse clicks involved.


Can't select edges after dissolving and using loop cut tool

Those dark orange edges are on a separate object which is selected outside of edit mode.  Either you had both objects selected when you went into edit mode, or you Ctrl + xlicked it while in edit mode, or (more likely) you inadvertently disconnected it by hitting P with that geometry selected.

Either way, you can fix this by exiting edit mode and joining the two back together again with Ctrl+J (with both still selected).

If you need to reconnect the edges, select the vertices in pairs and merge them with Alt+M.  (Selecting all with A and hitting W > Remove Doubles may also work to reconnect at least some of the geometry.)


How to preserve the main dimension when adding space between elements

let's start from your exemple with those objects (i'll call them Base):

1st, we create objects (i'll say Spacers), they don't need to have geometry but giving them a shape make them visible and selectable. The important thing here is their origin, it has to be in the middle of the space between the objects we want to control.

The horizontal Spacers on the right have to be rotated 90° on the Y axis in Object mode, because we'll use their local X axis.

Now select 1 of the Spacers RMB and the Base object touching it (in this order) Shift+RMB and enter Edit mode Tab. Select the face touching the Spacer, hit Spacebar to search for Hook to selected object, click it with LMB. Now your face is hooked to the spacer object. Get out of Edit mode Tab. You can move the spacer to check if the face is following as it should.

Repeat the same operations on every Spacers and their  adjacent faces. There are 3 Base objects that needs to be hooked to the same spacer.

Now select the second Spacer, go in constraints tab and add a Copy Scale constraint. The Target has to be the 1st Spacer, the controller. Remove Y and Z axis, choose local space from in 2 Space menus. For this spacer, we'll use an Influence of 0.5. This is important because the concerned Base object will be affected by 2 spacers but the left Base object is affected by only 1, so the scale has to be 1/2.

This one needs an Influence of 1.

The selected Spacers have an influence of 0.5, the others have 1.

Now you can select the Controler Spacer and scale it on it's local X axis with S->X->X and all object should be modified to use the same space between them!

Here is the .blend file


Given an object ob, you can access its mesh at ob.data, and its vertices at ob.data.vertices. The vertex groups are defined on the object as well, at ob.vertex_groups. Each vertex group has a weight() function you can call to get the weight of a vertex.

vg0 = ob.vertex_groups[0]
for index, vertex in enumerate(ob.data.vertices):
    try:
        weight = vg0.weight(index)
    except RuntimeError:
        # Raised when the vertex is not part of the group
        weight = 0.0

    print('Vertex #%d at %s has weight %f' % (index, vertex.co, weight))

For efficient distance queries (from a point in space to a mesh) you can use the BVHTree module. This may work faster than trying to compute the distance between every point of one mesh to every other point on the other.


Where is the "Project Paint" and "Layer" option in Blender 2.77a?

First, the video uses 2.61 not 2.7x. I edited your question to reflect this.
The project paint panel resides in the options tab, and the uv layer select is in the slots panel of the slots tab.

Blender User Interface Terms


In 3d viewport , how can i add object to new collection without it's being unlinked from current collection?

3D View object > collection Menu

Link the cube that is already in "Collection1" to a new collection, "Collection2"

The shortcuts as listed on the menu

M Move to Collection
ShiftM Link to Collection
CtrlG Create New COllection


While in texture paint, make uv map edges visible (Cycles)

If you switch back to BI then select texture paint, then you can go back to cycles to paint and the outlines should stay. I think it is a bug because it turns off sometimes until you switch back and forth again.


Parent two objects, without the child getting moved by the parent

This can be done fairly quickly; what you need to do is and an empty to the location of the child, and then make the child copy the location of the empty, using a constraint — now you can safely parent both objects and the child won't move.

You can do this by:

While in Edit mode, and with the child selected, pressing Shift + S > Cursor to selected
Pressing Shift + A > Empty > Plain Axis
Selecting the child, going to the Constraints tab of the Properties window and adding a  Copy Location constraint, with the target set to the empty created earlier


How can I get the names of the vertex groups these vertices are in?

There's no need for operators, nor the bmesh module:

import bpy

ob = bpy.context.object
assert ob is not None and ob.type == 'MESH', "active object invalid"

# ensure we got the latest assignments and weights
ob.update_from_editmode()
me = ob.data

# create vertex group lookup dictionary for names
vgroup_names = {vgroup.index: vgroup.name for vgroup in ob.vertex_groups}

# create dictionary of vertex group assignments per vertex
vgroups = {v.index: [vgroup_names[g.group] for g in v.groups] for v in me.vertices}

# test: print list of vertex group names vertex 0 is in
print(vgroups[0])


why when I rotate a point in a curve all the points is rotating?

When you are editing curves, selecting the point of the curve also selects the two control handles that define the curve going into and out of the control point. Rotating this selection moves all three and may not give the result you want.

Another property of the curves control point is Tilt, you can see this value under Transform in the properties sidebar N. When using a flat extrusion shape this can 'twist' the extrusion sideways without altering the curve shape.

You need to be cautious with it's use as a large tilt value compared to the next points can give a visible crease.


Using drivers, you can use a channel as input value for almost everything you want to animate.

To keep it simple, I've used only two objects: the location X channel of the Sphere will be applied to the location X channel of the Cube

In this example, I've added drivers to the Cube location, (move the cursor over the location fields then press d)

In the Graph Editor, switch to Drivers Mode

Select the channel you want to animate, then set the Drivers properties in the Properties Panel (n)

If you only need to copy the channel without any operations, you can set type="Averaged Value".
Otherwise, you can choose the type you need:


How do I prevent object distortion when applying a curve modifier?

You can use a proxy mesh as the curve object, then use Dupli faces to place an object at each face. This has the added advantage of using instances, which are more memory efficient than the array modifier.

Add a plane and set it up with the curve and array modifiers:

Parent the actual object to the plane (CtrlP).

With the plane selected, enable Faces in Properties > Object > Duplication > Faces.


In the painting options it is called "bleed" and defined in pixels.


With your 2D plane selected, enter edit mode with TAB.
Move your mouse along one of the long edges.
Hit CTRL+R.
Roll your mouse wheel until you see the correct number of cuts (in purple).
Click the left mouse button.
Click the right mouse button.

Your plane will now be subdivided into equal parts.

You can now separate them into individual objects by selecting each one in turn (in face select mode) then hitting P then ENTER.


Maybe you should use boolean modyfier.

Create an object that has the shape of the hole you want to create.

Add boolean modyfier to the object you want to cut a hole into.

Make sure that the operation type was set to difference. Choose object that you want to use as holecutter.

Slide the holecutter into the place where you want hole to be.

Apply the modyfier and remove the holecutter.

Hope you understood my bad english, but if this post helped then let me know by votng this answer up. Cheers! :)


Not every bone position is saved on the pose library

It was tough, but I finally found an answer for that issue. The thing is, Pose library don't save positions of bones with DEF in the beginning of their names (I don't know if it's also true for endings and middle, cause I didn't try this).So to use Pose Library, rename the bones with DEF


I can not find mesh panel or mesh check box which should be in the fluid tap

Click the little arrow beside the 'Liquid' checkbox which will expand the panel and you'll find the Mesh entry on that panel.


press Shift+A and add a lattice

after that, select the object to be deformed and add a lattice modifier
 Under the modifier, make sure you select the lattice as the object  select your lattice, and go to edit mode, pressing TAB key; press Shift+leftclick to select the 4 vertices on the -Y direction of the lattice, press S to scale them. I've uploaded your blend file with the lattice:


Why is the boolean difference modifier not working on joined meshes?

I notice you're using Blender 2.90.x. I don't have that, I'm still using 2.83.4 and 2.91.
That said, I made an "O" by scaling a cube, and then making 3 duplicates with appropriate rotations and translations. I then joined all 4 objects into one. As you can see from my second screenshot, I got a difference, not a union, as expected.
One thing I would suggest for you to do is enable the "3D Print Tools" add-on and check your mesh for degenerate topology.


What is causing this giraffe patterning in my fur?

The issue is you have too little particles (and too many children particles). The 'clump' setting makes the children particles follow the nearest parent particle direction. Since your parent particles are so few, they are far apart, and all the hairs in between are actually children particles leaning in the direction of the few 'parent' particles, and that's creating the pattern.
Increasing the amount of particles should solve the issue, also reduce the amount of children particles so the total amount of particles is still reasonable.
Increase this amount (I increased it to 20000):

And reduce this (I reduced it to 50):

Play around with the values to reach the result you want.


Final result:

I have slightly different method then @user3800527 it's quite similar but I've started making this answer before so I'll just post it.

Before proceeding further enable F2 add-on in User Preferences.

Steps:

Create Mesh > Circle with 64 vertices (or as much as you want) and Fill Type > Triangle fan.
Select outer Edge of this Circle then Select > Checker deselect.
Hit S and Scale them a little.

Most annoying step. Select each "inner" vertex, hover mouse to outer edge then press F to make new face.

Select one of the outer vertices then press Shift+G (Select similar) > Amount of adjacent faces.

Press G>Z and move those vertices down a bit.
Select 3 vertices from outer edge again Select Similar then E>Z and move them down.

With still selected bottom edge press S>Z>0 to make vertices even on Z axis.
Extrude them again and scale E>S and after that press Shift+Alt+S>1 to make this edge a Circle.

Before closing this shape, go back to the top of it, select one of the longest edge, again use Select Similar, but this time choose Length and move them down a little G>Z.

Now we are ready to close this shape. Select bottom outer edge, extrude it up to cover our inner part, then extrude it again and close circle with Alt+M > At center.

Now select top edge and Bevel it using Ctrl+B, you can use mouse wheel to choose number of Edge Loops.

It's almost the end. Select all and press Ctrl+N to Recalculate Normals.
Select only outer faces, choose Shading > Faces > Smooth and turn on Auto Smooth in Data tab.

Edit:

Lightning.

For lightning I have used HDRI studio environment, as for example this one:

HDRI studio - this one is free to use. I've used one that I've created by myself.

Material.

For material I've used Principled BSDF from Blender 2.79 RC2 with this settings:

Roughness for making it a little bit "milky". Play with this value to get desired result.
Clearcoat to add extra shiny layer.
Transmission to make it glass-like.

  Note that results may vary based on Camera angle, HDRI image and it's
  strength, object thickness and such.


How to make such a material (Frosted glass)

Here is a try with Eevee, basically it's a Principled BSDF with Roughness at 0.6, Transmission at 0.97 and IOR at 1.23 (nothing very scientific here, probably needs to be tweaked), I've mixed it with a Glossy BSDF with a Layer Weight as factor in order to have more reflections on its periphery, and give it a Bump with a thin noise:


Images that I mapped to an object won't show up when I render the image

An object that is UV-unwrapped will show the UV-mapped image in texture mode in a 3d-view. If however the object hasn't had a material and texture assigned to it, the image or texture wont be rendered, as seen in first image.

Add a material to the object, then a texture to the material. Choose "image or movie" and open the image. Set Mapping to UV and choose the UV-map.


You can change faces to smooth. Go to edit mode and press T it's in one of the tabs. Make sure you select all the faces you want to smoothen.


Looking for a complete list of Shortcut Keys for Blender 2.8

You will find them in the preferences menu. Edit>>Preferences>>Keymap


transparent PNG image not working in cycles

You are not using the transparency node, but the translucency node

Transparency makes the area transparent while translucency let's some light throu but scatters it a little bit. A good example for this are the leaves on trees. If the sun shines on them, they are bright from both sides, while the trunk is only bright on one side, as it is not letting light pass throu


How to change location, rotation, scale and dimensions of more objects at the same time?

If I understand it correctly and you just need to set the same value for multiple objects at once, there is simple trick for this purpose:

Select all the objects
Click the input field while holding Alt
Enter the value

In the default behaviour, new value is set only for the active object (the last selected one).


How to Make a Rotation on Two Different Axes?

Copy location constraint

The easiest way to keep the text horizontal is to not rotate it at all. Let's see the movement from another perspective: it's a text, that doesn't rotate, but it's origin is moving on a circular rail.

Use an empty to build a pivot in the center and another to set the position of the object's origin. Parent the last empty to the first one and animate the pivot to build a moving point.

Now add a constraint to the text object's location targeting the moving empty. The text will not rotate (why whould it?), but it's following the movement, achieving the desired effect.


How do I animate spinning arm with spinning end

Set the origin of the arm at the point where you want it to rotate (note that I added a cylinder object as axis, that will be used later).

Select the blade, then shift select the arm, and press CtrlP to parent the blade to the arm.
This will make it move and  rotate with the arm.

Select the blade only and add a Copy Rotation constraint to it. On the Target object I selected the cylinder on which the arm spins, but it could be the main object as well or an emtpy.

The blade now follows the movement of the arm but the rotation on the Z axis determined by the cylinder object.


Transparency of Image Empties not working

With no transparency level set, and all transparency options enabled (for all objects), blender defaults to complete transparency of all objects except the one selected, and behaves similar to x-ray.

To achieve the kind of transparency you'd like, follow these 2 steps:

1) Set a transparency level in properties> data (here I've set both images to 0.35).

2) Enable transparency in properties> object.


Emulate light scattering using a volumetric emission shader

Using Volumetric scatter produces the most accurate results but required a considerable number of render samples to get satisfactory results. A much more efficient alternative is to fake the light scattering using an Emission volumetric shader.

Create an image of the light emission - black where there is no emission and brighter where light is emitted. For example, to mimic the Windows logo you could start with an image as follows :

You can use the Surface of a mesh to render the image of the 'window' and the volume for the rays and the shader will use the Object coordinates. It's helpful to move the Origin of the mesh to a point on the surface and to use a Mapping node to re-orient the coordinates to something more intuitive. In my case, I've used the default Cube, moved the origin to the centre of the face crossing the -Y axis and rotated the coordinate space so that X/Y is along the axes of the window and Z represents the distance from the window.

To achieve this, start with the default cube, open the Properties panel (N) and move the 3D cursor to 0,-1,0. open the Tools panel (T) and Set Origin to 3D Cursor.

Assign a material and add the following nodes :

This arrangement remaps the X, Y, Z coordinates so that the XY plane maps to the 'back' of the cube and the Z coordinate represents the distance from the 'back'. In this way we can easily map our Texture coordinates (XY) and use Z to represent the depth. The re-mapping of the origin ensures that 0 depth (Z) represents the 'back' face of the mesh.

Using an Emission Shader to add the Image texture will result in the image being rendered on both the 'back' and 'front' surfaces of the mesh. To 'hide' the front face we can use the Z coordinate to set Strength to zero whenever Z is greater than a constant and adding in a Transparent shader makes the mesh transparent (Note : I've set the Transparent shader to be less than 100% White so that it shows in this image - normally this would want to be 100% transparent so the mesh is not visible.)

To add the rays we can start by simply adding another Emission shader driven from the same image and connected to Volume Material Output socket rather than Surface. This will produce parallel rays :

NOTE : The MixRGB Add nodes translate the coordinates so that the textures are centred around 0,0 rather than the texture origin falling at the bottom-left of the image.

To get the rays to diverge you can scale them using the Z coordinate - the scale should be '1' at the 'back' surface and increase as Z increases.

It may be useful to be able to control the direction of the rays and a similar technique can be used to add offsets (also based on Z) to Skew the rays as they travel through the volume.

The rays should fade along their length. For this we can simply vary the strength based on the Z coordinate :

We also might want them to spread out as they travel. Again, the Z coordinate can be used - this time controlling the effect of a high frequency Noise texture to scatter the rays :

Finally, we can add some variation to make the rays less uniform.

Bringing it all together produces the following material :

Tweaking the source image and varying the Z-coordinate of the noise used for the rays and adding a Fog Glow in the compositor can produce the following :

Of course, you aren't just limited to single-colour source images :

Blend file attached.


Is there a way to ease keyframes as a whole rather than easing each component?

Part I.

To move many keyframes at once you can use the Dope Sheet editor instead of the Graph Editor.

In the Dope Sheet editor all actions are represented by little diamond markers. In the above screen shot the column of markers on the right (colored) are selected, and the ones on the left are not selected. Selecting, deselecting, grabbing, etc in this editor works the same way as in Blender's other editors.

Notice the order of hierarchy: The top row is for all objects in the scene. The second row is for just the "Cube" object. The third row "CubeAction" is for actions involving the object, such as LocRotScale transformations (but not for things like Material animation). The fourth row "LocRotScale" contains the actual animation keyframes and if you expand it you will see the individual rows/tracks for Location, Rotation, and Scale for each of the X/Y/Z axes.

So if you want to move just one axis you would expand "LocRotScale", find "X Location" for example and move just its individual marker. But to do what you described - moving all axes at once - you can just leave "LocRotScale" collapsed and drag that marker. All of the animation data will be moved together.

Part II.

If you want to adjust just the ease of the curves specifically and not their position, you can select the keyframes in the Graph Editor and scale them along only the X axis. Their bezier handles will be moved closer to or farther from the keyframe points, thus altering the ease.

As a variation of this you can try scaling with the Pivot Point set to Individual Centers. You may find that scaling and rotating from individual centers gives you more control than simply scaling along X.


Approach to get fastest flat color render times?

The fastest flat-colour renders usually come from using Blender Render, although it's also possible in Cycles which may be quicker if you have a lot of geometry.

Blender Render:

All you need to do is enable Shadeless on all your materials, and then the diffuse colour will be what controls the colour of that object.

To be doubly sure you're not calculating anything unnecessary, delete any lights in the scene and disable all the Shading options in the render settings (except for Textures if you have any textures applied)

Cycles:

Use an Emission Shader - this will indeed emit light (onto any other kind of shaders), but it won't have any shading on it and renders quickly.

If you do that for all your materials, then there won't be any other surfaces to emit light on to. However, if you do have a few diffuse surfaces and want to prevent the objects from emitting light, just disable all but the Camera rays for that object:

Finally, just to make sure it's as fast as possible, set the render Samples to something reasonable like 32 or 64 (or even lower if you're not too fussed about crisp edges), disable Shadows and set the Max and Min bounces to 0:

If CPU is not being used fully:

Finally, while it's rendering take a look at your CPU usage in your OS's task manager. If it's not using 100% of the CPU, it can help to render with more than one Blender at a time:

If you disable Overwrite and enable Placeholders, Blender will create a small place-holder image as it starts rendering and won't rerender any frames where the image already exists. This way, if you open another Blender and render the exact same thing at the same time, they won't overlap and will be able to render at double the speed (unless of course your CPU usage was above 50%).

You might still never get to 100% CPU usage if you're limited by your hard-drive/network speed or the amount of RAM available.


Face normals, Edge angles, and link edges count.

In your screenshot the peaks and troughs are extrusions which have a vertex edge count of 5, which is a simple test.

Can also look at the signed edge angle to find peaks and troughs. I've used 50 degrees.

And also look at face normals vs an up vector. (A simple z axis to test)

Test script run in edit mode.

import bpy
import bmesh
from math import radians
from mathutils import Vector

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

up = Vector((0, 0, 1))

#  because its an extrusion select on link edges
for v in bm.verts:
    v.select = len(v.link_edges) == 5

test_angle = radians(50)
# select edges on face angle
for e in bm.edges:
    if e.is_boundary:
        continue
    # hills
    e.select = ( e.calc_face_angle_signed() > test_angle
    # troughs
    or e.calc_face_angle_signed() < test_angle

for f in bm.faces:
    f.select =  f.normal.angle(up) > test_angle

Some combination of any or all of the tests above should cover most cases.


To make you leg work properly you need to:

Deactivate the Manipulate Center Points option in Pose or Object mode (made to shift objects from each others) otherwise you won't be able to rotate anything.
In Edit mode, give a correct parentage to your bones: Deparent the IK controller from any bone except the root bone that you will create at the end. Parent the foot bone to this controller.


Adding hair particles in particle edit mode

Try moving the particle system above the subsurf modifier in the Modifier stack by pressing the up arrow:

The resulting order should be something like

The two particle systems
The Subsurf modifier

E.g.:


As I was throughly looking through preferences one last time lest I post a stupid question, it appears that the option is not related to node wrangler alone: it's a theme option for all node editors called "Noodle curving".

So links are really called noodles.


viewer node doesn't show up (even though I enabled node wrangler and pressed shift+ctrl+LMB)

Until you make it work, you can add the Viewer node manually :).

The Viewer node is just a renamed Emission node.
So you can add that, and it will have the same effect.


Considerations for using .blend files between operating systems

The only major one I think are path names, if you had anything linked into a non packed .blend, you would have to double check and make sure that the paths to files were relative (If they are in folders near or with the .blend that is).

You can do this simply by going to External Data > Make All Paths Relative

OR

This can be avoided by just packing the file.

Also, to further understand why this is important

A full path or absolute path is a path that points to the same location on one file system regardless of the working directory or combined paths. It is usually written in reference to a root directory.
A relative path is a path relative to the working directory of the user or application, so the full absolute path will not have to be given.

Update: thanks to jesterKing and ideasman42 in the comments for pointing these out.

Windows uses case-insensitive filenames, mostly this isnt a problem because blender will use the case from the filename you select, but if you rename a file or directory (and only change the case) after this is already referenced from blender, you could then run into the problem where windows will resolve the path but loading the project on Linux/OSX (any non windows system) will fail. You might be best off to avoid this by using all lowercase names.
For linked and non-packed blends, make sure you have as many of your relative paths preferably under your main .blend file. Especially for Windows users: don't put resources (textures, sound) on different drives compared to your .blend files.
Quicktime support isn't available on Windows or Linux, so these can't read image/video formats supported by Quicktime.


How to batch import Wavefront OBJ files?

Unfortunately, this is not possible by default with Blender 2.5x+ it seems. In 2.49, you could hold Shift then press the Import Obj button and it would prompt you to select a directory with the sequence.

In 2.69, you can do the same with a script — it could be converted into a more usable utility but it works.

import os
import bpy

# put the location to the folder where the objs are located here in this fashion
# this line will only work on windows ie C:\objects
path_to_obj_dir = os.path.join('C:\\', 'objects')

# get list of all files in directory
file_list = sorted(os.listdir(path_to_obj_dir))

# get a list of files ending in 'obj'
obj_list = [item for item in file_list if item.endswith('.obj')]

# loop through the strings in obj_list and add the files to the scene
for item in obj_list:
    path_to_file = os.path.join(path_to_obj_dir, item)
    bpy.ops.import_scene.obj(filepath = path_to_file)

For unix machines the direct path should look like:

# location of obj folder
path_to_obj_dir = '/home/user/Desktop/objects/'


The blueish line means that the frames have been prefetched or cached to RAM. Prefetching will give you better performance and playback, at the expense of available RAM.

Uncached frames are being read and decoded directly from the disk file.
(Form the Blender Manual)

Prefetch P
Fills cache with frames. As many frames as fits into cache are load form the drive. This allows to fill in the cache as fast as possible when you really need to track something, but this keeps CPU and drive bandwidth idle if you’ve got Clip editor opened but not actually interacting with it.

It is therefore recommended that you prefetch (cache) all of the frames that you are going to be working with to RAM. To do this load the video file on to the movie clip editor and press P to prefetch (or you can simply play back the video once and it will be cached).
By default blender will only use 1GB of RAM to cache frames. You can change that number depending on the amount of memory on your system. To do that open the User prefences (Ctrl + Alt + U) and on the System tab you'll see the options for the prefetch and cache limits.

Dark purple starts where the tracking is not reliable and has larger errors
If you see red-magenta on the timeline that means that Some Data Failed to Reconstruct, which means that the tracker information is missing or not reliable enough to reconstruct the 3d scene.
Read: Some Data Failed to Reconstruct, Motion Tracking
Recommended reading: How can I get better results when doing camera motion tracking?


Animating Material Nodes in the Game Engine

The easiest solution is to use Object Color. This can be accessed both by python and by the node editor, and gives you access to three per-object values.

In UPBGE you can access object color using the ObjectData node:

In normal BGE you have to create a shadeless white material with object color enabled. Remember to make the diffuse color white, otherwise the color is multiplied (by default) by 0.8!

Slightly unclear from the image is that there are two materials: the shadeless object color one, and the node one.


It's not clear from the question your exact requirement because the link provided doesn't work.
Since you already know how to set keyframes using the Python Api here,animating between keyframes is only a matter of setting the correct interpolation at individual keyframes until next keyframe.
#Setting individual interpolation points
import bpy
ob = bpy.data.objects['Cube']

frame_num = 0
bpy.context.scene.frame_set(frame_num)
ob.scale = (4,1,1)
ob.keyframe_insert(data_path="scale", index=-1) # "-1" sets values for all axis's
bpy.context.scene.frame_set(frame_num)
key = ob.animation_data.action.fcurves[0].keyframe_points[0]
key.interpolation = 'BEZIER'

frame_num = 10
bpy.context.scene.frame_set(frame_num)
ob.scale = (1,5,1)
ob.keyframe_insert(data_path="scale", index=-1)
key = ob.animation_data.action.fcurves[0].keyframe_points[1]
key.interpolation = 'LINEAR'

#And so on ............

#Setting all interpolations at once
import bpy

ob = bpy.data.objects['Cube']
scales = [(4,1,1),(1,5,1),(1,1,6),(1,1,1)]
frame_num = 0

for scale in scales:
   bpy.context.scene.frame_set(frame_num)
   ob.scale = scale
   ob.keyframe_insert(data_path="scale", index=-1) # "-1" sets values for all axis's

    for fcurve in ob.animation_data.action.fcurves:
        key = fcurve.keyframe_points[-1]
        key.interpolation = "BEZIER"
    frame_num += 10


How to Override Poll for Clear_Parent in Background mode

Don't use the operator.
It is pretty simple to clear parent (set to None) and keep transform with simple API calls.
Python console code., clear parent on context object.
>>> mw = C.object.matrix_world.copy()
>>> C.object.parent = None
>>> C.object.matrix_world = mw
>>>

Similarly, via API calls,  to remove non meshes from scene
>>> non_meshes = [o for o in C.scene.objects if o.type != 'MESH']
>>> non_meshes
[bpy.data.objects['Empty'], bpy.data.objects['Camera'], bpy.data.objects['Sun']]

>>> while non_meshes:
...     D.objects.remove(non_meshes.pop())
...
>>> non_meshes = [o for o in C.scene.objects if o.type != 'MESH']
>>> non_meshes
[]


Disable gravity for a single dynamic object in the BGE?

In order to make an object "not have" gravity, you can move the object up at the same speed gravity pulls it down.

Connect an Always sensor to an And controller and this last one to a Motion actuator, with a value of 9.8 * mass (where mass is the value for Mass, set in the Physics tab of the Properties window) for the Z axis.


Need help recreating crazy colors/material from example

Here is shader doing same result.

ADD:

Same result for Blender internal engine.


How can I copy the base pose from hand rig to my hand rig?

Consider creating a pose library for the source armature. Assuming your destination armature has the same exact structure as the source one (same number of bones, same names) then this will work.
With the source armature selected, go into Pose Mode, then go to the Object Data tab of the Properties Panel. Expand the Pose Library section, and click New.

You now have a pose library, which can store any number of poses for your armature, but has no poses in it initially. So the field you now see will be empty. To the right of that empty field is a button containing a + sign.

Click it and and then choose Add New.

You should now see a pose listed in the previously empty field. It is called "Pose" by default.

The pose of your source armature is now stored as this listed entry. You can test this by changing the pose of your source armature, then going back to this Pose Library UI, making sure the appropriate pose is selected in the list (you must make sure your desired pose is the selected one in the list. It will often be the case that there is more than one pose in the list), and then click the Apply Pose Library Pose button, which contains a Magnifying Glass icon.

This will force the currently selected bones of the currently selected armature to take on the stored pose. It's important to remember that these stored poses can be applied on an individual bone basis, if desired. Only the selected bones will change to the stored pose. No UNselected bones will ever change. This can cause some strange results if one was unaware that some bones were unselected, while still wanting every bone in the armature to be affected by the stored pose. So it's important to know that this is how it works.
Once this pose is stored, you will need to apply it to the destination armature. To do this, you will need to select the destination armature in Object Mode, and then switch to Pose Mode. Select all the bones you want affected by the new pose (in your particular case, all of them). Now, return to the Pose Library section, which should still be open in the Properties Panel. You will notice that there appears to be no pose library anymore. Actually, it still exists, but your destination armature isn't linked to it yet. Your destination armature needs to be linked to the same pose library you already created before that library's poses can be applied to it. To link the pose library, click the weird looking link button immediately to the left of the "New" Button.

You will see the name of your pose library show up in the list (probably only one item displays in the list here, since you only have one pose library).

Click it, and it becomes linked to your armature. You should also now see the actual stored pose show up in the empty field below, as well. Make sure that this pose is selected, then click the Apply Pose Library Pose button (Magnifying Glass). Your pose has now been transferred to the destination armature.
You might ask why we would do things this way when setting all this up is so much more involved than simply using Copy and Paste. For one thing, Copy and Paste often doesn't work in Blender as we might expect. We can easily be led astray by our experience of how these features work in other programs, which can then lead to frustration. For two, by doing this, your poses are always safe, and can be reused repeatedly. It may seem like a lot to deal with to set it up, but a pose library is actually pretty useful once you get the hang of how it works.
Hope this helps.


Extract sequence of frames from imported MP4 - scripted?

You can do this using the compositor.

All you need is to prepare a simple node setup where you have a Movie Clip (Input) Node connected to the Composite (Output) Node. Load your video into the movie clip node, set a few small params in the script below (namely the output folder where you'd like to save the extracted frames and the frame range), and run the script.

The script will copy the video dimensions and set up your render settings accordingly (but will not alter the output file format).

import bpy
from os.path import join

S = bpy.context.scene
n = S.node_tree

vidNode = n.nodes['Movie Clip']

# Set Render Settings dimensions according to video
S.render.resolution_percentage = 100
S.render.resolution_y          = vidNode.clip.size[1]
S.render.resolution_x          = vidNode.clip.size[0]

# Render desired frame numbers ( UPDATE THESE AS NEEDED )
start = 5
end   = 200
step  = 3
frame_numbers = range(start, end, step)

outputFolder = "C:/tmp/test"    # <=== Update this
for f in frame_numbers:
    S.frame_set( f )
    fileName = str(f) + S.render.file_extension
    S.render.filepath = join( outputFolder, fileName )
    bpy.ops.render.render( write_still = True )

Copy this to a new text file in the text editor, change the values in the outputFolder variable and the start, end and step for generating frame_numbers, and press "Run Script".

If you'd like, you can also automate the creation of the node setup and load the video to the movie clip node; there are several nice answers here in StackExchange showing how to create and manipulate nodes via python.


The red box is your render border (what you want to render) This helps reduce render time if you just want to see what part of your scene will look like. Instead of rendering the entire scene everytime.

To get rid of it: press Ctrl+Alt+B.

More info can be found here: Render just part of a final image from Cycles?


Thanks to iceythe on BlenderArtists I have resolved my problems in two ways. The first part is this:

for window in context.window_manager.windows:
    screen = window.screen

    for area in screen.areas:
        if area.type == 'VIEW_3D':

            tmp = bpy.context.copy()
            tmp.update(window=window, screen=screen, area=area)

            class Override:
                pass

            for key, val in tmp.items():
                setattr(Override, key, val)
            print('Unwrapping ...')
            from bl_operators.uvcalc_smart_project import main as uv_smart_project
            uv_smart_project(Override, .02, 30, 0.03, True, True)

            return

The second part was a problem caused by my using save/reopen to clear orphaned data blocks, whereas this avoids the problem by using the purge function (which I knew about but had struggled to implement via a script):

context = bpy.context

def override():
    for window in context.window_manager.windows:
        for area in window.screen.areas:
            if area.type == 'OUTLINER':
                override_dict = {}
                override_dict.update(area=area)
                return override_dict

def ClearAll():

    for c in context.scene.collection.children:
        context.scene.collection.children.unlink(c)

    for c in bpy.data.collections:
        if not c.users:
            bpy.data.collections.remove(c)

    for o in bpy.data.objects:
        try:
            bpy.data.objects.remove(o)
        except:
            print('All objects deleted')

    override_dict = override()
    if override_dict is not None:
        bpy.ops.outliner.orphans_purge(override_dict)


Why is the 'GPU compute' render option blurred out for me?

Press ctrl + alt + u to open the "User Preferences".

Switch to the "System" tab and change your compute device.

(I do not have a compatible GPU, but yours should show up here, if it is compatible.)

I recommend clicking "Save User Settings" so that this is saved for next time you open a new Blender file.

Your GPU should now appear under the GPU compute section.


Buildings Projected to Terrain - Lattice and ShrinkWrap - bypassing the terrain and deforming the roof

Unfortunately I couldn't download your file but here are some ideas.

Set the lattice so that is at the bottom of the buildings.

To prevent the deformation on top of the buildings generate a vertex group, and assign only the bottom vertices of your buildings to it.

Then use that vertex group for the lattice. That way only the vertices on the group will be affected by the modifier.


How do I make my character's walk animation stop when he jumps?

This happens when you don't add any layer for the jump animation.
What's the meaning of layers in animations?
This is something like Photoshop projects, for example: layer1 is not appearing because there is another layer on top of it which is layer 2.
How can I add a layer or delete a layer in animation?
In the action actuator Here :

This is the layer what the animation is. In your case make the animation layer 2.
What about Deleting a layer?
You can't delete a layer. you can delete the actuator. You can just change the layer.


Your UV editor only shows currently selected vertices.
When you add a loopcut, all other vertices are de-selected.

Just check the UV Sync Selection button and it will work.


Colours from imported MP4 screencast video look dull in Blender

Nevermind, it was my mistake: I had changed the default colour management in the Blender startup file to the new "Filmic" rendering and apparently, that's not what you'd want to use in this case... After changing it back to "Default" everything looks as intended.

I guess a new question could be: How would I handle this in a scenario where I actually want to use Filmic, e.g. if I were to set up a 3D scene where this video was shown on a TV screen? How would I have to adjust the settings for the video to display with its original colours?


Make The Camera Focus On A Rotating Cube On A Path In A Loop Animation

Never animate any object without a controler.

In your case I would give a hierarchy that goes this way : A locator called MainCtrl => A locator called RotCtrl=> The Cube.
MainCtrl would be the one constrained to the path and RotCtrl the one that would rotate the cube. The Cam could be the child of the MainCtrl.
Then the camera could also have a Target (made with another locator) so that you could control how it looks to your cube during animation...

Whatever, NEVER animate directly your mesh, always use a control (rig) so you'll be able to change any geometry afterward without loosing animation


I use TexTools addon. It was 2.79 but someone ported it to 2.8 and it works pretty well

as you can see it has a -90 and +90 which you can assign a shortcut key to if required

here is the download

https://github.com/SavMartin/TexTools-Blender/releases/download/TexTools_2.80/textools.zip


make a object see through to reference image behind

You probably want to be using X-Ray mode instead of Wireframe. You can do this by hitting Alt+Z to toggle it on/off or by hitting the circled button in the image below.

Ironically, it's right next to the Wireframe viewport option :)


How to get all available entries of an EnumProperty?

Enums are something Blender defines, which doesn't have a Python equivalent.
Therefor you need to use the RNA API. (See API docs)

Here is a function which returns possible values for an enum:

import bpy

def enum_members_from_type(rna_type, prop_str):
    prop = rna_type.bl_rna.properties[prop_str]
    return [e.identifier for e in prop.enum_items]

def enum_members_from_instance(rna_item, prop_str):
    return enum_members_from_type(type(rna_item), prop_str)

# Test the functions above:
enum = enum_members_from_instance(bpy.context.object, "rotation_mode")
print(enum)
# ['QUATERNION', 'XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX', 'AXIS_ANGLE']


Copy object to another scene, but keep data

There are at least 2 ways:

Select your object on the original scene, go in the Object menu > Make Links > Objects to Scene > then choose your other scene.

You could also create an object in the other scene, select it and go in the Properties panel > Data, and in the top dropdown menu (Browse Mesh Data to be Linked) choose the mesh you want.


Well, someone should write an answer, because long ago, I got stuck on such things. (Of course I never get stuck now :P)

If the red disk is supposed start off solid red and fade into invisibility at 50 frames in, then it works fine.  It may not look so in the 3D view, unless you have VIewport Shading set to  Rendered mode (the small button just right of the Object Mode / Edit Mode button.)  Textured, Material and Solid view shading modes won't show animation of textures.


The Grid Plane in Blender by default is 1m X 1m for every square. When you make a Vector drawing usually your Vector Editor (Illustrator / Inkscape) will be set to something standard like A4 or A3. The longest side of an A4 is about 30 cm. (one third of a meter), an svg the size of A4 would look like this in your Vector Editor.

Imported in Blender that looks like this:

SVG drawings are based on Scalar values, but when you use Vector graphics in a layout program or import into something like Blender the program needs to know what kind of world-dimensions the shape has. It's either pixels, cm, inches, meters, etc.

In Illustrator

You might have a tick-box checked to make your .svg export 'responsive'. From what I read this will omit any width / height / units information -- it assumes you want to use the .svg on the web or something. For more insight about how Illustrator saves / exports .svg files I recommend their built-in manual or support site.

In Blender

currently when the default SVG importer (io_curve_svg) encounters an .svg which has no dimensions or 'SVGUnits' it will treat the coordinates the same as it would if you had set the units to pixels in your Vector Editor.


Custom operator that applies transforms to all objects

Press A to select all and then ⎈ CtrlA->All Transforms - apply transforms already works on all selected objects.

To get your example working, the context calling the operator needs to be from the 3dviewport, so it will fail if you are running the script in the text editor. Don't call the operator from your script, register the class and then search for it in the 3d view.

If you still have an issue, you can override the context. You can find several questions here to explain ways to do that.


Low level alternative to bpy.ops.mesh.uv_texture_add()? Blender 2.8

A low-level alternative to bpy.ops.mesh.uv_texture_add() is obj.data.uv_layers.new(name="UvMap"). This way you don't need to set the operator context.
Though, it will not allow complex unwrapping such as Smart UV Project.