Intact physics and fall damage

A pot sits on a crate. You smash the crate. With intact physics, the pot does not hang in the air where the crate used to be: it drops under the world’s gravity and lands on the floor. If the pot was generated with the Ceramic preset and the fall is high enough, the landing can break it. A stone statue knocked off the same crate falls too, but by default the landing does not damage it.

This page describes exactly when that happens, and when it deliberately does not.

Three situations to tell apart

Situation	What the intact mesh does
New ordinary generation (Create Destructible or Batch Generate, any preset)	Simulated by default: it rests on its support and falls when the support breaks
Older setup you generated before this feature, not migrated	Unchanged. Its profile reads KeepExisting, so the mesh keeps whatever physics settings it already had, and fall damage stays off
Composite glass window (frame plus panes)	Always published Static. The frame and panes never simulate or fall as one body

Nothing converts existing content silently. Older setups switch to Simulated only through the explicit migration command. The demo content shipped with the plugin has already been migrated.

Physics modes

Every USDFDestructionProfile carries a PhysicsMode of type ESDFIntactPhysicsMode, applied to the intact representation at BeginPlay:

Mode	What SDF does at BeginPlay
KeepExisting	Nothing. The mesh keeps the physics settings it arrived with
Static	Switches the intact’s simulation off. Mobility is left alone
Simulated	Movable, physics collision, simulation and gravity on. The world’s configured gravity is used; SDF adds none of its own

KeepExisting is the default of the profile class, so a profile created by hand, or one saved before this feature existed, keeps its previous behaviour. The authoring window and batch tools publish Simulated for every preset family unless you pick another mode. Choose Static for props fixed to the world: a beam in a wall, a pillar, a shop sign.

Per-instance override

One placed instance can differ from the profile it shares with its neighbours:

• Intact Physics (Override) — PhysicsModeOverride on USDFDestructibleComponent, of type ESDFIntactPhysicsOverride: UseProfile, ForceStatic or ForceSimulated. Read at BeginPlay.
• SetPhysicsModeOverride(NewOverride) changes it during play and applies the result immediately.
• GetEffectivePhysicsMode() returns the mode the instance actually lives by: the profile’s mode with the override applied.

Which Actor simulates

A simulating component that is not its Actor’s root is detached from the Actor by Unreal and never reattached. SDF therefore makes sure the intact mesh is the root before it simulates.

• ASDFPhysicsDestructibleActor — the Blueprint parent of new Simulated generations. Its intact Static Mesh is the Actor’s root and its own collider; the bounds box stays present for API compatibility but collides with nothing. It keeps the mesh’s own pivot. The mesh does not simulate in the editor: the profile turns simulation on at BeginPlay.
• ASDFDestructibleActor — the classic Actor used by Static and KeepExisting setups and by older generations. When its effective mode is Simulated (after a migration, or through ForceSimulated), it re-roots itself as play begins: the intact mesh becomes the root, the former scene root (with the loot point and any component you added) is attached under it, every world transform is kept so nothing visibly moves, and the mesh becomes the collider.

That re-rooting happens in the running world only. The Blueprint asset and the level are never modified at runtime.

Simulation collision

A body can only simulate with simple collision that is not Use Complex As Simple, and it simulates as that simple shape. A mesh cannot simulate as it stands when:

• it has no simple collision;
• it uses Use Complex As Simple;
• its simple collision spans less than a quarter of the mesh along an axis — typically a hull authored at the wrong scale, which would make the prop topple or sink at rest.

The advanced option Generate Simulation Collision if Needed, in section 4. Runtime Profile of the authoring window, is on by default. When a Simulated generation meets such a mesh, SDF:

1. duplicates the mesh into the setup’s generated folder as SM_SDF_<Name>_Sim;
2. gives the copy a generated 26-DOP simple hull, removing an undersized shape first;
3. sets the copy’s collision complexity to Simple And Complex explicitly;
4. points the generated Blueprint at the copy.

The source mesh is never modified. The copy belongs to the setup: the manifest records and fingerprints it, and regeneration rebuilds it in place when the source changed. A source that already simulates is used directly, with no copy.

Code	Severity	Meaning
SDF-AUTH-PHYS-001	Error	Physics is Simulated, the mesh cannot simulate, and Generate Simulation Collision if Needed is off. Nothing was generated
SDF-AUTH-PHYS-002	Error	The simulation collision could not be generated, so nothing was published
SDF-AUTH-PHYS-003	Pass	A composite glass window was published with Physics = Static
SDF-AUTH-PHYS-004	Pass	The Blueprint uses an SDF-owned simulation copy; the source mesh was not modified

