@woosh/meep-engine 3.15.0 → 3.16.0

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js

@@ -4,6 +4,9 @@ import { EPSILON } from "../../../core/math/EPSILON.js";
 import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
 import { computeCellFilterGradient } from "../../filtering/numeric/process/computeCellFilterGradient.js";
 import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+
+const scratch_euler_rotation = new Quaternion();
 
 const v3_object = new Vector3();
 
@@ -64,7 +67,11 @@ export class MarkerNodeTransformerYRotateByFilterGradient extends MarkerNodeTran
 
         const finalAngle = this.offset + gradientAngle;
 
-        node.transform.rotation.toEulerAnglesYXZ(v3_object);
+        scratch_euler_rotation.set(
+            node.transform.rotation_x, node.transform.rotation_y,
+            node.transform.rotation_z, node.transform.rotation_w
+        );
+        scratch_euler_rotation.toEulerAnglesYXZ(v3_object);
 
         if (epsilonEquals(v3_object.y, finalAngle, EPSILON)) {
             //special case, already facing in the right direction
@@ -73,7 +80,14 @@ export class MarkerNodeTransformerYRotateByFilterGradient extends MarkerNodeTran
 
         const result = node.clone();
 
-        result.transform.rotation.fromEulerAnglesYXZ(v3_object.x, finalAngle, v3_object.z);
+        scratch_euler_rotation.fromEulerAnglesYXZ(v3_object.x, finalAngle, v3_object.z);
+
+        result.transform.setRotation(
+            scratch_euler_rotation.x, scratch_euler_rotation.y,
+            scratch_euler_rotation.z, scratch_euler_rotation.w
+        );
+
+        result.transform.updateMatrix();
 
         return result;
     }

package/src/shade/device/graph/BufferResourceDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BufferResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/BufferResourceDescriptor.js"],"names":[],"mappings":"AASA;IA0FI;;;;OAIG;IACH,0CAFa,wBAAwB,CAWpC;IAED;;;;;;;;OAQG;IACH,mBAJW,MAAM,SACN,iBAAe,MAAM,GACnB,wBAAwB,CASpC;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,iBAAe,MAAM,iBACrB,MAAM,eACN,MAAM,GACJ,wBAAwB,CAsCpC;IAvKD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,4BAAoC;IAUpC;;;OAGG;IACH,YAFW,wBAAwB,QAOlC;IAED;;;OAGG;IACH,SAFY,wBAAwB,CAQnC;IAMD,4BAMC;IAED;;;;OAIG;IACH,eAHW,wBAAwB,GACvB,MAAM,CAoBjB;IAmFL;;;OAGG;IACH,4BAFU,OAAO,CAE4C;CAN5D;mCA7KM,4EAA4E"}
+{"version":3,"file":"BufferResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/BufferResourceDescriptor.js"],"names":[],"mappings":"AAUA;IAkGI;;;;OAIG;IACH,0CAFa,wBAAwB,CAWpC;IAED;;;;;;;;OAQG;IACH,mBAJW,MAAM,SACN,iBAAe,MAAM,GACnB,wBAAwB,CASpC;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,iBAAe,MAAM,iBACrB,MAAM,eACN,MAAM,GACJ,wBAAwB,CAsCpC;IA/KD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,4BAAoC;IAUpC;;;OAGG;IACH,YAFW,wBAAwB,QAOlC;IAED;;;OAGG;IACH,SAFY,wBAAwB,CAQnC;IAcD,4BAMC;IAED;;;;OAIG;IACH,eAHW,wBAAwB,GACvB,MAAM,CAoBjB;IAmFL;;;OAGG;IACH,4BAFU,OAAO,CAE4C;CAN5D;mCArLM,4EAA4E"}

package/src/shade/device/graph/BufferResourceDescriptor.js

