Skip to content

Get / Set Physics Linear and Angular Velocity

At a glance

Lives in: Blueprint API / Physics - Target: one body owned by a Primitive Component - Get returns: a world-space Vector; zero can mean either a real stop or a failed body lookup - Set returns: no value and no success branch - Units: linear velocity is normally centimeters per second; the Degrees angular nodes use degrees per second - Official docs: Get Physics Linear Velocity, Set Physics Linear Velocity, Get Physics Angular Velocity in Degrees, and Set Physics Angular Velocity in Degrees

These nodes read or directly assign the motion of one rigid body. They do not mean "how fast is this Actor moving?" and they do not apply a physical push over time.

The one-minute version

  • Get Physics Linear Velocity returns one body's world-space travel velocity: direction plus speed, normally in centimeters per second.
  • Get Physics Angular Velocity in Degrees returns one body's world-space spin vector in degrees per second. It is not a Rotator, target orientation, or "degrees turned since last frame."
  • The setters directly replace that velocity, unless Add to Current is true. With that pin true, the supplied vector is added once to the body's current velocity.
  • Bone Name selects a body on a Skeletal Mesh Component's Physics Asset. None selects the component's root/default body. A Static Mesh Component normally has one body, so leave the name as None.
  • A missing body makes a getter return (0, 0, 0) and gives the setters nothing to change. There is no success pin and no guaranteed warning.
  • A non-simulating body is not driven through the world by an assigned physics velocity. Check Is Simulating Physics when visible rigid-body motion is the requirement.
  • An asleep simulating body normally reports no motion. A valid non-zero velocity write uses the body's auto-waking path, but constraints, contacts, damping, and later corrections can immediately change the result.
  • Direct velocity assignment is mass-independent. Use force, impulse, torque, launch, or a movement request when the cause of the motion matters.
  • The call is local. For replicated gameplay physics, make the authoritative change on the server and let the project's physics/movement replication strategy distribute the result.

The four main contracts

Node Input or output Vector means Result
Get Physics Linear Velocity World X/Y/Z travel velocity, normally cm/s Current value, or zero when no usable body is found
Set Physics Linear Velocity New world X/Y/Z travel velocity, normally cm/s Void; replace or add once
Get Physics Angular Velocity in Degrees World-axis spin, degrees/s Current value, or zero when no usable body is found
Set Physics Angular Velocity in Degrees New world-axis spin, degrees/s Void; replace or add once

All four choose the same kind of target: one FBodyInstance resolved through a Primitive Component and optional body name.

pseudocode - not engine source

GetLinear(Component, BodyName):
    Body = Component.FindPhysicsBody(BodyName)
    if Body is missing:
        return (0, 0, 0)
    return Body.WorldLinearVelocity

SetLinear(Component, NewVelocity, AddToCurrent, BodyName):
    Body = Component.FindPhysicsBody(BodyName)
    if Body is missing:
        return
    Body.LinearVelocity =
        AddToCurrent ? Body.LinearVelocity + NewVelocity : NewVelocity

GetAngularDegrees(Component, BodyName):
    RadiansPerSecond = GetAngularRadians(Component, BodyName)
    return RadiansToDegrees(RadiansPerSecond)

The angular Degrees setter performs the opposite unit conversion before the physics body receives the value. Degrees and radians are two numeric representations of the same world-space spin.

Which body does Bone Name select?

Static Meshes and simple collision components

A Static Mesh, Box, Sphere, or Capsule Component normally owns one rigid body. Use the component itself as Target and leave Bone Name as None.

BP_Crate
`-- CrateMesh (Static Mesh Component, Simulate Physics = true)

Target = CrateMesh
Bone Name = None

Calling the node on an Actor reference is not enough. Get the Primitive Component that owns the body.

Skeletal Meshes and Physics Assets

A Skeletal Mesh Component can own many bodies through its Physics Asset. The pin says Bone Name because Physics Asset bodies are associated with skeleton bones, but the operation needs a body that actually exists in that asset.

Skeletal Mesh Component
|-- pelvis body
|-- spine_01 body
|-- upperarm_l body
`-- ...
  • None follows the component's root/default-body lookup.
  • A valid body-associated name selects that one body.
  • A skeleton bone with no matching Physics Asset body is not made physical by naming it.
  • A misspelled, removed, or incompatible name produces the same zero/no-op shape as other failed body lookups.

Use the Physics Asset editor to confirm the body names. Do not assume every visual bone has an independent rigid body.

For a full or partial ragdoll, the single-body setters change only the selected body. Set All Physics Linear Velocity, Set All Physics Angular Velocity, and skeletal "all bodies below" helpers are separate operations with broader scope.

