StelCore.hpp

/*
 * Copyright (C) 2003 Fabien Chereau
 * Copyright (C) 2012 Matthew Gates
 *
 * 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 _STELCORE_HPP_
#define _STELCORE_HPP_

#include "StelProjector.hpp"
#include "StelProjectorType.hpp"
#include "StelLocation.hpp"
#include "StelSkyDrawer.hpp"
#include <QString>
#include <QStringList>
#include <QTime>

class StelToneReproducer;
class StelSkyDrawer;
class StelGeodesicGrid;
class StelMovementMgr;
class StelObserver;

class StelCore : public QObject
{
    Q_OBJECT
    Q_ENUMS(ProjectionType)
    Q_ENUMS(DeltaTAlgorithm)

public:
    enum FrameType
    {
        FrameUninitialized,     
        FrameAltAz,         
        FrameHeliocentricEcliptic,  
        FrameObservercentricEcliptic,   
        FrameEquinoxEqu,        

        FrameJ2000,         

        FrameGalactic           
    };

    enum ProjectionType
    {
        ProjectionPerspective,      
        ProjectionEqualArea,        
        ProjectionStereographic,    
        ProjectionFisheye,      
        ProjectionHammer,       
        ProjectionCylinder,     
        ProjectionMercator,     
        ProjectionOrthographic      
    };

    enum RefractionMode
    {
        RefractionAuto,         
        RefractionOn,           
        RefractionOff           
    };

    enum DeltaTAlgorithm
    {
        WithoutCorrection,              
        Schoch,                         
        Clemence,                       
        IAU,                            
        AstronomicalEphemeris,          
        TuckermanGoldstine,             
        MullerStephenson,               
        Stephenson1978,                 
        SchmadelZech1979,               
        MorrisonStephenson1982,         
        StephensonMorrison1984,         
        StephensonHoulden,              
        Espenak,                        
        Borkowski,                      
        SchmadelZech1988,               
        ChaprontTouze,                  
        StephensonMorrison1995,         
        Stephenson1997,                 
        ChaprontMeeus,                  
        JPLHorizons,                    
        MeeusSimons,                    
        MontenbruckPfleger,             
        ReingoldDershowitz,             
        MorrisonStephenson2004,         
        Reijs,                          
        EspenakMeeus,                   
        Custom                          
    };

    StelCore();
    virtual ~StelCore();

    void init(class StelRenderer* renderer);

    void update(double deltaTime);

    void windowHasBeenResized(float x, float y, float width, float height);

    void preDraw();

    void postDraw(StelRenderer* renderer);

    StelProjectorP getProjection2d() const;

    StelProjectorP getProjection(FrameType frameType, RefractionMode refractionMode=RefractionAuto) const;

    StelProjectorP getProjection(StelProjector::ModelViewTranformP modelViewTransform, ProjectionType projType=(ProjectionType)1000) const;

    StelToneReproducer* getToneReproducer();
    const StelToneReproducer* getToneReproducer() const;

    StelSkyDrawer* getSkyDrawer();
    const StelSkyDrawer* getSkyDrawer() const;

    const StelGeodesicGrid* getGeodesicGrid(int maxLevel) const;

    StelMovementMgr* getMovementMgr();
    const StelMovementMgr* getMovementMgr() const;

    void setClippingPlanes(double znear, double zfar);
    void getClippingPlanes(double* zn, double* zf) const;

    QString projectionTypeKeyToNameI18n(const QString& key) const;

    QString projectionNameI18nToTypeKey(const QString& nameI18n) const;

    StelProjector::StelProjectorParams getCurrentStelProjectorParams() const;
    void setCurrentStelProjectorParams(const StelProjector::StelProjectorParams& newParams);

    void lookAtJ2000(const Vec3d& pos, const Vec3d& up);

    Vec3d altAzToEquinoxEqu(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d equinoxEquToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d altAzToJ2000(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d j2000ToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d galacticToJ2000(const Vec3d& v) const;
    Vec3d equinoxEquToJ2000(const Vec3d& v) const;
    Vec3d j2000ToEquinoxEqu(const Vec3d& v) const;
    Vec3d j2000ToGalactic(const Vec3d& v) const;

    Vec3d heliocentricEclipticToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;

    Vec3d heliocentricEclipticToEquinoxEqu(const Vec3d& v) const;
    Vec3d heliocentricEclipticToEarthPosEquinoxEqu(const Vec3d& v) const;

    StelProjector::ModelViewTranformP getHeliocentricEclipticModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getObservercentricEclipticModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getEquinoxEquModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getAltAzModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getJ2000ModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getGalacticModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    static const Mat4d matJ2000ToVsop87;
    static const Mat4d matVsop87ToJ2000;
    static const Mat4d matJ2000ToGalactic;
    static const Mat4d matGalacticToJ2000;

    Vec3d getObserverHeliocentricEclipticPos() const;

    const StelLocation& getCurrentLocation() const;

    const QSharedPointer<class Planet> getCurrentPlanet() const;

    void moveObserverTo(const StelLocation& target, double duration=1., double durationIfPlanetChange=1.);

    // Conversion in standar Julian time format
    static const double JD_SECOND;
    static const double JD_MINUTE;
    static const double JD_HOUR;
    static const double JD_DAY;

    double getLocalSideralTime() const;

    double getLocalSideralDayLength() const;

    QString getStartupTimeMode();
    void setStartupTimeMode(const QString& s);

    double getDeltaT(double jDay) const;

    QString getCurrentDeltaTAlgorithmValidRange(double jDay, QString* marker) const;

public slots:
    void setCurrentProjectionType(ProjectionType type);
    ProjectionType getCurrentProjectionType() const;

    QString getCurrentProjectionTypeKey(void) const;
    void setCurrentProjectionTypeKey(QString type);

    QStringList getAllProjectionTypeKeys() const;

    void setCurrentDeltaTAlgorithm(DeltaTAlgorithm algorithm) { currentDeltaTAlgorithm=algorithm; }
    DeltaTAlgorithm getCurrentDeltaTAlgorithm() const { return currentDeltaTAlgorithm; }
    QString getCurrentDeltaTAlgorithmDescription(void) const;
    QString getCurrentDeltaTAlgorithmKey(void) const;
    void setCurrentDeltaTAlgorithmKey(QString type);

    void setMaskType(StelProjector::StelProjectorMaskType m);

    void setFlagGravityLabels(bool gravity);
    void setDefautAngleForGravityText(float a);
    void setFlipHorz(bool flip);
    void setFlipVert(bool flip);
    bool getFlipHorz(void) const;
    bool getFlipVert(void) const;

    QString getDefaultLocationID() const;
    void setDefaultLocationID(const QString& id);
    void returnToDefaultLocation();
    void returnToHome();

    void setJDay(double JD);
    double getJDay() const;

    void setMJDay(double MJD);
    double getMJDay() const;

    double getPresetSkyTime() const;
    void setPresetSkyTime(double d);

    void setTimeRate(double ts);
    double getTimeRate() const;

    void increaseTimeSpeed();
    void decreaseTimeSpeed();
    void increaseTimeSpeedLess();
    void decreaseTimeSpeedLess();

    void setZeroTimeSpeed();
    void setRealTimeSpeed();
    void toggleRealTimeSpeed();
    bool getRealTimeSpeed() const;

    void setTimeNow();
    void setTodayTime(const QTime& target);
    bool getIsTimeNow() const;

    QTime getInitTodayTime(void);
    void setInitTodayTime(const QTime& t);
    void setPresetSkyTime(QDateTime dt);

    void addHour();
    void addDay();
    void addWeek();

    void addSiderealDay();
    void addSiderealWeek();
    void addSiderealMonth();
    void addSiderealYear();
    void addSiderealCentury();

    void subtractHour();
    void subtractDay();
    void subtractWeek();

    void subtractSiderealDay();
    void subtractSiderealWeek();
    void subtractSiderealMonth();
    void subtractSiderealYear();
    void subtractSiderealCentury();

    void addSynodicMonth();

    void addDraconicYear();
    void addDraconicMonth();

    void addAnomalisticMonth();

    void addTropicalMonth();
    void addTropicalYear();
    void addTropicalCentury();

    void subtractSynodicMonth();

    void subtractDraconicYear();
    void subtractDraconicMonth();

    void subtractAnomalisticMonth();

    void subtractTropicalMonth();
    void subtractTropicalYear();
    void subtractTropicalCentury();

    void addSolarDays(double d);
    void addSiderealDays(double d);

    void moveObserverToSelected();

    void setCustomYear(float y) { customYear=y; }
    void setCustomNDot(float v) { customNDot=v; }
    void setCustomEquationCoefficients(Vec3f c) { customEquationCoeff=c; }

    float getCustomYear() const { return customYear; }
    float getCustomNDot() const { return customNDot; }
    Vec3f getCustomEquationCoefficients() const { return customEquationCoeff; }

signals:
    void locationChanged(StelLocation);
    void timeRateChanged(double rate);

private:
    StelToneReproducer* toneConverter;      // Tones conversion between stellarium world and display device
    StelSkyDrawer* skyDrawer;
    StelMovementMgr* movementMgr;       // Manage vision movements

    // Manage geodesic grid
    mutable StelGeodesicGrid* geodesicGrid;

    // The currently used projection type
    ProjectionType currentProjectionType;

    // The currentrly used time correction (DeltaT)
    DeltaTAlgorithm currentDeltaTAlgorithm;

    // Parameters to use when creating new instances of StelProjector
    StelProjector::StelProjectorParams currentProjectorParams;

    void updateTransformMatrices();
    void updateTime(double deltaTime);

    // Matrices used for every coordinate transfo
    Mat4d matHeliocentricEclipticToAltAz;      // Transform from heliocentric ecliptic (Vsop87) to observer-centric altazimuthal coordinate
    Mat4d matAltAzToHeliocentricEcliptic;      // Transform from observer-centric altazimuthal coordinate to heliocentric ecliptic (Vsop87)
    Mat4d matAltAzToEquinoxEqu;                // Transform from observer-centric altazimuthal coordinate to Earth Equatorial
    Mat4d matEquinoxEquToAltAz;                // Transform from observer-centric altazimuthal coordinate to Earth Equatorial
    Mat4d matHeliocentricEclipticToEquinoxEqu; // Transform from heliocentric ecliptic (Vsop87) to earth equatorial coordinate
    Mat4d matEquinoxEquToJ2000;
    Mat4d matJ2000ToEquinoxEqu;
    Mat4d matJ2000ToAltAz;

    Mat4d matAltAzModelView;           // Modelview matrix for observer-centric altazimuthal drawing
    Mat4d invertMatAltAzModelView;     // Inverted modelview matrix for observer-centric altazimuthal drawing

    // Position variables
    StelObserver* position;
    // The ID of the default startup location
    QString defaultLocationID;

    // Time variables
    double timeSpeed;                  // Positive : forward, Negative : Backward, 1 = 1sec/sec
    double JDay;                       // Curent time in Julian day
    double presetSkyTime;
    QTime initTodayTime;
    QString startupTimeMode;

    // Variables for custom equation of Delta-T
    Vec3f customEquationCoeff;
    float customNDot;
    float customYear;

};

#endif // _STELCORE_HPP_