Infinity::Types::Spatial::Transform Struct Reference

Complete 3D spatial transformation combining position, rotation, and scale. More...

#include <Transform.hpp>

Public Attributes
Infinity::Types::Math::Vector3	position {0.0f, 0.0f, 0.0f}
	World-space position (translation).
Infinity::Types::Math::Vector4	rotation {0.0f, 0.0f, 0.0f, 1.0f}
	Orientation as a quaternion.
Infinity::Types::Math::Vector3	scale {1.0f, 1.0f, 1.0f}
	Non-uniform scale factors along each axis.

Detailed Description

Complete 3D spatial transformation combining position, rotation, and scale.

Transform represents a full 3D transformation using the standard TRS (Translation, Rotation, Scale) decomposition. This is the fundamental representation for object placement, orientation, and sizing throughout the Infinity Engine's procedural generation systems.

The transform uses:

• Position: Vector3 representing world-space translation (x, y, z)
• Rotation: Vector4 quaternion (x, y, z, w) for orientation without gimbal lock
• Scale: Vector3 for non-uniform scaling along each axis

This decomposition allows for intuitive manipulation while maintaining numerical stability and avoiding gimbal lock issues associated with Euler angles. Quaternion representation enables smooth interpolation and efficient composition.

Common use cases in procedural generation:

• Object instance placement (scatter systems, foliage, rocks, props)
• Procedural building and structure generation
• Animation keyframes and interpolation
• Hierarchical transform chains (parent-child relationships)
• Camera positioning and orientation
• Coordinate system conversions
• Mesh instance transformations

Note

Rotation is stored as a quaternion (x, y, z, w), not Euler angles.

Scale allows non-uniform scaling - use (1, 1, 1) for uniform scaling.

Default values create an identity transform (no translation, no rotation, unit scale).

For quaternion operations, see Math utility functions (quaternionFromEuler, etc.).

Example usage:

// Create a basic transform
Transform tree;
tree.position = Vector3{10.0f, 0.0f, 5.0f};
tree.rotation = quaternionFromEuler(0.0f, randomFloat() * 360.0f, 0.0f);
tree.scale = Vector3{1.0f, randomFloat(0.8f, 1.2f), 1.0f};
 
// Generate scattered object placements
Array<Transform> instances;
for (int i = 0; i < 1000; ++i) {
    Transform inst;
    inst.position = Vector3{
        randomFloat(-100.0f, 100.0f),
        0.0f,
        randomFloat(-100.0f, 100.0f)
    };
    inst.rotation = quaternionFromEuler(
        0.0f,
        randomFloat(0.0f, 360.0f),
        0.0f
    );
    inst.scale = Vector3{1.0f, 1.0f, 1.0f};
    instances.push_back(inst);
}
 
// Use with ProceduralSystem
system->setIn("tree_instances", std::move(instances));
 
// Interpolate between transforms (for animation)
Transform interpolated;
interpolated.position = lerp(start.position, end.position, t);
interpolated.rotation = slerp(start.rotation, end.rotation, t);
interpolated.scale = lerp(start.scale, end.scale, t);
 
// Identity transform (no transformation)
Transform identity;
// position = {0, 0, 0}, rotation = {0, 0, 0, 1}, scale = {1, 1, 1}

Member Data Documentation

position

Infinity::Types::Math::Vector3 Infinity::Types::Spatial::Transform::position {0.0f, 0.0f, 0.0f}

World-space position (translation).

3D vector representing the position of the transformed object in world space. Default: (0, 0, 0) - origin

rotation

Infinity::Types::Math::Vector4 Infinity::Types::Spatial::Transform::rotation {0.0f, 0.0f, 0.0f, 1.0f}

Orientation as a quaternion.

4D vector representing rotation as a quaternion (x, y, z, w). Quaternions avoid gimbal lock and provide smooth interpolation. Default: (0, 0, 0, 1) - identity rotation (no rotation)

Note

Use quaternionFromEuler() to create from Euler angles (degrees).

Use quaternion multiplication for composition.

For interpolation, use slerp() for smooth rotation blending.

scale

Infinity::Types::Math::Vector3 Infinity::Types::Spatial::Transform::scale {1.0f, 1.0f, 1.0f}

Non-uniform scale factors along each axis.

3D vector representing scale multipliers for x, y, and z axes. Default: (1, 1, 1) - no scaling (identity scale)

Note

Values < 1 shrink, values > 1 enlarge.

Negative values cause reflection/mirroring.

Use uniform values (e.g., 2, 2, 2) for proportional scaling.