Struct Transform 

#[repr(C)]
pub struct Transform {
    pub position: Vec3,
    pub rotation: Quat,
    pub scale: Vec3,
}

A 3D spatial transformation component.

Represents position, rotation, and scale in 3D space. This is the primary component for positioning entities in the game world.

Memory Layout

The component is laid out as:

• position: 3 x f32 (12 bytes)
• rotation: 4 x f32 (16 bytes) - quaternion (x, y, z, w)
• scale: 3 x f32 (12 bytes)
• Total: 40 bytes

Example

use goud_engine::ecs::components::Transform;
use goud_engine::core::math::Vec3;

// Create at origin with default rotation and scale
let mut transform = Transform::default();

// Or create with specific position
let transform = Transform::from_position(Vec3::new(10.0, 0.0, 0.0));

// Or with full control
let transform = Transform::new(
    Vec3::new(10.0, 5.0, 0.0),     // position
    Transform::IDENTITY_ROTATION,   // rotation (identity quaternion)
    Vec3::one(),                    // scale
);

Fields

position: Vec3

Position in world space (or local space if entity has a parent).

rotation: Quat

Rotation as a quaternion (x, y, z, w).

The quaternion should be normalized. Use the rotation methods to ensure this invariant is maintained.

scale: Vec3

Scale along each axis.

A scale of (1, 1, 1) means no scaling. Negative values flip the object along that axis.

Implementations

impl Transform

pub const IDENTITY_ROTATION: Quat = Quat::IDENTITY

Identity rotation (no rotation).

pub const fn new(position: Vec3, rotation: Quat, scale: Vec3) -> Transform

Creates a new Transform with the specified position, rotation, and scale.

pub fn from_position(position: Vec3) -> Transform

Creates a Transform at the specified position with default rotation and scale.

pub fn from_rotation(rotation: Quat) -> Transform

Creates a Transform with the specified rotation and default position/scale.

pub fn from_scale(scale: Vec3) -> Transform

Creates a Transform with the specified scale and default position/rotation.

pub fn from_scale_uniform(scale: f32) -> Transform

Creates a Transform with uniform scale.

pub fn from_position_rotation(position: Vec3, rotation: Quat) -> Transform

Creates a Transform with position and rotation.

pub fn look_at(eye: Vec3, target: Vec3, up: Vec3) -> Transform

Creates a Transform looking at a target position.

Arguments

• eye - The position of the transform
• target - The point to look at
• up - The up direction (usually Vec3::unit_y())

Example

use goud_engine::ecs::components::Transform;
use goud_engine::core::math::Vec3;

let transform = Transform::look_at(
    Vec3::new(0.0, 5.0, 10.0),  // eye position
    Vec3::zero(),               // looking at origin
    Vec3::unit_y(),             // up direction
);

pub fn matrix(&self) -> Matrix4<f32>

Computes the 4x4 transformation matrix.

The matrix represents the combined transformation: Scale * Rotation * Translation (applied in that order when transforming points).

pub fn matrix_inverse(&self) -> Matrix4<f32>

Computes the inverse transformation matrix.

Useful for view matrices or converting world-space to local-space.

impl Transform

pub fn translate(&mut self, offset: Vec3)

Translates the transform by the given offset.

pub fn translate_local(&mut self, offset: Vec3)

Translates the transform in local space.

The offset is rotated by the transform’s rotation before being applied.

pub fn set_position(&mut self, position: Vec3)

Sets the position of the transform.

pub fn rotate(&mut self, rotation: Quat)

Rotates the transform by the given quaternion.

The rotation is applied in world space (rotation is applied after the current rotation).

pub fn rotate_x(&mut self, angle: f32)

Rotates around the X axis by the given angle in radians.

pub fn rotate_y(&mut self, angle: f32)

Rotates around the Y axis by the given angle in radians.

pub fn rotate_z(&mut self, angle: f32)

Rotates around the Z axis by the given angle in radians.

pub fn rotate_axis(&mut self, axis: Vec3, angle: f32)

Rotates around an arbitrary axis by the given angle in radians.

pub fn rotate_local_x(&mut self, angle: f32)

Rotates in local space around the X axis.

pub fn rotate_local_y(&mut self, angle: f32)

Rotates in local space around the Y axis.

pub fn rotate_local_z(&mut self, angle: f32)

Rotates in local space around the Z axis.

pub fn set_rotation_euler(&mut self, pitch: f32, yaw: f32, roll: f32)

Sets the rotation from Euler angles (in radians).

pub fn set_rotation(&mut self, rotation: Quat)

Sets the rotation.

pub fn look_at_target(&mut self, target: Vec3, up: Vec3)

Makes the transform look at a target position.

pub fn set_scale(&mut self, scale: Vec3)

Sets the scale of the transform.

pub fn set_scale_uniform(&mut self, scale: f32)

Sets uniform scale on all axes.

pub fn scale_by(&mut self, factors: Vec3)

Multiplies the current scale by the given factors.

pub fn forward(&self) -> Vec3

Returns the forward direction vector (negative Z in local space).

pub fn right(&self) -> Vec3

Returns the right direction vector (positive X in local space).

pub fn up(&self) -> Vec3

Returns the up direction vector (positive Y in local space).

pub fn back(&self) -> Vec3

Returns the back direction vector (positive Z in local space).

pub fn left(&self) -> Vec3

Returns the left direction vector (negative X in local space).

pub fn down(&self) -> Vec3

Returns the down direction vector (negative Y in local space).

pub fn transform_point(&self, point: Vec3) -> Vec3

Transforms a point from local space to world space.

pub fn transform_direction(&self, direction: Vec3) -> Vec3

Transforms a direction from local space to world space.

Unlike points, directions are not affected by translation.

pub fn inverse_transform_point(&self, point: Vec3) -> Vec3

Transforms a point from world space to local space.

pub fn inverse_transform_direction(&self, direction: Vec3) -> Vec3

Transforms a direction from world space to local space.

pub fn lerp(self, other: Transform, t: f32) -> Transform

Linearly interpolates between two transforms.

Position and scale are linearly interpolated, rotation uses slerp.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Transform

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns a Transform at the origin with no rotation and unit scale.

impl<'de> Deserialize<'de> for Transform

fn deserialize<__D>( __deserializer: __D, ) -> Result<Transform, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Transform> for GlobalTransform

fn from(transform: &Transform) -> GlobalTransform

Converts to this type from the input type.

impl From<Transform> for GlobalTransform

fn from(transform: Transform) -> GlobalTransform

Converts a local Transform to a GlobalTransform.

This is used for root entities where local == global.

impl Mul<&Transform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform) -> GlobalTransform

Performs the * operation.

impl Mul<Transform> for GlobalTransform

type Output = GlobalTransform

The resulting type after applying the * operator.

fn mul(self, rhs: Transform) -> GlobalTransform

Performs the * operation.

impl PartialEq for Transform

fn eq(&self, other: &Transform) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Transform

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Component for Transform

impl Copy for Transform

impl StructuralPartialEq for Transform