@woosh/meep-engine 2.165.0 → 2.165.2

package/src/engine/graphics/sh3/lightmap/bake_lightmap_for_scene.js

@@ -243,7 +243,10 @@ export function bake_lightmap_for_scene({
             transform.updateMatrix();
         });
 
-        scene.__background_sampler = background;
+        if (background !== undefined) {
+            scene.__background_sampler = background;
+        }
+
         populate_path_traced_scene_from_ecd(ecd, scene);
         scene.optimize();
 

package/src/engine/graphics/sh3/lpg/LightProbeGrid.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Dense irradiance field representation.
+ *
+ * Light probes are placed on a regular 3d grid spanning {@link #bounds}, probes on each axis are placed so that the
+ * first and the last layer lie exactly on the bounding box faces (spacing = extent / (resolution - 1)).
+ * Probe order matches WebGL 3d texture raster order: X varies fastest, then Y, then Z.
+ *
+ * Unlike {@link LightProbeVolume} there is no connectivity structure and no depth data, the field is intended to be
+ * uploaded into 3d textures and sampled with hardware trilinear filtering.
+ *
+ * @see "Irradiance Volumes" by G.Greger, 1998
+ */
+export class LightProbeGrid {
+    /**
+     *
+     * @return {number}
+     */
+    get version(): number;
+    /**
+     *
+     * @return {AABB3}
+     */
+    get bounds(): AABB3;
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_x(): number;
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_y(): number;
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_z(): number;
+    /**
+     *
+     * @return {number}
+     */
+    get count(): number;
+    /**
+     *
+     * @return {Float32Array}
+     */
+    get harmonics(): Float32Array;
+    clear(): void;
+    /**
+     * Allocate probe storage for a given region and grid resolution. Existing data is discarded.
+     * @param {AABB3} bounds
+     * @param {number} resolution_x number of probe layers along X, at least 2
+     * @param {number} resolution_y
+     * @param {number} resolution_z
+     */
+    build(bounds: AABB3, resolution_x: number, resolution_y: number, resolution_z: number): void;
+    /**
+     * World-space position of a probe
+     * @param {number[]|Float32Array} result probe position is written here as [x, y, z]
+     * @param {number} result_offset
+     * @param {number} index probe index
+     */
+    probe_position(result: number[] | Float32Array, result_offset: number, index: number): void;
+    incrementVersion(): void;
+    #private;
+}
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+//# sourceMappingURL=LightProbeGrid.d.ts.map

package/src/engine/graphics/sh3/lpg/LightProbeGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightProbeGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/LightProbeGrid.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAkBI;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,8BAEC;IAED,cAUC;IAED;;;;;;OAMG;IACH,cALW,KAAK,gBACL,MAAM,gBACN,MAAM,gBACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,QAmBhB;IAED,yBAEC;;CACJ;sBA3KqB,wCAAwC"}

package/src/engine/graphics/sh3/lpg/LightProbeGrid.js

@@ -0,0 +1,173 @@
+import { assert } from "../../../../core/assert.js";
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+
+/**
+ * Dense irradiance field representation.
+ *
+ * Light probes are placed on a regular 3d grid spanning {@link #bounds}, probes on each axis are placed so that the
+ * first and the last layer lie exactly on the bounding box faces (spacing = extent / (resolution - 1)).
+ * Probe order matches WebGL 3d texture raster order: X varies fastest, then Y, then Z.
+ *
+ * Unlike {@link LightProbeVolume} there is no connectivity structure and no depth data, the field is intended to be
+ * uploaded into 3d textures and sampled with hardware trilinear filtering.
+ *
+ * @see "Irradiance Volumes" by G.Greger, 1998
+ */
+export class LightProbeGrid {
+    #version = 0;
+
+    #bounds = new AABB3(0, 0, 0, 0, 0, 0);
+
+    #resolution_x = 0;
+    #resolution_y = 0;
+    #resolution_z = 0;
+
+    /**
+     * Probe irradiance color data
+     * Base-2 spherical harmonics, 4 coefficients per color channel for a total of 12 coefficients per probe
+     * Layout is coefficient-major with an RGB triplet per coefficient, matching the first 4 coefficients of
+     * {@link LightProbeVolume#harmonics}
+     * @type {Float32Array}
+     */
+    #sh2_rgb = new Float32Array(0);
+
+    /**
+     *
+     * @return {number}
+     */
+    get version() {
+        return this.#version;
+    }
+
+    /**
+     *
+     * @return {AABB3}
+     */
+    get bounds() {
+        return this.#bounds;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_x() {
+        return this.#resolution_x;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_y() {
+        return this.#resolution_y;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get resolution_z() {
+        return this.#resolution_z;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get count() {
+        return this.#resolution_x * this.#resolution_y * this.#resolution_z;
+    }
+
+    /**
+     *
+     * @return {Float32Array}
+     */
+    get harmonics() {
+        return this.#sh2_rgb;
+    }
+
+    clear() {
+        this.#bounds.setBounds(0, 0, 0, 0, 0, 0);
+
+        this.#resolution_x = 0;
+        this.#resolution_y = 0;
+        this.#resolution_z = 0;
+
+        this.#sh2_rgb = new Float32Array(0);
+
+        this.#version++;
+    }
+
+    /**
+     * Allocate probe storage for a given region and grid resolution. Existing data is discarded.
+     * @param {AABB3} bounds
+     * @param {number} resolution_x number of probe layers along X, at least 2
+     * @param {number} resolution_y
+     * @param {number} resolution_z
+     */
+    build(bounds, resolution_x, resolution_y, resolution_z) {
+        assert.isInstanceOf(bounds, AABB3, 'bounds');
+
+        assert.isNonNegativeInteger(resolution_x, 'resolution_x');
+        assert.isNonNegativeInteger(resolution_y, 'resolution_y');
+        assert.isNonNegativeInteger(resolution_z, 'resolution_z');
+
+        assert.greaterThanOrEqual(resolution_x, 2, 'resolution_x');
+        assert.greaterThanOrEqual(resolution_y, 2, 'resolution_y');
+        assert.greaterThanOrEqual(resolution_z, 2, 'resolution_z');
+
+        this.#bounds.copy(bounds);
+
+        this.#resolution_x = resolution_x;
+        this.#resolution_y = resolution_y;
+        this.#resolution_z = resolution_z;
+
+        const count = this.count;
+
+        const data = new Float32Array(count * 12);
+
+        // neutral-ambient placeholder for not-yet-baked probes: DC coefficient only, band-1 stays zero.
+        // Filling all 12 coefficients would reconstruct a directional gradient (negative for some normals), not white.
+        for (let i = 0; i < count; i++) {
+            const offset = i * 12;
+
+            data[offset] = 1;
+            data[offset + 1] = 1;
+            data[offset + 2] = 1;
+        }
+
+        this.#sh2_rgb = data;
+
+        this.#version++;
+    }
+
+    /**
+     * World-space position of a probe
+     * @param {number[]|Float32Array} result probe position is written here as [x, y, z]
+     * @param {number} result_offset
+     * @param {number} index probe index
+     */
+    probe_position(result, result_offset, index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.count, 'index');
+
+        const resolution_x = this.#resolution_x;
+        const resolution_y = this.#resolution_y;
+        const resolution_z = this.#resolution_z;
+
+        const x = index % resolution_x;
+        const y = ((index / resolution_x) | 0) % resolution_y;
+        const z = (index / (resolution_x * resolution_y)) | 0;
+
+        const bounds = this.#bounds;
+
+        result[result_offset] = bounds.x0 + (x / (resolution_x - 1)) * bounds.getExtentsX();
+        result[result_offset + 1] = bounds.y0 + (y / (resolution_y - 1)) * bounds.getExtentsY();
+        result[result_offset + 2] = bounds.z0 + (z / (resolution_z - 1)) * bounds.getExtentsZ();
+    }
+
+    incrementVersion() {
+        this.#version++;
+    }
+}

