Walking in a 3DGS Scene: Collision Support

LCC4Unreal supports dynamic collision data loading, so characters can move and interact freely in the 3DGS world.

Prerequisites

Collision relies on the collision file shipped with the data, and the requirements differ per format:

For .lcc and .lcc2, the plugin checks the collision file shipped with the data in the order collision.lci → collision.bin → data/mesh/*.ply, and prints a warning and disables collision when none of them exist.

Single-file formats (.sog / .spz / .ply) carry no collision data of their own. The Pro edition can automatically derive a collision mesh from the Gaussians, see Automatic Collision Generation for Single-file Models; the free edition requires building collision yourself.

After loading data, use HaveValidCollisionData() to confirm whether the current data contains usable collision data.

Note: collision.lci requires export from LCC Studio v1.6.1 or above; data exported by earlier versions uses collision.bin.

Loading Mechanism

Collision data is stored in spatial chunks just like render data. The plugin does not load all collision at once: it loads only the chunks within a certain range around the camera and swaps them in and out dynamically as the camera moves.

Camera position changes
      │
      ▼
Compute the set of collision chunks that should be loaded in range
      │
      ▼
Compare with the previous set ── same ──▶ skip, do nothing
      │ different
      ▼
Load the new chunks → hand them to the physics system for baking → generate collision bodies

A few implementation points:

• The load range is controlled by Max Load Collision Distance(m), and areas beyond that distance have no collision
• The first load is synchronous, which prevents the character from falling through the ground before collision is ready; every later update is asynchronous and does not block the main thread
• Updates are throttled, so collision is not rebuilt every frame while the camera moves continuously
• Updates are skipped when the visible chunk set is unchanged, so small movements in place do not trigger a rebuild
• Only the main camera is used for the calculation, and SceneCapture does not take part in collision loading

Advantages

• Memory usage depends only on the load range, not on the total data size, so collision works even for large scenes
• The number of collision bodies the physics system has to process stays under control and does not slow physics down as the scene grows

Costs and Mitigations

Loading All Collision at Once

Most of the costs above come from swapping chunks in and out at runtime. When the scene size is limited and memory allows, raise Max Load Collision Distance(m) high enough to cover the whole scene, so all collision is built in one pass while the data loads.

Runtime swapping of collision chunks then disappears, and none of the earlier issues occur: falling through the ground, missing collision after teleporting, stutter while moving, and repeated navigation rebuilds. This is especially recommended when using the navigation system.

The cost is a longer load time at startup and a fixed memory usage equal to the collision of the whole scene. To judge whether it is feasible, check Collision Data Usage in stat xgrids and confirm the memory usage after a full load is acceptable.

Enabling

LCCComponent->SetLCCCollisionEnable(true);

Or tick bEnableCollision in the Details panel.

Enabling LCC collision in the Details panel

Dynamic collision of a character in an LCC scene

Verification

Use the view mode settings and select player collision or visibility collision to observe whether collision is enabled.

Verifying collision bodies with the player collision or visibility collision mode

Related Properties

Configuring the collision enable state and the maximum load distance

Automatic Collision Generation for Single-file Models

A Pro edition feature. Single-file models (.ply / .spz / .sog) carry no collision data of their own. The plugin derives a collision mesh from the Gaussians themselves, caches it as <name>.collision.ply next to the model, and then loads and reuses it through the existing PLY collision path.

This is a Pro edition feature and only generates after an App Key is registered; see Editions and Licensing. Without a license no collision mesh is generated, and you need to build collision yourself as described in Manual Approach Without Automatic Generation.

Steps

1. Tick bEnableCollision in the LCC Actor panel.
2. Load a single-file model (.ply / .spz / .sog).
3. The first load enters the Generating state and builds the collision mesh on the spot. This takes from a few seconds to a few minutes depending on the data size; once finished it moves to Loaded and writes <name>.collision.ply next to the model.
4. On a later load of the same model, if the cache file exists it goes straight to Loaded and skips generation.

With collision enabled, a prompt appears in the bottom-right corner on the first load of a single-file model while the collision mesh is being generated

The generation and collision state can be queried with GetCollisionState() or by listening to the OnCollisionStateChanged event; for the values see ULCCComponentBase - State Query.

Tip: to avoid generation at runtime, distribute or package the generated <name>.collision.ply together with the model; at runtime the cache is reused directly once detected.

Tip: there is no built-in UI prompt when collision is generated in a packaged game. To tell the player "generating collision", listen for the Generating state of OnCollisionStateChanged and show it yourself.

Tip: a failed generation moves to the Failed state; the specific cause is in the Output Log, and toggling collision off and on retries it. To re-test the generation process, delete the .collision.ply cache file next to the model first.

Manual Approach Without Automatic Generation

To fully control the collision shape, or when the data is not suited to derivation, you can leave automatic generation off and build collision in the scene yourself:

• Blocking Volume: use engine blocking volumes to build the ground, walls, and other areas that need to block. Suited to regular shapes and the cheapest option
• Approximate mesh: place a mesh that matches the 3DGS shape and enable its collision. Suited to scenes with complex shapes. This mesh can reuse the proxy mesh by changing its collision preset to block

Neither manual approach involves the LCC collision loading mechanism, so they are unaffected by CollisionLoadMaxDistance and are not swapped in and out as the camera moves.

Clip Collision Regions

Collision can be clipped together with clipping volumes and section planes, so the collision range matches the rendered image. A clipping volume affects rendering only by default: the clipped-away area disappears from the image but collision remains, and a character runs into an invisible wall. With Clip Collision enabled, collision is removed in the clipped region as well.

Steps

1. Add and configure a clipping volume or section plane on the LCC Actor as described in Scene Editing, and confirm the rendered image is clipped as expected.
2. Tick Enable Collision (bEnableCollision) in the LCC Actor panel.
3. Tick Clip Collision in the panel; collision is then clipped by the clipping volume and no collision bodies are generated in the clipped-away area.

The images below use the visibility collision view mode to compare the collision wireframe before and after enabling Clip Collision. When off, collision covers the full area:

Clip Collision unchecked: the collision wireframe covers the full area

When on, the collision inside the clipping volume is clipped away as well, consistent with the rendering:

Clip Collision checked: the collision inside the clipped region is clipped away as well

Tip: Clip Collision requires collision to be enabled first, and it also applies to collision automatically generated for single-file models.

Collision State Query and Events

You can query the current collision state, or listen for collision state changes, for logic such as "spawn the character only when collision is ready" or "show progress while generating":

• GetCollisionState() returns the current state: NoCollision (off or no model) / Generating (a single-file model is generating its collision mesh) / Loading (collision near the camera is loading/cooking) / Loaded (collision near the camera is in place) / Failed (cannot be provided).
• The OnCollisionStateChanged event is dispatched when the state changes, so you can enable character movement only after Loaded, or show a prompt while Generating.

For the full interface and usage conventions, see ULCCComponentBase - State Query.

Tip: Loaded means collision near the camera is in place, not that the whole model has collision — collision keeps streaming as the camera moves. For "no falling through the ground underfoot", waiting for Loaded is enough; for collision in the distance, raise the load distance.

Notes

• Once collision is enabled, the LineTrace of the Unreal Engine itself can be used for ray tests against collision bodies, and the test range is limited by the load range as well
• The memory used by collision data can be viewed in Collision Data Usage of stat xgrids, the update cost in Update Collision, and the meaning of the items in Performance Parameters