Cloth Simulation — Set up basic cloth simulation and...

SECTION 1

Historical Context & Motivation

Simulating the behavior of fabric in 3D has been a longstanding challenge in computer graphics, driven by the entertainment industry's desire for believable digital clothing, flags, curtains, and other soft-body surfaces. Before dedicated cloth simulation systems existed, artists had to manually animate every fold and wrinkle of a draped surface—a painstaking process that scaled poorly for complex scenes. The pursuit of physically plausible fabric behavior motivated decades of research in computational mechanics, culminating in the real-time solvers embedded in modern tools like Blender.

1986

Terzopoulos Deformable Models

Demetri Terzopoulos and colleagues at MIT published foundational work on elastically deformable models, introducing the mass-spring paradigm that still underpins many cloth solvers today.

1998

Baraff & Witkin Implicit Integration

David Baraff and Andrew Witkin presented a landmark paper at SIGGRAPH demonstrating implicit integration methods for large-time-step cloth simulation, enabling much faster and more stable draping of virtual fabrics.

2005

Blender Introduces Cloth Physics

Blender 2.40 shipped with a basic cloth simulation system, bringing physics-based fabric behavior into the open-source pipeline for the first time and democratizing access for independent artists.

2018

Blender 2.80 Overhaul

The complete UI redesign in Blender 2.80 modernized the Physics Properties panel, added real-time viewport overlays for simulation cache, and integrated cloth into the new Eevee/Cycles workflow.

2023+

Geometry Nodes & Simulation Zones

Blender 3.x and 4.x introduced Simulation Zones inside Geometry Nodes, opening the door to procedural cloth setups and artist-programmable physics behaviors alongside the traditional modifier-based approach.

The central question this lesson addresses is straightforward yet technically rich: how do you configure a mesh in Blender so that it behaves like real cloth—responding to gravity, draping over obstacles, and producing convincing folds—while ensuring that collision objects in the scene properly interact with the simulated fabric? Understanding this workflow transforms static geometry into dynamic, physically motivated art.

SECTION 2

Core Principles & Definitions

Blender's cloth system relies on a small set of interconnected concepts. Before touching any panel in the UI, it is essential to internalize the vocabulary and the physics model driving the simulation. Every vertex of your cloth mesh is treated as a particle with mass, and every edge acts as a spring that resists stretching, bending, or shearing. This mass-spring model is evaluated at discrete time steps to produce the motion you see in the viewport. Collision objects—any meshes tagged with a Collision physics modifier—define the solid surfaces that the cloth cannot pass through.

Cloth Modifier

Applied via Physics Properties → Cloth, this modifier converts a mesh into a simulated fabric. It exposes settings for mass, stiffness, damping, and air resistance.

Collision Modifier

Added to other meshes in the scene via Physics Properties → Collision. It tells the solver that this object is a solid obstacle the cloth must drape over or deflect from.

Vertex Groups & Pinning

Vertex groups allow you to pin specific vertices so they remain fixed in space while the rest of the cloth falls freely—essential for hanging drapes, capes, or tablecloths.

Cache & Baking

The simulation is computed frame by frame and stored in a cache. Baking writes the cache to disk so playback is instantaneous and the result is reproducible across sessions.

Quality Steps

The Quality Steps parameter controls how many sub-steps the solver takes per frame. Higher values improve accuracy—especially for fast-moving or thin cloth—at the cost of longer computation time.

✦ KEY TAKEAWAY

Think of a cloth simulation like a marionette stage: the Cloth modifier turns your mesh into the puppet—responsive to gravity and forces—while Collision objects act as the stage floor and props the puppet cannot pass through. Pinning is the string that holds specific parts of the puppet aloft. Without any one of these three elements, the performance falls flat.

SECTION 3

Visual Explanation — The Cloth Pipeline

The upper row shows the four-step cloth setup pipeline: create the mesh, enable Cloth physics, configure parameters, and bake. The middle row illustrates how collision objects are prepared. The dashed box at the bottom represents the interaction between the two systems at runtime.

