lithium/lithium-utils/src/lib.rs

use std::fmt::{Debug, Formatter};
use std::ops::{Add, Mul, Sub};

pub struct Matrix3<const C: usize>([Vector3; C]);

impl Debug for Matrix3<3> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        writeln!(
            f,
            "[ {:03.2} {:03.2} {:03.2}",
            self.0[0].x, self.0[1].x, self.0[2].x,
        )?;
        writeln!(
            f,
            "  {:03.2} {:03.2} {:03.2}",
            self.0[0].y, self.0[1].y, self.0[2].y,
        )?;
        writeln!(
            f,
            "  {:03.2} {:03.2} {:03.2} ]",
            self.0[0].z, self.0[1].z, self.0[2].z,
        )?;
        Ok(())
    }
}

impl Matrix3<3> {
    pub fn new(i: Vector3, j: Vector3, k: Vector3) -> Self {
        Self { 0: [i, j, k] }
    }

    pub fn transform(&self, vector: Vector3) -> Vector3 {
        self.0[0] * vector.x + self.0[1] * vector.y + self.0[2] * vector.z
    }
}

#[derive(Debug)]
pub struct Vector2 {
    pub x: f32,
    pub y: f32,
}

impl Default for Vector2 {
    fn default() -> Self {
        Self { x: 0_f32, y: 0_f32 }
    }
}

impl Vector2 {
    pub fn new(x: f32, y: f32) -> Self {
        Self { x, y }
    }
}

#[derive(Debug, Copy, Clone)]
pub struct Vector3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl Default for Vector3 {
    fn default() -> Self {
        Self {
            x: 0_f32,
            y: 0_f32,
            z: 0_f32,
        }
    }
}

impl Add for Vector3 {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Self::Output {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
            z: self.z + rhs.z,
        }
    }
}

impl Sub for Vector3 {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        Self::Output {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
            z: self.z - rhs.z,
        }
    }
}

impl Mul for Vector3 {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        Self::Output {
            x: self.x * rhs.x,
            y: self.y * rhs.y,
            z: self.z * rhs.z,
        }
    }
}

impl Mul<f32> for Vector3 {
    type Output = Self;
    fn mul(self, rhs: f32) -> Self::Output {
        Self::Output {
            x: self.x * rhs,
            y: self.y * rhs,
            z: self.z * rhs,
        }
    }
}

impl Vector3 {
    pub fn new(x: f32, y: f32, z: f32) -> Self {
        Self { x, y, z }
    }
}

#[derive(Debug)]
pub struct Vertex {
    pub position: Vector3,
    pub uv: Vector2,
    pub normal: Vector3,
}

impl Vertex {
    pub fn new(position: Vector3, uv: Vector2, normal: Vector3) -> Self {
        Self {
            position,
            uv,
            normal,
        }
    }
}