@woosh/meep-engine 2.43.16 → 2.43.18

package/engine/graphics/sh3/path_tracer/PathTracer.js

@@ -0,0 +1,469 @@
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/bvh_query_leaves_ray.js";
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { mat4, vec3 } from "gl-matrix";
+import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.js";
+import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
+import { PathTracedMesh } from "./PathTracedMesh.js";
+import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
+import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
+import {
+    LinearEncoding,
+    LinearFilter,
+    LinearMipmapLinearFilter,
+    NearestFilter,
+    NearestMipMapLinearFilter,
+    sRGBEncoding,
+    UnsignedByteType
+} from "three";
+import { linear_to_sRGB } from "../../../../core/color/linear_to_sRGB.js";
+import { random_in_hemisphere } from "./random_in_hemisphere.js";
+import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
+import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
+import { make_sky_rtiw } from "./make_sky_rtiw.js";
+import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
+
+/*
+ Ray hit data layout:
+ position: v3
+ normal: v3
+ t: float
+ u: float
+ v: float
+ primitive_index: uint
+ instance_id: uint
+ */
+
+const temp_ray_results = [];
+
+const texture_uv = [0, 0];
+const color = [];
+
+const irradiance = [0, 0, 0];
+const trace_result = [];
+
+const _ray = [];
+
+const tmp = [];
+
+
+export class PathTracer {
+    constructor() {
+
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy}
+         */
+        this.bvh_top_level = new ExplicitBinaryBoundingVolumeHierarchy();
+
+        /**
+         *
+         * @type {Map<number, PathTracedMesh>}
+         */
+        this.meshes = new Map();
+
+        /**
+         *
+         * @type {Map<number, Light>}
+         */
+        this.lights = new Map();
+
+        /**
+         *
+         * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+         */
+        this.geo_cache = new Map();
+
+        /**
+         *
+         * @type {Map<THREE.Texture, Sampler2D>}
+         */
+        this.textures = new Map();
+
+        /**
+         *
+         * @type {function}
+         * @private
+         */
+        this.__background_sampler = make_sky_rtiw();
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @return {GeometryBVHBatched}
+     */
+    obtainGeometryBVH(geo) {
+        const cached = this.geo_cache.get(geo);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const bvh8 = new GeometryBVHBatched();
+
+        bvh8.build(geo);
+
+        this.geo_cache.set(geo, bvh8);
+
+        return bvh8;
+    }
+
+    optimize() {
+        this.bvh_top_level.trim();
+        this.bvh_top_level.sort_for_traversal_depth_first();
+    }
+
+    async build() {
+        for (const [id, mesh] of this.meshes) {
+            const material = mesh.material;
+
+            //patch textures
+            const materialType = material.type;
+
+            /**
+             *
+             * @type {TextureAttachment[]}
+             */
+            const attachments = TextureAttachmentsByMaterialType[materialType];
+
+            if (attachments === undefined) {
+                // unsupported
+                continue;
+            }
+
+            for (let i = 0; i < attachments.length; i++) {
+                const attachment = attachments[i];
+
+                const texture = attachment.read(material);
+
+                if (texture === undefined || texture === null) {
+                    continue;
+                }
+
+                if (this.textures.has(texture.id)) {
+                    continue;
+                }
+
+                const sampler2D = convertTexture2Sampler2D(texture, undefined, undefined, false);
+
+                this.textures.set(texture.id, sampler2D);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @param {THREE.Material} material
+     * @param {mat4|number[]} transform
+     */
+    addMesh(geo, material, transform) {
+        //meshopt_optimizeVertexCache(geo.getIndex().array, geo.getIndex().array, geo.getIndex().array.length, geo.getAttribute('position').count);
+
+        const mesh = new PathTracedMesh();
+        mesh.geometry = geo;
+        mesh.material = material;
+        mesh.transform = transform;
+
+
+        mesh.geo_bvh = this.obtainGeometryBVH(geo);
+
+        const bvh = this.bvh_top_level;
+
+        const bvh_node_id = bvh.allocate_node();
+
+        mesh.__bvh_node_id = bvh_node_id;
+
+        ensureGeometryBoundingBox(geo);
+
+        const aabb = [
+            geo.boundingBox.min.x,
+            geo.boundingBox.min.y,
+            geo.boundingBox.min.z,
+            geo.boundingBox.max.x,
+            geo.boundingBox.max.y,
+            geo.boundingBox.max.z,
+        ];
+
+        const aabb_t = [];
+
+        aabb3_matrix4_project(aabb_t, aabb, transform);
+
+        bvh.node_set_aabb(
+            bvh_node_id,
+            aabb_t
+        );
+        bvh.node_set_user_data(
+            bvh_node_id,
+            mesh.id
+        );
+        bvh.insert_leaf(bvh_node_id);
+
+        this.meshes.set(mesh.id, mesh);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {Texture} texture
+     * @param {number} u
+     * @param {number} v
+     */
+    sample_texture(out, texture, u, v) {
+        if (texture === undefined || texture == null) {
+            return;
+        }
+
+        const sampler = this.textures.get(texture.id);
+
+        if (sampler === undefined) {
+            return;
+        }
+
+        // TODO apply texture matrix transform
+
+        const _u = apply_texture_clamping_to_coordinate(texture.wrapS, u);
+        const _v = apply_texture_clamping_to_coordinate(texture.wrapT, v);
+
+        const magFilter = texture.magFilter;
+
+        switch (magFilter) {
+            default:
+            case NearestFilter:
+            case NearestMipMapLinearFilter:
+                sampler.sampleNearestUV(_u, _v, out);
+                break;
+
+            case LinearFilter:
+            case LinearMipmapLinearFilter:
+
+                sampler.sampleBicubicUV(_u, _v, out);
+                break;
+        }
+
+        if (texture.type === UnsignedByteType) {
+            vec3_uint8_to_float(out, out);
+        }
+
+        const texture_encoding = texture.encoding;
+
+        if (texture_encoding === LinearEncoding) {
+            // nothing
+        } else if (texture_encoding === sRGBEncoding) {
+            // convert value to sRGB
+            linear_to_sRGB(out, 0, out, 0);
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} hit
+     */
+    sample_material(out, hit) {
+        const primitive_id = hit[9];
+        const instance_id = hit[10];
+        const u = hit[7];
+        const v = hit[8];
+
+        out[0] = 1;
+        out[1] = 1;
+        out[2] = 1;
+
+        /**
+         *
+         * @type {PathTracedMesh}
+         */
+        const mesh = this.meshes.get(instance_id);
+
+        if (mesh === undefined) {
+            // instance not found
+            return;
+        }
+
+        const geometry = mesh.geometry;
+        const index_attribute = geometry.getIndex();
+        const index_array = index_attribute.array;
+
+
+        // sample surface normal
+        const index_offset = primitive_id * 3;
+
+        const index_0 = index_array[index_offset];
+        const index_1 = index_array[index_offset + 1];
+        const index_2 = index_array[index_offset + 2];
+
+        const normal_attribute = geometry.getAttribute('normal');
+
+        if (normal_attribute !== undefined) {
+            // vertex normals are present, use those
+            const normal_array = normal_attribute.array;
+
+            sample_triangle_attribute(out, 3, index_0, index_1, index_2, normal_array, 3, u, v);
+        } else {
+            // copy hit normal
+            array_copy(hit, 3, out, 3, 3);
+        }
+
+
+        const uv_attribute = geometry.getAttribute('uv');
+
+        if (uv_attribute !== undefined) {
+            const uv_array = uv_attribute.array;
+            sample_triangle_attribute(texture_uv, 0, index_0, index_1, index_2, uv_array, 2, u, v);
+        } else {
+            // default texture uv
+            texture_uv[0] = 0;
+            texture_uv[1] = 0;
+        }
+
+        const material = mesh.material;
+
+        if (material.isMeshStandardMaterial) {
+            out[0] *= material.color.r;
+            out[1] *= material.color.g;
+            out[2] *= material.color.b;
+
+            const diffuse_map = material.map;
+
+            if (diffuse_map !== null) {
+                this.sample_texture(color, diffuse_map, texture_uv[0], texture_uv[1]);
+
+                vec3.multiply(out, out, color);
+            }
+
+        } else {
+            // unsupported
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @return {number}
+     */
+    trace(out, ray, min_distance, max_distance) {
+        const bvh = this.bvh_top_level;
+        const hit_count = bvh_query_leaves_ray(bvh, temp_ray_results, 0, ray[0], ray[1], ray[2], ray[3], ray[4], ray[5]);
+
+        let nearest_hit_distance = max_distance;
+        let nearest_mesh = null;
+
+
+        for (let i = 0; i < hit_count; i++) {
+            const node_id = temp_ray_results[i];
+
+            const node_user_data = bvh.node_get_user_data(node_id);
+
+            const mesh = this.meshes.get(node_user_data);
+
+            const distance_to_hit = mesh.hit(tmp, ray, min_distance, nearest_hit_distance);
+
+            if (distance_to_hit >= 0) {
+                // since raycast in leaf nodes is already bound by maximum distance, any hit we get is necessarily a closer hit than before
+                nearest_hit_distance = distance_to_hit;
+                nearest_mesh = mesh;
+
+                array_copy(tmp, 0, out, 0, 11);
+            }
+        }
+
+        if (nearest_hit_distance !== max_distance) {
+
+            // out[6] = nearest_mesh;
+
+            return nearest_hit_distance;
+        }
+
+        return -1;
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} direction
+     * @param {number} direction_offset
+     */
+    sample_background(out, out_offset, direction, direction_offset) {
+
+
+        this.__background_sampler(out, out_offset, direction, direction_offset);
+    }
+
+    path_trace(out, ray, max_distance, max_bounce, random = Math.random) {
+        //TODO add importance sampling, see https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
+
+        array_copy(ray, 0, _ray, 0, 6);
+
+        irradiance[0] = 1;
+        irradiance[1] = 1;
+        irradiance[2] = 1;
+
+        let got_emission = false;
+
+        let i;
+        for (i = 0; i < max_bounce; i++) {
+
+            const hit_distance = this.trace(trace_result, _ray, 0.0001, max_distance);
+
+            if (hit_distance < 0) {
+                // ray didn't hit anything
+
+                // sample "environment" and terminate path as there is nothing to reflect off of
+
+                this.sample_background(tmp, 0, _ray, 3);
+
+                vec3.multiply(irradiance, irradiance, tmp);
+
+                got_emission = true;
+
+                break;
+            }
+
+
+            // irradiance[0] += m;
+            // irradiance[1] += m;
+            // irradiance[2] += m;
+            this.sample_material(tmp, trace_result);
+
+            // reflect ray
+            array_copy(trace_result, 0, _ray, 0, 3);
+
+            // getBiasedNormalSample(_ray, 3, tmp, 3, 1, random);
+            random_in_hemisphere(random, _ray, 3, tmp, 3);
+
+            vec3.multiply(irradiance, irradiance, tmp);
+
+        }
+
+        if (got_emission === false) {
+            // no light source was hit, propagate shadow(darkness) along the ray
+            irradiance[0] = 0;
+            irradiance[1] = 0;
+            irradiance[2] = 0;
+        }
+
+        array_copy(irradiance, 0, out, 0, 3);
+    }
+}
+
+/**
+ *
+ * @param {number} material
+ * @param {number} hit
+ */
+function compute_hit_reaction_standard_material(material, hit) {
+
+}
+
+

package/engine/graphics/sh3/path_tracer/apply_texture_clamping_to_coordinate.js

@@ -0,0 +1,22 @@
+import { ClampToEdgeWrapping, RepeatWrapping } from "three";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+
+/**
+ *
+ * @param {number} clamping
+ * @param {number} v
+ * @return {number}
+ */
+export function apply_texture_clamping_to_coordinate(clamping, v) {
+
+    switch (clamping) {
+        case  RepeatWrapping:
+            return v % 1;
+        case ClampToEdgeWrapping:
+            return clamp01(v);
+        default:
+            // unsupported?
+            return v;
+    }
+
+}

package/engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js

@@ -0,0 +1,36 @@
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ * Compute AABB for a group of triangles based on index-buffer
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>} indices
+ * @param {number[]|ArrayLike<number>} positions
+ * @param {number} index_offset
+ * @param {number} index_count
+ * @param {number} d
+ */
+export function compute_triangle_group_aabb3(output, output_offset, indices, positions, index_offset, index_count, d) {
+
+    let i = 0;
+    for (; i < d; i++) {
+        output[output_offset + i] = Infinity;
+        output[output_offset + i + d] = -Infinity;
+    }
+
+    for (i = 0; i < index_count; i++) {
+        for (let j = 0; j < 3; j++) {
+            const index = indices[index_offset + i * 3 + j];
+
+            const i3 = index * d;
+
+            for (let k = 0; k < d; k++) {
+                const v = positions[i3 + k];
+
+                output[output_offset + k] = min2(output[output_offset + k], v);
+                output[output_offset + k + d] = max2(output[output_offset + k + d], v);
+            }
+        }
+    }
+}

package/engine/graphics/sh3/path_tracer/getBiasedNormalSample.js

@@ -0,0 +1,55 @@
+/**
+ * @see 2003 "Global Illumination Compendium" by Philip Dutré (equation 36)
+ * @see http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} normal
+ * @param {number} normal_offset
+ * @param {number} power
+ * @param {function():number} random
+ */
+function getBiasedNormalSample(out, out_offset, normal, normal_offset, power, random) {
+    const dir_x = normal[normal_offset];
+    const dir_y = normal[normal_offset + 1];
+    const dir_z = normal[normal_offset + 2];
+
+    // we build orthonormal vectors with respect to the direction vector
+    let o1_x, o1_y, o1_z;
+
+    if (Math.abs(dir_x) > Math.abs(dir_z)) {
+        o1_x = -dir_y;
+        o1_y = dir_x;
+        o1_z = 0;
+    } else {
+        o1_x = 0;
+        o1_y = -dir_z;
+        o1_z = dir_y;
+    }
+
+    // normalize orthonormal vector
+    const o1_norm = 1 / Math.hypot(o1_x, o1_y, o1_z);
+
+    o1_x *= o1_norm;
+    o1_y *= o1_norm;
+    o1_z *= o1_norm;
+
+    const o2_x = dir_y * o1_z - dir_z * o1_y;
+    const o2_y = dir_z * o1_x - dir_x * o1_z;
+    const o2_z = dir_x * o1_y - dir_y * o1_x;
+
+    // we can skip normalizing second orthonormal vector, as it will be guaranteed to be unit length already
+    // for explanation, see https://math.stackexchange.com/questions/23259/is-the-cross-product-of-two-unit-vectors-itself-a-unit-vector#:~:text=If%20you%20know%20that%20the,(a%20length%20of%20one).
+
+    const r_x = (random()) * 2 * Math.PI;
+    const r_y = Math.pow((random()), 1 / (power + 1));
+
+    const oneminus = Math.sqrt(1.0 - r_y * r_y);
+
+    const k0 = Math.cos(r_x) * oneminus;
+    const k1 = Math.sin(r_x) * oneminus;
+
+
+    out[out_offset] = k0 * o1_x + k1 * o2_x + r_y * dir_x;
+    out[out_offset + 1] = k0 * o1_y + k1 * o2_y + r_y * dir_y;
+    out[out_offset + 2] = k0 * o1_z + k1 * o2_z + r_y * dir_z;
+}

package/engine/graphics/sh3/path_tracer/make_sky_hosek.js

@@ -0,0 +1,44 @@
+import {
+    sky_hosek_compute_irradiance_by_direction,
+    sky_hosek_precompute
+} from "../sky/hosek/sky_hosek_compute_irradiance_by_direction.js";
+import { vec3 } from "gl-matrix";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+export function make_sky_hosek(sun = [0, 1, 0], turbidity = 1, overcast = 0, albedo = [0, 0, 0]) {
+    const coeffs = new Float32Array(27);
+    const rad = new Float32Array([1, 1, 1]);
+    const sun_position = new Float32Array([sun[0], sun[2], sun[1]]);
+
+    vec3.normalize(sun_position, sun_position);
+
+    sky_hosek_precompute(coeffs, rad, sun_position, turbidity, albedo, overcast);
+
+    const v3 = [];
+
+    const value_scale = 8e-5;
+
+    return (result, result_offset, direction, direction_offset) => {
+        const d_x = direction[direction_offset];
+        const d_z = direction[direction_offset + 2];
+        const d_y = direction[direction_offset + 1];
+
+        sky_hosek_compute_irradiance_by_direction(
+            v3, coeffs, rad, sun_position,
+            d_z ,
+            d_x ,
+            d_y ,
+        );
+
+        vec3.scale(v3, v3, value_scale);
+
+        // clamp sky contribution
+        v3[0] = max2(0, v3[0]);
+        v3[1] = max2(0, v3[1]);
+        v3[2] = max2(0, v3[2]);
+
+
+        array_copy(v3, 0, result, result_offset, 3);
+    }
+}

package/engine/graphics/sh3/path_tracer/make_sky_rtiw.js

@@ -0,0 +1,15 @@
+import { lerp } from "../../../../core/math/lerp.js";
+
+export function make_sky_rtiw() {
+    // see https://raytracing.github.io/books/RayTracingInOneWeekend.html
+
+    return (out, out_offset, direction, direction_offset) => {
+
+        const dir_y = direction[direction_offset + 1];
+        const t = 0.5 * (dir_y + 1);
+
+        out[out_offset] = lerp(0.5, 1, t);
+        out[out_offset + 1] = lerp(0.7, 1, t);
+        out[out_offset + 2] = lerp(1, 1, t);
+    }
+}