@woosh/meep-engine 3.11.2 → 3.12.0

package/src/engine/graphics3/PickingSystem.js

@@ -0,0 +1,273 @@
+import { assert } from "../../core/assert.js";
+import { BVH } from "../../core/bvh2/bvh3/BVH.js";
+import {
+    aabb3_ray_segment_entry_distance
+} from "../../core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
+import { BVHQueryIntersectsRay } from "../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
+import { bvh_query_leaves_generic } from "../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
+import { System } from "../ecs/System.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import { Pickable } from "./Pickable.js";
+import { PickingResult } from "./PickingResult.js";
+
+/**
+ * @type {Float32Array}
+ */
+const SCRATCH_BOUNDS = new Float32Array(6);
+
+/**
+ * Answers "what is under this ray" for entities that asked to be pickable.
+ *
+ * **Asynchronous and batched from the first line, on purpose (I-9).** The backend here is a CPU
+ * bounding-volume hierarchy and could answer synchronously; the API does not let it, because the
+ * backend this is meant to grow into reads entity ids back off the GPU's visibility buffer, and that
+ * answer is inherently a frame late and arrives for a whole batch at once. A synchronous entry point
+ * would have to be broken to get there, and every caller broken with it.
+ *
+ * **Bounding boxes, not triangles.** A hit means the ray entered the entity's world bounding box.
+ * That is the precision this can offer for free — Shade maintains those boxes as part of drawing —
+ * and going finer means keeping CPU-side triangles for every pickable entity, which is the
+ * duplication {@link Pickable} exists to keep small. Terrain picking, which is where the game's
+ * precision actually matters, does not come through here at all: it is an exact raycast against the
+ * terrain's own representation and is untouched by any of this.
+ *
+ * The index is refreshed **on query rather than per frame**. Nothing pays for picking on a frame where
+ * nobody picks, and there is no window in which the index disagrees with the scene, so no class of
+ * bug where a pick lands on where something used to be.
+ */
+export class PickingSystem extends System {
+    /**
+     * @type {MeshSystem}
+     */
+    #meshes;
+
+    /**
+     * @type {BVH}
+     */
+    #bvh = new BVH();
+
+    /**
+     * The BVH leaf standing for each pickable entity.
+     *
+     * @type {Map<number, number>}
+     */
+    #leaves = new Map();
+
+    /**
+     * Entities that have opted in but have nothing in the scene yet — a model still loading, most
+     * often. They hold no leaf, and every query looks again, which is what lets one appear without
+     * anything having to notice the moment it did.
+     *
+     * @type {Set<number>}
+     */
+    #pending = new Set();
+
+    /**
+     * @param {MeshSystem} meshes what an entity looks like, which is where its bounds come from
+     */
+    constructor(meshes) {
+        super();
+
+        assert.defined(meshes, 'meshes');
+
+        this.#meshes = meshes;
+
+        this.dependencies = [Pickable, Transform];
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+    }
+
+    async shutdown(entityManager) {
+        for (const entity of Array.from(this.#leaves.keys())) {
+            this.#drop(entity);
+        }
+
+        this.#pending.clear();
+    }
+
+    /**
+     * @param {Pickable} pickable
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(pickable, transform, entity) {
+        // no bounds are taken here: the model may not have arrived, and the first query is early
+        // enough to find out
+        this.#pending.add(entity);
+    }
+
+    /**
+     * @param {Pickable} pickable
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(pickable, transform, entity) {
+        this.#drop(entity);
+    }
+
+    /**
+     * How many entities the index currently stands for.
+     *
+     * The index is built on query, so this is zero until the first {@link pick} — and stays behind by
+     * however many pickable entities are still waiting on their models.
+     *
+     * @returns {number}
+     */
+    get indexed_count() {
+        return this.#leaves.size;
+    }
+
+    /**
+     * What each of these rays hits first.
+     *
+     * One result per query, in the order the queries were given. A ray that hits nothing still gets a
+     * result — `entity` is {@link PickingResult.NOTHING} — so the two arrays line up by position and a
+     * caller never has to search for the answer to its own question.
+     *
+     * @param {PickingQuery[]} queries
+     * @returns {Promise<PickingResult[]>}
+     */
+    async pick(queries) {
+        assert.isArray(queries, 'queries');
+
+        this.#refresh();
+
+        const results = [];
+
+        for (let i = 0; i < queries.length; i++) {
+            results.push(this.#pick_one(queries[i]));
+        }
+
+        return results;
+    }
+
+    /**
+     * @param {PickingQuery} query
+     * @returns {PickingResult}
+     */
+    #pick_one(query) {
+        const result = new PickingResult();
+
+        const bvh = this.#bvh;
+
+        const origin = query.origin;
+        const direction = query.direction;
+
+        const origin_x = origin.x;
+        const origin_y = origin.y;
+        const origin_z = origin.z;
+
+        const hits = [];
+
+        const hit_count = bvh_query_leaves_generic(
+            hits, 0,
+            bvh, bvh.root,
+            BVHQueryIntersectsRay.from([
+                origin_x, origin_y, origin_z,
+                direction.x, direction.y, direction.z
+            ])
+        );
+
+        // reciprocals once for the whole batch of candidates; the entry-distance test wants them, and
+        // a division component that is zero deliberately produces an infinity it handles
+        const inv_x = 1 / direction.x;
+        const inv_y = 1 / direction.y;
+        const inv_z = 1 / direction.z;
+
+        let best_distance = query.max_distance;
+        let best_entity = PickingResult.NOTHING;
+
+        for (let i = 0; i < hit_count; i++) {
+            const leaf = hits[i];
+
+            bvh.node_get_aabb(leaf, SCRATCH_BOUNDS);
+
+            const distance = aabb3_ray_segment_entry_distance(
+                SCRATCH_BOUNDS[0], SCRATCH_BOUNDS[1], SCRATCH_BOUNDS[2],
+                SCRATCH_BOUNDS[3], SCRATCH_BOUNDS[4], SCRATCH_BOUNDS[5],
+                origin_x, origin_y, origin_z,
+                inv_x, inv_y, inv_z,
+                0, query.max_distance
+            );
+
+            if (distance >= best_distance) {
+                // further than something already found, or a miss the broadphase let through
+                continue;
+            }
+
+            best_distance = distance;
+            best_entity = bvh.node_get_user_data(leaf);
+        }
+
+        if (best_entity === PickingResult.NOTHING) {
+            return result;
+        }
+
+        result.entity = best_entity;
+        result.distance = best_distance;
+
+        result.position.set(
+            origin_x + direction.x * best_distance,
+            origin_y + direction.y * best_distance,
+            origin_z + direction.z * best_distance
+        );
+
+        return result;
+    }
+
+    /**
+     * Bring every leaf in line with where its entity now is, and give a leaf to any entity whose
+     * model has arrived since the last look.
+     */
+    #refresh() {
+        const meshes = this.#meshes;
+
+        for (const [entity, leaf] of this.#leaves) {
+            if (meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
+                this.#bvh.node_move_aabb(leaf, SCRATCH_BOUNDS);
+
+                continue;
+            }
+
+            // the model went away under it — the entity is still pickable, so it goes back to
+            // waiting rather than losing its opt-in
+            this.#drop(entity);
+            this.#pending.add(entity);
+        }
+
+        for (const entity of Array.from(this.#pending)) {
+            if (!meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
+                continue;
+            }
+
+            const leaf = this.#bvh.allocate_node();
+
+            this.#bvh.node_set_aabb(leaf, SCRATCH_BOUNDS);
+            this.#bvh.node_set_user_data(leaf, entity);
+            this.#bvh.insert_leaf(leaf);
+
+            this.#leaves.set(entity, leaf);
+            this.#pending.delete(entity);
+        }
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #drop(entity) {
+        this.#pending.delete(entity);
+
+        const leaf = this.#leaves.get(entity);
+
+        if (leaf === undefined) {
+            return;
+        }
+
+        this.#bvh.remove_leaf(leaf);
+        this.#bvh.release_node(leaf);
+
+        this.#leaves.delete(entity);
+    }
+}

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

@@ -1,67 +1,10 @@
 /**
- * Answers "what is under this ray" for entities that asked to be pickable.
+ * @deprecated Renamed to {@link PickingSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * **Asynchronous and batched from the first line, on purpose (I-9).** The backend here is a CPU
- * bounding-volume hierarchy and could answer synchronously; the API does not let it, because the
- * backend this is meant to grow into reads entity ids back off the GPU's visibility buffer, and that
- * answer is inherently a frame late and arrives for a whole batch at once. A synchronous entry point
- * would have to be broken to get there, and every caller broken with it.
- *
- * **Bounding boxes, not triangles.** A hit means the ray entered the entity's world bounding box.
- * That is the precision this can offer for free — Shade maintains those boxes as part of drawing —
- * and going finer means keeping CPU-side triangles for every pickable entity, which is the
- * duplication {@link Pickable} exists to keep small. Terrain picking, which is where the game's
- * precision actually matters, does not come through here at all: it is an exact raycast against the
- * terrain's own representation and is untouched by any of this.
- *
- * The index is refreshed **on query rather than per frame**. Nothing pays for picking on a frame where
- * nobody picks, and there is no window in which the index disagrees with the scene, so no class of
- * bug where a pick lands on where something used to be.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class PickingSystem3 extends System<any> {
-    /**
-     * @param {MeshSystem3} meshes what an entity looks like, which is where its bounds come from
-     */
-    constructor(meshes: MeshSystem3);
-    dependencies: (typeof Transform | typeof Pickable)[];
-    startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(pickable: Pickable, transform: Transform, entity: number): void;
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(pickable: Pickable, transform: Transform, entity: number): void;
-    /**
-     * How many entities the index currently stands for.
-     *
-     * The index is built on query, so this is zero until the first {@link pick} — and stays behind by
-     * however many pickable entities are still waiting on their models.
-     *
-     * @returns {number}
-     */
-    get indexed_count(): number;
-    /**
-     * What each of these rays hits first.
-     *
-     * One result per query, in the order the queries were given. A ray that hits nothing still gets a
-     * result — `entity` is {@link PickingResult.NOTHING} — so the two arrays line up by position and a
-     * caller never has to search for the answer to its own question.
-     *
-     * @param {PickingQuery[]} queries
-     * @returns {Promise<PickingResult[]>}
-     */
-    pick(queries: PickingQuery[]): Promise<PickingResult[]>;
-    #private;
-}
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { Pickable } from "./Pickable.js";
-import { PickingResult } from "./PickingResult.js";
+export const PickingSystem3: typeof PickingSystem;
+import { PickingSystem } from "./PickingSystem.js";
 //# sourceMappingURL=PickingSystem3.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PickingSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/PickingSystem3.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA2BI;;OAEG;IACH,iCAQC;IADG,qDAAyC;IAG7C,2CAEC;IAED,4CAMC;IAED;;;;OAIG;IACH,eAJW,QAAQ,aACR,SAAS,UACT,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAJW,QAAQ,aACR,SAAS,UACT,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAEC;IAED;;;;;;;;;OASG;IACH,cAHW,cAAc,GACZ,QAAQ,aAAa,EAAE,CAAC,CAcpC;;CAiIJ;uBAzQsB,kBAAkB;0BACf,+BAA+B;yBAChC,eAAe;8BACV,oBAAoB"}
