@woosh/meep-engine 2.56.1 → 2.57.0

package/src/core/geom/Vector3.spec.js

@@ -1,5 +1,6 @@
 import Vector3 from "./Vector3.js";
-import { v3_slerp } from "./v3_slerp.js";
+import { v3_slerp } from "./vec3/v3_slerp.js";
+import { MATRIX_4_IDENTITY } from "./3d/matrix/MATRIX_4_IDENTITY.js";
 
 test('slerp', () => {
 
@@ -105,3 +106,69 @@ test("roughlyEquals", () => {
     expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.11), 0.1))
         .toBe(false);
 });
+
+
+test("asArray", () => {
+    const v = new Vector3(2, 5, 7);
+
+    expect(v.asArray()).toEqual([2, 5, 7])
+});
+
+test("fromScalar", () => {
+    expect(Vector3.fromScalar(7).asArray()).toEqual([7, 7, 7])
+});
+
+test("iterator symbol", () => {
+    const v = new Vector3(5, 7, 11);
+
+    const iterator = v[Symbol.iterator]();
+
+    expect(iterator.next()).toEqual({ value: 5, done: false })
+    expect(iterator.next()).toEqual({ value: 7, done: false })
+    expect(iterator.next()).toEqual({ value: 11, done: false })
+    expect(iterator.next()).toEqual({ done: true })
+
+});
+
+test("array-style getters", () => {
+
+    const v = new Vector3(5, 7, 11);
+
+    expect(v[0]).toEqual(5);
+    expect(v[1]).toEqual(7);
+    expect(v[2]).toEqual(11);
+});
+test("array-style setters", () => {
+
+    const v = new Vector3();
+
+    v[0] = 5;
+    v[1] = 7;
+    v[2] = 11;
+
+    expect(v.x).toEqual(5);
+    expect(v.y).toEqual(7);
+    expect(v.z).toEqual(11);
+});
+
+test("fromJSON as scalar", () => {
+
+    const v = new Vector3();
+
+    v.fromJSON(7);
+
+    expect(v.asArray()).toEqual([7, 7, 7])
+
+});
+
+test("applyMatrix with identity", () => {
+
+    const v = new Vector3(3, 7, 11);
+
+    v.applyMatrix4(MATRIX_4_IDENTITY);
+
+    expect(v.x).toEqual(3);
+    expect(v.y).toEqual(7);
+    expect(v.z).toEqual(11);
+
+});

package/src/core/geom/mat2/m2_add.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number[]} a
+ * @param {number[]} b
+ */
+export function m2_add(result, a, b) {
+    const v0 = a[0] + b[0];
+    const v1 = a[1] + b[1];
+    const v2 = a[2] + b[2];
+    const v3 = a[3] + b[3];
+
+    result[0] = v0;
+    result[1] = v1;
+    result[2] = v2;
+    result[3] = v3;
+}

package/src/core/geom/mat2/m2_determinant.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]} a 2d matrix
+ * @returns {number}
+ */
+export function m2_determinant(a) {
+    return a[0] * a[3] - a[1] * a[2]
+}

package/src/core/geom/mat2/m2_multiply.js

@@ -0,0 +1,17 @@
+/**
+ * Multiplication of 2x2 matrices
+ * @param {number[]} result
+ * @param {number[]} a
+ * @param {number[]} b
+ */
+export function m2_multiply(result, a, b) {
+    const v0 = a[0] * b[0] + a[1] * b[2];
+    const v1 = a[0] * b[1] + a[1] * b[3];
+    const v2 = a[2] * b[0] + a[3] * b[2];
+    const v3 = a[2] * b[1] + a[3] * b[3];
+
+    result[0] = v0;
+    result[1] = v1;
+    result[2] = v2;
+    result[3] = v3;
+}

package/src/core/geom/mat2/m2_multiply_scalar.js

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number[]} a
+ * @param {number} scalar
+ */
+export function m2_multiply_scalar(result, a, scalar) {
+
+    const v0 = a[0] * scalar;
+    const v1 = a[1] * scalar;
+    const v2 = a[2] * scalar;
+    const v3 = a[3] * scalar;
+
+    result[0] = v0;
+    result[1] = v1;
+    result[2] = v2;
+    result[3] = v3;
+}

package/src/core/geom/mat2/m2_multiply_transposed.js

