Update rust version to 1.84.1

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "pinage404.rust-extension-pack",
+        "vadimcn.vscode-lldb",
+        "jnoortheen.nix-ide"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'rust_vulkan_test'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=rust_vulkan_test",
+                    "--package=rust_vulkan_test"
+                ],
+                "filter": {
+                    "name": "rust_vulkan_test",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'rust_vulkan_test'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=rust_vulkan_test",
+                    "--package=rust_vulkan_test"
+                ],
+                "filter": {
+                    "name": "rust_vulkan_test",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": "always",
+    },
+    "[rust]": {
+        "editor.defaultFormatter": "rust-lang.rust-analyzer",
+    },
+    "files.insertFinalNewline": true,
+    "files.trimTrailingWhitespace": true
+}

Cargo.toml

@@ -8,12 +8,13 @@ publish = false
 [dependencies]
 anyhow = "1.0"
 winit = { version = "0.30", features = ["rwh_06"] }
-ash = { version = "0.38", default-features = false, features = ["linked", "debug", "std"] }
-ash-window = "0.13"
+
+vulkano = "0.35"
+vulkano-shaders = "0.35"
+
+# Math
+glam = { version = "0.29" }
 
 # Log and tracing
 log = "0.4"
 env_logger = "0.11.5"
-
-[build-dependencies]
-glob = "0.3"

build.rs

@@ -1,24 +0,0 @@
-use std::process::Command;
-
-fn main() {
-    for shader in glob::glob("res/shaders/*").unwrap().filter_map(Result::ok) {
-        if !shader.is_file() {
-            continue;
-        }
-
-        let shader_file_name = shader.to_str().unwrap();
-
-        let mut command = Command::new("glslc");
-        command.arg(&shader);
-
-        let out_file = match shader.extension().unwrap().to_str().unwrap() {
-            "vert" => shader_file_name.replace(".vert", ".vert.spv"),
-            "frag" => shader_file_name.replace(".frag", ".frag.spv"),
-            _ => continue,
-        };
-
-        command.arg("-o");
-        command.arg(out_file);
-        command.output().unwrap();
-    }
-}

flake.lock

@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1726560853,
-        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -28,26 +28,27 @@
         ]
       },
       "locked": {
-        "lastModified": 1713543440,
-        "narHash": "sha256-lnzZQYG0+EXl/6NkGpyIz+FEOc/DSEG57AP1VsdeNrM=",
-        "owner": "nix-community",
+        "lastModified": 1735283791,
+        "narHash": "sha256-JlT4VFs8aVlW+l151HZIZumfFsccZXcO/k5WpbYF09Y=",
+        "owner": "phirsch",
         "repo": "nixGL",
-        "rev": "310f8e49a149e4c9ea52f1adf70cdc768ec53f8a",
+        "rev": "ea8baea3b9d854bf9cf5c834a805c50948dd2603",
         "type": "github"
       },
       "original": {
-        "owner": "nix-community",
+        "owner": "phirsch",
+        "ref": "fix-versionMatch",
         "repo": "nixGL",
         "type": "github"
       }
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1730831018,
-        "narHash": "sha256-2S0HwIFRxYp+afuoFORcZA9TjryAf512GmE0MTfEOPU=",
+        "lastModified": 1739863612,
+        "narHash": "sha256-UbtgxplOhFcyjBcNbTVO8+HUHAl/WXFDOb6LvqShiZo=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "8c4dc69b9732f6bbe826b5fbb32184987520ff26",
+        "rev": "632f04521e847173c54fa72973ec6c39a371211c",
         "type": "github"
       },
       "original": {
@@ -72,11 +73,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1730860036,
-        "narHash": "sha256-u0sfA4B65Q9cRO3xpIkQ4nldB8isfdIb3rWtsnRZ+Iw=",
+        "lastModified": 1739932111,
+        "narHash": "sha256-WkayjH0vuGw0hx2gmjTUGFRvMKpM17gKcpL/U8EUUw0=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "b8eb3aeb21629cbe14968a5e3b1cbaefb0d1b260",
+        "rev": "75b2271c5c087d830684cd5462d4410219acc367",
         "type": "github"
       },
       "original": {

flake.nix

@@ -9,7 +9,8 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
     nixgl = {
-      url = "github:nix-community/nixGL";
+      # Revert this to community version when https://github.com/nix-community/nixGL/pull/187 is merged
+      url = "github:phirsch/nixGL/fix-versionMatch";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.flake-utils.follows = "flake-utils";
     };
@@ -30,23 +31,29 @@
           cargo = rust;
         });
 
-        libs = with pkgs; [ vulkan-headers vulkan-loader vulkan-validation-layers ]
+        buildInputs = with pkgs; [ vulkan-headers vulkan-loader vulkan-validation-layers ]
           ++ pkgs.lib.optionals pkgs.stdenv.hostPlatform.isLinux (with pkgs; [ libxkbcommon wayland libGL ])
           ++ pkgs.lib.optionals pkgs.stdenv.hostPlatform.isDarwin (with pkgs; [ darwin.apple_sdk.frameworks.SystemConfiguration ]);
+
+        nativeBuildInputs = with pkgs; [
+          pkg-config
+          cmake
+          python312
+        ];
       in
       {
         devShells = {
           default = pkgs.mkShell {
             nativeBuildInputs = with pkgs; [
-              (rust.override { extensions = ["rust-src" "rust-analyzer"]; })
-              pkg-config
-            ];
+              (rust.override { extensions = [ "rust-src" "rust-analyzer" ]; })
+            ] ++ nativeBuildInputs;
 
-            buildInputs = libs ++ [
-              pkgs.nixgl.auto.nixVulkanNvidia pkgs.nixgl.nixVulkanIntel
-            ];
+            buildInputs = buildInputs
+              ++ [ pkgs.nixgl.auto.nixVulkanNvidia pkgs.nixgl.nixVulkanMesa ];
 
-            LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath (with pkgs; [ libxkbcommon wayland libGL ]);
+            LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath buildInputs;
+            VK_LAYER_PATH = "${pkgs.vulkan-validation-layers}/share/vulkan/explicit_layer.d";
+            RUST_LOG = "info,rust_vulkan_test=trace";
           };
         };
 
@@ -57,8 +64,7 @@
 
             src = self;
 
-            nativeBuildInputs = with pkgs; [ pkg-config shaderc ];
-            buildInputs = libs;
+            inherit nativeBuildInputs buildInputs;
 
             cargoLock = {
               lockFile = ./Cargo.lock;

res/shaders/main.frag

@@ -1,8 +0,0 @@
-#version 450
-
-layout (location = 0) in vec3 fragColor;
-layout (location = 0) out vec4 outColor;
-
-void main() {
-    outColor = vec4(fragColor, 1.0);
-}

res/shaders/main.vert

@@ -1 +0,0 @@
-#version 450

out gl_PerVertex {
    vec4 gl_Position;
};

layout (location = 0) out vec3 fragColor;

vec2 positions[3] = vec2[](
vec2(0.0, -0.5),
vec2(0.5, 0.5),
vec2(-0.5, 0.5)
);

vec3 colors[3] = vec3[](
vec3(1.0, 0.0, 0.0),
vec3(0.0, 1.0, 0.0),
vec3(0.0, 0.0, 1.0)
);

void main() {
    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
    fragColor = colors[gl_VertexIndex];
}

res/shaders/vertex.frag

@@ -1,10 +1,9 @@
 #version 450
-#extension GL_ARB_separate_shader_objects: enable
 
-layout (location = 0) in vec3 fragColor;
+layout (location = 0) in vec3 color;
 
-layout (location = 0) out vec4 outColor;
+layout (location = 0) out vec4 f_color;
 
 void main() {
-    outColor = vec4(fragColor, 1.0);
+    f_color = vec4(color, 1.0);
 }

res/shaders/vertex.vert

@@ -1 +1 @@
-#version 450
#extension GL_ARB_separate_shader_objects: enable

// NOTE: names must match the `Vertex` struct in Rust
layout (location = 0) in vec2 pos;
layout (location = 1) in vec3 color;

layout (location = 0) out vec3 fragColor;

out gl_PerVertex {
    vec4 gl_Position;
};

void main() {
    gl_Position = vec4(pos, 0.0, 1.0);
    fragColor = color;
}
+#version 450

layout (location = 0) in vec2 position;
layout (location = 1) in vec3 color;

layout (location = 0) out vec3 fragColor;

layout (set = 0, binding = 0) uniform MVPData {
    mat4 world;
    mat4 view;
    mat4 projection;
} uniforms;

void main() {
    mat4 worldview = uniforms.view * uniforms.world;
    gl_Position = uniforms.projection * worldview * vec4(position, 0.0, 1.0);
    fragColor = color;
}

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.82.0"
+channel = "1.84.1"

src/display/app.rs

@@ -1,93 +0,0 @@
-use crate::display::window::Window;
-use crate::renderer::{vulkan::VkRenderContext, Renderable};
-use winit::application::ApplicationHandler;
-use winit::event::WindowEvent;
-use winit::event_loop::ActiveEventLoop;
-use winit::window::WindowId;
-use crate::scene::TriangleScene;
-
-pub struct App {
-    window: Window,
-    render_context: Option<VkRenderContext>,
-    scene: Option<Box<dyn Renderable>>,
-}
-
-impl App {
-    pub fn new(window: Window) -> Self {
-        Self {
-            window,
-            render_context: None,
-            scene: None,
-        }
-    }
-
-    pub fn set_scene(&mut self, mut scene: Box<dyn Renderable>) {
-        let result = self.render_context.as_mut()
-            .ok_or_else(|| anyhow::anyhow!("No render context"))
-            .and_then(|render_context| render_context.init_scene(&mut scene));
-
-        match result {
-            Ok(_) => self.scene = Some(scene),
-            Err(err) => log::warn!("{err}"),
-        }
-    }
-}
-
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        self.window
-            .create_window(event_loop)
-            .map_err(|err| format!("Failed to create window: {}", err))
-            .unwrap();
-
-        self.render_context = VkRenderContext::init(&self.window).ok();
-
-        let scene = TriangleScene::new();
-        self.set_scene(Box::new(scene));
-    }
-
-    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
-        match event {
-            WindowEvent::CloseRequested => {
-                match self.render_context.as_ref() {
-                    Some(render_context) => render_context.exit(),
-                    None => log::warn!("Window closed but no render context found"),
-                };
-
-                log::debug!("The close button was pressed; stopping");
-                event_loop.exit();
-            }
-            WindowEvent::Resized(size) => {
-                match self.render_context.as_mut() {
-                    Some(render_context) => {
-                        if let Err(error) =
-                            render_context.update_resolution(size.width, size.height)
-                        {
-                            log::error!(
-                                "Failed to update resolution of render context : {}",
-                                error
-                            );
-                        }
-                    }
-                    None => log::warn!("Window resized but no render context found"),
-                };
-            }
-            WindowEvent::RedrawRequested => {
-                if !event_loop.exiting() {
-                    match self.render_context.as_mut() {
-                        Some(render_context) => {
-                            if let Err(error) = render_context.render(self.scene.as_ref()) {
-                                log::error!("Failed to render with render context : {}", error);
-                                event_loop.exit();
-                            }
-                        }
-                        None => log::warn!("Window resized but no render context found"),
-                    };
-                }
-
-                self.window.request_redraw();
-            }
-            _ => {}
-        }
-    }
-}

