🏡 index : cold-air-networks/mirror-webgpu-cts.git

import { assert, unreachable } from '../../common/util/util.js';
import {
  getBlockInfoForTextureFormat,
  isDepthOrStencilTextureFormat,
  isDepthStencilTextureFormat,
  isDepthTextureFormat,
  isSintOrUintFormat,
  isStencilTextureFormat,
} from '../format_info.js';
import { GPUTestBase } from '../gpu_test.js';

import { getTextureCopyLayout } from './texture/layout.js';
import { TexelView } from './texture/texel_view.js';
import { reifyExtent3D, reifyOrigin3D } from './unions.js';

// Note: For values that are supposedly unused we use 0.123 as a sentinel for
// float formats and 123 for integer formats. For example, rendering to r8unorm
// returns (v, 9.123, 0.123, 0.123). Since only v should be used this shouldn't
// matter but just in case we set it to 123 so it's more likely to cause an
// issue if something is wrong.
const kLoadValueFromStorageInfo: Partial<{
  [k in GPUTextureFormat]: {
    storageType: string;
    texelType: string;
    unpackWGSL: string;
  };
}> = {
  r8snorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    return vec4f(unpack4x8snorm(getSrc(byteOffset / 4))[byteOffset % 4], 0.123, 0.123, 0.123)
  `,
  },
  r8unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    return vec4f(unpack4x8unorm(getSrc(byteOffset / 4))[byteOffset % 4], 0.123, 0.123, 0.123)
  `,
  },
  r8uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
    return vec4u(unpack4xU8(getSrc(byteOffset / 4))[byteOffset % 4], 123, 123, 123)
  `,
  },
  r8sint: {
    storageType: 'u32',
    texelType: 'vec4i',
    unpackWGSL: `
    return vec4i(unpack4xI8(getSrc(byteOffset / 4))[byteOffset % 4], 123, 123, 123)
  `,
  },
  rg8snorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v = unpack4x8snorm(getSrc(byteOffset / 4));
    return vec4f(select(v.rg, v.ba, byteOffset % 4 >= 2), 0.123, 0.123)
  `,
  },
  rg8unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v = unpack4x8unorm(getSrc(byteOffset / 4));
    return vec4f(select(v.rg, v.ba, byteOffset % 4 >= 2), 0.123, 0.123)
  `,
  },
  rg8uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
    let v = unpack4xU8(getSrc(byteOffset / 4));
    return vec4u(select(v.rg, v.ba, byteOffset % 4 >= 2), 123, 123)
  `,
  },
  rg8sint: {
    storageType: 'u32',
    texelType: 'vec4i',
    unpackWGSL: `
    let v = unpack4xI8(getSrc(byteOffset / 4));
    return vec4i(select(v.rg, v.ba, byteOffset % 4 >= 2), 123, 123)
  `,
  },
  rgba8snorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: 'return unpack4x8snorm(getSrc(byteOffset / 4))',
  },
  rgba8unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: 'return unpack4x8unorm(getSrc(byteOffset / 4))',
  },
  'rgba8unorm-srgb': {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
      let v = unpack4x8unorm(getSrc(byteOffset / 4));
      let srgb = select(
        v / 12.92,
        pow((v + 0.055) / 1.055, vec4f(2.4)),
        v >= vec4f(0.04045)
      );
      return vec4f(srgb.rgb, v.a);
    `,
  },
  bgra8unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: 'return unpack4x8unorm(getSrc(byteOffset / 4)).bgra',
  },
  'bgra8unorm-srgb': {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
      let v = unpack4x8unorm(getSrc(byteOffset / 4));
      let srgb = select(
        v / 12.92,
        pow((v + 0.055) / 1.055, vec4f(2.4)),
        v >= vec4f(0.04045)
      );
      return vec4f(srgb.bgr, v.a);
    `,
  },
  rgba8uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: 'return unpack4xU8(getSrc(byteOffset / 4))',
  },
  rgba8sint: {
    storageType: 'u32',
    texelType: 'vec4i',
    unpackWGSL: 'return unpack4xI8(getSrc(byteOffset / 4))',
  },
  rg11b10ufloat: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `return unpackRG11B10UFloat(getSrc(byteOffset / 4))`,
  },
  r16float: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL:
      'return vec4f(unpack2x16float(getSrc(byteOffset / 4))[byteOffset % 4 / 2], 0.123, 0.123, 0.123)',
  },
  r16uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL:
      'return vec4u(extractBits(getSrc(byteOffset / 4), (byteOffset % 4 / 2 * 16), 16), 123, 123, 123)',
  },
  r16sint: {
    storageType: 'i32',
    texelType: 'vec4i',
    unpackWGSL:
      'return vec4i(extractBits(getSrc(byteOffset / 4), byteOffset % 4 / 2 * 16, 16), 123, 123, 123)',
  },
  rg16float: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: 'return vec4f(unpack2x16float(getSrc(byteOffset / 4)), 0.123, 0.123)',
  },
  rg16uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
      let v = getSrc(byteOffset / 4);
      return vec4u(v & 0xFFFF, v >> 16, 123, 123)
    `,
  },
  rg16sint: {
    storageType: 'i32',
    texelType: 'vec4i',
    unpackWGSL: `
      let v = getSrc(byteOffset / 4);
      return vec4i(
        extractBits(v, 0, 16),
        extractBits(v, 16, 16),
        123, 123)
    `,
  },
  rgba16float: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
      return vec4f(
        unpack2x16float(getSrc(byteOffset / 4)),
        unpack2x16float(getSrc(byteOffset / 4 + 1)))
    `,
  },
  rgba16uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
      let v0 = getSrc(byteOffset / 4);
      let v1 = getSrc(byteOffset / 4 + 1);
      return vec4u(v0 & 0xFFFF, v0 >> 16, v1 & 0xFFFF, v1 >> 16)
    `,
  },
  rgba16sint: {
    storageType: 'i32',
    texelType: 'vec4i',
    unpackWGSL: `
      let v0 = getSrc(byteOffset / 4);
      let v1 = getSrc(byteOffset / 4 + 1);
      return vec4i(
        extractBits(v0, 0, 16),
        extractBits(v0, 16, 16),
        extractBits(v1, 0, 16),
        extractBits(v1, 16, 16),
      )
    `,
  },
  r16unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    let raw = extractBits(getSrc(byteOffset / 4), (byteOffset % 4 / 2) * 16, 16);
    return vec4f(f32(raw) / 65535.0, 0.123, 0.123, 0.123);
  `,
  },
  r16snorm: {
    storageType: 'i32',
    texelType: 'vec4f',
    unpackWGSL: `
    let raw = extractBits(getSrc(byteOffset / 4), (byteOffset % 4 / 2) * 16, 16);
    let signedVal = i32(raw);
    return vec4f(f32(signedVal) / 32767.0, 0.123, 0.123, 0.123);
  `,
  },
  rg16unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v = getSrc(byteOffset / 4);
    let r = extractBits(v, 0, 16);
    let g = extractBits(v, 16, 16);
    return vec4f(f32(r) / 65535.0, f32(g) / 65535.0, 0.123, 0.123);
  `,
  },
  rg16snorm: {
    storageType: 'i32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v = getSrc(byteOffset / 4);
    let r = i32(extractBits(v, 0, 16));
    let g = i32(extractBits(v, 16, 16));
    return vec4f(f32(r) / 32767.0, f32(g) / 32767.0, 0.123, 0.123);
  `,
  },
  rgba16unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v0 = getSrc(byteOffset / 4);
    let v1 = getSrc(byteOffset / 4 + 1);
    let r = extractBits(v0, 0, 16);
    let g = extractBits(v0, 16, 16);
    let b = extractBits(v1, 0, 16);
    let a = extractBits(v1, 16, 16);
    return vec4f(
      f32(r) / 65535.0,
      f32(g) / 65535.0,
      f32(b) / 65535.0,
      f32(a) / 65535.0
    );
  `,
  },
  rgba16snorm: {
    storageType: 'i32',
    texelType: 'vec4f',
    unpackWGSL: `
    let v0 = getSrc(byteOffset / 4);
    let v1 = getSrc(byteOffset / 4 + 1);
    let r = i32(extractBits(v0, 0, 16));
    let g = i32(extractBits(v0, 16, 16));
    let b = i32(extractBits(v1, 0, 16));
    let a = i32(extractBits(v1, 16, 16));
    return vec4f(
      f32(r) / 32767.0,
      f32(g) / 32767.0,
      f32(b) / 32767.0,
      f32(a) / 32767.0
    );
  `,
  },
  r32float: {
    storageType: 'f32',
    texelType: 'vec4f',
    unpackWGSL: 'return vec4f(getSrc(byteOffset / 4), 0.123, 0.123, 0.123)',
  },
  rgb10a2uint: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
      let v = getSrc(byteOffset / 4);
      return vec4u(
        extractBits(v, 0, 10),
        extractBits(v, 10, 10),
        extractBits(v, 20, 10),
        extractBits(v, 30, 2),
      )
    `,
  },
  rgb10a2unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
      let v = getSrc(byteOffset / 4);
      return vec4f(
        f32(extractBits(v, 0, 10)) / f32(0x3FF),
        f32(extractBits(v, 10, 10)) / f32(0x3FF),
        f32(extractBits(v, 20, 10)) / f32(0x3FF),
        f32(extractBits(v, 30, 2)) / f32(0x3),
      )
    `,
  },
  depth16unorm: {
    storageType: 'u32',
    texelType: 'vec4f',
    unpackWGSL: `
      let v = unpack2x16unorm(getSrc(byteOffset / 4))[byteOffset % 4 / 2];
      return vec4f(v, 0.123, 0.123, 0.123)
    `,
  },
  depth32float: {
    storageType: 'f32',
    texelType: 'vec4f',
    unpackWGSL: `
      let v = getSrc(byteOffset / 4);
      return vec4f(v, 0.123, 0.123, 0.123)
    `,
  },
  stencil8: {
    storageType: 'u32',
    texelType: 'vec4u',
    unpackWGSL: `
      return vec4u(unpack4xU8(getSrc(byteOffset / 4))[byteOffset % 4], 123, 123, 123)
    `,
  },
};

function getDepthStencilOptionsForFormat(
  format: GPUTextureFormat,
  aspect: GPUTextureAspect | undefined
) {
  return {
    useFragDepth:
      isDepthTextureFormat(format) && (!aspect || aspect === 'all' || aspect === 'depth-only'),
    discardWithStencil:
      isStencilTextureFormat(format) && (!aspect || aspect === 'all' || aspect === 'stencil-only'),
  };
}

function getCopyBufferToTextureViaRenderCode(
  srcFormat: GPUTextureFormat,
  dstFormat: GPUTextureFormat,
  dstAspect: GPUTextureAspect | undefined
) {
  const info = kLoadValueFromStorageInfo[srcFormat];
  assert(!!info);
  const { storageType, texelType, unpackWGSL } = info;
  const { useFragDepth, discardWithStencil } = getDepthStencilOptionsForFormat(
    dstFormat,
    dstAspect
  );
  assert(!useFragDepth || !discardWithStencil, 'can not do both aspects at once');

  const [depthDecl, depthCode] = useFragDepth
    ? ['@builtin(frag_depth) d: f32,', 'fs.d = fs.v[0];']
    : ['', ''];

  const stencilCode = discardWithStencil ? 'if ((fs.v.r & vin.stencilMask) == 0) { discard; }' : '';

  const code = `
    struct Uniforms {
      numTexelRows: u32,
      bytesPerRow: u32,
      bytesPerSample: u32,
      sampleCount: u32,
      offset: u32,
    };

    struct VSOutput {
      @builtin(position) pos: vec4f,
      @location(0) @interpolate(flat, either) sampleIndex: u32,
      @location(1) @interpolate(flat, either) stencilMask: u32,
    };

    @vertex fn vs(@builtin(vertex_index) vNdx: u32, @builtin(instance_index) iNdx: u32) -> VSOutput {
      let points = array(
        vec2f(0, 0), vec2f(1, 0), vec2f(0, 1), vec2f(1, 1),
      );
      let sampleRow = vNdx / 4;
      let numSampleRows = f32(uni.numTexelRows * uni.sampleCount);
      let rowOffset = f32(sampleRow) / numSampleRows;
      let rowMult = 1.0 / numSampleRows;
      let p = (points[vNdx % 4] * vec2f(1, rowMult) + vec2f(0, rowOffset)) * 2.0 - 1.0;
      return VSOutput(
        vec4f(p, 0, 1),
        uni.sampleCount - sampleRow % uni.sampleCount - 1,
        1u << iNdx);
    }

    @group(0) @binding(0) var<uniform> uni: Uniforms;
    @group(0) @binding(1) var src: texture_2d<${storageType}>;

    // get a u32/i32/f32 from a r32uint/r32sint/r32float as though it was 1d array
    fn getSrc(offset: u32) -> ${storageType} {
      let width = textureDimensions(src, 0).x;
      let x = offset % width;
      let y = offset / width;
      return textureLoad(src, vec2u(x, y), 0).r;
    }

    const kFloat32FormatMantissaBits = 23;
    const kFloat32FormatBias = 127;
    fn floatBitsToNumber(
        rawBits: u32,
        bitOffset: u32,
        exponentBits: u32,
        mantissaBits: u32,
        bias: u32,
        signed: bool) -> f32 {
      let nonSignBits = exponentBits + mantissaBits;
      let allBits = nonSignBits + select(0u, 1u, signed);
      let allMask = (1u << allBits) - 1u;
      let bits = (rawBits >> bitOffset) & allMask;
      let nonSignBitsMask = (1u << nonSignBits) - 1u;
      let exponentAndMantissaBits = bits & nonSignBitsMask;
      let exponentMask = ((1u << exponentBits) - 1u) << mantissaBits;
      let infinityOrNaN = (bits & exponentMask) == exponentMask;
      if (infinityOrNaN) {
        let mantissaMask = (1u << mantissaBits) - 1;
        let signBit = 1u << nonSignBits;
        let isNegative = (bits & signBit) != 0;
        if ((bits & mantissaMask) != 0u) {
          return 0.0; // NaN (does not exist in WGSL)
        }
        if (isNegative) {
          return f32(-2e38); // NEGATIVE_INFINITY (does not exist in WGSL)
        } else {
          return f32(2e38); // POSITIVE_INFINITY (does not exist in WGSL)
        }
      }
      var f32BitsWithWrongBias =
        exponentAndMantissaBits << (kFloat32FormatMantissaBits - mantissaBits);
      // add in the sign
      f32BitsWithWrongBias |= (bits << (31u - nonSignBits)) & 0x80000000u;
      let numberWithWrongBias = bitcast<f32>(f32BitsWithWrongBias);
      return numberWithWrongBias * pow(2.0f, f32(kFloat32FormatBias - bias));
    }

    fn unpackRG11B10UFloat(v: u32) -> vec4f {
      return vec4f(
        floatBitsToNumber(v,  0, 5, 6, 15, false),
        floatBitsToNumber(v, 11, 5, 6, 15, false),
        floatBitsToNumber(v, 22, 5, 5, 15, false),
        1
      );
    }

    fn unpack(byteOffset: u32) -> ${texelType} {
      ${unpackWGSL};
    }

    struct FSOutput {
      @location(0) v: ${texelType},
      ${depthDecl}
    };

    @fragment fn fs(vin: VSOutput) -> FSOutput {
      let coord = vec2u(vin.pos.xy);
      let byteOffset =
        uni.offset +
        coord.y * uni.bytesPerRow +
        (coord.x * uni.sampleCount + vin.sampleIndex) * uni.bytesPerSample;
      var fs: FSOutput;
      fs.v = unpack(byteOffset);
      ${depthCode}
      ${stencilCode}
      return fs;
    }
    `;

  let dataFormat: GPUTextureFormat;
  switch (storageType) {
    case 'f32':
      dataFormat = 'r32float';
      break;
    case 'i32':
      dataFormat = 'r32sint';
      break;
    case 'u32':
      dataFormat = 'r32uint';
      break;
    default:
      unreachable();
  }
  return { code, dataFormat };
}

const s_copyBufferToTextureViaRenderPipelines = new WeakMap<
  GPUDevice,
  Map<string, GPURenderPipeline>
>();

// This function emulates copyBufferToTexture by by rendering into the texture.
// This is for formats that can't be copied to directly. depth textures, stencil
// textures, multisampled textures.
//
// For source data it creates an r32uint/r32sint/r32float texture
// and copies the source buffer into it and then reads the texture
// as a 1d array. It does this because compat mode might not have
// storage buffers in fragment shaders.
function copyBufferToTextureViaRender(
  t: GPUTestBase,
  encoder: GPUCommandEncoder,
  source: GPUTexelCopyBufferInfo,
  sourceFormat: GPUTextureFormat,
  dest: GPUTexelCopyTextureInfo,
  size: GPUExtent3D
) {
  const { format: textureFormat, sampleCount } = dest.texture;
  const origin = reifyOrigin3D(dest.origin ?? [0]);
  const copySize = reifyExtent3D(size);
  const { useFragDepth, discardWithStencil } = getDepthStencilOptionsForFormat(
    dest.texture.format,
    dest.aspect
  );
  const resourcesToDestroy: (GPUTexture | GPUBuffer)[] = [];

  const { device } = t;
  const numBlits = discardWithStencil ? 8 : 1;
  for (let blitCount = 0; blitCount < numBlits; ++blitCount) {
    const { code, dataFormat } = getCopyBufferToTextureViaRenderCode(
      sourceFormat,
      dest.texture.format,
      dest.aspect
    );
    const stencilWriteMask = 1 << blitCount;
    const id = JSON.stringify({
      textureFormat,
      sourceFormat,
      useFragDepth,
      stencilWriteMask,
      discardWithStencil,
      sampleCount,
      code,
    });
    const pipelines =
      s_copyBufferToTextureViaRenderPipelines.get(device) ?? new Map<string, GPURenderPipeline>();
    s_copyBufferToTextureViaRenderPipelines.set(device, pipelines);
    let pipeline = pipelines.get(id);
    if (!pipeline) {
      const module = device.createShaderModule({ code });
      pipeline = device.createRenderPipeline({
        label: `blitCopyFor-${textureFormat}`,
        layout: 'auto',
        vertex: { module },
        ...(discardWithStencil
          ? {
              fragment: {
                module,
                targets: [],
              },
              depthStencil: {
                depthWriteEnabled: false,
                depthCompare: 'always',
                format: textureFormat,
                stencilWriteMask,
                stencilFront: {
                  passOp: 'replace',
                },
              },
            }
          : useFragDepth
          ? {
              fragment: {
                module,
                targets: [],
              },
              depthStencil: {
                depthWriteEnabled: true,
                depthCompare: 'always',
                format: textureFormat,
              },
            }
          : {
              fragment: {
                module,
                targets: [{ format: textureFormat }],
              },
            }),
        primitive: {
          topology: 'triangle-strip',
        },
        ...(sampleCount > 1 && { multisample: { count: sampleCount } }),
      });
      pipelines.set(id, pipeline);
    }

    const width = 1024;
    const bytesPerRow = width * 4;
    const fullRows = Math.floor(source.buffer.size / bytesPerRow);
    const rows = Math.ceil(source.buffer.size / bytesPerRow);
    const srcTexture = t.createTextureTracked({
      format: dataFormat,
      size: [width, rows],
      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
    });
    resourcesToDestroy.push(srcTexture);

    if (fullRows > 0) {
      encoder.copyBufferToTexture({ buffer: source.buffer, bytesPerRow }, { texture: srcTexture }, [
        width,
        fullRows,
      ]);
    }
    if (rows > fullRows) {
      const totalPixels = source.buffer.size / 4;
      const pixelsCopied = fullRows * width;
      const pixelsInLastRow = totalPixels - pixelsCopied;
      encoder.copyBufferToTexture(
        {
          buffer: source.buffer,
          offset: pixelsCopied * 4,
          bytesPerRow,
        },
        {
          texture: srcTexture,
          origin: [0, fullRows],
        },
        [pixelsInLastRow, 1]
      );
    }
    const baseMipLevel = dest.mipLevel;
    for (let l = 0; l < copySize.depthOrArrayLayers; ++l) {
      const baseArrayLayer = origin.z + l;
      const mipLevelCount = 1;
      const arrayLayerCount = 1;
      const pass = encoder.beginRenderPass(
        discardWithStencil
          ? {
              colorAttachments: [],
              depthStencilAttachment: {
                view: dest.texture.createView({
                  baseMipLevel,
                  baseArrayLayer,
                  mipLevelCount,
                  arrayLayerCount,
                }),
                depthReadOnly: true,
                stencilClearValue: 0,
                stencilLoadOp: 'load',
                stencilStoreOp: 'store',
              },
            }
          : useFragDepth
          ? {
              colorAttachments: [],
              depthStencilAttachment: {
                view: dest.texture.createView({
                  baseMipLevel,
                  baseArrayLayer,
                  mipLevelCount,
                  arrayLayerCount,
                }),
                depthClearValue: 0,
                depthLoadOp: 'clear',
                depthStoreOp: 'store',
                stencilReadOnly: true,
              },
            }
          : {
              colorAttachments: [
                {
                  view: dest.texture.createView({
                    baseMipLevel,
                    baseArrayLayer,
                    mipLevelCount,
                    arrayLayerCount,
                  }),
                  loadOp: 'clear',
                  storeOp: 'store',
                },
              ],
            }
      );
      pass.setViewport(origin.x, origin.y, copySize.width, copySize.height, 0, 1);
      pass.setPipeline(pipeline);

      const info = getBlockInfoForTextureFormat(sourceFormat);
      const offset =
        (source.offset ?? 0) + (source.bytesPerRow ?? 0) * (source.rowsPerImage ?? 0) * l;
      const uniforms = new Uint32Array([
        copySize.height, //  numTexelRows: u32,
        source.bytesPerRow!, //  bytesPerRow: u32,
        info.bytesPerBlock!, //  bytesPerSample: u32,
        dest.texture.sampleCount, //  sampleCount: u32,
        offset, //  offset: u32,
      ]);

      const uniformBuffer = t.makeBufferWithContents(
        uniforms,
        GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM
      );
      resourcesToDestroy.push(uniformBuffer);
      const bindGroup = device.createBindGroup({
        layout: pipeline.getBindGroupLayout(0),
        entries: [
          { binding: 0, resource: { buffer: uniformBuffer } },
          { binding: 1, resource: srcTexture.createView() },
        ],
      });

      pass.setBindGroup(0, bindGroup);
      pass.setStencilReference(0xff);
      pass.draw(4 * copySize.height * dest.texture.sampleCount, 1, 0, blitCount);
      pass.end();
    }
  }

  return resourcesToDestroy;
}

/**
 * Creates a mipmapped texture where each mipmap level's (`i`) content is
 * from `texelViews[i]`.
 */
export function createTextureFromTexelViews(
  t: GPUTestBase,
  texelViews: TexelView[],
  desc: Omit<GPUTextureDescriptor, 'format'> & { format?: GPUTextureFormat }
): GPUTexture {
  // All texel views must be the same format for mipmaps.
  assert(texelViews.length > 0 && texelViews.every(e => e.format === texelViews[0].format));
  const viewsFormat = texelViews[0].format;
  const textureFormat = desc.format ?? viewsFormat;

  // Create the texture and then initialize each mipmap level separately.
  const texture = t.createTextureTracked({
    ...desc,
    format: textureFormat,
    usage: desc.usage | GPUTextureUsage.COPY_DST,
    mipLevelCount: texelViews.length,
  });
  // Note: At the time of this writing there is no such thing as a depth-stencil TexelView
  // so we couldn't have passed in data for "all" aspects. This seems like a code smell issue
  // but it's a big change to fix.
  const aspect = isDepthStencilTextureFormat(textureFormat)
    ? isSintOrUintFormat(viewsFormat)
      ? 'stencil-only'
      : 'depth-only'
    : 'all';
  copyTexelViewsToTexture(t, texture, aspect, texelViews);
  return texture;
}

export function copyTexelViewsToTexture(
  t: GPUTestBase,
  texture: GPUTexture,
  aspect: GPUTextureAspect,
  texelViews: TexelView[]
) {
  const viewsFormat = texelViews[0].format;
  const isTextureFormatDifferentThanTexelViewFormat = texture.format !== viewsFormat;
  const { width, height, depthOrArrayLayers } = texture;

  // Copy the texel view into each mip level layer.
  const commandEncoder = t.device.createCommandEncoder({ label: 'copyTexelViewToTexture' });
  const resourcesToDestroy: (GPUTexture | GPUBuffer)[] = [];
  for (let mipLevel = 0; mipLevel < texelViews.length; mipLevel++) {
    const {
      bytesPerRow,
      rowsPerImage,
      mipSize: [mipWidth, mipHeight, mipDepthOrArray],
    } = getTextureCopyLayout(
      viewsFormat,
      texture.dimension ?? '2d',
      [width, height, depthOrArrayLayers],
      {
        mipLevel,
      }
    );

    // Create a staging buffer to upload the texture mip level contents.
    const stagingBuffer = t.createBufferTracked({
      mappedAtCreation: true,
      size: bytesPerRow * mipHeight * mipDepthOrArray,
      usage: GPUBufferUsage.COPY_SRC,
    });
    resourcesToDestroy.push(stagingBuffer);

    // Write the texels into the staging buffer.
    texelViews[mipLevel].writeTextureData(new Uint8Array(stagingBuffer.getMappedRange()), {
      bytesPerRow,
      rowsPerImage: mipHeight,
      subrectOrigin: [0, 0, 0],
      subrectSize: [mipWidth, mipHeight, mipDepthOrArray],
      sampleCount: texture.sampleCount,
    });
    stagingBuffer.unmap();

    const copyB2TOk =
      !isTextureFormatDifferentThanTexelViewFormat &&
      texture.sampleCount === 1 &&
      !isDepthOrStencilTextureFormat(texture.format);

    if (!copyB2TOk) {
      resourcesToDestroy.push(
        ...copyBufferToTextureViaRender(
          t,
          commandEncoder,
          { buffer: stagingBuffer, bytesPerRow, rowsPerImage },
          viewsFormat,
          { texture, mipLevel, aspect },
          [mipWidth, mipHeight, mipDepthOrArray]
        )
      );
    } else {
      // Copy from the staging buffer into the texture.
      commandEncoder.copyBufferToTexture(
        { buffer: stagingBuffer, bytesPerRow, rowsPerImage },
        { texture, mipLevel, aspect: aspect ?? 'all' },
        [mipWidth, mipHeight, mipDepthOrArray]
      );
    }
  }
  t.device.queue.submit([commandEncoder.finish()]);

  // Cleanup temp buffers and textures.
  resourcesToDestroy.forEach(value => value.destroy());
}