Transform3

3D affine transform with position, rotation, and scale.

Transform3 represents a 3D transform combining translation, non-uniform scaling, and quaternion-based rotation. It lazily builds a Matrix4 suitable for use as a world transform in scene graphs and rendering code.

Construction

Constructors

Transform3() constexpr

Constructs a transform from a 4×4 affine matrix.

Decomposes the matrix into position, rotation, and scale. See SetFromMatrix for the assumptions the decomposition makes about the input.

Transform3::Transform3(const Matrix4& mat);

Parameter	Description
mat	Affine transform matrix to decompose.

Properties

position Vector3

Translation in 3D space.

Vector3 position {0.0f};

rotation Quaternion

Rotation stored as a unit quaternion.

Quaternion rotation {};

scale Vector3

Non-uniform scale in 3D.

Vector3 scale {1.0f};

touched bool

Dirty flag indicating the cached matrix needs to be recomputed.

bool touched {true};

Functions

Get() Matrix4

Returns the 4×4 transform matrix.

Recomputes the underlying matrix if any component has changed since the last call, then returns the cached Matrix4.

Matrix4 Transform3::Get();

Get() Matrix4

Returns the 4×4 transform matrix without updating the cache.

Computes the matrix on the fly if any component has changed since the last update, otherwise returns the cached Matrix4. The touched flag is not cleared, so a later non-const call still refreshes the cache.

Matrix4 Transform3::Get() const;

GetEuler() Euler

Returns the rotation as Euler angles.

Provided as a convenience for inspection; the conversion is lossy near gimbal lock and only resolves angles within the Euler reconstruction range. The quaternion remains the authoritative representation.

Euler Transform3::GetEuler() const;

LookAt() void

Sets the rotation such that the object looks at a target point.

Computes an orientation that looks from position toward target, using world_up to resolve roll and construct a stable basis.

void Transform3::LookAt(const Vector3& position, const Vector3& target, const Vector3& world_up);

Parameter	Description
position	Object position.
target	Target point to look at.
world_up	World up direction.

Rotate() void

Applies an additional rotation around an axis in local space.

The rotation is composed after the current orientation, so the axis is interpreted in the transform's local frame.

void Transform3::Rotate(const Vector3& axis, float angle);

Parameter	Description
axis	Rotation axis; normalized internally.
angle	Rotation angle in radians.

Scale() void

Scales the transform.

void Transform3::Scale(const Vector3& value);

Parameter	Description
value	Scale factors to apply.

SetFromMatrix() void

Replaces every component with those of a 4×4 affine matrix.

Decomposes the matrix into position, rotation, and scale, inverting the composition performed by Get.

The matrix is assumed to be a translation-rotation-scale affine transform. Shear is not representable and will not survive the round trip. A mirrored basis (negative determinant) is resolved by negating the x scale, and a degenerate basis with a zero-length axis carries no recoverable orientation, so the rotation is left as identity.

void Transform3::SetFromMatrix(const Matrix4& mat);

Parameter	Description
mat	Affine transform matrix to decompose.

SetPosition() void

Sets the translation component.

void Transform3::SetPosition(const Vector3& position);

Parameter	Description
position	New position.

SetRotation() void

Sets the rotation component from Euler angles.

Provided as a convenience; the angles are converted to and stored as a quaternion.

void Transform3::SetRotation(const Euler& rotation);

Parameter	Description
rotation	New Euler rotation.

SetRotation() void

Sets the rotation component.

void Transform3::SetRotation(const Quaternion& rotation);

Parameter	Description
rotation	New rotation quaternion.

SetScale() void

Sets the scale component.

void Transform3::SetScale(const Vector3& scale);

Parameter	Description
scale	New scale factors.

Translate() void

Translates the transform a distance along an axis in local space.

Convenience overload mirroring Rotate. The axis is normalized internally, so distance is a true distance along it. For an arbitrary offset, use the single-vector overload instead.

void Transform3::Translate(const Vector3& axis, float distance);

Parameter	Description
axis	Translation axis; normalized internally.
distance	Distance to translate along the axis.

Translate() void

Translates the transform in local space.

If the rotation is not empty, the input vector is rotated by the current orientation before being added to position.

void Transform3::Translate(const Vector3& value);

Parameter	Description
value	Translation vector.