@woosh/meep-engine 2.43.3 → 2.43.5

package/engine/graphics/sh3/LightProbeVolume.js

@@ -0,0 +1,595 @@
+import { TetrahedralMesh } from "../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
+import {
+    compute_delaunay_tetrahedral_mesh
+} from "../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
+import { visualise_probe } from "./visualise_probe.js";
+import {
+    build_tetrahedral_mesh_buffer_geometry
+} from "../../../core/geom/3d/tetrahedra/build_tetrahedral_mesh_buffer_geometry.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import {
+    CubeCamera,
+    LinearEncoding,
+    LinearFilter,
+    LineBasicMaterial,
+    RGBAFormat,
+    Scene,
+    WebGLCubeRenderTarget
+} from "three";
+import { DrawMode } from "../ecs/mesh-v2/DrawMode.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
+import { Light } from "../ecs/light/Light.js";
+import { threeMakeLight } from "../ecs/light/binding/three/threeMakeLight.js";
+import { ThreeLightCache } from "../ecs/light/three/ThreeLightCache.js";
+import { applyTransformToThreeObject } from "../ecs/mesh/applyTransformToThreeObject.js";
+import { build_three_object } from "../ecs/mesh-v2/build_three_object.js";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { v3_length_sqr } from "../../../core/geom/v3_length_sqr.js";
+
+const TEMP_CONTACT = new SurfacePoint3();
+
+/**
+ * evaluate the basis functions
+ * shBasis is an Array[ 9 ]
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} shBasis
+ */
+function getBasisAt(x, y, z, shBasis) {
+
+    // normal is assumed to be unit length
+
+
+    // band 0
+    shBasis[0] = 0.282095;
+
+    // band 1
+    shBasis[1] = 0.488603 * y;
+    shBasis[2] = 0.488603 * z;
+    shBasis[3] = 0.488603 * x;
+
+    // band 2
+    shBasis[4] = 1.092548 * x * y;
+    shBasis[5] = 1.092548 * y * z;
+    shBasis[6] = 0.315392 * (3 * z * z - 1);
+    shBasis[7] = 1.092548 * x * z;
+    shBasis[8] = 0.546274 * (x * x - y * y);
+
+}
+
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {THREE.WebGLRenderer} renderer
+ * @param {THREE.WebGLCubeRenderTarget} cubeRenderTarget
+ * @return {Float64Array}
+ */
+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
+            getBasisAt(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 < 27; j += 3) {
+
+                coefficients[j] += sh_basis[j] * color_r;
+                coefficients[j + 1] += sh_basis[j] * color_g;
+                coefficients[j + 2] += sh_basis[j] * color_b;
+
+            }
+
+        }
+
+    }
+
+    // normalize
+    const norm = (4 * Math.PI) / total_weight;
+
+    for (let j = 0; j < 27; j++) {
+
+        coefficients[j] *= norm;
+
+    }
+
+    return coefficients;
+
+}
+
+
+class CubeRenderer {
+    constructor() {
+        /**
+         *
+         * @type {GraphicsEngine|null}
+         */
+        this.ge = null;
+
+        /**
+         *
+         * @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();
+    }
+
+    /**
+     *
+     * @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);
+
+            object3D.material = sg.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) => {
+
+            const object = threeMakeLight(light, lightCache);
+            applyTransformToThreeObject(object, t);
+
+            this.__scene.add(object);
+        });
+
+        // this.__scene.add(this.__cube_camera);
+    }
+
+    bake_start() {
+        // this.__renderer = WebGLRendererPool.global.get();
+
+        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.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;
+    }
+}
+
+class Baker {
+    constructor() {
+        /**
+         *
+         * @type {EntityComponentDataset|null}
+         * @private
+         */
+        this.__ecd = null;
+
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
+         * @private
+         */
+        this.__bvh = null;
+
+        this.__min_bounce_count = 3;
+        this.__max_bounce_count = 100;
+
+        this._ren = new CubeRenderer();
+    }
+
+    /**
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} 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);
+
+    }
+
+    /**
+     *
+     * @param {Engine} engine
+     */
+    prepare(engine) {
+        this._ren.ge = engine.graphics;
+
+        this._ren.build_scene(engine.entityManager.dataset);
+
+        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;
+    }
+
+    /**
+     *
+     * @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
+     * @param {Engine} engine
+     */
+    bake(engine) {
+        const baker = new Baker();
+        // baker.set_bvh(entityManager.getSystem(ShadedGeometrySystem).__bvh_binary);
+
+        baker.prepare(engine);
+
+        const t0 = performance.now();
+
+
+        for (let i = 0; i < this.__length; i++) {
+
+            baker.bake_sh3_cube(
+                this.__positions, i * 3,
+                this.__probe_data, i * 9 * 3
+            );
+
+        }
+
+        const t1 = performance.now();
+
+        console.log(`Baked ${this.__length} probes in ${(t1 - t0)}ms, ~${((t1 - t0) / this.__length).toFixed(2)}ms per probe`);
+
+        baker.finish();
+    }
+
+    /**
+     *
+     * @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_probe({
+                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
+     */
+    visualize_mesh({ ecd, color = '#FF00FF' }) {
+
+        const geometry = build_tetrahedral_mesh_buffer_geometry(this.__mesh, this.__positions);
+
+        const sg = ShadedGeometry.from(geometry, new LineBasicMaterial({
+            color: color,
+            transparent: true,
+            opacity: 0.35,
+            depthWrite: false
+        }), DrawMode.LineSegments);
+
+        sg.clearFlag(ShadedGeometryFlags.CastShadow);
+        sg.clearFlag(ShadedGeometryFlags.ReceiveShadow);
+
+        new EntityBuilder()
+            .add(sg)
+            .add(new Transform())
+            .build(ecd);
+    }
+
+    /**
+     *
+     * @param {Engine} engine
+     */
+    build(engine) {
+        this.build_mesh();
+        this.bake(engine);
+    }
+}

package/engine/graphics/sh3/SH3VisualisationMaterial.js

@@ -0,0 +1,79 @@
+import { ShaderMaterial, Vector3 } from "three";
+
+const shader_vx = `
+varying vec3 vNormal;
+
+void main() {
+    
+    vNormal = normalize( normalMatrix * normal );
+    
+    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+}
+`;
+
+const shader_fg = `
+#define RECIPROCAL_PI 0.318309886
+
+vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {
+	// matrix is assumed to be orthogonal
+	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );
+}
+
+// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf
+vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+	// normal is assumed to have unit length
+	float x = normal.x, y = normal.y, z = normal.z;
+	// band 0
+	vec3 result = shCoefficients[ 0 ] * 0.886227;
+	// band 1
+	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
+	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
+	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+	// band 2
+	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
+	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
+	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
+	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
+	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
+	
+	return result;
+}
+
+uniform vec3 sh[ 9 ]; // sh coefficients
+uniform float intensity; // light probe intensity
+varying vec3 vNormal;
+
+void main() {
+	vec3 normal = normalize( vNormal );
+	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );
+	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;
+	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );
+}
+`;
+
+export class SH3VisualisationMaterial extends ShaderMaterial {
+
+    constructor() {
+        const sh = [];
+
+        for (let i = 0; i < 9; i++) {
+            sh.push(new Vector3());
+        }
+
+        super({
+            fragmentShader: shader_fg,
+            vertexShader: shader_vx,
+            uniforms: {
+                intensity: {
+                    value: 1,
+                },
+                sh: {
+                    value: sh
+                }
+            }
+        })
+    }
+
+}