qgscameracontroller.h

Go to the documentation of this file.

/***************************************************************************
  qgscameracontroller.h
  --------------------------------------
  Date                 : July 2017
  Copyright            : (C) 2017 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSCAMERACONTROLLER_H
#define QGSCAMERACONTROLLER_H
 
#include "qgis_3d.h"
#include "qgscamerapose.h"
#include "qgscoordinatetransform.h"
 
#include <Qt3DCore/QEntity>
#include <Qt3DInput/QMouseEvent>
#include <QImage>
 
#ifndef SIP_RUN
namespace Qt3DInput
{
  class QKeyEvent;
  class QKeyboardHandler;
  class QMouseEvent;
  class QMouseHandler;
  class QWheelEvent;
} // namespace Qt3DInput
 
namespace Qt3DRender
{
  class QCamera;
}
 
#endif
 
class QDomDocument;
class QDomElement;
 
class QgsCameraPose;
class QgsVector3D;
class QgsWindow3DEngine;
class Qgs3DMapScene;
 
#ifndef SIP_RUN
class _3D_EXPORT QgsCameraController : public Qt3DCore::QEntity
{
#else
class _3D_EXPORT QgsCameraController : public QObject
{
#endif
 
    Q_OBJECT
  public:
    QgsCameraController( Qgs3DMapScene *scene ) SIP_SKIP;
    ~QgsCameraController() override;
 
#ifndef SIP_RUN
 
    Qt3DRender::QCamera *camera() const { return mCamera; }
#endif
 
    Qgis::NavigationMode cameraNavigationMode() const { return mCameraNavigationMode; }
 
    double cameraMovementSpeed() const { return mCameraMovementSpeed; }
 
    void setCameraMovementSpeed( double movementSpeed );
 
    Qgis::VerticalAxisInversion verticalAxisInversion() const { return mVerticalAxisInversion; }
 
    void setVerticalAxisInversion( Qgis::VerticalAxisInversion inversion );
 
    void frameTriggered( float dt );
 
    void resetView( float distance );
 
    void setViewFromTop( float worldX, float worldY, float distance, float yaw = 0 );
 
    QgsVector3D lookingAtPoint() const;
 
    void setLookingAtPoint( const QgsVector3D &point, float distance, float pitch, float yaw );
 
    QgsVector3D lookingAtMapPoint() const;
 
    void setLookingAtMapPoint( const QgsVector3D &point, float distance, float pitch, float yaw );
 
    void setCameraPose( const QgsCameraPose &camPose, bool force = false );
 
    QgsCameraPose cameraPose() const { return mCameraPose; }
 
    float distance() const { return mCameraPose.distanceFromCenterPoint(); }
 
    float pitch() const { return mCameraPose.pitchAngle(); }
 
    float yaw() const { return mCameraPose.headingAngle(); }
 
    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );
 
    void zoom( float factor );
    void tiltUpAroundViewCenter( float deltaPitch );
    void rotateAroundViewCenter( float deltaYaw );
    void setCameraHeadingAngle( float angle );
    void moveView( float tx, float ty );
 
    void walkView( double tx, double ty, double tz );
 
    void rotateCamera( float diffPitch, float diffYaw );
 
    void rotateCameraAroundPivot( float newPitch, float newHeading, const QVector3D &pivotPoint );
 
    void zoomCameraAroundPivot( const QVector3D &oldCameraPosition, double zoomFactor, const QVector3D &pivotPoint );
 
    bool willHandleKeyEvent( QKeyEvent *event );
 
    void setOrigin( const QgsVector3D &origin );
 
    void setInputHandlersEnabled( bool enable ) { mInputHandlersEnabled = enable; }
 
    bool hasInputHandlersEnabled() const { return mInputHandlersEnabled; }
 
    void globeMoveCenterPoint( double latDiff, double lonDiff );
 
    void globeZoom( float factor );
 
    void globeUpdatePitchAngle( float angleDiff );
 
    void globeUpdateHeadingAngle( float angleDiff );
 
    void resetGlobe( float distance, double lat = 0, double lon = 0 );
 
    const QgsVector3D origin() const { return mOrigin; }
 
  public slots:
 
    void setCameraNavigationMode( Qgis::NavigationMode navigationMode );
 
    void depthBufferCaptured( const QImage &depthImage );
 
  private:
#ifdef SIP_RUN
    QgsCameraController();
    QgsCameraController( const QgsCameraController &other );
#endif
 
    void updateCameraFromPose();
    void moveCameraPositionBy( const QVector3D &posDiff );
    QWindow *window() const;
 
    enum class MouseOperation
    {
      None = 0,       // no operation
      Translation,    // left button pressed, no modifier
      RotationCamera, // left button pressed + ctrl modifier
      RotationCenter, // left button pressed + shift modifier
      Zoom,           // right button pressed
      ZoomWheel       // mouse wheel scroll
    };
 
    // This list gathers all the rotation and translation operations.
    // It is used to update the appropriate parameters when successive
    // translation and rotation happen.
    const QList<MouseOperation> mTranslateOrRotate = {
      MouseOperation::Translation,
      MouseOperation::RotationCamera,
      MouseOperation::RotationCenter
    };
 
    // check that current sequence (current operation and new operation) is a rotation or translation
    bool isATranslationRotationSequence( MouseOperation newOperation ) const;
 
    void setMouseParameters( const MouseOperation &newOperation, const QPoint &clickPoint = QPoint() );
 
  signals:
    void cameraChanged();
 
    void navigationModeChanged( Qgis::NavigationMode mode );
 
    void cameraMovementSpeedChanged( double speed );
 
    void setCursorPosition( QPoint point );
 
    void requestDepthBufferCapture();
 
    void cameraRotationCenterChanged( QVector3D position );
 
  private slots:
    void onPositionChanged( Qt3DInput::QMouseEvent *mouse );
    void onWheel( Qt3DInput::QWheelEvent *wheel );
    void onMousePressed( Qt3DInput::QMouseEvent *mouse );
    void onMouseReleased( Qt3DInput::QMouseEvent *mouse );
    void onKeyPressed( Qt3DInput::QKeyEvent *event );
    void onKeyReleased( Qt3DInput::QKeyEvent *event );
    void applyFlyModeKeyMovements();
 
  private:
    void onKeyPressedFlyNavigation( Qt3DInput::QKeyEvent *event );
    void onKeyPressedTerrainNavigation( Qt3DInput::QKeyEvent *event );
    void onKeyPressedGlobeTerrainNavigation( Qt3DInput::QKeyEvent *event );
    void onPositionChangedFlyNavigation( Qt3DInput::QMouseEvent *mouse );
    void onPositionChangedTerrainNavigation( Qt3DInput::QMouseEvent *mouse );
    void onPositionChangedGlobeTerrainNavigation( Qt3DInput::QMouseEvent *mouse );
 
    void handleTerrainNavigationWheelZoom();
 
    double sampleDepthBuffer( int px, int py );
 
    // Returns the average depth of all non void pixels
    double depthBufferNonVoidAverage();
 
#ifndef SIP_RUN
    bool screenPointToWorldPos( QPoint position, Qt3DRender::QCamera *cameraBefore, double &depth, QVector3D &worldPosition );
#endif
 
    // Moves given point (in ECEF) by specified lat/lon angle difference (in degrees) and returns new ECEF point
    QgsVector3D moveGeocentricPoint( const QgsVector3D &point, double latDiff, double lonDiff );
 
    Qgs3DMapScene *mScene = nullptr;
 
    Qt3DRender::QCamera *mCamera = nullptr;
 
    QgsCameraPose mCameraPose;
 
    QPoint mMousePos;
 
    QPoint mClickPoint;
 
    bool mDepthBufferIsReady = false;
    QImage mDepthBufferImage;
    // -1 when unset
    // TODO: Change to std::optional<double>
    double mDepthBufferNonVoidAverage = -1;
 
    std::unique_ptr<Qt3DRender::QCamera> mCameraBefore;
 
    bool mRotationCenterCalculated = false;
    QVector3D mRotationCenter;
    double mRotationDistanceFromCenter = 0;
    float mRotationPitch = 0;
    float mRotationYaw = 0;
 
    bool mDragPointCalculated = false;
    QVector3D mDragPoint;
    double mDragDepth;
 
    bool mZoomPointCalculated = false;
    QVector3D mZoomPoint;
 
    // used for globe
    QgsVector3D mMousePressViewCenter;
    QgsCoordinateTransform mGlobeCrsToLatLon;
 
    Qt3DInput::QMouseHandler *mMouseHandler = nullptr;
    Qt3DInput::QKeyboardHandler *mKeyboardHandler = nullptr;
    bool mInputHandlersEnabled = true;
    Qgis::NavigationMode mCameraNavigationMode = Qgis::NavigationMode::TerrainBased;
    Qgis::VerticalAxisInversion mVerticalAxisInversion = Qgis::VerticalAxisInversion::WhenDragging;
    double mCameraMovementSpeed = 5.0;
 
    QSet<int> mDepressedKeys;
    bool mCaptureFpsMouseMovements = false;
    bool mIgnoreNextMouseMove = false;
    QTimer *mFpsNavTimer = nullptr;
 
    double mCumulatedWheelY = 0;
 
    MouseOperation mCurrentOperation = MouseOperation::None;
 
    // 3D world's origin in map coordinates
    QgsVector3D mOrigin;
 
    bool mCameraChanged = false;
 
    // To test the cameracontroller
    friend class TestQgs3DRendering;
    friend class TestQgs3DCameraController;
};
class _3D_EXPORT QgsCameraController : public Qt3DCore::QEntity {…};
 
#endif // QGSCAMERACONTROLLER_H