@woosh/meep-engine 3.44.0 → 3.46.0

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

@@ -1,174 +1,179 @@
-import { assert } from "../../../core/assert.js";
-import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
-import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
-import {
-    ResourceDescriptor
-} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
-import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
-import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
-import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
-
-/**
- * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
- *
- * @enum {number}
- */
-export const TextureResolutionDomain = {
-    Absolute: 0,
-    PresentationRelative: 1
-}
-
-export class TextureResourceDescriptor extends ResourceDescriptor {
-    /**
-     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
-     *
-     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
-     * resolution it is given without touching this field, and every caller gives it pixels — so a
-     * descriptor's resolution is absolute pixels whatever this says, including on the default
-     * `PresentationRelative` that {@link from} leaves in place.
-     *
-     * @type {TextureResolutionDomain|number}
-     */
-    resolution_domain = TextureResolutionDomain.PresentationRelative;
-
-    // TODO use Uint32 instead
-    resolution = new Float64Array([1, 1, 1]);
-    sampleCount = 1;
-
-    mipLevelCount = 1;
-
-    /**
-     *
-     * @type {GPUTextureDimension|string}
-     */
-    dimension = "2d"
-
-    /**
-     * @type {string|GPUTextureFormat}
-     */
-    format = "rgba8unorm";
-
-    /**
-     * @type {number|GPUTextureUsageFlags}
-     */
-    usage = GPUTextureUsage.TEXTURE_BINDING;
-
-    /**
-     *
-     * @param {Object} options
-     * @param {number[]} options.resolution
-     * @param {GPUTextureDimension|string} [options.dimension]
-     * @param {GPUTextureFormat|string} options.format
-     * @param {GPUTextureUsageFlags|number} [options.usage]
-     * @param {boolean} [options.enableMips]
-     * @returns {TextureResourceDescriptor}
-     */
-    static from({
-                    resolution,
-                    dimension = "2d",
-                    format,
-                    usage = GPUTextureUsage.TEXTURE_BINDING,
-                    enableMips = false
-                }) {
-
-        assert.isString(format, 'format');
-        assert.defined(resolution, 'resolution');
-        assert.isArrayLike(resolution, 'resolution');
-        assert.isBoolean(enableMips, 'enableMips');
-
-        const r = new TextureResourceDescriptor();
-
-        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
-        r.dimension = dimension;
-        r.format = format;
-        r.usage = usage;
-
-        if (enableMips === true) {
-
-            // `r.resolution` rather than the argument: it has already been padded to three, so a
-            // caller that gave two axes reads as depth 1 instead of `undefined`
-            r.mipLevelCount = texture_mip_level_count(
-                r.resolution[0], r.resolution[1], r.resolution[2], r.dimension
-            );
-
-        }
-
-        return r;
-
-    }
-
-    /**
-     *
-     * @param {GPUTexture} texture
-     * @returns {TextureResourceDescriptor}
-     */
-    static fromTexture(texture) {
-        const r = new TextureResourceDescriptor();
-
-        r.format = texture.format;
-        r.dimension = texture.dimension;
-
-        r.usage = texture.usage;
-        r.sampleCount = texture.sampleCount;
-        r.resolution_domain = TextureResolutionDomain.Absolute;
-
-        r.resolution[0] = texture.width;
-        r.resolution[1] = texture.height;
-        r.resolution[2] = texture.depthOrArrayLayers;
-
-
-        r.mipLevelCount = texture.mipLevelCount;
-
-        return r;
-    }
-
-    get type() {
-        return "texture";
-    }
-
-    hash() {
-        return combine_hash(
-            this.resolution_domain,
-            this.mipLevelCount,
-            computeHashFloatArray(this.resolution),
-            this.sampleCount,
-            this.usage,
-            computeStringHash(this.format)
-        );
-    }
-
-    /**
-     *
-     * @param {TextureResourceDescriptor} other
-     * @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
-            && this.sampleCount === other.sampleCount
-            && this.dimension === other.dimension
-            && this.format === other.format
-            && this.usage === other.usage
-            ;
-    }
-
-    toString() {
-        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
-    }
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import {
+    ResourceDescriptor
+} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
+import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
+
+/**
+ * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
+ *
+ * @enum {number}
+ */
+export const TextureResolutionDomain = {
+    Absolute: 0,
+    PresentationRelative: 1
+}
+
+export class TextureResourceDescriptor extends ResourceDescriptor {
+    /**
+     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
+     *
+     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
+     * resolution it is given without touching this field, and every caller gives it pixels — so a
+     * descriptor's resolution is absolute pixels whatever this says, including on the default
+     * `PresentationRelative` that {@link from} leaves in place.
+     *
+     * @type {TextureResolutionDomain|number}
+     */
+    resolution_domain = TextureResolutionDomain.PresentationRelative;
+
+    // TODO use Uint32 instead
+    resolution = new Float64Array([1, 1, 1]);
+    sampleCount = 1;
+
+    mipLevelCount = 1;
+
+    /**
+     *
+     * @type {GPUTextureDimension|string}
+     */
+    dimension = "2d"
+
+    /**
+     * @type {string|GPUTextureFormat}
+     */
+    format = "rgba8unorm";
+
+    /**
+     * @type {number|GPUTextureUsageFlags}
+     */
+    usage = GPUTextureUsage.TEXTURE_BINDING;
+
+    /**
+     *
+     * @param {Object} options
+     * @param {number[]} options.resolution
+     * @param {GPUTextureDimension|string} [options.dimension]
+     * @param {GPUTextureFormat|string} options.format
+     * @param {GPUTextureUsageFlags|number} [options.usage]
+     * @param {boolean} [options.enableMips]
+     * @returns {TextureResourceDescriptor}
+     */
+    static from({
+                    resolution,
+                    dimension = "2d",
+                    format,
+                    usage = GPUTextureUsage.TEXTURE_BINDING,
+                    enableMips = false
+                }) {
+
+        assert.isString(format, 'format');
+        assert.defined(resolution, 'resolution');
+        assert.isArrayLike(resolution, 'resolution');
+        assert.isBoolean(enableMips, 'enableMips');
+
+        const r = new TextureResourceDescriptor();
+
+        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
+        r.dimension = dimension;
+        r.format = format;
+        r.usage = usage;
+
+        if (enableMips === true) {
+
+            // `r.resolution` rather than the argument: it has already been padded to three, so a
+            // caller that gave two axes reads as depth 1 instead of `undefined`
+            r.mipLevelCount = texture_mip_level_count(
+                r.resolution[0], r.resolution[1], r.resolution[2], r.dimension
+            );
+
+        }
+
+        return r;
+
+    }
+
+    /**
+     *
+     * @param {GPUTexture} texture
+     * @returns {TextureResourceDescriptor}
+     */
+    static fromTexture(texture) {
+        const r = new TextureResourceDescriptor();
+
+        r.format = texture.format;
+        r.dimension = texture.dimension;
+
+        r.usage = texture.usage;
+        r.sampleCount = texture.sampleCount;
+        r.resolution_domain = TextureResolutionDomain.Absolute;
+
+        r.resolution[0] = texture.width;
+        r.resolution[1] = texture.height;
+        r.resolution[2] = texture.depthOrArrayLayers;
+
+
+        r.mipLevelCount = texture.mipLevelCount;
+
+        return r;
+    }
+
+    get type() {
+        return "texture";
+    }
+
+    hash() {
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    this.resolution_domain,
+                    this.mipLevelCount,
+                    computeHashFloatArray(this.resolution)
+                ),
+                this.sampleCount,
+                this.usage
+            ),
+            computeStringHash(this.format)
+        );
+    }
+
+    /**
+     *
+     * @param {TextureResourceDescriptor} other
+     * @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
+            && this.sampleCount === other.sampleCount
+            && this.dimension === other.dimension
+            && this.format === other.format
+            && this.usage === other.usage
+            ;
+    }
+
+    toString() {
+        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
+    }
 }

package/src/shade/device/timing/profile/sgpt_read_header.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
 import { SGPTDefect } from "./SGPTDefect.js";
 import { SGPT_FORMAT_VERSION } from "./SGPT_FORMAT_VERSION.js";

package/src/shade/device/timing/profile/sgpt_read_records.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
 import { SGPTDefect } from "./SGPTDefect.js";
 import { SGPT_HEADER_SIZE } from "./SGPT_HEADER_SIZE.js";

package/src/shade/device/timing/profile/sgpt_write_header.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_FORMAT_VERSION } from "./SGPT_FORMAT_VERSION.js";
 import { SGPT_HEADER_CHECKSUM_COVERAGE } from "./SGPT_HEADER_CHECKSUM_COVERAGE.js";
 import { SGPT_HEADER_OFFSET } from "./SGPT_HEADER_OFFSET.js";

package/src/shade/device/timing/profile/sgpt_write_record.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_RECORD_HEADER_SIZE } from "./SGPT_RECORD_HEADER_SIZE.js";
 import { SGPT_RECORD_SYNC } from "./SGPT_RECORD_SYNC.js";
 

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

@@ -1,4 +1,5 @@
 import { jpeg_decode } from "../../../format/image/jpeg/jpeg_decode.js";
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Measures the trade `ImageRGBADataLoader`'s codec chain makes for a JPEG.
@@ -37,7 +38,7 @@ const table = document.getElementById("results");
  * @returns {number} the median, which a single GC pause cannot move
  */
 function median(values) {
-    const sorted = [...values].sort((a, b) => a - b);
+    const sorted = [...values].sort(number_compare_ascending);
     return sorted[sorted.length >> 1];
 }
 

