Skip to content

Break/Make Vector and Rotator / Transform Location / Inverse Transform Location

At a glance

Lives in: Blueprint struct utilities and Kismet Math Library / Math / Transform - Returns: rebuilt structs, component values, or converted Vector values; never None - Changes: nothing; these nodes only build, split, or calculate values - Fails by: silently producing the wrong value when the supplied Transform owns a different coordinate space, when a position is treated as a direction, or when scale has a zero axis - Official docs: Break Vector, Transform Location, and Inverse Transform Location

The one-minute version

  • Break Vector exposes X, Y, and Z. Make Vector rebuilds a Vector from those numbers. Neither node changes coordinate space.
  • Break Rotator exposes Roll, Pitch, and Yaw in degrees. Make Rotator rebuilds the orientation. A Rotator is not a direction Vector.
  • Right-clicking a struct pin and choosing Split Struct Pin is the compact version of a Make/Break node. Recombine it when the graph becomes noisy.
  • Transform Location uses a Transform to convert a local position to the space that Transform describes, commonly local to world.
  • Inverse Transform Location does the reverse, commonly world to local.
  • A location receives scale, rotation, and translation. A direction must not receive translation.
  • Blueprint Transform Direction applies orientation while preserving vector length, so Transform scale and translation do not affect it.
  • Core C++ FTransform::TransformVector applies scale and rotation but not translation. Use it for a displacement that should inherit scale, not for a pure unit direction.
  • For parent-relative or socket-local data, use the parent or socket world Transform. The Vector alone does not remember which space it belongs to.

Make and Break only change the graph shape

A Blueprint Vector is one struct containing three real numbers:

Break Vector (300, -20, 80)
-> X = 300
-> Y = -20
-> Z = 80

Make Vector
    X = 300
    Y = -20
    Z = 0
-> (300, -20, 0)

This is useful when you need to inspect or replace individual components:

  • keep velocity X/Y but set Z to zero;
  • read only vertical velocity from Z;
  • assemble an offset from separate forward/right/up values;
  • print coordinates independently while debugging.

Break does not modify the input. Make does not move an object. Both return values that another node must consume.

Most struct pins can be split directly:

right-click Vector pin
-> Split Struct Pin
-> X / Y / Z appear on the original node

Use a separate Break node when the same components feed several places or the named intermediate value improves readability. Split a pin for one small local edit. Avoid breaking and immediately remaking a value when no component changes.

Rotator components are not Vector axes

A Rotator stores three Euler angles in degrees:

Component Rotation meaning
Yaw turn around Z, usually left/right heading
Pitch rotate around Y, usually look up/down
Roll rotate around X, usually tilt around forward

A common ground-heading pattern is:

Get Control Rotation
-> Break Rotator
-> Make Rotator
     Roll = 0
     Pitch = 0
     Yaw = original Yaw
-> Get Forward Vector

Make Rotator expects Roll, Pitch, and Yaw angle values. Do not connect a direction Vector's X/Y/Z values as if they were those angles. To turn a direction into an orientation, use Make Rot from X, Find Look at Rotation, or another direction-to-rotation node.

Euler angles can wrap: 0 and 360 degrees describe the same full-turn orientation, and several Euler triples can represent the same orientation. For angular differences, use Rotator-aware delta/normalization nodes rather than subtracting three components blindly.

A Transform owns a coordinate conversion

A Transform bundles:

Location (translation)
Rotation
Scale

It can answer: "Where does this local point land after this object is scaled, rotated, and placed?"

For a position, the conceptual order is:

WorldPoint = Translation + Rotate(Scale * LocalPoint)

Example Transform:

Location = (100, 0, 0)
Rotation = (Pitch 0, Yaw 90, Roll 0)
Scale    = (2, 2, 2)

Transforming local point (10, 0, 0):

scale     -> (20, 0, 0)
rotate    -> (0, 20, 0)
translate -> (100, 20, 0)

Transform Location performs that local-to-world-style operation when the input Transform is an Actor or component's world Transform.

