@woosh/meep-engine 2.109.20 → 2.109.21

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

@@ -1,12 +1,30 @@
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import {
+    BVH,
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_build_for_geometry_morton } from "../../../../core/bvh2/bvh3/ebvh_build_for_geometry_morton.js";
 import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { aabb3_intersects_ray_segment } from "../../../../core/geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import {
+    computeTriangleClosestPointToPointBarycentric
+} from "../../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
 
 import {
     computeTriangleRayIntersectionBarycentricGeometry
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js";
+import { v3_compute_triangle_normal } from "../../../../core/geom/3d/v3_compute_triangle_normal.js";
+import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { makeGeometryIndexed } from "../../geometry/buffered/makeGeometryIndexed.js";
 import { computeBoundingSphereFromVertexData } from "../../geometry/computeBoundingSphereFromVertexData.js";
@@ -23,6 +41,10 @@ const scratch_uint32_array = new Uint32Array(4096);
  */
 const v3_scratch_0 = [];
 
+const scratch_contact = new SurfacePoint3();
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
 export class BufferedGeometryBVH {
     /**
      * @type {Uint32Array}
@@ -147,40 +169,418 @@ export class BufferedGeometryBVH {
 
         const bvh = this.#bvh;
 
-        const count = bvh_query_user_data_ray_segment(
-            bvh, bvh.root,
-            scratch_uint32_array, 0,
-            origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z,
-            0, max_distance
-        );
+        const root = bvh.root;
 
-        // check triangles found via BVH
-        for (let i = 0; i < count; i++) {
-            const triangle_index = scratch_uint32_array[i];
+        if (root === NULL_NODE) {
+            return -1;
+        }
 
-            const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
-                v3_scratch_0,
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+        const inv_direction_x = 1 / direction_x;
+        const inv_direction_y = 1 / direction_y;
+        const inv_direction_z = 1 / direction_z;
+
+        do {
+
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+            const intersects = aabb3_intersects_ray_segment(
+                float32[address], float32[address + 1], float32[address + 2],
+                float32[address + 3], float32[address + 4], float32[address + 5],
                 origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z,
-                indices, triangle_index,
-                positions
+                inv_direction_x, inv_direction_y, inv_direction_z,
+                0, max_distance
             );
 
-            if (!intersection_found) {
+            if (!intersects) {
                 continue;
             }
 
-            const t = v3_scratch_0[0];
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                stack[pointer++] = child_2;
+                stack[pointer++] = child_1;
+
+
+            } else {
+                // leaf node
+
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
+                    v3_scratch_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z,
+                    indices, triangle_index,
+                    positions
+                );
+
+                if (!intersection_found) {
+                    continue;
+                }
+
+                const t = v3_scratch_0[0];
+
+                if (t < max_distance && t > 0) {
+                    return true;
+
+                }
 
-            if (t < max_distance && t > 0) {
-                return true;
             }
-        }
+        } while (pointer > stack_top);
+
 
         return false;
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} result
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {boolean} true if result is found, only false when geometry is empty
+     */
+    nearestSurfacePoint(result, x, y, z) {
+
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const bvh = this.#bvh;
+
+        const root = bvh.root;
+
+        if (root === NULL_NODE) {
+            return false;
+        }
+
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+        let nearest_distance_sqr = Infinity;
+
+
+        do {
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+
+
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                // to achieve faster convergence, we sort children before adding them to the stack by their proximity to the reference point
+                const child_1_address = child_1 * ELEMENT_WORD_COUNT;
+
+                const distance_sqr_to_child1 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_1_address], float32[child_1_address + 1], float32[child_1_address + 2],
+                    float32[child_1_address + 3], float32[child_1_address + 4], float32[child_1_address + 5],
+                    x, y, z
+                );
+
+                const child_2_address = child_2 * ELEMENT_WORD_COUNT;
+
+                const distance_sqr_to_child2 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_2_address], float32[child_2_address + 1], float32[child_2_address + 2],
+                    float32[child_2_address + 3], float32[child_2_address + 4], float32[child_2_address + 5],
+                    x, y, z
+                );
+
+                if (distance_sqr_to_child1 < distance_sqr_to_child2) {
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[pointer++] = child_2;
+                    }
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[pointer++] = child_1;
+                    }
+
+                } else {
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[pointer++] = child_1;
+                    }
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[pointer++] = child_2;
+                    }
+
+                }
+
+
+            } else {
+                // leaf node
+                // read triangle data
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const a = indices[triangle_index];
+                const b = indices[triangle_index + 1];
+                const c = indices[triangle_index + 2];
+
+
+                const a_address = a * 3;
+                const b_address = b * 3;
+                const c_address = c * 3;
+
+                const ax = positions[a_address];
+                const ay = positions[a_address + 1];
+                const az = positions[a_address + 2];
+
+                const bx = positions[b_address];
+                const by = positions[b_address + 1];
+                const bz = positions[b_address + 2];
+
+                const cx = positions[c_address];
+                const cy = positions[c_address + 1];
+                const cz = positions[c_address + 2];
+
+                computeTriangleClosestPointToPointBarycentric(
+                    v3_scratch_0, 0,
+                    x, y, z,
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
+                );
+
+                const u = v3_scratch_0[0];
+                const v = v3_scratch_0[1];
+
+                // construct edge
+
+                const contact_x = (bx - ax) * u + (cx - ax) * v + ax;
+                const contact_y = (by - ay) * u + (cy - ay) * v + ay;
+                const contact_z = (bz - az) * u + (cz - az) * v + az;
+
+                const distance_to_triangle_sqr = v3_distance_sqr(contact_x, contact_y, contact_z, x, y, z);
+
+                if (distance_to_triangle_sqr >= nearest_distance_sqr) {
+                    continue;
+                }
+
+                nearest_distance_sqr = distance_to_triangle_sqr;
+
+                result.position.set(contact_x, contact_y, contact_z);
+
+                v3_compute_triangle_normal(result.normal, 0,
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
+                );
+
+                result.index = triangle_index;
+            }
+        } while (pointer > stack_top);
+
+
+        return true;
+    }
+
+
+    /**
+     * Code is largely inlined, to avoid extra checks
+     * NOTE: raycast is performed in local coordinate space
+     * @param {number[]} output
+     * @param {number[]|Ray3} ray
+     * @returns {number} distance along the ray, negative if no hit
+     */
+    raycast2(output, ray) {
+
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const origin_x = ray[0];
+        const origin_y = ray[1];
+        const origin_z = ray[2];
+
+        const direction_x = ray[3];
+        const direction_y = ray[4];
+        const direction_z = ray[5];
+
+        const max_distance = ray[6];
+
+        const bvh = this.#bvh;
+
+        const root = bvh.root;
+
+        if (root === NULL_NODE) {
+            return -1;
+        }
+
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        let nearest_hit_distance = max_distance;
+
+        let best_index = -1;
+        let best_u = 0;
+        let best_v = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+
+        const inv_direction_x = 1 / direction_x;
+        const inv_direction_y = 1 / direction_y;
+        const inv_direction_z = 1 / direction_z;
+
+        do {
+
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+            const intersects = aabb3_intersects_ray_segment(
+                float32[address], float32[address + 1], float32[address + 2],
+                float32[address + 3], float32[address + 4], float32[address + 5],
+                origin_x, origin_y, origin_z,
+                inv_direction_x, inv_direction_y, inv_direction_z,
+                0, nearest_hit_distance
+            );
+
+            if (!intersects) {
+                continue;
+            }
+
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                stack[pointer++] = child_2;
+                stack[pointer++] = child_1;
+
+            } else {
+                // leaf node
+
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
+                    v3_scratch_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z,
+                    indices, triangle_index,
+                    positions
+                );
+
+                if (!intersection_found) {
+                    continue;
+                }
+
+                const t = v3_scratch_0[0];
+
+                if (t < nearest_hit_distance && t > 0) {
+                    nearest_hit_distance = t;
+
+                    best_index = triangle_index;
+                    best_u = v3_scratch_0[1];
+                    best_v = v3_scratch_0[2];
+
+                }
+
+            }
+        } while (pointer > stack_top);
+
+        if (nearest_hit_distance === max_distance) {
+            // no hit
+            return -1;
+        }
+
+        construct_ray_hit_from_geometry(output, indices, positions, best_index, nearest_hit_distance, best_u, best_v);
+
+        return nearest_hit_distance;
+    }
+
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output

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

