@woosh/meep-engine 2.43.17 → 2.43.19

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

@@ -0,0 +1,265 @@
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { aabb3_signed_distance_sqr_to_point } from "../../../../core/bvh2/aabb3/aabb3_signed_distance_sqr_to_point.js";
+import {
+    computeTriangleRayIntersectionBarycentric
+} from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+import { ebvh_build_for_geometry_morton } from "../../../../core/bvh2/bvh3/ebvh_build_for_geometry_morton.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const leaf_buffer = [];
+/**
+ *
+ * @type {number[]}
+ */
+const v3_scratch_0 = [];
+
+const temp_aabb3 = new Float32Array(6);
+
+
+export class GeometryBVHBatched {
+    constructor() {
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy}
+         * @private
+         */
+        this.__bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         * @private
+         */
+        this.__geometry = null;
+
+        /**
+         *
+         * @type {number[]|null}
+         * @private
+         */
+        this.__geometry_index = null;
+
+        /**
+         *
+         * @type {number[]|null}
+         * @private
+         */
+        this.__geometry_positions = null;
+
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__triangle_count = 0;
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     */
+    build(geometry) {
+        this.__geometry = geometry;
+
+        const index = geometry.getIndex();
+        const index_array = index.array;
+
+
+        const attribute_position = geometry.getAttribute('position');
+        const array_positions = attribute_position.array;
+
+        this.__geometry_positions = array_positions;
+        this.__geometry_index = index_array;
+
+        this.__triangle_count = index_array.length / 3;
+
+        const bvh = this.__bvh;
+
+        ebvh_build_for_geometry_morton(bvh, index_array, array_positions);
+        //
+        // ebvh_build_for_geometry_incremental(bvh, index_array, array_positions, 1);
+
+        bvh.trim();
+    }
+
+    /**
+     *
+     * @param {number[]} output
+     * @param {number} face_index
+     * @param {number} t
+     * @param {number} u
+     * @param {number} v
+     */
+    construct_ray_hit(output, face_index, t, u, v) {
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const index_offset = face_index * 3;
+
+        const a = indices[index_offset];
+        const b = indices[index_offset + 1];
+        const c = indices[index_offset + 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];
+
+        // normal
+
+        // edge1 = a - b
+        const edge1_x = bx - ax;
+        const edge1_y = by - ay;
+        const edge1_z = bz - az;
+
+        // edge2 = c - a
+        const edge2_x = cx - ax;
+        const edge2_y = cy - ay;
+        const edge2_z = cz - az;
+
+        // Compute triangle normal
+
+        // normal = edge1 x edge2
+        const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+        const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+        const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+        output[3] = normal_x;
+        output[4] = normal_y;
+        output[5] = normal_z;
+
+        output[6] = t;
+        output[7] = u;
+        output[8] = v;
+        output[9] = face_index;
+    }
+
+    /**
+     *
+     * @param {number[]} output
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @returns {number} distance along the ray, negative if no hit
+     */
+    raycast(output, ray, min_distance, max_distance) {
+
+        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 bvh = this.__bvh;
+
+        // TODO we can unify BVH traversal with ray checks to reduce number of checks
+        const count = bvh_query_leaves_ray(
+            bvh, leaf_buffer, 0,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        let best_t = max_distance;
+
+        let best_index = -1;
+        let best_u = 0;
+        let best_v = 0;
+
+        for (let i = 0; i < count; i++) {
+            const node_id = leaf_buffer[i];
+
+
+            if (best_t < max_distance) {
+                // early bail-out
+
+                bvh.node_get_aabb(node_id, temp_aabb3);
+
+                const distance = aabb3_signed_distance_sqr_to_point(temp_aabb3[0], temp_aabb3[1], temp_aabb3[2], temp_aabb3[3], temp_aabb3[4], temp_aabb3[5], ray[0], ray[1], ray[2]);
+
+                if (distance > best_t * best_t) {
+                    // whole AABB is too far
+                    continue;
+                }
+            }
+
+            const triangle_index = bvh.node_get_user_data(node_id);
+
+            const index_offset = triangle_index * 3;
+
+            const a = indices[index_offset];
+            const b = indices[index_offset + 1];
+            const c = indices[index_offset + 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];
+
+            const intersection_found = computeTriangleRayIntersectionBarycentric(
+                v3_scratch_0,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z,
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
+            );
+
+            if (intersection_found && v3_scratch_0[0] < best_t && v3_scratch_0[0] > min_distance) {
+                best_t = v3_scratch_0[0];
+
+                best_index = triangle_index;
+                best_u = v3_scratch_0[1];
+                best_v = v3_scratch_0[2];
+
+            }
+        }
+
+        if (best_t === max_distance) {
+            return -1;
+        }
+
+        output[0] = origin_x + direction_x * best_t;
+        output[1] = origin_y + direction_y * best_t;
+        output[2] = origin_z + direction_z * best_t;
+
+        this.construct_ray_hit(output, best_index, best_t, best_u, best_v);
+
+        return best_t;
+    }
+}

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

@@ -0,0 +1,85 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { mat4 } from "gl-matrix";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
+
+const local_ray = new Float32Array(6);
+let mesh_id_counter = 0;
+
+export class PathTracedMesh {
+    constructor() {
+
+        /**
+         *
+         * @type {GeometryBVHBatched|null}
+         */
+        this.geo_bvh = null;
+
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         */
+        this.geometry = null;
+
+        /**
+         *
+         * @type {THREE.Material|null}
+         */
+        this.material = null;
+
+        const buffer = new ArrayBuffer(16 * 2 * 4);
+
+        this.__transform_inverse = new Float32Array(buffer, 0, 16);
+        this.__transform = new Float32Array(buffer, 16 * 4, 16);
+        this.__local_scale_inverse = 1;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.id = mesh_id_counter++;
+    }
+
+    set transform(m) {
+        array_copy(m, 0, this.__transform, 0, 16);
+        mat4.invert(this.__transform_inverse, m);
+
+        // precompute scaling factor for rays
+        const m4 = this.__transform_inverse;
+
+        const scale_x = Math.hypot(m4[0], m4[1], m4[2]);
+        const scale_y = Math.hypot(m4[4], m4[5], m4[6]);
+        const scale_z = Math.hypot(m4[8], m4[9], m4[10]);
+
+        this.__local_scale_inverse = Math.hypot(scale_x, scale_y, scale_z);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]} ray
+     * @param {number} min_distance
+     * @param {number} max_distance
+     * @returns {number} distance along the ray to contact
+     */
+    hit(out, ray, min_distance, max_distance) {
+        //transform ray
+        const m4 = this.__transform_inverse;
+        ray3_array_apply_matrix4(local_ray, ray, m4);
+
+        const scale_d = this.__local_scale_inverse;
+
+        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, min_distance * scale_d, max_distance * scale_d);
+
+        if (distance_to_hit >= 0) {
+            // transform output
+            ray_hit_apply_transform(out, out, this.__transform);
+
+            out[10] = this.id;
+
+            distance_to_hit /= scale_d;
+        }
+
+        return distance_to_hit;
+    }
+}