src/display/mod.rs

@@ -1,5 +0,0 @@
-mod app;
-mod window;
-
-pub use app::App;
-pub use window::Window;

src/display/window.rs

@@ -1,65 +0,0 @@
-use std::ffi::c_char;
-use winit::dpi::Pixel;
-use winit::event_loop::ActiveEventLoop;
-use winit::raw_window_handle::HasDisplayHandle;
-
-pub struct Window {
-    handle: Option<winit::window::Window>,
-    window_attributes: winit::window::WindowAttributes,
-}
-
-impl Window {
-    pub fn new(window_attributes: winit::window::WindowAttributes) -> Self {
-        Self {
-            handle: None,
-            window_attributes,
-        }
-    }
-
-    pub fn create_window(&mut self, event_loop: &ActiveEventLoop) -> anyhow::Result<()> {
-        let window = event_loop.create_window(self.window_attributes.clone())?;
-
-        self.handle = Some(window);
-
-        Ok(())
-    }
-
-    pub fn required_extensions(&self) -> anyhow::Result<Vec<*const c_char>> {
-        let display_handle = self
-            .handle
-            .as_ref()
-            .ok_or_else(|| anyhow::anyhow!("Window not found"))?
-            .display_handle()?;
-
-        #[allow(unused_mut)]
-        let mut extension_names =
-            ash_window::enumerate_required_extensions(display_handle.as_raw())?.to_vec();
-
-        // TODO: Move this because is not related to Window extensions
-        #[cfg(any(target_os = "macos", target_os = "ios"))]
-        {
-            extension_names.push(ash::khr::portability_enumeration::NAME.as_ptr());
-            // Enabling this extension is a requirement when using `VK_KHR_portability_subset`
-            extension_names.push(ash::khr::get_physical_device_properties2::NAME.as_ptr());
-        }
-
-        Ok(extension_names)
-    }
-
-    pub fn handle(&self) -> Option<&winit::window::Window> {
-        self.handle.as_ref()
-    }
-
-    pub fn physical_size<P: Pixel>(&self) -> Option<winit::dpi::PhysicalSize<P>> {
-        self.window_attributes
-            .inner_size
-            .and_then(|size| Some(size.to_physical::<P>(1.0)))
-    }
-
-    pub fn request_redraw(&self) {
-        match self.handle.as_ref() {
-            Some(window) => window.request_redraw(),
-            None => log::warn!("Redraw requested but no window found"),
-        }
-    }
-}

src/main.rs

@@ -1,24 +1,15 @@
+use std::error::Error;
 use winit::event_loop::{ControlFlow, EventLoop};
 
-mod display;
 mod renderer;
-mod scene;
 
-fn main() {
+fn main() -> Result<(), impl Error> {
     env_logger::init();
 
     let event_loop = EventLoop::new().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
 
-    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 mut app = renderer::App::new(&event_loop);
 
-    let window = display::Window::new(window_attributes);
-    let mut app = display::App::new(window);
-
-    event_loop.run_app(&mut app).unwrap();
+    event_loop.run_app(&mut app)
 }

src/renderer/app.rs

@@ -0,0 +1,291 @@
+use crate::renderer::render_context::RenderContext;
+use crate::renderer::Scene;
+use std::sync::Arc;
+use vulkano::buffer::allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo};
+use vulkano::buffer::BufferUsage;
+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::{acquire_next_image, Surface, SwapchainPresentInfo};
+use vulkano::sync::GpuFuture;
+use vulkano::{sync, Validated, Version, VulkanError, VulkanLibrary};
+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();
+
+        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");
+
+        println!(
+            "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;
+        }
+
+        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/renderer/mod.rs

@@ -1,9 +1,9 @@
-use std::sync::Arc;
-use ash::vk;
+mod app;
+mod pipelines;
+mod render_context;
+mod vertex;
+pub use app::App;
 
-pub mod vulkan;
-
-pub trait Renderable {
-    fn init(&mut self, device: &Arc<vulkan::VkDevice>, render_pass: &Arc<vulkan::VkRenderPass>) -> anyhow::Result<()>;
-    fn render(&self, device: &vulkan::VkDevice, swapchain: &vulkan::VkSwapchain, command_buffer: &vk::CommandBuffer) -> anyhow::Result<()>;
-}
+mod scene;
+pub use scene::Scene;
+pub use vertex::Vertex2D;

src/renderer/pipelines/mod.rs

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

src/renderer/pipelines/triangle_pipeline.rs

@@ -0,0 +1,111 @@
+use std::collections::BTreeMap;
+use std::error::Error;
+use std::sync::Arc;
+use vulkano::descriptor_set::layout::{
+    DescriptorSetLayoutBinding, DescriptorSetLayoutCreateInfo, DescriptorType,
+};
+use vulkano::device::Device;
+use vulkano::pipeline::graphics::color_blend::{ColorBlendAttachmentState, ColorBlendState};
+use vulkano::pipeline::graphics::input_assembly::InputAssemblyState;
+use vulkano::pipeline::graphics::multisample::MultisampleState;
+use vulkano::pipeline::graphics::rasterization::RasterizationState;
+use vulkano::pipeline::graphics::subpass::PipelineRenderingCreateInfo;
+use vulkano::pipeline::graphics::vertex_input::{Vertex, VertexDefinition};
+use vulkano::pipeline::graphics::viewport::ViewportState;
+use vulkano::pipeline::graphics::GraphicsPipelineCreateInfo;
+use vulkano::pipeline::layout::{PipelineDescriptorSetLayoutCreateInfo, PipelineLayoutCreateFlags};
+use vulkano::pipeline::{
+    DynamicState, GraphicsPipeline, PipelineLayout, PipelineShaderStageCreateInfo,
+};
+use vulkano::shader::{EntryPoint, ShaderStages};
+use vulkano::swapchain::Swapchain;
+
+use crate::renderer::Vertex2D;
+
+pub mod shaders {
+    pub mod vs {
+        vulkano_shaders::shader! {
+            ty: "vertex",
+            path: r"res/shaders/vertex.vert",
+        }
+    }
+
+    pub mod fs {
+        vulkano_shaders::shader! {
+            ty: "fragment",
+            path: r"res/shaders/vertex.frag",
+        }
+    }
+}
+
+pub fn create_triangle_pipeline(
+    device: &Arc<Device>,
+    swapchain: &Arc<Swapchain>,
+) -> Result<Arc<GraphicsPipeline>, Box<dyn Error>> {
+    let (vs, fs) = load_shaders(device)?;
+    let vertex_input_state = Vertex2D::per_vertex().definition(&vs)?;
+
+    let stages = [
+        PipelineShaderStageCreateInfo::new(vs),
+        PipelineShaderStageCreateInfo::new(fs),
+    ];
+
+    let mut bindings = BTreeMap::<u32, DescriptorSetLayoutBinding>::new();
+    let mut descriptor_set_layout_binding =
+        DescriptorSetLayoutBinding::descriptor_type(DescriptorType::UniformBuffer);
+    descriptor_set_layout_binding.stages = ShaderStages::VERTEX;
+    bindings.insert(0, descriptor_set_layout_binding);
+
+    let descriptor_set_layout = DescriptorSetLayoutCreateInfo {
+        bindings,
+        ..Default::default()
+    };
+
+    let create_info = PipelineDescriptorSetLayoutCreateInfo {
+        set_layouts: vec![descriptor_set_layout],
+        flags: PipelineLayoutCreateFlags::default(),
+        push_constant_ranges: vec![],
+    }
+    .into_pipeline_layout_create_info(device.clone())?;
+
+    let layout = PipelineLayout::new(device.clone(), create_info)?;
+
+    let subpass = PipelineRenderingCreateInfo {
+        color_attachment_formats: vec![Some(swapchain.image_format())],
+        ..Default::default()
+    };
+
+    let pipeline = GraphicsPipeline::new(
+        device.clone(),
+        None,
+        GraphicsPipelineCreateInfo {
+            stages: stages.into_iter().collect(),
+            vertex_input_state: Some(vertex_input_state),
+            input_assembly_state: Some(InputAssemblyState::default()),
+            viewport_state: Some(ViewportState::default()),
+            rasterization_state: Some(RasterizationState::default()),
+            multisample_state: Some(MultisampleState::default()),
+            color_blend_state: Some(ColorBlendState::with_attachment_states(
+                subpass.color_attachment_formats.len() as u32,
+                ColorBlendAttachmentState::default(),
+            )),
+            dynamic_state: [DynamicState::Viewport].into_iter().collect(),
+            subpass: Some(subpass.into()),
+            ..GraphicsPipelineCreateInfo::layout(layout)
+        },
+    )?;
+
+    Ok(pipeline)
+}
+
+fn load_shaders(device: &Arc<Device>) -> Result<(EntryPoint, EntryPoint), Box<dyn Error>> {
+    let vs = shaders::vs::load(device.clone())?
+        .entry_point("main")
+        .ok_or("Failed find main entry point of vertex shader".to_string())?;
+
+    let fs = shaders::fs::load(device.clone())?
+        .entry_point("main")
+        .ok_or("Failed find main entry point of fragment shader".to_string())?;
+
+    Ok((vs, fs))
+}

src/renderer/render_context.rs

