writing node buffer to gpu all at once

src/renderer/buffers/nodes.rs

@@ -102,27 +102,28 @@ impl Nodes {
             self.shift = None;
             self.dirty = true;
             self.working = false;
+            
         }
 
         if self.dirty {
             self.dirty = false;
             
-            // Write all nodes to gpu
-            for z in 0..NODE_TEX_SIZE {
+            let timer = Instant::now();
 
-                // Convert u32 node buffer to u8
-                let node_origin = wgpu::Origin3d{ x:0, y: 0, z: z as u32 };
-                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.buffer.read().unwrap()[offset..offset+NODE_TEX_SIZE_SQ], &mut node_bytes);
+            // Convert u32 node buffer to u8
+            let node_origin = wgpu::Origin3d{ x:0, y: 0, z: 0 };
+            let node_size = wgpu::Extent3d { width: NODE_TEX_SIZE as u32, height: NODE_TEX_SIZE as u32, depth: NODE_TEX_SIZE as u32 };
+            let mut node_bytes = vec![0_u8; NODE_TEX_SIZE_QB*4].into_boxed_slice();
+            LittleEndian::write_u32_into(&self.buffer.read().unwrap()[..], &mut node_bytes[..]);
     
-                // Write nodes
-                queue.write_texture(
-                    wgpu::TextureCopyView { texture: texture, mip_level: 0, origin: node_origin }, &node_bytes,
-                    wgpu::TextureDataLayout { offset: 0, bytes_per_row: 4*node_size.width, rows_per_image: node_size.height }, node_size
-                );
-            }
+            // Write nodes
+            queue.write_texture(
+               wgpu::TextureCopyView { texture: texture, mip_level: 0, origin: node_origin }, &node_bytes[..],
+               wgpu::TextureDataLayout { offset: 0, bytes_per_row: 4*node_size.width, rows_per_image: node_size.height }, node_size
+            );
+
+
+            println!("Write nodes: {} ms", timer.elapsed().as_millis());
         }
     }
 }

src/renderer/mod.rs

@@ -118,17 +118,19 @@ impl Renderer {
         self.ui.set_text("Performance", 1, format!("Update content: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
 
         // Update uniform buffer
+        let timer = Instant::now();
         let off = self.buffers.content.get_world_offset();
         let half = (buffers::nodes::NODE_TEX_SIZE / 2) as i32;
         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]));
+        self.ui.set_text("Performance", 2, format!("Update uniform: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
 
         // Get next frame to render to
         let timer = Instant::now();
         let frame = self.swapchain.get_current_frame()?.output;
-        self.ui.set_text("Performance", 2, format!("Swapchain get frame: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
+        self.ui.set_text("Performance", 3, format!("Swapchain get frame: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
 
         // Create encoder that will build command buffer for us
         let timer = Instant::now();
@@ -136,13 +138,13 @@ impl Renderer {
         self.raytrace_pass.render(&mut encoder, &mut self.buffers, &self.texture);//&frame.view);
         self.postprocess_pass.render(&mut encoder, &frame.view);
         self.ui.render(&self.device, &mut encoder, &frame.view, 1280, 720);
-        self.ui.set_text("Performance", 3, format!("Build renderpass: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
+        self.ui.set_text("Performance", 4, format!("Build renderpass: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
 
         // Submit encoder (command buffer)
         let timer = Instant::now();
         self.queue.submit(std::iter::once(encoder.finish()));
         self.ui.recall();
-        self.ui.set_text("Performance", 4, format!("Submit queue: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
+        self.ui.set_text("Performance", 5, format!("Submit queue: {}ms", timer.elapsed().as_micros() as f64 / 1000.0));
         
         // Stats
         let content_stats = self.buffers.content.stats();

src/renderer/renderer_view.rs

@@ -1,7 +1,7 @@
 use crate::renderer::UserInterface;
 use crate::renderer::camera::CameraTransform;
 use crate::Renderer;
-use crate::{game, game::world::{chunk, chunk::WorldChunk, block::WorldBlock}};
+use crate::{game, game::world::{chunk, chunk::WorldChunk}};
 use cgmath::Vector3;
 
 pub trait RendererView {