150 lines
2.9 KiB
Rust
150 lines
2.9 KiB
Rust
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,
|
|
}
|
|
|
|
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 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 {
|
|
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 }
|
|
}
|
|
|
|
pub fn flatten(&self) -> Vector2 {
|
|
Vector2::new(self.x, self.y)
|
|
}
|
|
}
|
|
|
|
#[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,
|
|
}
|
|
}
|
|
}
|