From BlenderWiki

A Softbody is really a physical simulation of what would happen "in the real world" if the mesh actually had substance and was a real "thing". Using Softbodies, you can simulate the shapes that a mesh would take on if it was real and have volume, was filled with something inside of it, and was acted on by real forces.

What's the difference between a bar of metal, a bar of rubber, and a bar of gelatin? Each will bend under the force of gravity if you hold it out by one end, but by very different amounts. To model a bending object, you could carefully adjust all of the vertices yourself, or you could try to insert some kind of bony armature inside the object. In the end though, you are only guessing what would really happen. Blender provides a much simpler alternative called "soft bodies" simulation. If you add the "soft body" modifier on a mesh, Blender will compute the interaction between the mesh and various environmental forces (like wind or gravity), and Blender will distort the mesh accordingly.

Softbody calculation is like an automatic animation. While you control what the world will do to the Softbody, and where it is pinned, Blender really takes over and calculates what the shape of the mesh will actually be at any given time. That means that it might bounce around in your scene, if that is what would happen in the real world based on your virtual reality. Therefore Softbodies are affected by:

• Deflections from hard bodies (meshes)
• Deflections from other Softbodies (e.g. two blobs of jello colliding)
• Gravity
• Fields (e.g. wind, vortex, spherical repulsion/attaction)
• Itself (e.g. a piece of cloth, folding over itself, stops itself from folding)

Only Mesh objects can be a Softbody.

Soft Bodies

Description

In between each neighboring vertex of a mesh, you typically create edges to connect them. Imagine each edge is really a spring. Any mechanical spring is able to stretch under tension, and able to squeeze under pressure. All springs have an ideal length, and a stiffness that limits how far you can stretch or squeeze the spring.

In Blender's case, the ideal length is the original edge length which you designed as a part of your mesh, even before you enable the "soft body" modifier. Until you add the modifier, all springs are assumed to be perfectly stiff: no stretch and no squeeze.

Once you add the Soft Body modifier, you can adjust the stiffness of all those edge springs, allowing your mesh to sag, to bend, to flutter in the breeze, or to puddle up on the ground.

There are two main methods to control the soft body effect:

Goal

Soft body Goal acts like a pin on a chosen set of vertices; controlling how much of an effect soft body has on them. With Goal fully active (1.0), the object will act like any regular animated object (no soft body effect). When setting Goal to 0.0, the object is only influenced by physical laws. By setting Goal values between 0.0 and 1.0, you can blend between having the object affected only by the animation system, and having the object affected only by the soft body effect. Goal also serves as a memory, to make sure soft objects don't deform too much, ending up in the non-soft animated shape. Using the Vertex Group weight system, you can define a Goal weight per vertex. To make this look more natural, spring forces can be defined to control how far vertices can move from their original position.

Springs

The Edge Spring Stiffness defines how much edges try to keep their original sizes. For example, by adding diagonal edges within a cube, it will become stiffer (less "jelly like"). By tweaking the E Stiff parameter, objects can be set to try to, more or less, keep their original shape, but still move freely with dynamics.

Softbody vertices interact with all the forces applied (usually to particles) in the layer, such as wind, force fields .. and what ever Physics Field effect is on a common layer.

Softbodies are also pushed by Fluids, as long as that fluid domain is marked as a deflector. Also, the Softbody has to be within the fluid's domain.

Softbodies have materials and textures just like any other mesh, and can be subsurfed, multires, and have other modifiers. In fact, when you designate a mesh to be a Softbody, you may notice the Softbody modifier in the modifier stack. When used with other modifiers, like the Subsurf modifier, the Softbody must be the first, or top, of the stack, since it operates on the base mesh. In fact, the Subsurf modifier is an excellent way to smooth out a Softbody without adding more vertices (and thus slowing down computation). A Softbody can have shape keys as well.

Interaction with Deflector

The simulation is really about an interaction between two objects: the Softbody and a Deflector (which can be a hardbody mesh, or another softbody). The deflector settings work in conjunction with the Softbody settings to provide accurate results. So, if you are not getting good results, be sure to check both objects.