@@ -126,7 +126,7 @@ export class PathTracedMesh {
 
         local_ray.applyMatrix4(m4);
 
-        let distance_to_hit = this.bvh.raycast(out, local_ray);
+        let distance_to_hit = this.bvh.raycast2(out, local_ray);
 
         if (distance_to_hit >= 0) {
             // transform output

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

@@ -67,8 +67,8 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 1;
-const PIXEL_RENDER_RATIO = 0.5;
+const PIXEL_SAMPLE_COUNT = 16;
+const PIXEL_RENDER_RATIO = 1;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();
@@ -534,8 +534,8 @@ async function start_renderer(camera) {
     // await prepare_scene_lucy(scene, camera);
     // await prepare_scene_rtiow(pt, camera);
     // await prepare_scene_sphere_01(pt, camera);
-    // await prepare_gi_box_scene(scene, camera);
-    await prepare_sponza(scene, camera);
+    await prepare_gi_box_scene(scene, camera);
+    // await prepare_sponza(scene, camera);
     // await prepare_attic_scene(scene, camera);
     // await prepare_scene_gltf({scene, camera, path, url: path});
 

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

@@ -246,7 +246,7 @@ async function getVolume({
         engine,
         ecd,
         bounds: mesh_bounds,
-        density: 5000
+        density: 500
     });
 
     const buffer = new BinaryBuffer();
@@ -378,7 +378,6 @@ async function main(engine) {
     // const path = 'data/models/samples/ancient_bath_house_-_modular_set/scene.gltf';
     // const path = 'data/models/samples/environment_-_library/scene.gltf';
     // const path = 'data/models/Scans/green_car_wreck/scene.gltf';
-    // const path = 'data/models/samples/low_poly_classroom/no-glass/model.gltf';
     // const path = 'data/models/samples/the_attic_environment/scene1.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/samples/cyberpunk_bike/scene.gltf';
@@ -391,6 +390,7 @@ async function main(engine) {
     // const path = 'data/models/samples/conference/model-no-curtains.glb';
     // const path = 'data/models/pica_pica/pica_pica.gltf';
     // const path = 'data/models/samples/gi_box_01/model.glb';
+    // const path = 'data/models/samples/low_poly_classroom/no-glass/model.gltf';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
     const gltf = mesh_asset.gltf;
@@ -410,6 +410,8 @@ async function main(engine) {
 
     const composition = three_object_to_entity_composition(gltf.scene);
 
+    // composition.transform.rotation.multiply(Quaternion.fromEulerAngles(DEG_TO_RAD * 30, DEG_TO_RAD * 30, 0));
+
     composition.traverse(n => {
 
         /**

package/src/engine/graphics/texture/virtual/prototype.js

@@ -451,7 +451,9 @@ function render() {
     //     mesh.rotation.x += 0.05 * delta;
     // }
 
-    virtual_texture_managers.forEach(vts => vts.update(renderer, scene, camera));
+    virtual_texture_managers.forEach(vts => {
+        vts.update(renderer, scene, camera);
+    });
 
     // renderer.setViewport(0, 0, view_port_size.x, view_port_size.y);
     renderer.clear();