@woosh/meep-engine 2.164.0 → 2.165.1

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

@@ -0,0 +1,186 @@
+import { BoxBufferGeometry, MeshStandardMaterial, SphereBufferGeometry } from "three";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Tag from "../../../ecs/components/Tag.js";
+import Entity from "../../../ecs/Entity.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { EngineHarness } from "../../../EngineHarness.js";
+import { Light } from "../../ecs/light/Light.js";
+import LightSystem from "../../ecs/light/LightSystem.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { bake_lightmap_for_scene } from "./bake_lightmap_for_scene.js";
+
+const harness = new EngineHarness();
+
+/**
+ * Add one coloured {@link ShadedGeometry} entity to the scene.
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {THREE.BufferGeometry} geometry
+ * @param {number} color hex colour
+ * @param {Vector3} position
+ * @param {Quaternion} [rotation]
+ */
+function spawn(ecd, geometry, color, position, rotation) {
+    const material = new MeshStandardMaterial({ color, roughness: 1, metalness: 0 });
+
+    const sg = ShadedGeometry.from(geometry, material);
+    sg.setFlag(ShadedGeometryFlags.CastShadow);
+    sg.setFlag(ShadedGeometryFlags.ReceiveShadow);
+    sg.setFlag(ShadedGeometryFlags.Visible);
+
+    const transform = new Transform();
+    transform.position.copy(position);
+    if (rotation !== undefined) {
+        transform.rotation.copy(rotation);
+    }
+
+    new Entity()
+        .add(sg)
+        .add(transform)
+        .add(Tag.fromJSON(["LightmapTarget"]))
+        .build(ecd);
+}
+
+/**
+ * Add a coloured light. DIRECTION lights bake crisp shadows; POINT lights add
+ * coloured bounce. Both are read by the path-traced bake.
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {number} type one of {@link Light.Type}
+ * @param {number[]} color linear [r, g, b] in 0..1
+ * @param {number} intensity
+ * @param {Object} placement
+ * @param {Vector3} [placement.position]
+ * @param {Vector3} [placement.direction]
+ * @param {number} [placement.distance] point-light influence radius
+ */
+function spawn_light(ecd, type, color, intensity, { position, direction, distance = 30 }) {
+    const light = new Light();
+    light.type.set(type);
+    light.color.setRGB(color[0], color[1], color[2]);
+    light.intensity.set(intensity);
+    light.distance.set(distance);
+    light.castShadow.set(true);
+
+    const transform = new Transform();
+    if (position !== undefined) {
+        transform.position.copy(position);
+    }
+    if (direction !== undefined) {
+        transform.rotation.lookRotation(direction.clone().normalize());
+    }
+
+    new Entity()
+        .add(light)
+        .add(transform)
+        .add(Tag.fromJSON(["Light"]))
+        .build(ecd);
+}
+
+/**
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    const em = engine.entityManager;
+
+    await em.addSystem(new ShadedGeometrySystem(engine));
+    await em.addSystem(new LightSystem(engine, { shadowResolution: 2048 }));
+
+    // camera + orbital/keyboard controls; no terrain (we build our own platform),
+    // no engine lights (we place our own so we can dim them after the bake)
+    await EngineHarness.buildBasics({
+        engine,
+        focus: new Vector3(0, 1.5, 0),
+        pitch: 0.95,
+        yaw: 0.6,
+        distance: 18,
+        enableTerrain: false,
+        enableWater: false,
+        enableLights: false,
+        cameraController: true,
+        showFps: true,
+    });
+
+    const ecd = em.dataset;
+
+    // --- platform ---
+    spawn(ecd, new BoxBufferGeometry(16, 1, 16), 0xA1A1A1, new Vector3(0, -0.5, 0));
+
+    // --- a few shapes ---
+    spawn(ecd, new BoxBufferGeometry(2, 2, 2), 0xe23b3b, new Vector3(-4, 1, -2));
+    spawn(ecd, new BoxBufferGeometry(2, 4, 2), 0x3bd16f, new Vector3(3.5, 2, 2));
+    spawn(ecd, new SphereBufferGeometry(1.5, 32, 24), 0x4f86ff, new Vector3(0, 1.5, 3.5));
+    spawn(
+        ecd,
+        new BoxBufferGeometry(2.5, 2.5, 2.5),
+        0xf0c020,
+        new Vector3(2.5, 1.25, -3.5),
+        Quaternion.fromEulerAngles(0, Math.PI / 5, 0)
+    );
+
+    // --- lights (baked) ---
+    spawn_light(ecd, Light.Type.DIRECTION, [1.0, 0.95, 0.88], 1.6, { direction: new Vector3(-0.6, -1, -0.35) });
+    spawn_light(ecd, Light.Type.POINT, [1.0, 0.3, 0.18], 1, { position: new Vector3(-4, 2.5, 4), distance: 16 });
+    spawn_light(ecd, Light.Type.POINT, [0.18, 0.42, 1.0], 1, { position: new Vector3(5, 3, -5), distance: 16 });
+
+    const status = make_status_overlay();
+
+    // give the ECS one frame to settle transforms before baking
+    requestAnimationFrame(() => {
+        const group = bake_lightmap_for_scene({
+            ecd,
+            lightmap_resolution: 1024,
+            samples_per_texel: 1024,
+            min_bounce: 1,
+            max_bounce: 4,
+            padding: 2,
+        });
+
+        // expose for console poking
+        window.lightmap_bake = group;
+
+        // engine.executor.runGroup(group);
+
+        // progress readout
+        function poll() {
+            const p = group.computeProgress();
+            status.textContent = `Baking lightmap… ${(p * 100).toFixed(1)}%`;
+            if (p < 1) {
+                requestAnimationFrame(poll);
+            }
+        }
+
+        poll();
+    });
+}
+
+/**
+ * @returns {HTMLDivElement}
+ */
+function make_status_overlay() {
+    const el = document.createElement("div");
+    el.style.position = "fixed";
+    el.style.left = "8px";
+    el.style.top = "8px";
+    el.style.zIndex = "1000";
+    el.style.padding = "6px 10px";
+    el.style.font = "13px monospace";
+    el.style.color = "#fff";
+    el.style.background = "rgba(0,0,0,0.55)";
+    el.style.borderRadius = "4px";
+    el.style.pointerEvents = "none";
+    el.textContent = "Preparing bake…";
+    document.body.appendChild(el);
+    return el;
+}
+
+harness.initialize({
+    configuration(config) {
+
+        // config.addPlugin(AmbientOcclusionPostProcessEffect)
+
+    },
+}).then(main);

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"}