@woosh/meep-engine 2.109.3 → 2.109.5

package/src/core/model/node-graph/node/NodeDescription.js

@@ -291,6 +291,29 @@ export class NodeDescription {
         return result;
     }
 
+    /**
+     * Useful for checking if a node has inputs/outputs
+     * Does not allocate and terminates early, so performance characteristics are very good
+     * @param {PortDirection} direction
+     * @return {boolean}
+     */
+    hasPortsByDirection(direction) {
+        assert.enum(direction, PortDirection, 'direction');
+
+        const ports = this.ports;
+        const port_count = ports.length;
+
+        for (let i = 0; i < port_count; i++) {
+            const port = ports[i];
+
+            if (port.direction === direction) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      *
      * @param {PortDirection} direction

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

@@ -5,6 +5,7 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     scene: PathTracedScene;
     bake_depth(position: any, position_offset: any, output: any, output_offset: any): void;
     bake(position: any, position_offset: any, output: any, output_offset: any): void;
+    bake_start(): void;
     build_scene(ecd: any): void;
 }
 import { ProbeRenderer } from "./ProbeRenderer.js";

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AA0BA;IACI,mBAA0B;IAC1B,qBAAmB;IACnB,qBAAyB;IAEzB,uBAA6B;IAE7B,uFAoBC;IAED,iFAmCC;IASD,4BAsCC;CACJ;8BA1H6B,oBAAoB;2BADvB,8BAA8B;gCADzB,mCAAmC"}
+{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AA2BA;IACI,mBAA0B;IAC1B,qBAAmB;IACnB,qBAAyB;IAEzB,uBAA6B;IAE7B,uFAoBC;IAED,iFAqCC;IAKD,mBACC;IAED,4BAsCC;CACJ;8BA3H6B,oBAAoB;2BADvB,8BAA8B;gCADzB,mCAAmC"}

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

@@ -1,4 +1,5 @@
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { sh3_basis_at } from "../../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
 import {
     sh3_dering_optimize_positive
@@ -21,7 +22,7 @@ const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
 const sh_basis = new Float64Array(__shared_buffer, 0, 9);
 const coefficients = new Float64Array(__shared_buffer, 9 * 8, 27);
 
-const ray = new Float32Array(6);
+const ray = new Ray3();
 const sampled_irradiance = new Float32Array(3);
 
 export class PathTracerProbeRenderer extends ProbeRenderer {
@@ -67,8 +68,10 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
         for (let i = 0; i < this.sample_count; i++) {
 
             randomPointOnSphere(this.random, ray, 3);
+            ray.tMax = Infinity;
+            ray.tMin = 0;
 
-            tracer.path_trace(sampled_irradiance, ray, Infinity, 1, 7, this.random, this.scene);
+            tracer.path_trace(sampled_irradiance, ray, 1, 7, this.random, this.scene);
 
             sh3_basis_at(ray[3], ray[4], ray[5], sh_basis);
 
@@ -94,7 +97,6 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     }
 
     bake_start() {
-        return this.scene.build();
     }
 
     build_scene(ecd) {

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

@@ -1 +1 @@
-{"version":3,"file":"sh3_bake_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/sh3_bake_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,uCATW,MAAM,EAAE,iBACR,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,eACN,MAAM,QAqDhB"}
+{"version":3,"file":"sh3_bake_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/sh3_bake_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,uCATW,MAAM,EAAE,iBACR,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,eACN,MAAM,QAsDhB"}

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

@@ -32,6 +32,7 @@ export function sh3_bake_depth(
     const sh = new Float32Array(9);
 
     ray.origin.set(position_x, position_y, position_z);
+    ray.tMax = max_depth;
 
     const encoder = new OctahedralUvEncoder();
 
@@ -42,7 +43,7 @@ export function sh3_bake_depth(
 
             encoder.uv_to_unit(ray.direction, [u, v])
 
-            let distance = scene.trace(ray_hit, ray, 0, max_depth);
+            let distance = scene.trace(ray_hit, ray);
 
             if (distance < 0) {
                 distance = 100;

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

@@ -33,15 +33,20 @@ export class BufferedGeometryBVH {
      * @param {THREE.BufferGeometry} geometry
      */
     build(geometry: THREE.BufferGeometry): void;
+    /**
+     * Tests ray for occlusion
+     * Returns true if ray hits anything at all
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
      * @returns {number} distance along the ray, negative if no hit
      */
-    raycast(output: number[], ray: number[], min_distance: number, max_distance: number): number;
+    raycast(output: number[], ray: number[] | Ray3): number;
     #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";

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":"AAwBA;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,CAyElB;;CACJ;sBAzMqB,wCAAwC"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAwBA;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;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBAhQqB,wCAAwC"}

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

@@ -122,16 +122,69 @@ export class BufferedGeometryBVH {
         r.toArray(this.#bounds_sphere);
     }
 
+    /**
+     * Tests ray for occlusion
+     * Returns true if ray hits anything at all
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(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 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
+        );
+
+        // check triangles found via BVH
+        for (let i = 0; i < count; i++) {
+            const triangle_index = scratch_uint32_array[i];
+
+            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;
+            }
+        }
+
+        return false;
+    }
 
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
      * @returns {number} distance along the ray, negative if no hit
      */
-    raycast(output, ray, min_distance, max_distance) {
+    raycast(output, ray) {
 
         const indices = this.__geometry_index;
         const positions = this.__geometry_positions;
@@ -144,6 +197,8 @@ export class BufferedGeometryBVH {
         const direction_y = ray[4];
         const direction_z = ray[5];
 
+        const max_distance = ray[6];
+
         const bvh = this.#bvh;
 
         const count = bvh_query_user_data_ray_segment(
@@ -151,7 +206,7 @@ export class BufferedGeometryBVH {
             scratch_uint32_array, 0,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,
-            min_distance, max_distance
+            0, max_distance
         );
 
         if (count === 0) {
@@ -184,7 +239,7 @@ export class BufferedGeometryBVH {
 
             const t = v3_scratch_0[0];
 
-            if (t < nearest_hit_distance && t > min_distance) {
+            if (t < nearest_hit_distance && t > 0) {
                 nearest_hit_distance = t;
 
                 best_index = triangle_index;

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

@@ -24,20 +24,27 @@ export class PathTracedMesh {
      * @type {StandardMaterial|null}
      */
     material: StandardMaterial | null;
+    get transform_inverse(): Float32Array;
     build_tight_bounds(): void;
     update_bounds(): void;
     set transform(arg: Float32Array);
     get transform(): Float32Array;
+    /**
+     *
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      *
      * @param {number[]} out
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
+     * @param {number} ray_limit overrides Ray.tMax
      * @returns {number} distance along the ray to contact
      */
-    hit(out: number[], ray: number[], min_distance: number, max_distance: number): number;
+    hit(out: number[], ray: number[] | Ray3, ray_limit: number): number;
     #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.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":"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"}
+{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAeA;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,sCAEC;IAED,2BAqBC;IAED,sBAGC;IAED,iCAQC;IAED,8BAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,SALW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,aACb,MAAM,GACJ,MAAM,CA4BlB;;CACJ;sBAhJqB,wCAAwC;qBAIzC,kCAAkC"}

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

@@ -4,17 +4,13 @@ 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 { Ray3 } from "../../../../core/geom/3d/Ray3.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 Vector3 from "../../../../core/geom/Vector3.js";
 import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
 
-const local_ray = new Float32Array(6);
-const scratch_v3 = new Float32Array(3);
+const local_ray = new Ray3();
 let mesh_id_counter = 0;
 
 export class PathTracedMesh {
@@ -52,6 +48,10 @@ export class PathTracedMesh {
     #transform = allocate_m4();
     #transform_inverse = allocate_m4();
 
+    get transform_inverse() {
+        return this.#transform_inverse;
+    }
+
     build_tight_bounds() {
         const position = new Vector3();
         const rotation = new Quaternion();
@@ -96,45 +96,37 @@ export class PathTracedMesh {
 
     /**
      *
-     * @param {number[]} out
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
-     * @returns {number} distance along the ray to contact
+     * @param {Ray3} ray
+     * @returns {boolean}
      */
-    hit(out, ray, min_distance, max_distance) {
-        //transform ray
-        const m4 = this.#transform_inverse;
-
-        // shift ray forward by "min distance"
-        ray3_shift_origin_along_direction(local_ray, 0, ray, 0, min_distance);
+    occluded(ray) {
 
+        const m4 = this.#transform_inverse;
 
-        ray3_array_apply_matrix4(local_ray, 0, local_ray, 0, m4);
+        local_ray.copy(ray);
+        local_ray.applyMatrix4(m4);
 
+        return this.bvh.occluded(local_ray);
 
-        let max_distance_local = Infinity;
+    }
 
-        if (max_distance !== Infinity) {
-            // compute position of point at max_distance along the ray
-            v3_array_displace_in_direction(
-                scratch_v3, 0,
-                ray[0], ray[1], ray[2],
-                ray[3], ray[4], ray[5],
-                max_distance-min_distance
-            );
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]|Ray3} ray
+     * @param {number} ray_limit overrides Ray.tMax
+     * @returns {number} distance along the ray to contact
+     */
+    hit(out, ray, ray_limit) {
+        //transform ray
+        const m4 = this.#transform_inverse;
 
-            // move far point into local coordinate space
-            v3_matrix4_multiply(scratch_v3, 0, scratch_v3, 0, m4);
+        local_ray.copy(ray);
+        local_ray.tMax = ray_limit;
 
-            // 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]
-            );
-        }
+        local_ray.applyMatrix4(m4);
 
-        let distance_to_hit = this.bvh.raycast(out, local_ray, 0, max_distance_local);
+        let distance_to_hit = this.bvh.raycast(out, local_ray);
 
         if (distance_to_hit >= 0) {
             // transform output

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

@@ -26,7 +26,6 @@ export class PathTracedScene {
      */
     private __background_sampler;
     optimize(): void;
-    build(): Promise<void>;
     /**
      *
      * @param {THREE.BufferGeometry} geo
@@ -56,6 +55,12 @@ export class PathTracedScene {
      * @returns {boolean}
      */
     removeMesh(mesh: PathTracedMesh): boolean;
+    /**
+     * Retrieves pre-cached material or build one from scratch, caches it and returns the result
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    obtainMaterial(material: THREE.Material): StandardMaterial;
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -67,17 +72,22 @@ export class PathTracedScene {
      *
      * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
      * @param {number[]} hit
+     * @param {Ray3} incoming_ray
      */
-    sample_material(out: number[], hit: number[]): void;
+    sample_material(out: number[], hit: number[], incoming_ray: Ray3): void;
+    /**
+     * Tests ray for occlusion
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      *
      * @param {number[]} out
      * @param {number[]|Ray3} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
      * @return {number} distance to contact, or -1 if no contact found
      */
-    trace(out: number[], ray: number[] | Ray3, min_distance: number, max_distance: number): number;
+    trace(out: number[], ray: number[] | Ray3): number;
     /**
      *
      * @param {number[]} out
@@ -91,14 +101,13 @@ export class PathTracedScene {
      * @param {number[]} out
      * @param {number} out_offset
      * @param {number[]} ray
-     * @param {number} ray_address
-     * @returns {boolean}
      */
-    sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
+    sample_lights(out: number[], out_offset: number, ray: number[]): void;
     #private;
 }
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
 import { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.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":"AA6CA;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,CA8CjB;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;oBA9d8B,mCAAmC;+BAiBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAgCA;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;;;;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;;;;OAIG;IACH,yBAHW,MAAM,QAAQ,oBAKxB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QAgCd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAkElB;;CACJ;oBArgB8B,mCAAmC;+BAkBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBALzC,kCAAkC"}