@woosh/meep-engine 2.131.35 → 2.131.36

package/src/engine/animation/curve/editor/createSelectionBoxTool.js

@@ -0,0 +1,93 @@
+import Vector2 from "../../../../core/geom/Vector2.js";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+import {position_canvas_to_curve} from "../draw/position_canvas_to_curve.js";
+import {applyActionSelection} from "../actionProcessorOperations/applyActionChange.js";
+import {DragHandler} from "./DragHandler.js";
+
+/**
+ *
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {CanvasView} graph
+ * @param {AABB2} frame
+ * @param {Vector2} margin
+ * @param {function} fnUpdate
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionCTX
+ * @returns {DragHandler}
+ */
+export function createSelectionBoxTool({
+                                                      keyframeStateManager,
+                                                      graph,
+                                                      frame,
+                                                      margin,
+                                                      fnUpdate,
+                                                      actionProcessor,
+                                                      actionCTX
+                                                  }) {
+    const anchorPos = new Vector2();
+    const targetPos = new Vector2();
+    const selectionBox = new AABB2();
+
+    const prevKeyframeList = keyframeStateManager.prevKeyframeList;
+    const curKeyframeList = keyframeStateManager.curKeyframeList;
+    const selectedKeyframes = keyframeStateManager.selectedKeyframes;
+    const keyframeViews = keyframeStateManager.keyframeViews;
+
+    /**
+     *
+     * @param {AABB2} box
+     */
+    function drawSelectionBox(box = new AABB2) {
+        fnUpdate();
+        const ctx = graph.context2d;
+        ctx.fillStyle = 'none';
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = '#FFFF00';
+        ctx.beginPath();
+        ctx.rect(box.x0, box.y0, box.width, box.height);
+        ctx.stroke();
+    }
+
+    return new DragHandler({
+        dragStart(position) {
+            // console.log("start drag")
+            anchorPos.copy(position);
+            targetPos.copy(position);
+            selectionBox.set(0, 0, 0, 0);
+        },
+        drag(position,delta) {
+            // console.log("dragging")
+            targetPos.copy(position);
+
+            const x0 = Math.min(targetPos.x, anchorPos.x);
+            const x1 = Math.max(targetPos.x, anchorPos.x);
+            const y0 = Math.min(targetPos.y, anchorPos.y);
+            const y1 = Math.max(targetPos.y, anchorPos.y);
+
+            selectionBox.set(x0, y0, x1, y1);
+            drawSelectionBox(selectionBox);
+        },
+        dragEnd() {
+            // console.log("end drag")
+            prevKeyframeList.copy(selectedKeyframes);
+            const startRange = position_canvas_to_curve(graph.size, frame, margin, selectionBox.x0, selectionBox.y0);
+            const endRange = position_canvas_to_curve(graph.size, frame, margin, selectionBox.x1, selectionBox.y1);
+            keyframeViews.forEach((marker_view, key) => {
+                if (key.time >= startRange.x && key.time <= endRange.x
+                    && key.value >= endRange.y && key.value <= startRange.y) {
+
+                    if (!curKeyframeList.find(kf => kf === key)) {
+                        curKeyframeList.add(key);
+                    }
+                }
+            })
+            if (!curKeyframeList.isEmpty()) {
+                applyActionSelection('Selection', keyframeStateManager, actionProcessor, actionCTX);
+            }
+            else{
+                //Clears the drawn selection box
+                fnUpdate();
+            }
+        }
+    });
+}

package/src/engine/animation/curve/editor/deleteKeyframeAndResetVars.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function deleteKeyframeAndResetVars(actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext, keyframeStateManager: KeyframeStateManager): void;
+//# sourceMappingURL=deleteKeyframeAndResetVars.d.ts.map

package/src/engine/animation/curve/editor/deleteKeyframeAndResetVars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteKeyframeAndResetVars.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/deleteKeyframeAndResetVars.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,qKAaC"}

package/src/engine/animation/curve/editor/deleteKeyframeAndResetVars.js

