hal/vk: barriers and copies

wgpu-core/Cargo.toml

@@ -56,6 +56,9 @@ hal = { path = "../wgpu-hal", package = "wgpu-hal", features = ["metal"] }
 [target.'cfg(all(not(target_arch = "wasm32"), unix, not(target_os = "ios"), not(target_os = "macos")))'.dependencies]
 hal = { path = "../wgpu-hal", package = "wgpu-hal", features = ["vulkan"] }
 
+[target.'cfg(all(not(target_arch = "wasm32"), windows))'.dependencies]
+hal = { path = "../wgpu-hal", package = "wgpu-hal", features = ["vulkan"] }
+
 [dev-dependencies]
 loom = "0.3"
 

wgpu-hal/src/vulkan/adapter.rs

@@ -199,7 +199,7 @@ impl PhysicalDeviceFeatures {
             | F::ADDRESS_MODE_CLAMP_TO_BORDER
             | F::SAMPLED_TEXTURE_BINDING_ARRAY
             | F::BUFFER_BINDING_ARRAY;
-        let mut dl_flags = Df::COMPARISON_SAMPLERS;
+        let mut dl_flags = Df::all();
 
         dl_flags.set(Df::CUBE_ARRAY_TEXTURES, self.core.image_cube_array != 0);
         dl_flags.set(Df::ANISOTROPIC_FILTERING, self.core.sampler_anisotropy != 0);

wgpu-hal/src/vulkan/command.rs

@@ -1,8 +1,42 @@
-use std::ops::Range;
+use super::conv;
 
 use ash::{version::DeviceV1_0, vk};
+use inplace_it::inplace_or_alloc_from_iter;
+
+use std::ops::Range;
 
 const ALLOCATION_GRANULARITY: u32 = 16;
+const DST_IMAGE_LAYOUT: vk::ImageLayout = vk::ImageLayout::TRANSFER_DST_OPTIMAL;
+
+impl super::Texture {
+    fn map_buffer_copies<T>(&self, regions: T) -> impl Iterator<Item = vk::BufferImageCopy>
+    where
+        T: Iterator<Item = crate::BufferTextureCopy>,
+    {
+        let dim = self.dim;
+        let aspects = self.aspects;
+        let fi = self.format_info;
+        regions.map(move |r| {
+            let (layer_count, image_extent) = conv::map_extent(r.size, dim);
+            let (image_subresource, image_offset) =
+                conv::map_subresource_layers(&r.texture_base, dim, aspects, layer_count);
+            vk::BufferImageCopy {
+                buffer_offset: r.buffer_layout.offset,
+                buffer_row_length: r
+                    .buffer_layout
+                    .bytes_per_row
+                    .map_or(0, |bpr| bpr.get() / fi.block_size as u32),
+                buffer_image_height: r
+                    .buffer_layout
+                    .rows_per_image
+                    .map_or(0, |rpi| rpi.get() * fi.block_dimensions.1 as u32),
+                image_subresource,
+                image_offset,
+                image_extent,
+            }
+        })
+    }
+}
 
 impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
     unsafe fn begin_encoding(&mut self, label: crate::Label) -> Result<(), crate::DeviceError> {
@@ -53,23 +87,102 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
     where
         T: Iterator<Item = crate::BufferBarrier<'a, super::Api>>,
     {
+        let mut src_stages = vk::PipelineStageFlags::empty();
+        let mut dst_stages = vk::PipelineStageFlags::empty();
+        let vk_barrier_iter = barriers.map(move |bar| {
+            let (src_stage, src_access) = conv::map_buffer_usage_to_barrier(bar.usage.start);
+            src_stages |= src_stage;
+            let (dst_stage, dst_access) = conv::map_buffer_usage_to_barrier(bar.usage.end);
+            dst_stages |= dst_stage;
+
+            vk::BufferMemoryBarrier::builder()
+                .buffer(bar.buffer.raw)
+                .size(vk::WHOLE_SIZE)
+                .src_access_mask(src_access)
+                .dst_access_mask(dst_access)
+                .build()
+        });
+
+        inplace_or_alloc_from_iter(vk_barrier_iter, |vk_barriers| {
+            self.device.raw.cmd_pipeline_barrier(
+                self.active,
+                src_stages,
+                dst_stages,
+                vk::DependencyFlags::empty(),
+                &[],
+                vk_barriers,
+                &[],
+            );
+        });
     }
 
     unsafe fn transition_textures<'a, T>(&mut self, barriers: T)
     where
         T: Iterator<Item = crate::TextureBarrier<'a, super::Api>>,
     {
+        let mut src_stages = vk::PipelineStageFlags::empty();
+        let mut dst_stages = vk::PipelineStageFlags::empty();
+        let vk_barrier_iter = barriers.map(move |bar| {
+            let range = conv::map_subresource_range(&bar.range, bar.texture.aspects);
+            let (src_stage, src_access) = conv::map_texture_usage_to_barrier(bar.usage.start);
+            let src_layout = conv::derive_image_layout(bar.usage.start);
+            src_stages |= src_stage;
+            let (dst_stage, dst_access) = conv::map_texture_usage_to_barrier(bar.usage.end);
+            let dst_layout = conv::derive_image_layout(bar.usage.end);
+            dst_stages |= dst_stage;
+
+            vk::ImageMemoryBarrier::builder()
+                .image(bar.texture.raw)
+                .subresource_range(range)
+                .src_access_mask(src_access)
+                .dst_access_mask(dst_access)
+                .old_layout(src_layout)
+                .new_layout(dst_layout)
+                .build()
+        });
+
+        inplace_or_alloc_from_iter(vk_barrier_iter, |vk_barriers| {
+            self.device.raw.cmd_pipeline_barrier(
+                self.active,
+                src_stages,
+                dst_stages,
+                vk::DependencyFlags::empty(),
+                &[],
+                &[],
+                vk_barriers,
+            );
+        });
     }
 
     unsafe fn fill_buffer(&mut self, buffer: &super::Buffer, range: crate::MemoryRange, value: u8) {
+        self.device.raw.cmd_fill_buffer(
+            self.active,
+            buffer.raw,
+            range.start,
+            range.end - range.start,
+            (value as u32) * 0x01010101,
+        );
     }
 
     unsafe fn copy_buffer_to_buffer<T>(
         &mut self,
         src: &super::Buffer,
         dst: &super::Buffer,
         regions: T,
-    ) {
+    ) where
+        T: Iterator<Item = crate::BufferCopy>,
+    {
+        let vk_regions_iter = regions.map(|r| vk::BufferCopy {
+            src_offset: r.src_offset,
+            dst_offset: r.dst_offset,
+            size: r.size.get(),
+        });
+
+        inplace_or_alloc_from_iter(vk_regions_iter, |vk_regions| {
+            self.device
+                .raw
+                .cmd_copy_buffer(self.active, src.raw, dst.raw, vk_regions)
+        })
     }
 
     unsafe fn copy_texture_to_texture<T>(
@@ -78,15 +191,57 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
         src_usage: crate::TextureUse,
         dst: &super::Texture,
         regions: T,
-    ) {
+    ) where
+        T: Iterator<Item = crate::TextureCopy>,
+    {
+        let src_layout = conv::derive_image_layout(src_usage);
+
+        let vk_regions_iter = regions.map(|r| {
+            let (layer_count, extent) = conv::map_extent(r.size, src.dim);
+            let (src_subresource, src_offset) =
+                conv::map_subresource_layers(&r.src_base, src.dim, src.aspects, layer_count);
+            let (dst_subresource, dst_offset) =
+                conv::map_subresource_layers(&r.dst_base, dst.dim, dst.aspects, layer_count);
+            vk::ImageCopy {
+                src_subresource,
+                src_offset,
+                dst_subresource,
+                dst_offset,
+                extent,
+            }
+        });
+
+        inplace_or_alloc_from_iter(vk_regions_iter, |vk_regions| {
+            self.device.raw.cmd_copy_image(
+                self.active,
+                src.raw,
+                src_layout,
+                dst.raw,
+                DST_IMAGE_LAYOUT,
+                vk_regions,
+            );
+        });
     }
 
     unsafe fn copy_buffer_to_texture<T>(
         &mut self,
         src: &super::Buffer,
         dst: &super::Texture,
         regions: T,
-    ) {
+    ) where
+        T: Iterator<Item = crate::BufferTextureCopy>,
+    {
+        let vk_regions_iter = dst.map_buffer_copies(regions);
+
+        inplace_or_alloc_from_iter(vk_regions_iter, |vk_regions| {
+            self.device.raw.cmd_copy_buffer_to_image(
+                self.active,
+                src.raw,
+                dst.raw,
+                DST_IMAGE_LAYOUT,
+                vk_regions,
+            );
+        });
     }
 
     unsafe fn copy_texture_to_buffer<T>(
@@ -95,7 +250,21 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
         src_usage: crate::TextureUse,
         dst: &super::Buffer,
         regions: T,
-    ) {
+    ) where
+        T: Iterator<Item = crate::BufferTextureCopy>,
+    {
+        let src_layout = conv::derive_image_layout(src_usage);
+        let vk_regions_iter = src.map_buffer_copies(regions);
+
+        inplace_or_alloc_from_iter(vk_regions_iter, |vk_regions| {
+            self.device.raw.cmd_copy_image_to_buffer(
+                self.active,
+                src.raw,
+                src_layout,
+                dst.raw,
+                vk_regions,
+            );
+        });
     }
 
     unsafe fn begin_query(&mut self, set: &super::QuerySet, index: u32) {}
@@ -228,3 +397,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
     unsafe fn dispatch(&mut self, count: [u32; 3]) {}
     unsafe fn dispatch_indirect(&mut self, buffer: &super::Buffer, offset: wgt::BufferAddress) {}
 }
+
+#[test]
+fn check_dst_image_layout() {
+    assert_eq!(
+        conv::derive_image_layout(crate::TextureUse::COPY_DST),
+        DST_IMAGE_LAYOUT
+    );
+}