Unreal Engine Plugin · UE 5.3+

Collision debugging,
finally visible.

Collision Commander gives you a single, always-live panel to see how every preset interacts with every other — color-coded, queryable, and ready for what-if experiments before you touch Project Settings.

UE 5.3 — 5.7 compatible Blueprint-only projects supported Windows · macOS · Linux (Editor) Read-only by default — never silently edits your project
vs
Pawn
Vehicle
WorldStatic
Trigger
Projectile
Pickup
Ragdoll
Pawn
BLOCK
BLOCK
OVERLAP
IGNORE
OVERLAP
BLOCK
Vehicle
BLOCK
BLOCK
IGNORE
BLOCK
IGNORE
BLOCK
WorldStatic
BLOCK
BLOCK
IGNORE
BLOCK
IGNORE
BLOCK
Trigger
OVERLAP
IGNORE
IGNORE
OVERLAP
IGNORE
IGNORE
Projectile
IGNORE
BLOCK
BLOCK
OVERLAP
IGNORE
BLOCK
Pickup
OVERLAP
IGNORE
IGNORE
IGNORE
IGNORE
IGNORE
Ragdoll
BLOCK
BLOCK
BLOCK
IGNORE
BLOCK
IGNORE

↑ Live color-coded matrix — every preset vs every preset, always current

Unreal's collision UI was
not built for debugging.

As projects grow, these five problems compound — and the standard tools give you no way to see them all at once.

Preset drift

Presets get edited in Project Settings without shared docs updating. No one notices until a late bug report arrives.

Channel budget exhaustion

UE supports 18 custom channels. Studios routinely hit this limit late in production with no visibility into which are actually used.

Query vs Physics confusion

Each channel has two independent responses. Treating them as one causes subtle gameplay bugs — triggers that don't fire, physics that passes through floors.

Overlap event mystery

Both actors need Generate Overlap Events enabled AND a non-Ignore response. When a trigger doesn't fire, finding which condition failed takes minutes.

Stale spreadsheets

Manual collision matrices become outdated within days. A wrong matrix is worse than none — team members trust it and waste time chasing phantom bugs.

Collision Commander solves all five.

Five panels. Always live. Every interaction visible at a glance.

Five panels. One tab.

Every feature lives in a single dockable editor tab under Window → Collision Commander. No jumping between screens.

Panel 01 — Matrix

Every preset interaction,
in one glance.

The Matrix panel is an N×N color-coded grid. Every preset pair resolves to BLOCK, OVERLAP, or IGNORE — live, always current, never a stale screenshot.

  • Toggle between Query responses (traces, overlaps) and Physics responses (rigid-body simulation) independently
  • Hover any cell to see both contributing responses — A→B and B→A — and the resolved result
  • Visual separator between UE built-in presets and your custom presets
  • Click any cell to jump straight to Collision Compare with that pair pre-loaded
  • Manual refresh button plus auto-refresh when Project Settings change
Collision Matrix panel in Unreal Editor
QUERY RESPONSES ● PHYSICS RESPONSES     [ Refresh ]
vs
Pawn
Vehicle
Static
Trigger
Proj.
Pawn
BLK
BLK
OVR
IGN
Vehicle
BLK
BLK
IGN
BLK
Static
BLK
BLK
IGN
BLK
Trigger
OVR
IGN
IGN
OVR
Proj.
IGN
BLK
BLK
OVR
Hover tooltip: Pawn → Vehicle: Block  |  Vehicle → Pawn: Block  ·  Resolved: BLOCK

Panel 02 — Actor Compare

One primary. Every actor it touches.

Pick a primary actor and drag in a list of others to compare against. Actor Compare evaluates every collision-capable component on each actor and shows how it resolves against the primary — all in one view.

  • Drag actors from the level viewport or Content Browser directly into the compare list
  • Or use the import button to pick an actor asset from the Content Browser
  • Compares each collision-capable component against all actors in the list
  • Shows raw A→B and B→A responses alongside the resolved result per row
  • Clicking a Matrix cell pre-populates the panel automatically — no manual setup
