@woosh/meep-engine 2.35.16 → 2.36.1

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);
+});

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

@@ -0,0 +1,154 @@
+import { EngineHarness } from "../../../EngineHarness.js";
+import { AnimationCurve } from "../AnimationCurve.js";
+import { Keyframe } from "../Keyframe.js";
+import { EngineConfiguration } from "../../../EngineConfiguration.js";
+import GUIElementSystem from "../../../ecs/gui/GUIElementSystem.js";
+import ViewportPositionSystem from "../../../ecs/gui/position/ViewportPositionSystem.js";
+import { animation_curve_to_float_array } from "./animation_curve_to_float_array.js";
+import { downsample_float_array_curve_by_error } from "./downsample_float_array_curve_by_error.js";
+import { build_plot_entity_from_array } from "../draw/build_plot_entity_from_array.js";
+
+const eh = new EngineHarness();
+
+async function init() {
+
+    const config = new EngineConfiguration();
+
+    const engine = eh.engine;
+
+    config.addSystem(new GUIElementSystem(engine.gameView, engine));
+    config.addSystem(new ViewportPositionSystem(engine.gameView.size));
+
+    await config.apply(engine);
+
+    await eh.initialize();
+
+    main(engine);
+}
+
+function build_error_scale(ecd, curve) {
+    const curve_data = [];
+    animation_curve_to_float_array(curve_data, curve, 0, 256);
+
+
+    build_plot_entity_from_array({
+        data: curve_data,
+        x: 10, y: 0
+    }).build(ecd);
+
+    const compressed_01 = [];
+    downsample_float_array_curve_by_error(compressed_01, 0, curve_data, 0, curve_data.length, 0.01);
+
+    build_plot_entity_from_array({
+        data: compressed_01,
+        x: 10, y: 202,
+        label: '1%'
+    }).build(ecd);
+
+    const compressed_03 = [];
+    downsample_float_array_curve_by_error(compressed_03, 0, curve_data, 0, curve_data.length, 0.03);
+
+    build_plot_entity_from_array({
+        data: compressed_03,
+        x: 10, y: 404,
+        label: '3%'
+    }).build(ecd);
+
+    const compressed_05 = [];
+    downsample_float_array_curve_by_error(compressed_05, 0, curve_data, 0, curve_data.length, 0.05);
+
+    build_plot_entity_from_array({
+        data: compressed_05,
+        x: 10, y: 606,
+        label: '5%'
+    }).build(ecd);
+
+    const compressed_10 = [];
+    downsample_float_array_curve_by_error(compressed_10, 0, curve_data, 0, curve_data.length, 0.10);
+
+    build_plot_entity_from_array({
+        data: compressed_10,
+        x: 10, y: 808,
+        label: '10%'
+    }).build(ecd);
+}
+
+async function main(engine) {
+
+    // EngineHarness.buildBasics({ engine });
+    function sample_curve_0() {
+
+        const curve = new AnimationCurve();
+
+        curve.keys.push(Keyframe.from(0, 0));
+        curve.keys.push(Keyframe.from(1, 1));
+        curve.keys.push(Keyframe.from(2, 0.5));
+
+        return curve;
+    }
+
+    function sample_curve_1() {
+
+        const curve = new AnimationCurve();
+
+        curve.keys.push(Keyframe.from(0, 0));
+        curve.keys.push(Keyframe.from(0.1, 1));
+        curve.keys.push(Keyframe.from(2, 0.5));
+
+        return curve;
+    }
+
+    function sample_curve_2() {
+
+        const curve = new AnimationCurve();
+
+        curve.keys.push(Keyframe.from(0, 1));
+        curve.keys.push(Keyframe.from(1, 2));
+        curve.keys.push(Keyframe.from(2, 3));
+        curve.keys.push(Keyframe.from(3, 4));
+
+        return curve;
+    }
+
+    function sample_curve_3() {
+
+        const curve = new AnimationCurve();
+
+        curve.keys.push(Keyframe.from(0, 1));
+        curve.keys.push(Keyframe.from(1, 1));
+        curve.keys.push(Keyframe.from(2, 1));
+        curve.keys.push(Keyframe.from(3, 1));
+
+        return curve;
+    }
+
+    function sample_curve_4() {
+
+        const curve = new AnimationCurve();
+
+        curve.keys.push(Keyframe.from(0, 1, 0, 1));
+        // curve.keys.push(Keyframe.from(1, 2, 1, -1));
+        curve.keys.push(Keyframe.from(1, 2, -1, 1));
+        curve.keys.push(Keyframe.from(2, 1));
+
+        return curve;
+    }
+
+    const curve = sample_curve_2();
+
+    const ecd = engine.entityManager.dataset;
+
+    build_error_scale(ecd, curve);
+
+    // const editor_view = build_curve_editor({ curve });
+    //
+    // new EntityBuilder()
+    //     .add(ViewportPosition.fromJSON({
+    //         offset: { x: 0, y: 0 }
+    //     }))
+    //     .add(GUIElement.fromView(editor_view))
+    //     .build(ecd);
+
+}
+
+init();