Skip to content

Set World / Relative Location, Rotation, Scale, and Transform

At a glance

Lives in: Blueprint API / Transformation · Target: one exact Scene Component · World setters: place that component in world space and recompute the relative values needed under its parent · Relative setters: write its offset from the attach parent/socket · Returns: no success Boolean; movement variants expose Sweep Hit Result · Can fail by: doing nothing, stopping partway, or being overwritten later · Official pages: Set World Location, Set Relative Transform, Set Relative Scale 3D, and USceneComponent

These nodes do not move “the Actor” in the abstract. They change the Scene Component connected to Target. If that component is the Actor's root, the Actor and its attached children follow. If it is a door panel, camera, mesh, or collision child, only that component's attachment subtree moves.

The one-minute version

  • Use Set World... when the destination is expressed in level/world coordinates. Unreal calculates the relative values needed to put the target there under its current parent.
  • Use Set Relative... when you mean an offset from the target's attach parent or socket. This is the normal choice for a door panel, weapon grip, camera offset, or other child part.
  • Location and rotation setters preserve scale. Scale setters preserve location and rotation. A full Transform setter writes all three together.
  • World and relative inputs can look identical on an unattached root. They stop being interchangeable as soon as a parent/socket moves, rotates, or scales.
  • Sweep does not test every component that follows the move. For these component-targeted setters, the Scene Component on Target is the swept mover when it has eligible query collision; components attached beneath it follow without their own sweeps.
  • Rotation sweep is currently unsupported. Scale is not swept. Sweep is useful for target-component translation with query collision, not as a general “make an attachment tree safe” switch.
  • Teleport is about physics velocity, not whether the visual change happens instantly. True preserves physics velocity; false can update it from the positional move.
  • Runtime transform changes require suitable mobility—normally Movable. Static components reject runtime movement and can warn in Play-In-Editor.
  • A simulating or welded physics body, movement component, attachment parent, Construction Script, or network correction can take transform ownership and overwrite the value.
  • The setter itself is local. Server-owned replicated Actor/component state must carry shared gameplay movement to other machines.

Pick the target before the node

Consider a door Actor:

BP_Door
-> SceneRoot (root)
   -> FrameMesh
   -> DoorPanelMesh
      -> HandleMesh
   -> InteractionBox
Target What follows the set What does not move
SceneRoot Frame, panel, handle, and interaction box Nothing else in this Actor tree.
DoorPanelMesh Door panel and handle SceneRoot, frame, and sibling interaction box.
HandleMesh Handle only Door panel and every ancestor/sibling.

Changing DoorPanelMesh does not change Get Actor Transform, because the Actor transform comes from SceneRoot. Changing the root does change the Actor transform. If code later replaces the root, a saved reference to the old root remains a component reference but no longer represents whole-Actor placement.

A plain Scene Component has a transform but no geometry. It can be moved and can parent children, but it has nothing to collide with during a sweep. A Primitive Component such as a Box, Capsule, or Mesh can contribute query and physics collision.

World space versus parent-relative space

A normal attached Scene Component stores a relative transform and derives its world transform through the attachment chain:

Component world transform
    = component relative transform combined with parent/socket world transform

Set Relative...

Set Relative Location (100, 0, 0) means “keep this component 100 Unreal Units along its parent's local X axis.” If the parent rotates or moves later, the child follows while preserving that offset.

For a panel hinged at the correct pivot:

Set Relative Rotation(DoorPanel, Pitch 0, Yaw 90, Roll 0)

means 90 degrees relative to the frame/hinge parent. It does not mean world yaw 90 unless the parent basis happens to make those the same.

Set World...

Set World Location takes an absolute level position. When the component has a parent, Unreal works backward from the desired world pose and updates the component's relative values so the resulting world transform reaches that pose.

pseudocode - not engine source

SetWorldTransform(Target, DesiredWorld):
    if Target has a normal attach parent:
        NewRelative = DesiredWorld made relative to ParentSocketWorld
        apply NewRelative to Target
    else:
        apply DesiredWorld directly

The component stays attached. If the parent moves after the call, the child normally follows from its newly calculated relative offset. A world setter is not “detach and stay forever at this world coordinate.”

Absolute location, rotation, and scale

Scene Components can mark location, rotation, and scale as absolute independently. An absolute channel treats its stored “relative” value as world space rather than inheriting that channel from the parent.

This can intentionally make a child follow parent location but ignore parent rotation, for example. It can also explain why a relative setter seems to act world-relative. Inspect Absolute Location, Absolute Rotation, and Absolute Scale before blaming the numbers.

Parent scale matters too. Relative scale is multiplied through the attachment chain; a world-scale setter computes the child value needed under the current parent scale. Non-uniform or negative parent scale combined with rotation can produce unintuitive axes. Prefer normal non-zero parent scale and use complete Transform helpers instead of hand-dividing vectors.

