@woosh/meep-engine 3.52.0 → 3.53.0

package/src/engine/graphics3/FoliageWindSystem.js

@@ -0,0 +1,257 @@
+import { assert } from "../../core/assert.js";
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { FoliageWindRigs } from "./animation/FoliageWindRigs.js";
+import { RowChains } from "./RowChains.js";
+
+/**
+ * @typedef {import("../../shade/ShadeGraphicsEngine.js").ShadeGraphicsEngine} ShadeGraphicsEngine
+ * @typedef {import("../../shade/PublicScene.js").PublicScene} PublicScene
+ * @typedef {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ * @typedef {import("../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig} FoliageWindRig
+ */
+
+/**
+ * @typedef {object} FoliageWindEntry
+ * @property {FoliageWindRigs} component
+ * @property {FoliageWindRig[]} rigs
+ * @property {GPUSceneContext|null} context
+ * @property {Int32Array|null} rig_ids
+ * @property {number} written_weight
+ */
+
+/**
+ * Registers every entity carrying {@link FoliageWindRigs} with the scene's
+ * {@link GPUAnimationManager}, so that procedural foliage skeletons deform in real time under
+ * the scene's 3D fluid dynamics cascades and global wind field (`GPUSceneWind`).
+ *
+ * **Rows.** Each rig's `root` entity and every `joint.target` entity are held in this system's
+ * {@link RowChains}, along with the transform chain above them, so every bone has a live
+ * `transforms` row on the GPU before {@link GPUAnimationManager#register_foliage_rig} binds it.
+ *
+ * **Lifecycle & Restart.** Mirrors {@link MeshSkinSystem}: rigs linked while a device is live
+ * register immediately; rigs linked before the renderer starts (or across a WebGPU device restart)
+ * bind and register on the next {@link update}. Changes to {@link FoliageWindRigs#weight} are
+ * propagated to {@link GPUAnimationManager#set_foliage_rig_weight} each frame.
+ */
+export class FoliageWindSystem extends System {
+    /**
+     * @type {ShadeGraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {PublicScene}
+     */
+    #scene;
+
+    /**
+     * @type {RowChains|null}
+     */
+    #chains = null;
+
+    /**
+     * @type {GPUSceneContext|null}
+     */
+    #context = null;
+
+    /**
+     * @type {Map<number, FoliageWindEntry>}
+     */
+    #entries = new Map();
+
+    /**
+     * @param {ShadeGraphicsEngine} graphics
+     * @param {PublicScene} scene
+     */
+    constructor(graphics, scene) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+        assert.defined(scene, 'scene');
+
+        this.#graphics = graphics;
+        this.#scene = scene;
+
+        this.dependencies = [FoliageWindRigs, Transform64];
+    }
+
+    async startup(entityManager) {
+        const dataset = entityManager.dataset;
+        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);
+    }
+
+    async shutdown() {
+        for (const entry of this.#entries.values()) {
+            this.#unregister(entry);
+        }
+
+        this.#entries.clear();
+
+        this.#chains.destroy();
+        this.#chains = null;
+        this.#context = null;
+    }
+
+    /**
+     * @param {FoliageWindRigs} component
+     * @param {Transform64} _transform
+     * @param {number} entity
+     */
+    link(component, _transform, entity) {
+        const rigs = component.rigs;
+        const chains = this.#chains;
+
+        for (let r = 0; r < rigs.length; r++) {
+            const rig = rigs[r];
+            chains.hold(rig.root);
+
+            const joints = rig.joints;
+            for (let j = 0; j < joints.length; j++) {
+                chains.hold(joints[j].target);
+            }
+        }
+
+        /** @type {FoliageWindEntry} */
+        const entry = {
+            component,
+            rigs,
+            context: null,
+            rig_ids: null,
+            written_weight: NaN,
+        };
+
+        this.#entries.set(entity, entry);
+
+        const context = this.#graphics.scene_context(this.#scene);
+
+        if (context !== null) {
+            chains.bind(context.rows);
+            this.#context = context;
+            this.#register(entry, context);
+        }
+    }
+
+    /**
+     * @param {FoliageWindRigs} _component
+     * @param {Transform64} _transform
+     * @param {number} entity
+     */
+    unlink(_component, _transform, entity) {
+        const entry = this.#entries.get(entity);
+
+        if (entry === undefined) {
+            return;
+        }
+
+        this.#entries.delete(entity);
+
+        this.#unregister(entry);
+
+        const chains = this.#chains;
+        const rigs = entry.rigs;
+
+        for (let r = 0; r < rigs.length; r++) {
+            const rig = rigs[r];
+            const joints = rig.joints;
+
+            for (let j = 0; j < joints.length; j++) {
+                chains.release(joints[j].target);
+            }
+
+            chains.release(rig.root);
+        }
+    }
+
+    update() {
+        const context = this.#graphics.scene_context(this.#scene);
+
+        if (context !== this.#context) {
+            this.#chains.bind(context === null ? null : context.rows);
+            this.#context = context;
+
+            if (context !== null) {
+                for (const entry of this.#entries.values()) {
+                    if (entry.context !== context) {
+                        this.#register(entry, context);
+                    }
+                }
+            }
+        }
+
+        if (context === null) {
+            return;
+        }
+
+        const manager = context.animation_manager;
+
+        for (const entry of this.#entries.values()) {
+            if (entry.context !== context) {
+                this.#register(entry, context);
+            }
+
+            const weight = entry.component.weight;
+            if (weight !== entry.written_weight && entry.rig_ids !== null) {
+                const rig_ids = entry.rig_ids;
+                for (let i = 0; i < rig_ids.length; i++) {
+                    manager.set_foliage_rig_weight(rig_ids[i], weight);
+                }
+                entry.written_weight = weight;
+            }
+        }
+    }
+
+    /**
+     * @param {FoliageWindEntry} entry
+     * @param {GPUSceneContext} context
+     */
+    #register(entry, context) {
+        const manager = context.animation_manager;
+        const rigs = entry.rigs;
+        const rig_ids = new Int32Array(rigs.length);
+        const weight = entry.component.weight;
+
+        for (let i = 0; i < rigs.length; i++) {
+            const rig_id = manager.register_foliage_rig(rigs[i]);
+            if (weight !== 1) {
+                manager.set_foliage_rig_weight(rig_id, weight);
+            }
+            rig_ids[i] = rig_id;
+        }
+
+        entry.context = context;
+        entry.rig_ids = rig_ids;
+        entry.written_weight = weight;
+    }
+
+    /**
+     * @param {FoliageWindEntry} entry
+     */
+    #unregister(entry) {
+        if (entry.context === null || entry.rig_ids === null) {
+            return;
+        }
+
+        if (entry.context === this.#graphics.scene_context(this.#scene)) {
+            const manager = entry.context.animation_manager;
+            const rig_ids = entry.rig_ids;
+
+            for (let i = 0; i < rig_ids.length; i++) {
+                manager.unregister_foliage_rig(rig_ids[i]);
+            }
+        }
+
+        entry.context = null;
+        entry.rig_ids = null;
+        entry.written_weight = NaN;
+    }
+}

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

