@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -0,0 +1,67 @@
+/**
+ * @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<any> {
+    /**
+     * @param {ShadeGraphicsEngine} graphics
+     * @param {PublicScene} scene
+     */
+    constructor(graphics: any, scene: any);
+    dependencies: (typeof Transform64 | typeof FoliageWindRigs)[];
+    startup(entityManager: any): Promise<void>;
+    shutdown(): Promise<void>;
+    /**
+     * @param {FoliageWindRigs} component
+     * @param {Transform64} _transform
+     * @param {number} entity
+     */
+    link(component: FoliageWindRigs, _transform: Transform64, entity: number): void;
+    /**
+     * @param {FoliageWindRigs} _component
+     * @param {Transform64} _transform
+     * @param {number} entity
+     */
+    unlink(_component: FoliageWindRigs, _transform: Transform64, entity: number): void;
+    update(): void;
+    #private;
+}
+export type ShadeGraphicsEngine = any;
+export type PublicScene = any;
+export type GPUSceneContext = import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
+export type FoliageWindRig = import("../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig;
+export type FoliageWindEntry = {
+    component: FoliageWindRigs;
+    rigs: FoliageWindRig[];
+    context: GPUSceneContext | null;
+    rig_ids: Int32Array | null;
+    written_weight: number;
+};
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { FoliageWindRigs } from "./animation/FoliageWindRigs.js";
+//# sourceMappingURL=FoliageWindSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageWindSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/FoliageWindSystem.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH;IA0BI;;;OAGG;IACH,uCAUC;IADG,8DAAkD;IAGtD,2CAYC;IAED,0BAUC;IAED;;;;OAIG;IACH,gBAJW,eAAe,cACf,WAAW,UACX,MAAM,QAkChB;IAED;;;;OAIG;IACH,mBAJW,eAAe,cACf,WAAW,UACX,MAAM,QA0BhB;IAED,eAoCC;;CA8CJ;;;8BAvPY,OAAO,+CAA+C,EAAE,eAAe;6BACvE,OAAO,0DAA0D,EAAE,cAAc;;eAKhF,eAAe;UACf,cAAc,EAAE;aAChB,eAAe,GAAC,IAAI;aACpB,UAAU,GAAC,IAAI;oBACf,MAAM;;uBAlBG,kBAAkB;4BACb,iCAAiC;gCAC7B,gCAAgC"}

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

@@ -22,11 +22,6 @@
  * @returns {boolean} whether the emitter differs from what it held before
  */
 export function apply_particle_effect(emitter: ParticleEmitter, effect: ParticleEffect): boolean;
-/**
- * @typedef {object} ParticleAtlasTexture
- * @property {number} references Number of entities using this URL.
- * @property {import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch|null} patch Null while loading or after failure.
- */
 /**
  * @typedef {object} ParticleEmitterEntry
  * @property {number} entity
@@ -38,7 +33,7 @@ export function apply_particle_effect(emitter: ParticleEmitter, effect: Particle
  * registered it, or after a device restart took that context away
  * @property {function():void} on_transform_changed
  * @property {string|null} url last observed {@link ParticleEffect#texture}
- * @property {ParticleAtlasTexture|null} texture shared image record, or null for an untextured effect
+ * @property {import("../graphics/texture/atlas/ManagedTextureAtlas.js").ManagedAtlasReference|null} texture shared image reference, or null for an untextured effect
  */
 /**
  * Draws the game's GPU particle effects: one emitter per entity carrying
@@ -78,8 +73,9 @@ export function apply_particle_effect(emitter: ParticleEmitter, effect: Particle
  * ## It owns the scene's sprite atlas
  *
  * Every {@link ParticleEffect#texture} is loaded through the supplied `AssetManager` and packed into
- * one {@link TextureAtlas} shared by the scene, one patch per distinct URL however many entities
- * name it, reference-counted so the last entity to let go is what unpacks it. A `FrameStart`
+ * one {@link SpriteAtlas} shared by the scene, one patch per distinct URL however many entities
+ * name it, reference-counted through {@link ManagedAtlas} so unreferenced sprites remain in the
+ * atlas graveyard and are only reaped when incoming sprites need the space. A `FrameStart`
  * extension publishes the pixels and every current patch region before the renderer records the
  * particle passes — every repack moves UVs that nothing else changed, so the regions are rewritten
  * whole rather than when a URL changes. Pending and failed images sample a transparent texel;
@@ -107,9 +103,9 @@ export class GPUParticleEmitterSystem extends System<any> {
     dependencies: (typeof Transform64 | typeof ParticleEffect)[];
     /**
      * CPU atlas, exposed for inspection. Owned by this system.
-     * @type {TextureAtlas}
+     * @type {SpriteAtlas}
      */
-    atlas: TextureAtlas;
+    atlas: SpriteAtlas;
     /**
      * The scene the emitters are put in. Received rather than created: meshes and lights come from
      * systems of their own, and all of them have to be writing into one scene for any of it to be
@@ -189,16 +185,6 @@ export class GPUParticleEmitterSystem extends System<any> {
     prepare(frame: import("../../shade/renderer/extension/FrameContext.js").FrameContext): void;
     #private;
 }
-export type ParticleAtlasTexture = {
-    /**
-     * Number of entities using this URL.
-     */
-    references: number;
-    /**
-     * Null while loading or after failure.
-     */
-    patch: import("../graphics/texture/atlas/AtlasPatch.js").AtlasPatch | null;
-};
 export type ParticleEmitterEntry = {
     entity: number;
     /**
@@ -224,13 +210,13 @@ export type ParticleEmitterEntry = {
      */
     url: string | null;
     /**
-     * shared image record, or null for an untextured effect
+     * shared image reference, or null for an untextured effect
      */
-    texture: ParticleAtlasTexture | null;
+    texture: import("../graphics/texture/atlas/ManagedTextureAtlas.js").ManagedAtlasReference | null;
 };
 import { ParticleEmitter } from "../../shade/renderer/particles/runtime/ParticleEmitter.js";
 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";
+import { SpriteAtlas } from "../graphics/texture/atlas/SpriteAtlas.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":"AAywBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAiFnB;AAn1BD;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IAoDI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAoB7D;IAzED,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,WAAW,CAEmC;IAqExD;;;;;;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,CAsB1B;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;;CAsTJ;;YAzuBa,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,OAAO,kDAAkD,EAAE,qBAAqB,GAAC,IAAI;;gCAnCnE,2DAA2D;+BAS5D,6CAA6C;uBAPrD,kBAAkB;4BAEb,iCAAiC;4BAOjC,0CAA0C"}