Which setter changes which fields?

Node family Input space Fields replaced Sweep / Hit / Teleport
Set World Location World Location Yes; useful for eligible target-component translation.
Set Relative Location Parent/socket relative Location Yes; same moved-component-only sweep limit.
Set World Rotation World Rotation Pins exist, but rotational sweeping is currently unsupported.
Set Relative Rotation Parent/socket relative Rotation Pins exist, but rotational sweeping is currently unsupported.
Set World Scale 3D World Scale No Sweep/Hit/Teleport pins.
Set Relative Scale 3D Parent/socket relative Scale No Sweep/Hit/Teleport pins.
Set World Transform World Location, rotation, scale Sweep applies to supported translation; rotation/scale are not swept.
Set Relative Transform Parent/socket relative Location, rotation, scale Same movement limits.
Set World/Relative Location and Rotation Named space Location and rotation Convenience pair; same sweep limits.

Use the narrow setter when only one field should change. Rebuilding a full Transform just to change location can accidentally reset scale or rotation to defaults.

All Blueprint wrappers are void operations. An output execution wire means the call ran; it is not proof that the requested transform was fully accepted.

Sweep and Sweep Hit Result

For supported translation, Sweep means “move toward the destination while testing blocking collision along the path.”

Set World Location on the Actor root
Sweep = true

clear path:
    root reaches destination
    attached children follow
    Sweep Hit Result has no blocking hit

blocked path:
    root stops at or before the blocker
    attached children follow to that partial result
    Sweep Hit Result describes the blocking impact

Four limits matter:

  1. Moved component only. The Scene Component connected to Target is the component Unreal attempts to sweep. A query-enabled Primitive Component can therefore sweep even when it is attached as a child, but components attached beneath that target follow without separate collision sweeps. Actor-targeted setters choose the Actor root as their moved component.
  2. Translation only. Current Blueprint docs explicitly say rotation sweep is unsupported. A rotating door can swing through a player even with Sweep checked.
  3. Collision must query. A Scene Component has no shape, and collision-off or Physics-Only setups do not provide the query blocking test Sweep needs.
  4. No pathfinding. Sweep stops at the first blocker; it does not slide or route around it like Character Movement or navigation.

An empty Hit Result does not prove every child cleared the path, and a blocking Hit Result means the requested destination was not fully reached. When exact placement matters, read the target's resulting world/relative transform after the call and compare it with an intentional tolerance.

Moving a query-enabled target can update overlaps along the way. Which overlap or hit events are enabled still depends on collision responses and notification flags; Sweep does not configure those systems.

Teleport and physics velocity

Every setter changes the transform immediately from Blueprint's point of view. The Teleport pin answers a physics-state question:

Teleport Physics meaning
true Preserve the body's current velocity while moving its transform.
false Allow velocity to be updated from the positional change; continuous collision detection can consider the swept volume when relevant.

This does not make a direct setter a good physics controller. When a Primitive Component simulates physics, the solver owns its ongoing pose. Repeatedly forcing a transform can fight velocity, constraints, contacts, and network physics. Use a Physics Handle, force/impulse, constraint, or an intentional teleport according to the design.

Simple bodies can detach when simulation is enabled. Welded children contribute to a parent body and do not behave as independently movable simulated bodies. Move the actual body owner or deliberately change the weld/simulation state before expecting a child setter to control it independently.

Mobility, registration, and construction timing

Mobility

Runtime-moving Scene/Primitive Components should be Movable. A Static component is declared not to move or change in game; Scene Component movement checks can reject the request and emit a Play-In-Editor warning. Stationary is also not the general runtime transform mode—it permits only class-specific changes, not arbitrary movement.

Construction-time placement is different. A Construction Script can establish the authored relative layout while the Actor is being built. That does not make a Static component safe to animate after BeginPlay.

Registration and attachment order

An unregistered runtime component can store transform values, but it has no live render/collision/physics state to sweep. Registration creates those scene representations. Attachment rules can then preserve or overwrite world/relative values.

Choose an order intentionally:

create component
-> register it with the world
-> attach with Keep World or Keep Relative for the desired meaning
-> apply the final relative/world transform

If the transform is set before attachment and the later attach uses Snap rules, the attach operation wins. If Construction Script or initialization code runs again, it can restore authored defaults over a value you tested in the editor.

When it fails (and what failure does)

There is no Boolean Failed pin. Common failure shapes are:

  1. Target is None. Blueprint reports an invalid-reference diagnostic in editor/development play, skips the call, and leaves the world unchanged.
  2. Wrong component. A valid child moves while the Actor root, collision, or visible mesh you meant stays put.
  3. Static/incompatible mobility. The component rejects runtime movement and can log a warning; the output execution wire still continues.
  4. Sweep blocks target translation. The target moves only partway and the Hit Result identifies the blocker.
  5. Sweep has no eligible collision. A plain Scene Component, non-query Primitive Component, or collision-disabled target reaches the destination because nothing was tested.
  6. Parent/absolute flags change the basis. The numbers are accepted but do not mean the space the caller assumed.
  7. Physics, movement, animation, or a constraint owns the next pose. The value appears for one update and is overwritten.
  8. Construction/attachment order overwrites it. A later setup step applies its own transform rules.
  9. Network authority is wrong. A client changes only its local copy and the server later corrects it.