In particular, both objects have Damping settings, but from their individual perspective. A couch cushion, a soccer (football) field and a basketball court are all Deflectors. A couch cushion that is very plush will absorb all of the force of a Softbody sitting on it; it therefore has a dampening of 1.0. A soccer field is turf and has much more cush than the hard surface of a pine wood floor. Therefore, the soccer field will dampen any softbody that it interacts with, perhaps by 0.5 depending on the length and strength of the grass, how hard the dirt is packed, and how much moisture it contains. It will absorb some of the blow, but not all. A hardwood floor, on the other hand, has 0.0 dampening effect.

When a ball bounces off the hardwood floor, it bounces a second time less, and less, until it eventually comes to rest. Therefore, if the floor didn't stop it, something about itself must dampen the spring interaction, or else it would keep bouncing forever. Therefore, the Softbody itself must have some amount of Edge dampening.

The similar argument goes for Error Limit; the Deflector has an inner/outer edge buffer zone, and the Softbody does as well. Adjust both in tandem to get acceptable results.

Workflow

Defining and using a Softbody is a quasi-animation task. However, important considerations before animation fit into and augment the normal workflow:

• Concept phase
  • Designate which objects are to be Softbody
  • Define how they are to jiggle and move, what gravity is
• Storyboarding
  • Annotate physical simulated forces (wind, vortex)
  • Annotate the action of deflectors via arrows
  • Pick camera angles that hide possible collisions
• Modeling
  • Use low-poly modeling on Softbody objects (or at least, lower, depending on CPU speed)
  • Apply Subsurf modifiers
• Lighting
• Animation
  • Apply Softbody modifier and begin Goal and weight painting
  • Run simulations

Options

Soft Body

This enables the soft body modifier on the selected object

Automatic Calculations

With versions prior to 2.46, you had to bake, or pre-compute the deformation of the mesh. This approach presented problems when using a render farm, or when you changed parameters and forgot to re-bake. With version 2.46 onward, the simulation computation happens automatically as needed. A cache, actually a set of disk-based files in a directory, saves the mesh shapes. These files are automatically created for you and saved when you save the .blend file. Using a cache eliminates a separate Bake step in the workflow, making the simulation process much more interactive and removes an interruption in the workflow.

Protect

You can Protect the cache from Softbody parameter changes. Enable this when you have them set, to avoid unwanted changes.

Clear

If you make changes to the Softbody or to objects that it collides with, you should Clear the unprotected cache and force Blender to recompute the Softbody shapes when they are needed. Otherwise, the Softbody may not pick up on the changes and will give you the cached results. An example of this is when you have changed the animation path of a colliding object; you should select the Softbody that it collides with (or used to collide with) and clear its cache.

Cache:

You must save your .blend file, so the solver knows where to put the cached results. When you first save your blend file, a //blendcache_softbody\ folder is created to hold the cached mesh shape information. If you move the .blend file, you should move these files as well, or Blender will have to recompute them in the new location. A 500-vertex softbody, computed for 250 frames, takes 1Meg of disk space. If you have never saved your .blend file, Blender has no place to put the files. Also, be sure Blender has security rights on your OS to create folders and files.

Friction

Sets the amount of friction the object 'feels' against the void/gas/liquid surrounding. 50 is no slipping at all, 1.0 is is like silk and can easily slide. Even the weight of the softbody itself can make a slippery cloth slide off an object.

Grav

Gravity, the amount of force in Z-axis direction. Earth gravity is a value close to 9.8 m/s2. Positive values make Softbodies drop; negative values make them rise.

Mass

Mass value for vertices. Larger mass slows down motion, except for gravity where the motion is constant regardless of mass. May be it's time to dust off the books on physics (yah that ol' school book that 'accidentially' dropped behind the 'hitchhiker' ) .. reading Newton's laws of motion. The mesh is assumed to have even density

Speed

