Skip to content

Set Collision Enabled / Response / Profile Name

At a glance

Lives in: Blueprint API / Collision - Target: usually a PrimitiveComponent; Set Actor Enable Collision targets an Actor - Returns: no value - Fails by: changing nothing useful, silently, or changing a different collision layer than the one you meant - Official docs: Set Collision Enabled, Set Collision Response to Channel, Set Collision Profile Name, and Set Actor Enable Collision

The one-minute version

  • Collision is decided mostly by PrimitiveComponent settings, not by the actor's visibility or class name.
  • Set Collision Enabled changes whether one component participates in queries, physics, both, or neither.
  • Set Collision Response to Channel changes one response entry on one component, such as "Pawn overlaps me now" or "Visibility traces ignore me."
  • Set Collision Profile Name applies a named preset and overwrites the component's custom collision settings with that profile.
  • Set Actor Enable Collision is an actor-level gate. It does not rewrite all component presets; it turns actor collision checking on or off while the component settings still exist underneath.
  • Hiding an actor does not disable collision. Destroying an actor is different again. Pick the node that matches the gameplay rule.

What it actually does

Collision is not one switch. A beginner usually touches four layers:

Actor
  bActorEnableCollision gate
  StaticMeshComponent / CapsuleComponent / BoxComponent / SkeletalMeshComponent
    Collision Enabled mode
    Object Type
    Response table: Block / Overlap / Ignore per channel
    Generate Overlap Events
    Collision Profile name

Most gameplay collision lives on PrimitiveComponent subclasses: capsule components, static mesh components, skeletal mesh components, sphere collision, box collision, and similar shapes. Those components have the body/query data that traces, overlaps, movement sweeps, and physics simulation use.

Set Collision Enabled

Set Collision Enabled changes what kind of collision representation the component has.

Mode Beginner meaning
NoCollision No query collision and no physics collision. Traces, sweeps, overlaps, and physics simulation should not use this component as a collider.
QueryOnly Used by spatial queries: traces, sweeps, overlaps, and many movement checks. Not used as a simulating physics body.
PhysicsOnly Used for physics simulation/contact, not normal query traces or overlaps.
QueryAndPhysics Used for both query collision and physics simulation.
ProbeOnly / QueryAndProbe Newer physics-probe modes for contact data without normal physical reaction. Beginners usually ignore these unless a system specifically asks for them.

If a pickup is collected and should stop blocking or overlapping while it waits to respawn, disabling the pickup's collision component is the important part:

Pickup collected
-> StaticMesh Set Visibility false
-> CollisionComponent Set Collision Enabled NoCollision
-> Set Timer by Event RespawnPickup

RespawnPickup
-> StaticMesh Set Visibility true
-> CollisionComponent Set Collision Enabled QueryOnly

Set Collision Response to Channel

Set Collision Response to Channel changes one response in the component's response table:

Component response table
    Pawn:       Block
    Visibility: Ignore
    Camera:     Ignore
    WeaponTrace: Block

Changing one channel is useful when the object still collides, but not with one kind of thing:

Ghost mode begins
-> Capsule Set Collision Response to Channel Pawn Ignore
-> Capsule Set Collision Response to Channel WeaponTrace Ignore

Ghost mode ends
-> Capsule Set Collision Response to Channel Pawn Block
-> Capsule Set Collision Response to Channel WeaponTrace Block

This does not change the component's object type, and it does not apply a whole preset. It changes one entry.

Set Collision Profile Name

Set Collision Profile Name applies a named preset such as BlockAll, OverlapAllDynamic, Pawn, Trigger, or a project-defined profile. The important word is overwrites: the profile replaces the component's current collision settings with the settings stored under that profile.

That makes profiles useful for clean modes:

Door locked:
    DoorMesh Set Collision Profile Name BlockAll

Door open:
    DoorMesh Set Collision Profile Name NoCollision

It also makes them dangerous after custom channel edits:

Set Collision Response to Channel Visibility Ignore
Set Collision Profile Name BlockAll

Result:
    the profile can replace your custom Visibility response

If you need several small runtime exceptions, change specific responses. If you need to restore a known whole collision setup, apply a profile.

