Planet.hpp

/*
 * Stellarium
 * Copyright (C) 2002 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., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _PLANET_HPP_
#define _PLANET_HPP_

#include "StelObject.hpp"
#include "StelProjector.hpp"
#include "VecMath.hpp"
#include "StelFader.hpp"
#include "StelTextureTypes.hpp"
#include "StelProjectorType.hpp"

#include <QString>

// The callback type for the external position computation function
// The last variable is the userData pointer.
typedef void (*posFuncType)(double, double*, void*);

typedef void (OsculatingFunctType)(double jde0,double jde,double xyz[3]);

// epoch J2000: 12 UT on 1 Jan 2000
#define J2000 2451545.0
#define ORBIT_SEGMENTS 360

class StelFont;
class StelPainter;
class StelTranslator;
class QOpenGLShaderProgram;

// Class used to store rotational elements, i.e. axis orientation for the planetary body.
class RotationElements
{
public:
    RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquity(0.), ascendingNode(0.), precessionRate(0.), siderealPeriod(0.) {}
    float period;          // (sidereal) rotation period [earth days]
    float offset;          // rotation at epoch  [degrees]
    double epoch;          // JDE (JD TT) of epoch for these elements
    float obliquity;       // tilt of rotation axis w.r.t. ecliptic [radians]
    float ascendingNode;   // long. of ascending node of equator on the ecliptic [radians]
    float precessionRate;  // rate of precession of rotation axis in [rads/JulianCentury(36525d)]
    double siderealPeriod; // sidereal period (Planet year in earth days) [earth days]
};

// Class to manage rings for planets like saturn
class Ring
{
public:
    Ring(float radiusMin, float radiusMax,const QString &texname);
    double getSize(void) const {return radiusMax;}
    const float radiusMin;
    const float radiusMax;
    StelTextureSP tex;
};


class Planet : public StelObject
{
public:
    friend class SolarSystem;

    Q_ENUMS(PlanetType)
    Q_ENUMS(PlanetOrbitColorStyle)
    Q_ENUMS(ApparentMagnitudeAlgorithm)
    // GZ: Until 0.13 QStrings were used for types.
    // GZ: Enums are slightly faster than string comparisons in time-critical comparisons.
    // GZ: If other types are introduced, add here and the string in init().
    enum PlanetType
    {
        isStar,         // ssystem.ini: type="star"
        isPlanet,       // ssystem.ini: type="planet"
        isMoon,         // ssystem.ini: type="moon"
        isAsteroid,     // ssystem.ini: type="asteroid"
        isPlutino,      // ssystem.ini: type="plutino"
        isComet,        // ssystem.ini: type="comet"
        isDwarfPlanet,      // ssystem.ini: type="dwarf planet"
        isCubewano,     // ssystem.ini: type="cubewano"
        isSDO,          // ssystem.ini: type="scattered disc object"
        isOCO,          // ssystem.ini: type="oco"
        isSednoid,      // ssystem.ini: type="sednoid"
        isUNDEFINED     // ssystem.ini: type=<anything else>
    };

    enum PlanetOrbitColorStyle
    {
        ocsOneColor,        // One color for all orbits
        ocsGroups,      // Separate colors for each group of Solar system bodies
        ocsMajorPlanets     // Separate colors for each of major planets of Solar system
    };

/*  enum ApparentMagnitudeAlgorithm
    {
        Planesas,       // Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
        Mueller,        // G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
        Harris,         // Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (D.L. Harris)
        UndefinedAlgorithm,
        Generic         // Visual magnitude based on phase angle and albedo
    };
*/
    enum ApparentMagnitudeAlgorithm
    {
        Mueller_1893,   // G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
        Astr_Alm_1984,  // Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (allegedly from D.L. Harris, but this is wrong!)
        Expl_Sup_1992,  // Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional) (Was called "Planesas")
        Expl_Sup_2013,  // Explanatory Supplement to the Astronomical Almanac, 3rd edition 2013
//      Planesas,       // Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
//      Mueller,        // G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
//      Harris,         // Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (D.L. Harris)
        UndefinedAlgorithm,
        Generic     // Visual magnitude based on phase angle and albedo. The formula source for this is totally unknown!
    };


    Planet(const QString& englishName,
           int flagLighting,
           double radius,
           double oblateness,
           Vec3f halocolor,
           float albedo,
           const QString& texMapName,
           const QString& normalMapName,
           posFuncType _coordFunc,
           void* userDataPtr,
           OsculatingFunctType *osculatingFunc,
           bool closeOrbit,
           bool hidden,
           bool hasAtmosphere,
           bool hasHalo,
           const QString &pTypeStr);

    virtual ~Planet();

    // Currently ensured by SolarSystem::init()
    static void init();

    // Methods inherited from StelObject
    virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
    virtual QVariantMap getInfoMap(const StelCore *core) const;
    virtual double getCloseViewFov(const StelCore* core) const;
    virtual double getSatellitesFov(const StelCore* core) const;
    virtual double getParentSatellitesFov(const StelCore* core) const;
    virtual float getVMagnitude(const StelCore* core) const;
    virtual float getSelectPriority(const StelCore* core) const;
    virtual Vec3f getInfoColor(void) const;
    virtual QString getType(void) const {return "Planet";}
    virtual Vec3d getJ2000EquatorialPos(const StelCore *core) const;
    virtual QString getEnglishName(void) const;
    virtual QString getNameI18n(void) const;
    virtual double getAngularSize(const StelCore* core) const;
    virtual bool hasAtmosphere(void) {return atmosphere;}
    virtual bool hasHalo(void) {return halo;}

    // Methods of SolarSystem object
    virtual void translateName(const StelTranslator &trans);

    // Draw the Planet
    // GZ Made that virtual to allow comets having their own draw().
    virtual void draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont);

    // Methods specific to Planet
    double getRadius(void) const {return radius;}
    double getOneMinusOblateness(void) const {return oneMinusOblateness;}
    double getSiderealDay(void) const {return re.period;}
    // must be virtual for Comets.
    virtual double getSiderealPeriod(void) const { return re.siderealPeriod; }
    double getMeanSolarDay(void) const;
    double getAlbedo(void) const { return albedo; }

    const QString& getTextMapName() const {return texMapName;}  
    const QString getPlanetTypeString() const {return pTypeMap.value(pType);}
    PlanetType getPlanetType() const {return pType;}

    void setNativeName(QString planet) { nativeName = planet; }

    float getAbsoluteMagnitude() const {return absoluteMagnitude;}
    float getMeanOppositionMagnitude() const;
    ApparentMagnitudeAlgorithm getApparentMagnitudeAlgorithm() const { return vMagAlgorithm; }
    const QString getApparentMagnitudeAlgorithmString() const { return vMagAlgorithmMap.value(vMagAlgorithm); }
    void setApparentMagnitudeAlgorithm(QString algorithm);

    double getSiderealTime(double JD, double JDE) const;
    Mat4d getRotEquatorialToVsop87(void) const;
    void setRotEquatorialToVsop87(const Mat4d &m);

    const RotationElements &getRotationElements(void) const {return re;}
    // Set the orbital elements
    void setRotationElements(float _period, float _offset, double _epoch,
                 float _obliquity, float _ascendingNode,
                 float _precessionRate, double _siderealPeriod);
    double getRotAscendingnode(void) const {return re.ascendingNode;}
    // return angle between axis and normal of ecliptic plane (or, for a moon, equatorial/reference plane defined by parent).
    // TODO: decide if this is always angle between axis and J2000 ecliptic, or should be axis//current ecliptic!
    double getRotObliquity(double JDE) const;



    void computePositionWithoutOrbits(const double dateJDE);
    void computePosition(const double dateJDE);

    void computeTransMatrix(double JD, double JDE);

    double getPhaseAngle(const Vec3d& obsPos) const;
    double getElongation(const Vec3d& obsPos) const;
    double getSpheroidAngularSize(const StelCore* core) const;
    float getPhase(const Vec3d& obsPos) const;

    Vec3d getEclipticPos() const;

    // Return the heliocentric ecliptical position
    Vec3d getHeliocentricEclipticPos() const {return getHeliocentricPos(eclipticPos);}

    // Return the heliocentric transformation for local coordinate
    Vec3d getHeliocentricPos(Vec3d) const;
    void setHeliocentricEclipticPos(const Vec3d &pos);

    // Compute the distance to the given position in heliocentric coordinate (in AU)
    double computeDistance(const Vec3d& obsHelioPos);
    double getDistance(void) const {return distance;}

    void setRings(Ring* r) {rings = r;}

    void setSphereScale(float s) {sphereScale = s;}
    float getSphereScale(void) const {return sphereScale;}

    const QSharedPointer<Planet> getParent(void) const {return parent;}

    static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
    static const Vec3f& getLabelColor(void) {return labelColor;}

    // update displayed elements. @param deltaTime: ms (since last call)
    virtual void update(int deltaTime);

    void setFlagHints(bool b){hintFader = b;}
    bool getFlagHints(void) const {return hintFader;}

    void setFlagLabels(bool b){flagLabels = b;}
    bool getFlagLabels(void) const {return flagLabels;}

    bool flagNativeName;
    void setFlagNativeName(bool b) { flagNativeName = b; }
    bool getFlagNativeName(void) { return flagNativeName; }

    bool flagTranslatedName;
    void setFlagTranslatedName(bool b) { flagTranslatedName = b; }
    bool getFlagTranslatedName(void) { return flagTranslatedName; }

    // DEPRECATED
    // Should move to an OrbitPath class which works on a SolarSystemObject, not a Planet
    void setFlagOrbits(bool b){orbitFader = b;}
    bool getFlagOrbits(void) const {return orbitFader;}
    LinearFader orbitFader;
    // draw orbital path of Planet
    void drawOrbit(const StelCore*);
    Vec3d orbit[ORBIT_SEGMENTS+1];   // store heliocentric coordinates for drawing the orbit
    Vec3d orbitP[ORBIT_SEGMENTS+1];  // store local coordinate for orbit
    double lastOrbitJDE;
    double deltaJDE;                 // time difference between positional updates.
    double deltaOrbitJDE;
    bool orbitCached;                // whether orbit calculations are cached for drawing orbit yet
    bool closeOrbit;                 // whether to connect the beginning of the orbit line to
                     // the end: good for elliptical orbits, bad for parabolic
                     // and hyperbolic orbits

    static Vec3f orbitColor;
    static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
    static const Vec3f& getOrbitColor() {return orbitColor;}

    static Vec3f orbitMajorPlanetsColor;
    static void setMajorPlanetOrbitColor(const Vec3f& oc) { orbitMajorPlanetsColor = oc;}
    static const Vec3f& getMajorPlanetOrbitColor() {return orbitMajorPlanetsColor;}

    static Vec3f orbitMoonsColor;
    static void setMoonOrbitColor(const Vec3f& oc) { orbitMoonsColor = oc;}
    static const Vec3f& getMoonOrbitColor() {return orbitMoonsColor;}

    static Vec3f orbitMinorPlanetsColor;
    static void setMinorPlanetOrbitColor(const Vec3f& oc) { orbitMinorPlanetsColor = oc;}
    static const Vec3f& getMinorPlanetOrbitColor() {return orbitMinorPlanetsColor;}

    static Vec3f orbitDwarfPlanetsColor;
    static void setDwarfPlanetOrbitColor(const Vec3f& oc) { orbitDwarfPlanetsColor = oc;}
    static const Vec3f& getDwarfPlanetOrbitColor() {return orbitDwarfPlanetsColor;}

    static Vec3f orbitCubewanosColor;
    static void setCubewanoOrbitColor(const Vec3f& oc) { orbitCubewanosColor = oc;}
    static const Vec3f& getCubewanoOrbitColor() {return orbitCubewanosColor;}

    static Vec3f orbitPlutinosColor;
    static void setPlutinoOrbitColor(const Vec3f& oc) { orbitPlutinosColor = oc;}
    static const Vec3f& getPlutinoOrbitColor() {return orbitPlutinosColor;}

    static Vec3f orbitScatteredDiscObjectsColor;
    static void setScatteredDiscObjectOrbitColor(const Vec3f& oc) { orbitScatteredDiscObjectsColor = oc;}
    static const Vec3f& getScatteredDiscObjectOrbitColor() {return orbitScatteredDiscObjectsColor;}

    static Vec3f orbitOortCloudObjectsColor;
    static void setOortCloudObjectOrbitColor(const Vec3f& oc) { orbitOortCloudObjectsColor = oc;}
    static const Vec3f& getOortCloudObjectOrbitColor() {return orbitOortCloudObjectsColor;}

    static Vec3f orbitCometsColor;
    static void setCometOrbitColor(const Vec3f& oc) { orbitCometsColor = oc;}
    static const Vec3f& getCometOrbitColor() {return orbitCometsColor;}

    static Vec3f orbitSednoidsColor;
    static void setSednoidOrbitColor(const Vec3f& oc) { orbitSednoidsColor = oc;}
    static const Vec3f& getSednoidOrbitColor() {return orbitSednoidsColor;}

    static Vec3f orbitMercuryColor;
    static void setMercuryOrbitColor(const Vec3f& oc) { orbitMercuryColor = oc;}
    static const Vec3f& getMercuryOrbitColor() {return orbitMercuryColor;}

    static Vec3f orbitVenusColor;
    static void setVenusOrbitColor(const Vec3f& oc) { orbitVenusColor = oc;}
    static const Vec3f& getVenusOrbitColor() {return orbitVenusColor;}

    static Vec3f orbitEarthColor;
    static void setEarthOrbitColor(const Vec3f& oc) { orbitEarthColor = oc;}
    static const Vec3f& getEarthOrbitColor() {return orbitEarthColor;}

    static Vec3f orbitMarsColor;
    static void setMarsOrbitColor(const Vec3f& oc) { orbitMarsColor = oc;}
    static const Vec3f& getMarsOrbitColor() {return orbitMarsColor;}

    static Vec3f orbitJupiterColor;
    static void setJupiterOrbitColor(const Vec3f& oc) { orbitJupiterColor = oc;}
    static const Vec3f& getJupiterOrbitColor() {return orbitJupiterColor;}

    static Vec3f orbitSaturnColor;
    static void setSaturnOrbitColor(const Vec3f& oc) { orbitSaturnColor = oc;}
    static const Vec3f& getSaturnOrbitColor() {return orbitSaturnColor;}

    static Vec3f orbitUranusColor;
    static void setUranusOrbitColor(const Vec3f& oc) { orbitUranusColor = oc;}
    static const Vec3f& getUranusOrbitColor() {return orbitUranusColor;}

    static Vec3f orbitNeptuneColor;
    static void setNeptuneOrbitColor(const Vec3f& oc) { orbitNeptuneColor = oc;}
    static const Vec3f& getNeptuneOrbitColor() {return orbitNeptuneColor;}

    static bool permanentDrawingOrbits;
    static PlanetOrbitColorStyle orbitColorStyle;

    QVector<const Planet*> getCandidatesForShadow() const;
    
