@treasuryspatial/viewer-kit 0.2.44 → 0.2.50

package/dist/systems/debugSystem.js

@@ -2,15 +2,22 @@ import * as THREE from "three";
 const DEFAULT_EXTRAS = {
     grid: true,
     ground: true,
-    axes: true,
-    origin: true,
-    gridOpacity: 0.12,
-    gridDivisions: 100,
-    gridSize: 100,
+    groundMode: "infinite",
+    gridMode: "infinite",
+    axes: false,
+    shadowHelpers: false,
+    origin: false,
+    gridUnit: 1,
+    gridMajorEvery: 5,
+    gridSuperMajorEvery: 10,
+    gridOpacity: 0.055,
+    gridMajorOpacity: 0.12,
+    gridSuperMajorOpacity: 0.2,
+    gridSize: 120,
     groundRoughness: 0.8,
     groundMetalness: 0.05,
     lightTarget: [0, 1.5, 0],
-    originHighlight: true,
+    originHighlight: false,
     originLineColor: 0x94a3b8,
     originLineLength: 40,
     originLineThickness: 0.06,
@@ -21,14 +28,27 @@ const DEFAULT_EXTRAS = {
         offset: 0.4,
         secondaryOffset: 0.5,
     },
+    outline: false,
+    outlineColor: 0x1f2937,
+    outlineOpacity: 0.38,
+    outlineThresholdAngle: 35,
+    outlineDepthTest: true,
 };
 const DEFAULT_GRID_SIZE = 100;
