fly/flightgear
1
0
Fork 0
Code Activity

- open window as soon as possible

Browse source 
- move most of the initialization in chunks into the idle loop
- remove unused first fgSplashUpdate() parameter
This commit is contained in:
mfranz 2005-05-04 21:28:42 +00:00
parent 2a5b1040d3
commit 99f4b7e66e
5 changed files with 657 additions and 640 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/Main/fg_init.cxx
View file

@ -133,6 +133,7 @@
#include "options.hxx" #include "options.hxx"
#include "globals.hxx" #include "globals.hxx"
#include "logger.hxx" #include "logger.hxx"
#include "splash.hxx"
#include "viewmgr.hxx" #include "viewmgr.hxx"
#if defined(FX) && defined(XMESA) #if defined(FX) && defined(XMESA)
@ -1059,6 +1060,8 @@ fgInitNav ()
fgAirportDBLoad( airports, runways, aptdb.str(), p_metar.str() ); fgAirportDBLoad( airports, runways, aptdb.str(), p_metar.str() );
fgSplashUpdate( 1.0 );
FGNavList *navlist = new FGNavList; FGNavList *navlist = new FGNavList;
FGNavList *loclist = new FGNavList; FGNavList *loclist = new FGNavList;
FGNavList *gslist = new FGNavList; FGNavList *gslist = new FGNavList;
@ -1076,6 +1079,8 @@ fgInitNav ()
"Problems loading one or more navigational database" ); "Problems loading one or more navigational database" );
} }
fgSplashUpdate( 1.0 );
if ( fgGetBool("/sim/navdb/localizers/auto-align", true) ) { if ( fgGetBool("/sim/navdb/localizers/auto-align", true) ) {
// align all the localizers with their corresponding runways // align all the localizers with their corresponding runways
// since data sources are good for cockpit navigation // since data sources are good for cockpit navigation
@ -1616,6 +1621,7 @@ bool fgInitSubsystems() {
// update the current timezone each 30 minutes // update the current timezone each 30 minutes
globals->get_event_mgr()->addTask( "fgUpdateLocalTime()", globals->get_event_mgr()->addTask( "fgUpdateLocalTime()",
&fgUpdateLocalTime, 30*60 ); &fgUpdateLocalTime, 30*60 );
fgInitTimeOffset(); // the environment subsystem needs this
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////

405
src/Main/main.cxx
View file

@ -651,13 +651,201 @@ static void fgIdleFunction ( void ) {
// printf("idle state == %d\n", idle_state); // printf("idle state == %d\n", idle_state);
if ( idle_state == 0 ) { if ( idle_state == 0 ) {
// Initialize the splash screen right away idle_state++;
if ( fgGetBool("/sim/startup/splash-screen") ) {
fgSplashInit(fgGetString("/sim/startup/splash-texture")); // This seems to be the absolute earliest in the init sequence
// that these calls will return valid info. Too bad it's after
// we've already created and sized out window. :-(
general.set_glVendor( (char *)glGetString ( GL_VENDOR ) );
general.set_glRenderer( (char *)glGetString ( GL_RENDERER ) );
general.set_glVersion( (char *)glGetString ( GL_VERSION ) );
SG_LOG( SG_GENERAL, SG_INFO, general.get_glRenderer() );
GLint tmp;
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tmp );
general.set_glMaxTexSize( tmp );
SG_LOG ( SG_GENERAL, SG_INFO, "Max texture size = " << tmp );
glGetIntegerv( GL_DEPTH_BITS, &tmp );
general.set_glDepthBits( tmp );
SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
// Initialize ssg (from plib). Needs to come before we do any
// other ssg stuff, but after opengl has been initialized.
ssgInit();
// Initialize the user interface (we need to do this before
// passing off control to the OS main loop and before
// fgInitGeneral to get our fonts !!!
guiInit();
} else if ( idle_state == 1 ) {
idle_state++;
// Read the list of available aircrafts
fgReadAircraft();
#ifdef GL_EXT_texture_lod_bias
glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, -0.5 ) ;
#endif
// get the address of our OpenGL extensions
if ( fgGetBool("/sim/rendering/distance-attenuation") ) {
if (SGIsOpenGLExtensionSupported("GL_EXT_point_parameters") ) {
glPointParameterIsSupported = true;
glPointParameterfPtr = (glPointParameterfProc)
SGLookupFunction("glPointParameterfEXT");
glPointParameterfvPtr = (glPointParameterfvProc)
SGLookupFunction("glPointParameterfvEXT");
} else if ( SGIsOpenGLExtensionSupported("GL_ARB_point_parameters") ) {
glPointParameterIsSupported = true;
glPointParameterfPtr = (glPointParameterfProc)
SGLookupFunction("glPointParameterfARB");
glPointParameterfvPtr = (glPointParameterfvProc)
SGLookupFunction("glPointParameterfvARB");
} else
glPointParameterIsSupported = false;
} }
} else if ( idle_state == 2 ) {
idle_state++;
fgInitNav();
} else if ( idle_state == 3 ) {
idle_state++;
// based on the requested presets, calculate the true starting
// lon, lat
fgInitPosition();
SGTime *t = fgInitTime();
globals->set_time_params( t );
// Do some quick general initializations
if( !fgInitGeneral()) {
SG_LOG( SG_GENERAL, SG_ALERT,
"General initializations failed ..." );
exit(-1);
}
////////////////////////////////////////////////////////////////////
// Initialize the property-based built-in commands
////////////////////////////////////////////////////////////////////
fgInitCommands();
////////////////////////////////////////////////////////////////////
// Initialize the material manager
////////////////////////////////////////////////////////////////////
globals->set_matlib( new SGMaterialLib );
globals->set_model_lib(new SGModelLib);
////////////////////////////////////////////////////////////////////
// Initialize the TG scenery subsystem.
////////////////////////////////////////////////////////////////////
globals->set_scenery( new FGScenery );
globals->get_scenery()->init();
globals->get_scenery()->bind();
globals->set_tile_mgr( new FGTileMgr );
////////////////////////////////////////////////////////////////////
// Initialize the general model subsystem.
////////////////////////////////////////////////////////////////////
globals->set_model_mgr(new FGModelMgr);
globals->get_model_mgr()->init();
globals->get_model_mgr()->bind();
} else if ( idle_state == 4 ) {
idle_state++;
////////////////////////////////////////////////////////////////////
// Initialize the 3D aircraft model subsystem (has a dependency on
// the scenery subsystem.)
////////////////////////////////////////////////////////////////////
globals->set_aircraft_model(new FGAircraftModel);
globals->get_aircraft_model()->init();
globals->get_aircraft_model()->bind();
////////////////////////////////////////////////////////////////////
// Initialize the view manager subsystem.
////////////////////////////////////////////////////////////////////
FGViewMgr *viewmgr = new FGViewMgr;
globals->set_viewmgr( viewmgr );
viewmgr->init();
viewmgr->bind();
} else if ( idle_state == 5 ) {
idle_state++;
// Initialize the sky
SGPath ephem_data_path( globals->get_fg_root() );
ephem_data_path.append( "Astro" );
SGEphemeris *ephem = new SGEphemeris( ephem_data_path.c_str() );
ephem->update( globals->get_time_params()->getMjd(),
globals->get_time_params()->getLst(),
0.0 );
globals->set_ephem( ephem );
// TODO: move to environment mgr
thesky = new SGSky;
SGPath texture_path(globals->get_fg_root());
texture_path.append("Textures");
texture_path.append("Sky");
for (int i = 0; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
SGCloudLayer * layer = new SGCloudLayer(texture_path.str());
thesky->add_cloud_layer(layer);
}
SGPath sky_tex_path( globals->get_fg_root() );
sky_tex_path.append( "Textures" );
sky_tex_path.append( "Sky" );
thesky->texture_path( sky_tex_path.str() );
// The sun and moon diameters are scaled down numbers of the
// actual diameters. This was needed to fit bot the sun and the
// moon within the distance to the far clip plane.
// Moon diameter: 3,476 kilometers
// Sun diameter: 1,390,000 kilometers
thesky->build( 80000.0, 80000.0,
463.3, 361.8,
globals->get_ephem()->getNumPlanets(),
globals->get_ephem()->getPlanets(),
globals->get_ephem()->getNumStars(),
globals->get_ephem()->getStars() );
// Initialize MagVar model
SGMagVar *magvar = new SGMagVar();
globals->set_mag( magvar );
// kludge to initialize mag compass
// (should only be done for in-flight
// startup)
// update magvar model
globals->get_mag()->update( fgGetDouble("/position/longitude-deg")
* SGD_DEGREES_TO_RADIANS,
fgGetDouble("/position/latitude-deg")
* SGD_DEGREES_TO_RADIANS,
fgGetDouble("/position/altitude-ft")
* SG_FEET_TO_METER,
globals->get_time_params()->getJD() );
double var = globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
fgSetDouble("/instrumentation/heading-indicator/offset-deg", -var);
// airport = new ssgBranch;
// airport->setName( "Airport Lighting" );
// lighting->addKid( airport );
// build our custom render states
globals->get_renderer()->build_states();
} else if ( idle_state == 6 ) {
idle_state++; idle_state++;
} else if ( idle_state == 1 ) {
// Initialize audio support // Initialize audio support
#ifdef ENABLE_AUDIO_SUPPORT #ifdef ENABLE_AUDIO_SUPPORT
@ -681,8 +869,6 @@ static void fgIdleFunction ( void ) {
} }
#endif #endif
idle_state++;
} else if ( idle_state == 2 ) {
// These are a few miscellaneous things that aren't really // These are a few miscellaneous things that aren't really
// "subsystems" but still need to be initialized. // "subsystems" but still need to be initialized.
@ -692,8 +878,6 @@ static void fgIdleFunction ( void ) {
} }
#endif #endif
idle_state++;
} else if ( idle_state == 3 ) {
// This is the top level init routine which calls all the // This is the top level init routine which calls all the
// other subsystem initialization routines. If you are adding // other subsystem initialization routines. If you are adding
// a subsystem to flightgear, its initialization call should // a subsystem to flightgear, its initialization call should
@ -704,8 +888,9 @@ static void fgIdleFunction ( void ) {
exit(-1); exit(-1);
} }
} else if ( idle_state == 7 ) {
idle_state++; idle_state++;
} else if ( idle_state == 4 ) {
// Initialize the time offset (warp) after fgInitSubsystem // Initialize the time offset (warp) after fgInitSubsystem
// (which initializes the lighting interpolation tables.) // (which initializes the lighting interpolation tables.)
fgInitTimeOffset(); fgInitTimeOffset();
@ -716,31 +901,25 @@ static void fgIdleFunction ( void ) {
// Read the list of available aircrafts // Read the list of available aircrafts
fgReadAircraft(); fgReadAircraft();
idle_state++;
} else if ( idle_state == 5 ) {
idle_state++;
} else if ( idle_state == 6 ) {
// sleep(1);
} else if ( idle_state == 8 ) {
idle_state = 1000; idle_state = 1000;
SG_LOG( SG_GENERAL, SG_INFO, "Panel visible = " << fgPanelVisible() ); SG_LOG( SG_GENERAL, SG_INFO, "Panel visible = " << fgPanelVisible() );
globals->get_renderer()->resize( fgGetInt("/sim/startup/xsize"), globals->get_renderer()->resize( fgGetInt("/sim/startup/xsize"),
fgGetInt("/sim/startup/ysize") ); fgGetInt("/sim/startup/ysize") );
} }
if ( idle_state == 1000 ) { if ( idle_state < 1000 ) {
fgSplashUpdate( 1.0 );
} else {
// We've finished all our initialization steps, from now on we // We've finished all our initialization steps, from now on we
// run the main loop. // run the main loop.
fgSetBool("sim/sceneryloaded",false); fgSetBool("sim/sceneryloaded",false);
fgRegisterIdleHandler( fgMainLoop );
fgRegisterIdleHandler(fgMainLoop);
} else {
if ( fgGetBool("/sim/startup/splash-screen") ) {
fgSplashUpdate(0.0, 1.0);
}
} }
} }
@ -835,6 +1014,9 @@ bool fgMainInit( int argc, char **argv ) {
bool get_stencil_buffer = false; bool get_stencil_buffer = false;
#endif #endif
// Initialize plib net interface
netInit( &argc, argv );
// Clouds3D requires an alpha channel // Clouds3D requires an alpha channel
// clouds may require stencil buffer // clouds may require stencil buffer
fgOSOpenWindow( fgGetInt("/sim/startup/xsize"), fgOSOpenWindow( fgGetInt("/sim/startup/xsize"),
@ -844,182 +1026,8 @@ bool fgMainInit( int argc, char **argv ) {
get_stencil_buffer, get_stencil_buffer,
fgGetBool("/sim/startup/fullscreen") ); fgGetBool("/sim/startup/fullscreen") );
// This seems to be the absolute earliest in the init sequence // Initialize the splash screen right away
// that these calls will return valid info. Too bad it's after fgSplashInit(fgGetString("/sim/startup/splash-texture"));
// we've already created and sized out window. :-(
general.set_glVendor( (char *)glGetString ( GL_VENDOR ) );
general.set_glRenderer( (char *)glGetString ( GL_RENDERER ) );
general.set_glVersion( (char *)glGetString ( GL_VERSION ) );
SG_LOG( SG_GENERAL, SG_INFO, general.get_glRenderer() );
GLint tmp;
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tmp );
general.set_glMaxTexSize( tmp );
SG_LOG ( SG_GENERAL, SG_INFO, "Max texture size = " << tmp );
glGetIntegerv( GL_DEPTH_BITS, &tmp );
general.set_glDepthBits( tmp );
SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
// Initialize plib net interface
netInit( &argc, argv );
// Initialize ssg (from plib). Needs to come before we do any
// other ssg stuff, but after opengl has been initialized.
ssgInit();
// Initialize the user interface (we need to do this before
// passing off control to the OS main loop and before
// fgInitGeneral to get our fonts !!!
guiInit();
// Read the list of available aircrafts
fgReadAircraft();
#ifdef GL_EXT_texture_lod_bias
glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, -0.5 ) ;
#endif
// get the address of our OpenGL extensions
if ( fgGetBool("/sim/rendering/distance-attenuation") )
{
if (SGIsOpenGLExtensionSupported("GL_EXT_point_parameters") ) {
glPointParameterIsSupported = true;
glPointParameterfPtr = (glPointParameterfProc)
SGLookupFunction("glPointParameterfEXT");
glPointParameterfvPtr = (glPointParameterfvProc)
SGLookupFunction("glPointParameterfvEXT");
} else if ( SGIsOpenGLExtensionSupported("GL_ARB_point_parameters") ) {
glPointParameterIsSupported = true;
glPointParameterfPtr = (glPointParameterfProc)
SGLookupFunction("glPointParameterfARB");
glPointParameterfvPtr = (glPointParameterfvProc)
SGLookupFunction("glPointParameterfvARB");
} else
glPointParameterIsSupported = false;
}
// based on the requested presets, calculate the true starting
// lon, lat
fgInitNav();
fgInitPosition();
SGTime *t = fgInitTime();
globals->set_time_params( t );
// Do some quick general initializations
if( !fgInitGeneral()) {
SG_LOG( SG_GENERAL, SG_ALERT,
"General initializations failed ..." );
exit(-1);
}
////////////////////////////////////////////////////////////////////
// Initialize the property-based built-in commands
////////////////////////////////////////////////////////////////////
fgInitCommands();
////////////////////////////////////////////////////////////////////
// Initialize the material manager
////////////////////////////////////////////////////////////////////
globals->set_matlib( new SGMaterialLib );
globals->set_model_lib(new SGModelLib);
////////////////////////////////////////////////////////////////////
// Initialize the TG scenery subsystem.
////////////////////////////////////////////////////////////////////
globals->set_scenery( new FGScenery );
globals->get_scenery()->init();
globals->get_scenery()->bind();
globals->set_tile_mgr( new FGTileMgr );
////////////////////////////////////////////////////////////////////
// Initialize the general model subsystem.
////////////////////////////////////////////////////////////////////
globals->set_model_mgr(new FGModelMgr);
globals->get_model_mgr()->init();
globals->get_model_mgr()->bind();
////////////////////////////////////////////////////////////////////
// Initialize the 3D aircraft model subsystem (has a dependency on
// the scenery subsystem.)
////////////////////////////////////////////////////////////////////
globals->set_aircraft_model(new FGAircraftModel);
globals->get_aircraft_model()->init();
globals->get_aircraft_model()->bind();
////////////////////////////////////////////////////////////////////
// Initialize the view manager subsystem.
////////////////////////////////////////////////////////////////////
FGViewMgr *viewmgr = new FGViewMgr;
globals->set_viewmgr( viewmgr );
viewmgr->init();
viewmgr->bind();
// Initialize the sky
SGPath ephem_data_path( globals->get_fg_root() );
ephem_data_path.append( "Astro" );
SGEphemeris *ephem = new SGEphemeris( ephem_data_path.c_str() );
ephem->update( globals->get_time_params()->getMjd(),
globals->get_time_params()->getLst(),
0.0 );
globals->set_ephem( ephem );
// TODO: move to environment mgr
thesky = new SGSky;
SGPath texture_path(globals->get_fg_root());
texture_path.append("Textures");
texture_path.append("Sky");
for (int i = 0; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
SGCloudLayer * layer = new SGCloudLayer(texture_path.str());
thesky->add_cloud_layer(layer);
}
SGPath sky_tex_path( globals->get_fg_root() );
sky_tex_path.append( "Textures" );
sky_tex_path.append( "Sky" );
thesky->texture_path( sky_tex_path.str() );
// The sun and moon diameters are scaled down numbers of the
// actual diameters. This was needed to fit bot the sun and the
// moon within the distance to the far clip plane.
// Moon diameter: 3,476 kilometers
// Sun diameter: 1,390,000 kilometers
thesky->build( 80000.0, 80000.0,
463.3, 361.8,
globals->get_ephem()->getNumPlanets(),
globals->get_ephem()->getPlanets(),
globals->get_ephem()->getNumStars(),
globals->get_ephem()->getStars() );
// Initialize MagVar model
SGMagVar *magvar = new SGMagVar();
globals->set_mag( magvar );
// kludge to initialize mag compass
// (should only be done for in-flight
// startup)
// update magvar model
globals->get_mag()->update( fgGetDouble("/position/longitude-deg")
* SGD_DEGREES_TO_RADIANS,
fgGetDouble("/position/latitude-deg")
* SGD_DEGREES_TO_RADIANS,
fgGetDouble("/position/altitude-ft")
* SG_FEET_TO_METER,
globals->get_time_params()->getJD() );
double var = globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
fgSetDouble("/instrumentation/heading-indicator/offset-deg", -var);
// airport = new ssgBranch;
// airport->setName( "Airport Lighting" );
// lighting->addKid( airport );
// build our custom render states
globals->get_renderer()->build_states();
// pass control off to the master event handler // pass control off to the master event handler
fgOSMainLoop(); fgOSMainLoop();
@ -1030,4 +1038,3 @@ bool fgMainInit( int argc, char **argv ) {
} }
// end of main.cxx