Collision Compare panel in Unreal Editor
Primary Preset: DR_PlayerCharacterCapsule    [ + Add Preset ]
Pawn
(Pawn)
BLOCK →B: Block →A: Block
DR_ItemPickup
(WorldDynamic)
OVERLAP →B: Overlap →A: Overlap
DR_Stunned_NonBlocking
(Pawn)
IGNORE →B: Block →A: Ignore
DR_HitEventOnly
(WorldDynamic)
OVERLAP →B: Overlap →A: Block

Panel 03 — Actor Inspector

See the full collision surface
of any actor in your project.

Select one or more Blueprint actors from the content browser. Actor Inspector enumerates every collision-capable component on each actor and shows you exactly how they interact with a configurable set of presets or channels.

  • Browse and select any Blueprint actor from a searchable content browser panel
  • Compare multiple actors side-by-side in the same table — grouped by actor
  • Per-component rows: component name, assigned preset, collision enabled mode, object type
  • Interaction columns color-coded Block / Overlap / Ignore against your chosen target presets
  • Reveals when actors with multiple components (capsule, hitbox, weapon sphere) have inconsistent collision across components
Actor Inspector panel in Unreal Editor
ACTOR INSPECTOR   3 actors   [ + Add Actor ]
Component Preset En. DR_Player… DR_Enemy… UI
BP_Kip_V3
CollisionCylinder DR_PlayerChar… Q+P BLK BLK OVR
BP_Boss_Lola
CollisionCylinder DR_EnemyChar… Q+P BLK BLK OVR
HeadCollisionComponent DR_EnemyChar… Q+P BLK BLK OVR

Panel 04 — Experiment

Design a new preset and see
every interaction before you commit.

The Experiment panel is a live preset designer. Set a name, object type, collision mode, and per-channel responses — then watch the interaction table update instantly, showing how your new preset would behave against every existing one. Hit Create Preset when you're satisfied.

  • Load from existing preset as a starting point, or begin from scratch
  • Set Game Channel and Engine Channel responses independently per Query / Physics
  • Live table shows the resolved interaction (Block / Overlap / Ignore) against all current presets
  • Grouped by built-in and custom presets — the same breakdown as the Matrix
  • Commit via Create Preset — nothing writes to Project Settings until you decide
Experiment panel in Unreal Editor
Load from existing: — New Preset —
Preset Name:SomeNewCollisionPreset Object Type:WorldDynamic Collision Enabled:Query and Physics
CHANNEL RESPONSES
WorldStatic Q: Block P: Block
Pawn Q: Overlap P: Ignore
HOW IT INTERACTS WITH EXISTING PRESETS
BlockAllWorldStaticBLK PawnPawnOVR TriggerWorldDynamicOVR
Create Preset

Panel 05 — Validation

Surface misconfigurations
before they become bugs.

Ten built-in rules catch common collision mistakes — from duplicate presets and all-Ignore configs to silently-overridden Block responses and CS_VISIBILITY_BLOCK surprises. Validation runs on demand via Run Validation.

  • Grouped by Warning and Info severity with counts in the section header
  • Each result shows the rule ID, a plain-language description, and a suggested fix
  • Double-click any result to navigate to the relevant panel
  • CS_VISIBILITY_BLOCK calls out presets that block the Visibility trace channel — common source of AI sight line bugs
  • CS_PRESET_DUPLICATE flags presets with identical response arrays that can be consolidated
Validation panel in Unreal Editor
VALIDATION RESULTS   9 Warnings   10 Info
WARN CS_PRESET_DUPLICATE
Presets 'NoCollision' and 'DR_DeadCharacter' have identical ObjectType and responses. Consolidate or document why both exist.
WARN CS_PRESET_ALL_IGNORE
Preset 'DR_AestheticMeshOnly' responds Ignore to every channel. Likely misconfiguration.
WARN CS_STATIC_IGNORED
Preset 'DR_VisibilityOverlap' (WorldDynamic) ignores WorldStatic. Dynamic actor may fall through floor.
INFO CS_VISIBILITY_BLOCK
Preset 'BlockAll' blocks the Visibility channel. Confirm intent — affects AI sight, shooting traces.

