Souls Destruction Framework Documentation

What Souls Destruction Framework is

Souls Destruction Framework (SDF) is a destruction plugin for Unreal Engine made of two layers that work together but remain usable separately:

• an editor authoring pipeline that turns an existing Static Mesh into a complete destructible setup without modifying the source asset;
• a runtime framework that evaluates incoming hits, decides whether an object reacts, takes damage or breaks, and dispatches the resulting presentation within explicit budgets.

The plugin ships three modules: SoulsDestructionRuntime (the core, shipped with the game), SoulsDestructionDemo (the playable showcase — a Runtime module you can strip from your own builds) and SoulsDestructionEditor (editor only). The core runtime module has no dependency on the demo or editor modules.

What problems it solves

Authoring a prop library is repetitive. Fracturing a mesh, assigning an interior material, building a data asset and wiring an Actor is a long manual sequence for every crate, pot and barricade. SDF performs that sequence from a preset, validates the output and can run it across a whole selection.

Regenerating a setup is risky. Re-running a fracture usually means new asset paths, broken references or silently overwritten manual work. SDF records ownership of everything it generates, detects drift, backs up packages before replacing them, keeps object paths stable and rolls back on failure.

Destruction has to stay integrated but not intrusive. A souls-like already has a combat system, a roll, projectiles and an audio pipeline. SDF accepts hits as plain data payloads and emits presentation requests through delegates, so the existing systems keep ownership of gameplay.

Destruction has to stay bounded. Physics representations, presentation events, audio and VFX are each capped, and a Geometry Collection that cannot be activated falls back to a lightweight path instead of failing silently.

Editor authoring versus runtime

	Editor authoring	Runtime framework
Module	SoulsDestructionEditor	SoulsDestructionRuntime
Runs	In the Unreal Editor only	In editor and packaged builds
Produces	Geometry Collection, destruction profile, optional Blueprint, authoring manifest, and a simulation mesh copy when needed	Destruction results, debris, audio/VFX/decal requests, intact physics and fall damage
Entry point	Content Browser context menu: Souls Destruction	USDFDestructibleComponent
Required?	No — profiles can be authored by hand	Yes, to destroy anything at runtime

Architecture overview

Static Mesh
    ↓
SDF Authoring
    ↓
Geometry Collection (or Glass setup) + Runtime Profile
    ↓
SDF Destructible Component
    ↓
Gameplay Hit
    ↓
Geometry Collection / Swap-and-Scatter / runtime Glass fracture

The runtime path in more detail:

Gameplay System
     ↓
FSDFDestructionHit
     ↓
USDFDestructibleComponent
     ↓
Profile Evaluation
     ↓
FSDFDestructionResult
     ↓
Geometry Collection / Swap-and-Scatter / Glass

Supported workflows

• Generate a destructible from a Static Mesh with one of the ten shipped presets — the structure-aware wood family, Ceramic, Stone, the runtime-fractured Glass pane, Glass Vessel and Generic.
• Split a multi-material glass prop (a stained glass window) into an unbreakable frame and independent panes, automatically at commit.
• Set the prop’s hit points directly in the authoring window — a positive Max Health publishes a ready-to-play multi-hit profile.
• Let generated props rest on their support and fall when it breaks, with optional height-based fall damage — a pot can break on landing while a statue survives by default. See Intact physics and fall damage.
• Generate destructibles for a full selection of meshes in one batch.
• Validate an existing generated setup without modifying anything.
• Regenerate a setup after the source mesh or the preset changed.
• Change how an existing destructible breaks — preset, density, wood cuts, collision shape, health — with Modify Destructible: it is rebuilt in place and every placed copy updates.
• Attach USDFDestructibleComponent to your own Actor and author a profile by hand.
• Drive destruction from your own melee, movement, projectile or ability code.
• Route all audio and VFX to your own middleware and disable the built-in playback.
• Open the shipped showcase map (/SoulsDestructionFramework/Demo/Maps/L_SDF_Showcase) to see and hear every family’s break before authoring your own props.

Supported engine versions

Engine	Status
Unreal Engine 5.7	Verified on 5.7.4, Win64 — its own edition
Unreal Engine 5.8	Verified on 5.8.2, Win64 — its own edition

Both editions are prepared as source-only packages, which are compiled with Unreal’s supported Visual Studio C++ toolchain. No other engine version is claimed — see Installation.

Blueprint and C++ support

Every runtime type the framework expects gameplay code to use is exposed to Blueprint: USDFDestructibleComponent, USDFDestructionProfile, USDFDestructionSubsystem, the three hit sender components, and all the payload and result structures. C++ projects can include the same public headers directly.

The editor authoring services are C++ facades intended for the plugin’s own UI and for automation; they are not part of the runtime API.

Intended game genres

SDF was built inside a souls-like project and is aimed at:

• souls-likes and action RPGs;
• dungeon crawlers;
• melee-focused third-person games;
• any project with prop-level environmental destruction — crates, pots, barricades, statues.

Where to go next

• Quick Start — first destructible in a few minutes.
• Installation — requirements and setup.
• Runtime overview — the runtime contract.
• Blueprint API — generated from the shipped headers.