Add feature float32-filterable

deno_webgpu/01_webgpu.js

@@ -5164,6 +5164,7 @@ webidl.converters["GPUFeatureName"] = webidl.createEnumConverter(
     "texture-compression-astc",
     "rg11b10ufloat-renderable",
     "bgra8unorm-storage",
+    "float32-filterable",
 
     // extended from spec
 

deno_webgpu/lib.rs

@@ -266,6 +266,9 @@ fn deserialize_features(features: &wgpu_types::Features) -> Vec<&'static str> {
     if features.contains(wgpu_types::Features::BGRA8UNORM_STORAGE) {
         return_features.push("bgra8unorm-storage");
     }
+    if features.contains(wgpu_types::Features::FLOAT32_FILTERABLE) {
+        return_features.push("float32-filterable");
+    }
 
     // extended from spec
 
@@ -498,6 +501,10 @@ impl From<GpuRequiredFeatures> for wgpu_types::Features {
             wgpu_types::Features::BGRA8UNORM_STORAGE,
             required_features.0.contains("bgra8unorm-storage"),
         );
+        features.set(
+            wgpu_types::Features::FLOAT32_FILTERABLE,
+            required_features.0.contains("float32-filterable"),
+        );
 
         // extended from spec
 

deno_webgpu/webgpu.idl

@@ -103,6 +103,7 @@ enum GPUFeatureName {
     "shader-f16",
     "rg11b10ufloat-renderable",
     "bgra8unorm-storage",
+    "float32-filterable",
 
     // extended from spec
 

tests/tests/bgra8unorm_storage.rs

@@ -1,4 +1,4 @@
-//! Tests for texture copy bounds checks.
+//! Tests for BGRA8UNORM_STORAGE feature
 
 use std::borrow::Cow;
 

tests/tests/float32_filterable.rs

@@ -0,0 +1,83 @@
+//! Tests for FLOAT32_FILTERABLE feature.
+
+use wgpu_test::{fail, gpu_test, GpuTestConfiguration, TestParameters};
+
+fn create_texture_binding(device: &wgpu::Device, format: wgpu::TextureFormat, filterable: bool) {
+    let texture = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 256,
+            height: 256,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    });
+
+    let view = texture.create_view(&wgpu::TextureViewDescriptor {
+        label: None,
+        format: None,
+        dimension: None,
+        aspect: wgpu::TextureAspect::All,
+        base_mip_level: 0,
+        base_array_layer: 0,
+        mip_level_count: Some(1),
+        array_layer_count: Some(1),
+    });
+
+    let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: None,
+        entries: &[wgpu::BindGroupLayoutEntry {
+            binding: 0,
+            visibility: wgpu::ShaderStages::FRAGMENT,
+            ty: wgpu::BindingType::Texture {
+                sample_type: wgpu::TextureSampleType::Float { filterable },
+                multisampled: false,
+                view_dimension: wgpu::TextureViewDimension::D2,
+            },
+            count: None,
+        }],
+    });
+
+    let _bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: None,
+        layout: &bgl,
+        entries: &[wgpu::BindGroupEntry {
+            binding: 0,
+            resource: wgpu::BindingResource::TextureView(&view),
+        }],
+    });
+}
+
+#[gpu_test]
+static FLOAT32_FILTERABLE_WITHOUT_FEATURE: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(TestParameters::default())
+    .run_sync(|ctx| {
+        let device = &ctx.device;
+        // Unorm textures are always filterable
+        create_texture_binding(device, wgpu::TextureFormat::R8Unorm, true);
+        create_texture_binding(device, wgpu::TextureFormat::R8Unorm, false);
+        // As are float16 textures
+        create_texture_binding(device, wgpu::TextureFormat::R16Float, true);
+        create_texture_binding(device, wgpu::TextureFormat::R16Float, false);
+        // Float 32 textures can be used as non-filterable only
+        create_texture_binding(device, wgpu::TextureFormat::R32Float, false);
+        fail(&ctx.device, || {
+            create_texture_binding(device, wgpu::TextureFormat::R32Float, true);
+        });
+    });
+
+#[gpu_test]
+static FLOAT32_FILTERABLE_WITH_FEATURE: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(TestParameters::default().features(wgpu::Features::FLOAT32_FILTERABLE))
+    .run_sync(|ctx| {
+        let device = &ctx.device;
+        // With the feature enabled, it does work!
+        create_texture_binding(device, wgpu::TextureFormat::R32Float, true);
+        create_texture_binding(device, wgpu::TextureFormat::Rg32Float, true);
+        create_texture_binding(device, wgpu::TextureFormat::Rgba32Float, true);
+    });