Planned updates

Collision Commander ships as a complete tool today. These updates are planned post-launch based on user requests and our own production use.

✓ Shipped

All five panels

Matrix, Collision Compare, Actor Inspector, Experiment, and Validation — all live at launch.

  • Color-coded N×N matrix (Query + Physics)
  • Collision Compare with per-preset interaction rows
  • Actor Inspector with multi-actor component table
  • Experiment preset designer with live interaction preview
  • Validation with 10 built-in rules

Planned

Excel Export

Export the full collision state to a formatted 5-sheet .xlsx workbook for QA, leads, or code review. Triggered via toolbar button, no auto-saves.

  • Sheet 1: Preset definitions with per-channel responses
  • Sheet 2: Full N×N collision matrix
  • Sheet 3: Current Collision Compare session
  • Sheet 4: Validation report at export time
  • Sheet 5: Snapshot metadata (project, engine version, timestamp)

Planned

Runtime Collision Tracker

Track a single actor during Play-In-Editor and log every runtime collision state change — including calls made via Blueprint or C++ at runtime.

  • Poll-based tracking (10–30 Hz) during PIE
  • Timestamped change log per component
  • Record / Clear controls
  • Captures SetCollisionEnabled and SetCollisionResponseToChannel

Considering

Have a feature request?

All post-launch directions are shaped by what buyers ask for. If you need something not on this list, reach out.

  • Email support@paracosm.gg with subject: Feature Request

Patch Notes

v1.0.0 — Initial Release March 2026
  • NEWColor-coded N×N Collision Matrix panel with Query/Physics toggle, hover tooltips, and click-to-compare
  • NEWActor Compare panel — drag or import actors from the level or Content Browser; evaluates every collision-capable component against the comparison list with overlap event warnings
  • NEWExperiment Mode — per-channel response overrides with live matrix diff highlighting and explicit Commit flow
  • NEWValidation panel with 10 built-in rules grouped by Error / Warning / Info severity
  • NEWExcel Export — 5-sheet workbook snapshot via toolbar button, no auto-save, no formulas
  • NEWUE 5.3 – 5.7 compatibility, Blueprint-only project support, Windows / macOS / Linux editor

User Guide

Everything you need to use Collision Commander effectively. Download as PDF ↓

SETUP Getting Started

Installation

Install Collision Commander from your Fab.com library via the Epic Games Launcher. Enable it in your project under Edit → Plugins → search "Collision Commander" → Enable → restart the editor.

A C++ project (or stub module) is required for the plugin to compile. Blueprint-only projects are fully supported once this prerequisite is met — the plugin itself adds no C++ requirement to your project code.

Opening the Panel

Go to Window → Collision Commander in the main menu bar, or click the toolbar button added to the Level Editor toolbar. The panel is a dockable Nomad Tab — you can drag it anywhere in the editor layout.

Understanding Query vs Physics

Unreal Engine stores two independent sets of collision responses per preset. The toggle at the top right of most panels controls which set you're viewing:

  • Query — governs line traces, shape sweeps, and overlap events. Use this when diagnosing trigger volumes, hit detection, and line-of-sight checks.
  • Physics — governs rigid-body simulation. Use this when diagnosing whether objects physically push against each other, land on surfaces, or pass through geometry.
💡 A preset can Block a channel for physics (objects collide) while Ignoring it for queries (traces pass through). This is intentional UE design — Collision Commander is the fastest way to confirm which mode is configured how.

How Pairwise Resolution Works

UE resolves interactions using the minimum of both actors' responses:

result = min(A's response to B's ObjectType, B's response to A's ObjectType)

