@woosh/meep-engine 2.39.24 → 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";
 
@@ -69,7 +68,7 @@ async function main(engine) {
 
     editor_controls.enable();
 
-    const camera_orientation_gizmo = new BlenderCameraOrientationGizmo(new Quaternion());
+    const camera_orientation_gizmo = new BlenderCameraOrientationGizmo();
 
     camera_orientation_gizmo.css({
         position: 'absolute',

package/editor/tools/v2/BlenderCameraOrientationGizmo.d.ts

@@ -6,8 +6,41 @@ interface ISignals extends IViewSignals {
     readonly axisSelected: Signal<string>
 }
 
+interface IDirectionStyle {
+    near_fill?: string
+    near_stroke_width?: number
+    near_stroke_color?: string
+
+    far_fill?: string
+    far_stroke_width?: number
+    far_stroke_color?: string
+}
+
+interface IOptions {
+    size?: number,
+    padding?: number,
+    bubbleSizePrimary?: number,
+    bubbleSizeSecondary?: number,
+    lineWidth?: number,
+    fontSize?: string,
+    fontFamily?: string,
+    fontWeight?: string,
+    fontColor?: string,
+    fontYAdjust?: number,
+    selectionFontColor?: string,
+    axisStyles?: {
+        px?: IDirectionStyle,
+        py?: IDirectionStyle,
+        pz?: IDirectionStyle,
+
+        nx?: IDirectionStyle,
+        ny?: IDirectionStyle,
+        nz?: IDirectionStyle,
+    }
+}
+
 export class BlenderCameraOrientationGizmo extends View {
-    constructor(orientation?: Quaternion)
+    constructor(options?: IOptions)
 
     on: ISignals
 

package/editor/tools/v2/BlenderCameraOrientationGizmo.js

@@ -57,6 +57,30 @@ class DirectionStyle {
     }
 }
 
+function apply_hierarchical_options(source, target) {
+    for (const prop_name in source) {
+        if (!target.hasOwnProperty(prop_name)) {
+            console.warn(`Property '${prop_name}' doesn't exist, valid properties are : ${Object.keys(target)}`);
+            continue;
+        }
+
+        const existing_target_value = target[prop_name];
+        const source_value = source[prop_name];
+
+        if (typeof existing_target_value === "object") {
+            if (typeof existing_target_value.fromJSON === "function") {
+                existing_target_value.fromJSON(source_value);
+            } else {
+                apply_hierarchical_options(source_value, existing_target_value);
+            }
+        } else {
+            target[prop_name] = source_value;
+        }
+
+
+    }
+}
+
 
 /**
  * Modelled on https://github.com/jrj2211/three-orientation-gizmo/blob/master/src/OrientationGizmo.js
@@ -64,16 +88,15 @@ class DirectionStyle {
 export class BlenderCameraOrientationGizmo extends CanvasView {
     /**
      *
-     * @param {Quaternion} quaternion
      */
-    constructor(quaternion = null) {
+    constructor(options = {}) {
         super();
 
         /**
          *
          * @type {Quaternion}
          */
-        this.orientation = quaternion;
+        this.orientation = null;
 
         this.options = {
             size: 100,
@@ -129,6 +152,9 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
             }
         };
 
+        // read options
+        apply_hierarchical_options(options, this.options);
+
         // Generate list of axes
         this.bubbles = [
             {
@@ -312,7 +338,7 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
         compose_matrix4_array(rotation_matrix, Vector3.zero, rotation, Vector3.one);
         mat4.invert(rotation_matrix, rotation_matrix);
 
-        for (let bubble of this.bubbles) {
+        for (const bubble of this.bubbles) {
             const direction = bubble.direction.clone();
             direction.applyMatrix4(rotation_matrix);
 
@@ -321,10 +347,12 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
 
         // Generate a list of layers to draw
         const layers = [];
-        for (let axis in this.bubbles) {
+
+        for (const bubble of this.bubbles) {
             // Check if the name starts with a negative and dont add it to the layer list if secondary axis is turned off
-            if (this.options.showSecondary === true || axis[0] !== "-") {
-                layers.push(this.bubbles[axis]);
+            const is_secondary = bubble.axis[0] !== "-";
+            if (this.options.showSecondary === true || is_secondary) {
+                layers.push(bubble);
             }
         }
 

package/engine/graphics/GraphicsEngine.d.ts

@@ -1,4 +1,4 @@
-import {Camera, PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget} from "three";
+import {PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget} from "three";
 import {RenderLayerManager} from "./render/layers/RenderLayerManager";
 import Vector3 from "../../core/geom/Vector3";
 import Vector2 from "../../core/geom/Vector2";

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.24",
+  "version": "2.39.28",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",