package/src/engine/graphics/sh3/lpg/LightProbeGridBaker.d.ts

@@ -0,0 +1,24 @@
+export class LightProbeGridBaker {
+    /**
+     * Renderer used to bake probes. Exposed so callers (and tests) can configure the underlying scene.
+     * @return {ProbeRenderer}
+     */
+    get renderer(): ProbeRenderer;
+    /**
+     * Bake light probes
+     * @returns {TaskGroup}
+     * @param {LightProbeGrid} grid
+     * @param {EntityComponentDataset} ecd
+     */
+    bake(grid: LightProbeGrid, ecd: EntityComponentDataset): TaskGroup;
+    /**
+     *
+     * @param {ProbeRenderer} renderer
+     * @param {LightProbeGrid} grid
+     * @param {number} probe_index
+     */
+    bake_probe(renderer: ProbeRenderer, grid: LightProbeGrid, probe_index: number): void;
+    #private;
+}
+import TaskGroup from "../../../../core/process/task/TaskGroup.js";
+//# sourceMappingURL=LightProbeGridBaker.d.ts.map

package/src/engine/graphics/sh3/lpg/LightProbeGridBaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightProbeGridBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/LightProbeGridBaker.js"],"names":[],"mappings":"AAWA;IAII;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,yDAJa,SAAS,CA2CrB;IAED;;;;;OAKG;IACH,uEAFW,MAAM,QAYhB;;CACJ;sBArFqB,4CAA4C"}