@@ -0,0 +1,102 @@
+use std::sync::Arc;
+use vulkano::device::Device;
+use vulkano::image::view::ImageView;
+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 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>>,
+}
+
+impl RenderContext {
+    pub fn new(window: Arc<Window>, surface: Arc<Surface>, device: &Arc<Device>) -> Self {
+        let window_size = window.inner_size();
+
+        let (swapchain, images) = {
+            let surface_capabilities = device
+                .physical_device()
+                .surface_capabilities(&surface, Default::default())
+                .unwrap();
+
+            let (image_format, _) = device
+                .physical_device()
+                .surface_formats(&surface, Default::default())
+                .unwrap()[0];
+
+            Swapchain::new(
+                device.clone(),
+                surface,
+                SwapchainCreateInfo {
+                    // 2 because with some graphics driver, it crash on fullscreen because fullscreen need to min image to works.
+                    min_image_count: surface_capabilities.min_image_count.max(2),
+                    image_format,
+                    image_extent: window_size.into(),
+                    image_usage: ImageUsage::COLOR_ATTACHMENT,
+                    composite_alpha: surface_capabilities
+                        .supported_composite_alpha
+                        .into_iter()
+                        .next()
+                        .unwrap(),
+
+                    ..Default::default()
+                },
+            )
+            .unwrap()
+        };
+
+        let attachment_image_views = window_size_dependent_setup(&images);
+
+        let viewport = Viewport {
+            offset: [0.0, 0.0],
+            extent: window_size.into(),
+            depth_range: 0.0..=1.0,
+        };
+
+        let recreate_swapchain = false;
+        let previous_frame_end = Some(sync::now(device.clone()).boxed());
+
+        Self {
+            window,
+            swapchain,
+            attachment_image_views,
+            viewport,
+            recreate_swapchain,
+            previous_frame_end,
+        }
+    }
+
+    pub fn update_swapchain(&mut self) -> Result<(), Validated<VulkanError>> {
+        if !self.recreate_swapchain {
+            return Ok(());
+        }
+
+        let window_size = self.window.inner_size();
+        let (new_swapchain, new_images) = self.swapchain.recreate(SwapchainCreateInfo {
+            image_extent: window_size.into(),
+            ..self.swapchain.create_info()
+        })?;
+
+        self.swapchain = new_swapchain;
+        self.attachment_image_views = window_size_dependent_setup(&new_images);
+        self.viewport.extent = window_size.into();
+        self.recreate_swapchain = false;
+
+        Ok(())
+    }
+}
+
+fn window_size_dependent_setup(images: &[Arc<Image>]) -> Vec<Arc<ImageView>> {
+    images
+        .iter()
+        .map(|image| ImageView::new_default(image.clone()).unwrap())
+        .collect::<Vec<_>>()
+}

src/renderer/scene.rs

@@ -0,0 +1,151 @@
+use crate::renderer::pipelines::triangle_pipeline::shaders::vs;
+use glam::{Mat3, Mat4, Vec3};
+use std::error::Error;
+use std::sync::Arc;
+use std::time::Instant;
+use vulkano::buffer::Subbuffer;
+use vulkano::command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer};
+use vulkano::descriptor_set::{DescriptorSet, WriteDescriptorSet};
+use vulkano::pipeline::{GraphicsPipeline, Pipeline, PipelineBindPoint};
+
+use crate::renderer::{pipelines::triangle_pipeline::create_triangle_pipeline, App, Vertex2D};
+
+const VERTICES: [Vertex2D; 12] = [
+    // Triangle en haut à gauche
+    Vertex2D {
+        position: [-0.5, -0.75],
+        color: [1.0, 0.0, 0.0],
+    },
+    Vertex2D {
+        position: [-0.75, -0.25],
+        color: [0.0, 1.0, 0.0],
+    },
+    Vertex2D {
+        position: [-0.25, -0.25],
+        color: [0.0, 0.0, 1.0],
+    },
+    // Triangle en bas à gauche
+    Vertex2D {
+        position: [-0.5, 0.25],
+        color: [0.5, 0.5, 0.5],
+    },
+    Vertex2D {
+        position: [-0.75, 0.75],
+        color: [0.2, 0.8, 0.2],
+    },
+    Vertex2D {
+        position: [-0.25, 0.75],
+        color: [0.8, 0.2, 0.2],
+    },
+    // Triangle en haut à droite
+    Vertex2D {
+        position: [0.5, -0.75],
+        color: [1.0, 1.0, 0.0],
+    },
+    Vertex2D {
+        position: [0.25, -0.25],
+        color: [0.0, 1.0, 1.0],
+    },
+    Vertex2D {
+        position: [0.75, -0.25],
+        color: [1.0, 0.0, 1.0],
+    },
+    // Triangle en bas à droite
+    Vertex2D {
+        position: [0.5, 0.25],
+        color: [0.1, 0.5, 0.8],
+    },
+    Vertex2D {
+        position: [0.25, 0.75],
+        color: [0.8, 0.6, 0.1],
+    },
+    Vertex2D {
+        position: [0.75, 0.75],
+        color: [0.3, 0.4, 0.6],
+    },
+];
+
+pub struct Scene {
+    pipeline: Arc<GraphicsPipeline>,
+    vertex_buffer: Subbuffer<[Vertex2D]>,
+
+    rotation_start: Instant,
+}
+
+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)?;
+        let vertex_buffer =
+            Vertex2D::create_buffer(Vec::from_iter(VERTICES), &app.memory_allocator)?;
+
+        Ok(Scene {
+            pipeline,
+            vertex_buffer,
+            rotation_start: Instant::now(),
+        })
+    }
+
+    pub fn render(
+        &self,
+        app: &App,
+        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 layout = &self.pipeline.layout().set_layouts()[0];
+        let descriptor_set = DescriptorSet::new(
+            app.descriptor_set_allocator.clone(),
+            layout.clone(),
+            [WriteDescriptorSet::buffer(0, uniform_buffer)],
+            [],
+        )
+        .unwrap();
+
+        unsafe {
+            builder
+                .bind_pipeline_graphics(self.pipeline.clone())?
+                .bind_descriptor_sets(
+                    PipelineBindPoint::Graphics,
+                    self.pipeline.layout().clone(),
+                    0,
+                    descriptor_set,
+                )?
+                .bind_vertex_buffers(0, self.vertex_buffer.clone())?
+                .draw(vertex_count, instance_count, 0, 0)?;
+        }
+
+        Ok(())
+    }
+
+    fn get_uniform_buffer(&self, app: &App) -> Subbuffer<vs::MVPData> {
+        let swapchain = &app.rcx.as_ref().unwrap().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);
+
+        // NOTE: This teapot was meant for OpenGL where the origin is at the lower left
+        // instead the origin is at the upper left in Vulkan, so we reverse the Y axis.
+        let aspect_ratio = swapchain.image_extent()[0] as f32 / swapchain.image_extent()[1] as f32;
+
+        let proj = Mat4::perspective_rh_gl(std::f32::consts::FRAC_PI_2, aspect_ratio, 0.01, 100.0);
+        let view = Mat4::look_at_rh(
+            Vec3::new(0.3, 0.3, 1.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, -1.0, 0.0),
+        );
+        let scale = Mat4::from_scale(Vec3::splat(1.0));
+
+        let uniform_data = vs::MVPData {
+            world: Mat4::from_mat3(rotation).to_cols_array_2d(),
+            view: (view * scale).to_cols_array_2d(),
+            projection: proj.to_cols_array_2d(),
+        };
+
+        let buffer = app.uniform_buffer_allocator.allocate_sized().unwrap();
+        *buffer.write().unwrap() = uniform_data;
+
+        buffer
+    }
+}

src/renderer/vertex.rs

@@ -0,0 +1,38 @@
+use std::sync::Arc;
+use vulkano::buffer::{
+    AllocateBufferError, Buffer, BufferContents, BufferCreateInfo, BufferUsage, Subbuffer,
+};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
+use vulkano::pipeline::graphics::vertex_input::Vertex;
+use vulkano::Validated;
+
+#[derive(BufferContents, Vertex)]
+#[repr(C)]
+pub struct Vertex2D {
+    #[format(R32G32_SFLOAT)]
+    pub position: [f32; 2],
+
+    #[format(R32G32B32_SFLOAT)]
+    pub color: [f32; 3],
+}
+
+impl Vertex2D {
+    pub fn create_buffer(
+        vertices: Vec<Vertex2D>,
+        memory_allocator: &Arc<StandardMemoryAllocator>,
+    ) -> Result<Subbuffer<[Vertex2D]>, Validated<AllocateBufferError>> {
+        Buffer::from_iter(
+            memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::VERTEX_BUFFER,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            vertices,
+        )
+    }
+}

src/renderer/vulkan/mod.rs

@@ -1,45 +0,0 @@
-mod vk_render_context;
-pub use vk_render_context::VkRenderContext;
-
-mod vk_instance;
-pub use vk_instance::VkInstance;
-
-mod vk_surface;
-pub use vk_surface::{SwapchainSupportDetails, VkSurface};
-
-mod vk_physical_device;
-pub use vk_physical_device::VkPhysicalDevice;
-
-mod vk_device;
-pub use vk_device::VkDevice;
-
-mod vk_swapchain;
-pub use vk_swapchain::VkSwapchain;
-
-mod vk_shader_module;
-pub use vk_shader_module::VkShaderModule;
-
-mod vk_graphics_pipeline;
-pub use vk_graphics_pipeline::VkGraphicsPipeline;
-
-mod vk_render_pass;
-pub use vk_render_pass::VkRenderPass;
-
-mod vk_semaphore;
-pub use vk_semaphore::VkSemaphore;
-
-mod vk_command_pool;
-pub use vk_command_pool::VkCommandPool;
-
-mod vk_framebuffer;
-pub use vk_framebuffer::VkFramebuffer;
-
-mod vk_fence;
-pub use vk_fence::VkFence;
-
-mod utils;
-mod vertex;
-mod vk_buffer;
-pub use vk_buffer::VkBuffer;
-
-pub use vertex::Vertex;

src/renderer/vulkan/utils/layers.rs

