Skip to content

Get Actor / Component Location, Rotation, and Transform

At a glance

Actor target: returns the Actor root component's world location, rotation, or full transform · Scene Component target: returns that specific component's world or relative values · Return types: Vector, Rotator, or Transform values—never object references · Can be None: the target reference can; the returned structs cannot · Official pages: Get Actor Location, Get Actor Rotation, Get Actor Transform, and Scene Component

An Actor does not keep a second, independent transform beside its components. Its Actor transform is the world transform of its root Scene Component. A component getter answers for the exact component you target, which can be a mesh, camera, spring arm, collision shape, or other Scene Component somewhere under that root.

The one-minute version

  • Get Actor Location, Get Actor Rotation, and Get Actor Transform read the Actor's root component in world space.
  • Get World Location, Get World Rotation, and Get World Transform read the exact Scene Component on the Target pin in world space.
  • Relative component values are offsets from the component's attach parent. They are not automatically offsets from the owning Actor.
  • Moving a child mesh or camera does not change Get Actor Location. Moving or replacing the root does.
  • A Transform bundles location, rotation, and scale. Use it when scale matters or when another node accepts a complete transform.
  • Locations are component origins/pivots—not bounds centers, visible centers, collision surfaces, socket positions, or camera viewpoints.
  • A None Actor/component target cannot be queried. Blueprint reports an invalid-reference runtime diagnostic and leaves struct outputs at defaults; a zero vector can therefore be an error-looking default or a real origin.
  • Every Blueprint return here is a snapshot copied into a value pin. Saving it does not create a live link to the Actor or component.
  • Attachment, parent motion, and animation can change the next world-transform result even while a child's relative values stay unchanged.

Which getter answers which question?

Question Target and node Space Output
Where is the whole Actor's root? Actor → Get Actor Location World Vector
Which way is the Actor root oriented? Actor → Get Actor Rotation World Rotator
What is the Actor root's full pose and scale? Actor → Get Actor Transform World Transform
Where is this exact mesh/camera/collision component? Scene Component → Get World Location World Vector
Which way is this exact component oriented? Scene Component → Get World Rotation World Rotator
What is this exact component's full world transform? Scene Component → Get World Transform World Transform
What offset does this component keep from its parent? Scene Component → relative location/rotation/transform getters Parent/relative Vector, Rotator, or Transform

The word World is explicit on the component nodes. Actor getters omit the word, but their normal result is world space too.

What the Actor getters actually read

A normal Actor/component relationship is:

flowchart TD
    Actor[Actor]
    Root[Root Scene Component<br/>Actor transform source]
    Mesh[Mesh child<br/>own world + relative transform]
    Camera[Camera child<br/>own world + relative transform]

    Actor --> Root
    Root --> Mesh
    Root --> Camera

The engine behavior can be read as:

pseudocode - not engine source

GetActorLocation():
    if RootComponent exists:
        return RootComponent world location
    return (0, 0, 0)

GetActorRotation():
    if RootComponent exists:
        return RootComponent world rotation
    return zero rotation

GetActorTransform():
    if RootComponent exists:
        return RootComponent component-to-world transform
    return identity transform

Most placed and spawned gameplay Actors have a root. The neutral rootless fallback is an unusual valid-Actor case; it is not the same as trying to call a node on a None Actor reference.

Actor does not mean visible mesh

For a Character:

BP_PlayerCharacter
-> CapsuleComponent (root)
   -> Mesh
   -> SpringArm
      -> Camera

Get Actor Location reports the capsule root origin. It does not report the skeletal mesh origin, the feet, head, camera, or weapon muzzle. Those are different components or sockets with different transforms.

This explains a common offset that looks like an engine mistake:

Actor location Z = capsule center
Mesh world location Z = mesh component origin after its relative offset
Foot socket Z = current animated foot position

All three can be correct at the same moment.

Component world vs relative values

A Scene Component stores a relative transform and maintains a component-to-world transform after applying its attachment chain:

pseudocode - not engine source

