@woosh/meep-engine 2.106.1 → 2.108.0

package/src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js

@@ -0,0 +1,123 @@
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { sh3_basis_at } from "../../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
+import {
+    sh3_dering_optimize_positive
+} from "../../../../core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js";
+import { randomPointOnSphere } from "../../../../core/geom/random/randomPointOnSphere.js";
+import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { Light } from "../../ecs/light/Light.js";
+import { LightType } from "../../ecs/light/LightType.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
+import { PathTracedScene } from "../path_tracer/PathTracedScene.js";
+import { PathTracer } from "../path_tracer/PathTracer.js";
+import { ProbeRenderer } from "./ProbeRenderer.js";
+
+const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
+const sh_basis = new Float64Array(__shared_buffer, 0, 9);
+const coefficients = new Float64Array(__shared_buffer, 9 * 8, 27);
+
+export class PathTracerProbeRenderer extends ProbeRenderer {
+    tracer = new PathTracer();
+    sample_count = 1000;
+    random = seededRandom(0);
+
+    scene = new PathTracedScene()
+
+    bake(position, position_offset, output, output_offset) {
+
+        const tracer = this.tracer;
+
+        const ray = [];
+
+        const direct_light = [];
+
+        array_copy(position, position_offset, ray, 0, 3);
+
+        const sampled_irradiance = [];
+
+        coefficients.fill(0);
+
+        for (let i = 0; i < this.sample_count; i++) {
+
+            randomPointOnSphere(this.random, ray, 3);
+
+            tracer.path_trace(sampled_irradiance, ray, Infinity, 1, 7, this.random, this.scene);
+
+            sh3_basis_at(ray[3], ray[4], ray[5], sh_basis);
+
+            // accumulate
+            for (let j = 0; j < 9; j++) {
+
+                const j3 = j * 3;
+
+                const projected_coefficient = sh_basis[j];
+
+                coefficients[j3] += projected_coefficient * sampled_irradiance[0];
+                coefficients[j3 + 1] += projected_coefficient * sampled_irradiance[1];
+                coefficients[j3 + 2] += projected_coefficient * sampled_irradiance[2];
+
+            }
+        }
+
+        // Area of a unit sphere is (4*PI)
+
+        const normalization_weight = (4 * Math.PI) / this.sample_count;
+
+        for (let i = 0; i < 27; i++) {
+            coefficients[i] *= normalization_weight;
+        }
+
+        sh3_dering_optimize_positive(coefficients, 0, coefficients, 0, 3);
+
+        array_copy(coefficients, 0, output, output_offset, 27);
+    }
+
+    bake_end() {
+    }
+
+    bake_start() {
+        return this.scene.build();
+    }
+
+    build_scene(ecd) {
+
+        const scene = this.scene;
+
+        ecd.traverseEntities([ShadedGeometry, Transform],
+            /**
+             *
+             * @param {ShadedGeometry} sg
+             * @param {Transform} transform
+             */
+            (sg, transform) => {
+
+                scene.addMesh(sg.geometry, sg.material, transform.matrix)
+
+            });
+
+
+        ecd.traverseEntities([Light, Transform],
+            /**
+             *
+             * @param {Light} light
+             * @param {Transform} transform
+             */
+            (light, transform) => {
+
+                if (light.type.getValue() === LightType.DIRECTION) {
+
+                    const l = new DirectionalLight();
+
+                    l.color.copy(light.color);
+                    l.direction.copy(transform.forward);
+                    l.intensity.copy(light.intensity);
+
+                    scene.addLight(l);
+                }
+
+            });
+
+    }
+}

package/src/engine/graphics/sh3/lpv/ProbeRenderer.d.ts

@@ -0,0 +1,29 @@
+/**
+ *  @abstract
+ */
+export class ProbeRenderer {
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @abstract
+     */
+    build_scene(ecd: EntityComponentDataset): void;
+    /**
+     *  @abstract
+     */
+    bake_start(): Promise<void>;
+    /**
+     *  @abstract
+     */
+    bake_end(): void;
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     * @abstract
+     */
+    bake(position: number[], position_offset: number, output: number[], output_offset: number): void;
+}
+//# sourceMappingURL=ProbeRenderer.d.ts.map

package/src/engine/graphics/sh3/lpv/ProbeRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/ProbeRenderer.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IACI;;;;OAIG;IACH,+CACC;IAED;;OAEG;IACH,4BACC;IAED;;OAEG;IACH,iBACC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,EAAE,mBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;CACJ"}

package/src/engine/graphics/sh3/lpv/ProbeRenderer.js

