@woosh/meep-engine 2.109.4 → 2.109.6

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

@@ -9,6 +9,7 @@ import { strictEquals } from "../../../../core/function/strictEquals.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { v3_morton_encode_bounded } from "../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
@@ -25,24 +26,10 @@ import { sample_material } from "./texture/sample_material.js";
  */
 const scratch_uint32_array = new Uint32Array(4096);
 
-const _ray_1 = [];
-const tmp_0 = new Float64Array(11);
-const null_output = [];
+const _ray_1 = new Ray3();
 
 const DEFAULT_CONVERTER = new MaterialConverter();
 
-
-/**
- *
- * @param {Uint32Array} result
- * @param {number} result_offset
- * @param {number} count
- * @param {BVH} bvh
- */
-function bvh_build_query_cache(result, result_offset, count, bvh) {
-
-}
-
 export class PathTracedScene {
 
 
@@ -183,10 +170,6 @@ export class PathTracedScene {
         this.#rebuild_bvh();
     }
 
-    async build() {
-
-    }
-
     /**
      *
      * @param {THREE.BufferGeometry} geo
@@ -289,6 +272,15 @@ export class PathTracedScene {
         return true;
     }
 
+    /**
+     * Retrieves pre-cached material or build one from scratch, caches it and returns the result
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    obtainMaterial(material) {
+        return this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -296,7 +288,7 @@ export class PathTracedScene {
      * @param {mat4|number[]} transform
      */
     createMesh(geometry, material, transform) {
-        const standard_material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+        const standard_material = this.obtainMaterial(material);
 
         const mesh = new PathTracedMesh();
         mesh.geometry = geometry;
@@ -312,8 +304,9 @@ 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, hit) {
+    sample_material(out, hit, incoming_ray) {
         const primitive_id = hit[9];
         const instance_id = hit[10];
         const u = hit[7];
@@ -336,17 +329,65 @@ export class PathTracedScene {
 
         sample_material(out, mesh, primitive_id, u, v);
 
+        // const pdf = mesh.material.scattering_pdf(
+        //     incoming_ray[3],incoming_ray[4],incoming_ray[5],
+        //     out[3],out[4],out[5],
+        //     incoming_ray[3],incoming_ray[4],incoming_ray[5],
+        // );
+
+
+    }
+
+    /**
+     * Tests ray for occlusion
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray) {
+
+        const bvh = this.bvh_top_level;
+
+        const ray_origin_x = ray[0];
+        const ray_origin_y = ray[1];
+        const ray_origin_z = ray[2];
+
+        const ray_direction_x = ray[3];
+        const ray_direction_y = ray[4];
+        const ray_direction_z = ray[5];
+
+        const max_distance = ray[6];
+
+        const hit_count = bvh_query_user_data_ray_segment(
+            bvh, bvh.root,
+            scratch_uint32_array, 0,
+            ray_origin_x, ray_origin_y, ray_origin_z,
+            ray_direction_x, ray_direction_y, ray_direction_z,
+            0, max_distance
+        );
+
+
+        for (let i = 0; i < hit_count; i++) {
+
+            const node_user_data = scratch_uint32_array[i];
+
+            const mesh = this.meshes.get(node_user_data);
+
+            if (mesh.occluded(ray)) {
+                return true;
+            }
+
+        }
+
+        return false;
     }
 
     /**
      *
      * @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, ray, min_distance, max_distance) {
+    trace(out, ray) {
 
         const bvh = this.bvh_top_level;
 
@@ -358,13 +399,14 @@ export class PathTracedScene {
         const ray_direction_y = ray[4];
         const ray_direction_z = ray[5];
 
+        const max_distance = ray[6];
 
         const hit_count = bvh_query_user_data_ray_segment(
             bvh, bvh.root,
             scratch_uint32_array, 0,
             ray_origin_x, ray_origin_y, ray_origin_z,
             ray_direction_x, ray_direction_y, ray_direction_z,
-            min_distance, max_distance
+            0, max_distance
         );
 
         let nearest_hit_distance = max_distance;
@@ -375,7 +417,7 @@ export class PathTracedScene {
 
             const mesh = this.meshes.get(node_user_data);
 
-            const distance_to_hit = mesh.hit(out, ray, min_distance, nearest_hit_distance);
+            const distance_to_hit = mesh.hit(out, ray, nearest_hit_distance);
 
             if (distance_to_hit >= 0) {
                 // since raycast in leaf nodes is already bound by maximum distance, any hit we get is necessarily a closer hit than before
@@ -408,11 +450,8 @@ export class PathTracedScene {
      * @param {number[]} out
      * @param {number} out_offset
      * @param {number[]} ray
-     * @param {number} ray_address
-     * @returns {boolean}
      */
-    sample_lights(out, out_offset, ray, ray_address) {
-        let lights_sampled = false;
+    sample_lights(out, out_offset, ray) {
 
         const lights = this.__lights;
         const light_count = lights.length;
@@ -430,9 +469,9 @@ export class PathTracedScene {
 
                 // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
 
-                const ray_direction_x = ray[ray_address + 3];
-                const ray_direction_y = ray[ray_address + 4];
-                const ray_direction_z = ray[ray_address + 5];
+                const ray_direction_x = ray[3];
+                const ray_direction_y = ray[4];
+                const ray_direction_z = ray[5];
 
                 const light_dir_inv_x = -dir.x;
                 const light_dir_inv_y = -dir.y;
@@ -448,33 +487,33 @@ export class PathTracedScene {
                     continue;
                 }
 
-                const ray_origin_x = ray[ray_address + 0];
-                const ray_origin_y = ray[ray_address + 1];
-                const ray_origin_z = ray[ray_address + 2];
+                const ray_origin_x = ray[0];
+                const ray_origin_y = ray[1];
+                const ray_origin_z = ray[2];
 
                 ray3_array_compose(_ray_1,
                     ray_origin_x, ray_origin_y, ray_origin_z,
                     light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
                 );
 
+                _ray_1.tMax = Infinity;
+
                 // check if there are any obstacles in the direction of the light
-                if (this.trace(null_output, _ray_1, 0.0001, Infinity) > 0) {
+                if (this.occluded(_ray_1)) {
                     // light is occluded
                     continue;
                 }
 
 
                 const intensity = dotNL * light.intensity.getValue();
+                const light_color = light.color;
+
+                out[out_offset] += light_color.r * intensity;
+                out[out_offset + 1] += light_color.g * intensity;
+                out[out_offset + 2] += light_color.b * intensity;
 
-                for (let j = 0; j < 3; j++) {
-                    // irradiance
-                    out[out_offset + j] += light.color[j] * intensity;
-                }
 
-                lights_sampled = true;
             }
         }
-
-        return lights_sampled;
     }
 }

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

@@ -2,13 +2,13 @@ export class PathTracer {
     /**
      *
      * @param {number[]|Float32Array} out
-     * @param {number[]|Float32Array} ray
-     * @param {number} max_distance
+     * @param {number[]|Float32Array|Ray3} ray
      * @param {number} min_bounce
      * @param {number} max_bounce
      * @param {function} random
      * @param {PathTracedScene} scene
      */
-    path_trace(out: number[] | Float32Array, ray: number[] | Float32Array, max_distance: number, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
+    path_trace(out: number[] | Float32Array, ray: number[] | Float32Array | Ray3, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
 }
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 //# sourceMappingURL=PathTracer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":"AA2BA;IAGI;;;;;;;;;OASG;IACH,gBARW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,cACN,MAAM,cACN,MAAM,kDAgFhB;CACJ"}
+{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":"AAiCA;IAGI;;;;;;;;OAQG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,EAAE,GAAC,YAAY,GAAC,IAAI,cAC1B,MAAM,cACN,MAAM,kDAkFhB;CACJ;qBA1HoB,kCAAkC"}

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

@@ -1,5 +1,6 @@
 import { vec3 } from "gl-matrix";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { getBiasedNormalSample } from "./sampling/getBiasedNormalSample.js";
 
 /*
@@ -18,21 +19,25 @@ const irradiance = [0, 0, 0];
 
 const trace_result = [];
 
-const _ray_0 = [];
+const _ray_0 = new Ray3();
 
-const tmp_0 = [];
-const tmp_1 = [];
+const tmp_0 = new Float32Array(6);
 
+/**
+ * Normalized probability of terminating the ray
+ * @type {number}
+ */
 const RUSSIAN_ROULETTE_PROBABILITY = 0.5;
 
+const color_mask = new Float32Array(3);
+
 export class PathTracer {
 
 
     /**
      *
      * @param {number[]|Float32Array} out
-     * @param {number[]|Float32Array} ray
-     * @param {number} max_distance
+     * @param {number[]|Float32Array|Ray3} ray
      * @param {number} min_bounce
      * @param {number} max_bounce
      * @param {function} random
@@ -41,19 +46,21 @@ export class PathTracer {
     path_trace(
         out,
         ray,
-        max_distance,
         min_bounce,
         max_bounce,
         random = Math.random,
         scene
     ) {
-        //TODO add importance sampling, see https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#lightscattering/thescatteringpdf
 
-        array_copy(ray, 0, _ray_0, 0, 6);
+        _ray_0.copy(ray);
+
+        irradiance[0] = 0;
+        irradiance[1] = 0;
+        irradiance[2] = 0;
 
-        irradiance[0] = 1;
-        irradiance[1] = 1;
-        irradiance[2] = 1;
+        color_mask[0] = 1;
+        color_mask[1] = 1;
+        color_mask[2] = 1;
 
         let i;
         for (i = 0; i < max_bounce; ++i) {
@@ -61,15 +68,13 @@ export class PathTracer {
             if (i >= min_bounce) {
                 const russian_roulette_roll = random();
 
-                if (russian_roulette_roll > RUSSIAN_ROULETTE_PROBABILITY) {
+                if (russian_roulette_roll < RUSSIAN_ROULETTE_PROBABILITY) {
                     // terminate ray
                     break;
                 }
             }
 
-
-            const hit_distance = scene.trace(trace_result, _ray_0, 0.0001, max_distance);
-
+            const hit_distance = scene.trace(trace_result, _ray_0);
 
             if (hit_distance < 0) {
                 // ray didn't hit anything
@@ -77,30 +82,33 @@ export class PathTracer {
                 break;
             }
 
-            scene.sample_material(tmp_0, trace_result);
-
-            // adjust normal on the hit
-            array_copy(tmp_0, 3, trace_result, 3, 3);
-            array_copy(trace_result, 0, _ray_0, 0, 3);
+            scene.sample_material(tmp_0, trace_result, _ray_0);
 
-            // accumulate irradiance
-            vec3.multiply(irradiance, irradiance, tmp_0);
 
-            // reflect ray
-            getBiasedNormalSample(_ray_0, 3, tmp_0, 3, 1, random);
+            vec3.multiply(color_mask, color_mask, tmp_0);
 
-        }
+            // construct new ray, aligned on the normal of the contact
+            array_copy(tmp_0, 3, _ray_0, 3, 3); // copy new direction
+            array_copy(trace_result, 0, _ray_0, 0, 3); // copy new origin
 
+            // move ray forward by a small amount to avoid self-occlusion
+            _ray_0.shiftForward(0.00001);
 
-        if (i > 0) {
             // light sampling
-            scene.sample_lights(tmp_1, 0, trace_result, 0);
+            scene.sample_lights(tmp_0, 0, _ray_0);
+
+            // sample on cosine lobe ray
+            getBiasedNormalSample(_ray_0, 3, _ray_0, 3, 1, random);
+
+            // // accumulate irradiance
+            irradiance[0] += color_mask[0] * tmp_0[0];
+            irradiance[1] += color_mask[1] * tmp_0[1];
+            irradiance[2] += color_mask[2] * tmp_0[2];
+
+        }
 
-            irradiance[0] *= tmp_1[0];
-            irradiance[1] *= tmp_1[1];
-            irradiance[2] *= tmp_1[2];
-        } else {
 
+        if (i === 0) {
             // ray didn't hit anything on the very first bounce
 
             // sample "environment" and terminate path as there is nothing to reflect off of
@@ -113,6 +121,5 @@ export class PathTracer {
         out[1] = irradiance[1]
         out[2] = irradiance[2]
 
-        // array_copy(irradiance, 0, out, 0, 3);
     }
-}
+}

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialConverter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js"],"names":[],"mappings":"AASA;IA4BI;;;;OAIG;IACH,kBAHW,MAAM,QAAQ,GACZ,gBAAgB,CA2D5B;;CAEJ;iCA/FgC,uBAAuB"}
+{"version":3,"file":"MaterialConverter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js"],"names":[],"mappings":"AA8BA;IA4BI;;;;OAIG;IACH,kBAHW,MAAM,QAAQ,GACZ,gBAAgB,CAyC5B;;CAEJ;iCApGgC,uBAAuB"}

package/src/engine/graphics/sh3/path_tracer/material/MaterialConverter.js

@@ -1,12 +1,33 @@
 import { Color } from "three";
-import {
-    TextureAttachmentsByMaterialType
-} from "../../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
 import { convertTexture2Sampler2D } from "../../../texture/sampler/convertTexture2Sampler2D.js";
 import { sampler_multiply_vector } from "../../../texture/sampler/sampler_multiply_vector.js";
+import { iterate_three_material_textures } from "../../../three/material/iterate_three_material_textures.js";
 import { StandardMaterial } from "./StandardMaterial.js";
 import { StandardTexture } from "./StandardTexture.js";
 
+/**
+ *
+ * @param {Map<number,StandardTexture>} cache
+ * @param {AssetManager} asset_manager
+ * @param {THREE.Material} material
+ * @returns {Promise<void>}
+ */
+async function precache_textures(cache, asset_manager, material) {
+
+    const textures = iterate_three_material_textures(material);
+
+    for (const { name, texture } of textures) {
+        if (cache.has(texture.id)) {
+            // already processed
+            continue;
+        }
+
+
+    }
+
+
+}
+
 export class MaterialConverter {
     /**
      * Maps {@link Texture.id} to relevant sampler
@@ -44,46 +65,28 @@ export class MaterialConverter {
 
         const result = new StandardMaterial();
 
-        //patch textures
-        const materialType = material.type;
-
-        /**
-         *
-         * @type {TextureAttachment[]}
-         */
-        const attachments = TextureAttachmentsByMaterialType[materialType];
-
-        if (attachments !== undefined) {
-
-            for (let i = 0; i < attachments.length; i++) {
-                const attachment = attachments[i];
-
-                const texture = attachment.read(material);
-
-                if (texture === undefined || texture === null) {
-                    continue;
-                }
-
-                const sampler = this.#ensure_texture(texture);
-
-                const name = attachment.name;
-
-                if (name === "diffuse") {
-                    result.diffuse = sampler;
-                } else if (name === "normal") {
-                    result.normal = sampler;
-                } else if (name === "metalness") {
-                    result.metalness = sampler;
-                } else if (name === "roughness") {
-                    result.roughness = sampler;
-                } else if (name === "emissive") {
-                    result.emissive = sampler;
-                } else {
-                    // unused
-                }
+        const textures = iterate_three_material_textures(material);
 
+        //patch textures
 
+        for (const { name, texture } of textures) {
+
+            const sampler = this.#ensure_texture(texture);
+
+            if (name === "diffuse") {
+                result.diffuse = sampler;
+            } else if (name === "normal") {
+                result.normal = sampler;
+            } else if (name === "metalness") {
+                result.metalness = sampler;
+            } else if (name === "roughness") {
+                result.roughness = sampler;
+            } else if (name === "emissive") {
+                result.emissive = sampler;
+            } else {
+                // unused
             }
+
         }
 
         if (material.color !== undefined && !material.color.equals(new Color(1, 1, 1))) {

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts

@@ -5,6 +5,20 @@ export class StandardMaterial {
     emissive: StandardTexture;
     roughness: StandardTexture;
     metalness: StandardTexture;
+    /**
+     *
+     * @param {number} incoming_direction_x
+     * @param {number} incoming_direction_y
+     * @param {number} incoming_direction_z
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} outgoing_x
+     * @param {number}  outgoing_y
+     * @param {number} outgoing_z
+     * @returns {number}
+     */
+    scattering_pdf(incoming_direction_x: number, incoming_direction_y: number, incoming_direction_z: number, normal_x: number, normal_y: number, normal_z: number, outgoing_x: number, outgoing_y: number, outgoing_z: number): number;
 }
 import { StandardTexture } from "./StandardTexture.js";
 //# sourceMappingURL=StandardMaterial.d.ts.map

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AAWA;IACI,WAAkB;IAElB,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;CACtD;gCAlB+B,sBAAsB"}
+{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AAaA;IACI,WAAkB;IAElB,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;IAEnD;;;;;;;;;;;;OAYG;IACH,qCAXW,MAAM,wBACN,MAAM,wBACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAkBlB;CACJ;gCAjD+B,sBAAsB"}

package/src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js

@@ -1,8 +1,10 @@
+import { v3_dot } from "../../../../../core/geom/vec3/v3_dot.js";
+import { PI_RECIPROCAL } from "../../../../../core/math/PI_RECIPROCAL.js";
 import { one_pixel_sampler_uint8 } from "../../../texture/sampler/one_pixel_sampler_uint8.js";
 import { StandardTexture } from "./StandardTexture.js";
 
 const DEFAULT_DIFFUSE = one_pixel_sampler_uint8([255, 255, 255, 255]);
-const DEFAULT_NORMAL = one_pixel_sampler_uint8([0, 0, 255]);
+const DEFAULT_NORMAL = one_pixel_sampler_uint8([127, 127, 255]);
 const DEFAULT_EMISSIVE = one_pixel_sampler_uint8([0, 0, 0]);
 const DEFAULT_ROUGHNESS = one_pixel_sampler_uint8([255]);
 const DEFAULT_METALNESS = one_pixel_sampler_uint8([0]);
@@ -17,5 +19,36 @@ export class StandardMaterial {
     emissive = StandardTexture.from(DEFAULT_EMISSIVE)
     roughness = StandardTexture.from(DEFAULT_ROUGHNESS)
     metalness = StandardTexture.from(DEFAULT_METALNESS)
+
+    /**
+     *
+     * @param {number} incoming_direction_x
+     * @param {number} incoming_direction_y
+     * @param {number} incoming_direction_z
+     * @param {number} normal_x
+     * @param {number} normal_y
+     * @param {number} normal_z
+     * @param {number} outgoing_x
+     * @param {number}  outgoing_y
+     * @param {number} outgoing_z
+     * @returns {number}
+     */
+    scattering_pdf(
+        incoming_direction_x, incoming_direction_y, incoming_direction_z,
+        normal_x, normal_y, normal_z,
+        outgoing_x, outgoing_y, outgoing_z,
+    ) {
+        const cos_theta = v3_dot(
+            normal_x, normal_y, normal_z,
+            outgoing_x, outgoing_y, outgoing_z
+        );
+
+        if (cos_theta < 0) {
+            // clamp rays below horizon
+            return 0;
+        }
+
+        return cos_theta * PI_RECIPROCAL;
+    }
 }
 

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

@@ -0,0 +1,21 @@
+export function make_sun({ temperature, color, intensity, direction }?: {
+    temperature?: number;
+    color?: string;
+    intensity?: number;
+    direction?: Vector3;
+}): DirectionalLight;
+/**
+ *
+ * @param {PathTracedScene} scene
+ * @param {THREE.Camera} camera
+ * @param {string} url
+ * @param {number} [zoom]
+ * @param {number} [floor_level]
+ * @param {Object} [sun]
+ * @param {boolean} [no_materials]
+ * @return {Promise<void>}
+ */
+export function prepare_scene_gltf({ scene, camera, url, zoom, floor_level, sun, no_materials }: PathTracedScene): Promise<void>;
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
+//# sourceMappingURL=prepare_scene_gltf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare_scene_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/prepare_scene_gltf.js"],"names":[],"mappings":"AAaA;;;;;qBAyBC;AAaD;;;;;;;;;;GAUG;AACH,mHAFY,QAAQ,IAAI,CAAC,CA8CxB;oBAnGmB,kCAAkC;iCAErB,qDAAqD"}