Clean up deprecated .copyDst/.renderable/.renderTarget* from kTexture…

…FormatInfo (#3412)

* Refactor deprecated .copyDst/.renderable in texture_zero_init_test.ts

* Remove no-op use of .renderable in texture_zero_init_test.ts

* Refactor deprecated .renderable in createTexture.spec.ts

* Remove deprecated .copyDst

* Remove deprecated .renderable

* Remove unused .renderTarget{ComponentAlignment,PixelByteCost}

.renderTargetComponentAlignment = .colorRender.alignment
.renderTargetPixelByteCost = .colorRender.byteCost

The one exception to this is rg11b10ufloat, which is not renderable in
core, but has an extension for renderability. kTextureFormatInfo
currently only expresses core capabilities. The alignment and byteCost
for this format will need to be added back when the refactor is done to
make a table for "static" properties of texture formats (which never
vary based on capabilities) - shape of that refactor is TBD.

* Refactor trivial uses of deprecated .bytesPerBlock

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

@@ -1595,7 +1595,7 @@ works for every format with 2d and 2d-array textures.
     };
     let textureHeight = 4 * info.blockHeight;
     let rowsPerImage = rowsPerImageEqualsCopyHeight ? copyHeight : copyHeight + 1;
-    const bytesPerRow = align(copyWidth * info.bytesPerBlock, 256);
+    const bytesPerRow = align(copyWidth * info.color.bytes, 256);
 
     if (dimension === '1d') {
       copySize.height = 1;

src/webgpu/api/operation/rendering/depth_clip_clamp.spec.ts

@@ -4,6 +4,7 @@ depth ranges as well.
 `;
 
 import { makeTestGroup } from '../../../../common/framework/test_group.js';
+import { assert } from '../../../../common/util/util.js';
 import { kDepthStencilFormats, kTextureFormatInfo } from '../../../format_info.js';
 import { GPUTest } from '../../../gpu_test.js';
 import {
@@ -52,6 +53,7 @@ have unexpected values then get drawn to the color buffer, which is later checke
   .fn(async t => {
     const { format, unclippedDepth, writeDepth, multisampled } = t.params;
     const info = kTextureFormatInfo[format];
+    assert(!!info.depth);
 
     /** Number of depth values to test for both vertex output and frag_depth output. */
     const kNumDepthValues = 8;
@@ -222,16 +224,16 @@ have unexpected values then get drawn to the color buffer, which is later checke
       : undefined;
 
     const dsActual =
-      !multisampled && info.bytesPerBlock
+      !multisampled && info.depth.bytes
         ? t.device.createBuffer({
-            size: kNumTestPoints * info.bytesPerBlock,
+            size: kNumTestPoints * info.depth.bytes,
             usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
           })
         : undefined;
     const dsExpected =
-      !multisampled && info.bytesPerBlock
+      !multisampled && info.depth.bytes
         ? t.device.createBuffer({
-            size: kNumTestPoints * info.bytesPerBlock,
+            size: kNumTestPoints * info.depth.bytes,
             usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
           })
         : undefined;

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

@@ -115,6 +115,14 @@ const initializedStateAsStencil = {
   [InitializedState.Canary]: 42,
 };
 
+function allAspectsCopyDst(info: (typeof kTextureFormatInfo)[UncompressedTextureFormat]) {
+  return (
+    (!info.color || info.color.copyDst) &&
+    (!info.depth || info.depth.copyDst) &&
+    (!info.stencil || info.stencil.copyDst)
+  );
+}
+
 export function getRequiredTextureUsage(
   format: UncompressedTextureFormat,
   sampleCount: number,
@@ -159,10 +167,11 @@ export function getRequiredTextureUsage(
     usage |= GPUConst.TextureUsage.RENDER_ATTACHMENT;
   }
 
-  if (!kTextureFormatInfo[format].copyDst) {
+  const info = kTextureFormatInfo[format];
+  if (!allAspectsCopyDst(info)) {
     // Copies are not possible. We need OutputAttachment to initialize
     // canary data.
-    assert(kTextureFormatInfo[format].renderable);
+    if (info.color) assert(!!info.colorRender, 'not implemented for non-renderable color');
     usage |= GPUConst.TextureUsage.RENDER_ATTACHMENT;
   }
 
@@ -388,10 +397,11 @@ export class TextureZeroInitTest extends GPUTest {
     state: InitializedState,
     subresourceRange: SubresourceRange
   ): void {
-    if (this.p.sampleCount > 1 || !kTextureFormatInfo[this.p.format].copyDst) {
+    const info = kTextureFormatInfo[this.p.format];
+    if (this.p.sampleCount > 1 || !allAspectsCopyDst(info)) {
       // Copies to multisampled textures not yet specified.
       // Use a storeOp for now.
-      assert(kTextureFormatInfo[this.p.format].renderable);
+      if (info.color) assert(!!info.colorRender, 'not implemented for non-renderable color');
       this.initializeWithStoreOp(state, texture, subresourceRange);
     } else {
       this.initializeWithCopy(texture, state, subresourceRange);
@@ -517,20 +527,15 @@ export const kTestParams = kUnitCaseParamsBuilder
     const info = kTextureFormatInfo[format];
 
     return (
-      ((usage & GPUConst.TextureUsage.RENDER_ATTACHMENT) !== 0 && !info.renderable) ||
+      ((usage & GPUConst.TextureUsage.RENDER_ATTACHMENT) !== 0 &&
+        info.color &&
+        !info.colorRender) ||
       ((usage & GPUConst.TextureUsage.STORAGE_BINDING) !== 0 && !info.color?.storage) ||
       (sampleCount > 1 && !info.multisample)
     );
   })
   .combine('nonPowerOfTwo', [false, true])
-  .combine('canaryOnCreation', [false, true])
-  .filter(({ canaryOnCreation, format }) => {
-    // We can only initialize the texture if it's encodable or renderable.
-    const canInitialize = format in kTextureFormatInfo || kTextureFormatInfo[format].renderable;
-
-    // Filter out cases where we want canary values but can't initialize.
-    return !canaryOnCreation || canInitialize;
-  });
+  .combine('canaryOnCreation', [false, true]);
 
 type TextureZeroParams = ParamTypeOf<typeof kTestParams>;
 

src/webgpu/api/operation/storage_texture/read_only.spec.ts

@@ -51,7 +51,7 @@ class F extends GPUTest {
     storageTexture: GPUTexture,
     format: ColorTextureFormat
   ): ArrayBuffer {
-    const bytesPerBlock = kTextureFormatInfo[format].bytesPerBlock;
+    const bytesPerBlock = kTextureFormatInfo[format].color.bytes;
     assert(bytesPerBlock !== undefined);
 
     const width = storageTexture.width;

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

@@ -299,7 +299,7 @@ g.test('sampleCount,various_sampleCount_with_all_formats')
       usage,
     };
 
-    const success = sampleCount === 1 || (sampleCount === 4 && info.multisample && info.renderable);
+    const success = sampleCount === 1 || (sampleCount === 4 && info.multisample);
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);
@@ -1066,16 +1066,13 @@ g.test('texture_usage')
     // Note that we unconditionally test copy usages for all formats. We don't check copySrc/copyDst in kTextureFormatInfo in capability_info.js
     // if (!info.copySrc && (usage & GPUTextureUsage.COPY_SRC) !== 0) success = false;
     // if (!info.copyDst && (usage & GPUTextureUsage.COPY_DST) !== 0) success = false;
-    if (
-      (usage & GPUTextureUsage.STORAGE_BINDING) !== 0 &&
-      !isTextureFormatUsableAsStorageFormat(format, t.isCompatibility)
-    )
-      success = false;
-    if (
-      (!info.renderable || (appliedDimension !== '2d' && appliedDimension !== '3d')) &&
-      (usage & GPUTextureUsage.RENDER_ATTACHMENT) !== 0
-    )
-      success = false;
+    if (usage & GPUTextureUsage.STORAGE_BINDING) {
+      if (!isTextureFormatUsableAsStorageFormat(format, t.isCompatibility)) success = false;
+    }
+    if (usage & GPUTextureUsage.RENDER_ATTACHMENT) {
+      if (appliedDimension === '1d') success = false;
+      if (info.color && !info.colorRender) success = false;
+    }
 
     t.expectValidationError(() => {
       t.device.createTexture(descriptor);

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

@@ -440,7 +440,7 @@ Test that the copy size must be aligned to the texture's format's block size.
     const texture = t.createAlignedTexture(format, size, origin, dimension);
 
     const bytesPerRow = align(
-      Math.max(1, Math.ceil(size.width / info.blockWidth)) * info.bytesPerBlock,
+      Math.max(1, Math.ceil(size.width / info.blockWidth)) * info.color.bytes,
       256
     );
     const rowsPerImage = Math.ceil(size.height / info.blockHeight);

src/webgpu/compat/api/validation/encoding/cmds/copyTextureToBuffer.spec.ts

@@ -19,16 +19,17 @@ g.test('compressed')
   .fn(t => {
     const { format } = t.params;
 
-    const { blockWidth, blockHeight, bytesPerBlock } = kTextureFormatInfo[format];
+    const info = kTextureFormatInfo[format];
 
+    const textureSize = [info.blockWidth, info.blockHeight, 1];
     const texture = t.device.createTexture({
-      size: [blockWidth, blockHeight, 1],
+      size: textureSize,
       format,
       usage: GPUTextureUsage.COPY_SRC,
     });
     t.trackForCleanup(texture);
 
-    const bytesPerRow = align(bytesPerBlock, 256);
+    const bytesPerRow = align(info.color.bytes, 256);
 
     const buffer = t.device.createBuffer({
       size: bytesPerRow,
@@ -37,7 +38,7 @@ g.test('compressed')
     t.trackForCleanup(buffer);
 
     const encoder = t.device.createCommandEncoder();
-    encoder.copyTextureToBuffer({ texture }, { buffer, bytesPerRow }, [blockWidth, blockHeight, 1]);
+    encoder.copyTextureToBuffer({ texture }, { buffer, bytesPerRow }, textureSize);
     t.expectGPUError('validation', () => {
       encoder.finish();
     });