@@ -0,0 +1,35 @@
+/**
+ *  @abstract
+ */
+export class ProbeRenderer {
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @abstract
+     */
+    build_scene(ecd) {
+    }
+
+    /**
+     *  @abstract
+     */
+    async bake_start() {
+    }
+
+    /**
+     *  @abstract
+     */
+    bake_end() {
+    }
+
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     * @abstract
+     */
+    bake(position, position_offset, output, output_offset) {
+    }
+}

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.d.ts

@@ -0,0 +1,27 @@
+export class WebGLCubeProbeRenderer extends ProbeRenderer {
+    /**
+     *
+     * @type {THREE.WebGLRenderer|null}
+     * @private
+     */
+    private __renderer;
+    render_target: WebGLCubeRenderTarget;
+    /**
+     * Used to read out GPU memory for each face
+     * @type {Uint8Array}
+     * @private
+     */
+    private __cube_face_raw;
+    __cube_camera: CubeCamera;
+    /**
+     *
+     * @type {Scene}
+     * @private
+     */
+    private __scene;
+    bake_start(): void;
+}
+import { ProbeRenderer } from "./ProbeRenderer.js";
+import { WebGLCubeRenderTarget } from "three";
+import { CubeCamera } from "three";
+//# sourceMappingURL=WebGLCubeProbeRenderer.d.ts.map

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLCubeProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js"],"names":[],"mappings":"AAuBA;IAIQ;;;;OAIG;IACH,mBAAsB;IAEtB,qCASE;IAEF;;;;OAIG;IACH,wBAA8F;IAG9F,0BAAiE;IAEjE;;;;OAIG;IACH,gBAA0B;IA8C9B,mBAMC;CA6CJ;8BAxI6B,oBAAoB;sCAZ3C,OAAO;2BAAP,OAAO"}

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js