849
src/Main/renderer.cxx
View file

@ -233,6 +233,18 @@ FGRenderer::init( void ) {
void void
FGRenderer::update( bool refresh_camera_settings ) { FGRenderer::update( bool refresh_camera_settings ) {
bool scenery_loaded = fgGetBool("sim/sceneryloaded") || fgGetBool("sim/sceneryloaded-override"); bool scenery_loaded = fgGetBool("sim/sceneryloaded") || fgGetBool("sim/sceneryloaded-override");
if ( idle_state < 1000 || !scenery_loaded ) {
// still initializing, draw the splash screen
fgSplashUpdate(1.0);
// Keep resetting sim time while the sim is initializing
globals->set_sim_time_sec( 0.0 );
SGAnimation::set_sim_time_sec( 0.0 );
return;
}
bool draw_otw = fgGetBool("/sim/rendering/draw-otw"); bool draw_otw = fgGetBool("/sim/rendering/draw-otw");
bool skyblend = fgGetBool("/sim/rendering/skyblend"); bool skyblend = fgGetBool("/sim/rendering/skyblend");
bool enhanced_lighting = fgGetBool("/sim/rendering/enhanced-lighting"); bool enhanced_lighting = fgGetBool("/sim/rendering/enhanced-lighting");
@ -290,481 +302,468 @@ FGRenderer::update( bool refresh_camera_settings ) {
// GLfloat mat_shininess[] = { 10.0 }; // GLfloat mat_shininess[] = { 10.0 };
GLbitfield clear_mask; GLbitfield clear_mask;
if ( idle_state != 1000 || !scenery_loaded ) { // idle_state is now 1000 meaning we've finished all our
// still initializing, draw the splash screen // initializations and are running the main loop, so this will
if ( fgGetBool("/sim/startup/splash-screen") ) { // now work without seg faulting the system.
fgSplashUpdate(0.0, 1.0);
}
// Keep resetting sim time while the sim is initializing
globals->set_sim_time_sec( 0.0 );
SGAnimation::set_sim_time_sec( 0.0 );
} else {
// idle_state is now 1000 meaning we've finished all our
// initializations and are running the main loop, so this will
// now work without seg faulting the system.
FGViewer *current__view = globals->get_current_view(); FGViewer *current__view = globals->get_current_view();
// calculate our current position in cartesian space // calculate our current position in cartesian space
Point3D cntr = globals->get_scenery()->get_next_center(); Point3D cntr = globals->get_scenery()->get_next_center();
globals->get_scenery()->set_center(cntr); globals->get_scenery()->set_center(cntr);
current__view->set_scenery_center(cntr); current__view->set_scenery_center(cntr);
if ( refresh_camera_settings ) { if ( refresh_camera_settings ) {
// update view port // update view port
resize( fgGetInt("/sim/startup/xsize"), resize( fgGetInt("/sim/startup/xsize"),
fgGetInt("/sim/startup/ysize") ); fgGetInt("/sim/startup/ysize") );
// Tell GL we are switching to model view parameters // Tell GL we are switching to model view parameters
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
ssgSetCamera( (sgVec4 *)current__view->get_VIEW() ); ssgSetCamera( (sgVec4 *)current__view->get_VIEW() );
} }
if ( fgGetBool("/sim/rendering/clouds3d") ) { if ( fgGetBool("/sim/rendering/clouds3d") ) {
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT ); glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
cloud3d_imposter_state->force(); cloud3d_imposter_state->force();
glDisable( GL_FOG ); glDisable( GL_FOG );
glColor4f( 1.0, 1.0, 1.0, 1.0 ); glColor4f( 1.0, 1.0, 1.0, 1.0 );
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ; glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ;
#ifdef FG_USE_CLOUDS_3D #ifdef FG_USE_CLOUDS_3D
if ( _bcloud_orig ) { if ( _bcloud_orig ) {
Point3D c = globals->get_scenery()->get_center(); Point3D c = globals->get_scenery()->get_center();
sgClouds3d->Set_Cloud_Orig( &c ); sgClouds3d->Set_Cloud_Orig( &c );
_bcloud_orig = false; _bcloud_orig = false;
} }
sgClouds3d->Update( current__view->get_absolute_view_pos() ); sgClouds3d->Update( current__view->get_absolute_view_pos() );
#endif #endif
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ; glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
} }
clear_mask = GL_DEPTH_BUFFER_BIT; clear_mask = GL_DEPTH_BUFFER_BIT;
if ( fgGetBool("/sim/rendering/wireframe") ) { if ( fgGetBool("/sim/rendering/wireframe") ) {
clear_mask |= GL_COLOR_BUFFER_BIT; clear_mask |= GL_COLOR_BUFFER_BIT;
} }
if ( skyblend ) { if ( skyblend ) {
if ( fgGetBool("/sim/rendering/textures") ) { if ( fgGetBool("/sim/rendering/textures") ) {
// glClearColor(black[0], black[1], black[2], black[3]); // glClearColor(black[0], black[1], black[2], black[3]);
glClearColor(l->adj_fog_color()[0], l->adj_fog_color()[1], glClearColor(l->adj_fog_color()[0], l->adj_fog_color()[1],
l->adj_fog_color()[2], l->adj_fog_color()[3]); l->adj_fog_color()[2], l->adj_fog_color()[3]);
clear_mask |= GL_COLOR_BUFFER_BIT; clear_mask |= GL_COLOR_BUFFER_BIT;
} }
} else {
glClearColor(l->sky_color()[0], l->sky_color()[1],
l->sky_color()[2], l->sky_color()[3]);
clear_mask |= GL_COLOR_BUFFER_BIT;
}
if ( multi_pass_clouds && draw_clouds ) {
glClearStencil( 0 );
clear_mask |= GL_STENCIL_BUFFER_BIT;
}
glClear( clear_mask );
// set the opengl state to known default values
default_state->force();
// update fog params if visibility has changed
double visibility_meters = fgGetDouble("/environment/visibility-m");
thesky->set_visibility(visibility_meters);
thesky->modify_vis( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER,
( global_multi_loop * fgGetInt("/sim/speed-up") )
/ (double)fgGetInt("/sim/model-hz") );
// Set correct opengl fog density
glFogf (GL_FOG_DENSITY, fog_exp2_density);
// update the sky dome
if ( skyblend ) {
/*
SG_LOG( SG_GENERAL, SG_BULK, "thesky->repaint() sky_color = "
<< l->sky_color()[0] << " "
<< l->sky_color()[1] << " "
<< l->sky_color()[2] << " "
<< l->sky_color()[3] );
SG_LOG( SG_GENERAL, SG_BULK, " fog = "
<< l->fog_color()[0] << " "
<< l->fog_color()[1] << " "
<< l->fog_color()[2] << " "
<< l->fog_color()[3] );
SG_LOG( SG_GENERAL, SG_BULK,
" sun_angle = " << l->sun_angle
<< " moon_angle = " << l->moon_angle );
*/
static SGSkyColor scolor;
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
scolor.sky_color = l->sky_color();
scolor.fog_color = l->adj_fog_color();
scolor.cloud_color = l->cloud_color();
scolor.sun_angle = l->get_sun_angle();
scolor.moon_angle = l->get_moon_angle();
scolor.nplanets = globals->get_ephem()->getNumPlanets();
scolor.nstars = globals->get_ephem()->getNumStars();
scolor.planet_data = globals->get_ephem()->getPlanets();
scolor.star_data = globals->get_ephem()->getStars();
thesky->repaint( scolor );
/*
SG_LOG( SG_GENERAL, SG_BULK,
"thesky->reposition( view_pos = " << view_pos[0] << " "
<< view_pos[1] << " " << view_pos[2] );
SG_LOG( SG_GENERAL, SG_BULK,
" zero_elev = " << zero_elev[0] << " "
<< zero_elev[1] << " " << zero_elev[2]
<< " lon = " << cur_fdm_state->get_Longitude()
<< " lat = " << cur_fdm_state->get_Latitude() );
SG_LOG( SG_GENERAL, SG_BULK,
" sun_rot = " << l->get_sun_rotation
<< " gst = " << SGTime::cur_time_params->getGst() );
SG_LOG( SG_GENERAL, SG_BULK,
" sun ra = " << globals->get_ephem()->getSunRightAscension()
<< " sun dec = " << globals->get_ephem()->getSunDeclination()
<< " moon ra = " << globals->get_ephem()->getMoonRightAscension()
<< " moon dec = " << globals->get_ephem()->getMoonDeclination() );
*/
// The sun and moon distances are scaled down versions
// of the actual distance to get both the moon and the sun
// within the range of the far clip plane.
// Moon distance: 384,467 kilometers
// Sun distance: 150,000,000 kilometers
double sun_horiz_eff, moon_horiz_eff;
if (fgGetBool("/sim/rendering/horizon-effect")) {
sun_horiz_eff = 0.67+pow(0.5+cos(l->get_sun_angle())*2/2, 0.33)/3;
moon_horiz_eff = 0.67+pow(0.5+cos(l->get_moon_angle())*2/2, 0.33)/3;
} else { } else {
glClearColor(l->sky_color()[0], l->sky_color()[1], sun_horiz_eff = moon_horiz_eff = 1.0;
l->sky_color()[2], l->sky_color()[3]);
clear_mask |= GL_COLOR_BUFFER_BIT;
}
if ( multi_pass_clouds && draw_clouds ) {
glClearStencil( 0 );
clear_mask |= GL_STENCIL_BUFFER_BIT;
}
glClear( clear_mask );
// set the opengl state to known default values
default_state->force();
// update fog params if visibility has changed
double visibility_meters = fgGetDouble("/environment/visibility-m");
thesky->set_visibility(visibility_meters);
thesky->modify_vis( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER,
( global_multi_loop * fgGetInt("/sim/speed-up") )
/ (double)fgGetInt("/sim/model-hz") );
// Set correct opengl fog density
glFogf (GL_FOG_DENSITY, fog_exp2_density);
// update the sky dome
if ( skyblend ) {
/*
SG_LOG( SG_GENERAL, SG_BULK, "thesky->repaint() sky_color = "
<< l->sky_color()[0] << " "
<< l->sky_color()[1] << " "
<< l->sky_color()[2] << " "
<< l->sky_color()[3] );
SG_LOG( SG_GENERAL, SG_BULK, " fog = "
<< l->fog_color()[0] << " "
<< l->fog_color()[1] << " "
<< l->fog_color()[2] << " "
<< l->fog_color()[3] );
SG_LOG( SG_GENERAL, SG_BULK,
" sun_angle = " << l->sun_angle
<< " moon_angle = " << l->moon_angle );
*/
static SGSkyColor scolor;
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
scolor.sky_color = l->sky_color();
scolor.fog_color = l->adj_fog_color();
scolor.cloud_color = l->cloud_color();
scolor.sun_angle = l->get_sun_angle();
scolor.moon_angle = l->get_moon_angle();
scolor.nplanets = globals->get_ephem()->getNumPlanets();
scolor.nstars = globals->get_ephem()->getNumStars();
scolor.planet_data = globals->get_ephem()->getPlanets();
scolor.star_data = globals->get_ephem()->getStars();
thesky->repaint( scolor );
/*
SG_LOG( SG_GENERAL, SG_BULK,
"thesky->reposition( view_pos = " << view_pos[0] << " "
<< view_pos[1] << " " << view_pos[2] );
SG_LOG( SG_GENERAL, SG_BULK,
" zero_elev = " << zero_elev[0] << " "
<< zero_elev[1] << " " << zero_elev[2]
<< " lon = " << cur_fdm_state->get_Longitude()
<< " lat = " << cur_fdm_state->get_Latitude() );
SG_LOG( SG_GENERAL, SG_BULK,
" sun_rot = " << l->get_sun_rotation
<< " gst = " << SGTime::cur_time_params->getGst() );
SG_LOG( SG_GENERAL, SG_BULK,
" sun ra = " << globals->get_ephem()->getSunRightAscension()
<< " sun dec = " << globals->get_ephem()->getSunDeclination()
<< " moon ra = " << globals->get_ephem()->getMoonRightAscension()
<< " moon dec = " << globals->get_ephem()->getMoonDeclination() );
*/
// The sun and moon distances are scaled down versions
// of the actual distance to get both the moon and the sun
// within the range of the far clip plane.
// Moon distance: 384,467 kilometers
// Sun distance: 150,000,000 kilometers
double sun_horiz_eff, moon_horiz_eff;
if (fgGetBool("/sim/rendering/horizon-effect")) {
sun_horiz_eff = 0.67+pow(0.5+cos(l->get_sun_angle())*2/2, 0.33)/3;
moon_horiz_eff = 0.67+pow(0.5+cos(l->get_moon_angle())*2/2, 0.33)/3;
} else {
sun_horiz_eff = moon_horiz_eff = 1.0;
}
static SGSkyState sstate;
sstate.view_pos = current__view->get_view_pos();
sstate.zero_elev = current__view->get_zero_elev();
sstate.view_up = current__view->get_world_up();
sstate.lon = current__view->getLongitude_deg()
* SGD_DEGREES_TO_RADIANS;
sstate.lat = current__view->getLatitude_deg()
* SGD_DEGREES_TO_RADIANS;
sstate.alt = current__view->getAltitudeASL_ft()
* SG_FEET_TO_METER;
sstate.spin = l->get_sun_rotation();
sstate.gst = globals->get_time_params()->getGst();
sstate.sun_ra = globals->get_ephem()->getSunRightAscension();
sstate.sun_dec = globals->get_ephem()->getSunDeclination();
sstate.sun_dist = 50000.0 * sun_horiz_eff;
sstate.moon_ra = globals->get_ephem()->getMoonRightAscension();
sstate.moon_dec = globals->get_ephem()->getMoonDeclination();
sstate.moon_dist = 40000.0 * moon_horiz_eff;
thesky->reposition( sstate, delta_time_sec );
} }
glEnable( GL_DEPTH_TEST ); static SGSkyState sstate;
if ( strcmp(fgGetString("/sim/rendering/fog"), "disabled") ) {
glEnable( GL_FOG );
glFogi( GL_FOG_MODE, GL_EXP2 );
glFogfv( GL_FOG_COLOR, l->adj_fog_color() );
}
// set sun/lighting parameters sstate.view_pos = current__view->get_view_pos();
ssgGetLight( 0 ) -> setPosition( l->sun_vec() ); sstate.zero_elev = current__view->get_zero_elev();
sstate.view_up = current__view->get_world_up();
sstate.lon = current__view->getLongitude_deg()
* SGD_DEGREES_TO_RADIANS;
sstate.lat = current__view->getLatitude_deg()
* SGD_DEGREES_TO_RADIANS;
sstate.alt = current__view->getAltitudeASL_ft()
* SG_FEET_TO_METER;
sstate.spin = l->get_sun_rotation();
sstate.gst = globals->get_time_params()->getGst();
sstate.sun_ra = globals->get_ephem()->getSunRightAscension();
sstate.sun_dec = globals->get_ephem()->getSunDeclination();
sstate.sun_dist = 50000.0 * sun_horiz_eff;
sstate.moon_ra = globals->get_ephem()->getMoonRightAscension();
sstate.moon_dec = globals->get_ephem()->getMoonDeclination();
sstate.moon_dist = 40000.0 * moon_horiz_eff;
// GL_LIGHT_MODEL_AMBIENT has a default non-zero value so if thesky->reposition( sstate, delta_time_sec );
// we only update GL_AMBIENT for our lights we will never get }
// a completely dark scene. So, we set GL_LIGHT_MODEL_AMBIENT
// explicitely to black.
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, black );
ssgGetLight( 0 ) -> setColour( GL_AMBIENT, l->scene_ambient() ); glEnable( GL_DEPTH_TEST );
if ( strcmp(fgGetString("/sim/rendering/fog"), "disabled") ) {
glEnable( GL_FOG );
glFogi( GL_FOG_MODE, GL_EXP2 );
glFogfv( GL_FOG_COLOR, l->adj_fog_color() );
}
// set sun/lighting parameters
ssgGetLight( 0 ) -> setPosition( l->sun_vec() );
// GL_LIGHT_MODEL_AMBIENT has a default non-zero value so if
// we only update GL_AMBIENT for our lights we will never get
// a completely dark scene. So, we set GL_LIGHT_MODEL_AMBIENT
// explicitely to black.
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, black );
ssgGetLight( 0 ) -> setColour( GL_AMBIENT, l->scene_ambient() );
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
ssgGetLight( 0 ) -> setColour( GL_SPECULAR, l->scene_specular() );
// texture parameters
// glEnable( GL_TEXTURE_2D );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
double agl =
current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER
- globals->get_scenery()->get_cur_elev();
if ( agl > 50.0 ) {
scene_nearplane = 10.0f;
scene_farplane = 120000.0f;
} else {
scene_nearplane = groundlevel_nearplane->getDoubleValue();
scene_farplane = 120000.0f;
}
setNearFar( scene_nearplane, scene_farplane );
if ( draw_otw && skyblend ) {
// draw the sky backdrop
// we need a white diffuse light for the phase of the moon
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, white );
thesky->preDraw( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER,
fog_exp2_density );
// return to the desired diffuse color
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() ); ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
ssgGetLight( 0 ) -> setColour( GL_SPECULAR, l->scene_specular() ); }
// texture parameters // draw the ssg scene
// glEnable( GL_TEXTURE_2D ); glEnable( GL_DEPTH_TEST );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
double agl = if ( fgGetBool("/sim/rendering/wireframe") ) {
current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER // draw wire frame
- globals->get_scenery()->get_cur_elev(); glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
}
if ( draw_otw ) {
if ( draw_clouds ) {
if ( agl > 10.0 ) { // Draw the terrain
scene_nearplane = 10.0f; FGTileMgr::set_tile_filter( true );
scene_farplane = 120000.0f; sgSetModelFilter( false );
} else { globals->get_aircraft_model()->select( false );
scene_nearplane = groundlevel_nearplane->getDoubleValue(); ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
scene_farplane = 120000.0f;
}
setNearFar( scene_nearplane, scene_farplane ); // Disable depth buffer update, draw the clouds
glDepthMask( GL_FALSE );
if ( draw_otw && skyblend ) { thesky->drawUpperClouds();
// draw the sky backdrop if ( multi_pass_clouds ) {
thesky->drawLowerClouds();
// we need a white diffuse light for the phase of the moon
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, white );
thesky->preDraw( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER,
fog_exp2_density );
// return to the desired diffuse color
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
}
// draw the ssg scene
glEnable( GL_DEPTH_TEST );
if ( fgGetBool("/sim/rendering/wireframe") ) {
// draw wire frame
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
}
if ( draw_otw ) {
if ( draw_clouds ) {
// Draw the terrain
FGTileMgr::set_tile_filter( true );
sgSetModelFilter( false );
globals->get_aircraft_model()->select( false );
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
// Disable depth buffer update, draw the clouds
glDepthMask( GL_FALSE );
thesky->drawUpperClouds();
if ( multi_pass_clouds ) {
thesky->drawLowerClouds();
}
glDepthMask( GL_TRUE );
if ( multi_pass_clouds ) {
// Draw the objects except the aircraft
// and update the stencil buffer with 1
glEnable( GL_STENCIL_TEST );
glStencilFunc( GL_ALWAYS, 1, 1 );
glStencilOp( GL_KEEP, GL_KEEP, GL_REPLACE );
}
FGTileMgr::set_tile_filter( false );
sgSetModelFilter( true );
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
} else {
FGTileMgr::set_tile_filter( true );
sgSetModelFilter( true );
globals->get_aircraft_model()->select( false );
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
} }
} glDepthMask( GL_TRUE );
// This is a bit kludgy. Every 200 frames, do an extra if ( multi_pass_clouds ) {
// traversal of the scene graph without drawing anything, but // Draw the objects except the aircraft
// with the field-of-view set to 360x360 degrees. This // and update the stencil buffer with 1
// ensures that out-of-range random objects that are not in glEnable( GL_STENCIL_TEST );
// the current view frustum will still be freed properly. glStencilFunc( GL_ALWAYS, 1, 1 );
static int counter = 0; glStencilOp( GL_KEEP, GL_KEEP, GL_REPLACE );
counter++; }
if (counter >= 200) { FGTileMgr::set_tile_filter( false );
sgFrustum f; sgSetModelFilter( true );
f.setFOV(360, 360); ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
// No need to put the near plane too close; } else {
// this way, at least the aircraft can be
// culled.
f.setNearFar(1000, 1000000);
sgMat4 m;
ssgGetModelviewMatrix(m);
FGTileMgr::set_tile_filter( true ); FGTileMgr::set_tile_filter( true );
sgSetModelFilter( true ); sgSetModelFilter( true );
globals->get_scenery()->get_scene_graph()->cull(&f, m, true); globals->get_aircraft_model()->select( false );
counter = 0; ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
} }
}
// change state for lighting here // This is a bit kludgy. Every 200 frames, do an extra
// traversal of the scene graph without drawing anything, but
// with the field-of-view set to 360x360 degrees. This
// ensures that out-of-range random objects that are not in
// the current view frustum will still be freed properly.
static int counter = 0;
counter++;
if (counter >= 200) {
sgFrustum f;
f.setFOV(360, 360);
// No need to put the near plane too close;
// this way, at least the aircraft can be
// culled.
f.setNearFar(1000, 1000000);
sgMat4 m;
ssgGetModelviewMatrix(m);
FGTileMgr::set_tile_filter( true );
sgSetModelFilter( true );
globals->get_scenery()->get_scene_graph()->cull(&f, m, true);
counter = 0;
}
// draw runway lighting // change state for lighting here
glFogf (GL_FOG_DENSITY, rwy_exp2_punch_through);
// CLO - 02/25/2005 - DO WE NEED THIS extra fgSetNearFar()? // draw runway lighting
// fgSetNearFar( scene_nearplane, scene_farplane ); glFogf (GL_FOG_DENSITY, rwy_exp2_punch_through);
if ( enhanced_lighting ) { // CLO - 02/25/2005 - DO WE NEED THIS extra fgSetNearFar()?
// fgSetNearFar( scene_nearplane, scene_farplane );
if ( enhanced_lighting ) {
// Enable states for drawing points with GL_extension
glEnable(GL_POINT_SMOOTH);
if ( distance_attenuation && glPointParameterIsSupported )
{
// Enable states for drawing points with GL_extension // Enable states for drawing points with GL_extension
glEnable(GL_POINT_SMOOTH); glEnable(GL_POINT_SMOOTH);
if ( distance_attenuation && glPointParameterIsSupported ) float quadratic[3] = {1.0, 0.001, 0.0000001};
{ // makes the points fade as they move away
// Enable states for drawing points with GL_extension glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT, quadratic);
glEnable(GL_POINT_SMOOTH); glPointParameterfPtr(GL_POINT_SIZE_MIN_EXT, 1.0);
float quadratic[3] = {1.0, 0.001, 0.0000001};
// makes the points fade as they move away
glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT, quadratic);
glPointParameterfPtr(GL_POINT_SIZE_MIN_EXT, 1.0);
}
glPointSize(4.0);
// blending function for runway lights
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;
} }
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glPointSize(4.0);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glPolygonMode(GL_FRONT, GL_POINT);
// draw runway lighting // blending function for runway lights
if ( draw_otw ) { glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;
ssgCullAndDraw( globals->get_scenery()->get_vasi_lights_root() ); }
ssgCullAndDraw( globals->get_scenery()->get_rwy_lights_root() );
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glPolygonMode(GL_FRONT, GL_POINT);
// draw runway lighting
if ( draw_otw ) {
ssgCullAndDraw( globals->get_scenery()->get_vasi_lights_root() );
ssgCullAndDraw( globals->get_scenery()->get_rwy_lights_root() );
}
// change punch through and then draw taxi lighting
glFogf ( GL_FOG_DENSITY, fog_exp2_density );
// sgVec3 taxi_fog;
// sgSetVec3( taxi_fog, 0.0, 0.0, 0.0 );
// glFogfv ( GL_FOG_COLOR, taxi_fog );
if ( draw_otw ) {
ssgCullAndDraw( globals->get_scenery()->get_taxi_lights_root() );
}
// clean up lighting
glPolygonMode(GL_FRONT, GL_FILL);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
//static int _frame_count = 0;
//if (_frame_count % 30 == 0) {
// printf("SSG: %s\n", ssgShowStats());
//}
//else {
// ssgShowStats();
//}
//_frame_count++;
if ( enhanced_lighting ) {
if ( distance_attenuation && glPointParameterIsSupported ) {
glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT,
default_attenuation);
} }
// change punch through and then draw taxi lighting glPointSize(1.0);
glFogf ( GL_FOG_DENSITY, fog_exp2_density ); glDisable(GL_POINT_SMOOTH);
// sgVec3 taxi_fog; }
// sgSetVec3( taxi_fog, 0.0, 0.0, 0.0 );
// glFogfv ( GL_FOG_COLOR, taxi_fog );
if ( draw_otw ) {
ssgCullAndDraw( globals->get_scenery()->get_taxi_lights_root() );
}
// clean up lighting // draw ground lighting
glPolygonMode(GL_FRONT, GL_FILL); glFogf (GL_FOG_DENSITY, ground_exp2_punch_through);
glDisable(GL_TEXTURE_GEN_S); if ( draw_otw ) {
glDisable(GL_TEXTURE_GEN_T); ssgCullAndDraw( globals->get_scenery()->get_gnd_lights_root() );
}
//static int _frame_count = 0; if ( draw_otw && fgGetBool("/sim/rendering/clouds3d") ) {
//if (_frame_count % 30 == 0) { glDisable( GL_FOG );
// printf("SSG: %s\n", ssgShowStats()); glDisable( GL_LIGHTING );
//} // cout << "drawing new clouds" << endl;
//else {
// ssgShowStats();
//}
//_frame_count++;
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ;
if ( enhanced_lighting ) { /*
if ( distance_attenuation && glPointParameterIsSupported ) { glEnable( GL_TEXTURE_2D );
glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT, glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
default_attenuation); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPointSize(1.0); */
glDisable(GL_POINT_SMOOTH);
}
// draw ground lighting
glFogf (GL_FOG_DENSITY, ground_exp2_punch_through);
if ( draw_otw ) {
ssgCullAndDraw( globals->get_scenery()->get_gnd_lights_root() );
}
if ( draw_otw && fgGetBool("/sim/rendering/clouds3d") ) {
glDisable( GL_FOG );
glDisable( GL_LIGHTING );
// cout << "drawing new clouds" << endl;
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ;
/*
glEnable( GL_TEXTURE_2D );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
*/
#ifdef FG_USE_CLOUDS_3D #ifdef FG_USE_CLOUDS_3D
sgClouds3d->Draw((sgVec4 *)current__view->get_VIEW()); sgClouds3d->Draw((sgVec4 *)current__view->get_VIEW());
#endif #endif
glEnable( GL_FOG );
glEnable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
}
if ( draw_otw && draw_clouds ) {
if ( multi_pass_clouds ) {
// Disable depth buffer update, draw the clouds where the
// objects overwrite the already drawn clouds, by testing
// the stencil buffer against 1
glDepthMask( GL_FALSE );
glStencilFunc( GL_EQUAL, 1, 1 );
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
thesky->drawUpperClouds();
thesky->drawLowerClouds();
glDepthMask( GL_TRUE );
glDisable( GL_STENCIL_TEST );
} else {
glDepthMask( GL_FALSE );
thesky->drawLowerClouds();
glDepthMask( GL_TRUE );
}
}
if ( draw_otw ) {
FGTileMgr::set_tile_filter( false );
sgSetModelFilter( false );
globals->get_aircraft_model()->select( true );
globals->get_model_mgr()->draw();
globals->get_aircraft_model()->draw();
// If the view is internal, the previous line draw the
// cockpit with modified near/far clip planes and deselect
// the aircraft in the global scenegraph
// Otherwise, it just enables the aircraft: The scenegraph
// must be drawn again to see the plane.
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
FGTileMgr::set_tile_filter( true );
sgSetModelFilter( true );
globals->get_aircraft_model()->select( true );
}
// display HUD && Panel
glDisable( GL_FOG );
glDisable( GL_DEPTH_TEST );
// glDisable( GL_CULL_FACE );
// glDisable( GL_TEXTURE_2D );
// update the controls subsystem
globals->get_controls()->update(delta_time_sec);
hud_and_panel->apply();
fgCockpitUpdate();
// Use the hud_and_panel ssgSimpleState for rendering the ATC output
// This only works properly if called before the panel call
if((fgGetBool("/sim/ATC/enabled")) || (fgGetBool("/sim/ai-traffic/enabled")))
globals->get_ATC_display()->update(delta_time_sec);
// update the panel subsystem
if ( globals->get_current_panel() != NULL ) {
globals->get_current_panel()->update(delta_time_sec);
}
fgUpdate3DPanels();
// We can do translucent menus, so why not. :-)
menus->apply();
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
puDisplay();
// glDisable ( GL_BLEND ) ;
glEnable( GL_DEPTH_TEST );
glEnable( GL_FOG ); glEnable( GL_FOG );
glEnable( GL_LIGHTING );
glEnable( GL_DEPTH_TEST );
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
}
// Fade out the splash screen over the first three seconds. if ( draw_otw && draw_clouds ) {
double t = globals->get_sim_time_sec(); if ( multi_pass_clouds ) {
if ( t <= 1.0 ) { // Disable depth buffer update, draw the clouds where the
fgSplashUpdate(0.0, 1.0); // objects overwrite the already drawn clouds, by testing
} else if ( t <= 3.0) { // the stencil buffer against 1
fgSplashUpdate(0.0, (3.0 - t) / 2.0); glDepthMask( GL_FALSE );
glStencilFunc( GL_EQUAL, 1, 1 );
glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
thesky->drawUpperClouds();
thesky->drawLowerClouds();
glDepthMask( GL_TRUE );
glDisable( GL_STENCIL_TEST );
} else {
glDepthMask( GL_FALSE );
thesky->drawLowerClouds();
glDepthMask( GL_TRUE );
} }
} }
if ( draw_otw ) {
FGTileMgr::set_tile_filter( false );
sgSetModelFilter( false );
globals->get_aircraft_model()->select( true );
globals->get_model_mgr()->draw();
globals->get_aircraft_model()->draw();
// If the view is internal, the previous line draw the
// cockpit with modified near/far clip planes and deselect
// the aircraft in the global scenegraph
// Otherwise, it just enables the aircraft: The scenegraph
// must be drawn again to see the plane.
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
FGTileMgr::set_tile_filter( true );
sgSetModelFilter( true );
globals->get_aircraft_model()->select( true );
}
// display HUD && Panel
glDisable( GL_FOG );
glDisable( GL_DEPTH_TEST );
// glDisable( GL_CULL_FACE );
// glDisable( GL_TEXTURE_2D );
// update the controls subsystem
globals->get_controls()->update(delta_time_sec);
hud_and_panel->apply();
fgCockpitUpdate();
// Use the hud_and_panel ssgSimpleState for rendering the ATC output
// This only works properly if called before the panel call
if((fgGetBool("/sim/ATC/enabled")) || (fgGetBool("/sim/ai-traffic/enabled")))
globals->get_ATC_display()->update(delta_time_sec);
// update the panel subsystem
if ( globals->get_current_panel() != NULL ) {
globals->get_current_panel()->update(delta_time_sec);
}
fgUpdate3DPanels();
// We can do translucent menus, so why not. :-)
menus->apply();
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
puDisplay();
// glDisable ( GL_BLEND ) ;
glEnable( GL_DEPTH_TEST );
glEnable( GL_FOG );
// Fade out the splash screen over the first three seconds.
double t = globals->get_sim_time_sec();
if (t <= 2.5)
fgSplashUpdate((2.5 - t) / 2.5);
} }