The nodes do not retry, detach, change mobility, disable physics, or promote a child to root. Inspect the Output Log, Hit Result, target component name, mobility, attachment parent, physics state, and final getter value.

The patterns everyone actually uses

Animate a hinged door panel

BeginPlay:
    cache ClosedRotation = DoorPanel.GetRelativeRotation()
    OpenRotation = ClosedRotation + (Yaw 90)

Timeline Update(Alpha):
    NewRotation = Lerp(ClosedRotation, OpenRotation, Alpha)
    Set Relative Rotation(DoorPanel, NewRotation)

DoorPanel is Movable and its pivot/parent defines the hinge. Rotation Sweep does not protect players in the swing arc; choose a collision-safe door design, a blocking/occupancy test, or a physics constraint if physical resistance is required.

Move a simple platform root with a sweep

Timeline Update(Alpha):
    DesiredWorld = Lerp(StartWorld, EndWorld, Alpha)
    Set World Location(PlatformRoot, DesiredWorld, Sweep true, Teleport false)
    if Sweep Hit Result is blocking:
        stop/reverse/report according to platform policy

Here the collision-bearing mover is the Actor root, so the documented sweep path applies. A dedicated movement component may be better when riders, network smoothing, or complex collision response matter.

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

FHitResult Hit;
PlatformRoot->SetWorldLocation(
    DesiredWorldLocation, true, &Hit, ETeleportType::None);

DoorPanel->SetRelativeRotation(
    DesiredRelativeRotation, false, nullptr, ETeleportType::None);

Multiplayer boundary

The setter runs only on the machine executing the graph. It is not a Remote Procedure Call (RPC).

For shared state, the server should own the decision and the transform source:

client interaction request
-> server validates door/platform and requested action
-> server changes authoritative state/transform
-> replication presents the result to clients

Replicate Movement is Actor/root-oriented. It is the normal built-in path for server-owned Actor movement, not a promise that every arbitrary child component setter is network-smoothed.

Scene Component attachment and relative-transform fields have replication support when both the owning Actor and the component participate in replication. That still does not grant a client authority: server property changes flow outward, and a local client set can be overwritten. Runtime-created components must also exist as replicated components on clients.

For a door, a compact replicated state such as Closed, Opening, Open, or Closing is often clearer than streaming a child Transform every frame. The server owns collision/gameplay state; each client can play the same Timeline from the replicated state. For a continuously moving gameplay platform, use an Actor/root movement solution designed for replication and riders.

What these setters do not do

  • They do not find the intended component from an Actor reference.
  • They do not move the whole Actor unless the target is its root.
  • They do not attach, detach, change root, or change absolute flags.
  • They do not make a component Movable or register a runtime component.
  • They do not separately sweep attached-descendant geometry, rotation, or scale.
  • They do not pathfind, accelerate, interpolate, or apply Character Movement.
  • They do not hand ownership away from physics, animation, or a movement component.
  • They do not automatically replicate the function call or grant client authority.
  • They do not return a general success Boolean.

The setter is the final placement operation. The caller still owns target, space, interpolation, collision policy, physics state, and networking.

Lookalikes - which one do I want?

Node / system Use when Important difference
Set World Location/Rotation/Scale/Transform One component must reach an absolute world pose. Keeps attachment and recomputes relative values.
Set Relative Location/Rotation/Scale/Transform A child offset from its parent/socket is the design. Parent motion continues to affect the result.
Set Actor Location/Rotation/Transform Move the Actor through its root component. Actor-targeted wrappers with actor-level return behavior.
Add World / Local / Relative Offset or Rotation Apply a delta to the current component transform. Adds change instead of replacing with a destination.
Attach Component / Actor To Component Establish transform parenting or a socket relationship. Changes the relationship, not only the current pose.
Move Component To A component should interpolate toward a target over time. Latent movement helper; still not a full movement system.
Timeline + Lerp + setter You need authored reversible motion and explicit update policy. You own start/end snapshots and interruption behavior.
Character Movement / AI Move To A Pawn should walk, fall, slide, or pathfind. Movement behavior, prediction, and navigation instead of direct placement.
Physics Handle / Force / Impulse / Constraint A simulated body should stay physics-driven. Works with solver ownership rather than forcing every pose.

Rule of thumb: world is a destination in the level; relative is an offset from the current parent; Actor setters target the root; component setters target exactly the component on the pin.

Going deeper