Welded bodies

When a simple simulated child is welded into a parent body, the visible component is no longer an independent rigid body in the ordinary sense. Body lookup can resolve through the welded aggregate, and changing "the child" can therefore affect the shared parent body rather than a separately moving piece.

If independent velocity matters, verify the attachment/weld setup or detach and unweld deliberately. The component hierarchy alone does not prove that two independent solver bodies exist.

Linear velocity: direction, speed, and units

The linear result is a world-space vector:

Velocity = (X = 300, Y = 0, Z = 200)

In the usual Unreal scale, that means the body is moving 300 centimeters per second along world X and 200 centimeters per second upward along world Z.

Useful derived values:

3D speed     = Vector Length(Velocity)
ground speed = Vector Length XY(Velocity)
direction    = Normalize(Velocity), if speed is not nearly zero

The vector is not relative to the body. Rotating a crate does not rotate a stored world velocity with it. To launch along the crate's current forward axis, build a world vector first:

New Velocity = CrateMesh.GetForwardVector * LaunchSpeed

Get Physics Linear Velocity reads the body's translation velocity. A point away from the center can move faster or in another direction while the body is spinning. Use Get Physics Linear Velocity at Point when the question is "how fast is this world point on the rotating body moving?"

At a point, the conceptual relationship is:

PointVelocity = BodyLinearVelocity
              + AngularVelocity cross (Point - CenterOfMass)

You do not need to implement that formula for the provided point-velocity node; it explains why its answer can differ.

Angular velocity: a spin vector, not a Rotator

Angular velocity describes an axis and rate:

  • the vector's direction is the world-space spin axis;
  • its length is the spin rate;
  • its components are rates about world X, Y, and Z.
(0, 0, 180) degrees/s

means spin about world Z at 180 degrees per second. It does not mean "set Pitch 0, Yaw 0, Roll 180," and it does not promise the body will end at a particular orientation.

The Degrees and Radians nodes describe the same physical motion:

360 degrees/s = 2 * Pi radians/s
180 degrees/s = Pi radians/s
1 radian/s    = about 57.2958 degrees/s

Choose one unit family and keep the math consistent. The Degrees nodes are friendlier when designers think in turns and angles. Radians are common in physics formulas and C++ APIs.

Do not mix a Degrees getter with a Radians setter without converting. The graph will accept both as ordinary Vectors; the type system cannot catch the unit mistake.

Replacement vs Add to Current

With Add to Current = false, the supplied value replaces the selected body's current value:

current linear velocity = (400, 0, -100)
new velocity            = (0, 0, 600)

result = (0, 0, 600)

With Add to Current = true, the supplied vector is added once:

current linear velocity = (400, 0, -100)
new velocity            = (0, 0, 600)

result = (400, 0, 500)

The same rule applies to angular velocity.

Add to Current does not turn the setter into a force or torque:

  • it is not mass-dependent;
  • it is not integrated over time;
  • it does not represent a physical contact;
  • calling it every Tick keeps injecting velocity every Tick.

Use replacement for an exact launch/reset contract. Use Add to Current only when the design literally wants an instantaneous velocity delta and direct assignment is acceptable.

When it fails (and what failure does)

The getters have no success Boolean, and the setters have no result at all. Common failure and ambiguity shapes are:

  1. Target is None. The Blueprint member call cannot run; expect the normal invalid-target diagnostic and default-looking output.
  2. Target is not the component that owns the intended body. Changing a Scene Root or Character capsule does not change a separate simulated mesh.
  3. No usable physics body exists. Collision/body setup may be missing, the component may not have created physics state yet, or a Skeletal Mesh may lack a compatible Physics Asset.
  4. Bone Name does not resolve to a body. Get returns zero; Set has nothing to write.
  5. The body is not simulating. A velocity value is not a command for a kinematic component to integrate its transform. The call does not enable Simulate Physics.
  6. The body is asleep. A sleeping body normally reads as stopped. A non-zero accepted setter normally wakes a dynamic body, but a zero write, constraint, or immediately settled state may remain visually still.
  7. A constraint or locked axis rejects part of the motion. The write can be accepted and then corrected by the solver.
  8. A contact, handle, drive, damping setting, or speed limit changes it. The value after the next physics step need not equal the value assigned before that step.
  9. Another system owns motion. Character Movement, Projectile Movement, animation/physical animation, a Physics Handle, or network correction can overwrite or compete with the body velocity.
  10. The call ran on the wrong machine. A client can change its local snapshot and still be corrected by the authoritative server.

A zero getter is therefore not a validity signal:

(0, 0, 0) can mean:
    valid body at rest
    valid body asleep
    missing body
    wrong body name
    physics state not ready

