On what Cloth Simulation Model is Blender Cloth Physics Based?

Summary: Initially in 2004, Todd Koeckeritz leveraged Provot's Cloth Model (Deformation Constraints in a Mass-Spring Model to Describe Rigid Cloth Behavior); also, he leveraged simplified portions of Provot's Cloth Collision Model (Collision and self-collision handling in cloth model dedicated to design garments). Then in 2006, Daniel Genrich completed an implementation of Mezger's Cloth Collision Model (Improved Collision Detection and Response Techniques for Cloth Animation). Additionally, Todd Koeckeritz created a parameter named "Steps"/"Quality" to handle time steps. Finally in 2008, Daniel Genrich released Blender Cloth (according to BlenderNation.com).

Research Papers:

Todd Koeckeritz (Contributor of Blender Cloth) says in April 2006:

  Provot was chosen when we started the project because I had the code written already from two years ago when I was working on cloth as a python module. So, we've started with that. However, the few semi-unique characteristics of the Provot paper referenced in the wiki page are being replaced now with a similar process from another paper. So, in some ways Provot is gone, or will be in the next release. However, the nice feature described by Provot in section 5 of his paper, deals with eliminating the super-elastic/rubbery effect that some cloth simulators exhibit. That was my reason for choosing the paper two+ years ago.

The initial checkin of Blender Cloth files for "trunk/blender/source/blender/makesdna/DNA_cloth_types.h" by Daniel Genrich (Contributor of Blender Cloth) reads in September 2007:

+/**
+* This struct contains all the global data required to run a simulation.
+* At the time of this writing, this structure contains data appropriate
+* to run a simulation as described in Deformation Constraints in a
+* Mass-Spring Model to Describe Rigid Cloth Behavior by Xavier Provot.
+*
+* I've tried to keep similar, if not exact names for the variables as
+* are presented in the paper.  Where I've changed the concept slightly,
+* as in stepsPerFrame comapred to the time step in the paper, I've used
+* variables with different names to minimize confusion.
+**/

Todd Koeckeritz talks about his implementation of Provot's Cloth Collision Model in April 2006:

  What we have now is a partial implementation of one described by Provot in his paper "Collision and self collision handling in cloth model dedicated to design garments."  We may not implement all that is described in that paper, but we do need to get friction working properly and get it working properly with moving and/or deforming collision objects.  What we have now works fine for dropping pieces of cloth on cubes and such, but there's no sliding when there should be and it isn't working now with collision meshes being deformed by armatures and such.

Todd Koeckeritz talks about Daniel Genrich implementation of Mezger's Cloth Collision Model in March/April 2006:

  Genscher is focusing on work on the k-dop collision system [...]
  The collision system we've implemented is described in papers by Metzger in 2002 and 2003 and is known as K-DOP BVH. From an end user standpoint, there isn't too much that needs to be understood about this implementation that is specific to the collision system. In most cases, you either want to spend CPU time computing collisions or you don't.

Todd Koeckeritz talks about Time Steps in April 2006:

  There is one more important concept for an end user to understand and that is the one of how the simulation deals with time. It is impossible to model all the atoms or molecules in a piece of cloth and those objects with which it might collide as it would simply take too much time to compute the results, so we compromise by using the point masses and springs described above. There is a similar problem when it comes to dealing with time. While some parts of the cloth modifier attempt to deal with time in a continuous sense, other parts only compute the results at specific points in time. For example, think of dropping a ball on frame one and having it hit the ground on frame 21. If you only had results on frame 1 and frame 21, you'd have no idea on how the ball behaved between those frames. It might have been moving at a constant velocity or it might have been accelerated from rest by gravity or another force. On the other hand, if you had all the frames from 1 to 21, you could examine the position of the ball in each frame and then know much better how the ball moved during that time. With that new information, you can then better predict how the ball should move between frames 22 and 51. The cloth modifier has some similar problems, although we deal with them at the sub-frame level. To do this a parameter called Steps is provided. The higher the number of steps, the more time is spent computing a result, however that result should be more precise. The lowest setting for Steps is 1, meaning we'll run the simulation once per frame. This is the fastest way to get a result from the cloth modifier, however, the results might be less physically accurate than if you choose a larger number.

In April 2006, Todd Koeckeritz called it "Steps". Between September 2007 and January 2008,  Daniel Genrich renamed "Steps Per Frame" to "Quality". The following code diff of "/source/blender/src/buttons_object.c" represents these changes:

-               uiDefButS(block, NUM, B_DIFF, "Steps:",                    10,80,100,20, &sb->minloops,  1.00,  30000.0, 10, 0, "Solver steps/frame ");
-               uiDefButI(block, NUM, B_DIFF, "Steps per Frame:",          10,150,150,20, &clmd->sim_parms.stepsPerFrame, 1.0, 100.0, 5, 0, "Quality of the simulation (higher=better=slower)");
+               uiDefButI(block, NUM, B_CLOTH_RENEW, "Quality:",           10,150,150,20, &clmd->sim_parms->stepsPerFrame, 4.0, 100.0, 5, 0, "Quality of the simulation (higher=better=slower)");

Parameters:

The Blender Cloth Modifier is based on a Spring Network, according to Todd Koeckeritz in April 2006:

  The spring network is built of three types of springs and the user is allowed to control the stiffness of the springs separately: (1) Structural Springs are built on the edges of the mesh. They provide the main structural integrity of the cloth. (2) Shear Springs are built on the diagonals of quad faces and provide some resistance to shearing forces in the cloth. (3) Flexion Springs are built similarly to the Structural Springs, but are built on top of two close to parallel Structural Springs. Flexion Springs provide resistance to folding, the stiffer they are, the more the cloth will attempt to retain its original shape. Think of them as starch for your collar.

The Blender Cloth Controls were more detailed in April 2006:

  Collision : This toggles whether the object is a collision object.    Collision objects are not cloth objects, they only allow the cloth
  objects to react to them when they collide. To collide with a cloth
  object, this button should be toggled on and the object should share
  a layer with the cloth objects with which it should collide.
  Bake Settings : This button switches the mode of the cloth modifier    panel to baking mode, allowing the user to bake the results.
  Simulation Type : Presently there is only one solver implemented, the
  Provot solver as described in his paper above. There are however 3
  forms of integration, Explicit Euler, Middle Point and Runge-Kutta.
  Collision Type : This allows the user to specify what type of    collisions to process for the cloth object. Presently only the None
  and KDOP options are available.
  Pinned Vertex Group : If a vertex group is chosen in this menu, those    vertices are not affected by the cloth modifier. They are
  pinned in    place.
  Mass Scale Vertex Group : This vertex group allows the user to    multiply the point mass by the influence/weight a vertice has in the
  vertex group. Thus parts of the cloth can have different weights
  making part of it appear wet or heavier for other reasons.
  Mass Vertex Group : This vertex group allows the user to directly    specify the weight of the vertices. The Scale parameter is used to
  adjust the results of this.
  Scale : This allows the user to scale the results of applying a Mass    Vertex Group.
  Gravity X, Y and Z : These provide an external force to the cloth.
  Spring Stiffness : These three parameters control the Structural,    Shear and Flexion spring stiffness.
  Damping Springs : This is the damping factor applied to motion    produced by the springs.
  Damping Viscous : This damping factor is applied to all motion of the    cloth, higher values produce results like moving through water
  or    mud.
  Damping Self Fr : This will be used as the damping factor for    friction caused by self collisions of the cloth.
  Damping Friction : This damping factor is applied to the cloth    vertices that collide with collisoin objects.
  Simulation Steps : This controls how many steps per frame are used in    the simulation. Higher values produce better results in general,
  but    take longer to compute.
  Simulate Adjustments : Adjustments controls whether or not attempts    are made to keep the springs in the cloth from exceeding their
  original length multipled by Tc. When set to -1, the Structural
  springs get increasingly stiffer, up to 100 times stiffer, as the
  springs's length divided by its original length aproaches Tc. At 0
  (zero), not adjustments are made. At 1 (one) or greater, Provot's
  algorithm of adjusting the springs is done as many times as specified
  by this parameter.
  Simulation Mass : This specifies the base mass of a vertice in a    cloth object. The final value of the mass for any given vertice can
  be influenced by the Mass Scale Vertex Group and/or the Maxx Vertex
  Group.
  Simulation MinZ : Provides an artificial floor below which the cloth    vertices will not go.
  Simulation Epsilon : This provides a buffer distance for collision    detection and response. In the current implementation, small values
  in the range of 0.001 to 0.005 generally work best, although in some
  cases larger values may be desired.
  Simulatin Tc : This specifies the critical deformation length as a    ratio to the original spring length. This value has no effect if
  Adjustments are 0 (zero).
  Simulation Spr Len : This allows the user to specify an artificially    large or small base spring length. When this value is
  1.0, the    simulation behaves normally. With values less than 1 (one), the    springs are treated as if they were shorter than they
  actually are    which can be useful to shrink clothing to fit tighter
  on a model ...    think spandex. If this value is greater than 1
  (one), it provides an    artificial force to expand the cloth object
  which can be useful to    give bounce to a skirt or dress.
  Simulation Pre-roll : This provides some artificial frames prior to    the start of the animation to allow the cloth to find its resting
  position.
  Simulation Col Loop : This is the maximum number of times per step    collisions will be tested. This parameter is likely to go away.