@@ -0,0 +1,24 @@
+import List from "../../../../core/collection/list/List.js";
+
+import {applyActionRemove} from "../actionProcessorOperations/applyActionChange.js";
+
+/**
+ *
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function deleteKeyframeAndResetVars(actionProcessor, actionProcessorCTX, keyframeStateManager) {
+    const activeKf = keyframeStateManager.observedActiveKeyframe.get();
+
+    const kfToDelete = new List(keyframeStateManager.selectedKeyframes.data);
+    if (activeKf !== keyframeStateManager.NULL_KEYFRAME && !kfToDelete.contains(activeKf))
+        kfToDelete.add(activeKf)
+
+    keyframeStateManager.prevKeyframeList.copy(keyframeStateManager.selectedKeyframes);
+    keyframeStateManager.curKeyframeList.reset();
+
+    if (kfToDelete.length > 0) {
+        applyActionRemove(keyframeStateManager, kfToDelete, actionProcessor, actionProcessorCTX);
+    }
+}

package/src/engine/animation/curve/editor/determineUnitSpacing.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} width
+ * @param {number} scale
+ * @returns {number}
+ */
+export function determineUnitSpacing(width: number, scale: number): number;
+//# sourceMappingURL=determineUnitSpacing.d.ts.map

package/src/engine/animation/curve/editor/determineUnitSpacing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineUnitSpacing.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/determineUnitSpacing.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,4CAJW,MAAM,SACN,MAAM,GACJ,MAAM,CA4BlB"}

package/src/engine/animation/curve/editor/determineUnitSpacing.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * @param {number} width
+ * @param {number} scale
+ * @returns {number}
+ */
+export function determineUnitSpacing(width, scale) {
+    const baseTicks = 10;
+    const axisLength = width * scale;
+
+    const basePixelPerUnit = axisLength / baseTicks;
+    const targetPixelSpacing = 32;
+
+    const niceDivisionPattern = [1, 2, 5];
+
+    let chosenDivision = 1;
+    let lastDiff = Infinity;
+    for (const patternValue of niceDivisionPattern) {
+        const idealChoice = targetPixelSpacing / basePixelPerUnit
+        //Note: patternValue × 10^n ≈ idealChoice
+        const idealScale = idealChoice / patternValue;
+        const n = Math.round(Math.log10(idealScale))
+        const chosenPattern = patternValue * Math.pow(10,n)
+        const diff = (Math.abs(basePixelPerUnit * chosenPattern - targetPixelSpacing))
+
+        if ((diff < lastDiff)) {
+            lastDiff = diff;
+            chosenDivision = chosenPattern;
+        }
+    }
+
+    return basePixelPerUnit * chosenDivision;
+}

package/src/engine/animation/curve/editor/formatTruncDecimal.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} num
+ * @returns {string}
+ */
+export function formatTruncDecimal(num: number): string;
+//# sourceMappingURL=formatTruncDecimal.d.ts.map

package/src/engine/animation/curve/editor/formatTruncDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatTruncDecimal.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/formatTruncDecimal.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/engine/animation/curve/editor/formatTruncDecimal.js

@@ -0,0 +1,14 @@
+
+const formatter = new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 3,
+    roundingMode: "trunc",
+})
+
+/**
+ *
+ * @param {number} num
+ * @returns {string}
+ */
+export function formatTruncDecimal(num) {
+    return formatter.format(num);
+}

package/src/engine/animation/curve/editor/inputEventHandlers.d.ts

