@woosh/meep-engine 3.45.0 → 3.47.0

package/src/shade/renderer/pool/TransientResourcePool.d.ts

@@ -13,8 +13,15 @@
  * immediately (within and across frames) — there is no frames-in-flight reuse gate; only
  * *destruction* is deferred, by {@link update}.
  *
+ * A record carries what the pool is ordered and accounted by, cached when its resource enters the
+ * pool: `size` here, and whatever else {@link describeRecord} adds for {@link compare} and
+ * {@link find}. A resource can be a platform object — a `GPUBuffer`'s `size` and `usage` are native
+ * reads — and the binary search and scan visit records many times a frame, so they read the record,
+ * never the resource.
+ *
  * @typedef {object} PoolRecord
  * @property {*} resource the pooled resource (or null while the record sits on the free-list)
+ * @property {number} size {@link sizeOf} the resource, as it was when it entered the pool
  * @property {number} last_used_frame frame the resource was last released into the pool
  * @property {boolean} referenced CLOCK second-chance bit; set on release and on reuse
  */
@@ -83,6 +90,13 @@ export class TransientResourcePool {
      * @abstract
      */
     destroyResource(resource: any): void;
+    /**
+     * Cache on a record entering the pool whatever {@link compare} and {@link find} read beyond `size`,
+     * so neither has to ask the resource. Called on {@link release} once `resource` and `size` are set,
+     * and before the record is placed in order. Default: nothing.
+     * @param {PoolRecord} record
+     */
+    describeRecord(record: PoolRecord): void;
     /**
      * Hook invoked at the end of {@link get}, after the resource is acquired and tracked. Subclasses
      * override it for post-acquire work (clear-on-reuse, postcondition asserts). Default: nothing.
@@ -147,12 +161,22 @@ export class TransientResourcePool {
  * Reuse safety: within WebGPU's single in-order queue, reusing a GPU-only transient is safe
  * immediately (within and across frames) — there is no frames-in-flight reuse gate; only
  * *destruction* is deferred, by {@link update }.
+ *
+ * A record carries what the pool is ordered and accounted by, cached when its resource enters the
+ * pool: `size` here, and whatever else {@link describeRecord } adds for {@link compare } and
+ * {@link find }. A resource can be a platform object — a `GPUBuffer`'s `size` and `usage` are native
+ * reads — and the binary search and scan visit records many times a frame, so they read the record,
+ * never the resource.
  */
 export type PoolRecord = {
     /**
      * the pooled resource (or null while the record sits on the free-list)
      */
     resource: any;
+    /**
+     * {@link sizeOf } the resource, as it was when it entered the pool
+     */
+    size: number;
     /**
      * frame the resource was last released into the pool
      */

package/src/shade/renderer/pool/TransientResourcePool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransientResourcePool.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/pool/TransientResourcePool.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;IAII,+EAA+E;IAC/E,wBADqE,MAAM,CACjC;IAE1C,6EAA6E;IAC7E,mBADmE,MAAM,CAClD;IAEvB,oEAAoE;IACpE,6BAD0D,MAAM,CAChC;IAEhC,sGAAsG;IACtG,uBAD4F,MAAM,CACtE;IAE5B,6EAA6E;IAC7E,mBADmE,MAAM,CACjD;IAExB,0EAA0E;IAC1E,mBADgE,MAAM,CAC9C;IAExB;;;;OAIG;IACH,SAFU,UAAU,EAAE,CAET;IAEb;;;OAGG;IACH,OAFU,QAAM,CAEE;IAElB;;;;OAIG;IACH,kBAFU,OAAO,CAEQ;IAyBzB;;;;;OAKG;IACH,uBAHa,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,WALW,UAAU,KACV,UAAU,GACR,MAAM,CAKlB;IAED;;;;;OAKG;IACH,uBAHa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,qCAEC;IAED;;;;;;;OAOG;IACH,qDAHW,OAAO,uBAIjB;IAID,uBAEC;IAED,oBAEC;IAqBD;;;;;;;OAOG;IACH,yCAsCC;IAED;;;;;;OAMG;IACH,wBAFa,OAAO,CA0BnB;IAED;;;;;OAKG;IACH,eAsDC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,gBAcC;IAED;;;OAGG;IACH,yBAsCC;;CACJ;;;;;;;;;;;;;;;;;;;;;;;;qBAnXa,MAAM;;;;gBACN,OAAO"}
+{"version":3,"file":"TransientResourcePool.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/pool/TransientResourcePool.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;IAII,+EAA+E;IAC/E,wBADqE,MAAM,CACjC;IAE1C,6EAA6E;IAC7E,mBADmE,MAAM,CAClD;IAEvB,oEAAoE;IACpE,6BAD0D,MAAM,CAChC;IAEhC,sGAAsG;IACtG,uBAD4F,MAAM,CACtE;IAE5B,6EAA6E;IAC7E,mBADmE,MAAM,CACjD;IAExB,0EAA0E;IAC1E,mBADgE,MAAM,CAC9C;IAExB;;;;OAIG;IACH,SAFU,UAAU,EAAE,CAET;IAEb;;;OAGG;IACH,OAFU,QAAM,CAEE;IAElB;;;;OAIG;IACH,kBAFU,OAAO,CAEQ;IAyBzB;;;;;OAKG;IACH,uBAHa,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,WALW,UAAU,KACV,UAAU,GACR,MAAM,CAKlB;IAED;;;;;OAKG;IACH,uBAHa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,qCAEC;IAED;;;;;OAKG;IACH,uBAFW,UAAU,QAGpB;IAED;;;;;;;OAOG;IACH,qDAHW,OAAO,uBAIjB;IAID,uBAEC;IAED,oBAEC;IAqBD;;;;;;;OAOG;IACH,yCA0CC;IAED;;;;;;OAMG;IACH,wBAFa,OAAO,CAiCnB;IAED;;;;;OAKG;IACH,eAsDC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,gBAcC;IAED;;;OAGG;IACH,yBAwCC;;CACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA1Ya,MAAM;;;;qBACN,MAAM;;;;gBACN,OAAO"}

package/src/shade/renderer/pool/TransientResourcePool.js

@@ -1,4 +1,6 @@
 import { assert } from "../../../core/assert.js";
+import { array_insert_at } from "../../../core/collection/array/array_insert_at.js";
+import { array_remove_at } from "../../../core/collection/array/array_remove_at.js";
 import { binarySearchHighIndex } from "../../../core/collection/array/binarySearchHighIndex.js";
 
 /**
@@ -16,8 +18,15 @@ import { binarySearchHighIndex } from "../../../core/collection/array/binarySear
  * immediately (within and across frames) — there is no frames-in-flight reuse gate; only
  * *destruction* is deferred, by {@link update}.
  *
+ * A record carries what the pool is ordered and accounted by, cached when its resource enters the
+ * pool: `size` here, and whatever else {@link describeRecord} adds for {@link compare} and
+ * {@link find}. A resource can be a platform object — a `GPUBuffer`'s `size` and `usage` are native
+ * reads — and the binary search and scan visit records many times a frame, so they read the record,
+ * never the resource.
+ *
  * @typedef {object} PoolRecord
  * @property {*} resource the pooled resource (or null while the record sits on the free-list)
+ * @property {number} size {@link sizeOf} the resource, as it was when it entered the pool
  * @property {number} last_used_frame frame the resource was last released into the pool
  * @property {boolean} referenced CLOCK second-chance bit; set on release and on reuse
  */
@@ -137,6 +146,15 @@ export class TransientResourcePool {
         throw new Error('TransientResourcePool.destroyResource is abstract');
     }
 
+    /**
+     * Cache on a record entering the pool whatever {@link compare} and {@link find} read beyond `size`,
+     * so neither has to ask the resource. Called on {@link release} once `resource` and `size` are set,
+     * and before the record is placed in order. Default: nothing.
+     * @param {PoolRecord} record
+     */
+    describeRecord(record) {
+    }
+
     /**
      * Hook invoked at the end of {@link get}, after the resource is acquired and tracked. Subclasses
      * override it for post-acquire work (clear-on-reuse, postcondition asserts). Default: nothing.
@@ -164,7 +182,7 @@ export class TransientResourcePool {
         const record = this.#free_records.pop();
 
         if (record === undefined) {
-            return { resource: null, last_used_frame: 0, referenced: false };
+            return { resource: null, size: 0, last_used_frame: 0, referenced: false };
         }
 
         return record;
@@ -191,21 +209,25 @@ export class TransientResourcePool {
         const index = this.find(descriptor);
 
         let resource;
+        let size;
         let reused;
 
         if (index !== -1) {
             const record = this.records[index];
 
             resource = record.resource;
+            size = record.size;
 
-            this.records.splice(index, 1);
-            this.#bytes_pooled -= this.sizeOf(resource);
+            array_remove_at(this.records, index);
+            this.#bytes_pooled -= size;
 
             this.#recycle_record(record);
 
             reused = true;
         } else {
             resource = this.make(descriptor);
+            size = this.sizeOf(resource);
+
             this.#surge++;
 
             reused = false;
@@ -214,7 +236,7 @@ export class TransientResourcePool {
         assert.notOk(this.bound.has(resource), 'resource is already bound');
 
         this.bound.add(resource);
-        this.#bytes_bound += this.sizeOf(resource);
+        this.#bytes_bound += size;
 
         this.afterAcquire(resource, descriptor, reused, context);
 
@@ -238,18 +260,25 @@ export class TransientResourcePool {
         }
 
         this.bound.delete(resource);
-        this.#bytes_bound -= this.sizeOf(resource);
+
+        // the one time a pooling asks the resource its size: the record keeps it from here on
+        const size = this.sizeOf(resource);
+
+        this.#bytes_bound -= size;
 
         const record = this.#take_record();
 
         record.resource = resource;
+        record.size = size;
         record.last_used_frame = this.#frame;
         record.referenced = true;
 
+        this.describeRecord(record);
+
         const index = binarySearchHighIndex(this.records, record, this.#compare);
 
-        this.records.splice(index, 0, record);
-        this.#bytes_pooled += this.sizeOf(resource);
+        array_insert_at(this.records, index, record);
+        this.#bytes_pooled += size;
 
         if (this.debug_invariants) {
             this.assertInvariants();
@@ -294,9 +323,9 @@ export class TransientResourcePool {
 
                 if (reclaim_budget > 0 && (under_pressure || idle_too_long)) {
                     const resource = record.resource;
-                    const size = this.sizeOf(resource);
+                    const size = record.size;
 
-                    records.splice(cursor, 1);
+                    array_remove_at(records, cursor);
                     this.#bytes_pooled -= size;
                     over_budget -= size;
                     record_count--;
@@ -371,7 +400,9 @@ export class TransientResourcePool {
                 assert.lessThanOrEqual(this.compare(record, records[i + 1]), 0, `records not sorted at index ${i}`);
             }
 
-            pooled_bytes += this.sizeOf(record.resource);
+            assert.equal(record.size, this.sizeOf(record.resource), `records[${i}].size is not its resource's`);
+
+            pooled_bytes += record.size;
         }
 
         assert.equal(this.#bytes_pooled, pooled_bytes, 'bytes_pooled drifted from actual pooled total');

package/src/shade/renderer/scene/optimization/geometry/internal/triangle_fingerprint_stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle_fingerprint_stream.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/triangle_fingerprint_stream.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;;;;;GAcG;AACH,iEAFa,WAAW,CA2EvB"}
+{"version":3,"file":"triangle_fingerprint_stream.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/triangle_fingerprint_stream.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;GAcG;AACH,iEAFa,WAAW,CAmFvB"}

package/src/shade/renderer/scene/optimization/geometry/internal/triangle_fingerprint_stream.js

@@ -1,5 +1,6 @@
 import { reinterpret_float32_as_int32 } from "../../../../../../core/binary/reinterpret_float32_as_int32.js";
-import { combine_hash } from "../../../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../../../core/math/hash/hash_mix3.js";
 import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
 import { StandardAttributes } from "../../../../geometry/StandardAttributes.js";
 
@@ -15,7 +16,7 @@ function fold_strided(h, data, stride, vertex_index) {
     if (data === null) return h;
     const base = vertex_index * stride;
     for (let i = 0; i < stride; i++) {
-        h = combine_hash(h, reinterpret_float32_as_int32(data[base + i]));
+        h = hash_mix2(h, reinterpret_float32_as_int32(data[base + i]));
     }
     return h;
 }
@@ -140,9 +141,17 @@ export function triangle_fingerprint_stream(geometry) {
 
         sort_three(keys_scratch, attrs_scratch);
 
-        result[t] = combine_hash(
-            keys_scratch[0], keys_scratch[1], keys_scratch[2],
-            attrs_scratch[0], attrs_scratch[1], attrs_scratch[2]
+        result[t] = hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    keys_scratch[0],
+                    keys_scratch[1],
+                    keys_scratch[2]
+                ),
+                attrs_scratch[0],
+                attrs_scratch[1]
+            ),
+            attrs_scratch[2]
         ) | 0;
     }
 

package/src/shade/renderer/scene/optimization/sampler2d_from_image_bitmap.js

@@ -8,7 +8,7 @@ import html_canvas_to_sampler2d from "../../../../engine/graphics/texture/html_c
 export function sampler2d_from_image_bitmap(bitmap) {
     // 1. Draw the bitmap to a canvas
     const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-    const ctx = canvas.getContext('2d');
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
     ctx.drawImage(bitmap, 0, 0);
 
     return html_canvas_to_sampler2d(canvas);

package/src/shade/renderer/shader/ComputeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA8FI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA0BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CA/VyC,gEAAgE;iCACzE,uBAAuB"}
+{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAMA;IA0GI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAhFD;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA8BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;0CA/WyC,gEAAgE;iCACzE,uBAAuB"}

package/src/shade/renderer/shader/ComputeShader.js

@@ -16,6 +16,18 @@ export class ComputeShader {
      */
     #pipeline;
 
+    /**
+     * The device this shader last passed {@link ShaderDescriptor#validate_against_device} on, or null.
+     *
+     * A device's limits and features are fixed for its life, and what this shader asks of them is fixed
+     * once it compiles, at construction. So the check is one per device rather than one per pass, which
+     * was ~400 native reads of `device.limits` and `device.features` a frame. Set only once the check
+     * has passed: a refused device is asked again, and refused again, every time.
+     *
+     * @type {GPUDevice|null}
+     */
+    #validated_device = null;
+
     /**
      *
      * @return {ComputePipelineDescriptor}
@@ -147,8 +159,12 @@ export class ComputeShader {
         assert.defined(encoder, 'encoder');
         assert.defined(bindings, 'bindings');
 
-        if (VALIDATION_ENABLED) {
-            this.#descriptor.validate_against_device(encoder.device);
+        const device = encoder.device;
+
+        if (VALIDATION_ENABLED && device !== this.#validated_device) {
+            this.#descriptor.validate_against_device(device);
+
+            this.#validated_device = device;
         }
 
         const resources = this.#descriptor.resources;

package/src/shade/renderer/shader/ImageShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAyGI;;;;;;;OAOG;IACH;QALqC,UAAU;QACR,OAAO,EAAnC,kBAAkB;QACU,YAAY;QACtC,WAAW,CAavB;IAnFD;;;;;OAKG;IACH,sEAuDC;IAhGD;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAOlB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,6BAEC;IAuFD;;;;;;;;;OASG;IACH,6HAsEC;;CACJ"}
+{"version":3,"file":"ImageShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ImageShader.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAiHI;;;;;;;OAOG;IACH;QALqC,UAAU;QACR,OAAO,EAAnC,kBAAkB;QACU,YAAY;QACtC,WAAW,CAavB;IAnFD;;;;;OAKG;IACH,sEAuDC;IAxGD;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,cAFU,MAAM,EAAE,EAAE,CAEF;IAelB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,6BAEC;IAuFD;;;;;;;;;OASG;IACH,6HA0EC;;CACJ"}