refactor textureLoad for texture formats

Author: greggman

src/webgpu/gpu_test.ts

@@ -631,6 +631,19 @@ export class GPUTestBase extends Fixture<GPUTestSubcaseBatchState> {
     }
   }
 
+  skipIfTextureLoadNotSupportedForTextureType(...types: (string | undefined | null)[]) {
+    if (this.isCompatibility) {
+      for (const type of types) {
+        switch (type) {
+          case 'texture_depth_2d':
+          case 'texture_depth_2d_array':
+          case 'texture_depth_multisampled_2d':
+            this.skip(`${type} is not supported by textureLoad in compatibility mode`);
+        }
+      }
+    }
+  }
+
   skipIfTextureFormatNotUsableAsStorageTexture(...formats: (GPUTextureFormat | undefined)[]) {
     for (const format of formats) {
       if (format && !isTextureFormatUsableAsStorageFormat(this.device, format)) {

src/webgpu/shader/execution/expression/call/builtin/textureLoad.spec.ts

@@ -21,16 +21,15 @@ import { makeTestGroup } from '../../../../../../common/framework/test_group.js'
 import {
   isCompressedFloatTextureFormat,
   isDepthTextureFormat,
-  isMultisampledTextureFormatDeprecated,
-  isStencilTextureFormat,
-  kDepthStencilFormats,
   kAllTextureFormats,
-  kTextureFormatInfo,
   textureDimensionAndFormatCompatible,
+  isCompressedTextureFormat,
+  kPossibleMultisampledTextureFormats,
+  kDepthTextureFormats,
+  kPossibleStorageTextureFormats,
 } from '../../../../../format_info.js';
 import { AllFeaturesMaxLimitsGPUTest, GPUTest } from '../../../../../gpu_test.js';
 import { maxMipLevelCount, virtualMipSize } from '../../../../../util/texture/base.js';
-import { TexelFormats } from '../../../../types.js';
 
 import {
   TextureCall,
@@ -101,19 +100,15 @@ Parameters:
       .combine('format', kAllTextureFormats)
       .filter(t => textureDimensionAndFormatCompatible('1d', t.format))
       // 1d textures can't have a height !== 1
-      .filter(t => kTextureFormatInfo[t.format].blockHeight === 1)
+      .filter(t => !isCompressedTextureFormat(t.format))
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
       .combine('L', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    t.skipIfTextureFormatNotSupportedDeprecated(format);
-    t.selectDeviceForTextureFormatOrSkipTestCase(t.params.format);
-  })
   .fn(async t => {
     const { format, stage, C, L, samplePoints } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
 
     // We want at least 4 blocks or something wide enough for 3 mip levels.
     const [width] = chooseTextureSize({ minSize: 8, minBlocks: 4, format });
@@ -192,13 +187,9 @@ Parameters:
       .combine('C', ['i32', 'u32'] as const)
       .combine('L', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    t.skipIfTextureFormatNotSupportedDeprecated(format);
-    t.selectDeviceForTextureFormatOrSkipTestCase(t.params.format);
-  })
   .fn(async t => {
     const { format, stage, samplePoints, C, L } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
 
     // We want at least 4 blocks or something wide enough for 3 mip levels.
     const size = chooseTextureSize({ minSize: 8, minBlocks: 4, format });
@@ -275,13 +266,9 @@ Parameters:
       .combine('C', ['i32', 'u32'] as const)
       .combine('L', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    const { format } = t.params;
-    t.skipIfTextureFormatNotSupportedDeprecated(format);
-    t.selectDeviceForTextureFormatOrSkipTestCase(t.params.format);
-  })
   .fn(async t => {
     const { format, stage, samplePoints, C, L } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
 
     // We want at least 4 blocks or something wide enough for 3 mip levels.
     const size = chooseTextureSize({ minSize: 8, minBlocks: 4, format, viewDimension: '3d' });
@@ -358,9 +345,7 @@ Parameters:
         'texture_multisampled_2d',
         'texture_depth_multisampled_2d',
       ] as const)
-      .combine('format', kAllTextureFormats)
-      .filter(t => isMultisampledTextureFormatDeprecated(t.format, false))
-      .filter(t => !isStencilTextureFormat(t.format))
+      .combine('format', kPossibleMultisampledTextureFormats)
       // Filter out texture_depth_multisampled_2d with non-depth formats
       .filter(
         t =>
@@ -371,14 +356,11 @@ Parameters:
       .combine('C', ['i32', 'u32'] as const)
       .combine('S', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    const { format, texture_type } = t.params;
-    t.skipIfTextureFormatNotSupportedDeprecated(format);
-    t.skipIfTextureLoadNotSupportedForTextureTypeDeprecated(texture_type);
-    t.skipIfMultisampleNotSupportedForFormatDeprecated(format);
-  })
   .fn(async t => {
     const { texture_type, format, stage, samplePoints, C, S } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureLoadNotSupportedForTextureType(texture_type);
+    t.skipIfTextureFormatNotMultisampled(format);
 
     const sampleCount = 4;
     const descriptor: GPUTextureDescriptor = {
@@ -446,20 +428,16 @@ Parameters:
   .params(u =>
     u
       .combine('stage', kShortShaderStages)
-      .combine('format', kDepthStencilFormats)
-      // filter out stencil only formats
-      .filter(t => isDepthTextureFormat(t.format))
+      .combine('format', kDepthTextureFormats)
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
       .combine('L', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    t.skipIfTextureLoadNotSupportedForTextureTypeDeprecated('texture_depth_2d');
-    t.selectDeviceForTextureFormatOrSkipTestCase(t.params.format);
-  })
   .fn(async t => {
     const { format, stage, samplePoints, C, L } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureLoadNotSupportedForTextureType('texture_depth_2d');
 
     // We want at least 4 blocks or something wide enough for 3 mip levels.
     const size = chooseTextureSize({ minSize: 8, minBlocks: 4, format });
@@ -623,14 +601,10 @@ Parameters:
       ] as const)
       .combine('depthOrArrayLayers', [1, 8] as const)
   )
-  .beforeAllSubcases(t => {
-    const { format, texture_type } = t.params;
-    t.skipIfTextureFormatNotSupportedDeprecated(format);
-    t.skipIfTextureLoadNotSupportedForTextureTypeDeprecated(texture_type);
-    t.selectDeviceForTextureFormatOrSkipTestCase(format);
-  })
   .fn(async t => {
     const { texture_type, format, stage, samplePoints, C, A, L, depthOrArrayLayers } = t.params;
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureLoadNotSupportedForTextureType(texture_type);
 
     // We want at least 4 blocks or something wide enough for 3 mip levels.
     const [width, height] = chooseTextureSize({ minSize: 8, minBlocks: 4, format });
@@ -702,22 +676,18 @@ Parameters:
   .params(u =>
     u
       .combine('stage', kShortShaderStages)
-      .combineWithParams([...TexelFormats, { format: 'bgra8unorm' }] as const)
+      .combine('format', kPossibleStorageTextureFormats)
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    t.skipIf(!t.hasLanguageFeature('readonly_and_readwrite_storage_textures'));
-    if (t.params.format === 'bgra8unorm') {
-      t.selectDeviceOrSkipTestCase('bgra8unorm-storage');
-    } else {
-      t.skipIfTextureFormatNotUsableAsStorageTextureDeprecated(t.params.format as GPUTextureFormat);
-    }
-  })
+  .beforeAllSubcases(t =>
+    t.skipIfLanguageFeatureNotSupported('readonly_and_readwrite_storage_textures')
+  )
   .fn(async t => {
     const { format, stage, samplePoints, C } = t.params;
 
+    t.skipIfTextureFormatNotUsableAsStorageTexture(format);
     skipIfStorageTexturesNotSupportedInStage(t, stage);
 
     // We want at least 3 blocks or something wide enough for 3 mip levels.
@@ -783,22 +753,19 @@ Parameters:
   .params(u =>
     u
       .combine('stage', kShortShaderStages)
-      .combineWithParams([...TexelFormats, { format: 'bgra8unorm' }] as const)
+      .combine('format', kPossibleStorageTextureFormats)
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
   )
-  .beforeAllSubcases(t => {
-    t.skipIf(!t.hasLanguageFeature('readonly_and_readwrite_storage_textures'));
-    if (t.params.format === 'bgra8unorm') {
-      t.selectDeviceOrSkipTestCase('bgra8unorm-storage');
-    } else {
-      t.skipIfTextureFormatNotUsableAsStorageTextureDeprecated(t.params.format as GPUTextureFormat);
-    }
-  })
+  .beforeAllSubcases(t =>
+    t.skipIfLanguageFeatureNotSupported('readonly_and_readwrite_storage_textures')
+  )
   .fn(async t => {
     const { format, stage, samplePoints, C } = t.params;
 
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatNotUsableAsStorageTexture(format);
     skipIfStorageTexturesNotSupportedInStage(t, stage);
 
     // We want at least 3 blocks or something wide enough for 3 mip levels.
@@ -864,24 +831,21 @@ Parameters:
   .params(u =>
     u
       .combine('stage', kShortShaderStages)
-      .combineWithParams([...TexelFormats, { format: 'bgra8unorm' }] as const)
+      .combine('format', kPossibleStorageTextureFormats)
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
       .combine('A', ['i32', 'u32'] as const)
       .combine('depthOrArrayLayers', [1, 8] as const)
   )
-  .beforeAllSubcases(t => {
-    t.skipIf(!t.hasLanguageFeature('readonly_and_readwrite_storage_textures'));
-    if (t.params.format === 'bgra8unorm') {
-      t.selectDeviceOrSkipTestCase('bgra8unorm-storage');
-    } else {
-      t.skipIfTextureFormatNotUsableAsStorageTextureDeprecated(t.params.format as GPUTextureFormat);
-    }
-  })
+  .beforeAllSubcases(t =>
+    t.skipIfLanguageFeatureNotSupported('readonly_and_readwrite_storage_textures')
+  )
   .fn(async t => {
     const { format, stage, samplePoints, C, A, depthOrArrayLayers } = t.params;
 
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatNotUsableAsStorageTexture(format);
     skipIfStorageTexturesNotSupportedInStage(t, stage);
 
     // We want at least 3 blocks or something wide enough for 3 mip levels.
@@ -952,22 +916,19 @@ Parameters:
   .params(u =>
     u
       .combine('stage', kShortShaderStages)
-      .combineWithParams([...TexelFormats, { format: 'bgra8unorm' }] as const)
+      .combine('format', kPossibleStorageTextureFormats)
       .beginSubcases()
       .combine('samplePoints', kSamplePointMethods)
       .combine('C', ['i32', 'u32'] as const)
   )
   .beforeAllSubcases(t => {
-    t.skipIf(!t.hasLanguageFeature('readonly_and_readwrite_storage_textures'));
-    if (t.params.format === 'bgra8unorm') {
-      t.selectDeviceOrSkipTestCase('bgra8unorm-storage');
-    } else {
-      t.skipIfTextureFormatNotUsableAsStorageTextureDeprecated(t.params.format as GPUTextureFormat);
-    }
+    t.skipIfLanguageFeatureNotSupported('readonly_and_readwrite_storage_textures');
   })
   .fn(async t => {
     const { format, stage, samplePoints, C } = t.params;
 
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatNotUsableAsStorageTexture(format);
     skipIfStorageTexturesNotSupportedInStage(t, stage);
 
     // We want at least 3 blocks or something wide enough for 3 mip levels.

src/webgpu/util/texture.ts

@@ -114,6 +114,11 @@ const kLoadValueFromStorageInfo: Partial<{
     texelType: 'vec4i',
     unpackWGSL: 'return unpack4xI8(getSrc(byteOffset / 4))',
   },
+  rg11b10ufloat: {
+    storageType: 'u32',
+    texelType: 'vec4f',
+    unpackWGSL: `return unpackRG11B10UFloat(getSrc(byteOffset / 4))`,
+  },
   r16float: {
     storageType: 'u32',
     texelType: 'vec4f',
@@ -308,6 +313,53 @@ function getCopyBufferToTextureViaRenderCode(
       return textureLoad(src, vec2u(x, y), 0).r;
     }
 
+    const kFloat32FormatMantissaBits = 23;
+    const kFloat32FormatBias = 127;
+    fn floatBitsToNumber(
+        rawBits: u32,
+        bitOffset: u32,
+        exponentBits: u32,
+        mantissaBits: u32,
+        bias: u32,
+        signed: bool) -> f32 {
+      let nonSignBits = exponentBits + mantissaBits;
+      let allBits = nonSignBits + select(0u, 1u, signed);
+      let allMask = (1u << allBits) - 1u;
+      let bits = (rawBits >> bitOffset) & allMask;
+      let nonSignBitsMask = (1u << nonSignBits) - 1u;
+      let exponentAndMantissaBits = bits & nonSignBitsMask;
+      let exponentMask = ((1u << exponentBits) - 1u) << mantissaBits;
+      let infinityOrNaN = (bits & exponentMask) == exponentMask;
+      if (infinityOrNaN) {
+        let mantissaMask = (1u << mantissaBits) - 1;
+        let signBit = 1u << nonSignBits;
+        let isNegative = (bits & signBit) != 0;
+        if ((bits & mantissaMask) != 0u) {
+          return 0.0; // NaN (does not exist in WGSL)
+        }
+        if (isNegative) {
+          return f32(-2e38); // NEGATIVE_INFINITY (does not exist in WGSL)
+        } else {
+          return f32(2e38); // POSITIVE_INFINITY (does not exist in WGSL)
+        }
+      }
+      var f32BitsWithWrongBias =
+        exponentAndMantissaBits << (kFloat32FormatMantissaBits - mantissaBits);
+      // add in the sign
+      f32BitsWithWrongBias |= (bits << (31u - nonSignBits)) & 0x80000000u;
+      let numberWithWrongBias = bitcast<f32>(f32BitsWithWrongBias);
+      return numberWithWrongBias * pow(2.0f, f32(kFloat32FormatBias - bias));
+    }
+
+    fn unpackRG11B10UFloat(v: u32) -> vec4f {
+      return vec4f(
+        floatBitsToNumber(v,  0, 5, 6, 15, false),
+        floatBitsToNumber(v, 11, 5, 6, 15, false),
+        floatBitsToNumber(v, 22, 5, 5, 15, false),
+        1
+      );
+    }
+
     fn unpack(byteOffset: u32) -> ${texelType} {
       ${unpackWGSL};
     }