Where Ignore (0) < Overlap (1) < Block (2). If either side is Ignore, the result is always Ignore regardless of the other side. Collision Commander applies this rule for every cell in the matrix.

PANEL Collision Matrix

What it shows

An N×N grid where every row is a preset (Actor A) and every column is a preset (Actor B). Each cell shows the resolved interaction between that pair using UE's pairwise resolution rule.

BLOCK — physical or query contact occurs
OVERLAP — overlap event fires (if enabled)
IGNORE — no interaction
Diagonal — same preset vs itself

Visual separator

A thick border divides UE's 14 built-in presets (top-left block) from your custom presets (bottom-right block). This helps you spot when a custom preset is misconfigured relative to the built-ins.

Hover tooltip

Hovering any non-diagonal cell shows:

  • PresetA's response to PresetB's Object Type channel
  • PresetB's response to PresetA's Object Type channel
  • The resolved result (the minimum of both)

Clicking a cell

Left-clicking any non-diagonal cell switches to the Actor Compare panel and pre-populates it with the row preset as Primary and the column preset as the first comparison entry.

Refreshing

Click the Refresh button to re-read UCollisionProfile and rebuild the matrix. The matrix also auto-refreshes when Project Settings change during your editor session.

PANEL Actor Compare

Purpose

Actor Compare lets you pick a primary actor and compare it against a list of other actors — all in one view. For each actor you add, the panel evaluates every collision-capable component on that actor and shows how it resolves against the primary, so you can see the full collision surface without jumping between presets.

A practical example: set your Projectile actor as the primary, then add a range of enemy and player actor types. You'll see in one glance exactly what the projectile blocks, overlaps, or ignores across your entire cast — and catch any mismatches before they show up in play.

Adding actors to the compare list

  • Click and drag any actor from the level viewport or Content Browser directly into the compare list panel
  • Click the import button (folder icon) to browse and select an actor asset from the Content Browser
  • Both methods support adding multiple actors — build the list as large as you need
  • Remove any entry using the × button on its row
  • Use the Refresh button to re-evaluate after a Project Settings change

Reading a result row

Each row shows: the comparison preset name, a color-coded BLOCK / OVERLAP / IGNORE badge, A→B raw response, B→A raw response, and an optional overlap event warning.

Overlap event warning (⚠)

When a resolved result is OVERLAP, a warning indicator appears. This is a reminder that for the BeginOverlap event to fire at runtime, both actors must have Generate Overlap Events enabled on their collision component — not just one. A resolved OVERLAP result is a necessary but not sufficient condition for the event to fire.

💡 The fastest way to start is to click any cell in the Matrix panel — the two presets are automatically loaded as Primary and Compare entry. From there, drag in more actors from the level to build out your list instantly.
PANEL Experiment Mode

What it is

Experiment Mode is a what-if sandbox. You temporarily override channel response values and the matrix updates live to show how those changes would affect all interactions — without touching your actual Project Settings.

Active experiment indicator

When any override is set, a prominent banner at the top of the Experiment panel reads "Experiment Mode Active". The Matrix panel also reflects this state. This visual indicator ensures you never confuse experimental values with your real project state.

Setting overrides

Each channel has Query and Physics override dropdowns. Set either to Ignore, Overlap, or Block. The matrix updates immediately — no evaluate button needed.

Diff highlighting

Cells in the Matrix that differ from the project baseline are highlighted with a distinct border, making it easy to see at a glance exactly what your override changes.

Committing an experiment

When you're satisfied with an experiment, press Commit to Project Settings. This writes your overrides to the project's collision configuration. This is the only place in Collision Commander where data is written back — and it requires an explicit button press. There is no auto-commit.

Resetting

Press Reset to clear all overrides instantly and return the matrix to its baseline state. Closing the panel without committing also discards all overrides.

⚠️ Committing an experiment modifies your project's DefaultEngine.ini collision configuration — the same change you would make manually in Project Settings → Collision. Always verify the matrix post-commit.
PANEL Validation