@@ -0,0 +1,32 @@
+/**
+ *
+ * @param {KeyboardEvent} event
+ * @param {KeyboardDevice} keyboard
+ * @param {AnimationCurve} curve
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext}actionProcessorCTX
+ */
+export function handleKeyDownEvents(event: KeyboardEvent, keyboard: KeyboardDevice, curve: AnimationCurve, keyframeStateManager: KeyframeStateManager, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext): void;
+/**
+ *
+ * @param {MouseEvent} e
+ * @param {CanvasView} graph
+ * @param {KeyboardDevice} keyboardElement
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function handleMouseDownEvents(e: MouseEvent, graph: CanvasView, keyboardElement: KeyboardDevice, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext, keyframeStateManager: KeyframeStateManager): void;
+export function handleMouseDoubleClickEvents(e: any, vContainer: any, graph: any, frame: any, margin: any, curve: any, validEditableBounds: any, actionProcessor: any, actionProcessorCTX: any): void;
+/**
+ *
+ * @param {KeyboardDevice} keyboardElement
+ * @param {Keyframe} keyframe
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function handleKeyframeSelectedByDevice(keyboardElement: KeyboardDevice, keyframe: Keyframe, actionProcessor: ActionProcessor, actionProcessorCTX: keyframesContext, keyframeStateManager: KeyframeStateManager): void;
+import { Keyframe } from "../Keyframe.js";
+//# sourceMappingURL=inputEventHandlers.d.ts.map

package/src/engine/animation/curve/editor/inputEventHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputEventHandlers.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/inputEventHandlers.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,2CAPW,aAAa,6KAqCvB;AAED;;;;;;;;GAQG;AACH,yCAPW,UAAU,gLAYpB;AAED,sMAUC;AAED;;;;;;;GAOG;AACH,0FALW,QAAQ,4HAiClB;yBAxHsB,gBAAgB"}

package/src/engine/animation/curve/editor/inputEventHandlers.js

@@ -0,0 +1,125 @@
+import {deleteKeyframeAndResetVars} from "./deleteKeyframeAndResetVars.js";
+import {applyActionSelection, applyGlobalKeyframeDeselection} from "../actionProcessorOperations/applyActionChange.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import {readPositionFromMouseEvent} from "../../../input/devices/PointerDevice.js";
+import {Keyframe} from "../Keyframe.js";
+import {AddKeyframeAction} from "../actionProcessorOperations/curveActions.js";
+import {isInjectedKeyframeInBounds} from "../draw/isInjectedKeyframeInBounds.js";
+import {downloadAsFile} from "../../../../core/binary/downloadAsFile.js";
+
+const keyType = {
+    deleteKey: 'delete',
+    alignTangentKey: 'a',
+    holdSelectionKey: 'shift',
+    controlKey: 'ctrl',
+    undoSecondaryKey: 'z',
+    redoSecondaryKey: 'y',
+    saveSecondaryKey: 's',
+}
+
+/**
+ *
+ * @param {KeyboardEvent} event
+ * @param {KeyboardDevice} keyboard
+ * @param {AnimationCurve} curve
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext}actionProcessorCTX
+ */
+export function handleKeyDownEvents(event, keyboard, curve, keyframeStateManager, actionProcessor, actionProcessorCTX) {
+    const {keys} = keyboard;
+
+    if (keys[keyType.deleteKey].is_down) {
+        deleteKeyframeAndResetVars(actionProcessor, actionProcessorCTX, keyframeStateManager);
+    }
+
+    if (keys[keyType.alignTangentKey].is_down
+        && keyframeStateManager.observedActiveKeyframe.get() !== keyframeStateManager.NULL_KEYFRAME) {
+        keyframeStateManager.tangentAlignmentEnabled.invert();
+    }
+
+    if (keys[keyType.controlKey].is_down) {
+        if (keys[keyType.undoSecondaryKey].is_down) {
+            keyframeStateManager.observedActiveKeyframe.set(keyframeStateManager.NULL_KEYFRAME);
+            actionProcessor.undo();
+        }
+
+        if (keys[keyType.redoSecondaryKey].is_down) {
+            keyframeStateManager.observedActiveKeyframe.set(keyframeStateManager.NULL_KEYFRAME);
+            actionProcessor.redo();
+        }
+
+        if (keys[keyType.saveSecondaryKey].is_down) {
+            event.preventDefault(); // prevent browser save dialog
+            const data = JSON.stringify(curve)
+            downloadAsFile(data, "curve.json")
+            // console.log(`${data}`)
+        }
+    }
+}
+
+/**
+ *
+ * @param {MouseEvent} e
+ * @param {CanvasView} graph
+ * @param {KeyboardDevice} keyboardElement
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function handleMouseDownEvents(e, graph, keyboardElement, actionProcessor, actionProcessorCTX, keyframeStateManager) {
+    const isClickedOnGraph = e.target === graph.el;
+    const isSelectionKeyHeld = keyboardElement.keys[keyType.holdSelectionKey].is_down;
+
+    applyGlobalKeyframeDeselection(isClickedOnGraph, isSelectionKeyHeld, actionProcessor, actionProcessorCTX, keyframeStateManager);
+}
+
+export function handleMouseDoubleClickEvents(e, vContainer, graph, frame, margin, curve, validEditableBounds, actionProcessor, actionProcessorCTX) {
+    const mousePosition = new Vector2();
+    readPositionFromMouseEvent(mousePosition, e, vContainer.el);
+
+    const newKeyframe = new Keyframe();
+
+    if (isInjectedKeyframeInBounds(graph, frame, margin, curve, validEditableBounds, mousePosition, newKeyframe)) {
+        actionProcessor.mark('add keyframe');
+        actionProcessor.do(new AddKeyframeAction(newKeyframe, actionProcessorCTX))
+    }
+}
+
+/**
+ *
+ * @param {KeyboardDevice} keyboardElement
+ * @param {Keyframe} keyframe
+ * @param {ActionProcessor} actionProcessor
+ * @param {keyframesContext} actionProcessorCTX
+ * @param {KeyframeStateManager} keyframeStateManager
+ */
+export function handleKeyframeSelectedByDevice(keyboardElement, keyframe, actionProcessor, actionProcessorCTX, keyframeStateManager) {
+    const isSelectionKeyHeld = keyboardElement.keys[keyType.holdSelectionKey].is_down;
+    const isKeyframeNotInSelection = !keyframeStateManager.curKeyframeList.find(kf => kf === keyframe);
+    const isActiveKeyframeNotInSelection = !keyframeStateManager.curKeyframeList.find(kf => kf === keyframeStateManager.observedActiveKeyframe.get());
+
+    keyframeStateManager.prevKeyframeList.copy(keyframeStateManager.selectedKeyframes);
+    keyframeStateManager.curKeyframeList.copy(keyframeStateManager.selectedKeyframes);
+
+    if (isSelectionKeyHeld) {
+        if (isKeyframeNotInSelection) {
+            if (isActiveKeyframeNotInSelection)
+                keyframeStateManager.curKeyframeList.add(keyframeStateManager.observedActiveKeyframe.get());
+
+            keyframeStateManager.curKeyframeList.add(keyframe);
+            applyActionSelection('Selection', keyframeStateManager, actionProcessor, actionProcessorCTX);
+        } else {
+            keyframeStateManager.curKeyframeList.removeIf(k => k === keyframe);
+            applyActionSelection('Deselection', keyframeStateManager, actionProcessor, actionProcessorCTX);
+        }
+    } else {
+        keyframeStateManager.tangentAlignmentEnabled.setFalse();
+        keyframeStateManager.observedActiveKeyframe.set(keyframe);
+
+        if (isKeyframeNotInSelection) {
+            keyframeStateManager.curKeyframeList.reset();
+            applyActionSelection('Deselection', keyframeStateManager, actionProcessor, actionProcessorCTX);
+        }
+    }
+}