package/src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff_traced_against_rasterized.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.js"],"names":[],"mappings":"AAsaA;;GAEG;AACH,2CAEC;AAoED;;;;;;;;;;;;;;;GAeG;AACH;IAT6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACc,OAAO,UAAhC,OAAO,KAAG,IAAI;IAEN,OAAO,GAAxB,MAAM;IAEJ,QAAQ,MAAM,CAAC,CA2O3B"}
+{"version":3,"file":"diff_traced_against_rasterized.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.js"],"names":[],"mappings":"AAuaA;;GAEG;AACH,2CAEC;AAoED;;;;;;;;;;;;;;;GAeG;AACH;IAT6B,QAAQ;IACC,MAAM;IAClB,KAAK;IACc,OAAO,UAAhC,OAAO,KAAG,IAAI;IAEN,OAAO,GAAxB,MAAM;IAEJ,QAAQ,MAAM,CAAC,CA2O3B"}

package/src/shade/playground/skinned_blas_refit/diff_traced_against_rasterized.js

@@ -1,4 +1,5 @@
 import { use_flat_environment } from "./flat_environment.js";
+import { number_compare_descending } from "../../../core/primitives/numbers/number_compare_descending.js";
 
 /**
  * Render the current view both ways and show, pixel by pixel, where they disagree.
@@ -415,7 +416,7 @@ function component_sizes(mask, width, height) {
         sizes.push(size);
     }
 
-    sizes.sort((a, b) => b - a);
+    sizes.sort(number_compare_descending);
 
     return sizes;
 }

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify_clone_vertices.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js"],"names":[],"mappings":"AA0JA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAb6B,QAAQ;IACX,KAAK;IACJ,MAAM,EAAtB,MAAM;IACW,SAAS,GAA1B,MAAM;IAQJ,QAAQ,MAAM,CAAC,CAsQ3B"}
+{"version":3,"file":"verify_clone_vertices.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js"],"names":[],"mappings":"AA2JA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAb6B,QAAQ;IACX,KAAK;IACJ,MAAM,EAAtB,MAAM;IACW,SAAS,GAA1B,MAAM;IAQJ,QAAQ,MAAM,CAAC,CAsQ3B"}

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js

@@ -37,6 +37,7 @@ import {
 import {
     SKINNING_WORKGROUP_SIZE
 } from "../../renderer/animation/skinning/shader_meshlet_apply_skinning.js";
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Copy a slice of a GPU buffer back to the CPU.
@@ -408,7 +409,7 @@ export async function verify_clone_vertices({ renderer, scene, entity, tolerance
     // The two shapes worth telling apart, named rather than left to be read out of the runs: a
     // stride-loop bug wrongs every slot at or past the workgroup size and nothing below it, and an
     // addressing bug wrongs whole meshlets.
-    const slots = [...wrong_by_slot.keys()].sort((a, b) => a - b);
+    const slots = [...wrong_by_slot.keys()].sort(number_compare_ascending);
 
     const lowest_wrong_slot = slots.length > 0 ? slots[0] : null;
 

package/src/shade/playground/ssr_variance/statistics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/statistics.js"],"names":[],"mappings":"AAAA,kGAAkG;AAClG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDC"}
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/statistics.js"],"names":[],"mappings":"AACA,kGAAkG;AAClG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDC"}

package/src/shade/playground/ssr_variance/statistics.js

@@ -1,3 +1,4 @@
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 /** Per-pixel temporal moments of linear Rec.709 luminance. No spatial pooling before variance. */
 export function measure_variance(samples, mask, width, height) {
     if (samples.length < 2) { throw new Error('At least two samples are required'); }
@@ -30,7 +31,7 @@ export function measure_variance(samples, mask, width, height) {
             sigmas.push(Math.sqrt(variance[p])); variance_sum += variance[p]; mean_sum += mean[p];
             const range = maximum[p] - minimum[p]; range_sum += range; max_range = Math.max(max_range, range);
         }
-        sigmas.sort((a, b) => a - b);
+        sigmas.sort(number_compare_ascending);
         const count = sigmas.length;
         if (!count) { throw new Error('Empty measurement region'); }
         return { pixels: count, mean_luminance: mean_sum / count,

package/src/shade/playground/texture_encode/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/texture_encode/main.js"],"names":[],"mappings":"AA+xBA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAmnBzB;;;;;WAhyCa,MAAM;YACN,MAAM;;;;;;UACN,UAAU;;;;UAGV,YAAY"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/texture_encode/main.js"],"names":[],"mappings":"AAgyBA;;;;GAIG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAmnBzB;;;;;WAhyCa,MAAM;YACN,MAAM;;;;;;UACN,UAAU;;;;UAGV,YAAY"}

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

