RAY CASTED OCT TREE RENDERING

src/common/component/chunk.rs

@@ -1,124 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use crate::{
-    client::render::voxel::{VoxelColor, VoxelFace},
-    util::oct_tree::OctTree,
-};
-use bevy_derive::{Deref, DerefMut};
-use bevy_ecs::{bundle::Bundle, component::Component, entity::Entity, system::Resource};
-use block_mesh::{ndshape::RuntimeShape, UnitQuadBuffer, RIGHT_HANDED_Y_UP_CONFIG};
-use nalgebra::Vector3;
-use ndarray::{s, Array3, Axis};
-
-pub const SIDE_LENGTH: usize = 16 * 16;
-pub const SHAPE: (usize, usize, usize) = (SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
-pub const DIMENSIONS: Vector3<usize> = Vector3::new(SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
-pub const LEN: usize = SHAPE.0 * SHAPE.1 * SHAPE.2;
-
-#[derive(Debug, Component, Clone, Deref, DerefMut)]
-pub struct ChunkData {
-    #[deref]
-    data: OctTree<VoxelColor>,
-}
-
-impl ChunkData {
-    pub fn empty() -> Self {
-        Self {
-            data: OctTree::Leaf(VoxelColor::none()),
-        }
-    }
-
-    pub fn from_tree(t: OctTree<VoxelColor>) -> Self {
-        Self { data: t }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component, Default, Deref, DerefMut)]
-pub struct ChunkPos(pub Vector3<i32>);
-impl ChunkPos {
-    pub fn new(x: i32, y: i32, z: i32) -> Self {
-        Self(Vector3::new(x, y, z))
-    }
-}
-impl From<Vector3<i32>> for ChunkPos {
-    fn from(val: Vector3<i32>) -> Self {
-        ChunkPos(val)
-    }
-}
-
-#[derive(Debug, Clone, Component)]
-pub struct ChunkMesh {
-    pub faces: [Vec<VoxelFace>; 6],
-}
-
-impl ChunkMesh {
-    pub fn from_data(data: &Array3<VoxelColor>) -> Self {
-        let dim_pad = Vector3::new(
-            data.len_of(Axis(0)) as u32,
-            data.len_of(Axis(1)) as u32,
-            data.len_of(Axis(2)) as u32,
-        );
-        let dim = dim_pad - Vector3::from_element(2);
-        let mut buffer = UnitQuadBuffer::new();
-        let shape = RuntimeShape::<u32, 3>::new(dim_pad.into());
-        let slice = data.as_slice().unwrap();
-        block_mesh::visible_block_faces(
-            slice,
-            &shape,
-            [0; 3],
-            (dim_pad - Vector3::new(1, 1, 1)).into(),
-            &RIGHT_HANDED_Y_UP_CONFIG.faces,
-            &mut buffer,
-        );
-        let faces = [2, 1, 0, 5, 4, 3].map(|f| {
-            buffer.groups[f]
-                .iter()
-                .map(|a| {
-                    let i = (a.minimum[0]-1) + (a.minimum[1]-1) * dim.y + (a.minimum[2]-1) * dim.y * dim.x;
-                    let i_pad = a.minimum[0] + a.minimum[1] * dim_pad.y + a.minimum[2] * dim_pad.y * dim_pad.x;
-                    VoxelFace {
-                        index: i,
-                        color: slice[i_pad as usize],
-                    }
-                })
-                .collect()
-        });
-        Self { faces }
-    }
-}
-
-#[derive(Debug, Clone, Component, Deref, DerefMut)]
-pub struct LoadedChunks {
-    loaded: HashSet<ChunkPos>,
-}
-
-impl LoadedChunks {
-    pub fn new() -> Self {
-        Self {
-            loaded: HashSet::new(),
-        }
-    }
-}
-
-#[derive(Resource, Deref, DerefMut)]
-pub struct ChunkMap {
-    #[deref]
-    map: HashMap<ChunkPos, Entity>,
-    pub generating: HashSet<ChunkPos>,
-}
-
-impl ChunkMap {
-    pub fn new() -> Self {
-        Self {
-            map: HashMap::new(),
-            generating: HashSet::new(),
-        }
-    }
-}
-
-#[derive(Bundle, Clone)]
-pub struct ChunkBundle {
-    pub pos: ChunkPos,
-    pub data: ChunkData,
-    pub mesh: ChunkMesh,
-}

src/common/component/chunk/mesh.rs

@@ -0,0 +1,52 @@
+use bevy_ecs::component::Component;
+use block_mesh::{ndshape::RuntimeShape, UnitQuadBuffer, RIGHT_HANDED_Y_UP_CONFIG};
+use nalgebra::Vector3;
+use ndarray::{ArrayView3, Axis};
+
+use crate::client::render::voxel::{VoxelColor, /*VoxelFace*/};
+
+#[derive(Debug, Clone, Component)]
+pub struct ChunkMesh {
+    // pub faces: [Vec<VoxelFace>; 6],
+}
+
+impl ChunkMesh {
+    pub fn from_data(data: ArrayView3<VoxelColor>) -> Self {
+        // let dim_pad = Vector3::new(
+        //     data.len_of(Axis(0)) as u32,
+        //     data.len_of(Axis(1)) as u32,
+        //     data.len_of(Axis(2)) as u32,
+        // );
+        // let dim = dim_pad - Vector3::from_element(2);
+        // let mut buffer = UnitQuadBuffer::new();
+        // let shape = RuntimeShape::<u32, 3>::new(dim_pad.into());
+        // let slice = data.as_slice().unwrap();
+        // block_mesh::visible_block_faces(
+        //     slice,
+        //     &shape,
+        //     [0; 3],
+        //     (dim_pad - Vector3::new(1, 1, 1)).into(),
+        //     &RIGHT_HANDED_Y_UP_CONFIG.faces,
+        //     &mut buffer,
+        // );
+        // let faces = [2, 1, 0, 5, 4, 3].map(|f| {
+        //     buffer.groups[f]
+        //         .iter()
+        //         .map(|a| {
+        //             let i = (a.minimum[0] - 1)
+        //                 + (a.minimum[1] - 1) * dim.y
+        //                 + (a.minimum[2] - 1) * dim.y * dim.x;
+        //             let i_pad = a.minimum[0]
+        //                 + a.minimum[1] * dim_pad.y
+        //                 + a.minimum[2] * dim_pad.y * dim_pad.x;
+        //             VoxelFace {
+        //                 index: i,
+        //                 color: slice[i_pad as usize],
+        //             }
+        //         })
+        //         .collect()
+        // });
+        Self { /*faces*/ }
+    }
+}
+

src/common/component/chunk/mod.rs

@@ -0,0 +1,80 @@
+mod mesh;
+pub use mesh::*;
+
+use std::collections::{HashMap, HashSet};
+
+use crate::util::oct_tree::OctTree;
+use bevy_derive::{Deref, DerefMut};
+use bevy_ecs::{bundle::Bundle, component::Component, entity::Entity, system::Resource};
+use nalgebra::Vector3;
+
+pub const SIDE_LENGTH: usize = 16 * 16;
+pub const SHAPE: (usize, usize, usize) = (SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
+pub const DIMENSIONS: Vector3<usize> = Vector3::new(SIDE_LENGTH, SIDE_LENGTH, SIDE_LENGTH);
+pub const LEN: usize = SHAPE.0 * SHAPE.1 * SHAPE.2;
+
+#[derive(Debug, Component, Clone, Deref, DerefMut)]
+pub struct ChunkData {
+    #[deref]
+    data: OctTree,
+}
+
+impl ChunkData {
+    pub fn from_tree(t: OctTree) -> Self {
+        Self { data: t }
+    }
+    pub fn empty() -> Self {
+        Self {
+            data: OctTree::from_leaf(0, 8),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component, Default, Deref, DerefMut)]
+pub struct ChunkPos(pub Vector3<i32>);
+impl ChunkPos {
+    pub fn new(x: i32, y: i32, z: i32) -> Self {
+        Self(Vector3::new(x, y, z))
+    }
+}
+impl From<Vector3<i32>> for ChunkPos {
+    fn from(val: Vector3<i32>) -> Self {
+        ChunkPos(val)
+    }
+}
+
+#[derive(Debug, Clone, Component, Deref, DerefMut)]
+pub struct LoadedChunks {
+    loaded: HashSet<ChunkPos>,
+}
+
+impl LoadedChunks {
+    pub fn new() -> Self {
+        Self {
+            loaded: HashSet::new(),
+        }
+    }
+}
+
+#[derive(Resource, Deref, DerefMut)]
+pub struct ChunkMap {
+    #[deref]
+    map: HashMap<ChunkPos, Entity>,
+    pub generating: HashSet<ChunkPos>,
+}
+
+impl ChunkMap {
+    pub fn new() -> Self {
+        Self {
+            map: HashMap::new(),
+            generating: HashSet::new(),
+        }
+    }
+}
+
+#[derive(Bundle, Clone)]
+pub struct ChunkBundle {
+    pub pos: ChunkPos,
+    pub data: ChunkData,
+    pub mesh: ChunkMesh,
+}