ComponentWorldTransform =
    ParentWorldTransform combined with ComponentRelativeTransform

Therefore:

  • changing the parent can change the child's world result without changing the child's relative numbers;
  • changing the child's relative transform changes its world result;
  • reattaching with Keep World can preserve world values while Unreal computes new relative values; and
  • reattaching with Keep Relative can preserve the relative numbers while the world result jumps under the new parent.

An unattached/root component often has relative values that look the same as world values. That coincidence is not a safe reason to treat the spaces as interchangeable. A component can also use absolute location, rotation, or scale for selected channels, which changes how its stored "relative" value is interpreted.

Root and attached Actors

An Actor's root component can itself be attached to a component on another Actor. Get Actor Transform still returns the root's resulting world transform. The attachment parent and the root's relative transform explain how that world result was produced.

For a sword Actor attached to a hand socket:

Sword Get Actor Transform
-> sword root's current world transform

Sword root Get Relative Transform
-> sword root's offset from the hand/socket attachment parent

Use the world result to spawn an effect at the current sword pose. Use the relative result to preserve or edit its attachment offset.

Location is an origin, not a surface or center

Every transform has an origin. Where that origin sits depends on component setup and imported asset pivots.

Get Actor Location does not promise:

  • the visual center of all meshes;
  • the center or nearest point of collision;
  • the bottom of a capsule or a Character's foot location;
  • the center of Actor bounds;
  • a named skeletal/static-mesh socket;
  • the active camera viewpoint; or
  • a NavMesh/path position.

If an imported Static Mesh pivot is at one corner, the mesh component's world location is that pivot—even though most visible geometry lies to one side. If an Actor contains several spread-out components, the root can sit outside the combined visual bounds.

Choose a purpose-specific source when the distinction matters: Actor bounds, collision closest point, socket transform, camera view point, or a trace hit.

When scale matters

Get Actor Location and Get Actor Rotation omit scale. Get Actor Transform includes world location, rotation, and scale together.

Scale matters when you:

  • transform a local point into world space;
  • reproduce a complete placement with Spawn Actor from Class;
  • attach or save an item whose size is meaningful;
  • transform offsets through a scaled parent;
  • compare component world and relative transforms; or
  • need a complete input for Set Actor Transform.

Example:

Marker Get Actor Transform
-> Spawn Actor from Class Spawn Transform

That copies the marker's scale too. If spawned gameplay objects must always use unit scale (1, 1, 1), build the spawn transform intentionally from only the location and rotation instead of unknowingly copying scaled level art.

Non-uniform scale plus rotation makes hand-written add/subtract math especially fragile. Use Transform Location, Inverse Transform Location, and relative- transform nodes rather than guessing component offsets.

Snapshots, not live references

Blueprint Vector, Rotator, and Transform pins carry values. This graph:

BeginPlay
-> Get Actor Transform
-> save as InitialTransform

stores the Actor's transform at BeginPlay. Moving the Actor later does not change InitialTransform.

Likewise:

Get World Location(CameraComponent)
-> save as OldCameraLocation

does not make OldCameraLocation follow the camera. Query again when you need the current value.

That distinction is useful for:

  • checkpoint/return positions;
  • before-and-after movement comparisons;
  • interpolation start/end values;
  • SaveGame placement data; and
  • spawn transforms.

It is also a trap. A saved transform does not retain the parent relationship, attachment socket, velocity, movement mode, or reference to the source object.

Saving world vs relative transforms

Choose what the save data means:

Saved value Rebuild requirement
World transform Restore into the intended world/map coordinate system. Parent motion since save is ignored.
Relative transform Recreate the same parent/socket relationship before applying the offset.
Object reference only The object must still exist/be resolvable; its transform is read live later.

For an attached inventory item, saving only its relative offset without the parent/socket identity is incomplete. Saving only its world transform may put it back in the level instead of back in the hand.

Spawn transforms and moving roots

Spawn Actor from Class consumes a transform value. The new Actor does not stay linked to the marker that supplied it:

