StelMovementMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2007 Fabien Chereau
 * Copyright (C) 2015 Georg Zotti (offset view adaptations)
 *
 * 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"

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

    // TODO: add others like MountEcliptical
    enum MountMode { MountAltAzimuthal, MountEquinoxEquatorial, MountGalactic};

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

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

    virtual void update(double) {;}
    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);
    // GZ: 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);

    // These are hopefully temporary.
    bool getHasDragged() const {return hasDragged;}

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

    Vec3d getViewUpVectorJ2000() const;
    void setViewUpVectorJ2000(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) {flagAutoZoomOutResetsDirection = 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, float moveDuration = 1., int zooming = 0);
    void moveToObject(const StelObjectP& target, float moveDuration = 1., int zooming = 0);

    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;}

    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 setMountMode(MountMode m);
    MountMode getMountMode(void) const {return mountMode;}
    bool getEquatorialMount(void) const {return mountMode == MountEquinoxEquatorial;}

    void setDragTimeMode(bool b) {dragTimeMode=b;}
    bool getDragTimeMode() const {return dragTimeMode;}

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

    double getInitConstellationIntensity() const {return initConstellationIntensity;}
    void setInitConstellationIntensity(double v) {initConstellationIntensity=v;}
    
private:
    Vec3d j2000ToMountFrame(const Vec3d& v) const;
    Vec3d mountFrameToJ2000(const Vec3d& v) const;

    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 initConstellationIntensity;   // The initial constellation art intensity (level at startup)

    void setFov(double f)
    {
        currentFov = f;
        if (f>maxFov)
            currentFov = maxFov;
        if (f<minFov)
            currentFov = minFov;

        changeConstellationArtIntensity();
    }
    void changeFov(double deltaFov);
    void changeConstellationArtIntensity();

    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

    // 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;
        float speed;
        float coef;
        // If not null, move to the object.
        StelObjectP targetObject;
    };

    AutoMove move;          // Current auto movement
    bool flagAutoMove;       // Define if automove is on or off
    int zoomingMode;        // 0 : undefined, 1 zooming, -1 unzooming

    double deltaFov,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
    struct DragHistoryEntry
    {
        double runTime;
        double jd;
        int x;
        int y;
    };

    QList<DragHistoryEntry> timeDragHistory;
    void addTimeDragPoint(int x, int y);
    float beforeTimeDragTimeRate;

    // Time mouse control
    bool dragTimeMode;

    // 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

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

    Vec3d upVectorMountFrame;

    float dragTriggerDistance;
};

#endif // _STELMOVEMENTMGR_HPP_