@woosh/meep-engine 3.45.0 → 3.46.0

package/src/shade/renderer/geometry/virtual/format/checksum/vgeo_compute_frame_checksum.js

@@ -1,41 +1,41 @@
-import { xxh3_64 } from "../../../../../../core/binary/hash/xxh3_64.js";
-import { VGEO_FRAME_HEADER_SIZE } from "../frame/VGEO_FRAME_HEADER_SIZE.js";
-import { VGEO_FRAME_OFFSET } from "../frame/VGEO_FRAME_OFFSET.js";
-
-/**
- * The identity-seeded checksum of one frame: xxh3-64 over the frame's bytes with its own `checksum`
- * field cut out, seeded so that a well-formed frame of the wrong page or the wrong asset fails to
- * verify rather than installing silently.
- *
- * The seed is taken from `asset_id`, which is why {@link vgeo_asset_id_preimage} zeroes this field
- * before hashing: the two would otherwise be defined in terms of each other.
- *
- * @param {BinaryBuffer} buffer whole file
- * @param {VGeoFrameExtent} frame
- * @param {bigint} asset_id_low64
- * @returns {bigint}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_frame_checksum(buffer, frame, asset_id_low64) {
-    const seed = asset_id_low64 ^ BigInt(frame.page_index);
-
-    const bytes = buffer.raw_bytes;
-
-    const covered = new Uint8Array(frame.extent - 8);
-
-    // frame bytes [0, 16)
-    covered.set(
-        bytes.subarray(frame.frame_offset, frame.frame_offset + VGEO_FRAME_OFFSET.CHECKSUM),
-        0
-    );
-
-    // frame bytes [24, extent)
-    covered.set(
-        bytes.subarray(frame.frame_offset + VGEO_FRAME_HEADER_SIZE, frame.frame_offset + frame.extent),
-        VGEO_FRAME_OFFSET.CHECKSUM
-    );
-
-    return xxh3_64(covered, seed);
-}
+import { xxh3_64 } from "../../../../../../core/math/hash/xxh3_64.js";
+import { VGEO_FRAME_HEADER_SIZE } from "../frame/VGEO_FRAME_HEADER_SIZE.js";
+import { VGEO_FRAME_OFFSET } from "../frame/VGEO_FRAME_OFFSET.js";
+
+/**
+ * The identity-seeded checksum of one frame: xxh3-64 over the frame's bytes with its own `checksum`
+ * field cut out, seeded so that a well-formed frame of the wrong page or the wrong asset fails to
+ * verify rather than installing silently.
+ *
+ * The seed is taken from `asset_id`, which is why {@link vgeo_asset_id_preimage} zeroes this field
+ * before hashing: the two would otherwise be defined in terms of each other.
+ *
+ * @param {BinaryBuffer} buffer whole file
+ * @param {VGeoFrameExtent} frame
+ * @param {bigint} asset_id_low64
+ * @returns {bigint}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_compute_frame_checksum(buffer, frame, asset_id_low64) {
+    const seed = asset_id_low64 ^ BigInt(frame.page_index);
+
+    const bytes = buffer.raw_bytes;
+
+    const covered = new Uint8Array(frame.extent - 8);
+
+    // frame bytes [0, 16)
+    covered.set(
+        bytes.subarray(frame.frame_offset, frame.frame_offset + VGEO_FRAME_OFFSET.CHECKSUM),
+        0
+    );
+
+    // frame bytes [24, extent)
+    covered.set(
+        bytes.subarray(frame.frame_offset + VGEO_FRAME_HEADER_SIZE, frame.frame_offset + frame.extent),
+        VGEO_FRAME_OFFSET.CHECKSUM
+    );
+
+    return xxh3_64(covered, seed);
+}

package/src/shade/renderer/geometry/virtual/format/checksum/vgeo_compute_header_checksum.js

@@ -1,25 +1,25 @@
-import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
-import { xxh3_64 } from "../../../../../../core/binary/hash/xxh3_64.js";
-import { VGEO_HEADER_OFFSET } from "../header/VGEO_HEADER_OFFSET.js";
-import { VGEO_HEADER_SIZE } from "../header/VGEO_HEADER_SIZE.js";
-
-/**
- * xxh3-64 of the header with `header_checksum` zeroed. `asset_id` must already be final: the
- * ordering is what keeps the two non-circular.
- *
- * @param {BinaryBuffer} buffer whole file
- * @returns {bigint}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function vgeo_compute_header_checksum(buffer) {
-    const header = new BinaryBuffer();
-
-    header.fromArrayBuffer(buffer.raw_bytes.slice(0, VGEO_HEADER_SIZE).buffer);
-
-    header.position = VGEO_HEADER_OFFSET.HEADER_CHECKSUM;
-    header.writeUint64(0n);
-
-    return xxh3_64(header.raw_bytes);
-}
+import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+import { xxh3_64 } from "../../../../../../core/math/hash/xxh3_64.js";
+import { VGEO_HEADER_OFFSET } from "../header/VGEO_HEADER_OFFSET.js";
+import { VGEO_HEADER_SIZE } from "../header/VGEO_HEADER_SIZE.js";
+
+/**
+ * xxh3-64 of the header with `header_checksum` zeroed. `asset_id` must already be final: the
+ * ordering is what keeps the two non-circular.
+ *
+ * @param {BinaryBuffer} buffer whole file
+ * @returns {bigint}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_compute_header_checksum(buffer) {
+    const header = new BinaryBuffer();
+
+    header.fromArrayBuffer(buffer.raw_bytes.slice(0, VGEO_HEADER_SIZE).buffer);
+
+    header.position = VGEO_HEADER_OFFSET.HEADER_CHECKSUM;
+    header.writeUint64(0n);
+
+    return xxh3_64(header.raw_bytes);
+}

package/src/shade/renderer/material/StandardShadeMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StandardShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/StandardShadeMaterial.js"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH;IACI;;;OAGG;IACH,gBAFU,YAAY,CAEP;IAEf;;;OAGG;IACH,eAFU,KAAK,CAEsB;IAErC;;OAEG;IACH,gBAFU,YAAY,CAEP;IAEf;;;;;;OAMG;IACH,aAFU,YAAY,CAEV;IAEZ;;OAEG;IACH,kBAFU,YAAY,CAEL;IAEjB;;;;;;;;OAQG;IACH,UAFU,mBAAmB,GAAC,SAAS,CAE9B;IAET;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,QAFU,mBAAmB,GAAC,IAAI,CAEpB;IAEd;;;OAGG;IACH,iBAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,iBAFU,cAAc,CAEmB;IAW3C;;;;;OAKG;IACH,YAFW,qBAAqB,QAoB/B;IAED;;;OAGG;IACH,SAFa,qBAAqB,CAQjC;IAaD;;;;OAIG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA+BnB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;2BAvMY,OAAO,4BAA4B,EAAE,YAAY;kCACjD,OAAO,2CAA2C,EAAE,mBAAmB;kCACvE,OAAO,kCAAkC,EAAE,mBAAmB;8BAL7C,oBAAoB;sBAJ5B,8BAA8B;2BACzB,4CAA4C"}
+{"version":3,"file":"StandardShadeMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/StandardShadeMaterial.js"],"names":[],"mappings":"AAQA;;;;GAIG;AAEH;IACI;;;OAGG;IACH,gBAFU,YAAY,CAEP;IAEf;;;OAGG;IACH,eAFU,KAAK,CAEsB;IAErC;;OAEG;IACH,gBAFU,YAAY,CAEP;IAEf;;;;;;OAMG;IACH,aAFU,YAAY,CAEV;IAEZ;;OAEG;IACH,kBAFU,YAAY,CAEL;IAEjB;;;;;;;;OAQG;IACH,UAFU,mBAAmB,GAAC,SAAS,CAE9B;IAET;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,QAFU,mBAAmB,GAAC,IAAI,CAEpB;IAEd;;;OAGG;IACH,iBAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,iBAFU,cAAc,CAEmB;IAW3C;;;;;OAKG;IACH,YAFW,qBAAqB,QAoB/B;IAED;;;OAGG;IACH,SAFa,qBAAqB,CAQjC;IAiBD;;;;OAIG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA+BnB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;2BA3MY,OAAO,4BAA4B,EAAE,YAAY;kCACjD,OAAO,2CAA2C,EAAE,mBAAmB;kCACvE,OAAO,kCAAkC,EAAE,mBAAmB;8BAL7C,oBAAoB;sBAJ5B,8BAA8B;2BACzB,4CAA4C"}

package/src/shade/renderer/material/StandardShadeMaterial.js

@@ -1,4 +1,5 @@
-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 { Color } from "../../../core/color/Color.js";
 import LinearModifier from "../../../core/model/stat/LinearModifier.js";
 import { optional_equality } from "../../../core/model/object/optional_equality.js";
@@ -160,13 +161,17 @@ export class StandardShadeMaterial extends ShadeMaterial {
     }
 
     hash() {
-        return combine_hash(
-            super.hash(),
-            this.diffuse_color.hash(),
-            optional_hash(this.texture_albedo),
-            optional_hash(this.texture_normal),
-            optional_hash(this.texture_orm),
-            optional_hash(this.texture_emissive),
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    super.hash(),
+                    this.diffuse_color.hash(),
+                    optional_hash(this.texture_albedo)
+                ),
+                optional_hash(this.texture_normal),
+                optional_hash(this.texture_orm)
+            ),
+            optional_hash(this.texture_emissive)
         );
     }
 

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/type/WGSLStructField.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { isArrayEqual } from "../../../../core/collection/array/isArrayEqual.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -181,7 +181,7 @@ export class WGSLStructField {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             computeStringHash(this.name),
             this.offset,
             this.type.hash()

package/src/shade/renderer/shader/type/WebGPUArray.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { CodeChunk } from "../compiler/CodeChunk.js";
 import { f32, u32, vec4f, vec4u } from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
@@ -61,7 +61,7 @@ export class WebGPUArray extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.type.hash(),
             this.count
         );

package/src/shade/renderer/shader/type/WebGPUStruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH;IAiNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA1QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAqGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BArb0B,iBAAiB;gCAEZ,sBAAsB"}
+{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH;IAmNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA5QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAuGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BAvb0B,iBAAiB;gCAEZ,sBAAsB"}

package/src/shade/renderer/shader/type/WebGPUStruct.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import LineBuilder from "../../../../core/codegen/LineBuilder.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 { isArrayEqual } from "../../../../core/collection/array/isArrayEqual.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -210,11 +211,13 @@ export class WebGPUStruct extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
-            computeStringHash(this.name),
-            this.#size,
-            this.#align,
-            this.fields.length,
+        return hash_mix2(
+            hash_mix3(
+                computeStringHash(this.name),
+                this.#size,
+                this.#align
+            ),
+            this.fields.length
         );
     }
 

package/src/shade/renderer/texture/ShadeTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAcA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAWC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBArKY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}
+{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAeA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAiBC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBA3KY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}

package/src/shade/renderer/texture/ShadeTexture.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.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 { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeTextureFlags } from "./ShadeTextureFlags.js";
 import { TextureFilterType } from "./TextureFilterType.js";
@@ -143,15 +144,21 @@ export class ShadeTexture {
     }
 
     hash() {
-        return combine_hash(
-            optional_hash(this.#image),
-            this.flags,
-            this.minFilter,
-            this.magFilter,
-            this.mipmapFilter,
-            this.wrapS,
-            this.wrapT,
-            this.wrapR,
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        optional_hash(this.#image),
+                        this.flags,
+                        this.minFilter
+                    ),
+                    this.magFilter,
+                    this.mipmapFilter
+                ),
+                this.wrapS,
+                this.wrapT
+            ),
+            this.wrapR
         );
     }
 

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { platform_compute_endianness } from "../../../../core/binary/platform_compute_endianness.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
 import { round_up } from "../../../../core/math/round_up.js";
@@ -69,7 +69,7 @@ class MipmapShaderKey {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.format),
             this.filter,
         )

package/src/shade/renderer/water/surface/chunk_water_surface_sample.d.ts

@@ -1,8 +1,8 @@
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET: 64;
 /**

package/src/shade/renderer/water/surface/chunk_water_surface_sample.js

@@ -5,10 +5,10 @@ import { chunk_water_spectrum } from "./spectrum/chunk_water_spectrum.js";
 import { chunk_water_particle } from "./particles/chunk_water_particle.js";
 
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET = 64;
 
@@ -133,8 +133,8 @@ fn water_surface_sum(wave: u32, p: vec2<f32>, footprint: f32) -> WaterSurfaceSum
             visited++;
             let entry = water_particle_entries[i];
             if (entry.key != key || any(entry.cell != cell)) { continue; }
-            let field = water_particle_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
-                entry.dispersion, entry.distance, entry.phase);
+            let field = water_particle_run_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
+                entry.dispersion, entry.distance, entry.phase, entry.run);
             // a packet is geometry while its wavelength spans eight samples, fading out by four
             let f = clamp(log2(entry.radius / (2.0 * footprint)), 0.0, 1.0);
             let rough = sqrt(1.0 - f * f);

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IA0BI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA6D7G;IAED,gBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aAmGhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAwBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA4D7G;IAED,gBAeC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aA8FhB;;CACJ"}

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.js

@@ -14,15 +14,15 @@ import {
     shader_water_particles_bin,
     shader_water_particles_bounds,
     shader_water_particles_clear,
+    shader_water_particles_cut,
     shader_water_particles_emit,
     shader_water_particles_finalize,
-    shader_water_particles_fronts,
-    shader_water_particles_groups,
+    shader_water_particles_keep,
+    shader_water_particles_links,
+    shader_water_particles_mark,
     shader_water_particles_nest,
     shader_water_particles_rank,
-    shader_water_particles_runs,
     shader_water_particles_scatter,
-    shader_water_particles_share,
     shader_water_particles_split,
     shader_water_particles_total,
     shader_water_particles_update,
@@ -58,17 +58,15 @@ export class GPUWaterParticles {
     #children = null;
     #child_sums = null;
     #images = null;
-    #fronts = null;
-    #front_sums = null;
-    #runs = null;
-    #draw = null;
+    #links = null;
+    #reaches = null;
+    #shown = null;
     #buckets = null;
     #offsets = null;
     #slots = null;
     #bucket_amplitude = null;
-    #bucket_weight = null;
+    #bucket_crowd = null;
     #bucket_nest = null;
-    #visible = null;
     #staging = null;
     #entries = null;
     #body_bounds = null;
@@ -114,22 +112,21 @@ export class GPUWaterParticles {
             this.#child_sums = buffer('child sums', sums(capacity));
             // per particle the mirror image the step left beside it at the outline
             this.#images = buffer('images', capacity * WATER_PARTICLE_STRUCT.size);
-            // per particle whether it starts a run, then the scanned run it is in; per run its first particle and its
-            // share; per particle its run and how it is drawn
-            this.#fronts = buffer('fronts', 16 + capacity * 4);
-            this.#front_sums = buffer('front sums', sums(capacity));
-            this.#runs = buffer('runs', capacity * 8);
-            this.#draw = buffer('draw', capacity * 8);
+            // per particle its front's neighbours before and after it
+            this.#links = buffer('links', capacity * 8);
+            // per particle the cells its support overlaps this frame: its first, its level and spans
+            this.#reaches = buffer('reaches', capacity * 12);
+            // per particle whether its crowds draw it
+            this.#shown = buffer('shown', capacity * 4);
             // per bucket its entries, then the hash: table size and inclusive offsets
             this.#buckets = buffer('buckets', 16 + this.#table_limit * 4);
             this.#offsets = buffer('offsets', sums(this.#table_limit));
             this.#slots = buffer('slots', capacity * WATER_PARTICLE_CORNERS * 4);
             this.#bucket_amplitude = buffer('bucket amplitude', this.#table_limit * 4);
-            // the summed steepness, the largest front and front complement entered, and the entries; then the most a point
-            // under it reads, and its entries by key
-            this.#bucket_weight = buffer('bucket weight', this.#table_limit * WATER_PARTICLE_CROWD_WORDS * 4);
+            // its runs by steepness class and in all; then the most a point under it reads at finer levels, the classes its
+            // points keep and draw, and a slot of the frame's table of cut fronts
+            this.#bucket_crowd = buffer('bucket crowd', this.#table_limit * WATER_PARTICLE_CROWD_WORDS * 4);
             this.#bucket_nest = buffer('bucket nest', this.#table_limit * WATER_PARTICLE_NEST_WORDS * 4);
-            this.#visible = buffer('visible', capacity * 4);
             const entries = capacity * WATER_PARTICLE_CORNERS * WATER_PARTICLE_ENTRY_STRUCT.size;
             this.#staging = buffer('staging', entries);
             this.#entries = buffer('entries', entries);
@@ -157,16 +154,15 @@ export class GPUWaterParticles {
     }
 
     dispose() {
-        for (const buffer of [...this.#particles, this.#children, this.#child_sums, this.#images, this.#fronts, this.#front_sums, this.#runs,
-            this.#draw, this.#buckets, this.#offsets, this.#slots, this.#bucket_amplitude, this.#bucket_weight, this.#bucket_nest, this.#visible,
-            this.#staging, this.#entries, this.#body_bounds, ...(this.#commands ?? [])]) {
+        for (const buffer of [...this.#particles, this.#children, this.#child_sums, this.#images, this.#links, this.#reaches, this.#shown, this.#buckets,
+            this.#offsets, this.#slots, this.#bucket_amplitude, this.#bucket_crowd, this.#bucket_nest, this.#staging, this.#entries, this.#body_bounds,
+            ...(this.#commands ?? [])]) {
             buffer?.destroy();
         }
         this.#particles = [];
         this.#children = this.#child_sums = this.#images = this.#buckets = this.#offsets = this.#slots = this.#bucket_amplitude = null;
         this.#staging = this.#entries = null;
-        this.#fronts = this.#front_sums = this.#runs = this.#draw = null;
-        this.#bucket_weight = this.#bucket_nest = this.#visible = null;
+        this.#links = this.#reaches = this.#shown = this.#bucket_crowd = this.#bucket_nest = null;
         this.#body_bounds = null;
         this.#commands = null;
         this.#device = null;
@@ -205,8 +201,6 @@ export class GPUWaterParticles {
         let child_sums = graph_import_buffer(graph, this.#child_sums, 'Water / particle child sums');
         let buckets = graph_import_buffer(graph, this.#buckets, 'Water / particle buckets');
         let offsets = graph_import_buffer(graph, this.#offsets, 'Water / particle offsets');
-        let fronts = graph_import_buffer(graph, this.#fronts, 'Water / particle fronts');
-        let front_sums = graph_import_buffer(graph, this.#front_sums, 'Water / particle front sums');
         const node = (name, execute, reads, writes) => {
             const data = {};
             const pass = graph.add(name, data, (d, resources, context) => execute(resources, context, d));
@@ -243,49 +237,46 @@ export class GPUWaterParticles {
             }, { child_sums }, {});
         }
 
-        // Each front's run of particles, so that a whole one is drawn as the seven it was emitted as.
-        fronts = node('Water / particles fronts', (resources, { encoder }) => {
+        // The frame's hash: each particle's neighbours round its front, so that a run of them is drawn as one; how crowded
+        // each cell is and so which runs it keeps, the steepest, dooming the rest and cutting, whole, the fronts the gather
+        // cannot read;
+        // then each drawn run entered into every cell its first particle's support overlaps, offsets, entries in order.
+        buckets = node('Water / particles bin', (resources, { encoder }) => {
             if (!stepping) {
                 // the table size the last stepping frame chose for these particles
                 shader_water_particles_finalize.dispatch({ encoder, bindings: { limits: { capacity, table_limit }, next, offsets: this.#buckets,
                     table_command: command_table } });
             }
             build_indirect_compute_dispatch_command(64, encoder, next, 0, command_next, 0, true);
-            encoder.copyBufferToBuffer(next, 0, this.#fronts, 0, 4);
-            shader_water_particles_fronts.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#fronts } });
-        }, {}, { fronts }).fronts;
-        front_sums = graph_prefix_scan_csdldf({ graph, input: fronts, output: front_sums, element_max_count: capacity });
-
-        // The frame's hash: how each particle is drawn, how crowded each cell is and so how much of each run its crowd
-        // leaves drawn, then each packet drawn into the cells its support overlaps, offsets, entries in order.
-        buckets = node('Water / particles bin', (resources, { encoder }) => {
-            const draw = this.#draw, runs = this.#runs;
-            shader_water_particles_runs.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#front_sums, runs } });
-            shader_water_particles_groups.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#front_sums, runs, draw } });
+            const links = this.#links;
+            const reaches = this.#reaches;
+            shader_water_particles_links.dispatchIndirect({ encoder, command: command_next, bindings: { next, links, reaches } });
             shader_water_particles_clear.dispatchIndirect({ encoder, command: command_table, bindings: {
-                buckets: this.#buckets, bucket_amplitude: this.#bucket_amplitude, bucket_weight: this.#bucket_weight,
-                bucket_nest: this.#bucket_nest } });
-            shader_water_particles_weigh.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, draw, bucket_weight: this.#bucket_weight, body_bounds: this.#body_bounds } });
-            shader_water_particles_nest.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, draw, body_bounds: this.#body_bounds, bucket_weight: this.#bucket_weight,
+                buckets: this.#buckets, bucket_amplitude: this.#bucket_amplitude, bucket_crowd: this.#bucket_crowd,
                 bucket_nest: this.#bucket_nest } });
-            shader_water_particles_share.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, bucket_weight: this.#bucket_weight, bucket_nest: this.#bucket_nest,
-                body_bounds: this.#body_bounds, draw, runs } });
+            const crowd = { next, activity, offsets: this.#buckets, links, reaches, body_bounds: this.#body_bounds,
+                bucket_crowd: this.#bucket_crowd };
+            shader_water_particles_weigh.dispatchIndirect({ encoder, command: command_next, bindings: crowd });
+            shader_water_particles_nest.dispatchIndirect({ encoder, command: command_next, bindings: { ...crowd, bucket_nest: this.#bucket_nest } });
+            shader_water_particles_cut.dispatchIndirect({ encoder, command: command_next, bindings: { ...crowd, bucket_nest: this.#bucket_nest } });
+            const shown = this.#shown;
+            shader_water_particles_mark.dispatchIndirect({ encoder, command: command_next, bindings: {
+                next, activity, offsets: this.#buckets, reaches, bucket_nest: this.#bucket_nest } });
+            shader_water_particles_keep.dispatchIndirect({ encoder, command: command_next, bindings: {
+                next, activity, offsets: this.#buckets, reaches, bucket_nest: this.#bucket_nest, shown } });
             shader_water_particles_bin.dispatchIndirect({ encoder, command: command_next, bindings: {
                 next, activity, buckets: this.#buckets, slots: this.#slots, bucket_amplitude: this.#bucket_amplitude,
-                body_bounds: this.#body_bounds, draw, runs, visible: this.#visible } });
-        }, { front_sums }, { buckets }).buckets;
+                body_bounds: this.#body_bounds, links, reaches, shown } });
+        }, {}, { buckets }).buckets;
         offsets = graph_prefix_scan_csdldf({ graph, input: buckets, output: offsets, element_max_count: table_limit });
         node('Water / particles order and bound', (resources, { encoder }) => {
-            const bindings = { next, offsets: this.#offsets, slots: this.#slots, draw: this.#draw };
+            const bindings = { next, offsets: this.#offsets, slots: this.#slots, reaches: this.#reaches };
             shader_water_particles_scatter.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings,
-                visible: this.#visible, staging: this.#staging } });
+                links: this.#links, shown: this.#shown, staging: this.#staging } });
             shader_water_particles_rank.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings,
                 staging: this.#staging, entries: this.#entries } });
-            shader_water_particles_bounds.dispatchIndirect({ encoder, command: command_next, bindings: { next, activity,
-                offsets: this.#offsets, bucket_amplitude: this.#bucket_amplitude, draw: this.#draw, body_bounds: this.#body_bounds } });
+            shader_water_particles_bounds.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings, activity,
+                bucket_amplitude: this.#bucket_amplitude, body_bounds: this.#body_bounds } });
         }, { offsets }, {});
     }
 }

package/src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.d.ts

@@ -8,9 +8,9 @@
  */
 export const WATER_PARTICLE_STRUCT: WebGPUStruct;
 /**
- * A particle as one hash cell holds it for the surface sampler: everything its kernel needs at the frame's
- * time, and the cell it was entered for, since one particle is entered in every cell its support overlaps and
- * two cells may share a bucket.
+ * A run of a front's particles as one hash cell holds it for the surface sampler: everything its kernel needs at the
+ * frame's time, from the run's first particle, and the cell it was entered for, since a front is entered in every cell
+ * its support overlaps and two cells may share a bucket.
  */
 export const WATER_PARTICLE_ENTRY_STRUCT: WebGPUStruct;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";

package/src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WATER_PARTICLE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,iDAoBoB;AAEpB;;;;GAIG;AACH,uDAkByB;6BAvDI,sCAAsC"}
+{"version":3,"file":"WATER_PARTICLE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,iDAyBoB;AAEpB;;;;GAIG;AACH,uDAuByB;6BAjEI,sCAAsC"}