@woosh/meep-engine 3.14.1 → 3.14.3

package/src/shade/device/mock/SoftwareGPUQueue.d.ts

@@ -19,10 +19,17 @@ export class SoftwareGPUQueue implements GPUQueue {
      */
     writeBuffer(buffer: GPUBuffer, bufferOffset: number, data: BufferSource, dataOffset?: number, size?: number): void;
     /**
-     * 2D single-layer subset of {@link GPUQueue#writeTexture}: copies rows
-     * from a BufferSource into the destination mip's lazily-allocated
-     * storage. `dataLayout.offset` is in bytes (spec), `bytesPerRow`
-     * defaults to a tightly-packed row.
+     * Emulates {@link GPUQueue#writeTexture}: copies rows of texel blocks from a BufferSource into
+     * the destination mip's lazily-allocated storage.
+     *
+     * The same operation as {@link SoftwareGPUCommandEncoder#copyBufferToTexture} with the bytes
+     * supplied inline rather than through a `GPUBuffer`, and it runs on the same two functions —
+     * which is what makes it block-aware, multi-layer and `rowsPerImage`-honouring rather than the
+     * 2D single-layer `bytes_per_texel` subset it used to be. A BC7 write is not a special case here;
+     * it is the same row loop over a row that happens to be four texels tall.
+     *
+     * `dataLayout.offset` is in bytes (spec), `bytesPerRow` defaults to a tightly packed row of
+     * blocks.
      *
      * @param {GPUTexelCopyTextureInfo} destination
      * @param {BufferSource} data

package/src/shade/device/mock/SoftwareGPUQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA2DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;OAUG;IACH,yDAJW,YAAY,iEAiDtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QA0BpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}
+{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yDAJW,YAAY,iEAmCtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QA0BpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}

package/src/shade/device/mock/SoftwareGPUQueue.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { array_buffer_copy } from "../../../core/collection/array/typed/array_buffer_copy.js";
+import { texture_copy_execute, texture_copy_refusal } from "./texture_copy.js";
 import { SoftwareGPUValidationError } from "./SoftwareGPUError.js";
 
 /**
@@ -184,10 +185,17 @@ export class SoftwareGPUQueue {
     }
 
     /**
-     * 2D single-layer subset of {@link GPUQueue#writeTexture}: copies rows
-     * from a BufferSource into the destination mip's lazily-allocated
-     * storage. `dataLayout.offset` is in bytes (spec), `bytesPerRow`
-     * defaults to a tightly-packed row.
+     * Emulates {@link GPUQueue#writeTexture}: copies rows of texel blocks from a BufferSource into
+     * the destination mip's lazily-allocated storage.
+     *
+     * The same operation as {@link SoftwareGPUCommandEncoder#copyBufferToTexture} with the bytes
+     * supplied inline rather than through a `GPUBuffer`, and it runs on the same two functions —
+     * which is what makes it block-aware, multi-layer and `rowsPerImage`-honouring rather than the
+     * 2D single-layer `bytes_per_texel` subset it used to be. A BC7 write is not a special case here;
+     * it is the same row loop over a row that happens to be four texels tall.
+     *
+     * `dataLayout.offset` is in bytes (spec), `bytesPerRow` defaults to a tightly packed row of
+     * blocks.
      *
      * @param {GPUTexelCopyTextureInfo} destination
      * @param {BufferSource} data
@@ -199,46 +207,32 @@ export class SoftwareGPUQueue {
 
         assert.equal(texture.isSoftwareGPUTexture, true, 'texture.isSoftwareGPUTexture !== true');
 
-        const texture_refusal = texture_write_refusal(texture);
+        /*
+         The destination half of a copy's validation, which is a superset of what this used to check
+         for itself: the same invalid/destroyed/COPY_DST refusals, and additionally a format WebGPU
+         forbids copies of, a mip outside the chain, and a region past the edge of it.
+        */
+        const refusal = texture_copy_refusal({ texture_destination: destination, size });
 
-        if (texture_refusal !== null) {
-            this.#device.generate_error(new SoftwareGPUValidationError(`writeTexture: ${texture_refusal}`));
+        if (refusal !== null) {
+            this.#device.generate_error(new SoftwareGPUValidationError(`writeTexture: ${refusal}`));
 
             return;
         }
 
-        const width = size.width ?? size[0] ?? 1;
-        const height = size.height ?? size[1] ?? 1;
-        const depth = size.depthOrArrayLayers ?? size[2] ?? 1;
-
-        assert.equal(depth, 1, 'only single-layer writes are emulated');
-
-        const mip = destination.mipLevel ?? 0;
-        const origin_x = destination.origin?.x ?? destination.origin?.[0] ?? 0;
-        const origin_y = destination.origin?.y ?? destination.origin?.[1] ?? 0;
-
-        const bytes_per_texel = texture.bytes_per_texel;
-
         const source = normalize_buffer_source(data);
 
-        const source_offset = source.byteOffset + (dataLayout?.offset ?? 0);
-        const bytes_per_row = dataLayout?.bytesPerRow ?? width * bytes_per_texel;
-
-        const mip_data = texture.get_mip_data(mip);
-        const dst_stride = texture.mip_width(mip) * bytes_per_texel;
-
-        assert.lessThanOrEqual(origin_x + width, texture.mip_width(mip), 'write exceeds mip width');
-        assert.lessThanOrEqual(origin_y + height, texture.mip_height(mip), 'write exceeds mip height');
-
-        for (let row = 0; row < height; row++) {
-            array_buffer_copy(
-                source.buffer,
-                source_offset + row * bytes_per_row,
-                mip_data,
-                (origin_y + row) * dst_stride + origin_x * bytes_per_texel,
-                width * bytes_per_texel
-            );
-        }
+        texture_copy_execute({
+            buffer_source: {
+                // the inline bytes, in the shape the buffer endpoint reads
+                buffer: { data: source.buffer },
+                offset: source.byteOffset + (dataLayout?.offset ?? 0),
+                bytesPerRow: dataLayout?.bytesPerRow,
+                rowsPerImage: dataLayout?.rowsPerImage,
+            },
+            texture_destination: destination,
+            size,
+        });
     }
 
     /**

package/src/shade/device/mock/SoftwareGPUTexture.d.ts

@@ -12,15 +12,17 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase implements GPUText
     /**
      * The texture a device hands back for a descriptor it rejected.
      *
+     * @param {SoftwareGPUDevice} device
      * @param {GPUTextureDescriptor} descriptor as asked for, so a log can say what was wanted
      * @returns {SoftwareGPUTexture}
      */
-    static invalid(descriptor: GPUTextureDescriptor): SoftwareGPUTexture;
+    static invalid(device: SoftwareGPUDevice, descriptor: GPUTextureDescriptor): SoftwareGPUTexture;
     /**
+     * @param {SoftwareGPUDevice} device
      * @param {GPUTextureDescriptor} descriptor
      * @param {boolean} [valid] whether the device accepted `descriptor`; see {@link isValid}
      */
-    constructor(descriptor: GPUTextureDescriptor, valid?: boolean);
+    constructor(device: SoftwareGPUDevice, descriptor: GPUTextureDescriptor, valid?: boolean);
     /**
      * Whether the device accepted the descriptor this was made from. See
      * {@link SoftwareGPUBuffer#isValid} — WebGPU hands back a texture for a descriptor it rejects,

package/src/shade/device/mock/SoftwareGPUTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IA+CtB;;;;;OAKG;IACH,kDAFa,kBAAkB,CAI9B;IA/BD;;;OAGG;IACH,sDAFW,OAAO,EAmBjB;IAtCD;;;;;;OAMG;IACH,uBAEC;IAoBG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IAatD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;OAGG;IACH,kEAMC;IAED;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCAzMqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;OAGG;IACH,kEAqBC;IAED;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCA7OqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTexture.js

@@ -1,8 +1,12 @@
 import {
     gpu_texture_format_info,
+    gpu_texture_format_is_block_compressed,
+    gpu_texture_format_level_bytes,
     gpu_texture_format_row_bytes,
     gpu_texture_format_row_count
 } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { texture_mip_size } from "../../util/texture_mip_extent.js";
+import { SoftwareGPUValidationError } from "./SoftwareGPUError.js";
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 import { SoftwareGPUTextureView } from "./SoftwareGPUTextureView.js";
 
@@ -39,13 +43,32 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
     #mip_data = [];
 
     /**
+     * The device that made this, which is where a refused view is reported.
+     *
+     * @type {SoftwareGPUDevice}
+     */
+    #device;
+
+    /**
+     * The formats a view may reinterpret this texture as, beyond its own — `viewFormats` of the
+     * descriptor. WebGPU allows only its own format and these, which is how `rgba8unorm-srgb` is
+     * read as `rgba8unorm` without a copy and only when the creator said it might be.
+     *
+     * @type {GPUTextureFormat[]}
+     */
+    #view_formats;
+
+    /**
+     * @param {SoftwareGPUDevice} device
      * @param {GPUTextureDescriptor} descriptor
      * @param {boolean} [valid] whether the device accepted `descriptor`; see {@link isValid}
      */
-    constructor(descriptor, valid = true) {
+    constructor(device, descriptor, valid = true) {
         super(descriptor);
 
+        this.#device = device;
         this.#valid = valid;
+        this.#view_formats = [...(descriptor.viewFormats ?? [])];
 
         const size = descriptor.size;
 
@@ -64,11 +87,12 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
     /**
      * The texture a device hands back for a descriptor it rejected.
      *
+     * @param {SoftwareGPUDevice} device
      * @param {GPUTextureDescriptor} descriptor as asked for, so a log can say what was wanted
      * @returns {SoftwareGPUTexture}
      */
-    static invalid(descriptor) {
-        return new SoftwareGPUTexture(descriptor, false);
+    static invalid(device, descriptor) {
+        return new SoftwareGPUTexture(device, descriptor, false);
     }
 
     /**
@@ -100,7 +124,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
     get bytes_per_texel() {
         const info = this.format_info;
 
-        if (info.block_width !== 1 || info.block_height !== 1) {
+        if (gpu_texture_format_is_block_compressed(this.format)) {
             throw new Error(
                 `bytes_per_texel: '${this.format}' is block-compressed (${info.block_width}x${info.block_height}), use row_bytes instead`
             );
@@ -114,7 +138,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     mip_width(mip) {
-        return Math.max(1, this.width >> mip);
+        return texture_mip_size(this.width, mip);
     }
 
     /**
@@ -122,7 +146,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     mip_height(mip) {
-        return Math.max(1, this.height >> mip);
+        return texture_mip_size(this.height, mip);
     }
 
     /**
@@ -154,7 +178,8 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     layer_bytes(mip = 0) {
-        return this.row_bytes(mip) * this.row_count(mip);
+        // one layer, hence the 1 — get_mip_data multiplies by depthOrArrayLayers itself
+        return gpu_texture_format_level_bytes(this.format, this.mip_width(mip), this.mip_height(mip), 1);
     }
 
     /**
@@ -189,6 +214,21 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
             throw new Error('createView on a destroyed texture');
         }
 
+        const format = descriptor?.format;
+
+        /*
+         A view may reinterpret the texture only as a format its descriptor declared. Reported the
+         way the device reports a refused descriptor — through the error scopes — rather than thrown,
+         so a caller reading an sRGB texture as linear without having said so at creation fails the
+         same way it fails on hardware.
+        */
+        if (format !== undefined && format !== this.format && !this.#view_formats.includes(format)) {
+            this.#device.generate_error(new SoftwareGPUValidationError(
+                `createView: '${format}' is neither the format of '${this.label}' (${this.format})`
+                + ` nor one of its viewFormats (${this.#view_formats.join(', ') || 'none'})`
+            ));
+        }
+
         return new SoftwareGPUTextureView(this, descriptor);
     }
 

package/src/shade/device/mock/SoftwareGPUTextureView.d.ts

@@ -9,6 +9,13 @@ export class SoftwareGPUTextureView extends SoftwareGPUObjectBase implements GPU
      */
     constructor(texture: SoftwareGPUTexture, descriptor?: GPUTextureViewDescriptor);
     texture: SoftwareGPUTexture;
+    /**
+     * What the view was asked to be, retained so a test can read which format a texture is
+     * being reinterpreted as — a real view exposes none of it.
+     *
+     * @type {GPUTextureViewDescriptor}
+     */
+    descriptor: GPUTextureViewDescriptor;
     /**
      * @readonly
      * @type {boolean}

package/src/shade/device/mock/SoftwareGPUTextureView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTextureView.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTextureView.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,6EAFgB,cAAc;IAG1B;;;OAGG;IACH,gFAGC;IADG,4BAAsB;IAI9B;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CANxD;sCAfqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTextureView.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTextureView.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,6EAFgB,cAAc;IAG1B;;;OAGG;IACH,gFAWC;IATG,4BAAsB;IAEtB;;;;;OAKG;IACH,qCAAkC;IAI1C;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CANxD;sCAvBqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTextureView.js

@@ -12,6 +12,14 @@ export class SoftwareGPUTextureView extends SoftwareGPUObjectBase {
     constructor(texture, descriptor) {
         super(descriptor);
         this.texture = texture;
+
+        /**
+         * What the view was asked to be, retained so a test can read which format a texture is
+         * being reinterpreted as — a real view exposes none of it.
+         *
+         * @type {GPUTextureViewDescriptor}
+         */
+        this.descriptor = descriptor ?? {};
     }
 }
 

