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 <QPointer>
#include <QRect>
#include <Qt3DCore/QEntity>
#include <Qt3DInput/QMouseEvent>
#include <QImage>
 
namespace Qt3DInput
{
  class QKeyEvent;
  class QKeyboardDevice;
  class QKeyboardHandler;
  class QMouseEvent;
  class QMouseDevice;
  class QMouseHandler;
  class QWheelEvent;
}
 
namespace Qt3DRender
{
  class QCamera;
  class QPickEvent;
}
 
#include "qgscamerapose.h"
 
class QDomDocument;
class QDomElement;
 
class QgsCameraPose;
class QgsTerrainEntity;
class QgsVector3D;
 
#define SIP_NO_FILE
 
class _3D_EXPORT QgsCameraController : public Qt3DCore::QEntity
{
    Q_OBJECT
    Q_PROPERTY( Qt3DRender::QCamera *camera READ camera WRITE setCamera NOTIFY cameraChanged )
    Q_PROPERTY( QRect viewport READ viewport WRITE setViewport NOTIFY viewportChanged )
  public:
 
    enum NavigationMode
    {
      TerrainBasedNavigation, 
      WalkNavigation 
    };
    Q_ENUM( NavigationMode )
 
    
    enum VerticalAxisInversion
    {
      Never, 
      WhenDragging, 
      Always, 
    };
    Q_ENUM( VerticalAxisInversion )
 
  public:
    QgsCameraController( Qt3DCore::QNode *parent = nullptr );
 
    Qt3DRender::QCamera *camera() const { return mCamera; }
    QRect viewport() const { return mViewport; }
 
    QgsCameraController::NavigationMode cameraNavigationMode() const { return mCameraNavigationMode; }
 
    double cameraMovementSpeed() const { return mCameraMovementSpeed; }
 
    void setCameraMovementSpeed( double movementSpeed );
 
    QgsCameraController::VerticalAxisInversion verticalAxisInversion() const { return mVerticalAxisInversion; }
 
    void setVerticalAxisInversion( QgsCameraController::VerticalAxisInversion inversion );
 
    void setTerrainEntity( QgsTerrainEntity *te );
 
    void setCamera( Qt3DRender::QCamera *camera );
    void setViewport( QRect viewport );
    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 );
 
    void setCameraPose( const QgsCameraPose &camPose );
 
    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 );
 
    bool willHandleKeyEvent( QKeyEvent *event );
 
  public slots:
 
    void setCameraNavigationMode( QgsCameraController::NavigationMode navigationMode );
 
    void depthBufferCaptured( const QImage &depthImage );
 
  private:
    void rotateCamera( float diffPitch, float diffYaw );
    void updateCameraFromPose();
    void moveCameraPositionBy( const QVector3D &posDiff );
 
  signals:
    void cameraChanged();
    void viewportChanged();
    void navigationModeChanged( QgsCameraController::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 onPickerMousePressed( Qt3DRender::QPickEvent *pick );
    void applyFlyModeKeyMovements();
 
  private:
    void onKeyPressedFlyNavigation( Qt3DInput::QKeyEvent *event );
    void onKeyPressedTerrainNavigation( Qt3DInput::QKeyEvent *event );
    void onPositionChangedFlyNavigation( Qt3DInput::QMouseEvent *mouse );
    void onPositionChangedTerrainNavigation( Qt3DInput::QMouseEvent *mouse );
 
    void handleTerrainNavigationWheelZoom();
 
    double sampleDepthBuffer( const QImage &buffer, int px, int py );
 
    bool screenPointToWorldPos( QPoint position, Qt3DRender::QCamera *cameraBefore, double &depth, QVector3D &worldPosition );
 
  private:
    Qt3DRender::QCamera *mCamera = nullptr;
    QRect mViewport;
    float mLastPressedHeight = 0;
 
    QPointer<QgsTerrainEntity> mTerrainEntity;
 
    QgsCameraPose mCameraPose;
 
    QPoint mMousePos;
    bool mMousePressed = false;
    Qt3DInput::QMouseEvent::Buttons mPressedButton = Qt3DInput::QMouseEvent::Buttons::NoButton;
 
    bool mDepthBufferIsReady = false;
    QImage mDepthBufferImage;
 
    QPoint mMiddleButtonClickPos;
    bool mRotationCenterCalculated = false;
    QVector3D mRotationCenter;
    double mRotationDistanceFromCenter;
    double mRotationPitch = 0;
    double mRotationYaw = 0;
    std::unique_ptr< Qt3DRender::QCamera > mCameraBeforeRotation;
 
    QPoint mDragButtonClickPos;
    std::unique_ptr< Qt3DRender::QCamera > mCameraBeforeDrag;
    bool mDragPointCalculated = false;
    QVector3D mDragPoint;
    double mDragDepth;
 
    bool mIsInZoomInState = false;
    std::unique_ptr< Qt3DRender::QCamera > mCameraBeforeZoom;
    bool mZoomPointCalculated = false;
    QVector3D mZoomPoint;
 
    Qt3DInput::QMouseDevice *mMouseDevice = nullptr;
    Qt3DInput::QKeyboardDevice *mKeyboardDevice = nullptr;
 
    Qt3DInput::QMouseHandler *mMouseHandler = nullptr;
    Qt3DInput::QKeyboardHandler *mKeyboardHandler = nullptr;
    NavigationMode mCameraNavigationMode = NavigationMode::TerrainBasedNavigation;
    VerticalAxisInversion mVerticalAxisInversion = WhenDragging;
    double mCameraMovementSpeed = 5.0;
 
    QSet< int > mDepressedKeys;
    bool mCaptureFpsMouseMovements = false;
    bool mIgnoreNextMouseMove = false;
    QTimer *mFpsNavTimer = nullptr;
 
    double mCumulatedWheelY = 0;
 
};
 
#endif // QGSCAMERACONTROLLER_H