package/src/engine/graphics/sh3/lpg/LightProbeGridBaker.js

@@ -0,0 +1,88 @@
+import { assert } from "../../../../core/assert.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import TaskGroup from "../../../../core/process/task/TaskGroup.js";
+import { actionTask } from "../../../../core/process/task/util/actionTask.js";
+import { countTask } from "../../../../core/process/task/util/countTask.js";
+import { promiseTask } from "../../../../core/process/task/util/promiseTask.js";
+import { PathTracerProbeRenderer } from "../lpv/PathTracerProbeRenderer.js";
+
+const __position = new Float32Array(3);
+const __sh3_rgb = new Float64Array(27);
+
+export class LightProbeGridBaker {
+
+    #ren = new PathTracerProbeRenderer();
+
+    /**
+     * Renderer used to bake probes. Exposed so callers (and tests) can configure the underlying scene.
+     * @return {ProbeRenderer}
+     */
+    get renderer() {
+        return this.#ren;
+    }
+
+    /**
+     * Bake light probes
+     * @returns {TaskGroup}
+     * @param {LightProbeGrid} grid
+     * @param {EntityComponentDataset} ecd
+     */
+    bake(grid, ecd) {
+        const renderer = this.#ren;
+
+        // async IIFE (not a Promise executor): a throw in build_scene/bake_start rejects the task rather than
+        // leaving the promise unsettled and hanging the bake forever
+        const tPrepare = promiseTask((async () => {
+            renderer.build_scene(ecd);
+            await renderer.bake_start(ecd);
+        })(), 'Prepare');
+
+
+        const probe_count = grid.count;
+
+        const tBakeIrradiance = countTask(0, probe_count, (probe_index) => {
+            this.bake_probe(renderer, grid, probe_index);
+
+        });
+        tBakeIrradiance.estimatedDuration = probe_count;
+
+        tBakeIrradiance.promise().then(() => {
+
+            const duration = tBakeIrradiance.__executedCpuTime;
+
+            console.log(`Baked ${probe_count} probes in ${duration}ms, ~${(duration / probe_count).toFixed(2)}ms per probe`);
+
+        });
+
+        const tFinish = actionTask(() => {
+            renderer.bake_end();
+
+            grid.incrementVersion();
+        });
+
+        tFinish.addDependency(tBakeIrradiance);
+        tBakeIrradiance.addDependency(tPrepare);
+
+        return new TaskGroup([
+            tPrepare, tBakeIrradiance, tFinish
+        ], "LightProbeGrid Bake");
+    }
+
+    /**
+     *
+     * @param {ProbeRenderer} renderer
+     * @param {LightProbeGrid} grid
+     * @param {number} probe_index
+     */
+    bake_probe(renderer, grid, probe_index) {
+        assert.isNonNegativeInteger(probe_index, 'probe_index');
+
+        grid.probe_position(__position, 0, probe_index);
+
+        // render a full SH3 probe with the shared facilities
+        renderer.bake(__position, 0, __sh3_rgb, 0);
+
+        // keep only bands 0 and 1: the coefficient-major layout puts them in the first 12 values
+        array_copy(__sh3_rgb, 0, grid.harmonics, probe_index * 12, 12);
+    }
+}

package/src/engine/graphics/sh3/lpg/build_light_probe_grid_for_scene.d.ts

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {LightProbeGrid} grid
+ * @param {EntityComponentDataset} ecd
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+export function light_probe_grid_bake_via_task(grid: LightProbeGrid, ecd: EntityComponentDataset, engine: Engine): Promise<void>;
+/**
+ *
+ * @param {LightProbeGrid} [grid]
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [spacing] desired distance between probes, in world units
+ * @returns {Promise<LightProbeGrid>}
+ */
+export function build_light_probe_grid_for_scene({ grid, engine, ecd, bounds, spacing }?: LightProbeGrid): Promise<LightProbeGrid>;
+import { LightProbeGrid } from "./LightProbeGrid.js";
+//# sourceMappingURL=build_light_probe_grid_for_scene.d.ts.map

