CliperVolume

1. Quick Start

Drop a BP_CliperVolume into your level, scale it over part of your scene, and the geometry inside the volume disappears — with the cut cross-section filled live by a GPU pass, recomputed every frame. Before you can see the clip you need to patch your materials so they know about the volume.

1. Install Copy the plugin folder into your project's Plugins/ directory (or install it through Fab) and restart the editor.
2. Patch your materials Window → CliperVolume → Material Patcher…  Rescan Scene lists the materials used by primitives a registered volume would affect (scene-scoped — not a project-wide /Game scan). Patch Selected inserts MF_CliperClip into the material's Opacity Mask input, flipping Opaque → Masked where needed. Fully reversible per row via Unpatch Selected.
3. Read-only parents are mirrored, never modified Materials whose parent is read-only engine or marketplace content are not modified: the patcher mirrors the parent into /Game/Cliper/Patcher/ and re-points your instance at the mirror. Unpatch restores the original parent.
4. Place a volume Drag BP_CliperVolume (in /CliperVolume/Blueprints/) into your level. Scale it to cover the region you want hidden.
5. Done Geometry inside the volume is hidden and the cut cross-section fills with the volume's Cap Color (unlit, per-volume).

2. What Can Be Patched

Clipping works by inserting MF_CliperClip into a material's Opacity Mask pin (Opacity for translucent blend modes). A material can be clipped when that pin is actually live for it. The patcher asks Unreal itself rather than guessing, so the answer always matches what the engine will compile — unsupported rows are greyed out in the list with the reason and cannot be selected.

Supported

Substrate materials are supported and patch like any other on Opaque, Masked and AlphaComposite.

Not supported

3. Shapes

Each volume picks one shape via the Shape dropdown. Switch at any time — clipping and the cap update immediately.

Capsule half height

Half-height comes from the Capsule Half Height property (centimeters) times Scale.Z, clamped so it can never drop below the radius. The default Capsule Half Height of 100 gives a 200 cm pill at default scale.

Analytic caps

Sphere and capsule caps are computed analytically (ray-marched), so the cut edge is an exact curve, not a mesh approximation.

4. Cap Appearance

The cut cross-section is filled by a GPU pass every frame. All cap properties live under the volume's CapMesh category.

Patterns are world-scale on the cut face

Spacing, thickness and texture size are world centimeters measured on the cut face, aligned to the volume's own axes. The pattern is therefore locked to the geometry: it does not swim as the camera moves, rotating the volume rotates the hatch with the cut, and scaling the volume does not stretch the density.

Texture fill

Set Cap Fill to Texture, assign a Cap Texture, and set Texture Size (cm) to the world size you want one tile to cover. The texture's alpha blends it over Cap Color, so a masked texture acts as a custom hatch pattern of your own. Leave the texture's sRGB setting ON (the default) so its colors match what the Cap Color picker produces. A missing or unstreamed texture degrades to solid color rather than failing.

Sequencer

Volume properties carry the Interp specifier, so Sequencer discovers them as ordinary property tracks — no custom track types. Enabled, Cap Color, Pattern Color, Pattern Spacing (cm), Pattern Thickness (cm), Pattern Angle and Texture Size (cm) all animate, alongside the actor transform.

Six properties are not animatable — they are switches and asset slots, not curves: Shape, Capsule Half Height, Cap Fill, Cap Texture, Occlude Light and Debug Visualization. The filter lists are arrays and are likewise not animatable.

5. Filtering (Whitelist / Blacklist)

By default every volume affects every clippable primitive. To narrow that down, use the filter lists on each volume.

• Whitelist Actors — drag actors from the World Outliner into the list (or use the eyedropper). Only listed actors get clipped by this volume.
• Whitelist Tags — plain actor tags. Actors whose Tags array (Actor → Advanced → Tags) contains any of these names get clipped. Useful for tagging large sets without enumerating them. These are ordinary tag names, not Gameplay Tags — nothing needs registering first.
• Blacklist Actors / Blacklist Tags — exclude specific actors. Only consulted when the whitelist is empty.
• Whitelist / Blacklist Component Names — the same idea at component granularity, matched against the component's FName.

Precedence

The component-name lists run first, then the actor lists. Within each pair the whitelist wins — a non-empty whitelist makes the matching blacklist irrelevant. Filtering is per-volume, so different volumes can target different subsets. Empty whitelist + empty blacklist = affects everything.

6. Lighting