You can control the internal timing of the Softbody system with this value. 1.0 uses normal mass, friction, and gravity. Use values less than one to simulate dense air or very light fabric dropping, or very heavy or stiff fabric in the breeze.

Use Goal

Enabling this tells Blender to use the motion from animations in the simulation (Ipo, Deform, Parents, etc). The "Goal" is the desired end-position for vertices based on this animation. How a softbody tries to achieve this goal can be defined using stiffness forces and damping.

Goal

The example image has a vertex group "Hands" which are two clumps of vertices along the edge of the mesh, simulating where two hands would be holding it and forcing it down. These vertices travel more closely with the object's animation and thus impart force to the mesh's movement.

If no vertex group is used, this numeric field is the default goal weight for all vertices when no Vertex Group is assigned. If a vertex group is present and assigned, this button instead shows an popup selector button that allows you to choose the name of the goal vertex group.

G Stiff

The spring stiffness for Goal. A low value creates very weak springs (more flexible "attatchement" to the goal), a high value creates a strong spring (a stiffer "attatchment" to the goal).

G Damp

The friction for Goal. Higher values dampen the effect of the goal on the soft body.

G Min/GMax

When you paint the values in vertex-groups (using WeightPaint mode), you can use the GMin and Gmax to fine-tune (clamp) the weight values. The lowest vertex-weight (blue) will become GMin, the highest value (red) becomes GMax. (please note that the blue-red color scale may be altered by User Preferences)

Use Edges

The edges in a Mesh Object (if there are, check Editing->Mesh Panel) can act as springs as well, like threads in fabric.

Stiff Quads

For quad faces, the diagonal edges are used as springs. This prevents quad faces from collapsing completely. Enabling this can make a sheet of cloth behave like a thin sheet of metal or thick piece of rubber.

CEdge

Checks for edges of the softbody mesh colliding

CFace

Checks for any portion of the face of the softbody mesh colliding (compute intensive!) While Cfaces enabled is great, and solves lots of collision errors, there doesn't seem to be any dampening settings for it, so parts of the s-b object near a collision mesh tend to "jitter" as they bounce off and fall back, even when there's no motion of any meshes. Edge collision has dampening, so that can be controlled, but Deflection dampening value on a collision object doesn't seem to affect the face collision.

E Pull

The spring stiffness for edges (how much the edges are stretched). A low value means very weak springs (a very elastic material), a high value is a strong spring (a stiffer material) that resists being pulled apart. 0.5 is latex, 0.9 is like a sweater, 0.999 is a highly-starched napkin or leather.

E Push

How much the Softbody resist being scrunched together, like a compression spring. Low values for fabric, high values for inflated objects and stiff material.

E Damp

The friction for edge springs. High values (max of 50) dampen the E Stiff effect and calm down the cloth.

Aero

Enable the N button if you want to use an aerodynamic model that is closer to physical laws and looks more interesting. Disable for a more muted simulation

Edges can feel wind as they move, and sail or flutter in the breeze. A simple aerodynamic model of a flag sailing in the wind. Nice value approx. 30. You must use a separate mesh that generates the Wind Field (physics buttons), or animate (move) the softbody in 3D space, which is assumed to be filled with air.

Technically, a force perpendicular to the edge is applied. The force scales with the projection of the relative speed on the edge ( dot product ). Note that the force is the same if wind is blowing or if you drag the edge through the air with the same speed.

That means that an edge moving in its own direction feels no force, and an edge moving perpendicular to its own direction feels maximum force.

In between you have the forces like they are when you fly a kite.

Bend

How much starch you want, Charlie? More rigidity and the Softbody is stiffer across a wider area (number of vertices). For example, new denim is much more rigid than silk. A steel bar is much more stiff than a steel tube.

Shear

How much force it takes until it suddenly gives way and bends. A spring, or copper tube has a much lower shear value than a steel tube.

Soft Body Solver

Description

The next step is to tell Blender how to use that basic information when performing the simulation. A "Solver" is an approach and settings that Blender uses when performing the simulation. Error settings control the fineness of the algorithm.

