@woosh/meep-engine 2.108.4 → 2.109.0

package/src/engine/graphics/ecs/camera/CameraSystem.js

@@ -5,6 +5,7 @@ import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../ecs/System.js';
 import { Transform } from '../../../ecs/transform/Transform.js';
+import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
 import { auto_set_camera_clipping_planes } from "./auto_set_camera_clipping_planes.js";
 import { build_three_camera_object } from "./build_three_camera_object.js";
 import { Camera } from './Camera.js';
@@ -13,6 +14,29 @@ import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
 import { set_camera_aspect_ratio } from "./set_camera_aspect_ratio.js";
 import { update_camera_transform } from "./update_camera_transform.js";
 
+/**
+ *
+ * @param {THREE.Camera} object
+ * @param {Quaternion} rotation
+ */
+export function three_camera_set_transform_rotation(object, rotation) {
+
+    /*
+    NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
+    See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
+     */
+
+    invertQuaternionOrientation(object.quaternion, rotation);
+
+    object.rotation.setFromQuaternion(object.quaternion);
+
+    // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
+    // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+
+    object.updateProjectionMatrix();
+    threeUpdateTransform(object);
+}
+
 export class CameraSystem extends System {
     /**
      *
@@ -104,19 +128,7 @@ export class CameraSystem extends System {
         function synchronizeRotation() {
             const rotation = transform.rotation;
 
-            /*
-            NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
-            See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
-             */
-
-            invertQuaternionOrientation(camera.object.quaternion, rotation);
-
-            camera.object.rotation.setFromQuaternion(camera.object.quaternion);
-
-            // rotation.__setThreeEuler(camera.object.rotation); // seems unnecessary, based on Object3D.lookAt implementation
-            // camera.object.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
-
-            update_camera_transform(camera);
+            three_camera_set_transform_rotation(camera.object, rotation);
         }
 
         function rebuild() {

package/src/engine/graphics/geometry/decode_attribute_value.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} input
+ * @param {BinaryDataType} raw_type
+ * @param {boolean} normalized
+ * @returns {number}
+ */
+export function decode_attribute_value(input: number, raw_type: BinaryDataType, normalized: boolean): number;
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+//# sourceMappingURL=decode_attribute_value.d.ts.map

package/src/engine/graphics/geometry/decode_attribute_value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_attribute_value.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/decode_attribute_value.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,8CALW,MAAM,YACN,cAAc,cACd,OAAO,GACL,MAAM,CAkBlB;+BA3B8B,6CAA6C"}

package/src/engine/graphics/geometry/decode_attribute_value.js

@@ -0,0 +1,28 @@
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { UINT16_MAX } from "../../../core/binary/UINT16_MAX.js";
+import { UINT32_MAX } from "../../../core/binary/UINT32_MAX.js";
+
+/**
+ *
+ * @param {number} input
+ * @param {BinaryDataType} raw_type
+ * @param {boolean} normalized
+ * @returns {number}
+ */
+export function decode_attribute_value(input, raw_type, normalized) {
+    if (!normalized) {
+        return input;
+    }
+
+    switch (raw_type) {
+        case BinaryDataType.Float32:
+        case BinaryDataType.Float64:
+            return input;
+        case BinaryDataType.Uint16:
+            return input / UINT16_MAX;
+        case BinaryDataType.Uint32:
+            return input / UINT32_MAX;
+        default:
+            throw new Error(`Unsupported data type ${raw_type}`);
+    }
+}

package/src/engine/graphics/geometry/geometry_construct_triangle_normal.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number[]|Float32Array} positions
+ */
+export function geometry_construct_triangle_normal(out: number[] | Float32Array, out_offset: number, a: number, b: number, c: number, positions: number[] | Float32Array): void;
+//# sourceMappingURL=geometry_construct_triangle_normal.d.ts.map

package/src/engine/graphics/geometry/geometry_construct_triangle_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_construct_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/geometry_construct_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wDAPW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,QAqB/B"}

package/src/engine/graphics/geometry/geometry_construct_triangle_normal.js

@@ -0,0 +1,31 @@
+import { v3_compute_triangle_normal } from "../../../core/geom/3d/v3_compute_triangle_normal.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number[]|Float32Array} positions
+ */
+export function geometry_construct_triangle_normal(out, out_offset, a, b, c, positions) {
+
+    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];
+
+    v3_compute_triangle_normal(out, out_offset, ax, ay, az, bx, by, bz, cx, cy, cz);
+}

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAkJA;IAGI,sBAEC;IAGG,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAQC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA8CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAFa,SAAS,CAKrB;;CACJ;gCArV+B,wDAAwD;sBAClE,4CAA4C"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AA4DA;IAGI,sBAEC;IAGG,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAQC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA8CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAFa,SAAS,CAKrB;;CACJ;gCAhQ+B,wDAAwD;sBAClE,4CAA4C"}

