Add texture size tests for 1D/2D/3D textures (gpuweb#479)

Yunchao He · web-flow · commit dd3c719fb39c · 2021-03-05T09:49:44.000Z
* Add texture size tests for 1D/2D/3D textures

* Update webgpu/types to 0.0.42 for texture dimension limits

* Fixes/Skip: total texture footprint issue, compressed texture alignment issue
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -36,7 +36,7 @@
     "@types/morgan": "^1.9.2",
     "@types/node": "^14.11.10",
     "@types/offscreencanvas": "^2019.6.2",
-    "@webgpu/types": "0.0.41",
+    "@webgpu/types": "0.0.42",
     "babel-plugin-add-header-comment": "^1.0.3",
     "babel-plugin-const-enum": "^1.0.1",
     "chokidar": "^3.4.3",
diff --git a/src/webgpu/api/validation/createTexture.spec.ts b/src/webgpu/api/validation/createTexture.spec.ts
@@ -10,15 +10,6 @@ TODO: review existing tests and merge with this plan:
 >     - with format that supports multisample, with all possible dimensions
 >     - with dimension that support multisample, with all possible formats
 >     - with format-dimension that support multisample, with {mipLevelCount, array layer count} = {1, 2}
-> - 1d, {width, height, depthOrArrayLayers} > whatever the max is
->     - height max is 1 (unless 1d-array is added)
->     - depthOrArrayLayers max is 1
->     - x= every texture format
-> - 2d, {width, height, depthOrArrayLayers} > whatever the max is
->     - depthOrArrayLayers max differs from width/height
->     - x= every texture format
-> - 3d, {width, height, depthOrArrayLayers} > whatever the max is
->     - x= every texture format
 > - usage flags
 >     - {0, ... each single usage flag}
 >     - x= every texture format
@@ -32,7 +23,13 @@ TODO: move destroy tests out of this file
 
 import { poptions, params } from '../../../common/framework/params_builder.js';
 import { makeTestGroup } from '../../../common/framework/test_group.js';
-import { kAllTextureFormats, kAllTextureFormatInfo } from '../../capability_info.js';
+import {
+  kAllTextureFormats,
+  kAllTextureFormatInfo,
+  kUncompressedTextureFormats,
+  kUncompressedTextureFormatInfo,
+} from '../../capability_info.js';
+import { DefaultLimits } from '../../constants.js';
 import { maxMipLevelCount } from '../../util/texture/base.js';
 
 import { ValidationTest } from './validation_test.js';
@@ -238,6 +235,132 @@ g.test('sampleCount')
     }, !_success);
   });
 
