.vscode/extensions.json

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

.vscode/launch.json

@@ -1,45 +0,0 @@
-{
-    // 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

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

Cargo.toml

@@ -8,13 +8,12 @@ publish = false
 [dependencies]
 anyhow = "1.0"
 winit = { version = "0.30", features = ["rwh_06"] }
-
+ash = { version = "0.38", default-features = false, features = ["linked", "debug", "std"] }
-vulkano = "0.35"
+ash-window = "0.13"
-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

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

flake.nix

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

res/shaders/main.frag

@@ -0,0 +1,8 @@
+#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

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

res/shaders/vertex.vert

@@ -1 +1 @@
-#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;
}
+#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;
}

rust-toolchain.toml

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

src/display/app.rs

@@ -0,0 +1,93 @@
+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

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

src/display/window.rs

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

src/renderer/app.rs

@@ -1,291 +0,0 @@
-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 @@
-mod app;
+use std::sync::Arc;
-mod pipelines;
+use ash::vk;
-mod render_context;
-mod vertex;
-pub use app::App;
 
-mod scene;
+pub mod vulkan;
-pub use scene::Scene;
+
-pub use vertex::Vertex2D;
+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<()>;
+}

src/renderer/pipelines/mod.rs

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

src/renderer/pipelines/triangle_pipeline.rs

@@ -1,111 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,51 @@
+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

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

src/renderer/vulkan/vertex.rs

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,206 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,297 @@
+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

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

src/scene/triangle.rs

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,39 @@
+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(())
+    }
+}