Daniel Genrich simplified the controls by May 2008:

  StructStiff: Structural Stiffness also includes shear stiffness. Both    define the stiffness of the structure of the cloth. Lower
  values will    make the cloth look like elastic rubber.
  BendStiff: Bending Stiffness describes how the cloth forms its    wrinkles. Higher values result in bigger but not necessarily more
  wrinkles.
  Spring Damp: Specifies how much the amount of movement will be    lowered. This can prevent unwanted jiggling, and can result also in
  smoother animation.
  Air Damp: How thick is the air? How much movement will it stop due to    its thickness? Practically speaking, you receive slower movement
  of    cloth with higher air damping. With air damping set to zero, you
  have    moon surface conditions.
  Quality: More quality gives more stable cloth (less jiggling with    high BendStiff) and additionally you receive better collision
  responses.
  Mass: More mass gives heavier cloth, with slightly more weight on the    border like normal cloth.
  Gravity: X, Y and Z direction of the gravity you want to have working    on the cloth.
  Min Distance: Defines the cloth thickness where the collision    response kicks in. It helps to keep a minimum distance between the
  Cloth and the colliding mesh. Just increase it if you encounter
  collision penetrations (This is only one of two available options
  to resolve that issue - you could also increase the Quality on the
  first Cloth panel).
  Friction: Friction defines how good a cloth can slide over a    collision object. See this for how friction effects the cloth
  collisions.
  Min Distance: Defines the cloth thickness where the selfcollision    response kicks in. It helps to keep a minimum distance between the
  Cloth.
  Selfcoll Quality: This values helps you to resolve several layers of    selfcollisions. Be carefull: the Collision Quality has to be at
  least    as high as Selfcoll Quality to have it working!
  StructStiff VGroup: Vertex Group to be used for Structural Stiffness    scaling.
  BendStiff VGroup: Vertex Group to be used for Bending Stiffness    scaling.
  StructStiff Max: Defines the Structural Stiffness maximum. The    structural stiffness gets scaled between this maximum (the red
  painted values on the vertex group) and the minimum StructStiff on
  the first Cloth panel (blue painted vertices on the vertex group). A
  linear interpolation function is used inbetween.
  BendStiff Max: Defines the Bending Stiffness maximum. The bending    stiffness gets scaled between this maximum (the red painted values on
  the vertex group) and the minimum BendStiff on the first Cloth panel
  (blue painted vertices on the vertex group). A linear interpolation
  function is used inbetween.

As of today (April 2015), the controls for Blender have three damping forces (Spring, Velocity, Air). Provot's model explains these three damping forces as follows (respectively: Internal, Gravity, Viscous-Damping/Air):

  The internal force is the resultant of the tensions of the springs
  linking P_ij to its neighbors. The external force is of various nature
  according to the kind of load to which we wish the model to be
  exposed. Omnipresent loads will be gravity, a viscous damping, and a
  viscous interaction with an air stream or wind. Let g be the
  acceleration of gravity, the weight of P_ij is given by F_g=mg. The
  viscous damping will be given by F_d=-C_dv where C_d is a damping
  coefficient and v is the velocity of point P_ij. The role of this
  damping is in fact to model in first approximation the dissipation of
  the mechanical energy of our model. It is introduced as an external
  force but could actually be considered as an internal force as well.
  Finally, a viscous fluid moving at a uniform velocity u exerts on the
  surface of a body moving at a velocity v a force F_v = C_v((n dot
  (u-v))n where n is the unit normal on the surface.

The controls today (April 2015) are very similar to the controls in May 2008. The full set of updated parameters can be found in the the current Blender Manual:
http://www.blender.org/manual/physics/cloth.html


Is there a way to hide the masking lines when using Texture Paint with masking enabled?

As far as I know there is no such option, which disables the white lines.
In Weight Paint Mode you have an option to display vertices instead of edges, but in Texture Paint Mode there is no option like this.

I think that using the Clipping Border Tool may be a good solution for you. Press ALT+B and drag a mouse to select the portion of the model which you want to be visible.

You can rotate selected portion, and paint on it precisely. And the most important is, there are no lines that may disturb you :).


Indeed, you should connect the composite node to the output of the node tree, otherwise it won't work -- that's a mistake in the tutorial.

If you want to change the mist colour, place a ColorRamp node in between, and change the colour of the right-most point.


How to hide Empty in perspective view Blender 2.8?

First press the related number on the numpad to select the view of your preference, then import the ImageReference Empty.
Then on its image properties deselect (uncheck) the "Display Perspective"


For some reason your model is "inverted".

Try this :

In object mode : Ctrl+A then choose "rotation and scale"
In edit mode : select all your vertices with A then replace your normals with Ctrl+N
Now simply reparent your mesh with the armature


Why faces created with Bsurfaces are not visible?

Check normals orientation

It is possible that some faces has negative normals facing to the cam. You should be able to recognize them by their darker blueish color once the "Backface Culling" option is disabled in the 3D view properties panel.

Bsurface take in account the sequence in which you draw each strokes to understand where the normals are pointing, according to the created face index.

With backface culling enabled, Blender will not show the faces who are pointing not toward the camera. Edges remain though, leading to your situation.

I suggest you to select Backfaces and run the Flip normals commmand.


I have error in my python code(while producing a blender addon) which i couldn't figure it out. Can anyone please help me out?

This looks like a path error, similar to what is described in this question.
Append python script for Blender 2.8


Whenever I press Shift + Z to Undo my errors It just goes into frame mode why does it do that?

The shortcut for undo is Ctrl+Z not Shift+Z.


Is It Possible To Do An 80's Style Anime Shading? If So How?

This technique is known as Cel-shading. There are quite a few tutorials on how to handle Cel-shading in Blender; I'd recommend starting here to get a reference on how to get the basics down.
Toon Shading in Cycles


how do i save my selfmade favorit color ramp gradient in node editor?

Depending on how often you want to use your gradients, you can save them in two ways.

Both methods start by grouping your ColorRamp node. After you have set the gradient as you want, select the color ramp node and press CrtlG that will create a node group only containing the color ramp node. Rename the new node group, in the properties region N so you can find the gradient later.

If you use the gradients a lot, just save the node groups in your start up file.

The second method is to have a file of node assets, and when you want a gradient Append the node group from the file, with ShiftF1.


How to generate a fake hand painted texture (Blizzard like), Borderlands effect or Pixel Art effect

Hand painted effect

One texture is needed: a normal map. I recommend you to bake it in 32 or 16 bits float in order to get more depth on your curvature map and to bake it at a minimum resolution of 2048*2048.

Once it's baked you will need to generate two maps from it:

Generate a curvature map from a normal map: https://blender.stackexchange.com/a/72602/23134
Generate a smooth curvature map from a curvature map: https://blender.stackexchange.com/a/100637/23134
to the second slot. We don't use Multiply so the value of your color will have no effect on your texture.

The node setup is simple, you must overlay the two maps, the order makes a subtle difference:

if the curvature smooth map is in the first input of the overlay node the details from the curvature map will be shadowed so it's more realistic I recommend it.
if the curvature is plugged on the first input, the details on it won't be shadowed making the result less realistic.

Add a value node, for the first input add a color ramp in between your curvatures and the value node, on the second input the curvatures. This will allow to use the curvature to change the brightness of the color so you don't have to worry about the value of your colors.

On the color ramp for the left cursor pick a cold color, it's a color closer to blue and saturated (= a lot of color), for the right cursor pick a warm color closer to yellow and desaturated (0.5 saturation maximum, you can go higher for effects like lava).

The result:

Top lighting

To create a top lighting effect for stylized games Diffuse/Color map (PBR games do not use lighting informations in their albedo textures) you can bake an Object Space normal. You can get more informations here on how to bake it: https://blender.stackexchange.com/a/72664/23134

Once it's baked you will need to separate the Green channel (it depends on your axis it can be another channel) to get a top lighting effect. Then you must overlay it to the curvature. Adjust the value, the default 1 adds too much lighting informations.

Texture a game character or creature (and how to make it a sprite)

To add some SSS on your albedo map you must bake a thickness map: https://blender.stackexchange.com/a/100725/23134

Like before all your map must be imported in Linear mode and you must again overlay the curvature smooth with the curvature map for your grayscale then add a value node and use a color ramp in HSV mode to pick the analogous colors. For the thickness map mix it with the base albedo, use a color ramp with R: 0.7 GB: 0.1 for the blood color, you don't need to touch the right cursor. For the factor of the mix node add a color ramp with the left cursor in RGB: 0.1 (you can adjust this value for the amount of blood visible, brighter = more blood visible) and move the right cursor to the middle (position 0.5). Then you can connect the alpha of the thickness map to the alpha of the output node for the transparency if you are baking a sprite.

Drawn lines effect

You can use a color ramp node in constant mode to fake a texture with drawn lines. On the color ramp the left cursor has a dark value the right cursor has the background color. The more you move the right cursor to the left the more lines disappears. Then add a relative blur. You can adjust the Pixel Width for the thickness of the lines.

You can overlay the curvature with the lines with the curvature smooth at 0.5 for example to get more color variations:

Retro texture effect

For a retro effect GIMP is needed. Import your fake hand painted texture, I recommend you the one with the top lighting effect.

Change the saturation, old games had saturated colors. Go in Color > Saturation..., you can increase is by 25% by entering 1.250.

Reduce the scale of the image, go in Image > Scale Image..., you can set it to 512x512, bellow too much details are lost for this texture. For the interpolation select None, using an interpolation will make the image blurry.

