@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/animation/GPUAnimationManager.d.ts

@@ -2,17 +2,17 @@
  * Top-level coordinator for GPU-resident animation.
  *
  * Owns a single {@link GPUDatabase} keyed by {@link ANIMATION_DATABASE_SPEC}
- * with five tables: `animation_curves`, `animation_keyframe_blocks`,
- * `animation_tracks`, `animation_clips`, `animation_bound_track_groups`.
- * Every record — including individual keyframes (inlined inside block
- * nodes) and individual bindings (inlined inside group nodes) — lives in
+ * with its tables: `animation_curves`, `animation_keyframes`,
+ * `animation_tracks`, `animation_clips`, `animation_bindings`,
+ * `animation_skins` and `animation_skin_joints`.
+ * Every record — including individual keyframes (a run of rows per
+ * curve) and individual bindings (a run of rows per clip) — lives in
  * the database, so the dispatch shader needs only one storage binding.
  *
  * Animation *data* (curves, keyframes, tracks) is independent from
- * *bound clips* (each carrying a `time` and a head pointer to its
- * bound-track group chain). Bindings are no longer their own table:
- * each chain node inlines up to {@link TRACKS_PER_GROUP_NODE} bindings
- * and back-references its owning clip.
+ * *bound clips* (each carrying a `time` and the run of its bindings).
+ * Each binding row names its clip, so the apply pass, one thread per
+ * binding, finds the clip's time from the binding alone.
  *
  * Usage:
  *  1. (Once at setup) Either low-level (`add_curve`, `add_track`,
@@ -42,8 +42,8 @@ export class GPUAnimationManager {
      * Per-frame skinning-matrix scratch buffer for the *current*
      * frame. `null` until the first skin is registered. The
      * skin-matrix-prep pass writes to it; the skinning compute pass
-     * reads from it to deform current-frame positions. Address `j`
-     * of skin `s` is at matrix index `s.skin_matrix_offset + j`.
+     * reads from it to deform current-frame positions. Joint `j` of
+     * skin `s` is at matrix index `s.joints_first + j` — the joint's row.
      *
      * The buffer reference is invalidated on grow AND flips role
      * every frame as part of the ping-pong with
@@ -65,12 +65,11 @@ export class GPUAnimationManager {
      */
     get prev_skin_matrices_buffer(): any;
     /**
-     * Matrices the buffer has to address: the high-water mark, which covers every registered
-     * skin plus any range sitting on the free list between the ones still in use. Independent
-     * of buffer capacity, which is at least this big.
+     * Matrices the buffer has to address: one past the highest joint row any skin has been
+     * given. Independent of buffer capacity, which is at least this big.
      *
-     * Not a count of live joints — a skin that unregisters leaves its range addressable for
-     * the next skin of its size, so this falls only when nothing has been registered yet.
+     * Not a count of live joints — rows a skin gives back stay addressable for the next skin
+     * that fits in them, so this never falls.
      *
      * @returns {number}
      */
@@ -105,31 +104,30 @@ export class GPUAnimationManager {
      * Read back a skin's record from the database's CPU shadow.
      *
      * @param {number} skin_id
-     * @returns {{joint_block_head: number, joint_count: number}}
+     * @returns {{joints_first: number, joint_count: number}}
      */
     get_skin(skin_id: number): {
-        joint_block_head: number;
+        joints_first: number;
         joint_count: number;
     };
     /**
-     * Base address of the skin's matrix range in the shared
+     * Base address of the skin's matrices in the shared
      * `skin_matrices` scratch buffer — matrix `j` of the skin lives
-     * at `skin_matrices[get_skin_matrix_offset(skin_id) + j]`.
+     * at `skin_matrices[get_skin_matrix_offset(skin_id) + j]`. A joint's
+     * matrix sits at the joint's row, so this is the skin's first joint
+     * row, read from its record — one word of it, not the record.
      *
-     * Tracked CPU-side rather than on the skin record because the
-     * value is only ever consumed by the skinning-binding upload
-     * path; the prep shader uses the per-block absolute offset
-     * (cheaper than a per-thread skin lookup for that hot path).
+     * A run never moves once handed out, so the offset holds for as long
+     * as the skin is registered; the skinning context reads it only when
+     * its bindings change.
      *
      * @param {number} skin_id
      * @returns {number}
      */
     get_skin_matrix_offset(skin_id: number): number;
     /**
-     * Add an animation curve. Keyframes are split into linked-list blocks
-     * of up to {@link KEYFRAMES_PER_BLOCK} entries each; the curve header
-     * points at the head block, and each block's `next` field chains
-     * forward.
+     * Add an animation curve. Its keyframes go into `animation_keyframes` as one run of rows, in
+     * order, and the curve's header names the run.
      *
      * The curve is a cubic Hermite spline — step, linear, and arbitrary
      * cubic shapes are all expressible by choosing tangents on each keyframe.
@@ -161,11 +159,9 @@ export class GPUAnimationManager {
     }): number;
     /**
      * Create a bound clip — a group of bound tracks that share a single
-     * `time`. Bindings are split into linked-list group nodes of up to
-     * {@link TRACKS_PER_GROUP_NODE} each; the clip points at the head
-     * node and each node back-references the clip so the apply shader
-     * (one thread per group node) can fetch the clip without walking the
-     * chain from the clip end.
+     * `time`. The bindings go into `animation_bindings` as one run of
+     * rows, each naming the clip, so the apply shader (one thread per
+     * binding) fetches the clip's time from the binding alone.
      *
      * Tracks may be authored on a clock that doesn't align with
      * `[time_start, time_end]` — their curves are clamped to their own
@@ -294,10 +290,11 @@ export class GPUAnimationManager {
      * Register a skin: an ordered list of joints, each pinning a
      * Node3D row that drives the joint plus the inverse-bind matrix
      * that takes vertex positions from mesh space into the joint's
-     * bind-pose local space. The skin reserves a contiguous range of
-     * `joints.length` matrices in the {@link #skin_matrices_buffer}
-     * scratch buffer; the prep pass populates that range each frame
-     * with `node.global × inverse_bind` for every joint.
+     * bind-pose local space. The joints go into `animation_skin_joints`
+     * as one run of rows, and a joint's matrix in the
+     * {@link #skin_matrices_buffer} scratch buffer sits at its row — so the
+     * skin's matrices are the same run of the buffer, which the prep pass
+     * fills each frame with `node.global × inverse_bind` for every joint.
      *
      * The skin record carries no mesh-world factor. The rasterizer
      * applies `mesh.transform_global` to the skinned clone vertex
@@ -307,13 +304,6 @@ export class GPUAnimationManager {
      * double-cancel against that re-application and shrink the rig
      * back to mesh-local coordinates rendered as world.
      *
-     * Joints are split into linked-list blocks of up to
-     * {@link JOINTS_PER_SKIN_BLOCK} each — same chain pattern used for
-     * bound-track groups and keyframe blocks. Each block records the
-     * absolute write offset for its slots, so the prep shader's
-     * per-thread work is one block load + a bounded inner loop with no
-     * indirection back through the skin record.
-     *
      * @param {{
      *     joints: Array<{ node: number, inverse_bind: Float32Array | number[] }>,
      * }} skin
@@ -330,12 +320,12 @@ export class GPUAnimationManager {
      * **entities**, allocates a GPU skin record, and binds every mesh entity through the
      * skinning context.
      *
-     * **Eventual consistency.** The `skin_id` is allocated and returned synchronously — callers
-     * can immediately pass it to state mutators or {@link unregister_skin}. If any joint has not
-     * taken its row yet (see `GPUSceneRows.acquire`), the joint-block chain that drives the
-     * deformation is queued and built on the next {@link update} that sees every joint there.
-     * The skin's table row uses a placeholder `joint_block_head` until then — observationally
-     * indistinguishable from "skin with no joints driving it" (no deformation runs).
+     * **Eventual consistency.** The `skin_id` is allocated and returned synchronously, and the
+     * skin's joints take their rows at once, so {@link get_skin_matrix_offset} and
+     * {@link unregister_skin} work from here on. If any joint's entity has not taken its
+     * transforms row yet (see `GPUSceneRows.acquire`), the joints name no node, and the meshes
+     * are not bound, until the next {@link update} that sees every joint there. Until then the
+     * skin's matrices are not written, and its meshes draw undeformed, as they were modelled.
      *
      * The frame a skin's meshes are deformed in is the prefab's business, fixed once at compile
      * (`prefab_normalize_skin_frames`); nothing about it is decided here.
@@ -351,14 +341,14 @@ export class GPUAnimationManager {
      * **Eventual consistency.** The `clip_id` is allocated and returned synchronously — callers
      * can immediately call {@link start} / {@link stop} / {@link set_time} / {@link set_playback_rate}
      * / {@link set_flags} / {@link clear_flags} / {@link set_playback_weight} /
-     * {@link unregister_clip}. If any target has not taken its row yet, the bindings chain that
-     * drives the apply pass is queued and built on the next {@link update} that sees every target
-     * there. The clip's table row uses a placeholder `bound_track_group_head` until then — apply
-     * produces no contributions, so the clip is observationally inert (still subject to time
-     * advancement via the tick shader if `Playing` is set).
-     *
-     * **Binding is what hands a target to the GPU.** When the chain is built, every entity it
-     * drives has its `GPUStateAuthority` TransformAttachment bit granted, so the CPU stops
+     * {@link unregister_clip}. If any target has not taken its row yet, the bindings that drive
+     * the apply pass are queued and added on the next {@link update} that sees every target there.
+     * The clip's table row holds an empty range until then — apply produces no contributions, so
+     * the clip is observationally inert (still subject to time advancement via the tick shader if
+     * `Playing` is set).
+     *
+     * **Binding is what hands a target to the GPU.** When the bindings are added, every entity
+     * they drive has its `GPUStateAuthority` TransformAttachment bit granted, so the CPU stops
      * writing its local TRS; the last clip to leave revokes it. The entity has to have declared
      * the component — a prefab does, on every node a clip reaches — because a grant that could
      * silently do nothing would be a claim nobody could see.
@@ -370,10 +360,9 @@ export class GPUAnimationManager {
      */
     register_clip(clip: ShadeAnimationClip): number;
     /**
-     * Drop a clip from the manager. Walks the bindings chain and
-     * removes every group-node + the clip row. Tolerates the clip
-     * still being pending (drains it from the queue without GPU
-     * touches besides the original row removal).
+     * Drop a clip from the manager: its row, and with it the run of its bindings — the clip's range
+     * owns the run, so the table removes it. Tolerates the clip still being pending (drains it from
+     * the queue without GPU touches besides the original row removal).
      *
      * Curves and tracks the clip referenced stay alive — they're
      * shared via {@link #intern_curve} / {@link #intern_track} and
@@ -381,41 +370,39 @@ export class GPUAnimationManager {
      * reference-counting the manager doesn't carry.
      *
      * Safe to call repeatedly on the same id: the second call finds the row unoccupied and
-     * returns without walking anything.
+     * returns without touching anything.
      *
      * @param {number} clip_id
      */
     unregister_clip(clip_id: number): void;
     /**
-     * Drop a skin from the manager. Walks the joint-block chain and
-     * removes every block + the skin row, and tears down every
-     * skinning binding pointing at this skin (so the skinning
-     * context doesn't try to read the now-freed skin's matrix
-     * offset on its next upload).
+     * Drop a skin from the manager: its row, and with it the run of its joints — the skin's range
+     * owns the run, so the table removes it — and every skinning binding pointing at this skin (so
+     * the skinning context doesn't try to read the now-freed skin's matrix offset on its next
+     * upload).
      *
-     * The skin's matrix range goes back on the free list, for the next skin with the same
-     * joint count to take as-is. A spawn/despawn loop over a fixed cast therefore costs
-     * what the cast costs, not what the loop has run.
+     * The joints' rows, and the matrices at them, are free for the next skin that fits. A
+     * respawn of the same rig fits the rows it left, and first fit takes them unless an earlier
+     * hole fits too — so a spawn/despawn loop over a fixed cast costs what the cast costs, not
+     * what the loop has run.
      *
      * Tolerates the skin still being pending. Safe to call repeatedly on the same id: the
-     * second call finds the row unoccupied and gives no range back twice.
+     * second call finds the row unoccupied and removes nothing.
      *
      * @param {number} skin_id
      */
     unregister_skin(skin_id: number): void;
     /**
-     * Flush all pending uploads (curves, keyframe blocks, tracks, clips,
-     * bound-track groups, skins, skin joint blocks) into the GPU
+     * Flush all pending uploads (curves, keyframes, tracks, clips,
+     * bindings, skins, skin joints) into the GPU
      * database. Call once per frame, before any shader that reads from
      * `database.buffer`.
      *
-     * Also drains the pending-registration queues: skins and clips
-     * whose dependencies (joint rows, channel-target rows)
-     * weren't ready at register time get one shot per `update` to
-     * complete. Once every entity has taken its row, the
-     * deferred chain build runs and the registration becomes
-     * observationally complete — the next-frame `database.update`
-     * picks up the patched head pointer.
+     * Drains the pending-registration queues first: skins and clips
+     * whose dependencies (joint rows, channel-target rows) weren't
+     * ready at register time get one shot per `update` to complete.
+     * Once every entity has taken its row, the deferred build runs,
+     * and this same call's `database.update` uploads what it wrote.
      *
      * Does not touch the skin-matrices ping-pong buffers — those
      * are scratch populated each frame by
@@ -431,23 +418,23 @@ export class GPUAnimationManager {
      * correct ping-pong behaviour across frames without leaking the
      * buffer-role bookkeeping into every caller.
      *
-     * No-op when no skins are registered (`group_count_x === 0`).
+     * No-op when the joints table has no page for it to walk
+     * (`group_count_x === 0`), which is never while a skin is
+     * registered: a page emptied of joints goes at the next database
+     * update.
      *
      * Per-frame ordering:
-     *  1. Flip {@link #skin_matrices_current_index} — the buffer that
-     *     was last frame's "current" is about to be overwritten with
-     *     this frame's matrices; the other buffer (last frame's prev)
-     *     becomes this frame's "previous" implicit data source for
-     *     {@link prev_skin_matrices_buffer}.
-     *  2. Wait — clarify: we want last frame's "current" to BECOME
-     *     this frame's "previous". So flipping current_index moves
-     *     the role tag the correct way: what was current[i] becomes
-     *     previous (= buffers[1 - i]), and current[1 - i] is the
-     *     write target.
-     *  3. Dispatch the prep shader into the new current.
-     *  4. On the very first frame (or after a grow), copy current →
-     *     previous so the first velocity reads see matching matrices
-     *     and produce zero velocity.
+     *  1. Flip {@link #skin_matrices_current_index}: last frame's
+     *     "current" becomes this frame's "previous"
+     *     ({@link prev_skin_matrices_buffer}), and the buffer that
+     *     held the frame before it becomes the write target.
+     *  2. Dispatch the prep shader into the new "current".
+     *  3. Copy "current" over "previous" on the rows that have no last
+     *     frame — every run handed out and every pending skin's run
+     *     named since the last dispatch, or all of it after a grow —
+     *     so the first velocity read over those rows sees matching
+     *     matrices and produces zero velocity. Every other row of
+     *     "previous" keeps last frame's matrices.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
      */
@@ -486,6 +473,7 @@ export class GPUAnimationManager {
     #private;
 }
 export type AnimationCurve = import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve;
+export type GPURecordWriter = import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter;
 export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type GPUSceneContext = import("../scene/GPUSceneContext.js").GPUSceneContext;
 export type ShadeAnimationClip = import("./ShadeAnimationClip.js").ShadeAnimationClip;

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"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"}