package/src/engine/animation/curve/editor/uiContext.d.ts

@@ -0,0 +1,10 @@
+export class UIContext {
+    constructor(curve: any, size: any, margin: any);
+    curve: any;
+    margin: any;
+    graph: CanvasView;
+    frame: AABB2;
+}
+import { CanvasView } from "../../../../view/elements/CanvasView.js";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+//# sourceMappingURL=uiContext.d.ts.map

package/src/engine/animation/curve/editor/uiContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uiContext.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/uiContext.js"],"names":[],"mappings":"AAGA;IAEI,gDAWC;IATG,WAAkB;IAElB,YAAoB;IAEpB,kBAA6B;IAG7B,aAAwB;CAG/B;2BAjBwB,yCAAyC;kBAChD,wCAAwC"}

package/src/engine/animation/curve/editor/uiContext.js

@@ -0,0 +1,18 @@
+import {CanvasView} from "../../../../view/elements/CanvasView.js";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+
+export class UIContext{
+
+    constructor(curve, size, margin){
+
+        this.curve = curve
+
+        this.margin = margin
+
+        this.graph = new CanvasView();
+        this.graph.size.copy(size)
+
+        this.frame = new AABB2();
+
+    }
+}

package/src/engine/animation/curve/editor/updateAxisRange.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  Modify the axis start and end value based on given scaling
+ * @param {number} axisLength
+ * @param {number} cursorToGraphPos
+ * @param {number} axisStart
+ * @param {number} axisEnd
+ * @param {number} scaling
+ * @returns {(number|*)[]}
+ */
+export function updateAxisRange(axisLength: number, cursorToGraphPos: number, axisStart: number, axisEnd: number, scaling: number): (number | any)[];
+//# sourceMappingURL=updateAxisRange.d.ts.map

package/src/engine/animation/curve/editor/updateAxisRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateAxisRange.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/updateAxisRange.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,4CAPW,MAAM,oBACN,MAAM,aACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,CAAC,MAAM,MAAE,CAAC,EAAE,CAaxB"}

package/src/engine/animation/curve/editor/updateAxisRange.js

