Add texture-component-swizzle tests (#4427)

* Add texture-component-swizzle tests

I removed the 3 stages and am only testing the fragment stage.
As for speed, with `debug` false it runs fast enough as is I
think. About 25 seconds for all tests on M1 Mac.

Note: One issue I ran into is the code that created textures
would potentially create them with RENDER_ATTACHMENT if they
needed to be rendered to to fill. A texture created with
RENDER_ATTACHMENT can't be swizzled. My solution was to change
the code that makes the texture such that, if the texture
had RENDER_ATTACHMENT added, and it can be copied texture to texture,
then make a copy without RENDER_ATTACHMENT

Another issue I ran into and I'm not sure what solution is better,
is testing depth-stencil formats. The existing code is not
designed for that. All the depth-stencil formats are "unencodable".
My solution was createTextureWithRandomDataAndGetTexelsForEachAspect
that returns 2 sets of TexelViews, one for the depth aspect,
another for the stencil aspec. It's possible, maybe we should
make those formats encodable as Texels? I didn't chose that becuase
depth-stencil has 2 types, f32 for depth, u32 for stencil. This seems
like it would cause issues all over the place where code expects just
one type.

Another issue is depth24plus-stencil, the depth part is undefined.
In the code, createTextureWithRandomDataAndGetTexelsForEachAspect
on a depth format returns a TexelView with float data, not depth24plus
data. I'm not sure all the encoders etc would handle this.

So, like I mentioned above, my solution was to return 2 sets of
TexelViews, one for the depth aspect and one for the stenci aspect.
The code then choose one based on which aspect it's testing.

* Move texture swizzle operation tests under api/operations
* skip non-matching swizzle operation tests in compat mode
* Test that mismatching swizzles cause validation error in compat mode
* Skip identity validation on browsers that have no yet implemented this
* Fix textureLoad test for multisampled textures

Multisampled textures are required to have RENDER_ATTACHMENT usage.
This was working by accident as `createTextureWithRandopmDataAndGetTexels`
as adding the RENDER_ATTACHMENT usage. That usage addition is removed
in this PR so the bug that it was not added here surfaced.

* More adjustment for texture-utils issues.

Originally the texture-utils made textures filled with random data based on
a texture descriptor. If the texture format was depth or stencil they needed
to render to the texture to get the data in since some formats do not support
writeTexture nor copyBufferToTexture. To do this they needed to add
RENDER_ATTACHMENT.

But, texture-component-swizzle requires that RENDER_ATTACHMENT not be set.
So, a check was added, if the texture created had texture.usage different
than was originally requested then, make a new texture without those added
usages and copy the texture into this new texture. 🎉

But, there were a few tests, like textureLoad multisample and texture_utils
that happened to be passing by accident. They were testing multisample.
Multisampled texture require RENDER_ATTACHMENT. They were not requesting
a texture with RENDER_ATTACHMENT but were instead getting one by luck on
the old path when RENDER_ATTACHMENT was magically added when needed.
With the fix to remove RENDER_ATTACHMENT when it was not requested, these
tests started failing.

On top of that, the texture-component-swizzle tests test both the depth
and stencil aspect of depth-stencil textures. Note that the WGSL builtin
texture tests do not (yet?) do this.

Adding the path to upload data for both depth AND stencil data broke
because the copy above happened in the wrong place. The old broken
path was

1. make texture with RENDER_ATTACHMENT
2. use copy texel data via render to fill depth data
3. make copy of texture without RENDER_ATTACHMENT
4. use copy texel data via render to fill stencil data (ERROR!)

You can't fill the stencil via render if RENDER_ATTACHMENT is removed.

The fix was to refactor so it's now effectively

1. make texture with RENDER_ATTACHMENT
2. use copy texel data via render to fill depth data
3. use copy texel data via render to fill stencil data
4. make copy of texture without RENDER_ATTACHMENT

* Add more compat limitation checks

1. `textureLoad` can not be uses with `texture_depth_2d`
2. `texture_depth_2d` can not be used with non-comparison samplers

* Check the correct usages when deciding to make a copy.

The code was checking COPY_SRC when it shouldn't have

* Switching to view.usage to validate bad usages

This was using texture.usage which was the wrong place to check.
Switching to view.usage lets us test multisampled textures.

* Test multisampled textures

* Expect depth textures to return D,0,0,1

Note: this changes both the texture-component-swizzle tests and the
general WGSL texture builtin tests so that if texture-component-swizzle
is enabled, the WGSL texture builtin tests will expect D,0,0,1 instead
of D,?,?,?

* Don't Copy Textures to remove RENDER_ATTACHMENT usage

This was added as RENDER_ATTACHMENT usage is incompatible with
swizzle under the current spec. Unfortunately, copying a texture
fails for depth textures on Mac Intel (because there is no test).
It turns out the current spec only requires the texture view's
usage not to have RENDER_ATTACHMENT, not the textures's, so this
copy step is not needed.

Removing it should let tests run on devices where copy is broken.

* Switch to WGSL syntax
* Add some swizzles that might mistakenly be accepted.
* Add copy support for r8snorm, rg8snorm, rgba8snorm
* remove invalid swizzle validation check
* add a few more invalid swizzles
* Refactor texture-component-swizzle validation tests.

Validation changed from createView time to createBindGroup,
beginRenderPass time.

Co-authored-by: François Beaufort <[email protected]>

Author: greggman

src/webgpu/api/operation/texture_view/texture_component_swizzle.spec.ts

@@ -0,0 +1,373 @@
+export const description = `
+Validation tests for the 'texture-component-swizzle' feature.
+
+Test that:
+* when the feature is off, swizzling is not allowed, even the identity swizzle.
+* swizzling is not allowed on textures with usage STORAGE_BINDING nor RENDER_ATTACHMENT
+  except the identity swizzle.
+`;
+
+import { makeTestGroup } from '../../../../../common/framework/test_group.js';
+import { UniqueFeaturesOrLimitsGPUTest } from '../../../../gpu_test.js';
+
+import { isIdentitySwizzle, kSwizzleTests } from './texture_component_swizzle_utils.js';
+
+export const g = makeTestGroup(UniqueFeaturesOrLimitsGPUTest);
+
+g.test('invalid_swizzle')
+  .desc(
+    `
+  Test that setting an invalid swizzle value on a texture view throws an exception.
+  `
+  )
+  .params(u =>
+    u.beginSubcases().combine('invalidSwizzle', [
+      'rgbA', // swizzles are case-sensitive
+      'RGBA', // swizzles are case-sensitive
+      'rgb', // must have 4 components
+      'rgba01',
+      'ɲgba', // r with 0x200 added to each code point to make sure values are not truncated.
+      'ɲɧɢɡ', // rgba with 0x200 added to each code point to make sure values are not truncated.
+      '𝐫𝐠𝐛𝐚', // various unicode values that normalize to rgba
+      '𝑟𝑔𝑏𝑎',
+      '𝗋𝗀𝖻𝖺',
+      '𝓇ℊ𝒷𝒶',
+      'ⓡⓖⓑⓐ',
+      'ｒｇｂａ',
+      'ʳᵍᵇᵃ',
+      '000',
+      '00000',
+      '111',
+      '11111',
+      0,
+      1,
+      1111, // passes because toString is '1111'
+      1234,
+      1111.1,
+      0x72676261, // big endian rgba
+      0x61626772, // little endian rgba
+      0x30303030, // 0000
+      0x31313131, // 1111
+      true,
+      false,
+      null,
+    ])
+  )
+  .beforeAllSubcases(t => {
+    // MAINTENANCE_TODO: Remove this cast once texture-component-swizzle is added to @webgpu/types
+    t.selectDeviceOrSkipTestCase('texture-component-swizzle' as GPUFeatureName);
+  })
+  .fn(t => {
+    const { invalidSwizzle } = t.params;
+    const texture = t.createTextureTracked({
+      format: 'rgba8unorm',
+      size: [1],
+      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
+    });
+
+    const failure = typeof invalidSwizzle !== 'number' || invalidSwizzle !== 1111;
+    t.shouldThrow(failure ? 'TypeError' : false, () => {
+      texture.createView({ swizzle: invalidSwizzle as GPUTextureComponentSwizzle });
+    });
+  });
+
+g.test('only_identity_swizzle')
+  .desc(
+    `
+  Test that if texture-component-swizzle is not enabled, having a non-default swizzle property generates a validation error.
+  `
+  )
+  .params(u => u.beginSubcases().combine('swizzle', kSwizzleTests))
+  .fn(t => {
+    // MAINTENANCE_TODO: Remove this check if the spec is updated to say that all implementations must validate this.
+    t.skipIf(
+      !t.adapter.features.has('texture-component-swizzle'),
+      'skip on browsers that have not implemented texture-component-swizzle'
+    );
+
+    const { swizzle } = t.params;
+    const texture = t.createTextureTracked({
+      format: 'rgba8unorm',
+      size: [1],
+      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
+    });
+    const shouldError = !isIdentitySwizzle(swizzle);
+    t.expectValidationError(() => {
+      texture.createView({ swizzle });
+    }, shouldError);
+  });
+
+g.test('no_render_no_resolve_no_storage')
+  .desc(
+    `
+  Test that setting a non-identity swizzle gets an error if used as a render attachment,
+  a resolve target, or a storage binding.
+  `
+  )
+  .params(u =>
+    u
+      .combine('useCase', [
+        'texture-binding',
+        'color-attachment',
+        'depth-attachment',
+        'stencil-attachment',
+        'resolve-target',
+        'storage-binding',
+      ] as const)
+      .beginSubcases()
+      .combine('swizzle', kSwizzleTests)
+  )
+  .beforeAllSubcases(t => {
+    // MAINTENANCE_TODO: Remove this cast once texture-component-swizzle is added to @webgpu/types
+    t.selectDeviceOrSkipTestCase('texture-component-swizzle' as GPUFeatureName);
+  })
+  .fn(t => {
+    const { swizzle, useCase } = t.params;
+    const texture = t.createTextureTracked({
+      format:
+        useCase === 'depth-attachment'
+          ? 'depth16unorm'
+          : useCase === 'stencil-attachment'
+          ? 'stencil8'
+          : 'rgba8unorm',
+      size: [1],
+      usage:
+        GPUTextureUsage.COPY_SRC |
+        GPUTextureUsage.COPY_DST |
+        GPUTextureUsage.TEXTURE_BINDING |
+        GPUTextureUsage.RENDER_ATTACHMENT |
+        (useCase === 'storage-binding' ? GPUTextureUsage.STORAGE_BINDING : 0),
+    });
+    const view = texture.createView({ swizzle });
+    const shouldError = useCase !== 'texture-binding' && !isIdentitySwizzle(swizzle);
+    switch (useCase) {
+      case 'texture-binding': {
+        const bindGroupLayout = t.device.createBindGroupLayout({
+          entries: [
+            {
+              binding: 0,
+              visibility: GPUShaderStage.FRAGMENT,
+              texture: {},
+            },
+          ],
+        });
+        t.expectValidationError(() => {
+          t.device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [{ binding: 0, resource: view }],
+          });
+        }, shouldError);
+        break;
+      }
+      case 'color-attachment': {
+        t.expectValidationError(() => {
+          const encoder = t.device.createCommandEncoder();
+          const pass = encoder.beginRenderPass({
+            colorAttachments: [
+              {
+                view,
+                loadOp: 'clear',
+                storeOp: 'store',
+              },
+            ],
+          });
+          pass.end();
+          encoder.finish();
+        }, shouldError);
+        break;
+      }
+      case 'depth-attachment': {
+        t.expectValidationError(() => {
+          const encoder = t.device.createCommandEncoder();
+          const pass = encoder.beginRenderPass({
+            colorAttachments: [],
+            depthStencilAttachment: {
+              view,
+              depthClearValue: 1,
+              depthLoadOp: 'clear',
+              depthStoreOp: 'store',
+            },
+          });
+          pass.end();
+          encoder.finish();
+        }, shouldError);
+        break;
+      }
+      case 'stencil-attachment': {
+        t.expectValidationError(() => {
+          const encoder = t.device.createCommandEncoder();
+          const pass = encoder.beginRenderPass({
+            colorAttachments: [],
+            depthStencilAttachment: {
+              view,
+              stencilClearValue: 0,
+              stencilLoadOp: 'clear',
+              stencilStoreOp: 'store',
+            },
+          });
+          pass.end();
+          encoder.finish();
+        }, shouldError);
+        break;
+      }
+      case 'resolve-target': {
+        t.expectValidationError(() => {
+          const encoder = t.device.createCommandEncoder();
+          const pass = encoder.beginRenderPass({
+            colorAttachments: [
+              {
+                view: t.createTextureTracked({
+                  format: 'rgba8unorm',
+                  size: [1],
+                  usage: GPUTextureUsage.RENDER_ATTACHMENT,
+                  sampleCount: 4,
+                }),
+                resolveTarget: view,
+                loadOp: 'clear',
+                storeOp: 'store',
+              },
+            ],
+          });
+          pass.end();
+          encoder.finish();
+        }, shouldError);
+        break;
+      }
+      case 'storage-binding': {
+        const bindGroupLayout = t.device.createBindGroupLayout({
+          entries: [
+            {
+              binding: 0,
+              visibility: GPUShaderStage.COMPUTE,
+              storageTexture: {
+                access: 'read-only',
+                format: 'rgba8unorm',
+              },
+            },
+          ],
+        });
+        t.expectValidationError(() => {
+          t.device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [{ binding: 0, resource: view }],
+          });
+        }, shouldError);
+        break;
+      }
+    }
+  });
+
+g.test('compatibility_mode')
+  .desc(
+    `
+  Test that in compatibility mode, swizzles must be equivalent.
+  `
+  )
+  .beforeAllSubcases(t => {
+    // MAINTENANCE_TODO: Remove this cast once texture-component-swizzle is added to @webgpu/types
+    t.selectDeviceOrSkipTestCase('texture-component-swizzle' as GPUFeatureName);
+  })
+  .params(u =>
+    u
+      .beginSubcases()
+      .combine('swizzle', kSwizzleTests)
+      .combine('otherSwizzle', kSwizzleTests)
+      .combine('pipelineType', ['render', 'compute'] as const)
+  )
+  .fn(t => {
+    const { swizzle, otherSwizzle, pipelineType } = t.params;
+
+    const module = t.device.createShaderModule({
+      code: `
+        @group(0) @binding(0) var tex0: texture_2d<f32>;
+        @group(1) @binding(0) var tex1: texture_2d<f32>;
+
+        @compute @workgroup_size(1) fn cs() {
+          _ = tex0;
+          _ = tex1;
+        }
+
+        @vertex fn vs() -> @builtin(position) vec4f {
+          return vec4f(0);
+        }
+
+        @fragment fn fs() -> @location(0) vec4f {
+          _ = tex0;
+          _ = tex1;
+          return vec4f(0);
+        }
+      `,
+    });
+
+    const pipeline =
+      pipelineType === 'compute'
+        ? t.device.createComputePipeline({
+            layout: 'auto',
+            compute: { module },
+          })
+        : t.device.createRenderPipeline({
+            layout: 'auto',
+            vertex: { module },
+            fragment: { module, targets: [{ format: 'rgba8unorm' }] },
+          });
+
+    const texture = t.createTextureTracked({
+      size: [1],
+      format: 'rgba8unorm',
+      usage: GPUTextureUsage.TEXTURE_BINDING,
+    });
+
+    const bindGroup0 = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: texture.createView({ swizzle }),
+        },
+      ],
+    });
+
+    const bindGroup1 = t.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        {
+          binding: 0,
+          resource: texture.createView({ swizzle: otherSwizzle }),
+        },
+      ],
+    });
+
+    const encoder = t.device.createCommandEncoder();
+    switch (pipelineType) {
+      case 'compute': {
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline as GPUComputePipeline);
+        pass.setBindGroup(0, bindGroup0);
+        pass.setBindGroup(1, bindGroup1);
+        pass.dispatchWorkgroups(1);
+        pass.end();
+        break;
+      }
+      case 'render': {
+        const view = t.createTextureTracked({
+          size: [1],
+          format: 'rgba8unorm',
+          usage: GPUTextureUsage.RENDER_ATTACHMENT,
+        });
+        const pass = encoder.beginRenderPass({
+          colorAttachments: [{ view, loadOp: 'clear', storeOp: 'store' }],
+        });
+        pass.setPipeline(pipeline as GPURenderPipeline);
+        pass.setBindGroup(0, bindGroup0);
+        pass.setBindGroup(1, bindGroup1);
+        pass.draw(3);
+        pass.end();
+      }
+    }
+
+    const shouldError = t.isCompatibility && swizzle !== otherSwizzle;
+
+    t.expectValidationError(() => {
+      encoder.finish();
+    }, shouldError);
+  });