buffer: adjust ash to use buffers

Author: Firestar99

Cargo.lock

@@ -1,8 +1,8 @@
 [workspace]
 members = [
-    "graphics/mygraphics",
-    "graphics/mygraphics-shaders",
-    "xtask",
+	"graphics/mygraphics",
+	"graphics/mygraphics-shaders",
+	"xtask",
 ]
 resolver = "3"
 
@@ -20,6 +20,7 @@ unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spir
 # API
 ash = "0.38"
 ash-window = "0.13"
+gpu-allocator = { version = "0.28.0", default-features = false, features = ["std", "vulkan"] }
 wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "vulkan-portability", "spirv", "wgsl"] }
 pollster = "0.4.0"
 

Cargo.toml

@@ -19,6 +19,7 @@ unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spir
 # API
 ash = "0.38"
 ash-window = "0.13"
+gpu-allocator = { version = "0.28.0", default-features = false, features = ["std", "vulkan"] }
 
 # rust-gpu
 cargo-gpu = { git = "https://github.com/Rust-GPU/cargo-gpu", rev = "bb74342b90066ce8b7d50ba8e058df356a54acf4" }

generated/graphics/ash/cargo-gpu/Cargo.toml

@@ -17,6 +17,7 @@ mygraphics-shaders = { path = "../mygraphics-shaders" }
 # API
 ash.workspace = true
 ash-window.workspace = true
+gpu-allocator.workspace = true
 
 # other
 raw-window-handle.workspace = true

generated/graphics/ash/cargo-gpu/mygraphics/Cargo.toml

@@ -1,9 +1,10 @@
 use anyhow::{Context, anyhow};
 use ash::{ext, khr, vk};
