core/StelCore.hpp

/*
 * Copyright (C) 2003 Fabien Chereau
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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)

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

        FrameJ2000,                   

        FrameGalactic                 
    };

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

    enum RefractionMode
    {
        RefractionAuto,         
        RefractionOn,           
        RefractionOff           
    };

    StelCore();
    virtual ~StelCore();

    void init();

    void update(double deltaTime);

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

    void preDraw();

    void postDraw();

    StelProjectorP getProjection2d() const;

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

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

    StelToneReproducer* getToneReproducer() {return toneConverter;}
    const StelToneReproducer* getToneReproducer() const {return toneConverter;}

    StelSkyDrawer* getSkyDrawer() {return skyDrawer;}
    const StelSkyDrawer* getSkyDrawer() const {return skyDrawer;}

    const StelGeodesicGrid* getGeodesicGrid(int maxLevel) const;

    StelMovementMgr* getMovementMgr() {return movementMgr;}
    const StelMovementMgr* getMovementMgr() const {return movementMgr;}

    void setClippingPlanes(double znear, double zfar) {currentProjectorParams.zNear=znear;currentProjectorParams.zFar=zfar;}
    void getClippingPlanes(double* zn, double* zf) const {*zn = currentProjectorParams.zNear; *zf = currentProjectorParams.zFar;}

    QString projectionTypeKeyToNameI18n(const QString& key) const;

    QString projectionNameI18nToTypeKey(const QString& nameI18n) const;

    StelProjector::StelProjectorParams getCurrentStelProjectorParams() const {return currentProjectorParams;}
    void setCurrentStelProjectorParams(const StelProjector::StelProjectorParams& newParams) {currentProjectorParams=newParams;}

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

    Vec3d altAzToEquinoxEqu(const Vec3d& v, RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return matAltAzToEquinoxEqu*v;
        Vec3d r(v);
        skyDrawer->getRefraction().backward(r);
        r.transfo4d(matAltAzToEquinoxEqu);
        return r;
    }
    Vec3d equinoxEquToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return matEquinoxEquToAltAz*v;
        Vec3d r(v);
        r.transfo4d(matEquinoxEquToAltAz);
        skyDrawer->getRefraction().forward(r);
        return r;
    }
    Vec3d altAzToJ2000(const Vec3d& v, RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return matEquinoxEquToJ2000*matAltAzToEquinoxEqu*v;
        Vec3d r(v);
        skyDrawer->getRefraction().backward(r);
        r.transfo4d(matEquinoxEquToJ2000*matAltAzToEquinoxEqu);
        return r;
    }
    Vec3d j2000ToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return matJ2000ToAltAz*v;
        Vec3d r(v);
        r.transfo4d(matJ2000ToAltAz);
        skyDrawer->getRefraction().forward(r);
        return r;
    }
    Vec3d galacticToJ2000(const Vec3d& v) const {return matGalacticToJ2000*v;}
    Vec3d equinoxEquToJ2000(const Vec3d& v) const {return matEquinoxEquToJ2000*v;}
    Vec3d j2000ToEquinoxEqu(const Vec3d& v) const {return matJ2000ToEquinoxEqu*v;}
    Vec3d j2000ToGalactic(const Vec3d& v) const {return matJ2000ToGalactic*v;}

    Vec3d heliocentricEclipticToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return matHeliocentricEclipticToAltAz*v;
        Vec3d r(v);
        r.transfo4d(matHeliocentricEclipticToAltAz);
        skyDrawer->getRefraction().forward(r);
        return r;
    }

    Vec3d heliocentricEclipticToEquinoxEqu(const Vec3d& v) const {return matHeliocentricEclipticToEquinoxEqu*v;}
    Vec3d heliocentricEclipticToEarthPosEquinoxEqu(const Vec3d& v) const {return matAltAzToEquinoxEqu*matHeliocentricEclipticToAltAz*v;}

    StelProjector::ModelViewTranformP getHeliocentricEclipticModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView*matHeliocentricEclipticToAltAz));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPreTransfoMat(matHeliocentricEclipticToAltAz);
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

    StelProjector::ModelViewTranformP getObservercentricEclipticModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView*matJ2000ToAltAz*matVsop87ToJ2000));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPreTransfoMat(matJ2000ToAltAz*matVsop87ToJ2000);
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

    StelProjector::ModelViewTranformP getEquinoxEquModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView*matEquinoxEquToAltAz));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPreTransfoMat(matEquinoxEquToAltAz);
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

    StelProjector::ModelViewTranformP getAltAzModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

    StelProjector::ModelViewTranformP getJ2000ModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView*matEquinoxEquToAltAz*matJ2000ToEquinoxEqu));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPreTransfoMat(matEquinoxEquToAltAz*matJ2000ToEquinoxEqu);
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

    StelProjector::ModelViewTranformP getGalacticModelViewTransform(RefractionMode refMode=RefractionAuto) const
    {
        if (refMode==RefractionOff || skyDrawer==false || (refMode==RefractionAuto && skyDrawer->getFlagHasAtmosphere()==false))
            return StelProjector::ModelViewTranformP(new StelProjector::Mat4dTransform(matAltAzModelView*matEquinoxEquToAltAz*matJ2000ToEquinoxEqu*matGalacticToJ2000));
        Refraction* refr = new Refraction(skyDrawer->getRefraction());
        // The pretransform matrix will convert from input coordinates to AltAz needed by the refraction function.
        refr->setPreTransfoMat(matEquinoxEquToAltAz*matJ2000ToEquinoxEqu*matGalacticToJ2000);
        refr->setPostTransfoMat(matAltAzModelView);
        return StelProjector::ModelViewTranformP(refr);
    }

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

    Vec3d getObserverHeliocentricEclipticPos() const;

    const StelLocation& getCurrentLocation() 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() {return startupTimeMode;}
    void setStartupTimeMode(const QString& s);

public slots:
    void setCurrentProjectionType(ProjectionType type);
    ProjectionType getCurrentProjectionType() const {return currentProjectionType;}

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

    QStringList getAllProjectionTypeKeys() const;

    void setMaskType(StelProjector::StelProjectorMaskType m) {currentProjectorParams.maskType = m; }

    void setFlagGravityLabels(bool gravity) { currentProjectorParams.gravityLabels = gravity; }
    void setDefautAngleForGravityText(float a) { currentProjectorParams.defautAngleForGravityText = a; }
    void setFlipHorz(bool flip) {currentProjectorParams.flipHorz = flip;}
    void setFlipVert(bool flip) {currentProjectorParams.flipVert = flip;}
    bool getFlipHorz(void) const {return currentProjectorParams.flipHorz;}
    bool getFlipVert(void) const {return currentProjectorParams.flipVert;}

    QString getDefaultLocationID() const {return defaultLocationID;}
    void setDefaultLocationID(const QString& id);


    void setJDay(double JD) {JDay=JD;}
    double getJDay() const {return JDay;}

    double getPresetSkyTime() const {return presetSkyTime;}
    void setPresetSkyTime(double d) {presetSkyTime=d;}

    void setTimeRate(double ts) {timeSpeed=ts; emit timeRateChanged(timeSpeed);}
    double getTimeRate() const {return timeSpeed;}

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

    void setZeroTimeSpeed() {setTimeRate(0);}
    void setRealTimeSpeed() {setTimeRate(JD_SECOND);}
    void toggleRealTimeSpeed() {(!getRealTimeSpeed()) ? setRealTimeSpeed() : setZeroTimeSpeed();}
    bool getRealTimeSpeed() const {return (fabs(timeSpeed-JD_SECOND)<0.0000001);}

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

    QTime getInitTodayTime(void) {return initTodayTime;}
    void setInitTodayTime(const QTime& t) {initTodayTime=t;}
    void setPresetSkyTime(QDateTime dt);

    void addHour() {addSolarDays(0.04166666666666666667);}
    void addDay() {addSolarDays(1.0);}
    void addWeek() {addSolarDays(7.0);}

    void addSiderealDay() {addSiderealDays(1.0);}
    void addSiderealWeek() {addSiderealDays(7.0);}

    void subtractHour() {addSolarDays(-0.04166666666666666667);}
    void subtractDay() {addSolarDays(-1.0);}
    void subtractWeek() {addSolarDays(-7.0);}

    void subtractSiderealDay() {addSiderealDays(-1.0);}
    void subtractSiderealWeek() {addSiderealDays(-7.0);}

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

    void moveObserverToSelected();

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;

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

#endif // _STELCORE_HPP_