[pull] main from gpuweb:main

package.json

@@ -50,7 +50,7 @@
     "@types/w3c-image-capture": "^1.0.10",
     "@typescript-eslint/eslint-plugin": "^6.9.1",
     "@typescript-eslint/parser": "^6.9.1",
-    "@webgpu/types": "^0.1.49",
+    "@webgpu/types": "^0.1.51",
     "ansi-colors": "4.1.3",
     "babel-plugin-add-header-comment": "^1.0.3",
     "babel-plugin-const-enum": "^1.2.0",

src/webgpu/api/operation/adapter/info.spec.ts

@@ -1,11 +1,12 @@
 export const description = `
-Tests GPUAdapter.info members formatting.
+Tests for GPUAdapterInfo.
 `;
 
 import { Fixture } from '../../../../common/framework/fixture.js';
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
+import { keysOf } from '../../../../common/util/data_tables.js';
 import { getGPU } from '../../../../common/util/navigator_gpu.js';
-import { assert } from '../../../../common/util/util.js';
+import { assert, objectEquals } from '../../../../common/util/util.js';
 
 export const g = makeTestGroup(Fixture);
 
@@ -39,3 +40,99 @@ g.test('adapter_info')
       `adapterInfo.device should be a normalized identifier. But it's '${adapterInfo.device}'`
     );
   });
+
+g.test('same_object')
+  .desc(
+    `
+GPUAdapter.info and GPUDevice.adapterInfo provide the same object each time they're accessed,
+but different objects from one another.`
+  )
+  .fn(async t => {
+    const gpu = getGPU(t.rec);
+    const adapter = await gpu.requestAdapter();
+    assert(adapter !== null);
+    assert(adapter.info instanceof GPUAdapterInfo);
+
+    const adapterInfo1 = adapter.info;
+    const adapterInfo2 = adapter.info;
+    t.expect(adapterInfo1 === adapterInfo2, 'adapter.info should obey [SameObject]');
+
+    const device = await t.requestDeviceTracked(adapter);
+    assert(device !== null);
+    assert(device.adapterInfo instanceof GPUAdapterInfo);
+
+    const deviceAdapterInfo1 = device.adapterInfo;
+    const deviceAdapterInfo2 = device.adapterInfo;
+    t.expect(
+      deviceAdapterInfo1 === deviceAdapterInfo2,
+      'device.adapterInfo should obey [SameObject]'
+    );
+
+    t.expect(
+      adapter.info !== device.adapterInfo,
+      'adapter.info and device.adapterInfo should NOT return the same object'
+    );
+  });
+
+g.test('device_matches_adapter')
+  .desc(
+    `
+Test that GPUDevice.adapterInfo matches GPUAdapter.info. Cases access the members in
+different orders to make sure that they are consistent regardless of the access order.`
+  )
+  .paramsSubcasesOnly(u =>
+    u.combine('testDeviceFirst', [true, false]).combine('testMembersFirst', [true, false])
+  )
+  .fn(async t => {
+    const { testDeviceFirst, testMembersFirst } = t.params;
+
+    const gpu = getGPU(t.rec);
+    const adapter = await gpu.requestAdapter();
+    assert(adapter !== null);
+
+    const device = await t.requestDeviceTracked(adapter);
+    assert(device !== null);
+
+    const deviceInfo: unknown[] = [];
+    const adapterInfo: unknown[] = [];
+
+    const kGPUAdapterInfoKeys = keysOf(GPUAdapterInfo.prototype);
+    if (testMembersFirst) {
+      if (testDeviceFirst) {
+        assert(device.adapterInfo instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          deviceInfo.push(device.adapterInfo[k]);
+        }
+        assert(adapter.info instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          adapterInfo.push(adapter.info[k]);
+        }
+      } else {
+        assert(adapter.info instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          adapterInfo.push(adapter.info[k]);
+        }
+        assert(device.adapterInfo instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          deviceInfo.push(device.adapterInfo[k]);
+        }
+      }
+    } else {
+      if (testDeviceFirst) {
+        assert(device.adapterInfo instanceof GPUAdapterInfo);
+        assert(adapter.info instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          deviceInfo.push(device.adapterInfo[k]);
+          adapterInfo.push(adapter.info[k]);
+        }
+      } else {
+        assert(adapter.info instanceof GPUAdapterInfo);
+        assert(device.adapterInfo instanceof GPUAdapterInfo);
+        for (const k of kGPUAdapterInfoKeys) {
+          adapterInfo.push(adapter.info[k]);
+          deviceInfo.push(device.adapterInfo[k]);
+        }
+      }
+      t.expect(objectEquals(deviceInfo, adapterInfo));
+    }
+  });

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

