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. 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 — Collision Compare

One preset. See every interaction in one view.

Pick a focus preset from the dropdown and add any number of others to compare against. Collision Compare shows you exactly how that preset resolves against each one, with both contributing responses visible per row.

  • Select a focus preset from the top dropdown
  • Add as many comparison presets as you need
  • Shows A→B and B→A raw responses alongside the resolved result per row
  • Overlap event warning appears on any pairing that resolves to Overlap
  • Click any cell in the Matrix to jump straight here with that pair pre-loaded
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.

Pick any Blueprint actor from the level or Content Browser. Actor Inspector lists every collision-capable component on that actor and shows exactly how each one interacts with a set of presets you choose.

  • Per-component rows: component name, assigned preset, collision enabled mode, object type
  • Interaction columns color-coded Block / Overlap / Ignore against your chosen target presets
  • Warns when a component is using a Custom profile instead of a named preset
  • Custom profile warnings are forwarded to the Validation tab automatically
  • Reveals multi-component actors (capsule, hitbox, weapon sphere) with inconsistent collision settings
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. The interaction table updates 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, same breakdown as the Matrix
  • Nothing writes to Project Settings until you hit Create Preset
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: duplicate presets, all-Ignore configs, silently-overridden Block responses, and CS_VISIBILITY_BLOCK surprises. Runs automatically on every refresh.

  • 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, a 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.

  • 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.3 April 2026
  • FIXVisual clarity and cleanliness
  • NEWSeperated Components by Actor for easier collision debugging
v1.2 March 2026
  • FIXActor Inspector now correctly finds components added in the Blueprint editor (SCS components were previously missed)
  • FIXPreset name column in Actor Inspector no longer overflows its cell — long names clip with an ellipsis
  • NEWUpdate notice in the Matrix tab toolbar when a newer version is available
v1.1 March 2026
  • NEWTrace channels are now visible in the Matrix and Actor Inspector panels
v1.0.0 — Initial Release March 2026
  • NEWColor-coded N×N Collision Matrix panel with Query/Physics toggle, hover tooltips, and click-to-compare
  • NEWCollision Compare: pick a focus preset and compare it against any number of others, with per-row A→B and B→A responses and overlap event warnings
  • NEWExperiment Mode: live preset designer with per-channel response editing and a full interaction preview before you commit anything
  • NEWValidation panel with 10 built-in rules grouped by Error / Warning / Info severity
  • 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, so you can drag it anywhere in the editor layout.

Update Checks

On each editor startup, Collision Commander makes a single request to paracosm.gg to check whether a newer version is available. If one is found, a notice appears in the Matrix tab toolbar. No personal data is sent. To opt out, go to Edit → Project Settings → Plugins → Collision Commander and disable Check for Updates.

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 Collision Compare panel and pre-populates it with the row preset as the focus 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 Collision Compare

What it's for

The Matrix gives you the full picture, but hunting down a specific pairing in a large grid gets old fast. Collision Compare gives you a focused view: pick one preset as your focus, then add however many others you want to compare against. One table, all the pairings you care about.

Good example: set your Projectile preset as the focus and add all your character and enemy presets. You'll see in one shot what it blocks, overlaps, or ignores across the board.

Building your compare list

  • Select a focus preset from the dropdown at the top
  • Add comparison presets to the list below it
  • Remove any entry with the × button on its row
  • Hit Refresh after a Project Settings change to re-evaluate

Reading a result row

Each row shows the comparison preset name, a color-coded BLOCK / OVERLAP / IGNORE badge, the A→B raw response, and the B→A raw response. Hover any row for the full tooltip.

Overlap event warning (⚠)

When a pairing resolves to OVERLAP, a warning icon appears on that row. This is a reminder that for BeginOverlap to actually fire at runtime, both actors need Generate Overlap Events enabled. A resolved OVERLAP result is necessary but not sufficient.

💡 Click any cell in the Matrix to jump straight here with that pair pre-loaded. That's the fastest way to drill into a specific interaction.
PANEL Actor Inspector

What it's for

A single actor can have a capsule, a skeletal mesh, a hitbox sphere, and a weapon trace component, each with its own preset and settings. Checking them individually in the Details panel is slow and gives you no combined view.

There's also a hidden problem worth knowing about: if you manually edit a component's collision responses in the Details panel without assigning a named preset, it gets set to Custom. That bypasses the preset system entirely and makes that component's collision harder to audit. The Actor Inspector calls that out explicitly.

How to use it

  • Pick a Blueprint actor from the level or the Content Browser
  • The panel lists every collision-capable component with its preset, enabled mode, and object type
  • Build a list of target presets or channels below, and the panel renders a per-component interaction table
  • Hover any cell for the tooltip with both contributing responses and the resolved result
  • Hit Refresh after loading a new actor or changing Project Settings

Custom preset warning

Any component using a Custom profile gets a ⚠ icon with a tooltip explaining the issue. These warnings are also forwarded to the Validation tab automatically when you refresh.

💡 Use Shift + Scroll to pan horizontally through the interaction table when you have a lot of target columns.
PANEL Experiment

What it's for

When you're thinking about adding a new preset or changing how an existing one behaves, there's no safe way to preview that in vanilla UE without actually editing Project Settings and then undoing if it's wrong. Experiment is a sandbox for that. Design a preset, tweak its channel responses, and see exactly how it would interact with everything else in your project before you commit to anything.

How to use it

  • Load an existing preset as a starting point, or start from scratch
  • Set a name, object type, collision enabled mode, and per-channel responses
  • The interaction table at the bottom updates live as you change values
  • Nothing is saved anywhere until you hit Create Preset

Committing

When you're happy with the result, press Create Preset. You'll get a confirmation dialog before anything writes. If you loaded from an existing preset and kept the same name, you'll be asked to confirm an overwrite. That's the only point in Collision Commander where data gets written back to Project Settings.

Visual indicator

When an experiment is in progress the panel shows a visible indicator so you always know you're in a modified state. Close without committing and everything is discarded.

⚠️ Creating a preset writes to your project's DefaultEngine.ini collision config, the same as doing it manually in Project Settings → Collision. Check the Matrix after committing to confirm the result looks right.
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.

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 answers 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 Create Preset in the Experiment panel.
  • → 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