Add support for transient textures on Vulkan and Metal

CHANGELOG.md

@@ -166,6 +166,8 @@ By @cwfitzgerald in [#8162](https://github.com/gfx-rs/wgpu/pull/8162).
 
 - Added support for external textures based on WebGPU's [`GPUExternalTexture`](https://www.w3.org/TR/webgpu/#gpuexternaltexture). These allow shaders to transparently operate on potentially multiplanar source texture data in either RGB or YCbCr formats via WGSL's `texture_external` type. This is gated behind the `Features::EXTERNAL_TEXTURE` feature, which is currently only supported on DX12. By @jamienicol in [#4386](https://github.com/gfx-rs/wgpu/issues/4386).
 
+- Added support for transient textures on Vulkan and Metal, gated behind the `Features::TRANSIENT_ATTACHMENTS` feature. By @Opstic in [#8247](https://github.com/gfx-rs/wgpu/pull/8247)
+
 ### Changes
 
 #### General

wgpu-core/src/command/render.rs

@@ -625,6 +625,8 @@ pub enum ColorAttachmentError {
         mip_level: u32,
         depth_or_array_layer: u32,
     },
+    #[error("Color attachment's usage cannot contain {0:?} if StoreOp is {1:?}")]
+    InvalidUsageForStoreOp(TextureUsages, StoreOp),
 }
 
 impl WebGpuError for ColorAttachmentError {
@@ -1585,6 +1587,17 @@ impl Global {
                     let view = texture_views.get(*view_id).get()?;
                     view.same_device(device)?;
 
+                    if view.desc.usage.contains(TextureUsages::TRANSIENT)
+                        && *store_op != StoreOp::Discard
+                    {
+                        return Err(RenderPassErrorInner::ColorAttachment(
+                            ColorAttachmentError::InvalidUsageForStoreOp(
+                                TextureUsages::TRANSIENT,
+                                *store_op,
+                            ),
+                        ));
+                    }
+
                     let resolve_target = if let Some(resolve_target_id) = resolve_target {
                         let rt_arc = texture_views.get(*resolve_target_id).get()?;
                         rt_arc.same_device(device)?;

wgpu-core/src/conv.rs

@@ -124,6 +124,10 @@ pub fn map_texture_usage(
         wgt::TextureUses::STORAGE_ATOMIC,
         usage.contains(wgt::TextureUsages::STORAGE_ATOMIC),
     );
+    u.set(
+        wgt::TextureUses::TRANSIENT,
+        usage.contains(wgt::TextureUsages::TRANSIENT),
+    );
     u
 }
 
@@ -183,6 +187,10 @@ pub fn map_texture_usage_from_hal(uses: wgt::TextureUses) -> wgt::TextureUsages
         wgt::TextureUsages::STORAGE_ATOMIC,
         uses.contains(wgt::TextureUses::STORAGE_ATOMIC),
     );
+    u.set(
+        wgt::TextureUsages::TRANSIENT,
+        uses.contains(wgt::TextureUses::TRANSIENT),
+    );
     u
 }
 

wgpu-core/src/device/resource.rs

@@ -1262,6 +1262,17 @@ impl Device {
             }
         }
 
+        if desc.usage.contains(wgt::TextureUsages::TRANSIENT) {
+            let extra_usage =
+                desc.usage - wgt::TextureUsages::TRANSIENT - wgt::TextureUsages::RENDER_ATTACHMENT;
+            if !extra_usage.is_empty() {
+                return Err(CreateTextureError::IncompatibleUsage(
+                    wgt::TextureUsages::TRANSIENT,
+                    extra_usage,
+                ));
+            }
+        }
+
         let format_features = self
             .describe_format_features(desc.format)
             .map_err(|error| CreateTextureError::MissingFeatures(desc.format, error))?;

wgpu-core/src/instance.rs

@@ -706,6 +706,7 @@ impl Adapter {
             wgt::TextureUsages::STORAGE_ATOMIC,
             caps.contains(Tfc::STORAGE_ATOMIC),
         );
+        allowed_usages |= wgt::TextureUsages::TRANSIENT;
 
         let mut flags = wgt::TextureFormatFeatureFlags::empty();
         flags.set(

wgpu-core/src/resource.rs

@@ -1509,6 +1509,8 @@ pub enum CreateTextureError {
     CreateTextureView(#[from] CreateTextureViewError),
     #[error("Invalid usage flags {0:?}")]
     InvalidUsage(wgt::TextureUsages),
+    #[error("Texture usage {0:?} is not compatible with texture usage {1:?}")]
+    IncompatibleUsage(wgt::TextureUsages, wgt::TextureUsages),
     #[error(transparent)]
     InvalidDimension(#[from] TextureDimensionError),
     #[error("Depth texture ({1:?}) can't be created as {0:?}")]
@@ -1564,6 +1566,7 @@ impl WebGpuError for CreateTextureError {
             Self::MissingDownlevelFlags(e) => e,
 
             Self::InvalidUsage(_)
+            | Self::IncompatibleUsage(_, _)
             | Self::InvalidDepthDimension(_, _)
             | Self::InvalidCompressedDimension(_, _)
             | Self::InvalidMipLevelCount { .. }

wgpu-hal/src/metal/adapter.rs

@@ -902,6 +902,7 @@ impl super::PrivateCapabilities {
                 && (device.supports_family(MTLGPUFamily::Apple7)
                     || device.supports_family(MTLGPUFamily::Mac2)),
             supports_shared_event: version.at_least((10, 14), (12, 0), os_is_mac),
+            supports_memoryless_storage: version.at_least((11, 0), (10, 0), os_is_mac),
         }
     }
 

wgpu-hal/src/metal/device.rs

@@ -452,13 +452,21 @@ impl crate::Device for super::Device {
                 }
             };
 
+            let mtl_storage_mode = if desc.usage.contains(wgt::TextureUses::TRANSIENT)
+                && self.shared.private_caps.supports_memoryless_storage
+            {
+                MTLStorageMode::Memoryless
+            } else {
+                MTLStorageMode::Private
+            };
+
             descriptor.set_texture_type(mtl_type);
             descriptor.set_width(desc.size.width as u64);
             descriptor.set_height(desc.size.height as u64);
             descriptor.set_mipmap_level_count(desc.mip_level_count as u64);
             descriptor.set_pixel_format(mtl_format);
             descriptor.set_usage(conv::map_texture_usage(desc.format, desc.usage));
-            descriptor.set_storage_mode(MTLStorageMode::Private);
+            descriptor.set_storage_mode(mtl_storage_mode);
 
             let raw = self.shared.device.lock().new_texture(&descriptor);
             if raw.as_ptr().is_null() {

wgpu-hal/src/metal/mod.rs

@@ -300,6 +300,7 @@ struct PrivateCapabilities {
     int64_atomics: bool,
     float_atomics: bool,
     supports_shared_event: bool,
+    supports_memoryless_storage: bool,
 }
 
 #[derive(Clone, Debug)]

wgpu-hal/src/vulkan/conv.rs

@@ -259,6 +259,9 @@ pub fn map_texture_usage(usage: wgt::TextureUses) -> vk::ImageUsageFlags {
     ) {
         flags |= vk::ImageUsageFlags::STORAGE;
     }
+    if usage.contains(wgt::TextureUses::TRANSIENT) {
+        flags |= vk::ImageUsageFlags::TRANSIENT_ATTACHMENT;
+    }
     flags
 }
 
@@ -348,6 +351,9 @@ pub fn map_vk_image_usage(usage: vk::ImageUsageFlags) -> wgt::TextureUses {
             | wgt::TextureUses::STORAGE_READ_WRITE
             | wgt::TextureUses::STORAGE_ATOMIC;
     }
+    if usage.contains(vk::ImageUsageFlags::TRANSIENT_ATTACHMENT) {
+        bits |= wgt::TextureUses::TRANSIENT;
+    }
     bits
 }
 

wgpu-hal/src/vulkan/device.rs

@@ -648,7 +648,6 @@ impl super::Device {
         }
     }
 
-    #[cfg(windows)]
     fn find_memory_type_index(
         &self,
         type_bits_req: u32,
@@ -738,7 +737,17 @@ impl super::Device {
             // VK_ERROR_COMPRESSION_EXHAUSTED_EXT
             super::map_host_device_oom_and_ioca_err(err)
         }
-        let req = unsafe { self.shared.raw.get_image_memory_requirements(raw) };
+        let mut req = unsafe { self.shared.raw.get_image_memory_requirements(raw) };
+
+        if desc.usage.contains(wgt::TextureUses::TRANSIENT) {
+            let mem_type_index = self.find_memory_type_index(
+                req.memory_type_bits,
+                vk::MemoryPropertyFlags::LAZILY_ALLOCATED,
+            );
+            if let Some(mem_type_index) = mem_type_index {
+                req.memory_type_bits = 1 << mem_type_index;
+            }
+        }
 
         Ok(ImageWithoutMemory {
             raw,

wgpu-types/src/lib.rs

@@ -5610,6 +5610,8 @@ bitflags::bitflags! {
         //
         /// Allows a texture to be used with image atomics. Requires [`Features::TEXTURE_ATOMIC`].
         const STORAGE_ATOMIC = 1 << 16;
+        /// Allows a texture to be transient. No-op on platforms other than Vulkan and Metal.
+        const TRANSIENT = 1 << 17;
     }
 }
 
@@ -5664,6 +5666,8 @@ bitflags::bitflags! {
         /// Flag used by the wgpu-core texture tracker to say that the tracker does not know the state of the sub-resource.
         /// This is different from UNINITIALIZED as that says the tracker does know, but the texture has not been initialized.
         const UNKNOWN = 1 << 13;
+        /// Transient image.
+        const TRANSIENT = 1 << 14;
     }
 }