@@ -1,51 +0,0 @@
-use std::ffi::CString;
-
-pub enum LayersSelector<'a> {
-    Nothing,
-    SpecificLayers(Vec<&'a str>),
-    All,
-}
-
-pub fn use_layers(entry: &ash::Entry, selector: LayersSelector) -> Vec<CString> {
-    let layers_available = get_layers_available(entry)
-        .iter()
-        .filter_map(|layer| {
-            layer
-                .layer_name_as_c_str()
-                .and_then(|layer_name| Ok(CString::from(layer_name)))
-                .ok()
-        })
-        .collect::<Vec<_>>();
-
-    match selector {
-        LayersSelector::Nothing => Vec::new(),
-        LayersSelector::SpecificLayers(layers) => select_layers(&layers_available, &layers),
-        LayersSelector::All => layers_available,
-    }
-}
-
-fn get_layers_available(entry: &ash::Entry) -> Vec<ash::vk::LayerProperties> {
-    unsafe {
-        entry
-            .enumerate_instance_layer_properties()
-            .unwrap_or_default()
-    }
-}
-
-fn select_layers(layers_available: &Vec<CString>, layers_to_select: &[&str]) -> Vec<CString> {
-    layers_to_select
-        .iter()
-        .filter_map(|layer_name| {
-            if layers_available.iter().any(|layer_available| {
-                layer_available
-                    .to_str()
-                    .and_then(|layer_available| Ok(layer_available.eq(*layer_name)))
-                    .unwrap_or(false)
-            }) {
-                CString::new(*layer_name).ok()
-            } else {
-                None
-            }
-        })
-        .collect::<Vec<_>>()
-}

src/renderer/vulkan/utils/mod.rs

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

src/renderer/vulkan/vertex.rs

@@ -1,37 +0,0 @@
-use ash::vk;
-use std::mem::offset_of;
-
-#[derive(Default)]
-pub struct Vertex {
-    pub position: [f32; 2],
-    pub color: [f32; 3],
-}
-
-impl Vertex {
-    pub fn new(position: [f32; 2], color: [f32; 3]) -> Self {
-        Self { position, color }
-    }
-
-    pub fn get_binding_description() -> vk::VertexInputBindingDescription {
-        vk::VertexInputBindingDescription::default()
-            .binding(0)
-            .stride(size_of::<Self>() as u32)
-            .input_rate(vk::VertexInputRate::VERTEX)
-    }
-
-    pub fn get_attribute_descriptions() -> [vk::VertexInputAttributeDescription; 2] {
-        let position_attribute = vk::VertexInputAttributeDescription::default()
-            .binding(0)
-            .location(0)
-            .format(vk::Format::R32G32_SFLOAT)
-            .offset(offset_of!(Vertex, position) as u32);
-
-        let color_attribute = vk::VertexInputAttributeDescription::default()
-            .binding(0)
-            .location(1)
-            .format(vk::Format::R32G32B32_SFLOAT)
-            .offset(offset_of!(Vertex, color) as u32);
-
-        [position_attribute, color_attribute]
-    }
-}

src/renderer/vulkan/vk_buffer.rs

@@ -1,31 +0,0 @@
-use std::sync::Arc;
-use ash::prelude::VkResult;
-use ash::vk;
-use crate::renderer::vulkan::VkDevice;
-
-pub struct VkBuffer {
-    device: Arc<VkDevice>,
-
-    handle: vk::Buffer,
-}
-
-impl VkBuffer {
-    pub fn new(device: &Arc<VkDevice>, info: &vk::BufferCreateInfo) -> VkResult<Self> {
-        let buffer = unsafe { device.handle.create_buffer(info, None)? };
-
-        Ok(VkBuffer { device: Arc::clone(device), handle: buffer })
-    }
-
-
-    pub fn mem_requirements(&self) -> vk::MemoryRequirements {
-        unsafe { self.device.handle.get_buffer_memory_requirements(self.handle) }
-    }
-}
-
-impl Drop for VkBuffer {
-    fn drop(&mut self) {
-        unsafe {
-            self.device.handle.destroy_buffer(self.handle, None);
-        }
-    }
-}

src/renderer/vulkan/vk_command_pool.rs

@@ -1,52 +0,0 @@
-use super::VkDevice;
-use ash::prelude::VkResult;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkCommandPool {
-    device: Arc<VkDevice>,
-
-    pub handle: vk::CommandPool,
-}
-
-impl VkCommandPool {
-    pub fn new(device: &Arc<VkDevice>) -> VkResult<Self> {
-        let command_pool_info =
-            vk::CommandPoolCreateInfo::default()
-                .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
-                .queue_family_index(device.queue_family_index);
-        let command_pool = unsafe {
-            device
-                .handle
-                .create_command_pool(&command_pool_info, None)?
-        };
-        log::debug!("Command pool created ({command_pool:?})");
-
-        Ok(Self {
-            device: device.clone(),
-            handle: command_pool,
-        })
-    }
-
-    pub fn allocate_command_buffers_for_framebuffers(&self, framebuffers_count: u32) -> VkResult<Vec<vk::CommandBuffer>> {
-        let command_buffer_info = vk::CommandBufferAllocateInfo::default()
-            .command_pool(self.handle)
-            .level(vk::CommandBufferLevel::PRIMARY)
-            .command_buffer_count(framebuffers_count);
-
-        let command_buffers = unsafe {
-            self.device
-                .handle
-                .allocate_command_buffers(&command_buffer_info)?
-        };
-
-        Ok(command_buffers)
-    }
-}
-
-impl Drop for VkCommandPool {
-    fn drop(&mut self) {
-        unsafe { self.device.handle.destroy_command_pool(self.handle, None) };
-        log::debug!("Command pool destroyed ({:?})", self.handle);
-    }
-}

src/renderer/vulkan/vk_device.rs

@@ -1,109 +0,0 @@
-use super::{VkInstance, VkPhysicalDevice};
-use ash::prelude::VkResult;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkDevice {
-    instance: Arc<VkInstance>,
-    physical_device: Arc<VkPhysicalDevice>,
-
-    pub handle: ash::Device,
-    pub swapchain_loader: ash::khr::swapchain::Device,
-    pub queue_family_index: u32,
-
-    // Arc not used because vk::Queue is destroyed with Device automatically
-    // so any references of vk::Queue must be destroyed with VkDevice
-    queues: Vec<vk::Queue>,
-}
-
-impl VkDevice {
-    pub fn new_graphics_device(
-        instance: &Arc<VkInstance>,
-        physical_device: &Arc<VkPhysicalDevice>,
-        queue_family_index: u32,
-    ) -> anyhow::Result<Self> {
-        let device_extension_names_raw = [
-            ash::khr::swapchain::NAME.as_ptr(),
-            #[cfg(any(target_os = "macos", target_os = "ios"))]
-            ash::khr::portability_subset::NAME.as_ptr(),
-        ];
-        let features = vk::PhysicalDeviceFeatures {
-            shader_clip_distance: 1,
-            ..Default::default()
-        };
-
-        let queues_priorities = [1.0];
-        let queue_info = vk::DeviceQueueCreateInfo::default()
-            .queue_family_index(queue_family_index)
-            .queue_priorities(&queues_priorities);
-
-        let device_create_info = vk::DeviceCreateInfo::default()
-            .queue_create_infos(std::slice::from_ref(&queue_info))
-            .enabled_extension_names(&device_extension_names_raw)
-            .enabled_features(&features);
-
-        let device = unsafe {
-            instance
-                .handle
-                .create_device(physical_device.handle, &device_create_info, None)?
-        };
-        log::debug!("Device created ({:?})", device.handle());
-
-        let queues = queues_priorities
-            .iter()
-            .enumerate()
-            .map(|(index, _)| unsafe { device.get_device_queue(queue_family_index, index as u32) })
-            .collect::<Vec<_>>();
-
-        let swapchain_loader = ash::khr::swapchain::Device::new(&instance.handle, &device);
-
-        Ok(Self {
-            instance: Arc::clone(instance),
-            physical_device: Arc::clone(&physical_device),
-            handle: device,
-            swapchain_loader,
-            queue_family_index,
-            queues,
-        })
-    }
-
-    pub fn get_device_queue(&self, queue_index: u32) -> Option<&vk::Queue> {
-        self.queues.get(queue_index as usize)
-    }
-
-    pub fn create_command_pool(
-        &self,
-        info: &vk::CommandPoolCreateInfo,
-    ) -> VkResult<vk::CommandPool> {
-        let info = info.queue_family_index(self.queue_family_index);
-
-        unsafe { self.handle.create_command_pool(&info, None) }
-    }
-
-    pub fn allocate_command_buffers(
-        &self,
-        info: &vk::CommandBufferAllocateInfo,
-    ) -> VkResult<Vec<vk::CommandBuffer>> {
-        unsafe { self.handle.allocate_command_buffers(&info) }
-    }
-
-    pub fn create_fence(&self, info: &vk::FenceCreateInfo) -> VkResult<vk::Fence> {
-        unsafe { self.handle.create_fence(&info, None) }
-    }
-
-    pub fn create_semaphore(
-        &self,
-        info: &vk::SemaphoreCreateInfo,
-    ) -> VkResult<vk::Semaphore> {
-        unsafe { self.handle.create_semaphore(&info, None) }
-    }
-}
-
-impl Drop for VkDevice {
-    fn drop(&mut self) {
-        unsafe {
-            self.handle.destroy_device(None);
-            log::debug!("Device destroyed ({:?})", self.handle.handle());
-        }
-    }
-}

src/renderer/vulkan/vk_fence.rs

@@ -1,30 +0,0 @@
-use super::VkDevice;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkFence {
-    device: Arc<VkDevice>,
-
-    pub handle: vk::Fence,
-}
-
-impl VkFence {
-    pub fn new(device: &Arc<VkDevice>) -> anyhow::Result<Self> {
-        let fence_info = vk::FenceCreateInfo::default()
-            .flags(vk::FenceCreateFlags::SIGNALED);
-        let fence = unsafe { device.handle.create_fence(&fence_info, None)? };
-        log::debug!("Fence created ({fence:?})");
-
-        Ok(Self {
-            device: device.clone(),
-            handle: fence,
-        })
-    }
-}
-
-impl Drop for VkFence {
-    fn drop(&mut self) {
-        unsafe { self.device.handle.destroy_fence(self.handle, None) };
-        log::debug!("Fence destroyed ({:?})", self.handle);
-    }
-}

src/renderer/vulkan/vk_framebuffer.rs