To reduce the number of color go in Image > Mode Indexed, enter the number of color you want. Use a very low number like for example 5 (at 4 the black color for the shadows wasn't visible). I suggest you to use a dithering effect it create a smooth color transition by adding points of the same color, the positioned effect gives a more retro style by placing the pixel more like a checkerboard.

Reset the scale of the image, if you export it in 512x512 in PNG the image will be blurred even with no compression. Set it back to 2048x2048 without interpolation.

Here is the result:

Should I export a Diffuse or Albedo map?

A diffuse map is a texture for non-PBR games (also means less real time lighting and less ressources used ideal for mobile games) so the map can include some lighting informations like using a multiply with an ambient occlusion or a soft light with a color channel of an object space normal map to add top lighting. You can also use them with an unlit shader so they do not receive any lighting and shadows for better performances.
In PBR we use an albedo that contains no lighting information (or a little amount for stylized textures) to make the asset works in every real time lighting conditions. Stay with the curvature and thickness map only. The ambient occlusion must be imported separately in the shader so it is only visible in the shadowed part of your asset and disappear when hit by direct lighting (for that you must set your game engine in deferred lighting instead of forward). Also use Linear color space in your game engine instead of gamma to make your PBR textures more realistic.

Where to use them?

Fake hand painted textures are popular on mobile games, MOBA and MMORPG. Those textures can be used as an hand painting base to finish them manually.

Those textures are popular on the Dota 2 Workshop, you can learn how to create an asset for the game here: https://blender.stackexchange.com/a/101830/23134


If you look closer to this tutorials, you'll notice, that they don't really paint lighting conditions but more like Ambient occlusion and some highlights, that are similar for each side of the object. In the tutorial you linked to, you can see the same amount of shadow under the top part on each side, The same with the highlights on cracks and tiles. The same on each side.Try to copy this effect while creating your painted textures. This will suggest some details, but won't interfere too much with added lighting.


Understanding how the Modifiers Panel's Convert button affects particle systems

I have not downloaded the blendswap file.
Creating a particle system with objects as particles

For this example, I created three different mushrooms.
Select ⇧ Shift RMB and group the mushrooms ⎈ CtrlG.
Move the mushrooms to a unused layer.
Add a plane Ground and add a particle system to it. Set the Start to 0 and End to 1 and the Lifetime the scenes length. Set Physics to No. Starting from frame 1 the particles should not move.
Set the initial Velocity to (0, 1, 0) (because my mushrooms face up in direction of Y). Set the Render Type to Group under the Render section. There are more group settings you can use.

You now have a particle system which emits mushrooms.

You can choose the number of particles (mushrooms) in the Emission tab.
Setting the physics to No makes the particles static (not move).
Setting the Start and End between 0 and 1 ensures that all particles are emitted before frame 1.
Setting Render type to Group shows the group objects instead of other particle display objects. Don't forget to select the correct group. You can also choose object, if you only want to create multiples of a single object.
Creating a particle system in the particle tab automatically creates the particle system modifier.

You can convert Particle Systems successfully, if their render type is an object or group. The convert button of the particle modifier creates a duplicate object of the object associated with each particle. While there was a shroom1 object at particle X, converting it creates an actual duplicate object linked to shroom1 at the position, rotation, scale of particle X.
Particles are defined by the settings in the particle system. (Emitter) Particles can not be edited manually, otherwise the particle settings in the particle system couldn't be executed.
Since you can't edit (emitter) particles, there is no way to convert the array of objects back to a particle system after you converted them to individual object.

How would I convert everything back into a single object (perhaps
after editing a few mushrooms), and what would that "single object" be
referred to as?

You can't convert the individual objects to a particle system. You can convert them into one mesh, by selecting all and pressing ⎈ CtrlJ. It may be easier to handle a single object (mesh), rather than many different objects (meshes). This would just be practical for editing purposes like selecting all mushrooms when there are many more scene elements.

[...] For exporting into a game perhaps as a single file?
For game export it usualy shouldn't matter if it is a single object or multiple.

The downside of joining (⎈ CtrlJ) all mushrooms objects is that you loose the editing of multiple objects. You can no longer edit a single mushroom and all other similiar mushrooms with the same meshdata change accordingly.
See Group Instancing as a further example of combining multiple objects into a "single" group object while maintaining editability.


You can add an Output->File Output Node

When you render the image a full render will happen, then the Compositor will crop it

But at the same time a file will be saved that is just the result of the crop.


How to mask triangle out of the video strip in VSE?

Use create a Mask (in an UV/Image Editor set to Mask Mode) covering the content you want to keep. You can Ctrl+Click to add Points to create a Mask and Alt+C to Toggle Cyclic so that the first and last point are connected. Use V to Set Handle Types if needed.
Set your Transform Effect Strips Blend type Properties (N) each to Alpha Over. Oh and you'd better mute (H) your underlying Video Strips when you use an Effect Strip on top to reduce unwanted side effects.
Use that Mask going to the Modifiers Properties of your Video Strip in the VSE, click Add Strip Modifier, set it to Mask instead of Strip (Type of input data) and select your Mask created in Step 1.


How can you launch an object at a specific velocity and angle outside of the game engine?

Faceb Faceb has most of the solution.  The only bit he left out is that you also keyframe the Animated checkbox.  You have it checked at the beginning, but just before the motion of the Location keyframes are completed, you add a keyframe that turns off the Animated checkbox.

That deactivates the animation system and lets the physics system take over and it uses the velocity left over from the animation system

I have keyframed Suzanne's X and Z location.  You might also keyframe Y.  Notice also the channel called Kinematic (Rigid Body Object) which is the fcurve for the Animated checkbox that appears green in the Physics > Rigid Body section (green or yellow means keyframed)

To know the velocity you need to know the derivative of the location.  Since I altered my keyframes to have linear interpolation it is a simple matter of vx=dx/dt which in this case becomes vx=(1-0)/( (6-1) / 24fps ) = 4.8 and vz=(3-2)/( (6-1) / 24 fps ) = 4.8 and the total velocity would be sqrt(4.8**2 + 4.8**2) = 6.7882 .  The angle would be atan((1-0)/(3-2)) = 45 degrees .

If you want to choose your own velocity and angle it is probably easiest to parent Suzanne to an empty.  Rig the empty with a rotation (to choose your angle) and a starting position.  Then for Suzanne just give her a velocity on her local X axis (or maybe Y or Z depending exactly on how you orient the parent empty) by keyframing that channel of her location.  Use x0=0 and x1 = (frame2-frame1)/fps * velocity  Pick frame1 to be the first frame you want it to be in motion, and pick frame2 such that it is after the point you want physics to to take over (which is the frame that the Animated checkbox is keyframed to become unchecked).

I used that technique to launch the cannonballs in https://youtu.be/gtP2dWmmXd8


Copy rotation rotates through wrong axis

Copy hand bone. Make the copy a little larger or a little smaller than the original hand bone, so it'll be easy to select. Parent it only to the root bone and make it an IK target. That's the easiest way to avoid Copy Rotation problems and have clean, easy to work with rig.


TLDR: You need to enable True Level Triggering.
By default the "Always" Sensor only runs once, when game starts.
Any time you need something "always" triggered then you must click the little button with the three dots on the right side of the "Always" Sensor called "True Level Triggering" (I have it marked in red in the image below).

So your script works fine, just it was not running during the game.


How can I bake textures on uneven goemetry without tearing and stretching

This issue can be solved by adding evenly spaced loops along the long axis of the model and then later deleting them after the normal map is baked.

The problem here is that altering a models geometry after the Tangent map is baked can invalidate a Tangent Space map.

There is a way around this:

(i) We can bake to an Object Space map first

(ii) Now the extra loops can be removed

(iii) Finally, a second bake pass that uses the Object Space map as Input for the Material normals can then be used to transfer the Object Space map info to a Tangent Space map and the resulting map will be valid for the low poly model that has had its control loops removed after the bake has taken place.

You can safely treat this second bake pass as a color transfer more than anything else.  Blender internal makes this quick and straight-forward. With practice, it shouldn't take more than 30 seconds even if you are being patient and going slow. Back to this in a minute.

To start with, add the control loops to one of the boards and then by using linked-duplicates, move and rotate the other boards into place; now most of the setup can be done on only one of the components and the changes will be reflected on all of them.

Here the loops are added in by using Ctrl+r and then pressing the NumPad(+) key about 30 times to increase the number of segments.

Now the pieces can be joined into one Object so the UV's can be layed out(mostly)properly as shown next.  Try to use all the available space so that the texture resolution is not wasted.  Also, try to leave a fair amount of space between the UV Islands and the borders so the textures do not bleed across the seams.  Mipmapping can exaggerate this issue so it's best to not skip this last detail.

Now bake to an Object space map and the results should be error free so long as the 'Selected To Active' settings are correct with regards to Bias/Distance/Cage controls that are available when Using Selected To Active for baking from a High-Poly Model to a Low-Poly model.

There are two good reasons to start with Object Space maps in a situation like this.  First, the models' geometry can be further reduced after the bake has taken place without invalidating the Normal Map because Object Space Maps are not susceptible to that problem.

Second, Object Space maps can be blurred without issue in a 2D Editor such as GIMP.

Blurring Tangent Space maps will almost certainly cause you problems.

The following animation shows how to quickly remove all the extra control loops prior to converting the Object Space map to Tangent Space.

To start with, Select the end faces and then use Ctrl+i to invert the Selection.  Now Use Ctrl+Numpad(-) to contract the Selection.

Switch to Edge Selection Mode and hold down the Shift and Alt keys and start mouse-clicking the long edges one at a time.  The combination of keys and clicks will remove the long edges from being selected.

When only the extra loops are still selected, use x+g to delete all the loops. Now there should only be the basic framework of the pieces just as before.

Next add a Blender Render(Blender Internal) Material and a texture to the material which should be set as an Object Space normal map using the settings shown in the following image.  The bake settings are also shown at the top right.

Now when you press bake, you should end up with a Tangent map that does not require the use of Selected to Active and its encoding should match up with the Low-Poly model.

Now for the Materials texture, replace the Object Space map with the Tangent space map and set the Image Sampling to 'Tangent' instead of 'Object' and you should have the following results.

Here is the Tangent map being used to light the model with GLSL.

Next the same normal map is being used in Cycles.  A Glossy shader is being used to exaggerate the normal map's detail in order to look for errors.  Glossy is basically a worse-case scenario for normal maps.  If looks good for shiny, it should always look good.(maybe not if it's really small and far away; then shiny will cause twinkles when the normal map detail is smaller that the computer screens pixels. :) <-You can fix that by blurring the map by a few pixels in GIMP, Krita, Photoshop, etc.


is it possible to paint diffuse and normal at the same time

It is possible with bpaint.
But on personal recommendation, if you need that kind of thing, you better use of MASK factors. That way you connect and arm your shader first, then you only need to paint black and white map to reveal "layers".


This Light effect not showing in Render but shows up in View-port rendering. Affecting both EEVEE and Cycles

The final result is hard to see because there is no texture in the shared file and all is pink.
Though, it seems some of the lamps are not activated for rendering.

To see this icon, use the filter button:

There is 3 levels of visibility:

The eye icon that corresponds to H and AltH

Enable/disable in viewports, the monitor icon

Enable/disable in renders, the camera icon

These last two also correspond to the object properties here:


After deleting the Armature modifier go to the Mesh Data header and delete all vertex groups (click the black down arrow-->Delete All Groups) in Vertex Groups panel. Do the same with shape keys in the Shape Keys panel to be able to apply your modifiers.


Moving mesh in pose mode is deforming inappropriately