Set Actor Enable Collision

Set Actor Enable Collision changes the actor-level collision-enabled flag. It is a broad gate over the actor's collision participation. It does not walk every component and change each profile, response channel, or Collision Enabled mode.

Use it when the gameplay rule is truly actor-wide:

Cutscene ghost actor begins
-> Set Actor Enable Collision false

Cutscene ends
-> Set Actor Enable Collision true

If only one component should change, target that component instead. For example, turn off a pickup trigger while leaving an attached sparkle effect visible, or make only a character's weapon hitbox active during an attack window.

What you get back

These nodes are commands. They do not return a success Boolean, actor reference, hit result, or list of overlaps.

Node Output
Set Collision Enabled execution continues after the component setting is changed
Set Collision Response to Channel execution continues after one response entry is changed
Set Collision Profile Name execution continues after the profile is applied
Set Actor Enable Collision execution continues after the actor-level flag is changed

If the next graph step depends on the new state, read the state back with the matching getter or test with a debug trace/overlap. Do not assume a missing return value means the engine verified your intent.

Current overlaps and future traces

Runtime collision changes affect future collision decisions, but existing overlap state can surprise you.

Common outcomes:

  • disabling collision prevents future traces, sweeps, overlaps, and blocking checks from using that component as a collider;
  • changing a response channel can make future traces or movement sweeps start hitting, overlapping, or ignoring it;
  • applying a profile can refresh several settings at once, including overlap behavior;
  • current overlap pairs may end, begin, or remain in your own cached variables until you handle events or rebuild that list.

Set Collision Profile Name exposes an Update Overlaps input. Use it when the profile change should immediately refresh overlap state for that component. Even then, remember that your own arrays, sets, booleans, and UI labels are your responsibility:

BeginOverlap
-> Add OtherActor to OverlappingActors set

Set Collision Enabled NoCollision
-> EndOverlap may fire for current pairs
-> also clear OverlappingActors if your gameplay rule requires it now

Do not let a hidden cached set keep damaging or interacting with an actor after the collision that justified the membership is gone.

Blocking movement, hidden actors, and traces

These are separate systems:

| Change | Visibility | Collision | Lifetime | |---|---|---| | Set Visibility false on a mesh component | Mesh stops rendering. | Collision can still block, overlap, and trace-hit. | Actor/component still exists. | | Set Actor Hidden In Game true | Actor's visual components are hidden in game. | Collision can still exist. | Actor still exists. | | Set Collision Enabled NoCollision | Visuals do not change. | That component stops participating in collision. | Actor/component still exists. | | Set Actor Enable Collision false | Visuals do not change. | Actor-level collision gate is off. | Actor still exists. | | Destroy Actor | Actor disappears after Unreal's destruction path. | Components are removed with the actor. | References can become stale. |

The classic bug is an invisible wall:

Set Actor Hidden In Game true

The actor is hidden, but its blocking collision still stops the player. If the gameplay rule is "the player can pass through it now," change collision too.

The opposite bug is a visible prop with no interaction:

StaticMesh Set Collision Enabled NoCollision

It still renders, but line traces and overlaps may never see it.

Replication and authoritative state

Collision changes are gameplay state when they affect movement, hit detection, damage, pickups, or access. In multiplayer, make the authoritative machine own the rule.

Typical shape:

Owning client presses Use
-> ServerUsePickup

ServerUsePickup
-> validate pickup and player
-> add item to inventory
-> pickup CollisionComponent Set Collision Enabled NoCollision
-> replicate pickup collected state

OnRep_Collected / client presentation
-> hide mesh, play sound, update UI

Do not trust a client-only collision change to protect gameplay. A client can hide or disable its local copy for presentation and still be wrong about what the server will block, overlap, trace, or damage.

For purely local presentation, such as making a local-only preview ghost ignore traces, client-side collision can be fine. For shared gameplay, replicate a clear state such as bCollected, bDoorOpen, or bShieldActive, and let each machine apply the matching collision/presentation setup.

When it fails (and what failure does)

