StelMovementMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2007 Fabien Chereau
 * Copyright (C) 2015 Georg Zotti (offset view adaptations, Up vector fix for zenithal views)
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELMOVEMENTMGR_HPP_
#define _STELMOVEMENTMGR_HPP_

#include "StelModule.hpp"
#include "StelProjector.hpp"
#include "StelObjectType.hpp"
#include <QTimeLine>
#include <QCursor>

class StelMovementMgr : public StelModule
{
    Q_OBJECT
    Q_PROPERTY(bool equatorialMount
           READ getEquatorialMount
           WRITE setEquatorialMount
           NOTIFY equatorialMountChanged)
    Q_PROPERTY(bool tracking
           READ getFlagTracking
           WRITE setFlagTracking
           NOTIFY flagTrackingChanged)

    //The targets of viewport offset animation
    Q_PROPERTY(float viewportHorizontalOffsetTarget
           READ getViewportHorizontalOffsetTarget
           WRITE setViewportHorizontalOffsetTarget
           NOTIFY viewportHorizontalOffsetTargetChanged)
    Q_PROPERTY(float viewportVerticalOffsetTarget
           READ getViewportVerticalOffsetTarget
           WRITE setViewportVerticalOffsetTarget
           NOTIFY viewportVerticalOffsetTargetChanged)

    Q_PROPERTY(bool flagAutoZoomOutResetsDirection
           READ getFlagAutoZoomOutResetsDirection
           WRITE setFlagAutoZoomOutResetsDirection
           NOTIFY flagAutoZoomOutResetsDirectionChanged)
public:

    // TODO: add others: MountEcliptical, MountEq2000, MountEcliptical2000 and implement proper variants.
    enum MountMode { MountAltAzimuthal, MountEquinoxEquatorial, MountGalactic, MountSupergalactic};

    enum ZoomingMode { ZoomOut=-1, ZoomNone=0, ZoomIn=1};

    StelMovementMgr(StelCore* core);
    virtual ~StelMovementMgr();

    // Methods defined in the StelModule class
    virtual void init();

    virtual void update(double)
    {
        if (dragTimeMode)
            addTimeDragPoint(QCursor::pos().x(), QCursor::pos().y());
    }
    virtual void draw(StelCore*) {;}
    virtual void handleKeys(QKeyEvent* event);
    virtual bool handleMouseMoves(int x, int y, Qt::MouseButtons b);
    virtual void handleMouseWheel(class QWheelEvent* event);
    virtual void handleMouseClicks(class QMouseEvent* event);
    // allow some keypress interaction by plugins.
    virtual double getCallOrder(StelModuleActionName actionName) const;
    virtual bool handlePinch(qreal scale, bool started);

    // Methods specific to StelMovementMgr

    void updateMotion(double deltaTime);

    // TODO: what are the units?
    double getZoomSpeed() {return keyZoomSpeed;}

    Vec3d getViewUpVectorJ2000() const;
    // You can set an upVector in J2000 coordinates which is translated to current mount mode. Important when viewing into the pole of the current mount mode coordinates.
    void setViewUpVectorJ2000(const Vec3d& up);
    // Set vector directly. This is set in the current mountmode, but will be translated to J2000 internally
    // We need this only when viewing to the poles of current coordinate system where the view vector would else be parallel to the up vector.
    void setViewUpVector(const Vec3d& up);

    void setMovementSpeedFactor(float s) {movementsSpeedFactor=s;}
    float getMovementSpeedFactor() const {return movementsSpeedFactor;}

    void setDragTriggerDistance(float d) {dragTriggerDistance=d;}

public slots:
    void toggleMountMode() {if (getMountMode()==MountAltAzimuthal) setMountMode(MountEquinoxEquatorial); else setMountMode(MountAltAzimuthal);}
    void setEquatorialMount(bool b) {setMountMode(b ? MountEquinoxEquatorial : MountAltAzimuthal);}

    void setFlagTracking(bool b=true);
    bool getFlagTracking(void) const {return flagTracking;}

    void setFlagLockEquPos(bool b);
    bool getFlagLockEquPos(void) const {return flagLockEquPos;}

    void panView(const double deltaAz, const double deltaAlt);

    void setAutoMoveDuration(float f) {autoMoveDuration = f;}
    float getAutoMoveDuration(void) const {return autoMoveDuration;}

    void setFlagAutoZoomOutResetsDirection(bool b) {if (flagAutoZoomOutResetsDirection != b) { flagAutoZoomOutResetsDirection = b; emit flagAutoZoomOutResetsDirectionChanged(b);}}
    bool getFlagAutoZoomOutResetsDirection(void) {return flagAutoZoomOutResetsDirection;}