Options

Solver Select

Blender has two solver algorithms that it can use:

• Soft - a step-size, adaptive algorithm for most situations
• Runge Kutta Correct Physics - a mathematically correct and educationally correct algorithm. Tends to be "unstable".

Error Limit

Rules the overall quality of the solution delivered. Default 0.1. The most critical setting that says how precise the solver should check for collisions. Start with a value that is 1/2 the average edge length. If there are visible errors, jitter, or over-exaggerated responses, decrease the value. The solver keeps track of how 'bad' it is doing and the 'error limit ' causes the solver to do some 'adaptive step sizing'.

Velocity Check

Enable to help the Solver figure out how much work it needs to do based on how fast things are moving.

These settings allow you to control how Blender will react (deform) the soft body once it either gets close to or actually intersects (cuts into) another collision object on the same layer.

Choke

Default 0. Calms down (reduces the exit velocity of) a vertex or edge once it penetrates a collision mesh.

Fuzzy

Default 1. The very last chance to get really fast collision situations integrated in limited time. This number is multiplied to the Error Limit when vertices are detected to be inside the collision mesh. Trades off with the stability/compute time of the simulation.

M button

If you turn on the Monitor button you'll get a print on the console how the solver is doing.

MinS - Minimum frame step

Default 10. To avoid misses on collision, the minimal step size MinS should be something like 10 or more. The positions of the (collision) objects then are (at a minimum) interpolated in MinS sub - positions per frame. For example, if your frame rate is 25 fps, then a setting of 10 would mean that Blender would look for intersections 10 times a frame (every 0.004 seconds of real-time animation). Think of a cube that is at the right hand side of the wig in frame n and on the other side in frame n+1. If you don't explore what happened in between you simply miss the collision.

MaxS

Default 0. MaxS is a kind of emergency brake to enforce really bad situations to obtain a result at all. Use a number that is much larger than MinS. It is the maximum number of steps per frame to be taken. It overrides the adaptive stepsize calulated form Error Limit if it gets too small. However the solution is less acurate then. A value of 0 disables this option (and Blender may spend a long time figuring out the deformations).

Speed vs. Stability

When setting up the simulation, there is a wide variety of uses for Softbody simulation under a wide variety of settings and situations. Therefore, there is no single right answer for these settings. If there was, we would automate them. In general, the simulation has competing goals:

• Compute time: you don't usually want to wait two days while Blender computes the exact placement of ever vertex, but you don't want it to be totally inaccurate either
• Collision Detection: If a fast moving object goes through a Softbody, even for a split second of a frame, you want to see some effect of that collision in a subsequent frame, even though the collider is long gone.
• Collision Resolution: If two meshes do collide and perhaps intersect, you want Blender to rebound the merge area quickly, but not so fast to to cause it to fly off into space
• Steady State: When the body comes to rest, you don't want to see it quiver, although in real life everything has a frequency and quivers somewhat

In general then, you want to run your simulation with the default settings, increasing Error Limit (and thus decreasing compute time) until you start to see issues.

Soft Body Collision

Description

The Soft Body is a mesh that deforms over time. That deformation is computed based on real-world physics. Part of that physics includes how the mesh will deform as it collides with 'solid' objects, including other soft bodies, on the same layer. This panel allows you to control how this cloth (soft-body) interacts with those other solid objects.

The reason for the layer restriction is for optimum use of computing resources. Softbody calculations, like Fluid calculations, can take a long time. So, usually, restrict your Softbody to a layer by itself, and then share that layer only with other objects that come in contact with it. To speed things up even more, if the Softbody only interacts with part of a mesh, duplicate only part of the mesh and move it to the layer.

Options

This panel has two parts:

• Self-collision - used to make sure the softbody does not intersect itself (think of a curtain or flag blowing in the wind)
• Deflection settings - reflect the Fields and Deflection panel settings; for convenience allows them to be set here as well.

Self Collision

When enabled, allows you to control how Blender will prevent the softbody from intersecting with itself.