SpawnPoint Get Actor Transform   // snapshot now
-> Spawn Actor from Class

move SpawnPoint later
-> already-spawned Actor does not follow

Use attachment when the new Actor should continue following something. Use a fresh getter each time when repeated spawns should use the marker's current pose.

Changing an Actor's root component changes which component represents the Actor transform. Changing only a child mesh's relative offset changes the mesh's world transform but leaves Actor location/rotation sourced from the same root.

When it fails (and what failure does)

These are pure queries with no success pin and no side effects.

Target reference is None

Blueprint cannot invoke an Actor/component getter on None. It reports an Accessed None-style runtime diagnostic and the unfilled value output can look like its default:

Vector    -> (0, 0, 0)
Rotator   -> (0, 0, 0)
Transform -> identity-like default

Do not use Location != (0, 0, 0) as a validity test—the world origin is a perfectly valid location. Validate the object reference before the getter.

Valid Actor has no root

A valid but rootless Actor receives the neutral actor-getter fallback described above. This is uncommon for placeable gameplay Actors, but again means neutral values are not proof that the target reference was invalid.

Correct value, wrong source

The most common "failure" is querying the wrong level of the hierarchy:

  1. Actor root when you wanted a child mesh or camera.
  2. Child component when you wanted the whole Actor.
  3. World transform when your operation expects a parent-relative offset.
  4. Mesh pivot when you wanted bounds, a socket, or a hit point.
  5. A transform cached earlier when you wanted the current frame.
  6. Player body transform when you wanted controller aim or camera view.

Print both the target object's name and the values while debugging. A plausible vector from the wrong component is harder to notice than a runtime error.

The pattern everyone actually uses

Spawn at a marker's current pose:

Is Valid(SpawnMarker)
-> SpawnMarker: Get Actor Transform
-> Spawn Actor from Class

Trace from a particular component:

CameraComponent: Get World Location -> Trace Start
CameraComponent: Get World Rotation -> Get Forward Vector
Trace End = Start + Forward * Distance

Move one child relative to its parent:

DoorPanel component: Get Relative Rotation
-> build desired relative rotation
-> Set Relative Rotation on DoorPanel

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

const FTransform ActorWorld = Pickup->GetActorTransform();
const FTransform MeshWorld = Pickup->GetMesh()->GetComponentTransform();
const FTransform MeshRelative = Pickup->GetMesh()->GetRelativeTransform();

Those can all differ and still be correct.

What these getters do not do

They do not:

  • move, attach, spawn, or cache the target;
  • return a live reference in Blueprint;
  • choose the visible or collision center;
  • find a socket or bone;
  • convert world values into relative values automatically;
  • include velocity, movement mode, or parent identity in a Transform;
  • validate that a saved transform still makes sense in another map; or
  • guarantee that two machines have received the same replicated pose this frame.

They are side-effect-free snapshots of transform state available on the local object copy at the moment of the call.

Lookalikes - which one do I want?

Node / value Use when Watch out
Get Actor Location / Rotation You need the Actor root's world position/orientation only. No scale; not a child component or viewpoint.
Get Actor Transform You need the root's complete world pose including scale. Copy is not a live link.
Get World Location / Rotation / Transform You need one exact Scene Component in world space. Target the correct component reference.
Get Relative Location / Rotation / Transform You need a component's offset from its attach parent. Meaning depends on the parent/socket and absolute flags.
Get Actor Bounds You need a combined world-space bounds center/extent. Bounds center is not Actor pivot.
Socket transform getters You need a named socket/bone on a mesh/component. Socket names and animation pose matter.
Get Player View Point You need a PlayerController's current view location and rotation. Not the pawn root or necessarily a Camera Component transform.
Get Velocity You need motion per second. A transform snapshot has no velocity.
Set Actor / Component Transform You intend to change placement. Getter nodes are read-only.

Rule of thumb: Actor means root; component means that component; world means level coordinates; relative means parent offset.

Going deeper