@@ -1,185 +1,194 @@
-import { assert } from "../../../core/assert.js";
-import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
-import { number_format_by_thousands } from "../../../core/primitives/numbers/number_format_by_thousands.js";
-import {
-    ResourceDescriptor
-} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
-import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
-
-
-export class BufferResourceDescriptor extends ResourceDescriptor {
-    /**
-     * In bytes
-     * @type {number}
-     */
-    size = 0;
-
-    /**
-     * Minimize the number of usage flags per-resource.
-     * The fewer flags you use - the more efficient the access will be.
-     * The driver can happily allow you the full set of flags - but the memory access will typically be much slower compared to just a few needed flags.
-     * @see GPUBufferUsage
-     * @type {number}
-     */
-    usage = 0;
-
-    /**
-     * Range of the buffer that needs to be cleared (reset to 0)
-     * Make sure to have a `GPUBufferUsage.COPY_DST` usage flag set if you want to clear the buffer
-     */
-    ensure_cleared = new Uint32Array(2);
-
-    toString() {
-        return `Buffer{ size = ${number_format_by_thousands(this.size)}, usage = ${decode_bitmask_enum(this.usage, GPUBufferUsage).join(" | ")} }`
-    }
-
-    get type() {
-        return "buffer";
-    }
-
-    /**
-     *
-     * @param {BufferResourceDescriptor} other
-     */
-    copy(other) {
-        this.size = other.size;
-        this.usage = other.usage;
-        this.ensure_cleared[0] = other.ensure_cleared[0];
-        this.ensure_cleared[1] = other.ensure_cleared[1];
-    }
-
-    /**
-     *
-     * @return {BufferResourceDescriptor}
-     */
-    clone() {
-        const r = new BufferResourceDescriptor();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    hash() {
-        return this.size ^ this.usage;
-    }
-
-    equals(other) {
-        return super.equals(other)
-            && this.size === other.size
-            && this.usage === other.usage
-            && isArrayEqualStrict(this.ensure_cleared, other.ensure_cleared)
-            ;
-    }
-
-    /**
-     *
-     * @param {BufferResourceDescriptor} other
-     * @return {number}
-     */
-    compare(other) {
-        if (other.type !== this.type) {
-            return super.compare(other);
-        }
-
-        const d_size = this.size - other.size;
-
-        if (d_size !== 0) {
-            return d_size;
-        }
-
-        const d_usage = this.usage - other.usage;
-
-        if (d_usage !== 0) {
-            return d_usage;
-        }
-
-        return 0;
-    }
-
-    /**
-     *
-     * @param {GPUBuffer} gpu_buffer
-     * @returns {BufferResourceDescriptor}
-     */
-    static fromBuffer(gpu_buffer) {
-        assert.defined(gpu_buffer, 'gpu_buffer');
-
-        const r = new BufferResourceDescriptor();
-
-        r.usage = gpu_buffer.usage;
-        r.size = gpu_buffer.size;
-
-        return r;
-    }
-
-    /**
-     * Shortcut to create a buffer that is cleared to 0 for the entire size.
-     * If you don't need the buffer to be cleared, use {@link BufferResourceDescriptor.from} instead.
-     *
-     *
-     * @param {number} size
-     * @param {GPUBufferUsage|number} usage
-     * @returns {BufferResourceDescriptor}
-     */
-    static empty(size, usage) {
-        return BufferResourceDescriptor.from(
-            size,
-            usage,
-            0,
-            size
-        );
-    }
-
-    /**
-     *
-     * @param {number} size
-     * @param {GPUBufferUsage|number} usage will automatically add `GPUBufferUsage.COPY_DST` if `clear_size > 0`
-     * @param {number} [clear_offset]
-     * @param {number} [clear_size]
-     * @returns {BufferResourceDescriptor}
-     */
-    static from(
-        size,
-        usage,
-        clear_offset = 0,
-        clear_size = 0
-    ) {
-
-        assert.isNonNegativeInteger(size, 'size');
-        assert.isNonNegativeInteger(usage, 'usage');
-        assert.notEqual(usage, 0, 'usage may not be 0');
-        assert.isNonNegativeInteger(clear_offset, 'clear_offset');
-        assert.isNonNegativeInteger(clear_size, 'clear_size');
-
-        assert.lessThanOrEqual(clear_offset + clear_size, size, 'clear region is out of bounds');
-
-        // spec requires 4 byte alignment: https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
-        assert.equal(clear_offset % 4, 0, 'offset must be a multiple of 4');
-        assert.equal(clear_size % 4, 0, 'size must be a multiple of 4');
-
-        const r = new BufferResourceDescriptor();
-
-        r.size = size;
-        r.usage = usage;
-
-        r.ensure_cleared[0] = clear_offset;
-        r.ensure_cleared[1] = clear_size;
-
-        if (clear_size > 0) {
-            // requesting buffer to be cleared, this requires COPY_DST to actually fulfill
-            // automatically add it in case it was missing
-            // "buffer.usage contains COPY_DST", spec https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
-            r.usage |= GPUBufferUsage.COPY_DST;
-        }
-
-
-        return r;
-    }
-}
-
-/**
- * Type check shortcut
- * @type {boolean}
- */
+import { assert } from "../../../core/assert.js";
+import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { number_format_by_thousands } from "../../../core/primitives/numbers/number_format_by_thousands.js";
+import {
+    ResourceDescriptor
+} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
+import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
+
+
+export class BufferResourceDescriptor extends ResourceDescriptor {
+    /**
+     * In bytes
+     * @type {number}
+     */
+    size = 0;
+
+    /**
+     * Minimize the number of usage flags per-resource.
+     * The fewer flags you use - the more efficient the access will be.
+     * The driver can happily allow you the full set of flags - but the memory access will typically be much slower compared to just a few needed flags.
+     * @see GPUBufferUsage
+     * @type {number}
+     */
+    usage = 0;
+
+    /**
+     * Range of the buffer that needs to be cleared (reset to 0)
+     * Make sure to have a `GPUBufferUsage.COPY_DST` usage flag set if you want to clear the buffer
+     */
+    ensure_cleared = new Uint32Array(2);
+
+    toString() {
+        return `Buffer{ size = ${number_format_by_thousands(this.size)}, usage = ${decode_bitmask_enum(this.usage, GPUBufferUsage).join(" | ")} }`
+    }
+
+    get type() {
+        return "buffer";
+    }
+
+    /**
+     *
+     * @param {BufferResourceDescriptor} other
+     */
+    copy(other) {
+        this.size = other.size;
+        this.usage = other.usage;
+        this.ensure_cleared[0] = other.ensure_cleared[0];
+        this.ensure_cleared[1] = other.ensure_cleared[1];
+    }
+
+    /**
+     *
+     * @return {BufferResourceDescriptor}
+     */
+    clone() {
+        const r = new BufferResourceDescriptor();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    hash() {
+        // XOR is symmetric, so it maps (size, usage) and (usage, size) onto one value, and it left
+        // `ensure_cleared` out entirely although `equals` compares it — two descriptors that are
+        // not equal sharing a bucket, which is how a texture ends up being probed with a buffer.
+        return combine_hash(
+            this.size,
+            this.usage,
+            this.ensure_cleared[0],
+            this.ensure_cleared[1]
+        );
+    }
+
+    equals(other) {
+        return super.equals(other)
+            && this.size === other.size
+            && this.usage === other.usage
+            && isArrayEqualStrict(this.ensure_cleared, other.ensure_cleared)
+            ;
+    }
+
+    /**
+     *
+     * @param {BufferResourceDescriptor} other
+     * @return {number}
+     */
+    compare(other) {
+        if (other.type !== this.type) {
+            return super.compare(other);
+        }
+
+        const d_size = this.size - other.size;
+
+        if (d_size !== 0) {
+            return d_size;
+        }
+
+        const d_usage = this.usage - other.usage;
+
+        if (d_usage !== 0) {
+            return d_usage;
+        }
+
+        return 0;
+    }
+
+    /**
+     *
+     * @param {GPUBuffer} gpu_buffer
+     * @returns {BufferResourceDescriptor}
+     */
+    static fromBuffer(gpu_buffer) {
+        assert.defined(gpu_buffer, 'gpu_buffer');
+
+        const r = new BufferResourceDescriptor();
+
+        r.usage = gpu_buffer.usage;
+        r.size = gpu_buffer.size;
+
+        return r;
+    }
+
+    /**
+     * Shortcut to create a buffer that is cleared to 0 for the entire size.
+     * If you don't need the buffer to be cleared, use {@link BufferResourceDescriptor.from} instead.
+     *
+     *
+     * @param {number} size
+     * @param {GPUBufferUsage|number} usage
+     * @returns {BufferResourceDescriptor}
+     */
+    static empty(size, usage) {
+        return BufferResourceDescriptor.from(
+            size,
+            usage,
+            0,
+            size
+        );
+    }
+
+    /**
+     *
+     * @param {number} size
+     * @param {GPUBufferUsage|number} usage will automatically add `GPUBufferUsage.COPY_DST` if `clear_size > 0`
+     * @param {number} [clear_offset]
+     * @param {number} [clear_size]
+     * @returns {BufferResourceDescriptor}
+     */
+    static from(
+        size,
+        usage,
+        clear_offset = 0,
+        clear_size = 0
+    ) {
+
+        assert.isNonNegativeInteger(size, 'size');
+        assert.isNonNegativeInteger(usage, 'usage');
+        assert.notEqual(usage, 0, 'usage may not be 0');
+        assert.isNonNegativeInteger(clear_offset, 'clear_offset');
+        assert.isNonNegativeInteger(clear_size, 'clear_size');
+
+        assert.lessThanOrEqual(clear_offset + clear_size, size, 'clear region is out of bounds');
+
+        // spec requires 4 byte alignment: https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
+        assert.equal(clear_offset % 4, 0, 'offset must be a multiple of 4');
+        assert.equal(clear_size % 4, 0, 'size must be a multiple of 4');
+
+        const r = new BufferResourceDescriptor();
+
+        r.size = size;
+        r.usage = usage;
+
+        r.ensure_cleared[0] = clear_offset;
+        r.ensure_cleared[1] = clear_size;
+
+        if (clear_size > 0) {
+            // requesting buffer to be cleared, this requires COPY_DST to actually fulfill
+            // automatically add it in case it was missing
+            // "buffer.usage contains COPY_DST", spec https://www.w3.org/TR/webgpu/#dom-gpucommandencoder-clearbuffer
+            r.usage |= GPUBufferUsage.COPY_DST;
+        }
+
+
+        return r;
+    }
+}
+
+/**
+ * Type check shortcut
+ * @type {boolean}
+ */
 BufferResourceDescriptor.prototype.isBufferResourceDescriptor = true;

package/src/shade/device/graph/TextureResourceDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/TextureResourceDescriptor.js"],"names":[],"mappings":";;;sCAgBU,MAAM;;;;;AAOhB;IAmCI;;;;;;;;OAQG;IACH,kEAPW,MAAM,EAAE,GAKN,yBAAyB,CAkCrC;IAED;;;;OAIG;IACH,yCAFa,yBAAyB,CAoBrC;IApGD;;;;;;;;;OASG;IACH,mBAFU,uBAAuB,GAAC,MAAM,CAEyB;IAGjE,yBAAyC;IACzC,oBAAgB;IAEhB,sBAAkB;IAElB;;;OAGG;IACH,WAFU,sBAAoB,MAAM,CAEpB;IAEhB;;OAEG;IACH,QAFU,MAAM,mBAAiB,CAEX;IAEtB;;OAEG;IACH,OAFU,MAAM,uBAAqB,CAEG;IAqFxC;;;;OAIG;IACH,cAHW,yBAAyB,GACvB,OAAO,CAWnB;CAKJ;mCAxJM,4EAA4E"}
+{"version":3,"file":"TextureResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/graph/TextureResourceDescriptor.js"],"names":[],"mappings":";;;sCAgBU,MAAM;;;;;AAOhB;IAmCI;;;;;;;;OAQG;IACH,kEAPW,MAAM,EAAE,GAKN,yBAAyB,CAkCrC;IAED;;;;OAIG;IACH,yCAFa,yBAAyB,CAoBrC;IApGD;;;;;;;;;OASG;IACH,mBAFU,uBAAuB,GAAC,MAAM,CAEyB;IAGjE,yBAAyC;IACzC,oBAAgB;IAEhB,sBAAkB;IAElB;;;OAGG;IACH,WAFU,sBAAoB,MAAM,CAEpB;IAEhB;;OAEG;IACH,QAFU,MAAM,mBAAiB,CAEX;IAEtB;;OAEG;IACH,OAFU,MAAM,uBAAqB,CAEG;IAqFxC;;;;OAIG;IACH,cAHW,yBAAyB,GACvB,OAAO,CAuBnB;CAKJ;mCApKM,4EAA4E"}

package/src/shade/device/graph/TextureResourceDescriptor.js

@@ -145,6 +145,18 @@ export class TextureResourceDescriptor extends ResourceDescriptor {
      * @returns {boolean}
      */
     equals(other) {
+        if (this === other) {
+            return true;
+        }
+
+        // A texture and a buffer descriptor share one `ImmutableObjectPool` in
+        // `RenderResourceManager`, so a hash collision puts a buffer in front of this method. The
+        // type check has to come first: without it the very next line reads `other.resolution.length`
+        // on undefined and the probe throws instead of missing the cache.
+        if (!super.equals(other)) {
+            return false;
+        }
+
         return isArrayEqualStrict(this.resolution, other.resolution)
             && this.mipLevelCount === other.mipLevelCount
             && this.resolution_domain === other.resolution_domain

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

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA4PA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAwID;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;OAGG;IACH,kEAEC;IAED;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAxpBa,mBAAiB,IAAI;;sCA3PG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAoQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;;;OAUG;IACH;QAT+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAyBrC;IAzDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAmCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAwID;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;OAGG;IACH,kEAEC;IAED;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAxpBa,mBAAiB,IAAI;;sCAnQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}

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

@@ -195,6 +195,14 @@ const CORE_FEATURE = "core-features-and-limits";
 const SUPPORTED_OPTIONAL_FEATURES = [
     "timestamp-query",
     "subgroups",
+    /*
+     `indirect-first-instance` is the `subgroups` argument once more: all it permits is a non-zero
+     `firstInstance` inside an indirect draw's arguments, which live in a buffer this device never
+     reads and issue a draw it never runs. Refusing it would leave every pass that draws meshlets
+     indirectly — the whole transparency orchestration, which asserts the feature before it records
+     anything — untestable at this tier, again for a reason unrelated to what the tier asserts.
+    */
+    "indirect-first-instance",
     /*
      The three compression families are the same argument as `subgroups` again, with one thing this
      device *can* honour: `createTexture` of a block format is a validation error without the family's

package/src/shade/playground/avboit/main.js

@@ -320,7 +320,7 @@ export async function start() {
     camera.far = CAMERA.far;
     camera.fov = CAMERA.fov_degrees * DEG_TO_RAD;
     camera.aspect = VIEWPORT.width / VIEWPORT.height;
-    camera.transform.position.copy(CAMERA.position);
+    camera.transform.setTranslation(CAMERA.position[0], CAMERA.position[1], CAMERA.position[2]);
     camera.transform.lookAt(CAMERA.target);
     camera.transform.updateMatrix();
 
@@ -340,13 +340,13 @@ export async function start() {
      * @returns {{position: number[], target: number[], fov_degrees: number}}
      */
     globalThis.camera_state = () => {
-        const p = camera.transform.position;
+        const p = camera.transform;
         const t = controller.target;
 
         const round = v => Math.round(v * 1000) / 1000;
 
         return {
-            position: [round(p.x), round(p.y), round(p.z)],
+            position: [round(p.translation_x), round(p.translation_y), round(p.translation_z)],
             target: [round(t.x), round(t.y), round(t.z)],
             fov_degrees: round(camera.fov / DEG_TO_RAD),
         };

package/src/shade/playground/basis_textures/main.js

@@ -135,7 +135,7 @@ export async function start() {
 
     const camera = new PerspectiveCamera();
 
-    camera.transform.position.set(0, 2, -5);
+    camera.transform.setTranslation(0, 2, -5);
     camera.transform.lookAt(Vector3.zero);
 
     camera.near = 0.1;

package/src/shade/playground/ground_seam/main.js

@@ -105,7 +105,7 @@ export async function start() {
     camera.near = CAMERA.near;
     camera.far = CAMERA.far;
     camera.fov = CAMERA.fov_degrees * DEG_TO_RAD;
-    camera.transform.position.copy(CAMERA.position);
+    camera.transform.setTranslation(CAMERA.position[0], CAMERA.position[1], CAMERA.position[2]);
     camera.transform.lookAt(CAMERA.target);
     camera.transform.updateMatrix();