Transform

The Transform namespace — 31 functions.

globals/Transform/direction

globals/Transform/direction(fromX: number, fromY: number, fromZ: number, toX: number, toY: number, toZ: number) -> (number, number, number)

Normalized direction vector from point A to point B. Returns zeros when the two points coincide (within ~0.001 units).

globals/Transform/directionBetween

globals/Transform/directionBetween(entityA: EntityRef, entityB: EntityRef) -> (number, number, number)

Normalized direction from one entity to another. Returns zeros if either entity can't be resolved.

globals/Transform/distance

globals/Transform/distance(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) -> number

Euclidean distance between two world-space positions.

globals/Transform/distanceBetween

globals/Transform/distanceBetween(entityA: EntityRef, entityB: EntityRef) -> number?

Distance between two entities in world space.

globals/Transform/euler

globals/Transform/euler(qx: number, qy: number, qz: number, qw: number) -> (number, number, number)

Convert quaternion to euler angles (yaw, pitch, roll) in radians.

globals/Transform/eulerToQuat

globals/Transform/eulerToQuat(yaw: number, pitch: number?, roll: number?) -> (number, number, number, number)

Identity-aware overload of euler-to-quaternion. Uses the negative-yaw convention shared with quatFromYaw, quatFromYawPitch, lookAtQuat, and T.euler extraction — so T.euler(T.eulerToQuat(y, p, r)) returns (y, p, r). Order is yaw (Y) then pitch (X) then roll (Z).

globals/Transform/lerp

globals/Transform/lerp(ax: number, ay: number, az: number, bx: number, by: number, bz: number, t: number) -> (number, number, number)

Linearly interpolate between two positions.

globals/Transform/lerp1

globals/Transform/lerp1(a: number, b: number, t: number) -> number

Linearly interpolate two scalars.

globals/Transform/lerpAngle

globals/Transform/lerpAngle(a: number, b: number, t: number) -> number

Lerp between two angles via the shortest arc; returns a value in [-pi, pi].

globals/Transform/localToWorld

globals/Transform/localToWorld(px: number, py: number, pz: number, pqx: number, pqy: number, pqz: number, pqw: number, lx: number, ly: number, lz: number) -> (number, number, number)

Transform a local-space position into world space using a parent pose.

globals/Transform/lookAt

globals/Transform/lookAt(entityOrId: EntityRef, txOrTarget: number | string, ty: number?, tz: number?)

Make an entity face a world position. The target slot accepts either three explicit coordinates or an entity id whose position is resolved.

globals/Transform/lookAtQuat

globals/Transform/lookAtQuat(fx: number, fy: number, fz: number, tx: number, ty: number, tz: number) -> (number?, number?, number?, number?)

Compute quaternion to look from origin position toward a target. Returns four components (qx, qy, qz, qw), or nil when the from and to points are too close to derive a meaningful direction.

globals/Transform/normalizeAngle

globals/Transform/normalizeAngle(a: number) -> number

Normalize an angle into [-pi, pi].

globals/Transform/orbit

globals/Transform/orbit(centerX: number, centerY: number, centerZ: number, radius: number, height: number, angle: number) -> (number, number, number, number, number, number, number)

Position + rotation for orbiting around a center point. Returns the world position followed by the orientation that faces the center.

globals/Transform/quatFromAxisAngle

globals/Transform/quatFromAxisAngle(ax: number, ay: number, az: number, angle: number) -> (number, number, number, number)

Create quaternion from axis and angle (radians). Returns the identity quaternion when the axis is degenerate (length < 0.001).

globals/Transform/quatFromYaw

globals/Transform/quatFromYaw(yaw: number) -> (number, number, number, number)

Create quaternion from yaw (Y-axis rotation) in radians. Uses the negative-yaw convention shared with quatFromYawPitch, lookAtQuat, and T.euler extraction — so T.euler(T.quatFromYaw(y)) round-trips to y.

globals/Transform/quatFromYawPitch

globals/Transform/quatFromYawPitch(yaw: number, pitch: number) -> (number, number, number, number)

Create quaternion from yaw and pitch in radians.

globals/Transform/quatIdentity

globals/Transform/quatIdentity() -> (number, number, number, number)

Identity quaternion (0, 0, 0, 1).

globals/Transform/quatInverse

globals/Transform/quatInverse(qx: number, qy: number, qz: number, qw: number) -> (number, number, number, number)

Quaternion inverse. Equal to the conjugate for unit quaternions.

globals/Transform/quatMul

globals/Transform/quatMul(ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number) -> (number, number, number, number)

Quaternion multiplication: returns qa * qb (composition: rotate by qb then qa).

globals/Transform/quatRotateVec

globals/Transform/quatRotateVec(qx: number, qy: number, qz: number, qw: number, vx: number, vy: number, vz: number) -> (number, number, number)

Rotate a 3-vector by a quaternion.

globals/Transform/quatToEuler

globals/Transform/quatToEuler(qx: number, qy: number, qz: number, qw: number) -> (number, number, number)

Convert quaternion to (yaw, pitch, roll). Alias of euler with the explicit name so callers don't have to remember the order.

globals/Transform/slerp

globals/Transform/slerp(ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number, t: number) -> (number, number, number, number)

Spherical linear interpolation between two quaternions. Picks the shortest path (flips sign if dot < 0). Falls back to lerp+normalize when the two quats are very close (avoids div-by-zero on near-parallel inputs).

globals/Transform/vec/add

globals/Transform/vec.add(ax: number, ay: number, az: number, bx: number, by: number, bz: number) -> (number, number, number)

Component-wise vec3 addition.

globals/Transform/vec/cross

globals/Transform/vec.cross(ax: number, ay: number, az: number, bx: number, by: number, bz: number) -> (number, number, number)

Cross product a x b.

globals/Transform/vec/dot

globals/Transform/vec.dot(ax: number, ay: number, az: number, bx: number, by: number, bz: number) -> number

Dot product of two vec3s.

globals/Transform/vec/length

globals/Transform/vec.length(x: number, y: number, z: number) -> number

Euclidean length of a vec3.

globals/Transform/vec/normalize

globals/Transform/vec.normalize(x: number, y: number, z: number) -> (number, number, number)

Normalize a vec3. Returns zeros when the input is degenerate (length < 1e-8).

globals/Transform/vec/scale

globals/Transform/vec.scale(x: number, y: number, z: number, s: number) -> (number, number, number)

Component-wise scalar multiplication of a vec3.

globals/Transform/vec/sub

globals/Transform/vec.sub(ax: number, ay: number, az: number, bx: number, by: number, bz: number) -> (number, number, number)

Component-wise vec3 subtraction (a - b).

globals/Transform/worldToLocal

globals/Transform/worldToLocal(px: number, py: number, pz: number, pqx: number, pqy: number, pqz: number, pqw: number, wx: number, wy: number, wz: number) -> (number, number, number)

Transform a world-space position into a parent's local space.