Occlude Light (per volume, default OFF) spawns hidden shadow / Lumen proxy meshes for every primitive the volume affects. The proxies sit at the source primitive's world transform and feed the lighting solver as if the clipped wall were still intact — direct sun stays blocked, indirect bounce still behaves, and no light leaks through the cut opening. The visible clip is unchanged; only the lighting sees the wall as solid.

Off by default because most archviz section views want light to spill in through the cut. Toggling reconciles the proxy set on the next tick — no manual rebuild. Static-mesh sources only; skeletal and dynamic-mesh sources are skipped with a verbose log line.

7. Project Settings

Edit → Project Settings → Plugins → CliperVolume. Eight settings, split over two categories: four under Performance, and four more under Performance → Plugin Content.

Group Mask CPD Slot (default 30)

Which Custom Primitive Data slot the per-primitive group mask is written to. Slot 0 collides too often with Quixel tints and colour drives, which is why the default is 30.

Skip Hidden-In-Game Meshes (default ON)

Components flagged hidden in game, or whose owner actor is hidden, are excluded from cap geometry so bounding / trigger helper meshes cannot produce ghost caps.

Max Primitive Half Extent (cm) (default 50000)

Skip primitives whose world half-extent on any axis exceeds this. Keeps sky spheres and world-scale helpers out of cap collection. 0 disables the filter.

Skip Foliage Primitives (default ON)

Foliage HISMs never register. Sectioning through grass produces visual noise, not a useful cut.

Performance → Plugin Content

The remaining four settings decide how much plugin-provided geometry enters the registry at all. They are a cost control, and nothing else — what keeps sky spheres, cloud domes and water out of your caps is the patched-material rule below, not these.

Plugin Actor Policy (default Register All)

How to treat primitives whose owning actor's class comes from a plugin rather than from project content or the engine. Register All Plugin Actors (Recommended) is the default and the recommendation: registration is cheap, and getting this wrong costs you geometry that silently refuses to clip. Skip Code Plugins Only and Skip All Plugin Actors exist for plugin-heavy scenes where registration cost is measurable. Project content under /Game and engine actor classes always register.

Always Register Plugins / Never Register Plugins

Per-plugin overrides, by plugin folder / .uplugin name. Both are checked before the policy, so an explicit list always beats the heuristic; a name in both lists registers.

Warn On Plugin Actor Skip (default ON)

Logs one warning per plugin the first time its actors are skipped, naming the plugin and the primitive count, so content that silently refuses to clip is diagnosable instead of mysterious.

Only patched meshes get capped

Clipping happens in the material, so a mesh whose material does not reference MF_CliperClip has no cut — and a cap over a cut that does not exist is a ghost cap. Cap collection therefore skips any mesh that is not patched, and such a mesh gets no cap at all.

This — not Plugin Actor Policy — is what keeps sky spheres, cloud domes, water bodies and weather meshes out of your caps: nobody patches those materials, so they fall out automatically, with no per-plugin allowlist to maintain. It also means the fix for “my mesh isn't capping” is always the same: patch it. The skip is not silent — the first mesh dropped for each material is named in the log at Warning level:

Not capping meshes using '/Game/M_Sky' — it does not reference MF_CliperClip …

Set r.CliperVolume.CapRequiresPatchedMaterial 0 to cap regardless (no rebuild needed). CliperVolume.DumpState reports clipFn= per material slot to audit what the rule is doing, and prints MISMATCH when it disagrees with the material's function list. The Material Patcher window always ignores this rule — it exists to find the meshes that are not patched yet.

8. Debug & Diagnostics

Toggle Debug Visualization on any volume to tint its wireframe cyan so it stands out in a busy scene, and to promote that volume's collection diagnostics from Verbose to Log so they appear in the Output Log without reconfiguring LogCliperVolume.

Console commands

r.CliperVolume.GpuCap 0        — kill switch for the whole cap pass; clipping is unaffected
r.CliperVolume.GpuCapDebug 1   — stencil parity heatmap (0 = off)
CliperVolume.DumpState         — one-shot report on the selected actor(s)
Log LogCliperVolume Verbose    — per-primitive registration / resolve logging

GpuCapDebug modes

• GpuCapDebug 1 — parity heatmap: green = a clean single-solid cut, cyan = nested solids, red/magenta = open or reversed-winding geometry.
• GpuCapDebug 2 — the cap's far-face depth, blue (far) to white (near).
• GpuCapDebug 3 — occlusion verdict where the stencil is set: green = the cap is visible, red = the scene occludes it. Use it when parity reads clean but the fill still looks wrong.