There is no Failed pin. Most mistakes look like "the wrong thing still blocks" or "nothing can hit this anymore."

Symptom Likely cause
Hidden object still blocks You changed visibility, not collision.
Trace ignores the object Collision Enabled is not query-capable, the trace channel response is Ignore, or you changed a different component.
Player still cannot pass through The capsule/mesh that blocks movement is still blocking Pawn or the actor-level gate is still on.
Overlap event never fires again Collision is disabled, Generate Overlap Events is off, or one side now ignores the other.
EndOverlap did not clean your gameplay state Your own stored set/Boolean was not cleared, or overlap update timing did not match your assumption.
Custom channel change disappeared A later Set Collision Profile Name reapplied a preset and overwrote it.
Physics stops working You switched to QueryOnly or NoCollision when the object needed physics collision.
Client sees a door open but server blocks it Collision was changed only on the client or replicated state did not drive server collision.
Node appears to do nothing Target is None, target is not the component that actually collides, or a later setup path reapplies another profile.

Failure does not log a guaranteed warning, return false, destroy the actor, clear your arrays, or rewrite other components. Print the target component name and its collision settings, then draw the trace or watch overlap events.

The pattern everyone actually uses

For a collectible that respawns:

Pickup BeginOverlap player
-> server validates pickup
-> add item
-> Set bCollected true
-> Mesh Set Visibility false
-> CollisionComponent Set Collision Enabled NoCollision
-> Set Timer by Event RespawnPickup

RespawnPickup
-> Set bCollected false
-> Mesh Set Visibility true
-> CollisionComponent Set Collision Enabled QueryOnly

For an attack hitbox:

Animation Notify State Begin
-> WeaponHitbox Set Collision Enabled QueryOnly
-> Clear AlreadyHitActors set

WeaponHitbox BeginOverlap
-> filter target
-> if not in AlreadyHitActors:
       Add to set
       Apply Damage

Animation Notify State End
-> WeaponHitbox Set Collision Enabled NoCollision
-> Clear AlreadyHitActors set

For a door:

Door opening Timeline starts
-> optional DoorMesh Set Collision Response to Channel Pawn Ignore

Door closed
-> DoorMesh Set Collision Response to Channel Pawn Block

Use a whole profile when the door has two known collision modes. Use one channel response when only one relationship changes.

What these nodes do not do

  • They do not hide, show, spawn, or destroy actors.
  • They do not change the visual mesh unless collision and visual mesh are the same component and you also change visibility/materials elsewhere.
  • They do not create a collision shape on a component that has no shape.
  • They do not change every component unless you target every relevant component or use the actor-level gate intentionally.
  • They do not make a trace hit if the trace uses a channel the component ignores.
  • They do not clear your stored references, arrays, or sets.
  • They do not guarantee a replicated gameplay result when called only on a client.
  • They do not replace filtering. A BeginOverlap still needs to check the other actor/component before applying gameplay.

Lookalikes - which one do I want?

Node / setting Use when It does not
Set Collision Enabled One component should stop/start query or physics collision. Change visibility or every component's profile.
Set Collision Response to Channel One component should treat one channel differently at runtime. Change object type or restore a full preset.
Set Collision Response to All Channels A component should Block/Overlap/Ignore everything, then you may override exceptions. Keep your old per-channel custom table.
Set Collision Profile Name You want to apply a named preset and overwrite custom settings. Preserve earlier one-off channel edits.
Set Actor Enable Collision The whole actor should be collision-enabled or disabled as an actor-wide rule. Rewrite individual component settings.
Set Generate Overlap Events You want a component to send or stop sending overlap notifications. Disable blocking traces or physics by itself.
Ignore Actor When Moving A moving component should ignore a specific actor during movement. Change global collision responses for everyone.
Set Visibility / Hidden In Game You only mean visual rendering. Stop traces, overlaps, movement blocking, or physics.
Destroy Actor / Set Life Span The object should leave the world or be cleaned up later. Temporarily hide/disable while keeping the same actor alive.

Rule of thumb: profiles restore a whole named setup; response nodes edit a row or table; Collision Enabled decides query/physics participation; visibility is only visual.

Going deeper