package/src/shade/device/mock/texture_copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_copy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/texture_copy.js"],"names":[],"mappings":"AAsHA;;;;;;;;;;;;;GAaG;AACH;IAP0C,cAAc;IACf,aAAa;IACZ,mBAAmB;IACpB,kBAAkB;IAC9B,IAAI;IACpB,MAAM,GAAC,IAAI,CAyDvB;AAiED;;;;;GAKG;AACH,uHAHW,MAAM,GACJ,IAAI,CA8BhB;;;;;;UA5Fa,WAAW;;;;YACX,MAAM;gBACN,MAAM;kBACN,MAAM"}
+{"version":3,"file":"texture_copy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/texture_copy.js"],"names":[],"mappings":"AAiLA;;;;;;;;;;;;;GAaG;AACH;IAP0C,cAAc;IACf,aAAa;IACZ,mBAAmB;IACpB,kBAAkB;IAC9B,IAAI;IACpB,MAAM,GAAC,IAAI,CA4DvB;AAiED;;;;;GAKG;AACH,uHAHW,MAAM,GACJ,IAAI,CA8BhB;;;;;;UA5Fa,WAAW;;;;YACX,MAAM;gBACN,MAAM;kBACN,MAAM"}

package/src/shade/device/mock/texture_copy.js

