feat: add path_geometry data

packages/utils/src/geometry/extrude_path.rs

@@ -1,4 +1,4 @@
-use super::{create_geometry_data, wrap_geometry_data};
+use super::{create_geometry_data, wrap_geometry_data, PathData};
 use glam::{Mat4, Vec3};
 
 fn create_circle(res: usize) -> Vec<f32> {
@@ -11,8 +11,8 @@ fn create_circle(res: usize) -> Vec<f32> {
     circle
 }
 
-pub fn extrude_path(input_path: &[i32], res_x: usize) -> Vec<i32> {
-    let point_amount = input_path.len() / 4;
+pub fn extrude_path(input_path: PathData, res_x: usize) -> Vec<i32> {
+    let point_amount = input_path.points.len() / 4;
     let face_amount = (point_amount - 1) * res_x * 2;
     let vertices_amount = point_amount * res_x;
 
@@ -26,12 +26,9 @@ pub fn extrude_path(input_path: &[i32], res_x: usize) -> Vec<i32> {
     let positions = geometry.positions;
     let indices = geometry.faces;
 
-    let path: &[f32];
-    unsafe {
-        path = std::slice::from_raw_parts(input_path.as_ptr() as *const f32, input_path.len());
-    }
+    let path: &[f32] = input_path.points;
 
-    for i in 0..point_amount {
+    for i in 0..input_path.length {
         let index_offset = i * res_x * 6;
         let position_offset = i * res_x;
 

packages/utils/src/geometry/geometry_data.rs

@@ -6,8 +6,13 @@ pub struct GeometryData<'a> {
     pub faces: &'a mut [i32],     // View into `data`
 }
 
+static GEOMETRY_HEADER_SIZE: usize = 3;
+// 0: geometry type = 0
+// 1: vertex amount
+// 2: face amount
+
 pub fn create_geometry_data(vertex_amount: usize, face_amount: usize) -> Vec<i32> {
-    let amount = 3 // definition (type, vertex_amount, face_amount)
+    let amount = GEOMETRY_HEADER_SIZE // definition (type, vertex_amount, face_amount)
       + 4 // opening and closing brackets
       + vertex_amount * 3  // positions
       + vertex_amount * 3  // normals
@@ -35,12 +40,12 @@ pub fn create_geometry_data(vertex_amount: usize, face_amount: usize) -> Vec<i32
 pub fn wrap_geometry_data(geometry: &mut [i32]) -> GeometryData {
     // Basic validity checks
     assert!(
-        geometry.len() > 5,
+        geometry.len() > GEOMETRY_HEADER_SIZE,
         "Geometry vector does not contain enough data for a header."
     );
 
     // Split at after header
-    let (header, rest) = geometry.split_at_mut(5);
+    let (header, rest) = geometry.split_at_mut(2 + GEOMETRY_HEADER_SIZE);
 
     let vertices_amount = header[3] as usize;
     let face_amount = header[4] as usize;

packages/utils/src/geometry/mod.rs

@@ -1,9 +1,11 @@
 mod calculate_normals;
 mod extrude_path;
-mod geometry;
+mod geometry_data;
+mod path_data;
 mod transform;
 
 pub use calculate_normals::*;
 pub use extrude_path::*;
-pub use geometry::*;
+pub use geometry_data::*;
+pub use path_data::*;
 pub use transform::*;

packages/utils/src/geometry/path_data.rs

@@ -0,0 +1,106 @@
+static PATH_HEADER_SIZE: usize = 2;
+// 0: node-type, stem: 0
+// 1: depth
+
+#[derive(Debug)]
+pub struct PathData<'a> {
+    pub header: &'a mut [i32],
+    pub length: usize,
+    pub points: &'a mut [f32],
+}
+
+pub fn create_multiple_paths(amount: usize, point_amount: usize, depth: i32) -> Vec<i32> {
+    let output_size = amount * (point_amount * 4 + PATH_HEADER_SIZE + 4) + 4;
+
+    let mut path: Vec<i32> = vec![0; output_size];
+
+    path[0] = 0; // encode opening bracket
+    path[1] = 1; // encode opening bracket
+    path[output_size - 2] = 1; // encode closing bracket
+    path[output_size - 1] = 1; // encode closing bracket
+
+    for i in 0..amount {
+        let start_index = 2 + i * (point_amount * 4 + PATH_HEADER_SIZE + 4);
+        let end_index = 2 + (i + 1) * (point_amount * 4 + PATH_HEADER_SIZE + 4);
+
+        path[start_index] = 0; // encode opening bracket
+        path[start_index + 1] = point_amount as i32 * 4 + 3; // encode opening bracket
+        path[start_index + 2] = 0; // encode node-type, stem: 0
+        path[start_index + 3] = depth; // encode depth
+
+        path[end_index - 2] = 1; // encode closing bracket
+        path[end_index - 1] = 1; // encode closing bracket
+    }
+
+    path
+}
+
+pub fn wrap_multiple_paths(mut input: &mut [i32]) -> Vec<PathData<'_>> {
+    let mut paths = Vec::new();
+    let mut end_index = 2;
+
+    // remove starting bracket
+    input = &mut input[2..];
+
+    while end_index < input.len() - 1 {
+        end_index = input[1] as usize + 3;
+        if end_index < input.len() {
+            let (path_slice, remaining) = input.split_at_mut(end_index);
+            let path_data = wrap_path(path_slice);
+            paths.push(path_data);
+            input = remaining;
+        } else {
+            break;
+        }
+    }
+
+    paths
+}
+
+pub fn create_path(point_amount: usize, depth: i32) -> Vec<i32> {
+    let output_size = point_amount * 4 + PATH_HEADER_SIZE + 4;
+
+    let mut path: Vec<i32> = vec![0; output_size];
+
+    path[0] = 0; // encode opening bracket
+    path[1] = (point_amount * 4) as i32 + 2; // encode opening bracket
+    path[2] = 0; //encode node-type, stem: 0
+    path[3] = depth; //encode depth
+    path[output_size - 2] = 1; // encode closing bracket
+    path[output_size - 1] = 1; // encode closing bracket
+
+    path
+}
+
+pub fn wrap_path<'a>(geometry: &'a mut [i32]) -> PathData<'a> {
+    // Basic validity checks
+    assert!(
+        geometry.len() > PATH_HEADER_SIZE,
+        "Geometry vector does not contain enough data for a header."
+    );
+
+    let (_opening_brackets, rest) = geometry.split_at_mut(2);
+
+    // Split at after header
+    let (header, rest) = rest.split_at_mut(PATH_HEADER_SIZE);
+
+    // split after points, excluding last two that encode closing bracket
+    let (points_slice, _closing_bracket) = rest.split_at_mut(rest.len() - 2);
+
+    assert!(
+        points_slice.len() % 4 == 0,
+        "Points slice does not match the expected size.",
+    );
+
+    let length = points_slice.len() / 4;
+
+    let points: &'a mut [f32] = unsafe {
+        std::slice::from_raw_parts_mut(points_slice.as_mut_ptr() as *mut f32, points_slice.len())
+    };
+
+    PathData {
+        header,
+        length,
+        points,
+    }
+}

packages/utils/src/main.rs

@@ -1,5 +1,9 @@
-use utils::get_args;
+use utils::{
+    geometry::{create_multiple_paths, create_path, wrap_multiple_paths},
+    get_args,
+};
 
+#[allow(dead_code)]
 #[rustfmt::skip]
 fn test_split_args(){
     let inputs = vec![
@@ -16,4 +20,17 @@ fn test_split_args(){
     }
 }
 
-fn main() {}
+fn test_path() {
+    // let path_data = create_path(3, 2);
+    // println!("{:?}", path_data);
+
+    let mut multiple_paths = create_multiple_paths(1, 4, 1);
+    let mut wrapped_paths = wrap_multiple_paths(&mut multiple_paths);
+    wrapped_paths[0].points[0] = 1.0;
+    println!("{:?}", wrapped_paths);
+    println!("{:?}", multiple_paths);
+}
+
+fn main() {
+    test_path()
+}