@woosh/meep-engine 3.68.0 → 3.69.0

package/src/engine/graphics/trail/TrailKnots.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A trail laid down whole by its author instead of by an entity's travel: a stroke, a helix. Each knot
+ * has a position, the frame its ring stands in, a thickness and the age it starts with. The knots never
+ * move; they only age, and fade by the trail's curve as they do.
+ *
+ * Plain data on the component: whatever draws the trail uploads it when the trail is linked, and again
+ * when {@link version} moves. Ages are seconds, as `Trail3D.maxAge` is.
+ */
+export class TrailKnots {
+    /**
+     * Moved by every write, so a consumer holding an upload can tell it is stale.
+     * @type {number}
+     */
+    version: number;
+    /**
+     * @returns {number} knots
+     */
+    get count(): number;
+    /**
+     * Resize to `count` knots. Knots kept keep their values; new ones are zero.
+     *
+     * @param {number} count at least 2, the two ends of one segment
+     */
+    setCount(count: number): void;
+    /**
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} nx ring frame's first axis, unit
+     * @param {number} ny
+     * @param {number} nz
+     * @param {number} bx second axis, unit, orthogonal to the first and to the tube's direction
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} thickness tube diameter
+     * @param {number} age seconds the knot is born having lived
+     */
+    setKnot(index: number, x: number, y: number, z: number, nx: number, ny: number, nz: number, bx: number, by: number, bz: number, thickness: number, age: number): void;
+    /**
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} index
+     */
+    getPosition(out: number[] | Float32Array | Float64Array, index: number): void;
+    /**
+     * @param {number[]|Float32Array|Float64Array} out `[nx, ny, nz, bx, by, bz]`
+     * @param {number} index
+     */
+    getFrame(out: number[] | Float32Array | Float64Array, index: number): void;
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getThickness(index: number): number;
+    /**
+     * @param {number} index
+     * @returns {number} seconds
+     */
+    getAge(index: number): number;
+    #private;
+}
+//# sourceMappingURL=TrailKnots.d.ts.map

package/src/engine/graphics/trail/TrailKnots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrailKnots.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/trail/TrailKnots.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH;IAWI;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAgBhB;IAED;;;;;;;;;;;;;OAaG;IACH,eAbW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,OACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,iBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,QAQhB;IAED;;;OAGG;IACH,cAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,QAQhB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAIlB;;CACJ"}

package/src/engine/graphics/trail/TrailKnots.js

@@ -0,0 +1,137 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Numbers per knot: position (3), normal (3), binormal (3), thickness, age.
+ * @type {number}
+ */
+const KNOT_STRIDE = 11;
+
+/**
+ * A trail laid down whole by its author instead of by an entity's travel: a stroke, a helix. Each knot
+ * has a position, the frame its ring stands in, a thickness and the age it starts with. The knots never
+ * move; they only age, and fade by the trail's curve as they do.
+ *
+ * Plain data on the component: whatever draws the trail uploads it when the trail is linked, and again
+ * when {@link version} moves. Ages are seconds, as `Trail3D.maxAge` is.
+ */
+export class TrailKnots {
+    /**
+     * @type {Float64Array}
+     */
+    #data = new Float64Array(0);
+
+    /**
+     * @type {number}
+     */
+    #count = 0;
+
+    /**
+     * Moved by every write, so a consumer holding an upload can tell it is stale.
+     * @type {number}
+     */
+    version = 0;
+
+    /**
+     * @returns {number} knots
+     */
+    get count() {
+        return this.#count;
+    }
+
+    /**
+     * Resize to `count` knots. Knots kept keep their values; new ones are zero.
+     *
+     * @param {number} count at least 2, the two ends of one segment
+     */
+    setCount(count) {
+        assert.isNonNegativeInteger(count, 'count');
+        assert.greaterThanOrEqual(count, 2, 'a trail needs at least two knots');
+
+        if (this.#data.length < count * KNOT_STRIDE) {
+            const data = new Float64Array(count * KNOT_STRIDE);
+
+            data.set(this.#data.subarray(0, this.#count * KNOT_STRIDE));
+
+            this.#data = data;
+        }
+
+        this.#count = count;
+        this.version++;
+    }
+
+    /**
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} nx ring frame's first axis, unit
+     * @param {number} ny
+     * @param {number} nz
+     * @param {number} bx second axis, unit, orthogonal to the first and to the tube's direction
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} thickness tube diameter
+     * @param {number} age seconds the knot is born having lived
+     */
+    setKnot(index, x, y, z, nx, ny, nz, bx, by, bz, thickness, age) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.#count, 'index');
+
+        const d = this.#data;
+        const at = index * KNOT_STRIDE;
+
+        d[at] = x;
+        d[at + 1] = y;
+        d[at + 2] = z;
+        d[at + 3] = nx;
+        d[at + 4] = ny;
+        d[at + 5] = nz;
+        d[at + 6] = bx;
+        d[at + 7] = by;
+        d[at + 8] = bz;
+        d[at + 9] = thickness;
+        d[at + 10] = age;
+
+        this.version++;
+    }
+
+    /**
+     * @param {number[]|Float32Array|Float64Array} out
+     * @param {number} index
+     */
+    getPosition(out, index) {
+        const at = index * KNOT_STRIDE;
+
+        out[0] = this.#data[at];
+        out[1] = this.#data[at + 1];
+        out[2] = this.#data[at + 2];
+    }
+
+    /**
+     * @param {number[]|Float32Array|Float64Array} out `[nx, ny, nz, bx, by, bz]`
+     * @param {number} index
+     */
+    getFrame(out, index) {
+        const at = index * KNOT_STRIDE + 3;
+
+        for (let i = 0; i < 6; i++) {
+            out[i] = this.#data[at + i];
+        }
+    }
+
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    getThickness(index) {
+        return this.#data[index * KNOT_STRIDE + 9];
+    }
+
+    /**
+     * @param {number} index
+     * @returns {number} seconds
+     */
+    getAge(index) {
+        return this.#data[index * KNOT_STRIDE + 10];
+    }
+}