When a support breaks

When a destructible is actually destroyed, SDF wakes the simulating bodies resting on it, so they fall at once instead of staying asleep in mid-air.

• Which bodies — gathered before anything changes, from the support’s world bounds grown by a 2 cm skin and a 10 cm band above it. Only simulating bodies in the dynamic object channels (WorldDynamic, PhysicsBody, Pawn, Vehicle, Destructible) are kept; the support and its own Actor are excluded.
• Stacks — only bodies touching the support are woken directly. Bodies higher in a stack are woken by Chaos when the body below them moves.
• Budget saturation — a destruction that commits with its presentation suppressed by the budget still removes the support, so the same wake happens.
• Failed destruction — when the destruction is rolled back, the support stays and nothing is woken.
• The destroyed support stops simulating before it is hidden, so it never falls through the world while invisible.
• Diagnostic — GetLastSupportWakeCount() returns how many bodies the last committed destruction woke.

Fall damage

Fall damage is optional, per profile, and applies to a simulating intact mesh only.

How a fall is measured

While the profile enables fall damage, the destructible component tracks the highest position of the intact body’s centre. A fall counts once the body descends faster than 15 cm/s. On the first landing after that, SDF measures the drop — apex height minus the landing height of the centre — and routes one hit. A contact is ignored when:

• the body is not simulating, or the destruction already committed;
• the other Actor is a Pawn, or the prop’s own Actor;
• the surface faces sideways or down (a wall scrape or a ceiling), rather than up;
• the same landing already produced its hit — further Chaos contacts from that landing do nothing.

Formula

FallDamage = max(0, (DropHeightCm - MinimumFallHeightCm) / 100 * FallDamagePerMeter)

Unreal distances are centimetres. The result is an amount of damage units fed into the normal hit pipeline, not a probability of breaking. A landing whose damage is zero sends no hit at all.

The landing hit carries FallDestructionPower, an impact speed of at least sqrt(2 × gravity × drop) and the gameplay tag SDF.Source.Collision.Fall. It then goes through the same rules as any other hit: MinimumImpactSpeed, MinimumDestructionPower, health, bDestroyOnSingleValidHit, resistance and persistence. ComputeFallDamage(DropHeightCm) on the profile returns the formula’s result for a given drop.

Defaults: the profile class versus the presets

Two different sets of numbers exist. Do not confuse them.

Profile class defaults — what a USDFDestructionProfile holds when created outside the new authoring pipeline:

Property	Default
PhysicsMode	KeepExisting
bEnableFallDamage	false
MinimumFallHeightCm	80.0 (cm)
FallDamagePerMeter	50.0 (damage per metre)
FallDestructionPower	VeryLight

New generations — what the authoring pipeline writes on the generated profile:

Preset family	PhysicsMode	Fall damage	MinimumFallHeightCm	FallDamagePerMeter	FallDestructionPower
Ceramic	Simulated	On	60	50	VeryLight
Glass Vessel	Simulated	On	80	80	VeryLight
Stone	Simulated	Off	—	—	—
Wood family (Wood, Wooden Crate, Wooden Barrel, Wooden Furniture, Wooden Coffin)	Simulated	Off	—	—	—
Glass (single pane), Generic	Simulated	Off	—	—	—
Composite glass window	Static	Off	—	—	—

These are editable material defaults, not a claim about real-world materials. Turn fall damage on or off on any generated profile.

Worked numbers

For a profile generated with the Ceramic preset (MinimumFallHeightCm = 60, FallDamagePerMeter = 50):

Drop of the centre	Fall damage
50 cm	0 — below the safe distance, no hit is sent
100 cm	((100 - 60) / 100) × 50 = 20
160 cm	((160 - 60) / 100) × 50 = 50

Those numbers are computed before the profile’s other rules. The Ceramic generation defaults use no health pool, destroy on a single valid hit and accept VeryLight power, so an eligible landing that produces damage normally breaks such a pot. Give the profile a health pool, turn off bDestroyOnSingleValidHit, or raise MinimumDestructionPower, MinimumDamageThreshold or MinimumImpactSpeed, and the same landing can leave it intact.

Why the statue survives

A statue generated with the Stone preset simulates, so it falls when its support breaks — but fall damage is off, so the landing sends no hit. If you enable fall damage on a Stone profile, note that Stone generations require Light power while the landing carries VeryLight by default: raise FallDestructionPower as well, or the landing is still rejected.