+g.test('texture_size,1d_texture')
+  .desc(`Test texture size requirement for 1D texture`)
+  .subcases(() =>
+    params()
+      .combine(poptions('format', kAllTextureFormats))
+      .combine(
+        poptions('width', [
+          DefaultLimits.maxTextureDimension1D - 1,
+          DefaultLimits.maxTextureDimension1D,
+          DefaultLimits.maxTextureDimension1D + 1,
+        ])
+      )
+      .combine(poptions('height', [1, 2]))
+      .combine(poptions('depthOrArrayLayers', [1, 2]))
+  )
+  .fn(async t => {
+    const { format, width, height, depthOrArrayLayers } = t.params;
+
+    await t.selectDeviceOrSkipTestCase(kAllTextureFormatInfo[format].extension);
+
+    const descriptor: GPUTextureDescriptor = {
+      size: [width, height, depthOrArrayLayers],
+      dimension: '1d' as const,
+      format,
+      usage: GPUTextureUsage.SAMPLED,
+    };
+
+    const success =
+      width <= DefaultLimits.maxTextureDimension1D && height === 1 && depthOrArrayLayers === 1;
+
+    t.expectValidationError(() => {
+      t.device.createTexture(descriptor);
+    }, !success);
+  });
+
+g.test('texture_size,2d_texture')
+  .desc(
+    `Test texture size requirement for 2D texture.
+	TODO: add tests for compressed texture.`
+  )
+  .subcases(() =>
+    params()
+      .combine(poptions('format', kUncompressedTextureFormats))
+      .combine(poptions('dimension', [undefined, '2d'] as const))
+      .combine([
+        // Test the bound of width
+        { size: [DefaultLimits.maxTextureDimension2D - 1, 1, 1] },
+        { size: [DefaultLimits.maxTextureDimension2D, 1, 1] },
+        { size: [DefaultLimits.maxTextureDimension2D + 1, 1, 1] },
+        // Test the bound of height
+        { size: [1, DefaultLimits.maxTextureDimension2D - 1, 1] },
+        { size: [1, DefaultLimits.maxTextureDimension2D, 1] },
+        { size: [1, DefaultLimits.maxTextureDimension2D + 1, 1] },
+        // Test the bound of array layers
+        { size: [1, 1, DefaultLimits.maxTextureArrayLayers - 1] },
+        { size: [1, 1, DefaultLimits.maxTextureArrayLayers] },
+        { size: [1, 1, DefaultLimits.maxTextureArrayLayers + 1] },
+      ])
+  )
+  .fn(async t => {
+    const { format, dimension, size } = t.params;
+
+    await t.selectDeviceOrSkipTestCase(kUncompressedTextureFormatInfo[format].extension);
+
+    const descriptor: GPUTextureDescriptor = {
+      size,
+      dimension,
+      format,
+      usage: GPUTextureUsage.SAMPLED,
+    };
+
+    const success =
+      size[0] <= DefaultLimits.maxTextureDimension2D &&
+      size[1] <= DefaultLimits.maxTextureDimension2D &&
+      size[2] <= DefaultLimits.maxTextureArrayLayers;
+
+    t.expectValidationError(() => {
+      t.device.createTexture(descriptor);
+    }, !success);
+  });
+
+g.test('texture_size,3d_texture')
+  .desc(
+    `Test texture size requirement for 3D texture.
+	TODO: add tests for compressed texture.`
+  )
+  .subcases(() =>
+    params()
+      .combine(poptions('format', kUncompressedTextureFormats))
+      .combine([
+        // Test the bound of width
+        { size: [DefaultLimits.maxTextureDimension3D - 1, 1, 1] },
+        { size: [DefaultLimits.maxTextureDimension3D, 1, 1] },
+        { size: [DefaultLimits.maxTextureDimension3D + 1, 1, 1] },
+        // Test the bound of height
+        { size: [1, DefaultLimits.maxTextureDimension3D - 1, 1] },
+        { size: [1, DefaultLimits.maxTextureDimension3D, 1] },
+        { size: [1, DefaultLimits.maxTextureDimension3D + 1, 1] },
+        // Test the bound of depth
+        { size: [1, 1, DefaultLimits.maxTextureDimension3D - 1] },
+        { size: [1, 1, DefaultLimits.maxTextureDimension3D] },
+        { size: [1, 1, DefaultLimits.maxTextureDimension3D + 1] },
+      ])
+  )
+  .fn(async t => {
+    const { format, size } = t.params;
+
+    await t.selectDeviceOrSkipTestCase(kUncompressedTextureFormatInfo[format].extension);
+
+    const descriptor: GPUTextureDescriptor = {
+      size,
+      dimension: '3d' as const,
+      format,
+      usage: GPUTextureUsage.SAMPLED,
+    };
+
+    const success =
+      size[0] <= DefaultLimits.maxTextureDimension3D &&
+      size[1] <= DefaultLimits.maxTextureDimension3D &&
+      size[2] <= DefaultLimits.maxTextureDimension3D;
+
+    t.expectValidationError(() => {
+      t.device.createTexture(descriptor);
+    }, !success);
+  });
+
 g.test('it_is_valid_to_destroy_a_texture').fn(t => {
   const descriptor = t.getDescriptor();
   const texture = t.device.createTexture(descriptor);
diff --git a/src/webgpu/constants.ts b/src/webgpu/constants.ts
@@ -44,6 +44,10 @@ export const GPUConst = {
 
 // Type ensures every field is specified.
 export const DefaultLimits: ResolveType<Required<Readonly<GPULimits>>> = {
+  maxTextureDimension1D: 8192,
+  maxTextureDimension2D: 8192,
+  maxTextureDimension3D: 2048,
+  maxTextureArrayLayers: 2048,
   maxBindGroups: 4,
   maxDynamicUniformBuffersPerPipelineLayout: 8,
   maxDynamicStorageBuffersPerPipelineLayout: 4,
