Check that createView format is compatible with the view usage. (#4495)

For example rgba8unorm -> rgba8unorm-srgb prevents using the storage
usage on the created view.

Author: Kangz

src/webgpu/api/validation/createView.spec.ts

@@ -17,6 +17,9 @@ import {
   filterFormatsByFeature,
   textureFormatsAreViewCompatible,
   isDepthTextureFormat,
+  isTextureFormatUsableWithStorageAccessMode,
+  isTextureFormatColorRenderable,
+  isColorTextureFormat,
   isStencilTextureFormat,
   getBlockInfoForTextureFormat,
   isTextureFormatPossiblyUsableAsRenderAttachment,
@@ -345,53 +348,95 @@ g.test('texture_view_usage')
   .params(u =>
     u //
       .combine('format', kAllTextureFormats)
-      .combine('textureUsage0', kTextureUsages)
-      .combine('textureUsage1', kTextureUsages)
-      .unless(({ format, textureUsage0, textureUsage1 }) => {
-        const textureUsage = textureUsage0 | textureUsage1;
+      .combine('textureUsage', kTextureUsages)
+      .unless(({ format, textureUsage }) => {
         return (
           (textureUsage & GPUConst.TextureUsage.RENDER_ATTACHMENT) !== 0 &&
           !isTextureFormatPossiblyUsableAsRenderAttachment(format)
         );
       })
       .beginSubcases()
-      .combine('textureViewUsage0', [0, ...kTextureUsages])
-      .combine('textureViewUsage1', [0, ...kTextureUsages])
+      .combine('textureViewUsage', [0, ...kTextureUsages])
   )
   .fn(t => {
-    const { format, textureUsage0, textureUsage1, textureViewUsage0, textureViewUsage1 } = t.params;
+    const { format, textureUsage, textureViewUsage } = t.params;
 
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatDoesNotSupportUsage(textureUsage, format);
 
     const { blockWidth, blockHeight } = getBlockInfoForTextureFormat(format);
 
-    const size = [blockWidth, blockHeight, 1];
-    const dimension = '2d';
-    const mipLevelCount = 1;
-    const usage = textureUsage0 | textureUsage1;
+    const texture = t.createTextureTracked({
+      size: [blockWidth, blockHeight, 1],
+      format,
+      usage: textureUsage,
+    });
 
-    t.skipIfTextureFormatDoesNotSupportUsage(usage, format);
+    let success = true;
 
-    const textureDescriptor: GPUTextureDescriptor = {
-      size,
-      mipLevelCount,
-      dimension,
-      format,
-      usage,
-    };
+    // Texture view usage must be a subset of texture usage
+    if ((~textureUsage & textureViewUsage) !== 0) success = false;
 
-    const texture = t.createTextureTracked(textureDescriptor);
+    t.expectValidationError(() => {
+      texture.createView({
+        usage: textureViewUsage,
+      });
+    }, !success);
+  });
 
-    let success = true;
+g.test('texture_view_usage_with_view_format')
+  .desc(
+    `Test that the texture view usage must be supported by the view's format. Checks for every view format possible, and every usage supported by the texture's format`
+  )
+  .params(u =>
+    u
+      .combine('textureFormat', kAllTextureFormats)
+      .combine('usage', kTextureUsages)
+      .beginSubcases()
+      .combine('viewFormat', kAllTextureFormats)
+  )
+  .fn(t => {
+    const { textureFormat, viewFormat, usage } = t.params;
 
-    const textureViewUsage = textureViewUsage0 | textureViewUsage1;
+    t.skipIfTextureFormatNotSupported(textureFormat, viewFormat);
+    t.skipIfTextureFormatDoesNotSupportUsage(usage, textureFormat);
+
+    if (!textureFormatsAreViewCompatible(t.device, textureFormat, viewFormat)) {
+      t.skip(`"${textureFormat}" and "${viewFormat}" are not view-compatible`);
+    }
+
+    const { blockWidth, blockHeight } = getBlockInfoForTextureFormat(textureFormat);
+    const texture = t.createTextureTracked({
+      size: [blockWidth, blockHeight, 1],
+      format: textureFormat,
+      usage,
+      viewFormats: [viewFormat],
+    });
+
+    let success = true;
 
     // Texture view usage must be a subset of texture usage
-    if ((~usage & textureViewUsage) !== 0) success = false;
+    if (usage & GPUTextureUsage.STORAGE_BINDING) {
+      if (!isTextureFormatUsableWithStorageAccessMode(t.device, viewFormat, 'write-only'))
+        success = false;
+    }
+    if (usage & GPUTextureUsage.RENDER_ATTACHMENT) {
+      if (isColorTextureFormat(viewFormat) && !isTextureFormatColorRenderable(t.device, viewFormat))
+        success = false;
+    }
+
+    // Test with explicitly setting the view usage.
+    t.expectValidationError(() => {
+      texture.createView({
+        usage,
+        format: viewFormat,
+      });
+    }, !success);
 
+    // Test with inheriting the view usage.
     t.expectValidationError(() => {
       texture.createView({
-        usage: textureViewUsage,
+        format: viewFormat,
       });
     }, !success);
   });