How to get the physics engine to wraps a string around the moving part of a motor constraint?

The simplest way to simulate rope or string is using a Soft Body simulation on a row of vertices and add thickness with Skin and Subdivision Surface modifiers. You can use the Soft Body Goal to pin one end to the spindle - similar to your example.

Looking at your Blend file it appears that there is a problem with your parenting of the 'hook' point - it appears to pass through the surface of the spindle and this could be interfering with your simulation (as it will drag the 'string' through the surface rather than resting on it.

The accuracy of the simulation is determined by the number of verticies in the soft body mesh (more vertices will give a better simulation but will take longer to calculate) and the Soft Body Solver settings (in particular the number of 'steps' and the 'Error Limit').

Start by creating the 'string' of vertices. The simplest way of achieving this is to create a Path (Add/Curve/Path) and convert it to a mesh (Object/Convert To/Mesh from Curve). Create a Plane for it to fall on, with Collision enabled in the Physics properties.

Rotate the string by a slight amount so that the vertices don't falls exactly onto each other (or it will unnaturally balance each vertex onto the next), then add Soft Body in the Physics properties. Disable the Soft Body Goal and run the simulation.

To make the string interact with itself, enable the Soft Body Self Collision.

Adjust the Collision settings until you get the desired effect (eg, increase the Size for a thicker string).

Add a Skin modifier and a Subdivision Surface modifier to give the string some thickness, setting the vertex Mean Radius X and Y when in Edit mode to control the thickness of the Skin modifier.

It's important to note here that the 'collision' is not with the actual skinned 'rope' - rather it is with the 'core' of vertices that runs through the middle. The self-collision (rope with rope) is controlled within the Soft Body Self Collision settings but the collision with the 'floor' surface is controlled by the Collision set on that surface (the 'Outer' Soft Body and Cloth property). This means that this method is only applicable to circular soft body objects and that all soft body objects must have the same radius (ie, you can't have two ropes of differing thicknesses).

All that now remains is to pin the rope onto the spindle and this is achieved using the Soft Body Goal and to explain this fully we need to understand how the Soft Body simulation works.

The Soft Body simulation moves the soft body verticies independently of the 'actual' mesh position. This means that the Soft Body vertices can move away from where the mesh vertices that 'spawned' them actually reside. Each soft body vertex has forces applied to it based on a number of factors (such as the distance to its neighbours, proximity to surfaces, etc.) and the simulation engine determines its new location for each frame by resolving these forces - as if springs were pushing and pulling in different directions. One such 'spring' is the Goal - a spring connecting the soft body vertex with the position of the actual object mesh vertex. With the goal enabled the soft body vertex is constantly pulled towards that location. By hooking the vertex to another location this allows us to drag the associated soft body vertex to that location - which can then be pinned to, say, a rotating spindle. The strength and presence of these 'goal' springs can be controlled by a Vertex Group.

In the example blend file I notice that the Empty used to pin the rope to the spindle is parented to a Vertex, not the parent object. As vertices do not convey any rotation data (they are simply a point in space), this means that the movement of the empty does not properly follow the expected motion around the spindle - it starts outside the spindle but crosses to inside as it travels around. Because it passes inside the spindle mesh this will interfere with the collision and causes unexpected issues with the soft body passing through the spindle. To resolve this, change the Parent Relation from 'Vertex' to 'Object' or '3 Vertices' and re-position the empty back to its start location (both these options include rotational data and so will keep the hook point relative to the outer surface of the rotating spindle). The hook point should now correctly move around the outside of the spindle.

To hook a vertex of the soft body simulation requires the following further steps.

Select the soft body mesh and go into Edit mode (Tab). Select the vertex to act as the hook, create a new Vertex Group, assign that vertex to the Vertex Group.

In Object mode, select the Empty to use as the hook. Hold Shift and click the soft body to select it (you should now have both the empty and the soft body mesh selected). Go into Edit mode (Tab) and select the vertex to hook and press Ctrl+H to bring up the Hook menu, select 'Hook to Selected Object'. And back to Object mode (Tab).
In the Soft Body, enable the Goal settings and set the Vertex Group to the Vertex Group created in the first step.
Check the order of the Modifiers on the Soft Body object - the Hook modifier must be above the Soft Body modifiers for the Soft Body Goal to take account of it's hooked location.

Rotating the spindle should now drag the soft body vertex around the spindle. Assuming the Spindle has been given suitable Collision properties the rope should lay on its surface and wrap around, colliding with itself (due to the Self Collision) as it accumulates on the spindle.

If the simulation is not accurate then there are a number properties that can be adjusted to help. It's a good idea to always adjust a single property at a time, evaluating the result before adjusting anything else (otherwise you won't know what had the effect). This also means that if you change something that makes the simulation worse it's easy to take a step back to try something else.

If the Soft Body rope is too angular as it wraps around, subdivide the mesh further to provide more vertices.
If the rope between vertices are passing through the spindle or the rope passes into itself, enabled Collision Edge in the Soft Body Edges settings.
If the simulation is erratic, adjust the Soft Body Solver settings (one at a time). eg, decrease the Error Limit, increase Max Step, increase Min Step - these settings can significantly affect calculation times for the simulation. It's not uncommon to adjust these settings by a factor of 10 or more to improve the simulation. eg, Error limit 0.01 or even 0.005 or lower, Max Step 3000 or more, Min Step 100 or more. The trick is to increase them enough to improve the simulation while still keeping the calculation time within acceptable limits.