package/src/engine/graphics/trail/tube/TubeXMaterialSpec.d.ts

@@ -1,5 +1,5 @@
 /**
- * Material configuration for a {@link TubeX}. Used as a cache key in
+ * Material configuration for a {@link Trail3D}'s tube. Used as a cache key in
  * {@link TubeXPlugin}, so any field that changes the compiled material (texture,
  * depth-write mode, lighting) participates in {@link equals}/{@link hash}.
  */

package/src/engine/graphics/trail/tube/TubeXMaterialSpec.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 
 /**
- * Material configuration for a {@link TubeX}. Used as a cache key in
+ * Material configuration for a {@link Trail3D}'s tube. Used as a cache key in
  * {@link TubeXPlugin}, so any field that changes the compiled material (texture,
  * depth-write mode, lighting) participates in {@link equals}/{@link hash}.
  */

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

@@ -0,0 +1,48 @@
+/**
+ * One system's hold on an entity's `transforms` row in a scene context, kept current as the entity
+ * moves: for a system whose GPU work reads where an entity is — a particle emitter, a trail's head.
+ *
+ * The listener on {@link TRANSFORM64_EVENT_CHANGE} stands from construction to {@link dispose}, whether
+ * or not a row is held, because an entity is linked before there is a scene context to hold a row in: a
+ * level loads before the device is up, and a device restart replaces the context under every entity.
+ * While a row is held in the context that is current, a move marks it, and the context's next build
+ * rewrites it from the transform. A Transform64 has no signals of its own; whoever writes it announces
+ * the change, and this wakes on that.
+ *
+ * {@link acquire} and {@link release} are the hold itself. A hold in a context that has since been
+ * replaced went with that context, so releasing it gives nothing back.
+ */
+export class EntityRowHold {
+    /**
+     * @param {import("../ecs/EntityComponentDataset.js").EntityComponentDataset} dataset
+     * @param {number} entity
+     * @param {function(): (import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null)} current
+     * the scene context the entity's scene renders through now
+     */
+    constructor(dataset: import("../ecs/EntityComponentDataset.js").EntityComponentDataset, entity: number, current: () => (import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext | null));
+    /**
+     * @returns {number}
+     */
+    get entity(): number;
+    /**
+     * @returns {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null} where the row
+     * is held, or null when it is not
+     */
+    get context(): import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
+    /**
+     * Hold the entity's row in `context`, letting go of any hold in another.
+     *
+     * @param {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} context
+     */
+    acquire(context: import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext): void;
+    /**
+     * Let go of the row, if one is held in the context that is current.
+     */
+    release(): void;
+    /**
+     * Release, and stop listening.
+     */
+    dispose(): void;
+    #private;
+}
+//# sourceMappingURL=EntityRowHold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EntityRowHold.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/EntityRowHold.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IAuBI;;;;;OAKG;IACH,qBALW,OAAO,kCAAkC,EAAE,sBAAsB,UACjE,MAAM,iBACM,CAAC,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI,CAAC,EAapG;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uFAEC;IAED;;;;OAIG;IACH,iBAFW,OAAO,+CAA+C,EAAE,eAAe,QAcjF;IAED;;OAEG;IACH,gBAYC;IAED;;OAEG;IACH,gBAIC;;CAWJ"}

