@woosh/meep-engine 2.131.35 → 2.131.36

package/src/core/math/hash/computeHashFloatArray.js

@@ -2,7 +2,8 @@ import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 /**
  *
- * @param {number[]|Float32Array|Float64Array} values
+ * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} values
+ * @returns {number}
  */
 export function computeHashFloatArray(values) {
     const dataLength = values.length;

package/src/core/process/undo/ActionProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,0BA4DC;IA3DG;;;OAGG;IACH,SAFU,YAAY,CAEG;IAEzB;;;OAGG;IACH,aAAsB;IAEtB;;;OAGG;IACH,aAAe;IAEf;;OAEG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,oBAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,6GAA+B;IAE/B;;;OAGG;IACH,+GAAiC;IAEjC;;;;OAIG;IACH,uBAAuC;IAG3C;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAqChB;IAED;;;OAGG;IACH,oCA+BC;IAED,uBA2BC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAQC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAQC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,iBAuBlB;IAED;;;OAGG;IACH,kCAQC;IAED;;;;;OAKG;IACH,oBAgBC;IAED;;;;OAIG;IACH,kBAMC;CACJ;iBAvfgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}
+{"version":3,"file":"ActionProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/core/process/undo/ActionProcessor.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,0BA4DC;IA3DG;;;OAGG;IACH,SAFU,YAAY,CAEG;IAEzB;;;OAGG;IACH,aAAsB;IAEtB;;;OAGG;IACH,aAAe;IAEf;;OAEG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,oBAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,6GAA+B;IAE/B;;;OAGG;IACH,+GAAiC;IAEjC;;;;OAIG;IACH,uBAAuC;IAG3C;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GACJ,CAAC,CAWb;IAED;;OAEG;IACH,cAGC;IAED;;;;;;;;OAQG;IACH,wBAFW,MAAM,QAqChB;IAED;;;OAGG;IACH,oCAiCC;IAED,uBA2BC;IAED;;;;;OAKG;IACH,2CAcC;IAED;;;;;OAKG;IACH,4BAJW,CAAC,GACC,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,4BAyDC;IAED,sBAQC;IAED;;;;OAIG;IACH,sBAmCC;IAED;;OAEG;IACH,sBAQC;IAED;;;;OAIG;IACH,sBA0BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,iBAuBlB;IAED;;;OAGG;IACH,kCAQC;IAED;;;;;OAKG;IACH,oBAgBC;IAED;;;;OAIG;IACH,kBAMC;CACJ;iBAzfgB,+BAA+B;qBAG3B,WAAW;mBAFb,+BAA+B"}

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

@@ -181,7 +181,9 @@ export class ActionProcessor {
 
                 const removed_marks = marks.splice(markIndexToKeep, numMarks - markIndexToKeep);
                 // dispatch signal
-                removed_marks.forEach(this.onMarkRemoved.send1, this.onMarkRemoved);
+                for( let mark of removed_marks){
+                    this.onMarkRemoved.send1(mark);
+                }
             }
         }
 

