Attempt to fix cube map generation

vulkan-rs/src/image.rs

@@ -172,11 +172,12 @@ impl ImageBuilder {
                     Self::optimize_fill(
                         device,
                         queue,
-                        &raw.into_iter()
+                        [raw.into_iter()
                             .map(|d| RawBuffer { d })
-                            .collect::<Vec<RawBuffer>>(),
+                            .collect::<Vec<RawBuffer>>()
+                            .as_slice()]
+                        .into_iter(),
                         &arc_image,
-                        0,
                     )?;
 
                     Ok(arc_image)
@@ -203,17 +204,21 @@ impl ImageBuilder {
                         self.file_name,
                     )?;
 
-                    for (layer, raw) in raw_array.into_iter().enumerate() {
+                    let data = raw_array
+                        .into_iter()
+                        .map(|raw| {
+                            raw.into_iter()
+                                .map(|d| RawBuffer { d })
+                                .collect::<Vec<RawBuffer>>()
+                        })
+                        .collect::<Vec<_>>();
+
                     Self::optimize_fill(
                         device,
                         queue,
-                            &raw.into_iter()
+                        data.iter().map(|r| r.as_slice()),
-                                .map(|d| RawBuffer { d })
-                                .collect::<Vec<RawBuffer>>(),
                         &arc_image,
-                            layer as u32,
                     )?;
-                    }
 
                     Ok(arc_image)
                 }
@@ -477,20 +482,23 @@ impl ImageBuilder {
         device.create_image(image_ci)
     }
 
-    fn optimize_fill(
+    fn optimize_fill<'a>(
         device: &Arc<Device>,
         queue: &Arc<Mutex<Queue>>,
-        data: &[RawBuffer],
+        data: impl Iterator<Item = &'a [RawBuffer]>,
         image: &Arc<Image>,
-        layer: u32,
     ) -> Result<()> {
-        let staging_buffer = Buffer::builder()
+        let staging_buffers = data
+            .map(|data| {
+                Buffer::builder()
                     .set_usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
                     .set_memory_usage(MemoryUsage::CpuToGpu)
                     .set_data(data)
-            .build(device.clone())?;
+                    .build(device.clone())
+            })
+            .collect::<Result<Vec<_>>>()?;
 
-        copy_buffer_to_image(device, queue, &staging_buffer, image, layer)?;
+        copy_buffers_to_image(device, queue, staging_buffers.iter(), image)?;
 
         Ok(())
     }
@@ -967,7 +975,7 @@ impl Image {
     }
 
     pub fn copy_buffer_to_image(self: &Arc<Image>, buffer: &Arc<Buffer<RawBuffer>>) -> Result<()> {
-        copy_buffer_to_image(&self.device, &self.queue, &buffer, self, 0)
+        copy_buffers_to_image(&self.device, &self.queue, [buffer].into_iter(), self)
     }
 }
 
@@ -1031,17 +1039,16 @@ fn into_layout(image: &Arc<Image>, layout: VkImageLayout) -> Result<()> {
     Ok(())
 }
 
-fn copy_buffer_to_image<T: ReprC + Send + Sync + 'static>(
+fn copy_buffers_to_image<'a, T: ReprC + Send + Sync + 'static>(
     device: &Arc<Device>,
     queue: &Arc<Mutex<Queue>>,
-    buffer: &Arc<Buffer<T>>,
+    buffers: impl ExactSizeIterator<Item = &'a Arc<Buffer<T>>>,
     image: &Arc<Image>,
-    layer: u32,
 ) -> Result<()>
 where
     T: Copy,
 {
-    debug_assert!(layer < image.layers);
+    debug_assert!(buffers.len() < image.layers as usize);
 
     // create a new command buffer
     let command_buffer = CommandBuffer::new_primary().build(device.clone(), queue.clone())?;
@@ -1052,27 +1059,8 @@ where
             VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
         ))?;
 
-        // copy info for copying the content of the buffer into the image
-        let buffer_image_copy = VkBufferImageCopy {
-            bufferOffset: 0,
-            bufferRowLength: 0,
-            bufferImageHeight: 0,
-            imageSubresource: VkImageSubresourceLayers {
-                aspectMask: VK_IMAGE_ASPECT_COLOR_BIT.into(),
-                mipLevel: 0,
-                baseArrayLayer: layer,
-                layerCount: 1,
-            },
-            imageOffset: VkOffset3D { x: 0, y: 0, z: 0 },
-            imageExtent: VkExtent3D {
-                width: image.width(),
-                height: image.height(),
-                depth: 1,
-            },
-        };
-
         // subresource information
-        let mut subresource_range = VkImageSubresourceRange {
+        let subresource_range = VkImageSubresourceRange {
             aspectMask: VK_IMAGE_ASPECT_COLOR_BIT.into(),
             baseMipLevel: 0,
             levelCount: image.levels(),
@@ -1087,6 +1075,26 @@ where
             subresource_range.clone(),
         );
 
+        for (layer, buffer) in buffers.enumerate() {
+            // copy info for copying the content of the buffer into the image
+            let buffer_image_copy = VkBufferImageCopy {
+                bufferOffset: 0,
+                bufferRowLength: 0,
+                bufferImageHeight: 0,
+                imageSubresource: VkImageSubresourceLayers {
+                    aspectMask: VK_IMAGE_ASPECT_COLOR_BIT.into(),
+                    mipLevel: 0,
+                    baseArrayLayer: layer as u32,
+                    layerCount: 1,
+                },
+                imageOffset: VkOffset3D { x: 0, y: 0, z: 0 },
+                imageExtent: VkExtent3D {
+                    width: image.width(),
+                    height: image.height(),
+                    depth: 1,
+                },
+            };
+
             // the actual copy command
             buffer_recorder.copy_buffer_to_image(
                 buffer,
@@ -1094,9 +1102,7 @@ where
                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 &[buffer_image_copy],
             );
-
+        }
-        // just transition one mip level at a time
-        subresource_range.levelCount = 1;
 
         // mip map creation
         if image.levels() > 1 {
@@ -1279,7 +1285,7 @@ fn blit_mip_maps(
         baseMipLevel: 0,
         levelCount: 1,
         baseArrayLayer: 0,
-        layerCount: 1,
+        layerCount: image.layers(),
     };
 
     for i in 1..image.levels() {