Stellarium 0.13.2
Planet.hpp
1 /*
2  * Stellarium
3  * Copyright (C) 2002 Fabien Chereau
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
18  */
19 
20 #ifndef _PLANET_HPP_
21 #define _PLANET_HPP_
22 
23 #include "StelObject.hpp"
24 #include "StelProjector.hpp"
25 #include "VecMath.hpp"
26 #include "StelFader.hpp"
27 #include "StelTextureTypes.hpp"
28 #include "StelProjectorType.hpp"
29 
30 #include <QString>
31 
32 // The callback type for the external position computation function
33 // The last variable is the userData pointer.
34 typedef void (*posFuncType)(double, double*, void*);
35 
36 typedef void (OsculatingFunctType)(double jd0,double jd,double xyz[3]);
37 
38 // epoch J2000: 12 UT on 1 Jan 2000
39 #define J2000 2451545.0
40 #define ORBIT_SEGMENTS 360
41 
42 class StelFont;
43 class StelPainter;
44 class StelTranslator;
45 class QOpenGLShaderProgram;
46 
47 // Class used to store orbital elements
49 {
50 public:
51  RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquity(0.), ascendingNode(0.), precessionRate(0.), siderealPeriod(0.) {}
52  float period; // rotation period
53  float offset; // rotation at epoch
54  double epoch;
55  float obliquity; // tilt of rotation axis w.r.t. ecliptic
56  float ascendingNode; // long. of ascending node of equator on the ecliptic
57  float precessionRate; // rate of precession of rotation axis in rads/day
58  double siderealPeriod; // sidereal period (Planet year in earth days)
59 };
60 
61 // Class to manage rings for planets like saturn
62 class Ring
63 {
64 public:
65  Ring(float radiusMin, float radiusMax,const QString &texname);
66  double getSize(void) const {return radiusMax;}
67  const float radiusMin;
68  const float radiusMax;
69  StelTextureSP tex;
70 };
71 
72 
73 class Planet : public StelObject
74 {
75 public:
76  friend class SolarSystem;
77 
78  Q_ENUMS(PlanetType)
79  Q_ENUMS(ApparentMagnitudeAlgorithm)
81  // GZ: Until 0.13 QStrings were used for types.
82  // GZ: Enums are slightly faster than string comparisons in time-critical comparisons.
83  // GZ: If other types are introduced, add here and the string in init().
84  enum PlanetType
85  {
86  isStar, // ssystem.ini: type="star"
87  isPlanet, // ssystem.ini: type="planet"
88  isMoon, // ssystem.ini: type="moon"
89  isAsteroid, // ssystem.ini: type="asteroid"
90  isPlutoid, // ssystem.ini: type="plutoid"
91  isComet, // ssystem.ini: type="comet"
92  isUNDEFINED // ssystem.ini: type=<anything else>
93  };
94 
95  enum ApparentMagnitudeAlgorithm
96  {
97  Planesas, // Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
98  Mueller, // G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
99  Harris, // Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (D.L. Harris)
100  UndefinedAlgorithm
101  };
102 
103  Planet(const QString& englishName,
104  int flagLighting,
105  double radius,
106  double oblateness,
107  Vec3f color,
108  float albedo,
109  const QString& texMapName,
110  const QString& normalMapName,
111  posFuncType _coordFunc,
112  void* userDataPtr,
113  OsculatingFunctType *osculatingFunc,
114  bool closeOrbit,
115  bool hidden,
116  bool hasAtmosphere,
117  bool hasHalo,
118  const QString &pTypeStr);
119 
120  virtual ~Planet();
121 
123  // Currently ensured by SolarSystem::init()
124  static void init();
125 
127  // Methods inherited from StelObject
141  virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
142  virtual double getCloseViewFov(const StelCore* core) const;
143  virtual double getSatellitesFov(const StelCore* core) const;
144  virtual double getParentSatellitesFov(const StelCore* core) const;
145  virtual float getVMagnitude(const StelCore* core) const;
146  virtual float getSelectPriority(const StelCore* core) const;
147  virtual Vec3f getInfoColor(void) const;
148  virtual QString getType(void) const {return "Planet";}
149  virtual Vec3d getJ2000EquatorialPos(const StelCore *core) const;
150  virtual QString getEnglishName(void) const;
151  virtual QString getNameI18n(void) const;
152  virtual double getAngularSize(const StelCore* core) const;
153  virtual bool hasAtmosphere(void) {return atmosphere;}
154  virtual bool hasHalo(void) {return halo;}
155 
157  // Methods of SolarSystem object
159  virtual void translateName(const StelTranslator &trans);
160 
161  // Draw the Planet
162  // GZ Made that virtual to allow comets having their own draw().
163  virtual void draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont);
164 
166  // Methods specific to Planet
169  double getRadius(void) const {return radius;}
171  double getSiderealDay(void) const {return re.period;}
173  // GZ: made that virtual for Comets.
174  virtual double getSiderealPeriod(void) const { return re.siderealPeriod; }
176  double getMeanSolarDay(void) const;
177 
178  const QString& getTextMapName() const {return texMapName;}
179  const QString getPlanetTypeString() const {return pTypeMap.value(pType);}
180  PlanetType getPlanetType() const {return pType;}
181 
182  void setNativeName(QString planet) { nativeName = planet; }
183 
184  ApparentMagnitudeAlgorithm getApparentMagnitudeAlgorithm() const { return vMagAlgorithm; }
185  const QString getApparentMagnitudeAlgorithmString() const { return vMagAlgorithmMap.value(vMagAlgorithm); }
186  void setApparentMagnitudeAlgorithm(QString algorithm);
187 
188  // Compute the z rotation to use from equatorial to geographic coordinates
189  double getSiderealTime(double jd) const;
190  Mat4d getRotEquatorialToVsop87(void) const;
191  void setRotEquatorialToVsop87(const Mat4d &m);
192 
193  const RotationElements &getRotationElements(void) const {return re;}
194 
195  // Compute the position in the parent Planet coordinate system
196  void computePositionWithoutOrbits(const double dateJD);
197  //virtual void computePosition(const double dateJD);// GZ: gets overridden in Comet!
198  void computePosition(const double dateJD);// GZ: gets overridden in Comet!
199 
200  // Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate
201  void computeTransMatrix(double date);
202 
203  // Get the phase angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
204  double getPhaseAngle(const Vec3d& obsPos) const;
205  // Get the elongation angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
206  double getElongation(const Vec3d& obsPos) const;
207  // Get the angular size of the spheroid of the planet (i.e. without the rings)
208  double getSpheroidAngularSize(const StelCore* core) const;
209  // Get the planet phase for an observer at pos obsPos in heliocentric coordinates (in AU)
210  float getPhase(const Vec3d& obsPos) const;
211 
212  // Set the orbital elements
213  void setRotationElements(float _period, float _offset, double _epoch,
214  float _obliquity, float _ascendingNode,
215  float _precessionRate, double _siderealPeriod);
216  double getRotAscendingnode(void) const {return re.ascendingNode;}
217  double getRotObliquity(double JDay) const;
218 
220  Vec3d getEclipticPos() const;
221 
222  // Return the heliocentric ecliptical position
223  Vec3d getHeliocentricEclipticPos() const;
224 
225  // Return the heliocentric transformation for local coordinate
226  Vec3d getHeliocentricPos(Vec3d) const;
227  void setHeliocentricEclipticPos(const Vec3d &pos);
228 
229  // Compute the distance to the given position in heliocentric coordinate (in AU)
230  double computeDistance(const Vec3d& obsHelioPos);
231  double getDistance(void) const {return distance;}
232 
233  void setRings(Ring* r) {rings = r;}
234 
235  void setSphereScale(float s) {sphereScale = s;}
236  float getSphereScale(void) const {return sphereScale;}
237 
238  const QSharedPointer<Planet> getParent(void) const {return parent;}
239 
240  static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
241  static const Vec3f& getLabelColor(void) {return labelColor;}
242 
243  // update displayed elements. @param deltaTime: ms (since last call)
244  virtual void update(int deltaTime);
245 
246  void setFlagHints(bool b){hintFader = b;}
247  bool getFlagHints(void) const {return hintFader;}
248 
249  void setFlagLabels(bool b){flagLabels = b;}
250  bool getFlagLabels(void) const {return flagLabels;}
251 
252  bool flagNativeName;
253  void setFlagNativeName(bool b) { flagNativeName = b; }
254  bool getFlagNativeName(void) { return flagNativeName; }
255 
256  bool flagTranslatedName;
257  void setFlagTranslatedName(bool b) { flagTranslatedName = b; }
258  bool getFlagTranslatedName(void) { return flagTranslatedName; }
259 
261  // DEPRECATED
263  // Should move to an OrbitPath class which works on a SolarSystemObject, not a Planet
264  void setFlagOrbits(bool b){orbitFader = b;}
265  bool getFlagOrbits(void) const {return orbitFader;}
266  LinearFader orbitFader;
267  // draw orbital path of Planet
268  void drawOrbit(const StelCore*);
269  Vec3d orbit[ORBIT_SEGMENTS+1]; // store heliocentric coordinates for drawing the orbit
270  Vec3d orbitP[ORBIT_SEGMENTS+1]; // store local coordinate for orbit
271  double lastOrbitJD;
272  double deltaJD; // time difference between positional updates.
273  double deltaOrbitJD;
274  bool orbitCached; // whether orbit calculations are cached for drawing orbit yet
275  bool closeOrbit; // whether to connect the beginning of the orbit line to
276  // the end: good for elliptical orbits, bad for parabolic
277  // and hyperbolic orbits
278 
279  static Vec3f orbitColor;
280  static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
281  static const Vec3f& getOrbitColor() {return orbitColor;}
282 
284  QVector<const Planet*> getCandidatesForShadow() const;
285 
286 protected:
287  static StelTextureSP texEarthShadow; // for lunar eclipses
288 
289  void computeModelMatrix(Mat4d &result) const;
290 
291  // Return the information string "ready to print" :)
292  QString getSkyLabel(const StelCore* core) const;
293 
294  // Draw the 3d model. Call the proper functions if there are rings etc..
295  void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing=false);
296 
297  // Draw the 3D sphere
298  void drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing=false);
299 
300  // Draw the circle and name of the Planet
301  void drawHints(const StelCore* core, const QFont& planetNameFont);
302 
303  QString englishName; // english planet name
304  QString nameI18; // International translated name
305  QString nativeName; // Can be used in a skyculture
306  QString texMapName; // Texture file path
307  QString normalMapName; // Texture file path
308  int flagLighting; // Set whether light computation has to be proceed
309  RotationElements re; // Rotation param
310  double radius; // Planet radius in AU
311  double oneMinusOblateness; // (polar radius)/(equatorial radius)
312  Vec3d eclipticPos; // Position in AU in the rectangular ecliptic coordinate system
313  // centered on the parent Planet
314  Vec3d screenPos; // Used to store temporarily the 2D position on screen
315  Vec3d previousScreenPos; // The position of this planet in the previous frame.
316  Vec3f color; // exclusively used for drawing the planet halo
317 
318  float albedo; // Planet albedo. Used for magnitude computation (but formula dubious!)
319  Mat4d rotLocalToParent;
320  float axisRotation; // Rotation angle of the Planet on it's axis
321  StelTextureSP texMap; // Planet map texture
322  StelTextureSP normalMap; // Planet normal map texture
323 
324  Ring* rings; // Planet rings
325  double distance; // Temporary variable used to store the distance to a given point
326  // it is used for sorting while drawing
327  float sphereScale; // Artificial scaling for better viewing
328  double lastJD; // caches JD of last positional computation
329  // The callback for the calculation of the equatorial rect heliocentric position at time JD.
330  posFuncType coordFunc;
331  void* userDataPtr;
332 
333  OsculatingFunctType *const osculatingFunc;
334  QSharedPointer<Planet> parent; // Planet parent i.e. sun for earth
335  QList<QSharedPointer<Planet> > satellites; // satellites of the Planet
336  LinearFader hintFader;
337  LinearFader labelsFader; // Store the current state of the label for this planet
338  bool flagLabels; // Define whether labels should be displayed
339  bool hidden; // useful for fake planets used as observation positions - not drawn or labeled
340  bool atmosphere; // Does the planet have an atmosphere?
341  bool halo; // Does the planet have a halo?
342  PlanetType pType; // Type of body
343 
344  ApparentMagnitudeAlgorithm vMagAlgorithm;
345 
346  static Vec3f labelColor;
347  static StelTextureSP hintCircleTex;
348  static QMap<PlanetType, QString> pTypeMap; // Maps fast type to english name.
349  static QMap<ApparentMagnitudeAlgorithm, QString> vMagAlgorithmMap;
350 
351  // Shader-related variables
353  int projectionMatrix;
354  int texCoord;
355  int unprojectedVertex;
356  int vertex;
357  int texture;
358  int lightDirection;
359  int eyeDirection;
360  int diffuseLight;
361  int ambientLight;
362  int shadowCount;
363  int shadowData;
364  int sunInfo;
365 
366  void initLocations(QOpenGLShaderProgram*);
367  };
368  static PlanetShaderVars planetShaderVars;
369  static QOpenGLShaderProgram* planetShaderProgram;
370 
371  // Shader-related variables
373  // Rings-specific variables
374  int isRing;
375  int ring;
376  int outerRadius;
377  int innerRadius;
378  int ringS;
379  };
380  static RingPlanetShaderVars ringPlanetShaderVars;
381  static QOpenGLShaderProgram* ringPlanetShaderProgram;
382 
384  // Moon-specific variables
385  int earthShadow;
386  int normalMap;
387  };
388  static MoonShaderVars moonShaderVars;
389  static QOpenGLShaderProgram* moonShaderProgram;
390 
391  static void initShader();
392  static void deinitShader();
393 };
394 
395 #endif // _PLANET_HPP_
396 
Q_ENUMS(PlanetType) Q_ENUMS(ApparentMagnitudeAlgorithm) enum PlanetType
numeric typecodes for the type descriptions in ssystem.ini
Definition: Planet.hpp:78
QVector< const Planet * > getCandidatesForShadow() const
Return the list of planets which project some shadow on this planet.
virtual void update(double deltaTime)
Update time-varying components.
void setFlagOrbits(bool b)
Set flag which determines if planet orbits are drawn or hidden.
double getMeanSolarDay(void) const
Get duration of mean solar day.
virtual double getSiderealPeriod(void) const
Get duration of sidereal year.
Definition: Planet.hpp:174
Class used to translate strings to any language.
Implementation of StelFader which implements a linear transition.
Definition: StelFader.hpp:77
The base abstract class for sky objects used in Stellarium like Stars, Planets, Constellations etc...
Definition: StelObject.hpp:36
virtual QString getNameI18n(void) const
Return translated object's name.
Define the StelTextureSP type.
virtual double getAngularSize(const StelCore *core) const
Return the angular radius of a circle containing the object as seen from the observer with the circle...
virtual Vec3f getInfoColor(void) const
Get a color used to display info about the object.
Main class for Stellarium core processing.
Definition: StelCore.hpp:46
void setFlagHints(bool b)
Set flag which determines if planet hints are drawn or hidden along labels.
void setFlagLabels(bool b)
Set flag which determines if planet labels are drawn or hidden.
bool getFlagLabels() const
Get the current value of the flag which determines if planet labels are drawn or hidden.
double getRadius(void) const
Get the radius of the planet in AU.
Definition: Planet.hpp:169
virtual QString getEnglishName(void) const
Return object's name in english.
This StelObjectModule derivative is used to model SolarSystem bodies.
Definition: SolarSystem.hpp:46
virtual QString getInfoString(const StelCore *core, const InfoStringGroup &flags) const
Get a string with data about the Planet.
Definition: Planet.hpp:62
A templatized column-major 4x4 matrix compatible with openGL.
Definition: VecMath.hpp:33
virtual double getCloseViewFov(const StelCore *core) const
Return the best FOV in degree to use for a close view of the object.
double getSiderealDay(void) const
Get duration of sidereal day.
Definition: Planet.hpp:171
virtual double getSatellitesFov(const StelCore *core) const
Return the best FOV in degree to use for a global view of the object satellite system (if there are s...
virtual Vec3d getJ2000EquatorialPos(const StelCore *core) const
Get observer-centered equatorial coordinates at equinox J2000.
Provides functions for performing openGL drawing operations.
Definition: StelPainter.hpp:40
virtual void translateName(const StelTranslator &trans)
Translate planet name using the passed translator.
virtual float getVMagnitude(const StelCore *core) const
Return object's apparent V magnitude as seen from observer, without including extinction.
QSharedPointer< ModelViewTranform > ModelViewTranformP
Shared pointer on a ModelViewTranform instance (implement reference counting)
bool getFlagOrbits() const
Get the current value of the flag which determines if planet orbits are drawn or hidden.
static void init()
Initializes static vars. Must be called before creating first planet.
A templatized 3d vector compatible with openGL.
Definition: VecMath.hpp:31
Define the StelProjectorP type.
virtual QString getType(void) const
Return object's type. It should be the name of the class.
Definition: Planet.hpp:148
Vec3d getEclipticPos() const
Get the Planet position in the parent Planet ecliptic coordinate in AU.
QSharedPointer< StelTexture > StelTextureSP
Use shared pointer to simplify memory managment.
bool getFlagHints() const
Get the current value of the flag which determines if planet hints are drawn or hidden along labels...
QString getPlanetType(QString planetName) const
Get type for Solar system bodies from scripts.
virtual float getSelectPriority(const StelCore *core) const
Return a priority value which is used to discriminate objects by priority As for magnitudes, the lower is the higher priority.
virtual void draw(StelCore *core)
Draw SolarSystem objects (planets).