@@ -0,0 +1,23 @@
+
+
+/**
+ *  Modify the axis start and end value based on given scaling
+ * @param {number} axisLength
+ * @param {number} cursorToGraphPos
+ * @param {number} axisStart
+ * @param {number} axisEnd
+ * @param {number} scaling
+ * @returns {(number|*)[]}
+ */
+export function updateAxisRange(axisLength,cursorToGraphPos, axisStart, axisEnd, scaling){
+
+    let axisRange = axisEnd - axisStart;
+    const ratioCursorToGraphX = cursorToGraphPos / axisLength;
+    const axisCentre = axisStart + (ratioCursorToGraphX * axisRange);
+
+    axisRange = (axisEnd - axisStart) / scaling;
+    axisStart = axisCentre - (ratioCursorToGraphX * axisRange);
+    axisEnd = axisCentre + (1 - ratioCursorToGraphX) * axisRange;
+
+    return [axisStart, axisEnd];
+}

package/src/engine/animation/curve/editor/updateKeyframePosition.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {Keyframe} selectedKeyframe
+ * @param {Vector2} deltaPosition
+ * @param {AnimationCurve} curve
+ */
+export function updateKeyframePosition(selectedKeyframe: Keyframe, deltaPosition: Vector2, curve: AnimationCurve): void;
+import Vector2 from "../../../../core/geom/Vector2.js";
+//# sourceMappingURL=updateKeyframePosition.d.ts.map

package/src/engine/animation/curve/editor/updateKeyframePosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateKeyframePosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/updateKeyframePosition.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yDAJW,QAAQ,iBACR,OAAO,+BAOjB;oBAZmB,kCAAkC"}

package/src/engine/animation/curve/editor/updateKeyframePosition.js

@@ -0,0 +1,38 @@
+import Vector2 from "../../../../core/geom/Vector2.js";
+
+/**
+ *
+ * @param {Keyframe} selectedKeyframe
+ * @param {Vector2} deltaPosition
+ * @param {AnimationCurve} curve
+ */
+export function updateKeyframePosition(selectedKeyframe, deltaPosition, curve) {
+    selectedKeyframe.time += deltaPosition.x;
+    selectedKeyframe.value += deltaPosition.y;
+    updateKeyFrameIndexes(curve, selectedKeyframe);
+}
+
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {Keyframe} keyframe
+ */
+function updateKeyFrameIndexes(curve, keyframe) {
+    let keyframeIndex = curve.keys.indexOf(keyframe);
+
+    if (keyframeIndex < (curve.keys.length - 1) && keyframe.time > curve.keys[keyframeIndex + 1].time) {
+        const nextIndex = keyframeIndex + 1;
+        const next = curve.keys[nextIndex];
+
+        curve.keys[nextIndex] = keyframe;
+        curve.keys[keyframeIndex] = next;
+
+    } else if (keyframeIndex > 0 && keyframe.time < curve.keys[keyframeIndex - 1].time) {
+        const prevIndex = keyframeIndex - 1;
+        const prev = curve.keys[prevIndex];
+
+        curve.keys[prevIndex] = keyframe;
+        curve.keys[keyframeIndex] = prev;
+
+    }
+}

package/src/engine/animation/curve/editor/updateMarkerPosition.d.ts

@@ -0,0 +1,2 @@
+export function updateMarkerPosition(graph: any, frame: any, margin: any, keyframe: any, vContainerMarker: any): void;
+//# sourceMappingURL=updateMarkerPosition.d.ts.map

package/src/engine/animation/curve/editor/updateMarkerPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateMarkerPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/updateMarkerPosition.js"],"names":[],"mappings":"AAEA,sHASC"}

package/src/engine/animation/curve/editor/updateMarkerPosition.js

@@ -0,0 +1,12 @@
+import {position_curve_to_canvas} from "../draw/position_curve_to_canvas.js";
+
+export function updateMarkerPosition(graph, frame, margin, keyframe, vContainerMarker) {
+    const canvasCoordinates = position_curve_to_canvas(
+        graph.size,
+        frame,
+        margin,
+        keyframe.time,
+        keyframe.value
+    );
+    vContainerMarker.position.copy(canvasCoordinates);
+}

package/src/engine/animation/curve/editor/updateMarkerVisual.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {Keyframe} keyframe
+ * @param {EmptyView} vTangentEditor
+ * @param {View} marker
+ */
+export function updateMarkerVisual(keyframeStateManager: KeyframeStateManager, keyframe: Keyframe, vTangentEditor: EmptyView, marker: View): void;
+//# sourceMappingURL=updateMarkerVisual.d.ts.map

package/src/engine/animation/curve/editor/updateMarkerVisual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateMarkerVisual.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/updateMarkerVisual.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,yFAJW,QAAQ,iDAalB"}