The diagram above maps the complete workflow from raw geometry to a finished drape. Notice that the cloth pipeline and the collision pipeline are independent until the solver runs: you configure them on separate objects and Blender's physics engine reconciles them during playback. This modularity means you can swap collision objects in and out without ever touching the cloth settings—an important flexibility when iterating on a scene composition. The dashed interaction box symbolizes the frame-by-frame evaluation where vertex positions of the cloth are updated according to forces and constrained by collision surfaces.

SECTION 4

How It Works — The Mass-Spring Model

Although you do not need to implement the solver yourself, understanding the underlying physics model helps you make informed decisions when tweaking parameters. Blender's cloth solver treats every vertex as a point mass connected to its neighbors by springs. Three types of springs govern different deformation modes: structural springs resist stretching along mesh edges, shear springs resist diagonal distortion across quads, and bending springs resist curvature between adjacent faces. The relative stiffness of each spring type is exactly what you control in the Cloth Properties panel.

HOOKE'S LAW (SPRING FORCE)

F = −k × (x − x₀)

F = spring force vector, k = spring stiffness constant (mapped to Blender's Tension/Compression values), x = current length, x₀ = rest length. Higher k values make the cloth stiffer and more resistant to stretching.

NEWTON'S SECOND LAW PER VERTEX

m × a = F_spring + F_gravity + F_damping + F_air

Each vertex of mass m is accelerated by the sum of all forces: spring forces from neighboring vertices, gravitational pull, velocity damping (which prevents perpetual oscillation), and aerodynamic drag from the Air Viscosity setting.

COLLISION CONSTRAINT

d(v, S) ≥ Outer Thickness + Inner Thickness

The solver ensures that the signed distance d from each cloth vertex v to the collision surface S never falls below the combined thickness offsets. Increasing these values pushes the cloth further away from the obstacle, preventing visual interpenetration at the cost of a slight 'hover' effect.

⚙️ Why Quality Steps Matter

The solver advances time in sub-steps. If the cloth moves farther than the collision thickness in a single sub-step, it can tunnel through the obstacle. Raising Quality Steps from the default 5 to 10 or 15 reduces each sub-step's displacement, dramatically lowering the chance of cloth passing through collision geometry—especially for fast-moving or thin fabrics.

SECTION 5

Detailed Parameter Breakdown

Blender ships with several cloth presets—Cotton, Denim, Leather, Rubber, and Silk—each of which pre-populates the stiffness, damping, and mass fields to approximate the named material. Choosing a preset is an excellent starting point, but understanding the individual parameters allows you to push beyond the defaults and achieve exactly the look your artwork requires. The diagram below maps the most critical settings to the visual behaviors they produce on a simulated drape.

Three parameter groups—Physical Properties, Stiffness, and Collision Settings—are mapped to their UI labels and default values. The bottom section shows how Blender's material presets position along a visual stiffness spectrum from fluid silk to rigid leather.

Approximate default values for Blender's built-in cloth presets (Blender 4.x).

Preset	Vertex Mass (kg)	Tension Stiffness	Bending Stiffness	Best Use
Cotton	0.3	15	0.5	T-shirts, curtains, tablecloths
Silk	0.15	5	0.05	Scarves, veils, flowing garments
Denim	0.4	40	10	Jeans, heavy workwear, sails
Leather	0.4	80	150	Jackets, armor straps, bags
Rubber	0.3	15	25	Elastic surfaces, bouncing sheets

SECTION 6

Worked Example — Draping a Tablecloth over a Sphere

In this step-by-step walkthrough, you will create a simple scene where a flat cloth plane falls under gravity and drapes over a UV sphere acting as a collision object. This is the canonical first exercise for cloth simulation in Blender and provides a foundation you can extend to far more complex setups.

Tablecloth Draping Exercise

Step 1 — Create the Collision ObjectOpen a new Blender file (File → New → General). Delete the default cube by pressing X. Add a UV Sphere via Add → Mesh → UV Sphere. Leave it at the default 32 segments and 16 rings, which provides sufficient collision resolution. Position it at the world origin (0, 0, 0). With the sphere still selected, open the Physics Properties tab (the bouncing-ball icon on the right side panel) and click Collision.

Sphere now acts as an impenetrable obstacle for cloth.

Step 2 — Create the Cloth MeshAdd a Plane via Add → Mesh → Plane. Scale it up to approximately 4× the sphere diameter by pressing S → 4 → Enter. Move it above the sphere: press G → Z → 3 → Enter to raise it 3 meters on the Z axis. The cloth needs mesh resolution to fold realistically, so enter Edit Mode (Tab), right-click and choose Subdivide, then set the number of cuts to 25 in the operator panel (bottom-left). Return to Object Mode (Tab).

A 26 × 26 subdivided plane hovers 3 m above the sphere—676 quad faces ready for simulation.

Step 3 — Enable Cloth PhysicsWith the plane selected, go to Physics Properties → Cloth. Blender immediately applies a default Cotton preset. For this exercise the defaults work well, but take a moment to note the Vertex Mass (0.3 kg) and Quality Steps (5). Under Collision within the cloth panel (this is self-collision, not the obstacle), ensure Object Collisions is checked so the cloth responds to the sphere.

Cloth modifier is active; the plane is now physics-driven.

Step 4 — Test the SimulationPress Space (or the Play button on the timeline) to run the simulation. The plane should fall under gravity, contact the sphere around frame 20–30, and drape over it, producing natural-looking folds. If you see the cloth passing through the sphere, increase Quality Steps to 10 on the cloth and raise the Outer Thickness on the sphere's Collision panel to 0.02. Press Esc to stop playback.

Cloth drapes convincingly over the sphere with visible folds and no interpenetration.

Step 5 — Bake & ApplyOnce satisfied, scroll down to the Cache section of the Cloth panel and click Bake. Blender computes every frame and writes the result to memory (or disk if you check an external directory). After baking, scrub the timeline freely without re-simulating. If you need a static draped mesh for sculpting or further modeling, navigate to the desired frame, then go to Physics Properties → Cloth → (dropdown arrow) → Apply as Shape Key or apply the modifier outright via the modifier stack.

Simulation is locked in; the draped cloth can be rendered or exported at any cached frame.

SECTION 7

Strengths, Limitations, and Common Pitfalls

Strengths, Limitations, and Common Pitfalls of Blender's Cloth Simulation

Strengths	Limitations	Common Pitfalls
Physically motivated: folds, drapes, and wrinkles emerge organically without hand-sculpting.	Simulation time grows with mesh resolution—a highly subdivided cloth can be extremely slow to bake.	Forgetting to add the Collision modifier to the obstacle, so the cloth passes straight through.
Presets (Cotton, Silk, Denim, etc.) provide artist-friendly starting points.	Self-collision is expensive; enabling it on dense meshes can double or triple bake times.	Leaving Quality Steps too low for fast-moving cloth, causing tunneling artifacts.
Pinning via vertex groups offers precise artistic control over which parts move.	No native support for woven-fiber-level detail; the model assumes a continuous sheet.	Non-manifold or overlapping geometry on the collision object producing erratic bouncing.
Integrates seamlessly with Blender's modifier stack, materials, and render engines.	The simulation is deterministic only within the same Blender version; results may differ across updates.	Applying scale (Ctrl+A → Scale) is often overlooked; un-applied scale produces wildly wrong behavior.

✦ KEY TAKEAWAY

Blender's cloth system is like a highly capable research assistant: it handles the tedious physics of draping and folding, but it requires precise instructions. If you hand it poorly prepared geometry (non-manifold meshes, un-applied transforms) or vague parameters (default everything on a scene that doesn't match the defaults), the results will be unreliable. Clean topology, applied scale, and deliberate parameter choices are the three pillars of a reliable cloth setup.