+{"version":3,"file":"PickingSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/PickingSystem3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,kDAA4C;8BATd,oBAAoB"}

package/src/engine/graphics3/PickingSystem3.js

@@ -1,273 +1,10 @@
-import { assert } from "../../core/assert.js";
-import { BVH } from "../../core/bvh2/bvh3/BVH.js";
-import {
-    aabb3_ray_segment_entry_distance
-} from "../../core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
-import { BVHQueryIntersectsRay } from "../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
-import { bvh_query_leaves_generic } from "../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { Pickable } from "./Pickable.js";
-import { PickingResult } from "./PickingResult.js";
+import { PickingSystem } from "./PickingSystem.js";
 
 /**
- * @type {Float32Array}
- */
-const SCRATCH_BOUNDS = new Float32Array(6);
-
-/**
- * Answers "what is under this ray" for entities that asked to be pickable.
- *
- * **Asynchronous and batched from the first line, on purpose (I-9).** The backend here is a CPU
- * bounding-volume hierarchy and could answer synchronously; the API does not let it, because the
- * backend this is meant to grow into reads entity ids back off the GPU's visibility buffer, and that
- * answer is inherently a frame late and arrives for a whole batch at once. A synchronous entry point
- * would have to be broken to get there, and every caller broken with it.
+ * @deprecated Renamed to {@link PickingSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
+ * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
  *
- * **Bounding boxes, not triangles.** A hit means the ray entered the entity's world bounding box.
- * That is the precision this can offer for free — Shade maintains those boxes as part of drawing —
- * and going finer means keeping CPU-side triangles for every pickable entity, which is the
- * duplication {@link Pickable} exists to keep small. Terrain picking, which is where the game's
- * precision actually matters, does not come through here at all: it is an exact raycast against the
- * terrain's own representation and is untouched by any of this.
- *
- * The index is refreshed **on query rather than per frame**. Nothing pays for picking on a frame where
- * nobody picks, and there is no window in which the index disagrees with the scene, so no class of
- * bug where a pick lands on where something used to be.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class PickingSystem3 extends System {
-    /**
-     * @type {MeshSystem3}
-     */
-    #meshes;
-
-    /**
-     * @type {BVH}
-     */
-    #bvh = new BVH();
-
-    /**
-     * The BVH leaf standing for each pickable entity.
-     *
-     * @type {Map<number, number>}
-     */
-    #leaves = new Map();
-
-    /**
-     * Entities that have opted in but have nothing in the scene yet — a model still loading, most
-     * often. They hold no leaf, and every query looks again, which is what lets one appear without
-     * anything having to notice the moment it did.
-     *
-     * @type {Set<number>}
-     */
-    #pending = new Set();
-
-    /**
-     * @param {MeshSystem3} meshes what an entity looks like, which is where its bounds come from
-     */
-    constructor(meshes) {
-        super();
-
-        assert.defined(meshes, 'meshes');
-
-        this.#meshes = meshes;
-
-        this.dependencies = [Pickable, Transform];
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-    }
-
-    async shutdown(entityManager) {
-        for (const entity of Array.from(this.#leaves.keys())) {
-            this.#drop(entity);
-        }
-
-        this.#pending.clear();
-    }
-
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(pickable, transform, entity) {
-        // no bounds are taken here: the model may not have arrived, and the first query is early
-        // enough to find out
-        this.#pending.add(entity);
-    }
-
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(pickable, transform, entity) {
-        this.#drop(entity);
-    }
-
-    /**
-     * How many entities the index currently stands for.
-     *
-     * The index is built on query, so this is zero until the first {@link pick} — and stays behind by
-     * however many pickable entities are still waiting on their models.
-     *
-     * @returns {number}
-     */
-    get indexed_count() {
-        return this.#leaves.size;
-    }
-
-    /**
-     * What each of these rays hits first.
-     *
-     * One result per query, in the order the queries were given. A ray that hits nothing still gets a
-     * result — `entity` is {@link PickingResult.NOTHING} — so the two arrays line up by position and a
-     * caller never has to search for the answer to its own question.
-     *
-     * @param {PickingQuery[]} queries
-     * @returns {Promise<PickingResult[]>}
-     */
-    async pick(queries) {
-        assert.isArray(queries, 'queries');
-
-        this.#refresh();
-
-        const results = [];
-
-        for (let i = 0; i < queries.length; i++) {
-            results.push(this.#pick_one(queries[i]));
-        }
-
-        return results;
-    }
-
-    /**
-     * @param {PickingQuery} query
-     * @returns {PickingResult}
-     */
-    #pick_one(query) {
-        const result = new PickingResult();
-
-        const bvh = this.#bvh;
-
-        const origin = query.origin;
-        const direction = query.direction;
-
-        const origin_x = origin.x;
-        const origin_y = origin.y;
-        const origin_z = origin.z;
-
-        const hits = [];
-
-        const hit_count = bvh_query_leaves_generic(
-            hits, 0,
-            bvh, bvh.root,
-            BVHQueryIntersectsRay.from([
-                origin_x, origin_y, origin_z,
-                direction.x, direction.y, direction.z
-            ])
-        );
-
-        // reciprocals once for the whole batch of candidates; the entry-distance test wants them, and
-        // a division component that is zero deliberately produces an infinity it handles
-        const inv_x = 1 / direction.x;
-        const inv_y = 1 / direction.y;
-        const inv_z = 1 / direction.z;
-
-        let best_distance = query.max_distance;
-        let best_entity = PickingResult.NOTHING;
-
-        for (let i = 0; i < hit_count; i++) {
-            const leaf = hits[i];
-
-            bvh.node_get_aabb(leaf, SCRATCH_BOUNDS);
-
-            const distance = aabb3_ray_segment_entry_distance(
-                SCRATCH_BOUNDS[0], SCRATCH_BOUNDS[1], SCRATCH_BOUNDS[2],
-                SCRATCH_BOUNDS[3], SCRATCH_BOUNDS[4], SCRATCH_BOUNDS[5],
-                origin_x, origin_y, origin_z,
-                inv_x, inv_y, inv_z,
-                0, query.max_distance
-            );
-
-            if (distance >= best_distance) {
-                // further than something already found, or a miss the broadphase let through
-                continue;
-            }
-
-            best_distance = distance;
-            best_entity = bvh.node_get_user_data(leaf);
-        }
-
-        if (best_entity === PickingResult.NOTHING) {
-            return result;
-        }
-
-        result.entity = best_entity;
-        result.distance = best_distance;
-
-        result.position.set(
-            origin_x + direction.x * best_distance,
-            origin_y + direction.y * best_distance,
-            origin_z + direction.z * best_distance
-        );
-
-        return result;
-    }
-
-    /**
-     * Bring every leaf in line with where its entity now is, and give a leaf to any entity whose
-     * model has arrived since the last look.
-     */
-    #refresh() {
-        const meshes = this.#meshes;
-
-        for (const [entity, leaf] of this.#leaves) {
-            if (meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
-                this.#bvh.node_move_aabb(leaf, SCRATCH_BOUNDS);
-
-                continue;
-            }
-
-            // the model went away under it — the entity is still pickable, so it goes back to
-            // waiting rather than losing its opt-in
-            this.#drop(entity);
-            this.#pending.add(entity);
-        }
-
-        for (const entity of Array.from(this.#pending)) {
-            if (!meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
-                continue;
-            }
-
-            const leaf = this.#bvh.allocate_node();
-
-            this.#bvh.node_set_aabb(leaf, SCRATCH_BOUNDS);
-            this.#bvh.node_set_user_data(leaf, entity);
-            this.#bvh.insert_leaf(leaf);
-
-            this.#leaves.set(entity, leaf);
-            this.#pending.delete(entity);
-        }
-    }
-
-    /**
-     * @param {number} entity
-     */
-    #drop(entity) {
-        this.#pending.delete(entity);
-
-        const leaf = this.#leaves.get(entity);
-
-        if (leaf === undefined) {
-            return;
-        }
-
-        this.#bvh.remove_leaf(leaf);
-        this.#bvh.release_node(leaf);
-
-        this.#leaves.delete(entity);
-    }
-}
+export const PickingSystem3 = PickingSystem;

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

@@ -0,0 +1,47 @@
+/**
+ * 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<any> {
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics: GraphicsEngine, scene: Scene);
+    dependencies: (typeof Transform | typeof ShadedGeometry)[];
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /**
+     * @param {ShadedGeometry} geometry
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(geometry: ShadedGeometry, transform: Transform, entity: number): void;
+    /**
+     * @param {ShadedGeometry} geometry
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(geometry: ShadedGeometry, transform: Transform, entity: number): void;
+    #private;
+}
+import { System } from "../ecs/System.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
+//# sourceMappingURL=ShadedGeometrySystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,2DAA+C;IAGnD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,SAAS,UACT,MAAM,QA2ChB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,SAAS,UACT,MAAM,QAMhB;;CAsCJ;uBApKsB,kBAAkB;0BACf,+BAA+B;+BAE1B,2CAA2C"}