package/src/engine/animation/curve/actionProcessorOperations/applyActionChange.d.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {List} kfToDelete
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionRemove(keyframeStateManager: KeyframeStateManager, kfToDelete: List, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext): void;
+/**
+ *
+ * @param {D} actionLabel
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionSelection(actionLabel: D, keyframeStateManager: KeyframeStateManager, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext): void;
+/**
+ *
+ * @param {D} actionLabel
+ * @param curveSet
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionMove(actionLabel: D, curveSet: any, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext): void;
+/**
+ *
+ * @param {Boolean} isClickedOnGraph
+ * @param {Boolean} isSelectionKeyHeld
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function applyGlobalKeyframeDeselection(isClickedOnGraph: boolean, isSelectionKeyHeld: boolean, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext, keyframeStateManager: KeyframeStateManager): void;
+//# sourceMappingURL=applyActionChange.d.ts.map

package/src/engine/animation/curve/actionProcessorOperations/applyActionChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyActionChange.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/applyActionChange.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,8KAIC;AAED;;;;;;GAMG;AACH,+KAMC;AAED;;;;;;GAMG;AACH,6IAGC;AAGD;;;;;;;GAOG;AACH,iOASC"}

package/src/engine/animation/curve/actionProcessorOperations/applyActionChange.js

@@ -0,0 +1,61 @@
+import {MoveKeyframeAction, RemoveKeyframeAction, SelectionAction} from "./curveActions.js";
+
+/**
+ *
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {List} kfToDelete
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionRemove(keyframeStateManager, kfToDelete, actionProcessor, actionProcessorCTX) {
+    actionProcessor.mark('delete keyframe(s)');
+    actionProcessor.do(new SelectionAction(keyframeStateManager.selectedKeyframes, keyframeStateManager.curKeyframeList, keyframeStateManager.prevKeyframeList, actionProcessorCTX))
+    actionProcessor.do(new RemoveKeyframeAction(kfToDelete, keyframeStateManager.NULL_KEYFRAME, actionProcessorCTX));
+}
+
+/**
+ *
+ * @param {D} actionLabel
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionSelection(actionLabel, keyframeStateManager, actionProcessor, actionProcessorCTX) {
+    //Applies only is there is a change
+    if (!keyframeStateManager.selectedKeyframes.equals(keyframeStateManager.curKeyframeList)) { //Prevent action when no change to selection
+        actionProcessor.mark(actionLabel);
+        actionProcessor.do(new SelectionAction(keyframeStateManager.selectedKeyframes, keyframeStateManager.curKeyframeList, keyframeStateManager.prevKeyframeList, actionProcessorCTX))
+    }
+}
+
+/**
+ *
+ * @param {D} actionLabel
+ * @param curveSet
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ */
+export function applyActionMove(actionLabel, curveSet, actionProcessor, actionProcessorCTX) {
+    actionProcessor.mark(actionLabel);
+    actionProcessor.do(new MoveKeyframeAction(curveSet.curveStartValues, curveSet.curveStartIndices, curveSet.curveEndValue, curveSet.curveEndIndices, actionProcessorCTX));
+}
+
+
+/**
+ *
+ * @param {Boolean} isClickedOnGraph
+ * @param {Boolean} isSelectionKeyHeld
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function applyGlobalKeyframeDeselection(isClickedOnGraph, isSelectionKeyHeld, actionProcessor, actionProcessorCTX, keyframeStateManager) {
+    if (isClickedOnGraph) {
+        keyframeStateManager.observedActiveKeyframe.set(keyframeStateManager.NULL_KEYFRAME);
+        if (!isSelectionKeyHeld) {
+            keyframeStateManager.prevKeyframeList.copy(keyframeStateManager.selectedKeyframes);
+            keyframeStateManager.curKeyframeList.reset();
+            applyActionSelection('Deselection', keyframeStateManager, actionProcessor, actionProcessorCTX);
+        }
+    }
+}

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts

@@ -0,0 +1,107 @@
+export class keyframesContext {
+    /**
+     *
+     * @param {AnimationCurve} curve
+     * @param {function} removeKeyframe
+     * @param {function} addKeyframe
+     * @param {Map} keyframeViews
+     * @param {ObservedValue} activeKeyframe
+     * @param {List} selectedKeyframes
+     * @param {function} handleCurveUpdate
+     * @param {function} updateGraph
+     */
+    constructor({ curve, removeKeyframe, addKeyframe, keyframeViews, activeKeyframe, selectedKeyframes, handleCurveUpdate, updateGraph }: AnimationCurve);
+    refCurve: any;
+    fnRemoveKeyframe: any;
+    fnAddKeyframe: any;
+    refKeyframeViews: any;
+    refActiveKeyframe: any;
+    refSelectionKeyframes: any;
+    fnHandleCurveUpdate: any;
+    fnUpdateGraph: any;
+}
+export class RemoveKeyframeAction extends Action<any> {
+    /**
+     *
+     * @param {List} passKeyframes
+     * @param {Keyframe} passNullKeyframe
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframes: List<any>, passNullKeyframe: Keyframe, context: keyframesContext);
+    copyKfToDelete: any;
+    refNullKeyframe: Keyframe;
+    actionContext: keyframesContext;
+    linkedActiveKeyframe: any;
+    linkedSelectionKeyframes: List<any>;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+export class AddKeyframeAction extends Action<any> {
+    /**
+     *
+     * @param {Keyframe} passKeyframe
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframe: Keyframe, context: keyframesContext);
+    newKeyframeToAdd: Keyframe;
+    actionContext: keyframesContext;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+export class MoveKeyframeAction extends Action<any> {
+    /**
+     *
+     * @param {AnimationCurve} passCurveValueStart
+     * @param {AnimationCurve} passCurveRefStart
+     * @param {AnimationCurve} passCurveValueEnd
+     * @param {AnimationCurve} passCurveRefEnd
+     * @param {keyframesContext} context
+     */
+    constructor(passCurveValueStart: AnimationCurve, passCurveRefStart: AnimationCurve, passCurveValueEnd: AnimationCurve, passCurveRefEnd: AnimationCurve, context: keyframesContext);
+    curveRefStart: AnimationCurve;
+    curveValueStart: AnimationCurve;
+    curveRefEnd: AnimationCurve;
+    curveValueEnd: AnimationCurve;
+    actionContext: keyframesContext;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+export class TangentChangeAction extends Action<any> {
+    /**
+     *
+     * @param {Keyframe} passKeyframe
+     * @param {Keyframe} passKeyframeValueStart
+     * @param {Keyframe} passKeyframeValueEnd
+     * @param {function} handleTangentUpdate
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframe: Keyframe, passKeyframeValueStart: Keyframe, passKeyframeValueEnd: Keyframe, handleTangentUpdate: Function, context: keyframesContext);
+    refKeyframe: Keyframe;
+    keyframeValueStart: Keyframe;
+    keyframeValueEnd: Keyframe;
+    actionContext: keyframesContext;
+    fnHandleTangentUpdate: Function;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+export class SelectionAction extends Action<any> {
+    /**
+     *
+     * @param {List} passSelectionKeyframe
+     * @param {List} passSelectionList
+     * @param {List} passPrevSelectionList
+     * @param {keyframesContext} context
+     */
+    constructor(passSelectionKeyframe: List<any>, passSelectionList: List<any>, passPrevSelectionList: List<any>, context: keyframesContext);
+    refSelectionKeyframe: List<any>;
+    keyframeList: List<any>;
+    prevKeyframeList: List<any>;
+    actionContext: keyframesContext;
+    apply(context: any): Promise<void>;
+    revert(context: any): Promise<void>;
+}
+import { AnimationCurve } from "../AnimationCurve.js";
+import { Action } from "../../../../core/process/undo/Action.js";
+import { Keyframe } from "../Keyframe.js";
+import List from "../../../../core/collection/list/List.js";
+//# sourceMappingURL=curveActions.d.ts.map

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curveActions.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/curveActions.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;OAUG;IACH,sIATW,cAAc,EAkBxB;IARG,cAAqB;IACrB,sBAAsC;IACtC,mBAAgC;IAChC,sBAAqC;IACrC,uBAAuC;IACvC,2BAA8C;IAC9C,yBAA4C;IAC5C,mBAAgC;CAEvC;AAED;IACI;;;;;OAKG;IACH,wDAHW,QAAQ,WACR,gBAAgB,EAc1B;IAVG,oBAA2C;IAC3C,0BAAuC;IAEvC,gCAA4B;IAE5B,0BAAsE;IACtE,oCAA0C;IAM9C,mCASC;IAED,oCAMC;CACJ;AAED;IACI;;;;OAIG;IACH,0BAHW,QAAQ,WACR,gBAAgB,EAO1B;IAHG,2BAA4C;IAE5C,gCAA4B;IAGhC,mCAIC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,iCANW,cAAc,qBACd,cAAc,qBACd,cAAc,mBACd,cAAc,WACd,gBAAgB,EAW1B;IAPG,8BAAsC;IACtC,gCAAkD;IAElD,4BAAkC;IAClC,8BAA8C;IAE9C,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,0BANW,QAAQ,0BACR,QAAQ,wBACR,QAAQ,0CAER,gBAAgB,EAU1B;IANG,sBAA+B;IAC/B,6BAAwD;IACxD,2BAAoD;IAEpD,gCAA4B;IAC5B,gCAAgD;IAGpD,mCAKC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;OAMG;IACH,uHAFW,gBAAgB,EAU1B;IANG,gCAAiD;IACjD,wBAA8B;IAE9B,4BAAkC;IAElC,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;+BAxM4B,sBAAsB;uBAD9B,yCAAyC;yBAEvC,gBAAgB;iBACtB,0CAA0C"}

package/src/engine/animation/curve/actionProcessorOperations/curveActions.js

@@ -0,0 +1,202 @@
+import {Action} from "../../../../core/process/undo/Action.js";
+import {AnimationCurve} from "../AnimationCurve.js";
+import {Keyframe} from "../Keyframe.js";
+import List from "../../../../core/collection/list/List.js";
+
+export class keyframesContext{
+    /**
+     *
+     * @param {AnimationCurve} curve
+     * @param {function} removeKeyframe
+     * @param {function} addKeyframe
+     * @param {Map} keyframeViews
+     * @param {ObservedValue} activeKeyframe
+     * @param {List} selectedKeyframes
+     * @param {function} handleCurveUpdate
+     * @param {function} updateGraph
+     */
+    constructor({curve, removeKeyframe, addKeyframe, keyframeViews, activeKeyframe, selectedKeyframes, handleCurveUpdate, updateGraph}) {
+        this.refCurve = curve;
+        this.fnRemoveKeyframe = removeKeyframe;
+        this.fnAddKeyframe = addKeyframe;
+        this.refKeyframeViews = keyframeViews;
+        this.refActiveKeyframe = activeKeyframe;
+        this.refSelectionKeyframes = selectedKeyframes;
+        this.fnHandleCurveUpdate = handleCurveUpdate;
+        this.fnUpdateGraph = updateGraph;
+    }
+}
+
+export class RemoveKeyframeAction extends Action {
+    /**
+     *
+     * @param {List} passKeyframes
+     * @param {Keyframe} passNullKeyframe
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframes, passNullKeyframe, context) {
+        super();
+        this.copyKfToDelete = passKeyframes.clone();
+        this.refNullKeyframe = passNullKeyframe;
+
+        this.actionContext = context;
+
+        this.linkedActiveKeyframe = this.actionContext.refActiveKeyframe.get();
+        this.linkedSelectionKeyframes = new List();
+        this.actionContext.refSelectionKeyframes.forEach(keyframe => {
+            this.linkedSelectionKeyframes.add(keyframe);
+        })
+    }
+
+    async apply(context){
+        this.copyKfToDelete.forEach((selKF) => {
+            this.actionContext.refCurve.remove(selKF);
+            this.actionContext.fnRemoveKeyframe(selKF);
+        });
+        this.actionContext.fnHandleCurveUpdate();
+
+        this.actionContext.refActiveKeyframe.set(this.refNullKeyframe);
+        this.actionContext.refSelectionKeyframes.reset();
+    }
+
+    async revert(context){
+        this.copyKfToDelete.forEach((selKF) => {
+            this.actionContext.refCurve.add(selKF);
+            this.actionContext.fnAddKeyframe(selKF);
+        });
+        this.actionContext.fnHandleCurveUpdate();
+    }
+}
+
+export class AddKeyframeAction extends Action {
+    /**
+     *
+     * @param {Keyframe} passKeyframe
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframe, context) {
+        super();
+        this.newKeyframeToAdd = passKeyframe.clone();
+
+        this.actionContext = context;
+    }
+
+    async apply(context){
+        this.actionContext.refCurve.add(this.newKeyframeToAdd);
+        this.actionContext.fnAddKeyframe(this.newKeyframeToAdd);
+        this.actionContext.fnHandleCurveUpdate();
+    }
+
+    async revert(context){
+        this.actionContext.refCurve.remove(this.newKeyframeToAdd);
+        this.actionContext.fnRemoveKeyframe(this.newKeyframeToAdd);
+
+        this.actionContext.fnHandleCurveUpdate();
+    }
+}
+
+export class MoveKeyframeAction extends Action {
+    /**
+     *
+     * @param {AnimationCurve} passCurveValueStart
+     * @param {AnimationCurve} passCurveRefStart
+     * @param {AnimationCurve} passCurveValueEnd
+     * @param {AnimationCurve} passCurveRefEnd
+     * @param {keyframesContext} context
+     */
+    constructor(passCurveValueStart, passCurveRefStart, passCurveValueEnd, passCurveRefEnd, context) {
+        super();
+        this.curveRefStart = passCurveRefStart;
+        this.curveValueStart = passCurveValueStart.clone();
+
+        this.curveRefEnd = passCurveRefEnd
+        this.curveValueEnd = passCurveValueEnd.clone();
+
+        this.actionContext = context;
+    }
+
+    async apply(context){
+        for (let i = 0; i < this.actionContext.refCurve.length; i++) {
+            this.actionContext.refCurve.keys[i] = this.curveRefEnd.keys[i];
+            this.actionContext.refCurve.keys[i].copy(this.curveValueEnd.keys[i]);
+        }
+        this.actionContext.fnHandleCurveUpdate();
+    }
+
+    async revert(context){
+        for (let i = 0; i < this.actionContext.refCurve.length; i++) {
+            this.actionContext.refCurve.keys[i] = this.curveRefStart.keys[i];
+            this.actionContext.refCurve.keys[i].copy(this.curveValueStart.keys[i]);
+        }
+        this.actionContext.fnHandleCurveUpdate();
+    }
+}
+
+export class TangentChangeAction extends Action {
+    /**
+     *
+     * @param {Keyframe} passKeyframe
+     * @param {Keyframe} passKeyframeValueStart
+     * @param {Keyframe} passKeyframeValueEnd
+     * @param {function} handleTangentUpdate
+     * @param {keyframesContext} context
+     */
+    constructor(passKeyframe, passKeyframeValueStart, passKeyframeValueEnd, handleTangentUpdate, context) {
+        super();
+        this.refKeyframe = passKeyframe;
+        this.keyframeValueStart = passKeyframeValueStart.clone();
+        this.keyframeValueEnd = passKeyframeValueEnd.clone();
+
+        this.actionContext = context;
+        this.fnHandleTangentUpdate = handleTangentUpdate
+    }
+
+    async apply(context){
+        this.refKeyframe.copy(this.keyframeValueEnd);
+
+        this.fnHandleTangentUpdate();
+        this.actionContext.fnHandleCurveUpdate();
+    }
+
+    async revert(context){
+        this.refKeyframe.copy(this.keyframeValueStart);
+
+        this.fnHandleTangentUpdate();
+        this.actionContext.fnHandleCurveUpdate();
+    }
+}
+
+export class SelectionAction extends Action {
+    /**
+     *
+     * @param {List} passSelectionKeyframe
+     * @param {List} passSelectionList
+     * @param {List} passPrevSelectionList
+     * @param {keyframesContext} context
+     */
+    constructor(passSelectionKeyframe, passSelectionList, passPrevSelectionList, context) {
+        super();
+        this.refSelectionKeyframe = passSelectionKeyframe;
+        this.keyframeList = new List()
+        this.keyframeList.copy(passSelectionList)
+        this.prevKeyframeList = new List()
+        this.prevKeyframeList.copy(passPrevSelectionList)
+        this.actionContext = context;
+    }
+
+    async apply(context){
+        this.refSelectionKeyframe.reset()
+        this.keyframeList.forEach(k => {
+            this.refSelectionKeyframe.add(k)
+        })
+        this.actionContext.fnUpdateGraph();
+    }
+
+    async revert(context){
+        this.refSelectionKeyframe.reset()
+        this.prevKeyframeList.forEach(k => {
+            this.refSelectionKeyframe.add(k)
+        })
+        this.actionContext.fnUpdateGraph();
+    }
+}

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

@@ -6,12 +6,13 @@ import ViewportPositionSystem from "../../../ecs/gui/position/ViewportPositionSy
 import { EngineConfiguration } from "../../../EngineConfiguration.js";
 import { EngineHarness } from "../../../EngineHarness.js";
 import { AnimationCurve } from "../AnimationCurve.js";
-import { build_curve_editor } from "../draw/build_curve_editor.js";
 import { build_plot_entity_from_array } from "../draw/build_plot_entity_from_array.js";
 import { Keyframe } from "../Keyframe.js";
 import { CURVE_EASE_IN_OUT } from "../preset/CURVE_EASE_IN_OUT.js";
 import { downsample_float_array_curve_by_error } from "./downsample_float_array_curve_by_error.js";
 import { sample_animation_curve_to_float_array } from "./sample_animation_curve_to_float_array.js";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+import {CurveEditorView} from "../editor/CurveEditorView.js";
 
 const eh = new EngineHarness();
 
@@ -154,7 +155,24 @@ async function main(engine) {
     // curve.smoothAllTangents();
 
     // const curve = sample_curve_5();
-    const curve = CURVE_EASE_IN_OUT;
+    // const curve = CURVE_EASE_IN_OUT;
+
+    const curve = new AnimationCurve();
+
+    // curve.add(Keyframe.from(0, 0, 0, 0));
+    // curve.add(Keyframe.from(0.4, 0.5, -1.4, 1));
+    // curve.add(Keyframe.from(0.5, 0.5, -1.4, 1));
+    // curve.add(Keyframe.from(0.6, 0.5, -1.4, 1));
+    // curve.add(Keyframe.from(0.7, 0.5, -1.4, 1));
+    // curve.add(Keyframe.from(1, 1, 0, 0));
+
+    curve.add(Keyframe.from(-0.2, 0, 0, 0));
+    curve.add(Keyframe.from(0.1, 1.5, -1.4, 1));
+    curve.add(Keyframe.from(0.5, 0.2, -1.4, 1));
+    curve.add(Keyframe.from(0.8, -0.5, -1.4, 1));
+    curve.add(Keyframe.from(1.0, 0.5, -1.4, 1));
+    curve.add(Keyframe.from(1.5, 1, 0, 0));
+
 
     const ecd = engine.entityManager.dataset;
 
@@ -162,7 +180,10 @@ async function main(engine) {
 
     console.log(curve);
 
-    const editor_view = build_curve_editor({ curve });
+    const editor_view = new CurveEditorView({
+        curve,
+        enableEdit:true
+    });
 
     new Entity()
         .add(ViewportPosition.fromJSON({

package/src/engine/animation/curve/draw/buildReadOnlyDisplay.d.ts

@@ -0,0 +1,3 @@
+export function buildReadOnlyDisplay(): LabelView;
+import LabelView from "../../../../view/common/LabelView.js";
+//# sourceMappingURL=buildReadOnlyDisplay.d.ts.map

package/src/engine/animation/curve/draw/buildReadOnlyDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildReadOnlyDisplay.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/buildReadOnlyDisplay.js"],"names":[],"mappings":"AAGA,kDAUC;sBAbqB,sCAAsC"}

package/src/engine/animation/curve/draw/buildReadOnlyDisplay.js

@@ -0,0 +1,14 @@
+import LabelView from "../../../../view/common/LabelView.js";
+import {CSS_ABSOLUTE_POSITIONING} from "../../../../view/CSS_ABSOLUTE_POSITIONING.js";
+
+export function buildReadOnlyDisplay() {
+    return new LabelView("Read Only Mode", {
+        css: {
+            background: `rgb(34, 34, 34)`,
+            ...CSS_ABSOLUTE_POSITIONING,
+            padding: '4px 25px',
+            color: 'red',
+            font: '12px Tahoma, monospaced'
+        }
+    });
+}

package/src/engine/animation/curve/draw/build_tangent_editor.d.ts

@@ -5,7 +5,12 @@
  * @param {Vector2} size
  * @param {AABB2} frame
  * @param {Vector2} margin
+ * @param {ObservedBoolean} enableTangentAlignment
+ * @param cbFnCurveUpdate
+ * @param {Signal} funcTrigger
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
  */
-export function build_tangent_editor({ ctx, keyframe, size, frame, margin }: CanvasRenderingContext2D): EmptyView;
+export function build_tangent_editor({ ctx, keyframe, size, frame, margin, enableTangentAlignment, cbFnCurveUpdate, funcTrigger, actionProcessor, actionProcessorCTX }: CanvasRenderingContext2D): EmptyView;
 import EmptyView from "../../../../view/elements/EmptyView.js";
 //# sourceMappingURL=build_tangent_editor.d.ts.map

package/src/engine/animation/curve/draw/build_tangent_editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_tangent_editor.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/build_tangent_editor.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,6EANW,wBAAwB,aA8GlC;sBAlHqB,wCAAwC"}
+{"version":3,"file":"build_tangent_editor.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/build_tangent_editor.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;GAYG;AACH,wKAXW,wBAAwB,aA2NlC;sBA3RqB,wCAAwC"}