SECTION 8

Connection to Advanced Techniques

The basic cloth-plus-collision workflow you have learned here is the gateway to a family of advanced simulation techniques in Blender. As your projects grow in complexity—character clothing, environmental cloth, or stylized fabric effects—you will encounter scenarios where the default modifier approach must be extended or combined with other systems.

From basic cloth setup to advanced simulation workflows.

Basic (This Lesson)	Advanced Extension
Single cloth mesh drapes over static collision objects.	Animated collision objects: a character mesh driven by an armature can serve as a collision body, causing the cloth to respond to walk cycles and poses in real time.
Uniform cloth properties across the entire mesh.	Per-vertex weight painting: stiffness, mass, and shrink can be painted per-vertex, allowing a single cloth to behave like silk in one region and denim in another.
Modifier-based simulation on the physics tab.	Geometry Nodes Simulation Zones: Blender 4.x lets you build custom cloth-like behaviors inside node graphs, enabling procedural tearing, stitching, and dynamic topology.
Gravity as the sole driving force.	Force Fields: wind, turbulence, and vortex force fields can be added to the scene to produce billowing flags, stormy curtains, or underwater fabric effects.
No self-collision enabled.	Self-collision & sewing springs: enabling self-collision prevents the cloth from passing through itself (crucial for layered garments), and sewing springs let separate cloth panels join mid-simulation.