@@ -1,4 +1,6 @@
 import { array_buffer_copy } from "../../../core/collection/array/typed/array_buffer_copy.js";
+import { gpu_texture_format_physical_size } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { COPY_BYTES_PER_ROW_ALIGNMENT } from "../COPY_BYTES_PER_ROW_ALIGNMENT.js";
 
 /**
  * The three texture copy commands — texture↔texture, buffer→texture, texture→buffer — differ only in
@@ -70,14 +72,38 @@ function texture_endpoint_refusal(info, role, required_usage, required_usage_nam
 
     const origin = normalize_origin(info.origin);
 
-    if (origin.x + extent.width > texture.mip_width(mip) || origin.y + extent.height > texture.mip_height(mip)) {
-        return `${role} region at (${origin.x}, ${origin.y}) sized ${extent.width}x${extent.height} exceeds mip ${mip} of '${texture.label}' (${texture.mip_width(mip)}x${texture.mip_height(mip)})`;
+    /*
+     A copy addresses whole blocks. Its origin sits on a block boundary, its extent is a whole number
+     of blocks, and the level it must fit is the *physical* one — the logical size rounded up to
+     blocks — so a 2x2 tail of a BC chain is copied as one 4x4 block and nothing smaller. WebGPU's
+     rule, not Vulkan's: there is no "partial at the edge" allowance. Checked on Dawn, which refuses
+     a 2x2 extent on a 2x2 level with `copySize.width (2) is not a multiple of compressed texture
+     format block width (4)`. Uncompressed formats are 1x1 blocks and pass trivially.
+    */
+    const format = texture.format_info;
+
+    const physical = gpu_texture_format_physical_size(texture.format, texture.mip_width(mip), texture.mip_height(mip));
+
+    if (origin.x + extent.width > physical[0] || origin.y + extent.height > physical[1]) {
+        return `${role} region at (${origin.x}, ${origin.y}) sized ${extent.width}x${extent.height} exceeds mip ${mip} of '${texture.label}' (${physical[0]}x${physical[1]})`;
     }
 
     if (origin.z + extent.depth > texture.depthOrArrayLayers) {
         return `${role} region reaches layer ${origin.z + extent.depth} of '${texture.label}', which has ${texture.depthOrArrayLayers}`;
     }
 