@@ -1,44 +0,0 @@
-use super::{VkDevice, VkRenderPass, VkSwapchain};
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkFramebuffer {
-    device: Arc<VkDevice>,
-    image_view: Arc<vk::ImageView>,
-    render_pass: Arc<VkRenderPass>,
-
-    pub handle: vk::Framebuffer,
-}
-
-impl VkFramebuffer {
-    pub fn from_swapchain_image_view(
-        device: &Arc<VkDevice>,
-        render_pass: &Arc<VkRenderPass>,
-        image_view: &Arc<vk::ImageView>,
-        swapchain: &VkSwapchain,
-    ) -> anyhow::Result<Self> {
-        let attachments = [*image_view.as_ref()];
-        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);
-
-        let framebuffer = unsafe { device.handle.create_framebuffer(&framebuffer_info, None)? };
-
-        Ok(Self {
-            device: device.clone(),
-            render_pass: render_pass.clone(),
-            image_view: image_view.clone(),
-
-            handle: framebuffer,
-        })
-    }
-}
-
-impl Drop for VkFramebuffer {
-    fn drop(&mut self) {
-        unsafe { self.device.handle.destroy_framebuffer(self.handle, None) };
-    }
-}

src/renderer/vulkan/vk_graphics_pipeline.rs

@@ -1,120 +0,0 @@
-use super::{VkDevice, VkRenderPass, VkShaderModule, VkSwapchain};
-use ash::vk;
-use std::ffi::CStr;
-use std::sync::Arc;
-
-pub struct VkGraphicsPipeline {
-    device: Arc<VkDevice>,
-    render_pass: Arc<VkRenderPass>,
-
-    pub pipeline_layout: vk::PipelineLayout,
-    pub pipeline: vk::Pipeline,
-    vertex_shader: VkShaderModule,
-    fragment_shader: VkShaderModule,
-}
-
-impl VkGraphicsPipeline {
-    pub fn new(
-        device: &Arc<VkDevice>,
-        render_pass: &Arc<VkRenderPass>,
-    ) -> anyhow::Result<Self> {
-        let shader_entry_name = CStr::from_bytes_with_nul(b"main\0")?;
-
-        let vert_shader_module =
-            VkShaderModule::from_spv_file(device, "res/shaders/main.vert.spv")?;
-
-        let vert_shader_info = vk::PipelineShaderStageCreateInfo::default()
-            .module(vert_shader_module.handle)
-            .name(shader_entry_name)
-            .stage(vk::ShaderStageFlags::VERTEX);
-
-        let frag_shader_module =
-            VkShaderModule::from_spv_file(device, "res/shaders/main.frag.spv")?;
-
-        let frag_shader_info = vk::PipelineShaderStageCreateInfo::default()
-            .module(frag_shader_module.handle)
-            .name(shader_entry_name)
-            .stage(vk::ShaderStageFlags::FRAGMENT);
-
-        let shader_stage_create_infos = [vert_shader_info, frag_shader_info];
-
-        let vertex_input_info = vk::PipelineVertexInputStateCreateInfo::default();
-
-        let input_assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
-            .topology(vk::PrimitiveTopology::TRIANGLE_LIST);
-
-        let viewport_state = vk::PipelineViewportStateCreateInfo::default()
-            .viewport_count(1)
-            .scissor_count(1);
-
-        let rasterizer = vk::PipelineRasterizationStateCreateInfo::default()
-            .polygon_mode(vk::PolygonMode::FILL)
-            .cull_mode(vk::CullModeFlags::BACK)
-            .front_face(vk::FrontFace::CLOCKWISE)
-            .line_width(1.0);
-
-        let multisampling = vk::PipelineMultisampleStateCreateInfo::default()
-            .rasterization_samples(vk::SampleCountFlags::TYPE_1)
-            .min_sample_shading(1.0);
-
-        let color_blend_attachment = vk::PipelineColorBlendAttachmentState::default()
-            .color_write_mask(vk::ColorComponentFlags::RGBA);
-
-        let attachments = [color_blend_attachment];
-        let color_blending =
-            vk::PipelineColorBlendStateCreateInfo::default().attachments(&attachments);
-
-        let dynamic_state = vk::PipelineDynamicStateCreateInfo::default()
-            .dynamic_states(&[vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]);
-
-        let pipeline_layout_info = vk::PipelineLayoutCreateInfo::default();
-        let pipeline_layout = unsafe {
-            device
-                .handle
-                .create_pipeline_layout(&pipeline_layout_info, None)?
-        };
-        log::debug!("Pipeline layout created ({pipeline_layout:?})");
-
-        let pipeline_info = vk::GraphicsPipelineCreateInfo::default()
-            .stages(&shader_stage_create_infos)
-            .vertex_input_state(&vertex_input_info)
-            .input_assembly_state(&input_assembly)
-            .viewport_state(&viewport_state)
-            .rasterization_state(&rasterizer)
-            .multisample_state(&multisampling)
-            .color_blend_state(&color_blending)
-            .dynamic_state(&dynamic_state)
-            .layout(pipeline_layout)
-            .render_pass(render_pass.handle);
-        let pipeline = unsafe {
-            device
-                .handle
-                .create_graphics_pipelines(vk::PipelineCache::null(), &[pipeline_info], None)
-                .map_err(|(_, error)| error)?[0]
-        };
-        log::debug!("Pipeline created ({pipeline_layout:?})");
-
-        Ok(Self {
-            device: device.clone(),
-            render_pass: render_pass.clone(),
-            pipeline_layout,
-            pipeline,
-            vertex_shader: vert_shader_module,
-            fragment_shader: frag_shader_module,
-        })
-    }
-}
-
-impl Drop for VkGraphicsPipeline {
-    fn drop(&mut self) {
-        unsafe {
-            self.device.handle.destroy_pipeline(self.pipeline, None);
-            log::debug!("Pipeline destroyed ({:?})", self.pipeline);
-
-            self.device
-                .handle
-                .destroy_pipeline_layout(self.pipeline_layout, None);
-            log::debug!("Pipeline layout destroyed ({:?})", self.pipeline_layout);
-        }
-    }
-}

src/renderer/vulkan/vk_instance.rs

@@ -1,128 +0,0 @@
-use crate::renderer::vulkan::{
-    utils::layers::{use_layers, LayersSelector},
-    VkPhysicalDevice,
-};
-use ash::khr::surface;
-use ash::{vk, Entry, Instance};
-use std::ffi::{c_char, CStr, CString};
-use std::sync::Arc;
-
-pub struct VkInstance {
-    pub entry: Entry,
-    pub handle: Instance,
-    pub surface_loader: surface::Instance,
-}
-
-impl VkInstance {
-    pub fn new(required_extensions: &Vec<*const c_char>) -> Self {
-        let entry = Entry::linked();
-
-        log::debug!("Initializing Vulkan instance");
-
-        if log::log_enabled!(log::Level::Debug) {
-            let layer_properties =
-                unsafe { entry.enumerate_instance_layer_properties() }.unwrap_or_default();
-
-            for layer_property in layer_properties {
-                let layer_extensions = unsafe {
-                    entry.enumerate_instance_extension_properties(
-                        layer_property.layer_name_as_c_str().ok(),
-                    )
-                }
-                    .unwrap_or_default();
-                log::debug!("{layer_property:#?} {layer_extensions:#?}");
-            }
-        }
-
-        {
-            let required_extensions = required_extensions
-                .iter()
-                .map(|str| unsafe { CStr::from_ptr(*str) })
-                .map(|cstr| cstr.to_string_lossy())
-                .collect::<Vec<_>>();
-            log::debug!(
-                "Required instance extensions: {}",
-                required_extensions.join(", ")
-            );
-        }
-
-        // Layers
-        #[allow(unused)]
-        let mut layer_selector = LayersSelector::Nothing;
-        #[cfg(debug_assertions)]
-        {
-            layer_selector = LayersSelector::SpecificLayers(vec![
-                "VK_LAYER_KHRONOS_validation",
-                "VK_LAYER_MANGOHUD_overlay_x86_64",
-                "VK_LAYER_NV_optimus",
-            ]);
-        }
-        let layers = use_layers(&entry, layer_selector);
-
-        {
-            let layers = layers
-                .iter()
-                .map(|layer| layer.to_string_lossy())
-                .collect::<Vec<_>>();
-            log::debug!("Selected debug layers : {}", layers.join(", "))
-        }
-
-        let layers_raw = layers.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
-
-        // App Info
-        let app_name = CString::new("VulkanTriangle").unwrap();
-        let appinfo = vk::ApplicationInfo::default()
-            .application_name(app_name.as_c_str())
-            .application_version(0)
-            .engine_name(app_name.as_c_str())
-            .engine_version(0)
-            .api_version(vk::make_api_version(0, 1, 0, 0));
-
-        let create_flags = if cfg!(any(target_os = "macos", target_os = "ios")) {
-            vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR
-        } else {
-            vk::InstanceCreateFlags::default()
-        };
-
-        // Instance Info
-        let create_info = vk::InstanceCreateInfo::default()
-            .application_info(&appinfo)
-            .enabled_layer_names(&layers_raw)
-            .enabled_extension_names(&required_extensions)
-            .flags(create_flags);
-
-        let instance: Instance = unsafe {
-            entry
-                .create_instance(&create_info, None)
-                .expect("Instance creation error")
-        };
-
-        let surface_loader = surface::Instance::new(&entry, &instance);
-
-        log::debug!("Vulkan instance created ({:?})", instance.handle());
-
-        Self {
-            entry,
-            handle: instance,
-            surface_loader,
-        }
-    }
-
-    pub fn get_physical_devices(instance: &Arc<Self>) -> Vec<VkPhysicalDevice> {
-        let physical_devices = unsafe { instance.handle.enumerate_physical_devices() };
-        physical_devices
-            .unwrap_or_default()
-            .iter()
-            .map(|physical_device| VkPhysicalDevice::new(&instance, *physical_device))
-            .collect()
-    }
-}
-
-impl Drop for VkInstance {
-    fn drop(&mut self) {
-        unsafe {
-            self.handle.destroy_instance(None);
-        }
-        log::debug!("Vulkan instance destroyed ({:?})", self.handle.handle());
-    }
-}

src/renderer/vulkan/vk_physical_device.rs