@@ -44,6 +44,7 @@ import { texture_write_level } from "../../renderer/texture/texture_write_level.
 import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
 import { ComputeShaderEmulator } from "../../wgsl/emulator/ComputeShaderEmulator.js";
 import { create_panel_group } from "./panel_view.js";
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * The GPU block encoder on a real device.
@@ -1379,7 +1380,7 @@ export async function start() {
         lines.push('');
         lines.push('  hardware, rounded to eight bits, minus the CPU decoder, over every pair and index:');
 
-        for (const delta of [...histogram.keys()].sort((a, b) => a - b)) {
+        for (const delta of [...histogram.keys()].sort(number_compare_ascending)) {
             lines.push(`    ${String(delta).padStart(3)}: ${String(histogram.get(delta)).padStart(7)}  (${(100 * histogram.get(delta) / total).toFixed(2)}%)`);
         }
 

package/src/shade/playground/volumetrics_froxel/measure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/measure.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH;IAL8B,QAAQ;IACX,KAAK;IACO,MAAM;IACA,UAAU;;;;;;;;;;UAuLtC,QAAQ,YAAY,CAAC;;;;;gCA5DvB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4MV,QAAQ,MAAM,EAAE,CAAC;;;;;;;;;;;;;QAsGF,MAAM,GAAvB,MAAM;QACW,MAAM,GAAvB,MAAM;UACJ;YAAe,MAAM,GAAE,MAAM;MAAE;;GAoF/C"}
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/measure.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH;IAL8B,QAAQ;IACX,KAAK;IACO,MAAM;IACA,UAAU;;;;;;;;;;UAuLtC,QAAQ,YAAY,CAAC;;;;;gCA5DvB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4MV,QAAQ,MAAM,EAAE,CAAC;;;;;;;;;;;;;QAsGF,MAAM,GAAvB,MAAM;QACW,MAAM,GAAvB,MAAM;UACJ;YAAe,MAAM,GAAE,MAAM;MAAE;;GAoF/C"}

package/src/shade/playground/volumetrics_froxel/measure.js

@@ -1,3 +1,4 @@
+import { number_compare_ascending } from "../../../core/primitives/numbers/number_compare_ascending.js";
 /**
  * The measurement protocol from this page's README, as code.
  *
@@ -527,7 +528,7 @@ export async function attach({
         const out = { __frames: capture.frames.length, __defects: capture.defects.length };
 
         for (const [label, values] of per_frame) {
-            values.sort((a, b) => a - b);
+            values.sort(number_compare_ascending);
             out[label] = values[values.length >> 1];
         }
 

package/src/shade/renderer/binding/BufferBinding.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import { BindingResource } from "./BindingResource.js";
 
 /**
@@ -35,7 +35,7 @@ export class BufferBinding extends BindingResource {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix3(
             this.offset,
             this.actual_size,
             this.buffer.id

package/src/shade/renderer/buffer/table/gpu_database_check_links.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu_database_check_links.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_database_check_links.js"],"names":[],"mappings":"AAiFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oDAHW,WAAW,EAAE,GACX,wBAAwB,EAAE,CA2VtC;0BAlcY,OAAO,kBAAkB,EAAE,WAAW;oCACtC,OAAO,4BAA4B,EAAE,qBAAqB;;2BAE1D,OAAO,mBAAmB,EAAE,YAAY;4BACxC,OAAO,oBAAoB,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;YAyBzC,UAAU,GAAC,kBAAkB,GAAC,iBAAiB,GAAC,YAAY,GAAC,QAAQ,GAAC,aAAa;;;;cACnF,MAAM;WACN,MAAM;SACN,MAAM;;;;;WACN,MAAM;WAEN,MAAM;;;;;yBAMP;IAAC,IAAI,EAAE,YAAY,GAAC,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,GAAC,IAAI,CAAC;IAAC,MAAM,kDAAe;CAAC"}
+{"version":3,"file":"gpu_database_check_links.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_database_check_links.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oDAHW,WAAW,EAAE,GACX,wBAAwB,EAAE,CA2VtC;0BAlcY,OAAO,kBAAkB,EAAE,WAAW;oCACtC,OAAO,4BAA4B,EAAE,qBAAqB;;2BAE1D,OAAO,mBAAmB,EAAE,YAAY;4BACxC,OAAO,oBAAoB,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;YAyBzC,UAAU,GAAC,kBAAkB,GAAC,iBAAiB,GAAC,YAAY,GAAC,QAAQ,GAAC,aAAa;;;;cACnF,MAAM;WACN,MAAM;SACN,MAAM;;;;;WACN,MAAM;WAEN,MAAM;;;;;yBAMP;IAAC,IAAI,EAAE,YAAY,GAAC,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,GAAC,IAAI,CAAC;IAAC,MAAM,kDAAe;CAAC"}

package/src/shade/renderer/buffer/table/gpu_database_check_links.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { GPU_DATABASE_NULL } from "./GPU_DATABASE_NULL.js";
 import { gpu_table_range_well_formed } from "./gpu_table_range_well_formed.js";
+import { number_compare_ascending } from "../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * @typedef {import("./GPUDatabase.js").GPUDatabase} GPUDatabase
@@ -412,7 +413,7 @@ export function gpu_database_check_links(databases) {
             const counts = owner_counts.get(table);
 
             if (counts !== undefined) {
-                const rows = Array.from(counts.keys()).sort((a, b) => a - b);
+                const rows = Array.from(counts.keys()).sort(number_compare_ascending);
 
                 for (let i = 0; i < rows.length; i++) {
                     const count = counts.get(rows[i]);

package/src/shade/renderer/camera/Camera.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 { m4_allocate } from "../../../core/geom/3d/mat4/m4_allocate.js";
 import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import { plane3_normalize } from "../../../core/geom/3d/plane/plane3_normalize.js";
@@ -189,7 +189,7 @@ export class Camera {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             computeHashFloat(this.#near),
             computeHashFloat(this.#far),
             computeHashFloat(this.#aspect),

package/src/shade/renderer/geometry/Attribute.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 {
     compute_binary_data_type_from_typed_array
 } from "../../../core/collection/array/typed/compute_binary_data_type_from_typed_array.js";
@@ -89,7 +89,7 @@ export class Attribute {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             this.spec.hash(),
             this.count,
             sparse_typed_array_hash(this.data, 0, this.data.length)

package/src/shade/renderer/geometry/Geometry.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 { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
 import { aabb3_from_v3_array } from "../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
@@ -178,7 +178,7 @@ export class Geometry {
 
     hash() {
 
-        return combine_hash(
+        return hash_mix3(
             computeStringHash(this.name),
             optional_hash(this.index),
             computeHashArray(this.attributes, invokeObjectHash)

package/src/shade/renderer/geometry/geometry_deduplicate_vertices.js

@@ -1,5 +1,5 @@
 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 { Attribute } from "./Attribute.js";
 import { Geometry } from "./Geometry.js";
 import { StandardAttributes } from "./StandardAttributes.js";
@@ -125,7 +125,7 @@ function vertex_hash(datas, strides, num_attrs, vertex_index) {
             // canonicalize -0 to +0: they compare `===` in vertices_equal but have
             // different bit patterns, which would scatter equal vertices across buckets
             const value = data[base + s];
-            h = combine_hash(h, reinterpret_float32_as_int32(value === 0 ? 0 : value));
+            h = hash_mix2(h, reinterpret_float32_as_int32(value === 0 ? 0 : value));
         }
     }
     return h | 0;