    bool getFlagEnableZoomKeys() const {return flagEnableZoomKeys;}
    void setFlagEnableZoomKeys(bool b) {flagEnableZoomKeys=b;}

    bool getFlagEnableMoveKeys() const {return flagEnableMoveKeys;}
    void setFlagEnableMoveKeys(bool b) {flagEnableMoveKeys=b;}

    bool getFlagEnableMoveAtScreenEdge() const {return flagEnableMoveAtScreenEdge;}
    void setFlagEnableMoveAtScreenEdge(bool b) {flagEnableMoveAtScreenEdge=b;}

    bool getFlagEnableMouseNavigation() const {return flagEnableMouseNavigation;}
    void setFlagEnableMouseNavigation(bool b) {flagEnableMouseNavigation=b;}

    void moveToJ2000(const Vec3d& aim, const Vec3d &aimUp, float moveDuration = 1., ZoomingMode zooming = ZoomNone);
    void moveToObject(const StelObjectP& target, float moveDuration = 1., ZoomingMode zooming = ZoomNone);

    void moveToAltAzi(const Vec3d& aim, const Vec3d &aimUp, float moveDuration = 1., ZoomingMode zooming = ZoomNone);

    void zoomTo(double aimFov, float moveDuration = 1.);
    double getCurrentFov() const {return currentFov;}

    double getInitFov() const {return initFov;}
    void setInitFov(double fov) {initFov=fov;}

    const Vec3d getInitViewingDirection() {return initViewPos;}
    void setInitViewDirectionToCurrent();

    Vec3d getViewDirectionJ2000() const {return viewDirectionJ2000;}
    void setViewDirectionJ2000(const Vec3d& v);

    void setMaxFov(double max);
    double getMaxFov(void) const {return maxFov;}

    double getMinFov(void) const {return minFov;}

    void autoZoomIn(float moveDuration = 1.f, bool allowManualZoom = 1);
    void autoZoomOut(float moveDuration = 1.f, bool full = 0);

    double getAimFov(void) const;

    void turnRight(bool);
    void turnLeft(bool);
    void turnUp(bool);
    void turnDown(bool);
    void moveSlow(bool b) {flagMoveSlow=b;}
    void zoomIn(bool);
    void zoomOut(bool);

    void lookEast(bool zero=false);
    void lookWest(bool zero=false);
    void lookNorth(bool zero=false);
    void lookSouth(bool zero=false);
    void lookZenith(void);
    void lookNadir(void);
    void lookTowardsNCP(void);
    void lookTowardsSCP(void);

    void moveViewport(float offsetX, float offsetY, const float duration=0.f);

    void setMountMode(MountMode m);
    MountMode getMountMode(void) const {return mountMode;}
    bool getEquatorialMount(void) const {return mountMode == MountEquinoxEquatorial;}

    void setInhibitAllAutomoves(bool inhibit) { flagInhibitAllAutomoves=inhibit;}

    Vec2f getViewportOffsetTarget() const { return targetViewportOffset; }
    float getViewportHorizontalOffsetTarget() const { return targetViewportOffset[0]; }
    float getViewportVerticalOffsetTarget() const { return targetViewportOffset[1]; }

    void setViewportHorizontalOffsetTarget(float f) { moveViewport(f,getViewportVerticalOffsetTarget()); }
    void setViewportVerticalOffsetTarget(float f) { moveViewport(getViewportHorizontalOffsetTarget(),f); }

signals:
    void flagTrackingChanged(bool b);
    void equatorialMountChanged(bool b);

    void flagAutoZoomOutResetsDirectionChanged(bool b);

    void viewportHorizontalOffsetTargetChanged(float f);
    void viewportVerticalOffsetTargetChanged(float f);

private slots:
    void selectedObjectChange(StelModule::StelModuleSelectAction action);

    void handleViewportOffsetMovement(qreal value);

public:
    Vec3d j2000ToMountFrame(const Vec3d& v) const;
    Vec3d mountFrameToJ2000(const Vec3d& v) const;

private:
    double currentFov; // The current FOV in degrees
    double initFov;    // The FOV at startup
    double minFov;     // Minimum FOV in degrees
    double maxFov;     // Maximum FOV in degrees
    double deltaFov;   // requested change of FOV (degrees) used during zooming.
    void setFov(double f)
    {
        currentFov=qMax(minFov, qMin(f, maxFov));
    }
    // immediately add deltaFov argument to FOV - does not change private var.
    void changeFov(double deltaFov);

    // Move (a bit) to selected/tracked object until move.coef reaches 1, or auto-follow (track) selected object.
    // Does nothing if flagInhibitAllAutomoves=true
    void updateVisionVector(double deltaTime);
    void updateAutoZoom(double deltaTime); // Update autoZoom if activated