29
src/Main/splash.cxx
View file

@ -57,6 +57,9 @@ static SGTexture splash;
// Initialize the splash screen // Initialize the splash screen
void fgSplashInit ( const char *splash_texture ) { void fgSplashInit ( const char *splash_texture ) {
if (!fgGetBool("/sim/startup/splash-screen"))
return;
SG_LOG( SG_GENERAL, SG_INFO, "Initializing splash screen" ); SG_LOG( SG_GENERAL, SG_INFO, "Initializing splash screen" );
splash.bind(); splash.bind();
@ -94,8 +97,8 @@ void fgSplashInit ( const char *splash_texture ) {
} }
// Update the splash screen with progress specified from 0.0 to 1.0 // Update the splash screen with alpha specified from 0.0 to 1.0
void fgSplashUpdate ( double progress, float alpha ) { void fgSplashUpdate ( float alpha ) {
int xmin, ymin, xmax, ymax; int xmin, ymin, xmax, ymax;
int xsize = 512; int xsize = 512;
int ysize = 512; int ysize = 512;
@ -133,17 +136,19 @@ void fgSplashUpdate ( double progress, float alpha ) {
glEnd(); glEnd();
// now draw the logo // now draw the logo
glEnable(GL_TEXTURE_2D); if (fgGetBool("/sim/startup/splash-screen") && splash.usable()) {
splash.bind(); glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); splash.bind();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f( 1.0, 1.0, 1.0, alpha ); glColor4f( 1.0, 1.0, 1.0, alpha );
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glTexCoord2f(0.0, 0.0); glVertex2f(xmin, ymin); glTexCoord2f(0.0, 0.0); glVertex2f(xmin, ymin);
glTexCoord2f(1.0, 0.0); glVertex2f(xmax, ymin); glTexCoord2f(1.0, 0.0); glVertex2f(xmax, ymin);
glTexCoord2f(1.0, 1.0); glVertex2f(xmax, ymax); glTexCoord2f(1.0, 1.0); glVertex2f(xmax, ymax);
glTexCoord2f(0.0, 1.0); glVertex2f(xmin, ymax); glTexCoord2f(0.0, 1.0); glVertex2f(xmin, ymax);
glEnd(); glEnd();
}
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);

4
src/Main/splash.hxx
View file

@ -34,8 +34,8 @@
// Initialize the splash screen // Initialize the splash screen
void fgSplashInit ( const char *splash_texture ); void fgSplashInit ( const char *splash_texture );
// Update the splash screen with progress specified from 0.0 to 1.0 // Update the splash screen with alpha specified from 0.0 to 1.0
void fgSplashUpdate ( double progress, float alpha ); void fgSplashUpdate ( float alpha );
#endif // _SPLASH_HXX #endif // _SPLASH_HXX