@@ -0,0 +1,158 @@
+import {
+    CubeCamera,
+    LinearEncoding,
+    LinearFilter,
+    MeshStandardMaterial,
+    RGBAFormat,
+    Scene,
+    VSMShadowMap,
+    WebGLCubeRenderTarget
+} from "three";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { three_set_shadow_resolution } from "../../ecs/light/binding/three/ThreeLightBinding.js";
+import { threeMakeLight } from "../../ecs/light/binding/three/threeMakeLight.js";
+import { Light } from "../../ecs/light/Light.js";
+import { ThreeLightCache } from "../../ecs/light/three/ThreeLightCache.js";
+import { build_three_object } from "../../ecs/mesh-v2/build_three_object.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { applyTransformToThreeObject } from "../../ecs/mesh/applyTransformToThreeObject.js";
+import { WebGLRendererPool } from "../../render/RendererPool.js";
+import { fromCubeRenderTarget } from "../fromCubeRenderTarget.js";
+import { ProbeRenderer } from "./ProbeRenderer.js";
+
+export class WebGLCubeProbeRenderer extends ProbeRenderer {
+    constructor() {
+
+        super();
+        /**
+         *
+         * @type {THREE.WebGLRenderer|null}
+         * @private
+         */
+        this.__renderer = null;
+
+        this.render_target = new WebGLCubeRenderTarget(32, {
+            format: RGBAFormat,
+            minFilter: LinearFilter,
+            magFilter: LinearFilter,
+            depthBuffer: true,
+            scissorTest: false,
+            stencilBuffer: false,
+            generateMipmaps: false,
+            encoding: LinearEncoding
+        });
+
+        /**
+         * Used to read out GPU memory for each face
+         * @type {Uint8Array}
+         * @private
+         */
+        this.__cube_face_raw = new Uint8Array(this.render_target.width * this.render_target.width * 4);
+
+
+        this.__cube_camera = new CubeCamera(0.1, 100, this.render_target);
+
+        /**
+         *
+         * @type {Scene}
+         * @private
+         */
+        this.__scene = new Scene();
+        // this.__scene.autoUpdate = false;
+        // this.__scene.matrixAutoUpdate = false;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     */
+    build_scene(ecd) {
+        this.__scene.children.splice(0, this.__scene.children.length);
+        ecd.traverseEntities([ShadedGeometry, Transform], (sg, t, entity) => {
+            const object3D = build_three_object(sg);
+            const source_material = sg.material;
+            //
+            if (source_material.isMeshStandardMaterial === true) {
+                object3D.material = new MeshStandardMaterial({
+                    map: source_material.map,
+                });
+                object3D.material.color.copy(source_material.color);
+            } else {
+                object3D.material = source_material.clone();
+            }
+            applyTransformToThreeObject(object3D, t);
+            array_copy(t.matrix, 0, object3D.matrixWorld.elements, 0, 16);
+            this.__scene.add(object3D);
+        });
+        const lightCache = new ThreeLightCache();
+        ecd.traverseEntities([Light, Transform], (light, t) => {
+            /**
+             *
+             * @type {DirectionalLight|SpotLight|PointLight|AmbientLight}
+             */
+            const object = threeMakeLight(light, lightCache);
+            applyTransformToThreeObject(object, t);
+            const shadow = object.shadow;
+            if (shadow !== undefined) {
+                shadow.radius = 1;
+                shadow.blurSamples = 8;
+                three_set_shadow_resolution(shadow, 2048);
+            }
+            this.__scene.add(object);
+        });
+        // this.__scene.add(this.__cube_camera);
+    }
+
+    bake_start() {
+        const renderer = WebGLRendererPool.global.get();
+        this.__renderer = renderer;
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = VSMShadowMap;
+        // this.__renderer = this.ge.getRenderer();
+    }
+
+    bake_end() {
+        WebGLRendererPool.global.release(this.__renderer);
+        this.__renderer = null;
+    }
+
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     */
+    bake(position, position_offset, output, output_offset) {
+        // console.warn(position_offset, output_offset);
+        // const ge = this.ge;
+        const renderer = this.__renderer;
+        const _rt = renderer.getRenderTarget();
+        const _rt_active_face = renderer.getActiveCubeFace();
+        const _acc = renderer.autoClearColor;
+        const _acd = renderer.autoClearDepth;
+        const _ac = renderer.autoClear;
+        const _outputEncoding = renderer.outputEncoding;
+        renderer.outputEncoding = LinearEncoding;
+        renderer.autoClearColor = true;
+        renderer.autoClearDepth = true;
+        renderer.autoClear = true;
+        this.__cube_camera.position.fromArray(position, position_offset);
+        this.__cube_camera.children.forEach(c => {
+            c.updateProjectionMatrix();
+            c.updateMatrix();
+            c.updateMatrixWorld(true);
+        });
+        this.__cube_camera.update(renderer, this.__scene);
+        // compute coefficients from renderer
+        const probe_coefficients = fromCubeRenderTarget(this.__cube_face_raw, renderer, this.render_target);
+        array_copy(probe_coefficients, 0, output, output_offset, 27);
+        // restore state
+        renderer.setRenderTarget(_rt, _rt_active_face);
+        renderer.autoClearColor = _acc;
+        renderer.autoClearDepth = _acd;
+        renderer.autoClear = _ac;
+        renderer.outputEncoding = _outputEncoding;
+    }
+}

package/src/engine/graphics/sh3/lpv/build_probes_for_scene.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [density]
+ * @returns {Promise<LightProbeVolume>}
+ */
+export function build_probes_for_scene({ engine, ecd, bounds, density }: Engine): Promise<LightProbeVolume>;
+import { LightProbeVolume } from "./LightProbeVolume.js";
+//# sourceMappingURL=build_probes_for_scene.d.ts.map

package/src/engine/graphics/sh3/lpv/build_probes_for_scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,kFAFa,QAAQ,gBAAgB,CAAC,CA8GrC;iCAtHgC,uBAAuB"}

package/src/engine/graphics/sh3/lpv/build_probes_for_scene.js

@@ -0,0 +1,127 @@
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { make_justified_point_grid } from "../../../../core/geom/3d/util/make_justified_point_grid.js";
+import Vector2 from "../../../../core/geom/Vector2.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";
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {AABB3} bounds
+ * @param {number} [density]
+ * @returns {Promise<LightProbeVolume>}
+ */
+export async function build_probes_for_scene(
+    {
+        engine,
+        ecd,
+        bounds,
+        density = 1000
+    }
+) {
+
+    const lpv = new LightProbeVolume();
+
+    // 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);
+
+    // for (let i = 0; i < 100; i++) {
+    //     lpv.add_point(
+    //         randomFloatBetween(random, light_volume_bounds.x0, light_volume_bounds.x1),
+    //         randomFloatBetween(random,  light_volume_bounds.y0, light_volume_bounds.y1),
+    //         randomFloatBetween(random,  light_volume_bounds.z0, light_volume_bounds.z1),
+    //     );
+    // }
+
+    make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
+        lpv.add_point(x, y, z);
+    });
+
+    // lpv.add_point(10, 1, -10);
+
+    await delay(2000);
+
+    //
+    // console.profile('lpv build');
+    //
+    const task = lpv.build(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);
+
+    // fill probes with random data
+    // for (let i = 0; i < lpv.__length * 27; i++) {
+    //     lpv.__probe_data[i] = random();
+    // }
+
+    // for (let i = 0; i < lpv.__length; i++) {
+    //
+    //     for (let j = 0; j < 9; j++) {
+    //         lpv.__probe_data[(i * 9 + j) * 3] = max2(0, (lpv.__positions[i * 3] + 10) / 20);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 1] = max2(0, (lpv.__positions[i * 3 + 1] - 0.5) / 10.5);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 2] = max2(0, (lpv.__positions[i * 3 + 2] + 10) / 20);
+    //     }
+    // }
+
+    // lpv.white_probe(0, [
+    //     0.7953949, 0.4405923, 0.5459412,
+    //     0.3981450, 0.3526911, 0.6097158,
+    //     -0.3424573, -0.1838151, -0.2715583,
+    //
+    //     -0.2944621, -0.0560606, 0.0095193,
+    //     -0.1123051, -0.0513088, -0.1232869,
+    //     -0.2645007, -0.2257996, -0.4785847,
+    //
+    //     -0.1569444, -0.0954703, -0.1485053,
+    //     0.5646247, 0.2161586, 0.1402643,
+    //     0.2137442, -0.0547578, -0.3061700], 0);
+
+
+    console.log(lpv);
+
+    await task.promise();
+
+    return lpv;
+}

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {LightProbeVolume} lpv
+ */
+export function probe_volume_to_textures(lpv: LightProbeVolume): {
+    mesh_vertices: AttributeDataTexture;
+    mesh_neighbours: AttributeDataTexture;
+    probe_positions: AttributeDataTexture;
+    probe_values: AttributeDataTexture;
+};
+import { AttributeDataTexture } from "../../texture/AttributeDataTexture.js";
+//# sourceMappingURL=probe_volume_to_textures.d.ts.map

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH;;;;;EAuDC;qCA9DoC,uCAAuC"}

