hotload shader + directional light

src/vulkan/mod.rs

@@ -250,7 +250,7 @@ impl VulkanRenderer {
 
         let pipelines: Vec<Box<dyn Drawcall>> = vec![
             Box::new(DefaultShader::new(device.clone(), render_pass.clone())),
-            // Box::new(LineShader::new(device.clone(), render_pass.clone(), line_vertex_buffer.clone())),
+            Box::new(LineShader::new(device.clone(), render_pass.clone(), line_vertex_buffer.clone())),
         ];
 
         // Dynamic viewports allow us to recreate just the viewport when the window is resized
@@ -269,9 +269,11 @@ impl VulkanRenderer {
             projection: Matrix4::identity().into(),
             time: 0.0,
             light_position: [0.0, 0.0, 0.0],
+            light_directional_rotation: [0.0, 0.0, 0.0],
             camera_position: [0.0, 0.0, 0.0],
             _dummy0: [0; 12],
             _dummy1: [0; 4],
+            _dummy2: [0; 4],
         };
 
         for _ in 0..swapchain.num_images() {
@@ -347,7 +349,7 @@ impl VulkanRenderer {
 
             self.pipelines = vec![
                 Box::new(DefaultShader::new(self.device.clone(), self.render_pass.clone())),
-                // Box::new(LineShader::new(self.device.clone(), self.render_pass.clone(), self.line_vertex_buffer.clone())),
+                Box::new(LineShader::new(self.device.clone(), self.render_pass.clone(), self.line_vertex_buffer.clone())),
             ];
 
             self.swapchain = new_swapchain;
@@ -473,6 +475,11 @@ impl VulkanRenderer {
 pub fn start_event_loop(mut renderer: VulkanRenderer, mut game: Box<dyn Game>, event_loop: EventLoop<()>) {
     event_loop.run(move |event, _, control_flow| {
         game.on_window_event(&event);
+
+        if renderer.game_data.shutdown {
+            *control_flow = ControlFlow::Exit;
+        }
+
         match event {
             Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
                 *control_flow = ControlFlow::Exit;

src/vulkan/pipelines.rs

@@ -1,12 +1,13 @@
 use std::{convert::TryInto, io::{Read, Write}, sync::Arc};
 
-use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::{descriptor::ShaderStages, descriptor_set::PersistentDescriptorSet}};
+use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::{descriptor::ShaderStages, descriptor_set::PersistentDescriptorSet}, pipeline::shader::ShaderModule};
 use vulkano::command_buffer::DynamicState;
 use vulkano::device::Device;
 use vulkano::framebuffer::RenderPassAbstract;
 use vulkano::framebuffer::Subpass;
 use vulkano::pipeline::GraphicsPipeline;
 use vulkano::pipeline::GraphicsPipelineAbstract;
+use vulkano::pipeline::shader::GraphicsShaderType;
 
 use crate::GameObject;
 use crate::vulkan::{LinePoint, Vertex};
@@ -42,6 +43,16 @@ pub struct DefaultShader {
     pipeline: GP,
 }
 
+fn shader_module_from_file(device: Arc<Device>, path: &str) -> Arc<ShaderModule> {
+    let mut file = std::fs::File::open(path).unwrap();
+    let mut buffer = vec![];
+    file.read_to_end(&mut buffer).unwrap();
+    let words: Vec<u32> = buffer.chunks_exact(4).map(|c| u32::from_ne_bytes(c.try_into().unwrap())).collect();
+    unsafe {
+        ShaderModule::from_words(device.clone(), &words).unwrap()
+    }
+}
+
 impl DefaultShader {
     pub fn new(device: Arc<Device>, render_pass: RP) -> Self {
         DefaultShader {
@@ -51,7 +62,6 @@ impl DefaultShader {
 
     fn create_pipeline(device: Arc<Device>, render_pass: RP) -> GP {
         let sub_pass = Subpass::from(render_pass.clone(), 0).unwrap();
-        let vertex_shader = vs::Shader::load(device.clone()).unwrap();
 
         #[cfg(debug_assertions)]
         {
@@ -65,22 +75,26 @@ impl DefaultShader {
         }
 
         unsafe {
-            let mut fs_file = std::fs::File::open("shaders/triangle.frag.spv").unwrap();
-            let mut fs_buf = vec![];
-            fs_file.read_to_end(&mut fs_buf).unwrap();
-            let fs_words: Vec<u32> = fs_buf.chunks_exact(4).map(|c| u32::from_ne_bytes(c.try_into().unwrap())).collect();
-            let fs_module = vulkano::pipeline::shader::ShaderModule::from_words(device.clone(), &fs_words).unwrap();
+            static ENTRY_NAME: [u8; 5usize] = [109u8, 97u8, 105u8, 110u8, 0];
+            let entry_name_c = std::ffi::CStr::from_ptr(ENTRY_NAME.as_ptr() as *const _);
+
+            let fs_module = shader_module_from_file(device.clone(), "shaders/triangle.frag.spv");
             let fs_layout = fs::Layout(ShaderStages {
                 fragment: true,
                 ..ShaderStages::none()
             });
-            static FS_NAME: [u8; 5usize] = [109u8, 97u8, 105u8, 110u8, 0];
-            let fs_name_c = std::ffi::CStr::from_ptr(FS_NAME.as_ptr() as *const _);
-            let fs_entry = fs_module.graphics_entry_point(fs_name_c, fs::MainInput, fs::MainOutput, fs_layout, vulkano::pipeline::shader::GraphicsShaderType::Fragment);
+            let fs_entry = fs_module.graphics_entry_point(entry_name_c, fs::MainInput, fs::MainOutput, fs_layout, GraphicsShaderType::Fragment);
+
+            let vs_module = shader_module_from_file(device.clone(), "shaders/triangle.vert.spv");
+            let vs_layout = vs::Layout(ShaderStages {
+                vertex: true,
+                ..ShaderStages::none()
+            });
+            let vs_entry = vs_module.graphics_entry_point(entry_name_c, vs::MainInput, vs::MainOutput, vs_layout, GraphicsShaderType::Vertex);
         
             Arc::new(GraphicsPipeline::start()
                 .vertex_input_single_buffer::<Vertex>()
-                .vertex_shader(vertex_shader.main_entry_point(), ())
+                .vertex_shader(vs_entry, ())
                 .triangle_list()
                 .viewports_dynamic_scissors_irrelevant(1)
                 .depth_stencil_simple_depth()