X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FMain%2Fmain.cxx;h=68535fc6dbebda37d415f8a9094726db0b38b5a6;hb=db89ecfae80aa8d62844e39b7aa5f31b67c25e48;hp=8820f7f6d8ceb0701f9118f74cd7b6d1dc2367ef;hpb=0f6565f764392e8373e353412a09f6f4ae62aaf1;p=flightgear.git

diff --git a/src/Main/main.cxx b/src/Main/main.cxx
index 8820f7f6d..68535fc6d 100644
--- a/src/Main/main.cxx
+++ b/src/Main/main.cxx
@@ -38,7 +38,8 @@
 #endif
 
 #include <GL/glut.h>
-#include <XGL/xgl.h>
+#include <simgear/xgl/xgl.h>
+
 #include <stdio.h>
 #include <string.h>
 #include <string>
@@ -55,53 +56,58 @@
 #  include <unistd.h>    /* for stat() */
 #endif
 
-#include <pu.h>			// plib include
-#include <ssg.h>		// plib include
+#include <plib/pu.h>			// plib include
+#include <plib/ssg.h>		// plib include
 
 #ifdef ENABLE_AUDIO_SUPPORT
-#  include <sl.h>		// plib include
-#  include <sm.h>		// plib include
+#  include <plib/sl.h>		// plib include
+#  include <plib/sm.h>		// plib include
 #endif
 
-#include <Include/fg_constants.h>  // for VERSION
+#include <simgear/constants.h>  // for VERSION
+#include <simgear/debug/logstream.hxx>
+#include <simgear/math/fg_geodesy.hxx>
+#include <simgear/math/polar3d.hxx>
+#include <simgear/math/fg_random.h>
+#include <simgear/misc/fgpath.hxx>
+
 #include <Include/general.hxx>
 
-#include <Debug/logstream.hxx>
 #include <Aircraft/aircraft.hxx>
-#include <Astro/sky.hxx>
-#include <Astro/stars.hxx>
-#include <Astro/solarsystem.hxx>
+#include <Ephemeris/ephemeris.hxx>
 
-#include <Autopilot/autopilot.hxx>
+#include <Autopilot/newauto.hxx>
 #include <Cockpit/cockpit.hxx>
+#include <Cockpit/radiostack.hxx>
+#include <Cockpit/steam.hxx>
+#include <FDM/UIUCModel/uiuc_aircraft.h>
+#include <FDM/UIUCModel/uiuc_aircraftdir.h>
 #include <GUI/gui.h>
 #include <Joystick/joystick.hxx>
-#include <Math/fg_geodesy.hxx>
-#include <Math/mat3.h>
-#include <Math/polar3d.hxx>
-#include <Math/fg_random.h>
-#include <Misc/fgpath.hxx>
 #ifdef FG_NETWORK_OLK
-#include <Network/network.h>
+#include <NetworkOLK/network.h>
 #endif
 #include <Objects/materialmgr.hxx>
 #include <Scenery/scenery.hxx>
 #include <Scenery/tilemgr.hxx>
+#include <Sky/sky.hxx>
 #include <Time/event.hxx>
 #include <Time/fg_time.hxx>
 #include <Time/fg_timer.hxx>
 #include <Time/sunpos.hxx>
 
-#ifndef FG_NEW_WEATHER
+#ifndef FG_OLD_WEATHER
+#  include <WeatherCM/FGLocalWeatherDatabase.h>
+#else
 #  include <Weather/weather.hxx>
 #endif
 
 #include "fg_init.hxx"
+#include "fg_io.hxx"
 #include "keyboard.hxx"
 #include "options.hxx"
 #include "splash.hxx"
 #include "views.hxx"
-#include "fg_serial.hxx"
 
 
 // -dw- use custom sioux settings so I can see output window
@@ -120,6 +126,7 @@ FGGeneral general;
 // our initializations out of the glutIdleLoop() so that we can get a
 // splash screen up and running right away.
 static int idle_state = 0;
+static int global_multi_loop;
 
 // Another hack
 int use_signals = 0;
@@ -141,6 +148,19 @@ ssgBranch *terrain = NULL;
 ssgSelector *penguin_sel = NULL;
 ssgTransform *penguin_pos = NULL;
 