Diagnostics

GetIntactPhysicsStatus() returns what SDF actually did, as ESDFIntactPhysicsStatus. When Simulated cannot be applied, SDF refuses, leaves the primitive exactly as it was and logs a warning. The only restructuring SDF ever performs is the classic SDF Actor’s own re-rooting described above, and only once every other check passes.

Status	Meaning
NotApplied	BeginPlay has not applied the mode yet
KeptExisting / AppliedStatic / AppliedSimulated	The mode was applied
RefusedNoIntact	No intact primitive could be resolved
RefusedIntactNotRoot	The intact is not the Actor’s root, on an Actor class that is not an SDF Actor. Make the intact the root, or force the instance to Static
RefusedMultipleDestructibles	The Actor carries several destructibles and cannot move as one body
RefusedNoSimpleCollision	The intact has no simple collision
RefusedComplexAsSimple	The mesh uses Use Complex As Simple
RefusedByPhysicsEngine	The physics engine did not start simulating the primitive

Function	Returns
GetEffectivePhysicsMode()	The applied mode, override included
GetIntactPhysicsStatus()	The status above
GetLastSupportWakeCount()	Bodies woken by the last committed destruction
GetLastFallHeightCm()	The drop of the last damaging landing, in centimetres; zero before one
GetLastFallDamage()	The fall damage of that landing
ComputeFallDamage(DropHeightCm)	On the profile: the formula’s result for a given drop

Reset and saved state

• Simulated props return to their placed pose. The pose is captured when play begins. ResetDestruction() teleports the intact there with no leftover velocity, restores collision, then resumes simulation. That also applies to a prop that was only pushed, never broken.
• KeepExisting props keep their classic reset, with no teleport.
• Physics transforms are not saved. A destroyed prop comes back destroyed after loading; an intact prop that was only moved by physics comes back at its placed location.

Migrating older setups

Setups generated before this feature read as KeepExisting. To switch the generated setups under a folder to Simulated, run this editor console command (or headless with -ExecCmds):

SDF.MigrateToSimulatedPhysics [VerifyOnly] [Root=/Game/Path] [Exit]

Argument	Effect
VerifyOnly	Changes nothing; reports each setup’s state and any problem
Root=/Game/Path	Limits the scope to manifests under that folder. Without it, the plugin’s own Demo folder is used
Exit	Quits the editor with status 0 when there was no problem, 1 otherwise — for automation

• Scope — SDF-managed setups only: every authoring manifest under Root whose generated Blueprint is an SDF Actor. It is not a blind conversion of every placed Actor, and composite glass stays Static.
• What changes — the managed profile gets PhysicsMode = Simulated and the manifest records the policy, so regeneration keeps it. Ceramic and Glass Vessel profiles that had not already opted in receive the fall-damage defaults; settings you enabled yourself are kept. A mesh that cannot simulate gets its setup-owned SM_SDF_<Name>_Sim copy, as a new generation would.
• Existing drift is kept — a setup whose profile or preset had already drifted from its generation baseline is migrated without absorbing that drift.
• No runtime mutation — Blueprints and levels are not rewritten; the classic Actor re-roots itself at play.

Cost

• Chaos is not free at rest. A sleeping simulated body still costs physics-scene time. The plugin’s SDF.Perf.IntactPhysics.RestingBodiesCost automation test compared 100 sleeping Simulated props with the same 100 props held Static, median of 240 physics frames: 0.0283 ms versus 0.0177 ms per physics step. It was measured on one machine (AMD Ryzen 9 9950X, UE 5.8.2) in a headless test world, and times the physics scene step alone — not a full game frame, not awake bodies, and not the fall-tracking tick. Run the test on your own target hardware.
• Fall tracking ticks. While a profile enables fall damage, the destructible component enables its component tick to follow the fall. The tick stays off when fall damage is off, stops when a destruction hides the intact, and is re-armed by a reset. See Performance.

Limits

• Fall damage never applies to a Static intact, a profile with fall damage off, debris, or a contact that is not an eligible landing.
• The support wake is not a structural support graph.
• Physics transforms of intact props are not saved.
• Network replication is not implemented, as everywhere else in the plugin.
• No frame-rate, platform or multiplayer guarantee is made for simulated props; validate your own scenes.

Next

• Quick Start: a pot on a crate
• Destruction profiles: physics and fall damage
• Validation and regeneration
• Blueprint API