Skip to main content

Welcome

Welcome to the documentation of the Easy Static Mesh Deformation Component - a powerful and flexible solution for deforming static meshes in Unreal Engine. This component was developed from the ground up to close a gap that no standard solution within Unreal Engine or common third-party tools reliably covers so far: the easy, dynamic, runtime-capable deformation of static meshes - regardless of their physics behavior.

In contrast to other approaches, which usually rely on skeletal meshes, this component works with static meshes. This allows for simple integration and offers a high-performance way of displaying visible deformations in the game - for example in the event of vehicle collisions.

It is important to note that the component is not a substitute for complex systems such as Chaos Destruction or high-end soft body simulations. Hyper-realistic deformation and physics-driven destruction are not the focus. Rather, it offers a practical solution for visual feedback and controlled mesh modifications in scenarios where full destruction or complex simulations are not necessary or desired.

In this documentation, you will learn how to integrate, customize and efficiently use the component in your project - from simple application examples to advanced possibilities.

Technical details​

Features​

  • Custom GPU Renderer: Visible runtime deformation through the plugin's own render path instead of using ProceduralMesh or RealtimeMesh as the GPU rendering solution.
  • Plugin-Local Compute Shaders: GPU processing of vertex deformation and vertex-color damage.
  • GPU Deformation Subsystem: Central hit collection, ordered batching and scheduling across deformable components.
  • GPU LOD Support: Uses prepared LODs independently of RealtimeMeshComponent.
  • Reduced CPU Mesh Rebuild Overhead: Moves vertex deformation to the GPU rather than rebuilding a CPU mesh after each hit. Designed for large meshes, many hits and multiple vehicles; actual performance depends on the workload and hardware.
  • Directional Impact Deformation: Orients GPU dents using the impact direction.
  • Asymmetric Dents: Impact-aligned deformation areas with uneven compression and lateral movement.
  • Noise, Shear and Buckling: Configurable irregularities, glancing-impact response and local folds.
  • Damage Accumulation: Persistent section damage from repeated impacts.
  • Structural Weakening: Previously damaged sections can respond more strongly to subsequent hits.
  • Damage Zone Boxes: User-placed front, rear, side, roof, core or custom regions per deformation component, with configurable resistance and soft boundaries evaluated at the hit location.
  • Advanced Damage Debugging: Optional zone, damage, hit-status and output diagnostics.
  • Damage Snapshots: Compact replicated section-damage state, not full vertex-position checkpoints.
  • Delta Hit History: Ordered delta hits alongside the bounded retained history.
  • Client Relevancy Recovery: Native recovery from available damage state when clients join or vehicles become relevant again.
  • Budgeted Replay: Spreads component recovery across frames to reduce simultaneous replay spikes when many vehicles become relevant; it is not a guarantee of spike-free frames.
  • One drivable car included.
  • Highly performant at runtime.
  • Ultra Fast Setup.
  • Our Component supports skeletal and static mesh based vehicle systems.
  • Supports high and low poly meshes.
  • The meshes can have any shape. (see best practices)

Deformable Mesh Tool​

  • Simplified Mesh Preparation: Easily prepare your static meshes for deformation without time-consuming setup.
  • Vertex Grouping: Automatically sorts vertices into groups to enhance performance and reduce CPU load.
  • Data Management: Create and manage deformation data assets effortlessly, enabling seamless integration with your vehicle systems.

Code Modules​

Last updated on