@@ -114,6 +114,13 @@ export const GPU_FLUID_SYSTEM_TICK_CAP: number;
  * releases everything, rows included. At a fixed scene, nothing is created after the first frame.
  */
 export class GPUFluidSystem extends System<any> {
+    /**
+     * Offer the compute pipelines the GPU fluid cascades, forcing, and query readback dispatch —
+     * see {@link PipelineEnquiry}.
+     *
+     * @param {import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     /**
      * @param {import("./GraphicsEngine.js").GraphicsEngine} graphics
      * @param {import("../../shade/renderer/scene/Scene.js").Scene} scene the scene whose wind this is

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

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUFluidSystem.js"],"names":[],"mappings":"AAyCA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAmG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AACH;IAyII;;;OAGG;IACH,sBAHW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,EAU7D;IAnJD,gEAAgD;IAEhD,oOAME;IA6IF;;OAEG;IACH,iEAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,eAFW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAQ5C;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAbW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CA+ClB;IAmMD,2CAoBC;IAED,4CAaC;IA6CD;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAiBhB;IAohBD;;;;;OAKG;IACH,eAFW,YAAY,QAetB;IAkKL;;;;;;;OAOG;IACH,2BAFU,OAAO,CAEwB;;CAVxC;AAYD;;;GAGG;AACH;IAII;;OAEG;IACH,oBAFW,cAAc,EAMxB;IADG,uBAAoB;CAS3B;8BAliDY,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,gDAAgD,EAAE,YAAY;oCACrE,OAAO,oDAAoD,EAAE,qBAAqB;kCAClF,OAAO,kEAAkE,EAAE,mBAAmB;kCAC9F,OAAO,2DAA2D,EAAE,mBAAmB;8BACvF,OAAO,6CAA6C,EAAE,eAAe;uBAjC3D,kBAAkB;4BACb,iCAAiC;kCAWtD,2CAA2C;wCARV,iDAAiD;4CAf7C,iDAAiD;8BAiB/D,uCAAuC;yBAJ5C,4BAA4B;0BAC3B,6BAA6B;qCARlB,oDAAoD;gCADzD,uDAAuD;gCAE5B,qDAAqD;gCAJhF,mDAAmD"}
+{"version":3,"file":"GPUFluidSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUFluidSystem.js"],"names":[],"mappings":"AAyCA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAmG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,OAAO,gDAAgD,EAAE,eAAe,QAMlF;IAyID;;;OAGG;IACH,sBAHW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,EAU7D;IAnJD,gEAAgD;IAEhD,oOAME;IA6IF;;OAEG;IACH,iEAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,eAFW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAQ5C;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAbW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CA+ClB;IAmMD,2CAoBC;IAED,4CAaC;IA6CD;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAiBhB;IAqiBD;;;;;OAKG;IACH,eAFW,YAAY,QAetB;IAkKL;;;;;;;OAOG;IACH,2BAFU,OAAO,CAEwB;;CAVxC;AAYD;;;GAGG;AACH;IAII;;OAEG;IACH,oBAFW,cAAc,EAMxB;IADG,uBAAoB;CAkB3B;8BAxkDY,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,gDAAgD,EAAE,YAAY;oCACrE,OAAO,oDAAoD,EAAE,qBAAqB;kCAClF,OAAO,kEAAkE,EAAE,mBAAmB;kCAC9F,OAAO,2DAA2D,EAAE,mBAAmB;8BACvF,OAAO,6CAA6C,EAAE,eAAe;uBAjC3D,kBAAkB;4BACb,iCAAiC;kCAWtD,2CAA2C;wCARV,iDAAiD;4CAf7C,iDAAiD;8BAiB/D,uCAAuC;yBAJ5C,4BAA4B;0BAC3B,6BAA6B;qCARlB,oDAAoD;gCADzD,uDAAuD;gCAE5B,qDAAqD;gCAJhF,mDAAmD"}

package/src/engine/graphics3/GPUFluidSystem.js

@@ -255,6 +255,18 @@ class ObstacleEntry {
  */
 export class GPUFluidSystem extends System {
 
+    /**
+     * Offer the compute pipelines the GPU fluid cascades, forcing, and query readback dispatch —
+     * see {@link PipelineEnquiry}.
+     *
+     * @param {import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        GPUFluidCascadeStack.enquirePipelines(enquiry);
+        GPUFluidForcing.enquirePipelines(enquiry);
+        GPUFluidQueries.enquirePipelines(enquiry);
+    }
+
     dependencies = [GPUFluidComponent, Transform64];
 
     components_used = [
@@ -1077,9 +1089,26 @@ export class GPUFluidSystem extends System {
         assert.isPositiveInteger(cascade_count, 'GPUFluidComponent.cascade_count');
         assert.lessThanOrEqual(cascade_count, GPU_FLUID_COMPONENT_CASCADE_LIMIT, 'GPUFluidComponent.cascade_count');
 
-        const device = this.#graphics.renderer.graphics.device;
+        const graphics = this.#graphics.renderer.graphics;
+        const device = graphics.device;
 
         if (this.#forcing === null) {
+            if (graphics.compute_pipelines !== undefined) {
+                const enquiry = /** @type {import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry} */ ({
+                    device,
+                    render: [],
+                    compute: [],
+                });
+
+                GPUFluidSystem.enquirePipelines(enquiry);
+
+                const compute = enquiry.compute;
+
+                for (let i = 0; i < compute.length; i++) {
+                    graphics.compute_pipelines.prepare(compute[i]);
+                }
+            }
+
             this.#forcing = new GPUFluidForcing({ device });
         }
 