The node does not know that the values are truly local or world. Those meanings come from your data. Feeding a world location into Transform Location as if it were local applies the Transform a second time.

Transform Location: local point to world point

Typical shape:

OwnerTransform = SomeActor.GetActorTransform
LocalOffset = (100, 0, 50)

WorldPoint = Transform Location(OwnerTransform, LocalOffset)

The result is the point 100 local units forward and 50 local units up from the Actor, including its world rotation and scale.

Choose the Transform that owns the local point:

Local value means Transform to supply
offset from an Actor root Actor world Transform
offset from a Scene Component component world Transform
offset from a parent component parent component world Transform
offset from a socket socket world Transform
offset authored in another helper Transform that helper Transform

Using the child Transform for a parent-local offset applies the wrong frame. Using Actor Transform for a muzzle offset can be wrong when the weapon or mesh has its own rotation.

Inverse Transform Location: world point to local point

The inverse node answers the opposite question:

LocalPoint = Inverse Transform Location(OwnerWorldTransform, WorldPoint)

Conceptually, it removes translation, undoes rotation, and removes scale. With a valid invertible Transform, the two operations round-trip:

LocalPoint
-> Transform Location with T
-> WorldPoint
-> Inverse Transform Location with the same T
-> approximately LocalPoint

Floating-point round trips can differ by tiny amounts, so use tolerances when comparing results.

Useful inverse-transform questions include:

  • is a world target in front of this Actor in local X?
  • where is a hit point relative to this component?
  • what parent-relative offset corresponds to this world location?
  • where should saved world data land in a rebuilt local frame?

Simple subtraction is not equivalent once rotation or scale is involved:

WorldPoint - OwnerLocation

removes translation only. Inverse Transform Location also accounts for the owner's rotation and scale.

Position, displacement, and direction

All three can use a Vector pin, but they have different transform rules:

Meaning Apply translation? Apply rotation? Apply scale? General operation
Position/location yes yes yes Transform Location
Scaled displacement/vector no yes yes C++ FTransform::TransformVector
Direction no yes no Blueprint Transform Direction

Why translation is wrong for a direction:

LocalForward = (1, 0, 0)

This means an axis, not a point near world origin. Moving the owner from world X 100 to 10000 should not change which way its forward points.

Blueprint Transform Direction and Inverse Transform Direction preserve the input's length. They apply the Transform's orientation but ignore translation and scale:

WorldDirection = Transform Direction(OwnerTransform, LocalDirection)
LocalDirection = Inverse Transform Direction(OwnerTransform, WorldDirection)

At the C++ FTransform level, TransformVector is a different operation: it applies scale and rotation but no translation. Its no-scale counterpart, TransformVectorNoScale, matches direction semantics.

Non-uniform and zero scale

Uniform scale (2, 2, 2) doubles every local offset equally. Non-uniform scale such as (2, 1, 0.5) changes each local axis differently.

That matters in three ways:

  1. Transform Location correctly includes that axis scale before rotation.
  2. A scale-aware TransformVector can change both vector length and direction. Local (1, 1, 0) scaled by (2, 1, 1) becomes (2, 1, 0) before rotation.
  3. Transform Direction deliberately ignores scale and keeps the direction's length unchanged.

If you use a scale-aware transformed vector as a direction, safely normalize afterward. If scale should not influence it at all, use direction/no-scale semantics from the start.

A zero scale axis is not invertible: information on that local axis was collapsed. Unreal uses safe reciprocal behavior rather than producing an infinite value, but an inverse transform cannot reconstruct what zero scale destroyed. Do not rely on a location round-trip through (0, 1, 1) scale.

Negative scale can mirror an axis and flip handedness. Inspect socket/component axes when mirrored assets produce reversed offsets or directions.

Relative Actor and component transforms

"Relative" needs a named parent. To convert one world point into a parent's local space:

ParentWorldTransform = ParentComponent.GetWorldTransform
ChildLocalPoint = Inverse Transform Location(
    ParentWorldTransform,
    ChildWorldPoint)

