Try refactor with cursor

.cursor/mcp.json

@@ -0,0 +1,10 @@
+{
+    "mcpServers": {
+        "run-program": {
+            "command": "cargo",
+            "args": [
+                "run"
+            ]
+        }
+    }
+}

src/main.rs

@@ -1,15 +1,14 @@
-use std::error::Error;
+use winit::event_loop::EventLoop;
-use winit::event_loop::{ControlFlow, EventLoop};
 
 mod renderer;
+mod vulkan;
 
-fn main() -> Result<(), impl Error> {
+use renderer::app::App;
-    env_logger::init();
+use vulkan::context::VulkanContext;
 
+fn main() {
     let event_loop = EventLoop::new().unwrap();
-    event_loop.set_control_flow(ControlFlow::Poll);
+    let vulkan_context = VulkanContext::new(&event_loop).unwrap();
-
+    let mut app = App::new(vulkan_context);
-    let mut app = renderer::App::new(&event_loop);
+    event_loop.run_app(&mut app).unwrap();
-
-    event_loop.run_app(&mut app)
 }

src/renderer/app.rs

@@ -1,160 +1,167 @@
-use crate::renderer::render_context::RenderContext;
+use crate::renderer::components::{Entity, Material, Mesh, Transform};
-use crate::renderer::Scene;
+use crate::vulkan::context::VulkanContext;
+use crate::vulkan::pipeline::{Pipeline, triangle::TrianglePipeline};
+use crate::vulkan::renderer::VulkanRenderer;
+use crate::vulkan::resources::vertex::{MVPData, Vertex2D};
+use std::error::Error;
 use std::sync::Arc;
-use vulkano::buffer::allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo};
+use vulkano::VulkanError;
-use vulkano::buffer::BufferUsage;
+use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage};
-use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
 use vulkano::command_buffer::{
-    AutoCommandBufferBuilder, CommandBufferUsage, RenderingAttachmentInfo, RenderingInfo,
+    AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer,
+    RenderingAttachmentInfo, RenderingInfo,
 };