Each of these extensions builds directly on the concepts introduced today. Mastering the basic collision-and-drape pipeline ensures you can diagnose issues at the foundational level before adding complexity. As a visual artist, your goal is not to become a physics programmer but to develop an intuitive sense for how mass, stiffness, and collision thickness interact—so you can art-direct the simulation rather than being at its mercy.

SECTION 9

Practice Problems

PROBLEM 1 — CONCEPTUAL

Explain why a mesh designated as a Collision object does not itself deform during a cloth simulation. What conceptual role does it play in the solver, and how does this differ from the cloth mesh?

PROBLEM 2 — BASIC CALCULATION

You have a cloth plane that is 4 m × 4 m subdivided with 30 cuts along each axis. How many vertices does this cloth mesh contain? If the simulation uses Quality Steps = 8 and the scene runs at 24 fps for a 120-frame animation, how many total vertex-force evaluations does the solver perform?

PROBLEM 3 — INTERMEDIATE

You are simulating a silk scarf dropping onto a mannequin. During playback, the scarf passes through the mannequin's shoulder. List at least three parameter adjustments you could make—and explain the trade-off of each—to resolve this interpenetration issue.

PROBLEM 4 — APPLIED

You are creating a short animation of a flag waving in the wind, pinned along its left edge to a flagpole (a cylinder). Describe the complete Blender setup: which objects need which physics modifiers, how you would create and assign the pin group, and what force field you would add to simulate wind. Include specific panel locations.

PROBLEM 5 — CRITICAL THINKING

Compare and contrast the traditional modifier-based cloth simulation workflow with the newer Geometry Nodes Simulation Zones approach available in Blender 4.x. In what artistic or technical scenarios might a visual arts student prefer one over the other? Consider factors such as artistic control, iteration speed, proceduralism, and learning curve.

SUMMARY

Lesson Summary

This lesson introduced the complete workflow for setting up cloth simulation in Blender. The process begins by designating a subdivided mesh as a Cloth object through the Physics Properties panel, configuring its vertex mass, stiffness (tension, compression, shear, and bending), and quality steps. Obstacle meshes must be separately assigned the Collision modifier so the solver treats them as impenetrable surfaces. Pinning via vertex groups lets artists anchor specific portions of the cloth while the rest drapes freely under gravity.

Key parameters that shape the cloth's behavior include the material presets (Cotton, Silk, Denim, Leather, Rubber), collision thickness values that prevent interpenetration, and the cache and bake system that locks in simulation results for reliable playback and rendering. Mastering these fundamentals prepares you for advanced techniques such as animated collision bodies, force-field-driven wind effects, per-vertex weight painting for variable stiffness, and the powerful Geometry Nodes Simulation Zones introduced in Blender 4.x.