queue transfer in graph barrier

crates/renderer_device/src/lib.rs

@@ -2,20 +2,24 @@
 
 extern crate self as renderer_device;
 
-use std::{fmt::Debug, path::PathBuf};
-use ash::{ext, vk::{self, SurfaceCapabilitiesKHR}};
-use dyn_clone::DynClone;
 use crate::instance::InstanceInner;
+use ash::{
+    ext,
+    vk::{self, SurfaceCapabilitiesKHR},
+};
+use dyn_clone::DynClone;
+use std::{fmt::Debug, path::PathBuf};
 
+mod debug;
 pub mod device;
 pub mod instance;
 pub mod pipeline_cache;
 pub mod queue;
 pub mod sync;
-mod debug;
 
 pub use device::{Device, DeviceOwned, DeviceRef, Extension};
 pub use instance::{DebugUtils, DebugUtilsCreateInfo, Instance};
+pub use queue::QueueFamilyIndex;
 
 #[cfg(test)]
 mod device_ref_derive_tests {

crates/renderer_rendergraph/src/graph.rs

@@ -13,6 +13,8 @@ use renderer_resources::{
     images::{Image as ImageResource, ImageDesc},
 };
 
+use renderer_device::QueueFamilyIndex;
+
 use crate::{
     recorder::{CommandIndex, CommandList, CommandRecorder, RecordError, scope_range},
     resources::{
@@ -27,6 +29,12 @@ pub enum GraphError {
     DependencyCycle,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct QueueTransfer {
+    pub src: QueueFamilyIndex,
+    pub dst: QueueFamilyIndex,
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct BarrierResource {
     pub id: ResourceId,
@@ -37,6 +45,7 @@ pub struct BarrierResource {
     pub dst_access: vk::AccessFlags2,
     pub old_layout: Option<vk::ImageLayout>,
     pub new_layout: Option<vk::ImageLayout>,
+    pub queue_transfer: Option<QueueTransfer>,
 }
 
 #[derive(Debug, Clone)]
@@ -339,9 +348,18 @@ impl<'a> GraphCompiler<'a> {
                 batch_indices[command.index()] = batch_index;
             }
         }
+
+        batches.iter().enumerate().flat_map(|(batch_index, batch)| {
+            batch
+                .iter()
+                .enumerate()
+                .map(move |(in_batch_index, &cmd)| (batch_index, in_batch_index, cmd))
+        });
+
         let mut result = Vec::new();
         for (ordered_index, &command_index) in order.iter().enumerate() {
             let mut barrier_resources = Vec::new();
+
             for current in &self.accesses[command_index.index()] {
                 let previous = order[..ordered_index]
                     .iter()
@@ -374,6 +392,7 @@ impl<'a> GraphCompiler<'a> {
                         dst_access: current.scope.access,
                         old_layout,
                         new_layout,
+                        queue_transfer: None,
                     });
 
                     continue;
@@ -403,6 +422,7 @@ impl<'a> GraphCompiler<'a> {
                         dst_access: current.scope.access,
                         old_layout,
                         new_layout,
+                        queue_transfer: None,
                     });
                 }
             }

crates/renderer_rendergraph/src/recorder.rs

@@ -164,11 +164,19 @@ impl<'a> CommandRecorder<'a> {
             .filter_map(|resource| match resource.range {
                 Subresource::Buffer(BufferRange { offset, size }) => {
                     self.buffers.get(&resource.id).map(|&buffer| {
+                        let (src, dst) = if let Some(queue_transfer) = resource.queue_transfer {
+                            (queue_transfer.src.index(), queue_transfer.dst.index())
+                        } else {
+                            (vk::QUEUE_FAMILY_IGNORED, vk::QUEUE_FAMILY_IGNORED)
+                        };
+
                         vk::BufferMemoryBarrier2::default()
                             .src_stage_mask(resource.src_stage)
                             .src_access_mask(resource.src_access)
                             .dst_stage_mask(resource.dst_stage)
                             .dst_access_mask(resource.dst_access)
+                            .src_queue_family_index(src)
+                            .dst_queue_family_index(dst)
                             .buffer(buffer)
                             .offset(offset)
                             .size(size)