Cloth Simulation — Set up basic cloth simulation and collision objects - Blender

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.

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

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

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

1
Step 1 — Create the Collision Object

Open 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.
2
Step 2 — Create the Cloth Mesh

Add 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.
3
Step 3 — Enable Cloth Physics

With 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.
4
Step 4 — Test the Simulation

Press 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.
5
Step 5 — Bake & Apply

Once 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	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.

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

✦

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.

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.

From basic cloth setup to advanced simulation workflows.

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

Question 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?

Show answer

A Collision object serves as an immovable (or keyframe-driven) boundary constraint for the solver. Unlike the cloth mesh, whose vertex positions are computed by integrating forces over time, the collision mesh's position is defined entirely by its animation data or static placement. The solver only reads the collision surface's geometry each frame to compute signed-distance constraints—it never writes back to it. This is analogous to a wall in a billiard simulation: the wall influences the ball's trajectory but is never itself moved by the impact. In Blender, if you need the obstacle to deform, you would use a Soft Body modifier on that object instead of (or in addition to) Collision.

Question 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?

Show answer

A plane with 30 subdivision cuts along each axis produces (30 + 1) × (30 + 1) = 31 × 31 = 961 vertices. With Quality Steps set to 8, the solver performs 8 sub-steps per frame. Over 120 frames that yields 120 × 8 = 960 sub-steps. Each sub-step must evaluate forces for all 961 vertices, giving a total of 960 × 961 = 922,560 vertex-force evaluations. This calculation illustrates why raising Quality Steps or mesh resolution has a multiplicative impact on bake time—doubling either parameter roughly doubles the computation.

Question 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.

Show answer

First, increase the cloth's Quality Steps from the default 5 to 12–15; this shortens each sub-step so the scarf moves less per iteration, reducing the chance it skips past the collision surface. The trade-off is longer bake time. Second, raise the Outer Thickness on the mannequin's Collision modifier from 0.001 to 0.01 or 0.02; this creates a thicker invisible buffer that the cloth detects earlier. The trade-off is that the scarf may appear to hover slightly above the shoulder surface. Third, increase the collision Quality on the collision object, which controls how many iterations the collision solver runs per sub-step. This catches remaining edge cases but further extends computation. A fourth optional step is to subdivide the mannequin's collision mesh in areas of contact—low-polygon collision surfaces can produce gaps between faces that the cloth slips through.

Question 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.

Show answer

Begin by modeling a rectangular plane (the flag) and a cylinder (the flagpole). On the cylinder, add Physics → Collision so the flag cannot pass through it. On the flag, add Physics → Cloth. To pin the left edge, enter Edit Mode on the flag, select the leftmost column of vertices, go to Object Data Properties → Vertex Groups, create a new group named 'Pin', and click Assign with a weight of 1.0. Back in the Cloth panel under Shape, check 'Pinning' and select the 'Pin' vertex group from the dropdown. Next, add a Wind force field (Add → Force Field → Wind), position and rotate it so it blows perpendicular to the flag's surface, and set its Strength to approximately 20–40 for a moderate breeze. You may add a Turbulence force field nearby (Strength ≈ 5) to break up the waving pattern and avoid a mechanical look. Finally, increase Quality Steps to 10 since wind can produce fast cloth motion, and bake the simulation. The result is a flag that flutters dynamically while remaining attached to the pole along its left edge.

Question 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.

Show answer

The modifier-based workflow is mature, well-documented, and fast to set up: you click a single button, choose a preset, and hit play. It excels for standard scenarios—draping, falling, billowing—where the built-in mass-spring solver and collision engine handle the physics without custom logic. However, it is largely a black box: the artist controls parameters but cannot alter the solver's internal behavior, making effects like procedural tearing, stitching, or adaptive topology impossible. Geometry Nodes Simulation Zones, by contrast, expose the simulation loop as a node graph. Each frame, the artist can define custom forces, modify topology, or inject noise at specific vertices. This makes them ideal for procedural and generative art workflows—imagine cloth that dissolves into particles as it falls or fabric that grows organically. The trade-off is a significantly steeper learning curve: the artist must understand frame-to-frame state propagation, attribute management, and field math. Iteration speed may also suffer because the node graph requires manual construction of behaviors that the modifier provides out of the box. For a visual arts student, the modifier approach is the right starting point for realistic cloth behavior, while Simulation Zones become valuable when the project demands bespoke, stylized, or procedurally driven fabric effects that the standard solver cannot produce.

SUMMARY

Lesson Summary

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.