@woosh/meep-engine 2.107.0 → 2.108.0

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

@@ -1,32 +1,6 @@
-import { mat4, vec3 } from "gl-matrix";
-import {
-    LinearEncoding,
-    LinearFilter,
-    LinearMipmapLinearFilter,
-    NearestFilter,
-    NearestMipMapLinearFilter,
-    sRGBEncoding,
-    UnsignedByteType
-} from "three";
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { ebvh_sort_for_traversal_depth_first } from "../../../../core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js";
-import { bvh_query_user_data_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray.js";
+import { vec3 } from "gl-matrix";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { linear_to_sRGB } from "../../../../core/color/sRGB/linear_to_sRGB.js";
-import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
-import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
-import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
-import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
-import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
-import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.js";
-import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
-import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
 import { getBiasedNormalSample } from "./getBiasedNormalSample.js";
-import { make_one_vector3 } from "./make_one_vector3.js";
-import { PathTracedMesh } from "./PathTracedMesh.js";
-import { transform_normal_m4 } from "./ray_hit_apply_transform.js";
-import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
-import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
 
 /*
  Ray hit data layout:
@@ -39,465 +13,40 @@ import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
  instance_id: uint
  */
 
-const temp_ray_results = [];
-
-const texture_uv = [0, 0];
-const color = [];
 
 const irradiance = [0, 0, 0];
 
 const trace_result = [];
 
 const _ray_0 = [];
-const _ray_1 = [];
 
 const tmp_0 = [];
 const tmp_1 = [];
 
-const null_output = [];
-
+const RUSSIAN_ROULETTE_PROBABILITY = 0.5;
 
 export class PathTracer {
-    constructor() {
-
-        /**
-         *
-         * @type {BVH}
-         */
-        this.bvh_top_level = new BVH();
-
-        /**
-         *
-         * @type {Map<number, PathTracedMesh>}
-         */
-        this.meshes = new Map();
-
-        /**
-         *
-         * @type {AbstractLight[]}
-         */
-        this.__lights = [];
-
-        /**
-         *
-         * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
-         */
-        this.geo_cache = new Map();
-
-        /**
-         * Maps {@link Texture.id} to relevant sampler
-         * @type {Map<number, Sampler2D>}
-         */
-        this.textures = new Map();
-
-        /**
-         *
-         * @type {function}
-         * @private
-         */
-        this.__background_sampler = make_one_vector3();
-    }
-
-    /**
-     *
-     * @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();
-        ebvh_sort_for_traversal_depth_first(this.bvh_top_level);
-    }
-
-    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 {AbstractLight} light
-     */
-    addLight(light) {
-        this.__lights.push(light);
-    }
-
-    /**
-     *
-     * @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.sampleBilinearUV(_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 [color_r, color_g, color_b, normal_x, normal_y, normal_z]
-     * @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);
-
-            // apply transform
-            transform_normal_m4(out, 3, out, 3, mesh.transform);
-        } 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) {
-            const material_color = material.color;
-
-            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}
+     * @param {number} min_bounce
+     * @param {number} max_bounce
+     * @param {function} random
+     * @param {PathTracedScene} scene
      */
-    trace(out, ray, min_distance, max_distance) {
-        const bvh = this.bvh_top_level;
-
-        const hit_count = bvh_query_user_data_ray(
-            bvh, bvh.root,
-            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_user_data = temp_ray_results[i];
-
-            const mesh = this.meshes.get(node_user_data);
-
-            const distance_to_hit = mesh.hit(tmp_0, 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, 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);
-    }
-
-    /**
-     *
-     * @param {number[]} out
-     * @param {number} out_offset
-     * @param {number[]} ray
-     * @param {number} ray_address
-     * @returns {boolean}
-     */
-    sample_lights(out, out_offset, ray, ray_address) {
-        let lights_sampled = false;
-
-        const lights = this.__lights;
-        const light_count = lights.length;
-
-        for (let i = 0; i < 3; i++) {
-            // initialize contribution to 0
-            out[out_offset + i] = 0;
-        }
-
-        for (let i = 0; i < light_count; i++) {
-            const light = lights[i];
-
-            if (light.isDirectionalLight === true) {
-                const dir = light.direction;
-
-                // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
-
-                const ray_direction_x = ray[ray_address + 3];
-                const ray_direction_y = ray[ray_address + 4];
-                const ray_direction_z = ray[ray_address + 5];
-
-                const light_dir_inv_x = -dir.x;
-                const light_dir_inv_y = -dir.y;
-                const light_dir_inv_z = -dir.z;
-
-                const dotNL = v3_dot(
-                    ray_direction_x, ray_direction_y, ray_direction_z,
-                    light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
-                );
-
-                if (dotNL <= 0) {
-                    // no contribution, facing away from the light
-                    continue;
-                }
-
-                const ray_origin_x = ray[ray_address + 0];
-                const ray_origin_y = ray[ray_address + 1];
-                const ray_origin_z = ray[ray_address + 2];
-
-                ray3_array_compose(_ray_1,
-                    ray_origin_x, ray_origin_y, ray_origin_z,
-                    light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
-                );
-
-                // check if there are any obstacles in the direction of the light
-                if (this.trace(null_output, _ray_1, 0.0001, Infinity) > 0) {
-                    // light is occluded
-                    continue;
-                }
-
-
-                const intensity = dotNL * light.intensity.getValue();
-
-                for (let j = 0; j < 3; j++) {
-                    // irradiance
-                    out[out_offset + j] += light.color[j] * intensity;
-                }
-
-                lights_sampled = true;
-            }
-        }
-
-        return lights_sampled;
-    }
-
-    path_trace(out, ray, max_distance, max_bounce, random = Math.random) {
+    path_trace(
+        out,
+        ray,
+        max_distance,
+        min_bounce,
+        max_bounce,
+        random = Math.random,
+        scene
+    ) {
         //TODO add importance sampling, see https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
 
         array_copy(ray, 0, _ray_0, 0, 6);
@@ -507,22 +56,28 @@ export class PathTracer {
         irradiance[2] = 1;
 
         let i;
-        for (i = 0; i < max_bounce; i++) {
+        for (i = 0; i < max_bounce; ++i) {
 
-            const hit_distance = this.trace(trace_result, _ray_0, 0.0001, max_distance);
+            if (i >= min_bounce) {
+                const russian_roulette_roll = random();
+
+                if (russian_roulette_roll > RUSSIAN_ROULETTE_PROBABILITY) {
+                    // terminate ray
+                    break;
+                }
+            }
+
+
+            const hit_distance = scene.trace(trace_result, _ray_0, 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, 0, _ray_0, 3);
-                vec3.multiply(irradiance, irradiance, tmp_0);
-
                 break;
             }
 
-            this.sample_material(tmp_0, trace_result);
+            scene.sample_material(tmp_0, trace_result);
 
             // adjust normal on the hit
             array_copy(tmp_0, 3, trace_result, 3, 3);
@@ -536,17 +91,26 @@ export class PathTracer {
 
         }
 
+
         if (i > 0) {
-            // direct lighting
-            this.sample_lights(tmp_1, 0, trace_result, 0);
+            // light sampling
+            scene.sample_lights(tmp_1, 0, trace_result, 0);
 
             irradiance[0] *= tmp_1[0];
             irradiance[1] *= tmp_1[1];
             irradiance[2] *= tmp_1[2];
+        } else {
+
+            // ray didn't hit anything on the very first bounce
+
+            // sample "environment" and terminate path as there is nothing to reflect off of
+            scene.sample_background(tmp_0, 0, _ray_0, 3);
+            vec3.multiply(irradiance, irradiance, tmp_0);
+
         }
 
-        out[0] =  irradiance[0]
-        out[1] =  irradiance[1]
+        out[0] = irradiance[0]
+        out[1] = irradiance[1]
         out[2] = irradiance[2]
 
         // array_copy(irradiance, 0, out, 0, 3);

package/src/engine/graphics/sh3/path_tracer/make_one_vector3.d.ts

@@ -1,2 +1,3 @@
 export function make_one_vector3(): (out: any, out_offset: any, direction: any, direction_offset: any) => void;
+export function make_vector3(x: any, y: any, z: any): (out: any, out_offset: any, direction: any, direction_offset: any) => void;
 //# sourceMappingURL=make_one_vector3.d.ts.map

package/src/engine/graphics/sh3/path_tracer/make_one_vector3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_one_vector3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/make_one_vector3.js"],"names":[],"mappings":"AAAA,+GAMC"}
+{"version":3,"file":"make_one_vector3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/make_one_vector3.js"],"names":[],"mappings":"AAAA,+GAEC;AACD,iIAMC"}

package/src/engine/graphics/sh3/path_tracer/make_one_vector3.js

@@ -1,7 +1,10 @@
 export function make_one_vector3() {
+    return make_vector3(1,1,1);
+}
+export function make_vector3(x,y,z) {
     return (out, out_offset, direction, direction_offset) => {
-        out[out_offset] = 1;
-        out[out_offset + 1] = 1;
-        out[out_offset + 2] = 1;
+        out[out_offset] = x;
+        out[out_offset + 1] = y;
+        out[out_offset + 2] = z;
     }
 }