Continued FGViewer cleanups. FGViewer is now a base class so that we can

derive specific viewer classes from it.  Here's what I currently have in mind:

FGViewer
  |
  |-> FGViewerPRH     (current system with orientation specified in
  |                    LaRCsim Euler angle convention)
  |
  |-> FGViewerLookAt  Feed in a position, view direction, and up vector
  |
  |-> FGViewerHPR     (similar to PRH, but using ssg hpr euler angle
  |                    convention)
  |-> others?

src/Cockpit/panel.cxx

@@ -35,6 +35,7 @@
 #include <simgear/misc/fgpath.hxx>
 #include <Main/globals.hxx>
 #include <Objects/texload.h>
+#include <Time/light.hxx>
 
 #include "hud.hxx"
 #include "panel.hxx"

src/Main/Makefile.am

@@ -43,7 +43,8 @@ fgfs_SOURCES = \
 	options.cxx options.hxx \
 	save.cxx save.hxx \
 	splash.cxx splash.hxx \
-	viewer.cxx viewer.hxx
+	viewer.cxx viewer.hxx \
+	viewer_rph.cxx viewer_rph.hxx
 
 fgfs_LDADD = \
 	$(top_builddir)/src/Aircraft/libAircraft.a \

src/Main/fg_init.cxx

