@woosh/meep-engine 3.43.0 → 3.45.0

package/src/engine/graphics3/register_clips.js

@@ -0,0 +1,166 @@
+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
+ */
+
+/**
+ * The id a clip has when nobody registered it.
+ * @type {number}
+ */
+export const CLIP_NOT_REGISTERED = -1;
+
+/**
+ * Which of an entity's clips a driver has playable, by their place in its `AnimationClips`.
+ *
+ * `ids[i]` is the manager's id for `clips[i]`, or {@link CLIP_NOT_REGISTERED} where this driver
+ * does not play that clip. Indexed by the clip's place rather than packed, because that is how
+ * both drivers already address a clip — the graph resolves a name to a slot, the clip list does the
+ * same — and a packed array would want a second table to say what each entry was.
+ */
+export class ClipRegistration {
+    /**
+     * The GPU scene context these ids were issued by.
+     *
+     * Carried rather than inferred, because **an id may only be handed back to the manager that
+     * issued it**. A renderer restart builds a new context, and a holder comparing this against what
+     * `scene_context` answers now knows in one `===` whether giving the ids back is returning them or
+     * corrupting a stranger's table.
+     *
+     * @type {GPUSceneContext|null}
+     */
+    context = null;
+
+    /**
+     * @type {Int32Array}
+     */
+    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.
+ *
+ * **Registering a clip is not free of consequence, which is why this takes a set.** The pose
+ * accumulator marks a joint dirty for every bound clip that writes to it, whatever its weight, so a
+ * bound clip at weight zero resolves the joints only it drives to zero rather than leaving them at
+ * rest. A driver therefore registers what it can play and re-registers when that changes; a clip no
+ * driver claims is never bound and so moves nothing.
+ *
+ * Each index is registered once however many times it is named. Two states of one graph can play
+ * the same clip, and two registrations of one clip are two rows the accumulator would add together.
+ *
+ * @param {GPUSceneContext} context
+ * @param {ShadeAnimationClip[]} clips an entity's `AnimationClips`; their channels target entities
+ * @param {ArrayLike<number>} slots indices into `clips`; duplicates are ignored
+ * @returns {ClipRegistration}
+ */
+export function register_clips(context, clips, slots) {
+    assert.defined(context, 'context');
+    assert.isArray(clips, 'clips');
+    assert.defined(slots, 'slots');
+
+    const manager = context.animation_manager;
+
+    const r = new ClipRegistration();
+
+    r.context = context;
+    r.ids = new Int32Array(clips.length).fill(CLIP_NOT_REGISTERED);
+
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
+
+        assert.isNonNegativeInteger(slot, 'slot');
+        assert.lessThan(slot, clips.length, 'slot');
+
+        if (r.ids[slot] !== CLIP_NOT_REGISTERED) {
+            // named twice by one driver, which is one clip either way
+            continue;
+        }
+
+        r.ids[slot] = manager.register_clip(clips[slot]);
+    }
+
+    return r;
+}
+
+/**
+ * Give back everything {@link register_clips} took out, for a manager that is still the one that
+ * issued it. A restart takes the GPU scene context with it, and the ids it issued mean nothing to the
+ * one that replaces it, so a caller holding a registration from another context forgets it rather
+ * than handing it back here.
+ *
+ * @param {ClipRegistration} registration
+ */
+export function unregister_clips(registration) {
+    assert.defined(registration, 'registration');
+    assert.defined(registration.context, 'registration.context');
+
+    const manager = registration.context.animation_manager;
+
+    const ids = registration.ids;
+
+    for (let i = 0; i < ids.length; i++) {
+        const id = ids[i];
+
+        if (id === CLIP_NOT_REGISTERED) {
+            continue;
+        }
+
+        manager.unregister_clip(id);
+    }
+
+    ids.fill(CLIP_NOT_REGISTERED);
+}

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