To rebuild the point:

ChildWorldPoint = Transform Location(
    ParentWorldTransform,
    ChildLocalPoint)

For a whole child Transform, use Make Relative Transform rather than converting location alone:

ChildRelativeTransform = Make Relative Transform(
    ChildWorldTransform,
    ParentWorldTransform)

That preserves the location, rotation, and scale relationship. See World vs relative transforms for Actor roots, Scene Component parents, and attachment rules.

These math nodes do not create an attachment or update a component's Relative Location property. Attach Actor To Component, Set Relative Location, and related transformation nodes perform those state changes.

Socket transforms and offsets

A socket already lives in a mesh/bone hierarchy. Ask the mesh for the socket Transform in world space when placing or spawning in the world:

SocketWorldTransform = Mesh.GetSocketTransform(SocketName, World)
MuzzleWorldPoint = Transform Location(
    SocketWorldTransform,
    LocalMuzzleOffset)

With LocalMuzzleOffset = (0, 0, 0), the result is the socket origin. A small positive local X offset moves along the socket's own forward axis.

Do not transform a socket world location through its world Transform again. It is already a world point. Also verify the Transform Space option on Get Socket Transform; a socket Transform requested in component space has a different contract from one requested in world space.

Make Transform is packaging, not movement

Make Transform bundles a Location, Rotator, and Scale into one value:

SpawnTransform = Make Transform
    Location = SpawnPoint
    Rotation = SpawnRotation
    Scale    = (1, 1, 1)

Scale (1, 1, 1) means no scale change. Scale (0, 0, 0) collapses all axes; it is not an identity default to use deliberately.

Making a Transform does not move or spawn anything. Pass it to a consumer such as Spawn Actor from Class, transform math, or a set-transform node. Likewise, breaking a Transform only reads its stored components.

Failure and debugging

Make, Break, and transform-math nodes do not return None or expose failure execution pins. Wrong-space bugs usually look like a plausible but displaced, rotated, scaled, or mirrored result.

Inspect these values together:

  1. the Transform's owner and whether it is world or relative;
  2. Transform Location, Rotation, and Scale;
  3. the input Vector and its declared meaning: point, displacement, direction;
  4. the output Vector;
  5. a round-trip through the inverse node;
  6. socket Transform Space, if a socket is involved.

If Get Actor Transform or Get World Transform is called on a None target, that earlier reference call can produce Accessed None. The math result itself is not nullable. Use Is Valid on uncertain object references before asking them for transforms.

The C++ twins

For the curious, the corresponding FTransform operations are:

const FTransform OwnerTransform = Owner->GetActorTransform();

const FVector WorldPoint = OwnerTransform.TransformPosition(LocalPoint);
const FVector LocalRoundTrip =
    OwnerTransform.InverseTransformPosition(WorldPoint);

const FVector WorldDirection =
    OwnerTransform.TransformVectorNoScale(LocalDirection);

const FVector ScaledWorldDisplacement =
    OwnerTransform.TransformVector(LocalDisplacement);

Use TransformPosition for a point, TransformVectorNoScale for a direction, and TransformVector for a displacement that should inherit scale.

Lookalikes - which one do I want?

Node/operation Use when Watch out
Break / Make Vector Read or rebuild X/Y/Z values. Does not convert coordinate space.
Break / Make Rotator Read or rebuild Roll/Pitch/Yaw angles. Direction components are not angles.
Make Transform Bundle Location/Rotation/Scale for another node. Does not apply the Transform.
Transform Location Convert a local position through a Transform. Includes translation and scale.
Inverse Transform Location Convert a position back into the Transform's local space. Zero scale loses information.
Transform Direction Rotate a direction between spaces without changing length. Ignores translation and scale.
Make Relative Transform Express one whole Transform relative to another. Both inputs must begin in the same space.
Set Relative Location Actually change a component's parent-relative position. This is a state-changing component node, not pure math.

Going deeper