@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -0,0 +1,205 @@
+import { assert } from "../../../core/assert.js";
+import { hold_clip_targets, register_clips, release_clip_targets, unregister_clips } from "../register_clips.js";
+import { RowChains } from "../RowChains.js";
+import { write_clip_playback } from "./write_clip_playback.js";
+
+/**
+ * @typedef {import("../../ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ * @typedef {import("../../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ * @typedef {import("../../../shade/renderer/scene/Scene.js").Scene} Scene
+ * @typedef {import("../GraphicsEngine.js").GraphicsEngine} GraphicsEngine
+ * @typedef {import("./AnimationClips.js").AnimationClips} AnimationClips
+ */
+
+/**
+ * Connects an animation driver (`AnimationSystem` or `AnimationGraphSystem`) to the scene's GPU
+ * context for every {@link AnimationClips} component the driver plays:
+ *
+ * - **Holds a row chain for every node the clips key** ({@link hold_clip_targets}), from the clips
+ *   being bound until they go. A clip binds on the GPU only once every node it keys holds a row, and
+ *   a keyed node outside every skin with nothing drawn under it is held by no other system.
+ * - **Registers only the clips the driver names** ({@link AnimationClips#played_slots}), and
+ *   re-registers when that set moves or when a renderer restart replaces the GPU scene context.
+ * - **Pushes this tick's weights and times** from {@link AnimationClips} to
+ *   {@link GPUAnimationManager} via {@link write_clip_playback}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class AnimationClipsSink {
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * The scene whose GPU context issues the clip ids.
+     *
+     * @type {Scene}
+     */
+    #scene;
+
+    /**
+     * The chains of the nodes the clips key. Null until the driver has a dataset.
+     *
+     * @type {RowChains|null}
+     */
+    #chains = null;
+
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics, scene) {
+        assert.defined(graphics, 'graphics');
+        assert.equal(scene?.isScene, true, 'scene.isScene !== true');
+
+        this.#graphics = graphics;
+        this.#scene = scene;
+    }
+
+    /**
+     * Bind the scene to the dataset and start tracking row chains for keyed nodes.
+     *
+     * @param {EntityComponentDataset} dataset
+     */
+    startup(dataset) {
+        // the scene's rows are this dataset's entities; the first system to place one says so
+        const scene = this.#scene;
+
+        assert.ok(
+            scene.dataset === null || scene.dataset === undefined || scene.dataset === dataset,
+            'the scene is bound to another dataset'
+        );
+
+        scene.dataset = dataset;
+
+        this.#chains = new RowChains(dataset);
+    }
+
+    /**
+     * Release the GPU registration and playback state of one {@link AnimationClips} during system
+     * shutdown, leaving row-chain teardown to {@link shutdown}.
+     *
+     * @param {AnimationClips} clips
+     */
+    unbind_on_shutdown(clips) {
+        this.#release_registration(clips);
+
+        clips.unbind();
+    }
+
+    /**
+     * Tear down the row chains on system shutdown.
+     */
+    shutdown() {
+        this.#chains.destroy();
+        this.#chains = null;
+    }
+
+    /**
+     * Bind the row chains to the current GPU context's rows and answer that context.
+     *
+     * No device — before the first start, and again after a stop — answers `null`. The driver's
+     * clocks still run; holds are recorded and acquired in whole when a context arrives.
+     *
+     * @returns {GPUSceneContext|null}
+     */
+    begin_update() {
+        const context = this.#graphics.scene_context(this.#scene);
+
+        // a new context after a restart is acquired in whole; until there is one, holds are recorded
+        this.#chains.bind(context === null ? null : context.rows);
+
+        return context;
+    }
+
+    /**
+     * Take up an entity's {@link AnimationClips}: allocate its playback buffers and hold a row chain
+     * for every node its channels key.
+     *
+     * Called before anything registers, so the clips bind on the GPU in the update that registers
+     * them.
+     *
+     * @param {AnimationClips} clips
+     */
+    bind(clips) {
+        if (clips.bound) {
+            this.release(clips);
+        }
+
+        clips.bind();
+
+        hold_clip_targets(this.#chains, clips.clips);
+    }
+
+    /**
+     * Let go of an entity's {@link AnimationClips}: return its GPU registration if the manager that
+     * issued it is still current, release the row chains held for its targets, and clear its
+     * playback state.
+     *
+     * @param {AnimationClips} clips
+     */
+    release(clips) {
+        if (!clips.bound) {
+            return;
+        }
+
+        this.#release_registration(clips);
+
+        release_clip_targets(this.#chains, clips.clips);
+
+        clips.unbind();
+    }
+
+    /**
+     * Keep the GPU registration equal to {@link AnimationClips#played_slots} on the current context,
+     * and write this tick's weights and times down to the animation manager.
+     *
+     * @param {AnimationClips} clips
+     * @param {GPUSceneContext|null} context
+     * @param {boolean} slots_changed whether {@link AnimationClips#played_slots} changed this tick
+     */
+    sync(clips, context, slots_changed) {
+        if (context === null) {
+            return;
+        }
+
+        const registration = clips.clip_registration;
+
+        if (slots_changed || registration === null || registration.context !== context) {
+            this.#release_registration(clips);
+
+            clips.clip_registration = register_clips(context, clips.clips, clips.played_slots);
+
+            // whatever the last registration was told is not what this one knows
+            clips.written.fill(-1);
+        }
+
+        write_clip_playback(context.animation_manager, clips);
+    }
+
+    /**
+     * Give these clips' registration back, if the manager that issued it is still the one running.
+     *
+     * **An id may only be handed back to the manager that issued it.** A renderer restart replaces
+     * the GPU scene context and voids every id it gave out, so a registration stamped with a context
+     * that is no longer current is forgotten rather than returned — returning it would corrupt a
+     * stranger's table.
+     *
+     * @param {AnimationClips} clips
+     */
+    #release_registration(clips) {
+        const registration = clips.clip_registration;
+
+        if (registration === null) {
+            return;
+        }
+
+        if (registration.context === this.#graphics.scene_context(this.#scene)) {
+            unregister_clips(registration);
+        }
+
+        clips.clip_registration = null;
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * The procedural foliage wind rigs a model came with, re-addressed to one placed instance's entities.
+ *
+ * **What it is for.** {@link prefab_instantiate} puts one of these on the root of a placed foliage
+ * model when the prefab carries {@link Prefab#foliage_rigs}, with every joint's `target` and the
+ * rig's `root` rewritten from the prefab's node index to the entity that node became in the
+ * instance. {@link FoliageWindSystem} pairs it with a {@link Transform64} on the same entity:
+ * `FoliageWindRigs` is *what* aeroelastic bone rigs the tree has and their blend weight, and
+ * `FoliageWindSystem` registers them with {@link GPUAnimationManager} and holds their scene rows.
+ */
+export class FoliageWindRigs {
+    /**
+     * @param {FoliageWindRig[]} [rigs]
+     * @param {number} [weight=1]
+     * @returns {FoliageWindRigs}
+     */
+    static from(rigs?: FoliageWindRig[], weight?: number): FoliageWindRigs;
+    /**
+     * Each rig's `root` and every joint's `target` are entity ids in the dataset this component
+     * lives in.
+     *
+     * @type {FoliageWindRig[]}
+     */
+    rigs: FoliageWindRig[];
+    /**
+     * Blend weight applied to all foliage wind rigs on this entity in `[0, 1]` (or `>= 0`). Setting
+     * `weight = 0` disables wind contribution in `GPUAnimationManager`'s pose accumulator.
+     *
+     * @type {number}
+     */
+    weight: number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isFoliageWindRigs: boolean;
+}
+export namespace FoliageWindRigs {
+    let typeName: string;
+    let serializable: boolean;
+}
+import { FoliageWindRig } from "../../../shade/renderer/animation/foliage/FoliageWindRig.js";
+//# sourceMappingURL=FoliageWindRigs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageWindRigs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/FoliageWindRigs.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;IAiBI;;;;OAIG;IACH,mBAJW,cAAc,EAAE,WAChB,MAAM,GACJ,eAAe,CAgB3B;IAnCD;;;;;OAKG;IACH,MAFU,cAAc,EAAE,CAEhB;IAEV;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAwBf;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;kBAUS,MAAM;sBAMN,OAAO;;+BAjEc,6DAA6D"}

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

@@ -0,0 +1,69 @@
+import { assert } from "../../../core/assert.js";
+import { FoliageWindRig } from "../../../shade/renderer/animation/foliage/FoliageWindRig.js";
+
+/**
+ * The procedural foliage wind rigs a model came with, re-addressed to one placed instance's entities.
+ *
+ * **What it is for.** {@link prefab_instantiate} puts one of these on the root of a placed foliage
+ * model when the prefab carries {@link Prefab#foliage_rigs}, with every joint's `target` and the
+ * rig's `root` rewritten from the prefab's node index to the entity that node became in the
+ * instance. {@link FoliageWindSystem} pairs it with a {@link Transform64} on the same entity:
+ * `FoliageWindRigs` is *what* aeroelastic bone rigs the tree has and their blend weight, and
+ * `FoliageWindSystem` registers them with {@link GPUAnimationManager} and holds their scene rows.
+ */
+export class FoliageWindRigs {
+    /**
+     * Each rig's `root` and every joint's `target` are entity ids in the dataset this component
+     * lives in.
+     *
+     * @type {FoliageWindRig[]}
+     */
+    rigs = [];
+
+    /**
+     * Blend weight applied to all foliage wind rigs on this entity in `[0, 1]` (or `>= 0`). Setting
+     * `weight = 0` disables wind contribution in `GPUAnimationManager`'s pose accumulator.
+     *
+     * @type {number}
+     */
+    weight = 1;
+
+    /**
+     * @param {FoliageWindRig[]} [rigs]
+     * @param {number} [weight=1]
+     * @returns {FoliageWindRigs}
+     */
+    static from(rigs = [], weight = 1) {
+        assert.isArray(rigs, 'rigs');
+        assert.isNumber(weight, 'weight');
+
+        for (let i = 0; i < rigs.length; i++) {
+            assert.isInstanceOf(rigs[i], FoliageWindRig, `rigs[${i}]`);
+        }
+
+        const r = new FoliageWindRigs();
+
+        r.rigs = rigs;
+        r.weight = weight;
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+FoliageWindRigs.prototype.isFoliageWindRigs = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
+FoliageWindRigs.typeName = "FoliageWindRigs";
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+FoliageWindRigs.serializable = false;

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

@@ -1,26 +1,32 @@
 /**
- * Hand one clip list's blend down to the renderer: what each of the entity's clips weighs, and where
- * each of the audible ones is playing.
+ * @typedef {import("../../../shade/renderer/animation/GPUAnimationManager.js").GPUAnimationManager} GPUAnimationManager
+ * @typedef {import("./AnimationClips.js").AnimationClips} AnimationClips
+ */
+/**
+ * Hand an entity's {@link AnimationClips} blend down to the renderer: what each of its playable
+ * clips weighs, and where each of the audible ones is playing.
  *
  * **Time is written every frame and weight only when it moves.** The clock is the reason this
  * function exists — Shade can advance a clip itself and is never asked to, because the pose gameplay
- * reads and the pose on the screen have to be the same one (I-4) — while a building looping one clip
- * has the weight it had last frame and there is nothing to say. Both calls go through the clip
- * table's upload dedupe, so a repeated value costs a comparison rather than a transfer; skipping the
- * unchanged weights is about not doing the read either.
+ * reads and the pose on the screen have to be the same one (I-4) — while an entity looping one clip
+ * or sitting in one graph state has the weights it had last frame and there is nothing to say. Both
+ * calls go through the clip table's upload dedupe, so a repeated value costs a comparison rather
+ * than a transfer; skipping the unchanged weights is about not doing the read either.
  *
  * A clip at zero weight has its time left alone. It contributes nothing wherever it is, and where it
  * is, is where it stopped.
  *
  * @param {GPUAnimationManager} manager
- * @param {ClipListPlayer} player
- * @param {ArrayLike<number>} clip_ids the manager's id for each of the entity's clips, in its
- * `AnimationClips`' order, or {@link CLIP_NOT_REGISTERED} for one this driver does not play. Those are
+ * @param {AnimationClips} clips
+ * @param {ArrayLike<number>} [clip_ids] the manager's id for each of the entity's clips, in
+ * `clips.clips`' order, or {@link CLIP_NOT_REGISTERED} for one the driver does not play. Those are
  * skipped rather than written at weight zero: an unregistered clip has no row, and it is unregistered
  * precisely so that it marks no joints (D37)
- * @param {Float32Array} written the weight each of those clips was last given; updated in place.
+ * @param {Float32Array} [written] the weight each of those clips was last given; updated in place.
  * A value no weight can take — `-1` — is how a caller says it does not know, which is the case
  * after a renderer restart
  */
-export function write_clip_playback(manager: GPUAnimationManager, player: ClipListPlayer, clip_ids: ArrayLike<number>, written: Float32Array): void;
+export function write_clip_playback(manager: GPUAnimationManager, clips: AnimationClips, clip_ids?: ArrayLike<number>, written?: Float32Array): void;
+export type GPUAnimationManager = import("../../../shade/renderer/animation/GPUAnimationManager.js").GPUAnimationManager;
+export type AnimationClips = import("./AnimationClips.js").AnimationClips;
 //# sourceMappingURL=write_clip_playback.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"write_clip_playback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/write_clip_playback.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oGARW,UAAU,MAAM,CAAC,WAIjB,YAAY,QAoCtB"}
+{"version":3,"file":"write_clip_playback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/write_clip_playback.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6CAVW,mBAAmB,SACnB,cAAc,aACd,UAAU,MAAM,CAAC,YAIjB,YAAY,QAwCtB;kCAhEY,OAAO,0DAA0D,EAAE,mBAAmB;6BACtF,OAAO,qBAAqB,EAAE,cAAc"}

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

@@ -2,59 +2,68 @@ import { assert } from "../../../core/assert.js";
 import { CLIP_NOT_REGISTERED } from "../register_clips.js";
 
 /**
- * Hand one clip list's blend down to the renderer: what each of the entity's clips weighs, and where
- * each of the audible ones is playing.
+ * @typedef {import("../../../shade/renderer/animation/GPUAnimationManager.js").GPUAnimationManager} GPUAnimationManager
+ * @typedef {import("./AnimationClips.js").AnimationClips} AnimationClips
+ */
+
+/**
+ * Hand an entity's {@link AnimationClips} blend down to the renderer: what each of its playable
+ * clips weighs, and where each of the audible ones is playing.
  *
  * **Time is written every frame and weight only when it moves.** The clock is the reason this
  * function exists — Shade can advance a clip itself and is never asked to, because the pose gameplay
- * reads and the pose on the screen have to be the same one (I-4) — while a building looping one clip
- * has the weight it had last frame and there is nothing to say. Both calls go through the clip
- * table's upload dedupe, so a repeated value costs a comparison rather than a transfer; skipping the
- * unchanged weights is about not doing the read either.
+ * reads and the pose on the screen have to be the same one (I-4) — while an entity looping one clip
+ * or sitting in one graph state has the weights it had last frame and there is nothing to say. Both
+ * calls go through the clip table's upload dedupe, so a repeated value costs a comparison rather
+ * than a transfer; skipping the unchanged weights is about not doing the read either.
  *
  * A clip at zero weight has its time left alone. It contributes nothing wherever it is, and where it
  * is, is where it stopped.
  *
  * @param {GPUAnimationManager} manager
- * @param {ClipListPlayer} player
- * @param {ArrayLike<number>} clip_ids the manager's id for each of the entity's clips, in its
- * `AnimationClips`' order, or {@link CLIP_NOT_REGISTERED} for one this driver does not play. Those are
+ * @param {AnimationClips} clips
+ * @param {ArrayLike<number>} [clip_ids] the manager's id for each of the entity's clips, in
+ * `clips.clips`' order, or {@link CLIP_NOT_REGISTERED} for one the driver does not play. Those are
  * skipped rather than written at weight zero: an unregistered clip has no row, and it is unregistered
  * precisely so that it marks no joints (D37)
- * @param {Float32Array} written the weight each of those clips was last given; updated in place.
+ * @param {Float32Array} [written] the weight each of those clips was last given; updated in place.
  * A value no weight can take — `-1` — is how a caller says it does not know, which is the case
  * after a renderer restart
  */
-export function write_clip_playback(manager, player, clip_ids, written) {
+export function write_clip_playback(
+    manager,
+    clips,
+    clip_ids = clips.clip_registration.ids,
+    written = clips.written
+) {
     assert.defined(manager, 'manager');
-    assert.defined(player, 'player');
+    assert.defined(clips, 'clips');
 
-    const weights = player.weights;
+    const weights = clips.weights;
+    const times = clips.times;
+    const played = clips.played_slots;
 
     assert.equal(clip_ids.length, weights.length, 'clip_ids.length');
     assert.equal(written.length, weights.length, 'written.length');
 
-    for (let i = 0; i < weights.length; i++) {
-        if (clip_ids[i] === CLIP_NOT_REGISTERED) {
+    for (let i = 0; i < played.length; i++) {
+        const slot = played[i];
+        const clip_id = clip_ids[slot];
+
+        if (clip_id === CLIP_NOT_REGISTERED) {
             continue;
         }
 
-        const weight = weights[i];
+        const weight = weights[slot];
 
-        if (weight !== written[i]) {
-            manager.set_playback_weight(clip_ids[i], weight);
+        if (weight !== written[slot]) {
+            manager.set_playback_weight(clip_id, weight);
 
-            written[i] = weight;
+            written[slot] = weight;
         }
-    }
-
-    const playbacks = player.playbacks;
-
-    for (let i = 0; i < playbacks.length; i++) {
-        const playback = playbacks[i];
 
-        if (playback.weight > 0) {
-            manager.set_time(clip_ids[playback.slot], playback.time);
+        if (weight > 0) {
+            manager.set_time(clip_id, times[slot]);
         }
     }
 }

package/src/engine/graphics3/decal/GPUDecalRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aAuBnC;IAgPD,gBAoBC;;CACJ"}
+{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aAuBnC;IAkPD,gBAoBC;;CACJ"}

package/src/engine/graphics3/decal/GPUDecalRenderer.js

@@ -7,7 +7,7 @@ import { TextureViewDescriptor } from "../../../shade/descriptor/texture/Texture
 import { TextureResourceDescriptor } from "../../../shade/device/graph/TextureResourceDescriptor.js";
 import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
 import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
-import { SAMPLER_LINEAR_UPSCALE } from "../../../shade/renderer/texture/SAMPLER_LINEAR_UPSCALE.js";
+import { SAMPLER_ANISOTROPIC_CLAMP } from "../../../shade/renderer/texture/SAMPLER_ANISOTROPIC_CLAMP.js";
 import { graph_build_decal_clusters } from "./graph_build_decal_clusters.js";
 import { DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
 import { shader_decal_composite } from "./shader_decal_composite.js";
@@ -138,7 +138,7 @@ export class GPUDecalRenderer {
         const data = {};
 
         const pass = graph.add('decals / composite', data, (data, resources, execution) => {
-            this.#execute(data, resources, execution, camera, cluster_params, resolution);
+            this.#execute(data, resources, execution, frame.view, cluster_params, resolution);
         });
 
         data.depth = pass.read(frame.get(ViewTextures).depth);
@@ -182,11 +182,12 @@ export class GPUDecalRenderer {
      * @param data
      * @param {FramePassResources} resources
      * @param {GraphicsExecutionContext} context
-     * @param {GPUCameraContext} camera
+     * @param {GPUViewContext} view_context
      * @param {number[]} cluster_params
      * @param {number[]} resolution
      */
-    #execute(data, resources, context, camera, cluster_params, resolution) {
+    #execute(data, resources, context, view_context, cluster_params, resolution) {
+        const camera = view_context.camera;
         const encoder = context.encoder;
         const graphics = context.graphics;
 
@@ -197,7 +198,7 @@ export class GPUDecalRenderer {
             distance_max: camera.camera.far,
         };
 
-        const sampler = graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE);
+        const sampler = graphics.samplers.obtain(SAMPLER_ANISOTROPIC_CLAMP);
 
         /**
          * @param {number} handle
@@ -217,7 +218,8 @@ export class GPUDecalRenderer {
         shader_decal_composite.draw({
             encoder,
             bindings: {
-                camera: camera.buffer,
+                camera: camera.buffer,
+                view: view_context.uniform_buffer.buffer,
                 settings,
                 gBufferPBR: view(data.in_pbr),
                 gBufferNormal: view(data.in_normal),

package/src/engine/graphics3/decal/shader_decal_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AA8DA,oDAKG;AAqSH;;;;;;;;;;;;GAYG;AACH,qCAFU,WAAW,CAclB;6BAtV0B,qDAAqD;4BAPtD,+CAA+C"}
+{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAgEA,oDAKG;AAySH;;;;;;;;;;;;GAYG;AACH,qCAFU,WAAW,CAclB;6BA1V0B,qDAAqD;4BAPtD,+CAA+C"}

package/src/engine/graphics3/decal/shader_decal_composite.js

@@ -1,4 +1,6 @@
-import { CAMERA_UNIFORM_STRUCT } from "../../../shade/renderer/camera/CAMERA_UNIFORM_STRUCT.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../shade/renderer/camera/CAMERA_UNIFORM_STRUCT.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../shade/renderer/view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_view_mip_bias } from "../../../shade/renderer/view/chunk_view_mip_bias.js";
 import { G_BUFFER_ALBEDO_FORMAT } from "../../../shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
 import {
     chunk_cluster_depth_to_z_slice
@@ -73,7 +75,8 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate("settings", DECAL_COMPOSITE_SETTINGS);
 
 resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT);
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT);
 
 /*
  The two integer targets are declared as such, exactly as `shader_deferred_main` declares the same
@@ -243,6 +246,8 @@ fn main(
     var normal = shading_normal;
     var emissive = rgbe9995_decode(old_emissive);
 
+    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
+
     for (var i = 0u; i < metadata.count; i++) {
         let decal_index = cluster_data[metadata.offset + i];
 
@@ -274,8 +279,8 @@ fn main(
         let local_x = (inverse * vec4<f32>(position_x, 1.0)).xy;
         let local_y = (inverse * vec4<f32>(position_y, 1.0)).xy;
 
-        let duv_dx = local_x - local.xy;
-        let duv_dy = local_y - local.xy;
+        let duv_dx = (local_x - local.xy) * uv_bias.x;
+        let duv_dy = (local_y - local.xy) * uv_bias.y;
 
         let lod = decal_vec4(decal_index, ${DECAL_RECORD_OFFSET_LOD}u);
 
@@ -354,7 +359,8 @@ fn main(
         chunk_rgbe9995_encode,
         chunk_light_cluster_resolution_xy_from_screen,
         chunk_cluster_depth_to_z_slice,
-        chunk_grid3d_to_index
+        chunk_grid3d_to_index,
+        chunk_view_mip_bias
     ]
 );
 

package/src/engine/graphics3/pose/collect_entity_playbacks.d.ts

@@ -1,12 +1,12 @@
 /**
- * Collect what every animation driver is playing on an entity, in the form the
- * CPU pose evaluator takes.
+ * Collect what is playing on an entity, in the form the CPU pose evaluator
+ * takes.
  *
- * Both drivers are asked because either may be the one driving it — a combat
- * unit runs a state machine, a building runs a clip list — and an entity has
- * one of them, so the two sets do not overlap in practice. What they hand back
- * is one entry per clip of the model, silent clips included, because that is
- * what the GPU's accumulator is summing.
+ * Whichever animation driver is running (`AnimationSystem` for a clip list,
+ * `AnimationGraphSystem` for a state machine) writes this tick's weights and
+ * times into the entity's {@link AnimationClips} sink. What it hands back is
+ * one entry per clip the driver plays, silent clips included, because that is
+ * what the GPU's accumulator is summing (D37).
  *
  * A free function rather than a private helper of
  * {@link query_entity_node_world_pose} because M3 gave it a second caller:

package/src/engine/graphics3/pose/collect_entity_playbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect_entity_playbacks.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/pose/collect_entity_playbacks.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iDARW,cAAc,yCAEd,MAAM,GACJ,IAAI,CAiBhB"}
+{"version":3,"file":"collect_entity_playbacks.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/pose/collect_entity_playbacks.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iDARW,cAAc,yCAEd,MAAM,GACJ,IAAI,CAiBhB"}

package/src/engine/graphics3/pose/collect_entity_playbacks.js

@@ -1,15 +1,14 @@
-import { AnimationGraphSystem } from "../AnimationGraphSystem.js";
-import { AnimationSystem } from "../AnimationSystem.js";
+import { AnimationClips } from "../animation/AnimationClips.js";
 
 /**
- * Collect what every animation driver is playing on an entity, in the form the
- * CPU pose evaluator takes.
+ * Collect what is playing on an entity, in the form the CPU pose evaluator
+ * takes.
  *
- * Both drivers are asked because either may be the one driving it — a combat
- * unit runs a state machine, a building runs a clip list — and an entity has
- * one of them, so the two sets do not overlap in practice. What they hand back
- * is one entry per clip of the model, silent clips included, because that is
- * what the GPU's accumulator is summing.
+ * Whichever animation driver is running (`AnimationSystem` for a clip list,
+ * `AnimationGraphSystem` for a state machine) writes this tick's weights and
+ * times into the entity's {@link AnimationClips} sink. What it hands back is
+ * one entry per clip the driver plays, silent clips included, because that is
+ * what the GPU's accumulator is summing (D37).
  *
  * A free function rather than a private helper of
  * {@link query_entity_node_world_pose} because M3 gave it a second caller:
@@ -26,15 +25,15 @@ import { AnimationSystem } from "../AnimationSystem.js";
  * @copyright Company Named Limited (c) 2026
  */
 export function collect_entity_playbacks(target, entity_manager, entity) {
-    const graphs = entity_manager.getSystem(AnimationGraphSystem);
+    const dataset = entity_manager.dataset;
 
-    if (graphs !== null) {
-        graphs.write_pose_playbacks(target, entity);
+    if (dataset === null || entity < 0 || !dataset.entityExists(entity)) {
+        return;
     }
 
-    const clips = entity_manager.getSystem(AnimationSystem);
+    const clips = dataset.getComponent(entity, AnimationClips);
 
-    if (clips !== null) {
-        clips.write_pose_playbacks(target, entity);
+    if (clips !== undefined) {
+        clips.write_pose_playbacks(target);
     }
 }