im lost..

crates/renderer/src/render_graph/commands.rs

@@ -41,48 +41,60 @@ impl<T: Resource> Command for ImportResource<T> {
     }
 }
 
-// pub struct CopyBuffers {
+pub struct CopyBuffers {
-//     pub src: Read<BufferSlice>,
+    pub src: BufferSlice,
-//     pub dst: Write<BufferSlice>,
+    pub dst: BufferSlice,
-// }
+}
 
-// pub struct CopyTextures {
+pub struct CopyTextures {
-//     pub src: Read<TextureRegion>,
+    pub src: TextureRegion,
-//     pub dst: Write<TextureRegion>,
+    pub dst: TextureRegion,
-// }
+}
 
-// pub struct CopyBufferToTexture {
+pub struct CopyBufferToTexture {
-//     pub src: Read<BufferSlice>,
+    pub src: BufferSlice,
-//     pub dst: Write<TextureRegion>,
+    pub rows: Option<BufferRows>,
-// }
+    pub dst: TextureRegion,
+}
 
-// pub struct CopyTextureToBuffer {
+pub struct CopyTextureToBuffer {
-//     pub src: Read<TextureRegion>,
+    pub src: TextureRegion,
-//     pub dst: Write<BufferSlice>,
+    pub rows: Option<BufferRows>,
-// }
+    pub dst: BufferSlice,
+}
+
+pub struct CopyBuffersToTextures {
+    pub src: BufferSlice,
+    pub src_rows: Vec<BufferRows>,
+    pub dst: Texture,
+    pub src_ranges: Vec<(TextureRegion, vk::Offset3D, vk::Extent3D)>,
+}
 
 pub struct Copy<T: Resource, U: Resource> {
     pub src: T,
     pub dst: U,
 }
-impl<T: Resource, U: Resource> Copy<T, U> {
+
-    fn side_effects_inner(&self, mut map: SideEffectMap) {
+fn copy_side_effects_inner<T, U>(src: &T, dst: &U, mut map: SideEffectMap)
-        self.src.side_effect(map.reborrow().into_side_effect_map2(
+where
-            vk::PipelineStageFlags2::TRANSFER,
+    T: Resource,
+    U: Resource,
+{
+    src.side_effect(map.reborrow().into_side_effect_map2(
+        vk::PipelineStageFlags2::COPY,
         vk::AccessFlags2::TRANSFER_READ,
         Some(vk::ImageLayout::TRANSFER_SRC_OPTIMAL),
     ));
-        self.src.side_effect(map.reborrow().into_side_effect_map2(
+    dst.side_effect(map.reborrow().into_side_effect_map2(
-            vk::PipelineStageFlags2::TRANSFER,
+        vk::PipelineStageFlags2::COPY,
         vk::AccessFlags2::TRANSFER_WRITE,
         Some(vk::ImageLayout::TRANSFER_DST_OPTIMAL),
     ));
-    }
 }
 
-impl Command for Copy<BufferRowSlice, TextureRegion> {
+impl Command for CopyBufferToTexture {
     fn side_effects(&self, map: SideEffectMap) {
-        self.side_effects_inner(map)
+        copy_side_effects_inner(&self.src, &self.dst, map)
     }
 
     fn apply(self, recorder: &mut CommandRecorder) {
@@ -93,12 +105,13 @@ impl Command for Copy<BufferRowSlice, TextureRegion> {
         // levels, considering the mip extents are different for each level.
         debug_assert_eq!(self.dst.range.mip_levels.len(), 1);
 
+        let rows = self.rows.unwrap_or_default();
         let regions = &[vk::BufferImageCopy2::default()
-            .buffer_offset(self.src.row.offset)
+            .buffer_offset(self.src.range.offset + rows.offset)
-            .buffer_row_length(self.src.row.row_size)
+            .buffer_row_length(rows.row_size)
-            .buffer_image_height(self.src.row.row_count)
+            .buffer_image_height(rows.row_count)
-            .image_offset(self.dst.range.offset())
+            .image_offset(self.dst.offset)
-            .image_extent(self.dst.range.extent())
+            .image_extent(self.dst.extent)
             .image_subresource(
                 vk::ImageSubresourceLayers::default()
                     .aspect_mask(self.dst.range.aspect)

crates/renderer/src/render_graph/resources.rs

@@ -9,9 +9,29 @@ pub trait Resource: Sized {
     fn side_effect(&self, map: SideEffectMap2);
 }
 
+mod sealed {
+    pub trait Texture {}
+    pub trait Buffer {}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum SubresourceRange {
+    Buffer(BufferRange),
+    Texture(TextureRange),
+}
+
 mod impls {
     use super::*;
 
+    impl sealed::Texture for Texture {}
+    impl sealed::Texture for TextureRegion {}
+    impl sealed::Texture for TextureRegions {}
+    impl sealed::Texture for TextureView {}
+
+    impl sealed::Buffer for Buffer {}
+    impl sealed::Buffer for BufferSlice {}
+    impl sealed::Buffer for BufferSlices {}
+
     impl Resource for Buffer {
         fn id(&self) -> ResourceId {
             self.0
@@ -102,7 +122,7 @@ mod impls {
 
         fn side_effect(&self, mut map: SideEffectMap2) {
             for range in &self.ranges {
-                map.insert_range(self.id(), *range);
+                map.insert_range(self.id(), range.0);
             }
         }
     }
@@ -330,8 +350,6 @@ pub enum ResourceRange {
         aspect: vk::ImageAspectFlags,
         mip_level: MipRange,
         array_layers: MipRange,
-        origin: (i32, i32, i32),
-        extent: (u32, u32, u32),
         layout: vk::ImageLayout,
     },
 }
@@ -372,25 +390,6 @@ pub struct TextureRange {
     pub aspect: vk::ImageAspectFlags,
     pub mip_levels: MipRange,
     pub array_layers: MipRange,
-    pub origin: (i32, i32, i32),
-    pub extent: (u32, u32, u32),
-}
-
-impl TextureRange {
-    pub fn offset(&self) -> vk::Offset3D {
-        vk::Offset3D {
-            x: self.origin.0,
-            y: self.origin.1,
-            z: self.origin.2,
-        }
-    }
-    pub fn extent(&self) -> vk::Extent3D {
-        vk::Extent3D {
-            width: self.extent.0,
-            height: self.extent.1,
-            depth: self.extent.2,
-        }
-    }
 }
 
 impl From<(BufferRange, vk::ImageLayout)> for ResourceRange {
@@ -408,8 +407,6 @@ impl From<(TextureRange, vk::ImageLayout)> for ResourceRange {
             aspect: value.aspect,
             mip_level: value.mip_levels,
             array_layers: value.array_layers,
-            origin: value.origin,
-            extent: value.extent,
             layout,
         }
     }
@@ -432,8 +429,6 @@ impl TextureRange {
                 | vk::ImageAspectFlags::STENCIL,
             mip_levels: MipRange::default(),
             array_layers: MipRange::default(),
-            origin: (0, 0, 0),
-            extent: (u32::MAX, u32::MAX, u32::MAX),
         }
     }
 }
@@ -477,11 +472,13 @@ pub struct BufferRowSlices {
 pub struct TextureRegion {
     pub texture: Texture,
     pub range: TextureRange,
+    pub offset: vk::Offset3D,
+    pub extent: vk::Extent3D,
 }
 
 pub struct TextureRegions {
     pub texture: Texture,
-    pub ranges: Vec<TextureRange>,
+    pub ranges: Vec<(TextureRange, vk::Offset3D, vk::Extent3D)>,
 }
 
 pub struct TextureView {