moves compiled shaders, first version with scene info on gpu

src/main.rs

@@ -8,7 +8,7 @@
 use anyhow::{anyhow, Result};
 use log::*;
 use winit::dpi::{LogicalSize, LogicalPosition};
-use winit::event::{Event, WindowEvent};
+use winit::event::{ElementState, Event, WindowEvent};
 use winit::event_loop::EventLoop;
 use winit::keyboard::NamedKey;
 use winit::window::{Window, WindowBuilder};
@@ -132,6 +132,9 @@ fn main() -> Result<()> {
                     if event.logical_key == "d" {
                         app.cur_pos += app.view_direction.cross(vertex::Vec3::new(0.0, 0.0, 1.0)) * 0.1;
                     }
+                    if event.logical_key == "f" && event.state == ElementState::Pressed && event.repeat == false {
+                        app.show_frame_rate = !app.show_frame_rate;
+                    }
                     if event.logical_key == NamedKey::Escape {
                         elwt.exit();
                         unsafe { app.device.device_wait_idle().unwrap(); }
@@ -164,6 +167,8 @@ struct App {
     view_direction: vertex::Vec3,
     cur_pos: cgmath::Point3<f32>,
     scene_handler: scene::Scene,
+    show_frame_rate: bool,
+    synchronized: usize,
 }
 
 impl App {
@@ -199,7 +204,7 @@ impl App {
         image::create_texture_image_view(&device, &mut data)?;
         image::create_texture_sampler(&device, &mut data)?;
         
-        scene_handler.prepare_data(&instance, &device, &data)?;
+        scene_handler.prepare_data(&instance, &device, &mut data)?;
 
         buffer::create_uniform_buffers(&instance, &device, &mut data)?;
         buffer::create_storage_buffers(&instance, &device, &mut data)?;
@@ -215,7 +220,9 @@ impl App {
             last_pos: LogicalPosition::new(-1 as f32, -1 as f32), 
             view_direction: vertex::Vec3::new(0.0, 0.0, 0.0),
             cur_pos: cgmath::point3(0.0, 0.0, 0.0),
-            scene_handler
+            scene_handler,
+            show_frame_rate: false,
+            synchronized: 0
         })
     }
 
@@ -247,6 +254,10 @@ impl App {
         self.data.images_in_flight[image_index] = in_flight_fence;
 
         self.update_uniform_buffer(image_index)?;
+        if self.synchronized < MAX_FRAMES_IN_FLIGHT {
+            self.update_storage_buffer(image_index)?;
+            self.synchronized += 1
+        }
 
         let wait_semaphores = &[self.data.image_available_semaphores[self.frame]];
         let wait_stages = &[vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT];
@@ -281,7 +292,9 @@ impl App {
 
         self.frame = (self.frame + 1) % MAX_FRAMES_IN_FLIGHT;
 
-        println!("{}", 1000000.0 / start_time.elapsed().as_micros() as f32);
+        if self.show_frame_rate {
+            println!("{}", 1000000.0 / start_time.elapsed().as_micros() as f32);
+        }
         Ok(())
     }
 
@@ -338,6 +351,7 @@ impl App {
         self.data
             .images_in_flight
             .resize(self.data.swapchain_images.len(), vk::Fence::null());
+        self.synchronized = 0;
         Ok(())
     }
 
@@ -431,14 +445,18 @@ impl App {
         
         self.device.unmap_memory(self.data.uniform_buffers_memory[image_index]);
 
+        Ok(())
+    }
+
+    unsafe fn update_storage_buffer(&mut self, image_index: usize) -> Result<()> {
         let memory = self.device.map_memory(
             self.data.storage_buffers_memory[image_index],
             0,
-            size_of::<buffer::UniformBufferObject>() as u64,
+            self.data.scene_rt_memory_size,
             vk::MemoryMapFlags::empty(),
         )?;
         
-        memcpy(&ubo, memory.cast(), 1);
+        memcpy(self.scene_handler.rt_memory.as_ptr(), memory.cast(), 2103);
         
         self.device.unmap_memory(self.data.storage_buffers_memory[image_index]);
 
@@ -677,9 +695,9 @@ unsafe fn create_logical_device(
 unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Result<()> {
     // set up shaders for cubes
     // load the byte data
-    let vert_cube = include_bytes!("../shaders/vert_cube.spv");
-    let geo_cube = include_bytes!("../shaders/geo_cube.spv");
-    let frag_cube = include_bytes!("../shaders/frag_cube.spv");
+    let vert_cube = include_bytes!("../shaders/compiled/vert_cube.spv");
+    let geo_cube = include_bytes!("../shaders/compiled/geo_cube.spv");
+    let frag_cube = include_bytes!("../shaders/compiled/frag_cube.spv");
     // create the shaders
     let vert_shader_module_cube = create_shader_module(device, &vert_cube[..])?;
     let geo_shader_module_cube = create_shader_module(device, &geo_cube[..])?;
@@ -708,9 +726,9 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
 
     // set up shaders for cuboids
     // load the byte data
-    let vert_cuboid = include_bytes!("../shaders/vert_cuboid.spv");
-    let geo_cuboid = include_bytes!("../shaders/geo_cuboid.spv");
-    let frag_cuboid = include_bytes!("../shaders/frag_cuboid.spv");
+    let vert_cuboid = include_bytes!("../shaders/compiled/vert_cuboid.spv");
+    let geo_cuboid = include_bytes!("../shaders/compiled/geo_cuboid.spv");
+    let frag_cuboid = include_bytes!("../shaders/compiled/frag_cuboid.spv");
     // create the shaders
     let vert_shader_module_cuboid = create_shader_module(device, &vert_cuboid[..])?;
     let geo_shader_module_cuboid = create_shader_module(device, &geo_cuboid[..])?;
@@ -739,8 +757,8 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
 
     // set up shaders for quads/raytracing
     // load the byte data
-    let vert_quad = include_bytes!("../shaders/vert_rt_quad.spv");
-    let frag_quad = include_bytes!("../shaders/frag_rt_quad.spv");
+    let vert_quad = include_bytes!("../shaders/compiled/vert_rt_quad.spv");
+    let frag_quad = include_bytes!("../shaders/compiled/frag_rt_quad.spv");
     // create the shaders
     let vert_shader_module_quad = create_shader_module(device, &vert_quad[..])?;
     let frag_shader_module_quad = create_shader_module(device, &frag_quad[..])?;