@@ -0,0 +1,18 @@
+/**
+ * Transposed multiplication of 2x2 matrices
+ * Second argument will be transposed before multiplication
+ * @param {number[]} result
+ * @param {number[]} a
+ * @param {number[]} b
+ */
+export function m2_multiply_transposed(result, a, b) {
+    const v0 = a[0] * b[0] + a[1] * b[1];
+    const v1 = a[0] * b[2] + a[1] * b[3];
+    const v2 = a[2] * b[0] + a[3] * b[1];
+    const v3 = a[2] * b[2] + a[3] * b[3];
+
+    result[0] = v0;
+    result[1] = v1;
+    result[2] = v2;
+    result[3] = v3;
+}

package/src/core/geom/mat2/m2_sub_transposed.js

@@ -0,0 +1,17 @@
+/**
+ * Transposes second matrix before subtraction
+ * @param {number[]} result
+ * @param {number[]} a
+ * @param {number[]} b
+ */
+export function m2_sub_transposed(result, a, b) {
+    const v0 = a[0] - b[0];
+    const v1 = a[2] - b[1];
+    const v2 = a[1] - b[2];
+    const v3 = a[3] - b[3];
+
+    result[0] = v0;
+    result[1] = v1;
+    result[2] = v2;
+    result[3] = v3;
+}

package/src/{view → core/geom/mat3}/m3_cm_compose_transform.js

@@ -35,32 +35,3 @@ export function m3_cm_compose_transform(
     result[7] = 0;
     result[8] = 1;
 }
-
-/**
- *
- * @param {number[]|Float32Array} result
- * @param {number} tX
- * @param {number} tY
- */
-export function m3_cm_from_translation(result, tX, tY) {
-    result[0] = 1;
-    result[1] = 0;
-    result[2] = tX;
-
-    result[3] = 0;
-    result[4] = 1;
-    result[5] = tY;
-
-    result[6] = 0;
-    result[7] = 0;
-    result[8] = 1;
-}
-
-/**
- * @see https://stackoverflow.com/questions/45159314/decompose-2d-transformation-matrix
- * @param {mat3|number[]|Float32Array} m3
- * @returns {number}
- */
-export function m3_cm_extract_rotation(m3) {
-    return Math.atan2(m3[3], m3[0]);
-}

package/src/core/geom/mat3/m3_cm_extract_rotation.js

@@ -0,0 +1,8 @@
+/**
+ * @see https://stackoverflow.com/questions/45159314/decompose-2d-transformation-matrix
+ * @param {mat3|number[]|Float32Array} m3
+ * @returns {number}
+ */
+export function m3_cm_extract_rotation(m3) {
+    return Math.atan2(m3[3], m3[0]);
+}

package/src/core/geom/mat3/m3_cm_from_translation.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} tX
+ * @param {number} tY
+ */
+export function m3_cm_from_translation(result, tX, tY) {
+    result[0] = 1;
+    result[1] = 0;
+    result[2] = tX;
+
+    result[3] = 0;
+    result[4] = 1;
+    result[5] = tY;
+
+    result[6] = 0;
+    result[7] = 0;
+    result[8] = 1;
+}

package/src/{view/multiplyMatrices3.js → core/geom/mat3/m3_multiply.js}

@@ -1,11 +1,11 @@
 /**
  * Performs matrix multiplication of 3x3 matrices
  * r = a * b
+ * @param {number[]|Float32Array} r result matrix
  * @param {number[]|Float32Array} a first matrix
  * @param {number[]|Float32Array} b second matrix
- * @param {number[]|Float32Array} r result matrix
  */
