@woosh/meep-engine 2.118.4 → 2.118.6

package/src/core/graph/layout/box/BoxLayouter.js

@@ -8,8 +8,8 @@ import AABB2 from "../../../geom/2d/aabb/AABB2.js";
 import Vector2 from "../../../geom/Vector2.js";
 import { computeDisconnectedSubGraphs } from "../computeDisconnectedSubGraphs.js";
 import { Connection } from "../Connection.js";
-import { resolveAABB2Overlap } from "./resolveAABB2Overlap.js";
 import { applyCentralGravityAABB2 } from "./applyCentralGravityAABB2.js";
+import { resolveAABB2Overlap } from "./resolveAABB2Overlap.js";
 
 
 /**
@@ -40,9 +40,15 @@ function computeBoundingBox(boxes) {
     const footprint = new AABB2();
     footprint.setNegativelyInfiniteBounds();
 
-    boxes.forEach(function (b) {
+    const n = boxes.length;
+
+    for (let i = 0; i < n; i++){
+
+        const b = boxes[i];
+
         footprint.expandToFit(b);
-    });
+
+    }
 
     return footprint;
 }
@@ -424,8 +430,8 @@ function doLayerLayout(boxes) {
  */
 export function centerAABB2CollectionOn(boxes, center) {
     const bBox = computeBoundingBox(boxes);
-    const dX = bBox.midX() - center.x;
-    const dY = bBox.midY() - center.y;
+    const dX = bBox.centerX - center.x;
+    const dY = bBox.centerY - center.y;
     boxes.forEach(function (b) {
         b.move(-dX, -dY);
     });

package/src/core/graph/layout/box/aabb2_force_into_container.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {AABB2} container
+ * @param {AABB2} box
+ */
+export function aabb2_force_into_container(container: AABB2, box: AABB2): void;
+//# sourceMappingURL=aabb2_force_into_container.d.ts.map

package/src/core/graph/layout/box/aabb2_force_into_container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_force_into_container.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/aabb2_force_into_container.js"],"names":[],"mappings":"AA4CA;;;;GAIG;AACH,+EAMC"}

package/src/core/graph/layout/box/aabb2_force_into_container.js

@@ -0,0 +1,56 @@
+/**
+ *
+ * @param {number} subject_v0
+ * @param {number} subject_v1
+ * @param {number} bounds_v0
+ * @param {number} bounds_v1
+ * @returns {number} displacement for subject to fit into bounds
+ */
+function interval_force_into_bounds(
+    subject_v0, subject_v1,
+    bounds_v0, bounds_v1
+){
+
+    let displacement = 0;
+
+    const bounds_span = bounds_v1 - bounds_v0;
+
+    const subject_span = subject_v1 - subject_v0;
+
+    if(bounds_span >= subject_span) {
+        // fits
+
+        if (subject_v0 < bounds_v0) {
+            displacement = bounds_v0 - subject_v0;
+        } else if (subject_v1 > bounds_v1) {
+            displacement = bounds_v1 - subject_v1;
+        }
+
+    }else{
+        // too big to fit, pick the smallest displacement to occupy entire bounds
+
+        const a = subject_v0 - bounds_v0;
+        const b = bounds_v1 - subject_v1;
+
+        if(a > 0 && a < b){
+            displacement = -a;
+        }else if(b > 0){
+            displacement = b;
+        }
+    }
+
+    return displacement;
+}
+
+/**
+ *
+ * @param {AABB2} container
+ * @param {AABB2} box
+ */
+export function aabb2_force_into_container(container, box) {
+
+    const dX = interval_force_into_bounds(box.x0, box.x1, container.x0, container.x1);
+    const dY = interval_force_into_bounds(box.y0, box.y1, container.y0, container.y1);
+
+    box.move(dX, dY);
+}

package/src/core/graph/layout/box/applyCentralGravityAABB2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyCentralGravityAABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/applyCentralGravityAABB2.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,gDAHW,CAAC,QAAM;IAAC,MAAM,EAAC,OAAO,CAAA;CAAC,CAAC,EAAE,YAC1B,MAAM,QAsBhB"}
+{"version":3,"file":"applyCentralGravityAABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/applyCentralGravityAABB2.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,gDAHW,CAAC,QAAM;IAAC,MAAM,EAAC,OAAO,CAAA;CAAC,CAAC,EAAE,YAC1B,MAAM,QAgBhB"}

package/src/core/graph/layout/box/applyCentralGravityAABB2.js

@@ -1,5 +1,5 @@
 import { aabb2_compute_center_from_multiple } from "../../../geom/2d/aabb/aabb2_compute_center_from_multiple.js";
-import Vector2 from "../../../geom/Vector2.js";
+import { pullBoxTowardsPoint } from "./pullBoxTowardsPoint.js";
 
 /**
  *
@@ -11,7 +11,6 @@ export function applyCentralGravityAABB2(boxes, strength) {
 
     const center = aabb2_compute_center_from_multiple(boxes);
 
-    const delta = new Vector2();
     for (let i = 0; i < numBoxes; i++) {
         const box = boxes[i];
 
@@ -19,11 +18,6 @@ export function applyCentralGravityAABB2(boxes, strength) {
             continue;
         }
 
-        delta.copy(center);
-        delta._sub(box.midX(), box.midY());
-
-        delta.multiplyScalar(strength);
-
-        box.move(delta.x, delta.y);
+        pullBoxTowardsPoint(box, center.x, center.y, strength);
     }
 }

package/src/core/graph/layout/box/forceIntoBox.d.ts

@@ -1,7 +1,9 @@
 /**
  * Note: assumes that boxes to be contained are strictly smaller than the container in both dimensions
  * @param {AABB2} container
- * @param {Array.<AABB2>} boxes
+ * @param {Array.<AABB2|{locked?:boolean}>} boxes
  */
-export function forceIntoBox(container: AABB2, boxes: Array<AABB2>): void;
+export function forceIntoBox(container: AABB2, boxes: Array<AABB2 | {
+    locked?: boolean;
+}>): void;
 //# sourceMappingURL=forceIntoBox.d.ts.map

package/src/core/graph/layout/box/forceIntoBox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forceIntoBox.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/forceIntoBox.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,sDAFW,YAAa,QAuCvB"}
+{"version":3,"file":"forceIntoBox.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/forceIntoBox.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAFW,MAAO,QAAM;IAAC,MAAM,CAAC,EAAC,OAAO,CAAA;CAAC,CAAC,QAazC"}

package/src/core/graph/layout/box/forceIntoBox.js

@@ -1,9 +1,11 @@
+import { aabb2_force_into_container } from "./aabb2_force_into_container.js";
+
 /**
  * Note: assumes that boxes to be contained are strictly smaller than the container in both dimensions
  * @param {AABB2} container
- * @param {Array.<AABB2>} boxes
+ * @param {Array.<AABB2|{locked?:boolean}>} boxes
  */
-function forceIntoBox(container, boxes) {
+export function forceIntoBox(container, boxes) {
     for (let i = 0, l = boxes.length; i < l; i++) {
         const box = boxes[i];
 
@@ -11,35 +13,7 @@ function forceIntoBox(container, boxes) {
             continue;
         }
 
-        let dX = 0;
-        let dY = 0;
-
-        const bx0 = box.x0;
-        const bx1 = box.x1;
-
-        const by0 = box.y0;
-        const by1 = box.y1;
-
-        const cx0 = container.x0;
-        const cx1 = container.x1;
-
-        const cy0 = container.y0;
-        const cy1 = container.y1;
-
-        if (bx0 < cx0) {
-            dX = cx0 - bx0;
-        } else if (bx1 > cx1) {
-            dX = cx1 - bx1;
-        }
-
-        if (by0 < cy0) {
-            dY = cy0 - by0;
-        } else if (by1 > cy1) {
-            dY = cy1 - by1;
-        }
+        aabb2_force_into_container(container, box);
 
-        box.move(dX, dY);
     }
 }
-
-export { forceIntoBox };

package/src/core/graph/layout/box/position_box_next_to_box.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {AABB2} box
+ * @param {AABB2} target
+ * @param {AABB2} bounds
+ * @returns {AABB2} input {@link box} parameter
+ */
+export function position_box_next_to_box(box: AABB2, target: AABB2, bounds: AABB2): AABB2;
+import AABB2 from "../../../geom/2d/aabb/AABB2.js";
+//# sourceMappingURL=position_box_next_to_box.d.ts.map

package/src/core/graph/layout/box/position_box_next_to_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position_box_next_to_box.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/position_box_next_to_box.js"],"names":[],"mappings":"AAyJA;;;;;;GAMG;AACH,8CALW,KAAK,UACL,KAAK,UACL,KAAK,GACH,KAAK,CA2DjB;kBAzNiB,gCAAgC"}

package/src/core/graph/layout/box/position_box_next_to_box.js

@@ -0,0 +1,218 @@
+import AABB2 from "../../../geom/2d/aabb/AABB2.js";
+import Vector2 from "../../../geom/Vector2.js";
+import { EPSILON } from "../../../math/EPSILON.js";
+import { forceIntoBox } from "./forceIntoBox.js";
+import { pullBoxTowardsPoint } from "./pullBoxTowardsPoint.js";
+import { resolveAABB2Overlap } from "./resolveAABB2Overlap.js";
+
+/**
+ *
+ * @param {AABB2} box
+ * @param {AABB2} target
+ * @param {AABB2} bounds
+ * @returns {Vector2}
+ */
+function computeInitialPlacement(box, target, bounds) {
+    /**
+     * list of preferred directions, ordered. First direction is higher priority than the next, last is lowest priority
+     * @type {Vector2[]}
+     */
+    const preferredDirections = [
+        Vector2.up,
+        Vector2.right,
+        Vector2.down,
+        Vector2.left
+    ];
+
+    const targetCenter = target.getCenter();
+
+    const targetH = target.getHeight();
+    const targetW = target.getWidth();
+
+    const targetDiagonal = Math.sqrt(targetH * targetH + targetW * targetW);
+
+    const boxWidth = box.getWidth();
+    const boxHeight = box.getHeight();
+
+    const boxWidth_2 = boxWidth / 2;
+    const boxHeight_2 = boxHeight / 2;
+
+    const intersectionPoint = new Vector2();
+
+    const placements = preferredDirections.map(function (direction) {
+        //invert Y axis, screen-space direction is Down(+) and Up(-)
+        const viewportDirection = direction.clone()._multiply(1, -1);
+
+        const pointOutside = viewportDirection.clone();
+        //scale vector to be larger than the box diagonal so it would intersect the boundary when placed in the middle
+        pointOutside.multiplyScalar(targetDiagonal + 1);
+        //move vector to the middle od the box
+        pointOutside.add(targetCenter);
+
+        target.lineIntersectionPoint(targetCenter, pointOutside, intersectionPoint);
+
+        //align placement to the opposite edge of the box
+        const offset = new Vector2(boxWidth_2, boxHeight_2);
+
+        offset.multiply(viewportDirection);
+
+        offset._sub(boxWidth_2, boxHeight_2);
+
+        offset.add(intersectionPoint);
+
+        return offset;
+    });
+
+    /**
+     *
+     * @param {Vector2} placement
+     * @returns {number}
+     */
+    function computePlacementScore(placement) {
+        //find space for the tip between bounds and the target
+        const availableSpace = new AABB2();
+
+        const px0 = placement.x;
+        const px1 = px0 + boxWidth;
+        const py0 = placement.y;
+        const py1 = py0 + boxHeight;
+
+        if (px1 <= target.x0) {
+            //left
+            availableSpace.set(
+                bounds.x0,
+                bounds.y0,
+                target.x0,
+                bounds.y1
+            );
+        } else if (px0 >= target.x1) {
+            //right
+            availableSpace.set(
+                target.x1,
+                bounds.y0,
+                bounds.x1,
+                bounds.y1
+            );
+        } else if (py1 <= target.y0) {
+            //up
+            availableSpace.set(
+                bounds.x0,
+                bounds.y0,
+                bounds.x1,
+                target.y0
+            );
+        } else if (py0 >= target.y1) {
+            //bottom
+            availableSpace.set(
+                bounds.x0,
+                target.y1,
+                bounds.x1,
+                bounds.y1
+            );
+        } else {
+            //tip is inside, no arbitration
+        }
+
+        let score = 0;
+
+        const availableWidth = availableSpace.getWidth();
+        const availableHeight = availableSpace.getHeight();
+
+        const spareWidth = availableWidth - boxWidth;
+        const spareHeight = availableHeight - boxHeight;
+
+        if (spareHeight < 0) {
+            score--;
+        }
+
+        if (spareWidth < 0) {
+            score--;
+        }
+
+        return score;
+    }
+
+    //score placements
+    const scores = placements.map(computePlacementScore);
+
+    //find best placement
+    let bestIndex = 0;
+    let bestScore = scores[0];
+
+    for (let i = 1; i < scores.length; i++) {
+        const score = scores[i];
+
+        if (score > bestScore + EPSILON) {
+            bestScore = score;
+            bestIndex = i;
+        }
+    }
+
+    return placements[bestIndex];
+}
+
+/**
+ *
+ * @param {AABB2} box
+ * @param {AABB2} target
+ * @param {AABB2} bounds
+ * @returns {AABB2} input {@link box} parameter
+ */
+export function position_box_next_to_box(box, target, bounds) {
+    const b = box.clone();
+    const t = target.clone();
+
+    //center box inside the bounds
+    const y0 = (bounds.height + b.height) / 2;
+    const x0 = (bounds.width + b.width) / 2;
+
+    b.set(x0, y0, x0 + b.width, y0 + b.height);
+
+    const targetCenter = new Vector2(t.centerX, t.centerY);
+
+    t.locked = true;
+
+    function touch() {
+
+        const bC = new Vector2(b.centerX, b.centerY);
+
+        const bE = new Vector2();
+        const tE = new Vector2();
+
+
+        t.lineIntersectionPoint(bC, targetCenter, tE);
+        const delta = new Vector2();
+
+        if (b.lineIntersectionPoint(bC, targetCenter, bE)) {
+            delta.copy(tE).sub(bE);
+        } else {
+            delta.copy(tE).sub(bC);
+        }
+
+        b.move(delta.x, delta.y);
+    }
+
+
+    const initialPosition = computeInitialPlacement(b, t, bounds);
+    //set bounds to initial position
+    b.set(initialPosition.x, initialPosition.y, initialPosition.x + b.width, initialPosition.y + b.height);
+
+    // touch();
+
+    function step() {
+        //pull
+        pullBoxTowardsPoint(b, initialPosition.x + b.width / 2, initialPosition.y + b.height / 2, 0.1);
+
+        resolveAABB2Overlap([b, t], 10);
+
+        forceIntoBox(bounds, [b]);
+    }
+
+    for (let i = 0; i < 5; i++) {
+        step();
+    }
+
+    box.copy(b);
+
+    return box;
+}

package/src/core/graph/layout/box/pullBoxTowardsPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pullBoxTowardsPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/pullBoxTowardsPoint.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yDAJW,MAAM,WACN,MAAM,YACN,MAAM,QAchB"}
+{"version":3,"file":"pullBoxTowardsPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/pullBoxTowardsPoint.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yDAJW,MAAM,WACN,MAAM,YACN,MAAM,QAmBhB"}

package/src/core/graph/layout/box/pullBoxTowardsPoint.js

@@ -5,9 +5,14 @@
  * @param {number} targetY target point Y coordinate
  * @param {number} strength
  */
-export function pullBoxTowardsPoint(box, targetX, targetY, strength) {
-    const midX = box.midX();
-    const midY = box.midY();
+export function pullBoxTowardsPoint(
+    box,
+    targetX, targetY,
+    strength
+) {
+
+    const midX = box.centerX;
+    const midY = box.centerY;
 
     const deltaX = targetX - midX;
     const deltaY = targetY - midY;

package/src/core/graph/layout/box/resolveAABB2Overlap.d.ts

@@ -1,7 +1,7 @@
 /**
  *
  * @param {AABB2[]} boxes
- * @param {number} maxSteps
+ * @param {number} [maxSteps]
  */
-export function resolveAABB2Overlap(boxes: AABB2[], maxSteps: number): void;
+export function resolveAABB2Overlap(boxes: AABB2[], maxSteps?: number): void;
 //# sourceMappingURL=resolveAABB2Overlap.d.ts.map

package/src/core/graph/layout/box/resolveAABB2Overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveAABB2Overlap.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/resolveAABB2Overlap.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2CAHW,OAAO,YACP,MAAM,QAehB"}
+{"version":3,"file":"resolveAABB2Overlap.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/resolveAABB2Overlap.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2CAHW,OAAO,aACP,MAAM,QAuBhB"}

package/src/core/graph/layout/box/resolveAABB2Overlap.js

@@ -4,19 +4,27 @@ import { resolveBoxOverlapUsingForce } from "./resolveBoxOverlapUsingForce.js";
 /**
  *
  * @param {AABB2[]} boxes
- * @param {number} maxSteps
+ * @param {number} [maxSteps]
  */
-export function resolveAABB2Overlap(boxes, maxSteps) {
+export function resolveAABB2Overlap(boxes, maxSteps=3) {
     const forces = [];
 
     const n = boxes.length;
+
     for (let i = 0; i < n; i++) {
         forces.push(new Vector2(0, 0));
     }
 
     let overlapMoves = -1;
-    while (maxSteps > 0 && overlapMoves !== 0) {
-        maxSteps--;
+
+    let steps = maxSteps;
+
+    while (steps > 0 && overlapMoves !== 0) {
+
+        steps--;
+
         overlapMoves = resolveBoxOverlapUsingForce(forces, boxes);
+
     }
+
 }

package/src/core/graph/layout/box/resolveBoxOverlapUsingForce.d.ts

@@ -2,6 +2,7 @@
  *
  * @param {Vector2[]} forces
  * @param {Array.<AABB2>} boxes
+ * @returns {number}
  */
 export function resolveBoxOverlapUsingForce(forces: Vector2[], boxes: Array<AABB2>): number;
 import Vector2 from "../../../geom/Vector2.js";

package/src/core/graph/layout/box/resolveBoxOverlapUsingForce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveBoxOverlapUsingForce.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/resolveBoxOverlapUsingForce.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,oDAHW,OAAO,EAAE,SACT,YAAa,UA6FvB;oBAlGmB,0BAA0B"}
+{"version":3,"file":"resolveBoxOverlapUsingForce.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/layout/box/resolveBoxOverlapUsingForce.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oDAJW,OAAO,EAAE,SACT,YAAa,GACX,MAAM,CA6FlB;oBAnGmB,0BAA0B"}

package/src/core/graph/layout/box/resolveBoxOverlapUsingForce.js

@@ -4,6 +4,7 @@ import Vector2 from "../../../geom/Vector2.js";
  *
  * @param {Vector2[]} forces
  * @param {Array.<AABB2>} boxes
+ * @returns {number}
  */
 export function resolveBoxOverlapUsingForce(forces, boxes) {
     const numBoxes = boxes.length;

package/src/core/math/hash/squirrel3.d.ts

@@ -1,5 +1,6 @@
 /**
  * Based on Squirrel3 hash function by Squirrel Eiserloh
+ * Alex: Personally I found it to have low entropy, so I don't see it as very useful
  * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
  * @param {number} value expected to be an integer, if not - it will be truncated to such
  * @returns {number} signed 32-bit integer

package/src/core/math/hash/squirrel3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}
+{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}

package/src/core/math/hash/squirrel3.js

@@ -4,6 +4,7 @@ const BIT_NOISE3 = 0x1B56C4E9;
 
 /**
  * Based on Squirrel3 hash function by Squirrel Eiserloh
+ * Alex: Personally I found it to have low entropy, so I don't see it as very useful
  * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
  * @param {number} value expected to be an integer, if not - it will be truncated to such
  * @returns {number} signed 32-bit integer

package/src/core/math/matrix/SquareMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SquareMatrix.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/matrix/SquareMatrix.js"],"names":[],"mappings":"AAIA;IACI;;;;OAIG;IACH,kBAHW,MAAM,QACN,iBAAe,MAAM,EA2B/B;IAhBG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,qBAAgB;IAEhB;;OAEG;IACH,MAFU,MAAM,EAAE,CAEqB;IAG3C,gBAEC;IAED,qBAEC;IAED,oBAEC;IAED,mBAEC;IAED;;;OAGG;IACH,gBAFW,YAAY,QAItB;IAED;;;;OAIG;IACH,oBAHW,YAAY,KACZ,YAAY,QAiBtB;IAED;;OAEG;IACH,eAMC;IAED;;OAEG;IACH,cAEC;IAED;;OAEG;IACH,YAMC;IAED;;;OAGG;IACH,YAFW,YAAY,QAMtB;IAED;;;OAGG;IACH,SAFY,YAAY,CAQvB;IAED;;OAEG;IACH,kBAcC;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,QAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,WACR,MAAM,YAMhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,gBACN,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,gBACN,MAAM,GACL,MAAM,CAWjB;IAED;;;OAGG;IACH,qBAFW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAU5C;CACJ"}

package/src/core/{graph → math/matrix}/SquareMatrix.js

@@ -1,6 +1,6 @@
-import { assert } from "../assert.js";
-import { DataType2TypedArrayConstructorMapping } from "../binary/type/DataType2TypedArrayConstructorMapping.js";
-import { array_copy } from "../collection/array/array_copy.js";
+import { assert } from "../../assert.js";
+import { DataType2TypedArrayConstructorMapping } from "../../binary/type/DataType2TypedArrayConstructorMapping.js";
+import { array_copy } from "../../collection/array/array_copy.js";
 
 export class SquareMatrix {
     /**

package/src/core/math/random/seededRandom_MersenneTwister.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Random number generator based on Mersenne Twister sequence
+ * @param {number} seed
+ * @returns {function():number} RNG
+ */
+export function seededRandom_MersenneTwister(seed: number): () => number;
+//# sourceMappingURL=seededRandom_MersenneTwister.d.ts.map

package/src/core/math/random/seededRandom_MersenneTwister.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seededRandom_MersenneTwister.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/seededRandom_MersenneTwister.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,mDAHW,MAAM,SACO,MAAM,CAmF7B"}

package/src/core/math/random/{seededRandomMersenneTwister.js → seededRandom_MersenneTwister.js}

@@ -1,9 +1,11 @@
 /**
- * https://gist.github.com/banksean/300494
+ * Random number generator based on Mersenne Twister sequence
  * @param {number} seed
  * @returns {function():number} RNG
  */
-export function seededRandomMersenneTwister(seed) {
+export function seededRandom_MersenneTwister(seed) {
+    // see https://gist.github.com/banksean/300494
+
     /* Period parameters */
     const N = 624;
     const M = 397;

package/src/core/math/spline/cubicCurve.d.ts

@@ -1,11 +1,6 @@
 /**
- *
- * @param {Number} t
- * @param {Number} p0
- * @param {Number} p1
- * @param {Number} p2
- * @param {Number} p3
- * @return {Number}
+ * @deprecated use {@link spline_bezier3} directly
  */
-export function cubicCurve(t: number, p0: number, p1: number, p2: number, p3: number): number;
+export const cubicCurve: typeof spline_bezier3;
+import { spline_bezier3 } from "./spline_bezier3.js";
 //# sourceMappingURL=cubicCurve.d.ts.map

package/src/core/math/spline/cubicCurve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cubicCurve.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/cubicCurve.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,8FAwBC"}
+{"version":3,"file":"cubicCurve.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/cubicCurve.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,+CAAyC;+BALV,qBAAqB"}

package/src/core/math/spline/cubicCurve.js

@@ -1,34 +1,6 @@
+import { spline_bezier3 } from "./spline_bezier3.js";
+
 /**
- *
- * @param {Number} t
- * @param {Number} p0
- * @param {Number} p1
- * @param {Number} p2
- * @param {Number} p3
- * @return {Number}
+ * @deprecated use {@link spline_bezier3} directly
  */
-export function cubicCurve(t, p0, p1, p2, p3) {
-    /**
-     *
-     * @type {number}
-     */
-    const cX = 3 * (p1 - p0);
-
-    /**
-     *
-     * @type {number}
-     */
-    const bX = 3 * (p2 - p1) - cX;
-
-    /**
-     *
-     * @type {number}
-     */
-    const aX = p3 - p0 - cX - bX;
-
-    const t_2 = t * t;
-
-    const t_3 = t_2 * t;
-
-    return (aX * t_3) + (bX * t_2) + (cX * t) + p0;
-}
+export const cubicCurve = spline_bezier3;