Split app, window render context and vulkan context

src/core/app.rs

@@ -0,0 +1,178 @@
+use crate::vulkan::scene::Scene;
+use crate::vulkan::vulkan_context::VulkanContext;
+use crate::vulkan::window_render_context::WindowRenderContext;
+use std::sync::Arc;
+use vulkano::command_buffer::{RenderingAttachmentInfo, RenderingInfo};
+use vulkano::render_pass::{AttachmentLoadOp, AttachmentStoreOp};
+use vulkano::swapchain::{SwapchainPresentInfo, acquire_next_image};
+use vulkano::sync::GpuFuture;
+use vulkano::{Validated, VulkanError, sync};
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::ActiveEventLoop;
+use winit::window::WindowId;
+
+pub struct App {
+    vulkan_context: VulkanContext,
+    window_render_context: Option<WindowRenderContext>,
+    scene: Option<Scene>,
+}
+
+impl From<VulkanContext> for App {
+    fn from(vulkan_context: VulkanContext) -> Self {
+        Self {
+            vulkan_context,
+            window_render_context: None,
+            scene: None,
+        }
+    }
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        let window_attributes = winit::window::Window::default_attributes()
+            .with_title("Rust ASH Test")
+            .with_inner_size(winit::dpi::PhysicalSize::new(
+                f64::from(800),
+                f64::from(600),
+            ));
+
+        let window = Arc::new(event_loop.create_window(window_attributes).unwrap());
+
+        let surface = self.vulkan_context.create_surface(window.clone());
+
+        self.window_render_context = Some(WindowRenderContext::new(
+            window,
+            surface,
+            &self.vulkan_context.device,
+        ));
+        self.scene = Some(
+            Scene::load(
+                &self.vulkan_context,
+                self.window_render_context.as_ref().unwrap(),
+            )
+            .unwrap(),
+        );
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        match event {
+            WindowEvent::CloseRequested => {
+                log::debug!("The close button was pressed; stopping");
+                event_loop.exit();
+            }
+            WindowEvent::Resized(_) => {
+                let rcx = self.window_render_context.as_mut().unwrap();
+                rcx.recreate_swapchain = true;
+            }
+            WindowEvent::RedrawRequested => {
+                let (image_index, acquire_future) = {
+                    let rcx = self.window_render_context.as_mut().unwrap();
+                    let window_size = rcx.window.inner_size();
+
+                    if window_size.width == 0 || window_size.height == 0 {
+                        return;
+                    }
+
+                    rcx.previous_frame_end.as_mut().unwrap().cleanup_finished();
+                    rcx.update_swapchain().unwrap();
+
+                    let (image_index, suboptimal, acquire_future) =
+                        match acquire_next_image(rcx.swapchain.clone(), None)
+                            .map_err(Validated::unwrap)
+                        {
+                            Ok(r) => r,
+                            Err(VulkanError::OutOfDate) => {
+                                rcx.recreate_swapchain = true;
+                                return;
+                            }
+                            Err(e) => panic!("failed to acquire next image: {e}"),
+                        };
+
+                    if suboptimal {
+                        rcx.recreate_swapchain = true;
+                    }
+
+                    (image_index, acquire_future)
+                };
+
+                let mut builder = self.vulkan_context.create_render_builder();
+
+                {
+                    let rcx = self.window_render_context.as_ref().unwrap();
+                    builder
+                        .begin_rendering(RenderingInfo {
+                            color_attachments: vec![Some(RenderingAttachmentInfo {
+                                load_op: AttachmentLoadOp::Clear,
+                                store_op: AttachmentStoreOp::Store,
+                                clear_value: Some([0.0, 0.0, 0.0, 1.0].into()),
+                                ..RenderingAttachmentInfo::image_view(
+                                    rcx.attachment_image_views[image_index as usize].clone(),
+                                )
+                            })],
+                            ..Default::default()
+                        })
+                        .unwrap()
+                        .set_viewport(0, [rcx.viewport.clone()].into_iter().collect())
+                        .unwrap();
+                }
+
+                if let Some(scene) = self.scene.as_ref() {
+                    scene
+                        .render(
+                            &self.vulkan_context,
+                            &self.window_render_context.as_ref().unwrap(),
+                            &mut builder,
+                        )
+                        .unwrap();
+                }
+
+                builder.end_rendering().unwrap();
+
+                let command_buffer = builder.build().unwrap();
+
+                {
+                    let rcx = self.window_render_context.as_mut().unwrap();
+
+                    let future = rcx
+                        .previous_frame_end
+                        .take()
+                        .unwrap()
+                        .join(acquire_future)
+                        .then_execute(self.vulkan_context.graphics_queue.clone(), command_buffer)
+                        .unwrap()
+                        .then_swapchain_present(
+                            self.vulkan_context.graphics_queue.clone(),
+                            SwapchainPresentInfo::swapchain_image_index(
+                                rcx.swapchain.clone(),
+                                image_index,
+                            ),
+                        )
+                        .then_signal_fence_and_flush();
+
+                    match future.map_err(Validated::unwrap) {
+                        Ok(future) => {
+                            rcx.previous_frame_end = Some(future.boxed());
+                        }
+                        Err(VulkanError::OutOfDate) => {
+                            rcx.recreate_swapchain = true;
+                            rcx.previous_frame_end =
+                                Some(sync::now(self.vulkan_context.device.clone()).boxed());
+                        }
+                        Err(e) => {
+                            println!("failed to flush future: {e}");
+                            rcx.previous_frame_end =
+                                Some(sync::now(self.vulkan_context.device.clone()).boxed());
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
+        let rcx = self.window_render_context.as_mut().unwrap();
+        rcx.window.request_redraw();
+    }
+}

src/core/mod.rs

@@ -0,0 +1 @@
+pub mod app;

src/main.rs

@@ -1,7 +1,8 @@
 use std::error::Error;
 use winit::event_loop::{ControlFlow, EventLoop};
 
-mod vulkan;
+pub mod core;
+pub mod vulkan;
 
 fn main() -> Result<(), impl Error> {
     env_logger::init();
@@ -9,7 +10,8 @@ fn main() -> Result<(), impl Error> {
     let event_loop = EventLoop::new().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
 
-    let mut app = vulkan::App::new(&event_loop);
+    let vulkan_context = vulkan::vulkan_context::VulkanContext::from(&event_loop);
+    let mut app = core::app::App::from(vulkan_context);
 
     event_loop.run_app(&mut app)
 }

src/vulkan/app.rs

@@ -1,295 +0,0 @@
-use crate::vulkan::Scene;
-use crate::vulkan::render_context::RenderContext;
-use std::sync::Arc;
-use vulkano::buffer::BufferUsage;
-use vulkano::buffer::allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo};
-use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
-use vulkano::command_buffer::{
-    AutoCommandBufferBuilder, CommandBufferUsage, RenderingAttachmentInfo, RenderingInfo,
-};
-use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
-use vulkano::device::physical::PhysicalDeviceType;
-use vulkano::device::{
-    Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures, Queue, QueueCreateInfo, QueueFlags,
-};
-use vulkano::instance::{Instance, InstanceCreateFlags, InstanceCreateInfo};
-use vulkano::memory::allocator::{MemoryTypeFilter, StandardMemoryAllocator};
-use vulkano::render_pass::{AttachmentLoadOp, AttachmentStoreOp};
-use vulkano::swapchain::{Surface, SwapchainPresentInfo, acquire_next_image};
-use vulkano::sync::GpuFuture;
-use vulkano::{Validated, Version, VulkanError, VulkanLibrary, sync};
-use winit::application::ApplicationHandler;
-use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
-use winit::window::WindowId;
-
-pub struct App {
-    pub instance: Arc<Instance>,
-    pub device: Arc<Device>,
-    pub queue: Arc<Queue>,
-
-    pub memory_allocator: Arc<StandardMemoryAllocator>,
-    pub command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
-    pub uniform_buffer_allocator: SubbufferAllocator,
-    pub descriptor_set_allocator: Arc<StandardDescriptorSetAllocator>,
-
-    pub rcx: Option<RenderContext>,
-    scene: Option<Scene>,
-}
-
-impl App {
-    pub fn new(event_loop: &EventLoop<()>) -> Self {
-        let library = VulkanLibrary::new().unwrap();
-
-        for layer in library.layer_properties().unwrap() {
-            log::debug!("Available layer: {}", layer.name());
-        }
-
-        let required_extensions = Surface::required_extensions(event_loop).unwrap();
-
-        let instance = Instance::new(
-            library,
-            InstanceCreateInfo {
-                // Enable enumerating devices that use non-conformant Vulkan implementations.
-                // (e.g. MoltenVK)
-                flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
-                enabled_extensions: required_extensions,
-                enabled_layers: vec![String::from("VK_LAYER_KHRONOS_validation")],
-                ..Default::default()
-            },
-        )
-        .unwrap();
-
-        let mut device_extensions = DeviceExtensions {
-            khr_swapchain: true,
-            ..DeviceExtensions::empty()
-        };
-
-        let (physical_device, queue_family_index) = instance
-            .enumerate_physical_devices()
-            .unwrap()
-            .filter(|p| {
-                p.api_version() >= Version::V1_3 || p.supported_extensions().khr_dynamic_rendering
-            })
-            .filter(|p| p.supported_extensions().contains(&device_extensions))
-            .filter_map(|p| {
-                p.queue_family_properties()
-                    .iter()
-                    .enumerate()
-                    .position(|(i, q)| {
-                        q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                            && p.presentation_support(i as u32, event_loop).unwrap()
-                    })
-                    .map(|i| (p, i as u32))
-            })
-            .min_by_key(|(p, _)| match p.properties().device_type {
-                PhysicalDeviceType::DiscreteGpu => 0,
-                PhysicalDeviceType::IntegratedGpu => 1,
-                PhysicalDeviceType::VirtualGpu => 2,
-                PhysicalDeviceType::Cpu => 3,
-                PhysicalDeviceType::Other => 4,
-                _ => 5,
-            })
-            .expect("no suitable physical device found");
-
-        log::debug!(
-            "Using device: {} (type: {:?})",
-            physical_device.properties().device_name,
-            physical_device.properties().device_type,
-        );
-
-        if physical_device.api_version() < Version::V1_3 {
-            device_extensions.khr_dynamic_rendering = true;
-        }
-
-        log::debug!("Using device extensions: {:#?}", device_extensions);
-
-        let (device, mut queues) = Device::new(
-            physical_device,
-            DeviceCreateInfo {
-                queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index,
-                    ..Default::default()
-                }],
-                enabled_extensions: device_extensions,
-                enabled_features: DeviceFeatures {
-                    dynamic_rendering: true,
-                    ..DeviceFeatures::empty()
-                },
-                ..Default::default()
-            },
-        )
-        .unwrap();
-
-        let queue = queues.next().unwrap();
-        let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
-
-        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
-            device.clone(),
-            Default::default(),
-        ));
-
-        let uniform_buffer_allocator = SubbufferAllocator::new(
-            memory_allocator.clone(),
-            SubbufferAllocatorCreateInfo {
-                buffer_usage: BufferUsage::UNIFORM_BUFFER,
-                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
-                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
-                ..Default::default()
-            },
-        );
-
-        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
-            device.clone(),
-            Default::default(),
-        ));
-
-        Self {
-            instance,
-            device,
-            queue,
-            memory_allocator,
-            command_buffer_allocator,
-            uniform_buffer_allocator,
-            descriptor_set_allocator,
-            rcx: None,
-            scene: None,
-        }
-    }
-}
-
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        let window_attributes = winit::window::Window::default_attributes()
-            .with_title("Rust ASH Test")
-            .with_inner_size(winit::dpi::PhysicalSize::new(
-                f64::from(800),
-                f64::from(600),
-            ));
-
-        let window = Arc::new(event_loop.create_window(window_attributes).unwrap());
-
-        let surface = Surface::from_window(self.instance.clone(), window.clone()).unwrap();
-
-        self.rcx = Some(RenderContext::new(window, surface, &self.device));
-        self.scene = Some(Scene::load(&self).unwrap());
-    }
-
-    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
-        match event {
-            WindowEvent::CloseRequested => {
-                log::debug!("The close button was pressed; stopping");
-                event_loop.exit();
-            }
-            WindowEvent::Resized(_) => {
-                let rcx = self.rcx.as_mut().unwrap();
-                rcx.recreate_swapchain = true;
-            }
-            WindowEvent::RedrawRequested => {
-                let (image_index, acquire_future) = {
-                    let rcx = self.rcx.as_mut().unwrap();
-                    let window_size = rcx.window.inner_size();
-
-                    if window_size.width == 0 || window_size.height == 0 {
-                        return;
-                    }
-
-                    rcx.previous_frame_end.as_mut().unwrap().cleanup_finished();
-                    rcx.update_swapchain().unwrap();
-
-                    let (image_index, suboptimal, acquire_future) =
-                        match acquire_next_image(rcx.swapchain.clone(), None)
-                            .map_err(Validated::unwrap)
-                        {
-                            Ok(r) => r,
-                            Err(VulkanError::OutOfDate) => {
-                                rcx.recreate_swapchain = true;
-                                return;
-                            }
-                            Err(e) => panic!("failed to acquire next image: {e}"),
-                        };
-
-                    if suboptimal {
-                        rcx.recreate_swapchain = true;
-                    }
-
-                    (image_index, acquire_future)
-                };
-
-                let mut builder = AutoCommandBufferBuilder::primary(
-                    self.command_buffer_allocator.clone(),
-                    self.queue.queue_family_index(),
-                    CommandBufferUsage::OneTimeSubmit,
-                )
-                .unwrap();
-
-                {
-                    let rcx = self.rcx.as_ref().unwrap();
-                    builder
-                        .begin_rendering(RenderingInfo {
-                            color_attachments: vec![Some(RenderingAttachmentInfo {
-                                load_op: AttachmentLoadOp::Clear,
-                                store_op: AttachmentStoreOp::Store,
-                                clear_value: Some([0.0, 0.0, 0.0, 1.0].into()),
-                                ..RenderingAttachmentInfo::image_view(
-                                    rcx.attachment_image_views[image_index as usize].clone(),
-                                )
-                            })],
-                            ..Default::default()
-                        })
-                        .unwrap()
-                        .set_viewport(0, [rcx.viewport.clone()].into_iter().collect())
-                        .unwrap();
-                }
-
-                if let Some(scene) = self.scene.as_ref() {
-                    scene.render(&self, &mut builder).unwrap();
-                }
-
-                builder.end_rendering().unwrap();
-
-                let command_buffer = builder.build().unwrap();
-
-                {
-                    let rcx = self.rcx.as_mut().unwrap();
-
-                    let future = rcx
-                        .previous_frame_end
-                        .take()
-                        .unwrap()
-                        .join(acquire_future)
-                        .then_execute(self.queue.clone(), command_buffer)
-                        .unwrap()
-                        .then_swapchain_present(
-                            self.queue.clone(),
-                            SwapchainPresentInfo::swapchain_image_index(
-                                rcx.swapchain.clone(),
-                                image_index,
-                            ),
-                        )
-                        .then_signal_fence_and_flush();
-
-                    match future.map_err(Validated::unwrap) {
-                        Ok(future) => {
-                            rcx.previous_frame_end = Some(future.boxed());
-                        }
-                        Err(VulkanError::OutOfDate) => {
-                            rcx.recreate_swapchain = true;
-                            rcx.previous_frame_end = Some(sync::now(self.device.clone()).boxed());
-                        }
-                        Err(e) => {
-                            println!("failed to flush future: {e}");
-                            rcx.previous_frame_end = Some(sync::now(self.device.clone()).boxed());
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
-        let rcx = self.rcx.as_mut().unwrap();
-        rcx.window.request_redraw();
-    }
-}

src/vulkan/mod.rs

@@ -1,9 +1,6 @@
-mod app;
-mod pipelines;
-mod render_context;
-mod vertex;
-pub use app::App;
+pub mod pipelines;
+pub mod vertex;
+pub mod vulkan_context;
+pub mod window_render_context;
 
-mod scene;
-pub use scene::Scene;
-pub use vertex::Vertex2D;
+pub mod scene;

src/vulkan/pipelines/triangle_pipeline.rs

@@ -20,7 +20,7 @@ use vulkano::pipeline::{
 use vulkano::shader::{EntryPoint, ShaderStages};
 use vulkano::swapchain::Swapchain;
 
-use crate::vulkan::Vertex2D;
+use crate::vulkan::vertex::Vertex2D;
 
 pub mod shaders {
     pub mod vs {

src/vulkan/scene.rs

@@ -8,7 +8,10 @@ use vulkano::command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer
 use vulkano::descriptor_set::{DescriptorSet, WriteDescriptorSet};
 use vulkano::pipeline::{GraphicsPipeline, Pipeline, PipelineBindPoint};
 
-use crate::vulkan::{App, Vertex2D, pipelines::triangle_pipeline::create_triangle_pipeline};
+use crate::vulkan::{pipelines::triangle_pipeline::create_triangle_pipeline, vertex::Vertex2D};
+
+use super::vulkan_context::VulkanContext;
+use super::window_render_context::WindowRenderContext;
 
 const VERTICES: [Vertex2D; 12] = [
     // Triangle en haut à gauche
@@ -73,10 +76,14 @@ pub struct Scene {
 }
 
 impl Scene {
-    pub fn load(app: &App) -> Result<Self, Box<dyn Error>> {
-        let pipeline = create_triangle_pipeline(&app.device, &app.rcx.as_ref().unwrap().swapchain)?;
+    pub fn load(
+        vulkan_context: &VulkanContext,
+        window_render_context: &WindowRenderContext,
+    ) -> Result<Self, Box<dyn Error>> {
+        let pipeline =
+            create_triangle_pipeline(&vulkan_context.device, &window_render_context.swapchain)?;
         let vertex_buffer =
-            Vertex2D::create_buffer(Vec::from_iter(VERTICES), &app.memory_allocator)?;
+            Vertex2D::create_buffer(Vec::from_iter(VERTICES), &vulkan_context.memory_allocator)?;
 
         Ok(Scene {
             pipeline,
@@ -87,16 +94,17 @@ impl Scene {
 
     pub fn render(
         &self,
-        app: &App,
+        vulkan_context: &VulkanContext,
+        window_render_context: &WindowRenderContext,
         builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
     ) -> Result<(), Box<dyn Error>> {
         let vertex_count = self.vertex_buffer.len() as u32;
         let instance_count = vertex_count / 3;
 
-        let uniform_buffer = self.get_uniform_buffer(app);
+        let uniform_buffer = self.get_uniform_buffer(vulkan_context, window_render_context);
         let layout = &self.pipeline.layout().set_layouts()[0];
         let descriptor_set = DescriptorSet::new(
-            app.descriptor_set_allocator.clone(),
+            vulkan_context.descriptor_set_allocator.clone(),
             layout.clone(),
             [WriteDescriptorSet::buffer(0, uniform_buffer)],
             [],
@@ -119,8 +127,12 @@ impl Scene {
         Ok(())
     }
 
-    fn get_uniform_buffer(&self, app: &App) -> Subbuffer<vs::MVPData> {
-        let swapchain = &app.rcx.as_ref().unwrap().swapchain;
+    fn get_uniform_buffer(
+        &self,
+        vulkan_context: &VulkanContext,
+        window_render_context: &WindowRenderContext,
+    ) -> Subbuffer<vs::MVPData> {
+        let swapchain = &window_render_context.swapchain;
         let elapsed = self.rotation_start.elapsed();
         let rotation = elapsed.as_secs() as f64 + elapsed.subsec_nanos() as f64 / 1_000_000_000.0;
         let rotation = Mat3::from_rotation_y(rotation as f32);
@@ -143,7 +155,10 @@ impl Scene {
             projection: proj.to_cols_array_2d(),
         };
 
-        let buffer = app.uniform_buffer_allocator.allocate_sized().unwrap();
+        let buffer = vulkan_context
+            .uniform_buffer_allocator
+            .allocate_sized()
+            .unwrap();
         *buffer.write().unwrap() = uniform_data;
 
         buffer

src/vulkan/vulkan_context.rs

@@ -0,0 +1,203 @@
+use std::{any::Any, sync::Arc};
+
+use vulkano::{
+    Version, VulkanLibrary,
+    buffer::{
+        BufferUsage,
+        allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo},
+    },
+    command_buffer::{
+        AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer,
+        allocator::StandardCommandBufferAllocator,
+    },
+    descriptor_set::allocator::StandardDescriptorSetAllocator,
+    device::{
+        Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures, Queue, QueueCreateInfo,
+        QueueFlags, physical::PhysicalDeviceType,
+    },
+    instance::{Instance, InstanceCreateFlags, InstanceCreateInfo, InstanceExtensions},
+    memory::allocator::{MemoryTypeFilter, StandardMemoryAllocator},
+    swapchain::Surface,
+};
+use winit::{
+    event_loop::EventLoop,
+    raw_window_handle::{HasDisplayHandle, HasWindowHandle},
+};
+
+pub struct VulkanContext {
+    instance: Arc<Instance>,
+    pub device: Arc<Device>,
+    pub graphics_queue: Arc<Queue>,
+
+    pub memory_allocator: Arc<StandardMemoryAllocator>,
+    pub command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
+    pub uniform_buffer_allocator: Arc<SubbufferAllocator>,
+    pub descriptor_set_allocator: Arc<StandardDescriptorSetAllocator>,
+}
+
+impl From<&EventLoop<()>> for VulkanContext {
+    fn from(event_loop: &EventLoop<()>) -> Self {
+        let library = load_library();
+
+        let enabled_extensions = Surface::required_extensions(event_loop).unwrap();
+
+        let instance = create_instance(library.clone(), enabled_extensions);
+
+        let (device, mut queues) = pick_graphics_device(&instance, event_loop);
+        let graphics_queue = queues.next().unwrap();
+
+        let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
+
+        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+
+        let uniform_buffer_allocator = Arc::new(SubbufferAllocator::new(
+            memory_allocator.clone(),
+            SubbufferAllocatorCreateInfo {
+                buffer_usage: BufferUsage::UNIFORM_BUFFER,
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+        ));
+
+        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+
+        Self {
+            instance,
+            device,
+            graphics_queue,
+            memory_allocator,
+            command_buffer_allocator,
+            uniform_buffer_allocator,
+            descriptor_set_allocator,
+        }
+    }
+}
+
+impl VulkanContext {
+    pub fn create_surface(
+        &self,
+        window: Arc<impl HasWindowHandle + HasDisplayHandle + Any + Send + Sync>,
+    ) -> Arc<Surface> {
+        Surface::from_window(self.instance.clone(), window).unwrap()
+    }
+
+    pub fn create_render_builder(&self) -> AutoCommandBufferBuilder<PrimaryAutoCommandBuffer> {
+        AutoCommandBufferBuilder::primary(
+            self.command_buffer_allocator.clone(),
+            self.graphics_queue.queue_family_index(),
+            CommandBufferUsage::OneTimeSubmit,
+        )
+        .unwrap()
+    }
+}
+
+fn load_library() -> Arc<VulkanLibrary> {
+    let library = VulkanLibrary::new().unwrap();
+
+    log::debug!("Available layer:");
+    for layer in library.layer_properties().unwrap() {
+        log::debug!(
+            "\t - Layer name: {}, Description: {}, Implementation Version: {}, Vulkan Version: {}",
+            layer.name(),
+            layer.description(),
+            layer.implementation_version(),
+            layer.vulkan_version()
+        );
+    }
+
+    library
+}
+
+fn create_instance(
+    library: Arc<VulkanLibrary>,
+    required_extensions: InstanceExtensions,
+) -> Arc<Instance> {
+    Instance::new(
+        library,
+        InstanceCreateInfo {
+            // Enable enumerating devices that use non-conformant Vulkan implementations.
+            // (e.g. MoltenVK)
+            flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
+            enabled_extensions: required_extensions,
+            enabled_layers: vec![String::from("VK_LAYER_KHRONOS_validation")],
+            ..Default::default()
+        },
+    )
+    .unwrap()
+}
+
+fn pick_graphics_device(
+    instance: &Arc<Instance>,
+    event_loop: &EventLoop<()>,
+) -> (
+    Arc<Device>,
+    impl ExactSizeIterator<Item = Arc<Queue>> + use<>,
+) {
+    let mut device_extensions = DeviceExtensions {
+        khr_swapchain: true,
+        ..DeviceExtensions::empty()
+    };
+
+    let (physical_device, queue_family_index) = instance
+        .enumerate_physical_devices()
+        .unwrap()
+        .filter(|p| {
+            p.api_version() >= Version::V1_3 || p.supported_extensions().khr_dynamic_rendering
+        })
+        .filter(|p| p.supported_extensions().contains(&device_extensions))
+        .filter_map(|p| {
+            p.queue_family_properties()
+                .iter()
+                .enumerate()
+                .position(|(i, q)| {
+                    q.queue_flags.intersects(QueueFlags::GRAPHICS)
+                        && p.presentation_support(i as u32, event_loop).unwrap()
+                })
+                .map(|i| (p, i as u32))
+        })
+        .min_by_key(|(p, _)| match p.properties().device_type {
+            PhysicalDeviceType::DiscreteGpu => 0,
+            PhysicalDeviceType::IntegratedGpu => 1,
+            PhysicalDeviceType::VirtualGpu => 2,
+            PhysicalDeviceType::Cpu => 3,
+            PhysicalDeviceType::Other => 4,
+            _ => 5,
+        })
+        .expect("no suitable physical device found");
+
+    log::debug!(
+        "Using device: {} (type: {:?})",
+        physical_device.properties().device_name,
+        physical_device.properties().device_type,
+    );
+
+    if physical_device.api_version() < Version::V1_3 {
+        device_extensions.khr_dynamic_rendering = true;
+    }
+
+    log::debug!("Using device extensions: {:#?}", device_extensions);
+
+    Device::new(
+        physical_device,
+        DeviceCreateInfo {
+            queue_create_infos: vec![QueueCreateInfo {
+                queue_family_index,
+                ..Default::default()
+            }],
+            enabled_extensions: device_extensions,
+            enabled_features: DeviceFeatures {
+                dynamic_rendering: true,
+                ..DeviceFeatures::empty()
+            },
+            ..Default::default()
+        },
+    )
+    .unwrap()
+}

src/vulkan/window_render_context.rs

@@ -5,19 +5,19 @@ use vulkano::image::{Image, ImageUsage};
 use vulkano::pipeline::graphics::viewport::Viewport;
 use vulkano::swapchain::{Surface, Swapchain, SwapchainCreateInfo};
 use vulkano::sync::GpuFuture;
-use vulkano::{sync, Validated, VulkanError};
+use vulkano::{Validated, VulkanError, sync};
 use winit::window::Window;
 
-pub struct RenderContext {
-    pub(super) window: Arc<Window>,
-    pub(super) swapchain: Arc<Swapchain>,
-    pub(super) attachment_image_views: Vec<Arc<ImageView>>,
-    pub(super) viewport: Viewport,
-    pub(super) recreate_swapchain: bool,
-    pub(super) previous_frame_end: Option<Box<dyn GpuFuture>>,
+pub struct WindowRenderContext {
+    pub window: Arc<Window>,
+    pub swapchain: Arc<Swapchain>,
+    pub attachment_image_views: Vec<Arc<ImageView>>,
+    pub viewport: Viewport,
+    pub recreate_swapchain: bool,
+    pub previous_frame_end: Option<Box<dyn GpuFuture>>,
 }
 
-impl RenderContext {
+impl WindowRenderContext {
     pub fn new(window: Arc<Window>, surface: Arc<Surface>, device: &Arc<Device>) -> Self {
         let window_size = window.inner_size();