refactor(engine): make mesh vertices dynamic

1 files changed, 60 insertions, 57 deletions

diff --git a/engine/src/mesh.rs b/engine/src/mesh.rs
index f26c9c1..a223f60 100644
--- a/engine/src/mesh.rs
+++ b/engine/src/mesh.rs
@@ -1,36 +1,29 @@
-use engine_macros::Reflection;
-use zerocopy::{Immutable, IntoBytes};
+use std::alloc::Layout;
 
-use crate::builder;
 use crate::vector::Vec3;
 
 pub mod cube;
+pub mod vertex_buffer;
 
-#[derive(Debug, Clone, Default)]
+pub const POSITION_VERTEX_ATTRIB_NAME: &str = "pos";
+
+#[derive(Debug, Clone)]
 pub struct Mesh
 {
-    vertices: Vec<Vertex>,
+    vertex_buf: vertex_buffer::VertexBuffer,
     indices: Option<Vec<u32>>,
 }
 
 impl Mesh
 {
-    #[must_use]
-    pub fn new(vertices: Vec<Vertex>, indices: Option<Vec<u32>>) -> Self
+    pub fn builder() -> Builder
     {
-        Self { vertices, indices }
+        Builder::default()
     }
 
-    #[must_use]
-    pub fn vertices(&self) -> &[Vertex]
+    pub fn vertex_buf(&self) -> &vertex_buffer::VertexBuffer
     {
-        &self.vertices
-    }
-
-    #[must_use]
-    pub fn vertices_mut(&mut self) -> &mut [Vertex]
-    {
-        &mut self.vertices
+        &self.vertex_buf
     }
 
     #[must_use]
@@ -49,23 +42,23 @@ impl Mesh
     /// that this can be quite time-expensive if the mesh has many vertices.
     pub fn find_furthest_vertex_positions(&self) -> DirectionPositions
     {
-        let mut point_iter = self
-            .vertices()
-            .iter()
-            .map(|vertex| Vec3::from(vertex.pos))
+        let mut pos_iter = self
+            .vertex_buf()
+            .iter::<[f32; 3]>(POSITION_VERTEX_ATTRIB_NAME)
+            .map(|vertex_pos| Vec3::from(*vertex_pos))
             .into_iter();
 
-        let first_point = point_iter.next().unwrap();
+        let first_pos = pos_iter.next().unwrap();
 
-        point_iter
+        pos_iter
             .fold(
                 FurthestPosAcc {
-                    up: FurthestPos::new(first_point, &Vec3::UP),
-                    down: FurthestPos::new(first_point, &Vec3::DOWN),
-                    left: FurthestPos::new(first_point, &Vec3::LEFT),
-                    right: FurthestPos::new(first_point, &Vec3::RIGHT),
-                    back: FurthestPos::new(first_point, &Vec3::BACK),
-                    front: FurthestPos::new(first_point, &Vec3::FRONT),
+                    up: FurthestPos::new(first_pos, &Vec3::UP),
+                    down: FurthestPos::new(first_pos, &Vec3::DOWN),
+                    left: FurthestPos::new(first_pos, &Vec3::LEFT),
+                    right: FurthestPos::new(first_pos, &Vec3::RIGHT),
+                    back: FurthestPos::new(first_pos, &Vec3::BACK),
+                    front: FurthestPos::new(first_pos, &Vec3::FRONT),
                 },
                 |mut furthest_pos_acc, pos| {
                     furthest_pos_acc.up.update_if_further(pos);
@@ -82,50 +75,60 @@ impl Mesh
     }
 }
 
-builder! {
-#[builder(name = VertexBuilder, derives = (Debug, Default, Clone))]
-#[derive(Debug, Clone, Default, PartialEq, IntoBytes, Immutable, Reflection)]
-#[non_exhaustive]
-pub struct Vertex
+/// Mesh builder
+#[derive(Debug, Clone, Default)]
+pub struct Builder
 {
-    #[builder(skip_generate_fn)]
-    pub pos: [f32; 3],
-
-    #[builder(skip_generate_fn)]
-    pub texture_coords: [f32; 2],
-
-    #[builder(skip_generate_fn)]
-    pub normal: [f32; 3],
-}
+    vertex_buf: vertex_buffer::VertexBuffer,
+    indices: Option<Vec<u32>>,
 }
 
-impl Vertex
+impl Builder
 {
-    #[must_use]
-    pub fn builder() -> VertexBuilder
+    pub fn new() -> Self
     {
-        VertexBuilder::default()
+        Self::default()
     }
-}
 
-impl VertexBuilder
-{
-    pub fn pos(mut self, pos: impl Into<[f32; 3]>) -> Self
+    pub fn vertices(mut self, vertices_bytes: vertex_buffer::VertexBuffer) -> Self
     {
-        self.pos = pos.into();
+        self.vertex_buf = vertices_bytes;
         self
     }
 
-    pub fn texture_coords(mut self, texture_coords: impl Into<[f32; 2]>) -> Self
+    pub fn indices(mut self, indices: impl IntoIterator<Item = u32>) -> Self
     {
-        self.texture_coords = texture_coords.into();
+        self.indices = Some(indices.into_iter().collect());
         self
     }
 
-    pub fn normal(mut self, normal: impl Into<[f32; 3]>) -> Self
+    pub fn build(self) -> Mesh
     {
-        self.normal = normal.into();
-        self
+        Mesh {
+            vertex_buf: self.vertex_buf,
+            indices: self.indices,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum VertexAttrType
+{
+    Float32,
+    Float32Array
+    {
+        length: usize,
+    },
+}
+
+impl VertexAttrType
+{
+    pub fn layout(&self) -> Layout
+    {
+        match self {
+            Self::Float32 => Layout::new::<f32>(),
+            Self::Float32Array { length } => Layout::array::<f32>(*length).unwrap(),
+        }
     }
 }