@woosh/meep-engine 3.23.0 → 3.24.0

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.d.ts

@@ -1,16 +1,15 @@
 /**
  * Outlines a highlighted model.
  *
- * **The rows come from `MeshSystem`, because a model's nodes are its.** An `SGMesh` is a file, and
- * what a file becomes in the scene is several nodes — instanced ones the mesh system holds, plus the
- * primitives of an expanded model, which are components on descendant entities. `traverse_meshes`
- * answers for both, so this system asks one question per highlight and does not care which kind of
- * model it got.
+ * **The rows come from `MeshSystem`, because a model's entities are its.** An `SGMesh` is a file, and
+ * what a file becomes in the scene is entities — descendants of the one that placed it, the ones
+ * that draw holding a mesh row each at `entity + 1`. `mesh_entities_of` names those, so this system
+ * asks one question per highlight and walks the answer.
  *
  * **What it no longer does is push the component downwards.** The system this replaces copied the
  * `Highlight` onto every entity the model expanded into, so that the system watching
  * `[Highlight, ShadedGeometry]` would find them — the walk existed because nothing else could see a
- * model whole. `MeshSystem.traverse_meshes` can, so the propagation buys nothing, and the
+ * model whole. `MeshSystem.mesh_entities_of` can, so the propagation buys nothing, and the
  * `SGMesh.__node` / `SGMeshEvents.AssetLoaded` pair it was driven by has had nothing writing to it
  * since `SGMeshSystem`. The name and the tuple are the same; the mechanism underneath is Shade's.
  *

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SGMeshHighlightSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAsBI;;;OAGG;IACH,iEAQC;IAjCD,mDAAmC;IAmCnC,2CAEC;IAED,4CAWC;IAED;;;;OAIG;IACH,gBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAYhB;;CACJ;uBA7GsB,2BAA2B;uBAE3B,aAAa;sBADd,8BAA8B"}
+{"version":3,"file":"SGMeshHighlightSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAsBI;;;OAGG;IACH,iEAQC;IAjCD,mDAAmC;IAmCnC,2CAEC;IAED,4CAWC;IAED;;;;OAIG;IACH,gBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAYhB;IAED;;;;OAIG;IACH,kBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAYhB;;CACJ;uBA/GsB,2BAA2B;uBAG3B,aAAa;sBAFd,8BAA8B"}

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js

@@ -1,21 +1,21 @@
 import { assert } from "../../../../../core/assert.js";
 import { System } from "../../../../ecs/System.js";
 import Highlight from "../../highlight/Highlight.js";
+import { row_of_entity } from "../../../../../shade/renderer/scene/rows/GPUSceneRows.js";
 import { SGMesh } from "./SGMesh.js";
 
 /**
  * Outlines a highlighted model.
  *
- * **The rows come from `MeshSystem`, because a model's nodes are its.** An `SGMesh` is a file, and
- * what a file becomes in the scene is several nodes — instanced ones the mesh system holds, plus the
- * primitives of an expanded model, which are components on descendant entities. `traverse_meshes`
- * answers for both, so this system asks one question per highlight and does not care which kind of
- * model it got.
+ * **The rows come from `MeshSystem`, because a model's entities are its.** An `SGMesh` is a file, and
+ * what a file becomes in the scene is entities — descendants of the one that placed it, the ones
+ * that draw holding a mesh row each at `entity + 1`. `mesh_entities_of` names those, so this system
+ * asks one question per highlight and walks the answer.
  *
  * **What it no longer does is push the component downwards.** The system this replaces copied the
  * `Highlight` onto every entity the model expanded into, so that the system watching
  * `[Highlight, ShadedGeometry]` would find them — the walk existed because nothing else could see a
- * model whole. `MeshSystem.traverse_meshes` can, so the propagation buys nothing, and the
+ * model whole. `MeshSystem.mesh_entities_of` can, so the propagation buys nothing, and the
  * `SGMesh.__node` / `SGMeshEvents.AssetLoaded` pair it was driven by has had nothing writing to it
  * since `SGMeshSystem`. The name and the tuple are the same; the mechanism underneath is Shade's.
  *
@@ -83,11 +83,13 @@ export class SGMeshHighlightSystem extends System {
      * @param {number} entity
      */
     link(highlight, mesh, entity) {
-        const entry = this.#outline.add_entry(
-            entity,
-            highlight,
-            visitor => this.#meshes.traverse_meshes(entity, visitor)
-        );
+        const entry = this.#outline.add_entry(entity, highlight, visitor => {
+            const primitives = this.#meshes.mesh_entities_of(entity);
+
+            for (let i = 0; i < primitives.length; i++) {
+                visitor(row_of_entity(primitives[i]));
+            }
+        });
 
         this.#entries.set(entity, entry);
     }

