@woosh/meep-engine 2.47.34 → 2.47.36

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.js

@@ -23,6 +23,12 @@ import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { EBBVHLeafProxy } from "../../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
 import { aabb3_matrix4_project } from "../../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { aabb3_raycast } from "../../../../../core/geom/3d/aabb/aabb3_raycast.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+import {
+    aabb3_transformed_compute_plane_side
+} from "../../../../../core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
@@ -289,6 +295,72 @@ export class FPDecalSystem extends AbstractContextSystem {
         super.shutdown(em, ready_callback, error_callback);
     }
 
+    /**
+     *
+     * @param {number[]} result entity IDs
+     * @param {number} result_offset
+     * @param {number[]} planes
+     * @returns {number} number of results
+     */
+    queryOverlapFrustum(result, result_offset, planes) {
+        const ecd = this.entityManager.dataset;
+
+        if (ecd === null) {
+            return 0;
+        }
+
+        const entities = [];
+        const rough_count = bvh_query_user_data_overlaps_frustum(
+            entities, 0,
+            this.bvh,
+            planes
+        );
+
+        let result_cursor = result_offset;
+
+        loop_0: for (let i = 0; i < rough_count; i++) {
+
+            const entity = entities[i];
+
+            /**
+             *
+             * @type {Transform}
+             */
+            const transform = ecd.getComponent(entity, Transform);
+
+            if (transform === undefined) {
+                // this shouldn't happen either
+                continue;
+            }
+
+            for (let j = 0; j < 6; j++) {
+                // test true box against each plane
+                const plane_address = j * 4;
+
+                const plane_x = planes[plane_address]
+                const plane_y = planes[plane_address + 1]
+                const plane_z = planes[plane_address + 2]
+                const plane_offset = planes[plane_address + 3]
+
+                const side = aabb3_transformed_compute_plane_side(
+                    -0.5, -0.5, -0.5,
+                    0.5, 0.5, 0.5,
+                    plane_x, plane_y, plane_z, plane_offset,
+                    transform.matrix
+                );
+
+                if (side < 0) {
+                    // completely outside
+                    continue loop_0;
+                }
+            }
+
+            result[result_cursor++] = entity;
+        }
+
+        return result_cursor - result_offset;
+    }
+
     /**
      *
      * @param {number} origin_x
@@ -345,6 +417,10 @@ export class FPDecalSystem extends AbstractContextSystem {
                 continue;
             }
 
+            /**
+             *
+             * @type {Transform}
+             */
             const transform = ecd.getComponent(entity, Transform);
 
             if (transform === undefined) {

package/src/engine/intelligence/behavior/behavior_to_dot.js

@@ -176,7 +176,7 @@ function build_node_label(behavior) {
 /**
  *
  * @param {LineBuilder} out
- * @param {Behavior|CompositeBehavior} behavior
+ * @param {Behavior|CompositeBehavior|AbstractDecoratorBehavior} behavior
  * @param {{id_counter:number, node_ids:Map<Behavior,string>}} context
  * @returns {string}
  */
@@ -213,6 +213,16 @@ function parse_behavior(out, behavior, context) {
 
     }
 
+    if(behavior.isDecoratorBehavior === true){
+        // is a decorator
+
+        const source = behavior.getSource();
+
+        const id = parse_behavior(out, source,context);
+
+        out.add(`${node_id} -> ${id} [label="source"];`)
+    }
+
     return node_id;
 }
 

package/src/engine/intelligence/behavior/decorator/AbstractDecoratorBehavior.js

@@ -44,3 +44,9 @@ export class AbstractDecoratorBehavior extends Behavior {
         this.__source.finalize();
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AbstractDecoratorBehavior.prototype.isDecoratorBehavior = true;

package/src/engine/intelligence/behavior/util/behavior_traverse_tree.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * @param {Behavior} root
+ * @param {function(Behavior):boolean?} visitor
+ * @param {*} [thisArg]
+ */
+export function behavior_traverse_tree(root, visitor, thisArg) {
+
+    const should_continue = visitor.call(thisArg, root);
+
+    if (should_continue === false) {
+        // terminate traversal
+        return;
+    }
+
+    if (root.isCompositeBehavior === true) {
+
+        const children = root.getChildren();
+
+        const child_count = children.length;
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            behavior_traverse_tree(child, visitor, thisArg);
+        }
+    }
+
+    if (root.isCompositeBehavior === true) {
+
+        const source = root.getSource();
+        behavior_traverse_tree(source, visitor, thisArg);
+    }
+
+}

package/src/engine/scene/transitionToScene.js

@@ -31,7 +31,10 @@ export function transitionToScene({ tasks = [], scene, engine, name }) {
 
 
     //wait for visible terrain tiles to be loaded
-    const tWaitForVisibleTerrainTiles = wrapTaskIgnoreFailure(loadVisibleTerrainTiles(engine.entityManager, scene.dataset));
+    const tWaitForVisibleTerrainTiles = wrapTaskIgnoreFailure(loadVisibleTerrainTiles({
+        em: engine.entityManager,
+        ecd: scene.dataset
+    }));
     tWaitForVisibleTerrainTiles.name = "Waiting for visible terrain tiles";
 
     tWaitForVisibleTerrainTiles.addDependencies(tasks);

package/src/view/elements/radial/RadialText.js

@@ -1,7 +1,7 @@
 import View from "../../View.js";
 import SVG, { svgCircularPath } from "../../SVG.js";
 import { assert } from "../../../core/assert.js";
-import { isValueBetween } from "../../../core/math/isValueBetween.js";
+import { isValueBetween } from "../../../core/math/interval/isValueBetween.js";
 import { PI2 } from "../../../core/math/PI2.js";
 
 let idCount = 0;

package/src/core/math/bezierCurve.js

@@ -1,22 +0,0 @@
-/**
- * 3-rd degree bezier curve
- * @param {number} t
- * @param {number} p0 start point
- * @param {number} p1 control point
- * @param {number} p2 control point
- * @param {number} p3 end point
- * @returns {number}
- */
-function bezierCurve(t, p0, p1, p2, p3) {
-    const nt = 1 - t;
-
-    const nt_2 = nt * nt;
-
-    const nt_3 = nt_2 * nt;
-
-    const t_2 = t * t;
-
-    const t_3 = t_2 * t;
-
-    return nt_3 * p0 + 3 * nt_2 * t * p1 + 3 * nt * t_2 * p2 + t_3 * p3;
-}