tests/tests/root.rs

@@ -15,6 +15,7 @@ mod create_surface_error;
 mod device;
 mod encoder;
 mod external_texture;
+mod float32_filterable;
 mod instance;
 mod life_cycle;
 mod mem_leaks;

wgpu-hal/src/dx11/adapter.rs

@@ -155,6 +155,10 @@ impl super::Adapter {
         // bgra8unorm-storage is never supported on dx11 according to:
         // https://learn.microsoft.com/en-us/windows/win32/direct3ddxgi/format-support-for-direct3d-11-0-feature-level-hardware#dxgi_format_b8g8r8a8_unormfcs-87
 
+        // float32-filterable should always be available on dx11
+        // https://learn.microsoft.com/en-us/windows/win32/direct3ddxgi/format-support-for-direct3d-11-0-feature-level-hardware#dxgi_format_r32g32b32a32_floatfcs-2
+        features.set(wgt::Features::FLOAT32_FILTERABLE, true);
+
         //
         // Fill out limits and alignments
         //

wgpu-hal/src/dx12/adapter.rs

@@ -293,6 +293,9 @@ impl super::Adapter {
             bgra8unorm_storage_supported,
         );
 
+        // float32-filterable should always be available on d3d12
+        features.set(wgt::Features::FLOAT32_FILTERABLE, true);
+
         // TODO: Determine if IPresentationManager is supported
         let presentation_timer = auxil::dxgi::time::PresentationTimer::new_dxgi();
 

wgpu-hal/src/gles/adapter.rs

@@ -549,6 +549,13 @@ impl super::Adapter {
             );
         }
 
+        features.set(
+            wgt::Features::FLOAT32_FILTERABLE,
+            extensions.contains("GL_ARB_color_buffer_float")
+                || extensions.contains("GL_EXT_color_buffer_float")
+                || extensions.contains("OES_texture_float_linear"),
+        );
+
         // We *might* be able to emulate bgra8unorm-storage but currently don't attempt to.
 
         let mut private_caps = super::PrivateCapabilities::empty();

wgpu-hal/src/metal/adapter.rs