package/src/engine/graphics3/EntityRowHold.js

@@ -0,0 +1,128 @@
+import { assert } from "../../core/assert.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
+
+/**
+ * One system's hold on an entity's `transforms` row in a scene context, kept current as the entity
+ * moves: for a system whose GPU work reads where an entity is — a particle emitter, a trail's head.
+ *
+ * The listener on {@link TRANSFORM64_EVENT_CHANGE} stands from construction to {@link dispose}, whether
+ * or not a row is held, because an entity is linked before there is a scene context to hold a row in: a
+ * level loads before the device is up, and a device restart replaces the context under every entity.
+ * While a row is held in the context that is current, a move marks it, and the context's next build
+ * rewrites it from the transform. A Transform64 has no signals of its own; whoever writes it announces
+ * the change, and this wakes on that.
+ *
+ * {@link acquire} and {@link release} are the hold itself. A hold in a context that has since been
+ * replaced went with that context, so releasing it gives nothing back.
+ */
+export class EntityRowHold {
+    /**
+     * @type {import("../ecs/EntityComponentDataset.js").EntityComponentDataset}
+     */
+    #dataset;
+
+    /**
+     * @type {number}
+     */
+    #entity;
+
+    /**
+     * Answers which scene context is current.
+     * @type {function(): (import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null)}
+     */
+    #current;
+
+    /**
+     * The context the row is held in, or null.
+     * @type {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null}
+     */
+    #context = null;
+
+    /**
+     * @param {import("../ecs/EntityComponentDataset.js").EntityComponentDataset} dataset
+     * @param {number} entity
+     * @param {function(): (import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null)} current
+     * the scene context the entity's scene renders through now
+     */
+    constructor(dataset, entity, current) {
+        assert.defined(dataset, 'dataset');
+        assert.isNonNegativeInteger(entity, 'entity');
+        assert.isFunction(current, 'current');
+
+        this.#dataset = dataset;
+        this.#entity = entity;
+        this.#current = current;
+
+        dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, this.#moved, this);
+    }
+
+    /**
+     * @returns {number}
+     */
+    get entity() {
+        return this.#entity;
+    }
+
+    /**
+     * @returns {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null} where the row
+     * is held, or null when it is not
+     */
+    get context() {
+        return this.#context;
+    }
+
+    /**
+     * Hold the entity's row in `context`, letting go of any hold in another.
+     *
+     * @param {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} context
+     */
+    acquire(context) {
+        assert.defined(context, 'context');
+
+        if (this.#context === context) {
+            return;
+        }
+
+        this.release();
+
+        context.rows.acquire(this.#entity);
+
+        this.#context = context;
+    }
+
+    /**
+     * Let go of the row, if one is held in the context that is current.
+     */
+    release() {
+        const context = this.#context;
+
+        if (context === null) {
+            return;
+        }
+
+        if (context === this.#current()) {
+            context.rows.release(this.#entity);
+        }
+
+        this.#context = null;
+    }
+
+    /**
+     * Release, and stop listening.
+     */
+    dispose() {
+        this.release();
+
+        this.#dataset.removeEntityEventListener(this.#entity, TRANSFORM64_EVENT_CHANGE, this.#moved, this);
+    }
+
+    #moved() {
+        const context = this.#context;
+
+        if (context === null || context !== this.#current()) {
+            return;
+        }
+
+        context.rows.mark_world(this.#entity);
+    }
+}

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

@@ -32,7 +32,7 @@ export function apply_particle_effect(emitter: ParticleEmitter, effect: Particle
  * @property {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null} context
  * the scene context the emitter is registered with, at the entity's row; null until a frame has
  * registered it, or after a device restart took that context away
- * @property {function():void} on_transform_changed
+ * @property {EntityRowHold} hold the entity's row, held in {@link context} while the emitter is registered
  * @property {string|null} url last observed {@link ParticleEffect#texture}
  * @property {import("../graphics/texture/atlas/ManagedTextureAtlas.js").ManagedAtlasReference|null} texture shared image reference, or null for an untextured effect
  * @property {Map<string, {entity: number, channel: number, live: boolean, on_removed: function|null, layout: import("../../shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null}>} bound
@@ -248,7 +248,10 @@ export type ParticleEmitterEntry = {
      * registered it, or after a device restart took that context away
      */
     context: import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext | null;
-    on_transform_changed: () => void;
+    /**
+     * the entity's row, held in {@link context } while the emitter is registered
+     */
+    hold: EntityRowHold;
     /**
      * last observed {@link ParticleEffecttexture }
      */
@@ -280,4 +283,5 @@ import { ParticleEffect } from "../graphics/ecs/particles/ParticleEffect.js";
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { SpriteAtlas } from "../graphics/texture/atlas/SpriteAtlas.js";
+import { EntityRowHold } from "./EntityRowHold.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":"AA6tCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAyGnB;AA1zCD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IA4FI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAoB7D;IAjHD,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,WAAW,CAEkC;IA6GvD;;;;;;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;IAED;;;;;;;;;;;;OAYG;IACH,uBAHW,MAAM,UACN,UAAU,MAAM,CAAC,QA8B3B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,MAAM,UACN,MAAM,WACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,0BAFW,MAAM,QAIhB;IA8PD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAuB1B;IA0ED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAuChB;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,CAgDhB;;CAoVJ;;YAvrCa,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;;;;;;;WACrF,IAAI,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,WAAS,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,yDAAyD,EAAE,cAAc,GAAC,IAAI,CAAA;KAAC,CAAC;;;;qBAKvL,OAAO,uDAAuD,EAAE,eAAe,GAAC,IAAI;;gCA/ClE,2DAA2D;+BAU5D,6CAA6C;uBARrD,kBAAkB;4BAEb,iCAAiC;4BAQjC,0CAA0C"}
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AA4rCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAyGnB;AAzxCD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IA4FI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAoB7D;IAjHD,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,WAAW,CAEkC;IA6GvD;;;;;;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;IAED;;;;;;;;;;;;OAYG;IACH,uBAHW,MAAM,UACN,UAAU,MAAM,CAAC,QA8B3B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,MAAM,UACN,MAAM,WACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,0BAFW,MAAM,QAIhB;IA8PD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAuB1B;IA0ED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QA6BhB;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,CAgDhB;;CA6TJ;;YAtpCa,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;;;;UAG5E,aAAa;;;;SACb,MAAM,GAAC,IAAI;;;;aACX,OAAO,kDAAkD,EAAE,qBAAqB,GAAC,IAAI;;;;;;;WACrF,IAAI,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,WAAS,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,yDAAyD,EAAE,cAAc,GAAC,IAAI,CAAA;KAAC,CAAC;;;;qBAKvL,OAAO,uDAAuD,EAAE,eAAe,GAAC,IAAI;;gCA/ClE,2DAA2D;+BAU5D,6CAA6C;uBARrD,kBAAkB;4BAGb,iCAAiC;4BAOjC,0CAA0C;8BATxC,oBAAoB"}

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -5,10 +5,10 @@ import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.
 import { ParticleEmitter } from "../../shade/renderer/particles/runtime/ParticleEmitter.js";
 import { GPUTextureContext } from "../../shade/renderer/texture/GPUTextureContext.js";
 import { System } from "../ecs/System.js";
+import { EntityRowHold } from "./EntityRowHold.js";
 import Name from "../ecs/name/Name.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { EventType } from "../ecs/EventType.js";
-import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 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";
@@ -41,7 +41,7 @@ const BURST_QUEUE_LIMIT = 256;
  * @property {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext|null} context
  * the scene context the emitter is registered with, at the entity's row; null until a frame has
  * registered it, or after a device restart took that context away
- * @property {function():void} on_transform_changed
+ * @property {EntityRowHold} hold the entity's row, held in {@link context} while the emitter is registered
  * @property {string|null} url last observed {@link ParticleEffect#texture}
  * @property {import("../graphics/texture/atlas/ManagedTextureAtlas.js").ManagedAtlasReference|null} texture shared image reference, or null for an untextured effect
  * @property {Map<string, {entity: number, channel: number, live: boolean, on_removed: function|null, layout: import("../../shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null}>} bound
@@ -744,7 +744,7 @@ export class GPUParticleEmitterSystem extends System {
             transform,
             emitter: null,
             context: null,
-            on_transform_changed: null,
+            hold: null,
             url: null,
             texture: null,
             bound: new Map(),
@@ -753,18 +753,8 @@ export class GPUParticleEmitterSystem extends System {
 
         this.#entries.set(entity, entry);
 
-        /*
-         The emitter is placed the moment its transform moves rather than on a poll. A Transform64
-         has no signals of its own, so the announcement comes from the dataset: whoever wrote the
-         transform sends TRANSFORM64_EVENT_CHANGE and this wakes on it. Coarser than watching
-         position, rotation and scale separately — a scale write wakes a placement that reads the
-         whole transform anyway — and that is the trade the type makes everywhere.
-        */
-        entry.on_transform_changed = () => this.#place(entry);
-
-        this.#dataset.addEntityEventListener(
-            entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
-        );
+        // The emitter is placed the moment its transform moves rather than on a poll: see EntityRowHold.
+        entry.hold = new EntityRowHold(this.#dataset, entity, () => this.#graphics.scene_context(this.#scene));
 
         // Everything else — building the emitter, acquiring the texture — is what a frame does
         // anyway, and doing it here as well would be a second copy of it that has to stay in step.
@@ -916,14 +906,12 @@ export class GPUParticleEmitterSystem extends System {
      * @param {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
      */
     #register(particles, scene_context) {
-        const rows = scene_context.rows;
-
         for (const entry of this.#entries.values()) {
             if (entry.emitter === null || entry.context === scene_context || entry.emitter.program === entry.refused_program) {
                 continue;
             }
 
-            rows.acquire(entry.entity);
+            entry.hold.acquire(scene_context);
 
             try {
                 particles.add_emitter(entry.emitter, row_of_entity(entry.entity));
@@ -931,7 +919,7 @@ export class GPUParticleEmitterSystem extends System {
                 // The program's global imports do not link against the scene's global fields. One
                 // effect must not stop every other one: it is reported, and not tried again until
                 // its program changes.
-                rows.release(entry.entity);
+                entry.hold.release();
                 entry.refused_program = entry.emitter.program;
                 warn_limited(`GPUParticleEmitterSystem: an effect was refused: ${e.message}`);
                 continue;
@@ -1073,21 +1061,6 @@ export class GPUParticleEmitterSystem extends System {
         }
     }
 
-    /**
-     * The entity moved: its row is rewritten from its transform by the context that holds it.
-     *
-     * @param {ParticleEmitterEntry} entry
-     */
-    #place(entry) {
-        const context = entry.context;
-
-        if (context === null || context !== this.#graphics.scene_context(this.#scene)) {
-            return;
-        }
-
-        context.rows.mark_world(entry.entity);
-    }
-
     /**
      * Retire an entity's emitter and let go of its row, leaving the entry linked.
      *
@@ -1111,14 +1084,15 @@ export class GPUParticleEmitterSystem extends System {
                 particles.remove_emitter(emitter);
             }
 
-            context.rows.release(entry.entity);
-
             // the registry dropped the bindings with the emitter; the rows they held go too
             for (const binding of entry.bound.values()) {
                 this.#let_go(context, binding);
             }
         }
 
+        // a hold in a context that has been replaced went with it, and releasing it gives nothing back
+        entry.hold.release();
+
         entry.context = null;
         this.#forget_bindings(entry);
 
@@ -1137,15 +1111,8 @@ export class GPUParticleEmitterSystem extends System {
             return;
         }
 
-        if (entry.on_transform_changed !== null) {
-            this.#dataset.removeEntityEventListener(
-                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
-            );
-
-            entry.on_transform_changed = null;
-        }
-
         this.#detach_emitter(entry);
+        entry.hold.dispose();
         entry.texture?.release();
 
         entry.url = null;