protected:
    static StelTextureSP texEarthShadow;     // for lunar eclipses

    void computeModelMatrix(Mat4d &result) const;

    Vec3f getCurrentOrbitColor();
    
    // Return the information string "ready to print" :)
    QString getSkyLabel(const StelCore* core) const;

    // Draw the 3d model. Call the proper functions if there are rings etc..
    void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing=false);

    // Draw the 3D sphere
    void drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing=false);

    // Draw the circle and name of the Planet
    void drawHints(const StelCore* core, const QFont& planetNameFont);

    QString englishName;             // english planet name
    QString nameI18;                 // International translated name
    QString nativeName;              // Can be used in a skyculture
    QString texMapName;              // Texture file path
    QString normalMapName;              // Texture file path
    int flagLighting;                // Set whether light computation has to be proceed
    RotationElements re;             // Rotation param
    double radius;                   // Planet radius in AU
    double oneMinusOblateness;       // (polar radius)/(equatorial radius)
    Vec3d eclipticPos;               // Position in AU in the rectangular ecliptic coordinate system
                     // centered on the parent Planet
    Vec3d screenPos;                 // Used to store temporarily the 2D position on screen
    Vec3d previousScreenPos;         // The position of this planet in the previous frame.
    Vec3f haloColor;                 // exclusively used for drawing the planet halo

    float albedo;                    // Planet albedo. Used for magnitude computation (but formula dubious!)
    float absoluteMagnitude;         // since 2017: V(1,0) from Explanatory Supplement or WGCCRE2009 paper for the planets, H in the H,G magnitude system for Minor planets, H10 for comets.
                     // This is the apparent visual magnitude when 1AU from sun and observer, with zero phase angle.
    Mat4d rotLocalToParent;          // GZ2015: was undocumented.
                     // Apparently this is the axis orientation with respect to the parent body. For planets, this is axis orientation w.r.t. VSOP87A/J2000 ecliptical system.
    float axisRotation;              // Rotation angle of the Planet on its axis.
                     // For Earth, this should be Greenwich Mean Sidereal Time GMST.
    StelTextureSP texMap;            // Planet map texture
    StelTextureSP normalMap;         // Planet normal map texture

    Ring* rings;                     // Planet rings
    double distance;                 // Temporary variable used to store the distance to a given point
                     // it is used for sorting while drawing
    float sphereScale;               // Artificial scaling for better viewing
    double lastJDE;                  // caches JDE of last positional computation
    // The callback for the calculation of the equatorial rect heliocentric position at time JDE.
    posFuncType coordFunc;
    void* userDataPtr;               // this is always used with an Orbit object.

    OsculatingFunctType *const osculatingFunc;
    QSharedPointer<Planet> parent;           // Planet parent i.e. sun for earth
    QList<QSharedPointer<Planet> > satellites;      // satellites of the Planet
    LinearFader hintFader;
    LinearFader labelsFader;         // Store the current state of the label for this planet
    bool flagLabels;                 // Define whether labels should be displayed
    bool hidden;                     // useful for fake planets used as observation positions - not drawn or labeled
    bool atmosphere;                 // Does the planet have an atmosphere?
    bool halo;                       // Does the planet have a halo?    
    PlanetType pType;                // Type of body

    ApparentMagnitudeAlgorithm vMagAlgorithm;

    static Vec3f labelColor;
    static StelTextureSP hintCircleTex; 
    static QMap<PlanetType, QString> pTypeMap; // Maps fast type to english name.
    static QMap<ApparentMagnitudeAlgorithm, QString> vMagAlgorithmMap;

    static bool flagCustomGrsSettings;  // Is enabled usage of custom settings for calculation of position of Great Red Spot?
    static double customGrsJD;      // Initial JD for calculation of position of Great Red Spot
    static int customGrsLongitude;      // Longitude of Great Red Spot (System II, degrees)
    static double customGrsDrift;       // Annual drift of Great Red Spot position (degrees)
    
    // Shader-related variables
    struct PlanetShaderVars {
        int projectionMatrix;
        int texCoord;
        int unprojectedVertex;
        int vertex;
        int texture;
        int lightDirection;
        int eyeDirection;
        int diffuseLight;
        int ambientLight;
        int shadowCount;
        int shadowData;
        int sunInfo;
        int skyBrightness;
        
        void initLocations(QOpenGLShaderProgram*);
    };
    static PlanetShaderVars planetShaderVars;
    static QOpenGLShaderProgram* planetShaderProgram;

    // Shader-related variables
    struct RingPlanetShaderVars : public PlanetShaderVars {
        // Rings-specific variables
        int isRing;
        int ring;
        int outerRadius;
        int innerRadius;
        int ringS;
    };
    static RingPlanetShaderVars ringPlanetShaderVars;
    static QOpenGLShaderProgram* ringPlanetShaderProgram;
    
    struct MoonShaderVars : public PlanetShaderVars {
        // Moon-specific variables
        int earthShadow;
        int normalMap;
    };
    static MoonShaderVars moonShaderVars;
    static QOpenGLShaderProgram* moonShaderProgram;
    
    static void initShader();
    static void deinitShader();
};

#endif // _PLANET_HPP_