package/src/engine/graphics/sh3/lpg/build_light_probe_grid_for_scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_light_probe_grid_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/build_light_probe_grid_for_scene.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,qDALW,cAAc,gDAGb,QAAQ,IAAI,CAAC,CA2BxB;AAED;;;;;;;;GAQG;AACH,0FAPW,cAAc,GAKZ,QAAQ,cAAc,CAAC,CA2BnC;+BAvE8B,qBAAqB"}

package/src/engine/graphics/sh3/lpg/build_light_probe_grid_for_scene.js

@@ -0,0 +1,79 @@
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { max2 } from "../../../../core/math/max2.js";
+import Entity from "../../../ecs/Entity.js";
+import GUIElement from "../../../ecs/gui/GUIElement.js";
+import ViewportPosition from "../../../ecs/gui/position/ViewportPosition.js";
+import { makeSimpleTaskProgressView } from "../../../makeSimpleTaskProgressView.js";
+import { LightProbeGrid } from "./LightProbeGrid.js";
+import { LightProbeGridBaker } from "./LightProbeGridBaker.js";
+
+/**
+ *
+ * @param {LightProbeGrid} grid
+ * @param {EntityComponentDataset} ecd
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+export async function light_probe_grid_bake_via_task(grid, ecd, engine) {
+    const baker = new LightProbeGridBaker();
+    const task = baker.bake(grid, ecd);
+
+    const progress = makeSimpleTaskProgressView({
+        task,
+        localization: engine.localization,
+        size: new Vector2(512, 64)
+    });
+
+    const progress_entity = new Entity();
+    progress_entity
+        .add(GUIElement.fromView(progress))
+        .add(ViewportPosition.fromJSON({
+            position: new Vector2(0, 1),
+            anchor: new Vector2(0, 1),
+            offset: new Vector2(16, -16)
+        }))
+        .build(ecd);
+
+    task.promise().finally(() => progress_entity.destroy())
+
+    engine.executor.runGroup(task);
+
+    await task.promise();
+}
+
+/**
+ *
+ * @param {LightProbeGrid} [grid]
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [spacing] desired distance between probes, in world units
+ * @returns {Promise<LightProbeGrid>}
+ */
+export async function build_light_probe_grid_for_scene(
+    {
+        grid = new LightProbeGrid(),
+        engine,
+        ecd,
+        bounds,
+        spacing = 1
+    }
+) {
+
+    const grid_bounds = new AABB3(0, 0, 0, 0, 0, 0);
+    grid_bounds.copy(bounds);
+
+    // push probe layers slightly past the geometry so that boundary surfaces are not sampled exactly at a probe shell
+    grid_bounds.grow(spacing * 1.05);
+
+    const resolution_x = max2(2, Math.ceil(grid_bounds.getExtentsX() / spacing) + 1);
+    const resolution_y = max2(2, Math.ceil(grid_bounds.getExtentsY() / spacing) + 1);
+    const resolution_z = max2(2, Math.ceil(grid_bounds.getExtentsZ() / spacing) + 1);
+
+    grid.build(grid_bounds, resolution_x, resolution_y, resolution_z);
+
+    await light_probe_grid_bake_via_task(grid, ecd, engine);
+
+    return grid;
+}

package/src/engine/graphics/sh3/lpg/light_probe_grid_obtain_storage_cached.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {Engine} engine
+ * @param {string} path
+ * @param {LightProbeGrid} [grid]
+ * @param {number} [spacing] only used when building, if loading this parameter is ignored
+ * @return {Promise<LightProbeGrid>}
+ */
+export function light_probe_grid_obtain_storage_cached({ engine, path, grid, spacing }: Engine): Promise<LightProbeGrid>;
+import { LightProbeGrid } from "./LightProbeGrid.js";
+//# sourceMappingURL=light_probe_grid_obtain_storage_cached.d.ts.map

package/src/engine/graphics/sh3/lpg/light_probe_grid_obtain_storage_cached.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"light_probe_grid_obtain_storage_cached.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/light_probe_grid_obtain_storage_cached.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,iGAFY,QAAQ,cAAc,CAAC,CAoElC;+BA7E8B,qBAAqB"}

package/src/engine/graphics/sh3/lpg/light_probe_grid_obtain_storage_cached.js

