@woosh/meep-engine 2.108.4 → 2.109.0

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

@@ -1,18 +1,22 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_sort_for_traversal_depth_first } from "../../../../core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.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 { Cache } from "../../../../core/cache/Cache.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { strictEquals } from "../../../../core/function/strictEquals.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
-import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
 import { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
-import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
 import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.js";
-import { GeometryBVHBatched } from "./GeometryBVHBatched.js";
+import { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
 import { make_vector3 } from "./make_one_vector3.js";
+import { MaterialConverter } from "./material/MaterialConverter.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { sample_material } from "./texture/sample_material.js";
 
@@ -21,6 +25,9 @@ const _ray_1 = [];
 const tmp_0 = [];
 const null_output = [];
 
+const DEFAULT_CONVERTER = new MaterialConverter();
+
+
 export class PathTracedScene {
 
 
@@ -44,16 +51,20 @@ export class PathTracedScene {
 
     /**
      *
-     * @type {Map<THREE.BufferGeometry, GeometryBVHBatched>}
+     * @type {Map<THREE.BufferGeometry, BufferedGeometryBVH>}
      */
     geo_cache = new Map();
 
     /**
-     * Maps {@link Texture.id} to relevant sampler
-     * @type {Map<number, Sampler2D>}
+     *
+     * @type {Cache<THREE.Material, StandardMaterial>}
      */
-    textures = new Map();
-
+    #material_cache = new Cache({
+        keyEqualityFunction: strictEquals,
+        keyHashFunction(mat) {
+            return mat.id
+        }
+    });
 
     /**
      *
@@ -72,44 +83,13 @@ export class PathTracedScene {
         for (const [id, mesh] of this.meshes) {
             const material = mesh.material;
 
-            //patch textures
-            const materialType = material.type;
-
-            /**
-             *
-             * @type {TextureAttachment[]}
-             */
-            const attachments = TextureAttachmentsByMaterialType[materialType];
-
-            if (attachments === undefined) {
-                // unsupported
-                continue;
-            }
-
-            for (let i = 0; i < attachments.length; i++) {
-                const attachment = attachments[i];
-
-                const texture = attachment.read(material);
-
-                if (texture === undefined || texture === null) {
-                    continue;
-                }
-
-                if (this.textures.has(texture.id)) {
-                    continue;
-                }
-
-                const sampler2D = convertTexture2Sampler2D(texture, undefined, undefined, false);
-
-                this.textures.set(texture.id, sampler2D);
-            }
         }
     }
 
     /**
      *
      * @param {THREE.BufferGeometry} geo
-     * @return {GeometryBVHBatched}
+     * @return {BufferedGeometryBVH}
      */
     obtainGeometryBVH(geo) {
         const cached = this.geo_cache.get(geo);
@@ -118,7 +98,7 @@ export class PathTracedScene {
             return cached;
         }
 
-        const bvh = new GeometryBVHBatched();
+        const bvh = new BufferedGeometryBVH();
 
         const label = `bvh build ${compute_geometry_polycount(geo)}`;
         console.time(label);
@@ -151,12 +131,13 @@ export class PathTracedScene {
 
         const mesh = new PathTracedMesh();
         mesh.geometry = geo;
-        mesh.material = material;
-        mesh.transform = transform;
 
+        mesh.material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
 
         mesh.geo_bvh = this.obtainGeometryBVH(geo);
 
+        mesh.transform = transform;
+
         const bvh = this.bvh_top_level;
 
         const bvh_node_id = bvh.allocate_node();
@@ -217,7 +198,7 @@ export class PathTracedScene {
             return;
         }
 
-        sample_material(out, mesh, this.textures, primitive_id, u, v);
+        sample_material(out, mesh, primitive_id, u, v);
 
     }
 
@@ -232,7 +213,7 @@ export class PathTracedScene {
     trace(out, ray, min_distance, max_distance) {
         const bvh = this.bvh_top_level;
 
-        const hit_count = bvh_query_user_data_ray(
+        const hit_count = bvh_query_leaves_ray(
             bvh, bvh.root,
             temp_ray_results, 0,
             ray[0], ray[1], ray[2],
@@ -244,7 +225,20 @@ export class PathTracedScene {
 
 
         for (let i = 0; i < hit_count; i++) {
-            const node_user_data = temp_ray_results[i];
+            const node = temp_ray_results[i];
+
+            bvh.node_get_aabb(node, tmp_0);
+
+            if (aabb3_unsigned_distance_sqr_to_point(
+                tmp_0[0], tmp_0[1], tmp_0[2],
+                tmp_0[3], tmp_0[4], tmp_0[5],
+                ray[0], ray[1], ray[2]
+            ) > nearest_hit_distance * nearest_hit_distance) {
+                // bounds of the mesh are too far
+                continue;
+            }
+
+            const node_user_data = bvh.node_get_user_data(node);
 
             const mesh = this.meshes.get(node_user_data);
 

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

@@ -0,0 +1,11 @@
+export class MaterialConverter {
+    /**
+     *
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    convert(material: THREE.Material): StandardMaterial;
+    #private;
+}
+import { StandardMaterial } from "./StandardMaterial.js";
+//# sourceMappingURL=MaterialConverter.d.ts.map

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

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

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

@@ -0,0 +1,102 @@
+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 { StandardMaterial } from "./StandardMaterial.js";
+import { StandardTexture } from "./StandardTexture.js";
+
+export class MaterialConverter {
+    /**
+     * Maps {@link Texture.id} to relevant sampler
+     * @type {Map<number, StandardTexture>}
+     */
+    #textures = new Map();
+
+    /**
+     *
+     * @param {THREE.Texture} texture
+     * @returns {StandardTexture}
+     */
+    #ensure_texture(texture) {
+        const existing = this.#textures.get(texture.id);
+
+        if (existing !== undefined) {
+            return existing
+        }
+
+        const sampler2D = convertTexture2Sampler2D(texture, undefined, undefined, false);
+
+        const st = StandardTexture.from(sampler2D);
+
+        this.#textures.set(texture.id, st);
+
+        return st;
+    }
+
+    /**
+     *
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    convert(material) {
+
+        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
+                }
+
+
+            }
+        }
+
+        if (material.color !== undefined && !material.color.equals(new Color(1, 1, 1))) {
+            const tinted_diffuse = result.diffuse.clone();
+
+            tinted_diffuse.sampler = tinted_diffuse.sampler.clone();
+
+            sampler_multiply_vector(tinted_diffuse.sampler, result.diffuse.sampler, material.color.toArray());
+
+            result.diffuse = tinted_diffuse;
+        }
+
+        return result;
+    }
+
+}

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

@@ -0,0 +1,9 @@
+export class StandardMaterial {
+    diffuse: StandardTexture;
+    normal: StandardTexture;
+    emissive: StandardTexture;
+    roughness: StandardTexture;
+    metalness: StandardTexture;
+}
+import { StandardTexture } from "./StandardTexture.js";
+//# sourceMappingURL=StandardMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StandardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardMaterial.js"],"names":[],"mappings":"AASA;IACI,yBAA+C;IAC/C,wBAA6C;IAC7C,0BAAiD;IACjD,2BAAmD;IACnD,2BAAmD;CACtD;gCAd+B,sBAAsB"}

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

@@ -0,0 +1,17 @@
+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_EMISSIVE = one_pixel_sampler_uint8([0, 0, 0]);
+const DEFAULT_ROUGHNESS = one_pixel_sampler_uint8([255]);
+const DEFAULT_METALNESS = one_pixel_sampler_uint8([0]);
+
+export class StandardMaterial {
+    diffuse = StandardTexture.from(DEFAULT_DIFFUSE)
+    normal = StandardTexture.from(DEFAULT_NORMAL)
+    emissive = StandardTexture.from(DEFAULT_EMISSIVE)
+    roughness = StandardTexture.from(DEFAULT_ROUGHNESS)
+    metalness = StandardTexture.from(DEFAULT_METALNESS)
+}
+

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

@@ -0,0 +1,31 @@
+export class StandardTexture {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {StandardTexture}
+     */
+    static from(sampler: Sampler2D): StandardTexture;
+    /**
+     * @type {Sampler2D}
+     */
+    sampler: Sampler2D;
+    magFilter: number;
+    type: BinaryDataType;
+    wrapS: number;
+    wrapT: number;
+    /**
+     *
+     * @param {StandardTexture} other
+     */
+    copy(other: StandardTexture): void;
+    clone(): StandardTexture;
+    /**
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} u
+     * @param {number} v
+     */
+    sample(out: number[] | Float32Array, u: number, v: number): void;
+}
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+//# sourceMappingURL=StandardTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StandardTexture.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/StandardTexture.js"],"names":[],"mappings":"AAOA;IA8BI;;;;OAIG;IACH,iCAFa,eAAe,CAQ3B;IAxCD;;OAEG;IACH,mBAAO;IACP,kBAAsC;IACtC,qBAA2B;IAC3B,cAA2C;IAC3C,cAA2C;IAE3C;;;OAGG;IACH,YAFW,eAAe,QAQzB;IAED,yBAMC;IAeD;;;;;OAKG;IACH,YAJW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,QA6BhB;CACJ;+BAnF8B,mDAAmD"}

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

@@ -0,0 +1,85 @@
+import { LinearFilter, LinearMipmapLinearFilter, NearestFilter, NearestMipMapLinearFilter } from "three";
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { apply_texture_clamping_to_coordinate } from "../texture/apply_texture_clamping_to_coordinate.js";
+import { vec3_uint8_to_float } from "../vec3_uint8_to_float.js";
+import { TextureFilter } from "./TextureFilter.js";
+import { TextureWrapping } from "./TextureWrapping.js";
+
+export class StandardTexture {
+    /**
+     * @type {Sampler2D}
+     */
+    sampler
+    magFilter = TextureFilter.LinearFilter
+    type = BinaryDataType.Uint8
+    wrapS = TextureWrapping.ClampToEdgeWrapping
+    wrapT = TextureWrapping.ClampToEdgeWrapping
+
+    /**
+     *
+     * @param {StandardTexture} other
+     */
+    copy(other) {
+        this.sampler = other.sampler
+        this.magFilter = other.magFilter
+        this.type = other.type
+        this.wrapS = other.wrapS
+        this.wrapT = other.wrapT
+    }
+
+    clone() {
+        const r = new StandardTexture();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {StandardTexture}
+     */
+    static from(sampler) {
+        const texture = new StandardTexture();
+
+        texture.sampler = sampler;
+
+        return texture;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} out
+     * @param {number} u
+     * @param {number} v
+     */
+    sample(out, u, v) {
+
+        const _u = apply_texture_clamping_to_coordinate(this.wrapS, u);
+        const _v = apply_texture_clamping_to_coordinate(this.wrapT, v);
+
+
+        const magFilter = this.magFilter;
+
+        const sampler = this.sampler;
+
+        switch (magFilter) {
+            default:
+            case NearestFilter:
+            case NearestMipMapLinearFilter:
+                sampler.sampleNearestUV(_u, _v, out);
+                break;
+
+            case LinearFilter:
+            case LinearMipmapLinearFilter:
+
+                sampler.sampleBilinearUV(_u, _v, out);
+                break;
+        }
+
+        if (this.type === BinaryDataType.Uint8) {
+            vec3_uint8_to_float(out, out);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+export type TextureFilter = number;
+export namespace TextureFilter {
+    let NearestFilter: number;
+    let NearestMipmapNearestFilter: number;
+    let NearestMipMapNearestFilter: number;
+    let NearestMipmapLinearFilter: number;
+    let NearestMipMapLinearFilter: number;
+    let LinearFilter: number;
+    let LinearMipmapNearestFilter: number;
+    let LinearMipMapNearestFilter: number;
+    let LinearMipmapLinearFilter: number;
+    let LinearMipMapLinearFilter: number;
+}
+//# sourceMappingURL=TextureFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextureFilter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/TextureFilter.js"],"names":[],"mappings":"4BACU,MAAM"}

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

@@ -0,0 +1,17 @@
+/**
+ * @enum {number}
+ */
+export const TextureFilter = {
+
+    NearestFilter: 1003,
+    NearestMipmapNearestFilter: 1004,
+    NearestMipMapNearestFilter: 1004,
+    NearestMipmapLinearFilter: 1005,
+    NearestMipMapLinearFilter: 1005,
+    LinearFilter: 1006,
+    LinearMipmapNearestFilter: 1007,
+    LinearMipMapNearestFilter: 1007,
+    LinearMipmapLinearFilter: 1008,
+    LinearMipMapLinearFilter: 1008
+
+};

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

@@ -0,0 +1,7 @@
+export type TextureWrapping = number;
+export namespace TextureWrapping {
+    let RepeatWrapping: number;
+    let ClampToEdgeWrapping: number;
+    let MirroredRepeatWrapping: number;
+}
+//# sourceMappingURL=TextureWrapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextureWrapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/material/TextureWrapping.js"],"names":[],"mappings":"8BACU,MAAM"}

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

@@ -0,0 +1,9 @@
+/**
+ * @enum {number}
+ */
+export const TextureWrapping = {
+
+    RepeatWrapping: 1000,
+    ClampToEdgeWrapping: 1001,
+    MirroredRepeatWrapping: 1002
+}

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

@@ -34,6 +34,7 @@ import { Transform } from "../../../ecs/transform/Transform.js";
 import { MouseEvents } from "../../../input/devices/events/MouseEvents.js";
 import { makeSimpleTaskProgressView } from "../../../makeSimpleTaskProgressView.js";
 import { Camera } from "../../ecs/camera/Camera.js";
+import { three_camera_set_transform_rotation } from "../../ecs/camera/CameraSystem.js";
 import { makeGeometryIndexed } from "../../geometry/buffered/makeGeometryIndexed.js";
 import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
 import { sampler2d_scale } from "../../texture/sampler/resize/sampler2d_scale.js";
@@ -73,7 +74,7 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 64;
+const PIXEL_SAMPLE_COUNT = 256;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();
@@ -164,10 +165,19 @@ function promise_gltf(url) {
  * @param {PathTracedScene} scene
  * @param {THREE.Camera} camera
  * @param {string} url
- * @param zoom
+ * @param {number} [zoom]
+ * @param {number} [floor_level]
+ * @param {Object} [sun]
  * @return {Promise<void>}
  */
-async function prepare_scene_gltf(scene, camera, url, zoom = 1) {
+async function prepare_scene_gltf({
+                                      scene,
+                                      camera,
+                                      url,
+                                      zoom = 1,
+                                      floor_level = 0,
+                                      sun
+                                  }) {
     const gltf = await promise_gltf(url);
 
 
@@ -175,7 +185,7 @@ async function prepare_scene_gltf(scene, camera, url, zoom = 1) {
         color: '#ffceae'
     });
     scene.addMesh(new PlaneBufferGeometry(), ground_material, Transform.fromJSON({
-        position: new Vector3(0, 0, 0),
+        position: new Vector3(0, floor_level, 0),
         scale: 5000,
         rotation: Quaternion.fromEulerAngles(-Math.PI / 2, 0, 0)
     }).matrix);
@@ -196,7 +206,7 @@ async function prepare_scene_gltf(scene, camera, url, zoom = 1) {
 
     box3.getBoundingSphere(sphere);
 
-    scene.addLight(make_sun());
+    scene.addLight(make_sun(sun));
 
     camera.position.set(1, 1.3, 1)
         .normalize()
@@ -241,6 +251,88 @@ async function prepare_scene_lucy(scene, camera) {
     camera.lookAt(0, 0, 0);
 }
 
+
+/**
+ *
+ * @param {THREE.Camera} camera
+ * @param {Transform} transform
+ */
+function set_camera_from_transform(camera, transform) {
+    camera.position.copy(transform.position);
+    three_camera_set_transform_rotation(camera, transform.rotation);
+
+    camera.updateMatrixWorld();
+}
+
+/**
+ *
+ * @param {PathTracedScene} scene
+ * @param {THREE.Camera} camera
+ * @returns {Promise<void>}
+ */
+async function prepare_gi_box_scene(scene, camera) {
+    const path = 'data/models/samples/gi_box_01/model.glb';
+    await prepare_scene_gltf({
+        scene: scene,
+        camera: camera,
+        url: path,
+        sun: {
+            direction: new Vector3(1.2, -1, 0.2)
+        }
+    });
+
+    const transform = Transform.fromJSON({
+        "position": { "x": -2.320852352090763, "y": 4.765851637629835, "z": 5.154489928319274 },
+        "rotation": {
+            "x": 0.00480805808535541,
+            "y": 0.9797795216336188,
+            "z": -0.19861114162102378,
+            "w": 0.02371889518587569
+        },
+        "scale": {
+            "x": 1, "y": 1, "z": 1
+        }
+    });
+
+    set_camera_from_transform(camera, transform);
+
+}
+
+/**
+ *
+ * @param {PathTracedScene} scene
+ * @param {THREE.Camera} camera
+ * @returns {Promise<void>}
+ */
+async function prepare_sponza(scene, camera) {
+    const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    await prepare_scene_gltf({
+        scene: scene,
+        camera: camera,
+        url: path,
+        sun: {
+            direction: new Vector3(0.2, -1, 0.2)
+        }
+    });
+
+    const transform = Transform.fromJSON({
+        "position": {
+            "x": -5.888122646477855,
+            "y": 4.631130854487186,
+            "z": -0.35698656745007035
+        },
+        "rotation": {
+            "x": 0.10780203229473442,
+            "y": 0.6847605545801206,
+            "z": -0.10349143573419042,
+            "w": 0.7132820111666399
+        },
+        "scale": { "x": 1, "y": 1, "z": 1 }
+    });
+
+    set_camera_from_transform(camera, transform);
+}
+
 /**
  * Ray-Tracing In One Weekend test scene
  * @param {PathTracer} pt
@@ -446,7 +538,7 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(pixel_color, ray, Infinity, 3, 7, random, scene);
+                        pt.path_trace(pixel_color, ray, Infinity, 1, 7, random, scene);
 
                         pixel_accummulation[0] += pixel_color[0];
                         pixel_accummulation[1] += pixel_color[1];
@@ -501,13 +593,16 @@ async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
     // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
-    const path = 'data/models/pica_pica/pica_pica.gltf';
+    // const path = 'data/models/pica_pica/pica_pica.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(scene, camera);
-    // await prepare_scene_rtiow(pt, camera);
+    await prepare_scene_rtiow(pt, camera);
     // await prepare_scene_sphere_01(pt, camera);
-    await prepare_scene_gltf(scene, camera, path);
+    // await prepare_gi_box_scene(scene, camera);
+    // await prepare_sponza(scene, camera);
+    // await prepare_scene_gltf(scene, camera, path);
+
 
     await scene.build();
     // pt.optimize();