Update [broken]

src/vulkan/vk_render_context.rs

@@ -1,6 +1,7 @@
-use crate::vulkan::vk_render_pass::VkRenderPass;
-use crate::vulkan::{VkDevice, VkGraphicsPipeline, VkInstance, VkPhysicalDevice, VkSurface, VkSwapchain};
+use crate::vulkan::vk_command_pool::VkCommandPool;
+use crate::vulkan::{VkDevice, VkGraphicsPipeline, VkInstance, VkPhysicalDevice, VkRenderPass, VkSemaphore, VkSurface, VkSwapchain};
 use ash::vk;
+use std::mem::swap;
 use std::sync::Arc;
 
 pub struct VkRenderContext {
@@ -9,6 +10,12 @@ pub struct VkRenderContext {
     device: Arc<VkDevice>,
 
     swapchain: Arc<VkSwapchain>,
+    render_pass: Arc<VkRenderPass>,
+    pipeline: Arc<VkGraphicsPipeline>,
+    command_pool: VkCommandPool,
+    command_buffers: Vec<vk::CommandBuffer>,
+    image_available_semaphore: VkSemaphore,
+    render_finished_semaphore: VkSemaphore,
 }
 
 impl VkRenderContext {
@@ -51,57 +58,88 @@ impl VkRenderContext {
             swapchain.clone(),
         )?);
 
+        let framebuffers = swapchain.create_framebuffers(render_pass.clone())
+            .ok_or_else(|| anyhow::anyhow!("Failed to get framebuffers"))?;
+
         let pipeline = Arc::new(VkGraphicsPipeline::new(
             device.clone(),
             swapchain.clone(),
             render_pass.clone(),
         )?);
 
-        let framebuffers = swapchain.present_image_views
-            .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("No present image views found"))?
-            .iter()
-            .map(|present_image_view| {
-                let attachments = [*present_image_view];
-                let framebuffer_info = vk::FramebufferCreateInfo::default()
-                    .render_pass(render_pass.handle)
-                    .width(swapchain.surface_resolution.width)
-                    .height(swapchain.surface_resolution.height)
-                    .attachments(&attachments)
-                    .layers(1);
-
-                unsafe { device.handle.create_framebuffer(&framebuffer_info, None).unwrap() }
-            })
-            .collect::<Vec<_>>();
-
-        let command_pool_info = vk::CommandPoolCreateInfo::default()
-            .queue_family_index(device.queue_family_index);
-        let command_pool = unsafe { device.handle.create_command_pool(&command_pool_info, None)? };
+        let command_pool = VkCommandPool::new(device.clone())?;
 
         let command_buffer_info = vk::CommandBufferAllocateInfo::default()
-            .command_pool(command_pool)
+            .command_pool(command_pool.handle)
             .level(vk::CommandBufferLevel::PRIMARY)
-            .command_buffer_count(framebuffers.len() as u32);
+            .command_buffer_count(framebuffers.as_ref().unwrap().len() as u32);
 
         // Destroyed with command pool
         let command_buffers = unsafe { device.handle.allocate_command_buffers(&command_buffer_info)? };
 
+        // Same in VkGraphicsPipeline (TODO: Refactor this)
+        let render_area = vk::Rect2D::default().extent(swapchain.surface_resolution);
+        let clear_value = vk::ClearValue::default();
+        for (index, command_buffer) in command_buffers.iter().enumerate() {
+            let command_buffer_begin_info = vk::CommandBufferBeginInfo::default();
+            unsafe { device.handle.begin_command_buffer(*command_buffer, &command_buffer_begin_info)? };
 
-        unsafe { device.handle.destroy_command_pool(command_pool, None) };
-        for framebuffer in framebuffers {
-            unsafe { device.handle.destroy_framebuffer(framebuffer, None) };
+            let clear_values = [clear_value];
+            let render_pass_begin_info = vk::RenderPassBeginInfo::default()
+                .render_pass(render_pass.handle)
+                .framebuffer(framebuffers[index])
+                .render_area(render_area)
+                .clear_values(&clear_values);
+
+            unsafe { device.handle.cmd_begin_render_pass(*command_buffer, &render_pass_begin_info, vk::SubpassContents::INLINE); };
+
+            unsafe { device.handle.cmd_bind_pipeline(*command_buffer, vk::PipelineBindPoint::GRAPHICS, pipeline.pipeline) };
+
+            unsafe { device.handle.cmd_draw(*command_buffer, 3, 1, 0, 0) };
+
+            unsafe { device.handle.cmd_end_render_pass(*command_buffer) };
+
+            unsafe { device.handle.end_command_buffer(*command_buffer)? };
         }
 
+        let image_available_semaphore = VkSemaphore::new(device.clone())?;
+        let render_finished_semaphore = VkSemaphore::new(device.clone())?;
+
         Ok(Self {
             instance,
             surface,
             device,
 
             swapchain,
+            render_pass,
+            pipeline,
+
+            command_pool,
+            command_buffers,
+
+            image_available_semaphore,
+            render_finished_semaphore,
         })
     }
 
     pub fn render(&mut self) -> anyhow::Result<()> {
+        let queue = self.device.get_device_queue(0)
+            .ok_or_else(|| anyhow::anyhow!("Failed to get a queue"))?;
+
+        let (index, _) = self.swapchain.acquire_next_image(&self.image_available_semaphore)?;
+
+        let wait_semaphores = [self.image_available_semaphore.handle];
+        let signal_semaphores = [self.render_finished_semaphore.handle];
+        let wait_stages = [vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT];
+        let command_buffers_to_submit = [self.command_buffers[index as usize]];
+        let submit_info = vk::SubmitInfo::default()
+            .wait_semaphores(&wait_semaphores)
+            .wait_dst_stage_mask(&wait_stages)
+            .command_buffers(&command_buffers_to_submit)
+            .signal_semaphores(&signal_semaphores);
+
+        unsafe { self.device.handle.queue_submit(*queue, &[submit_info], vk::Fence::null())? };
+
         Ok(())
     }
 
@@ -112,4 +150,8 @@ impl VkRenderContext {
 
         Ok(())
     }
+
+    pub fn exit(&self) {
+        unsafe { self.device.handle.device_wait_idle().unwrap() }
+    }
 }