@@ -126,7 +126,7 @@ const altDataGenerator = new DataArrayGenerator();
 
 class ImageCopyTest extends TextureTestMixin(GPUTest) {
   /**
-   * This is used for testing passing undefined members of `GPUImageDataLayout` instead of actual
+   * This is used for testing passing undefined members of `GPUTexelCopyBufferLayout` instead of actual
    * values where possible. Passing arguments as values and not as objects so that they are passed
    * by copy and not by reference.
    */
@@ -135,7 +135,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     rowsPerImage: number | undefined,
     bytesPerRow: number | undefined,
     changeBeforePass: ChangeBeforePass
-  ): GPUImageDataLayout {
+  ): GPUTexelCopyBufferLayout {
     if (changeBeforePass === 'undefined') {
       if (offset === 0) {
         offset = undefined;
@@ -151,7 +151,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
   }
 
   /**
-   * This is used for testing passing undefined members of `GPUImageCopyTexture` instead of actual
+   * This is used for testing passing undefined members of `GPUTexelCopyTextureInfo` instead of actual
    * values where possible and also for testing passing the origin as `[number, number, number]`.
    * Passing arguments as values and not as objects so that they are passed by copy and not by
    * reference.
@@ -163,7 +163,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     origin_z: number | undefined,
     mipLevel: number | undefined,
     changeBeforePass: ChangeBeforePass
-  ): GPUImageCopyTexture {
+  ): GPUTexelCopyTextureInfo {
     let origin: GPUOrigin3D | undefined = { x: origin_x, y: origin_y, z: origin_z };
 
     if (changeBeforePass === 'undefined') {
@@ -225,7 +225,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     buffer: GPUBuffer,
     format: ColorTextureFormat,
     size: Required<GPUExtent3DDict>,
-    dataLayout: Required<GPUImageDataLayout>
+    dataLayout: Required<GPUTexelCopyBufferLayout>
   ) {
     if (isCompressedTextureFormat(format)) {
       this.expectGPUBufferValuesEqual(buffer, expected);
@@ -323,7 +323,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
   /** Run a CopyT2B command with appropriate arguments corresponding to `ChangeBeforePass` */
   copyTextureToBufferWithAppliedArguments(
     buffer: GPUBuffer,
-    { offset, rowsPerImage, bytesPerRow }: Required<GPUImageDataLayout>,
+    { offset, rowsPerImage, bytesPerRow }: Required<GPUTexelCopyBufferLayout>,
     { width, height, depthOrArrayLayers }: Required<GPUExtent3DDict>,
     { texture, mipLevel, origin }: TextureCopyViewWithRequiredOrigin,
     changeBeforePass: ChangeBeforePass
@@ -363,7 +363,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
   /** Put data into a part of the texture with an appropriate method. */
   uploadLinearTextureDataToTextureSubBox(
     textureCopyView: TextureCopyViewWithRequiredOrigin,
-    textureDataLayout: GPUImageDataLayout & { bytesPerRow: number },
+    textureDataLayout: GPUTexelCopyBufferLayout & { bytesPerRow: number },
     copySize: Required<GPUExtent3DDict>,
     partialData: Uint8Array,
     method: InitMethod,
@@ -432,7 +432,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     copySize: Required<GPUExtent3DDict>,
     format: ColorTextureFormat,
     expected: Uint8Array,
-    expectedDataLayout: Required<GPUImageDataLayout>
+    expectedDataLayout: Required<GPUTexelCopyBufferLayout>
   ): void {
     const size = [
       actualTexture.width,
@@ -507,7 +507,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     checkSize: Required<GPUExtent3DDict>,
     format: ColorTextureFormat,
     expected: Uint8Array,
-    expectedDataLayout: Required<GPUImageDataLayout>,
+    expectedDataLayout: Required<GPUTexelCopyBufferLayout>,
     changeBeforePass: ChangeBeforePass = 'none'
   ): void {
     // The alignment is necessary because we need to copy and map data from this buffer.
@@ -573,7 +573,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
   copyWholeTextureToBufferAndCheckContentsWithUpdatedData(
     { texture, mipLevel, origin }: TextureCopyViewWithRequiredOrigin,
     fullTextureCopyLayout: TextureCopyLayout,
-    texturePartialDataLayout: Required<GPUImageDataLayout>,
+    texturePartialDataLayout: Required<GPUTexelCopyBufferLayout>,
     copySize: Required<GPUExtent3DDict>,
     format: ColorTextureFormat,
     fullData: GPUBuffer,
@@ -632,7 +632,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
     checkMethod,
     changeBeforePass = 'none',
   }: {
-    textureDataLayout: Required<GPUImageDataLayout>;
+    textureDataLayout: Required<GPUTexelCopyBufferLayout>;
     copySize: Required<GPUExtent3DDict>;
     dataSize: number;
     mipLevel?: number;

src/webgpu/api/operation/vertex_state/correctness.spec.ts

@@ -427,25 +427,51 @@ struct VSOutputs {
 
       case 'unorm': {
         if (formatInfo.bytesPerComponent === 'packed') {
-          assert(format === 'unorm10-10-10-2'); // This is the only packed format for now.
           assert(bitSize === 0);
 
-          /* prettier-ignore */
-          const data = [
-            [   0,    0,    0, 0],
-            [1023, 1023, 1023, 3],
-            [ 243,  567,  765, 2],
-          ];
-          const vertexData = new Uint32Array(data.map(makeRgb10a2)).buffer;
-          const expectedData = new Float32Array(data.flat().map(normalizeRgb10a2)).buffer;
-
-          return {
-            shaderBaseType: 'f32',
-            testComponentCount: data.flat().length,
-            expectedData,
-            vertexData,
-            floatTolerance: 0.1 / 1023,
-          };
+          switch (format) {
+            case 'unorm10-10-10-2': {
+              /* prettier-ignore */
+              const data = [
+              [   0,    0,    0, 0],
+              [1023, 1023, 1023, 3],
+              [ 243,  567,  765, 2],
+            ];
+              const vertexData = new Uint32Array(data.map(makeRgb10a2)).buffer;
+              const expectedData = new Float32Array(data.flat().map(normalizeRgb10a2)).buffer;
+
+              return {
+                shaderBaseType: 'f32',
+                testComponentCount: data.flat().length,
+                expectedData,
+                vertexData,
+                floatTolerance: 0.1 / 1023,
+              };
+            }
+
+            case 'unorm8x4-bgra': {
+              const data = [42, 0, 1, 2, 3, 4, 128, 255];
+              const vertexData = new Uint8Array(data).buffer;
+              const expectedData = new Float32Array(
+                data.map(v => normalizedIntegerAsFloat(v, 8, false))
+              );
+
+              for (let i = 0; i + 2 < expectedData.length; i += 4) {
+                const r = expectedData[i + 0];
+                const b = expectedData[i + 2];
+                expectedData[i + 0] = b;
+                expectedData[i + 2] = r;
+              }
+
+              return {
+                shaderBaseType: 'f32',
+                testComponentCount: data.length,
+                expectedData: expectedData.buffer,
+                vertexData,
+                floatTolerance: 0.1 / 255,
+              };
+            }
+          }
         }
 
         /* prettier-ignore */

src/webgpu/api/validation/capability_checks/limits/maxTextureDimension2D.spec.ts

@@ -59,7 +59,7 @@ g.test('configure,at_over')
 
           // This should not fail, even if the size is too large but it might fail
           // if we're in a worker and HTMLCanvasElement does not exist.
-          const canvas = createCanvas(t, canvasType, size[0], size[1])!;
+          const canvas = createCanvas(t, canvasType, size[0], size[1]);
           if (canvas) {
             const context = canvas.getContext('webgpu') as GPUCanvasContext;
             t.expect(!!context, 'should not fail to create context even if size is too large');
@@ -96,7 +96,7 @@ g.test('getCurrentTexture,at_over')
           // Start with a small size so configure will succeed.
           // This should not fail, even if the size is too large but it might fail
           // if we're in a worker and HTMLCanvasElement does not exist.
-          const canvas = createCanvas(t, canvasType, 1, 1)!;
+          const canvas = createCanvas(t, canvasType, 1, 1);
           if (canvas) {
             const context = canvas.getContext('webgpu') as GPUCanvasContext;
             t.expect(!!context, 'should not fail to create context even if size is too large');

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

@@ -718,6 +718,7 @@ g.test('resource_compatibility')
         !t.hasLanguageFeature('readonly_and_readwrite_storage_textures'),
       'Storage textures require language feature'
     );
+    t.skipIfTextureViewDimensionNotSupported(wgslResource.texture?.viewDimension);
 
     const layout = t.device.createPipelineLayout({
       bindGroupLayouts: [

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

@@ -19,8 +19,8 @@ import { ValidationTest } from '../../validation_test.js';
 
 class F extends ValidationTest {
   TestCopyTextureToTexture(
-    source: GPUImageCopyTexture,
-    destination: GPUImageCopyTexture,
+    source: GPUTexelCopyTextureInfo,
+    destination: GPUTexelCopyTextureInfo,
     copySize: GPUExtent3D,
     expectation: 'Success' | 'FinishError' | 'SubmitError'
   ): void {
@@ -691,7 +691,7 @@ TODO: Extend to 1D and 3D textures.`
 g.test('copy_aspects')
   .desc(
     `
-Test the validations on the member 'aspect' of GPUImageCopyTexture in CopyTextureToTexture().
+Test the validations on the member 'aspect' of GPUTexelCopyTextureInfo in CopyTextureToTexture().
 - for all the color and depth-stencil formats: the texture copy aspects must be both 'all'.
 - for all the depth-only formats: the texture copy aspects must be either 'all' or 'depth-only'.
 - for all the stencil-only formats: the texture copy aspects must be either 'all' or 'stencil-only'.