Skip to content

Set Actor Hidden In Game / Set Visibility

At a glance

Set Actor Hidden In Game lives in: Blueprint API / Rendering - Target: an Actor - Component version: Set Visibility or Set Hidden in Game on a Scene/Primitive Component - Blueprint returns: no value, just execution continues - Changes: rendering visibility, not actor lifetime, collision, tick, AI, input, or audio by itself - Official docs: Set Actor Hidden In Game, Set Visibility

The one-minute version

  • Set Actor Hidden In Game hides or shows an actor and its components during gameplay rendering.
  • Hiding an actor does not destroy it. References remain, BeginPlay has already happened, variables stay, and the actor can still exist in the world.
  • Hiding does not automatically disable collision, overlap events, tick, input, AI, timers, or audio.
  • Set Visibility is a component-level rendering control. Use it when only one mesh, light, camera helper, or child component should show/hide.
  • For UMG widgets, use widget visibility or Remove from Parent; actor hidden nodes do not remove viewport widgets.
  • If you want something gone, destroy it. If you want it non-interactive, disable collision/input/tick. If you only want it invisible, hide it.

What Set Actor Hidden In Game actually does

The actor node changes the actor's hidden-in-game state and propagates that rendering visibility intent to the actor's components.

pseudocode of the engine behavior - not engine source

function SetActorHiddenInGame(Actor, NewHidden):
    if Actor is None:
        execution continues
        return

    Actor.bHidden = NewHidden
    update component hidden/render state for the actor
    execution continues

That is a rendering change. The actor is still part of the world unless you also disable the systems you do not want.

Set Actor Hidden In Game true
-> actor is not drawn
-> collision can still block/overlap
-> Tick can still run
-> timers can still fire
-> AI can still think
-> audio components may keep playing

This is the most important beginner distinction: invisible is not inactive.

Actor hidden vs component visibility

Use the actor node when the whole actor should be visually hidden or shown as one unit.

BP_Chest
-> Set Actor Hidden In Game true

Use component visibility/hidden-in-game when only a part changes:

BP_Chest components:
    ClosedLidMesh
    OpenLidMesh

Open chest
-> ClosedLidMesh Set Visibility false
-> OpenLidMesh Set Visibility true

Component tags can help when a group of components should hide together:

Get Components by Tag "DamageOverlay"
-> For Each
-> Set Visibility false

Actor-level hiding is broad. Component-level visibility is precise.

What hiding does not do

Hiding is not cleanup and not gameplay disable.

Need Use
Stop rendering Set Actor Hidden In Game or component Set Visibility/Hidden in Game
Stop blocking/overlapping Set Collision Enabled / collision response changes
Stop Tick work Set Actor Tick Enabled / component tick enabled
Stop AI logic Stop behavior tree, unpossess, disable controller logic, or gate your AI state
Stop input Disable Input or change input mode/mapping/context
Stop sound Stop/Fade Out the AudioComponent
Remove actor from world Destroy Actor or Set Life Span
Remove widget from screen Remove from Parent or widget visibility

If a hidden pickup still blocks the player, the rendering part worked and the collision part is missing.

When it appears to fail

These nodes usually "fail" by doing exactly what they were asked, while another system still shows or affects something.

Common causes:

  1. Target is None. Execution continues and no actor/component changes.
  2. You hid the actor but another actor renders the visible thing. Common with child actors, attached actors, and spawned effects.
  3. You hid one component but another mesh is visible. Inspect the component tree.
  4. You changed Visibility when Hidden in Game is the active flag. Editor visibility and in-game hidden state are related but not the same debugging question.
  5. A later graph turns it visible again. Animation, construction, Tick, or state-update logic may overwrite the setting.
  6. You expected collision or audio to stop. Those are separate systems.

There is no return value and no hidden branch. Print the target name, then inspect visible components, collision, tick, and audio separately.

The pattern everyone actually uses

Hide a collected pickup but keep respawn logic:

Pickup collected
-> Set Actor Hidden In Game true
-> Set Collision Enabled No Collision on pickup collision/mesh
-> Set Actor Tick Enabled false if it had Tick work
-> Set Timer by Event RespawnPickup

RespawnPickup
-> reset variables
-> Set Collision Enabled Query Only or original setting
-> Set Actor Hidden In Game false

Show one damage overlay mesh:

HealthComponent OnHealthChanged
-> if HealthPercent < 0.25:
       DamageOverlayMesh Set Visibility true
   else:
       DamageOverlayMesh Set Visibility false

Close a pause menu:

Pause widget Close button
-> Remove from Parent or Set Widget Visibility Collapsed
-> restore input mode and cursor

Do not use actor hidden nodes for widgets. A widget is not an actor in the level.

Multiplayer note

Visibility changes are presentation unless you replicate the state that should cause them.

For replicated gameplay:

Server sets bPickupAvailable = false (replicated)
-> OnRep_PickupAvailable on clients
-> clients hide/show pickup visuals and collision as appropriate

Calling Set Actor Hidden In Game only on one client gives that client a local visual result. It does not automatically prove the server or other clients have the same gameplay state.

Lookalikes - which one do I want?

Node/tool Use when Watch out
Set Actor Hidden In Game Hide/show the whole actor in gameplay rendering. Does not disable collision, tick, input, AI, audio, or lifetime.
Set Visibility Hide/show one component's visibility. Component-level only; actor may still have other visible parts.
Set Hidden in Game Component-level hidden-in-game flag. Useful when gameplay hidden state matters per component.
Toggle Visibility Flip a component's current visibility. Harder to reason about than setting a known state.
Set Collision Enabled Stop physical/query interaction. Does not hide visuals.
Set Actor Tick Enabled Stop actor Tick. Components may have their own ticks.
Destroy Actor / Set Life Span Remove actor lifetime now/later. References become stale; teardown is real.
Remove from Parent Remove a widget from its parent/viewport. UMG, not actors.

Rule of thumb: hidden is visual, collision is interaction, tick is work, destroy is lifetime. Choose the node for the system you actually mean.

Going deeper