Ball Size

Default .49 BU or fraction of the length of attached edges. the edge length is computed based on the algorithm you choose. You know how when someone stands too close to you, and feel uncomfortable? We call that our "personal space", and this setting is the factor that is multiplied by the spring length. It is a spherical distance (radius) within which, if another vertex of the same mesh enters, the vertex starts to deflect in order to avoid a self-collision. Set this value to the fractional distance between vertices that you want them to have their own "space". Too high of a value will include too many vertices all the time and slow down the calculation. Too low of a level will let other vertices get too close and thus possibly intersect because there won't be enough time to slow them down.

Ball Size Calculation Algorithm

Because of the infinite number of ways to model a softbody, and thus their geometric relationship to each other, Blender gives you 5 different algorithms to choose based on the shape of the softbody. By default, the Average algorithm is used and works like this: The average length of all edges attached to the vertex is calculated and the multiplied with the ball size setting. So for a regular mesh with ball size 0.49 the 'personal spaces' are calculated such that everyone is feeling fine but would not want to get any closer. <-- needs review .. how collision balls are calculated using automatics BM

B Stiff

Default 1.0. How elastic that ball of personal space is. A high stiffness means that the vertex reacts immediately to someone invading their space, like an uptight girl on the bus.

B Damp

Default 0.5. How the vertex reacts. A low value just slows down the vertex as it gets too close. A high value repulses it.

Deflection Settings

Use this panel to make this Softbody deflect other Softbodies. These settings are identical to those used for Hardbodies.

Damping

The amount of bounce that surfaces will have, ranging from:

• 0.0 - No damping, soft bodies will have maximum bounce, to
• 1.0 - Maximum damping, soft bodies will not bounce at all.

Inner / Outer

An artificial padding distance added to the inside and outside of each face, to help prevent intersections. Softbody will come to rest this distance away from the face of the colliding object. Adjust to prevent tears and the Hardbody poking through a face of the Softbody.

Deflecting Objects must be Real: Arrays, and modifiers, including mirrors and duplicates, must be applied and be 'real' mesh objects in order to be detected by the Softbody, and to react to them and be deformed by them.

Examples

Many users have asked, what settings should I use to get useful results? This section suggests some settings that we know work. The issue is that Softbodies can be so many things:

• Cloth and all its applications: tablecloths, flags, clothes
• Woven fabric, knitted
• Trampoline and all other woven elastics; diving boards
• Flesh, water balloons, inflated tires
• Stretchy shapes, Latex, Mylar
• Jello, Gelatin, sponge
• Rubber Ball, baseball, basketball, football, tennis anyone?
• Magnet, victims of Darth Vader
• Carpet with a thick under padding, pillows, cushions
• Wrestling or workout mat, boxing gloves, punching bags
• Foam and/or spring-supported objects, like chairs, couches, seats
• Toys, especially foam-based, like pool noodles, #1 fan gloves
• Balloons, air mattresses and other low-pressure air-filled objects
• Melting, leaking stuff (this is where Softbodies cross over fluids)
• Gazoober (whatever your imagination wants it to be)

Using a negative Gravity, you can simulate:

• Helium-filled balloons
• oil drops rising to the surface in an underwater scene
• air bubbles underwater
• hot air rising (geothermal tidal currents)
• hot air balloons

Tablecloth

In this suggestion, we use a Cube as a Deflection object that is 2 BU cubed. The Softbody itself is a plane that is 4 BU square, and subdivided 19 times, so that each face is 0.2BU square. This is important, since many Softbody settings are measured in Blender Units, and collision detection and deformation can only be done where there are edges. For the colliding object, (the cube that represents the table), set Softbody deflection as shown:

• Damping 0.5 (simulates some air between the table and cloth. 0.2 makes the cloth fly off the table, 1.0 sticks like glue)
• Inner: 0.2
• Outer 0.2 (0.1 yields corner cuts; use 0.2 for no cuts)

