Cloth that moves convincingly sells a character instantly — and cloth that jitters, clips, or tanks your frame rate ruins one just as fast. Most tutorials show you how to simulate a cape in Blender and stop there, leaving you stranded when the asset has to actually run inside Unity, Unreal Engine 5, or Godot 4. This guide covers the full pipeline: simulating in Blender, baking the result into an export-friendly format, and choosing the right runtime cloth system per engine.
Why Real-Time Cloth Is Nothing Like Offline Simulation
Blender's cloth solver iterates over every vertex with collision checks, self-collision passes, and pressure forces — at whatever cost it takes, because it only has to produce frames, not hit 16 ms. A game engine has no such luxury. Runtime cloth must share a frame budget with rendering, AI, and physics, which is why every engine implementation is an approximation: fewer solver iterations, simplified collision proxies (capsules and spheres instead of the actual character mesh), and aggressive constraints on how far vertices can travel.
That difference drives every decision in this pipeline. You have two fundamentally different strategies. Baked cloth means simulating in Blender and exporting the motion as animation data — deterministic, cheap at runtime, but unable to react to gameplay. Runtime cloth means letting the engine simulate a low-resolution proxy mesh live — reactive, but more expensive and harder to tame. Most production characters use both: baked or bone-driven motion for primary garments, runtime simulation only for elements that must respond to movement, like a cape or dangling straps.
Pick the strategy per garment, not per character. A tight shirt needs nothing but skinning. A skirt needs a handful of physics bones. Only a cape or cloak truly earns a runtime solver.
Setting Up a Clean Cloth Simulation in Blender
Start with simulation topology, not render topology. A 60–80 cm cape simulates well at 30×40 quads — roughly 1,200 faces. Even, square quads matter more than density: the solver distributes stretch and bend forces along edges, so irregular topology produces irregular wrinkles.
The critical setup steps:
- Pin group: create a vertex group weighted 1.0 where the cloth attaches (shoulders for a cape, waistband for a skirt) and assign it under Cloth > Shape > Pin Group.
- Collision objects: never collide against your full character mesh. Duplicate it, decimate hard, delete everything the cloth can't reach, and add a Collision modifier with around 0.015 m outer thickness.
- Quality steps: 10–12 is enough for game-resolution cloth. Chasing film-quality folds with 20+ steps wastes bake time on detail your in-game mesh can't show.
- Self-collision: enable it only if the garment visibly folds onto itself. It is the single most expensive toggle in the solver.
Set fabric presets as a starting point — Cotton for general clothing, Silk for flowing capes — then tune. The values that matter most for game cloth are Stiffness > Bending (higher = fewer, larger folds that read better at game LODs) and Damping > Air Viscosity (higher = calmer motion that loops more cleanly).
Bake the simulation from the Cache panel, run the timeline once end to end, and scrub backwards to confirm the cache is solid before moving on.
Baking Cloth Motion for Export: Shape Keys, Bones, or VAT
A raw cloth simulation cannot survive a GLB or FBX export — exporters ship vertex positions, armatures, and shape keys, not physics caches. You need to convert the motion into one of three portable formats.
Shape keys (morph targets) work for short, fixed clips like a flag waving or a banner loop. With the simulated frame visible, apply the Cloth modifier as a shape key per sampled frame (Modifier dropdown > Apply as Shape Key), then key the shape values along the timeline. Heavy on memory — every frame stores a full vertex snapshot — so keep it to small meshes and short loops.
Bone baking is the production workhorse for character garments. Add a chain of 3–6 bones along the cloth's flow direction, parent the mesh with automatic weights, then constrain each bone to an empty hooked to the simulated surface and bake the action:
```python
import bpy
# Bake constrained cloth bones to keyframes, 30fps, frames 1-120
bpy.context.view_layer.objects.active = bpy.data.objects["CapeArmature"]
bpy.ops.object.mode_set(mode='POSE')
bpy.ops.nla.bake(
frame_start=1, frame_end=120, step=1,
only_selected=False, visual_keying=True,
clear_constraints=True, bake_types={'POSE'}
)
```
The result is a standard skeletal animation that every engine imports natively, plays through the normal animation system, and blends with locomotion.
Vertex Animation Textures (VAT) encode per-vertex motion into texture data sampled by a shader — ideal for many instances of ambient cloth like market-stall awnings. They require engine-side shader support, so treat them as the specialist option.
| Method | Runtime cost | Reacts to gameplay | Best for |
|---------------|--------------|--------------------|---------------------------------|
| Shape keys | Low–medium | No | Flags, banners, short loops |
| Baked bones | Very low | Via blending only | Skirts, coats, character cloth |
| VAT | Very low | No | Massed ambient cloth, crowds |
| Runtime cloth | High | Yes | Capes, cloaks, hero garments |
If you source rigged characters from a marketplace, check whether cloth bones are already in the skeleton — most game-ready characters on the BitSoul marketplace ship with skirt or coat bones you can drive directly instead of building chains from scratch.
Engine-Side Cloth: Unity, Unreal Engine 5, and Godot 4
Unity ships a Cloth component that runs on skinned meshes. Add it to the garment's SkinnedMeshRenderer, paint per-vertex Max Distance constraints (zero at the waistband, increasing toward the hem), and assign capsule colliders for the limbs. Keep the cloth mesh under ~2,000 vertices; constraint painting is what separates stable cloth from rubber sheeting.
Unreal Engine 5 uses Chaos Cloth. In the Skeletal Mesh editor, create cloth data from a material section, then paint Max Distance and Backstop weights directly on the mesh. Backstop is UE5's standout feature — it defines a virtual surface the cloth cannot penetrate, which kills most leg-through-skirt clipping without expensive per-triangle collision.
Godot 4 has SoftBody3D, a general-purpose soft-body node rather than a dedicated garment system. It works for flags and banners with pinned vertices, but it does not run on skinned character meshes. For Godot characters, baked bone animation plus a few jiggle-bone addons (or SkeletonModifier3D physics in 4.3+) is the practical route — another reason the bone-baking workflow above is the safest default for cross-engine assets.
Whichever engine you target, simulate a separate low-resolution proxy and render the detailed mesh — never simulate render topology directly.
Performance Budget Checklist
Run through this before calling a cloth asset done:
- [ ] Runtime cloth proxy under 2,000 vertices (under 1,000 for mobile)
- [ ] Collision uses capsules/spheres only — no mesh colliders on characters
- [ ] Self-collision disabled unless visibly necessary
- [ ] Baked bone chains: 6 bones or fewer per garment piece
- [ ] Cloth updates can drop to lower rates at distance (LOD the simulation, not just the mesh)
- [ ] Loop point verified — first and last frames match on baked clips
- [ ] One garment per cloth component; don't merge cape and skirt into one sim
Cloth is one of the highest-effort asset types to build from scratch, which makes it one of the best things to source ready-made. The BitSoul marketplace carries game-ready GLB characters and props with cloth bones, baked animations, and engine-tested skinning already in place — grab one, drop it into your engine, and spend your time on gameplay instead of solver settings.