@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -1,22 +1,25 @@
 /**
- * Puts one primitive into Shade's scene, and keeps it where the entity says.
+ * Gives one primitive its rows in the scene database, and keeps them where the entity says.
  *
  * **The component and the row are the same shape, which is the whole reason this system is short.**
  * `ShadedGeometry` is a geometry, a material and a flat transform — *"not a hierarchical data
- * structure"*, in its own docblock — and Shade's `Mesh` is a `Node3D` carrying a `MeshletGeometry`
- * and a `ShadeMaterial`. §4.3 asks for exactly that mapping, 1:1, and there is nothing else to do.
+ * structure"*, in its own docblock — and a `meshes` row is a geometry, a material and the
+ * `transforms` row it draws under. The entity is both rows, at `entity + 1`: the system
+ * `attach_mesh`es it and marks it when the entity moves, and the scene database's flush writes what
+ * the CPU owns.
  *
  * **What it is not is a model.** A model file is many primitives arranged in a hierarchy, and in an
- * ECS a hierarchy is entities — one per node, parented through `EntityNode`, each carrying its own
- * `ShadedGeometry` where it draws (D47). `SGMesh` is the layer that expands a loaded file into
- * those entities; this system never sees the file, only the primitives that came out of it, and
- * cannot tell them from primitives some tool built by hand.
+ * ECS a hierarchy is entities — one per node, attached to their parents, each carrying its own
+ * `ShadedGeometry` where it draws. `MeshSystem` is the layer that spawns a loaded file as those
+ * entities (a prefab); this system never sees the file, only the primitives that came out of it,
+ * and cannot tell them from primitives some tool built by hand. A primitive a skin deforms says so
+ * on its component ({@link ShadedGeometryFlags.Skinned}) and draws a per-instance clone the
+ * skinning pass writes; the skin itself is the model's business.
  *
- * **The payload is the renderer's own.** Under three the same component holds a `BufferGeometry`
- * and a three `Material`, and `ShadedGeometrySystem` reads those; here it holds Shade's pair. One
- * renderer runs at a time and each system reads what its own renderer draws — the same bargain the
- * v1 component made with `Mesh.mesh`, and not a neutral geometry format, which would be a redesign
- * rather than a transition.
+ * **Rows need a device.** A primitive linked before the renderer has started, or after it has been
+ * replaced, waits: {@link update} notices the scene's GPU context arriving or changing and attaches
+ * everything it holds to it. Nothing about the entity is lost meanwhile — the component and the
+ * transform are the truth, and the rows are written from them.
  */
 export class ShadedGeometrySystem extends System<any> {
     /**
@@ -25,6 +28,10 @@ export class ShadedGeometrySystem extends System<any> {
      */
     constructor(graphics: GraphicsEngine, scene: Scene);
     dependencies: (typeof Transform64 | typeof ShadedGeometry)[];
+    /**
+     * @returns {Scene}
+     */
+    get scene(): import("../../shade/renderer/scene/Scene.js").Scene;
     startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     /**
@@ -41,6 +48,9 @@ export class ShadedGeometrySystem extends System<any> {
     unlink(geometry: ShadedGeometry, transform: Transform64, entity: number): void;
     #private;
 }
+export type GPUSceneContext = import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
+export type GraphicsEngine = import("./GraphicsEngine.js").GraphicsEngine;
+export type Scene = import("../../shade/renderer/scene/Scene.js").Scene;
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";

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

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,6DAAiD;IAGrD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QA0ChB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAMhB;;CA4CJ;uBAzKsB,kBAAkB;4BACb,iCAAiC;+BAC9B,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAgCI;;;OAGG;IACH,sBAHW,cAAc,SACd,KAAK,EAYf;IADG,6DAAiD;IAGrD;;OAEG;IACH,iEAEC;IAED,2CAaC;IAED,4CAOC;IAuCD;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAqDhB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAOhB;;CAqDJ;8BA1SY,OAAO,+CAA+C,EAAE,eAAe;6BACvE,OAAO,qBAAqB,EAAE,cAAc;oBAC5C,OAAO,qCAAqC,EAAE,KAAK;uBAXzC,kBAAkB;4BACb,iCAAiC;+BAI9B,2CAA2C"}

package/src/engine/graphics3/ShadedGeometrySystem.js

@@ -1,174 +1,309 @@
-import { assert } from "../../core/assert.js";
-import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
-import { Mesh } from "../../shade/renderer/scene/Mesh.js";
-import Name from "../ecs/name/Name.js";
-import { System } from "../ecs/System.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
-import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
-
-/**
- * Puts one primitive into Shade's scene, and keeps it where the entity says.
- *
- * **The component and the row are the same shape, which is the whole reason this system is short.**
- * `ShadedGeometry` is a geometry, a material and a flat transform — *"not a hierarchical data
- * structure"*, in its own docblock — and Shade's `Mesh` is a `Node3D` carrying a `MeshletGeometry`
- * and a `ShadeMaterial`. §4.3 asks for exactly that mapping, 1:1, and there is nothing else to do.
- *
- * **What it is not is a model.** A model file is many primitives arranged in a hierarchy, and in an
- * ECS a hierarchy is entities — one per node, parented through `EntityNode`, each carrying its own
- * `ShadedGeometry` where it draws (D47). `SGMesh` is the layer that expands a loaded file into
- * those entities; this system never sees the file, only the primitives that came out of it, and
- * cannot tell them from primitives some tool built by hand.
- *
- * **The payload is the renderer's own.** Under three the same component holds a `BufferGeometry`
- * and a three `Material`, and `ShadedGeometrySystem` reads those; here it holds Shade's pair. One
- * renderer runs at a time and each system reads what its own renderer draws — the same bargain the
- * v1 component made with `Mesh.mesh`, and not a neutral geometry format, which would be a redesign
- * rather than a transition.
- */
-export class ShadedGeometrySystem extends System {
-    /**
-     * @type {GraphicsEngine}
-     */
-    #graphics;
-
-    /**
-     * @type {Scene}
-     */
-    #scene;
-
-    /**
-     * What each entity put in the scene, and what is listening on its behalf.
-     *
-     * @type {Map<number, {node: Mesh, bindings: SignalBinding[]}>}
-     */
-    #entries = new Map();
-
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {Scene} scene
-     */
-    constructor(graphics, scene) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-        assert.defined(scene, 'scene');
-
-        this.#graphics = graphics;
-        this.#scene = scene;
-
-        this.dependencies = [ShadedGeometry, Transform64];
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-    }
-
-    async shutdown(entityManager) {
-        for (const entity of Array.from(this.#entries.keys())) {
-            this.#drop(entity);
-        }
-    }
-
-    /**
-     * @param {ShadedGeometry} geometry
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    link(geometry, transform, entity) {
-        const node = new Mesh();
-
-        node.geometry = geometry.geometry;
-        node.material = geometry.material;
-
-        /*
-         The row takes the entity's name when it has one. Nothing draws differently for it — what it
-         buys is that a walk over what is in the scene still answers with the names the model file
-         gave its nodes, which is what `MeshSystem.traverse_meshes` has always yielded and what
-         makes a scene readable in a debugger.
-        */
-        const name = this.entityManager.dataset.getComponent(entity, Name);
-
-        if (name !== undefined && name !== null) {
-            node.name = name.getValue();
-        }
-
-        const bindings = [];
-
-        // placed when the transform moves rather than on a poll, which is the bargain `MeshSystem`
-        // makes for the same reason: an entity that has not moved costs nothing downstream either
-        const place = () => this.#place(entity, transform);
-
-        // One dataset listener replaces the three sub-object signals a Transform used to carry.
-        // Coarser - it wakes on any change to the transform rather than on a named channel - and
-        // that is the trade: the placement reads the whole transform anyway.
-        this.entityManager.dataset.addEntityEventListener(
-            entity, TRANSFORM64_EVENT_CHANGE, place
-        );
-
-        this.#entries.set(entity, { node, bindings, on_transform_changed: place });
-
-        // the component carries its own row, so anything holding the component can ask where the
-        // primitive ended up without going through this system
-        geometry.node = node;
-
-        this.#scene.add(node);
-
-        this.#place(entity, transform);
-    }
-
-    /**
-     * @param {ShadedGeometry} geometry
-     * @param {Transform64} transform
-     * @param {number} entity
-     */
-    unlink(geometry, transform, entity) {
-        geometry.node = null;
-
-        this.#drop(entity);
-    }
-
-    /**
-     * @param {number} entity
-     * @param {Transform64} transform
-     */
-    #place(entity, transform) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        entry.node.transform_local.copy(transform);
-
-        // recomputes `transform_global` and bumps the version the scene database reads to decide
-        // what to upload
-        entry.node.updateMatrices();
-    }
-
-    /**
-     * @param {number} entity
-     */
-    #drop(entity) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        for (const binding of entry.bindings) {
-            binding.unlink();
-        }
-
-        if (entry.on_transform_changed !== undefined) {
-            this.entityManager.dataset.removeEntityEventListener(
-                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
-            );
-        }
-
-        this.#scene.remove(entry.node);
-
-        this.#entries.delete(entity);
-    }
-}
+import { assert } from "../../core/assert.js";
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
+import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
+import { SHADED_GEOMETRY_EVENT_CHANGE } from "../graphics/ecs/mesh-v2/SHADED_GEOMETRY_EVENT_CHANGE.js";
+import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
+
+/**
+ * @typedef {import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ * @typedef {import("./GraphicsEngine.js").GraphicsEngine} GraphicsEngine
+ * @typedef {import("../../shade/renderer/scene/Scene.js").Scene} Scene
+ */
+
+/**
+ * One primitive's place in the scene database, and what is listening on its behalf.
+ */
+class Entry {
+    /**
+     * @type {number}
+     */
+    entity = -1;
+
+    /**
+     * @type {ShadedGeometry}
+     */
+    geometry = null;
+
+    /**
+     * The GPU context the entity's rows are held in, or null while there is no device — before
+     * the first start, and again after a stop.
+     *
+     * @type {GPUSceneContext|null}
+     */
+    context = null;
+
+    /**
+     * @type {function(): void}
+     */
+    on_world_changed = null;
+
+    /**
+     * @type {function(): void}
+     */
+    on_local_changed = null;
+}
+
+/**
+ * Gives one primitive its rows in the scene database, and keeps them where the entity says.
+ *
+ * **The component and the row are the same shape, which is the whole reason this system is short.**
+ * `ShadedGeometry` is a geometry, a material and a flat transform — *"not a hierarchical data
+ * structure"*, in its own docblock — and a `meshes` row is a geometry, a material and the
+ * `transforms` row it draws under. The entity is both rows, at `entity + 1`: the system
+ * `attach_mesh`es it and marks it when the entity moves, and the scene database's flush writes what
+ * the CPU owns.
+ *
+ * **What it is not is a model.** A model file is many primitives arranged in a hierarchy, and in an
+ * ECS a hierarchy is entities — one per node, attached to their parents, each carrying its own
+ * `ShadedGeometry` where it draws. `MeshSystem` is the layer that spawns a loaded file as those
+ * entities (a prefab); this system never sees the file, only the primitives that came out of it,
+ * and cannot tell them from primitives some tool built by hand. A primitive a skin deforms says so
+ * on its component ({@link ShadedGeometryFlags.Skinned}) and draws a per-instance clone the
+ * skinning pass writes; the skin itself is the model's business.
+ *
+ * **Rows need a device.** A primitive linked before the renderer has started, or after it has been
+ * replaced, waits: {@link update} notices the scene's GPU context arriving or changing and attaches
+ * everything it holds to it. Nothing about the entity is lost meanwhile — the component and the
+ * transform are the truth, and the rows are written from them.
+ */
+export class ShadedGeometrySystem extends System {
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {Scene}
+     */
+    #scene;
+
+    /**
+     * @type {Map<number, Entry>}
+     */
+    #entries = new Map();
+
+    /**
+     * Shade's GPU state for {@link scene}, as of the last {@link update}. A change means every
+     * row this system held is void and every primitive is attached again.
+     *
+     * @type {GPUSceneContext|null}
+     */
+    #context = null;
+
+    /**
+     * Entries not yet attached to {@link #context} — linked while there was no device, or since a
+     * restart. A queue rather than a scan, because the answer is almost always "nothing to do".
+     *
+     * @type {Entry[]}
+     */
+    #unattached = [];
+
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics, scene) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+        assert.defined(scene, 'scene');
+
+        this.#graphics = graphics;
+        this.#scene = scene;
+
+        this.dependencies = [ShadedGeometry, Transform64];
+    }
+
+    /**
+     * @returns {Scene}
+     */
+    get scene() {
+        return this.#scene;
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        // the scene's rows are this dataset's entities; the first system to place one says so
+        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;
+    }
+
+    async shutdown(entityManager) {
+        for (const entity of Array.from(this.#entries.keys())) {
+            this.#drop(entity);
+        }
+
+        this.#context = null;
+        this.#unattached.length = 0;
+    }
+
+    /**
+     * Attach what arrived since the last frame, and everything again after a renderer restart.
+     *
+     * @param {number} time_delta_seconds
+     */
+    update(time_delta_seconds) {
+        const context = this.#graphics.scene_context(this.#scene);
+
+        if (context === null) {
+            // No device — before the first start, or after a stop. Nothing holds rows while this
+            // holds, and the next context to arrive is a change like any other.
+            return;
+        }
+
+        if (context !== this.#context) {
+            this.#context = context;
+
+            const waiting = this.#unattached;
+
+            waiting.length = 0;
+
+            for (const entry of this.#entries.values()) {
+                entry.context = null;
+
+                waiting.push(entry);
+            }
+        }
+
+        const waiting = this.#unattached;
+
+        for (let i = 0; i < waiting.length; i++) {
+            this.#attach(waiting[i], context);
+        }
+
+        waiting.length = 0;
+    }
+
+    /**
+     * @param {ShadedGeometry} geometry
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    link(geometry, transform, entity) {
+        // the component's own bounds query reads the transform through this
+        geometry.__c_transform = transform;
+        geometry.__entity = entity;
+
+        const entry = new Entry();
+
+        entry.entity = entity;
+        entry.geometry = geometry;
+
+        // Marked when the entity moves rather than placed on a poll: an entity that has not moved
+        // costs nothing, which is the same bargain the scene database makes downstream. A
+        // Transform64 has no signals of its own, so the announcement comes from the dataset. The
+        // world event says the entity's pose moved; the attachment event says its offset from its
+        // parent did — which is what its row holds when the parent has a row of its own.
+        entry.on_world_changed = () => {
+            if (entry.context !== null) {
+                entry.context.rows.mark_world(entity);
+            }
+        };
+
+        entry.on_local_changed = () => {
+            if (entry.context !== null) {
+                entry.context.rows.mark_local(entity);
+            }
+        };
+
+        // The component changed in place — a material swapped, most often — and the row is
+        // rewritten from it. Same geometry, same clone: a skinned primitive fading out keeps the
+        // vertex region the skinning pass is deforming.
+        entry.on_changed = () => {
+            if (entry.context !== null) {
+                this.#attach(entry, entry.context);
+            }
+        };
+
+        const dataset = this.entityManager.dataset;
+
+        dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, entry.on_world_changed);
+        dataset.addEntityEventListener(entity, TRANSFORM_ATTACHMENT_EVENT_CHANGE, entry.on_local_changed);
+        dataset.addEntityEventListener(entity, SHADED_GEOMETRY_EVENT_CHANGE, entry.on_changed);
+
+        this.#entries.set(entity, entry);
+
+        const context = this.#context;
+
+        if (context !== null && context === this.#graphics.scene_context(this.#scene)) {
+            this.#attach(entry, context);
+        } else {
+            this.#unattached.push(entry);
+        }
+    }
+
+    /**
+     * @param {ShadedGeometry} geometry
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    unlink(geometry, transform, entity) {
+        geometry.__c_transform = null;
+        geometry.__entity = -1;
+
+        this.#drop(entity);
+    }
+
+    /**
+     * Give the primitive its rows in a context.
+     *
+     * @param {Entry} entry
+     * @param {GPUSceneContext} context
+     */
+    #attach(entry, context) {
+        const geometry = entry.geometry;
+
+        context.rows.attach_mesh(
+            entry.entity,
+            geometry.geometry,
+            geometry.material,
+            geometry.getFlag(ShadedGeometryFlags.Skinned)
+        );
+
+        entry.context = context;
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #drop(entity) {
+        const entry = this.#entries.get(entity);
+
+        if (entry === undefined) {
+            return;
+        }
+
+        this.#entries.delete(entity);
+
+        const dataset = this.entityManager.dataset;
+
+        dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, entry.on_world_changed);
+        dataset.removeEntityEventListener(entity, TRANSFORM_ATTACHMENT_EVENT_CHANGE, entry.on_local_changed);
+        dataset.removeEntityEventListener(entity, SHADED_GEOMETRY_EVENT_CHANGE, entry.on_changed);
+
+        const waiting = this.#unattached.indexOf(entry);
+
+        if (waiting !== -1) {
+            this.#unattached.splice(waiting, 1);
+        }
+
+        // A context that has been replaced took its rows with it; only the one that is running
+        // is handed anything back.
+        if (entry.context !== null && entry.context === this.#graphics.scene_context(this.#scene)) {
+            entry.context.rows.detach_mesh(entity);
+        }
+
+        entry.context = null;
+    }
+}

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

