add node tangent snapping every 15 degrees, it works for nodes and for keyframe nodes (timeline Graph)

Author: pgilfernandez

src/app/GUI/keysview.cpp

@@ -42,6 +42,8 @@
 #include "timelinehighlightwidget.h"
 #include "GUI/dialogsinterface.h"
 #include "themesupport.h"
+#include <QtMath>
+#include <cmath>
 
 KeysView::KeysView(BoxScrollWidget *boxesListVisible,
                    QWidget *parent) :
@@ -792,7 +794,9 @@ void KeysView::handleMouseMove(const QPoint &pos,
             dFrame = dX/mPixelsPerFrame;
             mValueInput.setDisplayedValue(dFrame);
         }
+        const auto mods = QApplication::keyboardModifiers();
         const bool ctrlPt = mGPressedPoint && mGPressedPoint->isCtrlPt();
+        const bool shiftPressed = mods & Qt::ShiftModifier;
         if(!ctrlPt) dFrame = round(dFrame);
         const qreal dDFrame = dFrame - mMoveDFrame;
         const int iDDFrame = qRound(dDFrame);
@@ -809,8 +813,31 @@ void KeysView::handleMouseMove(const QPoint &pos,
             const QPointF saved = mGPressedPoint->getSavedFrameAndValue();
             const qreal rawFrame = saved.x() + dFrameV;
             const qreal rawValue = saved.y() + dValue;
-            const qreal newFrame = qBound(mMinMoveFrame, rawFrame, mMaxMoveFrame);
-            const qreal newValue = qBound(mMinMoveVal, rawValue, mMaxMoveVal);
+            qreal newFrame = qBound(mMinMoveFrame, rawFrame, mMaxMoveFrame);
+            qreal newValue = qBound(mMinMoveVal, rawValue, mMaxMoveVal);
+            if(shiftPressed) {
+                if(const auto parentKey = mGPressedPoint->getParentKey()) {
+                    const qreal keyFrame = parentKey->getRelFrame();
+                    const qreal keyValue = parentKey->getValueForGraph();
+                    const qreal dx = newFrame - keyFrame;
+                    const qreal dy = newValue - keyValue;
+                    const qreal dxPx = dx * mPixelsPerFrame;
+                    const qreal dyPx = -dy * mPixelsPerValUnit;
+                    const qreal lengthPx = qSqrt(dxPx*dxPx + dyPx*dyPx);
+                    if(lengthPx > 0.0) {
+                        constexpr qreal snapStep = 15.0;
+                        const qreal angleDeg = qRadiansToDegrees(qAtan2(dyPx, dxPx));
+                        const qreal snappedDeg = std::round(angleDeg / snapStep) * snapStep;
+                        const qreal snappedRad = qDegreesToRadians(snappedDeg);
+                        const qreal snappedDxPx = lengthPx * qCos(snappedRad);
+                        const qreal snappedDyPx = lengthPx * qSin(snappedRad);
+                        newFrame = keyFrame + snappedDxPx / mPixelsPerFrame;
+                        newValue = keyValue - snappedDyPx / mPixelsPerValUnit;
+                    }
+                }
+            }
+            newFrame = qBound(mMinMoveFrame, newFrame, mMaxMoveFrame);
+            newValue = qBound(mMinMoveVal, newValue, mMaxMoveVal);
             mGPressedPoint->setFrameAndValue(newFrame, newValue,
                                              mPixelsPerFrame,
                                              mPixelsPerValUnit);

src/core/MovablePoints/smartctrlpoint.h

@@ -35,6 +35,7 @@ class CORE_EXPORT SmartCtrlPoint : public NonAnimatedMovablePoint {
     SmartCtrlPoint(SmartNodePoint * const parentPoint,
                    const Type &type);
 public:
+    SmartNodePoint* getParentPoint() const { return mParentPoint_k; }
     void drawSk(SkCanvas* const canvas,
                 const CanvasMode mode,
                 const float invScale,

src/core/canvas.cpp

@@ -1219,6 +1219,7 @@ bool Canvas::startScalingAction(const eKeyEvent &e)
     }
     mValueInput.clearAndDisableInput();
     mValueInput.setupScale();
+    mLastPointMoveBy = QPointF();
 
     mRotPivot->setMousePos(e.fPos);
     mTransMode = TransformMode::scale;
@@ -1234,6 +1235,7 @@ bool Canvas::startMovingAction(const eKeyEvent &e)
         mCurrentMode != CanvasMode::pointTransform) { return false; }
     mValueInput.clearAndDisableInput();
     mValueInput.setupMove();
+    mLastPointMoveBy = QPointF();
 
     mTransMode = TransformMode::move;
     mDoubleClick = false;

src/core/canvas.h

@@ -908,6 +908,7 @@ class CORE_EXPORT Canvas : public CanvasBase
     bool mStartTransform = false;
     bool mSelecting = false;
 //    bool mMoving = false;
+    QPointF mLastPointMoveBy;
 
     QRectF mSelectionRect;
     CanvasMode mCurrentMode = CanvasMode::boxTransform;

src/core/canvasmouseinteractions.cpp

@@ -61,6 +61,11 @@
 
 using namespace Friction::Core;
 
+namespace {
+constexpr qreal kDegToRad = static_cast<qreal>(0.017453292519943295769);
+constexpr qreal kRadToDeg = static_cast<qreal>(57.2957795130823208768);
+}
+
 void Canvas::handleMovePathMousePressEvent(const eMouseEvent& e) {
     mPressedBox = mCurrentContainer->getBoxAt(e.fPos);
     if(e.shiftMod()) return;
@@ -209,6 +214,7 @@ void Canvas::handleLeftButtonMousePress(const eMouseEvent& e) {
     mDoubleClick = false;
     //mMovesToSkip = 2;
     mStartTransform = true;
+    mLastPointMoveBy = QPointF();
 
     const qreal invScale = 1/e.fScale;
     const qreal invScaleUi = (qApp ? qApp->devicePixelRatio() : 1.0) * invScale;
@@ -726,14 +732,46 @@ void Canvas::handleMovePointMouseMove(const eMouseEvent &e) {
                 }
             }
 
+            const QPointF moveBy = getMoveByValueForEvent(e);
+            QPointF finalMoveBy = moveBy;
+            if((mods & Qt::ShiftModifier) && mPressedPoint->isCtrlPoint()) {
+                const auto ctrlPoint = enve_cast<SmartCtrlPoint*>(mPressedPoint.data());
+                if(ctrlPoint) {
+                    const auto parentPoint = ctrlPoint->getParentPoint();
+                    if(parentPoint) {
+                        const QPointF parentAbs = parentPoint->getAbsolutePos();
+                        const QPointF startAbs = ctrlPoint->getAbsolutePos() - mLastPointMoveBy;
+                        QPointF targetAbs = startAbs + moveBy;
+                        const QPointF dir = targetAbs - parentAbs;
+                        const qreal len = pointToLen(dir);
+                        if(len > 0.0) {
+                            constexpr qreal snapStep = 15.0;
+                            const qreal angleDeg = std::atan2(dir.y(), dir.x()) * kRadToDeg;
+                            const qreal snappedDeg = std::round(angleDeg / snapStep) * snapStep;
+                            const qreal snappedRad = snappedDeg * kDegToRad;
+                            const QPointF snappedVec(len * std::cos(snappedRad),
+                                                     len * std::sin(snappedRad));
+                            targetAbs = parentAbs + snappedVec;
+                            finalMoveBy = targetAbs - startAbs;
+                        }
+                    }
+                }
+            }
+
             if(!mPressedPoint->selectionEnabled()) {
                 if(mStartTransform) mPressedPoint->startTransform();
-                mPressedPoint->moveByAbs(getMoveByValueForEvent(e));
+                mPressedPoint->moveByAbs(finalMoveBy);
+                mLastPointMoveBy = finalMoveBy;
                 return;
             }
+            moveSelectedPointsByAbs(finalMoveBy,
+                                    mStartTransform);
+            mLastPointMoveBy = finalMoveBy;
+        } else {
+            const QPointF moveBy = getMoveByValueForEvent(e);
+            moveSelectedPointsByAbs(moveBy, mStartTransform);
+            mLastPointMoveBy = moveBy;
         }
-        moveSelectedPointsByAbs(getMoveByValueForEvent(e),
-                                mStartTransform);
     }
 }
 
@@ -872,6 +910,7 @@ bool Canvas::prepareRotation(const QPointF &startPos,
     mTransMode = TransformMode::rotate;
     mRotHalfCycles = 0;
     mLastDRot = 0;
+    mLastPointMoveBy = QPointF();
 
     mDoubleClick = false;
     mStartTransform = true;