@woosh/meep-engine 2.109.0 → 2.109.2

package/src/engine/graphics/sh3/lpv/worker/lpv_build_worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lpv_build_worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpv/worker/lpv_build_worker.js"],"names":[],"mappings":""}

package/src/engine/graphics/sh3/lpv/worker/lpv_build_worker.js

@@ -0,0 +1,38 @@
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { EntityComponentDataset } from "../../../../ecs/EntityComponentDataset.js";
+import { LightProbeVolume } from "../LightProbeVolume.js";
+import { LightProbeVolumeSerializationAdapter } from "../serialization/LightProbeVolumeSerializationAdapter.js";
+
+const adapter = new LightProbeVolumeSerializationAdapter();
+const volume = new LightProbeVolume();
+
+const scene = new EntityComponentDataset();
+
+self.Contex = {
+    volume,
+
+    /**
+     *
+     * @param {ArrayBuffer} data
+     */
+    load_scene(data){
+        const buffer = BinaryBuffer.fromArrayBuffer(data);
+
+
+
+    },
+
+    serialize() {
+        const buffer = new BinaryBuffer();
+
+        adapter.serialize(buffer, volume);
+
+        buffer.trim();
+
+        return buffer.data;
+    },
+
+    reset() {
+        volume.clear()
+    }
+};

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

