@woosh/meep-engine 2.43.22 → 2.43.24

package/core/geom/3d/topology/struct/binary/io/create_edge.js

@@ -0,0 +1,106 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_from
+ * @param {number} edge_to
+ * @param {number} vertex
+ */
+function edge_link_disk_forward(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_next(edge_from);
+
+        mesh.edge_write_v1_disk_next(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_next(edge_from);
+
+        mesh.edge_write_v2_disk_next(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+function edge_link_disk_back(mesh, edge_from, edge_to, vertex) {
+    const from_v1 = mesh.edge_read_vertex1(edge_from);
+
+    let displaced_edge;
+
+    if (from_v1 === vertex) {
+        displaced_edge = mesh.edge_read_v1_disk_prev(edge_from);
+
+        mesh.edge_write_v1_disk_prev(edge_from, edge_to);
+
+    } else {
+        displaced_edge = mesh.edge_read_v2_disk_prev(edge_from);
+
+        mesh.edge_write_v2_disk_prev(edge_from, edge_to);
+    }
+
+    return displaced_edge;
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_source anchor edge, new edge is inserted after this one
+ * @param {number} edge_new edge that is being introduced
+ * @param {number} vertex
+ */
+function edge_link_disk(mesh, edge_source, edge_new, vertex) {
+    const forward_link = edge_link_disk_forward(mesh, edge_source, edge_new, vertex);
+    edge_link_disk_forward(mesh, edge_new, forward_link, vertex);
+
+    edge_link_disk_back(mesh, forward_link, edge_new, vertex);
+    edge_link_disk_back(mesh, edge_new, edge_source, vertex);
+}
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @return {number}
+ */
+export function create_edge(mesh, v0, v1) {
+    const edge_id = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge_id, v0);
+    mesh.edge_write_vertex2(edge_id, v1);
+
+    // initialize rest of the edge
+    mesh.edge_write_loop(edge_id, NULL_POINTER);
+
+    // process disk links
+    const first_v0_edge = mesh.vertex_read_edge(v0);
+
+    if (first_v0_edge !== NULL_POINTER) {
+        edge_link_disk(mesh, first_v0_edge, edge_id, v0);
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v0, edge_id);
+        // link to self
+        mesh.edge_write_v1_disk_next(edge_id, edge_id);
+        mesh.edge_write_v1_disk_prev(edge_id, edge_id);
+    }
+
+    const first_v1_edge = mesh.vertex_read_edge(v1);
+
+    if (first_v1_edge !== NULL_POINTER) {
+
+        edge_link_disk(mesh, first_v1_edge, edge_id, v1);
+
+    } else {
+        // no edges attached yet, attach this one as the first
+        mesh.vertex_write_edge(v1, edge_id);
+        // link to self
+        mesh.edge_write_v2_disk_next(edge_id, edge_id);
+        mesh.edge_write_v2_disk_prev(edge_id, edge_id);
+    }
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/io/get_or_create_edge_map.js

@@ -0,0 +1,26 @@
+import { OrderedEdge } from "./OrderedEdge.js";
+import { create_edge } from "./create_edge.js";
+
+/**
+ *
+ * @param {number} v0
+ * @param {number} v1
+ * @param {HashMap<OrderedEdge,number>} map
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge_map(v0, v1, map, mesh) {
+    const scratch_ordered_edge = new OrderedEdge(v0, v1);
+
+    const existing = map.get(scratch_ordered_edge);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    // doesn't exist - create
+    const edge_id = create_edge(mesh, v0, v1);
+
+    map.set(scratch_ordered_edge, edge_id);
+
+    return edge_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @param {number} vertex_id
+ * @returns {boolean}
+ */
+export function bt_mesh_edge_has_vertex(mesh, edge_id, vertex_id) {
+    const v1 = mesh.edge_read_vertex1(edge_id);
+
+    if (v1 === vertex_id) {
+        return true;
+    }
+
+    return mesh.edge_read_vertex2(edge_id) === vertex_id;
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_has_vertex.spec.js

@@ -0,0 +1,15 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_has_vertex } from "./bt_mesh_edge_has_vertex.js";
+
+test('main', () => {
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 7)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 3)).toBe(true);
+    expect(bt_mesh_edge_has_vertex(mesh, edge, 1)).toBe(false);
+});

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.js

