Home · All Namespaces · All Classes · Functions · Coding Style · Plugins · File Structure

modules/Planet.hpp

00001 /*
00002  * Stellarium
00003  * Copyright (C) 2002 Fabien Chereau
00004  *
00005  * This program is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * as published by the Free Software Foundation; either version 2
00008  * of the License, or (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00018  */
00019 
00020 #ifndef _PLANET_HPP_
00021 #define _PLANET_HPP_
00022 
00023 #include <QString>
00024 
00025 #include "StelObject.hpp"
00026 #include "StelToneReproducer.hpp"
00027 #include "VecMath.hpp"
00028 #include "callbacks.hpp"
00029 #include "StelFader.hpp"
00030 #include "StelTranslator.hpp"
00031 #include "StelTextureTypes.hpp"
00032 #include "StelProjectorType.hpp"
00033 
00034 // The callback type for the external position computation function
00035 typedef boost::callback<void, double, double*> posFuncType;
00036 
00037 typedef void (OsulatingFunctType)(double jd0,double jd,double xyz[3]);
00038 
00039 // epoch J2000: 12 UT on 1 Jan 2000
00040 #define J2000 2451545.0
00041 #define ORBIT_SEGMENTS 72
00042 
00043 class StelFont;
00044 class StelPainter;
00045 
00046 struct TrailPoint
00047 {
00048     Vec3d point;
00049     double date;
00050 };
00051 
00052 
00053 // Class used to store orbital elements
00054 class RotationElements
00055 {
00056 public:
00057     RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquity(0.), ascendingNode(0.), precessionRate(0.) {}
00058     float period;          // rotation period
00059     float offset;          // rotation at epoch
00060     double epoch;
00061     float obliquity;       // tilt of rotation axis w.r.t. ecliptic
00062     float ascendingNode;   // long. of ascending node of equator on the ecliptic
00063     float precessionRate;  // rate of precession of rotation axis in rads/day
00064     double siderealPeriod; // sidereal period (Planet year in earth days)
00065 };
00066 
00067 // Class to manage rings for planets like saturn
00068 class Ring
00069 {
00070 public:
00071     Ring(double radiusMin,double radiusMax,const QString &texname);
00072     ~Ring(void);
00073     void draw(const StelPainter* painter,const Mat4d& mat,double screenSz);
00074     double getSize(void) const {return radiusMax;}
00075 private:
00076     const double radiusMin;
00077     const double radiusMax;
00078     StelTextureSP tex;
00079 };
00080 
00081 
00082 class Planet : public StelObject
00083 {
00084 public:
00085     friend class SolarSystem;
00086     Planet(const QString& englishName,
00087            int flagLighting,
00088            double radius,
00089            double oblateness,
00090            Vec3f color,
00091            float albedo,
00092            const QString& texMapName,
00093            const QString& texHaloName,
00094            posFuncType _coordFunc,
00095            OsulatingFunctType *osculatingFunc,
00096            bool closeOrbit,
00097            bool hidden, 
00098            bool hasAtmosphere);
00099 
00100     ~Planet();
00101 
00103     // Methods inherited from StelObject
00116     virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
00117     virtual double getCloseViewFov(const StelNavigator * nav) const;
00118     virtual double getSatellitesFov(const StelNavigator * nav) const;
00119     virtual double getParentSatellitesFov(const StelNavigator * nav) const;
00120     virtual float getVMagnitude(const StelNavigator * nav) const;
00121     virtual float getSelectPriority(const StelNavigator *nav) const;
00122     virtual Vec3f getInfoColor(void) const;
00123     virtual QString getType(void) const {return "Planet";}
00124     virtual Vec3d getJ2000EquatorialPos(const StelNavigator *nav) const;
00125     virtual QString getEnglishName(void) const {return englishName;}
00126     virtual QString getNameI18n(void) const {return nameI18;}
00127     virtual double getAngularSize(const StelCore* core) const;
00128     virtual bool hasAtmosphere(void) {return atmosphere;}
00129     
00131     // Methods of SolarSystem object
00133     void translateName(StelTranslator& trans) {nameI18 = trans.qtranslate(englishName);}
00134     
00135     // Draw the Planet
00136     void draw(StelCore* core, float maxMagLabels);
00137     
00139     // Methods specific to Planet
00141     void setParent(Planet* parent);
00142     
00145     double getRadius(void) const {return radius;}
00146     double getSiderealDay(void) const {return re.period;}
00147     
00148     const QString& getTextMapName() const {return texMapName;}
00149     
00150     // Compute the z rotation to use from equatorial to geographic coordinates
00151     double getSiderealTime(double jd) const;
00152     Mat4d getRotEquatorialToVsop87(void) const;
00153     void setRotEquatorialToVsop87(const Mat4d &m);
00154 
00155     const RotationElements &getRotationElements(void) const {return re;}
00156 
00157     // Compute the position in the parent Planet coordinate system
00158     void computePositionWithoutOrbits(const double date);
00159     void computePosition(const double date);
00160 
00161     // Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate
00162     void computeTransMatrix(double date);
00163 
00164     // Get the phase angle for an observer at pos obsPos in the heliocentric coordinate (in AU)
00165     double getPhase(Vec3d obsPos) const;
00166     // Get the angular size of the spheroid of the planet (i.e. without the rings)
00167     double getSpheroidAngularSize(const StelCore* core) const;
00168                 
00169     // Set the orbital elements
00170     void setRotationElements(float _period, float _offset, double _epoch,
00171         float _obliquity, float _ascendingNode, float _precessionRate, double _siderealPeriod);
00172     double getRotAscendingnode(void) const {return re.ascendingNode;}
00173     double getRotObliquity(void) const {return re.obliquity;}
00174 
00176     Vec3d getEclipticPos() const;
00177 
00178     // Return the heliocentric ecliptical position
00179     Vec3d getHeliocentricEclipticPos() const;
00180     void setHeliocentricEclipticPos(const Vec3d &pos);
00181 
00182     // Compute the distance to the given position in heliocentric coordinate (in AU)
00183     double computeDistance(const Vec3d& obsHelioPos);
00184     double getDistance(void) const {return distance;}
00185 
00186     void setRings(Ring* r) {rings = r;}
00187 
00188     void setSphereScale(float s) {sphereScale = s;}
00189     float getSphereScale(void) const {return sphereScale;}
00190 
00191     const Planet* getParent(void) const {return parent;}
00192 
00193     static void setFont(StelFont* f) {planetNameFont = f;}
00194     
00195     static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
00196     static const Vec3f& getLabelColor(void) {return labelColor;}
00197 
00198     void update(int deltaTime);
00199     
00200     void setFlagHints(bool b){hintFader = b;}
00201     bool getFlagHints(void) const {return hintFader;}
00202     
00203     void setFlagLabels(bool b){flagLabels = b;}
00204     bool getFlagLabels(void) const {return flagLabels;}
00205     
00207     // DEPRECATED
00208     
00210     // Should move to a TrailPath class which works on a StelObject, not on a Planet
00211     void updateTrail(const StelNavigator* nav);
00212     void drawTrail(const StelCore* core);
00214     void startTrail(bool b);
00215     void setFlagTrail(bool b){if(b == trailFader) return; trailFader = b; startTrail(b);}
00216     bool getFlagTrail(void) const {return trailFader;}
00217     static void setTrailColor(const Vec3f& c) { trailColor = c; }
00218     static const Vec3f& getTrailColor() { return trailColor; }
00219     static Vec3f trailColor;
00220     std::list<TrailPoint>trail;
00221     bool trailOn;                  // accumulate trail data if true
00222     double DeltaTrail;
00223     int MaxTrail;
00224     double lastTrailJD;
00225     bool firstPoint;               // if need to take first point of trail still
00226     LinearFader trailFader;
00227     
00229     // Should move to an OrbitPath class which works on a SolarSystemObject, not a Planet
00230     void setFlagOrbits(bool b){orbitFader = b;}
00231     bool getFlagOrbits(void) const {return orbitFader;}
00232     LinearFader orbitFader;
00233     // draw orbital path of Planet
00234     void drawOrbit(const StelCore*);
00235     Vec3d orbit[ORBIT_SEGMENTS];   // store heliocentric coordinates for drawing the orbit
00236     double lastOrbitJD;
00237     double deltaJD;
00238     double deltaOrbitJD;
00239     bool orbitCached;              // whether orbit calculations are cached for drawing orbit yet
00240     bool closeOrbit;               // whether to connect the beginning of the orbit line to
00241                                    // the end: good for elliptical orbits, bad for parabolic
00242                                    // and hyperbolic orbits
00243     
00244     static Vec3f orbitColor;
00245     static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
00246     static const Vec3f& getOrbitColor() {return orbitColor;}
00247     
00248 protected:
00249     static StelTextureSP texEarthShadow;     // for lunar eclipses
00250     
00251     // draw earth shadow on moon for lunar eclipses
00252     void drawEarthShadow(StelCore* core); 
00253     
00254     // Return the information string "ready to print" :)
00255     QString getSkyLabel(const StelNavigator * nav) const;
00256     
00257     // Draw the 3d model. Call the proper functions if there are rings etc..
00258     void draw3dModel(StelCore* core, const Mat4d& mat, float screenSz);
00259     
00260     // Draw the 3D sphere
00261     void drawSphere(const StelPainter* painter, float screenSz);
00262 
00263     // Draw the circle and name of the Planet
00264     void drawHints(const StelCore* core);
00265 
00266     QString englishName;            // english planet name
00267     QString nameI18;                // International translated name
00268     QString texMapName;             // Texture file path
00269     int flagLighting;               // Set wether light computation has to be proceed
00270     RotationElements re;            // Rotation param
00271     double radius;                  // Planet radius in UA
00272     double oneMinusOblateness;      // (polar radius)/(equatorial radius)
00273     Vec3d eclipticPos;             // Position in UA in the rectangular ecliptic coordinate system
00274                                     // centered on the parent Planet
00275     Vec3d screenPos;                // Used to store temporarily the 2D position on screen
00276     Vec3d previousScreenPos;        // The position of this planet in the previous frame.
00277     Vec3f color;
00278     float albedo;                   // Planet albedo
00279     Mat4d rotLocalToParent;
00280     float axisRotation;            // Rotation angle of the Planet on it's axis
00281     StelTextureSP texMap;             // Planet map texture
00282     Ring* rings;                    // Planet rings
00283     double distance;                // Temporary variable used to store the distance to a given point
00284                                     // it is used for sorting while drawing
00285     float sphereScale;             // Artificial scaling for better viewing
00286     double lastJD;
00287     // The callback for the calculation of the equatorial rect heliocentric position at time JD.
00288     posFuncType coordFunc;
00289     OsulatingFunctType *const osculatingFunc;
00290     const Planet *parent;           // Planet parent i.e. sun for earth
00291     QList<Planet*> satellites;      // satellites of the Planet
00292     LinearFader hintFader;
00293     LinearFader labelsFader;        // Store the current state of the label for this planet
00294     bool flagLabels;                // Define whether labels should be displayed
00295     bool hidden;                    // useful for fake planets used as observation positions - not drawn or labeled
00296     bool atmosphere;                // Does the planet have an atmosphere?
00297     
00298     static StelFont* planetNameFont; // Font for names
00299     static Vec3f labelColor;
00300     static StelTextureSP hintCircleTex;
00301 };
00302 
00303 #endif // _PLANET_HPP_
00304 

Generated on Mon Mar 9 16:16:16 2009 for Stellarium by  doxygen 1.5.5