package/src/engine/graphics/ecs/mesh-v2/shaded_geometry_announce_change.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Say that an entity's {@link ShadedGeometry} was changed in place, so the row it holds is
+ * rewritten from it.
+ *
+ * ```js
+ * geometry.material = faded;
+ * shaded_geometry_announce_change(dataset, entity);
+ * ```
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ */
+export function shaded_geometry_announce_change(dataset: EntityComponentDataset, entity: number): void;
+//# sourceMappingURL=shaded_geometry_announce_change.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/shaded_geometry_announce_change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaded_geometry_announce_change.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/shaded_geometry_announce_change.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,yFAFW,MAAM,QAOhB"}

package/src/engine/graphics/ecs/mesh-v2/shaded_geometry_announce_change.js

@@ -0,0 +1,21 @@
+import { assert } from "../../../../core/assert.js";
+import { SHADED_GEOMETRY_EVENT_CHANGE } from "./SHADED_GEOMETRY_EVENT_CHANGE.js";
+
+/**
+ * Say that an entity's {@link ShadedGeometry} was changed in place, so the row it holds is
+ * rewritten from it.
+ *
+ * ```js
+ * geometry.material = faded;
+ * shaded_geometry_announce_change(dataset, entity);
+ * ```
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ */
+export function shaded_geometry_announce_change(dataset, entity) {
+    assert.defined(dataset, 'dataset');
+    assert.isNonNegativeInteger(entity, 'entity');
+
+    dataset.sendEvent(entity, SHADED_GEOMETRY_EVENT_CHANGE);
+}

package/src/engine/graphics/ecs/particles/ParticleEffect.d.ts

@@ -24,7 +24,7 @@
  * the flipbook grid. That is deliberate, and it is what makes the component the unit an editor
  * inspects, a prefab carries and a system diffs.
  *
- * What is **not** here: the scene node the system built, the emitter's row in the GPU emitter table,
+ * What is **not** here: the emitter the system built, the emitter's row in the GPU emitter table,
  * the generation of that row, where the program was placed in the program heap, and where the
  * texture landed in the atlas. All of that belongs to whoever registered the emitter — see
  * {@link ../../../../shade/renderer/particles/runtime/GPUParticleEmitterContext.js} — and none of it

package/src/engine/graphics/ecs/particles/ParticleEffect.js

@@ -39,7 +39,7 @@ import { EMITTER_RENDER_CHANNELS } from "../../../../shade/renderer/particles/ru
  * the flipbook grid. That is deliberate, and it is what makes the component the unit an editor
  * inspects, a prefab carries and a system diffs.
  *
- * What is **not** here: the scene node the system built, the emitter's row in the GPU emitter table,
+ * What is **not** here: the emitter the system built, the emitter's row in the GPU emitter table,
  * the generation of that row, where the program was placed in the program heap, and where the
  * texture landed in the atlas. All of that belongs to whoever registered the emitter — see
  * {@link ../../../../shade/renderer/particles/runtime/GPUParticleEmitterContext.js} — and none of it

package/src/engine/graphics/sh3/path_tracer/populate_path_traced_scene_from_ecd.d.ts

@@ -2,7 +2,7 @@
  * Fill a traced scene from the entities of a dataset.
  *
  * **Two pieces are missing for this to work under Shade, and both are features rather than