@@ -0,0 +1,21 @@
+/**
+ * Returns other vertex ID
+ * Assumes that given vertex belongs to this edge
+ * Assumes that given edge exists
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id edge ID
+ * @param {number} vertex_id
+ * @returns {number}
+ */
+export function bt_mesh_edge_other_vertex(mesh, edge_id, vertex_id) {
+
+    const v1 = mesh.edge_read_vertex1(edge_id);
+    const v2 = mesh.edge_read_vertex2(edge_id);
+
+    if (v1 === vertex_id) {
+        return v2;
+    } else {
+        return v1;
+    }
+
+}

package/core/geom/3d/topology/struct/binary/query/bt_mesh_edge_other_vertex.spec.js

@@ -0,0 +1,16 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_other_vertex } from "./bt_mesh_edge_other_vertex.js";
+
+test('main', () => {
+
+    const mesh = new BinaryTopology();
+
+    const edge = mesh.edges.allocate();
+
+    mesh.edge_write_vertex1(edge, 7);
+    mesh.edge_write_vertex2(edge, 3);
+
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 7)).toBe(3);
+    expect(bt_mesh_edge_other_vertex(mesh, edge, 3)).toBe(7);
+
+});

package/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -1,7 +1,7 @@
 import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
 import { noop } from "../../../../function/Functions.js";
-import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
-import { BinaryTopology } from "./BinaryTopology.js";
+import { bt_index_geometry_to_topology } from "./binary/io/bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "./binary/BinaryTopology.js";
 import {
     compute_buffer_geometry_byte_size
 } from "../../../../../engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js";
@@ -18,27 +18,27 @@ function promise_ply(url) {
 
 async function main() {
 
-    // const url = "data/models/stanford/Lucy100k.ply";
-    const url = "data/models/stanford/dragon_recon/dragon_vrip.ply";
+    const url = "data/models/stanford/Lucy100k.ply";
+    // const url = "data/models/stanford/dragon_recon/dragon_vrip.ply";
     const lucy_geom = await promise_ply(url);
 
     const mesh = new BinaryTopology();
+    const topoMesh = new TopoMesh();
 
     const positions_array = lucy_geom.getAttribute('position').array;
     const index_array = lucy_geom.getIndex().array;
 
 
-    const topoMesh = new TopoMesh();
-
-    console.time('topo build - obj');
-    topoMesh.build(positions_array, index_array);
-    console.timeEnd('topo build - obj');
-
-    // console.time('topo build - bin');
-    console.profile('topo build - bin');
+    console.time('topo build - bin');
+    // console.profile('topo build - bin');
     bt_index_geometry_to_topology(mesh, index_array, positions_array);
-    console.profileEnd('topo build - bin');
-    // console.timeEnd('topo build - bin');
+    // console.profileEnd('topo build - bin');
+    console.timeEnd('topo build - bin');
+
+    //
+    // console.time('topo build - obj');
+    // topoMesh.build(positions_array, index_array);
+    // console.timeEnd('topo build - obj');
 
     mesh.trim();
 

package/core/path/PATH_SEPARATOR.js

@@ -0,0 +1 @@
+export const PATH_SEPARATOR = '/';

package/core/path/computeFileExtension.js

@@ -0,0 +1,24 @@
+import { computePathBase } from "./computePathBase.js";
+
+/**
+ *
+ * @param {string} path
+ * @returns {String|null}
+ */
+export function computeFileExtension(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    //get base
+    const pathBase = computePathBase(path);
+
+    const lastDotIndex = pathBase.lastIndexOf('.');
+
+    if (lastDotIndex !== -1) {
+        return pathBase.substring(lastDotIndex + 1);
+    } else {
+        //no extension
+        return null;
+    }
+}

package/core/path/computeFileExtension.spec.js

@@ -0,0 +1,13 @@
+import { computeFileExtension } from "./computeFileExtension.js";
+
+test('extract extension of cat.txt', () => {
+    expect(computeFileExtension('cat.txt')).toEqual('txt');
+});
+
+test('extract extension of ../hmm/cat.txt', () => {
+    expect(computeFileExtension('../hmm/cat.txt')).toEqual('txt');
+});
+
+test('extract extension of empty string', () => {
+    expect(computeFileExtension('')).toBeNull();
+});

package/core/path/computePathBase.js

@@ -0,0 +1,21 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Strips all directories from the path.
+ * @example 'a/b/c' -> 'c'
+ * @param {string} path
+ * @returns {string}
+ */
+export function computePathBase(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(lastSlashIndex + 1);
+    } else {
+        return path;
+    }
+}

package/core/path/computePathBase.spec.js

@@ -0,0 +1,13 @@
+import { computePathBase } from "./computePathBase.js";
+
+test('extract base path of empty string', () => {
+    expect(computePathBase('')).toBe('');
+});
+
+test('extract base path of hello', () => {
+    expect(computePathBase('hello')).toBe('hello');
+});
+
+test('extract base path of hello/there/world', () => {
+    expect(computePathBase('hello/there/world')).toBe('world');
+});

package/core/path/computePathDirectory.js

@@ -0,0 +1,25 @@
+import { PATH_SEPARATOR } from "./PATH_SEPARATOR.js";
+
+/**
+ * Returns the directory name of a path, similar to the Unix dirname command.
+ * @param {string} path
+ * @return {string}
+ */
+export function computePathDirectory(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    //rewind in case of trailing slashes
+    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
+        lastSlashIndex--;
+    }
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(0, lastSlashIndex);
+    } else {
+        return path;
+    }
+}

