@woosh/meep-engine 2.39.27 → 2.39.28

package/core/bvh2/aabb3/AABB3.js

@@ -14,6 +14,7 @@ import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
 import { aabb3_intersects_frustum_array } from "./aabb3_intersects_frustum_array.js";
 import { aabb3_matrix4_project } from "../../geom/3d/aabb/aabb3_matrix4_project.js";
+import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
 
 
 export class AABB3 {
@@ -209,35 +210,15 @@ export class AABB3 {
      * @returns {number} Squared distance to point, value is negative if the point is inside the box
      */
     distanceToPoint2(x, y, z) {
-        const _x0 = this.x0;
-        const _y0 = this.y0;
-        const _z0 = this.z0;
-        const _x1 = this.x1;
-        const _y1 = this.y1;
-        const _z1 = this.z1;
-
-        //do projection
-        const xp0 = _x0 - x;
-        const xp1 = x - _x1;
-        const yp0 = _y0 - y;
-        const yp1 = y - _y1;
-        const zp0 = _z0 - z;
-        const zp1 = z - _z1;
-
-        //calculate separation in each axis
-        const dx = Math.max(xp0, xp1);
-        const dy = Math.max(yp0, yp1);
-        const dz = Math.max(zp0, zp1);
-
-        //straight-line distance
-        const distance2 = dx * dx + dy * dy + dz * dz;
-
-        if (dx < 0 && dy < 0 && dz < 0) {
-            //penetration
-            return -distance2;
-        } else {
-            return distance2;
-        }
+        return aabb3_signed_distance_sqr_to_point(
+            this.x0,
+            this.y0,
+            this.z0,
+            this.x1,
+            this.y1,
+            this.z1,
+            x, y, z
+        );
     }
 
     /**

package/core/bvh2/aabb3/aabb3_signed_distance_sqr_to_point.js

@@ -0,0 +1,39 @@
+import { max2 } from "../../math/max2.js";
+
+/**
+ * Compute squared distance to point, value is negative if the point is inside the box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} point_x
+ * @param {number} point_y
+ * @param {number} point_z
+ * @returns {number}
+ */
+export function aabb3_signed_distance_sqr_to_point(x0, y0, z0, x1, y1, z1, point_x, point_y, point_z) {
+    //do projection
+    const xp0 = x0 - point_x;
+    const xp1 = point_x - x1;
+    const yp0 = y0 - point_y;
+    const yp1 = point_y - y1;
+    const zp0 = z0 - point_z;
+    const zp1 = point_z - z1;
+
+    //calculate separation in each axis
+    const dx = max2(xp0, xp1);
+    const dy = max2(yp0, yp1);
+    const dz = max2(zp0, zp1);
+
+    //straight-line distance
+    const distance_sqr = dx * dx + dy * dy + dz * dz;
+
+    if (dx < 0 && dy < 0 && dz < 0) {
+        //penetration, negative distance
+        return -distance_sqr;
+    } else {
+        return distance_sqr;
+    }
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -49,6 +49,12 @@ const ELEMENT_WORD_COUNT = 10;
  */
 const INITIAL_CAPACITY = 128;
 
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_stack = [];
+
 /**
  * Bounding Volume Hierarchy implementation. Stores unsigned integer values at leaves, these are typically IDs or Index values.
  * Highly optimized both in terms of memory usage and CPU. Most of the code inlined. No allocation are performed during usage (except for growing the tree capacity).
@@ -874,6 +880,40 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return iA;
     }
 
+    /**
+     * Release all nodes, this essentially resets the tree to empty state
+     */
+    release_all() {
+        let cursor = 0;
+        const stack = scratch_stack;
+
+        const root = this.__root;
+
+        if (root !== NULL_NODE) {
+            stack[cursor++] = root;
+        }
+
+        const uint32 = this.__data_uint32;
+
+        while (cursor > 0) {
+            cursor--;
+
+            const node = stack[cursor];
+
+            const node_address = node * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
+
+            if (child1 !== NULL_NODE) {
+                stack[cursor++] = child2;
+                stack[cursor++] = child1;
+            }
+
+            this.release_node(node);
+        }
+    }
+
     /**
      *
      * @param {(node:number, tree:ExplicitBinaryBoundingVolumeHierarchy)=>void} callback

package/core/bvh2/bvh3/bvh_query_user_data_generic.js

@@ -46,7 +46,7 @@ export function bvh_query_user_data_generic(
          */
         const node = traversal_stack[traversal_cursor];
 
-        // test node against the ray
+        // test node against the query
         const pass = query.evaluate(node, bvh);
 
         if (!pass) {

package/core/bvh2/bvh3/bvh_query_user_data_nearest_to_point.js

@@ -0,0 +1,96 @@
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_signed_distance_sqr_to_point } from "../aabb3/aabb3_signed_distance_sqr_to_point.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const traversal_stack = [];
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_aabb = [];
+
+/**
+ *
+ * @type {number}
+ */
+let traversal_cursor = 0;
+
+/**
+ *
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} [max_distance=Infinity] how far to search
+ * @returns {number} user data of the leaf, or -1 if not found
+ */
+export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance = Infinity) {
+    const stack_frame_address = traversal_cursor;
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return -1;
+    }
+
+    traversal_stack[traversal_cursor++] = root;
+
+    let best_leaf_data = -1;
+    let best_distance = max_distance;
+
+    while (traversal_cursor > stack_frame_address) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        // compute distance to box
+        const distance = max2(0, aabb3_signed_distance_sqr_to_point(
+            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
+            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+            x, y, z
+        ));
+
+        if (distance > best_distance) {
+            // node is too far
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            traversal_stack[traversal_cursor++] = child1;
+            traversal_stack[traversal_cursor++] = child2;
+
+        } else {
+
+            // leaf node
+            if (distance < best_distance) {
+                best_distance = distance;
+                best_leaf_data = bvh.node_get_user_data(node);
+            }
+
+        }
+    }
+
+    // drop stack frame
+    traversal_cursor = stack_frame_address;
+
+    return best_leaf_data;
+}

package/editor/tools/paint/prototypeTerrainEditor.js

@@ -13,7 +13,6 @@ import { TerrainLayer } from "../../../engine/ecs/terrain/ecs/layers/TerrainLaye
 import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { BlenderCameraOrientationGizmo } from "../v2/BlenderCameraOrientationGizmo.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import TopDownCameraController from "../../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.39.27",
+  "version": "2.39.28",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",