@@ -1,85 +0,0 @@
-use std::sync::Arc;
-use super::{VkInstance, VkSurface};
-use ash::vk;
-
-pub struct VkPhysicalDevice {
-    instance: Arc<VkInstance>,
-    pub handle: vk::PhysicalDevice,
-
-    pub properties: vk::PhysicalDeviceProperties,
-    pub features: vk::PhysicalDeviceFeatures,
-    pub queue_family_properties: Vec<vk::QueueFamilyProperties>,
-}
-
-impl VkPhysicalDevice {
-    pub fn new(instance: &Arc<VkInstance>, physical_device: vk::PhysicalDevice) -> Self {
-        log::debug!("New physical device");
-        let device_properties = unsafe { instance.handle.get_physical_device_properties(physical_device) };
-        log::debug!("{device_properties:#?}");
-        let device_features = unsafe { instance.handle.get_physical_device_features(physical_device) };
-        log::debug!("{device_features:#?}");
-        let device_queue_families =
-            unsafe { instance.handle.get_physical_device_queue_family_properties(physical_device) };
-        log::debug!("{device_queue_families:#?}");
-
-        Self {
-            instance: Arc::clone(instance),
-            handle: physical_device,
-            properties: device_properties,
-            features: device_features,
-            queue_family_properties: device_queue_families,
-        }
-    }
-
-    pub fn find_queue_family_by(
-        &self,
-        queue_flags: Option<vk::QueueFlags>,
-        surface: Option<&VkSurface>,
-    ) -> Option<(u32, &vk::QueueFamilyProperties)> {
-        self.queue_family_properties.iter().enumerate().find_map(
-            |(index, queue_family_property)| {
-                let surface_check_passed = match surface {
-                    Some(surface) => surface
-                        .physical_device_queue_supported(self, index as u32)
-                        .unwrap_or(false),
-                    None => true,
-                };
-
-                let queue_flags_check_passed = match queue_flags {
-                    Some(queue_flags) => queue_family_property.queue_flags.contains(queue_flags),
-                    None => true,
-                };
-
-                if surface_check_passed && queue_flags_check_passed {
-                    Some((index as u32, queue_family_property))
-                } else {
-                    None
-                }
-            },
-        )
-    }
-
-    pub fn pick_physical_device_and_queue_by<'a>(
-        physical_devices: &'a Vec<VkPhysicalDevice>,
-        queue_flags: Option<vk::QueueFlags>,
-        surface: Option<&VkSurface>,
-    ) -> Option<(&'a VkPhysicalDevice, u32, &'a vk::QueueFamilyProperties)> {
-        physical_devices.iter().find_map(|physical_device| {
-            physical_device
-                .find_queue_family_by(queue_flags, surface)
-                .and_then(|(queue_index, queue_family_properties)| {
-                    Some((physical_device, queue_index, queue_family_properties))
-                })
-        })
-    }
-
-    pub fn priority(&self) -> usize {
-        match self.properties.device_type {
-            vk::PhysicalDeviceType::CPU => 1,
-            vk::PhysicalDeviceType::VIRTUAL_GPU => 2,
-            vk::PhysicalDeviceType::INTEGRATED_GPU => 3,
-            vk::PhysicalDeviceType::DISCRETE_GPU => 4,
-            _ => 0,
-        }
-    }
-}

src/renderer/vulkan/vk_render_context.rs

@@ -1,206 +0,0 @@
-use super::{
-    VkCommandPool, VkDevice, VkFence, VkFramebuffer, VkGraphicsPipeline, VkInstance, VkPhysicalDevice,
-    VkRenderPass, VkSemaphore, VkSurface, VkSwapchain,
-};
-use ash::vk;
-use std::sync::Arc;
-use crate::renderer::Renderable;
-
-pub struct VkRenderContext {
-    instance: Arc<VkInstance>,
-    surface: Arc<VkSurface>,
-    device: Arc<VkDevice>,
-
-    swapchain: Arc<VkSwapchain>,
-    render_pass: Arc<VkRenderPass>,
-    framebuffers: Vec<Arc<VkFramebuffer>>,
-
-    command_pool: VkCommandPool,
-    command_buffers: Vec<vk::CommandBuffer>,
-    image_available_semaphore: VkSemaphore,
-    render_finished_semaphore: VkSemaphore,
-    in_flight_fence: VkFence,
-}
-
-impl VkRenderContext {
-    pub fn init(window: &crate::display::Window) -> anyhow::Result<Self> {
-        let required_extensions = window.required_extensions()?;
-
-        let instance = Arc::new(VkInstance::new(&required_extensions));
-        let surface = Arc::new(VkSurface::new(&window, instance.clone())?);
-
-        let mut physical_devices = VkInstance::get_physical_devices(&instance);
-        physical_devices.sort_by(|a, b| b.priority().cmp(&a.priority()));
-
-        let (physical_device, queue_family_index, properties) =
-            VkPhysicalDevice::pick_physical_device_and_queue_by(
-                &physical_devices,
-                Some(vk::QueueFlags::GRAPHICS),
-                Some(&surface),
-            )
-                .ok_or_else(|| anyhow::anyhow!("Unable to find physical device"))?;
-        log::debug!(
-            "Selected queue {properties:#?} for physical device {:?}",
-            physical_device.properties.device_name_as_c_str()
-        );
-
-        let device = Arc::new(VkDevice::new_graphics_device(
-            &instance,
-            &physical_device,
-            queue_family_index,
-        )?);
-
-        let swapchain = Arc::new(VkSwapchain::new(
-            &window,
-            &surface,
-            &device,
-            &physical_device,
-        )?);
-
-        let render_pass = Arc::new(VkRenderPass::new(&device, &swapchain)?);
-
-        let framebuffers = swapchain
-            .create_framebuffers(&render_pass)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get framebuffers"))?;
-
-        let command_pool = VkCommandPool::new(&device)?;
-
-        // Destroyed with command pool
-        let command_buffers = command_pool
-            .allocate_command_buffers_for_framebuffers(framebuffers.len() as u32)?;
-
-        let image_available_semaphore = VkSemaphore::new(&device)?;
-        let render_finished_semaphore = VkSemaphore::new(&device)?;
-        let in_flight_fence = VkFence::new(&device)?;
-
-        Ok(Self {
-            instance,
-            surface,
-            device,
-
-            swapchain,
-            render_pass,
-            framebuffers,
-
-            command_pool,
-            command_buffers,
-
-            image_available_semaphore,
-            render_finished_semaphore,
-            in_flight_fence,
-        })
-    }
-
-    pub fn render(&mut self, scene: Option<&Box<dyn Renderable>>) -> anyhow::Result<()> {
-        unsafe { self.device.handle.wait_for_fences(&[self.in_flight_fence.handle], true, u64::MAX)? };
-        unsafe { self.device.handle.reset_fences(&[self.in_flight_fence.handle])? };
-
-        let (index, _) = self
-            .swapchain
-            .acquire_next_image(&self.image_available_semaphore)?;
-
-        // if self.swapchain.is_dirty() {
-        //     self.update_swapchain()?
-        // }
-
-        let command_buffer = self.command_buffers[index as usize];
-        unsafe { self.device.handle.reset_command_buffer(command_buffer, vk::CommandBufferResetFlags::default())? };
-
-        let render_area = vk::Rect2D::default().extent(self.swapchain.surface_resolution);
-        let clear_value = vk::ClearValue::default();
-        let command_buffer_begin_info = vk::CommandBufferBeginInfo::default();
-        unsafe {
-            self.device
-                .handle
-                .begin_command_buffer(command_buffer, &command_buffer_begin_info)?
-        };
-
-        let clear_values = [clear_value];
-        let framebuffer = self.framebuffers[index as usize].as_ref();
-        let render_pass_begin_info = vk::RenderPassBeginInfo::default()
-            .render_pass(self.render_pass.handle)
-            .framebuffer(framebuffer.handle)
-            .render_area(render_area)
-            .clear_values(&clear_values);
-
-        unsafe {
-            self.device.handle.cmd_begin_render_pass(
-                command_buffer,
-                &render_pass_begin_info,
-                vk::SubpassContents::INLINE,
-            );
-        };
-
-        if let Some(scene) = scene {
-            scene.render(&self.device, &self.swapchain, &command_buffer)?;
-        }
-
-        unsafe { self.device.handle.cmd_end_render_pass(command_buffer) };
-
-        unsafe { self.device.handle.end_command_buffer(command_buffer)? };
-
-        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 = [command_buffer];
-        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);
-
-        let queue = self
-            .device
-            .get_device_queue(0)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get a queue"))?;
-
-        unsafe {
-            self.device
-                .handle
-                .queue_submit(*queue, &[submit_info], self.in_flight_fence.handle)?
-        };
-
-        let swapchains = [self.swapchain.handle.unwrap()];
-        let indices = [index];
-        let present_info = vk::PresentInfoKHR::default()
-            .wait_semaphores(&signal_semaphores)
-            .swapchains(&swapchains)
-            .image_indices(&indices);
-
-        unsafe { self.device.swapchain_loader.queue_present(*queue, &present_info)? };
-
-        Ok(())
-    }
-
-    pub fn update_resolution(&mut self, width: u32, height: u32) -> anyhow::Result<()> {
-        match Arc::get_mut(&mut self.swapchain) {
-            Some(swapchain) => swapchain.update_resolution(width, height)?,
-            None => log::warn!("Impossible to get mutable swapchain"),
-        }
-
-        Ok(())
-    }
-
-    pub fn exit(&self) {
-        unsafe { self.device.handle.device_wait_idle().unwrap() }
-    }
-
-    pub fn init_scene(&self, scene: &mut Box<dyn Renderable>) -> anyhow::Result<()> {
-        scene.init(&self.device, &self.render_pass)
-    }
-
-    fn update_swapchain(&mut self) -> anyhow::Result<()> {
-        match Arc::get_mut(&mut self.swapchain) {
-            Some(swapchain) => {
-                swapchain.create_swapchain()?;
-
-                self.framebuffers = self.swapchain
-                    .create_framebuffers(&self.render_pass)
-                    .ok_or_else(|| anyhow::anyhow!("Failed to get framebuffers"))?;
-            }
-            None => log::warn!("Impossible to get mutable swapchain"),
-        }
-
-        Ok(())
-    }
-}

src/renderer/vulkan/vk_render_pass.rs

