a basic background

Now we can draw a window with a basic background.

But the resizing part is troublesome, I need to figure out where the
bugs are and fix them later.

But we need to render files in the window, so we need to load some
file, and render the texts on the screen.

The loading part is easy, whereas the text part needs reflections: we
need some structure to hold the buffers and then some structure for
the to-be-rendered part.

1 files changed, 37 insertions, 23 deletions

diff --git a/src/renderer/vulkan.rs b/src/renderer/vulkan.rs
index 10a9692..325ad5e 100644
--- a/src/renderer/vulkan.rs
+++ b/src/renderer/vulkan.rs
@@ -2,7 +2,7 @@
 
 use winit::{
     application::ApplicationHandler,
-    dpi::LogicalSize,
+    dpi::{LogicalSize, PhysicalSize},
     error as werror,
     event::{DeviceEvent, DeviceId, Event, WindowEvent},
     event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
@@ -70,7 +70,7 @@ impl VulkanRenderer {
         }
     }
 
-    unsafe fn recreate_swapchain(&mut self, window: &Window) -> Result<(), MainError> {
+    unsafe fn recreate_swapchain(&mut self) -> Result<(), MainError> {
         unsafe {
             if let Some(device) = &self.device {
                 device.device_wait_idle()?;
@@ -78,7 +78,9 @@ impl VulkanRenderer {
 
             self.destroy_swapchain();
 
-            if let (Some(device), Some(instance)) = (&self.device, &self.instance) {
+            if let (Some(device), Some(instance), Some(window)) =
+                (&self.device, &self.instance, &self.window)
+            {
                 create_swapchain(window, instance, device, &mut self.data)?;
 
                 create_swapchain_image_views(device, &mut self.data)?;
@@ -124,9 +126,9 @@ impl VulkanRenderer {
         }
     }
 
-    unsafe fn render(&mut self, window: &Window) -> Result<(), MainError> {
+    unsafe fn render(&mut self) -> Result<(), MainError> {
         unsafe {
-            if let Some(device) = &self.device {
+            if let (Some(device), Some(window)) = (&self.device, &self.window) {
                 device.wait_for_fences(
                     &[self.data.in_flight_fences[self.frame]],
                     true,
@@ -142,7 +144,7 @@ impl VulkanRenderer {
 
                 let image_index = match acquire_image_result {
                     Ok((image_index, _)) => image_index,
-                    Err(vk::ErrorCode::OUT_OF_DATE_KHR) => return self.recreate_swapchain(window),
+                    Err(vk::ErrorCode::OUT_OF_DATE_KHR) => return self.recreate_swapchain(),
                     Err(code) => return Err(code.into()),
                 };
 
@@ -197,7 +199,7 @@ impl VulkanRenderer {
                 {
                     self.resized = false;
 
-                    self.recreate_swapchain(window)?;
+                    self.recreate_swapchain()?;
                 } else if let Err(e) = present_result {
                     return Err(e.into());
                 }
@@ -241,10 +243,12 @@ impl VulkanRenderer {
         }
     }
 
-    fn handle_resize(&mut self, new_size: LogicalSize<u32>) {
-        // destroy old swapchain
-
+    unsafe fn handle_resize(&mut self, new_size: PhysicalSize<u32>) {
         // recreate swapchain and framebuffers
+        unsafe {
+            // self.recreate_swapchain().unwrap();
+        }
+
         println!("Window resized to {:?}", new_size);
     }
 }
@@ -305,6 +309,12 @@ impl ApplicationHandler for VulkanRenderer {
             let resized = false;
 
             self.window = Some(window);
+
+            self.device = Some(device);
+
+            self.instance = Some(instance);
+
+            self.data = data;
         }
     }
 
@@ -314,10 +324,10 @@ impl ApplicationHandler for VulkanRenderer {
         _window_id: WindowId,
         event: WindowEvent,
     ) {
-        let window = match self.window.as_ref() {
-            Some(window) => window,
-            _ => return,
-        };
+        // let window = match self.window.as_ref() {
+        //     Some(window) => window,
+        //     _ => return,
+        // };
 
         match event {
             WindowEvent::CloseRequested => event_loop.exit(),
@@ -326,13 +336,17 @@ impl ApplicationHandler for VulkanRenderer {
                 // self.draw_text(&self.test_span); // store it in self maybe?
                 // self.present();
 
-                window.request_redraw();
-            }
-            WindowEvent::Resized(new_size) => {
-                // self.handle_resize(new_size);
-                dbg!(new_size);
-                window.request_redraw();
+                unsafe {
+                    self.render().unwrap();
+                }
+
+                self.window.as_ref().unwrap().request_redraw();
             }
+            WindowEvent::Resized(new_size) => unsafe {
+                self.handle_resize(new_size);
+
+                self.window.as_ref().unwrap().request_redraw();
+            },
             _ => (),
         }
     }
@@ -947,7 +961,7 @@ unsafe fn create_command_buffers(device: &Device, data: &mut AppData) -> Result<
 
             let color_clear_value = vk::ClearValue {
                 color: vk::ClearColorValue {
-                    float32: [0.3f32, 1f32, 1f32, 0.25f32],
+                    float32: [0.3f32, 1f32, 1f32, 0.35f32],
                 },
             };
 
@@ -961,9 +975,9 @@ unsafe fn create_command_buffers(device: &Device, data: &mut AppData) -> Result<
 
             device.cmd_begin_render_pass(*buffer, &info, vk::SubpassContents::INLINE);
 
-            device.cmd_bind_pipeline(*buffer, vk::PipelineBindPoint::GRAPHICS, data.pipeline);
+            // device.cmd_bind_pipeline(*buffer, vk::PipelineBindPoint::GRAPHICS, data.pipeline);
 
-            device.cmd_draw(*buffer, 3, 1, 0, 0);
+            // device.cmd_draw(*buffer, 3, 1, 0, 0);
 
             device.cmd_end_render_pass(*buffer);