Stellarium 0.14.0
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 rotational elements, i.e. axis orientation for the planetary body.
49 {
50 public:
51  RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquity(0.), ascendingNode(0.), precessionRate(0.), siderealPeriod(0.) {}
52  float period; // (sidereal) rotation period [earth days]
53  float offset; // rotation at epoch [degrees]
54  double epoch; // JD (TD) of epoch for these elements
55  float obliquity; // tilt of rotation axis w.r.t. ecliptic [radians]
56  float ascendingNode; // long. of ascending node of equator on the ecliptic [radians]
57  float precessionRate; // rate of precession of rotation axis in [rads/JulianCentury(36525d)]
58  double siderealPeriod; // sidereal period (Planet year in earth days) [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  isPlutino, // ssystem.ini: type="plutino"
91  isComet, // ssystem.ini: type="comet"
92  isDwarfPlanet, // ssystem.ini: type="dwarf planet"
93  isCubewano, // ssystem.ini: type="cubewano"
94  isSDO, // ssystem.ini: type="sdo"
95  isOCO, // ssystem.ini: type="oco"
96  isUNDEFINED // ssystem.ini: type=<anything else>
97  };
98 
99  enum ApparentMagnitudeAlgorithm
100  {
101  Planesas, // Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
102  Mueller, // G. Mueller, based on visual observations 1877-91. [Expl.Suppl.1961]
103  Harris, // Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes (D.L. Harris)
104  UndefinedAlgorithm,
105  Generic // Visual magnitude based on phase angle and albedo
106  };
107 
108  Planet(const QString& englishName,
109  int flagLighting,
110  double radius,
111  double oblateness,
112  Vec3f color,
113  float albedo,
114  const QString& texMapName,
115  const QString& normalMapName,
116  posFuncType _coordFunc,
117  void* userDataPtr,
118  OsculatingFunctType *osculatingFunc,
119  bool closeOrbit,
120  bool hidden,
121  bool hasAtmosphere,
122  bool hasHalo,
123  const QString &pTypeStr);
124 
125  virtual ~Planet();
126 
128  // Currently ensured by SolarSystem::init()
129  static void init();
130 
132  // Methods inherited from StelObject
146  virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
147  virtual double getCloseViewFov(const StelCore* core) const;
148  virtual double getSatellitesFov(const StelCore* core) const;
149  virtual double getParentSatellitesFov(const StelCore* core) const;
150  virtual float getVMagnitude(const StelCore* core) const;
151  virtual float getSelectPriority(const StelCore* core) const;
152  virtual Vec3f getInfoColor(void) const;
153  virtual QString getType(void) const {return "Planet";}
154  virtual Vec3d getJ2000EquatorialPos(const StelCore *core) const;
155  virtual QString getEnglishName(void) const;
156  virtual QString getNameI18n(void) const;
157  virtual double getAngularSize(const StelCore* core) const;
158  virtual bool hasAtmosphere(void) {return atmosphere;}
159  virtual bool hasHalo(void) {return halo;}
160 
162  // Methods of SolarSystem object
164  virtual void translateName(const StelTranslator &trans);
165 
166  // Draw the Planet
167  // GZ Made that virtual to allow comets having their own draw().
168  virtual void draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont);
169 
171  // Methods specific to Planet
174  double getRadius(void) const {return radius;}
176  double getSiderealDay(void) const {return re.period;}
178  // GZ: made that virtual for Comets.
179  virtual double getSiderealPeriod(void) const { return re.siderealPeriod; }
181  double getMeanSolarDay(void) const;
182 
183  const QString& getTextMapName() const {return texMapName;}
184  const QString getPlanetTypeString() const {return pTypeMap.value(pType);}
185  PlanetType getPlanetType() const {return pType;}
186 
187  void setNativeName(QString planet) { nativeName = planet; }
188 
189  ApparentMagnitudeAlgorithm getApparentMagnitudeAlgorithm() const { return vMagAlgorithm; }
190  const QString getApparentMagnitudeAlgorithmString() const { return vMagAlgorithmMap.value(vMagAlgorithm); }
191  void setApparentMagnitudeAlgorithm(QString algorithm);
192 
193  // Compute the z rotation to use from equatorial to geographic coordinates
194  double getSiderealTime(double jd) const;
195  Mat4d getRotEquatorialToVsop87(void) const;
196  void setRotEquatorialToVsop87(const Mat4d &m);
197 
198  const RotationElements &getRotationElements(void) const {return re;}
199 
200  // Compute the position in the parent Planet coordinate system
201  void computePositionWithoutOrbits(const double dateJD);
202  //virtual void computePosition(const double dateJD);// GZ: gets overridden in Comet!
203  void computePosition(const double dateJD);// GZ: gets overridden in Comet!
204 
205  // Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate
206  void computeTransMatrix(double date);
207 
208  // Get the phase angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
209  double getPhaseAngle(const Vec3d& obsPos) const;
210  // Get the elongation angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
211  double getElongation(const Vec3d& obsPos) const;
212  // Get the angular size of the spheroid of the planet (i.e. without the rings)
213  double getSpheroidAngularSize(const StelCore* core) const;
214  // Get the planet phase for an observer at pos obsPos in heliocentric coordinates (in AU)
215  float getPhase(const Vec3d& obsPos) const;
216 
217  // Set the orbital elements
218  void setRotationElements(float _period, float _offset, double _epoch,
219  float _obliquity, float _ascendingNode,
220  float _precessionRate, double _siderealPeriod);
221  double getRotAscendingnode(void) const {return re.ascendingNode;}
222  double getRotObliquity(double JDay) const;
223 
225  Vec3d getEclipticPos() const;
226 
227  // Return the heliocentric ecliptical position
228  Vec3d getHeliocentricEclipticPos() const;
229 
230  // Return the heliocentric transformation for local coordinate
231  Vec3d getHeliocentricPos(Vec3d) const;
232  void setHeliocentricEclipticPos(const Vec3d &pos);
233 
234  // Compute the distance to the given position in heliocentric coordinate (in AU)
235  double computeDistance(const Vec3d& obsHelioPos);
236  double getDistance(void) const {return distance;}
237 
238  void setRings(Ring* r) {rings = r;}
239 
240  void setSphereScale(float s) {sphereScale = s;}
241  float getSphereScale(void) const {return sphereScale;}
242 
243  const QSharedPointer<Planet> getParent(void) const {return parent;}
244 
245  static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
246  static const Vec3f& getLabelColor(void) {return labelColor;}
247 
248  // update displayed elements. @param deltaTime: ms (since last call)
249  virtual void update(int deltaTime);
250 
251  void setFlagHints(bool b){hintFader = b;}
252  bool getFlagHints(void) const {return hintFader;}
253 
254  void setFlagLabels(bool b){flagLabels = b;}
255  bool getFlagLabels(void) const {return flagLabels;}
256 
257  bool flagNativeName;
258  void setFlagNativeName(bool b) { flagNativeName = b; }
259  bool getFlagNativeName(void) { return flagNativeName; }
260 
261  bool flagTranslatedName;
262  void setFlagTranslatedName(bool b) { flagTranslatedName = b; }
263  bool getFlagTranslatedName(void) { return flagTranslatedName; }
264 
266  // DEPRECATED
268  // Should move to an OrbitPath class which works on a SolarSystemObject, not a Planet
269  void setFlagOrbits(bool b){orbitFader = b;}
270  bool getFlagOrbits(void) const {return orbitFader;}
271  LinearFader orbitFader;
272  // draw orbital path of Planet
273  void drawOrbit(const StelCore*);
274  Vec3d orbit[ORBIT_SEGMENTS+1]; // store heliocentric coordinates for drawing the orbit
275  Vec3d orbitP[ORBIT_SEGMENTS+1]; // store local coordinate for orbit
276  double lastOrbitJD;
277  double deltaJD; // time difference between positional updates.
278  double deltaOrbitJD;
279  bool orbitCached; // whether orbit calculations are cached for drawing orbit yet
280  bool closeOrbit; // whether to connect the beginning of the orbit line to
281  // the end: good for elliptical orbits, bad for parabolic
282  // and hyperbolic orbits
283 
284  static Vec3f orbitColor;
285  static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
286  static const Vec3f& getOrbitColor() {return orbitColor;}
287 
289  QVector<const Planet*> getCandidatesForShadow() const;
290 
291 protected:
292  static StelTextureSP texEarthShadow; // for lunar eclipses
293 
294  void computeModelMatrix(Mat4d &result) const;
295 
296  // Return the information string "ready to print" :)
297  QString getSkyLabel(const StelCore* core) const;
298 
299  // Draw the 3d model. Call the proper functions if there are rings etc..
300  void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing=false);
301 
302  // Draw the 3D sphere
303  void drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing=false);
304 
305  // Draw the circle and name of the Planet
306  void drawHints(const StelCore* core, const QFont& planetNameFont);
307 
308  QString englishName; // english planet name
309  QString nameI18; // International translated name
310  QString nativeName; // Can be used in a skyculture
311  QString texMapName; // Texture file path
312  QString normalMapName; // Texture file path
313  int flagLighting; // Set whether light computation has to be proceed
314  RotationElements re; // Rotation param
315  double radius; // Planet radius in AU
316  double oneMinusOblateness; // (polar radius)/(equatorial radius)
317  Vec3d eclipticPos; // Position in AU in the rectangular ecliptic coordinate system
318  // centered on the parent Planet
319  Vec3d screenPos; // Used to store temporarily the 2D position on screen
320  Vec3d previousScreenPos; // The position of this planet in the previous frame.
321  Vec3f color; // exclusively used for drawing the planet halo
322 
323  float albedo; // Planet albedo. Used for magnitude computation (but formula dubious!)
324  Mat4d rotLocalToParent;
325  float axisRotation; // Rotation angle of the Planet on it's axis
326  StelTextureSP texMap; // Planet map texture
327  StelTextureSP normalMap; // Planet normal map texture
328 
329  Ring* rings; // Planet rings
330  double distance; // Temporary variable used to store the distance to a given point
331  // it is used for sorting while drawing
332  float sphereScale; // Artificial scaling for better viewing
333  double lastJD; // caches JD of last positional computation
334  // The callback for the calculation of the equatorial rect heliocentric position at time JD.
335  posFuncType coordFunc;
336  void* userDataPtr;
337 
338  OsculatingFunctType *const osculatingFunc;
339  QSharedPointer<Planet> parent; // Planet parent i.e. sun for earth
340  QList<QSharedPointer<Planet> > satellites; // satellites of the Planet
341  LinearFader hintFader;
342  LinearFader labelsFader; // Store the current state of the label for this planet
343  bool flagLabels; // Define whether labels should be displayed
344  bool hidden; // useful for fake planets used as observation positions - not drawn or labeled
345  bool atmosphere; // Does the planet have an atmosphere?
346  bool halo; // Does the planet have a halo?
347  PlanetType pType; // Type of body
348 
349  ApparentMagnitudeAlgorithm vMagAlgorithm;
350 
351  static Vec3f labelColor;
352  static StelTextureSP hintCircleTex;
353  static QMap<PlanetType, QString> pTypeMap; // Maps fast type to english name.
354  static QMap<ApparentMagnitudeAlgorithm, QString> vMagAlgorithmMap;
355 
356  // Shader-related variables
358  int projectionMatrix;
359  int texCoord;
360  int unprojectedVertex;
361  int vertex;
362  int texture;
363  int lightDirection;
364  int eyeDirection;
365  int diffuseLight;
366  int ambientLight;
367  int shadowCount;
368  int shadowData;
369  int sunInfo;
370 
371  void initLocations(QOpenGLShaderProgram*);
372  };
373  static PlanetShaderVars planetShaderVars;
374  static QOpenGLShaderProgram* planetShaderProgram;
375 
376  // Shader-related variables
378  // Rings-specific variables
379  int isRing;
380  int ring;
381  int outerRadius;
382  int innerRadius;
383  int ringS;
384  };
385  static RingPlanetShaderVars ringPlanetShaderVars;
386  static QOpenGLShaderProgram* ringPlanetShaderProgram;
387 
389  // Moon-specific variables
390  int earthShadow;
391  int normalMap;
392  };
393  static MoonShaderVars moonShaderVars;
394  static QOpenGLShaderProgram* moonShaderProgram;
395 
396  static void initShader();
397  static void deinitShader();
398 };
399 
400 #endif // _PLANET_HPP_
401 
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:179
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:174
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
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:176
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.
Define the StelProjectorP type.
virtual QString getType(void) const
Return object's type. It should be the name of the class.
Definition: Planet.hpp:153
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).