@@ -1610,4 +1639,13 @@ export class GPUFluidExtension extends RenderExtension {
     record(frame) {
         this.system.prepare(frame);
     }
+
+    /**
+     * @param {import("../../shade/device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry) {
+        if (this.system.domain !== -1) {
+            GPUFluidSystem.enquirePipelines(enquiry);
+        }
+    }
 }

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

@@ -232,5 +232,4 @@ import { ParticleEmitter } from "../../shade/renderer/particles/runtime/Particle
 import { ParticleEffect } from "../graphics/ecs/particles/ParticleEffect.js";
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
-import { TextureAtlas } from "../graphics/texture/atlas/TextureAtlas.js";
 //# sourceMappingURL=GPUParticleEmitterSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAszBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAiFnB;AAl4BD;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAoDI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAgB7D;IArED,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,YAAY,CAEO;IAiE7B;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IA6BD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAyB1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAqChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CAiWJ;;;;;gBAxxBa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;YAKjE,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;gCAvCP,2DAA2D;+BAS5D,6CAA6C;uBAPrD,kBAAkB;4BAEb,iCAAiC;6BAMhC,2CAA2C"}
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAo0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAiFnB;AA94BD;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAoDI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAgB7D;IArED,6DAA6C;IAE7C;;;OAGG;IACH,oBAAsD;IAiEtD;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IA6BD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAyB1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAqChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CA6WJ;;;;;gBApyBa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;YAKjE,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;gCAzCP,2DAA2D;+BAS5D,6CAA6C;uBAPrD,kBAAkB;4BAEb,iCAAiC"}

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -12,7 +12,9 @@ import { row_of_entity } from "../../shade/renderer/scene/rows/GPUSceneRows.js";
 import { GameAssetType } from "../asset/GameAssetType.js";
 import { ImageRGBADataLoader } from "../asset/loaders/image/ImageRGBADataLoader.js";
 import { ParticleEffect } from "../graphics/ecs/particles/ParticleEffect.js";
-import { TextureAtlas } from "../graphics/texture/atlas/TextureAtlas.js";
+import { DecalAtlas } from "./decal/DecalAtlas.js";
+import { DecalAtlasFill } from "./decal/DecalAtlasFill.js";
+import { TextureFilterType } from "../../shade/renderer/texture/TextureFilterType.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
 import { sampler2d_ensure_uint8_RGBA } from "../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 
@@ -107,7 +109,7 @@ export class GPUParticleEmitterSystem extends System {
      * CPU atlas, exposed for inspection. Owned by this system.
      * @type {TextureAtlas}
      */
-    atlas = new TextureAtlas(64);
+    atlas = new DecalAtlas(DecalAtlasFill.EdgeExtend, 64);
 
     /** @type {import("./GraphicsEngine.js").GraphicsEngine} */
     #graphics;
@@ -459,7 +461,7 @@ export class GPUParticleEmitterSystem extends System {
 
         this.#register(particles, frame.view.scene);
 
-        this.#upload(renderer.graphics.device);
+        this.#upload(renderer.graphics);
 
         particles.atlas = this.#view;
 
@@ -767,7 +769,8 @@ export class GPUParticleEmitterSystem extends System {
      * @param {GPUDevice} device
      * @returns {void}
      */
-    #upload(device) {
+    #upload(graphics) {
+        const device = graphics.device;
         const source = this.atlas.sampler;
 
         if (this.#device !== device || this.#texture === null) {
@@ -780,7 +783,9 @@ export class GPUParticleEmitterSystem extends System {
 
             descriptor.label = "particles/sprite atlas";
             descriptor.format = "rgba8unorm";
-            descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+            descriptor.usage = GPUTextureUsage.TEXTURE_BINDING
+                | GPUTextureUsage.COPY_DST
+                | GPUTextureUsage.RENDER_ATTACHMENT;
 
             this.#uploaded_version = -1;
         }
@@ -788,6 +793,7 @@ export class GPUParticleEmitterSystem extends System {
         const texture = this.#texture;
 
         if (texture.width !== source.width || texture.height !== source.height) {
+            texture.descriptor.mipLevelCount = 1 + Math.floor(Math.log2(Math.max(source.width, source.height)));
             texture.resize(source.width, source.height);
 
             this.#uploaded_version = -1;
@@ -797,6 +803,14 @@ export class GPUParticleEmitterSystem extends System {
             device.queue.writeTexture({ texture: texture.gpu_texture }, source.data,
                 { bytesPerRow: source.width * 4 }, [source.width, source.height]);
 
+            if (texture.descriptor.mipLevelCount > 1) {
+                graphics.textures.mipmaps.generateMipmap(
+                    texture.gpu_texture,
+                    texture.descriptor,
+                    TextureFilterType.Linear
+                );
+            }
+
             texture.incrementVersion();
 
             this.#uploaded_version = source.version;

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

@@ -1,19 +1,18 @@
 /**
- * @typedef {import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
- */
-/**
- * The clips this entity can play: each a {@link ShadeAnimationClip} whose channels key entities —
- * the joints of a rig, the nodes of a loaded model.
+ * The clips this entity can play — each a {@link ShadeAnimationClip} whose channels key entities
+ * (the joints of a rig, the nodes of a loaded model) — and the playback sink where whichever driver
+ * plays them writes what each weighs and where it is playing this tick.
  *
  * **It lives on the entity that plays them**, beside its `Animation` or `AnimationGraphController`.
  * A clip is one clock over many targets and describes no single one of them, so it is not a
  * component on a joint. `AnimationSystem` and `AnimationGraphSystem` resolve the names their lists
- * and graphs ask for against this set. The CPU pose consumers (IK, ContactProbe, cloth) ask those
- * drivers about a joint's `ParentEntity`, so a joint they should see names this entity there.
+ * and graphs ask for against this set and write the resulting blend back onto it; the GPU clip
+ * uploader and the CPU pose consumers (IK, ContactProbe, cloth, `query_entity_node_world_pose`)
+ * read from here without caring which driver produced the blend.
  *
  * **Not `Animation.clips`.** That list says what to play — a name, a weight, a repeat count each;
- * this says what there is to play and what each of those does to which entity. A name in the one is
- * looked up by name in the other.
+ * this says what there is to play, what each of those does to which entity, and where the active
+ * driver has placed each clip this frame.
  *
  * A model loaded by `MeshSystem` carries one on its root, re-addressed to the entities of that
  * placement; code that builds a rig puts one there the same way. A model with no clips carries an
@@ -23,10 +22,10 @@
  * 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.
+ * **The entities it keys go no sooner than it does.** While it is bound, the driver's sink holds 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.
@@ -47,6 +46,99 @@ export class AnimationClips {
      * @type {ShadeAnimationClip[]}
      */
     clips: ShadeAnimationClip[];
+    /**
+     * Whether a driver currently has these clips bound. `false` before the driver's first `update`
+     * after `link`, and `false` again once the driver unlinks or shuts down.
+     *
+     * @type {boolean}
+     */
+    bound: boolean;
+    /**
+     * Distinct indices into {@link clips} that the active driver plays (and registers on the GPU),
+     * in the driver's own order.
+     *
+     * Maintained here rather than alongside the GPU registration because **the pose evaluator needs
+     * it whether or not there is a device**: `collect_entity_playbacks` answers on the CPU from the
+     * clips the driver plays, and a game with rendering disabled still asks (I-4).
+     *
+     * @type {Int32Array}
+     */
+    played_slots: Int32Array;
+    /**
+     * What each of {@link clips} weighs this tick, in {@link clips}' order and at `f32` width — the
+     * width the renderer's clip table takes, so the CPU pose evaluator and the GPU agree on every
+     * share.
+     *
+     * @type {Float32Array}
+     */
+    weights: Float32Array;
+    /**
+     * Where each of {@link clips} is playing this tick, in seconds from its start, in {@link clips}'
+     * order.
+     *
+     * @type {Float64Array}
+     */
+    times: Float64Array;
+    /**
+     * One reusable {@link PosePlayback} per entry of {@link clips}, rewritten by
+     * {@link write_pose_playbacks} so per-frame CPU pose queries allocate nothing.
+     *
+     * @type {PosePlayback[]}
+     */
+    poses: PosePlayback[];
+    /**
+     * The active GPU registration for {@link played_slots}, or `null` when no device context has
+     * registered them yet.
+     *
+     * @type {ClipRegistration|null}
+     */
+    clip_registration: ClipRegistration | null;
+    /**
+     * The weight each entry of {@link clips} was last given on the GPU (`-1` where not yet written
+     * to the current registration).
+     *
+     * @type {Float32Array}
+     */
+    written: Float32Array;
+    /**
+     * Prepare the playback buffers when a driver takes up these clips.
+     */
+    bind(): void;
+    /**
+     * Clear the playback state when the driver releases these clips.
+     */
+    unbind(): void;
+    /**
+     * Update which of {@link clips} the driver plays, deduplicated in order of first appearance.
+     *
+     * Two entries of a clip list or two states of a graph can name one clip, and it is one row on
+     * the GPU either way — registered once, and reported to the pose evaluator once.
+     *
+     * @param {ArrayLike<number>} slots indices into {@link clips}
+     * @returns {boolean} whether the distinct set changed
+     */
+    set_played_slots(slots: ArrayLike<number>): boolean;
+    /**
+     * What the entity is playing, in the form the CPU pose evaluator takes: one entry per clip of
+     * {@link clips} in {@link played_slots}, at the weight and the time the renderer has been given.
+     *
+     * **Only the clips the driver names are here, because they are the only ones registered** (D37).
+     * The GPU's accumulator marks a joint dirty for every bound clip that writes to it, weight and
+     * all — so a bound clip at weight zero resolves the joints only it drives to zero rather than
+     * leaving them at rest. The answer is not to hand the surplus to the evaluator so it agrees
+     * with a mistake; it is not to bind them, and then a clip nothing names moves nothing.
+     *
+     * A clip the driver names that is not currently playing **is** here, at weight zero, because it
+     * is bound and the accumulator does see it.
+     *
+     * The entries are this component's own and are rewritten by the next call, which is what keeps
+     * a query on a per-frame path from allocating.
+     *
+     * @param {PosePlayback[]} target appended to
+     * @returns {boolean} whether a driver has bound these clips — `false` when no driver is playing
+     * them, or when they arrived since the driver's last update
+     */
+    write_pose_playbacks(target: PosePlayback[]): boolean;
     /**
      * @readonly
      * @type {boolean}
@@ -58,4 +150,6 @@ export namespace AnimationClips {
     let serializable: boolean;
 }
 export type ShadeAnimationClip = import("../../../shade/renderer/animation/ShadeAnimationClip.js").ShadeAnimationClip;
+export type ClipRegistration = import("../register_clips.js").ClipRegistration;
+import { PosePlayback } from "../../../shade/renderer/animation/pose/PosePlayback.js";
 //# sourceMappingURL=AnimationClips.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"AnimationClips.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/AnimationClips.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAsEI;;;OAGG;IACH,mBAHW,kBAAkB,EAAE,GAClB,cAAc,CAc1B;IArFD;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAEX;;;;;OAKG;IACH,OAFU,OAAO,CAEH;IAEd;;;;;;;;;OASG;IACH,cAFU,UAAU,CAEO;IAE3B;;;;;;OAMG;IACH,SAFU,YAAY,CAEE;IAExB;;;;;OAKG;IACH,OAFU,YAAY,CAEF;IAEpB;;;;;OAKG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;;;OAKG;IACH,mBAFU,gBAAgB,GAAC,IAAI,CAEN;IAEzB;;;;;OAKG;IACH,SAFU,YAAY,CAEE;IAoBxB;;OAEG;IACH,aAWC;IAED;;OAEG;IACH,eAQC;IAED;;;;;;;;OAQG;IACH,wBAHW,UAAU,MAAM,CAAC,GACf,OAAO,CAsCnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,6BAJW,YAAY,EAAE,GACZ,OAAO,CA0BnB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;;kBAUS,MAAM;sBAMN,OAAO;;iCAlRJ,OAAO,yDAAyD,EAAE,kBAAkB;+BACpF,OAAO,sBAAsB,EAAE,gBAAgB;6BAJ/B,wDAAwD"}