Fix usages of textureDimensionAndFormatCompatible.

All of these usages were wrong as they need the device to
know if a dimension and format are compatible since
extensions enable 3d dimension with compressed textures.

So, rename textureDimensionAndFormatCompatible to
textureFormatAndDimensionAndPossiblyCompatible to
let a test filter out formats that can't possibly
be used with certain dimensions. Then, for each test,
call t.skipIfTextureFormatAndDimensionNotCompatible
which checks the extensions.

Further, a few tests needed fixing.

copyTextureToTexture validation tests needed to handle
3d compress texture size limits correctly.

createTexture needed to not skip 3d compressed textures

layout_related needed to pass dimension to createAlignedTexture
and also, several tests had dimension as a test parameter but
didn't seem to be using it anywhere so added it into at least
texture creation on those tests.

expectTextureToMatchByRendering needed to handle 3d textures

texture_zero tests were mostly indirectly affected by
changes to texture_zero_init_test.ts. Nothing interesting
changed in this PR but the params there are extremely
convoluted and I didn't bother to decode exactly what
is going on in detail. I did glance over them and I think
they aren't skipping compressed textures.

Author: greggman

src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts

@@ -21,7 +21,7 @@ import {
   kDepthStencilFormats,
   kRegularTextureFormats,
   RegularTextureFormat,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
   textureFormatsAreViewCompatible,
 } from '../../../format_info.js';
 import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
