Initial Commit

Working Vulkano test

.gitignore

@@ -0,0 +1 @@
+/target

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/dictionaries/project.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="project">
+    <words>
+      <w>swapchain</w>
+    </words>
+  </dictionary>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/vulkano-testing.iml" filepath="$PROJECT_DIR$/.idea/vulkano-testing.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="/mnt/data/User Library/Documents/Projects/Rust/vulkano-testing" vcs="Git" />
+  </component>
+</project>

.idea/vulkano-testing.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="EMPTY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "vulkano-testing"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+vulkano = "0.35.1"
+vulkano-shaders = "0.35.0"
+winit = {version = "0.30.11", features = ["wayland"]}
+
+# Reduce debug speed artifacts
+[profile.dev]
+opt-level = 1

src/app.rs

@@ -0,0 +1,315 @@
+use std::sync::Arc;
+use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer};
+use vulkano::command_buffer::{CommandBufferExecFuture, PrimaryAutoCommandBuffer};
+use vulkano::device::{DeviceExtensions};
+use vulkano::image::{Image};
+use vulkano::image::view::ImageView;
+use vulkano::instance::{Instance, InstanceCreateFlags, InstanceCreateInfo};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter};
+use vulkano::render_pass::{Framebuffer, FramebufferCreateInfo, RenderPass};
+use vulkano::shader::ShaderModule;
+use vulkano::swapchain::{PresentFuture, Surface, SwapchainAcquireFuture, SwapchainCreateInfo, SwapchainPresentInfo};
+use vulkano::{swapchain, sync, Validated, VulkanError, VulkanLibrary};
+use vulkano::sync::future::{FenceSignalFuture, JoinFuture};
+use vulkano::sync::GpuFuture;
+use winit::application::ApplicationHandler;
+use winit::event::{WindowEvent};
+use winit::event_loop::ActiveEventLoop;
+use winit::platform::x11::WindowAttributesExtX11;
+use winit::window::{Window, WindowId};
+use crate::util::{MyVertex, VulkanoWrapper};
+
+#[derive(Default)]
+pub(crate) struct App {
+    window: Option<Window>,
+    wrapper: Option<Arc<VulkanoWrapper>>,
+
+    vs: Option<Arc<ShaderModule>>,
+    fs: Option<Arc<ShaderModule>>,
+
+    command_buffers: Option<Vec<Arc<PrimaryAutoCommandBuffer>>>,
+    queue: Option<Arc<vulkano::device::Queue>>,
+
+    vertex_buffer: Option<Subbuffer<[MyVertex]>>,
+    pipeline: Option<Arc<vulkano::pipeline::GraphicsPipeline>>,
+
+    framebuffers: Option<Vec<Arc<Framebuffer>>>,
+
+    fences: Option<Vec<Option<Arc<FenceSignalFuture<PresentFuture<CommandBufferExecFuture<JoinFuture<Box<dyn GpuFuture>, SwapchainAcquireFuture>>>>>>>>,
+    previous_fence_i: usize,
+
+    window_resized: bool,
+    recreate_swapchain: bool,
+}
+
+
+fn get_framebuffers(
+    images: &[Arc<Image>],
+    render_pass: &Arc<RenderPass>,
+) -> Vec<Arc<Framebuffer>> {
+    images
+        .iter()
+        .map(|image| {
+            let view = ImageView::new_default(image.clone()).unwrap();
+            Framebuffer::new(
+                render_pass.clone(),
+                FramebufferCreateInfo {
+                    attachments: vec![view],
+                    ..Default::default()
+                },
+            )
+                .unwrap()
+        })
+        .collect::<Vec<_>>()
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        println!("Application resumed");
+
+        self.window = Some(event_loop.create_window(
+            Window::default_attributes()
+                .with_base_size(winit::dpi::LogicalSize::new(1024.0, 768.0))
+                .with_title("Hello, world!"),
+        ).unwrap());
+
+        let window = self.window.as_ref().unwrap();
+
+        let library = VulkanLibrary::new().expect("failed to load Vulkan library");
+
+        let required_extensions = Surface::required_extensions(&event_loop).unwrap();
+
+        let instance = Instance::new(
+            library,
+            InstanceCreateInfo {
+                flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
+                enabled_extensions: required_extensions,
+                ..Default::default()
+            },
+        ).expect("failed to create instance");
+
+        self.wrapper = Some(Arc::new(VulkanoWrapper::new(instance, window, DeviceExtensions {
+            khr_swapchain: true,
+            ..DeviceExtensions::empty()
+        })));
+
+        let wrapper = if let Some(wrapper) = self.wrapper.as_ref() {wrapper} else {panic!("wrapper has disappeared")};
+
+        self.framebuffers = Some(get_framebuffers(&wrapper.images, &wrapper.render_pass));
+        self.queue = Some(wrapper.queues.first().unwrap().clone());
+
+        let vertex1 = MyVertex {
+            position: [-0.5, -0.5],
+        };
+        let vertex2 = MyVertex {
+            position: [0.0, 0.5],
+        };
+        let vertex3 = MyVertex {
+            position: [0.5, -0.25],
+        };
+
+        self.vertex_buffer = Some(Buffer::from_iter(
+            wrapper.memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::VERTEX_BUFFER,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            vec![vertex1, vertex2, vertex3],
+        ).unwrap());
+
+        self.vs = Some(vs::load(wrapper.device.clone()).expect("failed to create shader module"));
+        self.fs = Some(fs::load(wrapper.device.clone()).expect("failed to create shader module"));
+
+        self.pipeline = Some(wrapper.get_pipeline(
+            self.vs.clone().unwrap(),
+            self.fs.clone().unwrap(),
+            wrapper.render_pass.clone(),
+            wrapper.viewport.read().unwrap().clone(),
+        ));
+
+        self.command_buffers = Some(wrapper.get_command_buffers(
+            &self.queue.clone().unwrap(),
+            &self.pipeline.clone().unwrap(),
+            &self.framebuffers.clone().unwrap(),
+            &self.vertex_buffer.clone().unwrap(),
+        ));
+
+        let frames_in_flight = wrapper.images.len();
+        self.fences = Some(vec![None; frames_in_flight]);
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
+        match event {
+            WindowEvent::CloseRequested => {
+                println!("The close button was pressed; stopping");
+                event_loop.exit();
+            },
+            WindowEvent::RedrawRequested => {
+                println!("{}", self.previous_fence_i);
+                // Redraw the application.
+                //
+                // It's preferable for applications that do not render continuously to render in
+                // this event rather than in AboutToWait, since rendering in here allows
+                // the program to gracefully handle redraws requested by the OS.
+
+                // Draw.
+                let wrapper = if let Some(wrapper) = self.wrapper.clone() {wrapper} else {panic!("wrapper has disappeared")};
+                let queue = self.queue.clone().unwrap();
+                let swapchain = wrapper.swapchain.read().unwrap().clone();
+
+                let (image_i, suboptimal, acquire_future) =
+                    match swapchain::acquire_next_image(swapchain.clone(), None)
+                        .map_err(Validated::unwrap)
+                    {
+                        Ok(r) => r,
+                        Err(VulkanError::OutOfDate) => {
+                            self.recreate_swapchain = true;
+                            return;
+                        }
+                        Err(e) => panic!("failed to acquire next image: {e}"),
+                    };
+
+                if suboptimal {
+                    self.recreate_swapchain = true;
+                }
+
+                let fences = self.fences.as_mut().unwrap();
+
+                if let Some(image_fence) = &fences[image_i as usize] {
+                    image_fence.wait(None).unwrap();
+                }
+
+                let previous_future = match fences[self.previous_fence_i].clone() {
+                    // Create a `NowFuture`.
+                    None => {
+                        let mut now = sync::now(wrapper.device.clone());
+                        now.cleanup_finished();
+
+                        now.boxed()
+                    }
+                    // Use the existing `FenceSignalFuture`.
+                    Some(fence) => fence.boxed(),
+                };
+
+                let future = previous_future
+                    .join(acquire_future)
+                    .then_execute(queue.clone(), self.command_buffers.clone().unwrap()[image_i as usize].clone())
+                    .unwrap()
+                    .then_swapchain_present(
+                        queue.clone(),
+                        SwapchainPresentInfo::swapchain_image_index(swapchain.clone(), image_i),
+                    )
+                    .then_signal_fence_and_flush();
+
+                fences[image_i as usize] = match future.map_err(Validated::unwrap) {
+                    Ok(value) => Some(Arc::new(value)),
+                    Err(VulkanError::OutOfDate) => {
+                        self.recreate_swapchain = true;
+                        None
+                    }
+                    Err(e) => {
+                        println!("failed to flush future: {e}");
+                        None
+                    }
+                };
+
+                self.previous_fence_i = image_i as usize;
+
+                // Queue a RedrawRequested event.
+                //
+                // You only need to call this if you've determined that you need to redraw in
+                // applications which do not always need to. Applications that redraw continuously
+                // can render here instead.
+                //self.window.as_ref().unwrap().request_redraw();
+            },
+            WindowEvent::Resized(_) => {
+                self.window_resized = true;
+            },
+            _ => (),
+        }
+    }
+
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if self.recreate_swapchain {
+            self.recreate_swapchain = false;
+
+            let new_dimensions = if let Some(window) = &self.window {
+                window.inner_size()
+            } else {
+                panic!("window is None");
+            };
+
+            let wrapper = if let Some(wrapper) = self.wrapper.clone() {wrapper} else {panic!("wrapper has disappeared")};
+
+
+            let (new_swapchain, new_images) = wrapper.swapchain.read().unwrap()
+                .recreate(SwapchainCreateInfo {
+                    // Here, `image_extend` will correspond to the window dimensions.
+                    image_extent: new_dimensions.into(),
+                    ..wrapper.swapchain.read().unwrap().create_info()
+                })
+                .expect("failed to recreate swapchain: {e}");
+            *wrapper.swapchain.write().unwrap() = new_swapchain;
+            let new_framebuffers = get_framebuffers(&new_images, &wrapper.render_pass);
+
+            self.framebuffers = Some(new_framebuffers);
+
+            if self.window_resized {
+                self.window_resized = false;
+                let mut viewport = wrapper.viewport.write().unwrap();
+
+                viewport.extent[0] = new_dimensions.width as f32;
+                self.pipeline = Some(wrapper.get_pipeline(
+                    self.vs.clone().unwrap(),
+                    self.fs.clone().unwrap(),
+                    wrapper.render_pass.clone(),
+                    viewport.clone(),
+                ));
+
+                self.command_buffers = Some(wrapper.get_command_buffers(
+                    &self.queue.clone().unwrap(),
+                    &self.pipeline.clone().unwrap(),
+                    &self.framebuffers.clone().unwrap(),
+                    &self.vertex_buffer.clone().unwrap(),
+                ));
+            }
+
+        }
+
+    }
+}
+
+mod vs {
+    vulkano_shaders::shader! {
+        ty: "vertex",
+        src: "
+            #version 460
+
+            layout(location = 0) in vec2 position;
+
+            void main() {
+                gl_Position = vec4(position, 0.0, 1.0);
+            }
+        ",
+    }
+}
+
+mod fs {
+    vulkano_shaders::shader! {
+        ty: "fragment",
+        src: "
+            #version 460
+
+            layout(location = 0) out vec4 f_color;
+
+            void main() {
+                f_color = vec4(1.0, 0.0, 0.0, 1.0);
+            }
+        ",
+    }
+}

