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

diff --git a/src/Main/main.cxx b/src/Main/main.cxx
index 5118ce04d..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,38 +56,41 @@
 #  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 <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>
@@ -153,6 +157,10 @@ ssgTransform *fgd_pos = NULL;
 // current fdm/position used for view
 FGInterface cur_view_fdm;
 
+// Sky structures
+FGEphemeris *ephem;
+SGSky *thesky;
+
 // hack
 sgMat4 copy_of_ssgOpenGLAxisSwapMatrix =
 {
@@ -183,6 +191,32 @@ 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
 void fgInitVisuals( void ) {
     fgLIGHT *l;
@@ -198,37 +232,37 @@ 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);      
 }
 
 
@@ -275,7 +309,7 @@ void fgRenderFrame( void ) {
 	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() ) {
@@ -295,7 +329,7 @@ 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
 
@@ -303,67 +337,84 @@ 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, 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 );
+	glLoadMatrixf( (float *)view_mat );
+	*/
 
-	xglDisable( GL_FOG );
-	/* if ( current_options.get_fog() > 0 ) {
-	    xglEnable( GL_FOG );
-	    xglFogi( GL_FOG_MODE, GL_EXP2 );
-	    xglFogfv( GL_FOG_COLOR, l->adj_fog_color );
-	} */
+	// set the opengl state to known default values
+	default_state->force();
 
-	xglShadeModel( GL_SMOOTH );
+	// 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 );
 	}
 
-	// xglDisable( GL_FOG );
-
-	// setup transformation for drawing astronomical objects
-	xglPushMatrix();
-	// Translate to view position
-	Point3D view_pos = current_view.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();
-	// reset blending function
-	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-
-	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 );
 	}
 
 	// update fog params if visibility has changed
@@ -455,50 +506,30 @@ void fgRenderFrame( void ) {
 	    fog_exp2_density = sqrt( -log(0.01) ) / actual_visibility;
     
 	    // Set correct opengl fog density
-	    xglFogf (GL_FOG_DENSITY, fog_exp2_density);
+	    glFogf (GL_FOG_DENSITY, fog_exp2_density);
 	}
  
 	// 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 );
+	glLightfv( GL_LIGHT0, GL_AMBIENT, l->scene_ambient );
+	glLightfv( GL_LIGHT0, GL_DIFFUSE, l->scene_diffuse );
+	// glLightfv(GL_LIGHT0, GL_SPECULAR, white );
 
 	// texture parameters
-	xglEnable( GL_TEXTURE_2D );
-	xglTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
-	xglHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
+	// 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)
-	// xglMaterialfv (GL_FRONT, GL_AMBIENT, white);
+	// glMaterialfv (GL_FRONT, GL_AMBIENT, white);
 	//  (GL_FRONT, GL_DIFFUSE, white);
-	// xglMaterialfv (GL_FRONT, GL_SPECULAR, white);
-	// xglMaterialfv (GL_FRONT, GL_SHININESS, mat_shininess);
-
-#if 0	
-	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);
-	}
-#endif
+	// 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();
+	// glMatrixMode( GL_PROJECTION );
+	// glLoadIdentity();
  	float fov = current_options.get_fov();
  	ssgSetFOV(fov * current_view.get_win_ratio(), fov);
 
@@ -509,9 +540,9 @@ 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 );
 	}
 
 	if ( current_options.get_view_mode() == 
@@ -541,10 +572,16 @@ 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, pilot_view.VIEW_ROT );
-	    sgMultMat4( sgTUX, sgTMP, sgTRANS );
+	    sgCopyMat4( sgTUX, sgROT );
+	    sgPostMultMat4( sgTUX, pilot_view.VIEW_ROT );
+	    sgPostMultMat4( sgTUX, sgTRANS );
 	
 	    sgCoord tuxpos;
 	    sgSetCoord( &tuxpos, sgTUX );
@@ -552,25 +589,27 @@ void fgRenderFrame( void ) {
 	}
 
 # ifdef FG_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 );
+	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;
 	    }
-	    other = other->next;
-	}
 
-	// fgd_sel->select(1);
-	// sgCopyMat4( sgTUX, current_view.sgVIEW);
-	// sgCoord fgdpos;
-	// sgSetCoord( &fgdpos, sgFGD_VIEW );
-	// fgd_pos->setTransform( &fgdpos);
+	    // fgd_sel->select(1);
+	    // sgCopyMat4( sgTUX, current_view.sgVIEW);
+	    // sgCoord fgdpos;
+	    // sgSetCoord( &fgdpos, sgFGD_VIEW );
+	    // fgd_pos->setTransform( &fgdpos);
+	}
 # endif
 
-	ssgSetCamera( current_view.VIEW );
+	// ssgSetCamera( current_view.VIEW );
 
 	// position tile nodes and update range selectors
 	global_tile_mgr.prep_ssg_nodes();
@@ -586,23 +625,26 @@ void fgRenderFrame( void ) {
 	// 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();
 }
 
 
@@ -622,7 +664,7 @@ void fgUpdateTimeDepCalcs(int multi_loop, int remainder) {
 
     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(), 
@@ -630,10 +672,12 @@ void fgUpdateTimeDepCalcs(int multi_loop, int remainder) {
 		     multi_loop * current_options.get_speed_up(),
 		     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(), 
 	//              fdm_state, 0, remainder );
 	cur_fdm_state->update( 0 );
+	FGSteam::update( 0 );
     }
 
     fdm_list.push_back( *cur_fdm_state );
@@ -696,6 +740,14 @@ void fgUpdateTimeDepCalcs(int multi_loop, int remainder) {
 	   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 );
 }
 
 
@@ -733,10 +785,12 @@ static void fgMainLoop( void ) {
     FG_LOG( FG_ALL, FG_DEBUG, "======= ==== ====");
 
 #ifdef FG_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
+    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
 
@@ -788,7 +842,9 @@ static void fgMainLoop( void ) {
 	   cur_fdm_state->get_Altitude() * FEET_TO_METER); */
 
     // update "time"
-    t->update(*cur_fdm_state);
+    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();
@@ -1086,11 +1142,11 @@ static void fgIdleFunction ( void ) {
 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) );
+	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), 
+	glViewport(0, (GLint)((height)*0.5768), (GLint)(width), 
 		    (GLint)((height)*0.4232) );
     }
 
@@ -1111,11 +1167,7 @@ void fgReshape( int width, int height ) {
 	// yes we've finished all our initializations and are running
 	// the main loop, so this will now work without seg faulting
 	// the system.
-	solarSystemRebuild();
 	current_view.UpdateViewParams(cur_view_fdm);
-	if ( current_options.get_panel_status() ) {
-	    FGPanel::OurPanel->ReInit(0, 0, 1024, 768);
-	}
     }
 }
 
@@ -1126,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
@@ -1210,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
@@ -1223,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);
 }
@@ -1236,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
 
@@ -1251,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 ..." );
@@ -1265,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
@@ -1278,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, 
@@ -1301,27 +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( scene ) );
+    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();