Validate the component, confirm the body in the Physics Asset, and use Is Simulating Physics for the same body before diagnosing the number.

These functions are marked unsafe during Actor construction. Physics state is not a stable runtime body contract in Construction Script. Configure defaults there; read or assign live velocity during gameplay after components and physics state exist.

Sleep, wake, and stopping

Sleep is a solver optimization for a simulated body that has settled. It is not the same as turning simulation off.

For a body that is already simulating:

Set Physics Linear Velocity(non-zero)
-> direct velocity write
-> valid dynamic body normally wakes

Set Physics Linear Velocity((0, 0, 0))
Set Physics Angular Velocity in Degrees((0, 0, 0))
-> motion is zeroed now
-> sleep state is still a separate question

If the gameplay contract says "stop and remain asleep," zero both velocities and use the explicit sleep node. If it says "resume solving," use Wake Rigid Body or Wake All Rigid Bodies instead of relying on an incidental write.

For a multi-body Skeletal Mesh, one asleep body does not prove the entire mesh is asleep. Match the same body scope when reading velocity, simulation state, and wake state.

Direct velocity vs a physical cause

Direct setters are useful, but they skip the cause-and-response step that forces and impulses model.

Desired meaning Better first choice
Start a physics projectile at an exact speed Set linear velocity once
Stop one loose body immediately Set linear and angular velocity to zero
Add a one-time collision/explosion shove Add Impulse
Push continuously with wind or a thruster Add Force
Start rotational motion from an impact Add Angular Impulse or Add Impulse at Location
Spin continuously with a motor-like push Add Torque
Launch a normal Character Launch Character
Move a Pawn through its movement system Add Movement Input / AI movement request
Carry a still-simulating object Physics Handle or constraint

Mass and inertia matter to force, impulse, torque, contact, and later solver response. Direct velocity assignment gives the requested initial rate regardless of mass. A feather and a heavy crate can both be assigned 500 cm/s; their later collision response will still differ.

The official setters warn to use them cautiously for this reason. If "an explosion hit it" is the design fact, an impulse preserves that fact better than replacing velocity.

Actor Get Velocity is a different scope

Get Velocity asks an Actor for its root/movement-owned velocity. Get Physics Linear Velocity asks one selected component body.