In addition to this it may help to adjust the Soft Body settings to improve stability. Again, adjust one thing at a time - by small amounts initially try progressively larger amounts if necessary.
Soft Body Goal - can increase 'Default' somewhat to make the goal 'spring' stronger (so it's tied more firmly to the goal), adjust Stiffnesss and/or Damping to prevent 'bouncing' around the goal.
Soft Body Edges - increase the Push and Pull springs to make them less flexible (so there's less stretch). Damping can slow down 'bouncing', Bending will make the rope less flexible. Enable 'Edge' collision for better collision detection (make edges collide rather than just vertices) - this can cause the simulation to take considerably longer to calculate.

Another thing to note is the Collision physics Soft Body settings. For small objects or fast moving vertices these become very important.

Note the Soft Body and Cloth settings - Outer and Inner - it's important to understand what they mean. For the Soft Body simulation, Blender calculates the new location of each vertex on each 'Step' of the animation. If the new location is within a surface then Blender will apply a repulsive force along the surface normal to repel that vertex. The 'Outer' setting controls how far off the surface the repulsive force starts to have an effect. The 'Inner' setting controls how far below the surface the repulsive force has an effect. For a vertex collision to take place it must 'hit' these collision zones otherwise it will pass straight through (if it's moving too fast, for example) - so larger zones usually produce a better simulation. However, it's also important that zones do not overlap. In the case of a small object like a spindle you should ensure that the Inner collision zone is not too deep as it can cause unexpected behaviour (see below).

Finally, fine tune the Self Collision, the Spindle Collision Outer, and the Skin radii to adjust the thickness of the 'rope' and its interaction with the surface.

Using your Blend as a start point I produced the following animation (after creating a fresh rope as detailed above and changing the parenting of the hook point to 'object') :

This was using the following Soft Body settings :

Spindle collision :

Spindle hook point parenting :

Note that I reduced the 'Inner' setting of the collision of the spindle - since the spindle is only 0.21 blender units in diameter, the default collision properties of 0.2 results in the collision zones from the front and back faces to overlap to that the opposite side 'inner' ends just 0.01 units below the upper surface. This means that if the 'rope' intersects with the spindle by by more 0.01 then it will be considered further below the opposite surface that it is below the upper surface and is dragged through the spindle. Reducing the Inner to 0.1 removes the overlap, giving a better simulation.

In addition, a stretchy and/or heavy soft body simulation will store up a lot more energy as it falls which can drag the upper vertices further through the spindle, further compounding the collision issue. This can be reduced by either decreasing the Mass of the soft body (in the main 'Soft Body' properties) or increasing the Soft Body Edges Pull/Push Springs closer to 1.0.

Blend file attached.


There Is No Media Output In A Specific Folder After Finishing My Render

In blender, animation renders/videos are automatically saved in the output folder location. But image renders are not. This is probably because, many a time we test render a scene to see how things are shaping up and we don't want to clutter our output folder.

In-order to save a rendered image manually, after the rendering is done, go to image editor.You can do this by clicking on bottom right dropdown of any window and clicking UV/Image editor as shown.
Once you are in this window, you can click on image menu and click 'save as image'as shown.
Alternatively, you can just press F3 key without even accessing the image editor window. Doing any of these, will direct you to a screen that asks you to select the folder location to save.

If you want the image to be saved automatically, you can use the following addon. https://github.com/elfnor/blender_auto_save_on_render

Please note that I didn't write this add-on. I only came across this while searching.


Applying a curve modifier to an extruded plane causes plane to become a line

There was a scaling problem (even though I applied scaling & rotation) but I couldn't find the Transform > Radius that Ramos described. I found that if I zoomed in far enough, what I thought was a line was the horribly deformed extruded plane. I tried numerous re-scaling of both the plane & the curve, and with the hint that Mr Zak supplied, went to the Bezier curve's shape properties, and unchecked 'radius' (path/curve deform) and set Minimum's Smooth (Twisting) value from 0 to 6.00. Mostly by luck(?) I got the desired results. Mission accomplished! Thanks all.


To me you will only need to Bones, one connecting the ankle with the heel and another connecting the heel with the toes.

First you need to construct the armature properly:

Shift+A add armature, then add a bone
Select the two markers 01, 04 to position in between, and align 3D cursor with Shift+S then Cursor to Selected, this will position the bone between the two markers.
Then enter edit-mode of armature and select the bone and Shift+S then Selection to Cursor
Select the markers 05, and align 3D cursor with Shift+S then Cursor to Selected
Then enter edit-mode of armature and select the second bone and Shift+S then Selection to Cursor

The second step is adding bone constraints:

For the first (root) bone use two Copy Location constraint with second on 50% influence to get in between position of two markers 01 and 04. Then add Damped Track to track marker 05
For the second bone use two Damped Track constraints with second on 50% influence to get in between position of two markers 02 and 03.

Result is shown as below:

The updated .blend file can be found here:


How can I force the Compositor to update via Python?

Compositing output can be updated by rendering without any Render Layers nodes in the compositing node tree.

See documentation about Render Operators

bpy.ops.render.render(animation=False, write_still=False, use_viewport=False, layer="", scene="")

If I am not mistaken this use_viewport parameter seems to be for controlling if the render process is shown in the UI. It is false by default so it should not show the render in the UI unless specified otherwise.


The Background image is not showing in the rendered slot

Without using additional geometry or compositing, you can use the image as background for the world. Set the Texture coordinates to Window.


Deform geometry along spline in Animation Nodes

First, you normalize the vertices positions into a unity setting. This is easily done by subtracting the lower-left-forward corner position of the bounding box and dividing by the difference between the upper-right-backward corner position and the lower-left-forward corner position of the bounding box as follows:

You will notice that the vertices are now in a cube located at the origin with length, width, and height of unity. Next, we choose an axis to evaluate the spline at, I will choose the x axis, because I want the cylinder to be deformed along that axis. I will then use the values of that chosen axis to evaluate the spline. We scale the tangent and cotangent based on the values of the other two axis (y and z because we chose x), add the result, and add the evaluated location on top of that as follows:

Want to center it? Just subtract 0.5 from the normalize locations:

You can compute the lower-left-forward and upper-right-backward bounding box points manually from a list of points using the following node tree:


Two materials overlapping each other in a weird way

You say that moving each face individually would take too long, but you can avoid that problem by moving them all at once:

Select all your objects in Object Mode.

Press Tab to enter Edit Mode and A to select all faces.

Press AltS to perform shrink/fatten, which moves faces along their normals.

Type a small, negative value like -0.01 and press Enter to confirm. (Depending on the details of your geometry, you may also want to try the Offset Even option in the operator panel, which could produce slightly nicer results.)

Now all your objects will be very slightly smaller, avoiding the overlapping faces.


You can use AltV for Rip fill.

Normally you could just press G with the vertex selected (or GG if you wanted to slide a vertex along the edge).
However, since the vertex you want to move has other edges connected to it, you must create a new, separate vertex with the one edge attached (Rip, V), and then fill in the newly formed hole (Fill, F). The Rip Fill tool does these two operations automatically.

I assumed that there is only one vertex at the corner. If you have multiple vertices in the same place (doubles), then you need only to press G with the right one selected.


Don't have a num pad, How would I go about changing the view?

Go to File-->User Preferences-->Input (or use a Ctrl+Alt+U shortcut) and check the Emulate Numpad box. You can now use the normal 1,2,3,4,5,6,7,8,9,0 buttons at the top of your keyboard to change camera views instead of the numpad.

Check out this answer also: How to reset the angle of rotated view without a numpad? It shows how to change the view without using any shortcuts.


What I see in this image is noise, not fireflies. What you are seeing is a preview render at only 10 samples, which is nowhere near enough for an interior scene. Simply try rendering with more samples. You may need 1000 to 5000 samples to completely remove all the noise.


ArchViz Glass for quick renders in Cycles?

Note: This has nothing to do with physically based glass.

Andrew Price reccomends this 'Glass Hack shader' specifically for archviz renders, where caustics aren't that important. Relevant part of video here

Working principle
It doesn't affect Shadow, Diffuse and Glossy rays in any way, but your camera still sees a reflection when looking at it.

Pros: Very fast, low noise
Cons: No refraction


Python script get face normal, then set it as another object's orientation (Z-axis) accordingly

Firstly, I'm not clear you are getting the normal of the selected face as opposed to the first face.

Quaternions are tricky.  I have found assigning to obj.rotation_quaternion does nothing, whereas assigning to obj.rotation_euler does, but I'm not sure I don't think I set rotation mode as you do at the end.

I don't think there is any value in setting the rotation of the first object to the selected face, this apart from not working (perhaps because of the above) doesn't help align the cone.

And I've got in the habit of using a bmesh, but you might be able to do it directly from the data.  But once you have the rotation Quaternion, you have to multiply the object's existing rotation by the inverse of the Quaternion.  Well, it worked for me.

# This example assumes we have a mesh object in edit-mode

import bpy
import bmesh
import mathutils

# Get the active mesh (assumes starting in edit mode)
obj = bpy.context.edit_object
me = obj.data
coneradius=1     # Im not sure how you plan to scale the cone.
Up=mathutils.Vector((0,0,1))

# Get a BMesh representation
bm = bmesh.from_edit_mesh(me)
selected_faces=[face for face in bm.faces if face.select]
if len(selected_faces)>0:
    norm=selected_faces[0].normal
    my_location=selected_faces[0].calc_center_median()
    # convert this to a rotation quaternion
    Qrot=norm.rotation_difference(Up)

    #Add the cone in object mode
    bpy.ops.object.mode_set(mode='OBJECT')
    bpy.ops.mesh.primitive_cone_add(location=my_location)
    cone=bpy.context.object
    cone.rotation_mode='QUATERNION'
    cone.rotation_quaternion*=Qrot.inverted()

    # Im not sure how you plan to scale the cone and translate it.


Base material:

In Node Editor add Subsurface Scattering shader set Radius to 1.5 to have nice darkened corners, select desired color (for example #CCE7D7) then add Glossy shader and set Roughness to 0. Add Mix shader, connect them and as a factor add Input > Fresnel to fake PBR reflections.

Now you will have something like this:

White spot:

To add this white spot in the center of the screen we will need Gradient Texture as color for Subsurface Scattering. We will also need some simple UV unwrap for the screen, mine is simple Project from view (bounds) from Front Ortho view.

Add Input > Texture Coordinates then Vector > Mapping, now in Mapping node choose Texture tab and set Scale to 0.7 (X, Y, Z) and Location to 0.5 (X, Y). Those values may vary based on your mesh/unwrap!

Now add Texture > Gradient, set it to Spherical, add Converter > Color Ramp, change black color to the one from base material steps and move white color to the left (more to the left, bigger white spot).

Connect it to the Subsurface Scaterring color slot and we are done here.

Note that I'm using Environment Texture for lightning and reflections. You will have it packed in .blend file.

Blend file:

Edit:

I tought that I can crank it up a little bit by adding this white spot in the center of the screen. More details above, I think that extending previous steps would be much better then creating it belowe edit.


Is it possible to get the length of a ray inside an object with nodes?

It is always the way you ask. Ray length is the distance from previous bounce or refraction.

What might be a bit confusing - you have to apply toning to the inner side (backfacing) of your object, because outside rays return distance from other objects - as ray begins from camera, not from light source.

As far as mapping goes - approaches are different - for instance: http://lesterbanks.com/2012/10/using-blenders-raylength-node-to-create-a-re-usable-custom-absorption-shader/


cannot import .obj into blender 2.8, but works in 2.79

You stumbled upon a curious problem with filename handling in the .obj format, that isn't well defined in the specification. I will discuss this with the Blender devs, perhaps the importer needs small adjustments to parse the file correctly under these specific circumstances. Since it worked in 2.79b it can be considered a regression.

TL;DR The handling for filenames with blanks isn't well defined in the .obj format specification and Blender expected a different format than what was provided in your file.

The Problem

The .obj is a text format for storing 3D models. The format contains various attributes that describe the geometry of the model. Typically the .obj is accompanied by a .mtl which describes the material and textures applied to the model. In order to keep track which files belong together, the .obj may contain a mtllib attribute followed by the filename of the .mtl.

Usually the beginning of an .obj would look something like this:

# Blender v2.80 (sub 74) OBJ File: ''
# www.blender.org
mtllib test.mtl
o Cube
v 1.000000 1.000000 -1.000000
v 1.000000 -1.000000 -1.000000

In case of your file it is:

#
mtllib "tree stump1 original model.mtl"
usemtl tree_stump1_original_model
v 4.136163 -1.200306 -10.798826 0.113725 0.152941 0.141176
v 4.140683 -1.205297 -10.794383 0.117647 0.156863 0.145098

Notice that the filename contains quotations marks. This is causing the problem. The software you used to export this model quoted the filename to avoid confusion on how to interpret the filename. While this is common practice in other file formats the specification for .obj doesn't mention quoting filenames and says specifically:

  Blank space and blank lines can be freely added to the file to aid in formatting and readability.

Which can be interpreted as blanks in filenames can be stored as is, which is precisely what Blender does. Unfortunately Blender's importer doesn't expect the quotation marks in the filename therefore misinterpreting the correct filepath. This results in the aforementioned error in your question.

The Fix

Open the .obj file in a text editor of your choice an remove the quotes and save. It should look like this:

#
mtllib tree stump1 original model.mtl
usemtl tree_stump1_original_model
v 4.136163 -1.200306 -10.798826 0.113725 0.152941 0.141176

The file can now be imported by Blender.


How can I randomize object instance's rotation?

It's pretty straightforward once you get ahold of the fcurves, which is the data used by Blender to animate properties.

This node tree works only for animated rotation, but you can easily expand it to take into account scale or location animations, by accessing the other fcurves.

First, add a group which we will use to extract each fcurve data at a given frame, and add an offset to it, with an integer as a parameter to randomize it for each individual cube.

Important :

Set the "Random Number" node to min =  - your max frame number (in my case -100) and max = min frame number (here, 0)
Set the "Repeat time" node to loop above your max frame number.
Set the "Evaluate Fcruve" node to Absolute

Then, simply loop over each object and gather the result of each fcurve, then assign it to your object's rotation :

Note that the rotations are in Radians.

My main tree looks like this :

Result :


Can't change Pose Position of Armatures to Rest with Alt-G,R,S combo

In the properties panel, under the armature settings you can reset the pose to the rest position by selecting "Rest Position."


Nevermind, I just found the solution. To adjust this just exit Retopoflow, pick the Retopoflow object and you will see it's using a mirror modifier. Align the origin of the mesh with the one of the object you're retopologizing and go back to Retopoflow, the mirror will be fine now.


Blue background is not just a paper that is blue. It basically means that the scene is filled with blue light thus your object seems blue.
You can set a transparent background from Render Properties panel under Film from the Transparent checkbox.


Making Emission Object Invisible with Volume Scatter

You have to go to the object tab under cycle setings, ray visibility and deselect the camera. It should not be rendered anymore.
You may have to set the surface to emission, not the volume.


Python API: How to pick the last created object?

Try this(I am on Blender 2.81a):

(set grease pencil object name to "Stroke")

import bpy

# De-select all
bpy.ops.object.select_all(action='DESELECT')

# Make blender think you are in a 3D drawing area
context = bpy.context.copy()
for area in bpy.context.screen.areas:
    if area.type == 'VIEW_3D':
        for region in area.regions:
            if region.type == 'WINDOW':
                context['area'] = area
                context['region'] = region
                break
        break

# The grease pencil must be active (name = Stroke)
context['active_object'] = bpy.data.objects['Stroke']

# Convert(create a new curve) grease pencil
bpy.ops.gpencil.convert(context, type='CURVE', use_timing_data=True)

# New curve will be the only selected object
obj_curve = bpy.context.selected_objects[0]
obj_curve.data.bevel_depth = 0.04
obj_curve.data.bevel_resolution = 8


Multiple UV maps -- One UV map always low res or missing

I found the solution.  It looks like the Unreal Engine only supports a single UV map for actual textures (you can still achieve multiple materials easily)

The reason my first example worked is because I was only actually using the 1 UV map and it had 2 materials inside of it and the other uv map was doing nothing.

I was going to delete this, but Blender and Unreal are pretty much attached at the hip at this point.  They fund Blender and the FBX export just went into the main package, so I'm sure I won't be the only one assuming I can duplicate the 'blender way of doing things' with multiple true UV maps like in this video
Tip: Using Multiple UV Coordinates (archive)

Simply put, it looks like Unreal Engine 4 only looks at UV map 0 for textures.


If you want deeper focus you need a higher number for the f-stop.
Or you can render the foreground image and deal with the background and it's sharpness through compositing.
How to blur background image.?
How to Blur a Video Background in blender?
An alternative would be to work at a larger scale, so that the model won't be as close to the camera, and the focus won't be as critical.
Depth of Field F-stop not doing anything?
A different solution also is to work with a much smaller sensor, so that you work with even smaller lens size to achieve the same Field of View, and gain a bit of depth of field.
How do I set focus range?


From the osl language specification under Global Variables -

  point P - Position of the point you are shading. In a displacement shader,
  changing this variable displaces the surface.

  float u, v - The 2D parametric coordinates of P (on the particular geometric
  primitive you are shading).

While you don't technically alter these values, you start with them and calculate an offset position that is then used to choose the output.


in edit mode select the loops you want to move, hit the "G" key twice will allow you to move the loop together.

Also, Propositional option while using the translation gismo


Is there a way to tile a texture automatically over an object?

While it isn't entirely clear what you are asking, if my assumption is correct, you want to map a texture onto an object in a way that it repeats X amount of times over one or both axes. Like a tiled floor.

The easiest way to do this is to scale the UV coordinates in the image editor to X times the bounds of the UV space. Any faces assigned UVs outside of this space will loop or "tile" like so:

Before scaling

After scaling


You can model a pine cone-like shape using icospheres and vertex bevelling.

Add an icosphere (Add > Mesh > Icosphere). In Edit Mode, select the topmost vertex, turn on Proportional Editing (O), and translate up (G > Z). Use the Mouse wheel to increase the size of the proportional editing influence area as needed, until you get an egg-like shape.

Select all vertices (A), then bevel the vertices into hexagonal faces using the shortcut CtrlShiftB. Try to scale the faces until they are as large as possible without overlapping each other.

Select all faces except the few on the bottom, then extrude the faces individually (Tools Shelf > Mesh Tools > Add > Extrude Individual).

With the extruded faces still selected, change the pivot to Individual Origins (through the menu at the bottom of the 3D viewport screen).

Scale the selected faces down in the Z axis to flatten them a bit (S > Z).

Change the pivot point back to Median Point.

Turn off proportional editing (O) and move the selected faces up a bit (S > Z).

Add a Subsurf modifier with at least 2 subdivision levels (Properties Window > Modifiers > Add Modifier > Subdivision Surface), and change the shading to smooth (Tools Shelf > Edit > Shading > Smooth).

If you want a slightly more twisted version, experiment with adding a Simple Deform Modifier in one of the steps along the way:


how do I make my textured objects look textured in my render?

Under the render panel/tab you must select to bake "Combined." My error was that I selected "Diffuse"


What is this pattern at the bottom of the default cube?

It is the 'active face', which is the face that was selected last.

This can be useful for actions like transforming, where if you change the 'Pivot Point' to 'Active Element' you can scale towards or away from the 'active face'.

'Vertex' and 'Edge' selection modes also have 'active' elements and will display the last selected element lighter than the others. Object mode also does this when you have multiple objects selected, which can be used to (among other things) copy settings from the active object to the other selected objects.


Magenta fog makes objects in foreground green tinted?

You're using some tricky compositing nodes here. A lot of compositor workflow uses "blending styles" (see the Mix RGB node dropdown for a complete list). Some styles have a procedural approach that creates extremely strange hue shifts and color distortion if you don't know what you're dealing with.

Since you're getting an unexpected green cast / hue-shift, it might be the Glare node to blame. It's really not designed for this kind of colored fog. You'd be better off either compositing in a discrete comp. app or using a custom node setup (e.g. Z-depth or fog render layer mask + Mix RGB > Hue). With your current setup, you'll have all sorts of unexpected visual results.


Armature is deforming too much mesh on one side. Rotating hand also rotates foot

Sounds like Automatic Weight Paint failed.
Possible reason can be wrong Normal Face orientation.

In this example I also model separate parts of body. Later I joined right parts together. When I Mirror right side to left side in edit mode with Ctrl+M+X Normals switched ... hmm. Automatic Weight Paint issue followed.

To fix it check first normal face orientation, like enable Display Face Normals in edit mode. On left side is direction pointed inward.
(Or you can display Face Orientation in object mode, but since this view mode use red/blue colors same as weight paint, I didnt wanted to mess up screenshots with similar colors here.)

Recalculate Normals Shift+N

Go to object Data Properties > Vertex Groups and Delete all Unlocked, and run Ctrl+P Parent > Armature Deform > With Automatic Weights again.

Note: I see red/blue color of face orientation vs WeightPaint Red/Blue is probably confusing here :)


This is because you are in Edit mode (↹ Tab). Try adding the plane in object mode to make it a separate object with it's own transforms.

That said, it's still possible to rotate geometry that's part of an object.

When you initially add the plane in edit mode there is an option to change its orientation in the Redo panel (F6):

And you can always use R to rotate geometry, e.g. RY 90 will rotate the selection 90° around the Y axis. See Why can't I translate parts of my mesh with the 3d widget?


To use an addon after copying it to Blenders addon folder, you must activate it first in User Preferences. You find it under: File > User preferences or you hit Ctrl+Alt+U.

In the Add-on tab you can search for your addon and activate it by ticking the checkbox.

Also see: Installing an addon


How to use these 6 textures ripped from a CryEngine game, with cycles render?

I noticed the Cryengine docs section on textures isn't complete but I managed to download a model and look at some of the textures. Hopefully these educated guesses will point you in the right direction.

I'm not seeing anything that matches the texture and color of her skin,
so that could be the game-engine vetex shader coloring the model and
using 1 for texture details. The model I downloaded also had 1a as an
alpha channel for the eyelashes.
Seems to be masking out the face to apply some effect on the lips.
Don't know about the rest.
You guessed it, the normal map. This one doesn't have an alpha
channel to handle gloss as mentioned in the Cryengine docs.
The eyebrows on this image don't match 1, So its possible that they
are only using the blue parts, perhaps in combination with 2.
This seems to be the Unified Detail Map, Which is separate from the
Normal map. This has an alpha channel so its controlling the glossiness.
Possibly for an effect in the eyeball geometry, Perhaps with the
sclera bit in 4

With all this in mind, you may need to do a few adjustments to some textures for blender, and you don't have to use all of them. For example; Blender doesn't use alpha channels to control glossiness, you will need to make a specular map based on the Alpha channel of 5.

The exact setup will depend on whether you are using Blender Internal or Cycles.


Control MixShader value by shape key value

Select the mesh, in the node editor right click hovering the mix Shader slider and choose "Add driver-manually create later".
Then open a graph editor window and set it as "drivers" instead of "F-Curves".
Select the Fac driver you created, open the "N" tab, choose "Drivers" tab, set all thoose options:
Scripted expression,
var,
Type of var: single property,
Type of single property: Key property.

Lastly hover on the shapekey slider, right click on it and choose "Copy data path", then in the driver tab click on the empty path field and press Ctrl V to paste.

Enjoy (consider that in some cases the driver is not updated in the viewport, like in "material" kind of visualisation, but it will work in rendered mode, and you can always click the "Update dependencies" button to have it work).

This is the complete driver in my setup, and an highlight of a common mistake you may be missing.


Correct skinning is still not deforming my mesh

Looks like your bone has the "deform" option unchecked


I'm not really sure that this will work for you...
But weeks ago, I faced a similar problem and after some digging, I found out that some parts of my model were disappearing because I had some Un-Applied Modifiers..

Just Check the Modifier tap in the Properties panel and hit apply on any existing modifiers..

EXCEPT FOR THE ARMATURE MODIFIER!!

please report back if this worked, otherwise upload the .blend file if you can!


Sounds like you somehow added a driver to an object on one of the layers. Simply right click the eye and choose Delete Driver. It is an undoable action so if you undo, it will revert so you might want to save the file and reload it.


Add a new UV set in the Properties panel , and unwrap the mesh in Edit mode using that UV set. Open a new image texture in the UV Image Editor at the size you want the final to be, and in the Render tab of the Proiperties panel, open up the Bake tab. Select 'Textures' and then press 'Bake', and you should see your existing textures from the object appear in the new image. Save it, and then set it in the material's texture stack for actual use.


2.8 How can I draw and fill a closed shape in 2D?

Blender 2.8: Grease Pencil Fill Brush Not Working

Set the fill in the Properties panel > Material section (same place as you would set the material for a mesh).  It's a little Check box.


How can I set the camera parameters for 3d motion tracking footage?

There is no need to un-squeeze the anamorphic pixels as an extra step (specially if you have already de-interlaced it, so you are dealing with a degraded original to begin with), just enter the aspect ratio in the Track > Camera > Pixel Aspect section.

For the sensor width enter the value you know and set the lens to 5.4mm
You can try to find the radial distortion coefficients (k1, k2) using the annotation tool. The procedure is outlined in this post:
How to determine lens undistortion values for motion tracking?
But Blender will optimize those settings in the solve if you set the refine settings to Focal Length, Optical Center, K1, K2.

At the time of solving and refining blender usually gets those parameters quite accurately.

You should aim for an error average of less than 1/3 of a pixel (0.3)
For accurate tracking and solving, please read the very detailed post on motion tracking:
How can I get better results when doing camera motion tracking?


Estimating the dimensions based on images alone is hard if you don't have a notion of the lens used, camera height and distance form the camera to the objects on the picture.
Finding dimensions for X and Y is quite easy in Google maps. There a tool to measure distance.
Click on the screen in your browser and select Measure distance.

That give us a solid starting point and a fairly accurate reference of the scale of things in the real world.

Make a screen capture of the image in your browser and import it to blender using the images as plane add-on (or create an empty as image) and place it flat at 0 on the Z axis.

At the bottom right of the image there is a scale for the map, you can use that to match the scale used in blender. Press S and re-size the plane until the scale is as large as 10ft in the 3Dviewport.

Make sure that the blender project is using the same units as those used in the image. In general it is a good idea to try to work in real world sizes.

Create the basic box shape of the building using the map as a reference (you might also want to have an image with satellite imagery that will reveal more details about the building). Keep that basic shape as simple as possible, you can add detail later.

The hard part of this project is going to be estimating the height of the building.
Start by Extruding the base shape in the Z axis to have something to work with. As a blind guess we can estimate that most buildings measure 10 feet per storey, so let's presume that our two storey building is 20 ft.

Add another image of the building to be used as background in the camera view. This time use street view.
(How to assign different background images for different 3d views?).

The next challenge is trying to match the placement for the camera in blender, so that the basic shape we created in blender matches the image of the building from google street view.
Set the camera to be at the same height as that of the google street view camera: 8.2 ft in the Z axis (this height might be different in other countries)
UPDATE:
The URL for google maps does provide some information that makes setting the camera a less painful process.

In addition to the latitude and longitude you can find:
y Is the field of view. It is not in degrees, it has to do with zoom levels in the browser, but by trial and error I've matched google maps "50y" to 90 degrees in blender.
(To set the camera's field of view change the settings on the lens section from millimeters to field of view so that you can use values in degrees)
h:  heading, in degrees relative from true north (0). In blender that translates to rotation values on the z axis. Note that for blender the numbers would be negative. NorthEast would be 45 in google maps, and -45 in blender.
t: Pitch angles are measured with positive values looking up and negative looking down. 90t would mean that the camera is looking straight, matching a 90 degree rotation on the X axis for blender's camera
Now move the camera in the x and Y axis and try to place it at the point where the the vertices of the object match the picture. Pay especial attention to the known dimensions, in this case the outside walls, at the point where they meet with the ground. Don't worry so much about the height, because we can't know for sure if our estimate is accurate. As long as the building matches in the X and Y dimensions we should be fine.

It will take a bit of trial and error to match the vanishing points of the building with the image by adjusting the position of the camera back and forth, maybe changing the rotation and refining the the lens size (field of view).
Once you have a decent match for the placement, then you can adjust the top vertices of our 3D building to match the correct height in the image. In this example the building is taller than the estimated 20 ft.
.

From there on, you can use more cameras and match them to the scene to refine the geometry and you could even do texture mapping based on the images.

Additional notes:
To navigate in the viewport while viewing through the the camera you can lock the camera to view

This link might be helpful:
How do I align my grid to background footage?, note that by doing that the camera height cannot be locked
If the field of view is clearly wrong or inaccurate you can use a tool like Blam to find out the correct lens for the camera.
If anyone has more information on how tho get the camera data from google street view please feel free to edit this answer.
Seems like the API for google street view  you can generate images with known parameters, as far as field of view and rotation (pitch) that will make the following procedure much easier and with accuracy...


Its because how the mesh is shaped as it contains ngons so if you would add subsurf modifier it would create weird geometry

try creating a good mesh without tris and ngons just with quads.

Here I've converted ngons to tris and quads by selecting all the ngons and Hit Ctrl+T in Edit Mode. Then ngons will be converted to tris and quads.

Then by bevel edges you can see that some of the shape remains same..

So, the solution is to create a new mesh with good geometry just with quads if possible. and bevel all the edges that curve when subsurf modifier is used.

If you can create the mesh its great. If not try using Booltool addon it would save lot of time in creating these kind of meshes.


I had a quick go.

Took the source image into GIMP and made it one long line.

Imported that image into Inkscape and used Path/Trace Bitmap to create the vector data, then saved as SVG. See notes at the end.

Used import from the File menu in Blender

Then extruded the curve. I also converted the curve to a Mesh and used the ReMesh Modifier to stop some bad geometry where vertices where connected from great distance.

From the User Preferences view I searched for Extra and selected the Curve: Extra Objects

Now I could add a new Curve and select the type Spiral and Logarithmic. Set the height and the number of turns to create the spring shape.

In the Curve panel ensure the Twisting is set to Tangent. This ensures the results do not twist as they are modified by the spiral. Without this you get an unpeeled orange effect.

Now you can add a Curve modifier and select the Spiral.

The final result.

Notes:
The image was not particularly high resolution and made the initial vector data quite messy.

I needed to remesh the curve to get the vertices density required to allow the curve to take place.

There are lots of disconnected pieces, not ideal for 3D printing.

My basic result has obvious sharp ends that would need additional work to create a clean cylinder.

Suggest you take a lot of time to create nice neat/clean vectors before trying to extrude/curve.


Curve not shrink-wrapping to some parts of mesh

Just increase the resolution (preview and render maybe, and keep the shrinkwrap to "project" as it is in your shared file):


Check scale, center geometry to origin, shift+C, clipping planes...

When importing DXF there are a few options to work with.

One is the scale. The default settings is scale = 1, wich obiuvsly means that Blender will multiply by this factor the incoming units of the DXF.

So if you had drawn with your vectorial software a square of 2mx2m, blender will import an object of 2unitsx2units.

If you were working in cm, your square shall measure 200. If in blender you are going to work in meters, you must put a 0.01 factor...

This is valid also for the location of objects. So it is important to consider also the relative distance of the square from the origin of the sistem. To avoid problems, if Is possible, I would suggest to move the geometry to the origin in your drawing software.

Another tool that may come useful is Shift+C

It will extend your view till all visible objects are in the 3d view. If it seem that the camera de-zoom too far away, there are probably objects much distant from the origin. Notice that they might come outside of the 3D camera's clipping planes, making them invisible.


Get Loc/Rot/Scale of object in material using Object Texture Coords?

You can get effective access to the shaded object's entire transformation matrix by using the Vector Transform node to find what the Object space's bases, (its [1,0,0], [0,1,0] and [0,0,1]) become, when they are measured in World coordinates.
Location:
(We know we can already get this from the Object Info node, but just for completeness...) Set a Vector Transform node to 'Point', from: 'Object' to: 'World'. Enter [0,0,0] as the point to be transformed, and you have the location of the shaded object in the World.
Scale:

These arrows point along the Y of their Object's spaces, and the objects have been scaled in Y, by between 1 and 2.5 . By transforming the Object-space vector [0,1,0] to World space, and taking its length, you get how much the object has been scaled in Y. Here, the scales are mapped to colors. Of course, you can do the same in X and Z, and, if you like, encode all 3 scales, XYZ -> RGB.
Rotation:
Well,  by taking the Object -> World transforms of [1,0,0], [0,1,0], and [0,0,1], we have the columns of the object's transformation matrix. We know the orientation of all the object axes. But how those orientations are expressed as rotations is another question. If you wanted to express the orientation as Euler rotations, you're into this territory. Even if you fix the order of rotations, (e.g. X, then Y, then Z), there is still no unique set that will arrive at the object's  orientation. So even if you make a node-group to make the Matrix to Euler conversion, and find a set of rotations that take you to the orientation, they won't necessarily be the rotations shown in the object's transform panel.

However, you can still do some useful things. This tree, for example, gets the angle of the projection of the object's Y axis  down onto the World XY plane, around Z. The angle comes out of the Arctan 2 node between -pi and pi. The other nodes just map that range to 0..1.
Although you can get the location of a shading-point as measured in another object's coordinates, that doesn't tell you anything about the scale or orientation of the other object's space, you still need something like drivers there, unless something comes up in Geometry Nodes? And I don't think you can deduce the absolute dimensions of your own, shaded object, unless you cheat by knowing the location of the object's origin in the object's Generated texture space, which always measures 0-1 along the sides of the object's bounding box, oriented with the object axes.


Set parent type to vertex.
Going by code in question it appears you wish to set each vertex as a parent of an empty.
In this case moving the vertex moves the empty.
Snaffled code from this answer
Notice that there is no requirement to set the empty location to the vertex, rather let the parenting take care of this. Having zero local translation from the location of the parent.  Using the UI confuses the issue somewhat as it sets the parent inverse
import bpy
from bpy import context

ob = context.object
coll = context.collection

for v in ob.data.vertices:
    mt = bpy.data.objects.new(
        f"Vert{v.index}",
        None,
        )
    mt.empty_display_type = 'CIRCLE'
    mt.empty_display_size = 0.2
    mt.parent = ob
    mt.parent_type = 'VERTEX'
    mt.parent_vertices = [v.index] * 3
    coll.objects.link(mt)

Re "hook" generally infers hooking a vertex to the empty such that moving the empty moves the vert.
How to iterate through mesh vertices and add hooks using script


How can I unsubdivide regions of flat faces with Python?

Edit Mode bmesh script.

Tested on subdivided and poked cube.

Tags all edges that have a face angle > EPS
Gets all triangular faces made up of only edges not tagged and joins them. (To Quad)
Feeds all verts that have no linked edges tagged into bmesh unsubdivide operator.

Can edit properties of both to quads, eg max face angle, and iterations for unsubdivide

Test script, run in edit mode. Needs no selection.

import bmesh
import bpy
from math import radians

EPS = 1e-5 # edge angle
ITER = 10 # unsubdiv iters
AST = radians(40)
AFT = radians(40)

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

for e in bm.edges:
    if len(e.link_faces) < 2:
        e.tag = True
    else:
        e.tag = e.calc_face_angle() > EPS

ret = bmesh.ops.join_triangles(
        bm,
        faces=[f for f in bm.faces if all(not e.tag for e in f.edges)],
        angle_face_threshold=AFT,
        angle_shape_threshold=AST,
        )

bmesh.ops.unsubdivide(bm,
        verts=[v for v in bm.verts if not any(e.tag for e in v.link_edges)],
        iterations=ITER,
        )

bmesh.update_edit_mesh(me)

Alternatively Dissolve edges with 0 face angle.

In edge select mode select an edge with no face angle, then select similar by face angle

Hit X

and dissolve edges.

A script

A quick edit mode bmesh script to do this.

import bmesh
import bpy

EPS = 1e-5

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

bmesh.ops.dissolve_edges(bm,
        edges = [e for e in bm.edges if e.calc_face_angle() < EPS],
        )

bmesh.update_edit_mesh(me)

Not sure how it will go on 5M ++ faces.  Could change slightly to work on selection.

        edges = [e for e in bm.edges if e.calc_face_angle() < EPS and e.select]

This will ofcourse create a number of ngons, that can be grid filled, and fed into the unsubdivided.


As Rob said, you should stop your loop at frame 59 so that the same pose is not repeated twice, but you should also copy your frame 15 pose and paste it at 45, because as you see it's not the same right now, so from frame 30 to 60 the movement is very slow and it may participate to what annoys you.


How can I map a texture node, using a factor similar to pointiness, when the mesh edges are too rounded?

I would use the normal output of the texture coordinate node and remap the values with a rgb curves node.

For this you need to have your model's normals pointing in a global direction. Say you modeled the body along the XY plane, so the normals of the part where the cord is (I don't know the technical term) points towards the Z direction.

So we will create a gradient from blackish to orange-ish along the mesh, depending on the value of the normal. A Z component of Z means black values, and a Z component of 1 (pointing UP) is more red.

We will add a noise texture to make it a little bit more believable, but I think you know how to do this already.

The node network :

Zoom on the "RGB curves" node :

Result :


Can a curve object modifier created geometry be used as boolean factor

As you have guessed blender doesn't let you use a curve object for boolean operations. While the remesh modifier technically turns the result into a mesh, it is still a curve based object.

I think your best option is to duplicate the text ⇧ ShiftD, then ⎇ AltC to convert the duplicate to a mesh and use it for the boolean. As you leave the original text object you can delete the mesh text, alter the text and repeat.


How to connect vertices together while joining another vertex in its path?

The best option is to use Join. Select the two vertices that you want to connect and press J to connect them. This will automatically create vertices at any edges that the new edge crosses:


When you import into Unity, there is an option to calculate normals, instead of importing them. Have you tried that?

Blender also has an option to show surface normals, as well as recalculate normals to face in or out of the mesh.


Problems with textures in Standalone Player

Procedural textures and generated texture coordinates or not supported in Blender OpenGL renderer, that means you won't see any procedural textures in Blender's Viewport nor in Blender Game Engine or Standalone Player.

For you textures to work the have to be image based textures (Voronoi, Noise, Clouds etc. procedural texture wont work) and the have to be UV Mapped, that means you have to create an UVMap Chanel, unwrap your mesh mesh and use that UV Chanel on your texture afterwards, generated texture coordinates won't do.

Unwrapping is an involved and time consuming process, try searching for video tutorials about unwrapping


Use only audio when mixing compositing and sequencer in post processing

Instead of hiding the movie clip in such an laborious way, just select it and delete it. Make sure you have only the movie clip selected, and nothing else.


I need help animating multiple rigid body hinge joints

You have a cube in the first layer that is bouncing off the physics of the arm. Delete that cube and you'll be fine.


How can an empty be added at intersection of edges using Python?

Getting the location is indeed trivial, even more with mathutils.geometry.intersect_line_line().

Getting rotation here is not so hard either. Let's call your two edges e1 and e2 (note that this is theoretical code, assuming you have your vertices array and empty object already at hand):

# We get 'average' intersection point - in case the two edges do not actually exactly intersect.
inter = mathutils.geometry.intersect_line_line(vertices[e1.v1].co, vertices[e1.v2].co, vertices[e2.v1].co, vertices[e2.v2].co)
vi = (inter[0] + inter[1]) / 2

# Then, we get our first axis.
ax = (vertices[e1.v1].co - vi).normalized()

# We get our third axis by cross product of first axis and second edge.
az = (ax.cross(vertices[e2.v1].co - vi)).normalized()

# Then second axis is crossproduct of the first and third ones.
# Note that if you know for sure your two edges are orthogonal,
# You can skip that and rather create ay exactly as we did with ax.
ay = (az.cross(ax)).normalized()

# Those three axes allow us to create a rotation matrix directly.
# However, we need to put them as columns, not rows. Since matrix
# creation in Blender uses rows, we'll have to transpose it.
mrot = mathutils.Matrix((ax, ay, az))
mrot.transpose()

# And now, we just have to make this a 4d matrix and add translation component.
mat = mrot.to_4x4()
mat.translation = vi

# And set this a base matrix of our empty:
empty.matrix_basis = mat


Grayed out appended Hemi lamps from older blender with odd behavior

Those two hemi's appear to be disabled in viewport. This is different to hidden in viewport, which is the eye button. disabled in viewport is the computer screen, as you can see in the first image.

If you click the Filter button next to the search (image below), you can then select what options appear next to the name of the object. Also, you can see that the cube here is disabled in the viewport, and is grayed out because of that.

You want to open it, and in particular, turn on the 'show in viewport'.

Here I have enabled show in viewport, and the cube is now visible for me in viewport.

I hope this helps, and if it's not this issue, then I guess it's something to do with 2.79 hemis in 2.8.


From 6 vertices for the base cylinder and 3 tentacles in the picture, you can assemble it in three parts :

First assemble the extremity, extruding one vertex on two
Extrude them (without moving)
Alt+M to join them at center
Then select more Ctrl+NumPad+
And make the faces F

Now select the three faces as the extremity
Extrude them with Alt+E then "individual faces"
Separate this faces a bit

Now round them using Alt+ShiftS and move the mouse to the right and validate
Then extrude again


Import materials from another blend file: how to deal with name issues?

You did, but blender renamed it because the old imported data was still in this file, even if not used. You can get rid of unused data blocks in File -> External Data -> Clean Up -> Purge, then try re-appending the material.


I have seen this a couple of times and it turned out to be one of the following:

the mesh is insufficiently subdivided (or not subdivided at all) before microdisplacement is executed

the mesh is overly subdivided before microdisplacment is executed

the max subdivisions setting is too low for the distance from camera to mesh (properties > render (set to experimental feature set) > geometry > max subdivisions)

the solution that worked for me in all cases was to find the sweet spot between too much and too little subdivision before I applied microdisplacement - in some situations (for reasons of available RAM) I was never able to get the visible mesh resolution to disappear entirely but it became a non-issue when motion blur was applied and/or when the render was viewed full frame (as opposed to very close in a pixel-peeping zoom-in)


Fast way to create loops between existing verticies

Duplicate points, seperate points, extrude them and use knife project?


can you add subdivision surface modifiers to specific vertex groups

No, you can't use Vertex Groups for Subdivision Surface modifier.

What you can do is select region you want to have smoother and use W > Subdivide Smooth.

Be aware that this method will create ngons and/or tris (when Quad/Tri Mode is checked).


Why does the previous frame sometimes get displayed as transparency when rendering animations?

Cycles cuts the final image into a number of tiles, as each tile begins to be processed it is cleared before the result gets entered into it. Blender internal doesn't appear to do this clearing step, leaving each tile update being drawn over the previous frame content.

For not seeing a tile in it's cleared state you will find the screen view gets updated in a thread separate from the rendering. A tile may get cleared and updated in between two screen updates so a tile that gets cleared may not be seen in a screen update before an image update is entered into it. The quicker the first sample is ready the more chance that the cleared tile is not updated to the screen. To test this set a large tile size and high samples rate using cpu so that it takes a while before an update is ready to view, even a simple background colour that updates quickly can be seen cleared before it gets updated.

As for the difference between your two example files, the startup.blend file has border turned on in the resolution settings with crop turned off. blue_ring.blend has both border and crop turned on.

It appears that border on with crop off causes full image clearing between each frame. Border off or border on and crop on doesn't perform this clear full image step.

Rendering within a border that doesn't get cropped would be a reason to clear the entire image to prevent any old image data being present around the cropped render. For an animation this step should only be needed for the first frame and should be able to be skipped after that. Probably no has thought of only running the clear step once at the start of the render animation task.


Re-do view of a photo via DEM data and Blender

Start with a plane. Subdivide it like 100 times.
In Top ortho view unwrap it using project from view bounds.

to the plane add a displace modifier that uses your hieght map as texture. Make sure the texture coordinates are set to UV.

For a smoother surface add a subsurf modifier.

From there just set the camera where you want.


How to reorder particle 'number' along a path?

You could try to emit the particles from faces and switch from Jittered to Grid:


how to make a 360 video (turntable) of an Object using a python script

You could use the add-ons linked to in the comments, but if you already have some form of script it's easy enough to plug in a small bit of code to get the same effect. Something like this. This adds a Camera (child) and an Empty (parent), then rotates the Empty on the Z-axis and keyframes each rotation, for frame: (1..num_frames+1).

import math
import bpy

def add_cam(location, rotation):
    bpy.ops.object.camera_add(location=location, rotation=rotation)
    return bpy.context.active_object

def add_empty(location):
    bpy.ops.object.empty_add(location=location)
    return bpy.context.active_object

cam = add_cam(location=(0, -5, 0), rotation=(math.pi/2, 0, 0))
empty = add_empty(location=(0, 0, 0))
cam.parent = empty

num_frames = 90
gamma = math.pi * 2 / num_frames
for i in range(1, num_frames+1):
    empty.rotation_euler[2] = gamma * i
    empty.keyframe_insert(data_path='rotation_euler', frame=i, index=-1)

You might perform some calculations to figure out based on the size and orientation of the Object, where to place the Empty and how far away to place the Camera and which Euler axis to rotate around.

animation example

Then you set your render resolution x, y and quality and output type, and scene.frame_start, scene.frame_end. A smart approach is to render the sequence as separate frames first, using the .png format. Then decide on the kind of final video format. A popular webformat is GIF or MP4. Blender can output a couple of video formats, but GIF is not one of them.

MP4
Blender can load a directory full of .png in the Video Sequence Editor  (VSE) and render directly to a video video format/container (mp4, avi...etc). See Save rendered images in different formats

GIF (animated)
Unfortunately there's no feature that lets you convert a sequence of .png straight to GIF built in. But there are add-ons that use tools like ImageMagick and ffmpeg to do the conversion.

spritify by Fweeb
roll your own scripts using ffmpeg: https://unix.stackexchange.com/questions/24014/creating-a-gif-animation-from-png-files


A character made of cubes? Is it bad for gaming?

The BGE needs more time to process multiple objects. Therefore it is advised to join objects that form a larger part of the landscape (e.g. a forest).

On a character the requirements of the character handling will dominate.

From artistic perspective an object that deforms (skin) is better to handle as a single object and animated via armature.

If you have objects with rigid parts like a robot or a car where nothing deforms you might use multiple objects. Nevertheless the armature method is still applicable.

You might even need a mix of both. E.g. the deformable mesh for presentation and the rigid objects for collision detection (check if the hand touched anything).

This strongly depends on your needs and your focus.

Other requirements might be:

breakable (can be done with both, but different objects are easier to handle).
lots of instances (here you need to look at the performance).

Edit:

When you want to change items and clothes in-game you better have them separated. If that is not the requirement they can be part of the skin mesh.


Why does assigning a second material to part of an object appear to delete that face?

All, after trying too many options and non worked, I had to uninstall version 2.82 which I was using and installed version 2.80, that solved the whole puzzle. I'm back on my project again. Thanks to all of you that contributed in one way or the other to help me solve this problem.


Glass: Increase "Transmission Roughness" as the object behind goes far

Cycles is physically based so you don't need to add anything to a regular transmissive shader.
Add a Principled BSDF to you plane. Set the transmission to 1. You can tweak the IOR but the default value of 1.45 is fine for the purpose.

The setup:

Result :


How do I stop wagon wheel effect when a wheel spins at low speed in blender

It's all about physics. You can change the movie fps, or you can use some motion blur to reduce the effect. You also cam change the count of details on the wheel to change the frequency,


Freestyle, render some objects with dashed lines and others with solid lines?

Use Groups

Freestyle has an option to apply the Line Set to a previusly created group. You just habe to enable it in the Selection by section and pick Groups. An empty fields will appear below where you can choose what groups will be affected by the linestyle options.

In the image above each cube belongs to a different group (you can see them in the outliner), and each of the two Line Set is targeting one of them.

You can group the selected objects by pressing Ctrl+G and select all the objects with the same material (or something else) with Select linked

What I presented is probably the most versatile way, but you can probably get a similar result by taking advantage of one of the other ways in which you can restrict the Line Style influence (e.g. you can hide your dotted object and use the Visibilty options...).


Rotate a 2D cross section to make a 3D object

Thibsert's answer is fine, but if you're using mesh already you can use the Spin tool from the Tool tab in Edit Mode. The number of degrees (Angle) needs to be set to 360 and you need to find the right axis and enter 1 there instead of the default 0


Bmesh script

This can be done similarly by using me.transform(T) with a translation matrix T. I have used an edit mode bmesh as it is simple to set  the active face interactively before running script.

Get the local coordinate of the face center.
Subtract it from all coordinates, effectively making face center (0, 0, 0) or origin.
Move the object globally to reflect the local transform of the origin.

Script and Origin to Selected 2.80 addon available here
 https://blender.stackexchange.com/a/134460/15543

Addon from link above, same result as script below

import bpy
from mathutils import Vector
import bmesh

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

f = bm.faces.active
if f:
    o = f.calc_center_median()
    bmesh.ops.translate(bm,
           verts = bm.verts,
           vec = -o,
           )
    bmesh.update_edit_mesh(me)
    me.update()
    # move the object globally to reflect
    mw = ob.matrix_world
    t = mw @ o - mw @ Vector()
    mw.translation += t

Since mw @ Vector() is essentially mw.translation the last line could be

     mw.translation = mw @ o

Related:  Set origin to bottom center of multiple objects


How can I render the entire video in Blender VSE?

You need to change the End Frame in the render settings.

If you are rendering at 24 frames per second, and since you have a 3 minute video you will need to set the End Frame to 4320.

You also will want to change the render Resolution (it is right next to the frame range), now you have it set to 960x540, full HD is 1920x1080 but with the scale set to 100%.
Read the video Encoding section of the blender manual for more information, or the 2.79 manual page.


You will have to reduce the number of polygons (vertices, edges and faces). My guess is that you have a pretty high poly model to generate a 41mb file.

One way to reduce a mesh's polygons is to use a Decimate modifier. Do note that you will have to apply the modifier before is takes effect on the export.


This solution really worked great for me. It is developed in python, the code is kind of long but the ideas are pretty simple.

First I found the global head and tail locations of each bone.

My solution to self-intersection detection between fingers and the palm is pretty straightforward. I checked the distance of each fingertip tail bone to a plane created from three points in the palm. This is the function that I built.

def getPointToSurfDist(testBone, triBones):
    #points for surface
    p1 = getBoneGlobalTailLocation(getBoneObByName(triBones[0]))
    p2 = getBoneGlobalTailLocation(getBoneObByName(triBones[1]))
    p3 = getBoneGlobalTailLocation(getBoneObByName(triBones[2]))
    #vectors
    v1 = p2-p1
    v2 = p3-p1
    #3D plane
    s1 = v1.cross(v2)
    #test point
    p4 = getBoneGlobalTailLocation(getBoneObByName(testBone))
    dis = (s1.x*p4.x + s1.y*p4.y + s1.z*p4.z)/math.sqrt(math.pow(s1.x,2)+math.pow(s1.y,2)+math.pow(s1.z,2))
    return dis

If the distance was below a certain threshold the fingers were considered to intersect the palm.

My solution to the finger-to-finger intersection is a bit more interesting and less trivial. I decided to look at each armature bone as a finite segment. Then I check the distance between each segment and all of the other segments. I have about 20 armature bones, translating into a cap of approximately 400 calculations (not too bad, very fast). If the minimum distance between two armature bones was under a given threshold it would be considered intersecting.

I translated the dist3D_Segment_to_Segment() function from:
http://geomalgorithms.com/a07-_distance.html
to python and applied in my code.
(look here to further understand the code.)

def getSeg2SegDistance(hs1,ts1,hs2,ts2):
    #implementation converted from C: http://geomalgorithms.com/a07-_distance.html
    #input heads and tails of both segments (head s1, tail s1, head s2, tail s2)
    #initialize vectors
    u = ts1 - hs1
    v = ts2 - hs2
    w = hs1 - hs2
    a = u.dot(u)
    b = u.dot(v)
    c = v.dot(v)
    d = u.dot(w)
    e = v.dot(w)
    D = a*c - b*b
    sc, sN, sD = [D, D, D]
    tc, tN, tD = [D, D, D]
    #compute the line parameters of the two closest points
    smallApproxErr = 0.01
    if D < smallApproxErr: #lines approx parallel
        sN = 0.0
        sD = 1.0
        tN = e
        tD = c
    else:               #closest point on infinite lines
        sN = b*e - c*d
        tN = a*e - b*d
        if sN<0.0:      #sc<0 -> s=0
            sN = 0.0
            tN = e
            tD = c
        elif sN > sD:   #sc>1 -> s=1
            sN = sD
            tN = e + b
            tD = c
    if tN < 0.0:        #tc<0 -> t=0
        tN = 0.0
        if (-d<0.0):
            sN = 0.0
        elif (-d>a):
            sN = sD
        else:
            sN = -d
            sD = a
    elif tN > tD:       #tc>1 -> t=1
        tN = tD
        if -d + b < 0.0:
            sN = 0
        elif -d +b > a:
            sN = sD
        else:
            sN = -d + b
            sD = a
    #division to get sc and tc
    if abs(sN) < smallApproxErr:
        sc = 0
    else:
        sc = sN/sD
    if abs(tN) < smallApproxErr:
        tc = 0
    else:
        tc = tN/tD

    dP = w + sc*u - tc*v
    return math.sqrt(dP.dot(dP))

This intersection detection works great. It is not a general solution to every armature rig self-intersection detection, yet for hands/ arms/ machines (with bars or pipes) this would work great. The idea can further be generalized taking into account the 'Envelope Radius' of the bones to effect the thresholding. It is useful to think about the distance calculation from the body you are rigging.

This solution is python based and really gets into the geometry. A simple solution from within the blender platform would still be nice

Good luck!


select the upper face, and press  I  to activate the inset tool.


Incorrect values when using the color picker?

Viewport colors are affected by lighting and color profile.
To display unchanged colors in the viewport, you need to do two things:

use the Emission shader (it's not affected by lights)
change View Transform to Standard

(Or just open your image texture in Image Viewer and pick color from there.)


Why are more particles showing in the render than in the viewport?

Your particle system is set to only show 10% of the total particles.

In the 'Display' panel of the particle system change the 'Display Percentage' to 100%:

This will display all the particles in the viewport.


Blend shadow casted by a 3d object over an object in real-life footage (VFX)

As for the floor, you should add a transparent object receiving shadows.

Since Cycles has been thought for photo-realistic renders, there's no easy way to isolate shadows.

You can use Layer and Render Passes.

Foreground

This layer contains all you want to render (your character)

Transparent objects receiveing shadows

This layer contains the helper objects that will receive shadows (the puppet).

Since we won't use any color informations, we'll use the Diffuse Direct Pass.

Background

This layer contains the shadow of our hero.

To avoid the "helper object" to cast any shadow, we'll exclude its layer.

Background image

Scene

Composite

Use the RGB Curve Nodes to adjust the shadows and to set the white level (white is transparent in Multiply Node)


Is there a way to move the pivot point directly of any selection

There is an option for that, it's a bit hidden:

upper right of the Viewport.
That would change the actual origin, though. If you want to temporarily do that, parenting and the 3D cursor are the only options I can think of. What exactly are you trying to do?


Is there a way to update Blender without deleting it and downloading the new version?

Blender doesn't have an (auto-)update function that would do this for you.

Some years ago I experimented with a way to create binary patches - that works pretty ok, but the experiment never took further form, as an entire infrastructure to support this needs to be created, and for such an effort no resources have been found (people willing to work on it, maintain it and the servers).

Until that day you'll just have to download the entire program. Note that you don't have to install Blender, you can just run it from the location you downloaded and extracted it to (at least on Linux and Windows, so assuming it works also on OS X).


procedurally generated mold (fungus) using voronoi texture?

Your technique seems to be the most adequate for the illustrated effect, just needs some tweaking.

All you have to do is run your Voronoi texture through two Color Ramps, one for transparency and one for color.

Add two stops to each so you can control progression smoothly.

You can control "cluster size" from a black to white color ramp connected to the shader mix node.

You can also control color variation with a green to white ramp independently, making cells more or less greenish.

For cell spacing you have to adjust the Voronoi texture size, on the texture node itself. If you increase the size the cells will be bigger and more spread out, you will then have to manually adjust the two other color ramps to make each cell "tighter", otherwise it will just increase size, without creating bigger gaps.

If you want better control over the color of your mold, instead of directly using a Color Ramp from green to white for color, use a mask color ramp from black to white conected to a Color Mix node Factor socket, and you can then use any other textures for actual diffuse.


I had the same problem, but when I updated renderman 19 to 20, my problem was solved.


Blender cycles with alpha texture and glass shader

It appears that this is caused by the alpha mask not being completely transparent, which results in the Alpha channel being a mix of white and dark grey instead of black. This will result in a mix of a lot of transparent shader and a tiny amount of glass/diffuse, giving the green haze.

As a quick workaround you can add a Math node set to .5 with Greater than as the operation.
This sets all pixels above .5 (gray) to 1 (white) and all those below .5 to 0 (black).
Add this to the alpha channel before the mix node (click for full size):

Without the math node:

With the math node:


Parts Of Object Hidden, Cannot Be Sculpted

This recently happened to me and I believe this is a glitch. When I switch to tab mode I tried to reveal hidden Alt+H  the vertices. When I switch back to sculpting mode, I can't sculpt it.
Again, I believe this is a glitch. I tried to copy the mesh to 2.83 version, unhide the vertices, and copy it back to 2.9 version and it worked.
Edit: after that, whenever I add a mask the it will be invisible. I think it's a bug


If you are using a Solidify modifier, you can't select the 'virtual' geometry generated by the modifier separately until it is applied.

The faces coloured in orange here are the real geometry, and the grey faces are 'virtual' geometry, this can't be selected separately. If you want to do something with the outer or inner layer you will need to Apply the modifier, that makes all geometry of that object 'real'.


Change Viewport Display Color of selection/collection of objects - Only changing one

It's even simpler than that ! Replace the last line with :
o.color = (0.8, 0.1, 0.0, 1)

FYI, the for loop iterates over all selected objects in the viewport, pretty straightforward.
Then the second line changes the material viewport display color. This is what you see when you set the Solid view mode to "Material". Be careful though, if your object doesn't have any active material, this will throw an error and terminate the script not so gracefully.

The last line is supposed to change the object viewport color, what you see when you set the mode to "Object".
Your script only takes the active object in the viewport, the one with the yellow outline. You rather want to change the color of each selected object, noted o inside the for loop.


Replace textures with colors in OBJ file?

In Object mode, select the object you wish to change colours on and click on the little ball icon at right.
This opens up the object's material channels or 'slots'.

Each face on an object can have one material slot which can be shared by other faces in that same or even other objects. With your cursor in the 3D window and the object selected. (RMB)  you can then access it's material slot(s)

Get into Edit mode (press TAB) and select just one of the faces you wish to de-texture.

In the materials panel at right, open up the "Diffuse" tab  and scroll to the top to see the list of materials this object is using.

The one that belongs to the face you've selected should be highlited.

Go up to the icons at the top again and select what looks like a multicoloured square.  That's the texture panel that is attached to the currently selected material slot.

Open that and scroll up to the top.  You'll see a list of textures.  There can only be one texture attached to each material slot so the one concerned with the selected material should be highlited.

Underneath that list is a one line slot that dispays the same name as the highlited one above.

To it's right there's a big 'X' .   That's what you have to click on to delete this texture slot.  If there's more than one showing, they're stray entries anyway so you can delete any you see there.  It won't affect other material slots that may be using those.

Once that's gone you're back to the basic colour that's showing in the material slot.

You can change this by opening the materials again and opening the 'Diffuse' tab, clicking in the small coloured  window.  A colour wheel will present itself.  Choose the colour by dragging the tiny white dot around.  To exit, press ESC.

-===============-

To re-colour faces, select the object, then go to Edit mode, (press TAB) and then press ALT-TAB and selct "Faces".  This which will place you in the "Faces mode. (amazingly)

In the 3D window you will see the faces associated with that object, all with dots in them.  Right clicking on any of these will highlite them.  Hold Shift down to multiselect.

Once selected, press the Plus sign to the right of the uppermost list.  A new (blank) slot will appear up there.  Give it a name by clicking in the slot below with an X at it's immediate right.  It may well have the default name - "Material" already in there.

Once named, click the "Assign" button.  Those surfaces selected will all take on this new material slot.

So - you can have a different materials or colours for each face if you wish, or the same material can be shared by several faces.

-==========-

If you have queries about this particular answer just leave a comment here.
They will be emailed to me.

Additional Info -

Have come across a new question relating to your own...  The answer has an animated demo!

The link -

Question on reflections


Boolean intersect behaves sometimes unpredictably

I tried the same, using plane for boolean operation and I got the same issue so I tried using a Cube for the Boolean rather than using a plan and there it is , solved! So you might have to use the cube for such operations and after you apply the boolean simply delete the Cube.


For existing addons you'll have to find its code and change the code where operators are added to menus.

When you write your own add-on, you can choose a different icon by specifying the icon parameter to the operator function with which you register your operator in a function.

From the Mesh Add operator template in the Blender text editor the snippet:

def menu_func(self, context):
    self.layout.operator(AddBox.bl_idname, icon='MESH_CUBE')

For a list of icons to choose from see the blender documention. There are many places where you can define an icon, but there is only one list. For instance for the menu function of a layout. It takes an icon, the list is the same.

Icons outside these are not (yet) supported. You can replace the entire icon set though by specifying an icon file at the bottom of the User Interface section of the theme editing in User Preferences


Can Blender model interaction of complex shapes

You won't be able to accurately produce the interaction of Stone Tetra Pods with the beach area and water in Blender. I'd advise against using it as a tool for engeneering research. It is best used as a tool for visual representations which don't have to be physically accurate. (However, there have been plenty of other applications.)

However, Blender has the rigid body system which can be used to simulate rigid bodies.

Add a rigid body world.
Add the objects (related) and make them active rigid bodies (with correct friction values e.g.).
Cache the simulation.

In this example the resulting interlocking of the shapes can be seen.


Make sure that the maximum draw type is set to textured and not Wireframe:

[


Applying FBX file data to 3D camera in blender

activate the "3D view: copy attributes" addon from your User preferences (CTRL+ALT+U)
Save user settings.
Close window, return to blender 3D view.
Space bar > search > import FBX file. Locate your boujou FBX file. Open it.
Draw a new space area for window, SHIFT+F9 to make your current view to outliner. Search using filter: CAMERA. If there´s a camera you´re in luck, go to 6.
select that camera and press CTRL+ALT+Numpad 0. It will make the camera you selected fro myour outline from bojou the "current" view camera. Press 0 in the numpad, your viewport will switch to camera view. Press ALT+A to play animation. See if it matches.
// You don´t need to apply any camera data to blender. Your FBX file SHOULD have a camera element.
Click on your camera from boujou, and go to camera properties on blender (properties zone to your right side of the screen, the camera icon). From there you should have all the properties Boujou sent, like aspect ratio, lens, sensor, etc.. Should all match accordingly.


In Pose mode, my bones are stuck in rotate, and wont transform

I found the solution!
You have to click on the button shown in the photo below.
sorry for my bad English I'm only 14 years old


The rendered image looks clipped, but in the viewport the clip distance seems OK

This is because Clipping Distance settings exist in two places.

One set for the viewport (in your Properties Panel):

...and another for the Camera / rendering:

Edit:

However...

Now that you've posted your .blend and I've had a chance to examine it, I can say your issue has nothing to do with clipping distance.

You have a SubSurf Modifier on your plane that is curving it.

It was set only to be visible in renders, not in the viewport.

Edit again:

I just saw your comment that you fixed it, so never mind. One last thing I'll mention - you can leave the SubSurf Modifier on, but switch it to Simple instead of Catmull-Clark, and this will give you the fine geometry for the Displace Modifier that follows, without rounding your plane.


how to import .glb file in blender 2.80 beta using python api?

GLB is the binary form of the glTF format, and the importer (2.80 and higher, or 2.79 with manual install) can handle GLB filenames directly.

bpy.ops.import_scene.gltf(filepath='path/to/myFile.glb')


Answer has been found here.
https://blenderartists.org/t/transparent-materials-workflow-from-cycles-to-eevee-from-2-79/1129207/5

TL;DR
Enable screen space refractions in your material under options.
Leave blend mode on opaque.
Ënable screen space reflections in your render settings under screen space reflection.


How to heal/fill this type of damage to a mesh?

For a flat mesh:
You can repair most issues like this by holding Alt and then right-clicking on the boundary edge. Now the perimiter of the hole will be selected. Now press Ctrl+F > Grid Fill. If it is a space with only four vertices/edges, you can simply press F to create the new face.

For a curved mesh: This is a little more complex, but still can be done. You will need to set the cursor position to the center of the curve/sphere. Now set the Pivot Point to 3D Cursor. You now are able to duplicate vertices on each loop and rotate them to the correct positions in the mesh. Simply select each quad of vertices and press F. This is more tedious, but is still effective.


multiple file package changes in blender 2.7?

I made the example of wiki blender with a little change. It seems to work well.
Version 2.79

# To support reload properly, try to access a package var,
# if it's there, reload everything
if "bpy" in locals():
    import importlib
    if 'simple_obj_import' in locals():
        importlib.reload(simple_obj_import)
    if 'simple_obj_export' in locals():
        importlib.reload(simple_obj_export)

import bpy
from bpy.props import *
#from io_utils import ExportHelper, ImportHelper
from bpy_extras.io_utils import ExportHelper, ImportHelper


Without using additional geometry or compositing, you can use the image as background for the world. Set the Texture coordinates to Window.


How do I add text comments to a blender file?

In order to access the text editor you would have to drag the window down. Try to change to the text editor from the 3d-view.

As the Info Area is basically just the header, when you switch to text editor you will just see the editor header. Try pulling the header down from the interface to the 3d-view and you will see the text input space appear. (note recommended).

Instead maybe switch the timeline area (usually bottom left (clock item)) to text editor and put something in there.

I recommend reading that.

https://www.blender.org/manual/interface/introduction.html


Freestyle is confusing me - Cycles Blender

So the thing is Cycyles viewport rendering doesnot support freestyle yet so you will have to render the scene to see the freestyle in action!


how to avoid gaps on the distribution of hair on a model?

Particles with Interpolated Children

Probably in some parts of your mesh, the particles (hair in this case) are not dense enough.

Interpolate option creates children based on the "main" particles properties (location, orientation...)

if these particles (main) are not enough, increasing the number of children would not help in filling the gaps. Notice how the spiral patter is similar to the one in your screenshots.

The image was made by adding a Particle system (Hair type) and tweaking the following values:

Emission Number = 100
Interpolated Display = 280

By disabling the Interplated children option, you can see the particles that actually are generated. These are the only one that will be truly affected by simulations, hair editing...the children will simply follow their properties.

You must ensure that the "main" particles are well distributed upon the mesh, and only at that point you can increase the overall density with childrens.

The image was made by adding a Particle system (Hair type) and tweaking the following values:

Emission Number = 4000
Interpolated Display = 7

Notice how the thinner part of the mesh is full of "guiding" particles.

Result:


Randomly coloring with script doesn't work correctly

Part of the issue is that when you append the new material to the duplicated object you never change the index of the active material slot which remains at 0 from the initial object. If you inspect the material slots of each object in turn you continue to add another material but never assign it. I would think that instead of constantly adding additional materials you would rather just have 1 material per object in this case.
import bpy
import random as r
import math as m
n=25

for i in range(1,n+1):
    ob = bpy.context.object
    material_i= bpy.data.materials.new(f'm{i}')
    material_i.diffuse_color=(r.uniform(0,1),r.uniform(0,1),r.uniform(0,1),1)
    if not ob.material_slots:
        bpy.ops.object.material_slot_add()
        new_mat = material_i
        ob.material_slots[0].material = new_mat
    else:
        new_mat = material_i
        ob.material_slots[0].material = new_mat
    angle = ((i-1)*4*(m.pi))/n
    bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={"linked":False, "mode":'TRANSLATION'})
    bpy.context.object.rotation_euler[2] = angle


As @MohammadHossein has said, it's important to have the length of the link longer than the driving arm.
I think of this as  a 2-bone IK rig, just like a character arm, if you want to look up tutorials on how to do those.

I've labelled the bones by analogy to an arm.

The Fore Arm bone has an IK bone constraint, target: IK Target, Pole:
IK Pole. The chain length is 2, to include the Upper arm.
The bones, target, and pole all lie in the same plane, parallel to the floor, normal to the axes of rotation
The IK target is parented to the rotating arm, and is the only connection between the rotating arm and the IK chain.
The meshes do not need to be in the same plane as the bones.

The differences from a character arm are:

It's mechanical, no need for deformation, weight-painting. Instead, the mesh-objects are directly Bone Parented to their bones

There are no poses, no disadvantage in having Empties as your IK target and IK Pole.

The rotation of the driving arm will then result in the reciprocal motion of the fan.


What are your "Clipping start" and "Clipping end" settings, the "Clipping start" option can too be too low, but you could also try setting the "Clipping end" option really high, because your scene could be scaled up, so what you think is a couple of meters actually could be hundreds of meters.
These settings are second to the top in the n menu


VSE script for to add constant gaps between strips?

I turned your question into one of my example scripts.  I'll include it inline because that's how stackexchange works:

import bpy

def gap_strips(strips, gap):
    strips = sorted(strips, key=lambda strip: strip.frame_start)

    cleanup = []
    for i in range(1, len(strips)):
        st0 = strips[i-1]
        st1 = strips[i]
        cleanup.append( [ st1, st1.channel ])
        st1.frame_start = st0.frame_start + st0.frame_final_duration + gap
    # blender's anti-overlap code might change the channel.  put it back.
    for x in cleanup:
        x[0].channel = x[1]

def gap_selected_strips(gap):
    gap_strips( bpy.context.selected_editable_sequences , gap)

gap_selected_strips(15)


I'd use the Simple deform modifier.
Add a bezier circle. Select the bracelet and go to the modifiers tab. Add a Simple deform modifier. Set it to bend and set the origin to the bezier circle. The bracelet will bend over the bezier circle's local Z axis, so you will have to rotate the circle. To get the result in the image below, I rotated the circle 90° around the global X axis. If I misinterpreted your description, you may have to rotate the circle differently. Once it bends the way you want it, change the angle. In the image below, I used 360°.

Note: I deleted the modifiers you had, except the subsurf. I did this for my convenience. I take it the curve modifier you had was the one you were using to get the bracelet to bend. If so, you should delete it. The order between the simple deform you already have and the one I'm suggesting makes a difference, and you will have to try to see which you want. You can change the order in which they are calculated by clicking the up and down arrows in the upper right corner of each modifier's config dialog.


In your case, the Molecular Addon works best. To download it, go here: https://github.com/scorpion81/Blender-Molecular-Script/releases and select the zip file for your OS. Do not unzip it. Go to Edit->Preferences->Addons, click Install and select the zip file. Then enable it.
Usage: The molecular add on is a way to make particle systems behave more lifelike, for example, collisions, stickiness, etc.
For your case (follow these):

Create a particle emitter (can be any shape)
Give your mechanical parts collision modifiers
Instance an object on the particle system (I use 1 subdivision Icospheres, low geometry is better)
Press the play button and make sure the particles fall correctly as you want. Note that the molecular addon is still not working right now and particles will still behave normally, which includes clipping through each other.
Once you are happy, scroll down inside the particle system settings and check "Molecular". The add on is now enabled, but in order for you to see the effects you need to bake it. Now we will adjust the settings.
Open the density menu and press the button. Choose "sand", and this will accurately calculate the weights of each particle.
Open the collision menu and enable Self Collision (particles collide) and Collision with Others (particles collide with other things).
In order to see the results, open the simulate menu, choose a frame range, and press "simulate". Once you are done you can view the simulation by playing the animation, and you can also reset it by just pressing "free bake"

Tips:

Instance low poly objects on your particle system. Even one less vertex makes a big difference
Make sure to increase the particle lifespan so they make it to the end of the animation.
Are items still clipping through each other? Increase the timesteps. I usually use around 16 timesteps for relatively fast simulations.


How do I fuse objects (like cubes and cones)?

You can join two objects with Ctrl+J:

Make sure that the object you want to have the modifiers for and the origin of the combined object is the last selected and the outline is lighter orange.

To separate again, Tab into edit mode and hit P > loose parts

note from author: Sorry for the terrible trident model. I didn't have motivation to try harder.


How do you select one of several meshes created in edit mode

In edit mode select any vertex, edge or face of the torus, then use Ctrl+L to select linked. All of the vertices (edges or Faces) of the torus will be selected, and given that the cube and the torus are not linked, or don't share any common vertices, none of the geometry of the cube will be selected.

If at that point you want to turn the selected vertices as a new object you can press P and choose separate selected. A new object will be created and can be transformed independently.

What you call "tree view" is the outliner window. To understand the difference between objects created in edit mode and those created in Object mode please read:   Why can't objects in Edit Mode have their own name?

If you are just starting using blender I recommend that you read trough the links on the following page: Resources for Blender


Just use a curve deform modifier:

Make sure that the origin of the curve is at the same position as that of the object you are wanting to deform...this will make it go much more smoothly.


Rendering on CPU vs GPU how to enable CUDA and performance on older system

Your card is way too old, below the minimum specs needed for the current versions of blender.
From the manual
https://docs.blender.org/manual/en/latest/render/cycles/gpu_rendering.html

CUDA
CUDA requires graphics cards with compute capability 3.0 and higher. To make sure your GPU is supported, see the list of Nvidia graphics cards with the compute capabilities and supported graphics cards. CUDA GPU rendering is supported on Windows, macOS, and Linux.

Check the minimum requirements here too:
https://www.blender.org/download/requirements/
You can try using older versions (2.79 or below) which might work, but know that you might not get any benefits for using CUDA at all.
Also blender does not work with SLI.


How to assign already created material with node editor?

Two things you need to do to make this work.

Change to Render Mode.
Learn how to add a HDRI image to your enviroment
so that your material have something to reflect.


Let say you've made your barbed wire with an Array modifier + Curve modifier. If you just want them to bend, you just need to subdivide your curve and move its handles, it will bend the barbed wire. If you want to bend + animate, here is a solution:

Select your curve, enter in Edit mode and W > Subdivide it enough.
Select each handle and ctrlH > Hook to New Object.
This has created empties that you can use to move the handle, thus bend your barbed wire as you want.
To make it more convenient and be able to reset the empties to their 0 position you can create an armature, and inside this armature create as many bones as you have empties.
Now switch your armature in Pose mode and select the first bone.
Select the corresponding empty, re-click on the bone, and ctrlP > Bone. Do the same for each empty.
Now the bones control the empties that control the handles, and you can come back to the basic curve position going in the armature Pose mode and altG to reset.

This solution will allow you to have a very flexible barbed wire, but if you don't need complicated movements you can use the Mesh Deform modifier or Bendy Bones, as Mathmaniage said.