@@ -1,56 +0,0 @@
-use super::{VkDevice, VkSwapchain};
-use ash::prelude::VkResult;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkRenderPass {
-    device: Arc<VkDevice>,
-
-    pub handle: vk::RenderPass,
-}
-
-impl VkRenderPass {
-    pub fn new(device: &Arc<VkDevice>, swapchain: &Arc<VkSwapchain>) -> VkResult<Self> {
-        let color_attachment = vk::AttachmentDescription::default()
-            .format(swapchain.surface_format.format)
-            .samples(vk::SampleCountFlags::TYPE_1)
-            .load_op(vk::AttachmentLoadOp::CLEAR)
-            .store_op(vk::AttachmentStoreOp::STORE)
-            .stencil_load_op(vk::AttachmentLoadOp::DONT_CARE)
-            .stencil_store_op(vk::AttachmentStoreOp::DONT_CARE)
-            .initial_layout(vk::ImageLayout::UNDEFINED)
-            .final_layout(vk::ImageLayout::PRESENT_SRC_KHR);
-
-        let color_attachment_ref = vk::AttachmentReference::default()
-            .attachment(0)
-            .layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
-
-        let color_attachments = [color_attachment_ref];
-        let subpass = vk::SubpassDescription::default()
-            .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
-            .color_attachments(&color_attachments);
-
-        let attachments = [color_attachment];
-        let subpasses = [subpass];
-        let render_pass_info = vk::RenderPassCreateInfo::default()
-            .attachments(&attachments)
-            .subpasses(&subpasses);
-
-        let render_pass = unsafe { device.handle.create_render_pass(&render_pass_info, None)? };
-        log::debug!("Render pass created ({render_pass:?})");
-
-        Ok(Self {
-            device: device.clone(),
-            handle: render_pass,
-        })
-    }
-}
-
-impl Drop for VkRenderPass {
-    fn drop(&mut self) {
-        unsafe {
-            self.device.handle.destroy_render_pass(self.handle, None);
-            log::debug!("Render pass destroyed ({:?})", self.handle);
-        }
-    }
-}

src/renderer/vulkan/vk_semaphore.rs

@@ -1,29 +0,0 @@
-use super::VkDevice;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkSemaphore {
-    device: Arc<VkDevice>,
-
-    pub handle: vk::Semaphore,
-}
-
-impl VkSemaphore {
-    pub fn new(device: &Arc<VkDevice>) -> anyhow::Result<Self> {
-        let semaphore_info = vk::SemaphoreCreateInfo::default();
-        let semaphore = unsafe { device.handle.create_semaphore(&semaphore_info, None)? };
-        log::debug!("Semaphore created ({semaphore:?})");
-
-        Ok(Self {
-            device: device.clone(),
-            handle: semaphore,
-        })
-    }
-}
-
-impl Drop for VkSemaphore {
-    fn drop(&mut self) {
-        unsafe { self.device.handle.destroy_semaphore(self.handle, None) };
-        log::debug!("Semaphore destroyed ({:?})", self.handle);
-    }
-}

src/renderer/vulkan/vk_shader_module.rs

@@ -1,42 +0,0 @@
-use super::VkDevice;
-use ash::vk;
-use std::path::Path;
-use std::sync::Arc;
-
-pub struct VkShaderModule {
-    device: Arc<VkDevice>,
-
-    pub handle: vk::ShaderModule,
-}
-
-impl VkShaderModule {
-    pub fn from_spv_file<P: AsRef<Path>>(device: &Arc<VkDevice>, path: P) -> anyhow::Result<Self> {
-        let mut file = std::fs::File::open(&path)?;
-        let frag_shader_str = ash::util::read_spv(&mut file)?;
-
-        let shader_create_info = vk::ShaderModuleCreateInfo::default().code(&frag_shader_str);
-        let shader_module = unsafe {
-            device
-                .handle
-                .create_shader_module(&shader_create_info, None)?
-        };
-        log::debug!(
-            "Shader module created ({shader_module:?}) from {:?}",
-            path.as_ref()
-        );
-
-        Ok(Self {
-            device: device.clone(),
-            handle: shader_module,
-        })
-    }
-}
-
-impl Drop for VkShaderModule {
-    fn drop(&mut self) {
-        unsafe {
-            self.device.handle.destroy_shader_module(self.handle, None);
-            log::debug!("Shader module destroyed ({:?})", self.handle);
-        }
-    }
-}

src/renderer/vulkan/vk_surface.rs

@@ -1,94 +0,0 @@
-use super::{VkInstance, VkPhysicalDevice};
-use ash::prelude::VkResult;
-use ash::vk;
-use std::sync::Arc;
-use winit::raw_window_handle::{HasDisplayHandle, HasWindowHandle};
-
-pub struct SwapchainSupportDetails(
-    pub Vec<vk::SurfaceFormatKHR>,
-    pub vk::SurfaceCapabilitiesKHR,
-    pub Vec<vk::PresentModeKHR>,
-);
-
-pub struct VkSurface {
-    instance: Arc<VkInstance>,
-
-    pub handle: vk::SurfaceKHR,
-}
-
-impl VkSurface {
-    pub fn new(window: &crate::display::Window, instance: Arc<VkInstance>) -> anyhow::Result<Self> {
-        let window_handle = window
-            .handle()
-            .ok_or_else(|| anyhow::anyhow!("Window handle is not available."))?;
-
-        let surface = unsafe {
-            ash_window::create_surface(
-                &instance.entry,
-                &instance.handle,
-                window_handle.display_handle()?.as_raw(),
-                window_handle.window_handle()?.as_raw(),
-                None,
-            )?
-        };
-
-        log::debug!("Surface created ({:?})", surface);
-
-        Ok(Self { instance, handle: surface })
-    }
-
-    pub fn physical_device_queue_supported(
-        &self,
-        physical_device: &VkPhysicalDevice,
-        queue_index: u32,
-    ) -> VkResult<bool> {
-        unsafe {
-            self.instance
-                .surface_loader
-                .get_physical_device_surface_support(
-                    physical_device.handle,
-                    queue_index,
-                    self.handle,
-                )
-        }
-    }
-
-    pub fn get_physical_device_swapchain_support_details(
-        &self,
-        physical_device: &VkPhysicalDevice,
-    ) -> VkResult<SwapchainSupportDetails> {
-        unsafe {
-            let formats = self
-                .instance
-                .surface_loader
-                .get_physical_device_surface_formats(physical_device.handle, self.handle)?;
-
-            let capabilities = self
-                .instance
-                .surface_loader
-                .get_physical_device_surface_capabilities(physical_device.handle, self.handle)?;
-
-            let present_modes = self
-                .instance
-                .surface_loader
-                .get_physical_device_surface_present_modes(physical_device.handle, self.handle)?;
-
-            Ok(SwapchainSupportDetails(
-                formats,
-                capabilities,
-                present_modes,
-            ))
-        }
-    }
-}
-
-impl Drop for VkSurface {
-    fn drop(&mut self) {
-        unsafe {
-            self.instance
-                .surface_loader
-                .destroy_surface(self.handle, None);
-        }
-        log::debug!("Surface destroyed ({:?})", self.handle);
-    }
-}

src/renderer/vulkan/vk_swapchain.rs

