some code cleaning

src/renderer/buffers/content.rs

@@ -172,8 +172,12 @@ impl Content {
         );
     }
 
-    pub fn shift(&mut self, offset: &Vector3<i32>) -> bool {
+    pub fn get_world_offset(&self) -> Vector3<i32> {
-        self.nodes.shift(offset)
+        self.nodes.get_world_offset()
+    } 
+
+    pub fn shift(&mut self, offset: &Vector3<i32>) {
+        self.nodes.shift(offset);
     }
 
     pub fn update(&mut self, queue: &wgpu::Queue) {

src/renderer/buffers/nodes.rs

@@ -1,66 +1,102 @@
+use std::sync::Arc;
+use std::sync::Mutex;
 use std::cmp::{min, max};
+use std::time::Instant;
 use cgmath::Vector3;
+use std::thread;
 use byteorder::{LittleEndian, ByteOrder};
 
 pub const NODE_TEX_SIZE: usize = 128; // 32x32x32 nodes in texture
 pub const NODE_TEX_SIZE_SQ: usize = NODE_TEX_SIZE*NODE_TEX_SIZE;
 pub const NODE_TEX_SIZE_QB: usize = NODE_TEX_SIZE*NODE_TEX_SIZE*NODE_TEX_SIZE;
 
+struct ShiftResult {
+    offset: Vector3<i32>,
+    active_buffer: usize
+}
 
 pub struct Nodes {
-    node_buffer: [Box<[u32]>; 2],
+    // Realtime variables
+    node_buffer: Arc<Mutex<[Box<[u32]>; 2]>>,
+    world_offset: Vector3<i32>,
     active_buffer: usize,
-    modified: bool,
+    dirty: bool,
+    // Threaded work
+    busy: i32,
 }
 
 impl Nodes {
     pub fn new() -> Self {
         Self {
-            node_buffer: [vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice(), vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice()],
+            // Realtime variables
+            node_buffer: Arc::new(Mutex::new([vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice(), vec![0_u32; NODE_TEX_SIZE_QB].into_boxed_slice()])),
+            world_offset: Vector3{x:0,y:0,z:0},
             active_buffer: 0,
-            modified: false,
+            dirty: false,
+            // Threaded work
+            busy: 0,
         }
     }
 
+    pub fn get_world_offset(&self) -> Vector3<i32> {
+        self.world_offset
+    }
+
     pub fn get_node(&self, index: usize) -> u32 {
-        self.node_buffer[self.active_buffer][index]
+        self.node_buffer.lock().unwrap()[self.active_buffer][index]
     }
 
     pub fn set_node(&mut self, index: usize, value: u32) {
-        self.node_buffer[self.active_buffer][index] = value;
+        self.node_buffer.lock().unwrap()[self.active_buffer][index] = value;
-        self.modified = true;
+        self.dirty = true;
     }
 
-    pub fn shift(&mut self, offset: &Vector3<i32>) -> bool {
+    pub fn shift(&mut self, offset: &Vector3<i32>) {
 
         let a = if self.active_buffer == 0 { 0 } else { 1 };
         let b = if self.active_buffer == 0 { 1 } else { 0 };
-
         let (ox, oy, oz) = (offset.x, offset.y, offset.z);
-        let size = NODE_TEX_SIZE  as i32;
+        let node_buffer = Arc::clone(&self.node_buffer);
         
-        for i in self.node_buffer[b].iter_mut() {
+        self.busy += 1;
-            *i = 0;
-        }
 
-        for x in max(0, -ox)..min(size-ox, size) {
-            for y in max(0, -oy)..min(size-oy, size) {
-                for z in max(0, -oz)..min(size-oz, size) {
-                    let idx0 = x + size * (y + size * z);
-                    let idx1 = (x+ox) + size * ((y+oy) + size * (z+oz));
-                    self.node_buffer[b][idx1 as usize] = self.node_buffer[a][idx0 as usize];
-                }
-             }
-        }
 
+        let t = thread::spawn(move || {
+            // Prepare variables
+            let mut node_buffer = node_buffer.lock().unwrap();
+            let size = NODE_TEX_SIZE  as i32;
+
+            // Clear target buffer
+            for i in node_buffer[b].iter_mut() {
+                *i = 0;
+            }
+
+            // Copy slice of source buffer into target buffer
+            for x in max(0, -ox)..min(size-ox, size) {
+                for y in max(0, -oy)..min(size-oy, size) {
+                    for z in max(0, -oz)..min(size-oz, size) {
+                        let idx0 = x + size * (y + size * z);
+                        let idx1 = (x+ox) + size * ((y+oy) + size * (z+oz));
+                        node_buffer[b][idx1 as usize] = node_buffer[a][idx0 as usize];
+                    }
+                 }
+            }
+        });
+
+        // DEBUG
+        t.join().unwrap();
+
+        self.world_offset += *offset;
         self.active_buffer = b;
-        self.modified = true;
+        self.dirty = true;
-        true
+        self.busy -= 1;
     }
 
     pub fn update(&mut self, queue: &wgpu::Queue, texture: &wgpu::Texture) {
-        if self.modified {
+
-            self.modified = false;
+
+        if self.dirty {
+            self.dirty = false;
             
             // Write all nodes to gpu
             for z in 0..NODE_TEX_SIZE {
@@ -70,7 +106,7 @@ impl Nodes {
                 let node_size = wgpu::Extent3d { width: NODE_TEX_SIZE as u32, height: NODE_TEX_SIZE as u32, depth: 1 };
                 let mut node_bytes = [0_u8; NODE_TEX_SIZE_SQ*4];
                 let offset = NODE_TEX_SIZE_SQ*z;
-                LittleEndian::write_u32_into(&self.node_buffer[self.active_buffer][offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
+                LittleEndian::write_u32_into(&self.node_buffer.lock().unwrap()[self.active_buffer][offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
         
                 // Write nodes
                 queue.write_texture(

src/renderer/mod.rs

@@ -26,8 +26,7 @@ pub struct Renderer {
     buffers: Buffers,
     // Other
     pub camera: Camera,
-    start: std::time::Instant,
+    start: std::time::Instant
-    world_offset: Vector3<i32>
 }
 
 impl Renderer {
@@ -88,8 +87,7 @@ impl Renderer {
 
         // Other
         let start = std::time::Instant::now();
-        let world_offset = Vector3{x:0, y:0, z:0};
+        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 }
     }
 
     /*
@@ -115,11 +113,14 @@ impl Renderer {
     pub fn render(&mut self) -> Result<(), wgpu::SwapChainError> {
         
         // Update uniform buffer
+        let off = self.buffers.content.get_world_offset();
         let half = (buffers::nodes::NODE_TEX_SIZE / 2) as i32;
-        let cam_offset = Vector3{x: (self.world_offset.x + half) as f32, y: (self.world_offset.y + half) as f32, z: (self.world_offset.z + half) as f32 };
+        let cam_offset = Vector3{x: (off.x + half) as f32, y: (off.y + half) as f32, z: (off.z + half) as f32 };
+
         self.buffers.uniforms.values.update(&self.camera, cam_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
         let timer = Instant::now();
         self.buffers.content.update(&self.queue);

src/renderer/renderer_view.rs

@@ -9,7 +9,6 @@ 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>;
     fn free_chunk(&mut self, chunk_pos: Vector3<i32>);
 }
 
@@ -17,7 +16,7 @@ impl RendererView for Renderer {
     
     fn write_chunk(&mut self, chunk_pos: &Vector3<i32>, chunk: &WorldChunk) -> bool {
         // Calculate chunk position in renderer space
-        let chunk_off = self.world_offset / chunk::SIZE as i32;
+        let chunk_off = self.buffers.content.get_world_offset() / chunk::SIZE as i32;
         let pos = chunk_pos + chunk_off;
         // Make sure we are withing current world bounds
         if pos.x.abs() > game::RENDER_DIST { println!("out of bounds! x: {} off: {:?} pos: {:?}", pos.x, chunk_off, chunk_pos); return false; }
@@ -50,8 +49,7 @@ impl RendererView for Renderer {
     */
     fn shift(&mut self, offset: Vector3<i32>) {
         self.buffers.content.shift(&-offset);
-        self.world_offset -= offset;
+        println!("World shifted by {:?}", offset);
-        println!("World shifted by {:?}. World offset is now {:?}", offset, self.world_offset);
     }
 
     fn get_camera_transform(&mut self) -> &mut dyn CameraTransform {
@@ -61,8 +59,4 @@ impl RendererView for Renderer {
     fn get_ui(&mut self) -> &mut UserInterface {
         &mut self.ui
     }
-
-    fn get_world_offset(&self) -> Vector3<i32> {
-        self.world_offset
-    }
 }