Skip to content

Collision presets, channels, and responses

Collision is not one checkbox. A component has a collision profile, an object type, and a response table; the other component gets a vote too.

The one-minute version

  • Collision settings live on primitive components: capsules, boxes, spheres, static meshes, skeletal meshes, and similar geometry-bearing components. An actor can have several components with different collision.
  • A preset is a named bundle of settings. It usually sets Collision Enabled, Object Type, object-channel responses, and trace-channel responses.
  • Object Type answers: "what kind of thing is this component?" Common examples are WorldStatic, WorldDynamic, Pawn, and PhysicsBody.
  • Responses answer: "when this component meets that channel, should it Block, Overlap, or Ignore?"
  • Two physical objects resolve collision as a pair. If either side ignores, they ignore. If both sides block, they block. If one side overlaps while the other blocks or overlaps, the result is overlap, not blocking contact.
  • Overlap events need more than an Overlap response: both relevant components also need Generate Overlap Events enabled.
  • Hit events need blocking contact from movement, sweep, or physics. For physics-simulated collisions to raise Blueprint hit notifications, the component that wants the event needs Simulation Generates Hit Events.

What a preset actually sets

Open a component's Details panel and find Collision Presets. Choosing Pawn, Trigger, BlockAll, or NoCollision is not a magic gameplay label. It applies a profile to that component's collision body.

The useful beginner model is:

Collision Profile
    Collision Enabled: can this component be used for queries, physics, both,
                       or neither?
    Object Type:       what channel does this component present to other objects?
    Object Responses:  how this component answers other object types
    Trace Responses:   how this component answers traces such as Visibility
                       and Camera

The profile name is just the saved recipe. Once you change individual responses in the Details panel, the preset usually becomes Custom, meaning "this instance no longer exactly matches a named profile."

That distinction matters when you debug. "My mesh is set to Pawn" is incomplete. You need to know which component is set to Pawn, whether collision is enabled, and what that component says about the other side's channel.

flowchart LR
    Capsule[Player Capsule\nObject Type: Pawn] --> PawnResponses[Responses table]
    Floor[Floor Mesh\nObject Type: WorldStatic] --> FloorResponses[Responses table]
    PawnResponses -- response to WorldStatic --> PairResult[Pair result]
    FloorResponses -- response to Pawn --> PairResult

How the pair resolves

When two collision-enabled primitive components interact, Unreal checks each component's response to the other component's object type.

pseudocode of the collision decision - not engine source

function ResolveObjectPair(A, B):
    AResponse = A.response_to(B.object_type)
    BResponse = B.response_to(A.object_type)

    if AResponse is Ignore or BResponse is Ignore:
        return Ignore

    if AResponse is Block and BResponse is Block:
        return Block

    return Overlap

This is why the settings can look "half right" and still not do what you expected:

Component A says Component B says Result
Block B's type Block A's type Blocking contact
Overlap B's type Block A's type Overlap
Block B's type Overlap A's type Overlap
Overlap B's type Overlap A's type Overlap
Ignore B's type Anything Ignore
Anything Ignore A's type Ignore

Blocking stops movement or physics bodies from passing through each other when the movement path asks collision to block. Overlap lets the shapes interpenetrate and optionally reports begin/end notifications. Ignore pretends the pair did not matter for that interaction.

The "optionally" is important: Overlap response is not the same thing as overlap events. The pair can resolve to overlap, but Blueprint begin/end overlap events still require Generate Overlap Events on both components.

Object channels vs trace channels

An object channel labels a component. It is the answer to "what am I?" A player capsule is commonly Pawn; a wall is commonly WorldStatic; a moving platform is commonly WorldDynamic; a simulated crate may be PhysicsBody.

A trace channel labels a query. It is the answer to "what question is this ray, sweep, or overlap test asking?" The usual beginner examples are:

Trace channel Common beginner meaning
Visibility Can my interaction ray or line of sight see this thing?
Camera Should the camera boom or camera trace treat this as an obstacle?
Custom trace channel A project-specific question such as "weapon fire" or "interact."

The component stores responses for both. That means a wall can block the player capsule, block a Visibility trace, and ignore a custom Interact trace if that is the behavior your project needs.

Do not use object channels and trace channels as naming decoration. Pick them by the question:

Does an existing object need to collide with another object?
-> object type + object response

Is a query asking what it hits?
-> trace channel + trace response

Why things fall through, refuse to overlap, or hit the wrong part

Most first collision bugs are a mismatch between the mental model "the actor has collision" and the real model "this specific component has collision."

Common misses:

  1. Wrong component. A Character usually has a capsule and a skeletal mesh. Movement collision normally comes from the capsule. The mesh can have a different profile, often one that ignores things the capsule blocks.
  2. Collision Enabled excludes the kind of work you need. NoCollision does nothing. Query-only collision is for traces, sweeps, and overlaps. Physics-only collision is for simulation. Full collision can participate in both.
  3. Only one side is set to block. For blocking contact between two objects, both components must block each other's object types.
  4. Overlap events are disabled. A response of Overlap is not enough; both components need Generate Overlap Events if you want begin/end overlap notifications.
  5. A mesh asset has no useful collision shape. A Static Mesh Component can be set to block, but if the mesh asset has no simple collision and your query/physics setup needs one, the setting is not enough.
  6. A preset was changed globally. Project Settings can define or modify collision profiles and channels. Changing a shared profile can change many placed actors the next time they use that profile.

When debugging, print or inspect the pair:

Component A:
    Which component is it?
    Collision Enabled?
    Object Type?
    Response to B's Object Type?
    Generate Overlap Events?

Component B:
    Which component is it?
    Collision Enabled?
    Object Type?
    Response to A's Object Type?
    Generate Overlap Events?

If you cannot name both components, you are still debugging at the wrong altitude.

What collision settings do not do

Collision does not decide your gameplay result. It only supplies contact, overlap, trace, or physics information.

  • It does not apply damage. Use collision, overlap, hit, or trace results to decide whether to call an Apply Damage node.
  • It does not cast Other Actor into your player class. You still filter.
  • It does not pick the component you meant. The capsule, mesh, weapon hitbox, and trigger box each have their own settings.
  • It does not guarantee an event. Event generation has its own switches, timing, and movement path requirements.
  • It does not make network authority decisions. In multiplayer, the machine that runs the collision logic matters; replicated gameplay state still needs explicit server-owned logic.

The pattern everyone actually uses

For a trigger volume that opens a door:

Box Collision component on BP_DoorTrigger
    Collision Preset: Trigger
    Generate Overlap Events: true

Player Character Capsule
    Object Type: Pawn
    Generate Overlap Events: true
    Response to WorldDynamic or trigger's channel: Overlap

OnComponentBeginOverlap(Box)
-> Other Actor
-> Cast To BP_PlayerCharacter
-> Open Door

For a projectile that should hit walls and enemies:

Projectile collision sphere
    Object Type: custom Projectile or WorldDynamic
    Response to WorldStatic: Block
    Response to Pawn: Block or Overlap, depending on your damage path
    Ignore owner/instigator so it does not hit the shooter immediately

On hit or overlap
-> filter Other Actor
-> Apply Damage if this is a valid target
-> destroy projectile or spawn impact effect

For a camera boom:

Wall mesh
    Response to Camera trace channel: Block

Decorative grass or small pickups
    Response to Camera trace channel: Ignore

The rule of thumb: set presets for broad defaults, then inspect the exact pair when a specific interaction does not behave.

Lookalikes - which one do I want?

Setting or concept Use it for Watch out
Collision Preset A reusable bundle of collision settings. Changing one detailed response usually turns the instance into Custom.
Object Type What this component is to other objects. It is not your Blueprint class.
Object Response How this component reacts to another object's type. The other component also gets a vote.
Trace Response How this component answers a trace channel such as Visibility or Camera. A trace is not an actor; it has a channel, not an object type.
Generate Overlap Events Whether overlap begin/end notifications are generated. Both overlapping components need it.
Simulation Generates Hit Events Whether this component asks for hit notifications from physics simulation. Blocking can still happen without a Blueprint event.
Collision Enabled Whether this body participates in query collision, physics collision, both, or neither. Query-only and physics-only are different worlds.

Rule of thumb: profile sets the defaults, object type labels the component, responses decide pair behavior, event switches decide whether Blueprint hears about it.

Going deeper