@@ -1,297 +0,0 @@
-use super::{SwapchainSupportDetails, VkDevice, VkFramebuffer, VkPhysicalDevice, VkRenderPass, VkSemaphore, VkSurface};
-use crate::display::Window;
-use ash::prelude::VkResult;
-use ash::vk;
-use std::sync::Arc;
-
-pub struct VkSwapchain {
-    surface: Arc<VkSurface>,
-    device: Arc<VkDevice>,
-
-    pub handle: Option<vk::SwapchainKHR>,
-    swapchain_support_details: SwapchainSupportDetails,
-
-    pub desired_image_count: u32,
-    pub surface_format: vk::SurfaceFormatKHR,
-    pub surface_resolution: vk::Extent2D,
-    pub new_requested_surface_resolution: Option<vk::Extent2D>,
-    pub present_mode: vk::PresentModeKHR,
-    pub pre_transform: vk::SurfaceTransformFlagsKHR,
-
-    pub present_images: Option<Vec<vk::Image>>,
-    pub present_image_views: Option<Vec<Arc<vk::ImageView>>>,
-}
-
-impl VkSwapchain {
-    pub fn new(
-        window: &Window,
-        surface: &Arc<VkSurface>,
-        device: &Arc<VkDevice>,
-        physical_device: &VkPhysicalDevice,
-    ) -> anyhow::Result<Self> {
-        log::debug!("Creating swapchain");
-
-        let window_size = window
-            .physical_size::<u32>()
-            .and_then(|size| {
-                Some(vk::Extent2D {
-                    width: size.width,
-                    height: size.height,
-                })
-            })
-            .ok_or_else(|| anyhow::anyhow!("Failed to get swapchain extent"))?;
-        log::debug!("Window size ({}x{})", window_size.width, window_size.height);
-
-        let swapchain_support_details =
-            surface.get_physical_device_swapchain_support_details(physical_device)?;
-        let SwapchainSupportDetails(surface_formats, surface_capabilities, present_modes) =
-            &swapchain_support_details;
-        log::debug!("Supported surface formats by physical device: {surface_formats:#?}");
-        log::debug!("Surface capabilities: {surface_capabilities:#?}");
-        log::debug!("Present modes: {present_modes:#?}");
-
-        let surface_format = Self::choose_surface_format(surface_formats)
-            .ok_or_else(|| anyhow::anyhow!("No available surface formats"))?;
-        let desired_image_count = Self::choose_desired_image_count(surface_capabilities);
-        let swapchain_extent = Self::choose_swapchain_extent(window_size, surface_capabilities);
-        let pre_transform = Self::choose_pre_transform(surface_capabilities);
-        let present_mode = Self::choose_present_mode(present_modes);
-
-        let mut swapchain = Self {
-            surface: surface.clone(),
-            device: device.clone(),
-
-            handle: None,
-            new_requested_surface_resolution: None,
-            swapchain_support_details,
-            desired_image_count,
-            surface_format,
-            surface_resolution: swapchain_extent,
-            present_mode,
-            pre_transform,
-            present_images: None,
-            present_image_views: None,
-        };
-
-        swapchain.create_swapchain()?;
-
-        Ok(swapchain)
-    }
-
-    pub fn create_swapchain(&mut self) -> VkResult<()> {
-        if let Some(new_requested_surface_resolution) = self.new_requested_surface_resolution {
-            self.surface_resolution = new_requested_surface_resolution;
-            self.new_requested_surface_resolution = None;
-        }
-
-        let mut swapchain_create_info = self.create_swapchain_info(&self.surface);
-
-        if let Some(old_swapchain) = self.handle {
-            swapchain_create_info.old_swapchain = old_swapchain;
-        }
-
-        let swapchain = unsafe {
-            self.device
-                .swapchain_loader
-                .create_swapchain(&swapchain_create_info, None)?
-        };
-
-        let present_images = unsafe {
-            self.device
-                .swapchain_loader
-                .get_swapchain_images(swapchain)?
-        };
-        let present_images_view = present_images
-            .iter()
-            .map(|i| {
-                self.create_present_image_view(*i)
-                    .expect("Failed to create image view")
-            })
-            .map(|i| Arc::new(i))
-            .collect::<Vec<_>>();
-
-        if log::log_enabled!(log::Level::Debug) {
-            let label = match self.handle {
-                None => "Swapchain created",
-                Some(_) => "Swapchain updated",
-            };
-            log::debug!("{label} ({swapchain:?}) : {swapchain_create_info:#?}");
-        }
-
-        self.handle = Some(swapchain);
-        self.present_image_views = Some(present_images_view);
-        self.present_images = Some(present_images);
-
-        Ok(())
-    }
-
-    pub fn create_framebuffers(
-        &self,
-        render_pass: &Arc<VkRenderPass>,
-    ) -> Option<Vec<Arc<VkFramebuffer>>> {
-        let present_image_views = self.present_image_views.as_ref()?;
-
-        Some(
-            present_image_views
-                .iter()
-                .map(|image_view| {
-                    VkFramebuffer::from_swapchain_image_view(
-                        &self.device,
-                        &render_pass,
-                        &image_view,
-                        &self,
-                    )
-                        .unwrap()
-                })
-                .map(|framebuffer| Arc::new(framebuffer))
-                .collect::<Vec<_>>(),
-        )
-    }
-
-    pub fn update_resolution(&mut self, width: u32, height: u32) -> VkResult<()> {
-        log::debug!("New resolution requested ({width}x{height})");
-
-        let chosen_extent = Self::choose_swapchain_extent(
-            vk::Extent2D { width, height },
-            &self.swapchain_support_details.1,
-        );
-        if chosen_extent.width != self.surface_resolution.width
-            || chosen_extent.height != self.surface_resolution.height
-        {
-            self.new_requested_surface_resolution = Some(chosen_extent);
-            log::debug!(
-                "New resolution submitted ({}x{})",
-                chosen_extent.width,
-                chosen_extent.height
-            );
-        } else {
-            log::debug!("New resolution skipped ({width}x{height}) : Same resolution");
-        }
-
-        Ok(())
-    }
-
-    pub fn acquire_next_image(&self, semaphore: &VkSemaphore) -> VkResult<(u32, bool)> {
-        unsafe {
-            self.device.swapchain_loader.acquire_next_image(
-                self.handle.unwrap(),
-                u64::MAX,
-                semaphore.handle,
-                vk::Fence::null(),
-            )
-        }
-    }
-
-    pub fn is_dirty(&self) -> bool {
-        self.new_requested_surface_resolution.is_some()
-    }
-
-    fn create_swapchain_info(&self, surface: &VkSurface) -> vk::SwapchainCreateInfoKHR {
-        vk::SwapchainCreateInfoKHR::default()
-            .surface(surface.handle)
-            .min_image_count(self.desired_image_count)
-            .image_color_space(self.surface_format.color_space)
-            .image_format(self.surface_format.format)
-            .image_extent(self.surface_resolution)
-            .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
-            .image_sharing_mode(vk::SharingMode::EXCLUSIVE)
-            .pre_transform(self.pre_transform)
-            .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
-            .present_mode(self.present_mode)
-            .clipped(true)
-            .image_array_layers(1)
-    }
-
-    fn choose_swapchain_extent(
-        window_size: vk::Extent2D,
-        surface_capabilities: &vk::SurfaceCapabilitiesKHR,
-    ) -> vk::Extent2D {
-        vk::Extent2D {
-            width: window_size
-                .width
-                .max(surface_capabilities.min_image_extent.width)
-                .min(surface_capabilities.max_image_extent.width),
-            height: window_size
-                .height
-                .max(surface_capabilities.min_image_extent.height)
-                .min(surface_capabilities.max_image_extent.height),
-        }
-    }
-
-    fn choose_surface_format(
-        surface_formats: &Vec<vk::SurfaceFormatKHR>,
-    ) -> Option<vk::SurfaceFormatKHR> {
-        surface_formats.first().and_then(|f| Some(*f))
-    }
-
-    fn choose_desired_image_count(surface_capabilities: &vk::SurfaceCapabilitiesKHR) -> u32 {
-        let mut desired_image_count = surface_capabilities.min_image_count + 1;
-        if surface_capabilities.max_image_count > 0
-            && desired_image_count > surface_capabilities.max_image_count
-        {
-            desired_image_count = surface_capabilities.max_image_count;
-        }
-        desired_image_count
-    }
-
-    fn choose_pre_transform(
-        surface_capabilities: &vk::SurfaceCapabilitiesKHR,
-    ) -> vk::SurfaceTransformFlagsKHR {
-        if surface_capabilities
-            .supported_transforms
-            .contains(vk::SurfaceTransformFlagsKHR::IDENTITY)
-        {
-            vk::SurfaceTransformFlagsKHR::IDENTITY
-        } else {
-            surface_capabilities.current_transform
-        }
-    }
-
-    fn choose_present_mode(present_modes: &Vec<vk::PresentModeKHR>) -> vk::PresentModeKHR {
-        present_modes
-            .iter()
-            .cloned()
-            .find(|&mode| mode == vk::PresentModeKHR::MAILBOX)
-            .unwrap_or(vk::PresentModeKHR::FIFO)
-    }
-
-    fn create_present_image_view(&self, image: vk::Image) -> VkResult<vk::ImageView> {
-        let create_view_info = vk::ImageViewCreateInfo::default()
-            .view_type(vk::ImageViewType::TYPE_2D)
-            .format(self.surface_format.format)
-            .components(vk::ComponentMapping {
-                r: vk::ComponentSwizzle::IDENTITY,
-                g: vk::ComponentSwizzle::IDENTITY,
-                b: vk::ComponentSwizzle::IDENTITY,
-                a: vk::ComponentSwizzle::IDENTITY,
-            })
-            .subresource_range(vk::ImageSubresourceRange {
-                aspect_mask: vk::ImageAspectFlags::COLOR,
-                base_mip_level: 0,
-                level_count: 1,
-                base_array_layer: 0,
-                layer_count: 1,
-            })
-            .image(image);
-
-        unsafe {
-            self.device
-                .handle
-                .create_image_view(&create_view_info, None)
-        }
-    }
-}
-
-impl Drop for VkSwapchain {
-    fn drop(&mut self) {
-        if let Some(swapchain) = self.handle {
-            unsafe {
-                self.device
-                    .swapchain_loader
-                    .destroy_swapchain(swapchain, None);
-            }
-            self.handle = None;
-            log::debug!("Swapchain destroyed ({swapchain:?})");
-        }
-    }
-}

src/scene/mod.rs

@@ -1,4 +0,0 @@
-mod triangle;
-mod vertex;
-
-pub use triangle::TriangleScene;

src/scene/triangle.rs

@@ -1,49 +0,0 @@
-use crate::renderer::vulkan::{VkDevice, VkGraphicsPipeline, VkRenderPass, VkSwapchain};
-use crate::renderer::Renderable;
-use ash::vk;
-use ash::vk::CommandBuffer;
-use std::sync::Arc;
-
-pub struct TriangleScene {
-    pipeline: Option<VkGraphicsPipeline>,
-}
-
-impl TriangleScene {
-    pub fn new() -> Self {
-        Self { pipeline: None }
-    }
-}
-
-impl Renderable for TriangleScene {
-    fn init(&mut self, device: &Arc<VkDevice>, render_pass: &Arc<VkRenderPass>) -> anyhow::Result<()> {
-        let pipeline = VkGraphicsPipeline::new(&device, &render_pass)?;
-        self.pipeline = Some(pipeline);
-
-        Ok(())
-    }
-
-    fn render(&self, device: &VkDevice, swapchain: &VkSwapchain, command_buffer: &CommandBuffer) -> anyhow::Result<()> {
-        unsafe {
-            device.handle.cmd_bind_pipeline(
-                *command_buffer,
-                vk::PipelineBindPoint::GRAPHICS,
-                self.pipeline.as_ref().unwrap().pipeline,
-            )
-        };
-
-        let viewport = vk::Viewport::default()
-            .width(swapchain.surface_resolution.width as f32)
-            .height(swapchain.surface_resolution.height as f32)
-            .max_depth(1.0);
-
-        unsafe { device.handle.cmd_set_viewport(*command_buffer, 0, &[viewport]) }
-
-        let scissor = swapchain.surface_resolution.into();
-
-        unsafe { device.handle.cmd_set_scissor(*command_buffer, 0, &[scissor]) }
-
-        unsafe { device.handle.cmd_draw(*command_buffer, 3, 1, 0, 0) };
-
-        Ok(())
-    }
-}

src/scene/vertex.rs

@@ -1,39 +0,0 @@
-use std::sync::Arc;
-use ash::prelude::VkResult;
-use ash::vk;
-use crate::renderer::vulkan::{Vertex, VkBuffer, VkDevice};
-
-#[derive(Default)]
-struct VertexScene {
-    vertices: Vec<Vertex>,
-
-    vertices_buffer: Option<VkBuffer>,
-}
-
-impl VertexScene {
-    pub fn new() -> Self {
-        let vertices = vec![
-            Vertex::new([0.0, -0.5], [1.0, 0.0, 0.0]),
-            Vertex::new([0.5, 0.5], [0.0, 1.0, 0.0]),
-            Vertex::new([-0.5, 0.5], [0.0, 0.0, 1.0]),
-        ];
-
-        Self {
-            vertices,
-            ..Default::default()
-        }
-    }
-
-
-    fn create_buffer(&mut self, device: &Arc<VkDevice>) -> VkResult<()> {
-        let buffer_info = vk::BufferCreateInfo::default()
-            .usage(vk::BufferUsageFlags::VERTEX_BUFFER)
-            .sharing_mode(vk::SharingMode::EXCLUSIVE)
-            .size(self.vertices.len() as u64 * size_of::<Vertex>() as u64);
-
-        let buffer = VkBuffer::new(device, &buffer_info)?;
-        self.vertices_buffer = Some(buffer);
-
-        Ok(())
-    }
-}