    void dragView(int x1, int y1, int x2, int y2);

    StelCore* core;          // The core on which the movement are applied
    class StelObjectMgr* objectMgr;
    bool flagLockEquPos;     // Define if the equatorial position is locked
    bool flagTracking;       // Define if the selected object is followed
    bool flagInhibitAllAutomoves; // Required for special installations: If true, there is no automatic centering etc.

    // Flags for mouse movements
    bool isMouseMovingHoriz;
    bool isMouseMovingVert;

    bool flagEnableMoveAtScreenEdge; // allow mouse at edge of screen to move view
    bool flagEnableMouseNavigation;
    float mouseZoomSpeed;

    bool flagEnableZoomKeys;
    bool flagEnableMoveKeys;
    float keyMoveSpeed;              // Speed of keys movement
    float keyZoomSpeed;              // Speed of keys zoom
    bool flagMoveSlow;

    // Speed factor for real life time movements, used for fast forward when playing scripts.
    float movementsSpeedFactor;

    struct AutoMove
    {
        Vec3d start;
        Vec3d aim;
        Vec3d startUp; // The Up vector at start time
        Vec3d aimUp;   // The Up vector at end time of move
        float speed;   // set to 1/duration[ms] during automove setup.
        float coef;    // Set to 0 at begin of an automove, runs up to 1.
        // If not null, move to the object instead of the aim.
        StelObjectP targetObject;
        MountMode mountMode; // In which frame we shall move. This may be different from the frame the display is set to!
        // The start and aim vectors are given in those coordinates, and are interpolated in the respective reference frames,
        // then the view vector is derived from the current coef.
        // AzAlt moves should be set to AltAz mode, else they will move towards the RA/Dec at begin of move which may have moved.
        // It is an error to move in J2000 or Eq frame with fast timelapse!
        // This is a March 2016 GZ hack. TODO: This class should be thought over a bit.
    };

    AutoMove move;          // Current auto movement. 2016-03: During setup, decide upon the frame for motion!
    bool flagAutoMove;       // Define if automove is on or off
    ZoomingMode zoomingMode;

    double deltaAlt,deltaAz; // View movement

    bool flagManualZoom;     // Define whether auto zoom can go further
    float autoMoveDuration; // Duration of movement for the auto move to a selected object in seconds

    // Mouse control options
    bool isDragging, hasDragged;
    int previousX, previousY;

    // Contains the last N real time / JD times pairs associated with the last N mouse move events at screen coordinates x/y
    struct DragHistoryEntry
    {
        double runTime;
        double jd;
        int x;
        int y;
    };
    QList<DragHistoryEntry> timeDragHistory; // list of max 3 entries.
    void addTimeDragPoint(int x, int y);
    float beforeTimeDragTimeRate;

    // Time mouse control
    bool dragTimeMode; // Internal flag, true during mouse time motion. This is set true when mouse is moving with ctrl pressed. Set false when releasing ctrl.

    // Components:
    // startFov: field of view at start
    // aimFov: intended field of view at end of zoom move
    // speed: rate of change. UNITS?
    // coef: set to 0 at begin of zoom, will increase to 1 during autozoom motion.
    struct AutoZoom
    {
        double startFov;
        double aimFov;
        float speed;
        float coef;
    };

    // Automove
    AutoZoom zoomMove; // Current auto movement
    bool flagAutoZoom; // Define if autozoom is on or off
    bool flagAutoZoomOutResetsDirection;

    // defines if view corrects for horizon, or uses equatorial coordinates
    MountMode mountMode;

    Vec3d initViewPos;        // Default viewing direction
    Vec3d initViewUp;         // original up vector. Usually 0/0/1, but maybe something else in rare setups (e.g. Planetarium dome upwards fisheye projection).

    // Viewing direction in equatorial J2000 coordinates
    Vec3d viewDirectionJ2000;
    // Viewing direction in the mount reference frame.
    Vec3d viewDirectionMountFrame;

    // Up vector (in OpenGL terms) in the mount reference frame.
    // This can usually be just 0/0/1, but must be set to something useful when viewDirectionMountFrame is parallel, i.e. looks into a pole.
    Vec3d upVectorMountFrame;

    // TODO: Docfix?
    float dragTriggerDistance;

    // Viewport shifting. This animates a property belonging to StelCore. But the shift itself is likely best placed here.
    QTimeLine *viewportOffsetTimeline;
    // Those two are used during viewport offset animation transitions. Both are set by moveViewport(), and irrelevant after the transition.
    Vec2f oldViewportOffset;
    Vec2f targetViewportOffset;

};

#endif // _STELMOVEMENTMGR_HPP_