@@ -612,6 +612,9 @@ impl super::PrivateCapabilities {
             function_specialization: Self::supports_any(device, FUNCTION_SPECIALIZATION_SUPPORT),
             depth_clip_mode: Self::supports_any(device, DEPTH_CLIP_MODE),
             texture_cube_array: Self::supports_any(device, TEXTURE_CUBE_ARRAY_SUPPORT),
+            supports_float_filtering: os_is_mac
+                || (version.at_least((11, 0), (14, 0), os_is_mac)
+                    && device.supports_32bit_float_filtering()),
             format_depth24_stencil8: os_is_mac && device.d24_s8_supported(),
             format_depth32_stencil8_filter: os_is_mac,
             format_depth32_stencil8_none: !os_is_mac,
@@ -829,6 +832,7 @@ impl super::PrivateCapabilities {
             | F::DEPTH32FLOAT_STENCIL8
             | F::BGRA8UNORM_STORAGE;
 
+        features.set(F::FLOAT32_FILTERABLE, self.supports_float_filtering);
         features.set(
             F::INDIRECT_FIRST_INSTANCE | F::MULTI_DRAW_INDIRECT,
             self.indirect_draw_dispatch,

wgpu-hal/src/metal/mod.rs

@@ -191,6 +191,7 @@ struct PrivateCapabilities {
     function_specialization: bool,
     depth_clip_mode: bool,
     texture_cube_array: bool,
+    supports_float_filtering: bool,
     format_depth24_stencil8: bool,
     format_depth32_stencil8_filter: bool,
     format_depth32_stencil8_none: bool,

wgpu-hal/src/vulkan/adapter.rs

@@ -535,6 +535,11 @@ impl PhysicalDeviceFeatures {
             supports_bgra8unorm_storage(instance, phd, caps.device_api_version),
         );
 
+        features.set(
+            F::FLOAT32_FILTERABLE,
+            is_float32_filterable_supported(instance, phd),
+        );
+
         (features, dl_flags)
     }
 
@@ -1756,6 +1761,21 @@ fn is_format_16bit_norm_supported(instance: &ash::Instance, phd: vk::PhysicalDev
     r16unorm && r16snorm && rg16unorm && rg16snorm && rgba16unorm && rgba16snorm
 }
 
+fn is_float32_filterable_supported(instance: &ash::Instance, phd: vk::PhysicalDevice) -> bool {
+    let tiling = vk::ImageTiling::OPTIMAL;
+    let features = vk::FormatFeatureFlags::SAMPLED_IMAGE_FILTER_LINEAR;
+    let r_float = supports_format(instance, phd, vk::Format::R32_SFLOAT, tiling, features);
+    let rg_float = supports_format(instance, phd, vk::Format::R32G32_SFLOAT, tiling, features);
+    let rgba_float = supports_format(
+        instance,
+        phd,
+        vk::Format::R32G32B32A32_SFLOAT,
+        tiling,
+        features,
+    );
+    r_float && rg_float && rgba_float
+}
+
 fn supports_format(
     instance: &ash::Instance,
     phd: vk::PhysicalDevice,

wgpu-types/src/lib.rs

@@ -337,7 +337,18 @@ bitflags::bitflags! {
 
         // ? const NORM16_FILTERABLE = 1 << 17; (https://github.com/gpuweb/gpuweb/issues/3839)
         // ? const NORM16_RESOLVE = 1 << 18; (https://github.com/gpuweb/gpuweb/issues/3839)
-        // TODO const FLOAT32_FILTERABLE = 1 << 19;
+
+        /// Allows textures with formats "r32float", "rg32float", and "rgba32float" to be filterable.
+        ///
+        /// Supported Platforms:
+        /// - Vulkan (mainly on Desktop GPUs)
+        /// - DX12
+        /// - Metal on macOS or Apple9+ GPUs, optional on iOS/iPadOS with Apple7/8 GPUs
+        /// - GL with one of `GL_ARB_color_buffer_float`/`GL_EXT_color_buffer_float`/`OES_texture_float_linear`
+        ///
+        /// This is a web and native feature.
+        const FLOAT32_FILTERABLE = 1 << 19;
+
         // ? const FLOAT32_BLENDABLE = 1 << 20; (https://github.com/gpuweb/gpuweb/issues/3556)
         // ? const 32BIT_FORMAT_MULTISAMPLE = 1 << 21; (https://github.com/gpuweb/gpuweb/issues/3844)
         // ? const 32BIT_FORMAT_RESOLVE = 1 << 22; (https://github.com/gpuweb/gpuweb/issues/3844)
@@ -3173,10 +3184,15 @@ impl TextureFormat {
             Self::Astc { .. } =>          (        noaa,      basic),
         };
 
-        let is_filterable =
-            self.sample_type(None) == Some(TextureSampleType::Float { filterable: true });
+        let sample_type = self.sample_type(None);
+        let mut is_filterable = sample_type == Some(TextureSampleType::Float { filterable: true });
+        let is_blendable = is_filterable;
+        if device_features.contains(Features::FLOAT32_FILTERABLE) {
+            is_filterable |= sample_type == Some(TextureSampleType::Float { filterable: false });
+        }
+
         flags.set(TextureFormatFeatureFlags::FILTERABLE, is_filterable);
-        flags.set(TextureFormatFeatureFlags::BLENDABLE, is_filterable);
+        flags.set(TextureFormatFeatureFlags::BLENDABLE, is_blendable);
 
         TextureFormatFeatures {
             allowed_usages,

wgpu/src/backend/web.rs

@@ -701,6 +701,10 @@ const FEATURES_MAPPING: [(wgt::Features, web_sys::GpuFeatureName); 10] = [
         wgt::Features::BGRA8UNORM_STORAGE,
         web_sys::GpuFeatureName::Bgra8unormStorage,
     ),
+    (
+        wgt::Features::FLOAT32_FILTERABLE,
+        web_sys::GpuFeatureName::Float32Filterable,
+    ),
 ];
 
 fn map_wgt_features(supported_features: web_sys::GpuSupportedFeatures) -> wgt::Features {