+    if (origin.x % format.block_width !== 0 || origin.y % format.block_height !== 0) {
+        return `${role} origin (${origin.x}, ${origin.y}) is not on a ${format.block_width}x${format.block_height} block boundary of ${texture.format}`;
+    }
+
+    if (extent.width % format.block_width !== 0) {
+        return `${role} copySize.width (${extent.width}) is not a multiple of the ${format.block_width}-texel block width of ${texture.format}`;
+    }
+
+    if (extent.height % format.block_height !== 0) {
+        return `${role} copySize.height (${extent.height}) is not a multiple of the ${format.block_height}-texel block height of ${texture.format}`;
+    }
+
     return null;
 }
 
@@ -88,9 +114,11 @@ function texture_endpoint_refusal(info, role, required_usage, required_usage_nam
  * @param {string} role
  * @param {GPUFlagsConstant} required_usage
  * @param {string} required_usage_name
+ * @param {GPUTextureFormatInfo} format of the texture at the other end, which decides the block size
+ * @param {{width: number, height: number, depth: number}} extent
  * @returns {string|null}
  */
-function buffer_endpoint_refusal(info, role, required_usage, required_usage_name) {
+function buffer_endpoint_refusal(info, role, required_usage, required_usage_name, format, extent) {
     const buffer = info.buffer;
 
     if (!buffer.isValid) {
@@ -109,8 +137,39 @@ function buffer_endpoint_refusal(info, role, required_usage, required_usage_name
         return `${role} buffer '${buffer.label}' was not created with ${required_usage_name}`;
     }
 
-    if ((info.offset ?? 0) % 4 !== 0) {
-        return `${role} buffer offset ${info.offset} is not a multiple of 4`;
+    const offset = info.offset ?? 0;
+
+    // WebGPU's "validating linear texture data": the offset lands on a whole block, and the rows are
+    // strided at a multiple of 256 whenever there is more than one of them to stride between
+    if (offset % format.bytes_per_block !== 0) {
+        return `${role} buffer offset ${offset} is not a multiple of the ${format.bytes_per_block}-byte block`;
+    }
+
+    const rows = Math.ceil(extent.height / format.block_height);
+    const tight_row = Math.ceil(extent.width / format.block_width) * format.bytes_per_block;
+
+    const multi_row = rows * extent.depth > 1;
+
+    if (info.bytesPerRow === undefined) {
+        if (multi_row) {
+            return `${role} bytesPerRow is required for a copy of more than one row`;
+        }
+    } else {
+        if (info.bytesPerRow % COPY_BYTES_PER_ROW_ALIGNMENT !== 0) {
+            return `${role} bytesPerRow ${info.bytesPerRow} is not a multiple of ${COPY_BYTES_PER_ROW_ALIGNMENT}`;
+        }
+
+        if (info.bytesPerRow < tight_row) {
+            return `${role} bytesPerRow ${info.bytesPerRow} is less than the ${tight_row} bytes a row of ${extent.width} texels takes`;
+        }
+    }
+
+    if (info.rowsPerImage === undefined) {
+        if (extent.depth > 1) {
+            return `${role} rowsPerImage is required for a copy of more than one layer`;
+        }
+    } else if (info.rowsPerImage < rows) {
+        return `${role} rowsPerImage ${info.rowsPerImage} is less than the ${rows} rows a layer of ${extent.height} texels takes`;
     }
 
     return null;
@@ -143,9 +202,9 @@ export function texture_copy_refusal({ texture_source, buffer_source, texture_de
         }
     }
 
-    if (buffer_source !== undefined) {
-        const refusal = buffer_endpoint_refusal(
-            buffer_source, 'source', GPUBufferUsage.COPY_SRC, 'COPY_SRC'
+    if (texture_destination !== undefined) {
+        const refusal = texture_endpoint_refusal(
+            texture_destination, 'destination', GPUTextureUsage.COPY_DST, 'COPY_DST', extent
         );
 
         if (refusal !== null) {
@@ -153,9 +212,12 @@ export function texture_copy_refusal({ texture_source, buffer_source, texture_de
         }
     }
 
-    if (texture_destination !== undefined) {
-        const refusal = texture_endpoint_refusal(
-            texture_destination, 'destination', GPUTextureUsage.COPY_DST, 'COPY_DST', extent
+    // one side is always a texture, and it is the side that knows the block size a buffer is read in
+    const format = (texture_source ?? texture_destination).texture.format_info;
+
+    if (buffer_source !== undefined) {
+        const refusal = buffer_endpoint_refusal(
+            buffer_source, 'source', GPUBufferUsage.COPY_SRC, 'COPY_SRC', format, extent
         );
 
         if (refusal !== null) {
@@ -165,7 +227,7 @@ export function texture_copy_refusal({ texture_source, buffer_source, texture_de
 
     if (buffer_destination !== undefined) {
         const refusal = buffer_endpoint_refusal(
-            buffer_destination, 'destination', GPUBufferUsage.COPY_DST, 'COPY_DST'
+            buffer_destination, 'destination', GPUBufferUsage.COPY_DST, 'COPY_DST', format, extent
         );
 
         if (refusal !== null) {

package/src/shade/device/timing/profile/frame_graph_extract_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame_graph_extract_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/frame_graph_extract_topology.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;GAgBG;AACH,iEALa,kBAAkB,CAkH9B;mCArKM,yBAAyB"}
+{"version":3,"file":"frame_graph_extract_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/frame_graph_extract_topology.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;GAgBG;AACH,iEALa,kBAAkB,CAkH9B;mCA3JM,yBAAyB"}