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