Struct AffineTransform 

#[repr(transparent)]
pub struct AffineTransform(pub Mat4);

Represents a 3D affine transformation (translation, rotation, scale).

This is a semantic wrapper around a Mat4 that guarantees the matrix represents a valid affine transform. It provides a dedicated API for creating and manipulating these transformations.

Tuple Fields

0: Mat4

Implementations

impl AffineTransform

pub const IDENTITY: AffineTransform

The identity transform, which results in no change.

pub fn from_translation(v: Vec3) -> AffineTransform

Creates an AffineTransform from a translation vector.

Arguments

• v - The translation vector to apply

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_translation(Vec3::new(1.0, 2.0, 3.0));
assert_eq!(transform.translation(), Vec3::new(1.0, 2.0, 3.0));

pub fn from_scale(scale: Vec3) -> AffineTransform

Creates an AffineTransform from a non-uniform scale vector.

Arguments

• scale - The scale vector to apply to each axis

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_scale(Vec3::new(2.0, 1.5, 0.5));

pub fn from_rotation_x(angle: f32) -> AffineTransform

Creates an AffineTransform from a rotation around the X axis.

Arguments

• angle - The angle of rotation in radians

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;
use std::f32::consts::PI;

let transform = AffineTransform::from_rotation_x(PI / 2.0);

pub fn from_rotation_y(angle: f32) -> AffineTransform

Creates an AffineTransform from a rotation around the Y axis.

Arguments

• angle - The angle of rotation in radians

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;
use std::f32::consts::PI;

let transform = AffineTransform::from_rotation_y(PI / 2.0);

pub fn from_rotation_z(angle: f32) -> AffineTransform

Creates an AffineTransform from a rotation around the Z axis.

Arguments

• angle - The angle of rotation in radians

Example

use std::f32::consts::PI;
use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_rotation_z(PI / 2.0);

pub fn from_axis_angle(axis: Vec3, angle: f32) -> AffineTransform

Creates an AffineTransform from a rotation around an arbitrary axis.

Uses Rodrigues’ rotation formula to create a rotation matrix.

Arguments

• axis - The axis of rotation (will be normalized automatically)
• angle - The angle of rotation in radians

Example

use std::f32::consts::PI;
use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let axis = Vec3::new(1.0, 1.0, 0.0);
let transform = AffineTransform::from_axis_angle(axis, PI / 4.0);

pub fn from_quat(q: Quaternion) -> AffineTransform

Creates an AffineTransform from a quaternion representing a rotation.

Arguments

• q - The quaternion representing the rotation

Example

use khora_core::math::{Quaternion, Vec3};
use khora_core::math::affine_transform::AffineTransform;
use std::f32::consts::PI;

let q = Quaternion::from_axis_angle(Vec3::Y, PI / 2.0);
let transform = AffineTransform::from_quat(q);

pub fn to_matrix(&self) -> Mat4

Converts the AffineTransform to a Mat4.

This is useful when you need to pass the transformation matrix to shaders or other systems that expect a raw matrix.

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::IDENTITY;
let matrix = transform.to_matrix();

pub fn translation(&self) -> Vec3

Extracts the translation component from the affine transform.

Returns the translation vector representing the position offset applied by this transformation.

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_translation(Vec3::new(1.0, 2.0, 3.0));
assert_eq!(transform.translation(), Vec3::new(1.0, 2.0, 3.0));

pub fn right(&self) -> Vec3

Extracts the right direction vector from the affine transform.

This returns the first column of the transformation matrix (excluding the w component), which represents the transformed positive X-axis direction.

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;
use std::f32::consts::PI;

let transform = AffineTransform::from_rotation_z(PI / 2.0);
let right = transform.right();
// After 90° rotation around Z, right vector points in -Y direction

pub fn up(&self) -> Vec3

Extracts the up direction vector from the affine transform.

This returns the second column of the transformation matrix (excluding the w component), which represents the transformed positive Y-axis direction.

Example

use std::f32::consts::PI;
use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_rotation_x(PI / 2.0);
let up = transform.up();
// After 90° rotation around X, up vector points in -Z direction

pub fn forward(&self) -> Vec3

Extracts the forward direction vector from the affine transform.

This returns the third column of the transformation matrix (excluding the w component), which represents the transformed positive Z-axis direction.

Example

use std::f32::consts::PI;
use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_rotation_y(PI / 2.0);
let forward = transform.forward();
// After 90° rotation around Y, forward vector points in X direction

pub fn rotation(&self) -> Quaternion

Extracts the rotation component as a quaternion.

This method extracts the rotation represented by the upper-left 3x3 portion of the transformation matrix.

Note

This assumes the transform has uniform or no scale. For transforms with non-uniform scale, the result may not represent a pure rotation. In such cases, consider normalizing the direction vectors first.

Example

use khora_core::math::{Quaternion, Vec3};
use khora_core::math::affine_transform::AffineTransform;
use std::f32::consts::PI;

let q = Quaternion::from_axis_angle(Vec3::Y, PI / 2.0);
let transform = AffineTransform::from_quat(q);
let extracted = transform.rotation();
// extracted should be approximately equal to q

pub fn inverse(&self) -> Option<AffineTransform>

Computes the inverse of the affine transformation.

This uses an optimized affine inverse algorithm that’s more efficient than a general matrix inverse, taking advantage of the affine transform structure. Returns None if the transformation is not invertible (e.g., zero scale).

Returns

Some(AffineTransform) if the inverse exists, None otherwise.

Example

use khora_core::math::Vec3;
use khora_core::math::affine_transform::AffineTransform;

let transform = AffineTransform::from_translation(Vec3::new(1.0, 2.0, 3.0));
let inverse = transform.inverse().unwrap();
// The inverse should translate by (-1, -2, -3)

Trait Implementations

impl Clone for AffineTransform

fn clone(&self) -> AffineTransform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AffineTransform

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

Formats the value using the given formatter.

impl Default for AffineTransform

fn default() -> AffineTransform

Returns the identity AffineTransform.

impl From<AffineTransform> for Mat4

fn from(transform: AffineTransform) -> Mat4

Converts the AffineTransform into its inner Mat4.

impl From<Mat4> for AffineTransform

fn from(val: Mat4) -> AffineTransform

Converts a Mat4 into an AffineTransform.

Panics

Panics if the matrix is not a valid affine transformation.

impl PartialEq for AffineTransform

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

impl StructuralPartialEq for AffineTransform