@woosh/meep-engine 2.109.6 → 2.109.8

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -6,7 +6,7 @@ import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
 import { aabb3_compute_from_triangle } from "../../geom/3d/aabb3_compute_from_triangle.js";
 import { max2 } from "../../math/max2.js";
 import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
-import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
+import { COLUMN_CHILD_1, COLUMN_HEIGHT, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
 
 /**
@@ -75,6 +75,10 @@ export function ebvh_build_for_geometry_morton(
     // sort leaves by morton codes
     array_quick_sort_by_lookup_uint(sorted_triangle_order, morton_codes, 0, tri_count - 1);
 
+
+    const bvh_float32 = bvh.__data_float32;
+    const bvh_uint32 = bvh.__data_uint32;
+
     // assign leaves
     for (let i = 0; i < tri_count; i++) {
         const node = nodes[i];
@@ -87,17 +91,15 @@ export function ebvh_build_for_geometry_morton(
         const b_index = index_array[triangle_index3 + 1];
         const c_index = index_array[triangle_index3 + 2];
 
-        const aabb_address = ELEMENT_WORD_COUNT * node;
-
+        const node_address = ELEMENT_WORD_COUNT * node;
         aabb3_compute_from_triangle(
-            bvh.__data_float32, aabb_address,
+            bvh_float32, node_address,
             position_array, a_index, b_index, c_index
         );
 
-        bvh.node_set_child1(node, NULL_NODE); //mark node as a leaf
-        bvh.node_set_user_data(node, triangle_index);
-
-        bvh.node_set_height(node, 0);
+        bvh_uint32[node_address + COLUMN_CHILD_1] = NULL_NODE; //mark node as a leaf
+        bvh_uint32[node_address + COLUMN_USER_DATA] = triangle_index;
+        bvh_uint32[node_address + COLUMN_HEIGHT] = 0;
     }
 
     // record newly generated nodes as "unprocessed"
@@ -105,5 +107,5 @@ export function ebvh_build_for_geometry_morton(
     array_copy(nodes, 0, unprocessed_nodes, 0, tri_count);
 
     // assign root
-    bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count);
+    bvh.root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count);
 }

package/src/core/geom/3d/Ray3.js

@@ -23,7 +23,7 @@ export class Ray3 extends Float32Array {
     }
 
     get direction() {
-        return new Float32Array(this.buffer, this.byteOffset + 3, 3);
+        return new Float32Array(this.buffer, this.byteOffset + 3 * 4, 3);
     }
 
     get origin() {

package/src/core/geom/3d/aabb/AABB3.js

@@ -629,7 +629,7 @@ export class AABB3 {
 
     /**
      * Get center position of the box
-     * @param {Vector3} target where to write result
+     * @param {Vector3} [target] where to write result
      */
     getCenter(target = new Vector3()) {
         const x = this.getCenterX();

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts

@@ -1,10 +1,10 @@
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]|Vector3} output
+ * @param {number[]|Vector3|Float32Array} output
  * @param {number} output_offset
- * @param {number} x range [0,1]
- * @param {number} y range [0,1]
+ * @param {number} u range [-1,1]
+ * @param {number} v range [-1,1]
  */
-export function decode_octahedron_to_unit(output: number[] | Vector3, output_offset: number, x: number, y: number): void;
+export function decode_octahedron_to_unit(output: number[] | Vector3 | Float32Array, output_offset: number, u: number, v: number): void;
 //# sourceMappingURL=decode_octahedron_to_unit.d.ts.map

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,UAAQ,iBAChB,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB"}
+{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,aAAS,YAAY,iBAC7B,MAAM,KACN,MAAM,KACN,MAAM,QA0BhB"}

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js

@@ -3,23 +3,27 @@ import { sign_not_zero } from "../../../../math/sign_not_zero.js";
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]|Vector3} output
+ * @param {number[]|Vector3|Float32Array} output
  * @param {number} output_offset
- * @param {number} x range [0,1]
- * @param {number} y range [0,1]
+ * @param {number} u range [-1,1]
+ * @param {number} v range [-1,1]
  */
