rename renderer to vulkan

src/vulkan/app.rs

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

src/vulkan/mod.rs

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

src/vulkan/pipelines/mod.rs

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

src/vulkan/pipelines/triangle_pipeline.rs

@@ -0,0 +1,111 @@
+use std::collections::BTreeMap;
+use std::error::Error;
+use std::sync::Arc;
+use vulkano::descriptor_set::layout::{
+    DescriptorSetLayoutBinding, DescriptorSetLayoutCreateInfo, DescriptorType,
+};
+use vulkano::device::Device;
+use vulkano::pipeline::graphics::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 vulkano::swapchain::Swapchain;
+
+use crate::vulkan::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/vulkan/render_context.rs

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

src/vulkan/scene.rs

@@ -0,0 +1,151 @@
+use crate::vulkan::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::vulkan::{App, Vertex2D, pipelines::triangle_pipeline::create_triangle_pipeline};
+
+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/vertex.rs

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