-export function m3_multiply(a, b, r) {
+export function m3_multiply(r, a, b) {
     //read out values of input matrices to support the case where result is written back into one of the inputs
     const a0 = a[0];
     const a1 = a[1];

package/src/{view → core/geom/mat3}/m3_rm_compose_transform.js

@@ -34,12 +34,3 @@ export function m3_rm_compose_transform(
     result[5] = 0;
     result[8] = 1;
 }
-
-
-export function m3_rm_extract_scale(result, m3) {
-    const scale_x = Math.hypot(m3[0], m3[3]);
-    const scale_y = Math.hypot(m3[1], m3[4]);
-
-    result[0] = scale_x;
-    result[1] = scale_y;
-}

package/src/core/geom/mat3/m3_rm_extract_scale.js

@@ -0,0 +1,7 @@
+export function m3_rm_extract_scale(result, m3) {
+    const scale_x = Math.hypot(m3[0], m3[3]);
+    const scale_y = Math.hypot(m3[1], m3[4]);
+
+    result[0] = scale_x;
+    result[1] = scale_y;
+}

package/src/core/geom/{3d/vector/allocate_v3.js → vec3/v3_allocate.js}

@@ -23,7 +23,7 @@ const ELEMENT_BYTE_SIZE = 4 * 3;
  * custom Float32Array allocator, allocated memory in continuous chunks
  * @returns {Float32Array}
  */
-export function allocate_v3() {
+export function v3_allocate() {
     if (bucket_cursor >= ALLOCATOR_BUCKET_CAPACITY) {
         bucket = new ArrayBuffer(ALLOCATOR_BUCKET_CAPACITY * ELEMENT_BYTE_SIZE);
         bucket_cursor = 0;

package/src/core/geom/{v3_angle_between.js → vec3/v3_angle_between.js}

@@ -1,6 +1,6 @@
 import { v3_dot } from "./v3_dot.js";
 import { v3_length } from "./v3_length.js";
-import { clamp } from "../math/clamp.js";
+import { clamp } from "../../math/clamp.js";
 
 /**
  *

package/src/core/geom/vec3/v3_dot_array_array.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {number[]|Float32Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array} b
+ * @param {number} b_offset
+ * @returns {number}
+ */
+export function v3_dot_array_array(a, a_offset, b, b_offset) {
+
+    const a_x = a[a_offset];
+    const a_y = a[a_offset + 1];
+    const a_z = a[a_offset + 2];
+
+    const b_x = b[b_offset];
+    const b_y = b[b_offset + 1];
+    const b_z = b[b_offset + 2];
+
+    return a_x * b_x + a_y * b_y + a_z * b_z;
+}

package/src/core/geom/{v3_lerp.js → vec3/v3_lerp.js}

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

package/src/core/graph/SquareMatrix.js

@@ -1,5 +1,6 @@
 import { DataType2TypedArrayConstructorMapping } from "../binary/type/DataType2TypedArrayConstructorMapping.js";
 import { assert } from "../assert.js";
+import { array_copy } from "../collection/array/array_copy.js";
 
 export class SquareMatrix {
     /**
@@ -44,7 +45,7 @@ export class SquareMatrix {
         return this.data;
     }
 
-    fill(v){
+    fill(v) {
         this.data.fill(v);
     }
 
@@ -53,16 +54,20 @@ export class SquareMatrix {
      * @param {SquareMatrix} other
      */
     subtract(other) {
-        this.subtractMatrices(this,other);
+        this.subtractMatrices(this, other);
     }
 
     /**
-     *
+     * Component-size subtraction
      * @param {SquareMatrix} a
      * @param {SquareMatrix} b
      */
     subtractMatrices(a, b) {
         const size = this.size;
+
+        assert.equal(a.size, size, 'a is of wrong size');
+        assert.equal(b.size, size, 'b is of wrong size');
+
         const data_length = size * size;
 
         const a_data = a.data;
@@ -152,6 +157,17 @@ export class SquareMatrix {
         this.data.set(arr);
     }
 
+    /**
+     *
+     * @param {number[]} [destination]
+     * @param {number} [offset]
+     */
+    toArray(destination = new Array(this.length), offset=0) {
+        array_copy(this.data, 0, destination, offset, this.length);
+
+        return destination;
+    }
+
     /**
      *
      * @param {number} row_index
@@ -177,6 +193,13 @@ export class SquareMatrix {
      * @return {number}
      */
     getCellValue(row_index, column_index) {
+        assert.isNonNegativeInteger(row_index, 'row_index');
+        assert.isNonNegativeInteger(column_index, 'row_index');
+
+        assert.lessThan(row_index, this.size, 'row overflow');
+        assert.lessThan(column_index, this.size, 'column overflow');
+
+
         return this.data[this.size * column_index + row_index];
     }
 

package/src/core/graph/SquareMatrix.spec.js

@@ -33,7 +33,7 @@ test('transpose', () => {
 });
 
 
-test('copy', ()=>{
+test('copy', () => {
     const m = new SquareMatrix(2, BinaryDataType.Uint8);
 
     m.setCellValue(0, 0, 7);
@@ -41,7 +41,7 @@ test('copy', ()=>{
     m.setCellValue(0, 1, 13);
     m.setCellValue(1, 1, 19);
 
-    const b = new SquareMatrix(2,BinaryDataType.Uint8);
+    const b = new SquareMatrix(2, BinaryDataType.Uint8);
 
     b.copy(m);
 
@@ -50,3 +50,53 @@ test('copy', ()=>{
     expect(b.getCellValue(0, 1)).toBe(13);
     expect(b.getCellValue(1, 1)).toBe(19);
 });
+
+test("eye", () => {
+    const m = new SquareMatrix(2, BinaryDataType.Uint8);
+
+    m.eye();
+
+    expect(m.getCellValue(0, 0)).toBe(1);
+    expect(m.getCellValue(1, 0)).toBe(0);
+    expect(m.getCellValue(0, 1)).toBe(0);
+    expect(m.getCellValue(1, 1)).toBe(1);
+});
+
+test("negate", () => {
+    const m = new SquareMatrix(2, BinaryDataType.Int8);
+
+    m.fromArray([
+        -3, 5,
+        7, -11
+    ]);
+
+    m.negate();
+
+    expect(m.toArray()).toEqual([
+        3, -5,
+        -7, 11
+    ]);
+});
+
+test("subtract", () => {
+    const a = new SquareMatrix(2, BinaryDataType.Int8);
+    const b = new SquareMatrix(2, BinaryDataType.Int8);
+
+    a.fromArray([
+        1, 3,
+        5, 7
+    ]);
+
+    b.fromArray([
+        -11, 13,
+        17, 23
+    ]);
+
+
+    a.subtract(b);
+
+    expect(a.toArray()).toEqual([
+        12, -10,
+        -12, -16
+    ]);
+});

package/src/core/math/clamp01.js

@@ -1,6 +1,7 @@
 /**
  * Clamps a value to 0..1 range
  * Same as `clamp(value, 0, 1)`
+ * Works the same as `saturate` function in GLSL
  * @param {number} value
  * @returns {number}
  */

package/src/core/math/fract.js

@@ -6,5 +6,7 @@
  * @returns {number} returns the fractional part of x. This is calculated as x - floor(x).
  */
 export function fract(v) {
-    return v % 1;
+    const whole = v >> 0; // fast way to cut off fraction
+
+    return v - whole;
 }

package/src/core/math/inverseLerp.js

@@ -10,11 +10,13 @@ export function inverseLerp(a, b, value) {
     const scaledValue = value - a;
 
     if (range === 0) {
-        //avoid division by zero error
+
+        // avoid division by zero error
+
+        // this is arbitrary output, as actual answer is undefined
+
         return 0;
     }
 
-    const fraction = scaledValue / range;
-
-    return fraction;
-}
+    return scaledValue / range;
+}

package/src/core/math/lerp.js

@@ -1,10 +1,10 @@
 /**
  * Linear interpolation between two values controlled by a given fraction
- * @param {Number} a
- * @param {Number} b
- * @param {Number} fraction Floating point value between 0 and 1
- * @return {Number}
+ * @param {number} a
+ * @param {number} b
+ * @param {number} fraction Floating point value between 0 and 1
+ * @return {number}
  */
 export function lerp(a, b, fraction) {
     return (b - a) * fraction + a;
-}
+}

package/src/core/math/physics/spring/computeHookeForce.js

@@ -0,0 +1,9 @@
+/**
+ * Spring force calculation
+ * @param {number} displacement how far the spring is being stretched from its resting state
+ * @param {number} stiffness how still is the spring
+ * @return {number} force in the direction of displacement exerted by the spring trying to pull back
+ */
+export function computeHookeForce(displacement, stiffness) {
+    return -stiffness * displacement;
+}

package/src/core/math/remap.js

@@ -0,0 +1,19 @@
+import { inverseLerp } from "./inverseLerp.js";
+import { lerp } from "./lerp.js";
+
+/**
+ * Returns linear remapping of {@link value} from source range [source_first, source_second] to target range [target_first, target_second]
+ * This method is non-clamping, meaning that if your input is outside the source range - output will be outside the target range as well
+ * @param {number} source_first
+ * @param {number} source_second
+ * @param {number} target_first
+ * @param {number} target_second
+ * @param {number} value
+ * @return {number}
+ */
+export function remap(source_first, source_second, target_first, target_second, value) {
+
+    const relative = inverseLerp(source_first, source_second, value);
+
+    return lerp(target_first, target_second, relative);
+}

package/src/core/math/remap.spec.js

@@ -0,0 +1,15 @@
+import { remap } from "./remap.js";
+
+test("basics", () => {
+    expect(remap(0, 0, 0, 0, 0)).toEqual(0);
+
+    expect(remap(0, 1, 0, 1, 0)).toEqual(0);
+
+    expect(remap(0, 1, 1, 5, 0)).toEqual(1);
+
+    expect(remap(0, 1, 1, 5, 1)).toEqual(5);
+
+    expect(remap(0, 1, 1, 5, 0.5)).toEqual(3);
+
+    expect(remap(1, 5, 0, 1, 3)).toEqual(0.5);
+});

package/src/core/math/smoothStep.spec.js

@@ -0,0 +1,16 @@
+import { smoothStep } from "./smoothStep.js";
+
+test("basics", () => {
+    expect(smoothStep(0, 1, 1)).toEqual(1);
+    expect(smoothStep(1, 2, 2)).toEqual(1);
+
+    expect(smoothStep(0, 1, 0)).toEqual(0);
+    expect(smoothStep(1, 2, 1)).toEqual(0);
+
+    expect(smoothStep(0, 1, 0.5)).toBeCloseTo(0.5);
+});
+
+test("clamping",()=>{
+    expect(smoothStep(1, 2, 0)).toEqual(0);
+    expect(smoothStep(1, 2, 3)).toEqual(1);
+});

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

@@ -0,0 +1,13 @@
+/**
+ * 2-nd (quadratic) degree bezier curve
+ * @param {number} t
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} p2
+ * @return {number}
+ */
+export function spline_bezier2(t, p0, p1, p2) {
+    const inv_t = 1 - t;
+
+    return inv_t * inv_t * p0 + 2 * inv_t * t * p1 + t * t * p2;
+}

package/src/core/math/spline/spline_bezier2.spec.js

@@ -0,0 +1,13 @@
+import { spline_bezier2 } from "./spline_bezier2.js";
+
+test("spline_bezier2", () => {
+    expect(spline_bezier2(2, 0.1, 0.2, 3)).toBe(11.3);
+
+    expect(spline_bezier2(1, -1, -2, -3)).toBe(-3);
+
+    expect(spline_bezier2(-1, -1, 0, 0)).toBe(-4);
+
+    expect(spline_bezier2(-1, -1, 1, 0)).toBe(-8);
+
+    expect(spline_bezier2(-1, 0, 0, 0)).toBe(0);
+});

package/src/core/model/object/compareValues.js

@@ -1,8 +1,8 @@
 import { compareStrings } from "../../primitives/strings/compareStrings.js";
-import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
 import { compareBooleans } from "../../primitives/boolean/compareBooleans.js";
 import { extractFunctionBody } from "../../function/extractFunctionBody.js";
 import { compareArrays } from "../../primitives/array/compareArrays.js";
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 /**
  *
@@ -25,7 +25,7 @@ export function compareValues(a, b) {
     if (aType === "string") {
         return compareStrings(a, b);
     } else if (aType === "number") {
-        return compareNumbers(a, b);
+        return number_compare_ascending(a, b);
     } else if (aType === "boolean") {
         return compareBooleans(a, b);
     } else if (aType === "function") {

package/src/core/model/object/read_property.js

@@ -6,9 +6,14 @@ import { string_capitalize } from "../../primitives/strings/string_capitalize.js
  * @param {string[]} parts
  * @param {number} part_offset
  * @param {number} part_count
+ * @param {boolean} [throw_on_missing] will throw an exception if property is not found
  * @returns {undefined|T}
  */
-export function read_property(root, parts, part_offset, part_count) {
+export function read_property(
+    root,
+    parts, part_offset, part_count,
+    throw_on_missing = false
+) {
 
     let thing = root;
 
@@ -25,7 +30,10 @@ export function read_property(root, parts, part_offset, part_count) {
             if (typeof getter === "function") {
                 // resolve via getter
                 thing = getter.call(thing);
-            } else {
+            } else if(throw_on_missing){
+                // no getter
+                throw new Error(`No no property or getter found for '${part}' on [${i}]'${parts.slice(part_offset, part_offset + part_count).join('/')}'`);
+            }else{
                 // no getter
                 return undefined;
             }