@woosh/meep-engine 2.106.1 → 2.108.0

package/src/engine/graphics/sh3/fromCubeRenderTarget.js

@@ -0,0 +1,145 @@
+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 { v3_length_sqr } from "../../../core/geom/vec3/v3_length_sqr.js";
+
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {THREE.WebGLRenderer} renderer
+ * @param {THREE.WebGLCubeRenderTarget} cubeRenderTarget
+ * @return {Float64Array}
+ */
+export function fromCubeRenderTarget(
+    data,
+    renderer,
+    cubeRenderTarget
+) {
+
+    // The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
+    let total_weight = 0;
+
+    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);
+
+    const image_size = cubeRenderTarget.width;
+
+    const pixel_size = 2 / image_size;
+
+    let normal_x = 0, normal_y = 0, normal_z = 0;
+
+    for (let faceIndex = 0; faceIndex < 6; faceIndex++) {
+
+        renderer.readRenderTargetPixels(cubeRenderTarget, 0, 0, image_size, image_size, data, faceIndex);
+
+        // RGBA assumed
+
+        for (let i = 0, il = data.length; i < il; i += 4) {
+
+
+            // pixel coordinate on unit cube
+
+            const pixelIndex = i / 4;
+
+            const col = -1 + (pixelIndex % image_size + 0.5) * pixel_size;
+
+            const row = 1 - (Math.floor(pixelIndex / image_size) + 0.5) * pixel_size;
+
+
+            switch (faceIndex) {
+
+                case 0:
+                    normal_x = 1;
+                    normal_y = row;
+                    normal_z = -col;
+                    break;
+
+                case 1:
+                    normal_x = -1;
+                    normal_y = row;
+                    normal_z = col;
+                    break;
+
+                case 2:
+                    normal_x = col;
+                    normal_y = 1;
+                    normal_z = -row;
+                    break;
+
+                case 3:
+                    normal_x = col;
+                    normal_y = -1;
+                    normal_z = row;
+                    break;
+
+                case 4:
+                    normal_x = col;
+                    normal_y = row;
+                    normal_z = 1;
+                    break;
+
+                case 5:
+                    normal_x = -col;
+                    normal_y = row;
+                    normal_z = -1;
+                    break;
+
+            }
+
+            // weight assigned to this pixel
+
+            const length_squared = v3_length_sqr(normal_x, normal_y, normal_z);
+
+            const length = Math.sqrt(length_squared);
+
+            const weight = 4 / (length * length_squared);
+
+            total_weight += weight;
+
+            // direction vector to this pixel
+            normal_x /= length;
+            normal_y /= length;
+            normal_z /= length;
+
+            // evaluate SH basis functions in direction dir
+            sh3_basis_at(normal_x, normal_y, normal_z, sh_basis);
+
+            // pixel color, already in linear space so no sRGB->Linear conversion necessary
+
+            // 0.003921 constant value is 1/255, a conversion value from UINT8 to normalized float
+            const weight_conv = weight * 0.00392156862745098;
+
+            const color_r = data[i] * weight_conv;
+            const color_g = data[i + 1] * weight_conv;
+            const color_b = data[i + 2] * weight_conv;
+
+            // accumulate
+            for (let j = 0; j < 9; j++) {
+
+                const j3 = j * 3;
+
+                coefficients[j3] += sh_basis[j] * color_r;
+                coefficients[j3 + 1] += sh_basis[j] * color_g;
+                coefficients[j3 + 2] += sh_basis[j] * color_b;
+
+            }
+
+        }
+
+    }
+
+    // normalize
+    const norm = (4 * Math.PI) / total_weight;
+
+    for (let j = 0; j < 27; j++) {
+
+        coefficients[j] *= norm;
+
+    }
+
+    sh3_dering_optimize_positive(coefficients, 0, coefficients, 0, 3);
+
+    return coefficients;
+
+}

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Assumes that the mesh is compacted
+ * @param {AttributeDataTexture} vertices
+ * @param {AttributeDataTexture} neighbours
+ * @param {TetrahedralMesh} mesh
+ */
+export function tetrahedral_mesh_to_texture(vertices: AttributeDataTexture, neighbours: AttributeDataTexture, mesh: TetrahedralMesh): void;
+//# sourceMappingURL=tetrahedral_mesh_to_texture.d.ts.map

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_to_texture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2IA0CC"}

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.js