The key is the dampening; you want the surface not to excite or repel the Softbody, but not so high as to have it stick like a vacuum. You want an outer shell (collision detection area) big enough to prevent cuts. Too big of an shell and the Softbody will "float" above the object and appear to puff away from the sides like repelling magnets. Too small and corners will cut through the cloth. As an alternative, bevel the edges of the table; our simplistic cube provides a very sharp, harsh corner.

The Softbody settings for the tablecloth itself reflect a table on earth that is clean and waxed (Friction). It is a light material with a teeny bit of stretch (E Stiff), not cotton but with a little rayon for an alive feel (E Damp). It is used in a restaurant so it has some starch for formality (Rigidity). Edges have to be used for collision avoidance.

Enable self-collision, so that it does not fold through itself. The Error Limit is one-tenth the size of an edge. Monitoring allows you to watch the console - so exciting.

Soccer Ball or Football

The soccer field is a plane and is the Deflector with the settings shown to the right. The field has short grass (Damping) that allows the ball to roll and slide, but not alot.

For the ball, use an Icosphere with 2 Subdivisions and a Radius of 0.5. This is your softbody. It is fairly slippery (Friction), as the surface is polished/waxed leather. It is lightweight (Mass) and fast to react (Speed).

While the leather can give (E Stiff) when kicked, it quickly gets back into shape (E Damp). Wind does not deform it (Aeor) and it is very stiff (Rigidity) when dropped onto a hard surface.

We don't worry about someone kicking the ball so hard as to blow it out (Self Collision). When it hits the ground, it kind of like plops down into the grass (Error Lim) and stays there (MinS).

Flag

This example will show you a way to do a simple flag moving with the wind. The steps are:

1. Create the Flag
2. Assign Weights to a Vertex Group
3. Designate it as Softbody
4. Add Wind

Create a plane in front view and subdivide it three times. Go to the Modifier panel activate Subsurf. In the Editing context Link panel, press Set Smooth.

Add two pins to our flag in both upper and lower corner of our plane, simulating where the flag would be attached to the flagpole. Create a new Vertex Group, and set Weight to 0. Select all vertices, and press Assign. Now, select both upper and lower corner vertices as shown. For these, set Weight to 1.0, and press Assign again. This will make these vertices stay where they are during the softbody simulation. In Weight Paint Mode you should see something like the image.

Next, exit EditMode and go to the Softbody panel in the Object Buttons F7. Click Enable Soft Body. Increase Grav to 9.8. Activate the Use Goal button. Click the selector button next to Use Goal and choose the name of the Vertex Group to use for the goal, in this case, the only choice should be the default name Group. Now set the edge stiffnes E Stiff to 0.9, set Mass to 0.5, Friction to 0.14 and Speed to 2. Set Aero to 40. Save your work.

• Now, you can press ALT-A to see the flag react to gravity and air resistance as it comes to rest.

Now we will add some wind to the simulation:

• Add an empty to the scene where the source of the wind will be. Select the Particle Interaction tab and activate the Wind button. Set Strength to 1.
• Rotate and move the empty so that the Z axis point towards the flag. See Example Wind setup.. You can temporarily increase the Strength value so that you can more easily see the effect of the wind.
• You can press ALT-A to see the flag react to wind.
• Add an IPO curve to simulate changing wind strength will add more realism to the animation. See Example Wind Strength IPO..

Swing

The soft body solver is a simulation system that knows about mass and gravity. Since you can pin certain parts of the mesh to stay at a goal point, you can make a swing very easily. Add a plane and delete one half, so that all that remains are two vertices connected by an edge. Select one vertex and make it the sole member of a vertex group. Tab out of edit mode and enable soft-body for the object. Use Goal, and select the vertex group. Set goal weight to 0, and save your blend file. This creates a rig where one vertex is pinned, but the edge and the other vertex is fully affected by the simulation.