+#ifdef FG_NETWORK_OLK
+ssgSelector *fgd_sel = NULL;
+ssgTransform *fgd_pos = NULL;
+//sgMat4 sgTUX;
+#endif
+
+// current fdm/position used for view
+FGInterface cur_view_fdm;
+
+// Sky structures
+FGEphemeris *ephem;
+SGSky *thesky;
+
 // hack
 sgMat4 copy_of_ssgOpenGLAxisSwapMatrix =
 {
@@ -171,8 +191,34 @@ sgMat4 copy_of_ssgOpenGLAxisSwapMatrix =
 //
 
 
+ssgSimpleState *default_state;
+ssgSimpleState *hud_and_panel;
+ssgSimpleState *menus;
+
+void fgBuildRenderStates( void ) {
+    default_state = new ssgSimpleState;
+    default_state->disable( GL_TEXTURE_2D );
+    default_state->enable( GL_CULL_FACE );
+    default_state->disable( GL_COLOR_MATERIAL );
+    default_state->disable( GL_BLEND );
+    default_state->disable( GL_ALPHA_TEST );
+    default_state->disable( GL_LIGHTING );
+    default_state->setMaterial( GL_AMBIENT_AND_DIFFUSE, 1.0, 1.0, 1.0, 1.0 );
+
+    hud_and_panel = new ssgSimpleState;
+    hud_and_panel->disable( GL_CULL_FACE );
+    hud_and_panel->disable( GL_TEXTURE_2D );
+    hud_and_panel->disable( GL_LIGHTING );
+
+    menus = new ssgSimpleState;
+    menus->disable( GL_CULL_FACE );
+    menus->disable( GL_TEXTURE_2D );
+    menus->enable( GL_BLEND );
+}
+
+
 // fgInitVisuals() -- Initialize various GL/view parameters
-static void fgInitVisuals( void ) {
+void fgInitVisuals( void ) {
     fgLIGHT *l;
 
     l = &cur_light_params;
@@ -186,53 +232,59 @@ static void fgInitVisuals( void ) {
 
     // If enabled, normal vectors specified with glNormal are scaled
     // to unit length after transformation.  See glNormal.
-    // xglEnable( GL_NORMALIZE );
+    // glEnable( GL_NORMALIZE );
 
-    xglEnable( GL_LIGHTING );
-    xglEnable( GL_LIGHT0 );
-    xglLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec );
+    glEnable( GL_LIGHTING );
+    glEnable( GL_LIGHT0 );
+    glLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec );
 
     sgVec3 sunpos;
     sgSetVec3( sunpos, l->sun_vec[0], l->sun_vec[1], l->sun_vec[2] );
     ssgGetLight( 0 ) -> setPosition( sunpos );
 
-    // xglFogi (GL_FOG_MODE, GL_LINEAR);
-    xglFogi (GL_FOG_MODE, GL_EXP2);
+    // glFogi (GL_FOG_MODE, GL_LINEAR);
+    glFogi (GL_FOG_MODE, GL_EXP2);
     if ( (current_options.get_fog() == 1) || 
 	 (current_options.get_shading() == 0) ) {
 	// if fastest fog requested, or if flat shading force fastest
-	xglHint ( GL_FOG_HINT, GL_FASTEST );
+	glHint ( GL_FOG_HINT, GL_FASTEST );
     } else if ( current_options.get_fog() == 2 ) {
-	xglHint ( GL_FOG_HINT, GL_NICEST );
+	glHint ( GL_FOG_HINT, GL_NICEST );
     }
     if ( current_options.get_wireframe() ) {
 	// draw wire frame
-	xglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+	glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
     }
 
     // This is the default anyways, but it can't hurt
-    xglFrontFace ( GL_CCW );
+    glFrontFace ( GL_CCW );
 
     // Just testing ...
-    // xglEnable(GL_POINT_SMOOTH);
-    // xglEnable(GL_LINE_SMOOTH);
-    // xglEnable(GL_POLYGON_SMOOTH);      
+    // glEnable(GL_POINT_SMOOTH);
+    // glEnable(GL_LINE_SMOOTH);
+    // glEnable(GL_POLYGON_SMOOTH);      
 }
 
 
 // Update all Visuals (redraws anything graphics related)
-static void fgRenderFrame( void ) {
+void fgRenderFrame( void ) {
     fgLIGHT *l = &cur_light_params;
     FGTime *t = FGTime::cur_time_params;
-    FGView *v = &current_view;
+    // FGView *v = &current_view;
+    static double last_visibility = -9999;
+    static bool in_puff = false;
+    static double puff_length = 0;
+    static double puff_progression = 0;
+    const double ramp_up = 0.15;
+    const double ramp_down = 0.15;
 
     double angle;
     // GLfloat black[4] = { 0.0, 0.0, 0.0, 1.0 };
-    GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
-    GLfloat terrain_color[4] = { 0.54, 0.44, 0.29, 1.0 };
+    // GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
+    // GLfloat terrain_color[4] = { 0.54, 0.44, 0.29, 1.0 };
     // GLfloat mat_shininess[] = { 10.0 };
     GLbitfield clear_mask;
-
+    
     if ( idle_state != 1000 ) {
 	// still initializing, draw the splash screen
 	if ( current_options.get_splash_screen() == 1 ) {
@@ -251,10 +303,13 @@ static void fgRenderFrame( void ) {
 	// end of hack
 
 	// update view volume parameters
-	v->UpdateViewParams();
+	// cout << "before pilot_view update" << endl;
+	pilot_view.UpdateViewParams(*cur_fdm_state);
+	// cout << "after pilot_view update" << endl;
+	current_view.UpdateViewParams(cur_view_fdm);
 
 	// set the sun position
-	xglLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec );
+	glLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec );
 
 	clear_mask = GL_DEPTH_BUFFER_BIT;
 	if ( current_options.get_wireframe() ) {
@@ -274,7 +329,7 @@ static void fgRenderFrame( void ) {
 			 l->sky_color[2], l->sky_color[3]);
 	    clear_mask |= GL_COLOR_BUFFER_BIT;
 	}
-	xglClear( clear_mask );
+	glClear( clear_mask );
 
 	// Tell GL we are switching to model view parameters
 
@@ -282,87 +337,201 @@ static void fgRenderFrame( void ) {
 	// back or something so that I can draw the sky within the
 	// ssgCullandDraw() function, but for now I just mimic what
 	// ssg does to set up the model view matrix
-	xglMatrixMode(GL_MODELVIEW);
-	xglLoadIdentity();
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+	ssgSetCamera( current_view.VIEW );
+
+	/*
 	sgMat4 vm_tmp, view_mat;
-	sgTransposeNegateMat4 ( vm_tmp, v->sgVIEW ) ;
+	sgTransposeNegateMat4 ( vm_tmp, current_view.VIEW ) ;
 	sgCopyMat4( view_mat, copy_of_ssgOpenGLAxisSwapMatrix ) ;
 	sgPreMultMat4( view_mat, vm_tmp ) ;
-	xglLoadMatrixf( (float *)view_mat );
-
-	// draw sky
-	xglDisable( GL_DEPTH_TEST );
-	xglDisable( GL_LIGHTING );
-	xglDisable( GL_CULL_FACE );
-	xglDisable( GL_FOG );
-	xglShadeModel( GL_SMOOTH );
+	glLoadMatrixf( (float *)view_mat );
+	*/
+
+	// set the opengl state to known default values
+	default_state->force();
+
+	// draw sky dome
 	if ( current_options.get_skyblend() ) {
-	    fgSkyRender();
+	    sgVec3 view_pos;
+	    sgSetVec3( view_pos,
+		       current_view.get_view_pos().x(),
+		       current_view.get_view_pos().y(),
+		       current_view.get_view_pos().z() );
+
+	    sgVec3 zero_elev;
+	    sgSetVec3( zero_elev,
+		       current_view.get_cur_zero_elev().x(),
+		       current_view.get_cur_zero_elev().y(),
+		       current_view.get_cur_zero_elev().z() );
+
+	    /* cout << "thesky->repaint() sky_color = "
+		 << cur_light_params.sky_color[0] << " "
+		 << cur_light_params.sky_color[1] << " "
+		 << cur_light_params.sky_color[2] << " "
+		 << cur_light_params.sky_color[3] << endl;
+	    cout << "    fog = "
+		 << cur_light_params.fog_color[0] << " "
+		 << cur_light_params.fog_color[1] << " "
+		 << cur_light_params.fog_color[2] << " "
+		 << cur_light_params.fog_color[3] << endl;
+	    cout << "    sun_angle = " << cur_light_params.sun_angle
+		 << "    moon_angle = " << cur_light_params.moon_angle
+                 << endl; */
+	    thesky->repaint( cur_light_params.sky_color,
+			     cur_light_params.adj_fog_color,
+			     cur_light_params.sun_angle,
+			     cur_light_params.moon_angle,
+			     ephem->getNumPlanets(), ephem->getPlanets(),
+			     ephem->getNumStars(), ephem->getStars() );
+ 
+	    /* cout << "thesky->reposition( view_pos = " << view_pos[0] << " "
+		 << view_pos[1] << " " << view_pos[2] << endl;
+	    cout << "    zero_elev = " << zero_elev[0] << " "
+		 << zero_elev[1] << " " << zero_elev[2]
+		 << " lon = " << cur_fdm_state->get_Longitude()
+		 << " lat = " << cur_fdm_state->get_Latitude() << endl;
+	    cout << "    sun_rot = " << cur_light_params.sun_rotation
+		 << " gst = " << FGTime::cur_time_params->getGst() << endl;
+	    cout << "    sun ra = " << ephem->getSunRightAscension()
+		 << " sun dec = " << ephem->getSunDeclination() 
+		 << " moon ra = " << ephem->getMoonRightAscension()
+		 << " moon dec = " << ephem->getMoonDeclination() << endl; */
+
+	    thesky->reposition( view_pos, zero_elev, 
+				cur_fdm_state->get_Longitude(),
+				cur_fdm_state->get_Latitude(),
+				cur_light_params.sun_rotation,
+				FGTime::cur_time_params->getGst(),
+				ephem->getSunRightAscension(),
+				ephem->getSunDeclination(), 50000.0,
+				ephem->getMoonRightAscension(),
+				ephem->getMoonDeclination(), 50000.0 );
 	}
 
-	// setup transformation for drawing astronomical objects
-	xglPushMatrix();
-	// Translate to view position
-	Point3D view_pos = v->get_view_pos();
-	xglTranslatef( view_pos.x(), view_pos.y(), view_pos.z() );
-	// Rotate based on gst (sidereal time)
-	// note: constant should be 15.041085, Curt thought it was 15
-	angle = t->getGst() * 15.041085;
-	// printf("Rotating astro objects by %.2f degrees\n",angle);
-	xglRotatef( angle, 0.0, 0.0, -1.0 );
-
-	// draw stars and planets
-	fgStarsRender();
-	xglDisable( GL_COLOR_MATERIAL ); // just to make sure ...
-	xglEnable( GL_CULL_FACE ); // for moon
-	xglLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec );
-	//xglEnable(GL_DEPTH_TEST);
-	SolarSystem::theSolarSystem->draw();
-
-	xglPopMatrix();
-
-	// draw scenery
-	if ( current_options.get_shading() ) {
-	    xglShadeModel( GL_SMOOTH ); 
-	} else {
-	    xglShadeModel( GL_FLAT ); 
-	}
-	xglEnable( GL_DEPTH_TEST );
+	glEnable( GL_DEPTH_TEST );
 	if ( current_options.get_fog() > 0 ) {
-	    xglEnable( GL_FOG );
-	    xglFogi( GL_FOG_MODE, GL_EXP2 );
-	    xglFogfv( GL_FOG_COLOR, l->adj_fog_color );
+	    glEnable( GL_FOG );
+	    glFogi( GL_FOG_MODE, GL_EXP2 );
+	    glFogfv( GL_FOG_COLOR, l->adj_fog_color );
 	}
-	// set lighting parameters
-	xglLightfv( GL_LIGHT0, GL_AMBIENT, l->scene_ambient );
-	xglLightfv( GL_LIGHT0, GL_DIFFUSE, l->scene_diffuse );
-	// xglLightfv(GL_LIGHT0, GL_SPECULAR, white );
-	
-	if ( current_options.get_textures() ) {
-	    // texture parameters
-	    xglEnable( GL_TEXTURE_2D );
-	    xglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
-	    xglHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
-	    // set base color (I don't think this is doing anything here)
-	    xglMaterialfv (GL_FRONT, GL_AMBIENT, white);
-	    xglMaterialfv (GL_FRONT, GL_DIFFUSE, white);
-	    // xglMaterialfv (GL_FRONT, GL_SPECULAR, white);
-	    // xglMaterialfv (GL_FRONT, GL_SHININESS, mat_shininess);
-	} else {
-	    xglDisable( GL_TEXTURE_2D );
-	    xglMaterialfv (GL_FRONT, GL_AMBIENT, terrain_color);
-	    xglMaterialfv (GL_FRONT, GL_DIFFUSE, terrain_color);
-	    // xglMaterialfv (GL_FRONT, GL_AMBIENT, white);
-	    // xglMaterialfv (GL_FRONT, GL_DIFFUSE, white);
+
+	// update fog params if visibility has changed
+#ifndef FG_OLD_WEATHER
+	double cur_visibility = WeatherDatabase->getWeatherVisibility();
+#else
+	double cur_visibility = current_weather.get_visibility();
+#endif
+	double actual_visibility = cur_visibility;
+
+	if ( current_options.get_clouds() ) {
+	    double diff = fabs( cur_fdm_state->get_Altitude() * FEET_TO_METER -
+				current_options.get_clouds_asl() );
+	    // cout << "altitude diff = " << diff << endl;
+	    if ( diff < 75 ) {
+		if ( ! in_puff ) {
+		    // calc chance of entering cloud puff
+		    double rnd = fg_random();
+		    double chance = rnd * rnd * rnd;
+		    if ( chance > 0.95 /* * (diff - 25) / 50.0 */ ) {
+			in_puff = true;
+			do {
+			    puff_length = fg_random() * 2.0; // up to 2 seconds
+			} while ( puff_length <= 0.0 );
+			puff_progression = 0.0;
+		    }
+		}
+
+		actual_visibility = cur_visibility * (diff - 25) / 50.0;
+
+		if ( in_puff ) {
+		    // modify actual_visibility based on puff envelope
+
+		    if ( puff_progression <= ramp_up ) {
+			double x = FG_PI_2 * puff_progression / ramp_up;
+			double factor = 1.0 - sin( x );
+			actual_visibility = actual_visibility * factor;
+		    } else if ( puff_progression >= ramp_up + puff_length ) {
+			double x = FG_PI_2 * 
+			    (puff_progression - (ramp_up + puff_length)) /
+			    ramp_down;
+			double factor = sin( x );
+			actual_visibility = actual_visibility * factor;
+		    } else {
+			actual_visibility = 0.0;
+		    }
+
+		    /* cout << "len = " << puff_length
+			 << "  x = " << x 
+			 << "  factor = " << factor
+			 << "  actual_visibility = " << actual_visibility 
+			 << endl; */
+
+		    puff_progression += ( global_multi_loop * 
+					  current_options.get_speed_up() ) /
+			(double)current_options.get_model_hz();
+
+		    /* cout << "gml = " << global_multi_loop 
+			 << "  speed up = " << current_options.get_speed_up()
+			 << "  hz = " << current_options.get_model_hz() << endl;
+			 */ 
+
+		    if ( puff_progression > puff_length + ramp_up + ramp_down) {
+			in_puff = false; 
+		    }
+		}
+
+		// never let visibility drop below zero
+		if ( actual_visibility < 0 ) {
+		    actual_visibility = 0;
+		}
+	    }
 	}
 
+	// cout << "actual visibility = " << actual_visibility << endl;
+
+	if ( actual_visibility != last_visibility ) {
+	    last_visibility = actual_visibility;
+
+	    // cout << "----> updating fog params" << endl;
+		
+	    GLfloat fog_exp_density;
+	    GLfloat fog_exp2_density;
+    
+	    // for GL_FOG_EXP
+	    fog_exp_density = -log(0.01 / actual_visibility);
+    
+	    // for GL_FOG_EXP2
+	    fog_exp2_density = sqrt( -log(0.01) ) / actual_visibility;
+    
+	    // Set correct opengl fog density
+	    glFogf (GL_FOG_DENSITY, fog_exp2_density);
+	}
+ 
+	// set lighting parameters
+	glLightfv( GL_LIGHT0, GL_AMBIENT, l->scene_ambient );
+	glLightfv( GL_LIGHT0, GL_DIFFUSE, l->scene_diffuse );
+	// glLightfv(GL_LIGHT0, GL_SPECULAR, white );
+
+	// texture parameters
+	// glEnable( GL_TEXTURE_2D );
+	glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
+	glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
+	// set base color (I don't think this is doing anything here)
+	// glMaterialfv (GL_FRONT, GL_AMBIENT, white);
+	//  (GL_FRONT, GL_DIFFUSE, white);
+	// glMaterialfv (GL_FRONT, GL_SPECULAR, white);
+	// glMaterialfv (GL_FRONT, GL_SHININESS, mat_shininess);
+
 	sgVec3 sunpos;
 	sgSetVec3( sunpos, l->sun_vec[0], l->sun_vec[1], l->sun_vec[2] );
 	ssgGetLight( 0 ) -> setPosition( sunpos );
 
-	// xglMatrixMode( GL_PROJECTION );
-	// xglLoadIdentity();
-	ssgSetFOV( current_options.get_fov(), 0.0f );
+	// glMatrixMode( GL_PROJECTION );
+	// glLoadIdentity();
+ 	float fov = current_options.get_fov();
+ 	ssgSetFOV(fov * current_view.get_win_ratio(), fov);
 
 	double agl = current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
 	    - scenery.cur_elev;
@@ -371,36 +540,31 @@ static void fgRenderFrame( void ) {
 	//         << current_weather.get_visibility() );
 	    
 	if ( agl > 10.0 ) {
-	    ssgSetNearFar( 10.0f, 100000.0f );
+	    ssgSetNearFar( 10.0f, 120000.0f );
 	} else {
-	    ssgSetNearFar( 0.5f, 100000.0f );
+	    ssgSetNearFar( 0.5f, 120000.0f );
 	}
 
-	sgMat4 sgVIEW;
-
-	while ( current_view.follow.size() > 400 ) {
-	    current_view.follow.pop_front();
-	}
-
-	if ( current_view.view_mode == FGView::FG_VIEW_FIRST_PERSON ) {
-	    // select current view matrix
-	    sgCopyMat4( sgVIEW, current_view.sgVIEW );
-
+	if ( current_options.get_view_mode() == 
+	     fgOPTIONS::FG_VIEW_PILOT )
+        {
 	    // disable TuX
 	    penguin_sel->select(0);
-	} else if ( current_view.view_mode == FGView::FG_VIEW_FOLLOW ) {
+	} else if ( current_options.get_view_mode() == 
+		    fgOPTIONS::FG_VIEW_FOLLOW )
+        {
 	    // select view matrix from front of view matrix queue
-	    FGMat4Wrapper tmp = current_view.follow.front();
-	    sgCopyMat4( sgVIEW, tmp.m );
+	    // FGMat4Wrapper tmp = current_view.follow.front();
+	    // sgCopyMat4( sgVIEW, tmp.m );
 
 	    // enable TuX and set up his position and orientation
 	    penguin_sel->select(1);
 
 	    sgMat4 sgTRANS;
 	    sgMakeTransMat4( sgTRANS, 
-			     current_view.view_pos.x(),
-			     current_view.view_pos.y(),
-			     current_view.view_pos.z() );
+			     pilot_view.view_pos.x(),
+			     pilot_view.view_pos.y(),
+			     pilot_view.view_pos.z() );
 
 	    sgVec3 ownship_up;
 	    sgSetVec3( ownship_up, 0.0, 0.0, 1.0);
@@ -408,17 +572,44 @@ static void fgRenderFrame( void ) {
 	    sgMat4 sgROT;
 	    sgMakeRotMat4( sgROT, -90.0, ownship_up );
 
-	    sgMat4 sgTMP;
+	    // sgMat4 sgTMP;
+	    // sgMat4 sgTUX;
+	    // sgMultMat4( sgTMP, sgROT, pilot_view.VIEW_ROT );
+	    // sgMultMat4( sgTUX, sgTMP, sgTRANS );
+
+	    // sgTUX = ( sgROT * pilot_view.VIEW_ROT ) * sgTRANS
 	    sgMat4 sgTUX;
-	    sgMultMat4( sgTMP, sgROT, current_view.sgVIEW_ROT );
-	    sgMultMat4( sgTUX, sgTMP, sgTRANS );
+	    sgCopyMat4( sgTUX, sgROT );
+	    sgPostMultMat4( sgTUX, pilot_view.VIEW_ROT );
+	    sgPostMultMat4( sgTUX, sgTRANS );
 	
 	    sgCoord tuxpos;
 	    sgSetCoord( &tuxpos, sgTUX );
 	    penguin_pos->setTransform( &tuxpos );
 	}
 
-	ssgSetCamera( sgVIEW );
+# ifdef FG_NETWORK_OLK
+	if ( current_options.get_network_olk() ) {
+	    sgCoord fgdpos;
+	    other = head->next;             /* put listpointer to start  */
+	    while ( other != tail) {        /* display all except myself */
+		if ( strcmp( other->ipadr, fgd_mcp_ip) != 0) {
+		    other->fgd_sel->select(1);
+		    sgSetCoord( &fgdpos, other->sgFGD_COORD );
+		    other->fgd_pos->setTransform( &fgdpos );
+		}
+		other = other->next;
+	    }
+
+	    // fgd_sel->select(1);
+	    // sgCopyMat4( sgTUX, current_view.sgVIEW);
+	    // sgCoord fgdpos;
+	    // sgSetCoord( &fgdpos, sgFGD_VIEW );
+	    // fgd_pos->setTransform( &fgdpos);
+	}
+# endif
+
+	// ssgSetCamera( current_view.VIEW );
 
 	// position tile nodes and update range selectors
 	global_tile_mgr.prep_ssg_nodes();
@@ -427,89 +618,118 @@ static void fgRenderFrame( void ) {
 	// we've changed things elsewhere
 	FGMaterialSlot m_slot;
 	FGMaterialSlot *m_ptr = &m_slot;
-	if ( material_mgr.find( "Default", m_ptr ) );
-	m_ptr->get_state()->force();
+	if ( material_mgr.find( "Default", m_ptr ) ) {
+	    m_ptr->get_state()->force();
+	}
 
 	// draw the ssg scene
 	ssgCullAndDraw( scene );
 
-	xglDisable( GL_TEXTURE_2D );
-	xglDisable( GL_FOG );
 
 	// display HUD && Panel
-	xglDisable( GL_CULL_FACE );
+	glDisable( GL_FOG );
+	glDisable( GL_DEPTH_TEST );
+	// glDisable( GL_CULL_FACE );
+	// glDisable( GL_TEXTURE_2D );
+	hud_and_panel->apply();
 	fgCockpitUpdate();
 
 	// We can do translucent menus, so why not. :-)
-	xglEnable    ( GL_BLEND ) ;
-	xglBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
+	// glEnable ( GL_BLEND ) ;
+	menus->apply();
+	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
 	puDisplay();
-	xglDisable   ( GL_BLEND ) ;
-	xglEnable( GL_FOG );
+	// glDisable ( GL_BLEND ) ;
 
+	// glEnable( GL_FOG );
     }
 
-    xglutSwapBuffers();
+    glutSwapBuffers();
 }
 
 
 // Update internal time dependent calculations (i.e. flight model)
 void fgUpdateTimeDepCalcs(int multi_loop, int remainder) {
-    FGInterface *f = current_aircraft.fdm_state;
+    static fdm_state_list fdm_list;
+    // FGInterface fdm_state;
     fgLIGHT *l = &cur_light_params;
     FGTime *t = FGTime::cur_time_params;
-    FGView *v = &current_view;
+    // FGView *v = &current_view;
     int i;
 
     // update the flight model
     if ( multi_loop < 0 ) {
-	multi_loop = DEFAULT_MULTILOOP;
+	multi_loop = 1;
     }
 
     if ( !t->getPause() ) {
 	// run Autopilot system
-	fgAPRun();
+	current_autopilot->run();
 
 	// printf("updating flight model x %d\n", multi_loop);
-	fgFDMUpdate( current_options.get_flight_model(), 
-		     cur_fdm_state, 
+	/* fgFDMUpdate( current_options.get_flight_model(), 
+		     fdm_state, 
 		     multi_loop * current_options.get_speed_up(),
-		     remainder );
+		     remainder ); */
+	cur_fdm_state->update( multi_loop * current_options.get_speed_up() );
+	FGSteam::update( multi_loop * current_options.get_speed_up() );
     } else {
-	fgFDMUpdate( current_options.get_flight_model(), 
-		     cur_fdm_state, 0, remainder );
+	// fgFDMUpdate( current_options.get_flight_model(), 
+	//              fdm_state, 0, remainder );
+	cur_fdm_state->update( 0 );
+	FGSteam::update( 0 );
+    }
+
+    fdm_list.push_back( *cur_fdm_state );
+    while ( fdm_list.size() > 15 ) {
+	fdm_list.pop_front();
+    }
+
+    if ( current_options.get_view_mode() == fgOPTIONS::FG_VIEW_PILOT ) {
+	cur_view_fdm = *cur_fdm_state;
+	// do nothing
+    } else if ( current_options.get_view_mode() == fgOPTIONS::FG_VIEW_FOLLOW ) {
+	cur_view_fdm = fdm_list.front();
     }
 
     // update the view angle
     for ( i = 0; i < multi_loop; i++ ) {
-	if ( fabs(v->get_goal_view_offset() - v->get_view_offset()) < 0.05 ) {
-	    v->set_view_offset( v->get_goal_view_offset() );
+	if ( fabs(current_view.get_goal_view_offset() - 
+		  current_view.get_view_offset()) < 0.05 )
+	{
+	    current_view.set_view_offset( current_view.get_goal_view_offset() );
 	    break;
 	} else {
-	    // move v->view_offset towards v->goal_view_offset
-	    if ( v->get_goal_view_offset() > v->get_view_offset() ) {
-		if ( v->get_goal_view_offset() - v->get_view_offset() < FG_PI ){
-		    v->inc_view_offset( 0.01 );
+	    // move current_view.view_offset towards current_view.goal_view_offset
+	    if ( current_view.get_goal_view_offset() > 
+		 current_view.get_view_offset() )
+            {
+		if ( current_view.get_goal_view_offset() - 
+		     current_view.get_view_offset() < FG_PI )
+                {
+		    current_view.inc_view_offset( 0.01 );
 		} else {
-		    v->inc_view_offset( -0.01 );
+		    current_view.inc_view_offset( -0.01 );
 		}
 	    } else {
-		if ( v->get_view_offset() - v->get_goal_view_offset() < FG_PI ){
-		    v->inc_view_offset( -0.01 );
+		if ( current_view.get_view_offset() - 
+		     current_view.get_goal_view_offset() < FG_PI )
+                {
+		    current_view.inc_view_offset( -0.01 );
 		} else {
-		    v->inc_view_offset( 0.01 );
+		    current_view.inc_view_offset( 0.01 );
 		}
 	    }
-	    if ( v->get_view_offset() > FG_2PI ) {
-		v->inc_view_offset( -FG_2PI );
-	    } else if ( v->get_view_offset() < 0 ) {
-		v->inc_view_offset( FG_2PI );
+	    if ( current_view.get_view_offset() > FG_2PI ) {
+		current_view.inc_view_offset( -FG_2PI );
+	    } else if ( current_view.get_view_offset() < 0 ) {
+		current_view.inc_view_offset( FG_2PI );
 	    }
 	}
     }
 
     double tmp = -(l->sun_rotation + FG_PI) 
-	- (f->get_Psi() - v->get_view_offset() );
+	- (cur_fdm_state->get_Psi() - current_view.get_view_offset() );
     while ( tmp < 0.0 ) {
 	tmp += FG_2PI;
     }
@@ -517,9 +737,17 @@ void fgUpdateTimeDepCalcs(int multi_loop, int remainder) {
 	tmp -= FG_2PI;
     }
     /* printf("Psi = %.2f, viewoffset = %.2f sunrot = %.2f rottosun = %.2f\n",
-	   FG_Psi * RAD_TO_DEG, v->view_offset * RAD_TO_DEG, 
+	   FG_Psi * RAD_TO_DEG, current_view.view_offset * RAD_TO_DEG, 
 	   -(l->sun_rotation+FG_PI) * RAD_TO_DEG, tmp * RAD_TO_DEG); */
     l->UpdateAdjFog();
+
+    // Update solar system
+    ephem->update( t, cur_fdm_state->get_Latitude() );
+
+    // Update radio stack model
+    current_radiostack->update( cur_fdm_state->get_Longitude(),
+				cur_fdm_state->get_Latitude(),
+				cur_fdm_state->get_Altitude() * FEET_TO_METER );
 }
 
 
@@ -527,20 +755,22 @@ void fgInitTimeDepCalcs( void ) {
     // initialize timer
 
     // #ifdef HAVE_SETITIMER
-    //   fgTimerInit( 1.0 / DEFAULT_TIMER_HZ, fgUpdateTimeDepCalcs );
+    //   fgTimerInit( 1.0 / current_options.get_model_hz(), 
+    //                fgUpdateTimeDepCalcs );
     // #endif HAVE_SETITIMER
 }
 
+
 static const double alt_adjust_ft = 3.758099;
 static const double alt_adjust_m = alt_adjust_ft * FEET_TO_METER;
 
+
 // What should we do when we have nothing else to do?  Let's get ready
 // for the next move and update the display?
 static void fgMainLoop( void ) {
-    FGInterface *f;
     FGTime *t;
     static long remainder = 0;
-    long elapsed, multi_loop;
+    long elapsed;
 #ifdef FANCY_FRAME_COUNTER
     int i;
     double accum;
@@ -549,12 +779,21 @@ static void fgMainLoop( void ) {
     static int frames = 0;
 #endif // FANCY_FRAME_COUNTER
 
-    f = current_aircraft.fdm_state;
     t = FGTime::cur_time_params;
 
     FG_LOG( FG_ALL, FG_DEBUG, "Running Main Loop");
     FG_LOG( FG_ALL, FG_DEBUG, "======= ==== ====");
 
+#ifdef FG_NETWORK_OLK
+    if ( current_options.get_network_olk() ) {
+	if ( net_is_registered == 0 ) {	     // We first have to reg. to fgd
+	    // printf("FGD: Netupdate\n");
+	    fgd_send_com( "A", FGFS_host);   // Send Mat4 data
+	    fgd_send_com( "B", FGFS_host);   // Recv Mat4 data
+	}
+    }
+#endif
+
 #if defined( ENABLE_PLIB_JOYSTICK )
     // Read joystick and update control settings
     if ( current_options.get_control_mode() == fgOPTIONS::FG_JOYSTICK ) {
@@ -566,7 +805,7 @@ static void fgMainLoop( void ) {
     // init routine and we don't have to worry about it again.
 #endif
 
-#ifndef FG_NEW_WEATHER
+#ifdef FG_OLD_WEATHER
     current_weather.Update();
 #endif
 
@@ -575,15 +814,15 @@ static void fgMainLoop( void ) {
 
     /* printf("Before - ground = %.2f  runway = %.2f  alt = %.2f\n",
 	   scenery.cur_elev,
-	   f->get_Runway_altitude() * FEET_TO_METER,
-	   f->get_Altitude() * FEET_TO_METER); */
+	   cur_fdm_state->get_Runway_altitude() * FEET_TO_METER,
+	   cur_fdm_state->get_Altitude() * FEET_TO_METER); */
 
     if ( scenery.cur_elev > -9990 ) {
-	if ( f->get_Altitude() * FEET_TO_METER < 
+	if ( cur_fdm_state->get_Altitude() * FEET_TO_METER < 
 	     (scenery.cur_elev + alt_adjust_m - 3.0) ) {
 	    // now set aircraft altitude above ground
-	    printf("Current Altitude = %.2f < %.2f forcing to %.2f\n", 
-		   f->get_Altitude() * FEET_TO_METER,
+	    printf("(*) Current Altitude = %.2f < %.2f forcing to %.2f\n", 
+		   cur_fdm_state->get_Altitude() * FEET_TO_METER,
 		   scenery.cur_elev + alt_adjust_m - 3.0,
 		   scenery.cur_elev + alt_adjust_m );
 	    fgFDMForceAltitude( current_options.get_flight_model(), 
@@ -591,7 +830,7 @@ static void fgMainLoop( void ) {
 
 	    FG_LOG( FG_ALL, FG_DEBUG, 
 		    "<*> resetting altitude to " 
-		    << f->get_Altitude() * FEET_TO_METER << " meters" );
+		    << cur_fdm_state->get_Altitude() * FEET_TO_METER << " meters" );
 	}
 	fgFDMSetGroundElevation( current_options.get_flight_model(),
 				 scenery.cur_elev );  // meters
@@ -599,11 +838,13 @@ static void fgMainLoop( void ) {
 
     /* printf("Adjustment - ground = %.2f  runway = %.2f  alt = %.2f\n",
 	   scenery.cur_elev,
-	   f->get_Runway_altitude() * FEET_TO_METER,
-	   f->get_Altitude() * FEET_TO_METER); */
+	   cur_fdm_state->get_Runway_altitude() * FEET_TO_METER,
+	   cur_fdm_state->get_Altitude() * FEET_TO_METER); */
 
     // update "time"
-    t->update(f);
+    t->update( cur_fdm_state->get_Longitude(),
+	       cur_fdm_state->get_Latitude(),
+	       cur_fdm_state->get_Altitude()* FEET_TO_METER );
 
     // Get elapsed time (in usec) for this past frame
     elapsed = fgGetTimeInterval();
@@ -646,23 +887,26 @@ static void fgMainLoop( void ) {
 	// Calculate model iterations needed for next frame
 	elapsed += remainder;
 
-	multi_loop = (int)(((double)elapsed * 0.000001) * DEFAULT_MODEL_HZ);
-	remainder = elapsed - ((multi_loop*1000000) / DEFAULT_MODEL_HZ);
+	global_multi_loop = (int)(((double)elapsed * 0.000001) * 
+			   current_options.get_model_hz());
+	remainder = elapsed - ( (global_multi_loop*1000000) / 
+				current_options.get_model_hz() );
 	FG_LOG( FG_ALL, FG_DEBUG, 
-		"Model iterations needed = " << multi_loop
+		"Model iterations needed = " << global_multi_loop
 		<< ", new remainder = " << remainder );
 	
 	// flight model
-	if ( multi_loop > 0 ) {
-	    fgUpdateTimeDepCalcs(multi_loop, remainder);
+	if ( global_multi_loop > 0 ) {
+	    fgUpdateTimeDepCalcs(global_multi_loop, remainder);
 	} else {
-	    FG_LOG( FG_ALL, FG_INFO, "Elapsed time is zero ... we're zinging" );
+	    FG_LOG( FG_ALL, FG_DEBUG, 
+		    "Elapsed time is zero ... we're zinging" );
 	}
     }
 
 #if ! defined( MACOS )
-    // Do any serial port work that might need to be done
-    fgSerialProcess();
+    // Do any I/O channel work that might need to be done
+    fgIOProcess();
 #endif
 
     // see if we need to load any new scenery tiles
@@ -689,16 +933,16 @@ static void fgMainLoop( void ) {
 
 	double pitch = log((controls.get_throttle(0) * 14.0) + 1.0);
 	//fprintf(stderr, "pitch1: %f ", pitch);
-	if (controls.get_throttle(0) > 0.0 || f->v_rel_wind > 40.0) {
-	    //fprintf(stderr, "rel_wind: %f ", f->v_rel_wind);
+	if (controls.get_throttle(0) > 0.0 || cur_fdm_state->v_rel_wind > 40.0) {
+	    //fprintf(stderr, "rel_wind: %f ", cur_fdm_state->v_rel_wind);
 	    // only add relative wind and AoA if prop is moving
 	    // or we're really flying at idle throttle
 	    if (pitch < 5.4) {  // this needs tuning
 		// prop tips not breaking sound barrier
-		pitch += log(f->v_rel_wind + 0.8)/2;
+		pitch += log(cur_fdm_state->v_rel_wind + 0.8)/2;
 	    } else {
 		// prop tips breaking sound barrier
-		pitch += log(f->v_rel_wind + 0.8)/10;
+		pitch += log(cur_fdm_state->v_rel_wind + 0.8)/10;
 	    }
 	    //fprintf(stderr, "pitch2: %f ", pitch);
 	    //fprintf(stderr, "AoA: %f ", FG_Gamma_vert_rad);
@@ -706,7 +950,7 @@ static void fgMainLoop( void ) {
 	    // Angle of Attack next... -x^3(e^x) is my best guess Just
 	    // need to calculate some reasonable scaling factor and
 	    // then clamp it on the positive aoa (neg adj) side
-	    double aoa = f->get_Gamma_vert_rad() * 2.2;
+	    double aoa = cur_fdm_state->get_Gamma_vert_rad() * 2.2;
 	    double tmp = 3.0;
 	    double aoa_adj = pow(-aoa, tmp) * pow(M_E, aoa);
 	    if (aoa_adj < -0.8) aoa_adj = -0.8;
@@ -720,7 +964,7 @@ static void fgMainLoop( void ) {
 	//fprintf(stderr, "pitch4: %f\n", pitch);
 
 	double volume = controls.get_throttle(0) * 1.15 + 0.3 +
-	    log(f->v_rel_wind + 1.0)/14.0;
+	    log(cur_fdm_state->v_rel_wind + 1.0)/14.0;
 	// fprintf(stderr, "volume: %f\n", volume);
 
 	pitch_envelope.setStep  ( 0, 0.01, pitch );
@@ -839,40 +1083,42 @@ static void fgIdleFunction ( void ) {
 	}
 #endif // WIN32
 
-	audio_sched = new slScheduler ( 8000 );
-	audio_mixer = new smMixer;
-	audio_mixer -> setMasterVolume ( 80 ) ;  /* 80% of max volume. */
-	audio_sched -> setSafetyMargin ( 1.0 ) ;
+	if ( current_options.get_sound() ) {
+	    audio_sched = new slScheduler ( 8000 );
+	    audio_mixer = new smMixer;
+	    audio_mixer -> setMasterVolume ( 80 ) ;  /* 80% of max volume. */
+	    audio_sched -> setSafetyMargin ( 1.0 ) ;
 
-	FGPath slfile( current_options.get_fg_root() );
-	slfile.append( "Sounds/wasp.wav" );
+	    FGPath slfile( current_options.get_fg_root() );
+	    slfile.append( "Sounds/wasp.wav" );
 
-	s1 = new slSample ( (char *)slfile.c_str() );
-	FG_LOG( FG_GENERAL, FG_INFO,
-		"Rate = " << s1 -> getRate()
-		<< "  Bps = " << s1 -> getBps()
-		<< "  Stereo = " << s1 -> getStereo() );
-	audio_sched -> loopSample ( s1 );
+	    s1 = new slSample ( (char *)slfile.c_str() );
+	    FG_LOG( FG_GENERAL, FG_INFO,
+		    "Rate = " << s1 -> getRate()
+		    << "  Bps = " << s1 -> getBps()
+		    << "  Stereo = " << s1 -> getStereo() );
+	    audio_sched -> loopSample ( s1 );
 
-	if ( audio_sched->not_working() ) {
-	    // skip
-	} else {
-	    pitch_envelope.setStep  ( 0, 0.01, 0.6 );
-	    volume_envelope.setStep ( 0, 0.01, 0.6 );
-
-	    audio_sched -> addSampleEnvelope( s1, 0, 0, 
-					      &pitch_envelope,
-					      SL_PITCH_ENVELOPE );
-	    audio_sched -> addSampleEnvelope( s1, 0, 1, 
-					      &volume_envelope,
-					      SL_VOLUME_ENVELOPE );
-	}
+	    if ( audio_sched->not_working() ) {
+		// skip
+	    } else {
+		pitch_envelope.setStep  ( 0, 0.01, 0.6 );
+		volume_envelope.setStep ( 0, 0.01, 0.6 );
+
+		audio_sched -> addSampleEnvelope( s1, 0, 0, 
+						  &pitch_envelope,
+						  SL_PITCH_ENVELOPE );
+		audio_sched -> addSampleEnvelope( s1, 0, 1, 
+						  &volume_envelope,
+						  SL_VOLUME_ENVELOPE );
+	    }
 
-	// strcpy(slfile, path);
-	// strcat(slfile, "thunder.wav");
-	// s2 -> loadFile ( slfile );
-	// s2 -> adjustVolume(0.5);
-	// audio_sched -> playSample ( s2 );
+	    // strcpy(slfile, path);
+	    // strcat(slfile, "thunder.wav");
+	    // s2 -> loadFile ( slfile );
+	    // s2 -> adjustVolume(0.5);
+	    // audio_sched -> playSample ( s2 );
+	}
 #endif
 
 	// sleep(1);
@@ -895,29 +1141,33 @@ static void fgIdleFunction ( void ) {
 // Handle new window size or exposure
 void fgReshape( int width, int height ) {
     if ( ! current_options.get_panel_status() ) {
-	// current_view.set_win_ratio( (GLfloat) width / (GLfloat) height );
-	// xglViewport(0, 0 , (GLint)(width), (GLint)(height) );
+	current_view.set_win_ratio( (GLfloat) width / (GLfloat) height );
+	glViewport(0, 0 , (GLint)(width), (GLint)(height) );
     } else {
-	// current_view.set_win_ratio( (GLfloat) width / 
-	//                             ((GLfloat) (height)*0.4232) );
-	// xglViewport(0, (GLint)((height)*0.5768), (GLint)(width), 
-	//                             (GLint)((height)*0.4232) );
+	current_view.set_win_ratio( (GLfloat) width / 
+	                            ((GLfloat) (height)*0.4232) );
+	glViewport(0, (GLint)((height)*0.5768), (GLint)(width), 
+		    (GLint)((height)*0.4232) );
     }
 
     current_view.set_winWidth( width );
     current_view.set_winHeight( height );
     current_view.force_update_fov_math();
 
+    // set these fov to be the same as in fgRenderFrame()
+    float x_fov = current_options.get_fov();
+    float y_fov = x_fov * 1.0 / current_view.get_win_ratio();
+    ssgSetFOV( x_fov, y_fov );
+
     glViewport ( 0, 0, width, height );
+    float fov = current_options.get_fov();
+    ssgSetFOV(fov * current_view.get_win_ratio(), fov);
 
     if ( idle_state == 1000 ) {
 	// yes we've finished all our initializations and are running
 	// the main loop, so this will now work without seg faulting
 	// the system.
-	current_view.UpdateViewParams();
-	if ( current_options.get_panel_status() ) {
-	    FGPanel::OurPanel->ReInit(0, 0, 1024, 768);
-	}
+	current_view.UpdateViewParams(cur_view_fdm);
     }
 }
 
@@ -928,23 +1178,23 @@ int fgGlutInit( int *argc, char **argv ) {
 #if !defined( MACOS )
     // GLUT will extract all glut specific options so later on we only
     // need wory about our own.
-    xglutInit(argc, argv);
+    glutInit(argc, argv);
 #endif
 
     // Define Display Parameters
-    xglutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
+    glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
 
     FG_LOG( FG_GENERAL, FG_INFO, "Opening a window: " <<
 	    current_options.get_xsize() << "x" << current_options.get_ysize() );
 
     // Define initial window size
-    xglutInitWindowSize( current_options.get_xsize(),
+    glutInitWindowSize( current_options.get_xsize(),
 			 current_options.get_ysize() );
 
     // Initialize windows
     if ( current_options.get_game_mode() == 0 ) {
 	// Open the regular window
-	xglutCreateWindow("Flight Gear");
+	glutCreateWindow("Flight Gear");
 #ifndef GLUT_WRONG_VERSION
     } else {
 	// Open the cool new 'game mode' window
@@ -1012,10 +1262,10 @@ int fgGlutInit( int *argc, char **argv ) {
 // Initialize GLUT event handlers
 int fgGlutInitEvents( void ) {
     // call fgReshape() on window resizes
-    xglutReshapeFunc( fgReshape );
+    glutReshapeFunc( fgReshape );
 
     // call GLUTkey() on keyboard event
-    xglutKeyboardFunc( GLUTkey );
+    glutKeyboardFunc( GLUTkey );
     glutSpecialFunc( GLUTspecialkey );
 
     // call guiMouseFunc() whenever our little rodent is used
@@ -1025,10 +1275,10 @@ int fgGlutInitEvents( void ) {
 
     // call fgMainLoop() whenever there is
     // nothing else to do
-    xglutIdleFunc( fgIdleFunction );
+    glutIdleFunc( fgIdleFunction );
 
     // draw the scene
-    xglutDisplayFunc( fgRenderFrame );
+    glutDisplayFunc( fgRenderFrame );
 
     return(1);
 }
@@ -1038,6 +1288,8 @@ int fgGlutInitEvents( void ) {
 int main( int argc, char **argv ) {
 
 #if defined( MACOS )
+    freopen ("stdout.txt", "w", stdout );
+    freopen ("stderr.txt", "w", stderr );
     argc = ccommand( &argv );
 #endif
 
@@ -1053,6 +1305,12 @@ int main( int argc, char **argv ) {
     // seed the random number generater
     fg_srandom();
 
+    // AIRCRAFT defined in uiuc_aircraft.h
+    // AIRCRAFTDIR defined in uiuc_aircraftdir.h
+    aircraft_ = new AIRCRAFT;
+    aircraftdir_ = new AIRCRAFTDIR;
+    aircraft_dir = ""; // Initialize the Aircraft directory to "" (UIUC)
+
     // Load the configuration parameters
     if ( !fgInitConfig(argc, argv) ) {
 	FG_LOG( FG_GENERAL, FG_ALERT, "Config option parsing failed ..." );
@@ -1067,12 +1325,13 @@ int main( int argc, char **argv ) {
 
     // Initialize the various GLUT Event Handlers.
     if( !fgGlutInitEvents() ) {
-	FG_LOG( FG_GENERAL, FG_ALERT, 
-		"GLUT event handler initialization failed ..." );
-	exit(-1);
+ 	FG_LOG( FG_GENERAL, FG_ALERT, 
+ 		"GLUT event handler initialization failed ..." );
+ 	exit(-1);
     }
-
-    // Initialize ssg (from plib)
+ 
+    // Initialize ssg (from plib).  Needs to come before we do any
+    // other ssg stuff, but after opengl/glut has been initialized.
     ssgInit();
 
     // Initialize the user interface (we need to do this before
@@ -1080,6 +1339,14 @@ int main( int argc, char **argv ) {
     // fonts !!!
     guiInit();
 
+    // Initialize time
+    FGTime::cur_time_params = new FGTime();
+    // FGTime::cur_time_params->init( cur_fdm_state->get_Longitude(), 
+    //                                cur_fdm_state->get_Latitude() );
+    // FGTime::cur_time_params->update( cur_fdm_state->get_Longitude() );
+    FGTime::cur_time_params->init( 0.0, 0.0 );
+    FGTime::cur_time_params->update( 0.0, 0.0, 0.0 );
+
     // Do some quick general initializations
     if( !fgInitGeneral()) {
 	FG_LOG( FG_GENERAL, FG_ALERT, 
@@ -1103,26 +1370,57 @@ int main( int argc, char **argv ) {
     ssgModelPath( (char *)modelpath.c_str() );
     ssgTexturePath( (char *)texturepath.c_str() );
 
+    // Scene graph root
     scene = new ssgRoot;
+    scene->setName( "Scene" );
+
+    // Initialize the sky
+    FGPath ephem_data_path( current_options.get_fg_root() );
+    ephem_data_path.append( "Astro" );
+    ephem = new FGEphemeris( ephem_data_path.c_str() );
+    ephem->update( FGTime::cur_time_params, 0.0 );
+
+    FGPath sky_tex_path( current_options.get_fg_root() );
+    sky_tex_path.append( "Textures" );
+    sky_tex_path.append( "Sky" );
+    thesky = new SGSky;
+    thesky->texture_path( sky_tex_path.str() );
+
+    ssgBranch *sky = thesky->build( 550.0, 550.0,
+				    ephem->getNumPlanets(), 
+				    ephem->getPlanets(), 60000.0,
+				    ephem->getNumStars(),
+				    ephem->getStars(), 60000.0 );
+    scene->addKid( sky );
+
+    // Terrain branch
     terrain = new ssgBranch;
     terrain->setName( "Terrain" );
+    scene->addKid( terrain );
+
+    // temporary visible aircraft "own ship"
     penguin_sel = new ssgSelector;
     penguin_pos = new ssgTransform;
-
+    // ssgBranch *tux_obj = ssgMakeSphere( 10.0, 10, 10 );
     ssgEntity *tux_obj = ssgLoadAC( "glider.ac" );
     // ssgEntity *tux_obj = ssgLoadAC( "Tower1x.ac" );
+
     penguin_pos->addKid( tux_obj );
     penguin_sel->addKid( penguin_pos );
     ssgFlatten( tux_obj );
     ssgStripify( penguin_sel );
+    penguin_sel->clrTraversalMaskBits( SSGTRAV_HOT );
+    scene->addKid( penguin_sel );
 
 #ifdef FG_NETWORK_OLK
     // Do the network intialization
-    printf("Multipilot mode %s\n", fg_net_init() );
+    if ( current_options.get_network_olk() ) {
+	printf("Multipilot mode %s\n", fg_net_init( scene ) );
+    }
 #endif
 
-    scene->addKid( terrain );
-    scene->addKid( penguin_sel );
+    // build our custom render states
+    fgBuildRenderStates();
 
     // pass control off to the master GLUT event handler
     glutMainLoop();