fly/flightgear
1
0
Fork 0
Code Activity

Eliminated current_input and added FGInput to the subsystems managed

Browse source 
by FGSubsystemMgr.
This commit is contained in:
david 2002-10-04 13:20:53 +00:00
parent 598db3d528
commit 29eb5f7f5d
4 changed files with 254 additions and 233 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
src/Input/input.cxx
View file

@ -69,9 +69,12 @@ SG_USING_STD(vector);
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Local data structures. // Local variables.
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
static FGInput * default_input = 0;
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Implementation of FGBinding. // Implementation of FGBinding.
@ -173,17 +176,17 @@ FGBinding::fire (double setting) const
// From main.cxx // From main.cxx
extern void fgReshape( int width, int height ); extern void fgReshape( int width, int height );
FGInput current_input;
FGInput::FGInput () FGInput::FGInput ()
{ {
// no op if (default_input == 0)
default_input = this;
} }
FGInput::~FGInput () FGInput::~FGInput ()
{ {
// no op if (default_input == this)
default_input = 0;
} }
void void
@ -222,6 +225,15 @@ FGInput::update (double dt)
_update_mouse(); _update_mouse();
} }
void
FGInput::makeDefault (bool status)
{
if (status)
default_input = this;
else if (default_input == this)
default_input = 0;
}
void void
FGInput::doKey (int k, int modifiers, int x, int y) FGInput::doKey (int k, int modifiers, int x, int y)
{ {
@ -1024,40 +1036,48 @@ void
GLUTkey(unsigned char k, int x, int y) GLUTkey(unsigned char k, int x, int y)
{ {
// Give PUI a chance to grab it first. // Give PUI a chance to grab it first.
if (!puKeyboard(k, PU_DOWN)) if (!puKeyboard(k, PU_DOWN)) {
current_input.doKey(k, get_mods(), x, y); if (default_input != 0)
default_input->doKey(k, get_mods(), x, y);
}
} }
void void
GLUTkeyup(unsigned char k, int x, int y) GLUTkeyup(unsigned char k, int x, int y)
{ {
current_input.doKey(k, get_mods()|FGInput::FG_MOD_UP, x, y); if (default_input != 0)
default_input->doKey(k, get_mods()|FGInput::FG_MOD_UP, x, y);
} }
void void
GLUTspecialkey(int k, int x, int y) GLUTspecialkey(int k, int x, int y)
{ {
// Give PUI a chance to grab it first. // Give PUI a chance to grab it first.
if (!puKeyboard(k + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN)) if (!puKeyboard(k + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN)) {
current_input.doKey(k + 256, get_mods(), x, y); if (default_input != 0)
default_input->doKey(k + 256, get_mods(), x, y);
}
} }
void void
GLUTspecialkeyup(int k, int x, int y) GLUTspecialkeyup(int k, int x, int y)
{ {
current_input.doKey(k + 256, get_mods()|FGInput::FG_MOD_UP, x, y); if (default_input != 0)
default_input->doKey(k + 256, get_mods()|FGInput::FG_MOD_UP, x, y);
} }
void void
GLUTmouse (int button, int updown, int x, int y) GLUTmouse (int button, int updown, int x, int y)
{ {
current_input.doMouseClick(button, updown, x, y); if (default_input != 0)
default_input->doMouseClick(button, updown, x, y);
} }
void void
GLUTmotion (int x, int y) GLUTmotion (int x, int y)
{ {
current_input.doMouseMotion(x, y); if (default_input != 0)
default_input->doMouseMotion(x, y);
} }
// end of input.cxx // end of input.cxx

15
src/Input/input.hxx
View file

@ -194,6 +194,18 @@ public:
virtual void update (double dt); virtual void update (double dt);
/**
* Control whether this is the default module to receive events.
*
* The first input module created will set itself as the default
* automatically.
*
* @param status true if this should be the default module for
* events, false otherwise.
*/
virtual void makeDefault (bool status = true);
/** /**
* Handle a single keystroke. * Handle a single keystroke.
* *
@ -398,9 +410,6 @@ private:
}; };
extern FGInput current_input;
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// GLUT callbacks. // GLUT callbacks.

417
src/Main/fg_init.cxx
View file

@ -39,11 +39,11 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> // strcmp() #include <string.h> // strcmp()
#if defined( unix ) || defined( __CYGWIN__ ) #if defined( unix ) || defined( __CYGWIN__ )
# include <unistd.h> // for gethostname() # include <unistd.h> // for gethostname()
#endif #endif
// work around a stdc++ lib bug in some versions of linux, but doesn't // work around a stdc++ lib bug in some versions of linux, but doesn't
@ -152,35 +152,35 @@ bool fgInitFGRoot ( int argc, char **argv ) {
#if defined( unix ) || defined( __CYGWIN__ ) #if defined( unix ) || defined( __CYGWIN__ )
// Next check home directory for .fgfsrc.hostname file // Next check home directory for .fgfsrc.hostname file
if ( root.empty() ) { if ( root.empty() ) {
envp = ::getenv( "HOME" ); envp = ::getenv( "HOME" );
if ( envp != NULL ) { if ( envp != NULL ) {
SGPath config( envp ); SGPath config( envp );
config.append( ".fgfsrc" ); config.append( ".fgfsrc" );
char name[256]; char name[256];
gethostname( name, 256 ); gethostname( name, 256 );
config.concat( "." ); config.concat( "." );
config.concat( name ); config.concat( name );
root = fgScanForRoot(config.str()); root = fgScanForRoot(config.str());
} }
} }
#endif #endif
// Next check home directory for .fgfsrc file // Next check home directory for .fgfsrc file
if ( root.empty() ) { if ( root.empty() ) {
envp = ::getenv( "HOME" ); envp = ::getenv( "HOME" );
if ( envp != NULL ) { if ( envp != NULL ) {
SGPath config( envp ); SGPath config( envp );
config.append( ".fgfsrc" ); config.append( ".fgfsrc" );
root = fgScanForRoot(config.str()); root = fgScanForRoot(config.str());
} }
} }
// Next check if fg-root is set as an env variable // Next check if fg-root is set as an env variable
if ( root.empty() ) { if ( root.empty() ) {
envp = ::getenv( "FG_ROOT" ); envp = ::getenv( "FG_ROOT" );
if ( envp != NULL ) { if ( envp != NULL ) {
root = envp; root = envp;
} }
} }
// Otherwise, default to a random compiled-in location if we can't // Otherwise, default to a random compiled-in location if we can't
@ -189,11 +189,11 @@ bool fgInitFGRoot ( int argc, char **argv ) {
#if defined( __CYGWIN__ ) #if defined( __CYGWIN__ )
root = "/FlightGear"; root = "/FlightGear";
#elif defined( WIN32 ) #elif defined( WIN32 )
root = "\\FlightGear"; root = "\\FlightGear";
#elif defined( macintosh ) #elif defined( macintosh )
root = ""; root = "";
#else #else
root = PKGLIBDIR; root = PKGLIBDIR;
#endif #endif
} }
@ -211,14 +211,14 @@ string fgBasePackageVersion() {
sg_gzifstream in( base_path.str() ); sg_gzifstream in( base_path.str() );
if ( !in.is_open() ) { if ( !in.is_open() ) {
SGPath old_path( globals->get_fg_root() ); SGPath old_path( globals->get_fg_root() );
old_path.append( "Thanks" ); old_path.append( "Thanks" );
sg_gzifstream old( old_path.str() ); sg_gzifstream old( old_path.str() );
if ( !old.is_open() ) { if ( !old.is_open() ) {
return "[none]"; return "[none]";
} else { } else {
return "[old version]"; return "[old version]";
} }
} }
string version; string version;
@ -231,7 +231,7 @@ string fgBasePackageVersion() {
// Read in configuration (file and command line) // Read in configuration (file and command line)
bool fgInitConfig ( int argc, char **argv ) { bool fgInitConfig ( int argc, char **argv ) {
// First, set some sane default values // First, set some sane default values
fgSetDefaults(); fgSetDefaults();
// Read global preferences from $FG_ROOT/preferences.xml // Read global preferences from $FG_ROOT/preferences.xml
@ -249,14 +249,14 @@ bool fgInitConfig ( int argc, char **argv ) {
aircraft_path.append(aircraft); aircraft_path.append(aircraft);
aircraft_path.concat("-set.xml"); aircraft_path.concat("-set.xml");
SG_LOG(SG_INPUT, SG_INFO, "Reading default aircraft: " << aircraft SG_LOG(SG_INPUT, SG_INFO, "Reading default aircraft: " << aircraft
<< " from " << aircraft_path.str()); << " from " << aircraft_path.str());
try { try {
readProperties(aircraft_path.str(), globals->get_props()); readProperties(aircraft_path.str(), globals->get_props());
} catch (const sg_exception &e) { } catch (const sg_exception &e) {
string message = "Error reading default aircraft: "; string message = "Error reading default aircraft: ";
message += e.getFormattedMessage(); message += e.getFormattedMessage();
SG_LOG(SG_INPUT, SG_ALERT, message); SG_LOG(SG_INPUT, SG_ALERT, message);
exit(2); exit(2);
} }
} else { } else {
SG_LOG(SG_INPUT, SG_ALERT, "No default aircraft specified"); SG_LOG(SG_INPUT, SG_ALERT, "No default aircraft specified");
@ -282,9 +282,9 @@ bool fgInitConfig ( int argc, char **argv ) {
// Check for ~/.fgfsrc // Check for ~/.fgfsrc
char* envp = ::getenv( "HOME" ); char* envp = ::getenv( "HOME" );
if ( envp != NULL ) { if ( envp != NULL ) {
config.set( envp ); config.set( envp );
config.append( ".fgfsrc" ); config.append( ".fgfsrc" );
fgParseOptions(config.str()); fgParseOptions(config.str());
} }
#if defined( unix ) || defined( __CYGWIN__ ) #if defined( unix ) || defined( __CYGWIN__ )
@ -306,26 +306,26 @@ bool fgInitConfig ( int argc, char **argv ) {
// find basic airport location info from airport database // find basic airport location info from airport database
bool fgFindAirportID( const string& id, FGAirport *a ) { bool fgFindAirportID( const string& id, FGAirport *a ) {
if ( id.length() ) { if ( id.length() ) {
SGPath path( globals->get_fg_root() ); SGPath path( globals->get_fg_root() );
path.append( "Airports" ); path.append( "Airports" );
path.append( "simple.mk4" ); path.append( "simple.mk4" );
FGAirports airports( path.c_str() ); FGAirports airports( path.c_str() );
SG_LOG( SG_GENERAL, SG_INFO, "Searching for airport code = " << id ); SG_LOG( SG_GENERAL, SG_INFO, "Searching for airport code = " << id );
if ( ! airports.search( id, a ) ) { if ( ! airports.search( id, a ) ) {
SG_LOG( SG_GENERAL, SG_ALERT, SG_LOG( SG_GENERAL, SG_ALERT,
"Failed to find " << id << " in " << path.str() ); "Failed to find " << id << " in " << path.str() );
return false; return false;
} }
} else { } else {
return false; return false;
} }
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is (" "Position for " << id << " is ("
<< a->longitude << ", " << a->longitude << ", "
<< a->latitude << ")" ); << a->latitude << ")" );
return true; return true;
} }
@ -337,19 +337,19 @@ bool fgSetPosFromAirportID( const string& id ) {
// double lon, lat; // double lon, lat;
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"Attempting to set starting position from airport code " << id ); "Attempting to set starting position from airport code " << id );
if ( fgFindAirportID( id, &a ) ) { if ( fgFindAirportID( id, &a ) ) {
fgSetDouble("/position/longitude-deg", a.longitude ); fgSetDouble("/position/longitude-deg", a.longitude );
fgSetDouble("/position/latitude-deg", a.latitude ); fgSetDouble("/position/latitude-deg", a.latitude );
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is (" "Position for " << id << " is ("
<< a.longitude << ", " << a.longitude << ", "
<< a.latitude << ")" ); << a.latitude << ")" );
return true; return true;
} else { } else {
return false; return false;
} }
} }
@ -367,12 +367,12 @@ bool fgSetTowerPosFromAirportID( const string& id, double hdg ) {
float fudge_lat = .003f - fudge_lon; float fudge_lat = .003f - fudge_lon;
if ( fgFindAirportID( id, &a ) ) { if ( fgFindAirportID( id, &a ) ) {
fgSetDouble("/sim/tower/longitude-deg", a.longitude + fudge_lon); fgSetDouble("/sim/tower/longitude-deg", a.longitude + fudge_lon);
fgSetDouble("/sim/tower/latitude-deg", a.latitude + fudge_lat); fgSetDouble("/sim/tower/latitude-deg", a.latitude + fudge_lat);
fgSetDouble("/sim/tower/altitude-ft", a.elevation + towerheight); fgSetDouble("/sim/tower/altitude-ft", a.elevation + towerheight);
return true; return true;
} else { } else {
return false; return false;
} }
} }
@ -452,7 +452,7 @@ bool fgSetPosFromAirportIDandHdg( const string& id, double tgt_hdg ) {
<< " + " << found_dir ); << " + " << found_dir );
} else { } else {
return false; return false;
} }
double heading = found_r.heading + found_dir; double heading = found_r.heading + found_dir;
@ -463,37 +463,37 @@ bool fgSetPosFromAirportIDandHdg( const string& id, double tgt_hdg ) {
while ( azimuth >= 360.0 ) { azimuth -= 360.0; } while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"runway = " << found_r.lon << ", " << found_r.lat "runway = " << found_r.lon << ", " << found_r.lat
<< " length = " << found_r.length * SG_FEET_TO_METER * 0.5 << " length = " << found_r.length * SG_FEET_TO_METER * 0.5
<< " heading = " << azimuth ); << " heading = " << azimuth );
geo_direct_wgs_84 ( 0, found_r.lat, found_r.lon, geo_direct_wgs_84 ( 0, found_r.lat, found_r.lon,
azimuth, found_r.length * SG_FEET_TO_METER * 0.5 - 5.0, azimuth, found_r.length * SG_FEET_TO_METER * 0.5 - 5.0,
&lat2, &lon2, &az2 ); &lat2, &lon2, &az2 );
if ( fabs( fgGetDouble("/sim/startup/offset-distance") ) > SG_EPSILON ) { if ( fabs( fgGetDouble("/sim/startup/offset-distance") ) > SG_EPSILON ) {
double olat, olon; double olat, olon;
double odist = fgGetDouble("/sim/startup/offset-distance"); double odist = fgGetDouble("/sim/startup/offset-distance");
odist *= SG_NM_TO_METER; odist *= SG_NM_TO_METER;
double oaz = azimuth; double oaz = azimuth;
if ( fabs(fgGetDouble("/sim/startup/offset-azimuth")) > SG_EPSILON ) { if ( fabs(fgGetDouble("/sim/startup/offset-azimuth")) > SG_EPSILON ) {
oaz = fgGetDouble("/sim/startup/offset-azimuth") + 180; oaz = fgGetDouble("/sim/startup/offset-azimuth") + 180;
} }
while ( oaz >= 360.0 ) { oaz -= 360.0; } while ( oaz >= 360.0 ) { oaz -= 360.0; }
geo_direct_wgs_84 ( 0, lat2, lon2, oaz, odist, &olat, &olon, &az2 ); geo_direct_wgs_84 ( 0, lat2, lon2, oaz, odist, &olat, &olon, &az2 );
lat2=olat; lat2=olat;
lon2=olon; lon2=olon;
} }
fgSetDouble("/position/longitude-deg", lon2 ); fgSetDouble("/position/longitude-deg", lon2 );
fgSetDouble("/position/latitude-deg", lat2 ); fgSetDouble("/position/latitude-deg", lat2 );
fgSetDouble("/orientation/heading-deg", heading ); fgSetDouble("/orientation/heading-deg", heading );
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is (" "Position for " << id << " is ("
<< lon2 << ", " << lon2 << ", "
<< lat2 << ") new heading is " << lat2 << ") new heading is "
<< heading ); << heading );
return true; return true;
} }
@ -507,25 +507,25 @@ void fgSetPosFromGlideSlope(void) {
//if glideslope and offset-distance are set and altitude is //if glideslope and offset-distance are set and altitude is
//not, calculate the initial altitude //not, calculate the initial altitude
if( fabs(gs) > 0.01 && fabs(od) > 0.1 && alt < -9990 ) { if( fabs(gs) > 0.01 && fabs(od) > 0.1 && alt < -9990 ) {
od *= SG_NM_TO_METER * SG_METER_TO_FEET; od *= SG_NM_TO_METER * SG_METER_TO_FEET;
alt = fabs(od*tan(gs)); alt = fabs(od*tan(gs));
fgSetDouble("/position/altitude-ft",alt); fgSetDouble("/position/altitude-ft",alt);
fgSetBool("/sim/startup/onground", false); fgSetBool("/sim/startup/onground", false);
SG_LOG(SG_GENERAL,SG_INFO, "Calculated altitude as: " << alt << " ft"); SG_LOG(SG_GENERAL,SG_INFO, "Calculated altitude as: " << alt << " ft");
} else if( fabs(gs) > 0.01 && alt > 0 && fabs(od) < 0.1) { } else if( fabs(gs) > 0.01 && alt > 0 && fabs(od) < 0.1) {
od = alt/tan(gs); od = alt/tan(gs);
od *= -1*SG_FEET_TO_METER * SG_METER_TO_NM; od *= -1*SG_FEET_TO_METER * SG_METER_TO_NM;
fgSetDouble("/sim/startup/offset-distance",od); fgSetDouble("/sim/startup/offset-distance",od);
SG_LOG(SG_GENERAL,SG_INFO, "Calculated offset distance as: " SG_LOG(SG_GENERAL,SG_INFO, "Calculated offset distance as: "
<< od << " nm"); << od << " nm");
} else if( fabs(gs) > 0.01 ) { } else if( fabs(gs) > 0.01 ) {
SG_LOG(SG_GENERAL,SG_ALERT, "Glideslope given but not altitude" SG_LOG(SG_GENERAL,SG_ALERT, "Glideslope given but not altitude"
<< " or offset-distance. Resetting" << " or offset-distance. Resetting"
<< " glideslope to zero" ); << " glideslope to zero" );
fgSetDouble("/velocities/glideslope",0); fgSetDouble("/velocities/glideslope",0);
} }
} }
// General house keeping initializations // General house keeping initializations
bool fgInitGeneral( void ) { bool fgInitGeneral( void ) {
@ -540,11 +540,11 @@ bool fgInitGeneral( void ) {
root = globals->get_fg_root(); root = globals->get_fg_root();
if ( ! root.length() ) { if ( ! root.length() ) {
// No root path set? Then bail ... // No root path set? Then bail ...
SG_LOG( SG_GENERAL, SG_ALERT, SG_LOG( SG_GENERAL, SG_ALERT,
"Cannot continue without a path to the base package " "Cannot continue without a path to the base package "
<< "being defined." ); << "being defined." );
exit(-1); exit(-1);
} }
SG_LOG( SG_GENERAL, SG_INFO, "FG_ROOT = " << '"' << root << '"' << endl ); SG_LOG( SG_GENERAL, SG_INFO, "FG_ROOT = " << '"' << root << '"' << endl );
@ -552,14 +552,14 @@ bool fgInitGeneral( void ) {
// initialize full screen flag // initialize full screen flag
globals->set_fullscreen(false); globals->set_fullscreen(false);
if ( strstr ( general.get_glRenderer(), "Glide" ) ) { if ( strstr ( general.get_glRenderer(), "Glide" ) ) {
// Test for the MESA_GLX_FX env variable // Test for the MESA_GLX_FX env variable
if ( (mesa_win_state = getenv( "MESA_GLX_FX" )) != NULL) { if ( (mesa_win_state = getenv( "MESA_GLX_FX" )) != NULL) {
// test if we are fullscreen mesa/glide // test if we are fullscreen mesa/glide
if ( (mesa_win_state[0] == 'f') || if ( (mesa_win_state[0] == 'f') ||
(mesa_win_state[0] == 'F') ) { (mesa_win_state[0] == 'F') ) {
globals->set_fullscreen(true); globals->set_fullscreen(true);
} }
} }
} }
#endif #endif
@ -583,23 +583,23 @@ void fgInitFDM() {
const string &model = fgGetString("/sim/flight-model"); const string &model = fgGetString("/sim/flight-model");
try { try {
if ( model == "larcsim" ) { if ( model == "larcsim" ) {
cur_fdm_state = new FGLaRCsim( dt ); cur_fdm_state = new FGLaRCsim( dt );
} else if ( model == "jsb" ) { } else if ( model == "jsb" ) {
cur_fdm_state = new FGJSBsim( dt ); cur_fdm_state = new FGJSBsim( dt );
} else if ( model == "ada" ) { } else if ( model == "ada" ) {
cur_fdm_state = new FGADA( dt ); cur_fdm_state = new FGADA( dt );
} else if ( model == "balloon" ) { } else if ( model == "balloon" ) {
cur_fdm_state = new FGBalloonSim( dt ); cur_fdm_state = new FGBalloonSim( dt );
} else if ( model == "magic" ) { } else if ( model == "magic" ) {
cur_fdm_state = new FGMagicCarpet( dt ); cur_fdm_state = new FGMagicCarpet( dt );
} else if ( model == "ufo" ) { } else if ( model == "ufo" ) {
cur_fdm_state = new FGUFO( dt ); cur_fdm_state = new FGUFO( dt );
} else if ( model == "external" ) { } else if ( model == "external" ) {
// external is a synonym for "--fdm=null" and is // external is a synonym for "--fdm=null" and is
// maintained here for backwards compatibility // maintained here for backwards compatibility
cur_fdm_state = new FGNullFDM( dt ); cur_fdm_state = new FGNullFDM( dt );
} else if ( model.find("network") == 0 ) { } else if ( model.find("network") == 0 ) {
string host = "localhost"; string host = "localhost";
int port1 = 5501; int port1 = 5501;
int port2 = 5502; int port2 = 5502;
@ -631,20 +631,20 @@ void fgInitFDM() {
port3 = atoi( net_options.substr(begin, end - begin).c_str() ); port3 = atoi( net_options.substr(begin, end - begin).c_str() );
begin = end + 1; begin = end + 1;
} }
cur_fdm_state = new FGExternalNet( dt, host, port1, port2, port3 ); cur_fdm_state = new FGExternalNet( dt, host, port1, port2, port3 );
} else if ( model == "null" ) { } else if ( model == "null" ) {
cur_fdm_state = new FGNullFDM( dt ); cur_fdm_state = new FGNullFDM( dt );
} else if ( model == "yasim" ) { } else if ( model == "yasim" ) {
cur_fdm_state = new YASim( dt ); cur_fdm_state = new YASim( dt );
} else { } else {
SG_LOG(SG_GENERAL, SG_ALERT, SG_LOG(SG_GENERAL, SG_ALERT,
"Unrecognized flight model '" << model "Unrecognized flight model '" << model
<< "', cannot init flight dynamics model."); << "', cannot init flight dynamics model.");
exit(-1); exit(-1);
} }
} catch ( ... ) { } catch ( ... ) {
SG_LOG(SG_GENERAL, SG_ALERT, "FlightGear aborting\n\n"); SG_LOG(SG_GENERAL, SG_ALERT, "FlightGear aborting\n\n");
exit(-1); exit(-1);
} }
} }
@ -675,11 +675,11 @@ void fgInitView() {
SGTime *fgInitTime() { SGTime *fgInitTime() {
// Initialize time // Initialize time
static const SGPropertyNode *longitude static const SGPropertyNode *longitude
= fgGetNode("/position/longitude-deg"); = fgGetNode("/position/longitude-deg");
static const SGPropertyNode *latitude static const SGPropertyNode *latitude
= fgGetNode("/position/latitude-deg"); = fgGetNode("/position/latitude-deg");
static const SGPropertyNode *cur_time_override static const SGPropertyNode *cur_time_override
= fgGetNode("/sim/time/cur-time-override", true); = fgGetNode("/sim/time/cur-time-override", true);
SGPath zone( globals->get_fg_root() ); SGPath zone( globals->get_fg_root() );
zone.append( "Timezone" ); zone.append( "Timezone" );
@ -738,11 +738,11 @@ SGTime *fgInitTime() {
// Returns non-zero if a problem encountered. // Returns non-zero if a problem encountered.
bool fgInitSubsystems( void ) { bool fgInitSubsystems( void ) {
static const SGPropertyNode *longitude static const SGPropertyNode *longitude
= fgGetNode("/position/longitude-deg"); = fgGetNode("/position/longitude-deg");
static const SGPropertyNode *latitude static const SGPropertyNode *latitude
= fgGetNode("/position/latitude-deg"); = fgGetNode("/position/latitude-deg");
static const SGPropertyNode *altitude static const SGPropertyNode *altitude
= fgGetNode("/position/altitude-ft"); = fgGetNode("/position/altitude-ft");
fgLIGHT *l = &cur_light_params; fgLIGHT *l = &cur_light_params;
@ -757,8 +757,8 @@ bool fgInitSubsystems( void ) {
SGPath mpath( globals->get_fg_root() ); SGPath mpath( globals->get_fg_root() );
mpath.append( "materials.xml" ); mpath.append( "materials.xml" );
if ( ! material_lib.load( mpath.str() ) ) { if ( ! material_lib.load( mpath.str() ) ) {
SG_LOG( SG_GENERAL, SG_ALERT, "Error loading material lib!" ); SG_LOG( SG_GENERAL, SG_ALERT, "Error loading material lib!" );
exit(-1); exit(-1);
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -769,8 +769,8 @@ bool fgInitSubsystems( void ) {
// Output event stats every 60 seconds // Output event stats every 60 seconds
global_events.Register( "FGEventMgr::print_stats()", global_events.Register( "FGEventMgr::print_stats()",
&global_events, &FGEventMgr::print_stats, &global_events, &FGEventMgr::print_stats,
60000 ); 60000 );
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -778,25 +778,25 @@ bool fgInitSubsystems( void ) {
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
if ( global_tile_mgr.init() ) { if ( global_tile_mgr.init() ) {
// Load the local scenery data // Load the local scenery data
double visibility_meters = fgGetDouble("/environment/visibility-m"); double visibility_meters = fgGetDouble("/environment/visibility-m");
global_tile_mgr.update( longitude->getDoubleValue(), global_tile_mgr.update( longitude->getDoubleValue(),
latitude->getDoubleValue(), latitude->getDoubleValue(),
visibility_meters ); visibility_meters );
} else { } else {
SG_LOG( SG_GENERAL, SG_ALERT, "Error in Tile Manager initialization!" ); SG_LOG( SG_GENERAL, SG_ALERT, "Error in Tile Manager initialization!" );
exit(-1); exit(-1);
} }
// cause refresh of viewer scenery timestamps every 15 seconds... // cause refresh of viewer scenery timestamps every 15 seconds...
global_events.Register( "FGTileMgr::refresh_view_timestamps()", global_events.Register( "FGTileMgr::refresh_view_timestamps()",
&global_tile_mgr, &FGTileMgr::refresh_view_timestamps, &global_tile_mgr, &FGTileMgr::refresh_view_timestamps,
15000 ); 15000 );
SG_LOG( SG_GENERAL, SG_DEBUG, SG_LOG( SG_GENERAL, SG_DEBUG,
"Current terrain elevation after tile mgr init " << "Current terrain elevation after tile mgr init " <<
globals->get_scenery()->get_cur_elev() ); globals->get_scenery()->get_cur_elev() );
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -804,7 +804,7 @@ bool fgInitSubsystems( void ) {
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
fgInitFDM(); fgInitFDM();
// allocates structures so must happen before any of the flight // allocates structures so must happen before any of the flight
// model or control parameters are set // model or control parameters are set
fgAircraftInit(); // In the future this might not be the case. fgAircraftInit(); // In the future this might not be the case.
@ -827,9 +827,9 @@ bool fgInitSubsystems( void ) {
fgUpdateSunPos(); fgUpdateSunPos();
fgUpdateMoonPos(); fgUpdateMoonPos();
global_events.Register( "fgUpdateSunPos()", &fgUpdateSunPos, global_events.Register( "fgUpdateSunPos()", &fgUpdateSunPos,
60000); 60000);
global_events.Register( "fgUpdateMoonPos()", &fgUpdateMoonPos, global_events.Register( "fgUpdateMoonPos()", &fgUpdateMoonPos,
60000); 60000);
// Initialize Lighting interpolation tables // Initialize Lighting interpolation tables
l->Init(); l->Init();
@ -838,8 +838,8 @@ bool fgInitSubsystems( void ) {
l->Update(); l->Update();
// update the lighting parameters (based on sun angle) // update the lighting parameters (based on sun angle)
global_events.Register( "fgLight::Update()", global_events.Register( "fgLight::Update()",
&cur_light_params, &fgLIGHT::Update, &cur_light_params, &fgLIGHT::Update,
30000 ); 30000 );
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -857,7 +857,7 @@ bool fgInitSubsystems( void ) {
// update the current timezone each 30 minutes // update the current timezone each 30 minutes
global_events.Register( "fgUpdateLocalTime()", &fgUpdateLocalTime, global_events.Register( "fgUpdateLocalTime()", &fgUpdateLocalTime,
30*60*1000 ); 30*60*1000 );
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -870,8 +870,8 @@ bool fgInitSubsystems( void ) {
SG_LOG(SG_GENERAL, SG_INFO, "Creating LocalWeatherDatabase"); SG_LOG(SG_GENERAL, SG_INFO, "Creating LocalWeatherDatabase");
sgVec3 position; sgVec3 position;
sgSetVec3( position, current_aircraft.fdm_state->get_Latitude(), sgSetVec3( position, current_aircraft.fdm_state->get_Latitude(),
current_aircraft.fdm_state->get_Longitude(), current_aircraft.fdm_state->get_Longitude(),
current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER ); current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER );
double init_vis = fgGetDouble("/environment/visibility-m"); double init_vis = fgGetDouble("/environment/visibility-m");
FGLocalWeatherDatabase::DatabaseWorkingType working_type; FGLocalWeatherDatabase::DatabaseWorkingType working_type;
@ -885,14 +885,14 @@ bool fgInitSubsystems( void ) {
if ( init_vis > 0 ) { if ( init_vis > 0 ) {
FGLocalWeatherDatabase::theFGLocalWeatherDatabase = FGLocalWeatherDatabase::theFGLocalWeatherDatabase =
new FGLocalWeatherDatabase( position, new FGLocalWeatherDatabase( position,
globals->get_fg_root(), globals->get_fg_root(),
working_type, working_type,
init_vis ); init_vis );
} else { } else {
FGLocalWeatherDatabase::theFGLocalWeatherDatabase = FGLocalWeatherDatabase::theFGLocalWeatherDatabase =
new FGLocalWeatherDatabase( position, new FGLocalWeatherDatabase( position,
globals->get_fg_root(), globals->get_fg_root(),
working_type ); working_type );
} }
@ -1039,8 +1039,8 @@ bool fgInitSubsystems( void ) {
// Initialize the radio stack subsystem. // Initialize the radio stack subsystem.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// A textbook example of how FGSubsystem // A textbook example of how FGSubsystem
// should work... // should work...
current_radiostack = new FGRadioStack; current_radiostack = new FGRadioStack;
current_radiostack->init(); current_radiostack->init();
current_radiostack->bind(); current_radiostack->bind();
@ -1051,10 +1051,10 @@ bool fgInitSubsystems( void ) {
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
if( fgCockpitInit( &current_aircraft )) { if( fgCockpitInit( &current_aircraft )) {
// Cockpit initialized ok. // Cockpit initialized ok.
} else { } else {
SG_LOG( SG_GENERAL, SG_ALERT, "Error in Cockpit initialization!" ); SG_LOG( SG_GENERAL, SG_ALERT, "Error in Cockpit initialization!" );
exit(-1); exit(-1);
} }
@ -1066,8 +1066,8 @@ bool fgInitSubsystems( void ) {
globals->get_autopilot()->init(); globals->get_autopilot()->init();
globals->get_autopilot()->bind(); globals->get_autopilot()->bind();
// FIXME: these should go in the // FIXME: these should go in the
// GUI initialization code, not here. // GUI initialization code, not here.
fgAPAdjustInit(); fgAPAdjustInit();
NewTgtAirportInit(); NewTgtAirportInit();
NewHeadingInit(); NewHeadingInit();
@ -1082,15 +1082,15 @@ bool fgInitSubsystems( void ) {
// Initialize the 2D panel. // Initialize the 2D panel.
string panel_path = fgGetString("/sim/panel/path", string panel_path = fgGetString("/sim/panel/path",
"Panels/Default/default.xml"); "Panels/Default/default.xml");
current_panel = fgReadPanel(panel_path); current_panel = fgReadPanel(panel_path);
if (current_panel == 0) { if (current_panel == 0) {
SG_LOG( SG_INPUT, SG_ALERT, SG_LOG( SG_INPUT, SG_ALERT,
"Error reading new panel from " << panel_path ); "Error reading new panel from " << panel_path );
} else { } else {
SG_LOG( SG_INPUT, SG_INFO, "Loaded new panel from " << panel_path ); SG_LOG( SG_INPUT, SG_INFO, "Loaded new panel from " << panel_path );
current_panel->init(); current_panel->init();
current_panel->bind(); current_panel->bind();
} }
@ -1121,8 +1121,9 @@ bool fgInitSubsystems( void ) {
// Initialize the input subsystem. // Initialize the input subsystem.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
current_input.init(); globals->get_subsystem_mgr()->add(FGSubsystemMgr::GENERAL,
current_input.bind(); "input",
new FGInput);
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -1139,8 +1140,8 @@ bool fgInitSubsystems( void ) {
SG_LOG( SG_GENERAL, SG_INFO, endl); SG_LOG( SG_GENERAL, SG_INFO, endl);
// Save the initial state for future // Save the initial state for future
// reference. // reference.
globals->saveInitialState(); globals->saveInitialState();
return true; return true;
@ -1150,21 +1151,21 @@ bool fgInitSubsystems( void ) {
void fgReInitSubsystems( void ) void fgReInitSubsystems( void )
{ {
static const SGPropertyNode *longitude static const SGPropertyNode *longitude
= fgGetNode("/position/longitude-deg"); = fgGetNode("/position/longitude-deg");
static const SGPropertyNode *latitude static const SGPropertyNode *latitude
= fgGetNode("/position/latitude-deg"); = fgGetNode("/position/latitude-deg");
static const SGPropertyNode *altitude static const SGPropertyNode *altitude
= fgGetNode("/position/altitude-ft"); = fgGetNode("/position/altitude-ft");
static const SGPropertyNode *master_freeze static const SGPropertyNode *master_freeze
= fgGetNode("/sim/freeze/master"); = fgGetNode("/sim/freeze/master");
SG_LOG( SG_GENERAL, SG_INFO, SG_LOG( SG_GENERAL, SG_INFO,
"fgReInitSubsystems(): /position/altitude = " "fgReInitSubsystems(): /position/altitude = "
<< altitude->getDoubleValue() ); << altitude->getDoubleValue() );
bool freeze = master_freeze->getBoolValue(); bool freeze = master_freeze->getBoolValue();
if ( !freeze ) { if ( !freeze ) {
fgSetBool("/sim/freeze/master", true); fgSetBool("/sim/freeze/master", true);
} }
// Initialize the Scenery Management subsystem // Initialize the Scenery Management subsystem
@ -1192,7 +1193,7 @@ void fgReInitSubsystems( void )
fgUpdateLocalTime(); fgUpdateLocalTime();
if ( !freeze ) { if ( !freeze ) {
fgSetBool("/sim/freeze/master", false); fgSetBool("/sim/freeze/master", false);
} }
} }

9
src/Main/main.cxx
View file

@ -126,8 +126,6 @@ SG_USING_STD(endl);
#include <Time/sunpos.hxx> #include <Time/sunpos.hxx>
#include <Time/tmp.hxx> #include <Time/tmp.hxx>
#include <Input/input.hxx>
// ADA // ADA
#include <simgear/misc/sgstream.hxx> #include <simgear/misc/sgstream.hxx>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
@ -796,9 +794,6 @@ void fgRenderFrame() {
// glDisable( GL_CULL_FACE ); // glDisable( GL_CULL_FACE );
// glDisable( GL_TEXTURE_2D ); // glDisable( GL_TEXTURE_2D );
// update the input subsystem
current_input.update(delta_time_sec);
// update the controls subsystem // update the controls subsystem
globals->get_controls()->update(delta_time_sec); globals->get_controls()->update(delta_time_sec);
@ -823,7 +818,6 @@ void fgRenderFrame() {
glEnable( GL_DEPTH_TEST ); glEnable( GL_DEPTH_TEST );
glEnable( GL_FOG ); glEnable( GL_FOG );
// globals->get_logger()->update(delta_time_sec);
} }
glutSwapBuffers(); glutSwapBuffers();
@ -1138,13 +1132,10 @@ static void fgMainLoop( void ) {
#ifdef ENABLE_AUDIO_SUPPORT #ifdef ENABLE_AUDIO_SUPPORT
if ( fgGetBool("/sim/sound/audible") if ( fgGetBool("/sim/sound/audible")
&& globals->get_soundmgr()->is_working() ) { && globals->get_soundmgr()->is_working() ) {
// globals->get_fx()->update( delta_time_sec );
globals->get_soundmgr()->update( delta_time_sec ); globals->get_soundmgr()->update( delta_time_sec );
} }
#endif #endif
// globals->get_systemmgr()->update( delta_time_sec );
// globals->get_instrumentmgr()->update( delta_time_sec );
globals->get_subsystem_mgr()->update(delta_time_sec); globals->get_subsystem_mgr()->update(delta_time_sec);
// //