When you scrub or play (Alt A your animation, the goaled vertex stays put, but the other is free to be affected by physics. Since the edge is pretty stiff, and there is gravity and mass and thus inertia, the other vertex swings at the end, back and forth, eventually coming to a stop.

You can now parent an empty to this vertex, and the empty will swing back and forth smoothly (much better than hand animating)! Now that you have a vertex moving nicely, you can add an armature, and set the IK target of the bone to the Empty. Now the bone swings back and forth!

Jello

This example illustrates the use of a volumetric solid. A volumetric solid is one with interior edges. Ths softbody simulation works much better when there are edges inside the mesh, to give it elasticity and resist compression and collapsing of its walls.

Walking Jello

This example illustrates the use of an Armature to control the softbody.

Crash Test

Softbodies can remember their deformation by setting Plas > 0 with tensile strength simulated by setting Be > 0.

Soft Camera

A [mini-tutorial on Blender Artists] on how to mount a camera to a soft body. The resulting soft bounce and dampening effect of the soft-body simulation/movement gives a realistic sway and movement as if held by a human, where muscles do not give perfectly smooth movement.

Hints

When you enable the Soft Body effect on an object, it will always be simulated forward in time. Moving backwards in time or jumping in steps larger than 9 frames will reset the soft body back to its original position. Use the Timeline window playback to make tweaking Soft Body effects interactive.

Why does it do nothing?

When you Enable Soft Body all of it's vertices are free floating particles in the void. This means unless any kind of interaction with 'the rest of the world' is established, they keep in the state of motion they are in (Newton's 1st law of motion). Since nothing is acting on them, they stick where they are. Reasons might be:

1. the softbody is in Edit mode,
2. you have not saved your file and thus Blender cannot save the cache
3. nothing deflects it, either other objects or forces
4. no Gravity and/or mass
5. no Edges as springs at all
6. you have Goal enabled, and the goal is to stay in the same place (no animation)

I only wanted a little jiggle...

Use Goal. It connects the free particles with their siblings (vertices in a mesh, but curves and lattices should work too) by establishing a 'damped spring'. Use G Min and G Max to get it as close as you want.

But I want it to fall down

Gravity or animation makes things fall down. Do not use Goal if there is no animation.

I want some vertices to be soft...while others stay

Then you need to to have a vertex group assigned to goal.
Weight painting in that group means 1.0 sticks extacly to what comes out of Modifier stack for 'sibling' 0.0 move free in terms of .. i'll care for any force but Goal. Using weight painting, you can restrict the freedom of the soft-body mesh to act like a soft body, making it possible to "adhere" to the parented mesh, for example the "scalp-ends" of the hair stick to the head while letting the "strands" move freely. Weight-painting is the "glue" that holds the wig in place. In the pic, red is full weight (1.0) to hold the "cap" portion in place and transitions to dark blue (0.0) along the length of the hair strand strips. It's OK to use the extremes of weight here -- the soft-body settings allow you to tweak the min/max of the weighting without further painting.

My cloth goes right through other 'hard' objects

You have to define those other objects as obstacles, and they have to exist on a common layer with the cloth. Increase your MinStep setting (MinsS on the Solver panel).

My deflection object cuts through pieces of my cloth

You also have to set tolerances (distance and timing) to tell Blender how much to compute to avoid that intersection. See Soft Body Collision. Increase your MinStep setting (MinsS on the Solver panel).

There's like a gap of air between my Softbody and the collision object

Reduce the Inner/Outer settings on the collision object. If that results in corners and edges cutting through your cloth again, enable CEdge. If the issue continues, enable CFace. consider making seams and edges that give the body some thickness. Change camera angle.

My cloth crumples up like paper

Try using the Old method. Increase dampening, choke and ball size.

My cloth is jumpy and jittery

There may be two issues: the edge springs are not being dampened (E Damp), or when a Collision is detected, Blender tries to resolve the collision too quickly. In this case you need to increase the MinS so that more checks are done, reduce the Error Limit during Collisions so that the collision is detected and prevented, or decrease the Fuzzy or increase the Choke on the response.

My cloth slides off the table

Increase Friction.

My cloth bounces off the table

Increase Dampening on the table (deflection object)

