@woosh/meep-engine 2.36.0 → 2.36.4

package/core/collection/queue/Deque.js

@@ -194,7 +194,7 @@ export class Deque {
 
     /**
      *
-     * @param {E} e
+     * @param {T} e
      * @returns {number}
      * @private
      */

package/core/color/Color.d.ts

@@ -7,7 +7,37 @@ export class Color {
     g: number
     b: number
 
-    onChanged: Signal
+    readonly onChanged: Signal<number, number, number, number, number, number>
 
-    setRGB(r: number, g: number, b: number)
+    parse(text: string): void
+
+    setRGB(r: number, g: number, b: number): void
+
+    setHSL(h: number, s: number, l: number): void
+
+    setHCL(h: number, c: number, l: number): void
+
+    setHSI(h: number, s: number, i: number): void
+
+    setHSV(h: number, s: number, v: number): void
+
+    getHSV(): { h: number, s: number, v: number }
+
+    toUint(): number
+
+    fromUint(v: number): void
+
+    equals(other: Color): boolean
+
+    hash(): number
+
+    copy(other: Color): void
+
+    clone(): Color
+
+    fromJSON(json: any): void
+
+    toJSON(): any
+
+    writeToArray(destination: ArrayLike<number>, destination_offset: number): void
 }

package/core/color/Color.js

@@ -10,7 +10,7 @@ import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 
-class Color {
+export class Color {
     /**
      *
      * @param {number} r value from 0 to 1
@@ -37,6 +37,10 @@ class Color {
          */
         this.b = b;
 
+        /**
+         * @readonly
+         * @type {Signal<number,number,number,number,number,number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -384,30 +388,39 @@ class Color {
         this.setRGB(r, g, b);
     }
 
+    /**
+     *
+     * @param {string} str CSS-style string
+     * @returns {void}
+     */
     parse(str) {
         const c = parseColor(str);
 
         this.setRGB(c[0] / 255, c[1] / 255, c[2] / 255);
     }
-}
 
-/**
- *
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {Color}
- */
-Color.fromRGB = function (r, g, b) {
-    return new Color(r, g, b);
-};
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @returns {Color}
+     */
+    static fromRGB(r, g, b) {
+        return new Color(r, g, b);
+    }
 
-Color.parse = function (str) {
-    const r = new Color();
 
-    r.parse(str);
+    /**
+     *
+     * @param {string} str
+     * @return {Color}
+     */
+    static parse(str) {
+        const r = new Color();
 
-    return r;
-};
+        r.parse(str);
 
-export { Color };
+        return r;
+    };
+}

package/core/geom/AABB2.d.ts

@@ -10,6 +10,8 @@ export default class AABB2 {
 
     set(x0: number, y0: number, x1: number, y1: number): void
 
+    copy(other: AABB2): void
+
     setBoundsUnordered(x0: number, y0: number, x1: number, y1: number): void
 
     getHeight(): number

package/core/geom/Vector3.js

@@ -1003,6 +1003,11 @@ Vector3.typeName = "Vector3";
 Vector3._dot = v3_dot;
 
 
+/**
+ *
+ * @param {{x:number, y:number, z:number}} v
+ * @return {number}
+ */
 function v3Length(v) {
     return v3_length(v.x, v.y, v.z);
 }
@@ -1016,7 +1021,6 @@ function v3Length(v) {
  * @param {number} fraction
  */
 function v3Lerp(result, a, b, fraction) {
-
     v3_lerp(result, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
 }
 

package/core/process/undo/ActionProcessor.js

@@ -213,6 +213,28 @@ export class ActionProcessor {
 
     }
 
+    /**
+     *
+     * @param {M} descriptor
+     * @returns {number[]}
+     * @private
+     */
+    __find_mark_indices_by_description(descriptor) {
+        const result = [];
+
+        const marks = this.marks;
+        const mark_count = marks.length;
+        for (let i = 0; i < mark_count; i++) {
+            const mark = marks[i];
+
+            if (mark.description === descriptor) {
+                result.push(i);
+            }
+        }
+
+        return result;
+    }
+
     /**
      * Navigate to a specific mark back or forward
      * @param {M} mark_descriptor specific mark description
@@ -221,7 +243,7 @@ export class ActionProcessor {
      */
     navigateTo(mark_descriptor) {
         // find all matching marks
-        const matching_marks = this.marks.filter(m => m.description === mark_descriptor);
+        const matching_marks = this.__find_mark_indices_by_description(mark_descriptor);
 
         if (matching_marks.length === 0) {
             // not found
@@ -232,9 +254,15 @@ export class ActionProcessor {
             throw new Error(`Attempting to navigate to a non-unique mark descriptor '${mark_descriptor}'. Mark descriptor must be unique, instead ${matching_marks.length} matches were found`);
         }
 
-        const match = matching_marks[0];
+        const match_index = matching_marks[0];
 
-        const target = match.index;
+        let target;
+        if (match_index + 1 >= this.marks.length) {
+            // mark is already at the end, go to the end of the history
+            target = this.history.length;
+        } else {
+            target = this.marks[match_index + 1].index;
+        }
 
         let temp_cursor = this.cursor;
 

package/core/process/undo/ActionProcessor.spec.js

@@ -29,7 +29,7 @@ test('navigateTo backwards', () => {
 
     expect(ap.navigateTo('a')).toBe(true);
 
-    expect(ctx.value).toBe(0);
+    expect(ctx.value).toBe(1);
 });
 
 test('navigateTo forward', () => {

package/engine/animation/curve/AnimationCurve.js

@@ -1,4 +1,5 @@
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { lerp } from "../../../core/math/lerp.js";
 
 /**
  *
@@ -32,12 +33,18 @@ function evaluate(t, keyframe0, keyframe1) {
 export class AnimationCurve {
     constructor() {
         /**
-         *
+         * @readonly
          * @type {Keyframe[]}
          */
         this.keys = [];
     }
 
+
+    /**
+     *
+     * @param {number} t
+     * @return {number}
+     */
     evaluate(t) {
         const keys = this.keys;
         const key_count = keys.length;
@@ -69,4 +76,36 @@ export class AnimationCurve {
         return keys[key_count - 1].value;
     }
 
+
+    /**
+     *
+     * @param {number} index
+     * @param {number} weight
+     */
+    smoothTangents(index, weight) {
+        const keys = this.keys;
+
+        const key_main = keys[index];
+
+        const has_previous = index > 0;
+        if (has_previous) {
+            const key_previous = keys[index - 1];
+
+            key_main.inTangent = key_main.value - key_previous.value;
+        }
+
+        const has_next = index < keys.length - 1;
+        if (has_next) {
+            const key_next = keys[index + 1];
+
+            key_main.outTangent = key_next.value - key_main.value;
+        }
+
+        if (has_previous && has_next) {
+            const average = lerp(key_main.inTangent, key_main.outTangent, 0.5);
+            key_main.inTangent = average;
+            key_main.outTangent = average;
+        }
+
+    }
 }

package/engine/animation/curve/Keyframe.js

@@ -24,4 +24,23 @@ export class Keyframe {
          */
         this.outTangent = 0;
     }
+
+    /**
+     *
+     * @param {number} time
+     * @param {number} value
+     * @param {number} inTangent
+     * @param {number} outTangent
+     * @return {Keyframe}
+     */
+    static from(time, value, inTangent = 0, outTangent = 0) {
+        const r = new Keyframe();
+
+        r.time = time;
+        r.value = value;
+        r.inTangent = inTangent;
+        r.outTangent = outTangent;
+
+        return r;
+    }
 }

package/engine/animation/curve/compression/animation_curve_to_float_array.js

@@ -0,0 +1,35 @@
+//
+
+
+/**
+ * Sample entire animation curve into a flat array with discrete equal intervals
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number} sample_count
+ * @param {AnimationCurve} curve
+ */
+export function animation_curve_to_float_array(out, curve, out_offset = 0, sample_count = out.length) {
+    const keyframes = curve.keys;
+    const keyframe_count = keyframes.length;
+
+    if (keyframe_count === 0) {
+        // not data
+        out.fill(0, out_offset, out_offset + sample_count);
+        return;
+    }
+
+    const key_first = keyframes[0];
+    const key_last = keyframes[keyframe_count - 1];
+
+    const time_start = key_first.time;
+    const time_end = key_last.time;
+    const time_span = time_end - time_start;
+
+    for (let i = 0; i < sample_count; i++) {
+        const f = i / (sample_count - 1);
+
+        const t = time_start + (f * time_span);
+
+        out[i + out_offset] = curve.evaluate(t);
+    }
+}

package/engine/animation/curve/compression/downsample_float_array.js

@@ -0,0 +1,50 @@
+//
+
+import { assert } from "../../../../core/assert.js";
+import { lerp } from "../../../../core/math/lerp.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number} input_size
+ */
+export function downsample_float_array(output, output_offset, input, input_offset, input_size) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(input_offset, 'input_offset');
+    assert.isNonNegativeInteger(input_size, 'input_size');
+
+    const target_samples = input_size / 2;
+
+    if (!Number.isInteger(target_samples)) {
+        throw new Error(`input_size(=${input_size}) is not divisible by 2`);
+    }
+
+    if (target_samples === 1) {
+        // special case, take average
+        output[output_offset] = (
+            input[input_offset] + input[input_offset + 1]
+        ) / 2;
+
+        return;
+    }
+
+    let i = 0;
+    for (; i < target_samples; i++) {
+
+        const f = i / (target_samples - 1);
+
+        const input_sample_offset = input_offset + i * 2;
+
+        const s0 = input[input_sample_offset];
+        const s1 = input[input_sample_offset + 1];
+
+        const sample_value = lerp(s0, s1, f);
+
+        // TODO implement decision scheme that would pick between min/max/average
+
+        output[output_offset + i] = sample_value;
+    }
+}

package/engine/animation/curve/compression/downsample_float_array_curve_by_error.js

@@ -0,0 +1,147 @@
+//
+
+
+import { max2 } from "../../../../core/math/max2.js";
+import { lerp } from "../../../../core/math/lerp.js";
+import { min3 } from "../../../../core/math/min3.js";
+import { max3 } from "../../../../core/math/max3.js";
+import { downsample_float_array } from "./downsample_float_array.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { isPowerOfTwo } from "../../../../core/math/isPowerOrTwo.js";
+
+/**
+ *
+ * @param {number[]} input
+ * @param {number} input_offset
+ * @param {number} input_size
+ * @param {number} f
+ * @return {number}
+ */
+function array_sampler_linear(input, input_offset, input_size, f) {
+    const t = f * (input_size - 1);
+
+    const fraction = t % 1;
+
+    if (fraction === 0) {
+        return input[input_offset + t];
+    }
+
+    const i0 = Math.floor(t);
+    const i1 = i0 + 1;
+
+    const s0 = input[input_offset + i0];
+    const s1 = input[input_offset + i1];
+
+    return lerp(s0, s1, fraction);
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} input0
+ * @param {number} input0_offset
+ * @param {number} input0_size
+ * @param {number[]|Float32Array} input1
+ * @param {number} input1_offset
+ * @param {number} input1_size
+ */
+function compute_float_array_curve_linear_sampling_relative_error(
+    input0, input0_offset, input0_size,
+    input1, input1_offset, input1_size
+) {
+
+    const largest_size = max2(input0_size, input1_size);
+
+    let max_error = 0;
+
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+
+    for (let i = 0; i < largest_size; i++) {
+        const f = i / (largest_size - 1);
+
+        const s0 = array_sampler_linear(input0, input0_offset, input0_size, f);
+        const s1 = array_sampler_linear(input1, input1_offset, input1_size, f);
+
+        const error = Math.abs(s0 - s1);
+
+        if (error > max_error) {
+            max_error = error;
+        }
+
+        min = min3(min, s0, s1);
+        max = max3(max, s0, s1);
+    }
+
+    const span = max - min;
+
+    if (span === 0) {
+        // avoid division by 0
+        return 0;
+    }
+
+    return max_error / span;
+}
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ * @param {number} input_size
+ * @param {number} [error]
+ * @return {number}
+ */
+export function downsample_float_array_curve_by_error(output, output_offset, input, input_offset, input_size, error = 0.03) {
+    if (!isPowerOfTwo(input_size)) {
+        throw new Error(`Input size must be a power of two, instead was '${input_size}'`);
+    }
+
+    const buffer_0 = new Float32Array(input_size >>> 1); // first step needs half the size of the original buffer
+    const buffer_1 = new Float32Array(input_size >>> 2); // next step needs quarter
+
+    let current = input;
+    let current_offset = input_offset;
+    let current_size = input_size;
+
+    let next = buffer_0;
+    let next_offset = 0;
+    let next_size = buffer_0.length;
+
+    let current_error = 0;
+
+    while (current_error <= error && current_size > 1) {
+        downsample_float_array(next, next_offset, current, current_offset, current_size);
+
+        current_error = compute_float_array_curve_linear_sampling_relative_error(
+            input, input_offset, input_size,
+            next, next_offset, next_size
+        );
+
+        if (current_error > error) {
+            // reached best possible reduction
+            break;
+        }
+
+        current = next;
+        current_offset = next_offset;
+        current_size = next_size;
+
+        // perform swap
+        if (next === buffer_0) {
+            next = buffer_1;
+        } else {
+            next = buffer_0;
+        }
+
+        next_offset = 0;
+        // next will be half the current size
+        next_size = current_size >>> 1;
+    }
+
+
+    // copy current buffer to output
+    array_copy(current, current_offset, output, output_offset, current_size);
+
+    return current_size;
+}

package/engine/animation/curve/compression/downsample_float_array_curve_by_error.spec.js

@@ -0,0 +1,47 @@
+import { downsample_float_array_curve_by_error } from "./downsample_float_array_curve_by_error.js";
+
+test('1 constant to 1', () => {
+    const output = [];
+
+    const sample_count = downsample_float_array_curve_by_error(output, 0, [1], 0, 1, 0.1);
+
+    expect(sample_count).toBe(1);
+    expect(output[0]).toBe(1);
+});
+
+test('4 constants to 1', () => {
+    const output = [];
+
+    const sample_count = downsample_float_array_curve_by_error(output, 0, [1, 1, 1, 1], 0, 4, 0.1);
+
+    expect(sample_count).toBe(1);
+    expect(output[0]).toBe(1);
+});
+
+test('2 constants to 1 with error = 0', () => {
+    const output = [];
+
+    const sample_count = downsample_float_array_curve_by_error(output, 0, [1, 1], 0, 2, 0);
+
+    expect(sample_count).toBe(1);
+    expect(output[0]).toBe(1);
+});
+
+test('2 different constants to 2', () => {
+    const output = [];
+
+    const sample_count = downsample_float_array_curve_by_error(output, 0, [1, 2], 0, 2, 0.1);
+
+    expect(sample_count).toBe(2);
+    expect(output).toEqual([1, 2]);
+});
+
+test('4 to 2, linear scale compression', () => {
+    const output = [];
+
+    const sample_count = downsample_float_array_curve_by_error(output, 0, [1, 2, 3, 4], 0, 4, 0.1);
+
+    expect(sample_count).toBe(2);
+    expect(output[0]).toBeCloseTo(1);
+    expect(output[1]).toBeCloseTo(4);
+});