@woosh/meep-engine 2.75.8 → 2.75.9

package/editor/actions/concrete/ModifyPatchSampler2DAction.js

@@ -1,5 +1,8 @@
 import { Action } from "../../../src/core/process/undo/Action.js";
 import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import {
+    sampler2d_sub_copy_same_item_size
+} from "../../../src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.js";
 
 export class ModifyPatchSampler2DAction extends Action {
     /**
@@ -95,12 +98,12 @@ export class ModifyPatchSampler2DAction extends Action {
         //store old data from the patch
         const patch_old = this.__patch_old;
 
-        patch_old.copy_sameItemSize(source, this.x, this.y, 0, 0, patch_old.width, patch_old.height);
+        sampler2d_sub_copy_same_item_size(patch_old,source, this.x, this.y, 0, 0, patch_old.width, patch_old.height);
 
         const patch_new = this.__patch_new;
 
         //apply the patch
-        source.copy_sameItemSize(patch_new, 0, 0, this.x, this.y, patch_new.width, patch_new.height);
+        sampler2d_sub_copy_same_item_size(source,patch_new, 0, 0, this.x, this.y, patch_new.width, patch_new.height);
     }
 
     async revert(context) {
@@ -113,6 +116,6 @@ export class ModifyPatchSampler2DAction extends Action {
         const patch_old = this.__patch_old;
 
         //apply the patch
-        source.copy_sameItemSize(patch_old, 0, 0, this.x, this.y, patch_old.width, patch_old.height);
+        sampler2d_sub_copy_same_item_size(source,patch_old, 0, 0, this.x, this.y, patch_old.width, patch_old.height);
     }
 }

package/editor/actions/concrete/PatchTerrainTextureAction.js

@@ -2,6 +2,9 @@ import { max2 } from "../../../src/core/math/max2.js";
 import { min2 } from "../../../src/core/math/min2.js";
 import { Action } from "../../../src/core/process/undo/Action.js";
 import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import {
+    sampler2d_sub_copy_same_item_size
+} from "../../../src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.js";
 
 export class PatchTerrainTextureAction extends Action {
 
@@ -115,13 +118,13 @@ export class PatchTerrainTextureAction extends Action {
         splat.readWeightData(this.__oldPatchWeight, this.x, this.y, this.width, this.height);
 
         const oldPatchMaterial = this.__oldPatchMaterial;
-        oldPatchMaterial.copy_sameItemSize(samplerMaterials, this.x, this.y, 0, 0, oldPatchMaterial.width, oldPatchMaterial.height);
+        sampler2d_sub_copy_same_item_size(oldPatchMaterial,samplerMaterials, this.x, this.y, 0, 0, oldPatchMaterial.width, oldPatchMaterial.height);
 
         //apply the patch
         splat.writeWeightData(this.patchWeight, this.x, this.y, this.width, this.height);
 
         const patchMaterial = this.patchMaterial;
-        samplerMaterials.copy_sameItemSize(patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
+        sampler2d_sub_copy_same_item_size(samplerMaterials,patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
 
         this.updateTerrain();
     }
@@ -142,7 +145,7 @@ export class PatchTerrainTextureAction extends Action {
         splat.writeWeightData(this.__oldPatchWeight, this.x, this.y, this.width, this.height);
 
         const patchMaterial = this.__oldPatchMaterial;
-        samplerMaterials.copy_sameItemSize(patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
+        sampler2d_sub_copy_same_item_size(samplerMaterials,patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
 
 
         this.updateTerrain();

package/editor/process/EditorProcess.js

@@ -1,30 +1,26 @@
-import { BaseProcess } from "../../src/core/process/BaseProcess.js";
 import { assert } from "../../src/core/assert.js";
+import { BaseProcess } from "../../src/core/process/BaseProcess.js";
 
 
 class EditorProcess extends BaseProcess {
 
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {string}
-         */
-        this.name = "unnamed";
-        /**
-         *
-         * @type {Editor|null}
-         */
-        this.editor = null;
-    }
+    /**
+     *
+     * @type {string}
+     */
+    name = "unnamed";
+    /**
+     *
+     * @type {Editor|null}
+     */
+    editor = null;
 
     /**
      *
      * @param {Editor} editor
      */
     initialize(editor) {
-        assert.defined(editor,'editor');
+        assert.defined(editor, 'editor');
 
         this.editor = editor;
 

package/editor/process/ProcessEngine.js

@@ -1,6 +1,6 @@
-import { EditorProcess } from "./EditorProcess.js";
 import List from "../../src/core/collection/list/List.js";
 import { ProcessState } from "../../src/core/process/ProcessState.js";
+import { EditorProcess } from "./EditorProcess.js";
 
 /**
  *
@@ -21,15 +21,14 @@ function tryInitialize(editor, process) {
 }
 
 class ProcessEngine extends EditorProcess {
-    constructor() {
-        super();
-        /**
-         * @type {List.<EditorProcess>}
-         */
-        this.processes = new List();
-
-        this.__suspendedList = new List();
-    }
+
+    /**
+     * @type {List.<EditorProcess>}
+     */
+    processes = new List();
+
+    __suspendedList = new List();
+
 
     startup() {
         super.startup();

package/package.json

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

package/src/core/binary/dec2hex.js

@@ -1,7 +1,7 @@
 /**
  * Convert a decimal value to hex
  * @param {number} c generally expects b byte value, 0-255
- * @returns {string}
+ * @returns {string} zero-padded value, for example instead of "0", will return "00" and instead of "F" will return "0F"
  */
 export function dec2hex(c) {
     const hex = Math.round(c).toString(16);

package/src/{engine/ecs/ik/IKMath.js → core/geom/vec3/v3_computeOffsetVector.js}

@@ -31,4 +31,4 @@ export function v3_computeOffsetVector(
     const z = sourceZ + directionZ * m;
 
     result.set(x, y, z);
-}
+}

package/src/core/math/newton_solver_1d.js

@@ -1,20 +1,29 @@
 /**
  * Newtonian solver, works by moving along the curve in the direction of gradient
- * @template T
- * @param {function(T):number} f
+ * @param {function(number):number} f Function for which we are trying to solve
  * @param {number} xStart
  * @param {number} [max_steps]
  * @param {number} [eps]
  * @returns {number}
  */
-export function newton_solver_1d(f, xStart, max_steps = 1000, eps = 0.00000001) {
+export function newton_solver_1d(
+    f,
+    xStart,
+    max_steps = 1000,
+    eps = 0.00000001
+) {
     let x = xStart, fx;
 
     let remaining_steps = max_steps;
 
     while ((remaining_steps--) && Math.abs(fx = f(x)) > eps) {
-        const dfdx = (f(x + eps) - fx) / eps;
+
+        const fx_eps = f(x + eps);
+
+        const dfdx = (fx_eps - fx) / eps;
+
         x = x - fx / dfdx;
+
     }
 
     return x;

package/src/core/math/solveQuadratic.js

@@ -1,3 +1,5 @@
+import { EPSILON } from "./EPSILON.js";
+
 /**
  * Return solutions for a quadratic equation
  * @param {number} a
@@ -9,9 +11,9 @@
  */
 export function solveQuadratic(result, result_offset, a, b, c) {
 
-    if (Math.abs(a) < 1e-6) {
-        if (Math.abs(b) < 1e-6) {
-            if (Math.abs(c) < 1e-6) {
+    if (Math.abs(a) < EPSILON) {
+        if (Math.abs(b) < EPSILON) {
+            if (Math.abs(c) < EPSILON) {
 
                 result[result_offset] = 0;
                 result[result_offset + 1] = 0;

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

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]} p0
+ * @param {number[]} p1
+ * @param {number} dimensions
+ * @param {number} half_alpha between 0..0.5
+ * @returns {number}
+ */
+export function catmull_rom_compute_T(p0, p1, dimensions, half_alpha) {
+    let a = 0;
+
+    for (let i = 0; i < dimensions; i++) {
+        const dx = p0[i] - p1[i];
+
+        a += dx * dx;
+    }
+
+    return Math.pow(a, half_alpha);
+}

package/src/{engine/navigation/ecs/components → core/math/spline}/computeCatmullRomSpline.js

@@ -1,6 +1,6 @@
-import { assert } from "../../../../core/assert.js";
-import { clamp } from "../../../../core/math/clamp.js";
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { assert } from "../../assert.js";
+import { array_copy } from "../../collection/array/array_copy.js";
+import { clamp } from "../clamp.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 
 /**

package/src/{engine/navigation/ecs/components → core/math/spline}/computeCatmullRomSplineUniformDistance.js

@@ -1,7 +1,7 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { assert } from "../../assert.js";
+import { array_copy } from "../../collection/array/array_copy.js";
+import { clamp } from "../clamp.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
-import { assert } from "../../../../core/assert.js";
 
 /**
  *

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

@@ -0,0 +1,109 @@
+import { catmull_rom_compute_T } from "./catmull_rom_compute_T.js";
+
+/**
+ * Based on wiki article: https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline#Code_example_in_Python
+ * @param {number[]} result
+ * @param {number[]} p0 spline point 0
+ * @param {number[]} p1 spline point 1
+ * @param {number[]} p2 spline point 2
+ * @param {number[]} p3 spline point 3
+ * @param {number} dimensions number of dimensions in the input and output vectors
+ * @param {number} f between 0..1
+ * @param {number} alpha between 0..1
+ */
+export function computeNonuniformCatmullRomSplineSample(result, p0, p1, p2, p3, dimensions, f, alpha) {
+    const half_alpha = alpha * 0.5;
+
+    // calculate T
+    const t0 = 0;
+    let t_01 = catmull_rom_compute_T(p0, p1, dimensions, half_alpha);
+    let t_02 = catmull_rom_compute_T(p1, p2, dimensions, half_alpha);
+    let t_03 = catmull_rom_compute_T(p2, p3, dimensions, half_alpha);
+
+    // safety check for repeated points, to prevent division by 0
+    if (t_01 < 1e-4) {
+        t_01 = 1;
+    }
+    if (t_02 < 1e-4) {
+        t_02 = t_01;
+    }
+    if (t_03 < 1e-4) {
+        t_03 = t_02;
+    }
+
+    const t1 = t_01 + t0;
+    const t2 = t_02 + t1;
+    const t3 = t_03 + t2;
+
+    /**
+     * Interpolation between points 1 and 2
+     * @type {number}
+     */
+    const t = t1 * (1 - f) + t2 * f;
+
+    /*
+            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
+		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
+		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
+
+		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
+		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
+
+		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
+     */
+
+    const d_t1_t0 = t1 - t0;
+
+    const m_A1_0 = (t1 - t) / d_t1_t0;
+    const m_A1_1 = (t - t0) / d_t1_t0;
+
+    const d_t2_t1 = t2 - t1;
+
+    const m_A2_0 = (t2 - t) / d_t2_t1;
+
+    const d_t_t1 = t - t1;
+
+    const m_A2_1 = d_t_t1 / d_t2_t1;
+
+    const d_t3_t2 = t3 - t2;
+
+    const d_t3_t = t3 - t;
+
+    const m_A3_0 = d_t3_t / d_t3_t2;
+    const m_A3_1 = (t - t2) / d_t3_t2;
+
+    const d_t2_t0 = t2 - t0;
+
+    const m_B1_0 = (t2 - t) / d_t2_t0;
+    const m_B1_1 = (t - t0) / d_t2_t0;
+
+    const d_t3_t1 = t3 - t1;
+
+    const m_B2_0 = d_t3_t / d_t3_t1;
+    const m_B2_1 = d_t_t1 / d_t3_t1;
+
+    const m_C_0 = (t2 - t) / d_t2_t1;
+    const m_C_1 = d_t_t1 / d_t2_t1;
+
+    for (let i = 0; i < dimensions; i++) {
+        // read vector values for the dimension
+        const v0 = p0[i];
+        const v1 = p1[i];
+        const v2 = p2[i];
+        const v3 = p3[i];
+
+        // compute resulting value in this dimension
+        const A1 = m_A1_0 * v0 + m_A1_1 * v1;
+        const A2 = m_A2_0 * v1 + m_A2_1 * v2;
+        const A3 = m_A3_0 * v2 + m_A3_1 * v3;
+
+        const B1 = m_B1_0 * A1 + m_B1_1 * A2;
+        const B2 = m_B2_0 * A2 + m_B2_1 * A3;
+
+        const C = m_C_0 * B1 + m_C_1 * B2;
+
+        result[i] = C;
+    }
+}
+
+

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

@@ -0,0 +1,12 @@
+/**
+ * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * @param {number} t ratio
+ * @param {number} a position -2
+ * @param {number} b position -1
+ * @param {number} c position +1
+ * @param {number} d position +2
+ * @returns {number}
+ */
+export function interpolate_bicubic(t, a, b, c, d) {
+    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
+}

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

@@ -0,0 +1,120 @@
+
+/**
+ *
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} half_alpha between 0..0.5
+ * @returns {number}
+ */
+function getT(p0, p1, half_alpha) {
+    const dx = p0 - p1;
+
+    const a = dx * dx;
+
+    return Math.pow(a, half_alpha);
+}
+
+
+/**
+ * Alpha assumed to be 0.5
+ * @param {number} f
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} p2
+ * @param {number} p3
+ * @returns {number}
+ */
+export function spline_catmullrom_1d(
+    f,
+    p0, p1, p2, p3
+) {
+    const half_alpha = 0.25;
+
+    // calculate T
+    const t0 = 0;
+    let t_01 = getT(p0, p1, half_alpha);
+    let t_02 = getT(p1, p2, half_alpha);
+    let t_03 = getT(p2, p3, half_alpha);
+
+    // safety check for repeated points, to prevent division by 0
+    if (t_01 < 1e-5) {
+        t_01 = 1;
+    }
+    if (t_02 < 1e-5) {
+        t_02 = t_01;
+    }
+    if (t_03 < 1e-5) {
+        t_03 = t_02;
+    }
+
+    const t1 = t_01 + t0;
+    const t2 = t_02 + t1;
+    const t3 = t_03 + t2;
+
+    /**
+     * Interpolation between points 1 and 2
+     * @type {number}
+     */
+    const t = t1 * (1 - f) + t2 * f;
+
+    /*
+            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
+		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
+		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
+
+		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
+		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
+
+		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
+     */
+
+    const d_t1_t0 = t1 - t0;
+
+    const m_A1_0 = (t1 - t) / d_t1_t0;
+    const m_A1_1 = (t - t0) / d_t1_t0;
+
+    const d_t2_t1 = t2 - t1;
+
+    const m_A2_0 = (t2 - t) / d_t2_t1;
+
+    const d_t_t1 = t - t1;
+
+    const m_A2_1 = d_t_t1 / d_t2_t1;
+
+    const d_t3_t2 = t3 - t2;
+
+    const d_t3_t = t3 - t;
+
+    const m_A3_0 = d_t3_t / d_t3_t2;
+    const m_A3_1 = (t - t2) / d_t3_t2;
+
+    const d_t2_t0 = t2 - t0;
+
+    const m_B1_0 = (t2 - t) / d_t2_t0;
+    const m_B1_1 = (t - t0) / d_t2_t0;
+
+    const d_t3_t1 = t3 - t1;
+
+    const m_B2_0 = d_t3_t / d_t3_t1;
+    const m_B2_1 = d_t_t1 / d_t3_t1;
+
+    const m_C_0 = (t2 - t) / d_t2_t1;
+    const m_C_1 = d_t_t1 / d_t2_t1;
+
+    // read vector values for the dimension
+    const v0 = p0;
+    const v1 = p1;
+    const v2 = p2;
+    const v3 = p3;
+
+    // compute resulting value in this dimension
+    const A1 = m_A1_0 * v0 + m_A1_1 * v1;
+    const A2 = m_A2_0 * v1 + m_A2_1 * v2;
+    const A3 = m_A3_0 * v2 + m_A3_1 * v3;
+
+    const B1 = m_B1_0 * A1 + m_B1_1 * A2;
+    const B2 = m_B2_0 * A2 + m_B2_1 * A3;
+
+    return m_C_0 * B1 + m_C_1 * B2;
+
+}

package/src/engine/control/ControlContext.js

@@ -1,36 +1,34 @@
-import Entity from "../ecs/Entity.js";
-import { ControlContextState } from "./ControlContextState.js";
 import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
 import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
+import Entity from "../ecs/Entity.js";
 import { EntityFlags } from "../ecs/EntityFlags.js";
+import { ControlContextState } from "./ControlContextState.js";
 
 export class ControlContext {
-    constructor() {
-        /**
-         * @private
-         * @type {EntityComponentDataset}
-         */
-        this.ecd = null;
+    /**
+     * @private
+     * @type {EntityComponentDataset}
+     */
+    ecd = null;
 
-        /**
-         * @private
-         * @type {Entity[]}
-         */
-        this.entities = [];
-
-        /**
-         * @private
-         * @type {ControlContextState|number}
-         */
-        this.state = ControlContextState.Initial;
-
-        /**
-         * Should entities be made transient or not, transient entities do not get persisted
-         * @private
-         * @type {boolean}
-         */
-        this.transientEntities = true;
-    }
+    /**
+     * @private
+     * @type {Entity[]}
+     */
+    entities = [];
+
+    /**
+     * @private
+     * @type {ControlContextState|number}
+     */
+    state = ControlContextState.Initial;
+
+    /**
+     * Should entities be made transient or not, transient entities do not get persisted
+     * @private
+     * @type {boolean}
+     */
+    transientEntities = true;
 
     /**
      *

package/src/engine/ecs/EntityManager.js

@@ -2,16 +2,16 @@
  * Created by Alex on 01/04/2014.
  */
 
-import {assert} from "../../core/assert.js";
-import {array_copy_unique} from "../../core/collection/array/array_copy_unique.js";
+import { assert } from "../../core/assert.js";
+import { array_copy_unique } from "../../core/collection/array/array_copy_unique.js";
 import Signal from "../../core/events/signal/Signal.js";
-import {IllegalStateException} from "../../core/fsm/exceptions/IllegalStateException.js";
-import {noop} from "../../core/function/Functions.js";
-import {ResourceAccessKind} from "../../core/model/ResourceAccessKind.js";
-import {EntityObserver} from "./EntityObserver.js";
-import {computeSystemName, System, SystemState} from "./System.js";
-import {computeSystemComponentDependencyGraph} from "./system/computeSystemComponentDependencyGraph.js";
-import {validateSystem} from "./validateSystem.js";
+import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
+import { noop } from "../../core/function/Functions.js";
+import { ResourceAccessKind } from "../../core/model/ResourceAccessKind.js";
+import { EntityObserver } from "./EntityObserver.js";
+import { computeSystemName, System, SystemState } from "./System.js";
+import { computeSystemComponentDependencyGraph } from "./system/computeSystemComponentDependencyGraph.js";
+import { validateSystem } from "./validateSystem.js";
 
 /**
  *
@@ -63,6 +63,9 @@ export class EntityManager {
     on = {
         systemStarted: new Signal(),
         systemStopped: new Signal(),
+        /**
+         * @type {Signal<System>}
+         */
         systemAdded: new Signal(),
         systemRemoved: new Signal(),
     };

package/src/engine/ecs/EntityObserver.js

@@ -6,10 +6,29 @@
  * @constructor
  * @class
  */
-import { BitSet } from "../../core/binary/BitSet.js";
 import { assert } from "../../core/assert.js";
+import { BitSet } from "../../core/binary/BitSet.js";
 
 export class EntityObserver {
+    /**
+     *
+     * @type {BitSet}
+     */
+    componentMask = new BitSet();
+
+    /**
+     * Mapping from component index to position in array of observed component types,
+     * this is used to build arguments for callbacks
+     * @type {number[]}
+     */
+    componentIndexMapping = [];
+
+    /**
+     *
+     * @type {EntityComponentDataset|null}
+     */
+    dataset = null;
+
     /**
      *
      * @param {Array} componentTypes
@@ -18,7 +37,12 @@ export class EntityObserver {
      * @param {*} [thisArg=undefined] will assume {@link this} value inside callbacks
      * @constructor
      */
-    constructor(componentTypes, completedCallback, brokenCallback, thisArg) {
+    constructor(
+        componentTypes,
+        completedCallback,
+        brokenCallback,
+        thisArg
+    ) {
         assert.isArray(componentTypes, 'componentTypes must be an array, instead was something else');
         assert.isFunction(completedCallback, 'completedCallback');
         assert.isFunction(brokenCallback, 'brokenCallback');
@@ -57,26 +81,6 @@ export class EntityObserver {
          * @type {*}
          */
         this.thisArg = thisArg;
-
-
-        /**
-         *
-         * @type {BitSet}
-         */
-        this.componentMask = new BitSet();
-
-        /**
-         * Mapping from component index to position in array of observed component types,
-         * this is used to build arguments for callbacks
-         * @type {number[]}
-         */
-        this.componentIndexMapping = [];
-
-        /**
-         *
-         * @type {EntityComponentDataset|null}
-         */
-        this.dataset = null;
     }
 
     /**