@woosh/meep-engine 2.78.0 → 2.79.0

package/build/meep.cjs

@@ -1980,10 +1980,15 @@ function v3_length(x, y, z) {
  * @param {number} z1
  * @returns {number}
  */
-function v3_angle_between(x0, y0, z0, x1, y1, z1) {
+function v3_angle_between(
+    x0, y0, z0,
+    x1, y1, z1
+) {
+
     const theta = v3_angle_cos_between(x0, y0, z0, x1, y1, z1);
 
     return Math.acos(theta);
+
 }
 
 /**
@@ -1994,9 +1999,13 @@ function v3_angle_between(x0, y0, z0, x1, y1, z1) {
  * @param {number} x1
  * @param {number} y1
  * @param {number} z1
- * @returns {number}
+ * @returns {number} value between -1 and 1, cosine of the angle between vectors
  */
-function v3_angle_cos_between(x0, y0, z0, x1, y1, z1){
+function v3_angle_cos_between(
+    x0, y0, z0,
+    x1, y1, z1
+) {
+
     const d = v3_dot(x0, y0, z0, x1, y1, z1);
 
     const magnitude_0 = v3_length(x0, y0, z0);
@@ -2006,10 +2015,12 @@ function v3_angle_cos_between(x0, y0, z0, x1, y1, z1){
 
     if (l === 0) {
         // collective magnitude is 0, provide arbitrary angle
+        // avoid division by 0
         return 0;
     }
 
     return clamp$1(d / l, -1, 1);
+
 }
 
 /**
@@ -4708,7 +4719,7 @@ let Quaternion$1 = class Quaternion {
      * @param {Quaternion} result
      * @param {Quaternion} from
      * @param {Quaternion} to
-     * @param {number} max_delta
+     * @param {number} max_delta in radians
      */
     static rotateTowards(result, from, to, max_delta) {
 
@@ -70585,10 +70596,19 @@ class Edge {
         return this.first === node || this.second === node;
     }
 
+    /**
+     *
+     * @param {N} source
+     * @param {N} target
+     * @returns {boolean} True  iff the edge contains both source and target and allows transition from source to target
+     */
     validateTransition(source, target) {
         const a = this.first;
         const b = this.second;
-        return (a === source && b === target && this.traversableForward()) || (b === source && a === target && this.traversableBackward());
+
+        return (a === source && b === target && this.traversableForward())
+            || (b === source && a === target && this.traversableBackward())
+            ;
     }
 
     /**
@@ -70636,16 +70656,6 @@ class Edge {
             || (this.second === node && this.direction === EdgeDirectionType.Backward)
     }
 
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    angle() {
-
-        const delta = this.second.clone().sub(this.first);
-        return Math.atan2(delta.y, delta.x);
-    }
-
     /**
      *
      * @returns {N[]}
@@ -70654,15 +70664,6 @@ class Edge {
         return [this.first, this.second];
     }
 
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    get length() {
-
-        return this.first.distanceTo(this.second);
-    }
 }
 
 /**
@@ -70693,6 +70694,7 @@ class NodeContainer {
     /**
      *
      * @type {Map<N,number>}
+     * Maps neighbour node to number of edges to that node from this one
      * @private
      */
     __neighbors = new Map();
@@ -71086,6 +71088,7 @@ class Graph {
     /**
      *
      * @param {N} node
+     * @returns {boolean}
      */
     removeNode(node) {
 
@@ -71159,7 +71162,7 @@ class Graph {
     }
 
     /**
-     *
+     * Node degree is the number of attached edges
      * @param {N} node
      * @return {number}
      */
@@ -71201,13 +71204,18 @@ class Graph {
      *
      * @param {N} source
      * @param {N} target
-     * @param {EdgeDirectionType} [type] Undirected by default
+     * @param {EdgeDirectionType} [direction] Undirected by default
      * @returns {Edge<N>}
      */
-    createEdge(source, target, type = EdgeDirectionType.Undirected) {
+    createEdge(
+        source,
+        target,
+        direction = EdgeDirectionType.Undirected
+    ) {
+
         const edge = new Edge(source, target);
 
-        edge.direction = type;
+        edge.direction = direction;
 
         this.addEdge(edge);
 
@@ -71215,9 +71223,10 @@ class Graph {
     }
 
     /**
-     *
+     * Both nodes that the edge is attached to must be present
      * @param {Edge<N>} edge
-     * @returns {boolean}
+     * @returns {boolean} true if edge was added, false if edge was already present
+     * @throws if one or both nodes are not contained in the graph
      */
     addEdge(edge) {
         if (this.hasEdge(edge)) {
@@ -71419,10 +71428,10 @@ class Graph {
     }
 
     /**
-     *
+     * Find a path through the graph
      * @param {N} start
      * @param {N} goal
-     * @returns {null|N[]}
+     * @returns {null|N[]} null if no path exists
      */
     findPath(start, goal) {
         const start_node_container = this.__nodes.get(start);
@@ -71462,6 +71471,7 @@ class Graph {
                 const b = edge.second;
 
                 let other = null;
+
                 if (a === current_node && (edge.direction === EdgeDirectionType.Forward || edge.direction === EdgeDirectionType.Undirected)) {
                     other = b;
                 } else if (b === current_node && (edge.direction === EdgeDirectionType.Backward || edge.direction === EdgeDirectionType.Undirected)) {
@@ -71490,6 +71500,9 @@ class Graph {
         return null;
     }
 
+    /**
+     * Remove all data from the graph, resetting it to empty state
+     */
     clear() {
         this.__nodes.clear();
         this.__edges.clear();
@@ -72958,6 +72971,7 @@ class TransformAttachment {
 
     /**
      * transform relative to the attachment target
+     * Think of it as "local transform"
      * @type {Transform}
      */
     transform = new Transform();
@@ -73571,7 +73585,10 @@ class UpdateContext {
     }
 
     update() {
-        this.transform.multiplyTransforms(this.parent_transform, this.attachment.transform);
+        this.transform.multiplyTransforms(
+            this.parent_transform,
+            this.attachment.transform
+        );
     }
 
     /**
@@ -73594,51 +73611,51 @@ class UpdateContext {
     link() {
         const t_parent = this.parent_transform;
 
-        t_parent.position.onChanged.add(this.update, this);
-        t_parent.rotation.onChanged.add(this.update, this);
-        t_parent.scale.onChanged.add(this.update, this);
+        t_parent.subscribe(this.update, this);
 
         const t_attachment = this.attachment.transform;
-        t_attachment.position.onChanged.add(this.update,this);
-        t_attachment.rotation.onChanged.add(this.update,this);
-        t_attachment.scale.onChanged.add(this.update,this);
+
+        t_attachment.subscribe(this.update, this);
     }
 
     unlink() {
         const transform = this.parent_transform;
 
-        transform.position.onChanged.remove(this.update, this);
-        transform.rotation.onChanged.remove(this.update, this);
-        transform.scale.onChanged.remove(this.update, this);
+        transform.unsubscribe(this.update, this);
 
         const t_attachment = this.attachment.transform;
-        t_attachment.position.onChanged.remove(this.update,this);
-        t_attachment.rotation.onChanged.remove(this.update,this);
-        t_attachment.scale.onChanged.remove(this.update,this);
+
+        t_attachment.unsubscribe(this.update, this);
     }
 }
 
 class TransformAttachmentSystem extends System {
+
+    /**
+     *
+     * @type {UpdateContext[]}
+     * @private
+     */
+    __contexts = [];
+
+    /**
+     *
+     * @type {UpdateContext[]}
+     * @private
+     */
+    __queue = [];
+    __queue_size = 0;
+    __queue_cursor = 0;
+
     constructor() {
         super();
 
         this.dependencies = [TransformAttachment, Transform];
 
-        /**
-         *
-         * @type {UpdateContext[]}
-         * @private
-         */
-        this.__contexts = [];
-
-        /**
-         *
-         * @type {UpdateContext[]}
-         * @private
-         */
-        this.__queue = [];
-        this.__queue_size = 0;
-        this.__queue_cursor = 0;
+        this.components_used = [
+            ResourceAccessSpecification.from(TransformAttachment, ResourceAccessKind.Read),
+            ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ];
     }
 
     /**
@@ -73666,6 +73683,12 @@ class TransformAttachmentSystem extends System {
         this.__queue[this.__queue_size++] = ctx;
     }
 
+    /**
+     *
+     * @param {number} entity
+     * @returns {boolean}
+     * @private
+     */
     __dequeue_entity(entity) {
         for (let i = 0; i < this.__queue_size; i++) {
             const ctx = this.__queue[i];
@@ -73694,9 +73717,7 @@ class TransformAttachmentSystem extends System {
         ctx.entity = entity;
 
 
-        const ecd = this.entityManager.dataset;
-
-        ctx.ecd = ecd;
+        ctx.ecd = this.entityManager.dataset;
 
         if (ctx.bind_parent()) {
             this.__finalize_link(ctx);
@@ -73731,12 +73752,14 @@ class TransformAttachmentSystem extends System {
 
     update(timeDelta) {
         const step_count = min2(this.__queue_size, QUEUE_ITERATION_COUNT);
+
         for (let i = 0; i < step_count; i++) {
             const index = this.__queue_cursor % this.__queue_size;
 
             const ctx = this.__queue[index];
 
             if (ctx.bind_parent()) {
+                // parent obtained
                 this.__finalize_link(ctx);
 
                 this.__queue.splice(index, 1);
@@ -73746,6 +73769,7 @@ class TransformAttachmentSystem extends System {
                 this.__queue_cursor++;
             }
         }
+
     }
 }