Preliminary implementation

Author: opstic

examples/features/src/msaa_line/mod.rs

@@ -112,7 +112,7 @@ impl Example {
             sample_count,
             dimension: wgpu::TextureDimension::D2,
             format: config.view_formats[0],
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TRANSIENT,
             label: None,
             view_formats: &[],
         };
@@ -128,6 +128,10 @@ impl crate::framework::Example for Example {
         wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
     }
 
+    fn required_features() -> wgpu::Features {
+        wgpu::Features::TRANSIENT_ATTACHMENTS
+    }
+
     fn init(
         config: &wgpu::SurfaceConfiguration,
         _adapter: &wgpu::Adapter,
@@ -214,6 +218,17 @@ impl crate::framework::Example for Example {
         }
     }
 
+    fn resize(
+        &mut self,
+        config: &wgpu::SurfaceConfiguration,
+        device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) {
+        self.config = config.clone();
+        self.multisampled_framebuffer =
+            Example::create_multisampled_framebuffer(device, config, self.sample_count);
+    }
+
     #[expect(clippy::single_match)]
     fn update(&mut self, event: winit::event::WindowEvent) {
         match event {
@@ -246,17 +261,6 @@ impl crate::framework::Example for Example {
         }
     }
 
-    fn resize(
-        &mut self,
-        config: &wgpu::SurfaceConfiguration,
-        device: &wgpu::Device,
-        _queue: &wgpu::Queue,
-    ) {
-        self.config = config.clone();
-        self.multisampled_framebuffer =
-            Example::create_multisampled_framebuffer(device, config, self.sample_count);
-    }
-
     fn render(&mut self, view: &wgpu::TextureView, device: &wgpu::Device, queue: &wgpu::Queue) {
         if self.rebuild_bundle {
             self.bundle = Example::create_bundle(

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/instance.rs

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

wgpu-hal/src/lib.rs

@@ -1675,6 +1675,9 @@ bitflags!(
         const COPY_SRC = 1 << 15;
         /// Format can be copied to.
         const COPY_DST = 1 << 16;
+
+        /// Format can be created as transient.
+        const TRANSIENT = 1 << 17;
     }
 );
 

wgpu-hal/src/metal/adapter.rs

@@ -149,7 +149,7 @@ impl crate::Adapter for super::Adapter {
             | msaa_count
             | Tfc::MULTISAMPLE_RESOLVE;
 
-        let extra = match format {
+        let mut extra = match format {
             Tf::R8Unorm | Tf::R16Float | Tf::Rgba8Unorm | Tf::Rgba16Float => {
                 read_write_tier2_if | all_caps
             }
@@ -352,6 +352,11 @@ impl crate::Adapter for super::Adapter {
             }
         };
 
+        extra.set(
+            Tfc::TRANSIENT,
+            self.shared.private_caps.supports_memoryless_storage,
+        );
+
         Tfc::COPY_SRC | Tfc::COPY_DST | Tfc::SAMPLED | Tfc::STORAGE_READ_ONLY | extra
     }
 
@@ -902,6 +907,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),
         }
     }
 
@@ -1001,6 +1007,8 @@ impl super::PrivateCapabilities {
             features.insert(F::SUBGROUP | F::SUBGROUP_BARRIER);
         }
 
+        features.set(F::TRANSIENT_ATTACHMENTS, self.supports_memoryless_storage);
+
         features
     }
 

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.features.contains(wgt::Features::TRANSIENT_ATTACHMENTS)
+            {
+                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/adapter.rs

@@ -560,7 +560,8 @@ impl PhysicalDeviceFeatures {
             | F::PIPELINE_CACHE
             | F::SHADER_EARLY_DEPTH_TEST
             | F::TEXTURE_ATOMIC
-            | F::EXPERIMENTAL_PASSTHROUGH_SHADERS;
+            | F::EXPERIMENTAL_PASSTHROUGH_SHADERS
+            | F::TRANSIENT_ATTACHMENTS;
 
         let mut dl_flags = Df::COMPUTE_SHADERS
             | Df::BASE_VERTEX
@@ -2445,7 +2446,7 @@ impl crate::Adapter for super::Adapter {
         };
         let features = properties.optimal_tiling_features;
 
-        let mut flags = Tfc::empty();
+        let mut flags = Tfc::TRANSIENT;
         flags.set(
             Tfc::SAMPLED,
             features.contains(vk::FormatFeatureFlags::SAMPLED_IMAGE),

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

@@ -1264,13 +1264,19 @@ impl crate::Device for super::Device {
                 unsafe { self.shared.raw.destroy_image(image.raw, None) };
             })?;
 
+        let mut alloc_usage = gpu_alloc::UsageFlags::FAST_DEVICE_ACCESS;
+        alloc_usage.set(
+            gpu_alloc::UsageFlags::TRANSIENT,
+            desc.usage.contains(wgt::TextureUses::TRANSIENT),
+        );
+
         let block = unsafe {
             self.mem_allocator.lock().alloc(
                 &*self.shared,
                 gpu_alloc::Request {
                     size: image.requirements.size,
                     align_mask: image.requirements.alignment - 1,
-                    usage: gpu_alloc::UsageFlags::FAST_DEVICE_ACCESS,
+                    usage: alloc_usage,
                     memory_types: image.requirements.memory_type_bits & self.valid_ash_memory_types,
                 },
             )