@woosh/meep-engine 2.109.0 → 2.109.2

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

@@ -1,33 +1,51 @@
 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, ELEMENT_WORD_COUNT, NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
+import { ebvh_build_hierarchy } from "../../../../core/bvh2/bvh3/ebvh_build_hierarchy.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 { array_quick_sort_by_lookup_map } from "../../../../core/collection/array/array_quick_sort_by_lookup_map.js";
 import { strictEquals } from "../../../../core/function/strictEquals.js";
-import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import {
     aabb3_unsigned_distance_sqr_to_point
 } from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.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 { 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";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
-import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.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";
 
-const temp_ray_results = [];
+/**
+ *
+ * @type {number[]|Uint32Array}
+ */
+const scratch_uint32_array = new Uint32Array(4096);
+
 const _ray_1 = [];
-const tmp_0 = [];
+const tmp_0 = new Float64Array(11);
 const null_output = [];
 
 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 {
 
 
@@ -37,6 +55,7 @@ export class PathTracedScene {
      */
     bvh_top_level = new BVH();
 
+
     /**
      *
      * @type {Map<number, PathTracedMesh>}
@@ -55,6 +74,13 @@ export class PathTracedScene {
      */
     geo_cache = new Map();
 
+    /**
+     *
+     * @type {Map<PathTracedMesh, number>}
+     */
+    #mesh_bvh_nodes = new Map();
+
+
     /**
      *
      * @type {Cache<THREE.Material, StandardMaterial>}
@@ -65,7 +91,6 @@ export class PathTracedScene {
             return mat.id
         }
     });
-
     /**
      *
      * @type {function}
@@ -73,17 +98,96 @@ export class PathTracedScene {
      */
     __background_sampler = make_vector3(0, 0, 0);
 
-    optimize() {
-        this.bvh_top_level.trim();
-        ebvh_sort_for_traversal_depth_first(this.bvh_top_level);
+    /**
+     *
+     * @returns {PathTracedMesh[]}
+     */
+    get #meshes() {
+        return Array.from(this.meshes.values());
     }
 
-    async build() {
+    #rebuild_bvh() {
+        const meshes = this.#meshes;
+
+        const bounds = new AABB3();
+
+        const bvh = this.bvh_top_level;
+
+        if (bvh.root === NULL_NODE) {
+            return;
+        }
+
+        bvh.node_get_aabb(bvh.root, bounds);
+
+        bvh.release_all();
+
+        const mesh_count = meshes.length;
+        const morton_codes = new Map();
+
+        for (let i = 0; i < mesh_count; i++) {
+            const mesh = meshes[i];
+
+            const center = mesh.aabb.getCenter();
+
+            const code = v3_morton_encode_bounded(center.x, center.y, center.z, bounds);
 
-        for (const [id, mesh] of this.meshes) {
-            const material = mesh.material;
+            morton_codes.set(mesh, code);
+        }
+
+        //
+        array_quick_sort_by_lookup_map(meshes, morton_codes, 0, mesh_count - 1);
+
+        const node_leaf_count = mesh_count;
+        const node_bin_count = max2(0, node_leaf_count - 1);
+
+        const node_total_count = node_leaf_count + node_bin_count;
+
+        const nodes = new Uint32Array(node_total_count);
+
+        // skip allocation calls, allocate exactly as many nodes as we need
+        bvh.node_capacity = node_total_count;
+        bvh.__size = node_total_count;
+
+        for (let i = 0; i < node_total_count; i++) {
+            // store nodes in reverse order so that top-level nodes end up on top
+            nodes[i] = (node_total_count - 1) - i;
+        }
+
+        // assign leaves
+        for (let i = 0; i < node_leaf_count; i++) {
+            const node = nodes[i];
+
+            const mesh = meshes[i];
+
+            bvh.node_set_aabb(node, mesh.aabb);
+
+            bvh.node_set_child1(node, NULL_NODE); //mark node as a leaf
+            bvh.node_set_user_data(node, mesh.id);
+
+            bvh.node_set_height(node, 0);
 
         }
+
+        // record newly generated nodes as "unprocessed"
+        const unprocessed_nodes = new Uint32Array(node_leaf_count);
+        array_copy(nodes, 0, unprocessed_nodes, 0, node_leaf_count);
+
+        // assign root
+        bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, node_leaf_count, nodes, node_leaf_count);
+
+    }
+
+    optimize() {
+        this.meshes.forEach((mesh, mesh_id) => {
+            mesh.build_tight_bounds();
+        });
+
+        // re-build bvh from bottom up
+        this.#rebuild_bvh();
+    }
+
+    async build() {
+
     }
 
     /**
@@ -122,47 +226,39 @@ export class PathTracedScene {
 
     /**
      *
-     * @param {THREE.BufferGeometry} geo
-     * @param {THREE.Material} material
-     * @param {mat4|number[]} transform
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
      */
-    addMesh(geo, material, transform) {
-        //meshopt_optimizeVertexCache(geo.getIndex().array, geo.getIndex().array, geo.getIndex().array.length, geo.getAttribute('position').count);
-
-        const mesh = new PathTracedMesh();
-        mesh.geometry = geo;
+    hasMesh(mesh) {
+        return this.#mesh_bvh_nodes.has(mesh);
+    }
 
-        mesh.material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+    /**
+     *
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
+     */
+    addMesh(mesh) {
+        if (this.hasMesh(mesh)) {
+            // already exists
+            return false;
+        }
 
-        mesh.geo_bvh = this.obtainGeometryBVH(geo);
+        mesh.bvh = this.obtainGeometryBVH(mesh.geometry);
 
-        mesh.transform = transform;
+        mesh.update_bounds();
 
         const bvh = this.bvh_top_level;
 
         const bvh_node_id = bvh.allocate_node();
 
-        mesh.__bvh_node_id = bvh_node_id;
-
-        ensureGeometryBoundingBox(geo);
-
-        const aabb = [
-            geo.boundingBox.min.x,
-            geo.boundingBox.min.y,
-            geo.boundingBox.min.z,
-            geo.boundingBox.max.x,
-            geo.boundingBox.max.y,
-            geo.boundingBox.max.z,
-        ];
-
-        const aabb_t = [];
-
-        aabb3_matrix4_project(aabb_t, aabb, transform);
+        this.#mesh_bvh_nodes.set(mesh, bvh_node_id);
 
         bvh.node_set_aabb(
             bvh_node_id,
-            aabb_t
+            mesh.aabb
         );
+
         bvh.node_set_user_data(
             bvh_node_id,
             mesh.id
@@ -170,6 +266,49 @@ export class PathTracedScene {
         bvh.insert_leaf(bvh_node_id);
 
         this.meshes.set(mesh.id, mesh);
+
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {PathTracedMesh} mesh
+     * @returns {boolean}
+     */
+    removeMesh(mesh) {
+
+        if (!this.hasMesh(mesh)) {
+            return false;
+        }
+
+        const node_id = this.#mesh_bvh_nodes.get(mesh);
+
+        this.#mesh_bvh_nodes.delete(mesh);
+
+        this.bvh_top_level.remove_leaf(node_id);
+        this.bvh_top_level.release_node(node_id);
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {THREE.Material} material
+     * @param {mat4|number[]} transform
+     */
+    createMesh(geometry, material, transform) {
+        const standard_material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+
+        const mesh = new PathTracedMesh();
+        mesh.geometry = geometry;
+
+        mesh.material = standard_material;
+
+        mesh.transform = transform;
+
+        this.addMesh(mesh);
     }
 
     /**
@@ -205,35 +344,51 @@ export class PathTracedScene {
     /**
      *
      * @param {number[]} out
-     * @param {number[]} ray
+     * @param {number[]|Ray3} ray
      * @param {number} min_distance
      * @param {number} max_distance
-     * @return {number}
+     * @return {number} distance to contact, or -1 if no contact found
      */
     trace(out, ray, min_distance, max_distance) {
+
         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 hit_count = bvh_query_leaves_ray(
             bvh, bvh.root,
-            temp_ray_results, 0,
-            ray[0], ray[1], ray[2],
-            ray[3], ray[4], ray[5]
+            scratch_uint32_array, 0,
+            ray_origin_x, ray_origin_y, ray_origin_z,
+            ray_direction_x, ray_direction_y, ray_direction_z
         );
 
         let nearest_hit_distance = max_distance;
-        let nearest_mesh = null;
 
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        let best_node;
 
         for (let i = 0; i < hit_count; i++) {
-            const node = temp_ray_results[i];
 
-            bvh.node_get_aabb(node, tmp_0);
+            const node = scratch_uint32_array[i];
+
+            const node_address = node * ELEMENT_WORD_COUNT;
 
             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) {
+                float32[node_address], float32[node_address + 1], float32[node_address + 2],
+                float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
+
+                ray_origin_x, ray_origin_y, ray_origin_z
+            ) > nearest_hit_distance * nearest_hit_distance ) {
                 // bounds of the mesh are too far
                 continue;
             }
@@ -242,22 +397,19 @@ export class PathTracedScene {
 
             const mesh = this.meshes.get(node_user_data);
 
-            const distance_to_hit = mesh.hit(tmp_0, ray, min_distance, nearest_hit_distance);
+            const distance_to_hit = mesh.hit(out, ray, min_distance, 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
                 nearest_hit_distance = distance_to_hit;
-                nearest_mesh = mesh;
-
-                array_copy(tmp_0, 0, out, 0, 11);
+                best_node = node;
             }
         }
 
         if (nearest_hit_distance !== max_distance) {
 
-            // out[6] = nearest_mesh;
-
             return nearest_hit_distance;
+
         }
 
         return -1;

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

@@ -1,6 +1,6 @@
 import { vec3 } from "gl-matrix";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { getBiasedNormalSample } from "./getBiasedNormalSample.js";
+import { getBiasedNormalSample } from "./sampling/getBiasedNormalSample.js";
 
 /*
  Ray hit data layout:

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

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number[]} node_list
+ * @param {number} node_list_offset
+ * @param {number} node_list_size
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_offset
+ */
+export function build_bvh_nodes_distances_along_ray(result: number[], result_offset: number, bvh: BVH, node_list: number[], node_list_offset: number, node_list_size: number, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_offset: number): void;
+//# sourceMappingURL=build_bvh_nodes_distances_along_ray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build_bvh_nodes_distances_along_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/build_bvh_nodes_distances_along_ray.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,4DAXW,MAAM,EAAE,iBACR,MAAM,uBAEN,MAAM,EAAE,oBACR,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,gBACN,MAAM,QA4BhB"}

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

@@ -0,0 +1,46 @@
+import { ELEMENT_WORD_COUNT } from "../../../../core/bvh2/bvh3/BVH.js";
+import {
+    aabb3_compute_distance_above_plane_min
+} from "../../../../core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number[]} node_list
+ * @param {number} node_list_offset
+ * @param {number} node_list_size
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_offset
+ */
+export function build_bvh_nodes_distances_along_ray(
+    result, result_offset,
+    bvh,
+    node_list, node_list_offset, node_list_size,
+    plane_normal_x, plane_normal_y, plane_normal_z,
+    plane_offset
+) {
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+
+    for (let i = 0; i < node_list_size; i++) {
+
+        const node = node_list[i + node_list_offset];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        const distance = aabb3_compute_distance_above_plane_min(
+            plane_normal_x, plane_normal_y, plane_normal_z, plane_offset,
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5]
+        );
+
+        result[result_offset + i] = distance;
+    }
+}
+

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

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number[]} node_list
+ * @param {number} node_list_offset
+ * @param {number} node_list_size
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function build_bvh_nodes_distances_sqr_to_point(result: number[], result_offset: number, bvh: BVH, node_list: number[], node_list_offset: number, node_list_size: number, x: number, y: number, z: number): void;
+//# sourceMappingURL=build_bvh_nodes_distances_sqr_to_point.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build_bvh_nodes_distances_sqr_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/build_bvh_nodes_distances_sqr_to_point.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,+DAVW,MAAM,EAAE,iBACR,MAAM,uBAEN,MAAM,EAAE,oBACR,MAAM,kBACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA2BhB"}

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

@@ -0,0 +1,43 @@
+import { ELEMENT_WORD_COUNT } from "../../../../core/bvh2/bvh3/BVH.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number[]} node_list
+ * @param {number} node_list_offset
+ * @param {number} node_list_size
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function build_bvh_nodes_distances_sqr_to_point(
+    result, result_offset,
+    bvh,
+    node_list, node_list_offset, node_list_size,
+    x, y, z
+) {
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+
+    for (let i = 0; i < node_list_size; i++) {
+
+        const node = node_list[i + node_list_offset];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        const distance = aabb3_unsigned_distance_sqr_to_point(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            x, y, z
+        );
+
+        result[result_offset + i] = distance;
+    }
+}

package/src/engine/graphics/sh3/path_tracer/geometry/compute_triangle_group_aabb3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_triangle_group_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/geometry/compute_triangle_group_aabb3.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qDARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,aAC1B,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,eACN,MAAM,mBACN,MAAM,QAkChB"}

package/src/engine/graphics/sh3/path_tracer/{compute_triangle_group_aabb3.js → geometry/compute_triangle_group_aabb3.js}

@@ -1,5 +1,5 @@
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../../core/math/max2.js";
+import { min2 } from "../../../../../core/math/min2.js";
 
 /**
  * Compute AABB for a group of triangles based on index-buffer

package/src/engine/graphics/sh3/path_tracer/geometry/construct_ray_hit_from_geometry.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number[]} indices
+ * @param {number[]} positions
+ * @param {number} face_index
+ * @param {number} t
+ * @param {number} u
+ * @param {number} v
+ */
+export function construct_ray_hit_from_geometry(output: number[], indices: number[], positions: number[], face_index: number, t: number, u: number, v: number): void;
+//# sourceMappingURL=construct_ray_hit_from_geometry.d.ts.map

package/src/engine/graphics/sh3/path_tracer/geometry/construct_ray_hit_from_geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct_ray_hit_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/geometry/construct_ray_hit_from_geometry.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wDARW,MAAM,EAAE,WACR,MAAM,EAAE,aACR,MAAM,EAAE,cACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA+DhB"}

package/src/engine/graphics/sh3/path_tracer/geometry/construct_ray_hit_from_geometry.js

@@ -0,0 +1,72 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number[]} indices
+ * @param {number[]} positions
+ * @param {number} face_index
+ * @param {number} t
+ * @param {number} u
+ * @param {number} v
+ */
+export function construct_ray_hit_from_geometry(
+    output,
+    indices, positions,
+    face_index,
+    t, u, v
+) {
+
+    const index_offset = face_index * 3;
+
+    const a = indices[index_offset];
+    const b = indices[index_offset + 1];
+    const c = indices[index_offset + 2];
+
+    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];
+
+    // normal
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    // compute position of intersection point
+    output[0] = ax + edge1_x * u + edge2_x * v;
+    output[1] = ay + edge1_y * u + edge2_y * v;
+    output[2] = az + edge1_z * u + edge2_z * v;
+
+    // Compute triangle normal
+
+    // normal = edge1 x edge2
+    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+    output[3] = normal_x;
+    output[4] = normal_y;
+    output[5] = normal_z;
+
+    output[6] = t;
+    output[7] = u;
+    output[8] = v;
+    output[9] = face_index;
+}

package/src/engine/graphics/sh3/path_tracer/geometry/sample_triangle_attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample_triangle_attribute.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/geometry/sample_triangle_attribute.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,+CAVW,MAAM,EAAE,cACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,mBACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,cACvC,MAAM,KACN,MAAM,KACN,MAAM,QAwBhB"}

package/src/engine/graphics/sh3/path_tracer/geometry/sort_triangles_by_distance_to_point.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @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
+ */
+export function sort_triangles_by_distance_to_point(triangles: number[], offset: number, count: number, morton_codes: any, bounds: any, point_x: number, point_y: number, point_z: number): void;
+//# sourceMappingURL=sort_triangles_by_distance_to_point.d.ts.map

package/src/engine/graphics/sh3/path_tracer/geometry/sort_triangles_by_distance_to_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort_triangles_by_distance_to_point.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/geometry/sort_triangles_by_distance_to_point.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,+DATW,MAAM,EAAE,UACR,MAAM,SACN,MAAM,2CACN,MAAM,WACN,MAAM,WACN,MAAM,QAoChB"}