@@ -1,10 +1,12 @@
 /**
- * Draws terrain under Shade: each built tile becomes one meshlet-encoded mesh in the scene, and a
- * pass after the opaque geometry textures the lot.
+ * Draws terrain under Shade: each built tile becomes one entity that draws — a `ShadedGeometry`
+ * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved
+ * — and a pass after the opaque geometry textures the lot. The system that owns primitives puts
+ * the tile in the scene's rows; this one makes and keeps the entity.
  *
  * **The tile is the unit, not the terrain.** Tiles are built on demand as the camera sees them and
  * destroyed as it leaves, which is the streaming the tile manager already does; this system follows
- * that with scene membership rather than deciding anything about it.
+ * that with entities rather than deciding anything about it.
  *
  * **Tile vertices are already in terrain space** — the height-field builder positions each tile
  * within the whole grid rather than at its own origin — so every tile mesh carries the terrain
@@ -24,7 +26,8 @@
 export class TerrainSystem extends System<any> {
     /**
      * @param {GraphicsEngine} graphics
-     * @param {Scene} scene
+     * @param {Scene} scene the scene the profile draws; a tile is an entity in its rows, put there
+     *        by the system that owns primitives, so this one keeps nothing of the scene itself
      * @param {AssetManager} assetManager
      */
     constructor(graphics: GraphicsEngine, scene: Scene, assetManager: AssetManager);
