@woosh/meep-engine/src/engine/graphics/sh3/lpv/build_probes_for_scene.js

Pure JavaScript game engine. Fully featured and production ready.

import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
import Vector2 from "../../../../core/geom/Vector2.js";
import Vector3 from "../../../../core/geom/Vector3.js";
import { seededRandom } from "../../../../core/math/random/seededRandom.js";
import { delay } from "../../../../core/process/delay.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 { LightProbeVolume } from "./LightProbeVolume.js";
import { LightProbeVolumeBaker } from "./LightProbeVolumeBaker.js";

/**
 *
 * @param {LightProbeVolume} volume
 * @param {EntityComponentDataset} ecd
 * @param {Engine} engine
 * @return {Promise<void>}
 */
export async function lpv_volume_bake_via_task(volume, ecd, engine) {
    const lpv_baker = new LightProbeVolumeBaker();
    const task = lpv_baker.bake(volume, ecd);
    // console.profileEnd('lpv build');

    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);

    console.log(volume);

    await task.promise();
}

/**
 *
 * @param {LightProbeVolume} volume
 * @param {Engine} engine
 * @param {EntityComponentDataset} ecd
 * @param {AABB3} bounds
 * @param {number} [density]
 * @returns {Promise<LightProbeVolume>}
 */
export async function build_probes_for_scene(
    {
        volume = new LightProbeVolume(),
        engine,
        ecd,
        bounds,
        density = 1000
    }
) {

    // lpv.add_point(10, 5, 10);

    // const desired_density = 8000;
    const desired_frequency = Math.cbrt(density);


    // const light_volume_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
    const probe_grid_spacing_dense = Math.min(bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()) / desired_frequency;
    const probe_grid_spacing_sparse = Math.max(bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()) / desired_frequency;

    const probe_grid_spacing = (probe_grid_spacing_sparse / probe_grid_spacing_dense) < 2 ? probe_grid_spacing_dense : probe_grid_spacing_sparse * 0.5;
    //
    // const probe_grid_spacing =desired_density/ (mesh_asset.boundingBox.getExtentsX()* mesh_asset.boundingBox.getExtentsY()* mesh_asset.boundingBox.getExtentsZ());

    const model_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
    model_bounds.copy(bounds);
    // model_bounds._translate(composition.transform.position.x, composition.transform.position.y, composition.transform.position.z);
    model_bounds.grow(probe_grid_spacing * 1.05);


    // sg_hierarchy_compute_bounding_box_via_parent_entity(light_volume_bounds, composition.entity.entity, ecd);
    const random = seededRandom(1);

    // for (let i = 0; i < 1000; i++) {
    //     volume.add_point(
    //         randomFloatBetween(random, model_bounds.x0, model_bounds.x1),
    //         randomFloatBetween(random, model_bounds.y0, model_bounds.y1),
    //         randomFloatBetween(random, model_bounds.z0, model_bounds.z1),
    //     );
    // }


    // lpv.add_point(10, 1, -10);

    await delay(1);


    //
    // console.profile('lpv build');
    //
    // volume.build_mesh();
    console.time('Grid Build')
    //
    // make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
    //     volume.add_point(x, y, z);
    // });
    // volume.build_mesh();
    //
    volume.build_grid(model_bounds, new Vector3(
        Math.ceil(model_bounds.width / probe_grid_spacing),
        Math.ceil(model_bounds.height / probe_grid_spacing),
        Math.ceil(model_bounds.depth / probe_grid_spacing)
    ));

    console.timeEnd('Grid Build');

    await lpv_volume_bake_via_task(volume, ecd, engine);

    return volume;
}