CliperVolume.DumpState

Select the mesh that misbehaves and run it. DumpState prints every link in the clip chain: each registered volume with its group bit and whether it holds a clip slot, then per primitive whether it is registered, the expected vs the actual group mask read back from live Custom Primitive Data (neither is visible in the details panel), and per material slot the patch state plus the authored and effective blend mode.

9. Limitations

Volume count

• Maximum 4 simultaneously clipping volumes. Enabled volumes past that are completely inert — they neither clip nor cap. An on-screen viewport error names them and a log warning is emitted; DumpState reports them as clipSlot=NO.
• Past 32 registered volumes the extras share group bit 31, so they can no longer be filtered apart from each other.

Cap appearance

• Caps are UNLIT by design — solid colour, procedural pattern or texture, never shaded. Arbitrary cap materials are not supported.
• The cut silhouette is drawn after the anti-aliasing resolve, so the cap outline is not anti-aliased. Pattern edges inside the cap are — except Checker, which has no AA and can shimmer at grazing angles. Prefer Hatch where that matters.
• Translucent surfaces in front of a cap: the opaque cap fill draws over them, so window-glass tint does not affect cap pixels behind it.
• Overlapping volumes: one volume's cap can appear inside another volume's cut region. Avoid overlapping capping volumes.

What can be capped

• Only patched meshes get capped. A mesh whose material does not reference MF_CliperClip has no cut, so it draws no cap at all — see Only patched meshes get capped.
• Only closed (watertight), correctly-wound static meshes are capped. Open shells, inside-out meshes and zero-thickness sheets still clip, but their cut draws no cap. Each is named once in the log with the reason.
• Skeletal and dynamic meshes clip but draw no cap.
• ISM / HISM instances clip but draw no cap. Their group mask uses per-instance custom data index 0 — if your project already stores its own data there (tint, random seed) it will be overwritten. A warning is logged when that is detected.
• Packaged builds: mesh verification needs CPU mesh data, which cooking strips. Enable Allow CPU Access on your meshes for editor-identical cap behaviour in a cooked build. Unverifiable meshes are capped as-is, so an open or inverted mesh the editor would have excluded can show parity artifacts there.

Which geometry the cap follows

• Nanite meshes: the cap is built from the mesh's fallback mesh, not its Nanite cluster geometry, so a heavily decimated fallback makes the cap outline deviate from the rendered cut. Raise the asset's Nanite fallback (Relative Error / Percent Triangles) to tighten the match. A Nanite asset with an empty fallback draws no cap at all. Both cases are named in the log, with the fallback-vs-Nanite triangle ratio.
• Why: the cap counts every surface crossing along the view ray to decide what is inside solid material. Nanite's visibility buffer only resolves the visible surface, so it cannot feed that count — a conventional triangle mesh has to be rasterized instead.
• LOD: cap parity always rasterizes LOD 0, the highest-detail conventional geometry the asset has, so a distance-LOD'd mesh's cap can be slightly more detailed than its visible cut (never less).
• Mixed-material meshes: parity counts every triangle of a closed mesh, including sections whose material is masked or translucent — geometrically solid beats visually transparent.
• World Position Offset: the clip cuts the displaced surface, but the cap follows the mesh's rest pose — WPO-animated meshes (flags, fabric) can show a cap that does not hug the displaced cut.
• Very large worlds: the material clip reads float32 volume data, so the clip boundary develops sub-centimeter wobble beyond roughly 10 km from the world origin. The cap itself is camera-relative and unaffected.

10. Troubleshooting

11. Asset Reference

Plugin content under /CliperVolume/ in the content browser:

MF_CliperClip holds the per-slot inside test and reads the group mask from the Custom Primitive Data slot authored into its CliperPrimMask parameter (per-instance custom data index 0 for ISM/HISM). It ships reading slot 30, matching the default setting. Editing it by hand is only needed if you move the Group Mask CPD Slot setting.

12. Support

Found a bug? File a repro at fab@eek.digital. Include:

• The volume shape and scale.
• Your engine version.
• A screenshot of the LogCliperVolume output with Verbose enabled (Log LogCliperVolume Verbose).
• For cap artifacts, a screenshot with r.CliperVolume.GpuCapDebug 1 active.

The same guide is available inside the editor at any time from Window → CliperVolume → Documentation. Every video on this page is also collected in the CliperVolume playlist.