@woosh/meep-engine 2.47.34 → 2.47.36

package/build/meep.module.js

@@ -47691,15 +47691,11 @@ function max2(a, b) {
 }
 
 /**
+ *
  * Produces a proportional mix of 2 values, a*(1-portion) + b*portion
- * @param {number} a
- * @param {number} b
- * @param {number} portion
- * @returns {number}
+ * Same as lerp
  */
-function mix(a, b, portion) {
-    return a * (1 - portion) + b * portion;
-}
+const mix = lerp$1;
 
 /**
  * Color blending modes
@@ -57876,16 +57872,21 @@ function hsv2rgb(h, s, v) {
     };
 }
 
+/**
+ * Converts string hex representation to a decimal integer
+ * @param {string} v
+ * @returns {number}
+ */
 function hex2dec(v) {
     return parseInt(v, 16)
-}
-
+}
+
 /**
  *
- * @param {string} hex
+ * @param {string} hex expect form #FFFFFF or #FFFFFFFF for RGBA
  * @returns {{r: number, g: number, b: number, a:number}} rgb
  */
-function parseHex(hex) {
+function hex2rgb(hex) {
 
 
     const result = {
@@ -57957,7 +57958,7 @@ function parseColor(c) {
 
         } else if (cL.startsWith('#')) {
 
-            const rgb = parseHex(cL);
+            const rgb = hex2rgb(cL);
 
             r = rgb.r;
             g = rgb.g;
@@ -58072,11 +58073,16 @@ function rgb2uint24(r, g, b) {
         ;
 }
 
+/**
+ * Convert a decimal value to hex
+ * @param {number} c generally expects b byte value, 0-255
+ * @returns {string}
+ */
 function dec2hex(c) {
     const hex = Math.round(c).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
-}
-
+}
+
 /**
  *
  * @param {number} r
@@ -58248,6 +58254,14 @@ class Color {
         this.set(r, g, b, this.a);
     }
 
+    /**
+     * set alpha
+     * @param {number} a
+     */
+    setA(a) {
+        this.set(this.r, this.g, this.b, a);
+    }
+
     /**
      *
      * @param {number} r
@@ -63944,17 +63958,17 @@ const TaskState = {
 class Task {
     /**
      *
-     * @param {string} name
-     * @param {function(Task, executor:ConcurrentExecutor)} [initializer]
+     * @param {string} [name] useful for identifying the task later on, for various UI and debug purposes
+     * @param {function(Task, executor:ConcurrentExecutor)} [initializer] function to be executed just before task starts
      * @param {function():TaskSignal} cycleFunction
      * @param {function():number} [computeProgress]
      * @param {Task[]} [dependencies=[]]
-     * @param {number} [estimatedDuration=1]
+     * @param {number} [estimatedDuration=1] in seconds
      * @constructor
      */
     constructor(
         {
-            name,
+            name = "Unnamed",
             initializer = noop,
             cycleFunction,
             computeProgress,
@@ -64108,6 +64122,8 @@ class Task {
     executeSync() {
         this.initialize();
 
+        this.on.started.send0();
+
         let s = this.cycle();
 
         for (; s !== TaskSignal.EndSuccess && s !== TaskSignal.EndFailure; s = this.cycle()) {
@@ -64115,9 +64131,9 @@ class Task {
         }
 
         if (s === TaskSignal.EndSuccess) {
-            this.on.completed.dispatch();
+            this.on.completed.send0();
         } else if (s === TaskSignal.EndFailure) {
-            this.on.failed.dispatch();
+            this.on.failed.send0();
         }
 
         return s;
@@ -100147,7 +100163,13 @@ class AbstractDecoratorBehavior extends Behavior {
 
         this.__source.finalize();
     }
-}
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AbstractDecoratorBehavior.prototype.isDecoratorBehavior = true;
 
 /**
  * @extends {Behavior}

package/editor/tools/FoliagePaintTool.js

@@ -5,7 +5,7 @@ import Vector4 from "../../src/core/geom/Vector4.js";
 import loadSampler2D from "../../src/engine/graphics/texture/sampler/loadSampler2D.js";
 import convertSampler2D2Canvas from "../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
 import { InstancedMeshComponent } from "../../src/engine/ecs/foliage/ecs/InstancedMeshComponent.js";
-import { parseHex } from "../../src/core/color/parseHex.js";
+import { hex2rgb } from "../../src/core/color/hex2rgb.js";
 import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
 
 class FoliagePaintTool extends Tool {
@@ -32,7 +32,7 @@ class FoliagePaintTool extends Tool {
     buildColor() {
 
         const color = new Vector4();
-        const baseColor = parseHex(this.settings.color.get());
+        const baseColor = hex2rgb(this.settings.color.get());
         color.set(baseColor.r, baseColor.g, baseColor.b, 0);
         color.multiplyScalar(1 / 255);
 
@@ -42,7 +42,7 @@ class FoliagePaintTool extends Tool {
     buildBaseColor() {
 
         const color = new Vector4();
-        const baseColor = parseHex(this.settings.baseColor.get());
+        const baseColor = hex2rgb(this.settings.baseColor.get());
         color.set(baseColor.r, baseColor.g, baseColor.b, 0);
         color.multiplyScalar(1 / 255);
 

package/editor/tools/GridPaintTool.js

@@ -10,7 +10,7 @@ import { decodeMouseEventButtons, PointerDevice } from "../../src/engine/input/d
 import Vector2 from "../../src/core/geom/Vector2.js";
 import TopDownCameraControllerSystem
     from "../../src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
-import { parseHex } from "../../src/core/color/parseHex.js";
+import { hex2rgb } from "../../src/core/color/hex2rgb.js";
 import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
 import { pick } from "../../src/ecs/grid/pick.js";
 
@@ -55,7 +55,7 @@ class GridPaintTool extends Tool {
     buildColor() {
 
         const color = new Vector4();
-        const baseColor = parseHex(this.settings.color.get());
+        const baseColor = hex2rgb(this.settings.color.get());
         color.set(baseColor.r, baseColor.g, baseColor.b, 0);
         color.multiplyScalar(1 / 255);
 

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.47.34",
+  "version": "2.47.36",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/dec2hex.js

@@ -0,0 +1,9 @@
+/**
+ * Convert a decimal value to hex
+ * @param {number} c generally expects b byte value, 0-255
+ * @returns {string}
+ */
+export function dec2hex(c) {
+    const hex = Math.round(c).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+}

package/src/core/binary/hex2dec.js

@@ -0,0 +1,8 @@
+/**
+ * Converts string hex representation to a decimal integer
+ * @param {string} v
+ * @returns {number}
+ */
+export function hex2dec(v) {
+    return parseInt(v, 16)
+}

package/src/core/color/Color.js

@@ -135,6 +135,14 @@ export class Color {
         this.set(r, g, b, this.a);
     }
 
+    /**
+     * set alpha
+     * @param {number} a
+     */
+    setA(a) {
+        this.set(this.r, this.g, this.b, a);
+    }
+
     /**
      *
      * @param {number} r

package/src/core/color/ColorUtils.js

@@ -3,7 +3,7 @@
  */
 
 import { hsv2rgb } from "./hsv2rgb.js";
-import { parseHex } from "./parseHex.js";
+import { hex2rgb } from "./hex2rgb.js";
 
 
 const rgbRegEx = /rgb\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\s*\)/;
@@ -55,7 +55,7 @@ export function parseColor(c) {
 
         } else if (cL.startsWith('#')) {
 
-            const rgb = parseHex(cL);
+            const rgb = hex2rgb(cL);
 
             r = rgb.r;
             g = rgb.g;

package/src/core/color/{parseHex.js → hex2rgb.js}

@@ -1,13 +1,11 @@
-function hex2dec(v) {
-    return parseInt(v, 16)
-}
+import { hex2dec } from "../binary/hex2dec.js";
 
 /**
  *
- * @param {string} hex
+ * @param {string} hex expect form #FFFFFF or #FFFFFFFF for RGBA
  * @returns {{r: number, g: number, b: number, a:number}} rgb
  */
-export function parseHex(hex) {
+export function hex2rgb(hex) {
 
 
     const result = {

package/src/core/color/rgb2hex.js

@@ -1,7 +1,4 @@
-export function dec2hex(c) {
-    const hex = Math.round(c).toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-}
+import { dec2hex } from "../binary/dec2hex.js";
 
 /**
  *

package/src/core/geom/3d/aabb/aabb3_intersects_aabb3.js

@@ -1,4 +1,4 @@
-import { intersects1D } from "../../../math/intersects1D.js";
+import { intersects1D } from "../../../math/interval/intersects1D.js";
 
 /**
  *

package/src/core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js

@@ -0,0 +1,65 @@
+import { aabb3_build_corners } from "./aabb3_build_corners.js";
+import { aabb3_matrix4_project_by_corners } from "./aabb3_matrix4_project_by_corners.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+
+const scratch_corners = new Float32Array(24);
+
+/**
+ *
+ * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_offset
+ * @param {number[]|Float32Array} transform_matrix
+ * @returns {number}
+ */
+export function aabb3_transformed_compute_plane_side(
+    x0, y0, z0, x1, y1, z1,
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset,
+    transform_matrix
+) {
+
+    aabb3_build_corners(
+        scratch_corners, 0,
+        x0, y0, z0, x1, y1, z1
+    );
+
+    aabb3_matrix4_project_by_corners(
+        scratch_corners,
+        scratch_corners,
+        transform_matrix
+    );
+
+    let has_above = false, has_below = false;
+
+    for (let i = 0; i < 8; i++) {
+        const i3 = i * 3;
+        const x = scratch_corners[i3];
+        const y = scratch_corners[i3 + 1];
+        const z = scratch_corners[i3 + 2];
+
+        if (v3_distance_above_plane(x, y, z, plane_normal_x, plane_normal_y, plane_normal_z, plane_offset)) {
+            has_above = true;
+        } else {
+            has_below = true;
+        }
+    }
+
+    let result = 0;
+
+    if (has_above) {
+        result += 2;
+    }
+    if (has_below) {
+        result -= 2;
+    }
+
+    return result;
+}

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -572,11 +572,17 @@ export class TopoMesh {
     /**
      *
      * @param {Float32Array} vertices
-     * @param {Uint16Array} faces
+     * @param {Uint32Array|Uint16Array|Uint8Array|number[]} faces
      */
     build(vertices, faces) {
 
-        const nVertices = vertices.length / 3;
+        const face_array_size = faces.length;
+        const vertex_array_size = vertices.length;
+
+        assert.equal(face_array_size % 3, 0, `Face array size must be multiple of 3, instead was ${face_array_size}`)
+        assert.equal(vertex_array_size % 3, 0, `Vertex array size must be multiple of 3, instead was ${vertex_array_size}`)
+
+        const nVertices = vertex_array_size / 3;
 
         //populate vertices
         const topoVertices = this.vertices;
@@ -596,7 +602,7 @@ export class TopoMesh {
             topoVertices[i] = v;
         }
 
-        const nFaces = faces.length / 3;
+        const nFaces = face_array_size / 3;
 
         // populate faces
         const topoFaces = this.getFaces();

package/src/core/geom/AABB2.js

@@ -10,7 +10,7 @@ import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import LineSegment2 from "./LineSegment2.js";
 import Vector2 from "./Vector2.js";
-import { overlap1D } from "../math/overlap1D.js";
+import { overlap1D } from "../math/interval/overlap1D.js";
 
 /**
  *

package/src/core/geom/Rectangle.js

@@ -4,8 +4,8 @@
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import Vector2 from "./Vector2.js";
-import { intersects1D } from "../math/intersects1D.js";
-import { overlap1D } from "../math/overlap1D.js";
+import { intersects1D } from "../math/interval/intersects1D.js";
+import { overlap1D } from "../math/interval/overlap1D.js";
 
 
 class Rectangle {

package/src/core/math/computeGreatestCommonDivisor.js

@@ -1,5 +1,6 @@
 import { assert } from "../assert.js";
 import { min2 } from "./min2.js";
+import { max2 } from "./max2.js";
 
 /**
  * Find the greatest common divisor (denominator/factor)
@@ -7,9 +8,9 @@ import { min2 } from "./min2.js";
  * @param {number} b
  * @returns {number}
  */
-export function computeGreatestCommonDivisor(a, b) {
-    assert.typeOf(a, 'number', 'a');
-    assert.typeOf(b, 'number', 'b');
+function computeGreatestCommonDivisor_Naive(a, b) {
+    assert.isNumber(a, 'a');
+    assert.isNumber(b,  'b');
 
     // start with the lowest of the two as a guess
     let result = min2(a, b);
@@ -26,3 +27,29 @@ export function computeGreatestCommonDivisor(a, b) {
 
     return result;
 }
+
+/**
+ * @see https://en.wikipedia.org/wiki/Euclidean_algorithm
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function computeGreatestCommonDivisor_Euclid(a, b) {
+    assert.isNumber(a, 'a');
+    assert.isNumber(b,  'b');
+
+    let _a = max2(a, b);
+    let _b = min2(a, b);
+
+    while (_b !== 0) {
+        const t = _b;
+        _b = _a % _b;
+
+        _a = t;
+    }
+
+    return _a;
+}
+
+
+export const computeGreatestCommonDivisor = computeGreatestCommonDivisor_Euclid;

package/src/core/math/{intersects1D.js → interval/intersects1D.js}

@@ -1,4 +1,4 @@
-import { assert } from "../assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * Returns true if two 1D lines intersect, touch is treated as intersection

package/src/core/math/{overlap1D.js → interval/overlap1D.js}

@@ -1,4 +1,4 @@
-import { assert } from "../assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * Returns true if two 1D lines overlap, touch is not considered overlap

package/src/core/math/mix.js

@@ -1,10 +1,8 @@
+import { lerp } from "./lerp.js";
+
 /**
+ *
  * Produces a proportional mix of 2 values, a*(1-portion) + b*portion
- * @param {number} a
- * @param {number} b
- * @param {number} portion
- * @returns {number}
+ * Same as lerp
  */
-export function mix(a, b, portion) {
-    return a * (1 - portion) + b * portion;
-}
+export const mix = lerp;

package/src/core/math/random/randomUint8.js

@@ -0,0 +1,10 @@
+import { randomIntegerBetween } from "./randomIntegerBetween.js";
+
+/**
+ *
+ * @param {function():number} random
+ * @returns {number}
+ */
+export function randomUint8(random){
+    return randomIntegerBetween(random,0,255);
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 3-rd (cubic) degree bezier curve
+ * @see https://www.youtube.com/watch?v=jvPPXbo87ds&t=234s
+ * @see https://en.wikipedia.org/wiki/B%C3%A9zier_curve
+ * @param {number} t factor value between 0..1
+ * @param {number} p0 start point
+ * @param {number} p1 control point
+ * @param {number} p2 control point
+ * @param {number} p3 end point
+ * @returns {number}
+ */
+function spline_bezier3(t, p0, p1, p2, p3) {
+    // first we compute necessary factors for each point
+    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;
+
+    // combine factors with point values to produce final result
+    return nt_3 * p0 + 3 * nt_2 * t * p1 + 3 * nt * t_2 * p2 + t_3 * p3;
+}

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

@@ -0,0 +1,87 @@
+import { min2 } from "../min2.js";
+import { max2 } from "../max2.js";
+import { assert } from "../../assert.js";
+
+/**
+ * Compute bounds of a 3-rd degree bezier curve
+ * Note that this is a 1d case solver
+ * Lower bound will be written into result[offset], upper bounds will be written into result[offset+result_stride]
+ * @see https://github.com/adobe-webplatform/Snap.svg/blob/c8e483c9694517e24b282f8f59f985629f4994ce/src/path.js#L856
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset offset into the result array
+ * @param {number} result_stride
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} p2
+ * @param {number} p3
+ */
+function spline_bezier3_bounds(result, result_offset, result_stride, p0, p1, p2, p3) {
+    assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
+    assert.isInteger(result_stride, 'result_stride');
+
+    const b = 6 * p0 - 12 * p1 + 6 * p2;
+    const a = -3 * p0 + 9 * p1 - 9 * p2 + 3 * p3;
+    const c = 3 * p1 - 3 * p0;
+
+    let min = min2(p0, p3);
+    let max = max2(p0, p3);
+
+    if (Math.abs(a) < 1e-12) {
+
+        if (Math.abs(b) >= 1e-12) {
+            const t = -c / b;
+
+            if (0 < t && t < 1) {
+                const value = spline_bezier3(t, p0, p1, p2, p3);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+
+            }
+
+        }
+
+    } else {
+
+        const b2ac = b * b - 4 * c * a;
+        const sqrtb2ac = Math.sqrt(b2ac);
+
+        if (b2ac >= 0) {
+
+            const t1 = (-b + sqrtb2ac) / (2 * a);
+
+            if (0 < t1 && t1 < 1) {
+                const value = spline_bezier3(t1, p0, p1, p2, p3);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+            }
+
+            const t2 = (-b - sqrtb2ac) / (2 * a);
+
+            if (0 < t2 && t2 < 1) {
+                const value = spline_bezier3(t2, p0, p1, p2, p3);
+
+                if (value < min) {
+                    min = value;
+                }
+                if (value > max) {
+                    max = value;
+                }
+            }
+
+        }
+
+    }
+
+    result[result_offset] = min;
+    result[result_offset + result_stride] = max;
+}

package/src/core/model/node-graph/node/NodeInstance.js

@@ -53,6 +53,7 @@ export class NodeInstance {
         /**
          * Extra ports that are present just on this instance, these exist in addition to ports from the description
          * IDs of these ports must not collide with IDs of ports on the description
+         * TODO implement functionality
          * @protected
          * @type {Port[]}
          */

package/src/core/process/task/Task.js

@@ -14,17 +14,17 @@ import TaskState from "./TaskState.js";
 class Task {
     /**
      *
-     * @param {string} name
-     * @param {function(Task, executor:ConcurrentExecutor)} [initializer]
+     * @param {string} [name] useful for identifying the task later on, for various UI and debug purposes
+     * @param {function(Task, executor:ConcurrentExecutor)} [initializer] function to be executed just before task starts
      * @param {function():TaskSignal} cycleFunction
      * @param {function():number} [computeProgress]
      * @param {Task[]} [dependencies=[]]
-     * @param {number} [estimatedDuration=1]
+     * @param {number} [estimatedDuration=1] in seconds
      * @constructor
      */
     constructor(
         {
-            name,
+            name = "Unnamed",
             initializer = noop,
             cycleFunction,
             computeProgress,
@@ -178,6 +178,8 @@ class Task {
     executeSync() {
         this.initialize();
 
+        this.on.started.send0();
+
         let s = this.cycle();
 
         for (; s !== TaskSignal.EndSuccess && s !== TaskSignal.EndFailure; s = this.cycle()) {
@@ -185,9 +187,9 @@ class Task {
         }
 
         if (s === TaskSignal.EndSuccess) {
-            this.on.completed.dispatch();
+            this.on.completed.send0();
         } else if (s === TaskSignal.EndFailure) {
-            this.on.failed.dispatch();
+            this.on.failed.send0();
         }
 
         return s;

package/src/engine/achievements/AchievementManager.js

@@ -23,7 +23,7 @@ import { globalMetrics } from "../metrics/GlobalMetrics.js";
 import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import { ClockChannelType } from "../intelligence/behavior/ecs/ClockChannelType.js";
 import { EnginePlugin } from "../plugin/EnginePlugin.js";
-import { makeCubicCurve } from "../../core/math/makeCubicCurve.js";
+import { makeCubicCurve } from "../../core/math/spline/makeCubicCurve.js";
 import { logger } from "../logging/GlobalLogger.js";
 import { assert } from "../../core/assert.js";