The clavicle bone will by default also move the arm as the arm is its child. Therefore the pauldron should only be weighted to the arm and not the the clavicle. Due to the way armature deformation is calculated, volume loss like this can occur when solving between a number of weights (checking preserve volume on the armature modifier can help, but it can cause other artifacts as well.

Another thing you may want to do is make a separate bone to control the pauldron and use contraints to mix rotation from the clavicle and arm onto the new bone.

(At work so I can't check the blend file, you may also want to check to see if any other bones have influence on the pauldron)


I haven't got a full picture of what you want to accomplish with this but:

What you can do is to have an armature that is scaled to -1 on one axis. That will give you an inverted coordinate system inside that. You could then drive bones on the deforming armature with those bones.

AFAIK bones will end up as matrices that deforms the mesh. Having a negatively  scaled matrix on one bone will also scale the deformation accordingly. By using a controlling bone that exist in another coordinate system, this problem will be limited to a non deforming armature, and this is fine.


I've fixed the issue. If anyone is having similar issues, you may have some topology that does not fit well with the bones. The solution that I found was to re-weight the armature and remove the corrective smoothing modifier from the entire mesh. I've found that for a mesh where the goal is to create a soft-bendy sort of pose, it's best to only use the corrective smoothing on specific vertex groups rather than the entire mesh.


Does anybody actually use "scenes"? if so, what are some good/typical use cases?

Not sure how much help this will be but I'll share my experience anyway. A usage that has worked well for me is as follows -
I been using Blender in place of an architectural CAD package to design a small summerhouse. I have a main scene in which all the elements are drawn (slab, landscape, sole plate, studs etc.) and these are all placed into collections in that scene to help organise them and manage visibility.
If I now want a drawing of a particular subset of these elements, I can now create a scene for it and link in the elements I want to show on that particular scene. The linkage can be by collections but it is also possible to link in individual elements from the master scene. I can now create a new collection in that scene for the elements that are to be present only in that scene; into this local collection I place a camera and possibly lights and adjust the scene settings to use this camera for renders. I also set the camera to be isometric to get a plan view, use freestyle to render the line edges and add dimension text to the scene local collection and use material override to render all objects in a plain grey material. I can now render this out and effectively get a plan view line drawing.
This now means that I can return to the main scene and continue to add elements to it and, as long as I'm carful about keeping things in the right collections, these new elements will also be visible in the other drawing scene (if that scene links that collection). The main scene still has its own camera and renders from this scene will be in perspective and with materials rendered.
This workflow loosely recreates the feature in CAD packages where you can have a number of drawings with different views and subsets of the main model. In my workflow, each scene is a drawing.
This is possibly not what the scenes feature was primarily designed for but I do find it it useful in this case.


The Density of Particle System is inverted between viewport and render

If you look at the "Density" entry, on the far right, there is an open diamond shape, and the <-> is orange.  This means that you have set a keyframe on density.

You need to clear the keyframe.  If you have a playback window, go to it and select all of the keyframes with the a key.  Then hit the x key and select "delete keyframes"

You can tell that this worked because the diamond and orange will disappear:


Baked procedural normal map reflect light only some sides

Silly me! It was the node graph that I connect to the Bump Map into the Normal Map then Output to the shader. (Normal => Color => Normal => Shader) Rearrange my node is the solution


Particle density animation using dynamic texture

Unfortunately, this is a known limitation of the particle system as noted in a bug report here.

To quote Brecht Van Lommel, from that bug report:

  The location of emitted particles are determined in advance now and
  stay fixed, so this can't be animated. There's been some working on
  designing an improved particle system that can handle such animations
  but it's not finished

It is currently listed as a 'To do' item on the development section of the blender wiki here.


Why does the math node change the noise texture's color output to B/W?

This is because the math node only deals with single scalar values (note the gray sockets).
See What is the meaning of the color of the node sockets in the node editor?

If you use a node with yellow sockets (Color > MixRGB), it will maintain all the color channels:


How do you store the edge locations of a cube with python?


Is it possible to change reflection direction?

You can map the normal input to obtain some various deformation effects (distorting mirror) so:

The node setting is the following (mix rgb is only here for the gif above):

The mapping: add some X if the view is Y aligned and some Y if the view is X aligned. There is probably some possible calculation to do it automatically from other inputs.

Another distorting mirror, as example:


Simply change that top toolbar back to Info.  That's the default for Blender.  From there you have all the traditional menus.  From the Info bar, you can select your preferred Workspace.  You can use the Motion Tracking Workspace which is already setup with three Movie Clip Editor panes or you can create your own custom Workspace:

As far as I know, the top bar is the only one you cannot pull down down into a pane (like all the other panes):


How to move a particle emitting object around a movie clip in Blender?

version Plane in 3D Scene

You didn't ask for it, but what I know all comp. apps works in that way, with the same amounth of "deterioration" a quality of the video footage - all apps operates with a video texture on a plane in 3D scene.

Simplified – If you connect a Texture node (with video sequence) directly into output (without shader) than colour information stay the same.

In Color Management switch from Filmic to Standard.

What I would miss in this case, are matte tools. Sorry for dirty way I found on the way (probably exists better), or you should separate foreground in compositor properly, render it with alpha and use this image sequence, but that's another topic.

Example with particles. GreenScren is taken from internet, easily find by name (Green Screen Sample | Panasonic HMC150).

Example with Smoke Simulation. GIF compression is too much here I will try post regular render later.

version Composite

Another way (without Plane in 3D scene) is Composite - to render Smoke separately with faked Z pass in RenderLayer (in this case simple greyscale gradient texture) because blender doesn't handle volumetric depth and even if you want to emit smoke like a particles (plane with texture) Z pass does not handle transparency as well.

Smoke for this version you can render from blend above, but not as Render output, but enable Composite first (and delete or exclude plane from rendering). If you switch layout to Compositing you will se two Render Layers - one is regular render, second with faked Zpass.

These images has to be saved as OpenEXR_Multilayer (32-bit) file format, so you would be able get enough depth data to composite plane. I expected much worse result, but for smoke type worked quite well :) Smoke was rendered only with 6 samples = noisy, but expect some noise in composite anyway. These even smooth anti-aliased pixels will be used as depth data, which means - any pixel represents position in - depth (little confusing call this Z pass in blender terminology where depth from front view is Y axis :), forget it. So in this level there is not any anti-aliasing (if I'm correct).

Result (also because of gif commpresion) is not fair, I probably changed some parameter for smoke material due testing mishmash.

For compositing is here is essential Z Combine node that is responsible for mixing depth data. Because video doesn§t have any depth info and we need to place it similar to 3Dscene it's enough to set to the actor some grey value for Z input. If you try to move slider to white or black you will se how smoke is appears forward or backward of actor.

Looks like even alpha from "Smoke Depth" render layer can do a good job. Colored for fun.


Accessing screen areas from render handler

Turns out that inside bpy.app.handlers.render_pre the context is different.

For example bpy.context.screen is None, bpy.context has no attribute active_object etc. Looks like its very limited when rendering.

What you have access to is bpy.context.window_manager. So modify your script like this and it should work:

import bpy

def allBound(scene):
    for window in bpy.context.window_manager.windows:
        for area in window.screen.areas:
            if area.type == 'VIEW_3D':
                for space in area.spaces:
                    if space.type == 'VIEW_3D':
                        space.viewport_shade = 'BOUNDBOX'

bpy.app.handlers.render_pre.append(allBound)

Also this now works on a multi-monitor layout.


looks like a low res zoomed image. check your render resolution, X, Y and %. a 1000x1000 render at 25% gives a 250x250 image. Aspect ratio has to be 1.


Springs affected by force!? (not sure how to ask)

This isn't too hard with Animation Nodes. Once you've installed the add-on, check a couple of things on your pins. First, make sure the "head" has an object origin in the object:

Second, make sure that the spring's object origin is at it's base:

Now, let's open up a Node Editor panel and create a new Animation Nodes tree.

Let's create our array of pegs, like this (you can search for nodes with Ctrl + A):

Explanation: The Distribute Matrices node creates a the locations of a grid of objects with the properties we set, the Object Instancer node creates the objects, then the Object Matrix Output node puts the objects into the scene. You should now have this lovely grid:

Now, lets create our "force sphere". Create a Sphere empty and give it a radius of 4. (You may need to adjust to your scene's scaling).

Now, to make the pins interact, add these nodes:

Explanation: The Object Matrix Input node gets the transformation attributes of the Empty. Decompose Matrix gets the location vector. The Point Distance Falloff node creates a 3D "gradient" radiating from the set origin (the location of the Empty). The Offset Matrix node applies the transformation of (0,0,-1) at the value determined by the Falloff.

It should look like this:

Next, we need to create the springs. Create another Object Instancer node for all the springs:

We want to offset the springs' matrices differently, though:

In the N panel of the second Offset Matrix node, under Advanced Settings, change Rotation: to Local Axis - Local Pivot:

Here is the final result:

Edit:

I've gotten better results with the Empty size set to 1, and the following node setup:

This way, it also responds to scaling the Empty.

Blend file:

(Requires Animation Nodes)


How to Create Photo Collage Template using Blender?

First you need to build the entire scene, that video link it's 360° and has a blog post link in the description that explains how to do it. It's that a requirement for you? (think twice because it involves much more work)

Second if you want just the camera movement try the Sniper addon


Unknown operation while following tutorial

Select the 3 vertices, then press V to rip them.


Wrong spline length with Animation Nodes

The Get Spline Length node approximates the length of the spline, as there is no efficient analytical solution to that. The node provides a resolution option in the Advanced Node Settings to control the precision of the approximation. Increasing that should allow a more accurate computation of the length:


I've been at it over a month. I have a 99% solution.
The pictures show what I have done in Forward and Backward gear.
The solution isn't perfect because the travel between gears is on a circular route. I posted a video on Youtube. The first 30 seconds are still photos and then the action starts. If anyone has an idea how to make a straight route let me know. Thanks. Have a great day.
TOM

https://youtu.be/L5k6kLqcca4


Why can't I paint on an existing texture?

Make sure the the image editor is in paint mode. There is a dropdown box in the header, that will change the mode. By default it is set to view, so no painting.


Is there a way to edit around another object?

As long as the meshes are different objects, editing one will not affect the other, in other words you can only edit one object at the time.

When you create an object in object mode it will be independent of other objects.

A more detailed explanation:

Blender uses a hierarchical structure to organize data.

You can Add a Mesh in Object Mode and Edit mode, but they are not the same.

So what is the difference?

When you add an mesh in Object Mode you are creating both, a mesh and an object. Objects created in object mode are independent of each other, meaning that they will be named with a unique name and will all have their own separate origin (or pivot point), and can be transformed independently.

Meshes created in Edit Mode are part of the Active object, an already existing object that is being edited.

Objects can contain one or many meshes, connected or not.

All meshes within that object will share a common origin and will behave as what they are: a single object, meaning they will move, rotate and resize together when transformed in Object Mode.

For example: Here's a scene with four different objects created in object mode. Each one of them shows as a different object in the outliner.

If new meshes are added in edit mode, they become part of the active object, note how the outliner shows no other objects being created, all new meshes are part of the same object called "cube":


How can I take a snapshot of the last frame of a video?

On the frame you would like to save, press F12 to render (you can also press Render image in Render at the top of the window, or Render in Properties > Render settings > Render):

Then press F3 to save the resulting image.

Note that this will take other strips into account.


Can you export a mp4 as .webm with the new Blender 2.8 update?

Update 2

Lukasz-40sth is right Blender 2.81 has a WEBM container which eliminates all the previous issues. It also supports the Opus audio codec. These features were added by Dr. Sybren Stüvel based on FFmpeg which implements the container and codecs.

Update

While the output described in the configuration below does output a video that is playable by all major browsers, it doesn't follow the guidelines for WEBM. For instance the WEBM Container Guidlines specify that:

  DocType element SHOULD be "webm"

However Blender's output has DocType set to matroska when using the Matroska container. I assume that SHOULD in this context refers to the meaning specified in RFC 2119, it's recommended but not a must. The file should therefore still be a valid WEBM.

Disclaimer: I'm not very familiar with video container formats, the following information may be inaccurate.

Blender 2.80 doesn't have a dedicated WEBM container, however WEBM is a subset of the Matroska container format that only allows a specific set of audio and video codecs. Therefore you should be able to produce a valid WEBM with the following settings:

Container   : Matroska
Video Codec : WEBM / VP9
Audio Codec : Vorbis

The output file will have the .mkv extension which you can rename to .webm.

When you have created your video in the VSE and then use Render Animation to export the video, it will be stored in the directory that is specified in the Output panel (for example in the screenshot it's /temp). Make sure that you're checking in the correct directory.


How to delete a collision modifier on blender 2.8?

To remove physics element, just click again on the button you've used to add it.

You can notice that once added, the original icon is replaced by a cross 'X' which indicate it could be removed.


How to remove modifiers from multiple objects at once

As stated in the comments by Mr Zak and Robert Gützkow, you can select the objects you wish to remove all modifiers from, then select an object with no modifiers, hit CTRL+L, and link the modifiers. This will get rid of all of them on all of the objects.


How to make objects more visible in wireframe mode?

You probably accidentally changed the wire color.
It can be found in Preferences > Themes > 3D View > Wire.

And don't forget to save your preferences :).


What are the benefits of modeling in one piece, or as separate parts?

The way I would go about that example, there would be separate objects for the hub and the blade. In the situation you described there is no reason to add vertices to the hub and extrude the blades out. In a real propeller there are separate pieces. There is no need to make modeling and texturing the propeller harder then it needs to be.
Another way to look at it, what do you gain by having the blades extruded from the hub? From modeling, texturing, rigging and animating in this case it is all easier with separate objects.


My Model disappears into the Blender Universe

try to select your model and press the period key on your numpad


For your example this could do the job:

Enable LoopTools addon in the User Preferences (CtrlAltU > Addons)
Select the outer vertices
Apply Relax function with Linear Interpolation


Use a grey scale image as factor to a Mix Shader node to control transparency or displacement.

Weight painting in a fully established material


How to make particles fall and land into predetermined shapes (like text)?

You could do it backwards.  Have a mesh (set to not be visible in the render itself) define the shape for the particles to end up in, have this mesh start with a lot of particles only inside its volume, and then animate them all 'falling' randomly upwards under an appropriate force.  Then reverse the animation, either externally or via baking it and reversing the order of keyframes.
Whether this looks good or very faked will depend on the look you're going for and the shapes of your targets.


Change default_frames_limit trough Text Editor script

Its the clip associated with the space.
Similarly to a text in the text editor, an image in the image editor, what is known as the context.clip in the movie clip editor, is the clip assigned to the space.
To the python console:
Loop thru the screens to find a movie clip area and return its active space.
>>> def get_clip():
...     for s in D.screens:
...         for a in s.areas:
...             if a.type == 'CLIP_EDITOR':
...                 return a.spaces.active
...     return None
...
>>> mc = get_clip()
>>> mc
bpy.data.screens['Default.002']...SpaceClipEditor

The active clip of that space
>>> clip = mc.clip
>>> clip
bpy.data.movieclips['Batman_(1966)_S01E01.mkv']

>>> clip.tracking.tracks.data.settings.default_frames_limit
0


How to make a game autosave and autoload

There's probably a much easier way, but you could have variables which change depending on what level your in ect, along with others that toggle the use of boost ups and collected points etc. Then you can save these variables to different .txt files so that they're the same when you start up the game next time.
For Python Variables:
Connect this script to a keyboard sensor, with a status of All Keys, followed by an always sensor. The pytho controller is in module mode. You need a folder next to the .blend called "SaveLoad". And finally add two game properties to you object just so that you can see that the script really works.
S Key to save, L Key to Load and A Key to change the variables, but obviously you can easily modify the code to you needs of automatic execution.
import bge
from bge import logic
path = logic.expandPath("//SaveLoad/")

cont = logic.getCurrentController()
own = cont.owner
keys = cont.sensors["Keyboard"]

var1 = 20
var2 = 60

def save():
    global var1
    global var2
    for key,status in keys.events:
        if status == logic.KX_INPUT_JUST_ACTIVATED:
            string = bge.events.EventToString(key)

            if string == "SKEY":
                info = str(var1)+","+str(var2)
                file = open(path+str(own)+".txt", "w")
                file.write(str(info))

            if string == "LKEY":
                file = open(path+str(own)+".txt", "r")
                line = file.readline().replace("\n","").split(",")
                var1 = int(line[0])
                var2 = int(line[1])

            if string == "AKEY":
                var1 += 1
                var2 += 2

    own["prop"] = var1
    own["prop0"] = var2

For Game Properties
This script needs to be set up the same way as the variable script, but yet again you do have the option to change it to your needs.
from bge import logic
path = logic.expandPath("//SaveLoad/")

cont = logic.getCurrentController()
own = cont.owner
keys = cont.sensors["Keyboard"]

### Use keyboard
for key,status in keys.events:
    if status == logic.KX_INPUT_JUST_ACTIVATED:
        string = bge.events.EventToString(key)

        ### Save "prop" and "prop0" to file
        if string == "SKEY":
            info = str(own["prop"])+","+str(own["prop0"])
            file = open(path+str(own)+".txt", "w")
            file.write(str(info))

        ### Load "prop" and "prop0" from file
        if string == "LKEY":
            file = open(path+str(own)+".txt", "r")
            line = file.readline().replace("\n","").split(",")
            own["prop"] = int(line[0])
            own["prop0"] = int(line[1])

        ### Change values
        if string == "AKEY":
            own["prop"] += 1
            own["prop0"] += 1.3


Grease Pencil data is stored globally in bpy.data.grease_pencil. Scenes and objects can reference a Grease Pencil datablock.

Up to Blender 2.72, the active object was used. With no active object (right after object deletion), the active scene was used instead. From 2.73 on, the active scene is chosen all the time. There's legacy support for the object level however. For future use, you should assume the GPencil data to be associated with the active scene:

gp = bpy.context.scene.grease_pencil

The GPencil data is hierarchically organized in layers, frames, strokes and points:

# Get 1st point of 1st stroke on active frame and layer
point = gp.layers.active.active_frame.strokes[0].points[0]

point.co       # 3D Vector location
point.pressure # tablet pressure (1.0 on mouse input)
point.select   # selection state (bool)

layer = gp.layers[0] # first layer (by index)
layer = gp.layers["GP_Layer"] # by name
layer.color # color (fill_color for fill color)
layer.alpha # opacity (fill_alpha for fill opacity)

frame = layer.frames[1] # 2nd frame
frame.frame_number # frame number of that frame object

stroke = frame.strokes[-1] # last stroke
stroke.draw_mode # e.g. '3DSPACE'

You can create new GPencil data from scratch too:

gp = bpy.data.grease_pencil.new("My GPencil")
scene = bpy.context.scene
scene.grease_pencil = gp
scene.frame_set(5) # ensure we'll see the stroke (set to frame 5 below)

layer = gp.layers.new("Name for new layer", set_active=True)
layer.info # note: it's not layer.name!
layer.color = (1, 0.3, 0)

frame = layer.frames.new(5) # frame number 5
stroke = frame.strokes.new()
stroke.draw_mode = '3DSPACE' # either of ('SCREEN', '3DSPACE', '2DSPACE', '2DIMAGE')

stroke.points.add(4) # add 4 points
#stroke.points[0].co = (..., ..., ...) # set 1st point's location
stroke.points.foreach_set("co", (0,0,0,0,0,4,0,6,4,8,6,4)) # set all at once efficiently


Give the red cube a dependency on the blue slider. Do this by adding a new variable as the slider location.z, you don't need to use this variable in your expression calculation but having it there adds a dependency that updates the location as you want.


Blender Game Engine: Added objects from actuater are invisible.

I figured out the problem, somehow every object wanted to add had "Invisible" turned on. I never did this, and I don't know how it was done either.


Is it possible to have a camera track a new empty in the middle of an animation?

You can have several "track to" constraints, and animate (keyframe) their respective influences:


Is there any way to apply a modifier to multiple objects in order to make an animation?

Ctrl+L gives you the option to link the modifiers from the active object to all other selected objects.

This will overwrite the modifiers of the object being copied to, so there is a really useful plugin to copy any one of the modifiers and not overwrite others, which is called: 3D View: Copy Attributes Menu.

When this is enabled, use the hotkey Crtl+C to bring up the menu options, and use the copy selected modifiers option to copy your modifier.


Export the animation of one bone to .bvh

Create a copy of your animation, in the dopesheet select all the data you're interested on, Ctrl I to invert the selection, X to delete unecessary data. Export to BVH.


Head bone moves top portion of body back, but leaves the eye lid sticking out far from eye ball

"why not just use the bone to make a shape key for blinking then remove the bone after transfering it weight to the head"
this ended up working for me!
I made a shape key with the uppereyebrow bone (Highhigheyebrow) using the CAT5 (CATS?) plugin, then I renamed the Vertex Group for Highhigheyebrow to Head2, which applies it to the Head2 Bone, and this works!


Approach for a Cheese material with SSS in Cycles?

You're right, SSS is what you want.

An SSS shader is pretty much it as far as the base shader goes, but a few textures and some diffuse shading for the scratches won't go amiss:

Also make sure the rind is a separate manifold mesh (i.e has a surface on the side against the cheese). Otherwise, light which should be blocked by the rind will enter the cheese material and get scattered out, giving a rather unconvincing transition without any darkening:

Cheese material:

Note the scattering radius values. These were just guessed at with some eyeballing, so you may want to play with them a bit to get the effect you want.

The control how far red, green, and blue light can be scattered, with the top value being red and the bottom being blue.

The sharpness and texture blur on the SSS node are both 0.


Making Proxy on a Linked Rig via the API

The make proxy operator works only on the active object (it has to be visible). You set the active object like this:

import bpy
objects = bpy.context.scene.objects
objects.active = objects["Name"]

If you don't know the name you can list all objects in the scene with dupli group:

ob_list = [ob for ob in objects if ob.dupli_group]

You can specify what object inside the group to make the proxy of like this:

bpy.ops.object.proxy_make(object="Name_Of_Object_Inside_Linked_Group")

If you don't know the name, you can list all the armatures inside the active object's dupli group:

armatures = [ob for ob in objects.active.dupli_group.objects if ob.type == 'ARMATURE']

The proxy object then becomes the active object. You can rename the proxy easily (otherwise it will carry the name of the linked group object):

objects.active.name = "Name_Of_Object_Inside_Linked_Group_PROXY"

To complete this you also get the linked group object from a proxy object like this (if you need to know what the proxy is influencing and if the object is a proxy at all):

group_ob = proxy_ob.proxy_group


I wrote to the author and he had explained it, I'll post the anwser here in case anyone else encounters this problem:

That's the representation in Unity of having 4 bone childs not connected.
In the picture below you will see that effect is achieved by having 4 not-connected-to-parent bone childs of the hand bone.


Meshes not visible in render and render is super grainy with black dots

A mesh, hidden in the work view but visible in the render, was in front of the camera. Stupid mistake, but the problem is solved. :J


Settings to improve video editor performance

Blenders VSE is an area that has not seen many improvements over the years. As you see one of its drawbacks is the inability to use all available cpus.

Someone recently agreed to work on improvements to the VSE, so this should start to improve over the next releases, but the improvements done in time to be included with 2.80 are limited.


On returning to my file 'Play Rendered Animation' says 'file not found'

If you have renamed your animation (if it was outputted to a movie file), then Blender will not be able to recognize it if it doesn't have the original output name. Did you rename your file? (Was it a movie file in the first place, or was it an image sequence?)


Correct way to delete double material on object by exact words inside

Match the compiled re

Not sure you will ever get ob.name == patch_list recommend using patch_list.match(str)

>>> "xxxxType1.001" == patch_list
False

>>> patch_list.match("xxxxType1.001")
<re.Match object; span=(0, 9), match='xxxxType1'>

>>> patch_list.match("xxxxType4.001")
<re.Match object; span=(0, 9), match='xxxxType4'>

>>> patch_list.match("xxxxTpe1.001")
>>> patch_list.match("xxxxTpe1.001") is None
True

In question code

import bpy
import re

scene = bpy.context.scene
obj_list = [".*Type%d" % i for i in range(1, 5)]
patch_list = re.compile('|'.join(obj_list))
get_objs = [o for o in scene.objects
        if  patch_list.match(o.name)]
print(get_objs)

on your edit.  I'm not sure this changes anything.  Below I've simply added a names list of potential names of objects and how they match.

To repeat I dont think any object name is ever  going to be equal to a compiled re object.  name == patch_list hence your get_objs list will always be empty.

import re

obj_list = [".*Type", ".*AnotherType", ".*Example", ".*AnotherExample"]

namelist = ["SnoopType", "Frog", "DogisAnotherExample.001"]
patch_list = re.compile('|'.join(obj_list))

get_objs = [name for name in namelist if  patch_list.match(name)]

print(get_objs)

results in

['SnoopType', 'DogisAnotherExample.001']


Weird ribbing effect when applying Mirror and Subdivide modifiers on an object in 2.92

If you recreate the steps of the tutorial, the result looks exactly like in the tutorial. What your friend accidentally did is doubling the center edge by hitting E for Extrude. Maybe she realised her error and pressed Esc or RMB to exit the Extrude, but unlike moving, rotating or scaling for example, the extra vertices remain created - aborting the function only keeps them in place, so they are directly lying on top of the old ones. To get rid of them, use A in Edit Mode to select all vertices, then M > Merge > By Distance.
The horizontal edge looks like there is an extra edge loop created above or below the original center edge. But they are doing nothing like that in the tutorial.


My object is disappearing in sculpt mode

To solve, I increased my clip end value to $100$ in the View panel on the 3D View Sidebar.


Creating a glass like material without it being transparent

You may achieve it using the Backfacing output of a Geometry node as a factor for mixing the Diffuse and Glossy nodes.

Set up the material nodes as pictured below.

Remember to set the Diffuse shader color to pure white and the Glossy shader Roughness value to 0.000. In the .gif above I added a blueish tint to the Glossy shader's color to make the glass plane visible, but if you want to recreate the look of the Glass shader set up the color to pure white.


I used a hexagonal torus with two array modifiers to create the mesh then I just used the Boolean modifier to cut it out.  It's dirty but quick and easy:

Use Circle Select to select the extremities and proportional editing to slope the curve downward:

Finally, I added a "rubber" grommet around the edge:


How to make semitransparency on an image plane of a 2D png in v2.8?

Of course I figure it out right after asking, after a day of no progress.

To help the next person out:

Import your Image Plane
In Materials -> Settings -> Blend Mode and Shadow Mode select "Alpha Blend", this displays existing image transparency
Still in Materials -> Settings check Show Backface (important!)
In Materials -> Surface, add a new Shader, you can do this by clicking the white circle on the last existing shader, and select Principled BSDF
Switch to the Shading workspace, at the very top bar next to the Rendering tab you can access it from General under the + sign.
The Principled BSDF will already have an output to the Mix Shader. You need to connect the Colour output from the PNG to the Base Colour of the Principled BSDF.

Now you can modify the alpha in the Principled BSDF and it will show up in the image plane.

Hope this helps. This is not clear at all for beginners.


Getting blender camera fov or focal length from the unity3d camera fov

I'm not sure if this is the answer you needed, but in the properties bar under data and then under "Lens," they have a field that displays the camera's focal length


How to scale a plane to the exact dimensions of a loop cut?

You may do it using a snapping tool.
First select the edge loop in Edit Mode (Alt+RMB) and snap the cursor to it (Shift+S-->Cursor to Selected). Then select the plane in Object Mode and press Shift+S-->Selection to Cursor [Offset]).

Next press the magnet icon to enable the snapping tool and change its type to Vertex. Scale the plane until it snaps to the loopcut's border.

To see the loopcut in Object Mode check the Wire and Draw All Edges checkboxes in Display panel of the Object header.

For irregular planes you can scale along the chosen axes (e.g. S,Y).

You may also snap the plane to the corner of the edge loop in Object Mode. Then change the pivot point type to 3D Cursor, snap the cursor to the corner of the plane in Edit Mode with Shift+S-->Cursor to Selected and then scale it until it fits the edgeloop.


I don't see any strange deformation there. You weightpainted the same vertices with full weight to multiple Bones, so the vertice position is interpolated between all the Bone locations which have weight assigned to them.

You have to weight the vertices only to one Bone, and maybe use some low weight blending between them.

The Updates Issue has most likely the same root: the bad vertice is influenced by another bone - doublecheck that all other bones have 0 weight on it and the correct Bone has full weight.


In the first image it seems like there is not enough samples and the light areas are really noisy.

In the second image it seems there are blurry spots all over the render, if I understand it correctly, that might be the result of very strong denoising with not enough samples.

My recommendation would be to try increasing the number of samples as well as adjusting the denoising settings for it not to be so strong if needed.


Got it, had to change the transparency from "Z Transparency" to "Raytrace".

Edit: In the material settings you have "mask" "z transparency" and "raytrace" - just select the "raytrace" box.


(Noob question) preparing the model for sculpting

You have basically two options to go from here but keep in mind that both of them (and sculpting in general) are destructive meaning they're irreversible. So if you like your low-poly mesh it would be smart to make a fallback-copy of it (Shift+D) and put it in a separate collection that you can hide, so it doesn't bother you during sculpting.

With that being said here are your options:

You can Voxel-Remesh your object (the function can be found in the Sculpting tab on the right hand side) to get evenly detailed geometry that you can work with.
You can use Dyntopo (short for dynamic topology, can be found just above the remeshing tools) which will dynamically add more, finer topology depending on how far you're zoomed in. It takes some time to get used to but it's really fast and handy once you're comfortable with it.


Try using a boolean modifier with Union.


How to apply a displacement modifier to one area of an object from an image?

I think you'll need to use a UV map here as using a vertex group does not seem to give a good result.

As you want to use a displace modifier you'll need to subdivide your shape a lot. But, whatever the subdivision level is, the precision of the displacement will be limited by the texture resolution itself.
So, if the model is to be 3D printed, both resolutions (subdivisions and texture) will matter.

First, make your UV map :

Select your face in edit mode
Go to front view (or more generally in front of the face)
UV unwrap : U then choose "project from view (bounds)"

Adjust your UV map

Note : you may also UV unwrap all the faces and / or make your texture after the unwrapping (so, or adjust the UV geometry to the texture, or make a texture adapted to the UV geometry)

Set your texture as displacement
And use UV as texture coordinates

Subdivide your face (a lot)

Adjust the displacement

Note

If you need to do this on several faces :

UV unwrap each face and eventually use the vertex group option of the displace modifier (a vertex group per face, but taking care of the border vertices). Alternative : use several UV maps.
I also suggest to apply the subdivision to all faces at the same time.

Again, I am not sure that the precision will be good enough for a 3D printed object.


Accessing the RMB feature on a Mac laptop

Yeah, it must be selected.

To select it with no RMB, you must change your user settings.

Now go to the "Input" tab and change to LEFT for select


Bad news
This is a bug in Blender 2.79b. It has already been reported.
Good news
There has already been a fix for this. If you download Master at https://builder.blender.org/download/ and check with the exact same file, the Bevel should work as expected. The same fix has also been applied to the 2.80 series of Blender as well.


Access Viewport Overlay options using Python API

The overlay attribute is part of the bpy.types.SpaceView3D. Therefore you first need to iterate over the areas of the current screen and find the 3D View. Then you can search for the space in the area that has the type attribute set to 'VIEW_3D' and is therefore of type bpy.types.SpaceView3D. If such a space exists you can access the overlay and through it show_face_orientation.

import bpy

for area in bpy.context.screen.areas:
    if area.type == 'VIEW_3D':
        for space in area.spaces:
            if space.type == 'VIEW_3D':
                space.overlay.show_face_orientation = not space.overlay.show_face_orientation
                break

Note that you cannot set the overlay option  using the code above if you don't have an area with the 3D View open in the current screen.


Explosions not rendering but showing up in viewport

I redid everything in Cycles, and everything seems to be working fine. It seems that I may have had a problem with lighting the the original render.


Is it possible to have windows which are independent of the workspace?

The "view/area" menus have a "duplicate area into new window" which gives an independant window that is not related to the workspace.


Apply the scale and rotation of both the character and armature, parent again and it will work fine


How to achieve clean Topology at joining edge of dissimilar features?

In Blender most of us would not model a screw by joining two separate meshes, one for the curvature and the other for the groove.

Other 3d packages such as AutoCAD / SolidWorks (and free alternatives) have a different internal representation of shapes. That's why boolean 'carving' is great for those kinds of programs. In those packages geometry remains a mathematical entity until converted to mesh-geometry for export.

In Blender we use mesh geometry (verts, edges, faces) all the way, and that means a different approach is worth considering. You've noticed that trying to match up two very different sections of mesh can be quite a  hassle.

Proportional Editing to the rescue!

I'd go for geometry roughly similar to this.

And the use Proportional Edition, move, to push the upper verts into that nice curve. Getting a dome curvature is the smaller problem with this kind of geometry. The biggest issue is thinking ahead about where you want sharp corners and you can do that as a flat surface first and extrude parts down later.

Enable proportional editing and press G to start moving, and Z to exclude the XY movement. Use Shift+Mouse wheel to adjust the sphere of influence. See the manual for more information about proportional editing
.

The outcome: (with some corrections to the base)


You can animate layer's Disable or Enable using I.

Set keyfrimes like you set keyframes for object visibility:

For example, for start frame on the 20th and end on the 35th, you should set 3 keyframes: off - anywhere before 20 frame, on - on the 20th frame, off - on the 35th frame


I found a solution (the best way is playing with all parameters). I think it is a good way to do what I want :-).

Step 1 :

Add a cube
Add a wind force field
Add a plane (for particles)

Step 2 :

Subdivision Surface on the plane -> to have more Faces for particles.
Add ParticleSystem on the plane and just put the same Face number in Emission number.

Step 3 :

Put the wind Force Field in the cube
Rotate (R|Y|90) the wind
Add Physics Collision on the cube

-> Set Force Fields Absorption : 1.00 (maximum)
Wind Force Field

-> In Physics : Collision -> Check Absorption
-> In Physics : Change the Strength to see the particle movement

When the plane are not in the cube, with gravity, they fall on Z axis. Create an animation on the cube (with Wind) or on the plane. When the plane are in the cube, particles fall on Z axis with a movment on the right.

Now I can create my text and animate all :-).

Hope this solution is good and maybe can help someone else :-).


