Stellarium 0.13.1
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  Planet(const QString& englishName,
78  int flagLighting,
79  double radius,
80  double oblateness,
81  Vec3f color,
82  float albedo,
83  const QString& texMapName,
84  const QString& normalMapName,
85  posFuncType _coordFunc,
86  void* userDataPtr,
87  OsculatingFunctType *osculatingFunc,
88  bool closeOrbit,
89  bool hidden,
90  bool hasAtmosphere,
91  bool hasHalo,
92  const QString &pType);
93 
94  virtual ~Planet();
95 
97  // Methods inherited from StelObject
111  virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
112  virtual double getCloseViewFov(const StelCore* core) const;
113  virtual double getSatellitesFov(const StelCore* core) const;
114  virtual double getParentSatellitesFov(const StelCore* core) const;
115  virtual float getVMagnitude(const StelCore* core) const;
116  virtual float getSelectPriority(const StelCore* core) const;
117  virtual Vec3f getInfoColor(void) const;
118  virtual QString getType(void) const {return "Planet";}
119  virtual Vec3d getJ2000EquatorialPos(const StelCore *core) const;
120  virtual QString getEnglishName(void) const {return englishName;}
121  virtual QString getNameI18n(void) const {return nameI18;}
122  virtual double getAngularSize(const StelCore* core) const;
123  virtual bool hasAtmosphere(void) {return atmosphere;}
124  virtual bool hasHalo(void) {return halo;}
125 
127  // Methods of SolarSystem object
129  virtual void translateName(const StelTranslator &trans);
130 
131  // Draw the Planet
132  // GZ Made that virtual to allow comets having their own draw().
133  virtual void draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont);
134 
136  // Methods specific to Planet
139  double getRadius(void) const {return radius;}
141  double getSiderealDay(void) const {return re.period;}
143  // GZ: made that virtual for Comets.
144  virtual double getSiderealPeriod(void) const { return re.siderealPeriod; }
146  double getMeanSolarDay(void) const;
147 
148  const QString& getTextMapName() const {return texMapName;}
149  const QString getPlanetType() const {return pType;}
150 
151  // Compute the z rotation to use from equatorial to geographic coordinates
152  double getSiderealTime(double jd) const;
153  Mat4d getRotEquatorialToVsop87(void) const;
154  void setRotEquatorialToVsop87(const Mat4d &m);
155 
156  const RotationElements &getRotationElements(void) const {return re;}
157 
158  // Compute the position in the parent Planet coordinate system
159  void computePositionWithoutOrbits(const double dateJD);
160  virtual void computePosition(const double dateJD);// GZ: gets overridden in Comet!
161 
162  // Compute the transformation matrix from the local Planet coordinate to the parent Planet coordinate
163  void computeTransMatrix(double date);
164 
165  // Get the phase angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
166  double getPhaseAngle(const Vec3d& obsPos) const;
167  // Get the elongation angle (rad) for an observer at pos obsPos in heliocentric coordinates (in AU)
168  double getElongation(const Vec3d& obsPos) const;
169  // Get the angular size of the spheroid of the planet (i.e. without the rings)
170  double getSpheroidAngularSize(const StelCore* core) const;
171  // Get the planet phase for an observer at pos obsPos in heliocentric coordinates (in AU)
172  float getPhase(const Vec3d& obsPos) const;
173 
174  // Set the orbital elements
175  void setRotationElements(float _period, float _offset, double _epoch,
176  float _obliquity, float _ascendingNode,
177  float _precessionRate, double _siderealPeriod);
178  double getRotAscendingnode(void) const {return re.ascendingNode;}
179  double getRotObliquity(double JDay) const;
180 
182  Vec3d getEclipticPos() const;
183 
184  // Return the heliocentric ecliptical position
185  Vec3d getHeliocentricEclipticPos() const;
186 
187  // Return the heliocentric transformation for local coordinate
188  Vec3d getHeliocentricPos(Vec3d) const;
189  void setHeliocentricEclipticPos(const Vec3d &pos);
190 
191  // Compute the distance to the given position in heliocentric coordinate (in AU)
192  double computeDistance(const Vec3d& obsHelioPos);
193  double getDistance(void) const {return distance;}
194 
195  void setRings(Ring* r) {rings = r;}
196 
197  void setSphereScale(float s) {sphereScale = s;}
198  float getSphereScale(void) const {return sphereScale;}
199 
200  const QSharedPointer<Planet> getParent(void) const {return parent;}
201 
202  static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
203  static const Vec3f& getLabelColor(void) {return labelColor;}
204 
205  // update displayed elements. @param deltaTime: ms (?)
206  void update(int deltaTime);
207 
208  void setFlagHints(bool b){hintFader = b;}
209  bool getFlagHints(void) const {return hintFader;}
210 
211  void setFlagLabels(bool b){flagLabels = b;}
212  bool getFlagLabels(void) const {return flagLabels;}
213 
215  // DEPRECATED
217  // Should move to an OrbitPath class which works on a SolarSystemObject, not a Planet
218  void setFlagOrbits(bool b){orbitFader = b;}
219  bool getFlagOrbits(void) const {return orbitFader;}
220  LinearFader orbitFader;
221  // draw orbital path of Planet
222  void drawOrbit(const StelCore*);
223  Vec3d orbit[ORBIT_SEGMENTS+1]; // store heliocentric coordinates for drawing the orbit
224  Vec3d orbitP[ORBIT_SEGMENTS+1]; // store local coordinate for orbit
225  double lastOrbitJD;
226  double deltaJD; // time difference between positional updates.
227  double deltaOrbitJD;
228  bool orbitCached; // whether orbit calculations are cached for drawing orbit yet
229  bool closeOrbit; // whether to connect the beginning of the orbit line to
230  // the end: good for elliptical orbits, bad for parabolic
231  // and hyperbolic orbits
232 
233  static Vec3f orbitColor;
234  static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
235  static const Vec3f& getOrbitColor() {return orbitColor;}
236 
238  QVector<const Planet*> getCandidatesForShadow() const;
239 
240 protected:
241  static StelTextureSP texEarthShadow; // for lunar eclipses
242 
243  void computeModelMatrix(Mat4d &result) const;
244 
245  // Return the information string "ready to print" :)
246  QString getSkyLabel(const StelCore* core) const;
247 
248  // Draw the 3d model. Call the proper functions if there are rings etc..
249  void draw3dModel(StelCore* core, StelProjector::ModelViewTranformP transfo, float screenSz, bool drawOnlyRing=false);
250 
251  // Draw the 3D sphere
252  void drawSphere(StelPainter* painter, float screenSz, bool drawOnlyRing=false);
253 
254  // Draw the circle and name of the Planet
255  void drawHints(const StelCore* core, const QFont& planetNameFont);
256 
257  QString englishName; // english planet name
258  QString nameI18; // International translated name
259  QString texMapName; // Texture file path
260  QString normalMapName; // Texture file path
261  int flagLighting; // Set whether light computation has to be proceed
262  RotationElements re; // Rotation param
263  double radius; // Planet radius in AU
264  double oneMinusOblateness; // (polar radius)/(equatorial radius)
265  Vec3d eclipticPos; // Position in AU in the rectangular ecliptic coordinate system
266  // centered on the parent Planet
267  Vec3d screenPos; // Used to store temporarily the 2D position on screen
268  Vec3d previousScreenPos; // The position of this planet in the previous frame.
269  Vec3f color; // exclusively used for drawing the planet halo
270 
271  float albedo; // Planet albedo. Used for magnitude computation (but formula dubious!)
272  Mat4d rotLocalToParent;
273  float axisRotation; // Rotation angle of the Planet on it's axis
274  StelTextureSP texMap; // Planet map texture
275  StelTextureSP normalMap; // Planet normal map texture
276 
277  Ring* rings; // Planet rings
278  double distance; // Temporary variable used to store the distance to a given point
279  // it is used for sorting while drawing
280  float sphereScale; // Artificial scaling for better viewing
281  double lastJD; // caches JD of last positional computation
282  // The callback for the calculation of the equatorial rect heliocentric position at time JD.
283  posFuncType coordFunc;
284  void* userDataPtr;
285 
286  OsculatingFunctType *const osculatingFunc;
287  QSharedPointer<Planet> parent; // Planet parent i.e. sun for earth
288  QList<QSharedPointer<Planet> > satellites; // satellites of the Planet
289  LinearFader hintFader;
290  LinearFader labelsFader; // Store the current state of the label for this planet
291  bool flagLabels; // Define whether labels should be displayed
292  bool hidden; // useful for fake planets used as observation positions - not drawn or labeled
293  bool atmosphere; // Does the planet have an atmosphere?
294  bool halo; // Does the planet have a halo?
295  QString pType; // Type of body
296 
297  static Vec3f labelColor;
298  static StelTextureSP hintCircleTex;
299 
300  // Shader-related variables
302  int projectionMatrix;
303  int texCoord;
304  int unprojectedVertex;
305  int vertex;
306  int texture;
307  int lightDirection;
308  int eyeDirection;
309  int diffuseLight;
310  int ambientLight;
311  int shadowCount;
312  int shadowData;
313  int sunInfo;
314 
315  void initLocations(QOpenGLShaderProgram*);
316  };
317  static PlanetShaderVars planetShaderVars;
318  static QOpenGLShaderProgram* planetShaderProgram;
319 
320  // Shader-related variables
322  // Rings-specific variables
323  int isRing;
324  int ring;
325  int outerRadius;
326  int innerRadius;
327  int ringS;
328  };
329  static RingPlanetShaderVars ringPlanetShaderVars;
330  static QOpenGLShaderProgram* ringPlanetShaderProgram;
331 
333  // Moon-specific variables
334  int earthShadow;
335  int normalMap;
336  };
337  static MoonShaderVars moonShaderVars;
338  static QOpenGLShaderProgram* moonShaderProgram;
339 
340  static void initShader();
341  static void deinitShader();
342 
343 };
344 
345 #endif // _PLANET_HPP_
346 
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:144
Class used to translate strings to any language.
Implementation of StelFader which implements a linear transition.
Definition: StelFader.hpp:79
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.
Definition: Planet.hpp:121
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:139
virtual QString getEnglishName(void) const
Return object's name in english.
Definition: Planet.hpp:120
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:35
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:141
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.
A templatized 3d vector compatible with openGL.
Definition: VecMath.hpp:33
Define the StelProjectorP type.
virtual QString getType(void) const
Return object's type. It should be the name of the class.
Definition: Planet.hpp:118
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).