- * omissions** (D62). A `ShadedGeometry` placed by `shade_node_to_entity_composition` holds a
+ * omissions** (D62). A `ShadedGeometry` a prefab spawned holds a
  * `MeshletGeometry`, whose triangles are quantized inside meshlet pages —
  * `geometry_build_from_meshlet_geometry` decodes one into the `Geometry` `createMesh` wants, and
  * who holds that decode is undecided. And it holds a `ShadeMaterial`, where the tracer integrates

package/src/engine/graphics/sh3/path_tracer/populate_path_traced_scene_from_ecd.js

@@ -10,7 +10,7 @@ import { PointLight } from "../../render/forward_plus/model/PointLight.js";
  * Fill a traced scene from the entities of a dataset.
  *
  * **Two pieces are missing for this to work under Shade, and both are features rather than
- * omissions** (D62). A `ShadedGeometry` placed by `shade_node_to_entity_composition` holds a
+ * omissions** (D62). A `ShadedGeometry` a prefab spawned holds a
  * `MeshletGeometry`, whose triangles are quantized inside meshlet pages —
  * `geometry_build_from_meshlet_geometry` decodes one into the `Geometry` `createMesh` wants, and
  * who holds that decode is undecided. And it holds a `ShadeMaterial`, where the tracer integrates

package/src/engine/graphics3/AnimationGraphSystem.js