@@ -0,0 +1,84 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { number_pretty_print } from "../../../../core/primitives/numbers/number_pretty_print.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { build_light_probe_grid_for_scene } from "./build_light_probe_grid_for_scene.js";
+import { LightProbeGrid } from "./LightProbeGrid.js";
+import { LightProbeGridSerializationAdapter } from "./serialization/LightProbeGridSerializationAdapter.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {string} path
+ * @param {LightProbeGrid} [grid]
+ * @param {number} [spacing] only used when building, if loading this parameter is ignored
+ * @return {Promise<LightProbeGrid>}
+ */
+export async function light_probe_grid_obtain_storage_cached({
+                                                                 engine,
+                                                                 path,
+                                                                 grid = new LightProbeGrid(),
+                                                                 spacing = 1
+                                                             }) {
+
+    grid.clear();
+
+    const key = `lpg:${path}`;
+
+    const adapter = new LightProbeGridSerializationAdapter();
+
+    if (await engine.storage.promiseContains(key)) {
+        const data = await engine.storage.promiseLoadBinary(key);
+
+        console.log(`LPG data size ${number_pretty_print(data.byteLength)} bytes`);
+
+        const buffer = BinaryBuffer.fromArrayBuffer(data);
+
+        adapter.deserialize(buffer, grid);
+
+        return grid;
+    }
+
+
+    const ecd = engine.entityManager.dataset;
+
+    // build bounding box for the scene
+    const mesh_bounds = new AABB3();
+    mesh_bounds.setNegativelyInfiniteBounds();
+
+    ecd.traverseEntities([ShadedGeometry, Transform],
+        /**
+         *
+         * @param {ShadedGeometry} sg
+         * @param transform
+         * @param entity
+         */
+        (sg, transform, entity) => {
+
+            const box = new AABB3();
+
+            sg.getBoundingBox(box);
+
+            mesh_bounds.union(box);
+
+        });
+
+    await build_light_probe_grid_for_scene({
+        grid,
+        engine,
+        ecd,
+        bounds: mesh_bounds,
+        spacing
+    });
+
+    const buffer = new BinaryBuffer();
+
+    adapter.serialize(buffer, grid);
+
+    buffer.trim();
+
+    engine.storage.promiseStoreBinary(key, buffer.data)
+
+    return grid;
+}

package/src/engine/graphics/sh3/lpg/light_probe_grid_textures.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Create the half-float luminance volume of a {@link LightProbeGrid}. Each texel holds the 4 SH2 Y coefficients in RGBA.
+ * @param {number} resolution_x
+ * @param {number} resolution_y
+ * @param {number} resolution_z
+ * @returns {DataTexture3D}
+ */
+export function make_light_probe_grid_luma_texture(resolution_x: number, resolution_y: number, resolution_z: number): DataTexture3D;
+/**
+ * Create an 8-bit chrominance volume (one of Co / Cg) of a {@link LightProbeGrid}. Each texel holds the 4 SH2
+ * coefficients of that chroma channel in RGBA.
+ * @param {number} resolution_x
+ * @param {number} resolution_y
+ * @param {number} resolution_z
+ * @returns {DataTexture3D}
+ */
+export function make_light_probe_grid_chroma_texture(resolution_x: number, resolution_y: number, resolution_z: number): DataTexture3D;
+/**
+ * Write probe data of a grid into the YCoCg textures created by {@link make_light_probe_grid_luma_texture} and
+ * {@link make_light_probe_grid_chroma_texture}. Texture dimensions must match the grid resolution.
+ * @param {LightProbeGrid} grid
+ * @param {DataTexture3D} texture_y luminance, half-float
+ * @param {DataTexture3D} texture_co chroma-orange, 8-bit
+ * @param {DataTexture3D} texture_cg chroma-green, 8-bit
+ */
+export function light_probe_grid_write_textures(grid: LightProbeGrid, texture_y: DataTexture3D, texture_co: DataTexture3D, texture_cg: DataTexture3D): void;
+export const LPG_CHROMA_SCALE: 0.25;
+import { DataTexture3D } from "three";
+//# sourceMappingURL=light_probe_grid_textures.d.ts.map

package/src/engine/graphics/sh3/lpg/light_probe_grid_textures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"light_probe_grid_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/light_probe_grid_textures.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,iEALW,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,aAAa,CA+BzB;AAED;;;;;;;GAOG;AACH,mEALW,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,aAAa,CA+BzB;AAUD;;;;;;;GAOG;AACH,iFAJW,aAAa,cACb,aAAa,cACb,aAAa,QAqCvB;AAtID,oCAAqC;8BAlB9B,OAAO"}