Skip to content

Set Simulate Physics / Is Simulating Physics / Set Enable Gravity

At a glance

Lives in: Blueprint API / Physics - Targets: Primitive Component for both setters; Scene Component for the query - Returns: the setters return no value; Is Simulating Physics returns a Boolean - Can fail? the setters have no success pin, and false from the query does not explain why a body is not simulating - Official docs: Set Simulate Physics, Is Simulating Physics, and Set Enable Gravity

These nodes switch a component's physics bodies between transform-driven and simulation-driven behavior, report a selected body's current simulation state, and decide whether world gravity affects a simulated body. They do not turn an arbitrary Actor into a working physics prop by themselves.

The one-minute version

  • The target is the Primitive Component that owns the physics body - often a Static Mesh Component or Skeletal Mesh Component - not merely the Actor that contains it.
  • Set Simulate Physics(true) lets the physics solver drive the body. false stops that solver-driven motion so the component/animation path can drive it according to the rest of your setup, but it does not restore an old attachment, transform, collision profile, or gameplay state for you.
  • On a simple one-body component, beginning simulation detaches an attached component. Stopping simulation later does not reattach it.
  • A Skeletal Mesh Component can contain many bodies from a Physics Asset. Set Simulate Physics has no Bone Name pin; its skeletal implementation affects the component's body set. Use body-specific skeletal nodes when the design needs only part of the hierarchy.
  • Is Simulating Physics(Bone Name) returns one Boolean for the body selected by that name. false can mean "simulation is off," "that body was not found," or "this Scene Component has no usable physics body."
  • Set Enable Gravity matters only while physics simulation is active. Gravity off does not freeze the object, cancel velocity, disable collision, or block forces and impulses.
  • A body may be simulating but asleep. Sleep is a performance state, not the opposite of Simulate Physics.
  • For a replicated gameplay object, make the authoritative transition on the server. A client-local setter call is not automatically a shared gameplay decision.

What they actually do

A visible Actor can contain several components, and each component can own zero, one, or many physics bodies:

BP_Pickup Actor
|-- Scene Root                    // may have no geometry or physics body
`-- Static Mesh Component         // owns the crate's one rigid body

BP_Character Actor
|-- Capsule Component             // Character collision; usually not a loose body
`-- Skeletal Mesh Component
    `-- Physics Asset bodies      // pelvis, spine, limbs, ...

The setters operate through the component that owns those bodies. The query is declared on the broader Scene Component type so it is available through a scene-component reference, but useful subclasses such as Primitive Component provide the real body lookup. A plain Scene Component has no geometry to simulate and reports false.

At beginner altitude, the family behaves like this:

pseudocode of the engine behavior - not engine source

SetSimulatePhysics(PrimitiveComponent, wantedState):
    ask the component for its physics implementation
    if it is a simple attached body and wantedState is true:
        detach it so attachment and simulation do not both own its transform
    tell the component's body or bodies to enter wantedState
    return no success result

IsSimulatingPhysics(SceneComponent, BoneName):
    ask the component for the body selected by BoneName
    if no matching physics body can answer:
        return false
    return whether that body currently uses simulation

SetEnableGravity(PrimitiveComponent, enabled):
    update whether gravity should affect the component's simulated body setup
    return no success result

This is a state change, not a movement command. Once simulation begins, current velocity, gravity, collision, constraints, forces, mass, damping, and contacts determine what happens next. "Simulating" does not necessarily mean "moving right now."

Which body does each node mean?

Static Mesh and simple collision components

A Static Mesh Component, Box Component, Sphere Component, or similar simple primitive normally exposes one body. Leave Bone Name as None on the query; there is no skeletal body hierarchy to choose from.

The component still needs a usable simulation setup:

  • mobility suitable for movement (normally Movable);
  • collision data that creates a physics representation;
  • a mesh with simple collision, or generated collision from the component;
  • a collision-enabled mode that includes physics, such as Physics Only or Query and Physics when queries are also needed.

Query Only can participate in traces, sweeps, and overlaps, but it is not a rigid-body/constraint simulation setup. No Collision has no physics representation at all.

Skeletal Mesh Components and Bone Name

A Skeletal Mesh Component obtains bodies and constraints from its Physics Asset. The body names follow the Physics Asset's bone/body mapping.

Is Simulating Physics accepts a Bone Name so you can ask about a particular body. None follows the component's default/root-body lookup. That means a single false is not proof that no skeletal body is simulating; another body may be active. Use Is Any Simulating Physics when the question is genuinely "does this component have any simulated body?"

Set Simulate Physics has no Bone Name pin. For partial ragdolls or a physical tail/limb, look at skeletal-specific nodes such as Set Body Simulate Physics, Set All Bodies Below Simulate Physics, and physics blend/animation controls. Do not toggle the whole mesh merely because one hand or one hit reaction needs physical motion.

Beginning simulation can break an attachment on purpose

A simple attached component cannot remain an ordinary transform-following child while also moving independently as a loose rigid body. When simulation begins, Unreal detaches that simple body. The world transform is then owned by physics rather than by its old parent/socket.

Character hand socket
`-- held pickup mesh
    -> Set Simulate Physics true
    -> pickup becomes an independent simulated body
    -> simple attachment is no longer the transform owner

