feat: made Matrix3 more dynamic

lithium-utils/src/lib.rs

@@ -1,5 +1,36 @@
-use std::ops::{Add, Sub};
+use std::fmt::{Debug, Formatter};
+use std::ops::{Add, Index, Mul, Sub};
 
+pub struct Matrix3(Vec<Vector3>);
+
+impl Debug for Matrix3 {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[")?;
+        for coord in 0..3 {
+            for vec in self.0.iter() {
+                write!(f, "  {:06.2}", vec[coord])?;
+            }
+            if coord == 2 {
+                write!(f, "  ]\n")?;
+            } else {
+                write!(f, "\n ")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Matrix3 {
+    pub fn new(i: Vector3, j: Vector3, k: Vector3) -> Self {
+        Self { 0: vec![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,
@@ -17,6 +48,7 @@ impl Vector2 {
     }
 }
 
+#[derive(Debug, Copy, Clone)]
 pub struct Vector3 {
     pub x: f32,
     pub y: f32,
@@ -33,6 +65,18 @@ impl Default for Vector3 {
     }
 }
 
+impl Index<usize> for Vector3 {
+    type Output = f32;
+    fn index(&self, index: usize) -> &Self::Output {
+        match index {
+            0 => &self.x,
+            1 => &self.y,
+            2 => &self.z,
+            _ => panic!("Index {index} is out of bounds in a Vector3!"),
+        }
+    }
+}
+
 impl Add for Vector3 {
     type Output = Self;
     fn add(self, rhs: Self) -> Self::Output {
@@ -45,7 +89,7 @@ impl Add for Vector3 {
 }
 
 impl Sub for Vector3 {
-    type Output = Vector3;
+    type Output = Self;
     fn sub(self, rhs: Self) -> Self::Output {
         Self::Output {
             x: self.x - rhs.x,
@@ -55,12 +99,39 @@ impl Sub for Vector3 {
     }
 }
 
+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 }
     }
+
+    pub fn flatten(&self) -> Vector2 {
+        Vector2::new(self.x, self.y)
+    }
 }
 
+#[derive(Debug)]
 pub struct Vertex {
     pub position: Vector3,
     pub uv: Vector2,