-use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::descriptor_set::{DescriptorSet, WriteDescriptorSet};
-use vulkano::device::physical::PhysicalDeviceType;
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter};
-use vulkano::device::{
+use vulkano::pipeline::{Pipeline as VulkanPipeline, PipelineBindPoint};
-    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::swapchain::Surface;
-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::event_loop::ActiveEventLoop;
 use winit::window::WindowId;
 
 pub struct App {
-    pub instance: Arc<Instance>,
+    pub vulkan_context: VulkanContext,
-    pub device: Arc<Device>,
+    pub renderer: Option<VulkanRenderer>,
-    pub queue: Arc<Queue>,
+    pub entities: Vec<Entity>,
-
-    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 {
+    pub fn new(vulkan_context: VulkanContext) -> Self {
-        let library = VulkanLibrary::new().unwrap();
+        Self {
-
+            vulkan_context,
-        for layer in library.layer_properties().unwrap() {
+            renderer: None,
-            log::debug!("Available layer: {}", layer.name());
+            entities: Vec::new(),
         }
+    }
 
-        let required_extensions = Surface::required_extensions(event_loop).unwrap();
+    pub fn setup_test_entities(&mut self) -> Result<(), Box<dyn Error>> {
+        // Créer un pipeline de test
+        let pipeline = TrianglePipeline::new(&self.vulkan_context.device);
 
-        let instance = Instance::new(
+        // Créer un buffer de vertex pour un triangle
-            library,
+        let vertices = [
-            InstanceCreateInfo {
+            Vertex2D {
-                // Enable enumerating devices that use non-conformant Vulkan implementations.
+                position: [-0.5, -0.5],
-                // (e.g. MoltenVK)
+                color: [1.0, 0.0, 0.0], // Rouge
-                flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
-                enabled_extensions: required_extensions,
-                enabled_layers: vec![String::from("VK_LAYER_KHRONOS_validation")],
-                ..Default::default()
             },
-        )
+            Vertex2D {
-        .unwrap();
+                position: [0.5, -0.5],
+                color: [0.0, 1.0, 0.0], // Vert
+            },
+            Vertex2D {
+                position: [0.0, 0.5],
+                color: [0.0, 0.0, 1.0], // Bleu
+            },
+        ];
 
-        let mut device_extensions = DeviceExtensions {
+        let vertex_buffer =
-            khr_swapchain: true,
+            Vertex2D::create_buffer(vertices.to_vec(), &self.vulkan_context.memory_allocator)
-            ..DeviceExtensions::empty()
+                .unwrap();
+
+        // Créer un buffer uniform pour les matrices MVP
+        let mvp_data = MVPData {
+            world: [
+                [1.0, 0.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
+            view: [
+                [1.0, 0.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
+            projection: [
+                [1.0, 0.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
         };
 
-        let (physical_device, queue_family_index) = instance
+        let uniform_buffer = Buffer::from_data(
-            .enumerate_physical_devices()
+            self.vulkan_context.memory_allocator.clone(),
-            .unwrap()
+            BufferCreateInfo {
-            .filter(|p| {
+                usage: BufferUsage::UNIFORM_BUFFER,
-                p.api_version() >= Version::V1_3 || p.supported_extensions().khr_dynamic_rendering
-            })
-            .filter(|p| p.supported_extensions().contains(&device_extensions))
-            .filter_map(|p| {
-                p.queue_family_properties()
-                    .iter()
-                    .enumerate()
-                    .position(|(i, q)| {
-                        q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                            && p.presentation_support(i as u32, event_loop).unwrap()
-                    })
-                    .map(|i| (p, i as u32))
-            })
-            .min_by_key(|(p, _)| match p.properties().device_type {
-                PhysicalDeviceType::DiscreteGpu => 0,
-                PhysicalDeviceType::IntegratedGpu => 1,
-                PhysicalDeviceType::VirtualGpu => 2,
-                PhysicalDeviceType::Cpu => 3,
-                PhysicalDeviceType::Other => 4,
-                _ => 5,
-            })
-            .expect("no suitable physical device found");
-
-        log::debug!(
-            "Using device: {} (type: {:?})",
-            physical_device.properties().device_name,
-            physical_device.properties().device_type,
-        );
-
-        if physical_device.api_version() < Version::V1_3 {
-            device_extensions.khr_dynamic_rendering = true;
-        }
-
-        log::debug!("Using device extensions: {:#?}", device_extensions);
-
-        let (device, mut queues) = Device::new(
-            physical_device,
-            DeviceCreateInfo {
-                queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index,
-                    ..Default::default()
-                }],
-                enabled_extensions: device_extensions,
-                enabled_features: DeviceFeatures {
-                    dynamic_rendering: true,
-                    ..DeviceFeatures::empty()
-                },
                 ..Default::default()
             },
-        )
+            AllocationCreateInfo {
-        .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()
             },
-        );
+            mvp_data,
+        )
+        .unwrap();
 
-        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+        // Créer un descriptor set de test
-            device.clone(),
+        let descriptor_set = DescriptorSet::new(
-            Default::default(),
+            self.vulkan_context.descriptor_set_allocator.clone(),
-        ));
+            pipeline
+                .get_pipeline()
+                .layout()
+                .set_layouts()
+                .get(0)
+                .unwrap()
+                .clone(),
+            [WriteDescriptorSet::buffer(0, uniform_buffer)],
+            [],
+        )?;
 
-        Self {
+        let material = Material {
-            instance,
+            pipeline: pipeline.get_pipeline().clone(),
-            device,
+            descriptor_set,
-            queue,
+        };
-            memory_allocator,
+
-            command_buffer_allocator,
+        // Créer quelques entités de test
-            uniform_buffer_allocator,
+        let mut entities = Vec::new();
-            descriptor_set_allocator,
+        for i in 0..3 {
-            rcx: None,
+            entities.push(Entity {
-            scene: None,
+                mesh: Mesh {
+                    vertex_buffer: vertex_buffer.clone(),
+                    vertex_count: 3,
+                    instance_count: 1,
+                },
+                material: material.clone(),
+                transform: Transform {
+                    position: [i as f32 * 0.5 - 0.5, 0.0, 0.0],
+                    rotation: [0.0, 0.0, 0.0],
+                    scale: [1.0, 1.0, 1.0],
+                },
+            });
         }
+        self.entities = entities;
+
+        Ok(())
+    }
+
+    pub fn render(
+        &self,
+        command_buffer: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+    ) -> Result<(), Box<dyn Error>> {
+        for entity in &self.entities {
+            command_buffer
+                .bind_pipeline_graphics(entity.material.pipeline.clone())
+                .unwrap()
+                .bind_descriptor_sets(
+                    PipelineBindPoint::Graphics,
+                    entity.material.pipeline.layout().clone(),
+                    0,
+                    entity.material.descriptor_set.clone(),
+                )
+                .unwrap()
+                .bind_vertex_buffers(0, entity.mesh.vertex_buffer.clone())
+                .unwrap();
+            unsafe {
+                command_buffer
+                    .draw(entity.mesh.vertex_count, 1, 0, 0)
+                    .unwrap();
+            }
+        }
+        Ok(())
     }
 }
 
@@ -169,10 +176,17 @@ impl ApplicationHandler for App {
 
         let window = Arc::new(event_loop.create_window(window_attributes).unwrap());
 
-        let surface = Surface::from_window(self.instance.clone(), window.clone()).unwrap();
+        let surface =
+            Surface::from_window(self.vulkan_context.instance.clone(), window.clone()).unwrap();
 
-        self.rcx = Some(RenderContext::new(window, surface, &self.device));
+        self.renderer = Some(VulkanRenderer::new(
-        self.scene = Some(Scene::load(&self).unwrap());
+            window,
+            surface,
+            self.vulkan_context.device.clone(),
+            self.vulkan_context.queue.clone(),
+        ));
+
+        self.setup_test_entities().unwrap();
     }
 
     fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
@@ -182,49 +196,25 @@ impl ApplicationHandler for App {
                 event_loop.exit();
             }
             WindowEvent::Resized(_) => {
-                let rcx = self.rcx.as_mut().unwrap();
+                let renderer = self.renderer.as_mut().unwrap();
-                rcx.recreate_swapchain = true;
+                renderer.recreate_swapchain = true;
             }
             WindowEvent::RedrawRequested => {
-                let (image_index, acquire_future) = {
+                let (image_index, acquire_future) =
-                    let rcx = self.rcx.as_mut().unwrap();
+                    match self.renderer.as_mut().unwrap().begin_frame() {
-                    let window_size = rcx.window.inner_size();
+                        Ok(r) => r,
-
+                        Err(VulkanError::OutOfDate) => return,
-                    if window_size.width == 0 || window_size.height == 0 {
+                        Err(e) => panic!("failed to acquire next image: {e}"),
-                        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.vulkan_context.command_buffer_allocator.clone(),
-                    self.queue.queue_family_index(),
+                    self.vulkan_context.queue.queue_family_index(),
                     CommandBufferUsage::OneTimeSubmit,
                 )
                 .unwrap();
 
                 {
-                    let rcx = self.rcx.as_ref().unwrap();
                     builder
                         .begin_rendering(RenderingInfo {
                             color_attachments: vec![Some(RenderingAttachmentInfo {
@@ -232,64 +222,41 @@ impl ApplicationHandler for App {
                                 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(),
+                                    self.renderer.as_ref().unwrap().attachment_image_views
+                                        [image_index as usize]
+                                        .clone(),
                                 )
                             })],
                             ..Default::default()
                         })
                         .unwrap()
-                        .set_viewport(0, [rcx.viewport.clone()].into_iter().collect())
+                        .set_viewport(
+                            0,
+                            [self.renderer.as_ref().unwrap().viewport.clone()]
+                                .into_iter()
+                                .collect(),
+                        )
                         .unwrap();
                 }
 
-                if let Some(scene) = self.scene.as_ref() {
+                self.render(&mut builder).unwrap();
-                    scene.render(&self, &mut builder).unwrap();
-                }
-
-                builder.end_rendering().unwrap();
-
-                let command_buffer = builder.build().unwrap();
 
                 {
-                    let rcx = self.rcx.as_mut().unwrap();
+                    builder.end_rendering().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());
-                        }
-                    }
                 }
+
+                self.renderer
+                    .as_mut()
+                    .unwrap()
+                    .end_frame(image_index, acquire_future, builder)
+                    .unwrap();
             }
             _ => {}
         }
     }
 
     fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
-        let rcx = self.rcx.as_mut().unwrap();
+        let renderer = self.renderer.as_mut().unwrap();
-        rcx.window.request_redraw();
+        renderer.window.request_redraw();
     }
 }

src/renderer/components.rs

@@ -0,0 +1,71 @@
+use std::sync::Arc;
+use vulkano::buffer::Subbuffer;
+use vulkano::buffer::allocator::SubbufferAllocator;
+use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
+use vulkano::command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer};
+use vulkano::descriptor_set::DescriptorSet;
+use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::device::Device;
+use vulkano::memory::allocator::StandardMemoryAllocator;
+use vulkano::pipeline::GraphicsPipeline;
+use vulkano::pipeline::Pipeline;
+
+use crate::vulkan::resources::vertex::Vertex2D;
+
+#[derive(Clone)]
+pub struct Mesh {
+    pub vertex_buffer: Subbuffer<[Vertex2D]>,
+    pub vertex_count: u32,
+    pub instance_count: u32,
+}
+
+#[derive(Clone)]
+pub struct Material {
+    pub pipeline: Arc<GraphicsPipeline>,
+    pub descriptor_set: Arc<DescriptorSet>,
+}
+
+#[derive(Clone)]
+pub struct Transform {
+    pub position: [f32; 3],
+    pub rotation: [f32; 3],
+    pub scale: [f32; 3],
+}
+
+#[derive(Clone)]
+pub struct RenderResources {
+    pub device: Arc<Device>,
+    pub memory_allocator: Arc<StandardMemoryAllocator>,
+    pub command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
+    pub uniform_buffer_allocator: Arc<SubbufferAllocator>,
+    pub descriptor_set_allocator: Arc<StandardDescriptorSetAllocator>,
+}
+
+pub struct Entity {
+    pub mesh: Mesh,
+    pub material: Material,
+    pub transform: Transform,
+}
+
+pub fn render_system(
+    _resources: &RenderResources,
+    builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+    entities: &[Entity],
+) -> Result<(), Box<dyn std::error::Error>> {
+    for entity in entities {
+        unsafe {
+            builder
+                .bind_pipeline_graphics(entity.material.pipeline.clone())?
+                .bind_descriptor_sets(
+                    vulkano::pipeline::PipelineBindPoint::Graphics,
+                    entity.material.pipeline.layout().clone(),
+                    0,
+                    entity.material.descriptor_set.clone(),
+                )?
+                .bind_vertex_buffers(0, entity.mesh.vertex_buffer.clone())?
+                .draw(entity.mesh.vertex_count, entity.mesh.instance_count, 0, 0)?;
+        }
+    }
+
+    Ok(())
+}

src/renderer/mod.rs

@@ -1,9 +1,2 @@
-mod app;
+pub mod app;
-mod pipelines;
+pub mod components;
-mod render_context;
-mod vertex;
-pub use app::App;
-
-mod scene;
-pub use scene::Scene;
-pub use vertex::Vertex2D;

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/vulkan/context.rs

@@ -0,0 +1,135 @@
+use std::sync::Arc;
+use vulkano::buffer::BufferUsage;
+use vulkano::buffer::allocator::{SubbufferAllocator, SubbufferAllocatorCreateInfo};
+use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
+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::swapchain::Surface;
+use vulkano::{Version, VulkanLibrary};
+use winit::event_loop::EventLoop;
+
+pub struct VulkanContext {
+    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: Arc<SubbufferAllocator>,
+    pub descriptor_set_allocator: Arc<StandardDescriptorSetAllocator>,
+}
+
+impl VulkanContext {
+    pub fn new(event_loop: &EventLoop<()>) -> Result<Self, Box<dyn std::error::Error>> {
+        let library = VulkanLibrary::new().unwrap();
+        for layer in library.layer_properties().unwrap() {
+            log::debug!("Available layer: {}", layer.name());
+        }
+
+        let required_extensions = Surface::required_extensions(event_loop).unwrap();
+        let instance = Instance::new(
+            library,
+            InstanceCreateInfo {
+                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))
+                    .map(|i| (p, i as u32))
+            })
+            .min_by_key(|(p, _)| match p.properties().device_type {
+                PhysicalDeviceType::DiscreteGpu => 0,
+                PhysicalDeviceType::IntegratedGpu => 1,
+                PhysicalDeviceType::VirtualGpu => 2,
+                PhysicalDeviceType::Cpu => 3,
+                PhysicalDeviceType::Other => 4,
+                _ => 5,
+            })
+            .expect("no suitable physical device found");
+
+        log::debug!(
+            "Using device: {} (type: {:?})",
+            physical_device.properties().device_name,
+            physical_device.properties().device_type,
+        );
+
+        if physical_device.api_version() < Version::V1_3 {
+            device_extensions.khr_dynamic_rendering = true;
+        }
+
+        log::debug!("Using device extensions: {:#?}", device_extensions);
+
+        let (device, mut queues) = Device::new(
+            physical_device,
+            DeviceCreateInfo {
+                queue_create_infos: vec![QueueCreateInfo {
+                    queue_family_index,
+                    ..Default::default()
+                }],
+                enabled_extensions: device_extensions,
+                enabled_features: DeviceFeatures {
+                    dynamic_rendering: true,
+                    ..DeviceFeatures::empty()
+                },
+                ..Default::default()
+            },
+        )
+        .unwrap();
+
+        let queue = queues.next().unwrap();
+        let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
+        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+
+        let uniform_buffer_allocator = Arc::new(SubbufferAllocator::new(
+            memory_allocator.clone(),
+            SubbufferAllocatorCreateInfo {
+                buffer_usage: BufferUsage::UNIFORM_BUFFER,
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+        ));
+
+        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+
+        Ok(Self {
+            instance,
+            device,
+            queue,
+            memory_allocator,
+            command_buffer_allocator,
+            uniform_buffer_allocator,
+            descriptor_set_allocator,
+        })
+    }
+}

src/vulkan/mod.rs

@@ -0,0 +1,4 @@
+pub mod context;
+pub mod pipeline;
+pub mod renderer;
+pub mod resources;

src/vulkan/pipeline/mod.rs

@@ -0,0 +1,30 @@
+pub mod triangle;
+
+use std::sync::Arc;
+use vulkano::device::Device;
+use vulkano::pipeline::GraphicsPipeline;
+
+pub trait Pipeline {
+    fn create_pipeline(device: &Arc<Device>) -> Arc<GraphicsPipeline>;
+    fn get_pipeline(&self) -> &Arc<GraphicsPipeline>;
+}
+
+pub struct PipelineManager {
+    pipelines: std::collections::HashMap<String, Arc<GraphicsPipeline>>,
+}
+
+impl PipelineManager {
+    pub fn new() -> Self {
+        Self {
+            pipelines: std::collections::HashMap::new(),
+        }
+    }
+
+    pub fn register_pipeline(&mut self, name: String, pipeline: Arc<GraphicsPipeline>) {
+        self.pipelines.insert(name, pipeline);
+    }
+
+    pub fn get_pipeline(&self, name: &str) -> Option<&Arc<GraphicsPipeline>> {
+        self.pipelines.get(name)
+    }
+}

src/vulkan/pipeline/triangle.rs

@@ -0,0 +1,127 @@
+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::GraphicsPipelineCreateInfo;
+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::layout::{PipelineDescriptorSetLayoutCreateInfo, PipelineLayoutCreateFlags};
+use vulkano::pipeline::{
+    DynamicState, GraphicsPipeline, PipelineLayout, PipelineShaderStageCreateInfo,
+};
+use vulkano::shader::{EntryPoint, ShaderStages};
+
+use crate::vulkan::resources::vertex::Vertex2D;
+
+use super::Pipeline;
+
+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 struct TrianglePipeline {
+    pipeline: Arc<GraphicsPipeline>,
+}
+
+impl super::Pipeline for TrianglePipeline {
+    fn create_pipeline(device: &Arc<Device>) -> Arc<GraphicsPipeline> {
+        let (vs, fs) = load_shaders(device).unwrap();
+        let vertex_input_state = Vertex2D::per_vertex().definition(&vs).unwrap();
+
+        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())
+        .unwrap();
+
+        let layout = PipelineLayout::new(device.clone(), create_info).unwrap();
+
+        let subpass = PipelineRenderingCreateInfo {
+            color_attachment_formats: vec![Some(vulkano::format::Format::B8G8R8A8_UNORM)],
+            ..Default::default()
+        };
+
+        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)
+            },
+        )
+        .unwrap()
+    }
+
+    fn get_pipeline(&self) -> &Arc<GraphicsPipeline> {
+        &self.pipeline
+    }
+}
+
+impl TrianglePipeline {
+    pub fn new(device: &Arc<Device>) -> Self {
+        Self {
+            pipeline: Self::create_pipeline(device),
+        }
+    }
+}
+
+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/vulkan/renderer.rs