Gosh this takes a long time to compute!

Reduce the number of vertices in your Softbody mesh. Disable CFace.

The density of a mesh increases compute time. A mesh that is not dense enough looks blocky (use Subsurf).

I made changes, but it doesn't seem to be doing anything

Clear the cache. Ensure that Blender can create the cache files, and that the files are not write-protected.

My ball comes to a rest, but then it just jitters, like Brownian motion

Increase the MinS setting so that it stops over-correcting vertex location.

Technical Details

In the softbody world vertices of meshes, lattices, curves .. are treated as particles having a mass. Their movement is determined by the forces affecting them. Beside other forces the individual particles can interact with another along edges using a physical model which is very close to shock absorbers used in cars. The working parts are:

• A spring trying to keep the particles at a certain distance. How hard the spring tries to do that is controlled by the softbody parameter 'E Stiff'.
• A damping element to calm the movement down. The resistance the element builds up against motion is controlled by the softbody parameter 'E Damp'.

Softbody goal

• There is another 'shock absorber' at each vertex of the softbody connecting the associated particle with the 'original' position of the vertex. So this defines a 'goal' the particle tries to reach. The strength of the springs here however is modified by either object global settings in the softbody panels or weight painted to a vertex group.
• A very special goal relation is obtained when the weight of the vertex is exactly 1. In this case the particle is "bolted" to the original vertex. The motion of that particle is the same as if it was no softbody at all. Defining goal weights smaller than 1 will cause the softbody to jiggle around it's "rest position".
• Having said that, it's not very surprising that a weight of 0 breaks the goal 'shock absorber' completely.

Clever solver

To get things done as fast as possible the solver used here follows a strategy called adaptive step sizing and works like this:

• First try to warp to frame N+1 (or shorter if we were told (MinS will do so)) with all the knowledge we have.
• Use some voodoo to detect how bad we were doing.
• If we did not violate the level of badness defined by the error limit we 're done and will happily return our results to the boss.

• Other ways we failed to hold the badness line go to plan B.
• Plan B:
• Assume there happened something we need to look at closer.
• Reduce the warp distance, if we are allowed to do so. (MaxS or internal emergency break will tell )
• Try to warp to reduced distance with all the knowledge we have.
• Use some voodoo to detect how bad we were doing.
• If we did not violate the level of badness defined by the error limit we continue trying to warp to next step with reduced distance with all the knowledge we have until we reach destination. Once hopefully there return to boss with a smile.
• Here we start to get optimistic: if voodoo tells us we were doing pretty good we'd even could try to go faster then!
• If we could not meet the level of badness still we will follow plan B recursively provided we are allowed to do so(MaxS or internal emergency break will tell )

• When we were not allowed to decrease step size any more (MaxS or internal emergency break did say), we will do our very best and return the poor results to the boss.

Note: you can kick, fire, kill your computer it won't give better results.

Baking Soft Bodies

Description

Pre-2.50, you had to manually bake the simulation. This section is preserved for those people using an old version of Blender.

Once you've got a working soft body simulation, you can Bake the simulation into a static animation system. A baked soft body plays back much more quickly, and is not dependent on before and after frames any more.

It is recommended that you bake soft bodies when rendering animations, because the simulation doesn't work correctly for Motion Blur rendering, or for rendering in small chunks via a network render system.

Cannot Bake in Edit Mode: You can only bake when in object mode. Clicking Bake with the object in edit mode won't appear to do something, but won't actually calculate anything.

Options

Start/End

Sets the range of the soft body simulation to be baked.

Interval

Sets the number of frames in between each baking "step" (the "resolution" of the baked result). Intermediate positions will be calculated using the steps as key frames, with B Spline interpolation.

Bake

Starts the Bake process. Depending on complexity, this might take a little while. You can press Esc to stop baking. Once Baked, this button changes into a "Free Bake" button. You must free the baked result to modify soft body settings.

Developer Notes

Previous: Manual/Static Particles Contents Next: Manual/Force Fields and Deflection