package/editor/Editor.js

@@ -71,8 +71,8 @@ import { ObservedIntegerEditor } from "./ecs/component/editors/ObservedIntegerEd
 
 import '../../../../css/editor/EntityEditorView.scss';
 import '../../../../css/editor/EditorView.scss';
-import {ParameterTrackSet} from "../engine/graphics/particles/particular/engine/parameter/ParameterTrackSet.js";
-import {ParameterTrackSetEditor} from "./ecs/component/editors/ecs/ParameterTrackSetEditor.js";
+import { ParameterTrackSet } from "../engine/graphics/particles/particular/engine/parameter/ParameterTrackSet.js";
+import { ParameterTrackSetEditor } from "./ecs/component/editors/ecs/ParameterTrackSetEditor.js";
 
 /**
  * @template T
@@ -485,6 +485,7 @@ function Editor() {
             resetSoundEmitterTracks(dataset);
 
             const serializer = new BinaryBufferSerializer();
+            serializer.engine = self.engine;
             serializer.registry = engine.binarySerializationRegistry;
 
             const state = new EncodingBinaryBuffer();

package/editor/view/library/MeshLibraryView.js

@@ -2,13 +2,13 @@ import View from "../../../view/View.js";
 import { makeModelView } from "../../../view/renderModel.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import domify from "../../../view/DOM.js";
-import { computePathBase } from "../../../core/FilePath.js";
 import LabelView from "../../../view/common/LabelView.js";
 import List from "../../../core/collection/list/List.js";
 import AABB2 from "../../../core/geom/AABB2.js";
 import { DragEvents } from "../../../engine/input/devices/events/DragEvents.js";
 import { MouseEvents } from "../../../engine/input/devices/events/MouseEvents.js";
 import { TouchEvents } from "../../../engine/input/devices/events/TouchEvents.js";
+import { computePathBase } from "../../../core/path/computePathBase.js";
 
 
 const ICON_SIZE = 50;

package/engine/EngineHarness.js

@@ -29,6 +29,8 @@ import { noop } from "../core/function/Functions.js";
 import SoundListenerSystem from "./sound/ecs/SoundListenerSystem.js";
 import SoundListener from "./sound/ecs/SoundListener.js";
 import { getURLHash } from "./platform/GetURLHash.js";
+import Stats from "three/examples/jsm/libs/stats.module.js";
+import EmptyView from "../view/elements/EmptyView.js";
 
 /**
  *
@@ -68,6 +70,22 @@ export class EngineHarness {
         this.p = null;
     }
 
+    /**
+     *
+     * @param {Engine} engine
+     */
+    static addFpsCounter(engine) {
+        const stats = new Stats();
+
+        engine.graphics.on.postRender.add(stats.update, stats);
+
+        const view = new EmptyView({
+            el: stats.domElement
+        });
+
+        engine.viewStack.addChild(view);
+    }
+
     /**
      * @param {(config:EngineConfiguration,engine:Engine)=>*} configuration
      * @param {boolean} [enable_localization] Whether or not to load localization data
@@ -228,6 +246,7 @@ export class EngineHarness {
      * @param {boolean} [cameraController=true]
      * @param {boolean} [cameraAutoClip]
      * @param shadowmapResolution
+     * @param showFps
      */
     static async buildBasics({
                                  engine,
@@ -246,9 +265,14 @@ export class EngineHarness {
                                  cameraFarDistance,
                                  cameraController = true,
                                  cameraAutoClip = false,
-                                 shadowmapResolution
+                                 shadowmapResolution,
+                                 showFps = true
                              }) {
 
+        if (showFps) {
+            EngineHarness.addFpsCounter(engine);
+        }
+
         if (enableLights) {
             await EngineHarness.buildLights({ engine: engine, shadowmapResolution });
         }

package/engine/asset/guessAssetType.js

@@ -1,4 +1,4 @@
-import { computeFileExtension } from "../../core/FilePath.js";
+import { computeFileExtension } from "../../core/path/computeFileExtension.js";
 
 /**
  *

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -1,5 +1,4 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { GameAssetType } from "../../GameAssetType.js";
 import { convertTexture2Sampler2D } from "../../../graphics/texture/sampler/convertTexture2Sampler2D.js";
 import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
@@ -7,6 +6,7 @@ import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
 import { CodecWithFallback } from "./codec/CodecWithFallback.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
 import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 

package/engine/asset/loaders/texture/TextureAssetLoader.js

@@ -1,7 +1,7 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { loadDDSTexture } from "./loadDDSTexture.js";
 import { loadStandardImageTexture } from "./loadStandardImageTexture.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 export class TextureAssetLoader extends AssetLoader {
     load(path, success, failure, progress) {

package/engine/ecs/storage/BinaryBufferSerializer.js

@@ -55,6 +55,11 @@ class BinaryBufferSerializer {
          * @type {BinarySerializationRegistry}
          */
         this.registry = null;
+        /**
+         *
+         * @type {Engine|null}
+         */
+        this.engine = null;
     }
 
     /**
@@ -92,6 +97,8 @@ class BinaryBufferSerializer {
 
         let i;
 
+        const engine = this.engine;
+
         for (i = 0; i < numSerializableTypes; i++) {
 
             const componentType = serializableComponentTypes[i];

package/engine/graphics/camera/camera_compute_distance_to_fit_length.js

@@ -8,9 +8,13 @@ import { assert } from "../../../core/assert.js";
  */
 export function camera_compute_distance_to_fit_length(length, fov) {
     assert.isNumber(length, 'length');
+    assert.greaterThanOrEqual(length, 0, 'length < 0');
+
     assert.isNumber(fov, 'fov');
     assert.greaterThan(fov, 0, 'fov <= 0');
     assert.lessThan(fov, Math.PI, 'fov >= pi');
 
-    return Math.abs((length / 2) / Math.sin(fov / 2));
+    const signed_distance = (length * 0.5) / Math.tan(fov * 0.5);
+
+    return Math.abs(signed_distance);
 }

package/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js

@@ -1,3 +1,29 @@
+import { array_quick_sort_by_comparator } from "../../../../../../core/collection/array/arrayQuickSort.js";
+
+/**
+ *
+ * @param {THREE.Object3D} a
+ * @param {THREE.Object3D} b
+ * @returns {number}
+ */
+function compare_by_material(a, b) {
+
+    const a_mat = a.material;
+    const b_mat = b.material;
+
+    if (a_mat === b_mat) {
+        return 0;
+    }
+
+    if (a_mat === undefined) {
+        return 1;
+    } else if (b_mat === undefined) {
+        return -1;
+    }
+
+    return a_mat.id - b_mat.id;
+}
+
 export class AbstractRenderAdapter {
     constructor() {
 
@@ -16,6 +42,13 @@ export class AbstractRenderAdapter {
         this.__objects = [];
     }
 
+    /**
+     * Sorting objects by material will help reduce context switching and number of graphics API calls
+     */
+    sort_by_material() {
+        array_quick_sort_by_comparator(this.__objects, compare_by_material, null, 0, this.__object_count - 1);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -110,6 +110,7 @@ async function main(engine) {
         // sg.draw_method = 2;
         // sg.draw_method = DRAW_METHOD_INSTANCED;
         // sg.draw_method = random() > 0.5 ? DRAW_METHOD_INSTANCED : 2;
+        sg.setFlag(ShadedGeometryFlags.DrawMethodLocked);
         sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
 
         new EntityBuilder()

package/engine/graphics/material/composeCompile.js

@@ -13,6 +13,7 @@ export function composeCompile(previous, next) {
     let t1_cache = cache.get(previous);
 
     if (t1_cache === undefined) {
+        // no caches starting from previous
         t1_cache = new WeakMap();
 
         cache.set(previous, t1_cache);
@@ -21,14 +22,11 @@ export function composeCompile(previous, next) {
     let result_function = t1_cache.get(next);
 
     if (result_function === undefined) {
+        // no matching function found for pair, let's create it
+
         // we create a custom function just to be able to name our function, this is because of how three.js caches onBeforeCompile by just turning it into the string, so changing the function name will result in altered cache key
         const f = new Function('previous, next', `return function f${id_counter++}(a,b,c,d){ previous(a,b,c,d); next(a,b,c,d); };`);
 
-        // result_function = function (a, b, c, d) {
-        //     previous(a, b, c, d);
-        //     next(a, b, c, d);
-        // };
-        //
 
         result_function = f(previous, next);
 

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -1,5 +1,4 @@
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { computePathDirectory } from "../../../../core/FilePath.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
@@ -12,6 +11,7 @@ import {
     deserialize_geometry_collection
 } from "../format/serialization/collection/geometry_collection_serialization.js";
 import { GLTF_MICRON_ID_FIELD } from "./GLTF_MICRON_ID_FIELD.js";
+import { computePathDirectory } from "../../../../core/path/computePathDirectory.js";
 
 export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 

package/engine/graphics/sh3/README.md

@@ -3,3 +3,5 @@ Path tracing ideas:
 * [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
 * [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)
 * http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/
+* [Global Illumination and Path Tracing](https://www.scratchapixel.com/lessons/3d-basic-rendering/global-illumination-path-tracing/global-illumination-path-tracing-practical-implementation)
+* [Path Tracing, by Steve Rotenberg](https://cseweb.ucsd.edu/classes/sp17/cse168-a/CSE168_08_PathTracing.pdf)

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

@@ -20,7 +20,6 @@ import {
     UnsignedByteType
 } from "three";
 import { linear_to_sRGB } from "../../../../core/color/linear_to_sRGB.js";
-import { random_in_hemisphere } from "./random_in_hemisphere.js";
 import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
 import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
 import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
@@ -527,10 +526,6 @@ export class PathTracer {
                 break;
             }
 
-
-            // irradiance[0] += m;
-            // irradiance[1] += m;
-            // irradiance[2] += m;
             this.sample_material(tmp_0, trace_result);
 
             // adjust normal on the hit
@@ -541,7 +536,6 @@ export class PathTracer {
             array_copy(trace_result, 0, _ray_0, 0, 3);
 
             getBiasedNormalSample(_ray_0, 3, tmp_0, 3, 1, random);
-            // random_in_hemisphere(random, _ray_0, 3, tmp_0, 3);
 
             // accumulate
             vec3.multiply(irradiance, irradiance, tmp_0);
@@ -556,14 +550,6 @@ export class PathTracer {
             vec3.multiply(irradiance, irradiance, tmp_1);
         }
 
-        //
-        // if (got_emission === false) {
-        //     // no light source was hit, propagate shadow(darkness) along the ray
-        //     irradiance[0] = 0;
-        //     irradiance[1] = 0;
-        //     irradiance[2] = 0;
-        // }
-
         array_copy(irradiance, 0, out, 0, 3);
     }
 }