mesh array modifier with simple deform taper and curve modifier

You could control the instance's radius with the curve's vertices radius, AltS, or N panel, but it's still not exactly the result you're looking for:

Actually you could have a much more accurate result with a bezier curve which you'd give a bevel and a taper object:


How to create a dictionary of all values of addon parameters?

You can use __annotations__ to access your custom properties instead of your conditional list comprehension:

import bpy

my_props = bpy.context.scene.my_props  # Access your custom properties (Replace if needed)
props_dic = '{'  # Open dictionary
for prop_name in my_props.__annotations__:  # Loop over all custom properties names
    value = getattr(my_props, prop_name)  # Access this particular prop value
    value_str = f"'{value}'" if type(value) is str else str(value)  # Transform it to string or add commas if it is already a string
    props_dic += f"'{prop_name}': {value_str}, "  # Add a new entry in the dictionary
props_dic += '}'  # Close dictionary
print(props_dic)

Be aware though that it will only work for 'simple' values, like floats, strings and booleans. If you have more complexe values, like Vectors you will have to add that to your parsing method.

Further and further reading.


Oh dear, I think there might have been a misunderstanding. When you add a Rigify Armature, what you get at first is only the Meta-Rig. Its purpose is to give you the possibility to fit the bones to your character in Edit Mode. You're not supposed to add constraints to it yet, and some edits to the armature are also unsupported. Once you're done editing the bones (and not deleting them), you'd generate the 'real' rig using an operator.

