Add set upVector and other interface in orbit cameracontroller

Default mouse operations like zoom, translate, rotate etc. are
irational when camera upVector is not (0,1,0).
In order to solve this problem, setUpVector and some interface
about inverse directions are added.

Change-Id: I4aacf9928e3f1fcbe382f43133531374fe98f7fe
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

3 files changed, 149 insertions, 9 deletions

diff --git a/src/extras/defaults/qorbitcameracontroller.cpp b/src/extras/defaults/qorbitcameracontroller.cpp
index 92b59e46c..f8887deb3 100644
--- a/src/extras/defaults/qorbitcameracontroller.cpp
+++ b/src/extras/defaults/qorbitcameracontroller.cpp
@@ -12,6 +12,12 @@ namespace Qt3DExtras {
 
 QOrbitCameraControllerPrivate::QOrbitCameraControllerPrivate()
     : m_zoomInLimit(2.0f)
+    , m_upVector(0.0f, 1.0f, 0.0f)
+    , m_inverseXTranslate(false)
+    , m_inverseYTranslate(false)
+    , m_inversePan(false)
+    , m_inverseTilt(false)
+    , m_zoomTranslateViewCenter(true)
 {}
 
 /*!
@@ -100,6 +106,95 @@ void QOrbitCameraController::setZoomInLimit(float zoomInLimit)
     }
 }
 
+QVector3D QOrbitCameraController::upVector() const {
+    Q_D(const QOrbitCameraController);
+    return d->m_upVector;
+}
+
+void QOrbitCameraController::setUpVector(const QVector3D& upVector)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_upVector != upVector) {
+        d->m_upVector = upVector;
+        emit upVectorChanged(d->m_upVector);
+    }
+}
+
+bool QOrbitCameraController::inverseXTranslate() const
+{
+    Q_D(const QOrbitCameraController);
+    return d->m_inverseXTranslate;
+}
+
+void QOrbitCameraController::setInverseXTranslate(bool isInverse)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_inverseXTranslate != isInverse) {
+        d->m_inverseXTranslate = isInverse;
+        emit inverseXTranslateChanged(d->m_inverseXTranslate);
+    }
+}
+
+bool QOrbitCameraController::inverseYTranslate() const
+{
+    Q_D(const QOrbitCameraController);
+    return d->m_inverseYTranslate;
+}
+
+void QOrbitCameraController::setInverseYTranslate(bool isInverse)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_inverseYTranslate != isInverse) {
+        d->m_inverseYTranslate = isInverse;
+        emit inverseYTranslateChanged(d->m_inverseYTranslate);
+    }
+}
+
+bool QOrbitCameraController::inversePan() const
+{
+    Q_D(const QOrbitCameraController);
+    return d->m_inversePan;
+}
+
+void QOrbitCameraController::setInversePan(bool isInverse)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_inversePan != isInverse) {
+        d->m_inversePan = isInverse;
+        emit inversePanChanged(d->m_inversePan);
+    }
+}
+
+bool QOrbitCameraController::inverseTilt() const
+{
+    Q_D(const QOrbitCameraController);
+    return d->m_inverseTilt;
+}
+
+void QOrbitCameraController::setInverseTilt(bool isInverse)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_inverseTilt != isInverse) {
+        d->m_inverseTilt = isInverse;
+        emit inverseTiltChanged(d->m_inverseTilt);
+    }
+}
+
+bool QOrbitCameraController::zoomTranslateViewCenter() const
+{
+    Q_D(const QOrbitCameraController);
+    return d->m_zoomTranslateViewCenter;
+}
+
+void QOrbitCameraController::setZoomTranslateViewCenter(bool isTranslate)
+{
+    Q_D(QOrbitCameraController);
+    if (d->m_zoomTranslateViewCenter != isTranslate) {
+        d->m_zoomTranslateViewCenter = isTranslate;
+        emit zoomTranslateViewCenterChanged(d->m_zoomTranslateViewCenter);
+    }
+}
+
 inline float clampInputs(float input1, float input2)
 {
     float axisValue = input1 + input2;
@@ -120,8 +215,6 @@ void QOrbitCameraController::moveCamera(const QAbstractCameraController::InputSt
     if (theCamera == nullptr)
         return;
 
-    const QVector3D upVector(0.0f, 1.0f, 0.0f);
-
     // Mouse input
     if (state.leftMouseButtonActive) {
         if (state.rightMouseButtonActive) {
@@ -133,22 +226,22 @@ void QOrbitCameraController::moveCamera(const QAbstractCameraController::InputSt
             }
         } else {
             // Translate
-            theCamera->translate(QVector3D(clampInputs(state.rxAxisValue, state.txAxisValue) * linearSpeed(),
-                                          clampInputs(state.ryAxisValue, state.tyAxisValue) * linearSpeed(),
-                                          0) * dt);
+            theCamera->translate(QVector3D((d->m_inverseXTranslate ? -1.0f : 1.0f) * clampInputs(state.rxAxisValue, state.txAxisValue) * linearSpeed(),
+                                           (d->m_inverseYTranslate ? -1.0f : 1.0f) * clampInputs(state.ryAxisValue, state.tyAxisValue) * linearSpeed(),
+                                           0) * dt);
         }
         return;
     }
     else if (state.rightMouseButtonActive) {
         // Orbit
-        theCamera->panAboutViewCenter((state.rxAxisValue * lookSpeed()) * dt, upVector);
-        theCamera->tiltAboutViewCenter((state.ryAxisValue * lookSpeed()) * dt);
+        theCamera->panAboutViewCenter((d->m_inversePan ? -1.0f : 1.0f) * (state.rxAxisValue * lookSpeed()) * dt, d->m_upVector);
+        theCamera->tiltAboutViewCenter((d->m_inverseTilt ? -1.0f : 1.0f) * (state.ryAxisValue * lookSpeed()) * dt);
     }
 
     // Keyboard Input
     if (state.altKeyActive) {
         // Orbit
-        theCamera->panAboutViewCenter((state.txAxisValue * lookSpeed()) * dt, upVector);
+        theCamera->panAboutViewCenter((state.txAxisValue * lookSpeed()) * dt, d->m_upVector);
         theCamera->tiltAboutViewCenter((state.tyAxisValue * lookSpeed()) * dt);
     } else if (state.shiftKeyActive) {
         if (zoomDistance(camera()->position(), theCamera->viewCenter()) > d->m_zoomInLimit * d->m_zoomInLimit) {
@@ -161,7 +254,8 @@ void QOrbitCameraController::moveCamera(const QAbstractCameraController::InputSt
         // Translate
         theCamera->translate(QVector3D(clampInputs(state.leftMouseButtonActive ? state.rxAxisValue : 0, state.txAxisValue) * linearSpeed(),
                                       clampInputs(state.leftMouseButtonActive ? state.ryAxisValue : 0, state.tyAxisValue) * linearSpeed(),
-                                      state.tzAxisValue * linearSpeed()) * dt);
+                                      state.tzAxisValue * linearSpeed()) * dt,
+                             d->m_zoomTranslateViewCenter ? theCamera->TranslateViewCenter : theCamera->DontTranslateViewCenter);
     }
 }
 
diff --git a/src/extras/defaults/qorbitcameracontroller.h b/src/extras/defaults/qorbitcameracontroller.h
index 09731c8d9..2cb2f6f3d 100644
--- a/src/extras/defaults/qorbitcameracontroller.h
+++ b/src/extras/defaults/qorbitcameracontroller.h
@@ -16,6 +16,12 @@ class Q_3DEXTRASSHARED_EXPORT QOrbitCameraController : public QAbstractCameraCon
 {
     Q_OBJECT
     Q_PROPERTY(float zoomInLimit READ zoomInLimit WRITE setZoomInLimit NOTIFY zoomInLimitChanged)
+    Q_PROPERTY(QVector3D upVector READ upVector WRITE setUpVector NOTIFY upVectorChanged)
+    Q_PROPERTY(bool inverseXTranslate READ inverseXTranslate WRITE setInverseXTranslate NOTIFY inverseXTranslateChanged)
+    Q_PROPERTY(bool inverseYTranslate READ inverseYTranslate WRITE setInverseYTranslate NOTIFY inverseYTranslateChanged)
+    Q_PROPERTY(bool inversePan READ inversePan WRITE setInversePan NOTIFY inversePanChanged)
+    Q_PROPERTY(bool inverseTilt READ inverseTilt WRITE setInverseTilt NOTIFY inverseTiltChanged)
+    Q_PROPERTY(bool zoomTranslateViewCenter READ zoomTranslateViewCenter WRITE setZoomTranslateViewCenter NOTIFY zoomTranslateViewCenterChanged)
 
 public:
     explicit QOrbitCameraController(Qt3DCore::QNode *parent = nullptr);
@@ -25,9 +31,45 @@ public:
 
     void setZoomInLimit(float zoomInLimit);
 
+    QVector3D upVector() const;
+
+    void setUpVector(const QVector3D& upVector);
+
+    bool inverseXTranslate() const;
+
+    void setInverseXTranslate(bool isInverse);
+
+    bool inverseYTranslate() const;
+
+    void setInverseYTranslate(bool isInverse);
+
+    bool inversePan() const;
+
+    void setInversePan(bool isInverse);
+
+    bool inverseTilt() const;
+
+    void setInverseTilt(bool isInverse);
+
+    bool zoomTranslateViewCenter() const;
+
+    void setZoomTranslateViewCenter(bool isTranslate);
+
 Q_SIGNALS:
     void zoomInLimitChanged();
 
+    void upVectorChanged(const QVector3D &upVector);
+
+    void inverseXTranslateChanged(bool isInverse);
+
+    void inverseYTranslateChanged(bool isInverse);
+
+    void inversePanChanged(bool isInverse);
+
+    void inverseTiltChanged(bool isInverse);
+
+    void zoomTranslateViewCenterChanged(bool isTranslate);
+
 protected:
     QOrbitCameraController(QOrbitCameraControllerPrivate &dd, Qt3DCore::QNode *parent = nullptr);
 
diff --git a/src/extras/defaults/qorbitcameracontroller_p.h b/src/extras/defaults/qorbitcameracontroller_p.h
index 602fad90f..720ed90b6 100644
--- a/src/extras/defaults/qorbitcameracontroller_p.h
+++ b/src/extras/defaults/qorbitcameracontroller_p.h
@@ -31,6 +31,10 @@ public:
     void init();
 
     float m_zoomInLimit;
+    QVector3D m_upVector;
+    bool m_inverseXTranslate, m_inverseYTranslate;
+    bool m_inversePan, m_inverseTilt;
+    bool m_zoomTranslateViewCenter;
 
 private:
     QOrbitCameraController *q_ptr;