Destructible crates, tumbling barrels, cascading debris — rigid body physics can make or break the feel of your game world. Yet most 3D artists spend hours fighting mismatched scales, broken constraints, and physics colliders that look nothing like the visual mesh. This guide covers the full pipeline: simulation in Blender, baking, and clean export to Unity, Unreal Engine 5, and Godot 4.
Why Rigid Body Physics Matters for Game Props
Physics-driven props add weight and believability that no hand-keyed animation can fully replicate. A bottle that shatters realistically, a shelf of books that topples when a player brushes past — these moments are cheap to author with a solid rigid body setup and expensive to fake without one.
The challenge is that Blender's rigid body solver and game engine physics systems are entirely separate. Blender simulates on the CPU using Bullet Physics; Unity uses PhysX 4 or Havok; Unreal Engine 5 uses Chaos Physics; Godot 4 ships its own Jolt-based solver. You cannot directly transfer a live simulation — you must either bake it to keyframes and export animation, or define physics properties (mass, friction, restitution) that the engine recalculates at runtime. Knowing which path to take is the first decision you'll make in every project.
Baked animation is the right choice when the physics sequence is scripted — a scripted cinematic, a one-shot destruction event, a cut-scene prop. Runtime physics (collider + rigid body component) is the right choice for interactive props the player can push, knock, or shoot. This guide covers both.
Setting Up Rigid Body Simulations in Blender
Start with correct scale. Blender's rigid body solver is calibrated to real-world metres. A crate that is 1 m × 1 m × 1 m in Blender will behave like a 1-metre crate. Apply scale (`Ctrl+A → Apply All Transforms`) before you enable rigid body physics — unapplied scale is the single most common cause of jittery, explosive simulations.
Enable rigid body via Properties → Physics → Rigid Body. For props that should move freely, choose Active. For the floor and static geometry, choose Passive. Key settings per prop:
- Mass: use realistic values. A wooden crate at 0.5 m³ weighs roughly 20–40 kg; a metal barrel at the same volume is 150–200 kg. Mass ratios matter more than absolute values.
- Friction: 0.5 is a sensible default for wood-on-concrete. Reduce to 0.1 for ice or polished metal.
- Restitution (Bounciness): keep below 0.3 for most props. High restitution on heavy objects causes energy gain and instability.
- Collision Shape: always use Convex Hull or Mesh for simple props; reserve Mesh (which is slow) only for concave passive geometry like terrain or hollow objects. For active rigid bodies, Blender requires convex shapes — you cannot use a concave mesh as an active rigid body.
```python
# Blender Python: batch-set rigid body mass for selected objects
import bpy
DENSITY_KG_M3 = 600 # e.g. pine wood
for obj in bpy.context.selected_objects:
if obj.rigid_body:
vol = sum(p.area for p in obj.data.polygons) / 6 # rough approximation
# Better: use actual volume from bpy.ops.object.volume_to_weight if available
obj.rigid_body.mass = max(1.0, DENSITY_KG_M3 * 0.01)
```
Run the simulation with `Space` in the timeline. If objects explode or clip, reduce the Substeps Per Frame (try 10–20) and enable Split Impulse in the Scene → Rigid Body World → Settings panel. These two settings cure 90% of instability issues.
Constraints and Compound Shapes
Many props need internal structure: a drawer that slides, a lid that hinges open, a chain of barrels linked by ropes. Blender's Rigid Body Constraints handle this.
Add a constraint via `Add → Empty → Plain Axes`, then in Physics → Rigid Body Constraint select the Type (Hinge, Slider, Generic, etc.) and assign Object A and Object B. Hinge constraints use a single rotation axis and are ideal for doors and lids. Generic constraints expose all six degrees of freedom with individual limits — useful for ragdoll-style joints or barrel chains.
Compound shapes solve the concave problem for active objects. Split your concave mesh into convex parts (Blender's `Mesh → Separate → By Loose Parts` after cutting), set each part to `Convex Hull`, parent them all to an Empty, and enable Rigid Body on the Empty. The children act as one compound collider.
| Collision Shape | Best For | Notes |
|---|---|---|
| Box | Crates, books, bricks | Fastest; use when visual is roughly box-shaped |
| Sphere | Barrels, balls, boulders | Very stable; slight shape mismatch is fine |
| Capsule | Bottles, pillars | Good for tall props with rounded tops |
| Convex Hull | Complex props, furniture | Wraps the mesh; no concavities |
| Mesh (passive only) | Terrain, hollow geometry | Slow; never use on active bodies |
| Compound | Concave active objects | Split into convex children + Empty parent |
Baking and Exporting to Game Engines
Once the simulation looks correct, you have two export paths.
Path A — Baked Keyframe Animation (FBX/GLB)
Bake the simulation to keyframes: Object → Rigid Body → Bake to Keyframes. Set the frame range to your simulation window. Blender writes a keyframe for every frame on every object. Clean up with `Object → Rigid Body → Connect` to remove the physics modifier — game engines do not read Blender's rigid body data, only the resulting animation curves.
Export as FBX or GLB. In Unity, import the FBX, expand the clip in the Animator, and set Loop Time to off for one-shot destruction sequences. In Unreal Engine 5, use a Level Sequence or a Matinee-style Sequencer clip. In Godot 4, import as an `AnimationPlayer` track.
Path B — Runtime Physics (Collider Mesh Export)
For props the player can interact with at runtime, skip baking. Instead, export the visual mesh as a GLB/FBX, then separately export a low-poly collision mesh. A good collision mesh has 20–60% fewer triangles than the visual and no thin faces or T-junctions.
In Unity: add a `Rigidbody` component, set mass/drag to match your Blender values, and assign a `MeshCollider` (convex = true for active bodies) or a Primitive Collider chain. Use `Edit → Project Settings → Physics` to set Default Contact Offset to 0.01 and Solver Iterations to 8 for stable stacking.
In Unreal Engine 5: enable Simulate Physics on the Static Mesh Actor, set Mass (kg) manually, and use a UCX_ prefixed convex hull mesh in the same FBX for automatic collision import. Name your collision mesh `UCX_PropName` and UE5 picks it up automatically — no extra import steps.
In Godot 4: use a `RigidBody3D` node. Assign a `CollisionShape3D` child with a `ConvexPolygonShape3D` for moving objects. Set `mass`, `physics_material_override` (for friction and bounce), and `linear_damp` to prevent infinite sliding on flat surfaces.
```gdscript
# Godot 4: runtime physics property setup
extends RigidBody3D
@export var prop_mass: float = 20.0
@export var prop_friction: float = 0.5
func _ready() -> void:
mass = prop_mass
var mat := PhysicsMaterial.new()
mat.friction = prop_friction
mat.bounce = 0.1
physics_material_override = mat
```
Sourcing Ready-Made Physics Props
Building every crate, barrel, and debris piece from scratch is time-consuming. The BitSoul marketplace stocks game-ready props with pre-built convex collision meshes and correctly scaled transforms — ready to drop into your physics scene. Look for assets tagged `collision-ready` or `game-physics` in the BitSoul marketplace to skip the collision-mesh authoring step entirely.
Whether you're simulating a crumbling wall or a shelf of jars that shatters on impact, the pipeline is the same: correct scale → stable Blender sim → bake or runtime export → engine-side collider setup. Nail each stage and your physics props will feel as solid as the world around them.
Browse physics-ready 3D game props at BitSoul Marketplace →