Planet.hpp   Planet.hpp 
skipping to change at line 26 skipping to change at line 26
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, U SA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, U SA.
*/ */
#ifndef _PLANET_HPP_ #ifndef _PLANET_HPP_
#define _PLANET_HPP_ #define _PLANET_HPP_
#include <QString> #include <QString>
#include "StelObject.hpp" #include "StelObject.hpp"
#include "StelToneReproducer.hpp"
#include "VecMath.hpp" #include "VecMath.hpp"
#include "callbacks.hpp"
#include "StelFader.hpp" #include "StelFader.hpp"
#include "StelTranslator.hpp"
#include "StelTextureTypes.hpp" #include "StelTextureTypes.hpp"
#include "StelProjectorType.hpp" #include "StelProjectorType.hpp"
// The callback type for the external position computation function // The callback type for the external position computation function
typedef boost::callback<void, double, double*> posFuncType; // The last variable is the userData pointer.
typedef void (*posFuncType)(double, double*, void*);
typedef void (OsulatingFunctType)(double jd0,double jd,double xyz[3]); typedef void (OsulatingFunctType)(double jd0,double jd,double xyz[3]);
// epoch J2000: 12 UT on 1 Jan 2000 // epoch J2000: 12 UT on 1 Jan 2000
#define J2000 2451545.0 #define J2000 2451545.0
#define ORBIT_SEGMENTS 72 #define ORBIT_SEGMENTS 72
class StelFont; class StelFont;
class StelPainter; class StelPainter;
class StelTranslator;
struct TrailPoint struct TrailPoint
{ {
Vec3d point; Vec3d point;
double date; double date;
}; };
// Class used to store orbital elements // Class used to store orbital elements
class RotationElements class RotationElements
{ {
public: public:
RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliquit RotationElements(void) : period(1.), offset(0.), epoch(J2000), obliq
y(0.), ascendingNode(0.), precessionRate(0.) {} uity(0.), ascendingNode(0.), precessionRate(0.) {}
float period; // rotation period float period; // rotation period
float offset; // rotation at epoch float offset; // rotation at epoch
double epoch; double epoch;
float obliquity; // tilt of rotation axis w.r.t. ecliptic float obliquity; // tilt of rotation axis w.r.t. ecliptic
float ascendingNode; // long. of ascending node of equator on the ecl float ascendingNode; // long. of ascending node of equator on the
iptic ecliptic
float precessionRate; // rate of precession of rotation axis in rads/d float precessionRate; // rate of precession of rotation axis in rad
ay s/day
double siderealPeriod; // sidereal period (Planet year in earth days) double siderealPeriod; // sidereal period (Planet year in earth days
)
}; };
// Class to manage rings for planets like saturn // Class to manage rings for planets like saturn
class Ring class Ring
{ {
public: public:
Ring(double radiusMin,double radiusMax,const QString &texname); Ring(double radiusMin,double radiusMax,const QString &texname);
~Ring(void); ~Ring(void);
void draw(const StelPainter* painter,const Mat4d& mat,double screenS z); void draw(StelPainter* painter,const Mat4d& mat,double screenSz);
double getSize(void) const {return radiusMax;} double getSize(void) const {return radiusMax;}
private: private:
const double radiusMin; const double radiusMin;
const double radiusMax; const double radiusMax;
StelTextureSP tex; StelTextureSP tex;
}; };
class Planet : public StelObject class Planet : public StelObject
{ {
public: public:
friend class SolarSystem; friend class SolarSystem;
Planet(const QString& englishName, Planet(const QString& englishName,
int flagLighting, int flagLighting,
double radius, double radius,
double oblateness, double oblateness,
Vec3f color, Vec3f color,
float albedo, float albedo,
const QString& texMapName, const QString& texMapName,
const QString& texHaloName, const QString& texHaloName,
posFuncType _coordFunc, posFuncType _coordFunc,
OsulatingFunctType *osculatingFunc, void* userDataPtr,
bool closeOrbit, OsulatingFunctType *osculatingFunc,
bool hidden, bool closeOrbit,
bool hasAtmosphere); bool hidden,
bool hasAtmosphere);
~Planet(); ~Planet();
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
// Methods inherited from StelObject // Methods inherited from StelObject
//! Get a string with data about the Planet. //! Get a string with data about the Planet.
//! Planets support the following InfoStringGroup flags: //! Planets support the following InfoStringGroup flags:
//! - Name //! - Name
//! - Magnitude //! - Magnitude
//! - RaDec //! - RaDec
skipping to change at line 131 skipping to change at line 131
virtual QString getType(void) const {return "Planet";} virtual QString getType(void) const {return "Planet";}
virtual Vec3d getJ2000EquatorialPos(const StelNavigator *nav) const; virtual Vec3d getJ2000EquatorialPos(const StelNavigator *nav) const;
virtual QString getEnglishName(void) const {return englishName;} virtual QString getEnglishName(void) const {return englishName;}
virtual QString getNameI18n(void) const {return nameI18;} virtual QString getNameI18n(void) const {return nameI18;}
virtual double getAngularSize(const StelCore* core) const; virtual double getAngularSize(const StelCore* core) const;
virtual bool hasAtmosphere(void) {return atmosphere;} virtual bool hasAtmosphere(void) {return atmosphere;}
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
// Methods of SolarSystem object // Methods of SolarSystem object
//! Translate planet name using the passed translator //! Translate planet name using the passed translator
void translateName(StelTranslator& trans) {nameI18 = trans.qtranslat e(englishName);} void translateName(StelTranslator& trans);
// Draw the Planet // Draw the Planet
void draw(StelCore* core, float maxMagLabels); void draw(StelCore* core, float maxMagLabels, const QFont& planetNam eFont);
//////////////////////////////////////////////////////////////////// /////// //////////////////////////////////////////////////////////////////// ///////
// Methods specific to Planet // Methods specific to Planet
//! Set the planet's parent, i.e. the one around which it's orbiting
void setParent(Planet* parent);
//! Get the radius of the planet in AU. //! Get the radius of the planet in AU.
//! @return the radius of the planet in astronomical units. //! @return the radius of the planet in astronomical units.
double getRadius(void) const {return radius;} double getRadius(void) const {return radius;}
double getSiderealDay(void) const {return re.period;} double getSiderealDay(void) const {return re.period;}
const QString& getTextMapName() const {return texMapName;} const QString& getTextMapName() const {return texMapName;}
// Compute the z rotation to use from equatorial to geographic coord inates // Compute the z rotation to use from equatorial to geographic coord inates
double getSiderealTime(double jd) const; double getSiderealTime(double jd) const;
Mat4d getRotEquatorialToVsop87(void) const; Mat4d getRotEquatorialToVsop87(void) const;
skipping to change at line 163 skipping to change at line 160
const RotationElements &getRotationElements(void) const {return re;} const RotationElements &getRotationElements(void) const {return re;}
// Compute the position in the parent Planet coordinate system // Compute the position in the parent Planet coordinate system
void computePositionWithoutOrbits(const double date); void computePositionWithoutOrbits(const double date);
void computePosition(const double date); void computePosition(const double date);
// Compute the transformation matrix from the local Planet coordinat e to the parent Planet coordinate // Compute the transformation matrix from the local Planet coordinat e to the parent Planet coordinate
void computeTransMatrix(double date); void computeTransMatrix(double date);
// Get the phase angle for an observer at pos obsPos in the heliocen tric coordinate (in AU) // Get the phase angle for an observer at pos obsPos in the heliocen tric coordinate (in AU)
double getPhase(Vec3d obsPos) const; double getPhase(const Vec3d& obsPos) const;
// Get the angular size of the spheroid of the planet (i.e. without the rings) // Get the angular size of the spheroid of the planet (i.e. without the rings)
double getSpheroidAngularSize(const StelCore* core) const; double getSpheroidAngularSize(const StelCore* core) const;
// Set the orbital elements // Set the orbital elements
void setRotationElements(float _period, float _offset, double _epoch , void setRotationElements(float _period, float _offset, double _epoch ,
float _obliquity, float _ascendingNode, float _precessionRat e, double _siderealPeriod); float _obliquity, float _ascendingNode, float _precessionRat e, double _siderealPeriod);
double getRotAscendingnode(void) const {return re.ascendingNode;} double getRotAscendingnode(void) const {return re.ascendingNode;}
double getRotObliquity(void) const {return re.obliquity;} double getRotObliquity(void) const {return re.obliquity;}
//! Get the Planet position in the parent Planet ecliptic coordinate in AU //! Get the Planet position in the parent Planet ecliptic coordinate in AU
skipping to change at line 189 skipping to change at line 186
// Compute the distance to the given position in heliocentric coordi nate (in AU) // Compute the distance to the given position in heliocentric coordi nate (in AU)
double computeDistance(const Vec3d& obsHelioPos); double computeDistance(const Vec3d& obsHelioPos);
double getDistance(void) const {return distance;} double getDistance(void) const {return distance;}
void setRings(Ring* r) {rings = r;} void setRings(Ring* r) {rings = r;}
void setSphereScale(float s) {sphereScale = s;} void setSphereScale(float s) {sphereScale = s;}
float getSphereScale(void) const {return sphereScale;} float getSphereScale(void) const {return sphereScale;}
const Planet* getParent(void) const {return parent;} const QSharedPointer<Planet> getParent(void) const {return parent;}
static void setFont(StelFont* f) {planetNameFont = f;}
static void setLabelColor(const Vec3f& lc) {labelColor = lc;} static void setLabelColor(const Vec3f& lc) {labelColor = lc;}
static const Vec3f& getLabelColor(void) {return labelColor;} static const Vec3f& getLabelColor(void) {return labelColor;}
void update(int deltaTime); void update(int deltaTime);
void setFlagHints(bool b){hintFader = b;} void setFlagHints(bool b){hintFader = b;}
bool getFlagHints(void) const {return hintFader;} bool getFlagHints(void) const {return hintFader;}
void setFlagLabels(bool b){flagLabels = b;} void setFlagLabels(bool b){flagLabels = b;}
skipping to change at line 233 skipping to change at line 228
bool firstPoint; // if need to take first point of tra il still bool firstPoint; // if need to take first point of tra il still
LinearFader trailFader; LinearFader trailFader;
///// Orbit related code ///// Orbit related code
// Should move to an OrbitPath class which works on a SolarSystemObj ect, not a Planet // Should move to an OrbitPath class which works on a SolarSystemObj ect, not a Planet
void setFlagOrbits(bool b){orbitFader = b;} void setFlagOrbits(bool b){orbitFader = b;}
bool getFlagOrbits(void) const {return orbitFader;} bool getFlagOrbits(void) const {return orbitFader;}
LinearFader orbitFader; LinearFader orbitFader;
// draw orbital path of Planet // draw orbital path of Planet
void drawOrbit(const StelCore*); void drawOrbit(const StelCore*);
Vec3d orbit[ORBIT_SEGMENTS]; // store heliocentric coordinates for drawing the orbit Vec3d orbit[ORBIT_SEGMENTS+1]; // store heliocentric coordinates f or drawing the orbit
double lastOrbitJD; double lastOrbitJD;
double deltaJD; double deltaJD;
double deltaOrbitJD; double deltaOrbitJD;
bool orbitCached; // whether orbit calculations are cac hed for drawing orbit yet bool orbitCached; // whether orbit calculations are cac hed for drawing orbit yet
bool closeOrbit; // whether to connect the beginning o f the orbit line to bool closeOrbit; // whether to connect the beginning o f the orbit line to
// the end: good for elliptical orbit // the en
s, bad for parabolic d: good for elliptical orbits, bad for parabolic
// and hyperbolic orbits // and hy
perbolic orbits
static Vec3f orbitColor; static Vec3f orbitColor;
static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;} static void setOrbitColor(const Vec3f& oc) {orbitColor = oc;}
static const Vec3f& getOrbitColor() {return orbitColor;} static const Vec3f& getOrbitColor() {return orbitColor;}
protected: protected:
static StelTextureSP texEarthShadow; // for lunar eclipses static StelTextureSP texEarthShadow; // for lunar eclipses
// draw earth shadow on moon for lunar eclipses // draw earth shadow on moon for lunar eclipses
void drawEarthShadow(StelCore* core); void drawEarthShadow(StelCore* core, StelPainter* sPainter);
// Return the information string "ready to print" :) // Return the information string "ready to print" :)
QString getSkyLabel(const StelNavigator * nav) const; QString getSkyLabel(const StelNavigator * nav) const;
// Draw the 3d model. Call the proper functions if there are rings e tc.. // Draw the 3d model. Call the proper functions if there are rings e tc..
void draw3dModel(StelCore* core, const Mat4d& mat, float screenSz); void draw3dModel(StelCore* core, const Mat4d& mat, float screenSz);
// Draw the 3D sphere // Draw the 3D sphere
void drawSphere(const StelPainter* painter, float screenSz); void drawSphere(StelPainter* painter, float screenSz);
// Draw the circle and name of the Planet // Draw the circle and name of the Planet
void drawHints(const StelCore* core); void drawHints(const StelCore* core, const QFont& planetNameFont);
QString englishName; // english planet name QString englishName; // english planet name
QString nameI18; // International translated name QString nameI18; // International translated name
QString texMapName; // Texture file path QString texMapName; // Texture file path
int flagLighting; // Set wether light computation has to be proceed int flagLighting; // Set whether light computation has to be proceed
RotationElements re; // Rotation param RotationElements re; // Rotation param
double radius; // Planet radius in UA double radius; // Planet radius in UA
double oneMinusOblateness; // (polar radius)/(equatorial radius ) double oneMinusOblateness; // (polar radius)/(equatorial radius )
Vec3d eclipticPos; // Position in UA in the rectangular ecliptic coordinate system Vec3d eclipticPos; // Position in UA in the rectangular ecliptic coordinate system
// centered on the parent Planet // c entered on the parent Planet
Vec3d screenPos; // Used to store temporarily the 2D position on screen Vec3d screenPos; // Used to store temporarily the 2D position on screen
Vec3d previousScreenPos; // The position of this planet in th e previous frame. Vec3d previousScreenPos; // The position of this planet in th e previous frame.
Vec3f color; Vec3f color;
float albedo; // Planet albedo float albedo; // Planet albedo
Mat4d rotLocalToParent; Mat4d rotLocalToParent;
float axisRotation; // Rotation angle of the Planet on it 's axis float axisRotation; // Rotation angle of the Planet on it 's axis
StelTextureSP texMap; // Planet map texture StelTextureSP texMap; // Planet map texture
Ring* rings; // Planet rings Ring* rings; // Planet rings
double distance; // Temporary variable used to store the distance to a given point double distance; // Temporary variable used to store the distance to a given point
// it is used for sorting while draw ing // i t is used for sorting while drawing
float sphereScale; // Artificial scaling for better view ing float sphereScale; // Artificial scaling for better view ing
double lastJD; double lastJD;
// The callback for the calculation of the equatorial rect heliocent ric position at time JD. // The callback for the calculation of the equatorial rect heliocent ric position at time JD.
posFuncType coordFunc; posFuncType coordFunc;
void* userDataPtr;
OsulatingFunctType *const osculatingFunc; OsulatingFunctType *const osculatingFunc;
const Planet *parent; // Planet parent i.e. sun for earth QSharedPointer<Planet> parent; // Planet parent i.e. sun f
QList<Planet*> satellites; // satellites of the Planet or earth
QList<QSharedPointer<Planet> > satellites; // satellites of the
Planet
LinearFader hintFader; LinearFader hintFader;
LinearFader labelsFader; // Store the current state of the la bel for this planet LinearFader labelsFader; // Store the current state of the la bel for this planet
bool flagLabels; // Define whether labels should be d isplayed bool flagLabels; // Define whether labels should be d isplayed
bool hidden; // useful for fake planets used as o bservation positions - not drawn or labeled bool hidden; // useful for fake planets used as o bservation positions - not drawn or labeled
bool atmosphere; // Does the planet have an atmospher e? bool atmosphere; // Does the planet have an atmospher e?
static StelFont* planetNameFont; // Font for names
static Vec3f labelColor; static Vec3f labelColor;
static StelTextureSP hintCircleTex; static StelTextureSP hintCircleTex;
}; };
#endif // _PLANET_HPP_ #endif // _PLANET_HPP_
 End of changes. 24 change blocks. 
50 lines changed or deleted 50 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/