Dynamic loading, saving, generating chunks works

src/game/world/chunk.rs

@@ -1,6 +1,7 @@
+use crate::game::RendererView;
 use byteorder::LittleEndian;
 use byteorder::ByteOrder;
-use cgmath::Point3;
+use cgmath::Vector3;
 use lzzzz::lz4;
 use crate::game::world::{WorldBlock, block};
 
@@ -23,7 +24,7 @@ pub struct WorldChunk {
 impl WorldChunk {
     pub fn new() -> Self {
         Self { 
-            nodes: vec![0_u32; SIZE_QB as usize].into_boxed_slice(),
+            nodes: vec![0_u32; SIZE_QB].into_boxed_slice(),
             blocks: Vec::new()
         }
     }
@@ -85,7 +86,7 @@ impl WorldChunk {
     }
 
     #[allow(unused)]
-    pub fn all_blocks(&self) -> Vec<(Point3<u32>, &WorldBlock)> {
+    pub fn all_blocks(&self) -> Vec<(Vector3<i32>, &WorldBlock)> {
         self.nodes.iter().enumerate()
             .filter(|(_, n)| **n != 0)
             .map(|(index, node)| {
@@ -96,17 +97,16 @@ impl WorldChunk {
                 let y = idx / SIZE;
                 let x = idx % SIZE;
 
-                let pos = Point3{x: x as u32, y: y as u32, z: z as u32};
-
+                let pos = Vector3{x: x as i32, y: y as i32, z: z as i32};
                 let block = &self.blocks[(*node-1) as usize];
                 (pos, block)
             })
             .collect()
     }
 
-    pub fn get_block_mut(&mut self, block_pos: &Point3<u32>) -> &mut WorldBlock {
+    pub fn get_block_mut(&mut self, block_pos: &Vector3<i32>) -> &mut WorldBlock {
         // Get block index
-        let index = (block_pos.x + SIZE as u32 * (block_pos.y + SIZE as u32 * block_pos.z)) as usize;
+        let index = (block_pos.x + SIZE as i32 * (block_pos.y + SIZE as i32 * block_pos.z)) as usize;
         let mut value = self.nodes[index];
         // Allocate new block
         if value == 0 {
@@ -118,11 +118,17 @@ impl WorldChunk {
         &mut self.blocks[(value-1) as usize]
     }
 
-    pub fn get_block(&self, block_pos: &Point3<u32>) -> &WorldBlock {
+    pub fn get_block(&self, block_pos: &Vector3<i32>) -> &WorldBlock {
         // Get block index
-        let index = (block_pos.x + SIZE as u32 * (block_pos.y + SIZE as u32 * block_pos.z)) as usize;
+        let index = (block_pos.x + SIZE as i32 * (block_pos.y + SIZE as i32 * block_pos.z)) as usize;
         let value = self.nodes[index];
         // Return block reference
         &self.blocks[(value-1) as usize]
     }
+
+    pub fn write_to(&self, renderer: &mut dyn RendererView, offset: Vector3<i32>) {
+        for (blpos, block) in self.all_blocks() {
+            renderer.write(&(offset + blpos), block);
+        }
+    }
 }