world shifting almost working

src/game/mod.rs

@@ -19,7 +19,8 @@ pub struct Game {
     #[allow(unused)]
     world: World,
 
-    prev_pos: Option<Vector3<i32>>
+    prev_pos: Option<Vector3<i32>>,
+    prev_chunk_pos: Option<Vector3<i32>>,
 }
 
 impl Game {
@@ -28,7 +29,8 @@ impl Game {
             state: GameState::Paused,
             player: Player::new(),
             world: World::init("hello".to_string()),
-            prev_pos: None
+            prev_pos: None,
+            prev_chunk_pos: None,
         }
 
         // // Try to load world from file
@@ -62,19 +64,33 @@ impl Game {
         let camera = renderer.get_camera_transform();
         self.player.camera_controller.update(delta, camera);
 
-        // Update chunks
+        // Get positions
         let pos = camera.get_position();
         let pos = Vector3{x: pos.x as i32, y: pos.y as i32, z: pos.z as i32};
-        if self.prev_pos == None || self.prev_pos != Some(pos) {
-            self.prev_pos = Some(pos);
-            renderer.get_ui().set_text("World", 0, format!("Position: {}, {}, {}", pos.x, pos.y, pos.z));
+        let chunk_pos = pos / world::chunk::SIZE as i32;
 
-            // Load sphere of chunks around player
-            let chunk_pos = pos / 32;//Vector3{x: pos.x / 32, y: pos.y / 32, z: pos.z / 32};
+        // Block position
+        if self.prev_pos == None || self.prev_pos != Some(pos) {
+            renderer.get_ui().set_text("World", 0, format!("Position: {}, {}, {}", pos.x, pos.y, pos.z));
+            self.prev_pos = Some(pos);
+        }
+
+        // Chunk position
+        if self.prev_chunk_pos == None || self.prev_chunk_pos != Some(chunk_pos) {
+            renderer.get_ui().set_text("World", 1, format!("Chunk: {}, {}, {}", chunk_pos.x, chunk_pos.y, chunk_pos.z));
+
+            // Shift world
+            let dir = chunk_pos - self.prev_chunk_pos.unwrap_or(chunk_pos);
+            renderer.shift(&(dir * world::chunk::SIZE as i32));
+
+            // Load chunk
             if self.world.load_chunk(chunk_pos) {
                 let chunk = self.world.get_chunk(&chunk_pos).unwrap();
-                chunk.write_to(renderer, chunk_pos * 32);
+                chunk.write_to(renderer, chunk_pos * world::chunk::SIZE as i32);
+                println!("Writing chunk to {:?}", chunk_pos * world::chunk::SIZE as i32);
             }
+
+            self.prev_chunk_pos = Some(chunk_pos);
         }
     }
 

src/renderer/buffers/content.rs

@@ -141,25 +141,26 @@ impl Content {
     pub fn shift(&mut self, offset: &Vector3<i32>) {
         let timer = Instant::now();
         let mut result = vec![0_u32; self.node_buffer.len()].into_boxed_slice();
-        let ox = offset.x as usize;
-        let oy = offset.y as usize;
-        let oz = offset.z as usize;
+        let ox = offset.x;
+        let oy = offset.y;
+        let oz = offset.z;
+        let size = NODE_TEX_SIZE  as i32;
 
-        for x0 in 0..NODE_TEX_SIZE {
+        for x0 in 0..size {
             let x1 = x0+ox;
-            if x1 >= NODE_TEX_SIZE { continue; }
+            if x1 < 0 || x1 >= size { continue; }
 
-            for y0 in 0..NODE_TEX_SIZE {
+            for y0 in 0..size {
                 let y1 = y0+oy;
-                if y1 >= NODE_TEX_SIZE { continue; }
+                if y1 < 0 || y1 >= size { continue; }
 
-                for z0 in 0..NODE_TEX_SIZE {
+                for z0 in 0..size {
                     let z1 = z0+oz;
-                    if z1 >= NODE_TEX_SIZE { continue; }
+                    if z1 < 0 || z1 >= size { continue; }
 
-                    let idx0 = x0 + NODE_TEX_SIZE * (y0 + NODE_TEX_SIZE * z0);
-                    let idx1 = x1 + NODE_TEX_SIZE * (y1 + NODE_TEX_SIZE * z1);
-                    result[idx1] = self.node_buffer[idx0];
+                    let idx0 = x0 + size * (y0 + size * z0);
+                    let idx1 = x1 + size * (y1 + size * z1);
+                    result[idx1 as usize] = self.node_buffer[idx0 as usize];
                 } 
             }        
         }

src/renderer/buffers/uniform.rs

@@ -23,10 +23,10 @@ impl UniformValues {
         Self { sun_dir, .. Default::default() }
     }
 
-    pub fn update(&mut self, camera: &Camera, time: f32) {
+    pub fn update(&mut self, camera: &Camera, offset: Vector3<f32>, time: f32) {
         self.view_inv = camera.get_view().invert().unwrap().into();
         self.proj_inv = camera.get_projection().invert().unwrap().into();
-        self.cam_pos = camera.get_position().into();
+        self.cam_pos = (camera.get_position() + offset).into();
         self.time = time;
     }
 }

src/renderer/mod.rs

@@ -1,3 +1,4 @@
+use cgmath::Vector3;
 use std::time::Instant;
 use winit::{window::Window, dpi::PhysicalSize};
 pub mod buffers; 
@@ -26,6 +27,7 @@ pub struct Renderer {
     // Other
     pub camera: Camera,
     start: std::time::Instant,
+    world_offset: Vector3<i32>
 }
 
 impl Renderer {
@@ -86,9 +88,10 @@ impl Renderer {
 
         // Other
         let start = std::time::Instant::now();
+        let world_offset = Vector3{x:0, y:0, z:0};
 
         println!("Renderer initialized");
-        Self { surface, device, queue, swapchain_desc, swapchain, texture, raytrace_pass, postprocess_pass, ui, buffers, camera, start }
+        Self { surface, device, queue, swapchain_desc, swapchain, texture, raytrace_pass, postprocess_pass, ui, buffers, camera, start, world_offset }
     }
 
     /*
@@ -114,7 +117,8 @@ impl Renderer {
     pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
         
         // Update uniform buffer
-        self.buffers.uniforms.values.update(&self.camera, self.start.elapsed().as_secs_f32());
+        let offset = Vector3{x: self.world_offset.x as f32, y: self.world_offset.y as f32, z: self.world_offset.z as f32 };
+        self.buffers.uniforms.values.update(&self.camera, offset, self.start.elapsed().as_secs_f32());
         self.queue.write_buffer(&self.buffers.uniforms.buffer, 0, bytemuck::cast_slice(&[self.buffers.uniforms.values]));
 
         // Update content

src/renderer/renderer_view.rs

@@ -9,16 +9,19 @@ pub trait RendererView {
     fn shift(&mut self, offset: &Vector3<i32>);
     fn get_camera_transform(&mut self) -> &mut dyn CameraTransform;
     fn get_ui(&mut self) -> &mut UserInterface;
+    fn get_world_offset(&self) -> Vector3<i32>;
 }
 
 impl RendererView for Renderer {
     
     fn write(&mut self, block_pos: &Vector3<i32>, block: &WorldBlock) { 
-        self.buffers.content.write(&self.queue, block_pos, block)
+        self.buffers.content.write(&self.queue, &block_pos, block)
     }
 
     fn shift(&mut self, offset: &Vector3<i32>) {
         self.buffers.content.shift(offset);
+        self.world_offset += *offset;
+        println!("World shifted by {:?}. World offset is now {:?}", offset, self.world_offset);
     }
 
     fn get_camera_transform(&mut self) -> &mut dyn CameraTransform {
@@ -28,4 +31,8 @@ impl RendererView for Renderer {
     fn get_ui(&mut self) -> &mut UserInterface {
         &mut self.ui
     }
+
+    fn get_world_offset(&self) -> Vector3<i32> {
+        self.world_offset
+    }
 }