Struct quick_maths::Transform

pub struct Transform<T, const N: usize> {
    pub fwd: Matrix<N, N, T>,
    pub bkwd: Matrix<N, N, T>,
}

Transform type which represents an easily invertible operator. i.e. rotation in 3D, translation, etc.

Fields

fwd: Matrix<N, N, T>

Forward transformation

bkwd: Matrix<N, N, T>

Inverted transformation

Implementations

impl<T: Float, const N: usize> Transform<T, N>

pub fn identity() -> Self

pub fn inv(&self) -> Self

impl<T: Float> Transform<T, 4_usize>

pub fn new(m: Mat4<T>) -> Self

pub fn scale(by: Vec3<T>) -> Self

pub fn rot(axis: Vec3<T>, theta: T) -> Self

pub fn translate(by: Vec3<T>) -> Self

pub fn orthographic(z_near: T, z_far: T) -> Self

pub fn perspective(fov: T, near: T, far: T) -> Self

Perspective transformation

pub fn look_at(pos: Vec3<T>, at: Vec3<T>, up: Vec3<T>) -> Self

A transformation that orients something as if it's looking towards "at" from "pos".

pub fn apply_point(&self, pt: &Vec3<T>) -> Vec3<T>

Applies this transformation as if to a point.

pub fn apply_vec(&self, vec: &Vec3<T>) -> Vec3<T>

Applies this transformation as if applying it to a vector What this means operationally is no transformations.

pub fn apply_normal(&self, n: &Vec3<T>) -> Vec3<T>

Applies this transformation as if applying it to a (surface) normal vector

pub fn apply_ray(&self, r: &Ray3<T>) -> Ray3<T>

Applies this transform to a ray (convenience for applying point to origin and vector to direction)

impl<T: Float> Transform<T, 3_usize>

pub fn scale(by: Vec2<T>) -> Self

pub fn rot(theta: T) -> Self

pub fn translate(by: Vec2<T>) -> Self

pub fn apply_point(&self, v: Vec2<T>) -> Vec2<T>

Trait Implementations

impl<T: Clone, const N: usize> Clone for Transform<T, N>

fn clone(&self) -> Transform<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const N: usize> Copy for Transform<T, N>

impl<T: Debug, const N: usize> Debug for Transform<T, N>

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

Formats the value using the given formatter.

impl<T: Eq, const N: usize> Eq for Transform<T, N>

impl<T: Float, const N: usize> Mul<Transform<T, N>> for Transform<T, N>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, o: Self) -> Self::Output

Performs the * operation.

impl<T: PartialEq, const N: usize> PartialEq<Transform<T, N>> for Transform<T, N>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Transform<T, N>) -> bool

This method tests for !=.

impl<T, const N: usize> StructuralEq for Transform<T, N>

impl<T, const N: usize> StructuralPartialEq for Transform<T, N>