Turning simulation off later only stops simulation. Unreal does not remember which socket, transform rules, collision profile, or gameplay reference your equip system intended.

Use explicit transitions:

Pick up as an attached item:
    Set Simulate Physics false on PickupMesh
    set held collision profile
    Attach Actor/Component to the hand socket
    store equipped-item gameplay state

Drop as a physics item:
    Detach using Keep World
    restore world-pickup collision profile
    Set Simulate Physics true on PickupMesh
    optionally Add Impulse for a toss

Skeletal meshes are the important exception to the simple-detach mental model. Their many bodies can move inside the component through the Physics Asset, so enabling the component's skeletal simulation does not automatically detach the component. If the entire skeletal component must leave its parent, detach it explicitly.

For the full attachment side of this transition, see Attach Actor To Component.

Gravity is only one influence

Set Enable Gravity(false) removes the world's gravity contribution from the simulated body setup. It does not make the body kinematic.

With gravity disabled, a body can still:

  • keep its existing linear and angular velocity;
  • collide and bounce;
  • respond to impulses, forces, handles, and constraints;
  • be pushed by another simulating object; and
  • go to sleep when its motion settles.

With simulation disabled, changing the gravity flag cannot make the component fall because physics is not driving it. Keep the two facts separate in your debug output:

Print:
    Is Simulating Physics(PickupMesh)
    Is Gravity Enabled(PickupMesh)
    Get Physics Linear Velocity(PickupMesh)

If the design means "freeze exactly here," disable simulation or apply an intentional constraint/kinematic control. Gravity off alone means "no downward gravity acceleration," not "stop."

Collision, mobility, mass, sleep, and welding

These settings answer different questions:

Setting What it controls What it does not prove
Simulate Physics Whether the solver drives the selected body. That the body is awake or visibly moving.
Collision Enabled Whether a physics/query representation exists and which systems use it. That the body is currently simulating.
Mobility Whether the component is allowed to move at runtime. That collision or a usable body exists.
Mass / inertia How the body responds to mass-dependent impulses, forces, and rotation. Whether gravity or simulation is enabled.
Sleep Whether an inactive simulated body can temporarily stop solver work. That Simulate Physics was turned off.
Enable Gravity Whether world gravity contributes while simulation is active. That velocity, collision, or other forces are disabled.

A sleeping body can still return true from Is Simulating Physics. An impact, force, impulse, or Wake Rigid Body / Wake All Rigid Bodies can wake it. Use sleep/wake nodes when the question is activity, not the simulation toggle.

Welding is another ownership change. Weld Simulated Bodies can move a child's collision shapes into the parent's simulated body so the pieces act as one. After welding, the visually obvious child may no longer behave like an independent body for queries, mass, forces, or toggles. Diagnose and change the welded parent body, or deliberately detach/unweld before expecting independent simulation. Some weld effects can persist after detachment, so welding is not a casual equip/drop substitute.

When the state does not change (and what failure looks like)

Neither setter returns a Boolean or Failed execution pin. The output exec wire continuing means only that Blueprint called the function.

Common causes of "I set it, but nothing happened" are:

  1. Wrong target component. The Actor's Scene Root is not the mesh/collision component that owns the intended body.
  2. No simulation-capable physics representation. Collision is No Collision/Query Only, the Static Mesh has no usable simple collision, or a Skeletal Mesh has no suitable Physics Asset body.
  3. Mobility or asset setup rejects the transition. Inspect the Output Log; editor/development builds can warn about invalid physics setup even though there is no Blueprint failure pin.
  4. Wrong skeletal Bone Name. Is Simulating Physics returns false for a body lookup that cannot report an active simulation state.
  5. The body is constrained, blocked, or asleep. Simulation may be on while visible motion is limited or absent.
  6. You are looking at an attachment change instead of motion. A simple component detached successfully but had no velocity or gravity-driven room to move.
  7. A client changed only its local copy. Server physics/movement correction restores the authoritative state.

A None Target is a separate Blueprint failure. Calling either setter on no object is skipped and can produce Accessed None in editor/development output. Calling the pure Is Simulating Physics query on no object can likewise report Accessed None and leave the default false output; that is not evidence that a valid body simply has simulation disabled. Validate the component reference before any of the three nodes.

For a valid component, query after the transition when you need diagnostic evidence:

Set Simulate Physics true
-> Is Simulating Physics (same component, intended body)
-> Branch
   true: continue with force/handle/drop behavior
   false: print component name, mobility, collision mode, and body name