@@ -43,16 +46,21 @@ export class TerrainSystem extends System<any> {
     unlink(terrain: Terrain, entity: number): void;
     update(timeDelta: any): void;
     /**
-     * Everything the splat pass draws one terrain from, assembled against the scene that will be
-     * asked for the rows. What the pass consumes and what a gate inspects are deliberately the
-     * same object — the same reason `DecalSystem` exposes its packed records.
+     * The entities a terrain's built tiles are.
+     *
+     * @param {number} entity the terrain entity
+     * @returns {Int32Array}
+     */
+    tiles_of(entity: number): Int32Array;
+    /**
+     * Everything the splat pass draws one terrain from. What the pass consumes and what a gate
+     * inspects are deliberately the same object — the same reason `DecalSystem` exposes its
+     * packed records.
      *
      * @param {number} entity
-     * @param {GPUSceneContext} scene
-     * @returns {object|null} `null` when this terrain has nothing on screen to texture — no tiles
-     * built, or none of them in the scene database yet
+     * @returns {object|null} `null` when this terrain has nothing to texture — no tiles built
      */
-    splat_frame(entity: number, scene: GPUSceneContext): object | null;
+    splat_frame(entity: number): object | null;
     /**
      * @param {FrameContext} frame
      */

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

@@ -1 +1 @@
-{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TerrainSystem.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAiCI;;;;OAIG;IACH,gFAUC;IA/CD,iCAAyB;IAiDzB,2CAQC;IAED,4CAUC;IAED;;;OAGG;IACH,cAHW,OAAO,UACP,MAAM,QA2DhB;IAED;;;OAGG;IACH,gBAHW,OAAO,UACP,MAAM,QAMhB;IAED,6BA0BC;IAoLD;;;;;;;;;OASG;IACH,oBALW,MAAM,2BAEJ,MAAM,GAAC,IAAI,CA2FvB;IAED;;OAEG;IACH,kCAaC;;CACJ;AAED;;;;;;GAMG;AACH;IAUI;;OAEG;IACH,oBAFW,aAAa,EAMvB;IAED,yBAEC;;CACJ;uBA3iBsB,kBAAkB;oBACrB,+BAA+B;gCASnB,mDAAmD"}
+{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TerrainSystem.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA0BI;;;;;OAKG;IACH,gFASC;IAxCD,iCAAyB;IA0CzB,2CAQC;IAED,4CAUC;IAED;;;OAGG;IACH,cAHW,OAAO,UACP,MAAM,QA2DhB;IAED;;;OAGG;IACH,gBAHW,OAAO,UACP,MAAM,QAMhB;IAED,6BA0BC;IAqFD;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,UAAU,CAUtB;IAiID;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAsFvB;IAED;;OAEG;IACH,kCAaC;;CACJ;AAED;;;;;;GAMG;AACH;IAUI;;OAEG;IACH,oBAFW,aAAa,EAMvB;IAED,yBAEC;;CACJ;uBA5lBsB,kBAAkB;oBACrB,+BAA+B;gCAcnB,mDAAmD"}