I've added a second Rigify Meta-Rig to illustrate that somewhere down the road, you might have accidentally edited the Meta-Rig in Edit Mode:

The armature on the left is yours, the one on the right a fresh rigify one. As you can see, there's relationship lines missing on your hip bones pointing to the spine. That's why the bones do not follow any longer the spine.

Retry creating a Rigify Armature, reposition the bones in Edit Mode to fit your character, and then locate the 'Generate' button in the Armature Tab of the Meta-Rig:

After you click it, you should get this:

This doesn't work on your Blend file any more, because some vital bones have been deleted unfortunately.

More details can be found for instance in this video https://www.youtube.com/watch?v=dYiAd_08-0k and many many other resources on the web on how to use it.


"but I want curved edges after applying the modifier"
There is no such thing as curved edges, edges are by definition strictly straight.

If you zoom in on one those apparently "curved" edges you will find that they are still in fact straight, just like before, just subdivided more finely into smaller straight segments.

And that is the basis of Subdivision Modelling you use a Subdivision Surface modifier to give the impression of curvature adjusted to a desired level of detail, but there never really is any true absolute curvature. There is always a fine balance between desired level detail and capable performance.

Anyway if you mean to say that you want to see the result of the Subdivision Surface modifier while modifying your mesh in Edit Mode you can activate the option Adjust Edit Cage to Modifier Results in the modifier header. You should for the most part never apply your modifier, and work on a low poly, good topology base mesh, while letting Blender do the hard work of subdividing it dynamically and non destructively.