Character Actor
|-- Capsule Component (root, Character Movement owns Actor velocity)
`-- Skeletal Mesh Component (can contain ragdoll body velocities)

During normal locomotion:

  • Actor Get Velocity reports Character Movement velocity;
  • a mesh physics-body getter may report no useful simulated motion.

During a partial ragdoll:

  • the Character capsule can still have movement velocity;
  • pelvis, arm, and leg bodies can each report different physics velocities.

For an Actor whose root Static Mesh simulates physics, the two readings may agree because the Actor delegates to that root body. Setting a child component's velocity does not guarantee the Actor-level getter changes.

Use Actor Get Velocity for whole-Actor locomotion and animation. Use the physics getter for a specific rigid body.

Teleports, constraints, and handles

Velocity is only one part of body state. Later operations can preserve, derive, reset, or fight it.

Transform moves and teleport choices

Actor and Scene Component transform setters expose a Teleport choice. With Teleport Physics, the body is moved while its current velocity is preserved. Without teleporting, Unreal can update physics velocity from the pose change. The native ResetPhysics teleport mode resets physics state completely.

That means order matters:

Set Physics Linear Velocity
-> Set Actor Location (Teleport = false)

can produce a different final observation from:

Set Actor Location (Teleport = true)
-> Set Physics Linear Velocity

Choose deliberately when respawning, rewinding, or moving ragdolls. If the design says "place here with no old motion," reset/teleport as appropriate and then explicitly establish the wanted velocity state.

Constraints and locked axes

A Physics Constraint, locked body axis, joint drive, or world collision can remove or redirect velocity that violates its rules. A setter does not break a constraint.

For example, assigning Z velocity to a body locked against Z translation may produce no visible rise. The missing motion is not proof that body lookup failed; inspect constraint state too.

Physics Handles

A Physics Handle drives a grabbed body toward a target using a constraint. Directly assigning velocity while the handle remains active makes two systems compete:

your setter says: move at this velocity
handle says: move toward this target
solver reconciles both

Release the handle when you want a free throw, then apply the chosen velocity or impulse. Do not continually overwrite velocity while expecting handle tuning to remain meaningful.

The patterns everyone actually uses

Launch a simulating prop at an exact speed

Is Valid(PropMesh)
-> Is Simulating Physics(PropMesh, None)
-> Branch
   true:
       Direction = Normalize(DesiredDirection)
       Set Physics Linear Velocity
           New Vel = Direction * LaunchSpeed
           Add to Current = false
           Bone Name = None
   false:
       diagnose body/simulation setup

This is appropriate when the design owns an exact initial velocity. Use an impulse when mass-dependent response is part of the design.

Stop one loose body completely

Set Physics Linear Velocity((0, 0, 0), Add to Current = false)
Set Physics Angular Velocity in Degrees((0, 0, 0), Add to Current = false)
optional Put Rigid Body to Sleep

Zeroing only linear velocity can leave the object spinning. Zeroing only angular velocity can leave it sliding.

Read a ragdoll impact body's speed

Hit Result
-> Hit Component as Skeletal Mesh Component
-> Hit Bone Name
-> Get Physics Linear Velocity(same component, same body name)
-> Vector Length

Validate that the hit bone maps to a Physics Asset body. A visual skeleton bone without a body can still yield zero.

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

void APhysicsLauncher::LaunchBody(
    UPrimitiveComponent* BodyComponent,
    FName BodyName,
    const FVector& Direction,
    double Speed)
{
    if (!IsValid(BodyComponent)
        || !BodyComponent->IsSimulatingPhysics(BodyName))
    {
        return;
    }

    BodyComponent->SetPhysicsLinearVelocity(
        Direction.GetSafeNormal() * Speed,
        false,
        BodyName);
}

Multiplayer and observed velocity

Each getter reads the physics state available on the machine running that graph. It does not fetch a fresh server value.

For ordinary replicated gameplay physics:

  1. the server validates the action;
  2. the server changes the authoritative body;
  3. movement/physics replication sends supported body state;
  4. clients simulate/interpolate and may receive corrections.

Calling a setter on a client is not a Server remote procedure call (RPC). Replicate Movement commonly covers an Actor's replicated root-body movement; it does not automatically replicate every body of a complex skeletal ragdoll as independent Blueprint state.

Consequences:

  • a client getter can differ briefly from the server because it sees a local interpolated/predicted snapshot;
  • a client-only assigned velocity can appear to work and then snap/correct;
  • a later server correction can replace an observed linear or angular value;
  • body-specific ragdoll replication needs a deliberate project strategy;
  • presentation can derive local speed, but damage, launch, and pickup rules should use authoritative state.

Do not replicate a velocity Vector every Tick on top of a working physics replication mode without evidence that it is needed. Pick one motion owner and debug that owner's state.

What these nodes do not do

They do not:

  • enable Simulate Physics or create a missing body;
  • prove a zero result is a valid stationary body;
  • select every skeletal body when one Bone Name is provided;
  • return local-space velocity;
  • turn an angular velocity Vector into a target orientation;
  • model mass-dependent force, impulse, or torque;
  • break constraints, release a Physics Handle, or unlock axes;
  • guarantee the assigned value survives the next solver step;
  • move a normal Character through Character Movement;
  • replicate the call to another machine; or
  • make a child body's velocity become the Actor root's Get Velocity.

Lookalikes - which one do I want?

Node / value Use when Important boundary
Get Physics Linear Velocity Read one body's world translation velocity Zero is ambiguous; body name matters
Get Physics Linear Velocity at Point Read velocity at a world point on a spinning body Includes angular contribution
Get Physics Angular Velocity in Degrees / Radians Read one body's world spin rate Units differ by about 57.3
Set Physics Linear / Angular Velocity Directly establish or add one instantaneous velocity Not a physical push and no success output
Set All Physics Linear / Angular Velocity Every body in a multi-body component needs the same assignment Broader than one Bone Name
Set All Bodies Below Linear Velocity A Skeletal Mesh subtree needs a shared linear value Uses Physics Asset hierarchy
Get Velocity Read whole-Actor root/Movement Component velocity Not a selected skeletal body
Get Component Velocity Read a Scene Component's tracked/component or simulating-body velocity No Bone Name selection
Get Bone Linear Velocity Read Skeletal Mesh bone motion Animation/bone motion is not necessarily rigid-body velocity
Add Impulse / Add Force Apply a one-time or continuous physical cause Mass flags and time semantics matter
Add Angular Impulse / Add Torque Apply a rotational physical cause Not a direct final spin rate
Set Physics Max Angular Velocity Change the body's spin-speed limit Does not assign the current spin
Launch Character Launch a normal Character through Character Movement Not loose-body physics
Projectile Movement Velocity Move a non-simulating projectile component Separate motion owner

Rule of thumb: read and set Physics Velocity for one rigid body; use Actor Velocity for whole-Actor movement; use forces, impulses, and torque when the cause should remain physical.

Going deeper