package/src/engine/graphics/sh3/lpv/LightProbeVolume.js

@@ -1,6 +1,5 @@
 import { LineBasicMaterial } from "three";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import {
     build_tetrahedral_mesh_buffer_geometry
 } from "../../../../core/geom/3d/tetrahedra/build_tetrahedral_mesh_buffer_geometry.js";
@@ -20,99 +19,14 @@ import { ShadedGeometryFlags } from "../../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { visualise_spherical_harmonic_sphere } from "../visualise_spherical_harmonic_sphere.js";
 import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
 
-const TEMP_CONTACT = new SurfacePoint3();
-
 
 class Baker {
     constructor() {
-        /**
-         *
-         * @type {EntityComponentDataset|null}
-         * @private
-         */
-        this.__ecd = null;
-
-        /**
-         *
-         * @type {BVH|null}
-         * @private
-         */
-        this.__bvh = null;
-
-        this.__min_bounce_count = 3;
-        this.__max_bounce_count = 100;
 
         // this._ren = new WebGLCubeProbeRenderer();
         this._ren = new PathTracerProbeRenderer();
     }
 
-    /**
-     * @param {BVH} bvh
-     */
-    set_bvh(bvh) {
-        this.__bvh = bvh;
-    }
-
-    build_spatial() {
-
-    }
-
-    /**
-     *
-     * @param {number[]} irradiance RGB irradiance result is written here
-     * @param {number} bounce_count number of reflections before this trace
-     * @param {number} origin_x
-     * @param {number} origin_y
-     * @param {number} origin_z
-     * @param {number} direction_x
-     * @param {number} direction_y
-     * @param {number} direction_z
-     */
-    trace_ray(irradiance, bounce_count,
-              origin_x, origin_y, origin_z,
-              direction_x, direction_y, direction_z) {
-
-        //
-
-        if (!this.ray_cast(TEMP_CONTACT, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z)) {
-            // no hit, assume irradiance is zeroed - black
-
-            return;
-        }
-
-        // record irradiance
-
-        // reflect ray around normal
-        // TODO apply BDRF to compute reflected ray
-
-        if (bounce_count > this.__max_bounce_count) {
-            // terminate
-        }
-
-    }
-
-    /**
-     *
-     * @param contact
-     * @param origin_x
-     * @param origin_y
-     * @param origin_z
-     * @param direction_x
-     * @param direction_y
-     * @param direction_z
-     * @returns {boolean}
-     */
-    ray_cast(contact,
-             origin_x, origin_y, origin_z,
-             direction_x, direction_y, direction_z
-    ) {
-
-    }
-
-    prepare_scene() {
-
-    }
-
     /**
      *
      * @param {number[]} position

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.d.ts

@@ -1,4 +1,5 @@
 export class WebGLCubeProbeRenderer extends ProbeRenderer {
+    constructor(resolution?: number);
     /**
      *
      * @type {THREE.WebGLRenderer|null}

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGLCubeProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js"],"names":[],"mappings":"AAuBA;IAIQ;;;;OAIG;IACH,mBAAsB;IAEtB,qCASE;IAEF;;;;OAIG;IACH,wBAA8F;IAG9F,0BAAiE;IAEjE;;;;OAIG;IACH,gBAA0B;IA8C9B,mBAMC;CA6CJ;8BAxI6B,oBAAoB;sCAZ3C,OAAO;2BAAP,OAAO"}
+{"version":3,"file":"WebGLCubeProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js"],"names":[],"mappings":"AAwBA;IACI,iCA0CC;IApCG;;;;OAIG;IACH,mBAAsB;IAEtB,qCASE;IAEF;;;;OAIG;IACH,wBAA8F;IAG9F,0BAAiE;IAEjE;;;;OAIG;IACH,gBAA0B;IA8C9B,mBAMC;CA6CJ;8BA3I6B,oBAAoB;sCAb3C,OAAO;2BAAP,OAAO"}

package/src/engine/graphics/sh3/lpv/WebGLCubeProbeRenderer.js

@@ -8,6 +8,7 @@ import {
     VSMShadowMap,
     WebGLCubeRenderTarget
 } from "three";
+import { assert } from "../../../../core/assert.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { three_set_shadow_resolution } from "../../ecs/light/binding/three/ThreeLightBinding.js";
@@ -22,9 +23,12 @@ import { fromCubeRenderTarget } from "../fromCubeRenderTarget.js";
 import { ProbeRenderer } from "./ProbeRenderer.js";
 
 export class WebGLCubeProbeRenderer extends ProbeRenderer {
-    constructor() {
+    constructor(resolution = 32) {
 
         super();
+
+        assert.isNonNegativeInteger(resolution, 'resolution');
+
         /**
          *
          * @type {THREE.WebGLRenderer|null}
@@ -32,7 +36,7 @@ export class WebGLCubeProbeRenderer extends ProbeRenderer {
          */
         this.__renderer = null;
 
-        this.render_target = new WebGLCubeRenderTarget(32, {
+        this.render_target = new WebGLCubeRenderTarget(resolution, {
             format: RGBAFormat,
             minFilter: LinearFilter,
             magFilter: LinearFilter,

package/src/engine/graphics/sh3/path_tracer/{GeometryBVHBatched.d.ts → BufferedGeometryBVH.d.ts}

@@ -1,4 +1,9 @@
-export class GeometryBVHBatched {
+export class BufferedGeometryBVH {
+    /**
+     *
+     * @param {AABB3|number[]} out
+     */
+    getBounds(out: AABB3 | number[]): void;
     /**
      *
      * @type {BVH}
@@ -43,5 +48,7 @@ export class GeometryBVHBatched {
      * @returns {number} distance along the ray, negative if no hit
      */
     raycast(output: number[], ray: number[], min_distance: number, max_distance: number): number;
+    #private;
 }
-//# sourceMappingURL=GeometryBVHBatched.d.ts.map
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+//# sourceMappingURL=BufferedGeometryBVH.d.ts.map

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

@@ -0,0 +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"}

package/src/engine/graphics/sh3/path_tracer/{GeometryBVHBatched.js → BufferedGeometryBVH.js}

@@ -1,22 +1,72 @@
+import { split_by_3 } from "../../../../core/binary/split_by_3.js";
 import { BVH } 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 { 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 {
     computeTriangleRayIntersectionBarycentricGeometry
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js";
+import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
 
 /**
  *
- * @type {number[]}
+ * @type {number[]|Uint32Array}
  */
-const scratch_uint32_array = [];
+const scratch_uint32_array = new Uint32Array(4096);
 /**
  *
  * @type {number[]}
  */
 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
@@ -90,7 +140,22 @@ function construct_ray_hit(
     output[9] = face_index;
 }
 
-export class GeometryBVHBatched {
+export class BufferedGeometryBVH {
+    /**
+     * @type {Uint32Array}
+     */
+    #morton_codes
+
+    #bounds = new AABB3()
+
+    /**
+     *
+     * @param {AABB3|number[]} out
+     */
+    getBounds(out) {
+        array_copy(this.#bounds, 0, out, 0, 6);
+    }
+
     constructor() {
         /**
          *
@@ -148,9 +213,17 @@ export class GeometryBVHBatched {
 
         this.__triangle_count = index_array.length / 3;
 
+        this.#morton_codes = new Uint32Array(this.__triangle_count);
+
         const bvh = this.__bvh;
 
-        ebvh_build_for_geometry_morton(bvh, index_array, array_positions);
+        ebvh_build_for_geometry_morton(
+            bvh,
+            index_array,
+            array_positions,
+            this.#morton_codes,
+            this.#bounds
+        );
         //
         // ebvh_build_for_geometry_incremental(bvh, index_array, array_positions, 1);
 
@@ -201,6 +274,13 @@ export class GeometryBVHBatched {
         let best_u = 0;
         let best_v = 0;
 
+        // 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);
+        }
+
+
         // check triangles found via BVH
         for (let i = 0; i < count; i++) {
             const triangle_index = scratch_uint32_array[i];
@@ -225,7 +305,6 @@ export class GeometryBVHBatched {
                 best_index = triangle_index;
                 best_u = v3_scratch_0[1];
                 best_v = v3_scratch_0[2];
-
             }
         }
 

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

@@ -1,9 +1,10 @@
 export class PathTracedMesh {
+    aabb: AABB3;
     /**
      *
-     * @type {GeometryBVHBatched|null}
+     * @type {BufferedGeometryBVH|null}
      */
-    geo_bvh: GeometryBVHBatched | null;
+    geo_bvh: BufferedGeometryBVH | null;
     /**
      *
      * @type {THREE.BufferGeometry|null}
@@ -11,9 +12,9 @@ export class PathTracedMesh {
     geometry: THREE.BufferGeometry | null;
     /**
      *
-     * @type {THREE.Material|null}
+     * @type {StandardMaterial|null}
      */
-    material: THREE.Material | null;
+    material: StandardMaterial | null;
     __transform_inverse: Float32Array;
     __transform: Float32Array;
     __local_scale_inverse: number;
@@ -34,4 +35,5 @@ export class PathTracedMesh {
      */
     hit(out: number[], ray: number[], min_distance: number, max_distance: number): number;
 }
+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":"AAQA;IAGQ;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEf;IAEpB;;;OAGG;IACH,UAFU,MAAM,QAAQ,GAAC,IAAI,CAET;IAIpB,kCAA0D;IAC1D,0BAAuD;IACvD,8BAA8B;IAE9B;;;OAGG;IACH,IAFU,MAAM,CAEW;IAG/B,iCAYC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAqBlB;CACJ"}
+{"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"}

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

@@ -1,17 +1,25 @@
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
 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 { 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 { 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 { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
 
 const local_ray = new Float32Array(6);
+const scratch_v3 = new Float32Array(3);
 let mesh_id_counter = 0;
 
 export class PathTracedMesh {
+    aabb = new AABB3();
+
     constructor() {
 
         /**
          *
-         * @type {GeometryBVHBatched|null}
+         * @type {BufferedGeometryBVH|null}
          */
         this.geo_bvh = null;
 
@@ -23,7 +31,7 @@ export class PathTracedMesh {
 
         /**
          *
-         * @type {THREE.Material|null}
+         * @type {StandardMaterial|null}
          */
         this.material = null;
 
@@ -51,7 +59,11 @@ export class PathTracedMesh {
         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);
+        this.__local_scale_inverse = Math.max(scale_x, scale_y, scale_z);
+
+        // get bounds
+        this.geo_bvh.getBounds(this.aabb);
+        this.aabb.applyMatrix4(m);
     }
 
     get transform() {
@@ -69,11 +81,37 @@ export class PathTracedMesh {
     hit(out, ray, min_distance, max_distance) {
         //transform ray
         const m4 = this.__transform_inverse;
-        ray3_array_apply_matrix4(local_ray,0, ray,0, 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);
+        // shift ray forward by "min distance"
+        ray3_shift_origin_along_direction(local_ray, 0, ray, 0, min_distance);
+
+
+        ray3_array_apply_matrix4(local_ray, 0, local_ray, 0, m4);
+
+
+        let max_distance_local = Infinity;
+
+        if (max_distance !== Infinity) {
+            // compute position of point at max_distance along the ray
+            v3_shift_along_direction(
+                scratch_v3, 0,
+                ray[0], ray[1], ray[2],
+                ray[3], ray[4], ray[5],
+                max_distance
+            );
+
+            // move far point into local coordinate space
+            v3_matrix4_multiply(scratch_v3, 0, scratch_v3, 0, m4);
+
+            // compute far distance in local space
+            max_distance_local = v3_distance(
+                local_ray[0], local_ray[1], local_ray[2],
+                scratch_v3[0], scratch_v3[1], scratch_v3[2]
+            );
+        }
+
+        let distance_to_hit = this.geo_bvh.raycast(out, local_ray, 0, max_distance_local);
 
         if (distance_to_hit >= 0) {
             // transform output
@@ -81,9 +119,17 @@ export class PathTracedMesh {
 
             out[10] = this.id;
 
-            distance_to_hit /= scale_d;
+            distance_to_hit = v3_distance(
+                ray[0], ray[1], ray[2],
+                out[0], out[1], out[2]
+            );
+
+            if (distance_to_hit > max_distance) {
+                return -1;
+            }
         }
 
+
         return distance_to_hit;
     }
 }

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

@@ -16,14 +16,9 @@ export class PathTracedScene {
     __lights: AbstractLight[];
     /**
      *
-     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     * @type {Map<THREE.BufferGeometry, BufferedGeometryBVH>}
      */
-    geo_cache: Map<THREE.BufferGeometry, GeometryBVHBatched>;
-    /**
-     * Maps {@link Texture.id} to relevant sampler
-     * @type {Map<number, Sampler2D>}
-     */
-    textures: Map<number, Sampler2D>;
+    geo_cache: Map<THREE.BufferGeometry, BufferedGeometryBVH>;
     /**
      *
      * @type {function}
@@ -35,9 +30,9 @@ export class PathTracedScene {
     /**
      *
      * @param {THREE.BufferGeometry} geo
-     * @return {GeometryBVHBatched}
+     * @return {BufferedGeometryBVH}
      */
-    obtainGeometryBVH(geo: THREE.BufferGeometry): GeometryBVHBatched;
+    obtainGeometryBVH(geo: THREE.BufferGeometry): BufferedGeometryBVH;
     /**
      *
      * @param {AbstractLight} light
@@ -82,9 +77,10 @@ export class PathTracedScene {
      * @returns {boolean}
      */
     sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
+    #private;
 }
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
-import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
+import { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
 //# sourceMappingURL=PathTracedScene.d.ts.map

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":"AAuBA;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,kBAAkB,CAAC,CAEjC;IAEtB;;;OAGG;IACH,UAFU,IAAI,MAAM,YAAY,CAEX;IAGrB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAqCC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAmB7B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA6CvB;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,CAwCjB;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;oBAnWmB,mCAAmC;+BAcxB,qBAAqB;8BALtB,kDAAkD;mCAG7C,yBAAyB"}
+{"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"}