When it runs

Validation runs automatically every time you refresh the matrix and every time you commit an experiment. Results are shown in the Validation panel and summarised as a badge count on the toolbar.

Severity levels

  • Error — configuration that will likely cause bugs or is known to cause incorrect behaviour. Fix before shipping.
  • Warning — potential misconfiguration worth reviewing. May be intentional.
  • Info — non-critical observation, such as unused channels. Worth knowing, not urgent.

All 10 validation rules

  • CS_CHAN_BUDGET_WARN — 14+ of 18 custom channel slots in use. Audit before adding more.
  • CS_CHAN_BUDGET_CRIT — 17+ slots used. Consolidate immediately — you're near the limit.
  • CS_CHAN_UNUSED — Custom channel defined but no preset responds non-Ignore. Remove or reserve.
  • CS_PRESET_DUPLICATE — Two presets with identical ObjectType and response arrays. Consolidate.
  • CS_PRESET_ALL_IGNORE — A preset ignores every channel. Likely misconfiguration.
  • CS_STATIC_IGNORED — Dynamic ObjectType preset ignores WorldStatic. Actor will fall through the floor.
  • CS_OVERLAP_MISMATCH — A wants to Block B, but B ignores A. The Block is silently overridden to Ignore.
  • CS_NAME_CONFLICT — Custom preset name matches a UE built-in exactly. Rename to avoid lookup ambiguity.
  • CS_OVERLAP_EVENT — Two presets resolve to Overlap but Generate Overlap Events may not be enabled.
  • CS_VISIBILITY_BLOCK — A preset blocks the Visibility channel. This affects AI sight, shooting traces, and camera.
💡 Individual rules can be toggled on or off in the plugin settings (Edit → Project Settings → Collision Commander) if a rule produces false positives for your project's intentional configuration.
FEATURE Excel Export

Triggering an export

Click Export… in the Collision Commander toolbar. A file-save dialog opens — choose a location and filename. The plugin writes a .xlsx workbook and shows a confirmation toast. There is no auto-save.

What's in the workbook

  • Sheet 1 — Preset Definitions: Every preset with its Object Type, Collision Enabled state, and per-channel Query responses. Blue rows for UE built-ins, green rows for custom presets.
  • Sheet 2 — Collision Matrix: The full N×N grid with BLOCK / OVERLAP / IGNORE fills and the built-in / custom separator border.
  • Sheet 3 — Actor Compare: Your current Actor Compare session, if one is active. "No active comparison" note otherwise.
  • Sheet 4 — Validation Report: All active validation warnings at export time, with severity colors, rule IDs, and suggested fixes.
  • Sheet 5 — Snapshot Info: Project name, engine version, export timestamp, plugin version, and preset / channel counts.

Compatibility

The workbook uses no formulas — all values are pre-computed at export time. Compatible with Microsoft Excel 2013+, LibreOffice Calc, and Google Sheets.

Support

Email Support

For help, bug reports, and feature requests, email us directly. Using the subject line format below helps us respond faster.

  • Help Something isn't working as expected
  • Bug Report Reproducible crash or incorrect behaviour
  • Feature Request A capability you'd like to see added
  • License Studio licensing or billing questions

Before You Email

A few things that usually answer common questions quickly:

  • Read the documentation above — the Query vs Physics toggle is the answer to a surprising number of "why isn't this working" questions.
  • Check the Validation panel — it may already be flagging the exact misconfiguration you're investigating.
  • The plugin is read-only by default. It never modifies your project unless you explicitly press Commit in Experiment Mode.
  • Blueprint-only project support is built in — no C++ code needed in your project beyond the minimal stub module.

Simple pricing

All updates included. Available on Fab.com under the standard Engine Plugin license.

Solo

$20

Single seat. Binary license.

  • All five panels included
  • All future updates
  • UE 5.3 – 5.7 support
  • Windows, macOS, Linux
  • Email support
Buy on Fab