-const DEFAULT_GRID_DIVISIONS = 100;
-const DEFAULT_GRID_OPACITY = 0.12;
-const DEFAULT_GRID_HEIGHT_OFFSET = 0.02;
-const DEFAULT_GROUND_OFFSET = -0.11;
-const HDR_GROUND_SIZE = 30;
-const HDR_GRID_SIZE = 30;
+const DEFAULT_GRID_OPACITY = 0.055;
+const DEFAULT_GRID_MAJOR_OPACITY = 0.12;
+const DEFAULT_GRID_SUPER_MAJOR_OPACITY = 0.2;
+const DEFAULT_GRID_UNIT = 1;
+const DEFAULT_GRID_MAJOR_EVERY = 5;
+const DEFAULT_GRID_SUPER_MAJOR_EVERY = 10;
+const MAX_METRIC_GRID_SIZE = 2000;
+const DEFAULT_GRID_HEIGHT_OFFSET = 0.05;
+const DEFAULT_GROUND_OFFSET = -0.08;
+const AO_GROUND_PROXY_CLEARANCE = 0.001;
+const MIN_GRID_GROUND_CLEARANCE = 0.05;
+const MIN_GRID_FLOOR_CLEARANCE = 0.05;
+const INFINITE_GROUND_SIZE = 20000;
+export const AO_DEPTH_PROXY_USER_DATA_KEY = "treasuryAoDepthProxy";
 const AXIS_COLORS = {
     x: 0xef4444,
     y: 0x22c55e,
@@ -176,80 +196,270 @@ function adjustGridColor(groundHex) {
     adjusted.setHSL(hsl.h, hsl.s, hsl.l);
     return adjusted.getHex();
 }
+const clampOpacity = (value) => Math.max(0, Math.min(1, value));
+function buildGridLineSegments(positions, color, opacity) {
+    if (positions.length === 0)
+        return null;
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+    const material = new THREE.LineBasicMaterial({
+        color,
+        transparent: true,
+        opacity: clampOpacity(opacity),
+        depthTest: true,
+        depthWrite: false,
+        toneMapped: false,
+    });
+    const lines = new THREE.LineSegments(geometry, material);
+    lines.frustumCulled = false;
+    lines.renderOrder = -10;
+    return lines;
+}
+function buildMetricGrid(extras, groundColor, requestedSize) {
+    const step = Math.max(0.001, extras.gridUnit ?? DEFAULT_GRID_UNIT);
+    const majorEvery = Math.max(1, Math.round(extras.gridMajorEvery ?? DEFAULT_GRID_MAJOR_EVERY));
+    const superMajorEvery = Math.max(majorEvery, Math.round(extras.gridSuperMajorEvery ?? DEFAULT_GRID_SUPER_MAJOR_EVERY));
+    const halfLines = Math.max(1, Math.ceil(Math.min(requestedSize, MAX_METRIC_GRID_SIZE) / (2 * step)));
+    const extent = halfLines * step;
+    const size = extent * 2;
+    const divisions = halfLines * 2;
+    const minorColor = extras.gridColorSecondary ?? adjustGridColor(groundColor);
+    const majorColor = extras.gridMajorColor ?? extras.gridColor ?? adjustGridColor(groundColor);
+    const superMajorColor = extras.gridSuperMajorColor ?? extras.gridColor ?? majorColor;
+    const minorOpacity = extras.gridOpacity ?? DEFAULT_GRID_OPACITY;
+    const majorOpacity = extras.gridMajorOpacity ?? Math.max(DEFAULT_GRID_MAJOR_OPACITY, minorOpacity * 2.1);
+    const superMajorOpacity = extras.gridSuperMajorOpacity ?? Math.max(DEFAULT_GRID_SUPER_MAJOR_OPACITY, majorOpacity * 1.55);
+    const minorPositions = [];
+    const majorPositions = [];
+    const superMajorPositions = [];
+    const appendLinePair = (target, coordinate) => {
+        target.push(-extent, 0, coordinate, extent, 0, coordinate);
+        target.push(coordinate, 0, -extent, coordinate, 0, extent);
+    };
+    for (let i = -halfLines; i <= halfLines; i += 1) {
+        const coordinate = i * step;
+        const absIndex = Math.abs(i);
+        if (superMajorEvery > 0 && absIndex % superMajorEvery === 0) {
+            appendLinePair(superMajorPositions, coordinate);
+        }
+        else if (majorEvery > 0 && absIndex % majorEvery === 0) {
+            appendLinePair(majorPositions, coordinate);
+        }
+        else {
+            appendLinePair(minorPositions, coordinate);
+        }
+    }
+    const group = new THREE.Group();
+    group.name = "metric-grid";
+    const minor = buildGridLineSegments(minorPositions, minorColor, minorOpacity);
+    const major = buildGridLineSegments(majorPositions, majorColor, majorOpacity);
+    const superMajor = buildGridLineSegments(superMajorPositions, superMajorColor, superMajorOpacity);
+    if (minor)
+        group.add(minor);
+    if (major)
+        group.add(major);
+    if (superMajor)
+        group.add(superMajor);
+    group.renderOrder = -10;
+    return { object: group, size, step, divisions, majorEvery, superMajorEvery };
+}
+function hasOwnSceneExtra(preset, key) {
+    return Object.prototype.hasOwnProperty.call(preset.sceneExtras ?? {}, key);
+}
+function buildOutlineGroup(root, extras) {
+    if (!root || extras.outline !== true)
+        return null;
+    const group = new THREE.Group();
+    const thresholdAngle = extras.outlineThresholdAngle ?? 35;
+    const baseMaterial = new THREE.LineBasicMaterial({
+        color: extras.outlineColor ?? 0x1f2937,
+        transparent: true,
+        opacity: extras.outlineOpacity ?? 0.38,
+        depthTest: extras.outlineDepthTest !== false,
+        depthWrite: false,
+        toneMapped: false,
+    });
+    root.updateMatrixWorld(true);
+    root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh || !mesh.geometry)
+            return;
+        const geometry = mesh.geometry;
+        const edges = new THREE.EdgesGeometry(geometry, thresholdAngle);
+        const line = new THREE.LineSegments(edges, baseMaterial.clone());
+        line.matrix.copy(mesh.matrixWorld);
+        line.matrixAutoUpdate = false;
+        line.renderOrder = 20;
+        line.frustumCulled = false;
+        group.add(line);
+    });
+    baseMaterial.dispose();
+    return group.children.length > 0 ? group : null;
+}
 export class DebugSystem {
     scene;
     objects = [];
+    ground = null;
+    groundAoProxy = null;
+    grid = null;
+    groundInfinite = false;
+    gridInfinite = false;
+    gridDivisionSize = 1;
+    state = {
+        groundEnabled: false,
+        gridEnabled: false,
+        groundY: null,
+        gridY: null,
+        gridSize: null,
+        gridDivisions: null,
+        gridStep: null,
+        gridMajorEvery: null,
+        gridSuperMajorEvery: null,
+        groundMode: null,
+        gridMode: null,
+    };
     constructor(scene) {
         this.scene = scene;
     }
-    apply(preset, bounds) {
+    update(anchor) {
+        if (!anchor)
+            return;
+        if (this.groundInfinite && this.ground) {
+            this.ground.position.x = anchor.x;
+            this.ground.position.z = anchor.z;
+        }
+        if (this.groundInfinite && this.groundAoProxy) {
+            this.groundAoProxy.position.x = anchor.x;
+            this.groundAoProxy.position.z = anchor.z;
+        }
+        if (this.gridInfinite && this.grid) {
+            const snap = Number.isFinite(this.gridDivisionSize) && this.gridDivisionSize > 0 ? this.gridDivisionSize : 1;
+            this.grid.position.x = Math.round(anchor.x / snap) * snap;
+            this.grid.position.z = Math.round(anchor.z / snap) * snap;
+        }
+    }
+    getState() {
+        return { ...this.state };
+    }
+    apply(preset, bounds, root) {
         const extras = { ...DEFAULT_EXTRAS, ...(preset.sceneExtras ?? {}) };
         this.clear();
-        const skyMode = preset.sky?.mode ?? "gradient";
-        const isHdr = skyMode === "hdr";
         const groundEnabled = extras.ground !== false;
         const gridEnabled = extras.grid !== false;
         const axesEnabled = extras.axes !== false;
+        const shadowHelpersEnabled = extras.shadowHelpers === true;
         const originEnabled = extras.origin !== false;
         const groundColor = extras.groundColor ?? 0x2c2f33;
-        const boundsSize = bounds && !bounds.isEmpty() ? bounds.getSize(new THREE.Vector3()) : null;
+        const hasBounds = Boolean(bounds && !bounds.isEmpty());
+        const boundsSize = hasBounds ? bounds.getSize(new THREE.Vector3()) : null;
+        const boundsMinY = hasBounds && Number.isFinite(bounds.min.y) ? bounds.min.y : 0;
         const modelSpan = boundsSize ? Math.max(boundsSize.x, boundsSize.z, 1) : null;
-        const groundScale = isHdr ? (extras.groundAutoScaleHdr ?? 1.25) : (extras.groundAutoScale ?? 2.5);
-        const gridScale = isHdr
-            ? (extras.gridAutoScaleHdr ?? extras.groundAutoScaleHdr ?? 1.25)
-            : (extras.gridAutoScale ?? extras.groundAutoScale ?? 2.5);
-        const groundSizeDefault = isHdr ? HDR_GROUND_SIZE : DEFAULT_GRID_SIZE;
-        const gridSizeDefault = isHdr ? HDR_GRID_SIZE : DEFAULT_GRID_SIZE;
-        const derivedGroundSize = modelSpan ? modelSpan * groundScale : groundSizeDefault;
+        // Ground/grid sizing is independent of sky mode. The metric grid uses real-world step
+        // size (gridUnit) so HDR-vs-non-HDR proportional scaling no longer adds value, and ground
+        // is forced to INFINITE_GROUND_SIZE in infinite mode regardless. Authors who genuinely
+        // want a different look under HDR can express it through gridUnit/gridMajorEvery directly.
+        const groundScale = extras.groundAutoScale ?? 2.5;
+        const gridScale = extras.gridAutoScale ?? extras.groundAutoScale ?? 2.5;
+        const derivedGroundSize = modelSpan ? modelSpan * groundScale : DEFAULT_GRID_SIZE;
         const derivedGridSize = groundEnabled
             ? (extras.groundSize ?? derivedGroundSize)
             : modelSpan
                 ? modelSpan * gridScale
-                : gridSizeDefault;
-        const groundOffset = extras.groundOffset ?? DEFAULT_GROUND_OFFSET;
-        const gridHeightOffset = extras.gridHeightOffset ?? DEFAULT_GRID_HEIGHT_OFFSET;
+                : DEFAULT_GRID_SIZE;
+        const groundOffsetAuthored = hasOwnSceneExtra(preset, "groundOffset");
+        const groundOffset = groundOffsetAuthored ? (extras.groundOffset ?? DEFAULT_GROUND_OFFSET) : boundsMinY + DEFAULT_GROUND_OFFSET;
+        const defaultGroundOffset = boundsMinY + DEFAULT_GROUND_OFFSET;
+        const useContactAoProxy = hasBounds &&
+            Number.isFinite(boundsMinY) &&
+            Math.abs(groundOffset - defaultGroundOffset) <= 1e-6;
+        const groundAoProxyY = useContactAoProxy ? boundsMinY - AO_GROUND_PROXY_CLEARANCE : groundOffset;
+        const rawGridHeightOffset = extras.gridHeightOffset ?? DEFAULT_GRID_HEIGHT_OFFSET;
+        const gridHeightOffsetFromGround = groundEnabled
+            ? Math.max(rawGridHeightOffset, MIN_GRID_GROUND_CLEARANCE)
+            : rawGridHeightOffset;
+        const gridFloorOffset = Math.max(rawGridHeightOffset, MIN_GRID_FLOOR_CLEARANCE);
+        const groundMode = extras.groundMode ?? "infinite";
+        const gridMode = extras.gridMode ?? groundMode;
+        this.groundInfinite = groundMode === "infinite";
+        this.gridInfinite = gridMode === "infinite";
         if (groundEnabled) {
-            const size = extras.groundSize ?? derivedGroundSize;
+            const size = groundMode === "infinite"
+                ? Math.max(extras.groundSize ?? derivedGroundSize, INFINITE_GROUND_SIZE)
+                : extras.groundSize ?? derivedGroundSize;
             const groundGeometry = new THREE.PlaneGeometry(size, size);
             const groundMaterial = new THREE.MeshStandardMaterial({
                 color: groundColor,
-                roughness: extras.groundRoughness ?? (isHdr ? 0.6 : 0.8),
-                metalness: extras.groundMetalness ?? (isHdr ? 0.02 : 0.05),
+                roughness: extras.groundRoughness ?? 0.8,
+                metalness: extras.groundMetalness ?? 0.05,
                 toneMapped: false,
             });
-            groundMaterial.polygonOffset = true;
-            groundMaterial.polygonOffsetFactor = 1;
-            groundMaterial.polygonOffsetUnits = 1;
+            // Ground draws first (renderOrder=-20) and must never z-fight with the model floor or grid.
+            // polygonOffset is view-angle-dependent (slope→0 at top-down), so the visible plane stays
+            // depthless and relies on render order. AO gets a separate invisible depth proxy instead.
+            groundMaterial.depthWrite = false;
             const ground = new THREE.Mesh(groundGeometry, groundMaterial);
             ground.rotation.x = -Math.PI / 2;
             ground.position.y = groundOffset;
             ground.receiveShadow = true;
+            ground.renderOrder = -20;
+            this.ground = ground;
             this.add(ground);
+            const groundAoProxyMaterial = new THREE.MeshBasicMaterial({
+                color: 0xffffff,
+                toneMapped: false,
+            });
+            groundAoProxyMaterial.colorWrite = false;
+            const groundAoProxy = new THREE.Mesh(groundGeometry.clone(), groundAoProxyMaterial);
+            groundAoProxy.rotation.x = -Math.PI / 2;
+            groundAoProxy.position.y = groundAoProxyY;
+            groundAoProxy.renderOrder = -19;
+            groundAoProxy.visible = false;
+            groundAoProxy.userData[AO_DEPTH_PROXY_USER_DATA_KEY] = true;
+            this.groundAoProxy = groundAoProxy;
+            this.add(groundAoProxy);
         }
         let lastGridPositionY = 0;
-        const gridSize = extras.gridSize ?? derivedGridSize;
+        const gridSize = Math.max(1, extras.gridSize ?? derivedGridSize);
+        let gridDivisionsResolved = null;
+        let gridStepResolved = null;
+        let gridMajorEveryResolved = null;
+        let gridSuperMajorEveryResolved = null;
+        let gridSizeResolved = null;
         if (gridEnabled) {
-            const gridPrimary = new THREE.Color(extras.gridColor ?? adjustGridColor(groundColor));
-            const gridSecondary = new THREE.Color(extras.gridColorSecondary ?? gridPrimary.getHex());
-            const gridDivisions = extras.gridDivisions ?? Math.max(1, gridSize);
-            const grid = new THREE.GridHelper(gridSize, gridDivisions, gridPrimary, gridSecondary);
-            const gridY = groundEnabled ? groundOffset + gridHeightOffset : -gridHeightOffset;
+            const requestedGridSize = gridMode === "infinite"
+                ? Math.max(gridSize, DEFAULT_GRID_SIZE)
+                : gridSize;
+            const metricGrid = buildMetricGrid(extras, groundColor, requestedGridSize);
+            gridDivisionsResolved = metricGrid.divisions;
+            gridStepResolved = metricGrid.step;
+            gridMajorEveryResolved = metricGrid.majorEvery;
+            gridSuperMajorEveryResolved = metricGrid.superMajorEvery;
+            gridSizeResolved = metricGrid.size;
+            this.gridDivisionSize = metricGrid.step;
+            const grid = metricGrid.object;
+            const gridPlane = extras.gridPlane ?? (groundEnabled ? "ground" : "floor");
+            const gridY = gridPlane === "ground" && groundEnabled
+                ? groundOffset + gridHeightOffsetFromGround
+                : boundsMinY + gridFloorOffset;
             grid.position.y = gridY;
             lastGridPositionY = grid.position.y;
-            const gridMaterial = grid.material;
-            const setTransparency = (mat) => {
-                mat.transparent = true;
-                mat.opacity = extras.gridOpacity ?? DEFAULT_GRID_OPACITY;
-            };
-            if (Array.isArray(gridMaterial)) {
-                gridMaterial.forEach((mat) => setTransparency(mat));
-            }
-            else if (gridMaterial) {
-                setTransparency(gridMaterial);
-            }
+            this.grid = grid;
             this.add(grid);
         }
-        const originPlaneY = groundEnabled ? groundOffset : lastGridPositionY || -gridHeightOffset;
+        this.state = {
+            groundEnabled,
+            gridEnabled,
+            groundY: groundEnabled ? groundOffset : null,
+            gridY: gridEnabled ? lastGridPositionY : null,
+            gridSize: gridEnabled ? gridSizeResolved : null,
+            gridDivisions: gridDivisionsResolved,
+            gridStep: gridStepResolved,
+            gridMajorEvery: gridMajorEveryResolved,
+            gridSuperMajorEvery: gridSuperMajorEveryResolved,
+            groundMode,
+            gridMode,
+        };
+        const originPlaneY = gridEnabled ? lastGridPositionY : groundEnabled ? groundOffset : boundsMinY + gridFloorOffset;
         if (extras.originHighlight !== false) {
             const originCross = buildOriginCross(extras, gridSize, originPlaneY);
             this.add(originCross);
@@ -275,6 +485,22 @@ export class DebugSystem {
                 this.add(axes);
             }
         }
+        if (shadowHelpersEnabled) {
+            this.scene.traverse((child) => {
+                if (!(child instanceof THREE.DirectionalLight) || !child.castShadow)
+                    return;
+                const lightHelper = new THREE.DirectionalLightHelper(child, 3);
+                lightHelper.update();
+                this.add(lightHelper);
+                if (child.shadow?.camera) {
+                    this.add(new THREE.CameraHelper(child.shadow.camera));
+                }
+            });
+        }
+        const outline = buildOutlineGroup(root, extras);
+        if (outline) {
+            this.add(outline);
+        }
     }
     dispose() {
         this.clear();
@@ -284,40 +510,61 @@ export class DebugSystem {
         this.objects.push(object);
     }
     clear() {
+        this.ground = null;
+        this.groundAoProxy = null;
+        this.grid = null;
+        this.groundInfinite = false;
+        this.gridInfinite = false;
+        this.gridDivisionSize = 1;
+        this.state = {
+            groundEnabled: false,
+            gridEnabled: false,
+            groundY: null,
+            gridY: null,
+            gridSize: null,
+            gridDivisions: null,
+            gridStep: null,
+            gridMajorEvery: null,
+            gridSuperMajorEvery: null,
+            groundMode: null,
+            gridMode: null,
+        };
         this.objects.forEach((object) => {
             if (object.parent)
                 object.parent.remove(object);
-            if (object instanceof THREE.Mesh) {
-                object.geometry.dispose();
-                const material = object.material;
-                if (Array.isArray(material)) {
-                    material.forEach((mat) => mat.dispose?.());
-                }
-                else {
-                    material.dispose?.();
-                }
-                return;
-            }
-            if (object instanceof THREE.Line) {
-                object.geometry.dispose();
-                const material = object.material;
-                if (Array.isArray(material)) {
-                    material.forEach((mat) => mat.dispose?.());
+            object.traverse((child) => {
+                if (child instanceof THREE.Mesh) {
+                    child.geometry.dispose();
+                    const material = child.material;
+                    if (Array.isArray(material)) {
+                        material.forEach((mat) => mat.dispose?.());
+                    }
+                    else {
+                        material.dispose?.();
+                    }
+                    return;
                 }
-                else {
-                    material?.dispose?.();
+                if (child instanceof THREE.Line) {
+                    child.geometry.dispose();
+                    const material = child.material;
+                    if (Array.isArray(material)) {
+                        material.forEach((mat) => mat.dispose?.());
+                    }
+                    else {
+                        material?.dispose?.();
+                    }
+                    return;
                 }
-                return;
-            }
-            if (object instanceof THREE.Sprite) {
-                const material = object.material;
-                if (material) {
-                    if (material.map) {
-                        material.map.dispose?.();
+                if (child instanceof THREE.Sprite) {
+                    const material = child.material;
+                    if (material) {
+                        if (material.map) {
+                            material.map.dispose?.();
+                        }
+                        material.dispose?.();
                     }
-                    material.dispose?.();
                 }
-            }
+            });
         });
         this.objects = [];
     }

package/dist/systems/environmentSystem.d.ts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 import type { AssetResolver, RenderPresetDefinition } from "../engine/types";
 export type EnvironmentState = {
-    mode: "none" | "gradient" | "hdr" | "cube";
+    mode: "none" | "gradient" | "image" | "hdr" | "cube";
     backgroundEnabled: boolean;
     lightingEnabled: boolean;
 };
@@ -13,21 +13,22 @@ export declare class EnvironmentSystem {
     private currentObjects;
     private currentBackground;
     private currentEnvironment;
-    private gradientSky;
-    private readonly gradientBaseRadius;
     private objectUrls;
     private loadToken;
+    private appliedSkySignature;
     private state;
     private fallbackGradient;
     constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer, assetResolver?: AssetResolver);
     getState(): EnvironmentState;
-    update(camera?: THREE.Camera): void;
+    update(_camera?: THREE.Camera): void;
     apply(preset: RenderPresetDefinition): Promise<void>;
     dispose(): void;
+    private static skySignature;
     private disposeCurrent;
     private applyGradientSky;
     private resolveAsset;
     private applyHdrSky;
+    private applyImageSky;
     private applyCubeSky;
     private applyRotationToScene;
 }

package/dist/systems/environmentSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environmentSystem.d.ts","sourceRoot":"","sources":["../../src/systems/environmentSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAA8C,MAAM,iBAAiB,CAAC;AAEzH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,MAAM,CAAC;IAC3C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,cAAc,CAAqC;IAE3D,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,iBAAiB,CAAkD;IAC3E,OAAO,CAAC,kBAAkB,CAAkD;IAC5E,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IAC1C,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,KAAK,CAAwF;IACrG,OAAO,CAAC,gBAAgB,CAMtB;gBAEU,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,aAAa;IAM5F,QAAQ,IAAI,gBAAgB;IAI5B,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI;IAa7B,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAuC1D,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,cAAc;IAsCtB,OAAO,CAAC,gBAAgB;YA+CV,YAAY;YAaZ,WAAW;YAwDX,YAAY;IAuD1B,OAAO,CAAC,oBAAoB;CAY7B"}
+{"version":3,"file":"environmentSystem.d.ts","sourceRoot":"","sources":["../../src/systems/environmentSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAa,aAAa,EAAE,sBAAsB,EAA8D,MAAM,iBAAiB,CAAC;AAEpJ,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACrD,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,cAAc,CAAqC;IAE3D,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,iBAAiB,CAAkD;IAC3E,OAAO,CAAC,kBAAkB,CAAkD;IAC5E,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,mBAAmB,CAAuB;IAElD,OAAO,CAAC,KAAK,CAAwF;IACrG,OAAO,CAAC,gBAAgB,CAMtB;gBAEU,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,aAAa;IAM5F,QAAQ,IAAI,gBAAgB;IAI5B,MAAM,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI;IAE9B,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2D1D,OAAO,IAAI,IAAI;IASf,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B,OAAO,CAAC,cAAc;IAoCtB,OAAO,CAAC,gBAAgB;YA8CV,YAAY;YAaZ,WAAW;YA0DX,aAAa;YAoEb,YAAY;IAyD1B,OAAO,CAAC,oBAAoB;CAY7B"}