@woosh/meep-engine 2.107.0 → 2.108.0

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

@@ -0,0 +1,340 @@
+import { LineBasicMaterial } from "three";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import {
+    build_tetrahedral_mesh_buffer_geometry
+} from "../../../../core/geom/3d/tetrahedra/build_tetrahedral_mesh_buffer_geometry.js";
+import {
+    compute_delaunay_tetrahedral_mesh
+} from "../../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
+import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.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 Entity from "../../../ecs/Entity.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { DrawMode } from "../../ecs/mesh-v2/DrawMode.js";
+import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { visualise_spherical_harmonic_sphere } from "../visualise_spherical_harmonic_sphere.js";
+import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
+
+const TEMP_CONTACT = new SurfacePoint3();
+
+
+class Baker {
+    constructor() {
+        /**
+         *
+         * @type {EntityComponentDataset|null}
+         * @private
+         */
+        this.__ecd = null;
+
+        /**
+         *
+         * @type {BVH|null}
+         * @private
+         */
+        this.__bvh = null;
+
+        this.__min_bounce_count = 3;
+        this.__max_bounce_count = 100;
+
+        this._ren = new PathTracerProbeRenderer();
+    }
+
+    /**
+     * @param {BVH} bvh
+     */
+    set_bvh(bvh) {
+        this.__bvh = bvh;
+    }
+
+    build_spatial() {
+
+    }
+
+    /**
+     *
+     * @param {number[]} irradiance RGB irradiance result is written here
+     * @param {number} bounce_count number of reflections before this trace
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     */
+    trace_ray(irradiance, bounce_count,
+              origin_x, origin_y, origin_z,
+              direction_x, direction_y, direction_z) {
+
+        //
+
+        if (!this.ray_cast(TEMP_CONTACT, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z)) {
+            // no hit, assume irradiance is zeroed - black
+
+            return;
+        }
+
+        // record irradiance
+
+        // reflect ray around normal
+        // TODO apply BDRF to compute reflected ray
+
+        if (bounce_count > this.__max_bounce_count) {
+            // terminate
+        }
+
+    }
+
+    /**
+     *
+     * @param contact
+     * @param origin_x
+     * @param origin_y
+     * @param origin_z
+     * @param direction_x
+     * @param direction_y
+     * @param direction_z
+     * @returns {boolean}
+     */
+    ray_cast(contact,
+             origin_x, origin_y, origin_z,
+             direction_x, direction_y, direction_z
+    ) {
+
+    }
+
+    prepare_scene() {
+
+    }
+
+    /**
+     *
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     */
+    bake_sh3_cube(
+        position, position_offset,
+        output, output_offset
+    ) {
+
+        this._ren.bake(position, position_offset, output, output_offset);
+
+    }
+
+    /**
+     *
+     */
+    async prepare(ecd) {
+
+        this._ren.build_scene(ecd);
+
+        await this._ren.bake_start();
+    }
+
+    finish() {
+        this._ren.bake_end();
+    }
+}
+
+export class LightProbeVolume {
+    constructor() {
+        this.__positions = [];
+
+        this.__mesh = new TetrahedralMesh();
+
+        this.__probe_data = [];
+
+        this.__length = 0;
+    }
+
+    clear() {
+        this.__positions.splice(0, this.__positions.length);
+        this.__probe_data.splice(0, this.__probe_data.length);
+        this.__mesh.clear();
+
+        this.__length = 0;
+    }
+
+    /**
+     *
+     * @return {TetrahedralMesh}
+     */
+    get mesh() {
+        return this.__mesh;
+    }
+
+    get points() {
+        return this.__positions;
+    }
+
+    get harmonics() {
+        return this.__probe_data;
+    }
+
+    get count() {
+        return this.__length;
+    }
+
+    set count(v) {
+        this.__length = v;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    add_point(x, y, z) {
+        const i = this.__length;
+
+        this.__positions[i * 3] = x;
+        this.__positions[i * 3 + 1] = y;
+        this.__positions[i * 3 + 2] = z;
+
+        for (let j = 0; j < 9 * 3; j++) {
+            this.__probe_data[i * 9 * 3 + j] = 1; // fill with white
+        }
+
+        this.__length++;
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} source
+     * @param {number} source_offset
+     */
+    white_probe(index, source, source_offset) {
+        array_copy(source, source_offset, this.__probe_data, index * 9 * 3, 9 * 3);
+    }
+
+    /**
+     * Build tetrahedral mesh
+     */
+    build_mesh() {
+
+        const t0 = performance.now();
+        compute_delaunay_tetrahedral_mesh(this.__mesh, this.__positions, this.__length);
+
+        const t1 = performance.now();
+
+        // optional step to improve memory utilization
+        this.__mesh.compact();
+
+        const t2 = performance.now();
+
+        console.log(`Tetrahedral mesh (${this.__length} points, ${this.__mesh.size()} tets) build took ${t2 - t0}ms`);
+    }
+
+
+    /**
+     * Bake light probes
+     * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
+     */
+    bake(ecd) {
+        const baker = new Baker();
+        // baker.set_bvh(entityManager.getSystem(ShadedGeometrySystem).__bvh_binary);
+
+
+        const tPrepare = promiseTask(new Promise(async (resolve, reject) => {
+            await baker.prepare(ecd);
+
+            resolve();
+        }), 'Prepare');
+
+
+        const probe_count = this.__length;
+        const tBake = countTask(0, probe_count, (i) => {
+
+            baker.bake_sh3_cube(
+                this.__positions, i * 3,
+                this.__probe_data, i * 9 * 3
+            );
+
+        });
+        tBake.estimatedDuration = probe_count;
+
+        tBake.promise().then(() => {
+
+            const duration = tBake.__executedCpuTime;
+
+            console.log(`Baked ${probe_count} probes in ${duration}ms, ~${(duration / probe_count).toFixed(2)}ms per probe`);
+
+        })
+
+        const tFinish = actionTask(() => {
+            baker.finish();
+        });
+
+        tFinish.addDependency(tBake);
+        tBake.addDependency(tPrepare);
+
+        return new TaskGroup([
+            tPrepare, tBake, tFinish
+        ], "LightProbeVolume Bake");
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {number} size
+     * @param {boolean} shadow
+     */
+    visualize_probes({ ecd, size = 0.2, shadow = false }) {
+        for (let i = 0; i < this.__length; i++) {
+            visualise_spherical_harmonic_sphere({
+                size,
+                position: this.__positions,
+                position_offset: i * 3,
+                sh: this.__probe_data,
+                sh_offset: i * 3 * 9,
+                shadow: shadow
+            }).build(ecd);
+        }
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {string|number} color CSS color definition
+     * @param {number} opacity
+     */
+    visualize_mesh({ ecd, color = '#FF00FF', opacity = 0.35 }) {
+
+        const geometry = build_tetrahedral_mesh_buffer_geometry(this.__mesh, this.__positions);
+
+        const sg = ShadedGeometry.from(geometry, new LineBasicMaterial({
+            color: color,
+            transparent: true,
+            opacity,
+            depthWrite: false
+        }), DrawMode.LineSegments);
+
+        sg.clearFlag(ShadedGeometryFlags.CastShadow);
+        sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+        new Entity()
+            .add(sg)
+            .add(new Transform())
+            .build(ecd);
+    }
+
+    /**
+     *
+     * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
+     */
+    build(ecd) {
+        this.build_mesh();
+        return this.bake(ecd);
+    }
+}

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

@@ -0,0 +1,18 @@
+export class LightProbeVolumeSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass: typeof LightProbeVolume;
+    /**
+     *
+     * @param buffer
+     * @param {LightProbeVolume} value
+     */
+    serialize(buffer: any, value: LightProbeVolume): void;
+    /**
+     *
+     * @param buffer
+     * @param {LightProbeVolume} value
+     */
+    deserialize(buffer: any, value: LightProbeVolume): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { LightProbeVolume } from "./LightProbeVolume.js";
+//# sourceMappingURL=LightProbeVolumeSerializationAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightProbeVolumeSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeSerializationAdapter.js"],"names":[],"mappings":"AAGA;IAEI,+BAAwB;IAGxB;;;;OAIG;IACH,8BAFW,gBAAgB,QAY1B;IAED;;;;OAIG;IACH,gCAFW,gBAAgB,QAc1B;CACJ;gDA3C+C,gEAAgE;iCAC/E,uBAAuB"}

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

@@ -0,0 +1,44 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { LightProbeVolume } from "./LightProbeVolume.js";
+
+export class LightProbeVolumeSerializationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = LightProbeVolume
+    version = 0
+
+    /**
+     *
+     * @param buffer
+     * @param {LightProbeVolume} value
+     */
+    serialize(buffer, value) {
+        const count = value.count;
+
+        buffer.writeUint32(count);
+        // write probe position data
+        buffer.writeFloat32Array(value.points, 0, count * 3);
+        // probe values
+        buffer.writeFloat32Array(value.harmonics, 0, count * 27);
+
+        value.mesh.serialize(buffer);
+    }
+
+    /**
+     *
+     * @param buffer
+     * @param {LightProbeVolume} value
+     */
+    deserialize(buffer, value) {
+        value.clear();
+
+        const count = buffer.readUint32();
+
+        value.count = count;
+
+        buffer.readFloat32Array(value.points, 0, count * 3);
+        buffer.readFloat32Array(value.harmonics, 0, count * 27);
+
+
+        value.mesh.deserialize(buffer);
+    }
+}

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

@@ -0,0 +1,12 @@
+export class PathTracerProbeRenderer extends ProbeRenderer {
+    tracer: PathTracer;
+    sample_count: number;
+    random: () => number;
+    scene: PathTracedScene;
+    bake(position: any, position_offset: any, output: any, output_offset: any): void;
+    build_scene(ecd: any): void;
+}
+import { ProbeRenderer } from "./ProbeRenderer.js";
+import { PathTracer } from "../path_tracer/PathTracer.js";
+import { PathTracedScene } from "../path_tracer/PathTracedScene.js";
+//# sourceMappingURL=PathTracerProbeRenderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AAoBA;IACI,mBAA0B;IAC1B,qBAAoB;IACpB,qBAAyB;IAEzB,uBAA6B;IAE7B,iFA+CC;IASD,4BAsCC;CACJ;8BA5G6B,oBAAoB;2BADvB,8BAA8B;gCADzB,mCAAmC"}

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