If you want "true curvature" you should be using a different type of modelling software with a geometry engine based on NURBS surfaces, where curvature is mathematically described, and surfaces controlled with control points.

And even then you would find that a computer is only really capable of displaying straight segments, and those apparently curved surfaces are still actually composed of straight segments, only they are dynamically generated and usually harder to spot to the naked eye.


NURBS convert to MESH and reverse operation

You cannot convert a surface to a curve without losing data AFAIK. I think you meant to convert to mesh.


How to specify tmp directory for rendering

In the Preferences dialog you can set the default directory for new scenes.
The actually used output directory can be changed in the Output Properties:


TOPBAR_HT_upper_bar.append add menus in two places?

If you want additional menus in the top bar you can add them to TOPBAR_MT_editor_menus. The following code adds a menu called Custom Menu with a sub menu that contains an operator. The draw() function of TOPBAR_MT_custom_menu is for drawing the sub menu, while menu_draw() is appended to the TOPBAR_MT_editor_menus in order to draw the menu itself.

import bpy

class TOPBAR_MT_custom_sub_menu(bpy.types.Menu):
    bl_label = "Sub Menu"

    def draw(self, context):
        layout = self.layout
        layout.operator("mesh.primitive_cube_add")

class TOPBAR_MT_custom_menu(bpy.types.Menu):
    bl_label = "Custom Menu"

    def draw(self, context):
        layout = self.layout
        layout.menu("TOPBAR_MT_custom_sub_menu")

    def menu_draw(self, context):
        self.layout.menu("TOPBAR_MT_custom_menu")

classes = (TOPBAR_MT_custom_sub_menu, TOPBAR_MT_custom_menu)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.TOPBAR_MT_editor_menus.append(TOPBAR_MT_custom_menu.menu_draw)

def unregister():
    bpy.types.TOPBAR_MT_editor_menus.remove(TOPBAR_MT_custom_menu.menu_draw)
    for cls in classes:
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":
    register()


How to add a pattern from a 2D image on a 3D object?

Put a Black and White image into an image texture and use it in a displacement modifier applied to a highly subdivided plane.


Modelling which is the easiest way to curve a face?

You can add some loopcuts and then use proportional editing with a sharp falloff to scale it into a nice curve. Notice how changing the radius and falloff type of the proportional editing tool completely changes how the vertices are deformed.(If none of the preset falloffs are good enough, you can make a custom curve to create the exact shape you want).


It is the Bend Tool, Mesh -> Transform -> Bend

Shortcut Shift-W.

It is documented as operator in the API

  Bend selected items between the 3D cursor and the mouse

The Warp function that used to be on Shift W is from 2.70 replaced by the Bend tool. The Warp Tool is still there, but you have to search for it. In the feature video you can actually hear the commenter telling he is using the Bend Tool.


How can you create still image fire in Blender 2.8 Cycles?