Do not treat that check as a replacement for correct asset setup. It is a diagnostic that turns a void setter into evidence.

The patterns everyone actually uses

Drop and toss a one-body pickup

Drop request
-> Is Valid(PickupMesh)
-> Detach From Component (Keep World)
-> restore pickup collision profile
-> Set Simulate Physics true
-> Is Simulating Physics(PickupMesh, None)
   true:
       Set Enable Gravity true
       Add Impulse(ThrowDirection * ThrowStrength)
   false:
       report invalid pickup physics setup

Return a pickup to exact hand attachment

Accepted pickup
-> Set Simulate Physics false on PickupMesh
-> set held collision profile
-> Attach to hand socket with intentional transform rules
-> update inventory/equipped reference

The order matters: physics gives up transform ownership before the ordinary attachment takes it.

Start a full skeletal ragdoll

Authoritative death state
-> stop/disable Character Movement as designed
-> choose capsule collision policy
-> set Skeletal Mesh collision profile to Ragdoll
-> Set Simulate Physics true on the Skeletal Mesh
-> optionally apply a body-specific impulse

That is a gameplay transition involving Character Movement, capsule collision, animation, the mesh Physics Asset, and networking. The one setter owns only the mesh physics part.

The C++ twin, for the curious (our own example code):

void APhysicsPickup::BeginDrop(const FVector& TossImpulse)
{
    if (!IsValid(PickupMesh))
    {
        return;
    }

    PickupMesh->DetachFromComponent(FDetachmentTransformRules::KeepWorldTransform);
    PickupMesh->SetCollisionProfileName(TEXT("PhysicsActor"));
    PickupMesh->SetSimulatePhysics(true);

    if (PickupMesh->IsSimulatingPhysics(NAME_None))
    {
        PickupMesh->SetEnableGravity(true);
        PickupMesh->AddImpulse(TossImpulse, NAME_None, false);
    }
}

Multiplayer boundary

Each machine owns a local component and local physics scene. Calling one of these nodes changes the copy on the machine where that graph executes.

For a shared gameplay prop:

owning client input
-> Server request (validate object, range, and allowed transition)
-> server changes collision / attachment / simulation / gravity state
-> replicated movement plus explicit replicated gameplay state update clients

Built-in physics replication is centered on a replicated Actor whose movement is replicated and whose root body simulates. It does not make every non-root component toggle, Bone Name choice, gravity flag, collision profile, attachment, or ragdoll policy into an automatic shared state machine.

Use a replicated enum/Boolean with RepNotify when clients must reproduce a transition such as Held, Dropped, or Ragdoll, and apply the matching local component setup from that state. Is Simulating Physics reports the state of the local copy; it does not ask the server.

Cosmetic debris that intentionally exists only on one client can simulate locally. Gameplay collision, pickups, damage, and shared object positions normally need server authority. See Replication basics and Replicate Movement vs replicated variables.

What these nodes do not do

They do not:

  • find the correct Primitive Component from an Actor reference;
  • create collision geometry or a Skeletal Mesh Physics Asset;
  • change mobility or choose a collision profile;
  • wake every sleeping body as a documented side effect;
  • detach every kind of multi-body component when simulation begins;
  • reattach a component when simulation ends;
  • restore a previous transform, velocity, collision profile, or gravity value;
  • make gravity disabled mean frozen;
  • stop Character Movement or configure a complete ragdoll;
  • guarantee that a false query identifies one specific setup problem; or
  • replicate an arbitrary physics transition merely because the Actor exists on several machines.

Lookalikes - which one do I want?

Node / setting Use when Watch out
Set Simulate Physics A component's body or body set should enter/leave physics-driven control. Void result; simple attached bodies detach on enable.
Is Simulating Physics You need the current state of one selected body. false combines several causes; Bone Name matters.
Is Any Simulating Physics A multi-body component may have some active simulated body. It does not identify which one.
Set Enable Gravity A simulated body should or should not receive world gravity. It does not freeze, stop, or enable simulation.
Set Body Simulate Physics / Set All Bodies Below Simulate Physics A Skeletal Mesh needs body-specific or partial simulation. Physics Asset hierarchy and animation blending still matter.
Wake Rigid Body / Put Rigid Body to Sleep Simulation stays enabled but solver activity should resume/pause. Sleep is not the simulation toggle.
Set Collision Enabled / Set Collision Profile Name The query/physics representation and channel responses must change. Collision state does not itself hand transform control to physics.
Add Impulse / Add Force An already simulated body needs a shove. They do not enable simulation.
Attach / Detach Transform parenting should start or end explicitly. Attachment and loose simulation need an owned transition order.
Physics Handle / Physics Constraint A simulated body should remain physical while being held or constrained. Different from exact socket attachment.

Rule of thumb: configure a real physics body, toggle simulation on the component that owns it, query the same intended body, and treat attachment, collision, gravity, sleep, and replication as separate state.

Going deeper