+use gpu_allocator::vulkan::{Allocator, AllocatorCreateDesc};
 use std::borrow::Cow;
 use std::ffi::{CStr, c_char};
 use std::ops::Deref;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex, MutexGuard};
 
 /// Central struct containing the Vulkan instance and device, among others
 pub struct MyDevice {
@@ -13,6 +14,7 @@ pub struct MyDevice {
     pub device: ash::Device,
     pub main_queue_family: u32,
     pub main_queue: vk::Queue,
+    allocator: Option<Mutex<Allocator>>,
     pub debug_ext_instance: ext::debug_utils::Instance,
     pub debug_ext_device: ext::debug_utils::Device,
     pub surface_ext: khr::surface::Instance,
@@ -134,6 +136,15 @@ impl MyDevice {
                 .context("create_device")?;
             let main_queue = device.get_device_queue(main_queue_family, 0);
 
+            let allocator = Allocator::new(&AllocatorCreateDesc {
+                instance: instance.clone(),
+                device: device.clone(),
+                physical_device,
+                debug_settings: Default::default(),
+                buffer_device_address: false,
+                allocation_sizes: Default::default(),
+            })?;
+
             Ok(Arc::new(Self {
                 debug_ext_device: ext::debug_utils::Device::new(&instance, &device),
                 surface_ext: khr::surface::Instance::new(&entry, &instance),
@@ -144,16 +155,22 @@ impl MyDevice {
                 device,
                 main_queue_family,
                 main_queue,
+                allocator: Some(Mutex::new(allocator)),
                 debug_ext_instance: debug_instance,
                 debug_callback,
             }))
         }
     }
+
+    pub fn borrow_allocator(&self) -> MutexGuard<'_, Allocator> {
+        self.allocator.as_ref().unwrap().lock().unwrap()
+    }
 }
 
 impl Drop for MyDevice {
     fn drop(&mut self) {
         unsafe {
+            drop(self.allocator.take());
             self.debug_ext_instance
                 .destroy_debug_utils_messenger(self.debug_callback, None);
             self.device.destroy_device(None);

generated/graphics/ash/cargo-gpu/mygraphics/src/ash_renderer/device.rs

@@ -0,0 +1,100 @@
+use crate::ash_renderer::device::MyDevice;
+use ash::vk;
+use std::sync::Arc;
+
+pub struct GlobalDescriptorSetLayout {
+    pub device: Arc<MyDevice>,
+    pub layout: vk::DescriptorSetLayout,
+}
+
+impl GlobalDescriptorSetLayout {
+    pub fn new(device: Arc<MyDevice>) -> anyhow::Result<Arc<Self>> {
+        unsafe {
+            Ok(Arc::new(Self {
+                layout: device.create_descriptor_set_layout(
+                    &vk::DescriptorSetLayoutCreateInfo::default().bindings(&[
+                        vk::DescriptorSetLayoutBinding::default()
+                            .binding(0)
+                            .descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
+                            .stage_flags(vk::ShaderStageFlags::ALL_GRAPHICS)
+                            .descriptor_count(1),
+                    ]),
+                    None,
+                )?,
+                device,
+            }))
+        }
+    }
+}
+
+impl Drop for GlobalDescriptorSetLayout {
+    fn drop(&mut self) {
+        unsafe {
+            self.device.destroy_descriptor_set_layout(self.layout, None);
+        }
+    }
+}
+
+/// This implementation of descriptor sets is kept simple on purpose, even at the cost of being quite inefficient.
+/// Don't use this as a reference on how it should be done!
+pub struct GlobalDescriptorSet {
+    pub layout: Arc<GlobalDescriptorSetLayout>,
+    pub pool: vk::DescriptorPool,
+    pub set: vk::DescriptorSet,
+}
+
+impl GlobalDescriptorSet {
+    /// # Safety
+    /// * `shader_constants` must not be dropped before `GlobalDescriptorSet` is dropped
+    /// * you must only drop this `GlobalDescriptorSet` when it is unused, e.g. by GPU execution
+    pub unsafe fn new(
+        layout: &Arc<GlobalDescriptorSetLayout>,
+        shader_constants: vk::Buffer,
+    ) -> anyhow::Result<Self> {
+        unsafe {
+            let device = &layout.device;
+            let pool = device.create_descriptor_pool(
+                &vk::DescriptorPoolCreateInfo::default()
+                    .pool_sizes(&[vk::DescriptorPoolSize::default()
+                        .ty(vk::DescriptorType::STORAGE_BUFFER)
+                        .descriptor_count(1)])
+                    .max_sets(1),
+                None,
+            )?;
+            let set = device.allocate_descriptor_sets(
+                &vk::DescriptorSetAllocateInfo::default()
+                    .descriptor_pool(pool)
+                    .set_layouts(&[layout.layout]),
+            )?[0];
+            device.update_descriptor_sets(
+                &[vk::WriteDescriptorSet::default()
+                    .dst_set(set)
+                    .dst_binding(0)
+                    .descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
+                    .descriptor_count(1)
+                    .buffer_info(&[vk::DescriptorBufferInfo::default()
+                        .buffer(shader_constants)
+                        .offset(0)
+                        .range(vk::WHOLE_SIZE)])],
+                &[],
+            );
+            Ok(Self {
+                layout: layout.clone(),
+                pool,
+                set,
+            })
+        }
+    }
+}
+
+impl Drop for GlobalDescriptorSet {
+    fn drop(&mut self) {
+        let device = &self.layout.device;
+        unsafe {
+            device
+                .reset_descriptor_pool(self.pool, vk::DescriptorPoolResetFlags::empty())
+                .ok();
+            device.destroy_descriptor_pool(self.pool, None);
+        }
+    }
+}

generated/graphics/ash/cargo-gpu/mygraphics/src/ash_renderer/global_descriptor_set.rs

@@ -1,5 +1,4 @@
 use crate::ash_renderer::device::MyDevice;
-use crate::ash_renderer::render_pipeline::MyRenderPipelineManager;
 use crate::ash_renderer::renderer::MyRenderer;
 use crate::ash_renderer::swapchain::MySwapchainManager;
 use crate::util::enable_debug_layer;
@@ -13,6 +12,7 @@ use winit::{
 };
 
 pub mod device;
+pub mod global_descriptor_set;
 pub mod render_pipeline;
 pub mod renderer;
 pub mod single_command_buffer;
@@ -36,24 +36,20 @@ pub fn main() -> anyhow::Result<()> {
     let extensions = ash_window::enumerate_required_extensions(window.display_handle()?.as_raw())?;
     let device = MyDevice::new(extensions, enable_debug_layer())?;
     let mut swapchain = MySwapchainManager::new(device.clone(), window)?;
-    let mut renderer = MyRenderer::new(MyRenderPipelineManager::new(
-        device.clone(),
-        swapchain.surface_format.format,
-        get_shaders()?,
-    )?)?;
+    let mut renderer = MyRenderer::new(device.clone(), swapchain.surface_format.format)?;
 
     let start = std::time::Instant::now();
     let mut event_handler =
         move |event: Event<_>, event_loop_window_target: &ActiveEventLoop| match event {
             Event::AboutToWait => swapchain.render(|frame| {
                 let extent = frame.extent;
-                let push_constants = ShaderConstants {
+                let shader_constants = ShaderConstants {
                     width: extent.width,
                     height: extent.height,
                     time: start.elapsed().as_secs_f32(),
                 };
 
-                renderer.render_frame(frame, push_constants)?;
+                renderer.render_frame(frame, &shader_constants)?;
                 Ok(())
             }),
             Event::WindowEvent { event, .. } => {

generated/graphics/ash/cargo-gpu/mygraphics/src/ash_renderer/mod.rs

@@ -1,13 +1,14 @@
 use crate::ash_renderer::device::MyDevice;
+use crate::ash_renderer::global_descriptor_set::{GlobalDescriptorSet, GlobalDescriptorSetLayout};
 use anyhow::Context;
 use ash::vk;
-use mygraphics_shaders::ShaderConstants;
 use std::sync::Arc;
 
 /// Manages the creation and recreation of [`MyRenderPipeline`], whenever new shader code ([`Self::set_shader_code`])
 /// is submitted
 pub struct MyRenderPipelineManager {
     pub device: Arc<MyDevice>,
+    global_descriptor_set_layout: Arc<GlobalDescriptorSetLayout>,
     color_out_format: vk::Format,
     shader_code: Vec<u32>,
     pipeline: Option<MyRenderPipeline>,
@@ -22,11 +23,13 @@ pub struct MyRenderPipeline {
 impl MyRenderPipelineManager {
     pub fn new(
         device: Arc<MyDevice>,
+        global_descriptor_set_layout: Arc<GlobalDescriptorSetLayout>,
         color_out_format: vk::Format,
         shader_code: Vec<u32>,
     ) -> anyhow::Result<Self> {
         Ok(Self {
             device,
+            global_descriptor_set_layout,
             color_out_format,
             shader_code,
             pipeline: None,
@@ -63,12 +66,8 @@ impl MyRenderPipelineManager {
             )?;
 
             let pipeline_layout = self.device.create_pipeline_layout(
-                &vk::PipelineLayoutCreateInfo::default().push_constant_ranges(&[
-                    vk::PushConstantRange::default()
-                        .offset(0)
-                        .size(size_of::<ShaderConstants>() as u32)
-                        .stage_flags(vk::ShaderStageFlags::ALL),
-                ]),
+                &vk::PipelineLayoutCreateInfo::default()
+                    .set_layouts(&[self.global_descriptor_set_layout.layout]),
                 None,
             )?;
 
@@ -177,7 +176,7 @@ impl MyRenderPipeline {
         cmd: vk::CommandBuffer,
         color_out: vk::ImageView,
         extent: vk::Extent2D,
-        push_constants: ShaderConstants,
+        global_descriptor_set: &GlobalDescriptorSet,
     ) -> anyhow::Result<()> {
         unsafe {
             let render_area = vk::Rect2D {
@@ -216,12 +215,13 @@ impl MyRenderPipeline {
                 }],
             );
             device.cmd_set_scissor(cmd, 0, &[render_area]);
-            device.cmd_push_constants(
+            device.cmd_bind_descriptor_sets(
                 cmd,
+                vk::PipelineBindPoint::GRAPHICS,
                 self.pipeline_layout,
-                vk::ShaderStageFlags::ALL,
                 0,
-                bytemuck::bytes_of(&push_constants),
+                &[global_descriptor_set.set],
+                &[],
             );
             device.cmd_draw(cmd, 3, 1, 0, 0);
             device.cmd_end_rendering(cmd);