src/main.rs

@@ -0,0 +1,14 @@
+use winit::event_loop::{ControlFlow, EventLoop};
+use crate::app::App;
+
+mod util;
+mod app;
+
+fn main() {
+    let event_loop = EventLoop::new().unwrap();
+    
+    // BEGIN WINDOW INIT
+    event_loop.set_control_flow(ControlFlow::Poll);
+    let mut app = App::default();
+    let _ = event_loop.run_app(&mut app);
+}

src/util.rs

@@ -0,0 +1,307 @@
+use std::sync::{Arc, RwLock};
+use vulkano::buffer::{BufferContents, Subbuffer};
+use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
+use vulkano::command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer, RenderPassBeginInfo, SubpassBeginInfo, SubpassContents, SubpassEndInfo};
+use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::device::{Device, DeviceCreateInfo, DeviceExtensions, Queue, QueueCreateInfo, QueueFlags};
+use vulkano::device::physical::{PhysicalDevice, PhysicalDeviceType};
+use vulkano::image::{Image, ImageCreateInfo, ImageUsage};
+use vulkano::instance::Instance;
+use vulkano::memory::allocator::{AllocationCreateInfo, StandardMemoryAllocator};
+use vulkano::pipeline::graphics::vertex_input::{Vertex, VertexDefinition};
+use vulkano::pipeline::graphics::viewport::{Viewport, ViewportState};
+use vulkano::pipeline::{GraphicsPipeline, PipelineLayout, PipelineShaderStageCreateInfo};
+use vulkano::pipeline::graphics::color_blend::{ColorBlendAttachmentState, ColorBlendState};
+use vulkano::pipeline::graphics::GraphicsPipelineCreateInfo;
+use vulkano::pipeline::graphics::input_assembly::InputAssemblyState;
+use vulkano::pipeline::graphics::multisample::MultisampleState;
+use vulkano::pipeline::graphics::rasterization::RasterizationState;
+use vulkano::pipeline::layout::PipelineDescriptorSetLayoutCreateInfo;
+use vulkano::render_pass::{Framebuffer, RenderPass, Subpass};
+use vulkano::shader::ShaderModule;
+use vulkano::swapchain::{Surface, Swapchain, SwapchainCreateInfo};
+use winit::window::Window;
+
+pub struct VulkanoWrapper {
+    pub instance: Arc<Instance>,
+    pub surface: Arc<Surface>,
+
+    pub device: Arc<Device>,
+    pub memory_allocator: Arc<StandardMemoryAllocator>,
+    pub command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
+    pub descriptor_set_allocator: Arc<StandardDescriptorSetAllocator>,
+    pub swapchain: RwLock<Arc<Swapchain>>,
+    pub images: Vec<Arc<Image>>,
+
+    pub queues: Vec<Arc<Queue>>,
+    pub render_pass: Arc<RenderPass>,
+    pub viewport: Arc<RwLock<Viewport>>,
+}
+
+impl VulkanoWrapper {
+    pub fn new(instance: Arc<Instance>, window: &Window, device_extensions: DeviceExtensions) -> Self {
+        let surface = unsafe {Surface::from_window_ref(instance.clone(), window)}.unwrap();
+
+        let (physical_device, queue_family_index) = Self::select_physical_device(&instance, &surface, &device_extensions);
+
+        for family in physical_device.queue_family_properties() {
+            println!("Found a queue family with flags: ({:?}) with {} queues", family.queue_flags, family.queue_count)
+        }
+
+        let (device, queues) = Device::new(
+            physical_device.clone(),
+            DeviceCreateInfo {
+                queue_create_infos: vec![QueueCreateInfo {
+                    queue_family_index,
+                    ..Default::default()
+                }],
+                enabled_extensions: device_extensions,
+                ..Default::default()
+            },
+        ).expect("failed to create logical device");
+
+        let caps = physical_device
+            .surface_capabilities(&surface, Default::default())
+            .expect("failed to get surface capabilities");
+
+        let dimensions = window.inner_size();
+        let composite_alpha = caps.supported_composite_alpha.into_iter().next().unwrap();
+        let image_format =  physical_device
+            .surface_formats(&surface, Default::default())
+            .unwrap()[0]
+            .0;
+
+        let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
+
+        let command_buffer_allocator = Arc::new(
+            StandardCommandBufferAllocator::new(
+                device.clone(),
+                Default::default()
+            )
+        );
+
+        let descriptor_set_allocator = Arc::new(
+            StandardDescriptorSetAllocator::new(
+                device.clone(),
+                Default::default()
+            )
+        );
+
+        let (swapchain, images) = Swapchain::new(
+            device.clone(),
+            surface.clone(),
+            SwapchainCreateInfo {
+                min_image_count: caps.min_image_count + 1, // How many buffers to use in the swapchain
+                image_format,
+                image_extent: dimensions.into(),
+                image_usage: ImageUsage::COLOR_ATTACHMENT, // What the images are going to be used for
+                composite_alpha,
+                ..Default::default()
+            },
+        ).unwrap();
+
+        let queues = queues.into_iter().collect();
+
+        let render_pass = Self::get_render_pass(&device, &swapchain);
+
+        let swapchain = RwLock::new(swapchain);
+
+        Self {
+            instance,
+            surface,
+            device,
+            memory_allocator,
+            command_buffer_allocator,
+            descriptor_set_allocator,
+            swapchain,
+            images,
+            queues,
+            render_pass,
+            viewport: Arc::new(RwLock::new(Viewport {
+                offset: [0.0, 0.0],
+                extent: window.inner_size().into(),
+                depth_range: 0.0..=1.0,
+            }))
+        }
+    }
+
+    fn select_physical_device(
+        instance: &Arc<Instance>,
+        surface: &Arc<Surface>,
+        device_extensions: &DeviceExtensions,
+    ) -> (Arc<PhysicalDevice>, u32) {
+        instance
+            .enumerate_physical_devices()
+            .expect("could not enumerate devices")
+            .filter(|p| p.supported_extensions().contains(&device_extensions))
+            .filter_map(|p| {
+                p.queue_family_properties()
+                    .iter()
+                    .enumerate()
+                    // Find the first first queue family that is suitable.
+                    // If none is found, `None` is returned to `filter_map`,
+                    // which disqualifies this physical device.
+                    .position(|(i, q)| {
+                        q.queue_flags.contains(QueueFlags::GRAPHICS)
+                            && p.surface_support(i as u32, &surface).unwrap_or(false)
+                    })
+                    .map(|q| (p, q as u32))
+            })
+            .min_by_key(|(p, _)| match p.properties().device_type {
+                PhysicalDeviceType::DiscreteGpu => 0,
+                PhysicalDeviceType::IntegratedGpu => 1,
+                PhysicalDeviceType::VirtualGpu => 2,
+                PhysicalDeviceType::Cpu => 3,
+
+                // Note that there exists `PhysicalDeviceType::Other`, however,
+                // `PhysicalDeviceType` is a non-exhaustive enum. Thus, one should
+                // match wildcard `_` to catch all unknown device types.
+                _ => 4,
+            })
+            .expect("no device available")
+    }
+
+    fn get_render_pass(device: &Arc<Device>, swapchain: &Swapchain) -> Arc<RenderPass> {
+        vulkano::single_pass_renderpass!(
+        device.clone(),
+        attachments: {
+            color: {
+                // Set the format the same as the swapchain.
+                format: swapchain.image_format(),
+                samples: 1,
+                load_op: Clear,
+                store_op: Store,
+            },
+        },
+        pass: {
+            color: [color],
+            depth_stencil: {},
+        },
+    ).unwrap()
+
+    }
+
+    pub fn create_image(&self, image_create_info: ImageCreateInfo, allocation_create_info: AllocationCreateInfo) -> Arc<Image> {
+        Image::new(
+            self.memory_allocator.clone(),
+            image_create_info,
+            allocation_create_info,
+        ).unwrap()
+    }
+
+    pub fn get_pipeline(&self, vs: Arc<ShaderModule>, fs: Arc<ShaderModule>, rp: Arc<RenderPass>, vp: Viewport) -> Arc<GraphicsPipeline> {
+        get_pipeline(self.device.clone(), vs, fs, rp, vp)
+    }
+
+    pub fn get_command_buffers(&self, queue: &Arc<Queue>, pipeline: &Arc<GraphicsPipeline>, framebuffers: &Vec<Arc<Framebuffer>>, vb: &Subbuffer<[MyVertex]>) -> Vec<Arc<PrimaryAutoCommandBuffer>> {
+        get_command_buffers(self.command_buffer_allocator.clone(), queue, pipeline, framebuffers, vb)
+    }
+}
+
+fn get_pipeline(
+    device: Arc<Device>,
+    vs: Arc<ShaderModule>,
+    fs: Arc<ShaderModule>,
+    render_pass: Arc<RenderPass>,
+    viewport: Viewport,
+) -> Arc<GraphicsPipeline> {
+    let vs = vs.entry_point("main").unwrap();
+    let fs = fs.entry_point("main").unwrap();
+
+    let vertex_input_state = MyVertex::per_vertex()
+        .definition(&vs)
+        .unwrap();
+
+    let stages = [
+        PipelineShaderStageCreateInfo::new(vs),
+        PipelineShaderStageCreateInfo::new(fs),
+    ];
+
+    let layout = PipelineLayout::new(
+        device.clone(),
+        PipelineDescriptorSetLayoutCreateInfo::from_stages(&stages)
+            .into_pipeline_layout_create_info(device.clone())
+            .unwrap(),
+    )
+        .unwrap();
+
+    let subpass = Subpass::from(render_pass.clone(), 0).unwrap();
+
+    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 {
+                viewports: [viewport].into_iter().collect(),
+                ..Default::default()
+            }),
+            rasterization_state: Some(RasterizationState::default()),
+            multisample_state: Some(MultisampleState::default()),
+            color_blend_state: Some(ColorBlendState::with_attachment_states(
+                subpass.num_color_attachments(),
+                ColorBlendAttachmentState::default(),
+            )),
+            subpass: Some(subpass.into()),
+            ..GraphicsPipelineCreateInfo::layout(layout)
+        },
+    )
+        .unwrap()
+}
+
+fn get_command_buffers(
+    command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
+    queue: &Arc<Queue>,
+    pipeline: &Arc<GraphicsPipeline>,
+    framebuffers: &Vec<Arc<Framebuffer>>,
+    vertex_buffer: &Subbuffer<[MyVertex]>,
+) -> Vec<Arc<PrimaryAutoCommandBuffer>> {
+    framebuffers
+        .iter()
+        .map(|framebuffer| {
+            let mut builder = AutoCommandBufferBuilder::primary(
+                command_buffer_allocator.clone(),
+                queue.queue_family_index(),
+                // Don't forget to write the correct buffer usage.
+                CommandBufferUsage::MultipleSubmit,
+            )
+                .unwrap();
+
+            builder
+                .begin_render_pass(
+                    RenderPassBeginInfo {
+                        clear_values: vec![Some([0.1, 0.1, 0.1, 1.0].into())],
+                        ..RenderPassBeginInfo::framebuffer(framebuffer.clone())
+                    },
+                    SubpassBeginInfo {
+                        contents: SubpassContents::Inline,
+                        ..Default::default()
+                    },
+                )
+                .unwrap()
+                .bind_pipeline_graphics(pipeline.clone())
+                .unwrap()
+                .bind_vertex_buffers(0, vertex_buffer.clone())
+                .unwrap();
+            unsafe {
+                builder
+                    .draw(vertex_buffer.len() as u32, 1, 0, 0)
+                    .unwrap();
+            }
+            builder
+                .end_render_pass(SubpassEndInfo::default())
+                .unwrap();
+
+            builder.build().unwrap()
+        })
+        .collect()
+}
+
+#[derive(BufferContents, Vertex)]
+#[repr(C)]
+pub struct MyVertex {
+    #[format(R32G32_SFLOAT)]
+    pub position: [f32; 2],
+}