Struct Transform2D 

#[repr(C)]
pub struct Transform2D {
    pub position: Vec2,
    pub rotation: f32,
    pub scale: Vec2,
}

A 2D spatial transformation component.

Represents position, rotation, and scale in 2D space. This is the primary component for positioning entities in 2D games.

Memory Layout

The component is laid out as:

• position: 2 x f32 (8 bytes)
• rotation: f32 (4 bytes)
• scale: 2 x f32 (8 bytes)
• Total: 20 bytes

Example

use goud_engine::ecs::components::Transform2D;
use goud_engine::core::math::Vec2;

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

// Or create with specific position
let transform = Transform2D::from_position(Vec2::new(100.0, 50.0));

// Or with full control
let transform = Transform2D::new(
    Vec2::new(100.0, 50.0),  // position
    0.0,                      // rotation (radians)
    Vec2::one(),              // scale
);

Fields

position: Vec2

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

rotation: f32

Rotation angle in radians (counter-clockwise).

scale: Vec2

Scale along each axis.

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

Implementations

impl Transform2D

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

Translates the transform by the given offset in world space.

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

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: Vec2)

Sets the position of the transform.

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

Rotates the transform by the given angle in radians.

pub fn rotate_degrees(&mut self, degrees: f32)

Rotates the transform by the given angle in degrees.

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

Sets the rotation angle in radians.

pub fn set_rotation_degrees(&mut self, degrees: f32)

Sets the rotation angle in degrees.

pub fn rotation_degrees(&self) -> f32

Returns the rotation angle in degrees.

pub fn look_at_target(&mut self, target: Vec2)

Makes the transform look at a target position.

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

Sets the scale of the transform.

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

Sets uniform scale on both axes.

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

Multiplies the current scale by the given factors.

pub fn forward(&self) -> Vec2

Returns the forward direction vector (positive X axis after rotation).

pub fn right(&self) -> Vec2

Returns the right direction vector (positive Y axis after rotation).

This is perpendicular to forward, rotated 90 degrees counter-clockwise.

pub fn backward(&self) -> Vec2

Returns the backward direction vector (negative X axis after rotation).

pub fn left(&self) -> Vec2

Returns the left direction vector (negative Y axis after rotation).

pub fn matrix(&self) -> Mat3x3

Computes the 3x3 transformation matrix.

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

pub fn matrix_inverse(&self) -> Mat3x3

Computes the inverse transformation matrix.

Useful for converting world-space to local-space.

pub fn to_mat4(&self) -> [f32; 16]

Converts to a 4x4 matrix for use with 3D rendering APIs.

The result places the 2D transform in the XY plane at Z=0.

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

Transforms a point from local space to world space.

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

Transforms a direction from local space to world space.

Unlike points, directions are not affected by translation.

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

Transforms a point from world space to local space.

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

Transforms a direction from world space to local space.

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

Linearly interpolates between two transforms.

Position and scale are linearly interpolated, rotation uses shortest-path angle interpolation.

impl Transform2D

pub const fn new(position: Vec2, rotation: f32, scale: Vec2) -> Transform2D

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

pub fn from_position(position: Vec2) -> Transform2D

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

pub fn from_rotation(rotation: f32) -> Transform2D

Creates a Transform2D at the origin with the specified rotation.

pub fn from_rotation_degrees(degrees: f32) -> Transform2D

Creates a Transform2D with specified rotation in degrees.

pub fn from_scale(scale: Vec2) -> Transform2D

Creates a Transform2D at the origin with the specified scale.

pub fn from_scale_uniform(scale: f32) -> Transform2D

Creates a Transform2D with uniform scale.

pub fn from_position_rotation(position: Vec2, rotation: f32) -> Transform2D

Creates a Transform2D with position and rotation.

pub fn look_at(position: Vec2, target: Vec2) -> Transform2D

Creates a Transform2D looking at a target position.

The transform’s forward direction (positive X after rotation) will point towards the target.

Trait Implementations

impl Clone for Transform2D

fn clone(&self) -> Transform2D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transform2D

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

Formats the value using the given formatter.

impl Default for Transform2D

fn default() -> Transform2D

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

impl<'de> Deserialize<'de> for Transform2D

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Transform2D> for GlobalTransform2D

fn from(transform: &Transform2D) -> GlobalTransform2D

Converts to this type from the input type.

impl From<FfiTransform2D> for Transform2D

fn from(t: FfiTransform2D) -> Transform2D

Converts to this type from the input type.

impl From<Transform2D> for GlobalTransform2D

fn from(transform: Transform2D) -> GlobalTransform2D

Converts a local Transform2D to a GlobalTransform2D.

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

impl Mul<&Transform2D> for GlobalTransform2D

type Output = GlobalTransform2D

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform2D) -> GlobalTransform2D

Performs the * operation.

impl Mul<Transform2D> for GlobalTransform2D

type Output = GlobalTransform2D

The resulting type after applying the * operator.

fn mul(self, rhs: Transform2D) -> GlobalTransform2D

Performs the * operation.

impl PartialEq for Transform2D

fn eq(&self, other: &Transform2D) -> 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 Transform2D

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 Transform2D

impl Copy for Transform2D

impl StructuralPartialEq for Transform2D