@@ -39,7 +39,7 @@ export class AnimationGraphSystem extends System {
     #meshes;
 
     /**
-     * @type {Map<number, {controller: AnimationGraphController, instance: SceneBundleInstance|null, clip_registration: InstanceClipRegistration|null, slots: Int32Array, played_slots: Int32Array, clip_ids: Int32Array, weights: Float32Array, poses: PosePlayback[]}>}
+     * @type {Map<number, {controller: AnimationGraphController, instance: PrefabInstance|null, clip_registration: InstanceClipRegistration|null, slots: Int32Array, played_slots: Int32Array, clip_ids: Int32Array, weights: Float32Array, poses: PosePlayback[]}>}
      */
     #entries = new Map();
 
@@ -245,7 +245,7 @@ export class AnimationGraphSystem extends System {
      *
      * @param {object} entry
      * @param {number} entity
-     * @param {SceneBundleInstance} instance
+     * @param {PrefabInstance} instance
      * @param {EntityComponentDataset} ecd
      */
     #bind_model(entry, entity, instance, ecd) {
@@ -308,7 +308,7 @@ export class AnimationGraphSystem extends System {
      * resolves its joints to zero rather than to the model's own pose.
      *
      * @param {object} entry
-     * @param {SceneBundleInstance} instance
+     * @param {PrefabInstance} instance
      * @param {GPUSceneContext} context
      */
     #bind_gpu(entry, instance, context) {

package/src/engine/graphics3/AnimationSystem.js

@@ -49,7 +49,7 @@ export class AnimationSystem extends System {
     #meshes;
 
     /**
-     * @type {Map<number, {player: ClipListPlayer, instance: SceneBundleInstance|null, clip_registration: InstanceClipRegistration|null, played_slots: Int32Array, written: Float32Array, poses: PosePlayback[]}>}
+     * @type {Map<number, {player: ClipListPlayer, instance: PrefabInstance|null, clip_registration: InstanceClipRegistration|null, played_slots: Int32Array, written: Float32Array, poses: PosePlayback[]}>}
      */
     #entries = new Map();
 
@@ -281,7 +281,7 @@ export class AnimationSystem extends System {
      * the joints only it drives down to zero with it.
      *
      * @param {object} entry
-     * @param {SceneBundleInstance} instance
+     * @param {PrefabInstance} instance
      * @param {GPUSceneContext} context
      * @param {boolean} set_changed whether {@link #refresh_played_slots} just moved
      * @returns {boolean} whether the registration was replaced

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

@@ -1 +1 @@
-{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAcC;IAlFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAqBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCAwBC;;CACJ;AAED;;;;GAIG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAdD,oCAA4B;IAgB5B,yBAEC;;CACJ;uBAlMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD;kCAFjD,qBAAqB"}
+{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAYC;IAhFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAmBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCAwBC;;CACJ;AAED;;;;GAIG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAdD,oCAA4B;IAgB5B,yBAEC;;CACJ;uBAhMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD;kCAFjD,qBAAqB"}

package/src/engine/graphics3/DebugDrawSystem.js

@@ -112,10 +112,8 @@ export class DebugDrawSystem extends System {
 
         this.#graphics = graphics;
 
-        // vertices are written in world space, so what the draw applies is identity — but a node's
-        // world transform is derived and stays unset until it is asked for
-        this.#mesh.updateMatrices();
-
+        // vertices are written in world space, and what the draw applies is the mesh's own
+        // transform, identity until moved
         this.#batch.add(this.#mesh);
 
         this.#clear = () => Gizmo.clear();

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

@@ -1,5 +1,5 @@
 /**
- * Copy a component onto the scene node built for it, reporting whether anything actually moved.
+ * Copy a component onto the emitter built for it, reporting whether anything actually moved.
  *
  * Comparing while assigning rather than in a pass of its own is what makes change detection cost
  * nothing extra: the fields have to be read to be written, and the only addition is an `||` per
@@ -11,11 +11,11 @@
  * to. Layout and program are shared by reference, never copied — two entities of one effect belong
  * on one program id in the heap.
  *
- * @param {ParticleEmitter} node
+ * @param {ParticleEmitter} emitter
  * @param {ParticleEffect} effect
- * @returns {boolean} whether the node differs from what it held before
+ * @returns {boolean} whether the emitter differs from what it held before
  */
-export function apply_particle_effect(node: ParticleEmitter, effect: ParticleEffect): boolean;
+export function apply_particle_effect(emitter: ParticleEmitter, effect: ParticleEffect): boolean;
 /**
  * @typedef {object} ParticleAtlasTexture
  * @property {number} references Number of entities using this URL.
@@ -26,7 +26,10 @@ export function apply_particle_effect(node: ParticleEmitter, effect: ParticleEff
  * @property {number} entity
  * @property {ParticleEffect} effect the entity's component — what to emit
  * @property {Transform64} transform the entity's transform — where to emit it
- * @property {ParticleEmitter|null} node the scene node, once the effect has a program to run
+ * @property {ParticleEmitter|null} emitter the emitter, once the effect has a program to run
+ * @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 {string|null} url last observed {@link ParticleEffect#texture}
  * @property {ParticleAtlasTexture|null} texture shared image record, or null for an untextured effect
@@ -53,14 +56,14 @@ export function apply_particle_effect(node: ParticleEmitter, effect: ParticleEff
  *
  * ## What this system does with the pair
  *
- * It builds a {@link ParticleEmitter} scene node per entity and owns it: the node is added to
- * {@link scene} when the component has a compiled effect, follows the entity's transform, carries
- * whatever the component currently says, and leaves the scene when the entity does. The node is not
- * hidden — {@link node_of} hands it out — but it is not the interface either: write to the
- * component and the next frame carries it.
+ * It builds a {@link ParticleEmitter} per entity and owns it: the emitter is registered with the
+ * scene's particle system at the entity's row when the component has a compiled effect, so it
+ * stands where the entity stands, carries whatever the component currently says, and is retired
+ * when the entity goes. The emitter is not hidden — {@link emitter_of} hands it out — but it is
+ * not the interface either: write to the component and the next frame carries it.
  *
  * Changes are found by **comparison** rather than announced. Once a frame each entity's
- * fields are compared against what was last written to its node, and the node is marked dirty only
+ * fields are compared against what was last written to its emitter, and the emitter is marked dirty only
  * where they differ; `EmitterRegistry` then restages exactly the rows that moved. A component nobody
  * touched costs a run of integer comparisons and no upload, so there is no change signal to fire and
  * none to forget. What that buys is that gameplay can write `effect.spawn_rate = 0` anywhere,
@@ -76,9 +79,9 @@ export function apply_particle_effect(node: ParticleEmitter, effect: ParticleEff
  * whole rather than when a URL changes. Pending and failed images sample a transparent texel;
  * effects with no image sample a white one.
  *
- * An emitter node in this scene that this system did not build — one added to the `Scene` directly —
- * gets the white texel. The atlas is the scene's and that emitter has nothing in it, so the
- * alternative is not "its own texture" but a UV rectangle from somebody else's image.
+ * An emitter in this scene that this system did not build — one registered with the particle
+ * system directly — gets the white texel. The atlas is the scene's and that emitter has nothing in
+ * it, so the alternative is not "its own texture" but a UV rectangle from somebody else's image.
  *
  * ## What it is not
  *
@@ -113,25 +116,24 @@ export class GPUParticleEmitterSystem extends System<any> {
      */
     get scene(): import("../../shade/renderer/scene/Scene.js").Scene;
     /**
-     * The emitter nodes this system currently has in the scene, in no particular order. Read-only —
-     * they follow the entities.
+     * The emitters this system currently holds, in no particular order. Read-only — they follow
+     * the entities.
      *
      * @returns {ParticleEmitter[]}
      */
     get emitters(): ParticleEmitter[];
     /**
-     * The scene node built for an entity.
+     * The emitter built for an entity.
      *
-     * Handed out for the things an entity reference cannot express — parenting something to the
-     * emitter, reading the world matrix the hierarchy pass composed — and for nothing routine: the
-     * component is how an effect is changed, and a node written to behind the component's back is
-     * overwritten by the next comparison.
+     * Handed out for what an entity reference cannot express — asking the particle system about
+     * it — and for nothing routine: the component is how an effect is changed, and an emitter
+     * written to behind the component's back is overwritten by the next comparison.
      *
      * @param {number} entity
      * @returns {ParticleEmitter|null} `null` for an entity this system has not linked, or one whose
      * component has no compiled effect yet
      */
-    node_of(entity: number): ParticleEmitter | null;
+    emitter_of(entity: number): ParticleEmitter | null;
     /**
      * Ask an entity's emitter for `count` particles on top of its rate, on the next frame.
      *
@@ -160,9 +162,9 @@ export class GPUParticleEmitterSystem extends System<any> {
      */
     unlink(effect: ParticleEffect, transform: Transform64, entity: number): void;
     /**
-     * Bring every emitter in line with its entity: build nodes for effects that have arrived, retire
-     * nodes for effects that have gone, copy changed fields onto the ones that stay, and follow the
-     * texture URLs.
+     * Bring every emitter in line with its entity: build emitters for effects that have arrived,
+     * retire emitters for effects that have gone, copy changed fields onto the ones that stay, and
+     * follow the texture URLs.
      *
      * @param {number} [time_delta_seconds]
      * @returns {void}
@@ -205,9 +207,14 @@ export type ParticleEmitterEntry = {
      */
     transform: Transform64;
     /**
-     * the scene node, once the effect has a program to run
+     * the emitter, once the effect has a program to run
      */
-    node: ParticleEmitter | null;
+    emitter: ParticleEmitter | null;
+    /**
+     * 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
+     */
+    context: import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext | null;
     on_transform_changed: () => void;
     /**
      * last observed {@link ParticleEffecttexture }

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":"AAqtBA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CA4BnB;AAvuBD;;;;GAIG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;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;;;;;;;;;;;OAWG;IACH,gBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IAkBD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CAyB1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAgChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CAqChB;;CA0TJ;;;;;gBAxrBa,MAAM;;;;WACN,OAAO,yCAAyC,EAAE,UAAU,GAAC,IAAI;;;YAKjE,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;UACX,eAAe,GAAC,IAAI;gCACT,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,oBAAoB,GAAC,IAAI;;gCAnCP,2DAA2D;+BAQ5D,6CAA6C;uBANrD,kBAAkB;4BAEb,iCAAiC;6BAKhC,2CAA2C"}
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAyzBA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CA4BnB;AA10BD;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;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;;;;;gBA3xBa,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"}