package/src/engine/graphics/sh3/lpv/probe_volume_to_textures.js

@@ -0,0 +1,89 @@
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { AttributeSpec } from "../../geometry/AttributeSpec.js";
+import { AttributeDataTexture } from "../../texture/AttributeDataTexture.js";
+import { tetrahedral_mesh_to_texture } from "../gi/tetrahedral_mesh_to_texture.js";
+
+/**
+ *
+ * @param {LightProbeVolume} lpv
+ */
+export function probe_volume_to_textures(lpv) {
+
+    const tex_vertices = new AttributeDataTexture(
+        AttributeSpec.fromJSON({
+            name: "vertex",
+            type: BinaryDataType.Uint16,
+            itemSize: 4,
+            normalized: false
+        }),
+        256, 1
+    );
+
+    const tex_neighbours = new AttributeDataTexture(
+        AttributeSpec.fromJSON({
+            name: "neighbour",
+            type: BinaryDataType.Uint32,
+            itemSize: 4,
+            normalized: false
+        }),
+        256, 1
+    );
+
+    const tex_positions = new AttributeDataTexture(
+        AttributeSpec.fromJSON({
+            name: "positions",
+            type: BinaryDataType.Float32,
+            itemSize: 3,
+            normalized: false
+        }),
+        256, 1
+    );
+
+    const tex_harmonics = new AttributeDataTexture(
+        AttributeSpec.fromJSON({
+            name: "harmonics",
+            type: BinaryDataType.Float32,
+            itemSize: 3,
+            normalized: false
+        }),
+        256, 9
+    );
+
+    vector_buffer_to_attribute_texture(tex_positions, lpv.points, lpv.count, 3);
+    vector_buffer_to_attribute_texture(tex_harmonics, lpv.harmonics, lpv.count * 9, 3);
+    tetrahedral_mesh_to_texture(
+        tex_vertices, tex_neighbours, lpv.mesh
+    );
+
+    return {
+        mesh_vertices: tex_vertices,
+        mesh_neighbours: tex_neighbours,
+
+        probe_positions: tex_positions,
+        probe_values: tex_harmonics
+    };
+}
+
+/**
+ *
+ * @param {AttributeDataTexture} target
+ * @param {number[]} points
+ * @param {number} point_count
+ * @param {number} dimensions
+ */
+function vector_buffer_to_attribute_texture(
+    target,
+    points,
+    point_count,
+    dimensions = 3
+) {
+    if (target.spec.itemSize !== dimensions) {
+        throw new Error(`Expected spec.itemCount = ${dimensions} (number of dimensions), instead got ${target.spec.itemSize}`);
+    }
+
+    target.resize(point_count);
+    target.build();
+
+    array_copy(points, 0, target.data, 0, point_count * dimensions);
+}