-export function decode_octahedron_to_unit(output, output_offset, x, y) {
-    let v_x = x;
-    let v_y = y;
+export function decode_octahedron_to_unit(
+    output, output_offset,
+    u, v
+) {
+    let v_x = u;
+    let v_z = v;
 
     const abs_x = Math.abs(v_x);
-    const abs_y = Math.abs(v_y);
+    const abs_z = Math.abs(v_z);
 
-    let v_z = 1 - abs_x - abs_y;
+    let v_y = 1 - abs_x - abs_z;
 
-    if (v_z < 0) {
-        v_x = (1 - abs_y) * sign_not_zero(v_x);
-        v_y = (1 - abs_x) * sign_not_zero(v_y);
+    // Handle octahedron's fold
+    if (v_y < 0) {
+        v_x = (1 - abs_z) * sign_not_zero(v_x);
+        v_z = (1 - abs_x) * sign_not_zero(v_z);
     }
 
     // normalize

package/src/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode_unit_to_octahedron.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,kDANW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAoBhB"}
+{"version":3,"file":"encode_unit_to_octahedron.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,kDANW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA0BhB"}

package/src/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js

@@ -12,20 +12,26 @@ import { sign_not_zero } from "../../../../math/sign_not_zero.js";
  * @param {number} y range [-1,1]
  * @param {number} z range [-1,1]
  */
-export function encode_unit_to_octahedron(output, output_offset, x, y, z) {
+export function encode_unit_to_octahedron(
+    output, output_offset,
+    x, y, z
+) {
+
     // Project the sphere onto the octahedron, and then onto the xy plane
-    const l2 = 1 / (Math.abs(x) + Math.abs(y) + Math.abs(z));
+    const abs_sum = Math.abs(x) + Math.abs(y) + Math.abs(z);
+
+    const inverse_sum = 1 / abs_sum;
 
-    let p_x = x * l2;
-    let p_y = y * l2;
+    let p_x = x * inverse_sum;
+    let p_y = y * inverse_sum;
 
     // Reflect the folds of the lower hemisphere over the diagonals
-    if (z <= 0) {
+    if (z < 0) {
         const abs_x = Math.abs(p_x);
         const abs_y = Math.abs(p_y);
 
-        p_x = sign_not_zero(p_x) * (1 - abs_y);
-        p_y = sign_not_zero(p_y) * (1 - abs_x);
+        p_x = (1 - abs_y) * sign_not_zero(p_x);
+        p_y = (1 - abs_x) * sign_not_zero(p_y);
     }
 
     output[output_offset] = p_x;

package/src/core/geom/3d/normal/octahedron/encoding.spec.js

@@ -1,5 +1,5 @@
-import { encode_unit_to_octahedron } from "./encode_unit_to_octahedron.js";
 import { decode_octahedron_to_unit } from "./decode_octahedron_to_unit.js";
+import { encode_unit_to_octahedron } from "./encode_unit_to_octahedron.js";
 
 /**
  *
@@ -26,4 +26,29 @@ test("encoding/decoding consistency", () => {
 
     // center
     try_one(0.5, 0.5);
+
+    // sweep
+    try_one(0.1, 0);
+    try_one(0.1, 0.1);
+    try_one(0.1, 0.4);
+    try_one(0.1, 0.6);
+    try_one(0.1, 0.9);
+
+    try_one(0.4, 0);
+    try_one(0.4, 0.1);
+    try_one(0.4, 0.4);
+    try_one(0.4, 0.6);
+    try_one(0.4, 0.9);
+
+    try_one(0.6, 0);
+    try_one(0.6, 0.1);
+    try_one(0.6, 0.4);
+    try_one(0.6, 0.6);
+    try_one(0.6, 0.9);
+
+    try_one(0.9, 0);
+    try_one(0.9, 0.1);
+    try_one(0.9, 0.4);
+    try_one(0.9, 0.6);
+    try_one(0.9, 0.9);
 });

package/src/core/geom/3d/normal/octahedron/prototype.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prototype.d.ts.map

package/src/core/geom/3d/normal/octahedron/prototype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/prototype.js"],"names":[],"mappings":""}

package/src/core/geom/3d/normal/octahedron/prototype.js

@@ -0,0 +1,226 @@
+import {
+    AmbientLight,
+    Mesh,
+    MeshStandardMaterial,
+    OctahedronBufferGeometry,
+    PerspectiveCamera,
+    Scene,
+    TextureLoader,
+    Vector3,
+    WebGLRenderer
+} from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { makeSolidArrowGeometry } from "../../../../../../editor/process/symbolic/makeSolidArrowGeometry.js";
+import { AssetManager } from "../../../../../engine/asset/AssetManager.js";
+import { ImageRGBADataLoader } from "../../../../../engine/asset/loaders/image/ImageRGBADataLoader.js";
+import sampler2D2Canvas from "../../../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { MouseEvents } from "../../../../../engine/input/devices/events/MouseEvents.js";
+import { CSS_ABSOLUTE_POSITIONING } from "../../../../../view/CSS_ABSOLUTE_POSITIONING.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import EmptyView from "../../../../../view/elements/EmptyView.js";
+import { Color } from "../../../../color/Color.js";
+import { decode_octahedron_to_unit } from "./decode_octahedron_to_unit.js";
+
+const renderer = new WebGLRenderer();
+
+const scene = new Scene();
+
+const camera = new PerspectiveCamera();
+
+
+function onWindowResize() {
+
+
+    camera.aspect = window.innerWidth / window.innerHeight;
+    camera.updateProjectionMatrix();
+    renderer.setSize(window.innerWidth, window.innerHeight);
+
+}
+
+
+onWindowResize();
+
+
+window.addEventListener('resize', onWindowResize, false);
+
+const vContainer = new EmptyView({
+    css: {
+        ...CSS_ABSOLUTE_POSITIONING
+    }
+});
+
+const vCanvas = new CanvasView();
+vCanvas.size.set(512, 512);
+
+vContainer.addChild(vCanvas);
+
+const assetManager = new AssetManager();
+
+
+function placeMarker(u, v, color = "rgba(255,0,0,1)") {
+
+    const direciton_0 = new Vector3(0, 1, 0);
+
+    const encoded = [];
+    decode_octahedron_to_unit(encoded, 0, u, v);
+
+    direciton_0.fromArray(encoded);
+
+    const arrow_mesh_0 = new Mesh(
+        makeSolidArrowGeometry(),
+        new MeshStandardMaterial({
+            color: color
+        })
+    );
+
+    arrow_mesh_0.position.copy(direciton_0).multiplyScalar(1);
+
+    arrow_mesh_0.lookAt(
+        arrow_mesh_0.position.clone().add(direciton_0)
+    );
+
+    scene.add(arrow_mesh_0);
+}
+
+function canvasPlaceDot(u, v, color = "rgba(255,0,0,1)") {
+
+
+    const marker_0 = new EmptyView({
+        css: {
+            ...CSS_ABSOLUTE_POSITIONING,
+            borderRadius: "5px",
+            width: "5px",
+            height: "5px",
+            background: color,
+            boxShadow: "0 0 4px 2px black"
+        }
+    });
+
+    marker_0.position.set(u * vCanvas.size.x, v * vCanvas.size.y);
+
+    vContainer.addChild(marker_0);
+}
+
+async function init_debug() {
+
+    const ctx2d = vCanvas.context2d;
+
+    ctx2d.fillStyle = 'rgba(0,0,0,0.5)';
+    ctx2d.fillRect(0, 0, vCanvas.size.x, vCanvas.size.y);
+
+    const asset = await assetManager.promise("data/textures/utility/uv_map_reference.png", 'image');
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    const sampler = asset.create();
+
+    sampler2D2Canvas(sampler, 1, 0, vCanvas.el);
+
+
+    const marker_0 = new EmptyView({
+        css: {
+            ...CSS_ABSOLUTE_POSITIONING,
+            borderRadius: "5px",
+            width: "5px",
+            height: "5px",
+            background: "rgba(255,0,0,1)",
+            boxShadow: "0 0 4px 2px black"
+        }
+    });
+
+    function make_grid(RESOLUTION = 16) {
+
+        const color = new Color();
+
+        const sample_color = [255, 255, 255];
+
+        const pixel_size = 1 / RESOLUTION;
+
+        for (let i = 0; i < RESOLUTION; i++) {
+
+            for (let j = 0; j < RESOLUTION; j++) {
+
+                const u = (i) / (RESOLUTION);
+                const v = (j) / (RESOLUTION);
+
+                sampler.sampleBicubicUV(u + pixel_size * 0.1, v + pixel_size * 0.1, sample_color);
+
+                color.setRGBUint8(sample_color[0], sample_color[1], sample_color[2]);
+
+                const color_string = color.toCssRGBAString();
+
+                const centered_u = u + pixel_size * 0.5;
+                const centered_v = v + pixel_size * 0.5;
+
+                canvasPlaceDot(centered_u, centered_v, color_string);
+                placeMarker(centered_u * 2 - 1, centered_v * 2 - 1, color_string);
+            }
+
+        }
+    }
+
+    make_grid(16);
+
+    vContainer.addChild(marker_0);
+
+    vCanvas.el.addEventListener(MouseEvents.Down,
+        /**
+         *
+         * @param {MouseEvent} mouseEvent
+         */
+        (mouseEvent) => {
+
+            const x = mouseEvent.clientX;
+            const y = mouseEvent.clientY;
+            marker_0.position.set(x, y);
+        });
+}
+
+function animate() {
+    requestAnimationFrame(animate);
+
+
+    renderer.render(scene, camera);
+}
+
+async function init() {
+    await assetManager.registerLoader('image', new ImageRGBADataLoader());
+
+    assetManager.startup();
+
+    document.body.appendChild(renderer.domElement);
+    document.body.appendChild(vContainer.el);
+    vContainer.link();
+
+    await init_debug();
+
+    // camera
+
+    camera.position.set(0, 0, -3);
+    camera.lookAt(0, 0, 0);
+
+    // meshes
+
+    const geometry = new OctahedronBufferGeometry(1, 3);
+
+    const texture = new TextureLoader().load("data/textures/utility/uv_map_reference.png");
+    texture.flipY = true;
+
+    const mesh = new Mesh(geometry, new MeshStandardMaterial({
+        map: texture
+    }));
+
+    scene.add(mesh);
+
+    // lights
+
+    scene.add(new AmbientLight(0x333333));
+
+    const controls = new OrbitControls(camera, document.body);
+
+    animate();
+}
+
+init();

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.d.ts

@@ -1,5 +1,5 @@
 /**
- *
+ * Rotate spherical harmonics
  * @param {number[]|Float32Array} result sh3
  * @param {number[]} sh input
  * @param {number[]} rotation 3x3 rotation matrix

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.js

@@ -1,7 +1,7 @@
 const scratch_mat_5x5 = new Float64Array(25);
 
 /**
- *
+ * Rotate spherical harmonics
  * @param {number[]|Float32Array} result sh3
  * @param {number[]} sh input
  * @param {number[]} rotation 3x3 rotation matrix
@@ -22,15 +22,15 @@ export function sh3_rotate_bl(result, sh, rotation) {
     const r22 = rotation[8];
 
 
-    // Constant
+    // band-0 : Constant
     result[0] = sh[0];
 
-    // Linear
+    // band-1: Linear
     result[1] = r11 * sh[1] - r12 * sh[2] + r10 * sh[3];
     result[2] = -r21 * sh[1] + r22 * sh[2] - r20 * sh[3];
     result[3] = r01 * sh[1] - r02 * sh[2] + r00 * sh[3];
 
-    // Quadratic
+    // band-2: Quadratic
     const t41 = r01 * r00;
     const t43 = r11 * r10;
     const t48 = r11 * r12;

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts

@@ -208,15 +208,15 @@ export class TetrahedralMesh {
      */
     removeTetrasConnectedToPoints(range_start: number, range_end: number): void;
     /**
-     *
+     * Note that this method does not guarantee to find the containing tet in case of concave mesh, that is - if there is a gap between the starting tet and the countaining tet
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @param {number[]} points Positions of vertices of tetrahedrons
-     * @param {number} [hint_tetrahedron]
+     * @param {number} [start_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(x: number, y: number, z: number, points: number[], hint_tetrahedron?: number): number;
+    walkToTetraContainingPoint(x: number, y: number, z: number, points: number[], start_tetrahedron?: number): number;
     /**
      * Relocate tetrahedron in memory, patches neighbourhood links as well
      * NOTE: The destination slot will be overwritten. This is a dangerous method that can break the topology, make sure you fully understand what you are doing when using it

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,4BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CAyDlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA1tB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CA8DlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA/tB4B,iCAAiC"}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -522,19 +522,19 @@ export class TetrahedralMesh {
     }
 
     /**
-     *
+     * Note that this method does not guarantee to find the containing tet in case of concave mesh, that is - if there is a gap between the starting tet and the countaining tet
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @param {number[]} points Positions of vertices of tetrahedrons
-     * @param {number} [hint_tetrahedron]
+     * @param {number} [start_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(x, y, z, points, hint_tetrahedron = 0) {
+    walkToTetraContainingPoint(x, y, z, points, start_tetrahedron = 0) {
 
         let entering_face = 4;
 
-        let cur_tet = hint_tetrahedron;
+        let cur_tet = start_tetrahedron;
 
         let i;
         while (true) {
@@ -570,7 +570,12 @@ export class TetrahedralMesh {
                     // point is outside the tet on the neighbour's side, move in that direction
                     const neighbour = this.getNeighbour(cur_tet, i);
 
-                    assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
+                    if(neighbour === INVALID_NEIGHBOUR){
+                        // walked outside the mesh, point is not contained within
+                        return -1;
+                    }
+
+                    // assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
 
                     cur_tet = neighbour >>> 2;
                     entering_face = neighbour & 3;

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.d.ts

@@ -1,3 +1,9 @@
-export function triangle_encode_rasterized_depth(barycentric_x: any, barycentric_y: any): number;
+/**
+ *
+ * @param {number} barycentric_x
+ * @param {number} barycentric_y
+ * @returns {number}
+ */
+export function triangle_encode_rasterized_depth(barycentric_x: number, barycentric_y: number): number;
 export function triangle_decode_depth(encodedDepth: any, input_offset: any, barycentric_x: any, barycentric_y: any): number;
 //# sourceMappingURL=triangle_encode_rasterized_depth.d.ts.map

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle_encode_rasterized_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.js"],"names":[],"mappings":"AAEA,iGA6CC;AAkBD,4HAwCC"}
+{"version":3,"file":"triangle_encode_rasterized_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,gEAJW,MAAM,iBACN,MAAM,GACJ,MAAM,CA+ClB;AAkBD,4HAwCC"}

package/src/core/geom/3d/tetrahedra/triangle/triangle_encode_rasterized_depth.js

@@ -1,5 +1,11 @@
 import { uint8_to_float } from "../../../../binary/uint8_to_float.js";
 
+/**
+ *
+ * @param {number} barycentric_x
+ * @param {number} barycentric_y
+ * @returns {number}
+ */
 export function triangle_encode_rasterized_depth(barycentric_x, barycentric_y) {
     const sampleY = (barycentric_y * 4.0) >>> 0;
     const sampleX = (barycentric_x * 4.0) >>> 0;

package/src/core/geom/vec3/v3_distance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_distance.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_distance.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,gCARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAKlB"}
+{"version":3,"file":"v3_distance.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_distance.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,gCARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAOlB"}

package/src/core/geom/vec3/v3_distance.js

@@ -1,5 +1,3 @@
-import { v3_distance_sqr } from "./v3_distance_sqr.js";
-
 /**
  *
  * @param {number} x0
@@ -10,7 +8,9 @@ import { v3_distance_sqr } from "./v3_distance_sqr.js";
  * @param {number} z1
  * @returns {number}
  */
-export function v3_distance(x0, y0, z0, x1, y1, z1) {
-
-    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
+export function v3_distance(
+    x0, y0, z0,
+    x1, y1, z1
+) {
+    return Math.hypot(x1 - x0, y1 - y0, z1 - z0);
 }

package/src/core/geometry/3d/tetrahedra/tetrahedral_mesh_find_tets_attached_to_vertex.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {TetrahedralMesh} mesh
+ * @param {number} vertex_index
+ * @returns {number}
+ */
+export function tetrahedral_mesh_find_tets_attached_to_vertex(result: number[], result_offset: number, mesh: TetrahedralMesh, vertex_index: number): number;
+//# sourceMappingURL=tetrahedral_mesh_find_tets_attached_to_vertex.d.ts.map

package/src/core/geometry/3d/tetrahedra/tetrahedral_mesh_find_tets_attached_to_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_find_tets_attached_to_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geometry/3d/tetrahedra/tetrahedral_mesh_find_tets_attached_to_vertex.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,sEANW,MAAM,EAAE,iBACR,MAAM,uCAEN,MAAM,GACJ,MAAM,CAyBlB"}

package/src/core/geometry/3d/tetrahedra/tetrahedral_mesh_find_tets_attached_to_vertex.js

@@ -0,0 +1,34 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {TetrahedralMesh} mesh
+ * @param {number} vertex_index
+ * @returns {number}
+ */
+export function tetrahedral_mesh_find_tets_attached_to_vertex(
+    result, result_offset,
+    mesh, vertex_index
+) {
+
+    assert.isNonNegativeInteger(vertex_index, "vertex_index");
+
+    let offset = result_offset;
+
+    mesh.forEach((tet) => {
+
+        for (let i = 0; i < 4; i++) {
+            const vert = mesh.getVertexIndex(tet, i);
+
+            if (vert === vertex_index) {
+                result[offset++] = tet;
+                break;
+            }
+        }
+
+    });
+
+    return offset - result_offset;
+}

package/src/core/model/node-graph/DataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.js"],"names":[],"mappings":"AAEA;IAgDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAYpB;IA3ED;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED,eAEC;IAED;;;aAMC;IAmCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}
+{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.js"],"names":[],"mappings":"AAEA;IAyDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED,eAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}