@woosh/meep-engine 3.44.0 → 3.46.0

package/src/engine/graphics3/ParticipatingMedia.js

@@ -1,204 +1,204 @@
-import { assert } from "../../core/assert.js";
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
-import { rgb_to_luminance } from "../../core/color/rgb_to_luminance.js";
-import { computeHashFloat } from "../../core/primitives/numbers/computeHashFloat.js";
-import {
-    VOLUMETRIC_PARTICLE_SPEC_FOG,
-    VolumetricsParticleSpec
-} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
-
-/**
- * Particles per cubic metre of dense fog, which is what a medium is until it is told otherwise.
- * @type {number}
- */
-const DEFAULT_DENSITY = 3e7;
-
-/**
- * @type {number}
- */
-const DEFAULT_FADE_DISTANCE = 0.1;
-
-/**
- * A box of fog, smoke, dust or cloud that an entity carries around.
- *
- * **What is in here is the medium; the {@link Transform} beside it is the box.** Shade's
- * {@link ParticipatingMediaVolume} is a unit cube centred on the origin, posed by a transform — so
- * position, size and orientation are already an ECS concept and there is nothing to restate. Which
- * is also why this component does nothing on its own: {@link ParticipatingMediaSystem} links it
- * against a `Transform` and only that pair becomes a volume.
- *
- * **Three numbers, in two different currencies.** {@link particle_spec} is what a single particle
- * does to light — a Mie solution, physical and reusable — and {@link density} is how many of them
- * there are per cubic metre. The pair is what makes smoke and fog different things rather than the
- * same fog at two strengths. Authoring in raw density means knowing the cross-sections, so
- * {@link target_extinction} exists to author the other way round: say how much light the medium
- * should swallow and let the particle decide the count.
- *
- * @see ParticipatingMediaSystem what turns this into something the renderer draws
- * @see ParticipatingMediaVolume the renderer's own object
- */
-export class ParticipatingMedia {
-
-    /**
-     * Particles per cubic metre.
-     *
-     * Physically a count, so the numbers are large — the default is dense fog — and the useful range
-     * depends entirely on {@link particle_spec}: a cloud droplet blocks far more light than a haze
-     * particle, so the same count of them is a very different medium.
-     *
-     * @type {number}
-     */
-    density = DEFAULT_DENSITY;
-
-    /**
-     * What one particle of this medium does to light.
-     *
-     * Defaults to fog. The generated `MIE_PARTICLES_STANDARD_PRECOMPUTED` library is where the
-     * physically meaningful values live — `VolumetricsParticleSpec.fromMeep` converts an entry of it
-     * into one of these.
-     *
-     * @type {VolumetricsParticleSpec}
-     */
-    particle_spec = VolumetricsParticleSpec.fromJSON(VOLUMETRIC_PARTICLE_SPEC_FOG);
-
-    /**
-     * How far in from the box's faces the medium fades out, in metres.
-     *
-     * **World-space, and deliberately not scaled by the transform**, so a 0.5 here is half a metre
-     * of softness whether the volume is a metre across or a hundred. Zero gives the box hard edges,
-     * which is visible as a straight line across the screen wherever the box crosses the view.
-     *
-     * @type {number}
-     */
-    fade_distance = DEFAULT_FADE_DISTANCE;
-
-    /**
-     * The medium's extinction per metre, which is {@link density} expressed in what it does rather
-     * than in how many particles it took.
-     *
-     * The point of it is that it is comparable across particles: a smoke volume and a fog volume set
-     * to the same target extinction swallow the same amount of light, while the same *density* in
-     * both would differ by orders of magnitude.
-     *
-     * **Derived, not stored** — writing it sets {@link density}, and changing `particle_spec`
-     * afterwards therefore changes what reading it back gives. The density is what survives a save.
-     *
-     * @returns {number}
-     */
-    get target_extinction() {
-        return this.density * rgb_to_luminance(...this.particle_spec.extinction);
-    }
-
-    /**
-     * @param {number} value
-     */
-    set target_extinction(value) {
-        assert.isNumber(value, 'target_extinction');
-        assert.isFinite(value, 'target_extinction');
-
-        const density = value / rgb_to_luminance(...this.particle_spec.extinction);
-
-        /*
-         Catches the one way this goes wrong: a particle spec that extinguishes nothing. A default-
-         constructed `VolumetricsParticleSpec` has zero cross-sections, and asking such a medium to
-         reach any extinction at all needs infinitely many of its particles. Rejecting it here names
-         the mistake; letting it through puts an `Infinity` in the GPU table, where it becomes a
-         screenful of NaN several passes later.
-        */
-        assert.isFinite(density, 'the density this target_extinction implies (the particle spec extinguishes nothing)');
-
-        this.density = density;
-    }
-
-    /**
-     * @param {*} json
-     * @returns {ParticipatingMedia}
-     */
-    static fromJSON(json) {
-        const r = new ParticipatingMedia();
-
-        r.fromJSON(json);
-
-        return r;
-    }
-
-    toJSON() {
-        const spec = this.particle_spec;
-
-        return {
-            density: this.density,
-            fade_distance: this.fade_distance,
-            particle_spec: {
-                scattering: spec.scattering.slice(),
-                extinction: spec.extinction.slice(),
-                radius: spec.radius,
-                g: spec.g
-            }
-        };
-    }
-
-    /**
-     * @param {Object} options
-     * @param {number} [options.density]
-     * @param {number} [options.fade_distance]
-     * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
-     * the component already held — a load has to determine the whole component, or an instance being
-     * reused would carry the previous level's particle into the next one
-     */
-    fromJSON({
-                 density = DEFAULT_DENSITY,
-                 fade_distance = DEFAULT_FADE_DISTANCE,
-                 particle_spec
-             }) {
-        assert.isNumber(density, 'density');
-        assert.isFinite(density, 'density');
-        assert.greaterThanOrEqual(density, 0, 'density must not be negative');
-
-        assert.isNumber(fade_distance, 'fade_distance');
-        assert.isFinite(fade_distance, 'fade_distance');
-        assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
-
-        this.density = density;
-        this.fade_distance = fade_distance;
-
-        if (particle_spec === undefined) {
-            this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
-        } else {
-            this.particle_spec.fromJSON(particle_spec);
-        }
-    }
-
-    /**
-     * **The cross-sections and the radius are left out of this on purpose.** They run to 1e-16 and
-     * 1e-6, and {@link computeHashFloat} collapses anything that small to zero, so mixing them in
-     * would cost a multiply and buy no dispersion at all. A hash is allowed to collide;
-     * {@link equals} is the exact one.
-     *
-     * @returns {number}
-     */
-    hash() {
-        const spec = this.particle_spec;
-
-        return combine_hash(
-            computeHashFloat(this.density),
-            computeHashFloat(this.fade_distance),
-            computeHashFloat(spec.g)
-        );
-    }
-
-    /**
-     * @param {ParticipatingMedia} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.density === other.density
-            && this.fade_distance === other.fade_distance
-            && this.particle_spec.equals(other.particle_spec);
-    }
-}
-
-/**
- * @readonly
- * @type {string}
- */
-ParticipatingMedia.typeName = "ParticipatingMedia";
+import { assert } from "../../core/assert.js";
+import { hash_mix3 } from "../../core/math/hash/hash_mix3.js";
+import { rgb_to_luminance } from "../../core/color/rgb_to_luminance.js";
+import { computeHashFloat } from "../../core/primitives/numbers/computeHashFloat.js";
+import {
+    VOLUMETRIC_PARTICLE_SPEC_FOG,
+    VolumetricsParticleSpec
+} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
+
+/**
+ * Particles per cubic metre of dense fog, which is what a medium is until it is told otherwise.
+ * @type {number}
+ */
+const DEFAULT_DENSITY = 3e7;
+
+/**
+ * @type {number}
+ */
+const DEFAULT_FADE_DISTANCE = 0.1;
+
+/**
+ * A box of fog, smoke, dust or cloud that an entity carries around.
+ *
+ * **What is in here is the medium; the {@link Transform} beside it is the box.** Shade's
+ * {@link ParticipatingMediaVolume} is a unit cube centred on the origin, posed by a transform — so
+ * position, size and orientation are already an ECS concept and there is nothing to restate. Which
+ * is also why this component does nothing on its own: {@link ParticipatingMediaSystem} links it
+ * against a `Transform` and only that pair becomes a volume.
+ *
+ * **Three numbers, in two different currencies.** {@link particle_spec} is what a single particle
+ * does to light — a Mie solution, physical and reusable — and {@link density} is how many of them
+ * there are per cubic metre. The pair is what makes smoke and fog different things rather than the
+ * same fog at two strengths. Authoring in raw density means knowing the cross-sections, so
+ * {@link target_extinction} exists to author the other way round: say how much light the medium
+ * should swallow and let the particle decide the count.
+ *
+ * @see ParticipatingMediaSystem what turns this into something the renderer draws
+ * @see ParticipatingMediaVolume the renderer's own object
+ */
+export class ParticipatingMedia {
+
+    /**
+     * Particles per cubic metre.
+     *
+     * Physically a count, so the numbers are large — the default is dense fog — and the useful range
+     * depends entirely on {@link particle_spec}: a cloud droplet blocks far more light than a haze
+     * particle, so the same count of them is a very different medium.
+     *
+     * @type {number}
+     */
+    density = DEFAULT_DENSITY;
+
+    /**
+     * What one particle of this medium does to light.
+     *
+     * Defaults to fog. The generated `MIE_PARTICLES_STANDARD_PRECOMPUTED` library is where the
+     * physically meaningful values live — `VolumetricsParticleSpec.fromMeep` converts an entry of it
+     * into one of these.
+     *
+     * @type {VolumetricsParticleSpec}
+     */
+    particle_spec = VolumetricsParticleSpec.fromJSON(VOLUMETRIC_PARTICLE_SPEC_FOG);
+
+    /**
+     * How far in from the box's faces the medium fades out, in metres.
+     *
+     * **World-space, and deliberately not scaled by the transform**, so a 0.5 here is half a metre
+     * of softness whether the volume is a metre across or a hundred. Zero gives the box hard edges,
+     * which is visible as a straight line across the screen wherever the box crosses the view.
+     *
+     * @type {number}
+     */
+    fade_distance = DEFAULT_FADE_DISTANCE;
+
+    /**
+     * The medium's extinction per metre, which is {@link density} expressed in what it does rather
+     * than in how many particles it took.
+     *
+     * The point of it is that it is comparable across particles: a smoke volume and a fog volume set
+     * to the same target extinction swallow the same amount of light, while the same *density* in
+     * both would differ by orders of magnitude.
+     *
+     * **Derived, not stored** — writing it sets {@link density}, and changing `particle_spec`
+     * afterwards therefore changes what reading it back gives. The density is what survives a save.
+     *
+     * @returns {number}
+     */
+    get target_extinction() {
+        return this.density * rgb_to_luminance(...this.particle_spec.extinction);
+    }
+
+    /**
+     * @param {number} value
+     */
+    set target_extinction(value) {
+        assert.isNumber(value, 'target_extinction');
+        assert.isFinite(value, 'target_extinction');
+
+        const density = value / rgb_to_luminance(...this.particle_spec.extinction);
+
+        /*
+         Catches the one way this goes wrong: a particle spec that extinguishes nothing. A default-
+         constructed `VolumetricsParticleSpec` has zero cross-sections, and asking such a medium to
+         reach any extinction at all needs infinitely many of its particles. Rejecting it here names
+         the mistake; letting it through puts an `Infinity` in the GPU table, where it becomes a
+         screenful of NaN several passes later.
+        */
+        assert.isFinite(density, 'the density this target_extinction implies (the particle spec extinguishes nothing)');
+
+        this.density = density;
+    }
+
+    /**
+     * @param {*} json
+     * @returns {ParticipatingMedia}
+     */
+    static fromJSON(json) {
+        const r = new ParticipatingMedia();
+
+        r.fromJSON(json);
+
+        return r;
+    }
+
+    toJSON() {
+        const spec = this.particle_spec;
+
+        return {
+            density: this.density,
+            fade_distance: this.fade_distance,
+            particle_spec: {
+                scattering: spec.scattering.slice(),
+                extinction: spec.extinction.slice(),
+                radius: spec.radius,
+                g: spec.g
+            }
+        };
+    }
+
+    /**
+     * @param {Object} options
+     * @param {number} [options.density]
+     * @param {number} [options.fade_distance]
+     * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
+     * the component already held — a load has to determine the whole component, or an instance being
+     * reused would carry the previous level's particle into the next one
+     */
+    fromJSON({
+                 density = DEFAULT_DENSITY,
+                 fade_distance = DEFAULT_FADE_DISTANCE,
+                 particle_spec
+             }) {
+        assert.isNumber(density, 'density');
+        assert.isFinite(density, 'density');
+        assert.greaterThanOrEqual(density, 0, 'density must not be negative');
+
+        assert.isNumber(fade_distance, 'fade_distance');
+        assert.isFinite(fade_distance, 'fade_distance');
+        assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
+
+        this.density = density;
+        this.fade_distance = fade_distance;
+
+        if (particle_spec === undefined) {
+            this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
+        } else {
+            this.particle_spec.fromJSON(particle_spec);
+        }
+    }
+
+    /**
+     * **The cross-sections and the radius are left out of this on purpose.** They run to 1e-16 and
+     * 1e-6, and {@link computeHashFloat} collapses anything that small to zero, so mixing them in
+     * would cost a multiply and buy no dispersion at all. A hash is allowed to collide;
+     * {@link equals} is the exact one.
+     *
+     * @returns {number}
+     */
+    hash() {
+        const spec = this.particle_spec;
+
+        return hash_mix3(
+            computeHashFloat(this.density),
+            computeHashFloat(this.fade_distance),
+            computeHashFloat(spec.g)
+        );
+    }
+
+    /**
+     * @param {ParticipatingMedia} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.density === other.density
+            && this.fade_distance === other.fade_distance
+            && this.particle_spec.equals(other.particle_spec);
+    }
+}
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ParticipatingMedia.typeName = "ParticipatingMedia";

package/src/engine/graphics3/animation/AnimationClips.d.ts

@@ -23,6 +23,11 @@
  * clip, take the component off and put another on, which the drivers see as their entity leaving
  * and coming back.
  *
+ * **The entities it keys go no sooner than it does.** While it is on, the drivers hold a row for
+ * every entity a channel keys, as a skin holds its joints'. Removing one of them means taking this
+ * off before the next frame — `prefab_instance_destroy` removes the entities and then the clips, in
+ * one step — or the scene is left holding the row of an entity that is gone.
+ *
  * **Not saved**, for the reason `MeshSkin` is not: the channels key entities that whatever builds
  * the rig creates, and the curves are asset data. A load rebuilds them the way it rebuilds the rig.
  *

package/src/engine/graphics3/animation/AnimationClips.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationClips.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/AnimationClips.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IASI;;;OAGG;IACH,mBAHW,kBAAkB,EAAE,GAClB,cAAc,CAc1B;IAxBD;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAqBf;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;;kBAUS,MAAM;sBAMN,OAAO;;iCAzEJ,OAAO,yDAAyD,EAAE,kBAAkB"}
+{"version":3,"file":"AnimationClips.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/AnimationClips.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IASI;;;OAGG;IACH,mBAHW,kBAAkB,EAAE,GAClB,cAAc,CAc1B;IAxBD;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAqBf;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;;kBAUS,MAAM;sBAMN,OAAO;;iCA9EJ,OAAO,yDAAyD,EAAE,kBAAkB"}

package/src/engine/graphics3/animation/AnimationClips.js

@@ -26,6 +26,11 @@ import { assert } from "../../../core/assert.js";
  * clip, take the component off and put another on, which the drivers see as their entity leaving
  * and coming back.
  *
+ * **The entities it keys go no sooner than it does.** While it is on, the drivers hold a row for
+ * every entity a channel keys, as a skin holds its joints'. Removing one of them means taking this
+ * off before the next frame — `prefab_instance_destroy` removes the entities and then the clips, in
+ * one step — or the scene is left holding the row of an entity that is gone.
+ *
  * **Not saved**, for the reason `MeshSkin` is not: the channels key entities that whatever builds
  * the rig creates, and the curves are asset data. A load rebuilds them the way it rebuilds the rig.
  *

package/src/engine/graphics3/register_clips.d.ts

@@ -1,3 +1,30 @@
+/**
+ * Hold a row, with the chain above it, for every entity the clips key.
+ *
+ * **A clip binds only once every node it keys holds a row**, and until then it is queued and moves
+ * nothing. A skin holds its joints' chains and a primitive its own, but a keyed node that is neither
+ * — a leaf an exporter left out of the skin, a socket nothing is attached to yet, an animated empty
+ * — is held by nothing else, and one such node keeps the whole clip from playing. So the driver that
+ * plays the clips holds every node they key, for as long as it has the clips.
+ *
+ * Every clip of the set, not only the ones registered: the set is replaced and never edited, so its
+ * targets are settled once, while which of its clips are registered moves with the list or the graph.
+ *
+ * One hold per channel, given back one per channel by {@link release_clip_targets}: the chains count
+ * holds, so a node keyed by several channels is held until the last of them is released.
+ *
+ * @param {RowChains} chains
+ * @param {ShadeAnimationClip[]} clips their channels target entities
+ */
+export function hold_clip_targets(chains: RowChains, clips: ShadeAnimationClip[]): void;
+/**
+ * Give back what {@link hold_clip_targets} took for the same clips. Released after the clips are
+ * unregistered, so no binding outlives the row it writes.
+ *
+ * @param {RowChains} chains
+ * @param {ShadeAnimationClip[]} clips
+ */
+export function release_clip_targets(chains: RowChains, clips: ShadeAnimationClip[]): void;
 /**
  * Make some of an entity's clips playable — the ones a driver actually plays, and no others.
  *
@@ -28,6 +55,7 @@ export function unregister_clips(registration: ClipRegistration): void;
 /**
  * @typedef {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ * @typedef {import("./RowChains.js").RowChains} RowChains
  */
 /**
  * The id a clip has when nobody registered it.
@@ -61,4 +89,5 @@ export class ClipRegistration {
 }
 export type GPUSceneContext = import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
 export type ShadeAnimationClip = import("../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip;
+export type RowChains = import("./RowChains.js").RowChains;
 //# sourceMappingURL=register_clips.d.ts.map

package/src/engine/graphics3/register_clips.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register_clips.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/register_clips.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;GAgBG;AACH,wCALW,eAAe,SACf,kBAAkB,EAAE,SACpB,UAAU,MAAM,CAAC,GACf,gBAAgB,CA6B5B;AAED;;;;;;;GAOG;AACH,+CAFW,gBAAgB,QAqB1B;AA/GD;;;GAGG;AAEH;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH;IACI;;;;;;;;;OASG;IACH,SAFU,eAAe,GAAC,IAAI,CAEf;IAEf;;OAEG;IACH,KAFU,UAAU,CAEI;CAC3B;8BAnCY,OAAO,+CAA+C,EAAE,eAAe;iCACvE,OAAO,sDAAsD,EAAE,kBAAkB"}
+{"version":3,"file":"register_clips.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/register_clips.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAHW,SAAS,SACT,kBAAkB,EAAE,QAa9B;AAED;;;;;;GAMG;AACH,6CAHW,SAAS,SACT,kBAAkB,EAAE,QAa9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wCALW,eAAe,SACf,kBAAkB,EAAE,SACpB,UAAU,MAAM,CAAC,GACf,gBAAgB,CA6B5B;AAED;;;;;;;GAOG;AACH,+CAFW,gBAAgB,QAqB1B;AAnKD;;;;GAIG;AAEH;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH;IACI;;;;;;;;;OASG;IACH,SAFU,eAAe,GAAC,IAAI,CAEf;IAEf;;OAEG;IACH,KAFU,UAAU,CAEI;CAC3B;8BApCY,OAAO,+CAA+C,EAAE,eAAe;iCACvE,OAAO,sDAAsD,EAAE,kBAAkB;wBACjF,OAAO,gBAAgB,EAAE,SAAS"}

package/src/engine/graphics3/register_clips.js

@@ -3,6 +3,7 @@ import { assert } from "../../core/assert.js";
 /**
  * @typedef {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
+ * @typedef {import("./RowChains.js").RowChains} RowChains
  */
 
 /**
@@ -38,6 +39,57 @@ export class ClipRegistration {
     ids = new Int32Array(0);
 }
 
+/**
+ * Hold a row, with the chain above it, for every entity the clips key.
+ *
+ * **A clip binds only once every node it keys holds a row**, and until then it is queued and moves
+ * nothing. A skin holds its joints' chains and a primitive its own, but a keyed node that is neither
+ * — a leaf an exporter left out of the skin, a socket nothing is attached to yet, an animated empty
+ * — is held by nothing else, and one such node keeps the whole clip from playing. So the driver that
+ * plays the clips holds every node they key, for as long as it has the clips.
+ *
+ * Every clip of the set, not only the ones registered: the set is replaced and never edited, so its
+ * targets are settled once, while which of its clips are registered moves with the list or the graph.
+ *
+ * One hold per channel, given back one per channel by {@link release_clip_targets}: the chains count
+ * holds, so a node keyed by several channels is held until the last of them is released.
+ *
+ * @param {RowChains} chains
+ * @param {ShadeAnimationClip[]} clips their channels target entities
+ */
+export function hold_clip_targets(chains, clips) {
+    assert.defined(chains, 'chains');
+    assert.isArray(clips, 'clips');
+
+    for (let i = 0; i < clips.length; i++) {
+        const channels = clips[i].channels;
+
+        for (let j = 0; j < channels.length; j++) {
+            chains.hold(channels[j].target);
+        }
+    }
+}
+
+/**
+ * Give back what {@link hold_clip_targets} took for the same clips. Released after the clips are
+ * unregistered, so no binding outlives the row it writes.
+ *
+ * @param {RowChains} chains
+ * @param {ShadeAnimationClip[]} clips
+ */
+export function release_clip_targets(chains, clips) {
+    assert.defined(chains, 'chains');
+    assert.isArray(clips, 'clips');
+
+    for (let i = 0; i < clips.length; i++) {
+        const channels = clips[i].channels;
+
+        for (let j = 0; j < channels.length; j++) {
+            chains.release(channels[j].target);
+        }
+    }
+}
+
 /**
  * Make some of an entity's clips playable — the ones a driver actually plays, and no others.
  *

package/src/engine/grid/obstacle/GridObstacle.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 { computeIntegerArrayHash } from "../../../core/collection/array/computeIntegerArrayHash.js";
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 import Vector2 from '../../../core/geom/Vector2.js';
@@ -235,7 +235,7 @@ class GridObstacle {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.size.hash(),
             computeIntegerArrayHash(this.data, 0, this.data.length)
         );

package/src/engine/intelligence/behavior/selector/WeightedElement.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 { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
@@ -66,7 +66,7 @@ export class WeightedElement {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.weight),
             invokeObjectHash(this.data)
         );

package/src/engine/interpolation/Interpolated.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../core/math/hash/hash_mix2.js";
 
 /**
  * Sentinel for {@link Interpolated#key} before assignment. The
@@ -114,7 +114,7 @@ export class Interpolated {
         let h = this.sourceId | 0;
         const ips = this.interpolands;
         for (let i = 0; i < ips.length; i++) {
-            h = combine_hash(h, ips[i].type_id | 0);
+            h = hash_mix2(h, ips[i].type_id | 0);
         }
         return h;
     }

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -50,4 +50,13 @@ export function fatten_world_aabb_array(aabb: number[] | Float32Array | Float64A
  * @param {number} dt step size
  */
 export function compute_fat_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform64, vx: number, vy: number, vz: number, dt: number): void;
+/**
+ * Constant inflation applied to a world AABB so a small motion doesn't churn
+ * the broadphase. Tuned to Box2D / Bullet conventions. Symmetric: jitter has
+ * no preferred direction.
+ *
+ * Exported because `ClothColliderIndex` fattens its leaves by the same slack, for the same reason.
+ * @type {number}
+ */
+export const FAT_LINEAR: number;
 //# sourceMappingURL=compute_fat_world_aabb.d.ts.map

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,wDAchB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAUhB;AAKD;;;;;;;;;;GAUG;AACH,8CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,MACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAyBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,wDAchB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAUhB;AAKD;;;;;;;;;;GAUG;AACH,8CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,MACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB;AAvHD;;;;;;;GAOG;AACH,yBAFU,MAAM,CAEe"}

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -6,9 +6,11 @@ const scratch_local = new Float64Array(6);
  * Constant inflation applied to a world AABB so a small motion doesn't churn
  * the broadphase. Tuned to Box2D / Bullet conventions. Symmetric: jitter has
  * no preferred direction.
+ *
+ * Exported because `ClothColliderIndex` fattens its leaves by the same slack, for the same reason.
  * @type {number}
  */
-const FAT_LINEAR = 0.05;
+export const FAT_LINEAR = 0.05;
 
 /**
  * Per-second-of-velocity inflation. Two seconds of motion is a generous