@@ -515,26 +515,16 @@ bool fgInitSubsystems( void ) {
 
     // now handled inside of the fgTileMgrUpdate()
 
-    /*
-    geod_pos = Point3D( cur_fdm_state->get_Longitude(), cur_fdm_state->get_Latitude(), 0.0);
-    tmp_abs_view_pos = sgGeodToCart(geod_pos);
-
-    FG_LOG( FG_GENERAL, FG_DEBUG,
-    	    "Initial abs_view_pos = " << tmp_abs_view_pos );
-    scenery.cur_elev =
-	fgTileMgrCurElev( cur_fdm_state->get_Longitude(), cur_fdm_state->get_Latitude(),
-			  tmp_abs_view_pos );
-    FG_LOG( FG_GENERAL, FG_DEBUG,
-	    "Altitude after update " << scenery.cur_elev );
-    */
-
     // Reset our altitude if we are below ground
-    FG_LOG( FG_GENERAL, FG_DEBUG, "Current altitude = " << cur_fdm_state->get_Altitude() );
+    FG_LOG( FG_GENERAL, FG_DEBUG, "Current altitude = "
+	    << cur_fdm_state->get_Altitude() );
     FG_LOG( FG_GENERAL, FG_DEBUG, "Current runway altitude = " <<
 	    cur_fdm_state->get_Runway_altitude() );
 
-    if ( cur_fdm_state->get_Altitude() < cur_fdm_state->get_Runway_altitude() + 3.758099) {
+    if ( cur_fdm_state->get_Altitude() < cur_fdm_state->get_Runway_altitude() +
-	cur_fdm_state->set_Altitude( cur_fdm_state->get_Runway_altitude() + 3.758099 );
+	 3.758099) {
+	cur_fdm_state->set_Altitude( cur_fdm_state->get_Runway_altitude() +
+				     3.758099 );
     }
 
     FG_LOG( FG_GENERAL, FG_INFO,

src/Main/globals.hxx

@@ -31,7 +31,7 @@
 #include <simgear/timing/sg_time.hxx>
 
 #include "options.hxx"
-#include "viewer.hxx"
+#include "viewer_rph.hxx"
 
 
 class FGGlobals {
@@ -65,8 +65,7 @@ private:
     FGOptions *options;
 
     // viewers
-    // FGViewer *pilot_view;
+    FGViewerRPH *current_view;
-    FGViewer *current_view;
 
 public:
 
@@ -102,8 +101,8 @@ public:
     // inline FGViewer *get_pilot_view() const { return pilot_view; }
     // inline void set_pilot_view( FGViewer *v ) { pilot_view = v; }
     
-    inline FGViewer *get_current_view() const { return current_view; }
+    inline FGViewerRPH *get_current_view() const { return current_view; }
-    inline void set_current_view( FGViewer *v ) { current_view = v; }
+    inline void set_current_view( FGViewerRPH *v ) { current_view = v; }
     
 };
 

src/Main/keyboard.cxx

@@ -79,7 +79,7 @@ extern void fgReshape( int width, int height );
 // Handle keyboard events
 void GLUTkey(unsigned char k, int x, int y) {
     FGInterface *f;
-    FGViewer *v;
+    FGViewerRPH *v;
     float fov, tmp;
     static bool winding_ccw = true;
     int speed;
@@ -473,7 +473,7 @@ void GLUTkey(unsigned char k, int x, int y) {
 
 // Handle "special" keyboard events
 void GLUTspecialkey(int k, int x, int y) {
-    FGViewer *v;
+    FGViewerRPH *v;
 
     v = globals->get_current_view();
 

src/Main/main.cxx

@@ -89,6 +89,7 @@
 #include <Scenery/tilemgr.hxx>
 #include <Time/event.hxx>
 #include <Time/fg_timer.hxx>
+#include <Time/light.hxx>
 #include <Time/sunpos.hxx>
 #include <Time/tmp.hxx>
 
@@ -1339,7 +1340,7 @@ int main( int argc, char **argv ) {
     FGOptions *options = new FGOptions;
     globals->set_options( options );
 
-    FGViewer *pv = new FGViewer;
+    FGViewerRPH *pv = new FGViewerRPH;
     globals->set_current_view( pv );
     // FGViewer *cv = new FGViewer;
     // globals->set_current_view( cv );

src/Main/options.hxx

@@ -56,6 +56,8 @@ FG_USING_STD(vector);
 FG_USING_STD(string);
 
 #define NEW_DEFAULT_MODEL_HZ 120
+#define FG_FOV_MIN 0.1
+#define FG_FOV_MAX 179.9
 
 
 class FGOptions {

src/Main/viewer.cxx

@@ -36,10 +36,6 @@
 #include <simgear/math/polar3d.hxx>
 #include <simgear/math/vector.hxx>
 
-#include <Aircraft/aircraft.hxx>
-#include <Cockpit/panel.hxx>
-#include <Scenery/scenery.hxx>
-
 #include "globals.hxx"
 #include "viewer.hxx"
 
@@ -84,290 +80,15 @@ inline static void fgMakeViewRot( sgMat4 dst, const sgMat4 m1, const sgMat4 m2 )
 
 // Initialize a view structure
 void FGViewer::init( void ) {
-    dirty = true;
+    FG_LOG( FG_VIEW, FG_ALERT, "Shouldn't ever see this" );
-
+    exit(-1);
-    FG_LOG( FG_VIEW, FG_INFO, "Initializing View parameters" );
-
-    view_offset = goal_view_offset =
-	globals->get_options()->get_default_view_offset();
-    sgSetVec3( pilot_offset, 0.0, 0.0, 0.0 );
-
-    globals->get_options()->set_win_ratio( globals->get_options()->get_xsize() /
-					   globals->get_options()->get_ysize()
-					   );
-
-#ifndef USE_FAST_VIEWROT
-    // This never changes -- NHV
-    LARC_TO_SSG[0][0] = 0.0; 
-    LARC_TO_SSG[0][1] = 1.0; 
-    LARC_TO_SSG[0][2] = -0.0; 
-    LARC_TO_SSG[0][3] = 0.0; 
-
-    LARC_TO_SSG[1][0] = 0.0; 
-    LARC_TO_SSG[1][1] = 0.0; 
-    LARC_TO_SSG[1][2] = 1.0; 
-    LARC_TO_SSG[1][3] = 0.0;
-	
-    LARC_TO_SSG[2][0] = 1.0; 
-    LARC_TO_SSG[2][1] = -0.0; 
-    LARC_TO_SSG[2][2] = 0.0; 
-    LARC_TO_SSG[2][3] = 0.0;
-	
-    LARC_TO_SSG[3][0] = 0.0; 
-    LARC_TO_SSG[3][1] = 0.0; 
-    LARC_TO_SSG[3][2] = 0.0; 
-    LARC_TO_SSG[3][3] = 1.0; 
-#endif // USE_FAST_VIEWROT
-}
-
-
-#define USE_FAST_LOCAL
-#ifdef USE_FAST_LOCAL
-inline static void fgMakeLOCAL( sgMat4 dst, const double Theta,
-				const double Phi, const double Psi)
-{
-    SGfloat cosTheta = (SGfloat) cos(Theta);
-    SGfloat sinTheta = (SGfloat) sin(Theta);
-    SGfloat cosPhi   = (SGfloat) cos(Phi);
-    SGfloat sinPhi   = (SGfloat) sin(Phi);
-    SGfloat sinPsi   = (SGfloat) sin(Psi) ;
-    SGfloat cosPsi   = (SGfloat) cos(Psi) ;
-	
-    dst[0][0] = cosPhi * cosTheta;
-    dst[0][1] =	sinPhi * cosPsi + cosPhi * -sinTheta * -sinPsi;
-    dst[0][2] =	sinPhi * sinPsi + cosPhi * -sinTheta * cosPsi;
-    dst[0][3] =	SG_ZERO;
-
-    dst[1][0] = -sinPhi * cosTheta;
-    dst[1][1] =	cosPhi * cosPsi + -sinPhi * -sinTheta * -sinPsi;
-    dst[1][2] =	cosPhi * sinPsi + -sinPhi * -sinTheta * cosPsi;
-    dst[1][3] = SG_ZERO ;
-	
-    dst[2][0] = sinTheta;
-    dst[2][1] =	cosTheta * -sinPsi;
-    dst[2][2] =	cosTheta * cosPsi;
-    dst[2][3] = SG_ZERO;
-	
-    dst[3][0] = SG_ZERO;
-    dst[3][1] = SG_ZERO;
-    dst[3][2] = SG_ZERO;
-    dst[3][3] = SG_ONE ;
-}
-#endif
-
-
-// convert sgMat4 to MAT3 and print
-static void print_sgMat4( sgMat4 &in) {
-    int i, j;
-    for ( i = 0; i < 4; i++ ) {
-	for ( j = 0; j < 4; j++ ) {
-	    printf("%10.4f ", in[i][j]);
-	}
-	cout << endl;
-    }
 }
 
 
 // Update the view parameters
 void FGViewer::update() {
-    Point3D tmp;
+    FG_LOG( FG_VIEW, FG_ALERT, "Shouldn't ever see this" );
-    sgVec3 minus_z, forward;
+    exit(-1);
-    sgMat4 VIEWo;
-
-    // calculate the cartesion coords of the current lat/lon/0 elev
-    Point3D p = Point3D( geod_view_pos[0], 
-			 geod_view_pos[1], 
-			 sea_level_radius );
-
-    tmp = sgPolarToCart3d(p) - scenery.center;
-    sgSetVec3( zero_elev, tmp[0], tmp[1], tmp[2] );
-
-    // calculate view position in current FG view coordinate system
-    // p.lon & p.lat are already defined earlier, p.radius was set to
-    // the sea level radius, so now we add in our altitude.
-    if ( geod_view_pos[2] > (scenery.cur_elev + 0.5 * METER_TO_FEET) ) {
-	p.setz( p.radius() + geod_view_pos[2] );
-    } else {
-	p.setz( p.radius() + scenery.cur_elev + 0.5 * METER_TO_FEET );
-    }
-
-    tmp = sgPolarToCart3d(p);
-    sgdSetVec3( abs_view_pos, tmp[0], tmp[1], tmp[2] );
-
-    sgdVec3 sc;
-    sgdSetVec3( sc, scenery.center.x(), scenery.center.y(), scenery.center.z());
-    sgdVec3 vp;
-    sgdSubVec3( vp, abs_view_pos, sc );
-    sgSetVec3( view_pos, vp );
-    // view_pos = abs_view_pos - scenery.center;
-
-    FG_LOG( FG_VIEW, FG_DEBUG, "sea level radius = " << sea_level_radius );
-    FG_LOG( FG_VIEW, FG_DEBUG, "Polar view pos = " << p );
-    FG_LOG( FG_VIEW, FG_DEBUG, "Absolute view pos = "
-	    << abs_view_pos[0] << ","
-	    << abs_view_pos[1] << ","
-	    << abs_view_pos[2] );
-    FG_LOG( FG_VIEW, FG_DEBUG, "Relative view pos = "
-	    << view_pos[0] << "," << view_pos[1] << "," << view_pos[2] );
-
-    // code to calculate LOCAL matrix calculated from Phi, Theta, and
-    // Psi (roll, pitch, yaw) in case we aren't running LaRCsim as our
-    // flight model
-	
-#ifdef USE_FAST_LOCAL
-	
-    fgMakeLOCAL( LOCAL, rph[1], rph[0], -rph[2] );
-	
-#else // USE_TEXT_BOOK_METHOD
-	
-    sgVec3 rollvec;
-    sgSetVec3( rollvec, 0.0, 0.0, 1.0 );
-    sgMat4 PHI;		// roll
-    sgMakeRotMat4( PHI, rph[0] * RAD_TO_DEG, rollvec );
-
-    sgVec3 pitchvec;
-    sgSetVec3( pitchvec, 0.0, 1.0, 0.0 );
-    sgMat4 THETA;		// pitch
-    sgMakeRotMat4( THETA, rph[1] * RAD_TO_DEG, pitchvec );
-
-    // ROT = PHI * THETA
-    sgMat4 ROT;
-    // sgMultMat4( ROT, PHI, THETA );
-    sgCopyMat4( ROT, PHI );
-    sgPostMultMat4( ROT, THETA );
-
-    sgVec3 yawvec;
-    sgSetVec3( yawvec, 1.0, 0.0, 0.0 );
-    sgMat4 PSI;		// heading
-    sgMakeRotMat4( PSI, -rph[2] * RAD_TO_DEG, yawvec );
-
-    // LOCAL = ROT * PSI
-    // sgMultMat4( LOCAL, ROT, PSI );
-    sgCopyMat4( LOCAL, ROT );
-    sgPostMultMat4( LOCAL, PSI );
-
-#endif // USE_FAST_LOCAL
-	
-    // cout << "LOCAL matrix" << endl;
-    // print_sgMat4( LOCAL );
-	
-    sgMakeRotMat4( UP, 
-		   geod_view_pos[0] * RAD_TO_DEG,
-		   0.0,
-		   -geod_view_pos[1] * RAD_TO_DEG );
-
-    sgSetVec3( local_up, UP[0][0], UP[0][1], UP[0][2] );
-    // sgXformVec3( local_up, UP );
-    // cout << "Local Up = " << local_up[0] << "," << local_up[1] << ","
-    //      << local_up[2] << endl;
-    
-    // Alternative method to Derive local up vector based on
-    // *geodetic* coordinates
-    // alt_up = sgPolarToCart(FG_Longitude, FG_Latitude, 1.0);
-    // printf( "    Alt Up = (%.4f, %.4f, %.4f)\n", 
-    //         alt_up.x, alt_up.y, alt_up.z);
-
-    // VIEWo = LOCAL * UP
-    // sgMultMat4( VIEWo, LOCAL, UP );
-    sgCopyMat4( VIEWo, LOCAL );
-    sgPostMultMat4( VIEWo, UP );
-    // cout << "VIEWo matrix" << endl;
-    // print_sgMat4( VIEWo );
-
-    // generate the sg view up and forward vectors
-    sgSetVec3( view_up, VIEWo[0][0], VIEWo[0][1], VIEWo[0][2] );
-    // cout << "view = " << view[0] << ","
-    //      << view[1] << "," << view[2] << endl;
-    sgSetVec3( forward, VIEWo[2][0], VIEWo[2][1], VIEWo[2][2] );
-    // cout << "forward = " << forward[0] << ","
-    //      << forward[1] << "," << forward[2] << endl;
-
-    // generate the pilot offset vector in world coordinates
-    sgVec3 pilot_offset_world;
-    sgSetVec3( pilot_offset_world, 
-	       pilot_offset[2], pilot_offset[1], -pilot_offset[0] );
-    sgXformVec3( pilot_offset_world, pilot_offset_world, VIEWo );
-
-    // generate the view offset matrix
-    sgMakeRotMat4( VIEW_OFFSET, view_offset * RAD_TO_DEG, view_up );
-    // cout << "VIEW_OFFSET matrix" << endl;
-    // print_sgMat4( VIEW_OFFSET );
-    sgXformVec3( view_forward, forward, VIEW_OFFSET );
-    // cout << "view_forward = " << view_forward[0] << ","
-    //      << view_forward[1] << "," << view_forward[2] << endl;
-	
-    // VIEW_ROT = LARC_TO_SSG * ( VIEWo * VIEW_OFFSET )
-#ifdef USE_FAST_VIEWROT
-    fgMakeViewRot( VIEW_ROT, VIEW_OFFSET, VIEWo );
-#else
-    // sgMultMat4( VIEW_ROT, VIEW_OFFSET, VIEWo );
-    // sgPreMultMat4( VIEW_ROT, LARC_TO_SSG );
-    sgCopyMat4( VIEW_ROT, VIEWo );
-    sgPostMultMat4( VIEW_ROT, VIEW_OFFSET );
-    sgPreMultMat4( VIEW_ROT, LARC_TO_SSG );
-#endif
-    // cout << "VIEW_ROT matrix" << endl;
-    // print_sgMat4( VIEW_ROT );
-
-    sgVec3 trans_vec;
-    sgAddVec3( trans_vec, view_pos, pilot_offset_world );
-
-    // VIEW = VIEW_ROT * TRANS
-    sgCopyMat4( VIEW, VIEW_ROT );
-    sgPostMultMat4ByTransMat4( VIEW, trans_vec );
-
-    //!!!!!!!!!!!!!!!!!!!	
-    // THIS IS THE EXPERIMENTAL VIEWING ANGLE SHIFTER
-    // THE MAJORITY OF THE WORK IS DONE IN GUI.CXX
-    // this in gui.cxx for now just testing
-    extern float quat_mat[4][4];
-    sgPreMultMat4( VIEW, quat_mat);
-    // !!!!!!!!!! testing	
-
-    // Given a vector pointing straight down (-Z), map into onto the
-    // local plane representing "horizontal".  This should give us the
-    // local direction for moving "south".
-    sgSetVec3( minus_z, 0.0, 0.0, -1.0 );
-
-    sgmap_vec_onto_cur_surface_plane(local_up, view_pos, minus_z,
-				     surface_south);
-    sgNormalizeVec3(surface_south);
-    // cout << "Surface direction directly south " << surface_south[0] << ","
-    //      << surface_south[1] << "," << surface_south[2] << endl;
-
-    // now calculate the surface east vector
-#define USE_FAST_SURFACE_EAST
-#ifdef USE_FAST_SURFACE_EAST
-    sgVec3 local_down;
-    sgNegateVec3(local_down, local_up);
-    sgVectorProductVec3(surface_east, surface_south, local_down);
-#else
-#define USE_LOCAL_UP
-#ifdef USE_LOCAL_UP
-    sgMakeRotMat4( TMP, FG_PI_2 * RAD_TO_DEG, local_up );
-#else
-    sgMakeRotMat4( TMP, FG_PI_2 * RAD_TO_DEG, view_up );
-#endif // USE_LOCAL_UP
-    // cout << "sgMat4 TMP" << endl;
-    // print_sgMat4( TMP );
-    sgXformVec3(surface_east, surface_south, TMP);
-#endif //  USE_FAST_SURFACE_EAST
-    // cout << "Surface direction directly east " << surface_east[0] << ","
-    //      << surface_east[1] << "," << surface_east[2] << endl;
-    // cout << "Should be close to zero = "
-    //      << sgScalarProductVec3(surface_south, surface_east) << endl;
-
-    dirty = false;
-}
-
-
-void FGViewer::CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src) {
-    sgVec3 tmp;
-    sgSetVec3(tmp, src[0], src[1], src[2] );
-    sgMat4 TMP;
-    sgTransposeNegateMat4 ( TMP, UP ) ;
-    sgXformVec3(tmp, tmp, TMP);
-    sgSetVec3(dst, tmp[2], tmp[1], tmp[0] );
 }
 
 

src/Main/viewer.hxx

@@ -33,20 +33,8 @@
 #include <simgear/compiler.h>
 #include <simgear/timing/sg_time.hxx>
 
-#include <list>
-
 #include <plib/sg.h>		// plib include
 
-#include <FDM/flight.hxx>
-#include <Time/light.hxx>
-
-
-FG_USING_STD(list);
-
-
-#define FG_FOV_MIN 0.1
-#define FG_FOV_MAX 179.9
-
 
 // Define a structure containing view information
 class FGViewer {
@@ -55,7 +43,9 @@ private:
 
     // flag forcing a recalc of derived view parameters
     bool dirty;
-	
+
+protected:
+
     // the current view offset angle from forward (rotated about the
     // view_up vector)
     double view_offset;
@@ -63,12 +53,6 @@ private:
     // the goal view offset angle  (used for smooth view changes)
     double goal_view_offset;
 
-    // geodetic view position
-    sgdVec3 geod_view_pos;
-
-    // radius to sea level from center of the earth (m)
-    double sea_level_radius;
-
     // absolute view position in earth coordinates
     sgdVec3 abs_view_pos;
 
@@ -76,18 +60,18 @@ private:
     // abs_view_pos translated to scenery.center)
     sgVec3 view_pos;
 
-    // pilot offset from center of gravity.  The X axis is positive
+    // radius to sea level from center of the earth (m)
-    // out the tail, Y is out the right wing, and Z is positive up.
+    double sea_level_radius;
-    // Distances in meters of course.
-    sgVec3 pilot_offset;
-
-    // view orientation (roll, pitch, heading)
-    sgVec3 rph;
 
     // cartesion coordinates of current lon/lat if at sea level
     // translated to scenery.center
     sgVec3 zero_elev;
 
+    // pilot offset from center of gravity.  The X axis is positive
+    // out the tail, Y is out the right wing, and Z is positive up.
+    // Distances in meters of course.
+    sgVec3 pilot_offset;
+
     // vector in cartesian coordinates from current position to the
     // postion on the earth's surface the sun is directly over
     sgVec3 to_sun;
@@ -113,22 +97,14 @@ private:
     // surface at the spot we are directly above
     sgVec3 local_up;
 
-    // up vector for the view (usually point straight up through the
-    // top of the aircraft
-    sgVec3 view_up;
-
-    // the vector pointing straight out the nose of the aircraft
-    sgVec3 view_forward;
-
-    // Transformation matrix for the view direction offset relative to
-    // the AIRCRAFT matrix
-    sgMat4 VIEW_OFFSET;
-
     // sg versions of our friendly matrices
-    sgMat4 LOCAL, UP, VIEW_ROT, TRANS, VIEW, LARC_TO_SSG;
+    sgMat4 VIEW, VIEW_ROT, UP;
+
+    inline void set_dirty() { dirty = true; }
+    inline void set_clean() { dirty = false; }
 
     // Update the view volume, position, and orientation
-    void update();
+    virtual void update();
 
 public:
 
@@ -136,59 +112,44 @@ public:
     FGViewer( void );
 
     // Destructor
-    ~FGViewer( void );
+    virtual ~FGViewer( void );
 
     // Initialize a view class
-    void init( void );
+    virtual void init( void );
-
-    // Transform a vector from world coordinates to the local plane
-    void CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src);
 
     //////////////////////////////////////////////////////////////////////
     // setter functions
     //////////////////////////////////////////////////////////////////////
-    inline void set_geod_view_pos( double lon, double lat, double alt ) {
-	// data should be in radians and meters asl
-	dirty = true;
-	// cout << "set_geod_view_pos = " << lon << ", " << lat << ", " << alt
-	//      << endl;
-	sgdSetVec3( geod_view_pos, lon, lat, alt );
-    }
-    inline void set_sea_level_radius( double r ) {
-	// data should be in meters from the center of the earth
-	dirty = true;
-	sea_level_radius = r;
-    }
-    inline void set_rph( double r, double p, double h ) {
-	// data should be in radians
-	dirty = true;
-	sgSetVec3( rph, r, p, h );
-    }
-    inline void set_pilot_offset( float x, float y, float z ) {
-	dirty = true;
-	sgSetVec3( pilot_offset, x, y, z );
-    }
     inline void set_view_offset( double a ) {
-	dirty = true;
+	set_dirty();
 	view_offset = a;
     }
     inline void inc_view_offset( double amt ) {
-	dirty = true;
+	set_dirty();
 	view_offset += amt;
     }
     inline void set_goal_view_offset( double a) {
-	dirty = true;
+	set_dirty();
 	goal_view_offset = a;
     }
+    inline void set_pilot_offset( float x, float y, float z ) {
+	set_dirty();
+	sgSetVec3( pilot_offset, x, y, z );
+    }
+    inline void set_sea_level_radius( double r ) {
+	// data should be in meters from the center of the earth
+	set_dirty();
+	sea_level_radius = r;
+    }
 
     //////////////////////////////////////////////////////////////////////
     // accessor functions
     //////////////////////////////////////////////////////////////////////
+    inline bool is_dirty() const { return dirty; }
     inline double get_view_offset() const { return view_offset; }
     inline double get_goal_view_offset() const { return goal_view_offset; }
     inline float *get_pilot_offset() { return pilot_offset; }
     inline double get_sea_level_radius() const { return sea_level_radius; }
-    inline float *get_rph() { return rph; }
 
     //////////////////////////////////////////////////////////////////////
     // derived values accessor functions
@@ -217,10 +178,6 @@ public:
 	if ( dirty ) { update(); }
 	return local_up;
     }
-    inline float *get_view_forward() {
-	if ( dirty ) { update(); }
-	return view_forward;
-    }
     inline const sgVec4 *get_VIEW() {
 	if ( dirty ) { update(); }
 	return VIEW;
@@ -229,6 +186,10 @@ public:
 	if ( dirty ) { update(); }
 	return VIEW_ROT;
     }
+    inline const sgVec4 *get_UP() {
+	if ( dirty ) { update(); }
+	return UP;
+    }
 
     //////////////////////////////////////////////////////////////////////
     // need to fix these

src/Scenery/tilemgr.cxx

@@ -153,16 +153,22 @@ void FGTileMgr::load_tile( const FGBucket& b, int cache_index) {
 }
 
 
+static void CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src) {
+    sgVec3 tmp;
+    sgSetVec3(tmp, src[0], src[1], src[2] );
+    sgMat4 TMP;
+    sgTransposeNegateMat4 ( TMP, globals->get_current_view()->get_UP() ) ;
+    sgXformVec3(tmp, tmp, TMP);
+    sgSetVec3(dst, tmp[2], tmp[1], tmp[0] );
+}
+
+
 // Determine scenery altitude via ssg.  Normally this just happens
 // when we render the scene, but we'd also like to be able to do this
 // explicitely.  lat & lon are in radians.  view_pos in current world
 // coordinate translated near (0,0,0) (in meters.)  Returns result in
 // meters.
-
+bool FGTileMgr::current_elev_ssg( sgdVec3 abs_view_pos, sgVec3 view_pos ) {
-bool
-FGTileMgr::current_elev_ssg( sgdVec3 abs_view_pos, 
-			     sgVec3 view_pos )
-{
     sgdVec3 orig, dir;
 
     sgdSetVec3(orig, view_pos );
@@ -193,7 +199,7 @@ FGTileMgr::current_elev_ssg( sgdVec3 abs_view_pos,
 	sgSetVec3(tmp, hit_list.get_normal(this_hit));
 	ssgState *IntersectedLeafState =
 	    ((ssgLeaf*)hit_list.get_entity(this_hit))->getState();
-	globals->get_current_view()->CurrentNormalInLocalPlane(tmp, tmp);
+	CurrentNormalInLocalPlane(tmp, tmp);
 	sgdSetVec3( scenery.cur_normal, tmp );
 	// cout << "NED: " << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
 	return true;

src/Time/moonpos.cxx

@@ -62,6 +62,7 @@
 
 #include <Main/globals.hxx>
 #include <Scenery/scenery.hxx>
+#include <Time/light.hxx>
 
 #include "moonpos.hxx"
 
@@ -334,7 +335,7 @@ static void fgMoonPositionGST(double gst, double *lon, double *lat) {
 // update the cur_time_params structure with the current moon position
 void fgUpdateMoonPos( void ) {
     fgLIGHT *l;
-    FGViewer *v;
+    FGViewerRPH *v;
     sgVec3 nup, nmoon, surface_to_moon;
     Point3D p, rel_moonpos;
     double dot, east_dot;

src/Time/sunpos.cxx

@@ -63,6 +63,7 @@
 
 #include <Main/globals.hxx>
 #include <Scenery/scenery.hxx>
+#include <Time/light.hxx>
 
 #include "sunpos.hxx"
 
@@ -242,7 +243,7 @@ static void fgSunPositionGST(double gst, double *lon, double *lat) {
 // update the cur_time_params structure with the current sun position
 void fgUpdateSunPos( void ) {
     fgLIGHT *l;
-    FGViewer *v;
+    FGViewerRPH *v;
     sgVec3 nup, nsun, surface_to_sun;
     Point3D p, rel_sunpos;
     double dot, east_dot;