@@ -82,6 +82,9 @@ class F extends AllFeaturesMaxLimitsGPUTest {
     dstCopyLevel: number
   ): void {
     this.skipIfTextureFormatNotSupported(srcFormat, dstFormat);
+    this.skipIfCopyTextureToTextureNotSupportedForFormat(srcFormat, dstFormat);
+    this.skipIfTextureFormatAndDimensionNotCompatible(srcFormat, dimension);
+    this.skipIfTextureFormatAndDimensionNotCompatible(dstFormat, dimension);
 
     // If we're in compatibility mode and it's a compressed texture
     // then we need to render the texture to test the results of the copy.
@@ -802,8 +805,8 @@ g.test('color_textures,non_compressed,non_array')
       .combine('dimension', kTextureDimensions)
       .filter(
         ({ dimension, srcFormat, dstFormat }) =>
-          textureDimensionAndFormatCompatible(dimension, srcFormat) &&
-          textureDimensionAndFormatCompatible(dimension, dstFormat)
+          textureFormatAndDimensionPossiblyCompatible(dimension, srcFormat) &&
+          textureFormatAndDimensionPossiblyCompatible(dimension, dstFormat)
       )
       .beginSubcases()
       .expandWithParams(p => {
@@ -979,8 +982,8 @@ g.test('color_textures,non_compressed,array')
       .combine('dimension', ['2d', '3d'] as const)
       .filter(
         ({ dimension, srcFormat, dstFormat }) =>
-          textureDimensionAndFormatCompatible(dimension, srcFormat) &&
-          textureDimensionAndFormatCompatible(dimension, dstFormat)
+          textureFormatAndDimensionPossiblyCompatible(dimension, srcFormat) &&
+          textureFormatAndDimensionPossiblyCompatible(dimension, dstFormat)
       )
       .beginSubcases()
       .combine('textureSize', [
@@ -1071,11 +1074,6 @@ g.test('color_textures,compressed,array')
       srcCopyLevel,
       dstCopyLevel,
     } = t.params;
-    t.skipIfTextureFormatNotSupported(srcFormat, dstFormat);
-    t.skipIfCopyTextureToTextureNotSupportedForFormat(srcFormat, dstFormat);
-    t.skipIfTextureFormatAndDimensionNotCompatible(srcFormat, dimension);
-    t.skipIfTextureFormatAndDimensionNotCompatible(dstFormat, dimension);
-
     const { blockWidth: srcBlockWidth, blockHeight: srcBlockHeight } =
       getBlockInfoForColorTextureFormat(srcFormat);
     const { blockWidth: dstBlockWidth, blockHeight: dstBlockHeight } =

src/webgpu/api/operation/command_buffer/image_copy.spec.ts

@@ -47,7 +47,7 @@ import {
   kDepthStencilFormats,
   kColorTextureFormats,
   depthStencilBufferTextureCopySupported,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
   depthStencilFormatAspectSize,
   DepthStencilFormat,
   ColorTextureFormat,
@@ -1218,7 +1218,9 @@ bytes in copy works for every format.
       .combine('format', kColorTextureFormats)
       .filter(formatCanBeTested)
       .combine('dimension', kTextureDimensions)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combineWithParams(kRowsPerImageAndBytesPerRowParams.paddings)
       .expandWithParams(p => {
@@ -1240,7 +1242,8 @@ bytes in copy works for every format.
       initMethod,
       checkMethod,
     } = t.params;
-    t.skipIfTextureFormatNotSupported(t.params.format);
+    t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     const info = getBlockInfoForTextureFormat(format);
     // For CopyB2T and CopyT2B we need to have bytesPerRow 256-aligned,
     // to make this happen we align the bytesInACompleteRow value and multiply
@@ -1321,7 +1324,9 @@ works for every format with 2d and 2d-array textures.
       .combine('format', kColorTextureFormats)
       .filter(formatCanBeTested)
       .combine('dimension', kTextureDimensions)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combineWithParams(kOffsetsAndSizesParams.offsetsAndPaddings)
       .combine('copyDepth', kOffsetsAndSizesParams.copyDepth) // 2d and 2d-array textures
@@ -1352,6 +1357,7 @@ works for every format with 2d and 2d-array textures.
       rowsPerImageEqualsCopyHeight,
     } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
 
     // Skip test cases designed for special cases coverage on compatibility mode to save run time.
     if (!(t.isCompatibility && (format === 'r8snorm' || format === 'rg8snorm'))) {
@@ -1420,7 +1426,9 @@ for all formats. We pass origin and copyExtent as [number, number, number].`
       .combine('format', kColorTextureFormats)
       .filter(formatCanBeTested)
       .combine('dimension', kTextureDimensions)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combine('originValueInBlocks', [0, 7, 8])
       .combine('copySizeValueInBlocks', [0, 7, 8])
@@ -1444,6 +1452,7 @@ for all formats. We pass origin and copyExtent as [number, number, number].`
       checkMethod,
     } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     const info = getBlockInfoForColorTextureFormat(format);
 
     let originBlocks = [1, 1, 1];
@@ -1581,7 +1590,9 @@ TODO: Make a variant for depth-stencil formats.
       .combine('format', kColorTextureFormats)
       .filter(formatCanBeTested)
       .combine('dimension', ['2d', '3d'] as const)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combineWithParams([
         // origin + copySize = texturePhysicalSizeAtMipLevel for all coordinates, 2d texture */
@@ -1641,6 +1652,8 @@ TODO: Make a variant for depth-stencil formats.
       checkMethod,
     } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
+
     const info = getBlockInfoForColorTextureFormat(format);
 
     const origin = {

src/webgpu/api/operation/resource_init/check_texture/texture_zero_init_test.ts

@@ -8,7 +8,7 @@ import { kTextureAspects, kTextureDimensions } from '../../../../capability_info
 import { GPUConst } from '../../../../constants.js';
 import {
   kUncompressedTextureFormats,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
   UncompressedTextureFormat,
   EncodableTextureFormat,
   isColorTextureFormat,
@@ -480,7 +480,7 @@ export const kTestParams = kUnitCaseParamsBuilder
   ])
   // [3] compressed formats
   .combine('format', kUncompressedTextureFormats)
-  .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+  .filter(({ dimension, format }) => textureFormatAndDimensionPossiblyCompatible(dimension, format))
   .beginSubcases()
   .combine('aspect', kTextureAspects)
   .unless(({ readMethod, format, aspect }) => {

src/webgpu/api/operation/resource_init/texture_zero.spec.ts

@@ -42,6 +42,7 @@ g.test('uninitialized_texture_is_zero')
   .params(kTestParams)
   .fn(t => {
     t.skipIfTextureFormatNotSupportedForTest(t.params);
+    t.skipIfTextureFormatAndDimensionNotCompatible(t.params.format, t.params.dimension);
 
     const usage = getRequiredTextureUsage(
       t.params.format,

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

@@ -12,7 +12,7 @@ import {
   kRegularTextureFormats,
   kFeaturesForFormats,
   filterFormatsByFeature,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
   getBlockInfoForTextureFormat,
   isTextureFormatMultisampled,
   isTextureFormatColorRenderable,
@@ -53,11 +53,15 @@ g.test('zero_size_and_usage')
         'usage',
       ] as const)
       // Filter out incompatible dimension type and format combinations.
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
   )
   .fn(t => {
     const { dimension, zeroArgument, format } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
+
     const info = getBlockInfoForTextureFormat(format);
 
     const size = [info.blockWidth, info.blockHeight, 1];
@@ -141,13 +145,16 @@ g.test('mipLevelCount,format')
       .beginSubcases()
       .combine('mipLevelCount', [1, 2, 3, 6, 7])
       // Filter out incompatible dimension type and format combinations.
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .combine('largestDimension', [0, 1, 2])
       .unless(({ dimension, largestDimension }) => dimension === '1d' && largestDimension > 0)
   )
   .fn(t => {
     const { dimension, format, mipLevelCount, largestDimension } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     const info = getBlockInfoForTextureFormat(format);
 
     // Compute dimensions such that the dimensions are in range [17, 32] and aligned with the
@@ -325,7 +332,9 @@ g.test('sampleCount,valid_sampleCount_with_other_parameter_varies')
         return usageSet;
       })
       // Filter out incompatible dimension type and format combinations.
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .unless(({ usage, format, mipLevelCount, dimension }) => {
         return (
           ((usage & GPUConst.TextureUsage.RENDER_ATTACHMENT) !== 0 &&
@@ -340,6 +349,7 @@ g.test('sampleCount,valid_sampleCount_with_other_parameter_varies')
   .fn(t => {
     const { dimension, sampleCount, format, mipLevelCount, arrayLayerCount, usage } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     if ((usage & GPUConst.TextureUsage.RENDER_ATTACHMENT) !== 0) {
       t.skipIfTextureFormatNotUsableAsRenderAttachment(format);
     }
@@ -416,11 +426,14 @@ g.test('texture_size,default_value_and_smallest_size,uncompressed_format')
       .beginSubcases()
       .combine('size', [[1], [1, 1], [1, 1, 1]])
       // Filter out incompatible dimension type and format combinations.
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
   )
   .fn(t => {
     const { dimension, format, size } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
 
     const descriptor: GPUTextureDescriptor = {
       size,
@@ -439,9 +452,12 @@ g.test('texture_size,default_value_and_smallest_size,compressed_format')
   )
   .params(u =>
     u
-      // Compressed formats are invalid for 1D and 3D.
-      .combine('dimension', [undefined, '2d'] as const)
+      // Compressed formats are invalid for 1D.
+      .combine('dimension', [undefined, '2d', '3d'] as const)
       .combine('format', kCompressedTextureFormats)
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .expandWithParams(p => {
         const { blockWidth, blockHeight } = getBlockInfoForTextureFormat(p.format);
@@ -458,6 +474,7 @@ g.test('texture_size,default_value_and_smallest_size,compressed_format')
   .fn(t => {
     const { dimension, format, size, _success } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
 
     const descriptor: GPUTextureDescriptor = {
       size,
@@ -770,6 +787,7 @@ g.test('texture_size,3d_texture,uncompressed_format')
   .fn(t => {
     const { format, sizeVariant } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, '3d');
     const maxTextureDimension3D = t.device.limits.maxTextureDimension3D;
     const size = sizeVariant.map(variant => t.makeLimitVariant('maxTextureDimension3D', variant));
 
@@ -945,13 +963,10 @@ g.test('texture_size,3d_texture,compressed_format')
         ];
       })
   )
-  .beforeAllSubcases(t => {
-    // Compressed formats are not supported in 3D in WebGPU v1 because they are complicated but not very useful for now.
-    t.skip('Compressed 3D texture is not supported');
-  })
   .fn(t => {
     const { format, sizeVariant } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, '3d');
     const info = getBlockInfoForTextureFormat(format);
 
     const maxTextureDimension3D = t.device.limits.maxTextureDimension3D;
@@ -974,7 +989,8 @@ g.test('texture_size,3d_texture,compressed_format')
       size[1] % info.blockHeight === 0 &&
       size[0] <= maxTextureDimension3D &&
       size[1] <= maxTextureDimension3D &&
-      size[2] <= maxTextureDimension3D;
+      size[2] <= maxTextureDimension3D &&
+      textureDimensionAndFormatCompatibleForDevice(t.device, '3d', format);
 
     t.expectValidationError(() => {
       t.createTextureTracked(descriptor);
@@ -994,11 +1010,14 @@ g.test('texture_usage')
       .combine('usage0', kTextureUsages)
       .combine('usage1', kTextureUsages)
       // Filter out incompatible dimension type and format combinations.
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
   )
   .fn(t => {
     const { dimension, format, usage0, usage1 } = t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     const info = getBlockInfoForTextureFormat(format);
 
     const size = [info.blockWidth, info.blockHeight, 1];

src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts

@@ -8,7 +8,7 @@ import {
   kAllTextureFormats,
   kCompressedTextureFormats,
   kDepthStencilFormats,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
   getBlockInfoForTextureFormat,
   getBaseFormatForTextureFormat,
   canCopyFromAllAspectsOfTextureFormat,
@@ -757,7 +757,9 @@ TODO: Express the offsets in "block size" so as to be able to test non-4x4 compr
     u
       .combine('format', kCompressedTextureFormats)
       .combine('dimension', kTextureDimensions)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combine('copyBoxOffsets', [
         { x: 0, y: 0, z: 0, width: 0, height: 0, depthOrArrayLayers: -2 },
@@ -779,6 +781,7 @@ TODO: Express the offsets in "block size" so as to be able to test non-4x4 compr
     const { format, dimension, copyBoxOffsets, srcCopyLevel, dstCopyLevel } = t.params;
 
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
     t.skipIfCopyTextureToTextureNotSupportedForFormat(format);
 
     const { blockWidth, blockHeight } = getBlockInfoForTextureFormat(format);
@@ -828,8 +831,12 @@ TODO: Express the offsets in "block size" so as to be able to test non-4x4 compr
       Math.min(srcSizeAtLevel.height, dstSizeAtLevel.height) + copyBoxOffsets.height - copyOrigin.y,
       0
     );
-    const copyDepth =
-      kTextureSize.depthOrArrayLayers + copyBoxOffsets.depthOrArrayLayers - copyOrigin.z;
+    const copyDepth = Math.max(
+      Math.min(srcSizeAtLevel.depthOrArrayLayers, dstSizeAtLevel.depthOrArrayLayers) +
+        copyBoxOffsets.depthOrArrayLayers -
+        copyOrigin.z,
+      0
+    );
 
     const isSuccessForCompressedFormats =
       copyOrigin.x % blockWidth === 0 &&

src/webgpu/api/validation/image_copy/buffer_related.spec.ts

@@ -7,7 +7,7 @@ import {
   getBlockInfoForSizedTextureFormat,
   isDepthOrStencilTextureFormat,
   kSizedTextureFormats,
-  textureDimensionAndFormatCompatible,
+  textureFormatAndDimensionPossiblyCompatible,
 } from '../../../format_info.js';
 import { kResourceStates } from '../../../gpu_test.js';
 import { kImageCopyTypes } from '../../../util/texture/layout.js';
@@ -160,7 +160,9 @@ Test that bytesPerRow must be a multiple of 256 for CopyB2T and CopyT2B if it is
       .combine('format', kSizedTextureFormats)
       .filter(formatCopyableWithMethod)
       .combine('dimension', kTextureDimensions)
-      .filter(({ dimension, format }) => textureDimensionAndFormatCompatible(dimension, format))
+      .filter(({ dimension, format }) =>
+        textureFormatAndDimensionPossiblyCompatible(dimension, format)
+      )
       .beginSubcases()
       .combine('bytesPerRow', [undefined, 0, 1, 255, 256, 257, 512])
       .combine('copyHeightInBlocks', [0, 1, 2, 3])
@@ -188,6 +190,7 @@ Test that bytesPerRow must be a multiple of 256 for CopyB2T and CopyT2B if it is
     const { method, dimension, format, bytesPerRow, copyHeightInBlocks, _textureHeightInBlocks } =
       t.params;
     t.skipIfTextureFormatNotSupported(format);
+    t.skipIfTextureFormatAndDimensionNotCompatible(format, dimension);
 
     const info = getBlockInfoForSizedTextureFormat(format);