@@ -0,0 +1,51 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Assumes that the mesh is compacted
+ * @param {AttributeDataTexture} vertices
+ * @param {AttributeDataTexture} neighbours
+ * @param {TetrahedralMesh} mesh
+ */
+export function tetrahedral_mesh_to_texture(
+    vertices,
+    neighbours,
+    mesh
+) {
+
+    assert.equal(mesh.isCompacted, true, 'mesh.isCompacted');
+
+    if (mesh.isCompacted !== true) {
+        throw new Error(`mesh is not compacted`);
+    }
+
+    if (vertices.spec.itemSize !== 4) {
+        throw new Error(`vertices texture spec must have itemSize of 4, instead was ${vertices.spec.itemSize}`);
+    }
+
+    if (neighbours.spec.itemSize !== 4) {
+        throw new Error(`neighbours texture spec must have itemSize of 4, instead was ${neighbours.spec.itemSize}`);
+    }
+
+    const tetrahedron_count = mesh.count;
+
+    vertices.resize(tetrahedron_count);
+    neighbours.resize(tetrahedron_count);
+
+    vertices.build()
+    neighbours.build();
+
+    const vertices_data = vertices.data;
+    const neighbours_data = neighbours.data;
+
+    for (let i = 0; i < tetrahedron_count; i++) {
+
+        const i4 = i * 4;
+
+        for (let j = 0; j < 4; j++) {
+            vertices_data[i4 + j] = mesh.getVertexIndex(i, j);
+
+            neighbours_data[i4 + j] = mesh.getNeighbour(i, j);
+        }
+
+    }
+}

package/src/engine/graphics/sh3/{LightProbeVolume.d.ts → lpv/LightProbeVolume.d.ts}

@@ -3,6 +3,16 @@ export class LightProbeVolume {
     __mesh: TetrahedralMesh;
     __probe_data: any[];
     __length: number;
+    clear(): void;
+    /**
+     *
+     * @return {TetrahedralMesh}
+     */
+    get mesh(): TetrahedralMesh;
+    get points(): any[];
+    get harmonics(): any[];
+    set count(arg: number);
+    get count(): number;
     /**
      *
      * @param {number} x
@@ -23,10 +33,10 @@ export class LightProbeVolume {
     build_mesh(): void;
     /**
      * Bake light probes
-     * @param {Engine} engine
      * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
      */
-    bake(engine: Engine): TaskGroup;
+    bake(ecd: EntityComponentDataset): TaskGroup;
     /**
      *
      * @param {EntityComponentDataset} ecd
@@ -38,15 +48,16 @@ export class LightProbeVolume {
      *
      * @param {EntityComponentDataset} ecd
      * @param {string|number} color CSS color definition
+     * @param {number} opacity
      */
-    visualize_mesh({ ecd, color }: EntityComponentDataset): void;
+    visualize_mesh({ ecd, color, opacity }: EntityComponentDataset): void;
     /**
      *
-     * @param {Engine} engine
      * @returns {TaskGroup}
+     * @param {EntityComponentDataset} ecd
      */
-    build(engine: Engine): TaskGroup;
+    build(ecd: EntityComponentDataset): TaskGroup;
 }
-import { TetrahedralMesh } from "../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
-import TaskGroup from "../../../core/process/task/TaskGroup.js";
+import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
+import TaskGroup from "../../../../core/process/task/TaskGroup.js";
 //# sourceMappingURL=LightProbeVolume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAiJA;IAEQ,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAMC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA4CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAHa,SAAS,CAMrB;CACJ;gCA1U+B,wDAAwD;sBAClE,4CAA4C"}

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