@@ -0,0 +1,167 @@
+use std::sync::Arc;
+use vulkano::command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer};
+use vulkano::device::Queue;
+use vulkano::image::view::ImageView;
+use vulkano::pipeline::graphics::viewport::Viewport;
+use vulkano::swapchain::{Surface, Swapchain, SwapchainCreateInfo, SwapchainPresentInfo};
+use vulkano::sync::{self, GpuFuture};
+use vulkano::{Validated, VulkanError};
+use winit::window::Window;
+
+pub struct VulkanRenderer {
+    pub window: Arc<Window>,
+    pub surface: Arc<Surface>,
+    pub swapchain: Arc<Swapchain>,
+    pub queue: Arc<Queue>,
+    pub attachment_image_views: Vec<Arc<ImageView>>,
+    pub previous_frame_end: Option<Box<dyn GpuFuture>>,
+    pub recreate_swapchain: bool,
+    pub viewport: Viewport,
+}
+
+impl VulkanRenderer {
+    pub fn new(
+        window: Arc<Window>,
+        surface: Arc<Surface>,
+        device: Arc<vulkano::device::Device>,
+        queue: Arc<Queue>,
+    ) -> Self {
+        let window_size = window.inner_size();
+        let surface_formats = device
+            .physical_device()
+            .surface_formats(&surface, Default::default())
+            .unwrap();
+        let surface_format = surface_formats[0];
+
+        let (swapchain, images) = Swapchain::new(
+            device.clone(),
+            surface.clone(),
+            SwapchainCreateInfo {
+                image_extent: window_size.into(),
+                image_usage: vulkano::image::ImageUsage::COLOR_ATTACHMENT,
+                image_format: surface_format.0,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+
+        let attachment_image_views = images
+            .into_iter()
+            .map(|image| ImageView::new_default(image).unwrap())
+            .collect();
+
+        let viewport = Viewport {
+            offset: [0.0, 0.0],
+            extent: window_size.into(),
+            depth_range: 0.0..=1.0,
+        };
+
+        Self {
+            window,
+            surface,
+            swapchain,
+            queue,
+            attachment_image_views,
+            previous_frame_end: Some(sync::now(device).boxed()),
+            recreate_swapchain: false,
+            viewport,
+        }
+    }
+
+    pub fn begin_frame(&mut self) -> Result<(u32, Box<dyn GpuFuture>), VulkanError> {
+        self.previous_frame_end.as_mut().unwrap().cleanup_finished();
+
+        if self.recreate_swapchain {
+            self.recreate_swapchain();
+            self.recreate_swapchain = false;
+        }
+
+        let (image_index, suboptimal, acquire_future) =
+            match vulkano::swapchain::acquire_next_image(self.swapchain.clone(), None)
+                .map_err(Validated::unwrap)
+            {
+                Ok(r) => r,
+                Err(VulkanError::OutOfDate) => {
+                    self.recreate_swapchain = true;
+                    return Err(VulkanError::OutOfDate);
+                }
+                Err(e) => panic!("failed to acquire next image: {e}"),
+            };
+
+        if suboptimal {
+            self.recreate_swapchain = true;
+        }
+
+        Ok((image_index, acquire_future.boxed()))
+    }
+
+    pub fn end_frame(
+        &mut self,
+        image_index: u32,
+        acquire_future: Box<dyn GpuFuture>,
+        command_buffer: AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
+    ) -> Result<(), VulkanError> {
+        let command_buffer = command_buffer.build().unwrap();
+        let future = self
+            .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(self.swapchain.clone(), image_index),
+            )
+            .then_signal_fence_and_flush();
+
+        match future.map_err(Validated::unwrap) {
+            Ok(future) => {
+                self.previous_frame_end = Some(future.boxed());
+                Ok(())
+            }
+            Err(VulkanError::OutOfDate) => {
+                self.recreate_swapchain = true;
+                self.previous_frame_end = Some(sync::now(self.queue.device().clone()).boxed());
+                Ok(())
+            }
+            Err(e) => {
+                println!("failed to flush future: {e}");
+                self.previous_frame_end = Some(sync::now(self.queue.device().clone()).boxed());
+                Ok(())
+            }
+        }
+    }
+
+    fn recreate_swapchain(&mut self) {
+        let image_extent: [u32; 2] = self.window.inner_size().into();
+        if image_extent.contains(&0) {
+            return;
+        }
+
+        let surface_formats = self
+            .queue
+            .device()
+            .physical_device()
+            .surface_formats(&self.surface, Default::default())
+            .unwrap();
+        let surface_format = surface_formats[0];
+
+        let (new_swapchain, new_images) = self
+            .swapchain
+            .recreate(SwapchainCreateInfo {
+                image_extent,
+                image_usage: vulkano::image::ImageUsage::COLOR_ATTACHMENT,
+                image_format: surface_format.0,
+                ..self.swapchain.create_info()
+            })
+            .expect("failed to recreate swapchain");
+
+        self.swapchain = new_swapchain;
+        self.attachment_image_views = new_images
+            .into_iter()
+            .map(|image| ImageView::new_default(image).unwrap())
+            .collect();
+        self.viewport.extent = [image_extent[0] as f32, image_extent[1] as f32];
+    }
+}

src/vulkan/resources/buffer.rs

@@ -0,0 +1,65 @@
+use std::sync::Arc;
+use vulkano::buffer::BufferContents;
+use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
+
+pub struct BufferManager {
+    memory_allocator: Arc<StandardMemoryAllocator>,
+}
+
+impl BufferManager {
+    pub fn new(memory_allocator: Arc<StandardMemoryAllocator>) -> Self {
+        Self { memory_allocator }
+    }
+
+    pub fn create_vertex_buffer<T: BufferContents + Clone>(&self, data: &[T]) -> Subbuffer<[T]> {
+        Buffer::from_iter(
+            self.memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::VERTEX_BUFFER,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            data.iter().cloned(),
+        )
+        .unwrap()
+    }
+
+    pub fn create_index_buffer(&self, data: &[u32]) -> Subbuffer<[u32]> {
+        Buffer::from_iter(
+            self.memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::INDEX_BUFFER,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            data.iter().cloned(),
+        )
+        .unwrap()
+    }
+
+    pub fn create_uniform_buffer<T: BufferContents + Copy>(&self, data: &T) -> Subbuffer<T> {
+        Buffer::from_data(
+            self.memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::UNIFORM_BUFFER,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            *data,
+        )
+        .unwrap()
+    }
+}

src/vulkan/resources/descriptor.rs

@@ -0,0 +1,47 @@
+use std::sync::Arc;
+use vulkano::descriptor_set::DescriptorSet;
+use vulkano::descriptor_set::WriteDescriptorSet;
+use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::descriptor_set::layout::{
+    DescriptorSetLayout, DescriptorSetLayoutBinding, DescriptorSetLayoutCreateInfo, DescriptorType,
+};
+use vulkano::device::Device;
+use vulkano::shader::ShaderStages;
+
+pub struct DescriptorManager {
+    device: Arc<Device>,
+    allocator: Arc<StandardDescriptorSetAllocator>,
+}
+
+impl DescriptorManager {
+    pub fn new(device: Arc<Device>, allocator: Arc<StandardDescriptorSetAllocator>) -> Self {
+        Self { device, allocator }
+    }
+
+    pub fn create_descriptor_set_layout(
+        &self,
+        bindings: &[(u32, DescriptorType, u32)],
+    ) -> Arc<DescriptorSetLayout> {
+        let mut bindings_map = std::collections::BTreeMap::new();
+        for (binding_index, ty, _count) in bindings {
+            let mut binding = DescriptorSetLayoutBinding::descriptor_type(*ty);
+            binding.stages = ShaderStages::all_graphics();
+            bindings_map.insert(*binding_index, binding);
+        }
+
+        let create_info = DescriptorSetLayoutCreateInfo {
+            bindings: bindings_map,
+            ..Default::default()
+        };
+
+        DescriptorSetLayout::new(self.device.clone(), create_info).unwrap()
+    }
+
+    pub fn create_descriptor_set(
+        &self,
+        layout: &Arc<DescriptorSetLayout>,
+        writes: Vec<WriteDescriptorSet>,
+    ) -> Arc<DescriptorSet> {
+        DescriptorSet::new(self.allocator.clone(), layout.clone(), writes, []).unwrap()
+    }
+}

src/vulkan/resources/mod.rs

@@ -0,0 +1,3 @@
+pub mod buffer;
+pub mod descriptor;
+pub mod vertex;

src/vulkan/resources/vertex.rs

@@ -1,12 +1,12 @@
 use std::sync::Arc;
+use vulkano::Validated;
 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)]
+#[derive(BufferContents, Vertex, Clone)]
 #[repr(C)]
 pub struct Vertex2D {
     #[format(R32G32_SFLOAT)]
@@ -16,6 +16,14 @@ pub struct Vertex2D {
     pub color: [f32; 3],
 }
 
+#[derive(BufferContents, Clone)]
+#[repr(C)]
+pub struct MVPData {
+    pub world: [[f32; 4]; 4],
+    pub view: [[f32; 4]; 4],
+    pub projection: [[f32; 4]; 4],
+}
+
 impl Vertex2D {
     pub fn create_buffer(
         vertices: Vec<Vertex2D>,
@@ -32,7 +40,7 @@ impl Vertex2D {
                     | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
                 ..Default::default()
             },
-            vertices,
+            vertices.into_iter(),
         )
     }
 }