package/src/engine/animation/curve/editor/updateMarkerVisual.js

@@ -0,0 +1,53 @@
+/**
+ *
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {Keyframe} keyframe
+ * @param {EmptyView} vTangentEditor
+ * @param {View} marker
+ */
+export function updateMarkerVisual(keyframeStateManager, keyframe, vTangentEditor, marker) {
+    const markerView = keyframeStateManager.keyframeViews.get(keyframe);
+    const markerColour = getKeyframeMarkerColour(keyframeStateManager, keyframe);
+
+    updateTangentMarker(keyframeStateManager, keyframe, markerView, vTangentEditor)
+
+    marker.css({
+        background: markerColour
+    });
+}
+
+/**
+ * Acquire the pre-defined colour for marker(keyframe) based on the keyframe selection state
+ * @param {KeyframeStateManager} keyframeStateManager
+ * @param {Keyframe} keyframe
+ * @returns {string}
+ */
+function getKeyframeMarkerColour(keyframeStateManager, keyframe) {
+    const activeKeyframe = keyframeStateManager.observedActiveKeyframe;
+    const selectedKeyframes = keyframeStateManager.selectedKeyframes;
+
+    if (activeKeyframe.get() === keyframe) {
+        return '#FFFFFF'
+    } else if (selectedKeyframes.find(kf => kf === keyframe)) {
+        return '#B700FFFF'
+    } else {
+        return '#00ff00'
+    }
+}
+
+function updateTangentMarker(keyframeStateManager, keyframe, markerView, vTangentEditor) {
+    const activeKeyframe = keyframeStateManager.observedActiveKeyframe;
+    const selectedKeyframes = keyframeStateManager.selectedKeyframes;
+
+    if (activeKeyframe.get() === keyframe) {
+        if (!markerView.hasChild(vTangentEditor))
+            markerView.addChild(vTangentEditor);
+    } else if (selectedKeyframes.find(kf => kf === keyframe)) { //Todo remove if covered by else condition
+        if (markerView.hasChild(vTangentEditor))
+            markerView.removeChild(vTangentEditor);
+    } else {
+        if (markerView.hasChild(vTangentEditor))
+            markerView.removeChild(vTangentEditor);
+    }
+}
+

package/src/engine/animation/curve/editor/uploadViaElement.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Attaches drag & drop to an element
+ * @param {HTMLElement} el
+ * @param {(data: any) => void} data
+ */
+export function uploadViaElement(el: HTMLElement, data: (data: any) => void): void;
+//# sourceMappingURL=uploadViaElement.d.ts.map

package/src/engine/animation/curve/editor/uploadViaElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadViaElement.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/uploadViaElement.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,qCAHW,WAAW,eACJ,GAAG,KAAK,IAAI,QA6B7B"}

package/src/engine/animation/curve/editor/uploadViaElement.js

@@ -0,0 +1,35 @@
+import {DragEvents} from "../../../input/devices/events/DragEvents.js";
+
+/**
+ * Attaches drag & drop to an element
+ * @param {HTMLElement} el
+ * @param {(data: any) => void} data
+ */
+export function uploadViaElement(el, data) {
+    if (!el) throw new Error("Element is required");
+
+    el.addEventListener(DragEvents.DragOver, (e) => {
+        // console.log("dragging over element");
+        e.preventDefault(); // prevent browser from opening file
+    });
+
+    el.addEventListener(DragEvents.Drop, (e) => {
+        e.preventDefault();
+
+        const file = e.dataTransfer.files[0];
+        if (!file) return;
+
+        const reader = new FileReader();
+        reader.readAsText(file);
+        reader.onload = () => {
+            try {
+                const text = String(reader.result).replace(/^\uFEFF/, '').trim();
+                data(text);
+                // console.log("Imported data: ", text);
+
+            } catch (err) {
+                console.error("Error reading file: ", err);
+            }
+        };
+    });
+}

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

@@ -1,9 +0,0 @@
-/**
- *
- * @param {AnimationCurve} curve
- * @param {Vector2} [size]
- * @param {Vector2} [margin] How much space to leave empty around the plotted bounds
- * @returns {View}
- */
-export function build_curve_editor({ curve, size, margin }: AnimationCurve): View;
-//# sourceMappingURL=build_curve_editor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"build_curve_editor.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/build_curve_editor.js"],"names":[],"mappings":"AAiEA;;;;;;GAMG;AACH,kFAiSC"}