@@ -4,12 +4,6 @@ export class BufferedGeometryBVH {
      * @param {AABB3|number[]} out
      */
     getBounds(out: AABB3 | number[]): void;
-    /**
-     *
-     * @type {BVH}
-     * @private
-     */
-    private __bvh;
     /**
      *
      * @type {THREE.BufferGeometry|null}
@@ -40,7 +34,7 @@ export class BufferedGeometryBVH {
      */
     build(geometry: THREE.BufferGeometry): void;
     /**
-     *
+     * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
      * @param {number[]} ray
      * @param {number} min_distance

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

@@ -1 +1 @@
-{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AA8IA;IAQI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAGG;;;;OAIG;IACH,cAAsB;IAEtB;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,gBAFW,MAAM,cAAc,QAiC9B;IAGD;;;;;;;OAOG;IACH,gBANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CA8ElB;;CACJ;sBAzTqB,wCAAwC"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AA2BA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,gBAFW,MAAM,cAAc,QAsC9B;IAGD;;;;;;;OAOG;IACH,gBANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CA+FlB;;CACJ;sBAlOqB,wCAAwC"}

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

@@ -1,15 +1,18 @@
-import { split_by_3 } from "../../../../core/binary/split_by_3.js";
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BVH, ELEMENT_WORD_COUNT } 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 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { array_quick_sort_by_comparator } from "../../../../core/collection/array/array_quick_sort_by_comparator.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
 
 import {
     computeTriangleRayIntersectionBarycentricGeometry
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js";
-import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
+import Vector4 from "../../../../core/geom/Vector4.js";
+import { computeBoundingSphereFromVertexData } from "../../geometry/computeBoundingSphereFromVertexData.js";
+import { construct_ray_hit_from_geometry } from "./geometry/construct_ray_hit_from_geometry.js";
 
 /**
  *
@@ -22,124 +25,6 @@ const scratch_uint32_array = new Uint32Array(4096);
  */
 const v3_scratch_0 = [];
 
-/**
- *
- * @param {number[]} triangles
- * @param {number} offset
- * @param {number} count
- * @param {number} point_x
- * @param {number} point_y
- * @param {number} point_z
- * @param morton_codes
- * @param bounds
- */
-function sort_triangles_by_distance_to_point(
-    triangles, offset, count,
-    morton_codes, bounds,
-    point_x, point_y, point_z,
-) {
-    const bounds_x0 = bounds.x0;
-    const bounds_y0 = bounds.y0;
-    const bounds_z0 = bounds.z0;
-
-    const bounds_scale_x = bounds.getExtentsX() / 1023;
-    const bounds_scale_y = bounds.getExtentsY() / 1023;
-    const bounds_scale_z = bounds.getExtentsZ() / 1023;
-
-    array_quick_sort_by_comparator(scratch_uint32_array, (a, b) => {
-
-        const morton_a = morton_codes[a];
-        const morton_b = morton_codes[b];
-
-        const ax = bounds_x0 + bounds_scale_x * split_by_3(morton_a);
-        const ay = bounds_y0 + bounds_scale_y * split_by_3(morton_a >>> 1);
-        const az = bounds_z0 + bounds_scale_z * split_by_3(morton_a >>> 2);
-
-        const bx = bounds_x0 + bounds_scale_x * split_by_3(morton_b);
-        const by = bounds_y0 + bounds_scale_y * split_by_3(morton_b >>> 1);
-        const bz = bounds_z0 + bounds_scale_z * split_by_3(morton_b >>> 2);
-
-        const delta_a = v3_distance_sqr(ax, ay, az, point_x, point_y, point_z);
-        const delta_b = v3_distance_sqr(bx, by, bz, point_x, point_y, point_z);
-
-        return delta_b - delta_a;
-    }, undefined, offset, count - 1);
-
-}
-
-/**
- *
- * @param {number[]} output
- * @param {number[]} indices
- * @param {number[]} positions
- * @param {number} face_index
- * @param {number} t
- * @param {number} u
- * @param {number} v
- */
-function construct_ray_hit(
-    output,
-    indices, positions,
-    face_index,
-    t, u, v
-) {
-
-    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 position of intersection point
-    output[0] = ax + edge1_x * u + edge2_x * v;
-    output[1] = ay + edge1_y * u + edge2_y * v;
-    output[2] = az + edge1_z * u + edge2_z * v;
-
-    // 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;
-}
-
 export class BufferedGeometryBVH {
     /**
      * @type {Uint32Array}
@@ -148,6 +33,16 @@ export class BufferedGeometryBVH {
 
     #bounds = new AABB3()
 
+    #bounds_sphere = new Float32Array(4);
+
+
+    /**
+     *
+     * @type {BVH}
+     * @private
+     */
+    #bvh = new BVH();
+
     /**
      *
      * @param {AABB3|number[]} out
@@ -157,12 +52,6 @@ export class BufferedGeometryBVH {
     }
 
     constructor() {
-        /**
-         *
-         * @type {BVH}
-         * @private
-         */
-        this.__bvh = new BVH();
 
         /**
          *
@@ -215,7 +104,7 @@ export class BufferedGeometryBVH {
 
         this.#morton_codes = new Uint32Array(this.__triangle_count);
 
-        const bvh = this.__bvh;
+        const bvh = this.#bvh;
 
         ebvh_build_for_geometry_morton(
             bvh,
@@ -229,11 +118,16 @@ export class BufferedGeometryBVH {
 
         // remove any extra unused space
         bvh.trim();
+
+        const r = new Vector4();
+        computeBoundingSphereFromVertexData(array_positions, r);
+
+        r.toArray(this.#bounds_sphere);
     }
 
 
     /**
-     *
+     * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
      * @param {number[]} ray
      * @param {number} min_distance
@@ -242,6 +136,7 @@ export class BufferedGeometryBVH {
      */
     raycast(output, ray, min_distance, max_distance) {
 
+
         const indices = this.__geometry_index;
         const positions = this.__geometry_positions;
 
@@ -253,10 +148,9 @@ export class BufferedGeometryBVH {
         const direction_y = ray[4];
         const direction_z = ray[5];
 
-        const bvh = this.__bvh;
+        const bvh = this.#bvh;
 
-        // TODO we can unify BVH traversal with ray checks to reduce number of checks
-        const count = bvh_query_user_data_ray(
+        const count = bvh_query_leaves_ray(
             bvh, bvh.root,
             scratch_uint32_array, 0,
             origin_x, origin_y, origin_z,
@@ -268,22 +162,37 @@ export class BufferedGeometryBVH {
             return -1;
         }
 
-        let best_t = max_distance;
+
+        let nearest_hit_distance = max_distance;
 
         let best_index = -1;
         let best_u = 0;
         let best_v = 0;
+        let best_node = -1;
 
-        // sort triangles by distance to origin
-        if (count > 64) {
-            // encode
-            sort_triangles_by_distance_to_point(scratch_uint32_array, 0, count, this.#morton_codes, this.#bounds, origin_x, origin_y, origin_z);
-        }
 
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
 
         // check triangles found via BVH
         for (let i = 0; i < count; i++) {
-            const triangle_index = scratch_uint32_array[i];
+            const node = scratch_uint32_array[i];
+
+            const node_address = node * ELEMENT_WORD_COUNT;
+
+            if (aabb3_unsigned_distance_sqr_to_point(
+                float32[node_address], float32[node_address + 1], float32[node_address + 2],
+                float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
+
+                origin_x, origin_y, origin_z
+            ) > nearest_hit_distance * nearest_hit_distance) {
+                // bounds of the mesh are too far
+                continue;
+            }
+
+            const triangle_index = bvh.node_get_user_data(node);
 
             const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
                 v3_scratch_0,
@@ -299,22 +208,24 @@ export class BufferedGeometryBVH {
 
             const t = v3_scratch_0[0];
 
-            if (t < best_t && t > min_distance) {
-                best_t = t;
+            if (t < nearest_hit_distance && t > min_distance) {
+                nearest_hit_distance = t;
 
                 best_index = triangle_index;
                 best_u = v3_scratch_0[1];
                 best_v = v3_scratch_0[2];
+
+                best_node = node;
             }
         }
 
-        if (best_t === max_distance) {
+        if (nearest_hit_distance === max_distance) {
             // no hit
             return -1;
         }
 
-        construct_ray_hit(output, indices, positions, best_index, best_t, best_u, best_v);
+        construct_ray_hit_from_geometry(output, indices, positions, best_index, nearest_hit_distance, best_u, best_v);
 
-        return best_t;
+        return nearest_hit_distance;
     }
-}
+}

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

@@ -1,10 +1,19 @@
 export class PathTracedMesh {
+    /**
+     *
+     * @type {number}
+     */
+    id: number;
+    /**
+     *
+     * @type {AABB3}
+     */
     aabb: AABB3;
     /**
      *
      * @type {BufferedGeometryBVH|null}
      */
-    geo_bvh: BufferedGeometryBVH | null;
+    bvh: BufferedGeometryBVH | null;
     /**
      *
      * @type {THREE.BufferGeometry|null}
@@ -15,14 +24,8 @@ export class PathTracedMesh {
      * @type {StandardMaterial|null}
      */
     material: StandardMaterial | null;
-    __transform_inverse: Float32Array;
-    __transform: Float32Array;
-    __local_scale_inverse: number;
-    /**
-     *
-     * @type {number}
-     */
-    id: number;
+    build_tight_bounds(): void;
+    update_bounds(): void;
     set transform(arg: Float32Array);
     get transform(): Float32Array;
     /**
@@ -34,6 +37,7 @@ export class PathTracedMesh {
      * @returns {number} distance along the ray to contact
      */
     hit(out: number[], ray: number[], min_distance: number, max_distance: number): number;
+    #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 //# sourceMappingURL=PathTracedMesh.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAcA;IACI,YAAmB;IAIf;;;OAGG;IACH,SAFU,sBAAoB,IAAI,CAEf;IAEnB;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEf;IAEpB;;;OAGG;IACH,UAFU,mBAAiB,IAAI,CAEX;IAIpB,kCAA0D;IAC1D,0BAAuD;IACvD,8BAA8B;IAE9B;;;OAGG;IACH,IAFU,MAAM,CAEW;IAG/B,iCAgBC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAuDlB;CACJ;sBApIqB,wCAAwC"}
+{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAmBA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,KAAK,CAEI;IAEnB;;;OAGG;IACH,KAFU,sBAAoB,IAAI,CAEvB;IAGX;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEnB;IAEhB;;;OAGG;IACH,UAFU,mBAAiB,IAAI,CAEf;IAKhB,2BAqBC;IAED,sBAGC;IAED,iCAQC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAmDlB;;CACJ;sBAxJqB,wCAAwC"}

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

@@ -1,11 +1,16 @@
 import { mat4 } from "gl-matrix";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { aabb3_from_v3_array_transformed } from "../../../../core/geom/3d/aabb/aabb3_from_v3_array_transformed.js";
+import { decompose_matrix_4_array } from "../../../../core/geom/3d/decompose_matrix_4_array.js";
+import { allocate_m4 } from "../../../../core/geom/3d/mat4/allocate_m4.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 import { ray3_shift_origin_along_direction } from "../../../../core/geom/3d/ray/ray3_shift_origin_along_direction.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import { v3_array_displace_in_direction } from "../../../../core/geom/vec3/v3_array_displace_in_direction.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
-import { v3_shift_along_direction } from "../../../../core/geom/vec3/v3_shift_along_direction.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
 
 const local_ray = new Float32Array(6);
@@ -13,61 +18,80 @@ const scratch_v3 = new Float32Array(3);
 let mesh_id_counter = 0;
 
 export class PathTracedMesh {
+    /**
+     *
+     * @type {number}
+     */
+    id = mesh_id_counter++;
+
+    /**
+     *
+     * @type {AABB3}
+     */
     aabb = new AABB3();
 
-    constructor() {
-
-        /**
-         *
-         * @type {BufferedGeometryBVH|null}
-         */
-        this.geo_bvh = null;
-
-        /**
-         *
-         * @type {THREE.BufferGeometry|null}
-         */
-        this.geometry = null;
-
-        /**
-         *
-         * @type {StandardMaterial|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++;
-    }
+    /**
+     *
+     * @type {BufferedGeometryBVH|null}
+     */
+    bvh = null;
 
-    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;
+    /**
+     *
+     * @type {THREE.BufferGeometry|null}
+     */
+    geometry = null;
 
-        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]);
+    /**
+     *
+     * @type {StandardMaterial|null}
+     */
+    material = null;
+
+    #transform = allocate_m4();
+    #transform_inverse = allocate_m4();
+
+    build_tight_bounds() {
+        const position = new Vector3();
+        const rotation = new Quaternion();
+        const scale = new Vector3();
+
+        decompose_matrix_4_array(this.#transform, position, rotation, scale);
+
+        if (rotation.roughlyEquals(Quaternion.identity)) {
+            // no rotation component, can safely scale/translate geometry bounds to get tight fit
+            this.update_bounds();
+
+        } else {
+
+            const position_attribute = this.geometry.getAttribute('position');
+            const position_array = position_attribute.array;
+            aabb3_from_v3_array_transformed(
+                this.aabb,
+                position_array, position_array.length,
+                this.#transform
+            );
+        }
+    }
+
+    update_bounds() {
+        this.bvh.getBounds(this.aabb);
+        this.aabb.applyMatrix4(this.#transform);
+    }
 
-        this.__local_scale_inverse = Math.max(scale_x, scale_y, scale_z);
+    set transform(m) {
+        array_copy(m, 0, this.#transform, 0, 16);
+
+        mat4.invert(this.#transform_inverse, m);
 
-        // get bounds
-        this.geo_bvh.getBounds(this.aabb);
-        this.aabb.applyMatrix4(m);
+        if (this.bvh !== null) {
+            this.update_bounds();
+        }
     }
 
     get transform() {
-        return this.__transform;
+        return this.#transform;
     }
 
     /**
@@ -80,8 +104,7 @@ export class PathTracedMesh {
      */
     hit(out, ray, min_distance, max_distance) {
         //transform ray
-        const m4 = this.__transform_inverse;
-
+        const m4 = this.#transform_inverse;
 
         // shift ray forward by "min distance"
         ray3_shift_origin_along_direction(local_ray, 0, ray, 0, min_distance);
@@ -94,7 +117,7 @@ export class PathTracedMesh {
 
         if (max_distance !== Infinity) {
             // compute position of point at max_distance along the ray
-            v3_shift_along_direction(
+            v3_array_displace_in_direction(
                 scratch_v3, 0,
                 ray[0], ray[1], ray[2],
                 ray[3], ray[4], ray[5],
@@ -111,11 +134,11 @@ export class PathTracedMesh {
             );
         }
 
-        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, 0, max_distance_local);
+        let distance_to_hit = this.bvh.raycast(out, local_ray, 0, max_distance_local);
 
         if (distance_to_hit >= 0) {
             // transform output
-            ray_hit_apply_transform(out, out, this.__transform);
+            ray_hit_apply_transform(out, out, this.#transform);
 
             out[10] = this.id;
 
@@ -124,9 +147,6 @@ export class PathTracedMesh {
                 out[0], out[1], out[2]
             );
 
-            if (distance_to_hit > max_distance) {
-                return -1;
-            }
         }
 
 

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

@@ -40,11 +40,29 @@ export class PathTracedScene {
     addLight(light: AbstractLight): void;
     /**
      *
-     * @param {THREE.BufferGeometry} geo
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
+     */
+    hasMesh(mesh: PathTracedMesh): boolean;
+    /**
+     *
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
+     */
+    addMesh(mesh: PathTracedMesh): boolean;
+    /**
+     *
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
+     */
+    removeMesh(mesh: PathTracedMesh): boolean;
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
      * @param {THREE.Material} material
      * @param {mat4|number[]} transform
      */
-    addMesh(geo: THREE.BufferGeometry, material: THREE.Material, transform: mat4 | number[]): void;
+    createMesh(geometry: THREE.BufferGeometry, material: THREE.Material, transform: mat4 | number[]): void;
     /**
      *
      * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
@@ -54,12 +72,12 @@ export class PathTracedScene {
     /**
      *
      * @param {number[]} out
-     * @param {number[]} ray
+     * @param {number[]|Ray3} ray
      * @param {number} min_distance
      * @param {number} max_distance
-     * @return {number}
+     * @return {number} distance to contact, or -1 if no contact found
      */
-    trace(out: number[], ray: number[], min_distance: number, max_distance: number): number;
+    trace(out: number[], ray: number[] | Ray3, min_distance: number, max_distance: number): number;
     /**
      *
      * @param {number[]} out

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AA8BA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAE1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAatB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAMC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA8CvB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACL,MAAM,CAqDjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;;CACJ;oBA7VmB,mCAAmC;+BAkBxB,qBAAqB;8BALtB,kDAAkD;oCAE5C,0BAA0B"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAgDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAiF7C,iBAOC;IAED,uBAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,gBACb,MAAM,gBACN,MAAM,GACL,MAAM,CAkEjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;;CACJ;oBArfkD,mCAAmC;+BAoBvD,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B"}