Initial revision

1999-06-17 18:07:36 +00:00
parent ca444b07bd
commit 29e3a4e231
30 changed files with 486 additions and 1026 deletions
@@ -0,0 +1,19 @@
+noinst_LIBRARIES = libAstro.a
+
+libAstro_a_SOURCES = \
+	celestialBody.cxx celestialBody.hxx \
+	jupiter.cxx jupiter.hxx \
+	mars.cxx mars.hxx \
+	mercury.cxx mercury.hxx \
+	moon.cxx moon.hxx \
+	neptune.cxx neptune.hxx \
+	pluto.hxx \
+	saturn.cxx saturn.hxx \
+	sky.cxx sky.hxx \
+	solarsystem.cxx solarsystem.hxx \
+	star.cxx star.hxx \
+	stars.cxx stars.hxx \
+	uranus.cxx uranus.hxx \
+	venus.cxx venus.hxx
+
+INCLUDES += -I$(top_builddir) -I$(top_builddir)/Lib -I$(top_builddir)/Simulator
@@ -0,0 +1,176 @@
+/**************************************************************************
+ * celestialBody.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#include "celestialBody.hxx"
+#include "star.hxx"
+#include <Debug/logstream.hxx>
+
+#ifdef FG_MATH_EXCEPTION_CLASH
+#  define exception c_exception
+#endif
+#include <math.h>
+
+/**************************************************************************
+ * void CelestialBody::updatePosition(fgTIME *t, Star *ourSun)
+ *
+ * Basically, this member function provides a general interface for 
+ * calculating the right ascension and declinaion. This function is 
+ * used for calculating the planetary positions. For the planets, an 
+ * overloaded member function is provided to additionally calculate the
+ * planet's magnitude. 
+ * The sun and moon have their own overloaded updatePosition member, as their
+ * position is calculated an a slightly different manner.  
+ *
+ * arguments:
+ * fgTIME t: provides the current time.
+ * Star *ourSun: the sun's position is needed to convert heliocentric 
+ *               coordinates into geocentric coordinates.
+ *
+ * return value: none
+ *
+ *************************************************************************/
+void CelestialBody::updatePosition(FGTime *t, Star *ourSun)
+{
+  double eccAnom, v, ecl, actTime, 
+    xv, yv, xh, yh, zh, xg, yg, zg, xe, ye, ze;
+
+  updateOrbElements(t);
+  actTime = fgCalcActTime(t);
+
+  // calcualate the angle bewteen ecliptic and equatorial coordinate system
+  ecl = DEG_TO_RAD * (23.4393 - 3.563E-7 *actTime);
+  
+  eccAnom = fgCalcEccAnom(M, e);  //calculate the eccentric anomaly
+  xv = a * (cos(eccAnom) - e);
+  yv = a * (sqrt (1.0 - e*e) * sin(eccAnom));
+  v = atan2(yv, xv);           // the planet's true anomaly
+  r = sqrt (xv*xv + yv*yv);    // the planet's distance
+  
+  // calculate the planet's position in 3D space
+  xh = r * (cos(N) * cos(v+w) - sin(N) * sin(v+w) * cos(i));
+  yh = r * (sin(N) * cos(v+w) + cos(N) * sin(v+w) * cos(i));
+  zh = r * (sin(v+w) * sin(i));
+
+  // calculate the ecliptic longitude and latitude
+  xg = xh + ourSun->getxs();
+  yg = yh + ourSun->getys();
+  zg = zh;
+
+  lonEcl = atan2(yh, xh);
+  latEcl = atan2(zh, sqrt(xh*xh+yh*yh));
+
+  xe = xg;
+  ye = yg * cos(ecl) - zg * sin(ecl);
+  ze = yg * sin(ecl) + zg * cos(ecl);
+  rightAscension = atan2(ye, xe);
+  declination = atan2(ze, sqrt(xe*xe + ye*ye));
+  FG_LOG(FG_GENERAL, FG_INFO, "Planet found at : " 
+	 << rightAscension << " (ra), " << declination << " (dec)" );
+
+  //calculate some variables specific to calculating the magnitude 
+  //of the planet
+  R = sqrt (xg*xg + yg*yg + zg*zg);
+  s = ourSun->getDistance();
+
+  // It is possible from these calculations for the argument to acos
+  // to exceed the valid range for acos(). So we do a little extra
+  // checking.
+
+  double tmp = (r*r + R*R - s*s) / (2*r*R);
+  if ( tmp > 1.0) { 
+      tmp = 1.0;
+  } else if ( tmp < -1.0) {
+      tmp = -1.0;
+  }
+
+  FV = RAD_TO_DEG * acos( tmp );
+};
+
+/****************************************************************************
+ * double CelestialBody::fgCalcEccAnom(double M, double e)
+ * this private member calculates the eccentric anomaly of a celestial body, 
+ * given its mean anomaly and eccentricity.
+ * 
+ * -Mean anomaly: the approximate angle between the perihelion and the current
+ *  position. this angle increases uniformly with time.
+ *
+ * True anomaly: the actual angle between perihelion and current position.
+ *
+ * Eccentric anomaly: this is an auxilary angle, used in calculating the true
+ * anomaly from the mean anomaly.
+ * 
+ * -eccentricity. Indicates the amount in which the orbit deviates from a 
+ *  circle (0 = circle, 0-1, is ellipse, 1 = parabola, > 1 = hyperbola).
+ *
+ * This function is also known as solveKeplersEquation()
+ *
+ * arguments: 
+ * M: the mean anomaly
+ * e: the eccentricity
+ *
+ * return value:
+ * the eccentric anomaly
+ *
+ ****************************************************************************/
+double CelestialBody::fgCalcEccAnom(double M, double e)
+{
+  double 
+    eccAnom, E0, E1, diff;
+  
+  eccAnom = M + e * sin(M) * (1.0 + e * cos (M));
+  // iterate to achieve a greater precision for larger eccentricities 
+  if (e > 0.05)
+    {
+      E0 = eccAnom;
+      do
+	{
+	  E1 = E0 - (E0 - e * sin(E0) - M) / (1 - e *cos(E0));
+	  diff = fabs(E0 - E1);
+	  E0 = E1;
+	}
+      while (diff > (DEG_TO_RAD * 0.001));
+      return E0;
+    }
+  return eccAnom;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -0,0 +1,195 @@
+/**************************************************************************
+ * celestialBody.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+
+#ifndef _CELESTIALBODY_H_
+#define _CELESTIALBODY_H_
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+#include <Time/fg_time.hxx>
+#include <Include/fg_constants.h>
+
+class Star;
+
+class CelestialBody
+{
+protected:              // make the data protected, in order to give the inherited
+                        // classes direct access to the data
+  double NFirst;       	/* longitude of the ascending node first part */
+  double NSec;		/* longitude of the ascending node second part */
+  double iFirst;       	/* inclination to the ecliptic first part */
+  double iSec;		/* inclination to the ecliptic second part */
+  double wFirst;       	/* first part of argument of perihelion */
+  double wSec;		/* second part of argument of perihelion */
+  double aFirst;       	/* semimayor axis first part*/
+  double aSec;		/* semimayor axis second part */
+  double eFirst;       	/* eccentricity first part */
+  double eSec;		/* eccentricity second part */
+  double MFirst;       	/* Mean anomaly first part */
+  double MSec;		/* Mean anomaly second part */
+
+  double N, i, w, a, e, M; /* the resulting orbital elements, obtained from the former */
+
+  double rightAscension, declination;
+  double r, R, s, FV;
+  double magnitude;
+  double lonEcl, latEcl;
+
+  double fgCalcEccAnom(double M, double e);
+  double fgCalcActTime(FGTime *t);
+  void updateOrbElements(FGTime *t);
+
+public:
+  CelestialBody(double Nf, double Ns,
+		double If, double Is,
+		double wf, double ws,
+		double af, double as,
+		double ef, double es,
+		double Mf, double Ms, FGTime *t);
+  void getPos(double *ra, double *dec);
+  void getPos(double *ra, double *dec, double *magnitude);
+  double getLon();
+  double getLat(); 
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+/*****************************************************************************
+ * inline CelestialBody::CelestialBody
+ * public constructor for a generic celestialBody object.
+ * initializes the 6 primary orbital elements. The elements are:
+ * N: longitude of the ascending node
+ * i: inclination to the ecliptic
+ * w: argument of perihelion
+ * a: semi-major axis, or mean distance from the sun
+ * e: eccenticity
+ * M: mean anomaly
+ * Each orbital element consists of a constant part and a variable part that 
+ * gradually changes over time. 
+ *
+ * Argumetns:
+ * the 13 arguments to the constructor constitute the first, constant 
+ * ([NiwaeM]f) and the second variable ([NiwaeM]s) part of the orbital 
+ * elements. The 13th argument is the current time. Note that the inclination
+ * is written with a capital (If, Is), because 'if' is a reserved word in the 
+ * C/C++ programming language.
+ ***************************************************************************/ 
+inline CelestialBody::CelestialBody(double Nf, double Ns,
+				    double If, double Is,
+				    double wf, double ws,
+				    double af, double as,
+				    double ef, double es,
+				    double Mf, double Ms, FGTime *t)
+{
+  NFirst = Nf;     NSec = Ns;
+  iFirst = If;     iSec = Is;
+  wFirst = wf;     wSec = ws;
+  aFirst = af;     aSec = as;
+  eFirst = ef;     eSec = es;
+  MFirst = Mf;     MSec = Ms;
+  updateOrbElements(t);
+};
+
+/****************************************************************************
+ * inline void CelestialBody::updateOrbElements(FGTime *t)
+ * given the current time, this private member calculates the actual 
+ * orbital elements
+ *
+ * Arguments: FGTime *t: the current time:
+ *
+ * return value: none
+ ***************************************************************************/
+inline void CelestialBody::updateOrbElements(FGTime *t)
+{
+  double actTime = fgCalcActTime(t);
+   M = DEG_TO_RAD * (MFirst + (MSec * actTime));
+   w = DEG_TO_RAD * (wFirst + (wSec * actTime));
+   N = DEG_TO_RAD * (NFirst + (NSec * actTime));
+   i = DEG_TO_RAD * (iFirst + (iSec * actTime));
+   e = eFirst + (eSec * actTime);
+   a = aFirst + (aSec * actTime);
+}
+/*****************************************************************************
+ * inline double CelestialBody::fgCalcActTime(FGTime *t)
+ * this private member function returns the offset in days from the epoch for
+ * wich the orbital elements are calculated (Jan, 1st, 2000).
+ * 
+ * Argument: the current time
+ *
+ * return value: the (fractional) number of days until Jan 1, 2000.
+ ****************************************************************************/
+inline double CelestialBody::fgCalcActTime(FGTime *t)
+{
+  return (t->getMjd() - 36523.5);
+}
+
+/*****************************************************************************
+ * inline void CelestialBody::getPos(double* ra, double* dec)
+ * gives public access to Right Ascension and declination
+ *
+ ****************************************************************************/
+inline void CelestialBody::getPos(double* ra, double* dec)
+{
+  *ra  = rightAscension;
+  *dec = declination;
+}
+
+/*****************************************************************************
+ * inline void CelestialBody::getPos(double* ra, double* dec, double* magnitude
+ * gives public acces to the current Right ascension, declination, and 
+ * magnitude
+ ****************************************************************************/
+inline void CelestialBody::getPos(double* ra, double* dec, double* magn)
+{
+  *ra = rightAscension;
+  *dec = declination;
+  *magn = magnitude;
+}
+
+inline double CelestialBody::getLon()
+{
+  return lonEcl;
+}
+
+inline double CelestialBody::getLat()
+{
+  return latEcl;
+}
+
+#endif // _CELESTIALBODY_H_
+
+
+
+
+
+
+
+
+
+
+
+
@@ -0,0 +1,65 @@
+/**************************************************************************
+ * jupiter.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "jupiter.hxx"
+
+/*************************************************************************
+ * Jupiter::Jupiter(FGTime *t)
+ * Public constructor for class Jupiter
+ * Argument: The current time.
+ * the hard coded orbital elements for Jupiter are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Jupiter::Jupiter(FGTime *t) :
+  CelestialBody(100.4542,  2.7685400E-5,	
+		1.3030,   -1.557E-7,
+		273.8777,  1.6450500E-5,
+		5.2025600, 0.000000,
+		0.048498,  4.469E-9,
+		19.89500,  0.08308530010, t)
+{
+}
+
+/*************************************************************************
+ * void Jupiter::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Jupiter, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Jupiter specific equation
+ *************************************************************************/
+void Jupiter::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -9.25 + 5*log10( r*R ) + 0.014 * FV;
+}
+
+
+
+
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * jupiter.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _JUPITER_HXX_
+#define _JUPITER_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Jupiter : public CelestialBody
+{
+public:
+  Jupiter (FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _JUPITER_HXX_
@@ -0,0 +1,59 @@
+/**************************************************************************
+ * mars.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "mars.hxx"
+
+/*************************************************************************
+ * Mars::Mars(FGTime *t)
+ * Public constructor for class Mars
+ * Argument: The current time.
+ * the hard coded orbital elements for Mars are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Mars::Mars(FGTime *t) :
+  CelestialBody(49.55740,  2.1108100E-5,
+		1.8497,   -1.78E-8,
+		286.5016,  2.9296100E-5,
+		1.5236880, 0.000000,
+		0.093405,  2.516E-9,
+		18.60210,  0.52402077660, t)
+{
+}
+/*************************************************************************
+ * void Mars::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Mars, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Mars specific equation
+ *************************************************************************/
+void Mars::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -1.51 + 5*log10( r*R ) + 0.016 * FV;
+}
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * mars.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _MARS_HXX_
+#define _MARS_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Mars : public CelestialBody
+{
+public:
+  Mars ( FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _MARS_HXX_
@@ -0,0 +1,61 @@
+/**************************************************************************
+ * mercury.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "mercury.hxx"
+
+/*************************************************************************
+ * Mercury::Mercury(FGTime *t)
+ * Public constructor for class Mercury
+ * Argument: The current time.
+ * the hard coded orbital elements for Mercury are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Mercury::Mercury(FGTime *t) :
+  CelestialBody (48.33130,   3.2458700E-5,
+                  7.0047,    5.00E-8,
+                  29.12410,  1.0144400E-5,
+                  0.3870980, 0.000000,
+                  0.205635,  5.59E-10,
+                  168.6562,  4.09233443680, t)
+{
+}
+/*************************************************************************
+ * void Mercury::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Mercury, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Mercury specific equation
+ *************************************************************************/
+void Mercury::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -0.36 + 5*log10( r*R ) + 0.027 * FV + 2.2E-13 * pow(FV, 6); 
+}
+
+
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * mercury.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _MERCURY_HXX_
+#define _MERCURY_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Mercury : public CelestialBody
+{
+public:
+  Mercury ( FGTime *t);
+  void updatePosition(FGTime *t, Star* ourSun);
+};
+
+#endif // _MERURY_HXX_
@@ -0,0 +1,401 @@
+/**************************************************************************
+ * moon.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#include <FDM/flight.hxx>
+
+#include <string.h>
+#include "moon.hxx"
+
+#include <Debug/logstream.hxx>
+#include <Main/options.hxx>
+#include <Misc/fgpath.hxx>
+#include <Objects/texload.h>
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+
+/*************************************************************************
+ * Moon::Moon(FGTime *t)
+ * Public constructor for class Moon. Initializes the orbital elements and 
+ * sets up the moon texture.
+ * Argument: The current time.
+ * the hard coded orbital elements for Moon are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Moon::Moon(FGTime *t) :
+  CelestialBody(125.1228, -0.0529538083,
+		5.1454,    0.00000,
+		318.0634,  0.1643573223,
+		60.266600, 0.000000,
+		0.054900,  0.000000,
+		115.3654,  13.0649929509, t)
+{
+  int width, height;
+  
+  FG_LOG( FG_GENERAL, FG_INFO, "Initializing Moon Texture");
+#ifdef GL_VERSION_1_1
+  xglGenTextures(1, &moon_texid);
+  xglBindTexture(GL_TEXTURE_2D, moon_texid);
+#elif GL_EXT_texture_object
+  xglGenTexturesEXT(1, &moon_texid);
+  xglBindTextureEXT(GL_TEXTURE_2D, moon_texid);
+#else
+#  error port me
+#endif
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+  // load in the texture data
+  FGPath tpath( current_options.get_fg_root() );
+  tpath.append( "Textures" );
+  tpath.append( "moon.rgb" );
+
+  if ( (moon_texbuf = read_rgb_texture(tpath.c_str(), &width, &height)) 
+       == NULL )
+  {
+    // Try compressed
+    FGPath fg_tpath = tpath;
+    fg_tpath.append( ".gz" );
+    if ( (moon_texbuf = read_rgb_texture(fg_tpath.c_str(), &width, &height)) 
+	 == NULL )
+    {
+	FG_LOG( FG_GENERAL, FG_ALERT, 
+		"Error in loading moon texture " << tpath.str() );
+	exit(-1);
+    } 
+  } 
+
+  glTexImage2D( GL_TEXTURE_2D,
+		0,
+		GL_RGB,
+		256, 256,
+		0,
+		GL_RGB, GL_UNSIGNED_BYTE,
+		moon_texbuf);
+
+  // setup the halo texture
+  FG_LOG( FG_GENERAL, FG_INFO, "Initializing Moon Texture");
+#ifdef GL_VERSION_1_1
+  xglGenTextures(1, &moon_halotexid);
+  xglBindTexture(GL_TEXTURE_2D, moon_halotexid);
+#elif GL_EXT_texture_object
+  xglGenTexturesEXT(1, &moon_halotexid);
+  xglBindTextureEXT(GL_TEXTURE_2D, moon_halotexid);
+#else
+#  error port me
+#endif
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  setHalo();
+  glTexImage2D( GL_TEXTURE_2D,
+		0,
+		GL_RGBA,
+		256, 256,
+		0,
+		GL_RGBA, GL_UNSIGNED_BYTE,
+		moon_halotexbuf);
+  moonObject = gluNewQuadric();
+}
+
+Moon::~Moon()
+{
+  //delete moonObject;
+  delete moon_texbuf;
+  delete moon_halotexbuf;
+}
+
+
+static int texWidth = 256;	/* 64x64 is plenty */
+
+void Moon::setHalo()
+{
+  int texSize;
+  //void *textureBuf;
+  GLubyte *p;
+  int i,j;
+  double radius;
+  
+  texSize = texWidth*texWidth;
+  
+  moon_halotexbuf = new GLubyte[texSize*4];
+  if (!moon_halotexbuf) 
+    return;  // Ugly!
+  
+  p = moon_halotexbuf;
+  
+  radius = (double)(texWidth / 2);
+  
+  for (i=0; i < texWidth; i++) {
+    for (j=0; j < texWidth; j++) {
+      double x, y, d;
+	    
+      x = fabs((double)(i - (texWidth / 2)));
+      y = fabs((double)(j - (texWidth / 2)));
+
+      d = sqrt((x * x) + (y * y));
+      if (d < radius) 
+	{
+	  double t = 1.0 - (d / radius); // t is 1.0 at center, 0.0 at edge */
+	  // inverse square looks nice 
+	  *p = (int)((double)0xff * (t * t));
+	  *(p+1) = (int)((double) 0xff * (t*t));
+	  *(p+2) = (int)((double) 0xff * (t*t));
+	  *(p+3) = 0x11;
+	} 
+      else
+	{
+	  *p = 0x00;
+	  *(p+1) = 0x00;
+	  *(p+2) = 0x00;
+	  *(p+3) = 0x11;
+	}
+      p += 4;
+    }
+  }
+  //gluBuild2DMipmaps(GL_TEXTURE_2D, 1, texWidth, texWidth, 
+  //	    GL_LUMINANCE,
+  //	    GL_UNSIGNED_BYTE, textureBuf);
+  //free(textureBuf);
+}
+
+
+/*****************************************************************************
+ * void Moon::updatePosition(FGTime *t, Star *ourSun)
+ * this member function calculates the actual topocentric position (i.e.) 
+ * the position of the moon as seen from the current position on the surface
+ * of the moon. 
+ ****************************************************************************/
+void Moon::updatePosition(FGTime *t, Star *ourSun)
+{
+  double 
+    eccAnom, ecl, actTime,
+    xv, yv, v, r, xh, yh, zh, xg, yg, zg, xe, ye, ze,
+    Ls, Lm, D, F, mpar, gclat, rho, HA, g,
+    geoRa, geoDec;
+  
+  fgAIRCRAFT *air;
+  FGInterface *f;
+
+  air = &current_aircraft;
+  f = air->fdm_state;
+ 
+  updateOrbElements(t);
+  actTime = fgCalcActTime(t);
+
+  // calculate the angle between ecliptic and equatorial coordinate system
+  // in Radians
+  ecl = ((DEG_TO_RAD * 23.4393) - (DEG_TO_RAD * 3.563E-7) * actTime);  
+  eccAnom = fgCalcEccAnom(M, e);  // Calculate the eccentric anomaly
+  xv = a * (cos(eccAnom) - e);
+  yv = a * (sqrt(1.0 - e*e) * sin(eccAnom));
+  v = atan2(yv, xv);               // the moon's true anomaly
+  r = sqrt (xv*xv + yv*yv);       // and its distance
+  
+  // estimate the geocentric rectangular coordinates here
+  xh = r * (cos(N) * cos (v+w) - sin (N) * sin(v+w) * cos(i));
+  yh = r * (sin(N) * cos (v+w) + cos (N) * sin(v+w) * cos(i));
+  zh = r * (sin(v+w) * sin(i));
+
+  // calculate the ecliptic latitude and longitude here
+  lonEcl = atan2 (yh, xh);
+  latEcl = atan2(zh, sqrt(xh*xh + yh*yh));
+
+  /* Calculate a number of perturbatioin, i.e. disturbances caused by the 
+   * gravitational infuence of the sun and the other major planets.
+   * The largest of these even have a name */
+  Ls = ourSun->getM() + ourSun->getw();
+  Lm = M + w + N;
+  D = Lm - Ls;
+  F = Lm - N;
+  
+  lonEcl += DEG_TO_RAD * (-1.274 * sin (M - 2*D)
+			  +0.658 * sin (2*D)
+			  -0.186 * sin(ourSun->getM())
+			  -0.059 * sin(2*M - 2*D)
+			  -0.057 * sin(M - 2*D + ourSun->getM())
+			  +0.053 * sin(M + 2*D)
+			  +0.046 * sin(2*D - ourSun->getM())
+			  +0.041 * sin(M - ourSun->getM())
+			  -0.035 * sin(D)
+			  -0.031 * sin(M + ourSun->getM())
+			  -0.015 * sin(2*F - 2*D)
+			  +0.011 * sin(M - 4*D)
+			  );
+  latEcl += DEG_TO_RAD * (-0.173 * sin(F-2*D)
+			  -0.055 * sin(M - F - 2*D)
+			  -0.046 * sin(M + F - 2*D)
+			  +0.033 * sin(F + 2*D)
+			  +0.017 * sin(2*M + F)
+			  );
+  r += (-0.58 * cos(M - 2*D)
+	-0.46 * cos(2*D)
+	);
+  FG_LOG(FG_GENERAL, FG_INFO, "Running moon update");
+  xg = r * cos(lonEcl) * cos(latEcl);
+  yg = r * sin(lonEcl) * cos(latEcl);
+  zg = r *               sin(latEcl);
+  
+  xe = xg;
+  ye = yg * cos(ecl) -zg * sin(ecl);
+  ze = yg * sin(ecl) +zg * cos(ecl);
+
+  geoRa  = atan2(ye, xe);
+  geoDec = atan2(ze, sqrt(xe*xe + ye*ye));
+
+  /* FG_LOG( FG_GENERAL, FG_INFO, 
+	  "(geocentric) geoRa = (" << (RAD_TO_DEG * geoRa) 
+	  << "), geoDec= (" << (RAD_TO_DEG * geoDec) << ")" ); */
+
+
+  // Given the moon's geocentric ra and dec, calculate its 
+  // topocentric ra and dec. i.e. the position as seen from the
+  // surface of the earth, instead of the center of the earth
+
+  // First calculate the moon's parrallax, that is, the apparent size of the 
+  // (equatorial) radius of the earth, as seen from the moon 
+  mpar = asin ( 1 / r);
+  // FG_LOG( FG_GENERAL, FG_INFO, "r = " << r << " mpar = " << mpar );
+  // FG_LOG( FG_GENERAL, FG_INFO, "lat = " << f->get_Latitude() );
+
+  gclat = f->get_Latitude() - 0.003358 * 
+      sin (2 * DEG_TO_RAD * f->get_Latitude() );
+  // FG_LOG( FG_GENERAL, FG_INFO, "gclat = " << gclat );
+
+  rho = 0.99883 + 0.00167 * cos(2 * DEG_TO_RAD * f->get_Latitude());
+  // FG_LOG( FG_GENERAL, FG_INFO, "rho = " << rho );
+  
+  if (geoRa < 0)
+    geoRa += (2*FG_PI);
+  
+  HA = t->getLst() - (3.8197186 * geoRa);
+  /* FG_LOG( FG_GENERAL, FG_INFO, "t->getLst() = " << t->getLst() 
+	  << " HA = " << HA ); */
+
+  g = atan (tan(gclat) / cos ((HA / 3.8197186)));
+  // FG_LOG( FG_GENERAL, FG_INFO, "g = " << g );
+
+  rightAscension = geoRa - mpar * rho * cos(gclat) * sin(HA) / cos (geoDec);
+  declination = geoDec - mpar * rho * sin (gclat) * sin (g - geoDec) / sin(g);
+
+  /* FG_LOG( FG_GENERAL, FG_INFO, 
+	  "Ra = (" << (RAD_TO_DEG *rightAscension) 
+	  << "), Dec= (" << (RAD_TO_DEG *declination) << ")" ); */
+}
+
+
+/************************************************************************
+ * void Moon::newImage()
+ *
+ * This function regenerates a new visual image of the moon, which is added to
+ * solarSystem display list.
+ *
+ * Arguments: Right Ascension and declination
+ *
+ * return value: none
+ **************************************************************************/
+void Moon::newImage()
+{
+  fgLIGHT *l = &cur_light_params;
+  float moon_angle = l->moon_angle;
+  
+  /*double x_2, x_4, x_8, x_10;
+  GLfloat ambient;
+  GLfloat amb[4];*/
+  int moonSize = 750;
+
+  GLfloat moonColor[4] = {0.85, 0.75, 0.35, 1.0};
+  GLfloat black[4] = {0.0, 0.0, 0.0, 1.0};
+  GLfloat white[4] = {1.0, 1.0, 1.0, 0.0};
+  
+  if( moon_angle*RAD_TO_DEG < 100 ) 
+    {
+      FG_LOG( FG_ASTRO, FG_INFO, "Generating Moon Image" );
+
+      xglPushMatrix();
+      {
+	xglRotatef(((RAD_TO_DEG * rightAscension)- 90.0), 0.0, 0.0, 1.0);
+	xglRotatef((RAD_TO_DEG * declination), 1.0, 0.0, 0.0);
+	
+	FG_LOG( FG_GENERAL, FG_INFO, 
+		"Ra = (" << (RAD_TO_DEG *rightAscension) 
+		<< "), Dec= (" << (RAD_TO_DEG *declination) << ")" );
+	xglTranslatef(0.0, 60000.0, 0.0);
+	glEnable(GL_BLEND);	// BLEND ENABLED
+
+	// Draw the halo...
+	if (current_options.get_textures())
+	  {
+	    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	    glEnable(GL_TEXTURE_2D); // TEXTURE ENABLED
+	    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);  
+	    glBindTexture(GL_TEXTURE_2D, moon_halotexid);
+	  
+	    glBegin(GL_QUADS);
+	    glTexCoord2f(0.0f, 0.0f); glVertex3f(-5000, 0.0, -5000);
+	    glTexCoord2f(1.0f, 0.0f); glVertex3f( 5000, 0.0, -5000);
+	    glTexCoord2f(1.0f, 1.0f); glVertex3f( 5000, 0.0,  5000);
+	    glTexCoord2f(0.0f, 1.0f); glVertex3f(-5000, 0.0,  5000);
+	    glEnd();
+	  }
+	
+	xglEnable(GL_LIGHTING);	// LIGHTING ENABLED
+	xglEnable( GL_LIGHT0 );
+	// set lighting parameters
+	xglLightfv(GL_LIGHT0, GL_AMBIENT, white );
+	xglLightfv(GL_LIGHT0, GL_DIFFUSE, white );
+	// xglEnable( GL_CULL_FACE );
+	xglMaterialfv(GL_FRONT, GL_AMBIENT, black);
+	xglMaterialfv(GL_FRONT, GL_DIFFUSE, moonColor); 
+	
+	//glEnable(GL_TEXTURE_2D);
+	
+	glBlendFunc(GL_ONE, GL_ONE);
+	
+	//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
+	// Draw the moon-proper
+	
+	if (current_options.get_textures())
+	  {
+	    glBindTexture(GL_TEXTURE_2D, moon_texid);                         
+	    gluQuadricTexture(moonObject, GL_TRUE );
+	  }
+	gluSphere(moonObject,  moonSize, 12, 12 );
+	glDisable(GL_TEXTURE_2D); // TEXTURE DISABLED
+	glDisable(GL_BLEND);	// BLEND DISABLED
+      }
+      xglPopMatrix();
+      glDisable(GL_LIGHTING);	// Lighting Disabled.
+      
+    }
+  else
+    {
+    }
+}
@@ -0,0 +1,56 @@
+/**************************************************************************
+ * moon.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _MOON_HXX_
+#define _MOON_HXX_
+
+#include <Aircraft/aircraft.hxx>
+#include <Include/fg_constants.h>
+#include <Main/views.hxx>
+#include <Time/fg_time.hxx>
+
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Moon : public CelestialBody
+{
+private:
+  void TexInit();  // This should move to the constructor eventually.
+
+  GLUquadricObj *moonObject;
+  GLuint Sphere;
+  GLuint moon_texid;
+  GLuint moon_halotexid;
+  GLubyte *moon_texbuf;
+  GLubyte *moon_halotexbuf;
+  
+  void setHalo();
+public:
+  Moon ( FGTime *t);
+  ~Moon();
+  void updatePosition(FGTime *t, Star *ourSun);
+  void newImage();
+};
+
+
+#endif // _MOON_HXX_
@@ -0,0 +1,59 @@
+/**************************************************************************
+ * neptune.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "neptune.hxx"
+
+/*************************************************************************
+ * Neptune::Neptune(FGTime *t)
+ * Public constructor for class Neptune
+ * Argument: The current time.
+ * the hard coded orbital elements for Neptune are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Neptune::Neptune(FGTime *t) :
+  CelestialBody(131.7806,   3.0173000E-5,
+		1.7700,	   -2.550E-7,
+		272.8461,  -6.027000E-6,	
+		30.058260,  3.313E-8,
+		0.008606,   2.150E-9,
+		260.2471,   0.00599514700, t)
+{
+}
+/*************************************************************************
+ * void Neptune::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Neptune, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Neptune specific equation
+ *************************************************************************/
+void Neptune::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -6.90 + 5*log10 (r*R) + 0.001 *FV;
+}
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * neptune.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _NEPTUNE_HXX_
+#define _NEPTUNE_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Neptune : public CelestialBody
+{
+public:
+  Neptune ( FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _NEPTUNE_HXX_
@@ -0,0 +1,36 @@
+/**************************************************************************
+ * pluto.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _PLUTO_HXX_
+#define _PLUTO_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+
+class Pluto : public CelestialBody
+{
+public:
+  Pluto ( FGTime t);
+};
+
+#endif // _PLUTO_HXX_
@@ -0,0 +1,69 @@
+/**************************************************************************
+ * saturn.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "saturn.hxx"
+
+/*************************************************************************
+ * Saturn::Saturn(FGTime *t)
+ * Public constructor for class Saturn
+ * Argument: The current time.
+ * the hard coded orbital elements for Saturn are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Saturn::Saturn(FGTime *t) :
+  CelestialBody(113.6634,   2.3898000E-5,
+		2.4886,	   -1.081E-7,
+		339.3939,   2.9766100E-5,
+		9.5547500,  0.000000,
+		0.055546,  -9.499E-9,
+		316.9670,   0.03344422820, t)
+{
+}
+
+/*************************************************************************
+ * void Saturn::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Saturn, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Saturn specific equation
+ *************************************************************************/
+void Saturn::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  
+  double actTime = fgCalcActTime(t);
+  double ir = 0.4897394;
+  double Nr = 2.9585076 + 6.6672E-7*actTime;
+  double B = asin (sin(declination) * cos(ir) - 
+		   cos(declination) * sin(ir) *
+		   sin(rightAscension - Nr));
+  double ring_magn = -2.6 * sin(fabs(B)) + 1.2 * pow(sin(B), 2);
+  magnitude = -9.0 + 5*log10(r*R) + 0.044 * FV + ring_magn;
+}
+
@@ -0,0 +1,45 @@
+/**************************************************************************
+ * saturn.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _SATURN_HXX_
+#define _SATURN_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Saturn : public CelestialBody
+{
+public:
+  Saturn ( FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _SATURN_HXX_
+
+
+
+
+
+
+
@@ -0,0 +1,367 @@
+// sky.cxx -- model sky with an upside down "bowl"
+//
+// Written by Curtis Olson, started December 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include <math.h>
+
+#include <GL/glut.h>
+#include <XGL/xgl.h>
+
+#include <Aircraft/aircraft.hxx>
+#include <Debug/logstream.hxx>
+#include <FDM/flight.hxx>
+#include <Include/fg_constants.h>
+#include <Main/views.hxx>
+#include <Math/fg_random.h>
+#include <Time/event.hxx>
+#include <Time/fg_time.hxx>
+
+#include "sky.hxx"
+
+
+#ifdef __MWERKS__
+#  pragma global_optimizer off
+#endif
+
+
+// in meters of course
+#define CENTER_ELEV   25000.0
+
+#define INNER_RADIUS  50000.0
+#define INNER_ELEV    20000.0
+
+#define MIDDLE_RADIUS 70000.0
+#define MIDDLE_ELEV    8000.0
+
+#define OUTER_RADIUS  80000.0
+#define OUTER_ELEV        0.0
+
+#define BOTTOM_RADIUS 50000.0
+#define BOTTOM_ELEV   -2000.0
+
+
+static float inner_vertex[12][3];
+static float middle_vertex[12][3];
+static float outer_vertex[12][3];
+static float bottom_vertex[12][3];
+
+static float inner_color[12][4];
+static float middle_color[12][4];
+static float outer_color[12][4];
+
+
+// Calculate the sky structure vertices
+void fgSkyVerticesInit( void ) {
+    float theta;
+    int i;
+
+    FG_LOG(FG_ASTRO, FG_INFO, "  Generating the sky dome vertices.");
+
+    for ( i = 0; i < 12; i++ ) {
+	theta = (i * 30.0) * DEG_TO_RAD;
+	
+	inner_vertex[i][0] = cos(theta) * INNER_RADIUS;
+	inner_vertex[i][1] = sin(theta) * INNER_RADIUS;
+	inner_vertex[i][2] = INNER_ELEV;
+	
+	// printf("    %.2f %.2f\n", cos(theta) * INNER_RADIUS, 
+	//        sin(theta) * INNER_RADIUS);
+
+	middle_vertex[i][0] = cos((double)theta) * MIDDLE_RADIUS;
+	middle_vertex[i][1] = sin((double)theta) * MIDDLE_RADIUS;
+	middle_vertex[i][2] = MIDDLE_ELEV;
+	    
+	outer_vertex[i][0] = cos((double)theta) * OUTER_RADIUS;
+	outer_vertex[i][1] = sin((double)theta) * OUTER_RADIUS;
+	outer_vertex[i][2] = OUTER_ELEV;
+	    
+	bottom_vertex[i][0] = cos((double)theta) * BOTTOM_RADIUS;
+	bottom_vertex[i][1] = sin((double)theta) * BOTTOM_RADIUS;
+	bottom_vertex[i][2] = BOTTOM_ELEV;
+    }
+}
+
+
+// (Re)calculate the sky colors at each vertex
+void fgSkyColorsInit( void ) {
+    fgLIGHT *l;
+    double sun_angle, diff;
+    double outer_param[3], outer_amt[3], outer_diff[3];
+    double middle_param[3], middle_amt[3], middle_diff[3];
+    int i, j;
+
+    l = &cur_light_params;
+
+    FG_LOG( FG_ASTRO, FG_INFO, 
+	    "  Generating the sky colors for each vertex." );
+
+    // setup for the possibility of sunset effects
+    sun_angle = l->sun_angle * RAD_TO_DEG;
+    // fgPrintf( FG_ASTRO, FG_INFO, 
+    //           "  Sun angle in degrees = %.2f\n", sun_angle);
+
+    if ( (sun_angle > 80.0) && (sun_angle < 100.0) ) {
+	// 0.0 - 0.4
+	outer_param[0] = (10.0 - fabs(90.0 - sun_angle)) / 20.0;
+	outer_param[1] = (10.0 - fabs(90.0 - sun_angle)) / 40.0;
+	outer_param[2] = -(10.0 - fabs(90.0 - sun_angle)) / 30.0;
+	// outer_param[2] = 0.0;
+
+	middle_param[0] = (10.0 - fabs(90.0 - sun_angle)) / 40.0;
+	middle_param[1] = (10.0 - fabs(90.0 - sun_angle)) / 80.0;
+	middle_param[2] = 0.0;
+
+	outer_diff[0] = outer_param[0] / 6.0;
+	outer_diff[1] = outer_param[1] / 6.0;
+	outer_diff[2] = outer_param[2] / 6.0;
+
+	middle_diff[0] = middle_param[0] / 6.0;
+	middle_diff[1] = middle_param[1] / 6.0;
+	middle_diff[2] = middle_param[2] / 6.0;
+    } else {
+	outer_param[0] = outer_param[1] = outer_param[2] = 0.0;
+	middle_param[0] = middle_param[1] = middle_param[2] = 0.0;
+
+	outer_diff[0] = outer_diff[1] = outer_diff[2] = 0.0;
+	middle_diff[0] = middle_diff[1] = middle_diff[2] = 0.0;
+    }
+    // printf("  outer_red_param = %.2f  outer_red_diff = %.2f\n", 
+    //        outer_red_param, outer_red_diff);
+
+    // calculate transition colors between sky and fog
+    for ( j = 0; j < 3; j++ ) {
+	outer_amt[j] = outer_param[j];
+	middle_amt[j] = middle_param[j];
+    }
+
+    for ( i = 0; i < 6; i++ ) {
+	for ( j = 0; j < 3; j++ ) {
+	    diff = l->sky_color[j] - l->fog_color[j];
+
+	    // printf("sky = %.2f  fog = %.2f  diff = %.2f\n", 
+	    //        l->sky_color[j], l->fog_color[j], diff);
+
+	    inner_color[i][j] = l->sky_color[j] - diff * 0.3;
+	    middle_color[i][j] = l->sky_color[j] - diff * 0.9 + middle_amt[j];
+	    outer_color[i][j] = l->fog_color[j] + outer_amt[j];
+
+	    if ( inner_color[i][j] > 1.00 ) { inner_color[i][j] = 1.00; }
+	    if ( inner_color[i][j] < 0.10 ) { inner_color[i][j] = 0.10; }
+	    if ( middle_color[i][j] > 1.00 ) { middle_color[i][j] = 1.00; }
+	    if ( middle_color[i][j] < 0.10 ) { middle_color[i][j] = 0.10; }
+	    if ( outer_color[i][j] > 1.00 ) { outer_color[i][j] = 1.00; }
+	    if ( outer_color[i][j] < 0.10 ) { outer_color[i][j] = 0.10; }
+	}
+	inner_color[i][3] = middle_color[i][3] = outer_color[i][3] = 
+	    l->sky_color[3];
+
+	for ( j = 0; j < 3; j++ ) {
+	    outer_amt[j] -= outer_diff[j];
+	    middle_amt[j] -= middle_diff[j];
+	}
+
+	/*
+	printf("inner_color[%d] = %.2f %.2f %.2f %.2f\n", i, inner_color[i][0],
+	       inner_color[i][1], inner_color[i][2], inner_color[i][3]);
+	printf("middle_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	       middle_color[i][0], middle_color[i][1], middle_color[i][2], 
+	       middle_color[i][3]);
+	printf("outer_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	       outer_color[i][0], outer_color[i][1], outer_color[i][2], 
+	       outer_color[i][3]);
+	*/
+    }
+
+    for ( j = 0; j < 3; j++ ) {
+	outer_amt[j] = 0.0;
+	middle_amt[j] = 0.0;
+    }
+
+    for ( i = 6; i < 12; i++ ) {
+
+	for ( j = 0; j < 3; j++ ) {
+	    diff = l->sky_color[j] - l->fog_color[j];
+
+	    // printf("sky = %.2f  fog = %.2f  diff = %.2f\n", 
+	    //        l->sky_color[j], l->fog_color[j], diff);
+
+	    inner_color[i][j] = l->sky_color[j] - diff * 0.3;
+	    middle_color[i][j] = l->sky_color[j] - diff * 0.9 + middle_amt[j];
+	    outer_color[i][j] = l->fog_color[j] + outer_amt[j];
+
+	    if ( inner_color[i][j] > 1.00 ) { inner_color[i][j] = 1.00; }
+	    if ( inner_color[i][j] < 0.10 ) { inner_color[i][j] = 0.10; }
+	    if ( middle_color[i][j] > 1.00 ) { middle_color[i][j] = 1.00; }
+	    if ( middle_color[i][j] < 0.10 ) { middle_color[i][j] = 0.10; }
+	    if ( outer_color[i][j] > 1.00 ) { outer_color[i][j] = 1.00; }
+	    if ( outer_color[i][j] < 0.15 ) { outer_color[i][j] = 0.15; }
+	}
+	inner_color[i][3] = middle_color[i][3] = outer_color[i][3] = 
+	    l->sky_color[3];
+
+	for ( j = 0; j < 3; j++ ) {
+	    outer_amt[j] += outer_diff[j];
+	    middle_amt[j] += middle_diff[j];
+	}
+
+	/*
+	printf("inner_color[%d] = %.2f %.2f %.2f %.2f\n", i, inner_color[i][0],
+	       inner_color[i][1], inner_color[i][2], inner_color[i][3]);
+	printf("middle_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	       middle_color[i][0], middle_color[i][1], middle_color[i][2], 
+	       middle_color[i][3]);
+	printf("outer_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	       outer_color[i][0], outer_color[i][1], outer_color[i][2], 
+	       outer_color[i][3]);
+	*/
+    }
+}
+
+
+// Initialize the sky structure and colors
+void fgSkyInit( void ) {
+    FG_LOG( FG_ASTRO, FG_INFO, "Initializing the sky" );
+
+    fgSkyVerticesInit();
+
+    // regester fgSkyColorsInit() as an event to be run periodically
+    global_events.Register( "fgSkyColorsInit()", fgSkyColorsInit, 
+		            fgEVENT::FG_EVENT_READY, 30000);
+}
+
+
+// Draw the Sky
+void fgSkyRender( void ) {
+    FGInterface *f;
+    fgLIGHT *l;
+    float inner_color[4];
+    float middle_color[4];
+    float outer_color[4];
+    double diff;
+    int i;
+
+    f = current_aircraft.fdm_state;
+    l = &cur_light_params;
+
+    // printf("Rendering the sky.\n");
+
+    // calculate the proper colors
+    for ( i = 0; i < 3; i++ ) {
+	diff = l->sky_color[i] - l->adj_fog_color[i];
+
+	// printf("sky = %.2f  fog = %.2f  diff = %.2f\n", 
+	//        l->sky_color[j], l->adj_fog_color[j], diff);
+
+	inner_color[i] = l->sky_color[i] - diff * 0.3;
+	middle_color[i] = l->sky_color[i] - diff * 0.9;
+	outer_color[i] = l->adj_fog_color[i];
+    }
+    inner_color[3] = middle_color[3] = outer_color[3] = l->adj_fog_color[3];
+
+    xglPushMatrix();
+
+    // Translate to view position
+    Point3D zero_elev = current_view.get_cur_zero_elev();
+    xglTranslatef( zero_elev.x(), zero_elev.y(), zero_elev.z() );
+    // printf("  Translated to %.2f %.2f %.2f\n", 
+    //        zero_elev.x, zero_elev.y, zero_elev.z );
+
+    // Rotate to proper orientation
+    // printf("  lon = %.2f  lat = %.2f\n", FG_Longitude * RAD_TO_DEG,
+    //        FG_Latitude * RAD_TO_DEG);
+    xglRotatef( f->get_Longitude() * RAD_TO_DEG, 0.0, 0.0, 1.0 );
+    xglRotatef( 90.0 - f->get_Latitude() * RAD_TO_DEG, 0.0, 1.0, 0.0 );
+    xglRotatef( l->sun_rotation * RAD_TO_DEG, 0.0, 0.0, 1.0 );
+
+    // Draw inner/center section of sky*/
+    xglBegin( GL_TRIANGLE_FAN );
+    xglColor4fv(l->sky_color);
+    xglVertex3f(0.0, 0.0, CENTER_ELEV);
+    for ( i = 11; i >= 0; i-- ) {
+	xglColor4fv( inner_color );
+	xglVertex3fv( inner_vertex[i] );
+    }
+    xglColor4fv( inner_color );
+    xglVertex3fv( inner_vertex[11] );
+    xglEnd();
+
+    // Draw the middle ring
+    xglBegin( GL_TRIANGLE_STRIP );
+    for ( i = 0; i < 12; i++ ) {
+	xglColor4fv( middle_color );
+	// printf("middle_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	//        middle_color[i][0], middle_color[i][1], middle_color[i][2], 
+	//        middle_color[i][3]);
+	// xglColor4f(1.0, 0.0, 0.0, 1.0);
+	xglVertex3fv( middle_vertex[i] );
+	xglColor4fv( inner_color );
+	// printf("inner_color[%d] = %.2f %.2f %.2f %.2f\n", i, 
+	//        inner_color[i][0], inner_color[i][1], inner_color[i][2], 
+	//        inner_color[i][3]);
+	// xglColor4f(0.0, 0.0, 1.0, 1.0);
+	xglVertex3fv( inner_vertex[i] );
+    }
+    xglColor4fv( middle_color );
+    // xglColor4f(1.0, 0.0, 0.0, 1.0);
+    xglVertex3fv( middle_vertex[0] );
+    xglColor4fv( inner_color );
+    // xglColor4f(0.0, 0.0, 1.0, 1.0);
+    xglVertex3fv( inner_vertex[0] );
+    xglEnd();
+
+    // Draw the outer ring
+    xglBegin( GL_TRIANGLE_STRIP );
+    for ( i = 0; i < 12; i++ ) {
+	xglColor4fv( outer_color );
+	xglVertex3fv( outer_vertex[i] );
+	xglColor4fv( middle_color );
+	xglVertex3fv( middle_vertex[i] );
+    }
+    xglColor4fv( outer_color );
+    xglVertex3fv( outer_vertex[0] );
+    xglColor4fv( middle_color );
+    xglVertex3fv( middle_vertex[0] );
+    xglEnd();
+
+    // Draw the bottom skirt
+    xglBegin( GL_TRIANGLE_STRIP );
+    xglColor4fv( outer_color );
+    for ( i = 0; i < 12; i++ ) {
+	xglVertex3fv( bottom_vertex[i] );
+	xglVertex3fv( outer_vertex[i] );
+    }
+    xglVertex3fv( bottom_vertex[0] );
+    xglVertex3fv( outer_vertex[0] );
+    xglEnd();
+
+    xglPopMatrix();
+}
+
+
@@ -0,0 +1,45 @@
+// sky.hxx -- model sky with an upside down "bowl"
+//
+// Written by Curtis Olson, started December 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+
+
+#ifndef _SKY_HXX
+#define _SKY_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+
+// (Re)generate the display list
+void fgSkyInit( void );
+
+// (Re)calculate the sky colors at each vertex
+void fgSkyColorsInit( void );
+
+// Draw the Sky
+void fgSkyRender( void );
+
+
+#endif // _SKY_HXX
+
+
@@ -0,0 +1,215 @@
+/**************************************************************************
+ * solarsystem.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include <GL/glut.h>
+#include <XGL/xgl.h>
+#include <Debug/logstream.hxx>
+#include <Time/sunpos.hxx>
+#include <Time/moonpos.hxx>
+#include "solarsystem.hxx"
+
+/***************************************************************************
+ * default constructor for class  SolarSystem:   
+ * or course there can only be one way to create an entire solar system -:) )
+ * the FGTime argument is needed to properly initialize the the current orbital
+ * elements
+ *************************************************************************/
+SolarSystem::SolarSystem(FGTime *t)
+{
+  if (theSolarSystem)
+    {
+      FG_LOG( FG_GENERAL, FG_ALERT, "Error: only one solarsystem allowed" );
+      exit(-1);
+    }
+  theSolarSystem = this;
+  ourSun     = new Star(t);   
+  earthsMoon = new Moon(t);
+  mercury    = new Mercury(t);
+  venus      = new Venus(t);
+  mars       = new Mars(t);
+  jupiter    = new Jupiter(t);
+  saturn     = new Saturn(t);
+  uranus     = new Uranus(t);
+  neptune    = new Neptune(t);
+
+  displayList = 0;
+};
+
+/**************************************************************************
+ * the destructor for class SolarSystem;
+ **************************************************************************/
+SolarSystem::~SolarSystem()
+{
+  delete ourSun;
+  delete earthsMoon;
+  delete mercury;
+  delete venus;
+  delete mars;
+  delete jupiter;
+  delete saturn;
+  delete uranus;
+  delete neptune;
+}
+/****************************************************************************
+ * void SolarSystem::rebuild()
+ *
+ * this member function updates the positions for the sun, moon, and planets,
+ * and then rebuilds the display list. 
+ *
+ * arguments: none
+ * return value: none
+ ***************************************************************************/
+void SolarSystem::rebuild()
+{
+  //fgLIGHT *l = &cur_light_params;
+  FGTime *t = FGTime::cur_time_params;  
+  //float x, y, z;
+  //double sun_angle;
+  double ra, dec;
+  //double x_2, x_4, x_8, x_10;*/
+  double magnitude;
+  //GLfloat ambient;
+  //GLfloat amb[4];
+  
+  glDisable(GL_LIGHTING);
+
+  // Step 1: update all the positions
+  ourSun->updatePosition(t);
+  earthsMoon->updatePosition(t, ourSun);
+  mercury->updatePosition(t, ourSun);
+  venus->updatePosition(t, ourSun);
+  mars->updatePosition(t, ourSun);
+  jupiter->updatePosition(t, ourSun);
+  saturn->updatePosition(t, ourSun);
+  uranus->updatePosition(t, ourSun);
+  neptune->updatePosition(t, ourSun);
+  
+  fgUpdateSunPos();   // get the right sun angle (especially important when 
+                      // running for the first time).
+  fgUpdateMoonPos();
+
+  if (displayList)
+    xglDeleteLists(displayList, 1);
+
+  displayList = xglGenLists(1);
+
+  FG_LOG( FG_ASTRO, FG_INFO, "Rebuilding astro display list" );
+
+  // Step 2: rebuild the display list
+  xglNewList( displayList, GL_COMPILE);
+  {
+    // Step 2a: Add the moon...
+    // Not that it is preferred to draw the moon first, and the sun next, in order to mime a
+    // solar eclipse. This is yet untested though...
+    // Euhh, actually the ecplise doesn't work...
+
+    earthsMoon->newImage();
+    // Step 2b:  Add the sun
+    ourSun->newImage();
+    // Step 2c: Add the planets
+    xglBegin(GL_POINTS);
+    mercury->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    venus  ->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    mars   ->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    jupiter->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    saturn ->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    uranus ->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    neptune->getPos(&ra, &dec, &magnitude);addPlanetToList(ra, dec, magnitude);
+    xglEnd();
+    xglEnable(GL_LIGHTING);
+  }
+  xglEndList();
+}
+
+/*****************************************************************************
+ * double SolarSystem::scaleMagnitude(double magn)
+ * This private member function rescales the original magnitude, as used in the
+ * astronomical sense of the word, into a value used by OpenGL to draw a 
+ * convincing Star or planet
+ * 
+ * Argument: the astronomical magnitude
+ *
+ * return value: the rescaled magnitude
+ ****************************************************************************/
+double SolarSystem::scaleMagnitude(double magn)
+{
+  double magnitude = (0.0 - magn) / 5.0 + 1.0;
+  magnitude = magnitude * 0.7 + (3 * 0.1);
+  if (magnitude > 1.0) magnitude = 1.0;
+  if (magnitude < 0.0) magnitude = 0.0;
+  return magnitude;
+}
+
+/***************************************************************************
+ * void SolarSytem::addPlanetToList(double ra, double dec, double magn);
+ *
+ * This private member function first causes the magnitude to be properly
+ * rescaled, and then adds the planet to the display list.
+ * 
+ * arguments: Right Ascension, declination, and magnitude
+ *
+ * return value: none
+ **************************************************************************/
+void SolarSystem::addPlanetToList(double ra, double dec, double magn)
+{
+  double
+    magnitude = scaleMagnitude ( magn );
+
+  fgLIGHT *l = &cur_light_params;
+
+  if ((double) (l->sun_angle - FG_PI_2) > 
+      ((magnitude - 1.0) * - 20 * DEG_TO_RAD)) 
+    {
+      xglColor3f (magnitude, magnitude, magnitude);
+      xglVertex3f( 50000.0 * cos (ra) * cos (dec),
+		   50000.0 * sin (ra) * cos (dec),
+		   50000.0 * sin (dec));
+    }
+}
+
+
+SolarSystem* SolarSystem::theSolarSystem = 0;
+
+/******************************************************************************
+ * void solarSystemRebuild()
+ * this a just a wrapper function, provided for use as an interface to the 
+ * event manager
+ *****************************************************************************/
+void solarSystemRebuild()
+{
+  SolarSystem::theSolarSystem->rebuild();
+}
@@ -0,0 +1,91 @@
+/**************************************************************************
+ * solarsystem.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _SOLARSYSTEM_H_
+#define _SOLARSYSTEM_H_
+
+#include <Time/light.hxx>
+#include <Time/fg_time.hxx>
+#include <Main/views.hxx>
+
+#include "star.hxx"
+#include "moon.hxx"
+#include "mercury.hxx"
+#include "venus.hxx"
+#include "mars.hxx"
+#include "jupiter.hxx"
+#include "saturn.hxx"
+#include "uranus.hxx"
+#include "neptune.hxx"
+#include "pluto.hxx"
+
+
+class SolarSystem
+{
+private:
+  Star*    ourSun;
+  Moon*    earthsMoon;
+  Mercury* mercury;
+  Venus*   venus;
+  Mars*    mars;
+  Jupiter* jupiter;
+  Saturn*  saturn;
+  Uranus*  uranus;
+  Neptune* neptune;
+  //Pluto*   pluto;
+  
+  GLint displayList;
+  double scaleMagnitude(double magn);
+  void addPlanetToList(double ra, double dec, double magn);
+
+
+public:
+  SolarSystem(FGTime *t);
+  CelestialBody *getSun();
+  CelestialBody *getMoon();
+  ~SolarSystem();
+
+  static SolarSystem *theSolarSystem;  // thanks to Bernie Bright!
+  void rebuild();
+  friend void solarSystemRebuild();
+  void draw();
+};
+
+inline CelestialBody* SolarSystem::getSun()
+{
+  return ourSun;
+}
+
+inline CelestialBody* SolarSystem::getMoon()
+{
+  return earthsMoon;
+}
+
+inline void SolarSystem::draw()
+{
+  xglCallList(displayList);
+}
+  
+extern void solarSystemRebuild();
+
+#endif // _SOLARSYSTEM_H_
@@ -0,0 +1,271 @@
+/**************************************************************************
+ * star.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+#include <Time/sunpos.hxx>
+#include <Debug/logstream.hxx>
+#include <Time/light.hxx>
+#include <Main/options.hxx>
+#include "star.hxx"
+
+/*************************************************************************
+ * Star::Star(FGTime *t)
+ * Public constructor for class Star
+ * Argument: The current time.
+ * the hard coded orbital elements our sun are passed to 
+ * CelestialBody::CelestialBody();
+ * note that the word sun is avoided, in order to prevent some compilation
+ * problems on sun systems 
+ ************************************************************************/
+Star::Star(FGTime *t) :
+  CelestialBody (0.000000,  0.0000000000,
+		 0.0000,    0.00000,
+		 282.9404,  4.7093500E-5,	
+		 1.0000000, 0.000000,	
+		 0.016709,  -1.151E-9,
+		 356.0470,  0.98560025850, t)
+{
+    
+  FG_LOG( FG_GENERAL, FG_INFO, "Initializing Sun Texture");
+#ifdef GL_VERSION_1_1
+  xglGenTextures(1, &sun_texid);
+  xglBindTexture(GL_TEXTURE_2D, sun_texid);
+#elif GL_EXT_texture_object
+  xglGenTexturesEXT(1, &sun_texid);
+  xglBindTextureEXT(GL_TEXTURE_2D, sun_texid);
+#else
+#  error port me
+#endif
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  setTexture();
+  glTexImage2D( GL_TEXTURE_2D,
+		0,
+		GL_RGBA,
+		256, 256,
+		0,
+		GL_RGBA, GL_UNSIGNED_BYTE,
+		sun_texbuf);
+     
+  SunObject = gluNewQuadric();
+  if(SunObject == NULL)
+    {
+      printf("gluNewQuadric(SunObject) failed  !\n");
+      exit(0);
+    }
+  
+  //SunList = 0;
+  distance = 0.0;
+}
+
+Star::~Star()
+{
+  //delete SunObject;
+  delete [] sun_texbuf;
+}
+
+
+
+static int texWidth = 256;	/* 64x64 is plenty */
+
+void Star::setTexture()
+{
+  int texSize;
+  //void *textureBuf;
+  GLubyte *p;
+  int i,j;
+  double radius;
+  
+  texSize = texWidth*texWidth;
+  
+  sun_texbuf = new GLubyte[texSize*4];
+  if (!sun_texbuf) 
+    return;  // Ugly!
+  
+  p = sun_texbuf;
+  
+  radius = (double)(texWidth / 2);
+  
+  for (i=0; i < texWidth; i++) {
+    for (j=0; j < texWidth; j++) {
+      double x, y, d;
+	    
+      x = fabs((double)(i - (texWidth / 2)));
+      y = fabs((double)(j - (texWidth / 2)));
+
+      d = sqrt((x * x) + (y * y));
+      if (d < radius) 
+	{
+	  double t = 1.0 - (d / radius); // t is 1.0 at center, 0.0 at edge */
+	  // inverse square looks nice 
+	  *p = (int)((double)0xff * (t * t));
+	  *(p+1) = (int)((double) 0xff * (t*t));
+	  *(p+2) = (int)((double) 0xff * (t*t));
+	  *(p+3) = (int)((double) 0xff * (t*t));
+	} 
+      else
+	{
+	  *p = 0x00;
+	  *(p+1) = 0x00;
+	  *(p+2) = 0x00;
+	  *(p+3) = 0x00;
+	}
+      p += 4;
+    }
+  }
+  //gluBuild2DMipmaps(GL_TEXTURE_2D, 1, texWidth, texWidth, 
+  //	    GL_LUMINANCE,
+  //	    GL_UNSIGNED_BYTE, textureBuf);
+  //free(textureBuf);
+}
+/*************************************************************************
+ * void Jupiter::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of our sun.
+ *************************************************************************/
+void Star::updatePosition(FGTime *t)
+{
+  double 
+    actTime, eccAnom, 
+    xv, yv, v, r,
+    xe, ye, ze, ecl;
+
+  updateOrbElements(t);
+  
+  actTime = fgCalcActTime(t);
+  ecl = DEG_TO_RAD * (23.4393 - 3.563E-7 * actTime); // Angle in Radians
+  eccAnom = fgCalcEccAnom(M, e);  // Calculate the eccentric Anomaly (also known as solving Kepler's equation)
+  
+  xv = cos(eccAnom) - e;
+  yv = sqrt (1.0 - e*e) * sin(eccAnom);
+  v = atan2 (yv, xv);                   // the sun's true anomaly
+  distance = r = sqrt (xv*xv + yv*yv);  // and its distance
+
+  lonEcl = v + w; // the sun's true longitude
+  latEcl = 0;
+
+  // convert the sun's true longitude to ecliptic rectangular 
+  // geocentric coordinates (xs, ys)
+  xs = r * cos (lonEcl);
+  ys = r * sin (lonEcl);
+
+  // convert ecliptic coordinates to equatorial rectangular
+  // geocentric coordinates
+
+  xe = xs;
+  ye = ys * cos (ecl);
+  ze = ys * sin (ecl);
+
+  // And finally, calculate right ascension and declination
+  rightAscension = atan2 (ye, xe);
+  declination = atan2 (ze, sqrt (xe*xe + ye*ye));
+}
+  
+void Star::newImage(void)
+{
+  /*static float stars[3];
+  stars[0] = 0.0;
+  stars[1] = 0.0;
+  stars[2] = 1.0;*/
+
+  fgLIGHT *l = &cur_light_params;
+  float sun_angle = l->sun_angle;
+  
+  if( sun_angle*RAD_TO_DEG < 100 ) { // else no need to draw sun
+    
+    
+    double x_2, x_4, x_8, x_10;
+    GLfloat ambient;
+    GLfloat amb[4];
+    int sun_size = 750;
+    
+    // daily variation sun gets larger near horizon
+    /*if(sun_angle*RAD_TO_DEG > 84.0 && sun_angle*RAD_TO_DEG < 95)
+      {
+      double sun_grow = 9*fabs(94-sun_angle*RAD_TO_DEG);
+      sun_size = (int)(sun_size + sun_size * cos(sun_grow*DEG_TO_RAD));
+      }*/
+    x_2 = sun_angle * sun_angle;
+    x_4 = x_2 * x_2;
+    x_8 = x_4 * x_4;
+    x_10 = x_8 * x_2;
+    ambient = (float)(0.4 * pow (1.1, - x_10 / 30.0));
+    if (ambient < 0.3) ambient = 0.3;
+    if (ambient > 1.0) ambient = 1.0;
+    
+    amb[0] = ((ambient * 6.0)  - 1.0); // minimum value = 0.8
+    amb[1] = ((ambient * 11.0) - 3.0); // minimum value = 0.3
+    amb[2] = ((ambient * 12.0) - 3.6); // minimum value = 0.0
+    amb[3] = 1.00;
+    
+    if (amb[0] > 1.0) amb[0] = 1.0;
+    if (amb[1] > 1.0) amb[1] = 1.0;
+    if (amb[2] > 1.0) amb[2] = 1.0;
+    xglColor3fv(amb);
+    glPushMatrix();
+    {
+      xglRotatef(((RAD_TO_DEG * rightAscension)- 90.0), 0.0, 0.0, 1.0);
+      xglRotatef((RAD_TO_DEG * declination), 1.0, 0.0, 0.0);
+      xglTranslatef(0,60000,0);
+      if (current_options.get_textures())
+	{
+	  glEnable(GL_TEXTURE_2D);                                             // TEXTURE ENABLED
+	  glEnable(GL_BLEND);                                                  // BLEND ENABLED
+	  
+	  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);  
+	  glBindTexture(GL_TEXTURE_2D, sun_texid);
+
+	  glBegin(GL_QUADS);
+	  glTexCoord2f(0.0f, 0.0f); glVertex3f(-5000, 0.0, -5000);
+	  glTexCoord2f(1.0f, 0.0f); glVertex3f( 5000, 0.0, -5000);
+	  glTexCoord2f(1.0f, 1.0f); glVertex3f( 5000, 0.0,  5000);
+	  glTexCoord2f(0.0f, 1.0f); glVertex3f(-5000, 0.0,  5000);
+	  glEnd();
+	}
+      xglDisable(GL_TEXTURE_2D); // TEXTURE DISABLED
+      xglDisable(GL_BLEND);	// BLEND DISABLED
+    }
+
+    glPopMatrix();
+    glDisable(GL_LIGHTING);	//LIGHTING DISABLED
+    glDisable(GL_BLEND);	//BLEND DISABLED
+    glPushMatrix();
+    {     
+      xglRotatef(((RAD_TO_DEG * rightAscension)- 90.0), 0.0, 0.0, 1.0);
+      xglRotatef((RAD_TO_DEG * declination), 1.0, 0.0, 0.0);
+      xglColor4fv(amb);
+      xglTranslatef(0,60000,0);
+      gluSphere( SunObject,  sun_size, 10, 10 );
+      }
+    glPopMatrix();
+    glDisable(GL_TEXTURE_2D);                                             // TEXTURE DISABLED
+    glDisable(GL_BLEND);                                                  // BLEND DISABLED  
+  }
+}
@@ -0,0 +1,98 @@
+/**************************************************************************
+ * star.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _STAR_HXX_
+#define _STAR_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+
+
+class Star : public CelestialBody
+{
+private:
+  //double longitude;  // the sun's true longitude - this is depreciated by
+                       // CelestialBody::lonEcl 
+  double xs, ys;     // the sun's rectangular geocentric coordinates
+  double distance;   // the sun's distance to the earth
+   GLUquadricObj *SunObject;
+  GLuint sun_texid;
+  GLubyte *sun_texbuf;
+
+  void setTexture();
+public:
+  Star (FGTime *t);
+  ~Star();
+  void updatePosition(FGTime *t);
+  double getM();
+  double getw();
+  //double getLon();
+  double getxs();
+  double getys();
+  double getDistance();
+  void newImage();
+};
+
+
+
+inline double Star::getM()
+{
+  return M;
+}
+
+inline double Star::getw()
+{
+  return w;
+}
+
+inline double Star::getxs()
+{
+  return xs;
+}
+
+inline double Star::getys()
+{
+  return ys;
+}
+
+inline double Star::getDistance()
+{
+  return distance;
+}
+
+
+#endif // _STAR_HXX_
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -0,0 +1,267 @@
+// stars.cxx -- data structures and routines for managing and rendering stars.
+//
+// Written by Curtis Olson, started August 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@me.umn.edu
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+//*************************************************************************/
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include "Include/compiler.h"
+#ifdef FG_HAVE_STD_INCLUDES
+#  include <cmath>
+#  include <cstdio>
+#  include <cstring>
+#  include <ctime>
+#else
+#  include <math.h>
+#  include <stdio.h>
+#  include <string.h>
+#  include <time.h>
+#endif
+
+#include <string>
+
+#include <GL/glut.h>
+#include <XGL/xgl.h>
+
+#include <Aircraft/aircraft.hxx>
+#include <Debug/logstream.hxx>
+#include <Include/fg_constants.h>
+#include <Misc/fgpath.hxx>
+#include <Misc/fgstream.hxx>
+#include <Misc/stopwatch.hxx>
+#include <Main/options.hxx>
+#include <Main/views.hxx>
+#include <Time/fg_time.hxx>
+#include "Misc/stopwatch.hxx"
+
+#include "stars.hxx"
+
+FG_USING_STD(getline);
+
+#define EpochStart           (631065600)
+#define DaysSinceEpoch(secs) (((secs)-EpochStart)*(1.0/(24*3600)))
+#define FG_MAX_STARS 3500
+
+// Define four structures, each with varying amounts of stars
+static GLint stars[FG_STAR_LEVELS];
+
+
+// Initialize the Star Management Subsystem
+int fgStarsInit( void ) {
+    // -dw- avoid local data > 32k error by dynamic allocation of the
+    // array, problem for some compilers
+    Point3D *starlist = new Point3D[FG_MAX_STARS];
+    // struct CelestialCoord pltPos;
+    double right_ascension, declination, magnitude;
+    double min_magnitude[FG_STAR_LEVELS];
+    // double ra_save, decl_save;
+    // double ra_save1, decl_save1;
+    int i, j, starcount, count;
+
+    FG_LOG( FG_ASTRO, FG_INFO, "Initializing stars" );
+
+    if ( FG_STAR_LEVELS < 4 ) {
+	FG_LOG( FG_ASTRO, FG_ALERT, "Big whups in stars.cxx" );
+	exit(-1);
+    }
+
+    // build the full path name to the stars data base file
+    FGPath path ( current_options.get_fg_root() );
+    path.append( "Astro/stars" );
+    FG_LOG( FG_ASTRO, FG_INFO, "  Loading stars from " << path.str() );
+
+    fg_gzifstream in( path.str() );
+    if ( ! in ) {
+	FG_LOG( FG_ASTRO, FG_ALERT, "Cannot open star file: " << path.str() );
+	exit(-1);
+    }
+
+    starcount = 0;
+
+    StopWatch timer;
+    timer.start();
+
+    // read in each line of the file
+    while ( ! in.eof() && starcount < FG_MAX_STARS )
+    {
+	in >> skipcomment;
+	string name;
+	getline( in, name, ',' );
+	in >> starlist[starcount];
+	++starcount;
+    }
+
+    timer.stop();
+    FG_LOG( FG_ASTRO, FG_INFO, 
+	    "Loaded " << starcount << " stars in "
+	    << timer.elapsedSeconds() << " seconds" );
+
+    min_magnitude[0] = 4.2;
+    min_magnitude[1] = 3.6;
+    min_magnitude[2] = 3.0;
+    min_magnitude[3] = 2.4;
+    min_magnitude[4] = 1.8;
+    min_magnitude[5] = 1.2;
+    min_magnitude[6] = 0.6;
+    min_magnitude[7] = 0.0;
+
+    // build the various star display lists
+    for ( i = 0; i < FG_STAR_LEVELS; i++ ) {
+
+	stars[i] = xglGenLists(1);
+	xglNewList( stars[i], GL_COMPILE );
+	xglBegin( GL_POINTS );
+
+	count = 0;
+
+	for ( j = 0; j < starcount; j++ ) {
+	    magnitude = starlist[j].z();
+	    // printf("magnitude = %.2f\n", magnitude);
+
+	    if ( magnitude < min_magnitude[i] ) {
+		right_ascension = starlist[j].x();
+		declination = starlist[j].y();
+
+		count++;
+
+		// scale magnitudes to (0.0 - 1.0)
+		magnitude = (0.0 - magnitude) / 5.0 + 1.0;
+		
+		// scale magnitudes again so they look ok
+		if ( magnitude > 1.0 ) { magnitude = 1.0; }
+		if ( magnitude < 0.0 ) { magnitude = 0.0; }
+		// magnitude =
+		//     magnitude * 0.7 + (((FG_STAR_LEVELS - 1) - i) * 0.042);
+		  
+		magnitude = magnitude * 0.9 + 
+		    (((FG_STAR_LEVELS - 1) - i) * 0.014);
+		// printf("  Found star: %d %s, %.3f %.3f %.3f\n", count,
+		//        name, right_ascension, declination, magnitude);
+		    
+		xglColor3f( magnitude, magnitude, magnitude );
+		//xglColor3f(0,0,0);*/
+		xglVertex3f( 50000.0*cos(right_ascension)*cos(declination),
+			     50000.0*sin(right_ascension)*cos(declination),
+			     50000.0*sin(declination) );
+	    }
+	} // while
+
+	xglEnd();
+
+	/*
+	xglBegin(GL_LINE_LOOP);
+        xglColor3f(1.0, 0.0, 0.0);
+	xglVertex3f( 50000.0 * cos(ra_save-0.2) * cos(decl_save-0.2),
+		    50000.0 * sin(ra_save-0.2) * cos(decl_save-0.2),
+		    50000.0 * sin(decl_save-0.2) );
+	xglVertex3f( 50000.0 * cos(ra_save+0.2) * cos(decl_save-0.2),
+		    50000.0 * sin(ra_save+0.2) * cos(decl_save-0.2),
+		    50000.0 * sin(decl_save-0.2) );
+ 	xglVertex3f( 50000.0 * cos(ra_save+0.2) * cos(decl_save+0.2),
+		    50000.0 * sin(ra_save+0.2) * cos(decl_save+0.2),
+		    50000.0 * sin(decl_save+0.2) );
+ 	xglVertex3f( 50000.0 * cos(ra_save-0.2) * cos(decl_save+0.2),
+		    50000.0 * sin(ra_save-0.2) * cos(decl_save+0.2),
+		    50000.0 * sin(decl_save+0.2) );
+	xglEnd();
+	*/
+
+	/*
+	xglBegin(GL_LINE_LOOP);
+        xglColor3f(0.0, 1.0, 0.0);
+	xglVertex3f( 50000.0 * cos(ra_save1-0.2) * cos(decl_save1-0.2),
+		    50000.0 * sin(ra_save1-0.2) * cos(decl_save1-0.2),
+		    50000.0 * sin(decl_save1-0.2) );
+	xglVertex3f( 50000.0 * cos(ra_save1+0.2) * cos(decl_save1-0.2),
+		    50000.0 * sin(ra_save1+0.2) * cos(decl_save1-0.2),
+		    50000.0 * sin(decl_save1-0.2) );
+ 	xglVertex3f( 50000.0 * cos(ra_save1+0.2) * cos(decl_save1+0.2),
+		    50000.0 * sin(ra_save1+0.2) * cos(decl_save1+0.2),
+		    50000.0 * sin(decl_save1+0.2) );
+ 	xglVertex3f( 50000.0 * cos(ra_save1-0.2) * cos(decl_save1+0.2),
+		    50000.0 * sin(ra_save1-0.2) * cos(decl_save1+0.2),
+		    50000.0 * sin(decl_save1+0.2) );
+	xglEnd();
+	*/
+
+	xglEndList();
+	    
+	FG_LOG( FG_ASTRO, FG_INFO,
+		"  Loading " << count << " stars brighter than " 
+		<< min_magnitude[i] );
+    }
+
+    return 1;  // OK, we got here because initialization worked.
+}
+
+
+// Draw the Stars
+void fgStarsRender( void ) {
+    FGInterface *f;
+    fgLIGHT *l;
+    FGTime *t;
+    int i;
+
+    f = current_aircraft.fdm_state;
+    l = &cur_light_params;
+    t = FGTime::cur_time_params;
+
+    // FG_PI_2 + 0.1 is about 6 degrees after sundown and before sunrise
+
+    // t->sun_angle = 3.0; // to force stars to be drawn (for testing)
+
+    // render the stars
+    if ( l->sun_angle > (FG_PI_2 + 5 * DEG_TO_RAD ) ) {
+	// determine which star structure to draw
+	if ( l->sun_angle > (FG_PI_2 + 10.0 * DEG_TO_RAD ) ) {
+	    i = 0;
+	} else if ( l->sun_angle > (FG_PI_2 + 8.8 * DEG_TO_RAD ) ) {
+	    i = 1;
+	} else if ( l->sun_angle > (FG_PI_2 + 7.5 * DEG_TO_RAD ) ) {
+	    i = 2;
+	} else if ( l->sun_angle > (FG_PI_2 + 7.0 * DEG_TO_RAD ) ) {
+	    i = 3;
+	} else if ( l->sun_angle > (FG_PI_2 + 6.5 * DEG_TO_RAD ) ) {
+	    i = 4;
+	} else if ( l->sun_angle > (FG_PI_2 + 6.0 * DEG_TO_RAD ) ) {
+	    i = 5;
+	} else if ( l->sun_angle > (FG_PI_2 + 5.5 * DEG_TO_RAD ) ) {
+	    i = 6;
+	} else {
+	    i = 7;
+	}
+
+	// printf("RENDERING STARS = %d (night)\n", i);
+
+	xglCallList(stars[i]);
+    } else {
+	// printf("not RENDERING STARS (day)\n");
+    }
+}
+
+
@@ -0,0 +1,47 @@
+// stars.hxx -- data structures and routines for managing and rendering stars.
+//
+// Written by Curtis Olson, started August 1997.
+//
+// Copyright (C) 1997  Curtis L. Olson  - curt@me.umn.edu
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+
+
+#ifndef _STARS_HXX
+#define _STARS_HXX
+
+
+#ifndef __cplusplus                                                          
+# error This library requires C++
+#endif                                   
+
+#include <Time/fg_time.hxx>
+
+#define FG_STAR_LEVELS 8         // how many star transitions
+
+// Initialize the Star Management Subsystem
+int fgStarsInit( void );
+
+// Draw the Stars
+void fgStarsRender( void );
+
+// [no longer used?] extern FGTime cur_time_params;
+
+
+#endif // _STARS_HXX
+
+
@@ -0,0 +1,60 @@
+/**************************************************************************
+ * uranus.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "uranus.hxx"
+
+/*************************************************************************
+ * Uranus::Uranus(FGTime *t)
+ * Public constructor for class Uranus
+ * Argument: The current time.
+ * the hard coded orbital elements for Uranus are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Uranus::Uranus(FGTime *t) :
+  CelestialBody(74.00050,   1.3978000E-5,
+		0.7733,     1.900E-8,
+		96.66120,   3.0565000E-5,
+		19.181710, -1.55E-8,
+		0.047318,   7.450E-9,
+		142.5905,   0.01172580600, t)
+{
+}
+
+/*************************************************************************
+ * void Uranus::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Uranus, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Uranus specific equation
+ *************************************************************************/
+void Uranus::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -7.15 + 5*log10( r*R) + 0.001 * FV;
+}
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * uranus.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _URANUS_HXX_
+#define _URANUS_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Uranus : public CelestialBody
+{
+public:
+  Uranus ( FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _URANUS_HXX_
@@ -0,0 +1,60 @@
+/**************************************************************************
+ * venus.cxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#ifdef __BORLANDC__
+#  define exception c_exception
+#endif
+#include <math.h>
+
+#include "venus.hxx"
+
+/*************************************************************************
+ * Venus::Venus(FGTime *t)
+ * Public constructor for class Venus
+ * Argument: The current time.
+ * the hard coded orbital elements for Venus are passed to 
+ * CelestialBody::CelestialBody();
+ ************************************************************************/
+Venus::Venus(FGTime *t) :
+  CelestialBody(76.67990,  2.4659000E-5, 
+		3.3946,    2.75E-8,
+		54.89100,  1.3837400E-5,
+		0.7233300, 0.000000,
+		0.006773, -1.302E-9,
+		48.00520,  1.60213022440, t)
+{
+}
+
+/*************************************************************************
+ * void Venus::updatePosition(FGTime *t, Star *ourSun)
+ * 
+ * calculates the current position of Venus, by calling the base class,
+ * CelestialBody::updatePosition(); The current magnitude is calculated using 
+ * a Venus specific equation
+ *************************************************************************/
+void Venus::updatePosition(FGTime *t, Star *ourSun)
+{
+  CelestialBody::updatePosition(t, ourSun);
+  magnitude = -4.34 + 5*log10( r*R ) + 0.013 * FV + 4.2E-07 * pow(FV,3);
+}
@@ -0,0 +1,38 @@
+/**************************************************************************
+ * venus.hxx
+ * Written by Durk Talsma. Originally started October 1997, for distribution  
+ * with the FlightGear project. Version 2 was written in August and 
+ * September 1998. This code is based upon algorithms and data kindly 
+ * provided by Mr. Paul Schlyter. (pausch@saaf.se). 
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ **************************************************************************/
+#ifndef _VENUS_HXX_
+#define _VENUS_HXX_
+
+#include <Time/fg_time.hxx>
+#include "celestialBody.hxx"
+#include "star.hxx"
+
+class Venus : public CelestialBody
+{
+public:
+  Venus ( FGTime *t);
+  void updatePosition(FGTime *t, Star *ourSun);
+};
+
+#endif // _VENUS_HXX_