I'm still learning to create fire in Blender as well but what helped me was (if you're down with that?) is using premade FireFX mov. files and import them as planes. They are ofc animated but you can use it as stills also and it's a great way to use fire in your art even though you did not make them yourself atm. You should be able to shape it in a heart in some way. When you import them make sure to select EMIT or the fire won't be bright. Also it will shine on objects in Cycles but you have to add a light in Evee to create the illusion. Grts
PS; I've used these; https://www.youtube.com/watch?v=-pljzKVwkzU
Link is in the description below the video. Hope this helped a bit. I for one can't get Mantaflow to work for the life of me no matter how much tutorials I copy to the letter so this helped me out seriously. Happy creating!


Determine if the cursor is over Tools shelf, Properties shelf or 3D content

There is a context.region.type variable which can have the following values:

WINDOW - 3D View
UI - Properties Panel
TOOLS -  Tool Panel
values for the other possible regions (see the documentation)

However context.region.type seems to be determined once on operator invokation. So it will always have the same value while a modal operator is running. The only way seems to be to find out manually:

for region in context.area.regions:
    if(region.x <= event.mouse_x < region.x + region.width  and
       region.y <= event.mouse_y < region.y + region.height and
       region.type in ("TOOLS", "UI")):
        #
        return {'PASS_THROUGH'}

Perhaps a more appropriate way would be to check if the cursor is over the  3D View:

for region in context.area.regions:
    if(region.type == "WINDOW" and
       region.x <= event.mouse_x < region.x + region.width and
       region.y <= event.mouse_y < region.y + region.height):
        break
else:
    return {'PASS_THROUGH'}


Too much RAM after load scene textures in high resolution

So my solution to complete this project was:

I prepared same lowres textures in the different directory for example:
D:\MyProject\MyTextures for highres and D:\MyProject\MyTexturesLow for lowres
I used simple script for change name folder from MyTextures to MyTexturesLow and opposite
I renamed textures folder with script before open scene and switch back before render

It is only solution which save my project :) You can rename folder without script of course.


Why is Keyboard C selecting the Cursor and not Circle Select?

I'm not sure how to fix this but u have a cover up , you can get into circle select by clicking on the small triangle in the select box tool and then select the circle select


If you want to add a simple color in Blender Render open the Diffuse tab
If you want the Surface tab then switch to Cycle Render (on the topbar, the dropdown juste after "Scene")


How do I get Cycles to use GPU on a linux server?

For enabling the device for use, see bpy.context.user_preferences.system.compute_device_type and
bpy.context.user_preferences.system.compute_device.

To check these from a shell, put the python you wish to execute in a file and run

blender --background --python <file.py>

Or, more concisely for quick tests,

blender -b --python-expr 'import bpy; <python code here>'

For convenience, here's a script which will print the possible and current values of compute_device_type and compute_device:

import bpy

sysp = bpy.context.user_preferences.system

devt = sysp.compute_device_type
dev = sysp.compute_device

# get list of possible values of enum, see http://blender.stackexchange.com/a/2268/599
devt_list = sysp.bl_rna.properties['compute_device_type'].enum_items.keys()
dev_list = sysp.bl_rna.properties['compute_device'].enum_items.keys()

# pretty print
lines=[
("Property", "Value", "Possible Values"),
("Device Type:", devt, str(devt_list)),
("Device:", dev, str(dev_list)),
]
print("\nGPU compute configuration:")
for l in lines:
    print("{0:<20} {1:<20} {2:<50}".format(*l))

If CUDA shows up in the possible values for device type, then enabling the device should be as simple as doing something like this in python:

devt = sysp.compute_device_type = 'CUDA'
dev = sysp.compute_device = 'CUDA_0'

To find the identifier for the device, you can use the script above with a line to set compute_device_type to CUDA before getting the list of possible devices.

Once that's all enabled we must still tell cycles to actually use it; to do this set bpy.context.scene.cycles.device to GPU.


How to write a simple OBJ exporter with Python?(With Normals and UV)

Okay, thanks to lemon for this answer:

  If I remember well, vertex normals are not at the "face level" but at the "vertex level" in OBJ. So you should export them the same way you did for 'v', outside of the polygons loop

I added this code in the vertex loop:

f.write( 'vn %f %f %f\n' % (vert.normal.x,vert.normal.y,vert.normal.z))

And used the same index for both the vertices and normals in the face definitions and it imports correctly!


How to make a rigid body pass through only certain other rigid bodies?

Rigid bodies collisions do not allow the kind of control you describe so, instead, a different approach is required.

First model the system using non-overlapping rigid bodies - create the rigid bodies and enable collision and use Rigid Body Constraints to set up the relationships between them.

The constraints can be easily created using the 'Connect' button in the Physics tab of the 3d view Tool Shelf (T). However, for each connection you need to uncheck the Disable Collisions property in the Rigid Body Constraints panel so that the collisions remain active.

To add the overlapping elements, create new objects and size and position them as desired and parent each one to the relevant rigid body (select the new object, hold Shift and select the associated rigid body, then press Ctrl+P and select 'Object') - they will now follow the motion of the associated rigid body.

Since the overlapping elements are no longer rigid bodies they do not affect the collision (and so can overlap) while the (non-overlapping) rigid bodies can handle the physics. You can 'hide' the rigid body 'skeleton' by moving it to another layer if desired - or simply set it not to render (click the camera icon against each object in the Outliner).

To take this a step further you could parent bones to the rigid bodies and have those deform a mesh that would act as a 'skin' to the rigid body skeleton. This is more complicated but would produce much more convincing joint motion for 'organic' characters.


Go to Add-on and write "device" on search space.

You'll see the option Render: Cycles Render Engine. Select this and you will see the options you want!


Change units , and respect the scale of the scene?

When you change the unit preset to centimetres you are changing the unit scale. The unit scale determines how big a unit is, a scale of 1.0 means one unit is one metre, and a scale of 0.01 means the same one unit is 0.01 metre or one centimetre.

You don't need to change the unit scale to be able to enter centimetre measurements, you just need the object size to be the correct scale compared to other object in your scene, this would mean scaling down small objects that import too large or adding .0 before any measurements you want to be in centimetres.

To move an item using unit measurements, press = to start advanced entry mode before you enter the amount. That is GX=30CM will move the object 30 centimetres on the x axis.


Is there any way to limit reflection on a specific part of a mesh

Select the faces inside the ring and give them their own material. You can then assign them a material that doesn't reflect (or has diffuse reflections) and render that. If you really need to fake a reflective material inside the ring that can't see the rest of the ring....

Take that same new inner material and Set it to holdout. Do a render. Switch the material back to the same as before and do another render, but set the number of bounces in this new render to 1 or otherwise disable reflections. You can even hide the whole rest of the ring for the second render.  Then composite the two images together.


If this scene is not an animation, you can use the time axis to animate your camera.  At frame 1 keyframe your camera's location and rotation so it is viewing the Right image.  At frame 2 keyframe the camera so it is viewing the Left image.  Continue frame by frame until you have all the views you want.  Then adjust the start and end frame of the animation to match the number of images you want.

Make sure your camera is configured for orthogonal.

Now when you render the animation the camera will hop around to the different locations for the shots and each frame of the animation will be one of the views you want.


How to get same hair particles from collection in second particle system/ or how to delete instanced particles without converting them to real meshes?

Found a makeshift solution via Python: Get transform of Instances and the corresponding instanced mesh and create a new mesh in a separate collection with the transform and mesh data of the instance.

Converting all Particles to a real mesh wouldn’t be possible because of face-count but creating new meshes for only those particles in the area of the rb simulation is doable.

import bpy

context = bpy.context

dg = context.evaluated_depsgraph_get()

    # objects that are spawned from particle system via collection as source
obj_cube = bpy.data.objects['Cube']
obj_colum = bpy.data.objects['Colum']
obj_ico = bpy.data.objects['Icosphere']
    # empty collection to spawn the new meshes to
new_collection = bpy.data.collections['SecondInstances']

counter = 0
for i in dg.object_instances:
    obj = i.object
    print(obj.name)
        #filter all objects that are not instances by is_instence
    if not i.is_instance:
        print("not an instance")
    else:
        print(f"Instance of {obj.name} at {i.matrix_world}")
        counter += 1

        if obj.name == 'Cube':
                #create new object and keep data (also modifiers) from right source object
            new_obj = obj_cube.copy()
            new_obj.data = obj_cube.data.copy()
            new_obj.animation_data_clear()
                #set new_object transform from instance transform
            new_obj.matrix_world = i.matrix_world
                #move to seperate collection
            new_collection.objects.link(new_obj)

        elif obj.name == 'Colum':
            new_obj = obj_colum.copy()
            new_obj.data = obj_colum.data.copy()
            new_obj.animation_data_clear()
            new_obj.matrix_world = i.matrix_world
            new_collection.objects.link(new_obj)

        elif obj.name == 'Icosphere':
            new_obj = obj_ico.copy()
            new_obj.data = obj_ico.data.copy()
            new_obj.animation_data_clear()
            new_obj.matrix_world = i.matrix_world
            new_collection.objects.link(new_obj)

I will keep the question open for now, because maybe there is a better way and having real meshes is not ideal either and could be optimized?


How does one use cycle's image sequence?

You can use a sequence of numbered images as the input to an Image Texture node set to Image Sequence.
The key is to ensure your image filenames include a numeric element to represent the frame as the last part of the filename before the file extension - eg, 'flame_heat_fuel_000002.exr'.

Blender will identify the 'frame' part of the filename (in this case '000002') and use that to determine which image to pickup for the current animation frame, with the Frames, Start Frame, Offset manipulate how the Blender current frame maps to one of the image sequence frames :

'Frames' defines how many frames are in the sequence
'Start Frame' defines which timeline frame maps to the first image in the sequence
'Offset' shifts the animation along the image sequence by the specified number of frames (so an Offset of zero will map 1 to 1, 2 to 2, etc., while an offset of, say, 5 will map 1 to 6, 2 to 7, etc.)

Enable 'Cyclic' so as to loop the animation over the specified number of frames.

The Image Texture node shows the actual in-use frame just above the 'Frames' field. As you move along the timeline this will update to show which of the image frames is currently selected.


I don't quite understand the problem, but I think what is wrong is that your pivot point is off. Tab edit mode, select the face you want to be a hinge, snap cursor to selected, then set the rotation point to cursor. Let's hope it works!