// Initialize an Aircraft structure
void fgAircraftInit( void ) {
- FG_LOG( FG_AIRCRAFT, FG_INFO, "Initializing Aircraft structure" );
+ SG_LOG( SG_AIRCRAFT, SG_INFO, "Initializing Aircraft structure" );
current_aircraft.fdm_state = cur_fdm_state;
current_aircraft.controls = &controls;
f = a->fdm_state;
- FG_LOG( FG_FLIGHT, FG_DEBUG,
+ SG_LOG( SG_FLIGHT, SG_DEBUG,
"Pos = ("
<< (f->get_Longitude() * 3600.0 * SGD_RADIANS_TO_DEGREES) << ","
<< (f->get_Latitude() * 3600.0 * SGD_RADIANS_TO_DEGREES) << ","
<< f->get_Theta() << ","
<< f->get_Psi() << ")" );
- FG_LOG( FG_FLIGHT, FG_DEBUG,
+ SG_LOG( SG_FLIGHT, SG_DEBUG,
"Kts = " << f->get_V_equiv_kts()
<< " Elev = " << controls.get_elevator()
<< " Aileron = " << controls.get_aileron()
storage = new c4_Storage( file.c_str(), false );
if ( !storage->Strategy().IsValid() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
exit(-1);
}
fg_gzifstream in( file );
if ( !in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
exit(-1);
}
storage = new c4_Storage( file.c_str(), false );
if ( !storage->Strategy().IsValid() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
exit(-1);
}
fg_gzifstream in( file );
if ( !in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << file );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
exit(-1);
}
double t1, t2;
if ( fgFindAirportID( TgtAptId, &a ) ) {
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Adding waypoint (airport) = " << TgtAptId );
sprintf( NewTgtAirportId, "%s", TgtAptId.c_str() );
} else if ( current_fixlist->query( TgtAptId, 0.0, 0.0, 0.0,
&f, &t1, &t2 ) )
{
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Adding waypoint (fix) = " << TgtAptId );
sprintf( NewTgtAirportId, "%s", TgtAptId.c_str() );
void NewTgtAirportInit(void)
{
- FG_LOG( FG_AUTOPILOT, FG_INFO, " enter NewTgtAirportInit()" );
+ SG_LOG( SG_AUTOPILOT, SG_INFO, " enter NewTgtAirportInit()" );
// fgAPset_tgt_airport_id( fgGetString("/sim/startup/airport-id") );
sprintf( NewTgtAirportId, "%s", fgGetString("/sim/startup/airport-id").c_str() );
- FG_LOG( FG_AUTOPILOT, FG_INFO, " NewTgtAirportId " << NewTgtAirportId );
+ SG_LOG( SG_AUTOPILOT, SG_INFO, " NewTgtAirportId " << NewTgtAirportId );
// printf(" NewTgtAirportId %s\n", NewTgtAirportId);
int len = 150 - puGetStringWidth( puGetDefaultLabelFont(),
NewTgtAirportLabel ) / 2;
// Initialize autopilot subsystem
void FGAutopilot::init() {
- FG_LOG( FG_AUTOPILOT, FG_INFO, "Init AutoPilot Subsystem" );
+ SG_LOG( SG_AUTOPILOT, SG_INFO, "Init AutoPilot Subsystem" );
heading_hold = false ; // turn the heading hold off
altitude_hold = false ; // turn the altitude hold off
// figure out how far off we are from desired heading
// Now it is time to deterime how far we should be rolled.
- FG_LOG( FG_AUTOPILOT, FG_DEBUG, "RelHeading: " << RelHeading );
+ SG_LOG( SG_AUTOPILOT, SG_DEBUG, "RelHeading: " << RelHeading );
// Check if we are further from heading than the roll out point
// Compare Target roll to Current Roll, Generate Rel Roll
- FG_LOG( FG_COCKPIT, FG_BULK, "TargetRoll: " << TargetRoll );
+ SG_LOG( SG_COCKPIT, SG_BULK, "TargetRoll: " << TargetRoll );
RelRoll = NormalizeDegrees( TargetRoll - FGBFI::getRoll() );
MakeTargetAltitudeStr( TargetAltitude * SG_METER_TO_FEET );
}
- FG_LOG( FG_COCKPIT, FG_INFO, " set_HeadingMode: ( "
+ SG_LOG( SG_COCKPIT, SG_INFO, " set_HeadingMode: ( "
<< get_TargetLatitude() << " "
<< get_TargetLongitude() << " ) "
);
}
update_old_control_values();
- FG_LOG( FG_COCKPIT, FG_INFO, " set_AltitudeMode():" );
+ SG_LOG( SG_COCKPIT, SG_INFO, " set_AltitudeMode():" );
}
}
update_old_control_values();
- FG_LOG( FG_COCKPIT, FG_INFO, " fgAPSetAutoThrottle: ("
+ SG_LOG( SG_COCKPIT, SG_INFO, " fgAPSetAutoThrottle: ("
<< auto_throttle << ") " << TargetSpeed );
}
bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
{
- FG_LOG( FG_COCKPIT, FG_INFO, "Initializing cockpit subsystem" );
+ SG_LOG( SG_COCKPIT, SG_INFO, "Initializing cockpit subsystem" );
// cockpit->code = 1; /* It will be aircraft dependent */
// cockpit->status = 0;
// Have to set the LatLon display type
fgLatLonFormat = toDM;
- FG_LOG( FG_COCKPIT, FG_INFO,
+ SG_LOG( SG_COCKPIT, SG_INFO,
" Code " << ac_cockpit->code() << " Status "
<< ac_cockpit->status() );
void fgCockpitUpdate( void ) {
- FG_LOG( FG_COCKPIT, FG_DEBUG,
+ SG_LOG( SG_COCKPIT, SG_DEBUG,
"Cockpit: code " << ac_cockpit->code() << " status "
<< ac_cockpit->status() );
waypoint = node->getBoolValue("enable_waypoint_marker",false);
working = node->getBoolValue("working");
- FG_LOG(FG_INPUT, FG_INFO, "Done reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
p = (instr_item *) new HudLadder( name, x, y,
working = node->getBoolValue("working");
- FG_LOG(FG_INPUT, FG_INFO, "Done reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
if(type=="guage")
working = node->getBoolValue("working");
- FG_LOG(FG_INPUT, FG_INFO, "Done reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
if(justi==0)
gap_width = node->getIntValue("gap_width");
working = node->getBoolValue("working");
- FG_LOG(FG_INPUT, FG_INFO, "Done reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
p = (instr_item *) new fgTBI_instr( x,
if (!readProperties(input, &root)) {
- FG_LOG(FG_INPUT, FG_ALERT, "Malformed property list for hud.");
+ SG_LOG(SG_INPUT, SG_ALERT, "Malformed property list for hud.");
return 0;
}
- FG_LOG(FG_INPUT, FG_INFO, "Read properties for " <<
+ SG_LOG(SG_INPUT, SG_INFO, "Read properties for " <<
root.getStringValue("name"));
HUD_deque.erase( HUD_deque.begin(), HUD_deque.end()); // empty the HUD deque
- FG_LOG(FG_INPUT, FG_INFO, "Reading Hud instruments");
+ SG_LOG(SG_INPUT, SG_INFO, "Reading Hud instruments");
const SGPropertyNode * instrument_group = root.getChild("instruments");
int nInstruments = instrument_group->nChildren();
FGPath path( globals->get_fg_root() );
path.append(node->getStringValue("path"));
- FG_LOG(FG_INPUT, FG_INFO, "Reading Instrument "
+ SG_LOG(SG_INPUT, SG_INFO, "Reading Instrument "
<< node->getName()
<< " from "
<< path.str());
HUD_style = 1;
- FG_LOG( FG_COCKPIT, FG_INFO, "Initializing current aircraft HUD" );
+ SG_LOG( SG_COCKPIT, SG_INFO, "Initializing current aircraft HUD" );
string hud_path =
fgGetString("/sim/hud/path", "Huds/Default/default.xml");
ifstream input(path.c_str());
if (!input.good())
{
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"Cannot read Hud configuration from " << path.str());
}
else
HUD_style = 2;
- FG_LOG( FG_COCKPIT, FG_INFO, "Initializing current aircraft HUD" );
+ SG_LOG( SG_COCKPIT, SG_INFO, "Initializing current aircraft HUD" );
FGPath path(globals->get_fg_root());
path.append("Huds/Minimal/default.xml");
ifstream input(path.c_str());
if (!input.good()) {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"Cannot read Hud configuration from " << path.str());
}
else {
pHUDInstr = *current;
if( pHUDInstr->enabled()) {
- // fgPrintf( FG_COCKPIT, FG_DEBUG, "HUD Code %d Status %d\n",
+ // fgPrintf( SG_COCKPIT, SG_DEBUG, "HUD Code %d Status %d\n",
// hud->code, hud->status );
pHUDInstr->draw();
#ifdef DEBUGHUD
- fgPrintf( FG_COCKPIT, FG_DEBUG, format_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
- fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, format_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, label_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
#endif
// lenstr = strlen( label_buffer );
}
#ifdef DEBUGHUD
- fgPrintf( FG_COCKPIT, FG_DEBUG, format_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
- fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, format_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, label_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
#endif
lenstr = getStringWidth(label_buffer);
}
#ifdef DEBUGHUD
- fgPrintf( FG_COCKPIT, FG_DEBUG, format_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
- fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
- fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, format_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, label_buffer );
+ fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
#endif
lenstr = getStringWidth(label_buffer);
node->getFloatValue("y1"),
node->getFloatValue("x2", 1.0),
node->getFloatValue("y2", 1.0));
- FG_LOG(FG_INPUT, FG_INFO, "Read texture " << node->getName());
+ SG_LOG(SG_INPUT, SG_INFO, "Read texture " << node->getName());
return texture;
}
int h = int(node->getIntValue("h") * vscale);
if (type == "") {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"No type supplied for action " << name << " assuming \"adjust\"");
type = "adjust";
}
float max = node->getFloatValue("max", 0.0);
bool wrap = node->getBoolValue("wrap", false);
if (min == max)
- FG_LOG(FG_INPUT, FG_ALERT, "Action " << node->getName()
+ SG_LOG(SG_INPUT, SG_ALERT, "Action " << node->getName()
<< " has same min and max value");
action = new FGAdjustAction(button, x, y, w, h, value,
increment, min, max, wrap);
// Unrecognized type
else {
- FG_LOG(FG_INPUT, FG_ALERT, "Unrecognized action type " << type);
+ SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized action type " << type);
return 0;
}
SGValue * value = 0;
if (type == "") {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"No type supplied for transformation " << name
<< " assuming \"rotation\"");
type = "rotation";
}
else {
- FG_LOG(FG_INPUT, FG_ALERT, "Unrecognized transformation type " << type);
+ SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized transformation type " << type);
delete t;
return 0;
}
- FG_LOG(FG_INPUT, FG_INFO, "Read transformation " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Read transformation " << name);
return t;
}
// Default to literal text.
if (type == "") {
- FG_LOG(FG_INPUT, FG_INFO, "No type provided for text chunk " << name
+ SG_LOG(SG_INPUT, SG_INFO, "No type provided for text chunk " << name
<< " assuming \"literal\"");
type = "literal";
}
// Unknown type.
else {
- FG_LOG(FG_INPUT, FG_ALERT, "Unrecognized type " << type
+ SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized type " << type
<< " for text chunk " << name);
return 0;
}
if (type == "") {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"No type supplied for layer " << name
<< " assuming \"texture\"");
type = "texture";
}
else if (layerclass == "") {
- FG_LOG(FG_INPUT, FG_ALERT, "No class provided for built-in layer "
+ SG_LOG(SG_INPUT, SG_ALERT, "No class provided for built-in layer "
<< name);
return 0;
}
else {
- FG_LOG(FG_INPUT, FG_ALERT, "Unknown built-in layer class "
+ SG_LOG(SG_INPUT, SG_ALERT, "Unknown built-in layer class "
<< layerclass);
return 0;
}
// An unknown type.
else {
- FG_LOG(FG_INPUT, FG_ALERT, "Unrecognized layer type " << type);
+ SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized layer type " << type);
delete layer;
return 0;
}
}
}
- FG_LOG(FG_INPUT, FG_INFO, "Read layer " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Read layer " << name);
return layer;
}
h = real_h;
}
- FG_LOG(FG_INPUT, FG_INFO, "Reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Reading instrument " << name);
FGLayeredInstrument * instrument =
new FGLayeredInstrument(x, y, w, h);
}
}
- FG_LOG(FG_INPUT, FG_INFO, "Done reading instrument " << name);
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
return instrument;
}
// Read the property list from disk.
//
if (!readProperties(input, &root)) {
- FG_LOG(FG_INPUT, FG_ALERT, "Malformed property list for panel.");
+ SG_LOG(SG_INPUT, SG_ALERT, "Malformed property list for panel.");
return 0;
}
- FG_LOG(FG_INPUT, FG_INFO, "Read properties for panel " <<
+ SG_LOG(SG_INPUT, SG_INFO, "Read properties for panel " <<
root.getStringValue("name"));
//
if (bgTexture == "")
bgTexture = "FOO";
panel->setBackground(FGTextureManager::createTexture(bgTexture.c_str()));
- FG_LOG(FG_INPUT, FG_INFO, "Set background texture to " << bgTexture);
+ SG_LOG(SG_INPUT, SG_INFO, "Set background texture to " << bgTexture);
//
// Create each instrument.
//
- FG_LOG(FG_INPUT, FG_INFO, "Reading panel instruments");
+ SG_LOG(SG_INPUT, SG_INFO, "Reading panel instruments");
const SGPropertyNode * instrument_group = root.getChild("instruments");
if (instrument_group != 0) {
int nInstruments = instrument_group->nChildren();
FGPath path( globals->get_fg_root() );
path.append(node->getStringValue("path"));
- FG_LOG(FG_INPUT, FG_INFO, "Reading instrument "
+ SG_LOG(SG_INPUT, SG_INFO, "Reading instrument "
<< node->getName()
<< " from "
<< path.str());
int h = node->getIntValue("h", -1);
if (x == -1 || y == -1) {
- FG_LOG(FG_INPUT, FG_ALERT, "x and y positions must be specified and >0");
+ SG_LOG(SG_INPUT, SG_ALERT, "x and y positions must be specified and >0");
delete panel;
return 0;
}
panel->addInstrument(instrument);
}
}
- FG_LOG(FG_INPUT, FG_INFO, "Done reading panel instruments");
+ SG_LOG(SG_INPUT, SG_INFO, "Done reading panel instruments");
//
path.append(relative_path);
ifstream input(path.c_str());
if (!input.good()) {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"Cannot read panel configuration from " << path.str());
} else {
panel = fgReadPanel(input);
_set_Omega_Body( P_body, Q_body, R_body );
_set_Geocentric_Rates( Latitude_dot, Longitude_dot, Radius_dot );
- // FG_LOG( FG_FLIGHT, FG_DEBUG, "lon = " << Longitude
+ // SG_LOG( SG_FLIGHT, SG_DEBUG, "lon = " << Longitude
// << " lat_geoc = " << Lat_geocentric << " lat_geod = " << Latitude
// << " alt = " << Altitude << " sl_radius = " << Sea_level_radius
// << " radius_to_vehicle = " << Radius_to_vehicle );
void FGBalloonSim::init() {
sgVec3 temp;
- FG_LOG( FG_FLIGHT, FG_INFO, "Starting initializing BalloonSim" );
+ SG_LOG( SG_FLIGHT, SG_INFO, "Starting initializing BalloonSim" );
- FG_LOG( FG_FLIGHT, FG_INFO, " created a balloon" );
+ SG_LOG( SG_FLIGHT, SG_INFO, " created a balloon" );
//set position
sgSetVec3( temp,
fgGetDouble("/velocities/wBody") );
current_balloon.setVelocity( temp );
- FG_LOG( FG_FLIGHT, FG_INFO, "Finished initializing BalloonSim" );
+ SG_LOG( SG_FLIGHT, SG_INFO, "Finished initializing BalloonSim" );
}
/*sgVec3 temp, temp2;
current_balloon.getPosition( temp );
current_balloon.getVelocity( temp2 );
- FG_LOG( FG_FLIGHT, FG_INFO, "T: " << current_balloon.getTemperature() <<
+ SG_LOG( SG_FLIGHT, SG_INFO, "T: " << current_balloon.getTemperature() <<
" alt: " << temp[2] <<
" gr_alt: " << get_Runway_altitude() <<
" burner: " << controls.get_elevator() <<
engine_path.str(),
fgGetString("/sim/aircraft") );
int Neng=fdmex->GetAircraft()->GetNumEngines();
- FG_LOG(FG_FLIGHT,FG_INFO, "Neng: " << Neng );
+ SG_LOG(SG_FLIGHT,SG_INFO, "Neng: " << Neng );
for(int i=0;i<Neng;i++) {
add_engine( FGEngInterface() );
}
bool result;
- FG_LOG( FG_FLIGHT, FG_INFO, "Starting and initializing JSBsim" );
+ SG_LOG( SG_FLIGHT, SG_INFO, "Starting and initializing JSBsim" );
#if 0
FGPath aircraft_path( globals->get_fg_root() );
fgGetString("/sim/aircraft") );
if (result) {
- FG_LOG( FG_FLIGHT, FG_INFO, " loaded aircraft " << fgGetString("/sim/aircraft") );
+ SG_LOG( SG_FLIGHT, SG_INFO, " loaded aircraft " << fgGetString("/sim/aircraft") );
} else {
- FG_LOG( FG_FLIGHT, FG_INFO, " aircraft "
+ SG_LOG( SG_FLIGHT, SG_INFO, " aircraft "
<< fgGetString("/sim/aircraft")
<< " does not exist" );
exit(-1);
fdmex->GetAtmosphere()->UseInternal();
- FG_LOG( FG_FLIGHT, FG_INFO, " Initializing JSBSim with:" );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Initializing JSBSim with:" );
switch(fgic->GetSpeedSet()) {
case setned:
- FG_LOG(FG_FLIGHT,FG_INFO, " Vn,Ve,Vd= "
+ SG_LOG(SG_FLIGHT,SG_INFO, " Vn,Ve,Vd= "
<< fdmex->GetPosition()->GetVn()
<< ", " << fdmex->GetPosition()->GetVe()
<< ", " << fdmex->GetPosition()->GetVd()
<< " ft/s");
break;
case setuvw:
- FG_LOG(FG_FLIGHT,FG_INFO, " U,V,W= "
+ SG_LOG(SG_FLIGHT,SG_INFO, " U,V,W= "
<< fdmex->GetTranslation()->GetUVW()(1)
<< ", " << fdmex->GetTranslation()->GetUVW()(2)
<< ", " << fdmex->GetTranslation()->GetUVW()(3)
<< " ft/s");
break;
case setmach:
- FG_LOG(FG_FLIGHT,FG_INFO, " Mach: "
+ SG_LOG(SG_FLIGHT,SG_INFO, " Mach: "
<< fdmex->GetTranslation()->GetMach() );
break;
case setvc:
default:
- FG_LOG(FG_FLIGHT,FG_INFO, " Indicated Airspeed: "
+ SG_LOG(SG_FLIGHT,SG_INFO, " Indicated Airspeed: "
<< fdmex->GetAuxiliary()->GetVcalibratedKTS() << " knots" );
}
- FG_LOG( FG_FLIGHT, FG_INFO, " Bank Angle: "
+ SG_LOG( SG_FLIGHT, SG_INFO, " Bank Angle: "
<< fdmex->GetRotation()->Getphi()*RADTODEG << " deg");
- FG_LOG( FG_FLIGHT, FG_INFO, " Pitch Angle: "
+ SG_LOG( SG_FLIGHT, SG_INFO, " Pitch Angle: "
<< fdmex->GetRotation()->Gettht()*RADTODEG << " deg" );
- FG_LOG( FG_FLIGHT, FG_INFO, " True Heading: "
+ SG_LOG( SG_FLIGHT, SG_INFO, " True Heading: "
<< fdmex->GetRotation()->Getpsi()*RADTODEG << " deg" );
- FG_LOG( FG_FLIGHT, FG_INFO, " Latitude: "
+ SG_LOG( SG_FLIGHT, SG_INFO, " Latitude: "
<< fdmex->GetPosition()->GetLatitude() << " deg" );
- FG_LOG( FG_FLIGHT, FG_INFO, " Longitude: "
+ SG_LOG( SG_FLIGHT, SG_INFO, " Longitude: "
<< fdmex->GetPosition()->GetLongitude() << " deg" );
// for debug only
- /* FG_LOG( FG_FLIGHT, FG_DEBUG, " FGJSBSim::get_Altitude(): " << get_Altitude() );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " FGJSBSim::get_Sea_level_radius(): " << get_Sea_level_radius() );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " scenery.cur_radius*SG_METER_TO_FEET: "
+ /* SG_LOG( SG_FLIGHT, SG_DEBUG, " FGJSBSim::get_Altitude(): " << get_Altitude() );
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " FGJSBSim::get_Sea_level_radius(): " << get_Sea_level_radius() );
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " scenery.cur_radius*SG_METER_TO_FEET: "
<< scenery.cur_radius*SG_METER_TO_FEET );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " Calculated Terrain ASL: " << endl
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " Calculated Terrain ASL: " << endl
<< " " << "scenery.cur_radius*SG_METER_TO_FEET -get_Sea_level_radius()= "
<< scenery.cur_radius*SG_METER_TO_FEET - get_Sea_level_radius() );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " Calculated Aircraft AGL: " << endl
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " Calculated Aircraft AGL: " << endl
<< " " << "get_Altitude() + get_Sea_level_radius() - scenery.cur_radius*SG_METER_TO_FEET= "
<< get_Altitude() + get_Sea_level_radius()- scenery.cur_radius*SG_METER_TO_FEET );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " fgGetDouble("/position/altitude"): "
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " fgGetDouble("/position/altitude"): "
<< fgGetDouble("/position/altitude") );
- FG_LOG( FG_FLIGHT, FG_DEBUG, " FGBFI::getAltitude(): "
+ SG_LOG( SG_FLIGHT, SG_DEBUG, " FGBFI::getAltitude(): "
<< FGBFI::getAltitude() ); */
- FG_LOG( FG_FLIGHT, FG_INFO, " loaded initial conditions" );
+ SG_LOG( SG_FLIGHT, SG_INFO, " loaded initial conditions" );
- FG_LOG( FG_FLIGHT, FG_INFO, " set dt" );
+ SG_LOG( SG_FLIGHT, SG_INFO, " set dt" );
- FG_LOG( FG_FLIGHT, FG_INFO, "Finished initializing JSBSim" );
+ SG_LOG( SG_FLIGHT, SG_INFO, "Finished initializing JSBSim" );
}
/******************************************************************************/
controls.set_aileron(fdmex->GetFCS()->GetDaCmd());
controls.set_rudder(fdmex->GetFCS()->GetDrCmd());
- FG_LOG( FG_FLIGHT, FG_INFO, " Trim complete" );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Trim complete" );
}
for( i=0; i<get_num_engines(); i++ ) {
void FGJSBsim::set_Latitude(double lat) {
double sea_level_radius_meters,lat_geoc;
- FG_LOG(FG_FLIGHT,FG_INFO,"FGJSBsim::set_Latitude: " << lat );
+ SG_LOG(SG_FLIGHT,SG_INFO,"FGJSBsim::set_Latitude: " << lat );
snap_shot();
sgGeodToGeoc( lat, get_Altitude() , &sea_level_radius_meters, &lat_geoc);
void FGJSBsim::set_Longitude(double lon) {
- FG_LOG(FG_FLIGHT,FG_INFO,"FGJSBsim::set_Longitude: " << lon );
+ SG_LOG(SG_FLIGHT,SG_INFO,"FGJSBsim::set_Longitude: " << lon );
snap_shot();
fgic->SetLongitudeRadIC(lon);
void FGJSBsim::set_Altitude(double alt) {
double sea_level_radius_meters,lat_geoc;
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Altitude: " << alt );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Altitude: " << alt );
snap_shot();
sgGeodToGeoc( get_Latitude(), alt , &sea_level_radius_meters, &lat_geoc);
}
void FGJSBsim::set_V_calibrated_kts(double vc) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_V_calibrated_kts: " << vc );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_V_calibrated_kts: " << vc );
snap_shot();
fgic->SetVcalibratedKtsIC(vc);
}
void FGJSBsim::set_Mach_number(double mach) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Mach_number: " << mach );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Mach_number: " << mach );
snap_shot();
fgic->SetMachIC(mach);
}
void FGJSBsim::set_Velocities_Local( double north, double east, double down ){
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Velocities_Local: "
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Local: "
<< north << ", " << east << ", " << down );
snap_shot();
}
void FGJSBsim::set_Velocities_Wind_Body( double u, double v, double w){
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Velocities_Wind_Body: "
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Wind_Body: "
<< u << ", " << v << ", " << w );
snap_shot();
//Euler angles
void FGJSBsim::set_Euler_Angles( double phi, double theta, double psi ) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Euler_Angles: "
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Euler_Angles: "
<< phi << ", " << theta << ", " << psi );
snap_shot();
//Flight Path
void FGJSBsim::set_Climb_Rate( double roc) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Climb_Rate: " << roc );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Climb_Rate: " << roc );
snap_shot();
fgic->SetClimbRateFpsIC(roc);
}
void FGJSBsim::set_Gamma_vert_rad( double gamma) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Gamma_vert_rad: " << gamma );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Gamma_vert_rad: " << gamma );
snap_shot();
fgic->SetFlightPathAngleRadIC(gamma);
//Earth
void FGJSBsim::set_Sea_level_radius(double slr) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Sea_level_radius: " << slr );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Sea_level_radius: " << slr );
snap_shot();
fgic->SetSeaLevelRadiusFtIC(slr);
}
void FGJSBsim::set_Runway_altitude(double ralt) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Runway_altitude: " << ralt );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Runway_altitude: " << ralt );
snap_shot();
_set_Runway_altitude( ralt );
}
void FGJSBsim::set_Static_pressure(double p) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Static_pressure: " << p );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Static_pressure: " << p );
snap_shot();
fdmex->GetAtmosphere()->SetExPressure(p);
}
void FGJSBsim::set_Static_temperature(double T) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Static_temperature: " << T );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Static_temperature: " << T );
snap_shot();
fdmex->GetAtmosphere()->SetExTemperature(T);
void FGJSBsim::set_Density(double rho) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Density: " << rho );
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Density: " << rho );
snap_shot();
fdmex->GetAtmosphere()->SetExDensity(rho);
void FGJSBsim::set_Velocities_Local_Airmass (double wnorth,
double weast,
double wdown ) {
- FG_LOG(FG_FLIGHT,FG_INFO, "FGJSBsim::set_Velocities_Local_Airmass: "
+ SG_LOG(SG_FLIGHT,SG_INFO, "FGJSBsim::set_Velocities_Local_Airmass: "
<< wnorth << ", " << weast << ", " << wdown );
snap_shot();
set_Tank1Fuel(28.0);
set_Tank2Fuel(28.0);
- // FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::init()" );
+ // SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::init()" );
double save_alt = 0.0;
// actual LaRCsim top level init
// ls_toplevel_init( dt, (char *)fgGetString("/sim/aircraft").c_str() );
- FG_LOG( FG_FLIGHT, FG_INFO, "FG pos = " <<
+ SG_LOG( SG_FLIGHT, SG_INFO, "FG pos = " <<
get_Latitude() );
// translate LaRCsim back to FG structure
* get_delta_t() );
#if 0
- FG_LOG( FG_FLIGHT, FG_INFO, "Throttle = "
+ SG_LOG( SG_FLIGHT, SG_INFO, "Throttle = "
<< controls.get_throttle( 0 ) * 100.0);
- FG_LOG( FG_FLIGHT, FG_INFO, " Mixture = " << 80);
- FG_LOG( FG_FLIGHT, FG_INFO, " RPM = " << eng.get_RPM());
- FG_LOG( FG_FLIGHT, FG_INFO, " MP = " << eng.get_Manifold_Pressure());
- FG_LOG( FG_FLIGHT, FG_INFO, " HP = "
+ SG_LOG( SG_FLIGHT, SG_INFO, " Mixture = " << 80);
+ SG_LOG( SG_FLIGHT, SG_INFO, " RPM = " << eng.get_RPM());
+ SG_LOG( SG_FLIGHT, SG_INFO, " MP = " << eng.get_Manifold_Pressure());
+ SG_LOG( SG_FLIGHT, SG_INFO, " HP = "
<< ( eng.get_MaxHP() * eng.get_Percentage_Power()/ 100.0) );
- FG_LOG( FG_FLIGHT, FG_INFO, " EGT = " << eng.get_EGT());
- FG_LOG( FG_FLIGHT, FG_INFO, " Thrust (N) "
+ SG_LOG( SG_FLIGHT, SG_INFO, " EGT = " << eng.get_EGT());
+ SG_LOG( SG_FLIGHT, SG_INFO, " Thrust (N) "
<< eng.get_prop_thrust_SI()); // Thrust in Newtons
- FG_LOG( FG_FLIGHT, FG_INFO, '\n');
+ SG_LOG( SG_FLIGHT, SG_INFO, '\n');
#endif
F_X_engine = eng.get_prop_thrust_lbs();
// cout << "F_X_engine = " << F_X_engine << '\n';
_set_Mach_number( Mach_number );
- FG_LOG( FG_FLIGHT, FG_DEBUG, "lon = " << Longitude
+ SG_LOG( SG_FLIGHT, SG_DEBUG, "lon = " << Longitude
<< " lat_geoc = " << Lat_geocentric << " lat_geod = " << Latitude
<< " alt = " << Altitude << " sl_radius = " << Sea_level_radius
<< " radius_to_vehicle = " << Radius_to_vehicle );
V_down_airmass = lsic->GetVdownAirmassFpsIC();
ls_loop(0.0,-1);
copy_from_LaRCsim();
- FG_LOG( FG_FLIGHT, FG_INFO, " FGLaRCsim::set_ls(): " );
- FG_LOG( FG_FLIGHT, FG_INFO, " Phi: " << Phi );
- FG_LOG( FG_FLIGHT, FG_INFO, " Theta: " << Theta );
- FG_LOG( FG_FLIGHT, FG_INFO, " Psi: " << Psi );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_north: " << V_north );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_east: " << V_east );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_down: " << V_down );
- FG_LOG( FG_FLIGHT, FG_INFO, " Altitude: " << Altitude );
- FG_LOG( FG_FLIGHT, FG_INFO, " Latitude: " << Latitude );
- FG_LOG( FG_FLIGHT, FG_INFO, " Longitude: " << Longitude );
- FG_LOG( FG_FLIGHT, FG_INFO, " Runway_altitude: " << Runway_altitude );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_north_airmass: " << V_north_airmass );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_east_airmass: " << V_east_airmass );
- FG_LOG( FG_FLIGHT, FG_INFO, " V_down_airmass: " << V_down_airmass );
+ SG_LOG( SG_FLIGHT, SG_INFO, " FGLaRCsim::set_ls(): " );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Phi: " << Phi );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Theta: " << Theta );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Psi: " << Psi );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_north: " << V_north );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_east: " << V_east );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_down: " << V_down );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Altitude: " << Altitude );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Latitude: " << Latitude );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Longitude: " << Longitude );
+ SG_LOG( SG_FLIGHT, SG_INFO, " Runway_altitude: " << Runway_altitude );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_north_airmass: " << V_north_airmass );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_east_airmass: " << V_east_airmass );
+ SG_LOG( SG_FLIGHT, SG_INFO, " V_down_airmass: " << V_down_airmass );
}
void FGLaRCsim::snap_shot(void) {
//Positions
void FGLaRCsim::set_Latitude(double lat) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Latitude: " << lat );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Latitude: " << lat );
snap_shot();
lsic->SetLatitudeGDRadIC(lat);
set_ls();
}
void FGLaRCsim::set_Longitude(double lon) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Longitude: " << lon );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Longitude: " << lon );
snap_shot();
lsic->SetLongitudeRadIC(lon);
set_ls();
}
void FGLaRCsim::set_Altitude(double alt) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Altitude: " << alt );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Altitude: " << alt );
snap_shot();
lsic->SetAltitudeFtIC(alt);
set_ls();
}
void FGLaRCsim::set_V_calibrated_kts(double vc) {
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO,
"FGLaRCsim::set_V_calibrated_kts: " << vc );
snap_shot();
lsic->SetVcalibratedKtsIC(vc);
}
void FGLaRCsim::set_Mach_number(double mach) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Mach_number: " << mach );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Mach_number: " << mach );
snap_shot();
lsic->SetMachIC(mach);
set_ls();
}
void FGLaRCsim::set_Velocities_Local( double north, double east, double down ){
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Velocities_local: "
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Velocities_local: "
<< north << " " << east << " " << down );
snap_shot();
lsic->SetVNEDFpsIC(north, east, down);
}
void FGLaRCsim::set_Velocities_Wind_Body( double u, double v, double w){
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Velocities_Wind_Body: "
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Velocities_Wind_Body: "
<< u << " " << v << " " << w );
snap_shot();
lsic->SetUVWFpsIC(u,v,w);
//Euler angles
void FGLaRCsim::set_Euler_Angles( double phi, double theta, double psi ) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Euler_angles: "
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Euler_angles: "
<< phi << " " << theta << " " << psi );
snap_shot();
//Flight Path
void FGLaRCsim::set_Climb_Rate( double roc) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Climb_rate: " << roc );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Climb_rate: " << roc );
snap_shot();
lsic->SetClimbRateFpsIC(roc);
set_ls();
}
void FGLaRCsim::set_Gamma_vert_rad( double gamma) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Gamma_vert_rad: " << gamma );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Gamma_vert_rad: " << gamma );
snap_shot();
lsic->SetFlightPathAngleRadIC(gamma);
set_ls();
}
void FGLaRCsim::set_Runway_altitude(double ralt) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Runway_altitude: " << ralt );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Runway_altitude: " << ralt );
snap_shot();
lsic->SetRunwayAltitudeFtIC(ralt);
set_ls();
}
void FGLaRCsim::set_AltitudeAGL(double altagl) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_AltitudeAGL: " << altagl );
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_AltitudeAGL: " << altagl );
snap_shot();
lsic->SetAltitudeAGLFtIC(altagl);
set_ls();
void FGLaRCsim::set_Velocities_Local_Airmass (double wnorth,
double weast,
double wdown ) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Velocities_Local_Airmass: "
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Velocities_Local_Airmass: "
<< wnorth << " " << weast << " " << wdown );
snap_shot();
lsic->SetVNEDAirmassFpsIC( wnorth, weast, wdown );
}
void FGLaRCsim::set_Static_pressure(double p) {
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO,
"FGLaRCsim::set_Static_pressure: " << p );
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO,
"LaRCsim does not support externally supplied atmospheric data" );
}
void FGLaRCsim::set_Static_temperature(double T) {
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO,
"FGLaRCsim::set_Static_temperature: " << T );
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO,
"LaRCsim does not support externally supplied atmospheric data" );
}
void FGLaRCsim::set_Density(double rho) {
- FG_LOG( FG_FLIGHT, FG_INFO, "FGLaRCsim::set_Density: " << rho );
- FG_LOG( FG_FLIGHT, FG_INFO,
+ SG_LOG( SG_FLIGHT, SG_INFO, "FGLaRCsim::set_Density: " << rho );
+ SG_LOG( SG_FLIGHT, SG_INFO,
"LaRCsim does not support externally supplied atmospheric data" );
}
$Header$
$Log$
+Revision 1.3 2001/03/24 05:03:12 curt
+SG-ified logstream.
+
Revision 1.2 2000/10/23 22:34:54 curt
I tested:
LaRCsim c172 on-ground and in-air starts, reset: all work
-- that small set is declared virtual, the default implementation
provided preserves the old behavior
-- all of the vector data members are now initialized.
--- added busdump() method -- FG_LOG's all the bus data when called,
+-- added busdump() method -- SG_LOG's all the bus data when called,
useful for diagnostics.
src/FDM/ADA.cxx
$Header$
$Log$
+Revision 1.3 2001/03/24 05:03:12 curt
+SG-ified logstream.
+
Revision 1.2 2000/10/23 22:34:54 curt
I tested:
LaRCsim c172 on-ground and in-air starts, reset: all work
-- that small set is declared virtual, the default implementation
provided preserves the old behavior
-- all of the vector data members are now initialized.
--- added busdump() method -- FG_LOG's all the bus data when called,
+-- added busdump() method -- SG_LOG's all the bus data when called,
useful for diagnostics.
src/FDM/ADA.cxx
/* Flight Gear Modification Log
*
* $Log$
+ * Revision 1.4 2001/03/24 05:03:12 curt
+ * SG-ified logstream.
+ *
* Revision 1.3 2000/10/23 22:34:54 curt
* I tested:
* LaRCsim c172 on-ground and in-air starts, reset: all work
* -- that small set is declared virtual, the default implementation
* provided preserves the old behavior
* -- all of the vector data members are now initialized.
- * -- added busdump() method -- FG_LOG's all the bus data when called,
+ * -- added busdump() method -- SG_LOG's all the bus data when called,
* useful for diagnostics.
*
* src/FDM/ADA.cxx
// $Log$
+// Revision 1.5 2001/03/24 05:03:12 curt
+// SG-ified logstream.
+//
// Revision 1.4 2000/10/23 22:34:54 curt
// I tested:
// LaRCsim c172 on-ground and in-air starts, reset: all work
// -- that small set is declared virtual, the default implementation
// provided preserves the old behavior
// -- all of the vector data members are now initialized.
-// -- added busdump() method -- FG_LOG's all the bus data when called,
+// -- added busdump() method -- SG_LOG's all the bus data when called,
// useful for diagnostics.
//
// src/FDM/ADA.cxx
$Header$
$Log$
+Revision 1.4 2001/03/24 05:03:12 curt
+SG-ified logstream.
+
Revision 1.3 2000/10/23 22:34:55 curt
I tested:
LaRCsim c172 on-ground and in-air starts, reset: all work
-- that small set is declared virtual, the default implementation
provided preserves the old behavior
-- all of the vector data members are now initialized.
--- added busdump() method -- FG_LOG's all the bus data when called,
+-- added busdump() method -- SG_LOG's all the bus data when called,
useful for diagnostics.
src/FDM/ADA.cxx
&lat_geod, &tmp_alt, &sl_radius1 );
sgGeodToGeoc( lat_geod, alt * SG_FEET_TO_METER, &sl_radius2, &tmp_lat_geoc );
- FG_LOG( FG_FLIGHT, FG_DEBUG, "lon = " << lon
+ SG_LOG( SG_FLIGHT, SG_DEBUG, "lon = " << lon
<< " lat_geod = " << lat_geod
<< " lat_geoc = " << lat_geoc
<< " alt = " << alt
// Set the local ground elevation
void fgFDMSetGroundElevation(const string &model, double ground_meters) {
- FG_LOG( FG_FLIGHT,FG_INFO, "fgFDMSetGroundElevation: "
+ SG_LOG( SG_FLIGHT,SG_INFO, "fgFDMSetGroundElevation: "
<< ground_meters*SG_METER_TO_FEET );
base_fdm_state.set_Runway_altitude( ground_meters * SG_METER_TO_FEET );
cur_fdm_state->set_Runway_altitude( ground_meters * SG_METER_TO_FEET );
void FGInterface::_busdump(void) {
- FG_LOG(FG_FLIGHT,FG_INFO,"d_pilot_rp_body_v[3]: " << d_pilot_rp_body_v[0] << ", " << d_pilot_rp_body_v[1] << ", " << d_pilot_rp_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"d_cg_rp_body_v[3]: " << d_cg_rp_body_v[0] << ", " << d_cg_rp_body_v[1] << ", " << d_cg_rp_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"f_body_total_v[3]: " << f_body_total_v[0] << ", " << f_body_total_v[1] << ", " << f_body_total_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"f_local_total_v[3]: " << f_local_total_v[0] << ", " << f_local_total_v[1] << ", " << f_local_total_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"f_aero_v[3]: " << f_aero_v[0] << ", " << f_aero_v[1] << ", " << f_aero_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"f_engine_v[3]: " << f_engine_v[0] << ", " << f_engine_v[1] << ", " << f_engine_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"f_gear_v[3]: " << f_gear_v[0] << ", " << f_gear_v[1] << ", " << f_gear_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"m_total_rp_v[3]: " << m_total_rp_v[0] << ", " << m_total_rp_v[1] << ", " << m_total_rp_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"m_total_cg_v[3]: " << m_total_cg_v[0] << ", " << m_total_cg_v[1] << ", " << m_total_cg_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"m_aero_v[3]: " << m_aero_v[0] << ", " << m_aero_v[1] << ", " << m_aero_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"m_engine_v[3]: " << m_engine_v[0] << ", " << m_engine_v[1] << ", " << m_engine_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"m_gear_v[3]: " << m_gear_v[0] << ", " << m_gear_v[1] << ", " << m_gear_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_dot_local_v[3]: " << v_dot_local_v[0] << ", " << v_dot_local_v[1] << ", " << v_dot_local_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_dot_body_v[3]: " << v_dot_body_v[0] << ", " << v_dot_body_v[1] << ", " << v_dot_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"a_cg_body_v[3]: " << a_cg_body_v[0] << ", " << a_cg_body_v[1] << ", " << a_cg_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"a_pilot_body_v[3]: " << a_pilot_body_v[0] << ", " << a_pilot_body_v[1] << ", " << a_pilot_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"n_cg_body_v[3]: " << n_cg_body_v[0] << ", " << n_cg_body_v[1] << ", " << n_cg_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"n_pilot_body_v[3]: " << n_pilot_body_v[0] << ", " << n_pilot_body_v[1] << ", " << n_pilot_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"omega_dot_body_v[3]: " << omega_dot_body_v[0] << ", " << omega_dot_body_v[1] << ", " << omega_dot_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_local_v[3]: " << v_local_v[0] << ", " << v_local_v[1] << ", " << v_local_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_local_rel_ground_v[3]: " << v_local_rel_ground_v[0] << ", " << v_local_rel_ground_v[1] << ", " << v_local_rel_ground_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_local_airmass_v[3]: " << v_local_airmass_v[0] << ", " << v_local_airmass_v[1] << ", " << v_local_airmass_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_local_rel_airmass_v[3]: " << v_local_rel_airmass_v[0] << ", " << v_local_rel_airmass_v[1] << ", " << v_local_rel_airmass_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_local_gust_v[3]: " << v_local_gust_v[0] << ", " << v_local_gust_v[1] << ", " << v_local_gust_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"v_wind_body_v[3]: " << v_wind_body_v[0] << ", " << v_wind_body_v[1] << ", " << v_wind_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"omega_body_v[3]: " << omega_body_v[0] << ", " << omega_body_v[1] << ", " << omega_body_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"omega_local_v[3]: " << omega_local_v[0] << ", " << omega_local_v[1] << ", " << omega_local_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"omega_total_v[3]: " << omega_total_v[0] << ", " << omega_total_v[1] << ", " << omega_total_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"euler_rates_v[3]: " << euler_rates_v[0] << ", " << euler_rates_v[1] << ", " << euler_rates_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"geocentric_rates_v[3]: " << geocentric_rates_v[0] << ", " << geocentric_rates_v[1] << ", " << geocentric_rates_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"geocentric_position_v[3]: " << geocentric_position_v[0] << ", " << geocentric_position_v[1] << ", " << geocentric_position_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"geodetic_position_v[3]: " << geodetic_position_v[0] << ", " << geodetic_position_v[1] << ", " << geodetic_position_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"euler_angles_v[3]: " << euler_angles_v[0] << ", " << euler_angles_v[1] << ", " << euler_angles_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"d_cg_rwy_local_v[3]: " << d_cg_rwy_local_v[0] << ", " << d_cg_rwy_local_v[1] << ", " << d_cg_rwy_local_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"d_cg_rwy_rwy_v[3]: " << d_cg_rwy_rwy_v[0] << ", " << d_cg_rwy_rwy_v[1] << ", " << d_cg_rwy_rwy_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"d_pilot_rwy_local_v[3]: " << d_pilot_rwy_local_v[0] << ", " << d_pilot_rwy_local_v[1] << ", " << d_pilot_rwy_local_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"d_pilot_rwy_rwy_v[3]: " << d_pilot_rwy_rwy_v[0] << ", " << d_pilot_rwy_rwy_v[1] << ", " << d_pilot_rwy_rwy_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rp_body_v[3]: " << d_pilot_rp_body_v[0] << ", " << d_pilot_rp_body_v[1] << ", " << d_pilot_rp_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rp_body_v[3]: " << d_cg_rp_body_v[0] << ", " << d_cg_rp_body_v[1] << ", " << d_cg_rp_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"f_body_total_v[3]: " << f_body_total_v[0] << ", " << f_body_total_v[1] << ", " << f_body_total_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"f_local_total_v[3]: " << f_local_total_v[0] << ", " << f_local_total_v[1] << ", " << f_local_total_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"f_aero_v[3]: " << f_aero_v[0] << ", " << f_aero_v[1] << ", " << f_aero_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"f_engine_v[3]: " << f_engine_v[0] << ", " << f_engine_v[1] << ", " << f_engine_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"f_gear_v[3]: " << f_gear_v[0] << ", " << f_gear_v[1] << ", " << f_gear_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"m_total_rp_v[3]: " << m_total_rp_v[0] << ", " << m_total_rp_v[1] << ", " << m_total_rp_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"m_total_cg_v[3]: " << m_total_cg_v[0] << ", " << m_total_cg_v[1] << ", " << m_total_cg_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"m_aero_v[3]: " << m_aero_v[0] << ", " << m_aero_v[1] << ", " << m_aero_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"m_engine_v[3]: " << m_engine_v[0] << ", " << m_engine_v[1] << ", " << m_engine_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"m_gear_v[3]: " << m_gear_v[0] << ", " << m_gear_v[1] << ", " << m_gear_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_local_v[3]: " << v_dot_local_v[0] << ", " << v_dot_local_v[1] << ", " << v_dot_local_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_body_v[3]: " << v_dot_body_v[0] << ", " << v_dot_body_v[1] << ", " << v_dot_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"a_cg_body_v[3]: " << a_cg_body_v[0] << ", " << a_cg_body_v[1] << ", " << a_cg_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"a_pilot_body_v[3]: " << a_pilot_body_v[0] << ", " << a_pilot_body_v[1] << ", " << a_pilot_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"n_cg_body_v[3]: " << n_cg_body_v[0] << ", " << n_cg_body_v[1] << ", " << n_cg_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"n_pilot_body_v[3]: " << n_pilot_body_v[0] << ", " << n_pilot_body_v[1] << ", " << n_pilot_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"omega_dot_body_v[3]: " << omega_dot_body_v[0] << ", " << omega_dot_body_v[1] << ", " << omega_dot_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_v[3]: " << v_local_v[0] << ", " << v_local_v[1] << ", " << v_local_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_rel_ground_v[3]: " << v_local_rel_ground_v[0] << ", " << v_local_rel_ground_v[1] << ", " << v_local_rel_ground_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_airmass_v[3]: " << v_local_airmass_v[0] << ", " << v_local_airmass_v[1] << ", " << v_local_airmass_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_rel_airmass_v[3]: " << v_local_rel_airmass_v[0] << ", " << v_local_rel_airmass_v[1] << ", " << v_local_rel_airmass_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_gust_v[3]: " << v_local_gust_v[0] << ", " << v_local_gust_v[1] << ", " << v_local_gust_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_wind_body_v[3]: " << v_wind_body_v[0] << ", " << v_wind_body_v[1] << ", " << v_wind_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"omega_body_v[3]: " << omega_body_v[0] << ", " << omega_body_v[1] << ", " << omega_body_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"omega_local_v[3]: " << omega_local_v[0] << ", " << omega_local_v[1] << ", " << omega_local_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"omega_total_v[3]: " << omega_total_v[0] << ", " << omega_total_v[1] << ", " << omega_total_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"euler_rates_v[3]: " << euler_rates_v[0] << ", " << euler_rates_v[1] << ", " << euler_rates_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_rates_v[3]: " << geocentric_rates_v[0] << ", " << geocentric_rates_v[1] << ", " << geocentric_rates_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_position_v[3]: " << geocentric_position_v[0] << ", " << geocentric_position_v[1] << ", " << geocentric_position_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geodetic_position_v[3]: " << geodetic_position_v[0] << ", " << geodetic_position_v[1] << ", " << geodetic_position_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"euler_angles_v[3]: " << euler_angles_v[0] << ", " << euler_angles_v[1] << ", " << euler_angles_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rwy_local_v[3]: " << d_cg_rwy_local_v[0] << ", " << d_cg_rwy_local_v[1] << ", " << d_cg_rwy_local_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rwy_rwy_v[3]: " << d_cg_rwy_rwy_v[0] << ", " << d_cg_rwy_rwy_v[1] << ", " << d_cg_rwy_rwy_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rwy_local_v[3]: " << d_pilot_rwy_local_v[0] << ", " << d_pilot_rwy_local_v[1] << ", " << d_pilot_rwy_local_v[2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rwy_rwy_v[3]: " << d_pilot_rwy_rwy_v[0] << ", " << d_pilot_rwy_rwy_v[1] << ", " << d_pilot_rwy_rwy_v[2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"t_local_to_body_m[0][3]: " << t_local_to_body_m[0][0] << ", " << t_local_to_body_m[0][1] << ", " << t_local_to_body_m[0][2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"t_local_to_body_m[1][3]: " << t_local_to_body_m[1][0] << ", " << t_local_to_body_m[1][1] << ", " << t_local_to_body_m[1][2]);
- FG_LOG(FG_FLIGHT,FG_INFO,"t_local_to_body_m[2][3]: " << t_local_to_body_m[2][0] << ", " << t_local_to_body_m[2][1] << ", " << t_local_to_body_m[2][2]);
-
- FG_LOG(FG_FLIGHT,FG_INFO,"mass: " << mass );
- FG_LOG(FG_FLIGHT,FG_INFO,"i_xx: " << i_xx );
- FG_LOG(FG_FLIGHT,FG_INFO,"i_yy: " << i_yy );
- FG_LOG(FG_FLIGHT,FG_INFO,"i_zz: " << i_zz );
- FG_LOG(FG_FLIGHT,FG_INFO,"i_xz: " << i_xz );
- FG_LOG(FG_FLIGHT,FG_INFO,"nlf: " << nlf );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_rel_wind: " << v_rel_wind );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_true_kts: " << v_true_kts );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_rel_ground: " << v_rel_ground );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_inertial: " << v_inertial );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_ground_speed: " << v_ground_speed );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_equiv: " << v_equiv );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_equiv_kts: " << v_equiv_kts );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_calibrated: " << v_calibrated );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_calibrated_kts: " << v_calibrated_kts );
- FG_LOG(FG_FLIGHT,FG_INFO,"gravity: " << gravity );
- FG_LOG(FG_FLIGHT,FG_INFO,"centrifugal_relief: " << centrifugal_relief );
- FG_LOG(FG_FLIGHT,FG_INFO,"alpha: " << alpha );
- FG_LOG(FG_FLIGHT,FG_INFO,"beta: " << beta );
- FG_LOG(FG_FLIGHT,FG_INFO,"alpha_dot: " << alpha_dot );
- FG_LOG(FG_FLIGHT,FG_INFO,"beta_dot: " << beta_dot );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_alpha: " << cos_alpha );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_alpha: " << sin_alpha );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_beta: " << cos_beta );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_beta: " << sin_beta );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_phi: " << cos_phi );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_phi: " << sin_phi );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_theta: " << cos_theta );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_theta: " << sin_theta );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_psi: " << cos_psi );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_psi: " << sin_psi );
- FG_LOG(FG_FLIGHT,FG_INFO,"gamma_vert_rad: " << gamma_vert_rad );
- FG_LOG(FG_FLIGHT,FG_INFO,"gamma_horiz_rad: " << gamma_horiz_rad );
- FG_LOG(FG_FLIGHT,FG_INFO,"sigma: " << sigma );
- FG_LOG(FG_FLIGHT,FG_INFO,"density: " << density );
- FG_LOG(FG_FLIGHT,FG_INFO,"v_sound: " << v_sound );
- FG_LOG(FG_FLIGHT,FG_INFO,"mach_number: " << mach_number );
- FG_LOG(FG_FLIGHT,FG_INFO,"static_pressure: " << static_pressure );
- FG_LOG(FG_FLIGHT,FG_INFO,"total_pressure: " << total_pressure );
- FG_LOG(FG_FLIGHT,FG_INFO,"impact_pressure: " << impact_pressure );
- FG_LOG(FG_FLIGHT,FG_INFO,"dynamic_pressure: " << dynamic_pressure );
- FG_LOG(FG_FLIGHT,FG_INFO,"static_temperature: " << static_temperature );
- FG_LOG(FG_FLIGHT,FG_INFO,"total_temperature: " << total_temperature );
- FG_LOG(FG_FLIGHT,FG_INFO,"sea_level_radius: " << sea_level_radius );
- FG_LOG(FG_FLIGHT,FG_INFO,"earth_position_angle: " << earth_position_angle );
- FG_LOG(FG_FLIGHT,FG_INFO,"runway_altitude: " << runway_altitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"runway_latitude: " << runway_latitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"runway_longitude: " << runway_longitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"runway_heading: " << runway_heading );
- FG_LOG(FG_FLIGHT,FG_INFO,"radius_to_rwy: " << radius_to_rwy );
- FG_LOG(FG_FLIGHT,FG_INFO,"climb_rate: " << climb_rate );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_lat_geocentric: " << sin_lat_geocentric );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_lat_geocentric: " << cos_lat_geocentric );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_longitude: " << sin_longitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_longitude: " << cos_longitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"sin_latitude: " << sin_latitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"cos_latitude: " << cos_latitude );
- FG_LOG(FG_FLIGHT,FG_INFO,"altitude_agl: " << altitude_agl );
+ SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[0][3]: " << t_local_to_body_m[0][0] << ", " << t_local_to_body_m[0][1] << ", " << t_local_to_body_m[0][2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[1][3]: " << t_local_to_body_m[1][0] << ", " << t_local_to_body_m[1][1] << ", " << t_local_to_body_m[1][2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[2][3]: " << t_local_to_body_m[2][0] << ", " << t_local_to_body_m[2][1] << ", " << t_local_to_body_m[2][2]);
+
+ SG_LOG(SG_FLIGHT,SG_INFO,"mass: " << mass );
+ SG_LOG(SG_FLIGHT,SG_INFO,"i_xx: " << i_xx );
+ SG_LOG(SG_FLIGHT,SG_INFO,"i_yy: " << i_yy );
+ SG_LOG(SG_FLIGHT,SG_INFO,"i_zz: " << i_zz );
+ SG_LOG(SG_FLIGHT,SG_INFO,"i_xz: " << i_xz );
+ SG_LOG(SG_FLIGHT,SG_INFO,"nlf: " << nlf );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_rel_wind: " << v_rel_wind );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_true_kts: " << v_true_kts );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_rel_ground: " << v_rel_ground );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_inertial: " << v_inertial );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_ground_speed: " << v_ground_speed );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_equiv: " << v_equiv );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_equiv_kts: " << v_equiv_kts );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_calibrated: " << v_calibrated );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_calibrated_kts: " << v_calibrated_kts );
+ SG_LOG(SG_FLIGHT,SG_INFO,"gravity: " << gravity );
+ SG_LOG(SG_FLIGHT,SG_INFO,"centrifugal_relief: " << centrifugal_relief );
+ SG_LOG(SG_FLIGHT,SG_INFO,"alpha: " << alpha );
+ SG_LOG(SG_FLIGHT,SG_INFO,"beta: " << beta );
+ SG_LOG(SG_FLIGHT,SG_INFO,"alpha_dot: " << alpha_dot );
+ SG_LOG(SG_FLIGHT,SG_INFO,"beta_dot: " << beta_dot );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_alpha: " << cos_alpha );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_alpha: " << sin_alpha );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_beta: " << cos_beta );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_beta: " << sin_beta );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_phi: " << cos_phi );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_phi: " << sin_phi );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_theta: " << cos_theta );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_theta: " << sin_theta );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_psi: " << cos_psi );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_psi: " << sin_psi );
+ SG_LOG(SG_FLIGHT,SG_INFO,"gamma_vert_rad: " << gamma_vert_rad );
+ SG_LOG(SG_FLIGHT,SG_INFO,"gamma_horiz_rad: " << gamma_horiz_rad );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sigma: " << sigma );
+ SG_LOG(SG_FLIGHT,SG_INFO,"density: " << density );
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_sound: " << v_sound );
+ SG_LOG(SG_FLIGHT,SG_INFO,"mach_number: " << mach_number );
+ SG_LOG(SG_FLIGHT,SG_INFO,"static_pressure: " << static_pressure );
+ SG_LOG(SG_FLIGHT,SG_INFO,"total_pressure: " << total_pressure );
+ SG_LOG(SG_FLIGHT,SG_INFO,"impact_pressure: " << impact_pressure );
+ SG_LOG(SG_FLIGHT,SG_INFO,"dynamic_pressure: " << dynamic_pressure );
+ SG_LOG(SG_FLIGHT,SG_INFO,"static_temperature: " << static_temperature );
+ SG_LOG(SG_FLIGHT,SG_INFO,"total_temperature: " << total_temperature );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sea_level_radius: " << sea_level_radius );
+ SG_LOG(SG_FLIGHT,SG_INFO,"earth_position_angle: " << earth_position_angle );
+ SG_LOG(SG_FLIGHT,SG_INFO,"runway_altitude: " << runway_altitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"runway_latitude: " << runway_latitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"runway_longitude: " << runway_longitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"runway_heading: " << runway_heading );
+ SG_LOG(SG_FLIGHT,SG_INFO,"radius_to_rwy: " << radius_to_rwy );
+ SG_LOG(SG_FLIGHT,SG_INFO,"climb_rate: " << climb_rate );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_lat_geocentric: " << sin_lat_geocentric );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_lat_geocentric: " << cos_lat_geocentric );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_longitude: " << sin_longitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_longitude: " << cos_longitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"sin_latitude: " << sin_latitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"cos_latitude: " << cos_latitude );
+ SG_LOG(SG_FLIGHT,SG_INFO,"altitude_agl: " << altitude_agl );
}
if ( AptId.length() ) {
// set initial position from airport id
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Attempting to set starting position from airport code "
<< AptId );
if (output.good() && fgSaveFlight(output)) {
output.close();
mkDialog("Saved flight");
- FG_LOG(FG_INPUT, FG_INFO, "Saved flight");
+ SG_LOG(SG_INPUT, SG_INFO, "Saved flight");
} else {
mkDialog("Cannot save flight");
- FG_LOG(FG_INPUT, FG_ALERT, "Cannot save flight");
+ SG_LOG(SG_INPUT, SG_ALERT, "Cannot save flight");
}
}
if (input.good() && fgLoadFlight(input)) {
input.close();
mkDialog("Loaded flight");
- FG_LOG(FG_INPUT, FG_INFO, "Restored flight");
+ SG_LOG(SG_INPUT, SG_INFO, "Restored flight");
} else {
mkDialog("Failed to load flight");
- FG_LOG(FG_INPUT, FG_ALERT, "Cannot load flight");
+ SG_LOG(SG_INPUT, SG_ALERT, "Cannot load flight");
}
}
void goodBye(puObject *)
{
- // FG_LOG( FG_INPUT, FG_ALERT,
+ // SG_LOG( SG_INPUT, SG_ALERT,
// "Program exiting normally at user request." );
cout << "Program exiting normally at user request." << endl;
y = _mY - (int)(offset * elevator_sensitivity);
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
- FG_LOG( FG_INPUT, FG_INFO, "Mouse in yoke mode" );
+ SG_LOG( SG_INPUT, SG_INFO, "Mouse in yoke mode" );
break;
case MOUSE_YOKE:
Quat0();
build_rotmatrix(GuiQuat_mat, curGuiQuat);
glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
- FG_LOG( FG_INPUT, FG_INFO, "Mouse in view mode" );
+ SG_LOG( SG_INPUT, SG_INFO, "Mouse in view mode" );
break;
case MOUSE_VIEW:
if(!gui_menu_on)
TurnCursorOff();
- FG_LOG( FG_INPUT, FG_INFO, "Mouse in pointer mode" );
+ SG_LOG( SG_INPUT, SG_INFO, "Mouse in pointer mode" );
break;
}
glutWarpPointer( x, y );
{
bool seen_joystick = false;
- FG_LOG(FG_INPUT, FG_INFO, "Initializing joysticks");
+ SG_LOG(SG_INPUT, SG_INFO, "Initializing joysticks");
for (int i = 0; i < MAX_JOYSTICKS; i++) {
jsJoystick * js = new jsJoystick(i);
joysticks[i].js = js;
if (js->notWorking()) {
- FG_LOG(FG_INPUT, FG_INFO, "Joystick " << i << " not found");
+ SG_LOG(SG_INPUT, SG_INFO, "Joystick " << i << " not found");
continue;
}
#ifdef WIN32
joysticks[i].naxes = naxes;
joysticks[i].nbuttons = nbuttons;
- FG_LOG(FG_INPUT, FG_INFO, "Initializing joystick " << i);
+ SG_LOG(SG_INPUT, SG_INFO, "Initializing joystick " << i);
seen_joystick = true;
// Set up range arrays
base += jsNames[i];
base += '/';
base += axisNames[j];
- FG_LOG(FG_INPUT, FG_INFO, " Axis " << j << ':');
+ SG_LOG(SG_INPUT, SG_INFO, " Axis " << j << ':');
// Control property
string name = base;
name += "/control";
SGValue * value = fgGetValue(name);
if (value == 0) {
- FG_LOG(FG_INPUT, FG_INFO, " no control defined");
+ SG_LOG(SG_INPUT, SG_INFO, " no control defined");
continue;
}
const string &control = value->getStringValue();
a.value = fgGetValue(control, true);
- FG_LOG(FG_INPUT, FG_INFO, " using control " << control);
+ SG_LOG(SG_INPUT, SG_INFO, " using control " << control);
// Dead band
name = base;
value = fgGetValue(name);
if (value != 0)
js->setDeadBand(j, value->getDoubleValue());
- FG_LOG(FG_INPUT, FG_INFO, " dead-band is " << js->getDeadBand(j));
+ SG_LOG(SG_INPUT, SG_INFO, " dead-band is " << js->getDeadBand(j));
// Offset
name = base;
value = fgGetValue(name);
if (value != 0)
a.offset = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " offset is " << a.offset);
+ SG_LOG(SG_INPUT, SG_INFO, " offset is " << a.offset);
// Factor
value = fgGetValue(name);
if (value != 0)
a.factor = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " factor is " << a.factor);
+ SG_LOG(SG_INPUT, SG_INFO, " factor is " << a.factor);
// Tolerance
value = fgGetValue(name);
if (value != 0)
a.tolerance = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " tolerance is " << a.tolerance);
+ SG_LOG(SG_INPUT, SG_INFO, " tolerance is " << a.tolerance);
// Saturation
value = fgGetValue(name);
if (value != 0)
js->setSaturation(j, value->getDoubleValue());
- FG_LOG(FG_INPUT, FG_INFO, " saturation is " << js->getSaturation(j));
+ SG_LOG(SG_INPUT, SG_INFO, " saturation is " << js->getSaturation(j));
// Minimum range
name = base;
value = fgGetValue(name);
if (value != 0)
minRange[j] = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " min-range is " << minRange[j]);
+ SG_LOG(SG_INPUT, SG_INFO, " min-range is " << minRange[j]);
// Maximum range
name = base;
value = fgGetValue(name);
if (value != 0)
maxRange[j] = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " max-range is " << maxRange[j]);
+ SG_LOG(SG_INPUT, SG_INFO, " max-range is " << maxRange[j]);
// Center
name = base;
value = fgGetValue(name);
if (value != 0)
center[j] = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " center is " << center[j]);
+ SG_LOG(SG_INPUT, SG_INFO, " center is " << center[j]);
// Capture
name = base;
a.capture->captured = false;
a.capture->name = control;
a.capture->value = fgGetValue(trimname);
- FG_LOG(FG_INPUT, FG_INFO, " capture is "
+ SG_LOG(SG_INPUT, SG_INFO, " capture is "
<< value->getDoubleValue() );
} else {
a.capture = NULL;
- FG_LOG(FG_INPUT, FG_INFO, " capture is "
+ SG_LOG(SG_INPUT, SG_INFO, " capture is "
<< "unsupported by FDM" );
}
}
base += jsNames[i];
base += '/';
base += buttonNames[j];
- FG_LOG(FG_INPUT, FG_INFO, " Button " << j << ':');
+ SG_LOG(SG_INPUT, SG_INFO, " Button " << j << ':');
// Control property
string name = base;
cout << "Trying name " << name << endl;
SGValue * value = fgGetValue(name);
if (value == 0) {
- FG_LOG(FG_INPUT, FG_INFO, " no control defined");
+ SG_LOG(SG_INPUT, SG_INFO, " no control defined");
continue;
}
const string &control = value->getStringValue();
b.value = fgGetValue(control, true);
- FG_LOG(FG_INPUT, FG_INFO, " using control " << control);
+ SG_LOG(SG_INPUT, SG_INFO, " using control " << control);
// Step
name = base;
value = fgGetValue(name);
if (value != 0)
b.step = value->getDoubleValue();
- FG_LOG(FG_INPUT, FG_INFO, " step is " << b.step);
+ SG_LOG(SG_INPUT, SG_INFO, " step is " << b.step);
// Type
name = base;
b.action = button::ADJUST;
b.isRepeatable = true;
} else {
- FG_LOG(FG_INPUT, FG_ALERT, " unknown action " << action);
+ SG_LOG(SG_INPUT, SG_ALERT, " unknown action " << action);
action = "adjust";
b.action = button::ADJUST;
b.isRepeatable = true;
}
- FG_LOG(FG_INPUT, FG_INFO, " action is " << action);
+ SG_LOG(SG_INPUT, SG_INFO, " action is " << action);
// Repeatability.
name = base;
value = fgGetValue(name);
if (value != 0)
b.isRepeatable = value->getBoolValue();
- FG_LOG(FG_INPUT, FG_INFO, (b.isRepeatable ?
+ SG_LOG(SG_INPUT, SG_INFO, (b.isRepeatable ?
" repeatable" : " not repeatable"));
}
trimmed = fgGetValue("/fdm/trim/trimmed");
if (seen_joystick)
- FG_LOG(FG_INPUT, FG_INFO, "Done initializing joysticks");
+ SG_LOG(SG_INPUT, SG_INFO, "Done initializing joysticks");
else
- FG_LOG(FG_INPUT, FG_ALERT, "No joysticks detected");
+ SG_LOG(SG_INPUT, SG_ALERT, "No joysticks detected");
return seen_joystick;
}
// joystick. When a trim succeeds, the above
// is true for one frame only.
a.capture->captured = false;
- FG_LOG( FG_GENERAL, FG_INFO, "Successful trim, capture is " <<
+ SG_LOG( SG_GENERAL, SG_INFO, "Successful trim, capture is " <<
"enabled on " << a.capture->name );
}
if ( a.capture && !a.capture->captured ) {
diff = js_val - a.capture->value->getDoubleValue();
- FG_LOG( FG_GENERAL, FG_INFO, a.capture->name
+ SG_LOG( SG_GENERAL, SG_INFO, a.capture->name
<< " capture: " << diff );
if ( fabs( diff ) < a.capture->tolerance ) {
flag = a.value->setDoubleValue( js_val );
a.capture->captured = true;
- FG_LOG(FG_GENERAL,FG_INFO, a.capture->name
+ SG_LOG(SG_GENERAL,SG_INFO, a.capture->name
<< " captured." );
}
} else {
}
if (!flag)
- FG_LOG(FG_INPUT, FG_ALERT, "Failed to set value for joystick "
+ SG_LOG(SG_INPUT, SG_ALERT, "Failed to set value for joystick "
<< i << ", axis " << j);
}
b.lastState = 0;
}
if (!flag)
- FG_LOG(FG_INPUT, FG_ALERT, "Failed to set value for "
+ SG_LOG(SG_INPUT, SG_ALERT, "Failed to set value for "
<< jsNames[i] << ' ' << buttonNames[j]);
}
}
// that's going to get clobbered
// when we reinit the subsystems.
- FG_LOG(FG_GENERAL, FG_INFO, "Starting BFI reinit");
+ SG_LOG(SG_GENERAL, SG_INFO, "Starting BFI reinit");
// TODO: add more AP stuff
bool apHeadingLock = FGBFI::getAPHeadingLock();
_needReinit = false;
- FG_LOG(FG_GENERAL, FG_INFO, "Ending BFI reinit");
+ SG_LOG(SG_GENERAL, SG_INFO, "Ending BFI reinit");
}
// BEGIN: kludge
void
FGBFI::init ()
{
- FG_LOG(FG_GENERAL, FG_INFO, "Starting BFI init");
+ SG_LOG(SG_GENERAL, SG_INFO, "Starting BFI init");
// Simulation
fgTie("/sim/aircraft-dir", getAircraftDir, setAircraftDir);
_needReinit = false;
- FG_LOG(FG_GENERAL, FG_INFO, "Ending BFI init");
+ SG_LOG(SG_GENERAL, SG_INFO, "Ending BFI init");
}
// if the save file has been edited
// by hand.
if (ret != 6) {
- FG_LOG(FG_INPUT, FG_ALERT, "Date/time string " << date_string
+ SG_LOG(SG_INPUT, SG_ALERT, "Date/time string " << date_string
<< " not in YYYY-MM-DDTHH:MM:SS format; skipped");
return;
}
#endif
}
- FG_LOG(FG_INPUT, FG_INFO, "fg_root = " << root );
+ SG_LOG(SG_INPUT, SG_INFO, "fg_root = " << root );
globals->set_fg_root(root);
return true;
// Read global preferences from $FG_ROOT/preferences.xml
FGPath props_path(globals->get_fg_root());
props_path.append("preferences.xml");
- FG_LOG(FG_INPUT, FG_INFO, "Reading global preferences");
+ SG_LOG(SG_INPUT, SG_INFO, "Reading global preferences");
if (!readProperties(props_path.str(), globals->get_props())) {
- FG_LOG(FG_INPUT, FG_ALERT, "Failed to read global preferences from "
+ SG_LOG(SG_INPUT, SG_ALERT, "Failed to read global preferences from "
<< props_path.str());
} else {
- FG_LOG(FG_INPUT, FG_INFO, "Finished Reading global preferences");
+ SG_LOG(SG_INPUT, SG_INFO, "Finished Reading global preferences");
}
// Attempt to locate and parse the various config files in order
path.append( "simple.mk4" );
FGAirports airports( path.c_str() );
- FG_LOG( FG_GENERAL, FG_INFO, "Searching for airport code = " << id );
+ SG_LOG( SG_GENERAL, SG_INFO, "Searching for airport code = " << id );
if ( ! airports.search( id, a ) ) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Failed to find " << id << " in " << path.str() );
return false;
}
return false;
}
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is ("
<< a->longitude << ", "
<< a->latitude << ")" );
FGAirport a;
// double lon, lat;
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Attempting to set starting position from airport code " << id );
if ( fgFindAirportID( id, &a ) ) {
fgSetDouble("/position/longitude", a.longitude );
fgSetDouble("/position/latitude", a.latitude );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is ("
<< a.longitude << ", "
<< a.latitude << ")" );
path.append( "runways.mk4" );
FGRunways runways( path.c_str() );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Attempting to set starting position from runway code "
<< id << " heading " << tgt_hdg );
// airports.dump_gdbm( outpath.c_str() );
if ( ! runways.search( id, &r ) ) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Failed to find " << id << " in database." );
return false;
}
while ( diff < -180.0 ) { diff += 360.0; }
while ( diff > 180.0 ) { diff -= 360.0; }
diff = fabs(diff);
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Runway " << r.rwy_no << " heading = " << r.heading <<
" diff = " << diff );
if ( diff < min_diff ) {
while ( diff < -180.0 ) { diff += 360.0; }
while ( diff > 180.0 ) { diff -= 360.0; }
diff = fabs(diff);
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Runway -" << r.rwy_no << " heading = " <<
r.heading + 180.0 <<
" diff = " << diff );
runways.next( &r );
}
- FG_LOG( FG_GENERAL, FG_INFO, "closest runway = " << found_r.rwy_no
+ SG_LOG( SG_GENERAL, SG_INFO, "closest runway = " << found_r.rwy_no
<< " + " << found_dir );
} else {
double azimuth = found_r.heading + found_dir + 180.0;
while ( azimuth >= 360.0 ) { azimuth -= 360.0; }
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"runway = " << found_r.lon << ", " << found_r.lat
<< " length = " << found_r.length * SG_FEET_TO_METER * 0.5
<< " heading = " << azimuth );
fgSetDouble("/position/latitude", lat2 );
fgSetDouble("/orientation/heading", heading );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Position for " << id << " is ("
<< lon2 << ", "
<< lat2 << ") new heading is "
f->set_Longitude( fgGetDouble("/position/longitude") * SGD_DEGREES_TO_RADIANS );
f->set_Latitude( fgGetDouble("/position/latitude") * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"scenery.cur_elev = " << scenery.cur_elev );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"/position/altitude = " << fgGetDouble("/position/altitude") );
// if we requested on ground startups
(scenery.cur_elev + 1) * METERS_TO_FEET );
}
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"starting altitude is = " <<
fgGetDouble("/position/altitude") );
f->set_Altitude( fgGetDouble("/position/altitude") );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Initial position is: ("
<< (f->get_Longitude() * SGD_RADIANS_TO_DEGREES) << ", "
<< (f->get_Latitude() * SGD_RADIANS_TO_DEGREES) << ", "
char *mesa_win_state;
#endif
- FG_LOG( FG_GENERAL, FG_INFO, "General Initialization" );
- FG_LOG( FG_GENERAL, FG_INFO, "======= ==============" );
+ SG_LOG( SG_GENERAL, SG_INFO, "General Initialization" );
+ SG_LOG( SG_GENERAL, SG_INFO, "======= ==============" );
root = globals->get_fg_root();
if ( ! root.length() ) {
// No root path set? Then bail ...
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Cannot continue without environment variable FG_ROOT"
<< "being defined." );
exit(-1);
}
- FG_LOG( FG_GENERAL, FG_INFO, "FG_ROOT = " << '"' << root << '"' << endl );
+ SG_LOG( SG_GENERAL, SG_INFO, "FG_ROOT = " << '"' << root << '"' << endl );
#if defined(FX) && defined(XMESA)
// initialize full screen flag
fgGetDouble("/velocities/speed-east"),
fgGetDouble("/velocities/speed-down"));
} else {
- FG_LOG(FG_GENERAL, FG_ALERT,
+ SG_LOG(SG_GENERAL, SG_ALERT,
"Unrecognized value for /sim/startup/speed-set: " << speedset);
current_aircraft.fdm_state->set_V_calibrated_kts(0.0);
}
bool fgInitSubsystems( void ) {
fgLIGHT *l = &cur_light_params;
- FG_LOG( FG_GENERAL, FG_INFO, "Initialize Subsystems");
- FG_LOG( FG_GENERAL, FG_INFO, "========== ==========");
+ SG_LOG( SG_GENERAL, SG_INFO, "Initialize Subsystems");
+ SG_LOG( SG_GENERAL, SG_INFO, "========== ==========");
// Initialize the material property lib
FGPath mpath( globals->get_fg_root() );
mpath.append( "materials" );
if ( material_lib.load( mpath.str() ) ) {
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error loading material lib!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error loading material lib!" );
exit(-1);
}
if ( fgSceneryInit() ) {
// Material lib initialized ok.
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Scenery initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Scenery initialization!" );
exit(-1);
}
global_tile_mgr.update( fgGetDouble("/position/longitude"),
fgGetDouble("/position/latitude") );
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Tile Manager initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Tile Manager initialization!" );
exit(-1);
}
- FG_LOG( FG_GENERAL, FG_DEBUG,
+ SG_LOG( SG_GENERAL, SG_DEBUG,
"Current terrain elevation after tile mgr init " <<
scenery.cur_elev );
} else if (model == "external") {
cur_fdm_state = new FGExternal( dt );
} else {
- FG_LOG(FG_GENERAL, FG_ALERT,
+ SG_LOG(SG_GENERAL, SG_ALERT,
"Unrecognized flight model '" << model
<< ", can't init aircraft");
exit(-1);
// now handled inside of the fgTileMgrUpdate()
// Reset our altitude if we are below ground
- FG_LOG( FG_GENERAL, FG_DEBUG, "Current altitude = "
+ SG_LOG( SG_GENERAL, SG_DEBUG, "Current altitude = "
<< cur_fdm_state->get_Altitude() );
- FG_LOG( FG_GENERAL, FG_DEBUG, "Current runway altitude = " <<
+ SG_LOG( SG_GENERAL, SG_DEBUG, "Current runway altitude = " <<
cur_fdm_state->get_Runway_altitude() );
if ( cur_fdm_state->get_Altitude() < cur_fdm_state->get_Runway_altitude() +
3.758099 );
}
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Updated position (after elevation adj): ("
<< (cur_fdm_state->get_Latitude() * SGD_RADIANS_TO_DEGREES) << ", "
<< (cur_fdm_state->get_Longitude() * SGD_RADIANS_TO_DEGREES) << ", "
// set current view to 0 (first) which is our main pilot view
globals->set_current_view( pilot_view );
- FG_LOG( FG_GENERAL, FG_DEBUG, " abs_view_pos = "
+ SG_LOG( SG_GENERAL, SG_DEBUG, " abs_view_pos = "
<< globals->get_current_view()->get_abs_view_pos());
// fgUpdateSunPos() needs a few position and view parameters set
// Initialize the weather modeling subsystem
#ifndef FG_OLD_WEATHER
// Initialize the WeatherDatabase
- FG_LOG(FG_GENERAL, FG_INFO, "Creating LocalWeatherDatabase");
+ SG_LOG(SG_GENERAL, SG_INFO, "Creating LocalWeatherDatabase");
sgVec3 position;
sgSetVec3( position, current_aircraft.fdm_state->get_Latitude(),
current_aircraft.fdm_state->get_Longitude(),
#endif
// Initialize vor/ndb/ils/fix list management and query systems
- FG_LOG(FG_GENERAL, FG_INFO, "Loading Navaids");
+ SG_LOG(SG_GENERAL, SG_INFO, "Loading Navaids");
- FG_LOG(FG_GENERAL, FG_INFO, " VOR/NDB");
+ SG_LOG(SG_GENERAL, SG_INFO, " VOR/NDB");
current_navlist = new FGNavList;
FGPath p_nav( globals->get_fg_root() );
p_nav.append( "Navaids/default.nav" );
current_navlist->init( p_nav );
- FG_LOG(FG_GENERAL, FG_INFO, " ILS and Marker Beacons");
+ SG_LOG(SG_GENERAL, SG_INFO, " ILS and Marker Beacons");
current_beacons = new FGMarkerBeacons;
current_beacons->init();
current_ilslist = new FGILSList;
p_ils.append( "Navaids/default.ils" );
current_ilslist->init( p_ils );
- FG_LOG(FG_GENERAL, FG_INFO, " Fixes");
+ SG_LOG(SG_GENERAL, SG_INFO, " Fixes");
current_fixlist = new FGFixList;
FGPath p_fix( globals->get_fg_root() );
p_fix.append( "Navaids/default.fix" );
if( fgCockpitInit( ¤t_aircraft )) {
// Cockpit initialized ok.
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Cockpit initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Cockpit initialization!" );
exit(-1);
}
// if ( cur_fdm_state->init( 1.0 / fgGetInt("/sim/model-hz") ) ) {
// // fdm init successful
// } else {
-// FG_LOG( FG_GENERAL, FG_ALERT, "FDM init() failed! Cannot continue." );
+// SG_LOG( SG_GENERAL, SG_ALERT, "FDM init() failed! Cannot continue." );
// exit(-1);
// }
3.758099 );
}
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Updated position (after elevation adj): ("
<< (cur_fdm_state->get_Latitude() * SGD_RADIANS_TO_DEGREES) << ", "
<< (cur_fdm_state->get_Longitude() * SGD_RADIANS_TO_DEGREES) << ", "
// Joystick support
if ( ! fgJoystickInit() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Joystick initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Joystick initialization!" );
}
// Autopilot init
"Panels/Default/default.xml");
current_panel = fgReadPanel(panel_path);
if (current_panel == 0) {
- FG_LOG( FG_INPUT, FG_ALERT,
+ SG_LOG( SG_INPUT, SG_ALERT,
"Error reading new panel from " << panel_path );
} else {
- FG_LOG( FG_INPUT, FG_INFO, "Loaded new panel from " << panel_path );
+ SG_LOG( SG_INPUT, SG_INFO, "Loaded new panel from " << panel_path );
current_panel->init();
current_panel->bind();
}
controls.init();
controls.bind();
- FG_LOG( FG_GENERAL, FG_INFO, endl);
+ SG_LOG( SG_GENERAL, SG_INFO, endl);
// Save the initial state for future
// reference.
void fgReInitSubsystems( void )
{
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"/position/altitude = " << fgGetDouble("/position/altitude") );
bool freeze = globals->get_freeze();
// Initialize the Scenery Management subsystem
if ( ! fgSceneryInit() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Scenery initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Scenery initialization!" );
exit(-1);
}
global_tile_mgr.update( fgGetDouble("/position/longitude"),
fgGetDouble("/position/latitude") );
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Error in Tile Manager initialization!" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Error in Tile Manager initialization!" );
exit(-1);
}
fgInitPosition();
// Reset our altitude if we are below ground
- FG_LOG( FG_GENERAL, FG_DEBUG, "Current altitude = "
+ SG_LOG( SG_GENERAL, SG_DEBUG, "Current altitude = "
<< cur_fdm_state->get_Altitude() );
- FG_LOG( FG_GENERAL, FG_DEBUG, "Current runway altitude = "
+ SG_LOG( SG_GENERAL, SG_DEBUG, "Current runway altitude = "
<< cur_fdm_state->get_Runway_altitude() );
if ( cur_fdm_state->get_Altitude() <
// set current view to 0 (first) which is our main pilot view
globals->set_current_view( pilot_view );
- FG_LOG( FG_GENERAL, FG_DEBUG, " abs_view_pos = "
+ SG_LOG( SG_GENERAL, SG_DEBUG, " abs_view_pos = "
<< globals->get_current_view()->get_abs_view_pos());
cur_fdm_state->init();
begin = 0;
- FG_LOG( FG_IO, FG_INFO, "Parse I/O channel request: " << config );
+ SG_LOG( SG_IO, SG_INFO, "Parse I/O channel request: " << config );
// determine protocol
end = config.find(",", begin);
string protocol = config.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " protocol = " << protocol );
+ SG_LOG( SG_IO, SG_INFO, " protocol = " << protocol );
FGProtocol *io;
if ( protocol == "atlas" ) {
string medium = config.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " medium = " << medium );
+ SG_LOG( SG_IO, SG_INFO, " medium = " << medium );
// determine direction
end = config.find(",", begin);
string direction = config.substr(begin, end - begin);
begin = end + 1;
io->set_direction( direction );
- FG_LOG( FG_IO, FG_INFO, " direction = " << direction );
+ SG_LOG( SG_IO, SG_INFO, " direction = " << direction );
// determine hertz
end = config.find(",", begin);
begin = end + 1;
double hertz = atof( hertz_str.c_str() );
io->set_hz( hertz );
- FG_LOG( FG_IO, FG_INFO, " hertz = " << hertz );
+ SG_LOG( SG_IO, SG_INFO, " hertz = " << hertz );
if ( medium == "serial" ) {
// device name
string device = config.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " device = " << device );
+ SG_LOG( SG_IO, SG_INFO, " device = " << device );
// baud
string baud = config.substr(begin);
- FG_LOG( FG_IO, FG_INFO, " baud = " << baud );
+ SG_LOG( SG_IO, SG_INFO, " baud = " << baud );
SGSerial *ch = new SGSerial( device, baud );
io->set_io_channel( ch );
} else if ( medium == "file" ) {
// file name
string file = config.substr(begin);
- FG_LOG( FG_IO, FG_INFO, " file name = " << file );
+ SG_LOG( SG_IO, SG_INFO, " file name = " << file );
SGFile *ch = new SGFile( file );
io->set_io_channel( ch );
string hostname = config.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " hostname = " << hostname );
+ SG_LOG( SG_IO, SG_INFO, " hostname = " << hostname );
// port string
end = config.find(",", begin);
string port = config.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " port string = " << port );
+ SG_LOG( SG_IO, SG_INFO, " port string = " << port );
// socket style
string style_str = config.substr(begin);
- FG_LOG( FG_IO, FG_INFO, " style string = " << style_str );
+ SG_LOG( SG_IO, SG_INFO, " style string = " << style_str );
SGSocket *ch = new SGSocket( hostname, port, style_str );
io->set_io_channel( ch );
// step through the port config streams (from fgOPTIONS) and setup
// serial port channels for each
void fgIOInit() {
- // FG_LOG( FG_IO, FG_INFO, "I/O Channel initialization, " <<
+ // SG_LOG( SG_IO, SG_INFO, "I/O Channel initialization, " <<
// globals->get_channel_options_list()->size() << " requests." );
FGProtocol *p;
p->open();
global_io_list.push_back( p );
if ( !p->is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "I/O Channel config failed." );
+ SG_LOG( SG_IO, SG_ALERT, "I/O Channel config failed." );
exit(-1);
}
} else {
- FG_LOG( FG_IO, FG_INFO, "I/O Channel parse failed." );
+ SG_LOG( SG_IO, SG_INFO, "I/O Channel parse failed." );
}
}
}
// new initial state.
globals->saveInitialState();
} else {
- FG_LOG(FG_INPUT, FG_ALERT, "Error restoring flight; aborted");
+ SG_LOG(SG_INPUT, SG_ALERT, "Error restoring flight; aborted");
return false;
}
}
fgUntie (const string &name)
{
if (!globals->get_props()->untie(name))
- FG_LOG(FG_GENERAL, FG_WARN, "Failed to untie property " << name);
+ SG_LOG(SG_GENERAL, SG_WARN, "Failed to untie property " << name);
}
{
if (!globals->get_props()->tie(name, SGRawValuePointer<bool>(pointer),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to a pointer");
}
{
if (!globals->get_props()->tie(name, SGRawValuePointer<int>(pointer),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to a pointer");
}
{
if (!globals->get_props()->tie(name, SGRawValuePointer<float>(pointer),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to a pointer");
}
{
if (!globals->get_props()->tie(name, SGRawValuePointer<double>(pointer),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to a pointer");
}
{
if (!globals->get_props()->tie(name, SGRawValuePointer<string>(pointer),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to a pointer");
}
{
if (!globals->get_props()->tie(name, SGRawValueFunctions<V>(getter, setter),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to functions");
}
getter,
setter),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to indexed functions");
}
if (!globals->get_props()->tie(name,
SGRawValueMethods<T,V>(*obj, getter, setter),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to object methods");
}
getter,
setter),
useDefault))
- FG_LOG(FG_GENERAL, FG_WARN,
+ SG_LOG(SG_GENERAL, SG_WARN,
"Failed to tie property " << name << " to indexed object methods");
}
delete initial_state;
initial_state = new SGPropertyNode();
if (!copyProperties(props, initial_state))
- FG_LOG(FG_GENERAL, FG_ALERT, "Error saving initial state");
+ SG_LOG(SG_GENERAL, SG_ALERT, "Error saving initial state");
}
FGGlobals::restoreInitialState ()
{
if (initial_state == 0) {
- FG_LOG(FG_GENERAL, FG_ALERT, "No initial state available to restore!!!");
+ SG_LOG(SG_GENERAL, SG_ALERT, "No initial state available to restore!!!");
} else if (!copyProperties(initial_state, props)) {
- FG_LOG(FG_GENERAL, FG_INFO,
+ SG_LOG(SG_GENERAL, SG_INFO,
"Some errors restoring initial state (probably just read-only props)");
} else {
- FG_LOG(FG_GENERAL, FG_INFO, "Initial state restored successfully");
+ SG_LOG(SG_GENERAL, SG_INFO, "Initial state restored successfully");
}
}
FGInterface *f = current_aircraft.fdm_state;
FGViewer *v = globals->get_current_view();
- FG_LOG( FG_INPUT, FG_DEBUG, "Key hit = " << k );
+ SG_LOG( SG_INPUT, SG_DEBUG, "Key hit = " << k );
if ( puKeyboard(k, PU_DOWN) ) {
return;
}
if ( GLUT_ACTIVE_ALT && glutGetModifiers() ) {
- FG_LOG( FG_INPUT, FG_DEBUG, " SHIFTED" );
+ SG_LOG( SG_INPUT, SG_DEBUG, " SHIFTED" );
switch (k) {
case 1: // Ctrl-A key
current_autopilot->set_AltitudeMode(
return;
}
} else {
- FG_LOG( FG_INPUT, FG_DEBUG, "" );
+ SG_LOG( SG_INPUT, SG_DEBUG, "" );
switch (k) {
case 50: // numeric keypad 2
if ( current_autopilot->get_AltitudeEnabled() ) {
return;
case 91: // [ key
controls.move_flaps(-0.34);
- FG_LOG( FG_INPUT, FG_INFO,
+ SG_LOG( SG_INPUT, SG_INFO,
"Set flaps to " << controls.get_flaps() );
return;
case 93: // ] key
controls.move_flaps(0.34);
- FG_LOG( FG_INPUT, FG_INFO,
+ SG_LOG( SG_INPUT, SG_INFO,
"Set flaps to " << controls.get_flaps() );
return;
case 97: // a key
tile_path.append( p.gen_index_str() );
// printf position and attitude information
- FG_LOG( FG_INPUT, FG_INFO,
+ SG_LOG( SG_INPUT, SG_INFO,
"Lon = " << f->get_Longitude() * SGD_RADIANS_TO_DEGREES
<< " Lat = " << f->get_Latitude() * SGD_RADIANS_TO_DEGREES
<< " Altitude = " << f->get_Altitude() * SG_FEET_TO_METER
);
- FG_LOG( FG_INPUT, FG_INFO,
+ SG_LOG( SG_INPUT, SG_INFO,
"Heading = " << f->get_Psi() * SGD_RADIANS_TO_DEGREES
<< " Roll = " << f->get_Phi() * SGD_RADIANS_TO_DEGREES
<< " Pitch = " << f->get_Theta() * SGD_RADIANS_TO_DEGREES );
- FG_LOG( FG_INPUT, FG_INFO, tile_path.c_str());
+ SG_LOG( SG_INPUT, SG_INFO, tile_path.c_str());
}
return;
case 116: // t key
// if( fg_DebugOutput ) {
// fclose( fg_DebugOutput );
// }
- FG_LOG( FG_INPUT, FG_ALERT,
+ SG_LOG( SG_INPUT, SG_ALERT,
"Program exit requested." );
ConfirmExitDialog();
return;
void GLUTspecialkey(int k, int x, int y) {
FGViewer *v = globals->get_current_view();
- FG_LOG( FG_INPUT, FG_DEBUG, "Special key hit = " << k );
+ SG_LOG( SG_INPUT, SG_DEBUG, "Special key hit = " << k );
if ( puKeyboard(k + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN) ) {
return;
}
if ( GLUT_ACTIVE_SHIFT && glutGetModifiers() ) {
- FG_LOG( FG_INPUT, FG_DEBUG, " SHIFTED" );
+ SG_LOG( SG_INPUT, SG_DEBUG, " SHIFTED" );
switch (k) {
case GLUT_KEY_F1: {
ifstream input("fgfs.sav");
if (input.good() && fgLoadFlight(input)) {
input.close();
- FG_LOG(FG_INPUT, FG_INFO, "Restored flight from fgfs.sav");
+ SG_LOG(SG_INPUT, SG_INFO, "Restored flight from fgfs.sav");
} else {
- FG_LOG(FG_INPUT, FG_ALERT, "Cannot load flight from fgfs.sav");
+ SG_LOG(SG_INPUT, SG_ALERT, "Cannot load flight from fgfs.sav");
}
return;
}
case GLUT_KEY_F2: {
- FG_LOG(FG_INPUT, FG_INFO, "Saving flight");
+ SG_LOG(SG_INPUT, SG_INFO, "Saving flight");
cerr << "Opening output stream" << endl;
ofstream output("fgfs.sav");
cerr << "output stream opened" << endl;
if (output.good() && fgSaveFlight(output)) {
output.close();
- FG_LOG(FG_INPUT, FG_INFO, "Saved flight to fgfs.sav");
+ SG_LOG(SG_INPUT, SG_INFO, "Saved flight to fgfs.sav");
} else {
- FG_LOG(FG_INPUT, FG_ALERT, "Cannot save flight to fgfs.sav");
+ SG_LOG(SG_INPUT, SG_ALERT, "Cannot save flight to fgfs.sav");
}
return;
}
fgGetString("/sim/panel/path", "Panels/Default/default.xml");
FGPanel * new_panel = fgReadPanel(panel_path);
if (new_panel == 0) {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"Error reading new panel from " << panel_path);
return;
}
- FG_LOG(FG_INPUT, FG_INFO, "Loaded new panel from " << panel_path);
+ SG_LOG(SG_INPUT, SG_INFO, "Loaded new panel from " << panel_path);
current_panel->unbind();
delete current_panel;
current_panel = new_panel;
case GLUT_KEY_F4: {
FGPath props_path(globals->get_fg_root());
props_path.append("preferences.xml");
- FG_LOG(FG_INPUT, FG_INFO, "Rereading global preferences");
+ SG_LOG(SG_INPUT, SG_INFO, "Rereading global preferences");
if (!readProperties(props_path.str(), globals->get_props())) {
- FG_LOG(FG_INPUT, FG_ALERT,
+ SG_LOG(SG_INPUT, SG_ALERT,
"Failed to reread global preferences from "
<< props_path.str());
} else {
- FG_LOG(FG_INPUT, FG_INFO, "Finished Reading global preferences");
+ SG_LOG(SG_INPUT, SG_INFO, "Finished Reading global preferences");
}
return;
}
return;
}
} else {
- FG_LOG( FG_INPUT, FG_DEBUG, "" );
+ SG_LOG( SG_INPUT, SG_DEBUG, "" );
switch (k) {
case GLUT_KEY_F2: // F2 Reload Tile Cache...
{
bool freeze = globals->get_freeze();
- FG_LOG(FG_INPUT, FG_INFO, "ReIniting TileCache");
+ SG_LOG(SG_INPUT, SG_INFO, "ReIniting TileCache");
if ( !freeze )
globals->set_freeze( true );
BusyCursor(0);
cur_fdm_state->get_Longitude() * SGD_RADIANS_TO_DEGREES,
cur_fdm_state->get_Latitude() * SGD_RADIANS_TO_DEGREES );
} else {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Error in Tile Manager initialization!" );
exit(-1);
}
const string &fog = fgGetString("/sim/rendering/fog");
if (fog == "disabled") {
fgSetString("/sim/rendering/fog", "fastest");
- FG_LOG(FG_INPUT, FG_INFO, "Fog enabled, hint=fastest");
+ SG_LOG(SG_INPUT, SG_INFO, "Fog enabled, hint=fastest");
} else if (fog == "fastest") {
fgSetString("/sim/rendering/fog", "nicest");
- FG_LOG(FG_INPUT, FG_INFO, "Fog enabled, hint=nicest");
+ SG_LOG(SG_INPUT, SG_INFO, "Fog enabled, hint=nicest");
} else if (fog == "nicest") {
fgSetString("/sim/rendering/fog", "disabled");
- FG_LOG(FG_INPUT, FG_INFO, "Fog disabled");
+ SG_LOG(SG_INPUT, SG_INFO, "Fog disabled");
} else {
fgSetString("/sim/rendering/fog", "disabled");
- FG_LOG(FG_INPUT, FG_ALERT, "Unrecognized fog type "
+ SG_LOG(SG_INPUT, SG_ALERT, "Unrecognized fog type "
<< fog << ", changed to 'disabled'");
}
return;
}
case GLUT_KEY_F9: // F9 toggles textures on and off...
- FG_LOG( FG_INPUT, FG_INFO, "Toggling texture" );
+ SG_LOG( SG_INPUT, SG_INFO, "Toggling texture" );
if ( fgGetBool("/sim/rendering/textures")) {
fgSetBool("/sim/rendering/textures", false);
material_lib.set_step( 1 );
}
return;
case GLUT_KEY_F10: // F10 toggles menu on and off...
- FG_LOG(FG_INPUT, FG_INFO, "Invoking call back function");
+ SG_LOG(SG_INPUT, SG_INFO, "Invoking call back function");
guiToggleMenu();
return;
case GLUT_KEY_F11: // F11 Altitude Dialog.
- FG_LOG(FG_INPUT, FG_INFO, "Invoking Altitude call back function");
+ SG_LOG(SG_INPUT, SG_INFO, "Invoking Altitude call back function");
NewAltitude( NULL );
return;
case GLUT_KEY_F12: // F12 Heading Dialog...
- FG_LOG(FG_INPUT, FG_INFO, "Invoking Heading call back function");
+ SG_LOG(SG_INPUT, SG_INFO, "Invoking Heading call back function");
NewHeading( NULL );
return;
case GLUT_KEY_UP:
double agl = current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER
- scenery.cur_elev;
- // FG_LOG( FG_ALL, FG_INFO, "visibility is "
+ // SG_LOG( SG_ALL, SG_INFO, "visibility is "
// << current_weather.get_visibility() );
if ( agl > 10.0 ) {
SGTime *t = globals->get_time_params();
- FG_LOG( FG_ALL, FG_DEBUG, "Running Main Loop");
- FG_LOG( FG_ALL, FG_DEBUG, "======= ==== ====");
+ SG_LOG( SG_ALL, SG_DEBUG, "Running Main Loop");
+ SG_LOG( SG_ALL, SG_DEBUG, "======= ==== ====");
#ifdef FG_NETWORK_OLK
if ( fgGetBool("/sim/networking/network-olk") ) {
fgFDMForceAltitude( fgGetString("/sim/flight-model"),
scenery.cur_elev + alt_adjust_m );
- FG_LOG( FG_ALL, FG_DEBUG,
+ SG_LOG( SG_ALL, SG_DEBUG,
"<*> resetting altitude to "
<< cur_fdm_state->get_Altitude() * SG_FEET_TO_METER
<< " meters" );
// Get elapsed time (in usec) for this past frame
elapsed = fgGetTimeInterval();
- FG_LOG( FG_ALL, FG_DEBUG,
+ SG_LOG( SG_ALL, SG_DEBUG,
"Elapsed time interval is = " << elapsed
<< ", previous remainder is = " << remainder );
#else
if ( (t->get_cur_time() != last_time) && (last_time > 0) ) {
general.set_frame_rate( frames );
- FG_LOG( FG_ALL, FG_DEBUG,
+ SG_LOG( SG_ALL, SG_DEBUG,
"--> Frame rate is = " << general.get_frame_rate() );
frames = 0;
}
fgGetInt("/sim/model-hz"));
remainder = elapsed - ( (global_multi_loop*1000000) /
fgGetInt("/sim/model-hz") );
- FG_LOG( FG_ALL, FG_DEBUG,
+ SG_LOG( SG_ALL, SG_DEBUG,
"Model iterations needed = " << global_multi_loop
<< ", new remainder = " << remainder );
if ( global_multi_loop > 0 ) {
fgUpdateTimeDepCalcs();
} else {
- FG_LOG( FG_ALL, FG_DEBUG,
+ SG_LOG( SG_ALL, SG_DEBUG,
"Elapsed time is zero ... we're zinging" );
}
// redraw display
fgRenderFrame();
- FG_LOG( FG_ALL, FG_DEBUG, "" );
+ SG_LOG( SG_ALL, SG_DEBUG, "" );
}
string command = "(touch " + lockfile + "; mpg123 "
+ mp3file.str() + "> /dev/null 2>&1; /bin/rm "
+ lockfile + ") &";
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Starting intro music: " << mp3file.str() );
system ( command.c_str() );
}
// a subsystem to flightgear, its initialization call should
// located in this routine.
if( !fgInitSubsystems()) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Subsystem initializations failed ..." );
exit(-1);
}
string lockfile = "/tmp/mpg123.running";
struct stat stat_buf;
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Waiting for mpg123 player to finish ..." );
while ( stat(lockfile.c_str(), &stat_buf) == 0 ) {
// file exist, wait ...
sleep(1);
- FG_LOG( FG_GENERAL, FG_INFO, ".");
+ SG_LOG( SG_GENERAL, SG_INFO, ".");
}
- FG_LOG( FG_GENERAL, FG_INFO, "");
+ SG_LOG( SG_GENERAL, SG_INFO, "");
}
#endif // WIN32
"Sounds/wasp.wav") );
globals->get_soundmgr()->add( s1, "engine loop" );
globals->get_soundmgr()->play_looped( "engine loop" );
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Rate = " << s1->get_sample()->getRate()
<< " Bps = " << s1->get_sample()->getBps()
<< " Stereo = " << s1->get_sample()->getStereo() );
// Define Display Parameters
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
- FG_LOG( FG_GENERAL, FG_INFO, "Opening a window: " <<
+ SG_LOG( SG_GENERAL, SG_INFO, "Opening a window: " <<
fgGetInt("/sim/startup/xsize") << "x"
<< fgGetInt("/sim/startup/ysize") );
fgGetInt("/sim/startup/ysize"),
fgGetInt("/sim/rendering/bits-per-pixel"));
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"game mode params = " << game_mode_str );
glutGameModeString( game_mode_str );
glutEnterGameMode();
general.set_glVendor( (char *)glGetString ( GL_VENDOR ) );
general.set_glRenderer( (char *)glGetString ( GL_RENDERER ) );
general.set_glVersion( (char *)glGetString ( GL_VERSION ) );
- FG_LOG( FG_GENERAL, FG_INFO, general.get_glRenderer() );
+ SG_LOG( SG_GENERAL, SG_INFO, general.get_glRenderer() );
GLint tmp;
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tmp );
general.set_glMaxTexSize( tmp );
- FG_LOG ( FG_GENERAL, FG_INFO, "Max texture size = " << tmp );
+ SG_LOG ( SG_GENERAL, SG_INFO, "Max texture size = " << tmp );
glGetIntegerv( GL_DEPTH_BITS, &tmp );
general.set_glDepthBits( tmp );
- FG_LOG ( FG_GENERAL, FG_INFO, "Depth buffer bits = " << tmp );
+ SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
return 1;
}
#endif
// set default log levels
- fglog().setLogLevels( FG_ALL, FG_INFO );
+ sglog().setLogLevels( SG_ALL, SG_INFO );
string version;
#ifdef FLIGHTGEAR_VERSION
#else
version = "unknown version";
#endif
- FG_LOG( FG_GENERAL, FG_INFO, "FlightGear: Version "
+ SG_LOG( SG_GENERAL, SG_INFO, "FlightGear: Version "
<< version << endl );
// Allocate global data structures. This needs to happen before
// Load the configuration parameters
if ( !fgInitConfig(argc, argv) ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Config option parsing failed ..." );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Config option parsing failed ..." );
exit(-1);
}
// Initialize the Window/Graphics environment.
if( !fgGlutInit(&argc, argv) ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "GLUT initialization failed ..." );
+ SG_LOG( SG_GENERAL, SG_ALERT, "GLUT initialization failed ..." );
exit(-1);
}
// Initialize the various GLUT Event Handlers.
if( !fgGlutInitEvents() ) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"GLUT event handler initialization failed ..." );
exit(-1);
}
globals->set_warp( offset - (aircraftLocalTime - systemLocalTime) -
cur_time );
} else {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Unsupported offset type " << offset_type );
exit( -1 );
}
- FG_LOG( FG_GENERAL, FG_INFO, "After time init, warp = "
+ SG_LOG( SG_GENERAL, SG_INFO, "After time init, warp = "
<< globals->get_warp() );
globals->set_warp_delta( 0 );
// Do some quick general initializations
if( !fgInitGeneral()) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"General initializations failed ..." );
exit(-1);
}
acmodel_proprpms[acmodel_npropsettings][1] = prop_high;
acmodel_npropsettings++;
- FG_LOG( FG_GENERAL, FG_INFO, "PROPELLER SETTING " << prop_low <<
+ SG_LOG( SG_GENERAL, SG_INFO, "PROPELLER SETTING " << prop_low <<
" " << prop_high );
}
}
tile_path.append( "Objects.txt" );
fg_gzifstream in( tile_path.str() );
if ( ! in.is_open() ) {
- FG_LOG( FG_TERRAIN, FG_ALERT, "Cannot open file: " << tile_path.str() );
+ SG_LOG( SG_TERRAIN, SG_ALERT, "Cannot open file: " << tile_path.str() );
}
FGPath modelpath( globals->get_fg_root() );
ship_sel->addKid( ship_pos[objc] ); // add transform node to selector
}
else
- FG_LOG( FG_TERRAIN, FG_ALERT, "Cannot open file: " << obj_filename );
+ SG_LOG( SG_TERRAIN, SG_ALERT, "Cannot open file: " << obj_filename );
if (in.eof()) break;
objc++;
}
if ( !geometry_ok ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Unknown geometry: " << geometry );
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT, "Unknown geometry: " << geometry );
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Setting geometry to " << xsize << 'x' << ysize << '\n');
} else {
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Setting geometry to " << xsize << 'x' << ysize << '\n');
fgSetInt("/sim/startup/xsize", xsize);
fgSetInt("/sim/startup/ysize", ysize);
} else if ( bits_per_pix == "32" ) {
fgSetInt("/sim/rendering/bits-per-pixel", 32);
} else {
- FG_LOG(FG_GENERAL, FG_ALERT, "Unsupported bpp " << bits_per_pix);
+ SG_LOG(SG_GENERAL, SG_ALERT, "Unsupported bpp " << bits_per_pix);
}
} else if ( arg == "--units-feet" ) {
fgSetString("/sim/startup/units", "feet");
string assign = arg.substr(7);
int pos = assign.find('=');
if (pos == arg.npos || pos == 0) {
- FG_LOG(FG_GENERAL, FG_ALERT, "Bad property assignment: " << arg);
+ SG_LOG(SG_GENERAL, SG_ALERT, "Bad property assignment: " << arg);
return FG_OPTIONS_ERROR;
}
string name = assign.substr(0, pos);
string value = assign.substr(pos + 1);
fgSetString(name.c_str(), value);
- // FG_LOG(FG_GENERAL, FG_INFO, "Setting default value of property "
+ // SG_LOG(SG_GENERAL, SG_INFO, "Setting default value of property "
// << name << " to \"" << value << '"');
// $$$ begin - added VS Renganathan, 14 Oct 2K
// for multi-window outside window imagery
string val = arg.substr(7);
int pos = val.find('@');
if (pos == string::npos) {
- FG_LOG(FG_GENERAL, FG_ALERT, "bad wind value " << val);
+ SG_LOG(SG_GENERAL, SG_ALERT, "bad wind value " << val);
return FG_OPTIONS_ERROR;
}
double dir = atof(val.substr(0,pos).c_str());
double speed = atof(val.substr(pos+1).c_str());
- FG_LOG(FG_GENERAL, FG_INFO, "WIND: " << dir << '@' <<
+ SG_LOG(SG_GENERAL, SG_INFO, "WIND: " << dir << '@' <<
speed << " knots" << endl);
// convert to fps
speed *= SG_NM_TO_METER * SG_METER_TO_FEET * (1.0/3600);
} else if ( arg.find( "--config=" ) == 0 ) {
string file = arg.substr(9);
if (!readProperties(file, globals->get_props())) {
- FG_LOG(FG_IO, FG_ALERT,
+ SG_LOG(SG_IO, SG_ALERT,
"--config: failed to read properties from " << file);
return FG_OPTIONS_ERROR;
}
} else {
- FG_LOG( FG_GENERAL, FG_ALERT, "Unknown option '" << arg << "'" );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Unknown option '" << arg << "'" );
return FG_OPTIONS_ERROR;
}
{
int i = 1;
- FG_LOG(FG_GENERAL, FG_INFO, "Scanning for root: command line");
+ SG_LOG(SG_GENERAL, SG_INFO, "Scanning for root: command line");
while ( i < argc ) {
- FG_LOG( FG_GENERAL, FG_DEBUG, "argv[" << i << "] = " << argv[i] );
+ SG_LOG( SG_GENERAL, SG_DEBUG, "argv[" << i << "] = " << argv[i] );
string arg = argv[i];
if ( arg.find( "--fg-root=" ) == 0 ) {
if ( !in.is_open() )
return "";
- FG_LOG( FG_GENERAL, FG_INFO, "Scanning for root: " << path );
+ SG_LOG( SG_GENERAL, SG_INFO, "Scanning for root: " << path );
in >> skipcomment;
#ifndef __MWERKS__
int i = 1;
int result;
- FG_LOG(FG_GENERAL, FG_INFO, "Processing command line arguments");
+ SG_LOG(SG_GENERAL, SG_INFO, "Processing command line arguments");
while ( i < argc ) {
- FG_LOG( FG_GENERAL, FG_DEBUG, "argv[" << i << "] = " << argv[i] );
+ SG_LOG( SG_GENERAL, SG_DEBUG, "argv[" << i << "] = " << argv[i] );
result = parse_option(argv[i]);
if ( (result == FG_OPTIONS_HELP) || (result == FG_OPTIONS_ERROR) ) {
if ( !in.is_open() )
return;
- FG_LOG( FG_GENERAL, FG_INFO, "Processing config file: " << path );
+ SG_LOG( SG_GENERAL, SG_INFO, "Processing config file: " << path );
in >> skipcomment;
#ifndef __MWERKS__
#endif
if ( parse_option( line ) == FG_OPTIONS_ERROR ) {
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Config file parse error: " << path << " '"
<< line << "'" );
fgUsage();
void fgSplashInit ( void ) {
int width, height;
- FG_LOG( FG_GENERAL, FG_INFO, "Initializing splash screen" );
+ SG_LOG( SG_GENERAL, SG_INFO, "Initializing splash screen" );
#ifdef GL_VERSION_1_1
xglGenTextures(1, &splash_texid);
xglBindTexture(GL_TEXTURE_2D, splash_texid);
if ( (splash_texbuf =
read_rgb_texture(fg_tpath.c_str(), &width, &height)) == NULL )
{
- FG_LOG( FG_GENERAL, FG_ALERT,
+ SG_LOG( SG_GENERAL, SG_ALERT,
"Error in loading splash screen texture " << tpath.str() );
exit(-1);
}
// Update the view parameters
void FGViewer::update() {
- FG_LOG( FG_VIEW, FG_ALERT, "Shouldn't ever see this" );
+ SG_LOG( SG_VIEW, SG_ALERT, "Shouldn't ever see this" );
exit(-1);
}
sgSetVec3( view_pos, vp );
sgAddVec3( view_pos, pilot_offset );
- FG_LOG( FG_VIEW, FG_DEBUG, "sea level radius = " << sea_level_radius );
- FG_LOG( FG_VIEW, FG_DEBUG, "Polar view pos = " << p );
- FG_LOG( FG_VIEW, FG_DEBUG, "Absolute view pos = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "sea level radius = " << sea_level_radius );
+ SG_LOG( SG_VIEW, SG_DEBUG, "Polar view pos = " << p );
+ SG_LOG( SG_VIEW, SG_DEBUG, "Absolute view pos = "
<< abs_view_pos[0] << ","
<< abs_view_pos[1] << ","
<< abs_view_pos[2] );
- FG_LOG( FG_VIEW, FG_DEBUG, "Relative view pos = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "Relative view pos = "
<< view_pos[0] << "," << view_pos[1] << "," << view_pos[2] );
- FG_LOG( FG_VIEW, FG_DEBUG, "pilot offset = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "pilot offset = "
<< pilot_offset[0] << "," << pilot_offset[1] << ","
<< pilot_offset[2] );
- FG_LOG( FG_VIEW, FG_DEBUG, "view forward = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "view forward = "
<< view_forward[0] << "," << view_forward[1] << ","
<< view_forward[2] );
- FG_LOG( FG_VIEW, FG_DEBUG, "view up = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "view up = "
<< view_up[0] << "," << view_up[1] << ","
<< view_up[2] );
sgdSubVec3( vp, abs_view_pos, sc );
sgSetVec3( view_pos, vp );
- FG_LOG( FG_VIEW, FG_DEBUG, "sea level radius = " << sea_level_radius );
- FG_LOG( FG_VIEW, FG_DEBUG, "Polar view pos = " << p );
- FG_LOG( FG_VIEW, FG_DEBUG, "Absolute view pos = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "sea level radius = " << sea_level_radius );
+ SG_LOG( SG_VIEW, SG_DEBUG, "Polar view pos = " << p );
+ SG_LOG( SG_VIEW, SG_DEBUG, "Absolute view pos = "
<< abs_view_pos[0] << ","
<< abs_view_pos[1] << ","
<< abs_view_pos[2] );
- FG_LOG( FG_VIEW, FG_DEBUG, "(RPH) Relative view pos = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "(RPH) Relative view pos = "
<< view_pos[0] << "," << view_pos[1] << "," << view_pos[2] );
// code to calculate LOCAL matrix calculated from Phi, Theta, and
// cout << "VIEW_OFFSET matrix" << endl;
// print_sgMat4( VIEW_OFFSET );
sgXformVec3( view_forward, forward, VIEW_OFFSET );
- FG_LOG( FG_VIEW, FG_DEBUG, "(RPH) view forward = "
+ SG_LOG( SG_VIEW, SG_DEBUG, "(RPH) view forward = "
<< view_forward[0] << "," << view_forward[1] << ","
<< view_forward[2] );
fg_gzifstream in( path.str() );
if ( !in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << path.str() );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << path.str() );
exit(-1);
}
fg_gzifstream in( path.str() );
if ( !in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << path.str() );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << path.str() );
exit(-1);
}
fg_gzifstream in( path.str() );
if ( !in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << path.str() );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << path.str() );
exit(-1);
}
current_radiostack->get_adf_freq() );
sprintf( patla_sum, "%02X", calc_atlas_cksum(patla) );
- FG_LOG( FG_IO, FG_DEBUG, rmc );
- FG_LOG( FG_IO, FG_DEBUG, gga );
- FG_LOG( FG_IO, FG_DEBUG, patla );
+ SG_LOG( SG_IO, SG_DEBUG, rmc );
+ SG_LOG( SG_IO, SG_DEBUG, gga );
+ SG_LOG( SG_IO, SG_DEBUG, patla );
string atlas_sentence;
// $GPGGA,163227,3321.173,N,11039.855,W,1,,,3333,F,,,,*0F
bool FGAtlas::parse_message() {
- FG_LOG( FG_IO, FG_INFO, "parse atlas message" );
+ SG_LOG( SG_IO, SG_INFO, "parse atlas message" );
string msg = buf;
msg = msg.substr( 0, length );
- FG_LOG( FG_IO, FG_INFO, "entire message = " << msg );
+ SG_LOG( SG_IO, SG_INFO, "entire message = " << msg );
string::size_type begin_line, end_line, begin, end;
begin_line = begin = 0;
while ( end_line != string::npos ) {
string line = msg.substr(begin_line, end_line - begin_line);
begin_line = end_line + 1;
- FG_LOG( FG_IO, FG_INFO, " input line = " << line );
+ SG_LOG( SG_IO, SG_INFO, " input line = " << line );
// leading character
string start = msg.substr(begin, 1);
++begin;
- FG_LOG( FG_IO, FG_INFO, " start = " << start );
+ SG_LOG( SG_IO, SG_INFO, " start = " << start );
// sentence
end = msg.find(",", begin);
string sentence = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " sentence = " << sentence );
+ SG_LOG( SG_IO, SG_INFO, " sentence = " << sentence );
double lon_deg, lon_min, lat_deg, lat_min;
double lon, lat, speed, heading, altitude;
string utc = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " utc = " << utc );
+ SG_LOG( SG_IO, SG_INFO, " utc = " << utc );
// junk
end = msg.find(",", begin);
string junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// lat val
end = msg.find(",", begin);
}
cur_fdm_state->set_Latitude( lat * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lat = " << lat );
+ SG_LOG( SG_IO, SG_INFO, " lat = " << lat );
// lon val
end = msg.find(",", begin);
}
cur_fdm_state->set_Longitude( lon * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lon = " << lon );
+ SG_LOG( SG_IO, SG_INFO, " lon = " << lon );
#if 0
double sl_radius, lat_geoc;
speed = atof( speed_str.c_str() );
cur_fdm_state->set_V_calibrated_kts( speed );
// cur_fdm_state->set_V_ground_speed( speed );
- FG_LOG( FG_IO, FG_INFO, " speed = " << speed );
+ SG_LOG( SG_IO, SG_INFO, " speed = " << speed );
// heading
end = msg.find(",", begin);
cur_fdm_state->set_Euler_Angles( cur_fdm_state->get_Phi(),
cur_fdm_state->get_Theta(),
heading * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " heading = " << heading );
+ SG_LOG( SG_IO, SG_INFO, " heading = " << heading );
} else if ( sentence == "GPGGA" ) {
// time
end = msg.find(",", begin);
string utc = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " utc = " << utc );
+ SG_LOG( SG_IO, SG_INFO, " utc = " << utc );
// lat val
end = msg.find(",", begin);
}
// cur_fdm_state->set_Latitude( lat * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lat = " << lat );
+ SG_LOG( SG_IO, SG_INFO, " lat = " << lat );
// lon val
end = msg.find(",", begin);
}
// cur_fdm_state->set_Longitude( lon * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lon = " << lon );
+ SG_LOG( SG_IO, SG_INFO, " lon = " << lon );
// junk
end = msg.find(",", begin);
string junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// junk
end = msg.find(",", begin);
junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// junk
end = msg.find(",", begin);
junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// altitude
end = msg.find(",", begin);
cur_fdm_state->set_Altitude( altitude );
- FG_LOG( FG_IO, FG_INFO, " altitude = " << altitude );
+ SG_LOG( SG_IO, SG_INFO, " altitude = " << altitude );
} else if ( sentence == "PATLA" ) {
// nav1 freq
string nav1_freq = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " nav1_freq = " << nav1_freq );
+ SG_LOG( SG_IO, SG_INFO, " nav1_freq = " << nav1_freq );
// nav1 selected radial
end = msg.find(",", begin);
string nav1_rad = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " nav1_rad = " << nav1_rad );
+ SG_LOG( SG_IO, SG_INFO, " nav1_rad = " << nav1_rad );
// nav2 freq
end = msg.find(",", begin);
string nav2_freq = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " nav2_freq = " << nav2_freq );
+ SG_LOG( SG_IO, SG_INFO, " nav2_freq = " << nav2_freq );
// nav2 selected radial
end = msg.find(",", begin);
string nav2_rad = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " nav2_rad = " << nav2_rad );
+ SG_LOG( SG_IO, SG_INFO, " nav2_rad = " << nav2_rad );
// adf freq
end = msg.find("*", begin);
string adf_freq = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " adf_freq = " << adf_freq );
+ SG_LOG( SG_IO, SG_INFO, " adf_freq = " << adf_freq );
}
// printf("%.8f %.8f\n", lon, lat);
// open hailing frequencies
bool FGAtlas::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
parse_message();
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
parse_message();
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
}
sprintf( rmz, "PGRMZ,%s,f,3", altitude_ft );
sprintf( rmz_sum, "%02X", calc_nmea_cksum(rmz) );
- FG_LOG( FG_IO, FG_DEBUG, rmc );
- FG_LOG( FG_IO, FG_DEBUG, rmz );
+ SG_LOG( SG_IO, SG_DEBUG, rmc );
+ SG_LOG( SG_IO, SG_DEBUG, rmz );
string garmin_sentence;
// parse Garmin message
bool FGGarmin::parse_message() {
- FG_LOG( FG_IO, FG_INFO, "parse garmin message" );
+ SG_LOG( SG_IO, SG_INFO, "parse garmin message" );
string msg = buf;
msg = msg.substr( 0, length );
- FG_LOG( FG_IO, FG_INFO, "entire message = " << msg );
+ SG_LOG( SG_IO, SG_INFO, "entire message = " << msg );
string::size_type begin_line, end_line, begin, end;
begin_line = begin = 0;
while ( end_line != string::npos ) {
string line = msg.substr(begin_line, end_line - begin_line);
begin_line = end_line + 1;
- FG_LOG( FG_IO, FG_INFO, " input line = " << line );
+ SG_LOG( SG_IO, SG_INFO, " input line = " << line );
// leading character
string start = msg.substr(begin, 1);
++begin;
- FG_LOG( FG_IO, FG_INFO, " start = " << start );
+ SG_LOG( SG_IO, SG_INFO, " start = " << start );
// sentence
end = msg.find(",", begin);
string sentence = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " sentence = " << sentence );
+ SG_LOG( SG_IO, SG_INFO, " sentence = " << sentence );
double lon_deg, lon_min, lat_deg, lat_min;
double lon, lat, speed, heading, altitude;
string utc = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " utc = " << utc );
+ SG_LOG( SG_IO, SG_INFO, " utc = " << utc );
// junk
end = msg.find(",", begin);
string junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// lat val
end = msg.find(",", begin);
}
cur_fdm_state->set_Latitude( lat * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lat = " << lat );
+ SG_LOG( SG_IO, SG_INFO, " lat = " << lat );
// lon val
end = msg.find(",", begin);
}
cur_fdm_state->set_Longitude( lon * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lon = " << lon );
+ SG_LOG( SG_IO, SG_INFO, " lon = " << lon );
#if 0
double sl_radius, lat_geoc;
speed = atof( speed_str.c_str() );
cur_fdm_state->set_V_calibrated_kts( speed );
// cur_fdm_state->set_V_ground_speed( speed );
- FG_LOG( FG_IO, FG_INFO, " speed = " << speed );
+ SG_LOG( SG_IO, SG_INFO, " speed = " << speed );
// heading
end = msg.find(",", begin);
cur_fdm_state->set_Euler_Angles( cur_fdm_state->get_Phi(),
cur_fdm_state->get_Theta(),
heading * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " heading = " << heading );
+ SG_LOG( SG_IO, SG_INFO, " heading = " << heading );
} else if ( sentence == "PGRMZ" ) {
// altitude
end = msg.find(",", begin);
cur_fdm_state->set_Altitude( altitude );
- FG_LOG( FG_IO, FG_INFO, " altitude = " << altitude );
+ SG_LOG( SG_IO, SG_INFO, " altitude = " << altitude );
}
// open hailing frequencies
bool FGGarmin::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
- FG_LOG( FG_IO, FG_ALERT, "Success reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Success reading data." );
if ( parse_message() ) {
- FG_LOG( FG_IO, FG_ALERT, "Success parsing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Success parsing data." );
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error parsing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error parsing data." );
}
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
- FG_LOG( FG_IO, FG_ALERT, "Success reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Success reading data." );
if ( parse_message() ) {
- FG_LOG( FG_IO, FG_ALERT, "Success parsing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Success parsing data." );
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error parsing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error parsing data." );
}
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
}
// open hailing frequencies
bool FGJoyClient::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
int length = sizeof(int[2]);
if ( get_direction() == SG_IO_OUT ) {
- FG_LOG( FG_IO, FG_ALERT, "joyclient protocol is read only" );
+ SG_LOG( SG_IO, SG_ALERT, "joyclient protocol is read only" );
return false;
} else if ( get_direction() == SG_IO_IN ) {
- FG_LOG( FG_IO, FG_DEBUG, "Searching for data." );
+ SG_LOG( SG_IO, SG_DEBUG, "Searching for data." );
if ( io->get_type() == sgFileType ) {
if ( io->read( (char *)(& buf), length ) == length ) {
- FG_LOG( FG_IO, FG_DEBUG, "Success reading data." );
+ SG_LOG( SG_IO, SG_DEBUG, "Success reading data." );
int *msg;
msg = (int *)buf;
- FG_LOG( FG_IO, FG_DEBUG, "X = " << msg[0] << " Y = "
+ SG_LOG( SG_IO, SG_DEBUG, "X = " << msg[0] << " Y = "
<< msg[1] );
double aileron = ((double)msg[0] / 2048.0) - 1.0;
double elevator = ((double)msg[1] / 2048.0) - 1.0;
}
} else {
while ( io->read( (char *)(& buf), length ) == length ) {
- FG_LOG( FG_IO, FG_DEBUG, "Success reading data." );
+ SG_LOG( SG_IO, SG_DEBUG, "Success reading data." );
int *msg;
msg = (int *)buf;
- FG_LOG( FG_IO, FG_DEBUG, "X = " << msg[0] << " Y = "
+ SG_LOG( SG_IO, SG_DEBUG, "X = " << msg[0] << " Y = "
<< msg[1] );
double aileron = ((double)msg[0] / 2048.0) - 1.0;
double elevator = ((double)msg[1] / 2048.0) - 1.0;
// open hailing frequencies
bool FGNative::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
// cout << "size of cur_fdm_state = " << length << endl;
buf = *cur_fdm_state;
if ( ! io->write( (char *)(& buf), length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
if ( io->get_type() == sgFileType ) {
if ( io->read( (char *)(& buf), length ) == length ) {
- FG_LOG( FG_IO, FG_DEBUG, "Success reading data." );
+ SG_LOG( SG_IO, SG_DEBUG, "Success reading data." );
*cur_fdm_state = buf;
}
} else {
while ( io->read( (char *)(& buf), length ) == length ) {
- FG_LOG( FG_IO, FG_DEBUG, "Success reading data." );
+ SG_LOG( SG_IO, SG_DEBUG, "Success reading data." );
*cur_fdm_state = buf;
}
}
sprintf( gga_sum, "%02X", calc_nmea_cksum(gga) );
- FG_LOG( FG_IO, FG_DEBUG, rmc );
- FG_LOG( FG_IO, FG_DEBUG, gga );
+ SG_LOG( SG_IO, SG_DEBUG, rmc );
+ SG_LOG( SG_IO, SG_DEBUG, gga );
string nmea_sentence;
// $GPGGA,163227,3321.173,N,11039.855,W,1,,,3333,F,,,,*0F
bool FGNMEA::parse_message() {
- FG_LOG( FG_IO, FG_INFO, "parse nmea message" );
+ SG_LOG( SG_IO, SG_INFO, "parse nmea message" );
string msg = buf;
msg = msg.substr( 0, length );
- FG_LOG( FG_IO, FG_INFO, "entire message = " << msg );
+ SG_LOG( SG_IO, SG_INFO, "entire message = " << msg );
string::size_type begin_line, end_line, begin, end;
begin_line = begin = 0;
while ( end_line != string::npos ) {
string line = msg.substr(begin_line, end_line - begin_line);
begin_line = end_line + 1;
- FG_LOG( FG_IO, FG_INFO, " input line = " << line );
+ SG_LOG( SG_IO, SG_INFO, " input line = " << line );
// leading character
string start = msg.substr(begin, 1);
++begin;
- FG_LOG( FG_IO, FG_INFO, " start = " << start );
+ SG_LOG( SG_IO, SG_INFO, " start = " << start );
// sentence
end = msg.find(",", begin);
string sentence = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " sentence = " << sentence );
+ SG_LOG( SG_IO, SG_INFO, " sentence = " << sentence );
double lon_deg, lon_min, lat_deg, lat_min;
double lon, lat, speed, heading, altitude;
string utc = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " utc = " << utc );
+ SG_LOG( SG_IO, SG_INFO, " utc = " << utc );
// junk
end = msg.find(",", begin);
string junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// lat val
end = msg.find(",", begin);
}
cur_fdm_state->set_Latitude( lat * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lat = " << lat );
+ SG_LOG( SG_IO, SG_INFO, " lat = " << lat );
// lon val
end = msg.find(",", begin);
}
cur_fdm_state->set_Longitude( lon * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lon = " << lon );
+ SG_LOG( SG_IO, SG_INFO, " lon = " << lon );
#if 0
double sl_radius, lat_geoc;
speed = atof( speed_str.c_str() );
cur_fdm_state->set_V_calibrated_kts( speed );
// cur_fdm_state->set_V_ground_speed( speed );
- FG_LOG( FG_IO, FG_INFO, " speed = " << speed );
+ SG_LOG( SG_IO, SG_INFO, " speed = " << speed );
// heading
end = msg.find(",", begin);
cur_fdm_state->set_Euler_Angles( cur_fdm_state->get_Phi(),
cur_fdm_state->get_Theta(),
heading * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " heading = " << heading );
+ SG_LOG( SG_IO, SG_INFO, " heading = " << heading );
} else if ( sentence == "GPGGA" ) {
// time
end = msg.find(",", begin);
string utc = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " utc = " << utc );
+ SG_LOG( SG_IO, SG_INFO, " utc = " << utc );
// lat val
end = msg.find(",", begin);
}
// cur_fdm_state->set_Latitude( lat * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lat = " << lat );
+ SG_LOG( SG_IO, SG_INFO, " lat = " << lat );
// lon val
end = msg.find(",", begin);
}
// cur_fdm_state->set_Longitude( lon * SGD_DEGREES_TO_RADIANS );
- FG_LOG( FG_IO, FG_INFO, " lon = " << lon );
+ SG_LOG( SG_IO, SG_INFO, " lon = " << lon );
// junk
end = msg.find(",", begin);
string junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// junk
end = msg.find(",", begin);
junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// junk
end = msg.find(",", begin);
junk = msg.substr(begin, end - begin);
begin = end + 1;
- FG_LOG( FG_IO, FG_INFO, " junk = " << junk );
+ SG_LOG( SG_IO, SG_INFO, " junk = " << junk );
// altitude
end = msg.find(",", begin);
cur_fdm_state->set_Altitude( altitude );
- FG_LOG( FG_IO, FG_INFO, " altitude = " << altitude );
+ SG_LOG( SG_IO, SG_INFO, " altitude = " << altitude );
}
// open hailing frequencies
bool FGNMEA::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
parse_message();
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
if ( (length = io->readline( buf, FG_MAX_MSG_SIZE )) > 0 ) {
parse_message();
} else {
- FG_LOG( FG_IO, FG_ALERT, "Error reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error reading data." );
return false;
}
}
path = "/";
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
set_enabled( true );
- FG_LOG( FG_IO, FG_INFO, "Opening properties channel communication layer." );
+ SG_LOG( SG_IO, SG_INFO, "Opening properties channel communication layer." );
return true;
}
if ( get_direction() == SG_IO_BI ) {
// cout << " (bi directional)" << endl;
while ( io->readline( buf, max_cmd_len ) > 0 ) {
- FG_LOG( FG_IO, FG_ALERT, "Success reading data." );
+ SG_LOG( SG_IO, SG_ALERT, "Success reading data." );
process_command( buf );
}
} else {
- FG_LOG( FG_IO, FG_ALERT,
+ SG_LOG( SG_IO, SG_ALERT,
"in or out direction not supported for FGProps." );
}
// standard I/O channel open routine
bool FGProtocol::open() {
if ( is_enabled() ) {
- FG_LOG( FG_IO, FG_ALERT, "This shouldn't happen, but the channel "
+ SG_LOG( SG_IO, SG_ALERT, "This shouldn't happen, but the channel "
<< "is already in use, ignoring" );
return false;
}
SGIOChannel *io = get_io_channel();
if ( ! io->open( get_direction() ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error opening channel communication layer." );
+ SG_LOG( SG_IO, SG_ALERT, "Error opening channel communication layer." );
return false;
}
// dummy process routine
bool FGProtocol::process() {
- FG_LOG( FG_IO, FG_INFO, "dummy FGProtocol::process()" );
+ SG_LOG( SG_IO, SG_INFO, "dummy FGProtocol::process()" );
return false;
}
// dummy close routine
bool FGProtocol::close() {
- FG_LOG( FG_IO, FG_INFO, "dummy FGProtocol::close()" );
+ SG_LOG( SG_IO, SG_INFO, "dummy FGProtocol::close()" );
return false;
}
// dummy close routine
bool FGProtocol::parse_message() {
- FG_LOG( FG_IO, FG_INFO, "dummy FGProtocol::close()" );
+ SG_LOG( SG_IO, SG_INFO, "dummy FGProtocol::close()" );
return false;
}
// printf( "p [ %u %u ] [ %u %u ] [ %u %u ]\n",
// roll_b1, roll_b2, pitch_b1, pitch_b2, heave_b1, heave_b2 );
- FG_LOG( FG_IO, FG_INFO, "roll=" << roll << " pitch=" << pitch <<
+ SG_LOG( SG_IO, SG_INFO, "roll=" << roll << " pitch=" << pitch <<
" heave=" << heave );
return true;
// parse RUL message
bool FGPVE::parse_message() {
- FG_LOG( FG_IO, FG_ALERT, "PVE input not supported" );
+ SG_LOG( SG_IO, SG_ALERT, "PVE input not supported" );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
- FG_LOG( FG_IO, FG_ALERT, "in direction not supported for RUL." );
+ SG_LOG( SG_IO, SG_ALERT, "in direction not supported for RUL." );
return false;
}
// parse RUL message
bool FGRAY::parse_message() {
- FG_LOG( FG_IO, FG_ALERT, "RAY input not supported" );
+ SG_LOG( SG_IO, SG_ALERT, "RAY input not supported" );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
- FG_LOG( FG_IO, FG_ALERT, "in direction not supported for RAY." );
+ SG_LOG( SG_IO, SG_ALERT, "in direction not supported for RAY." );
return false;
}
sprintf( buf, "p%c%c\n", roll, pitch);
length = 4;
- FG_LOG( FG_IO, FG_INFO, "p " << roll << " " << pitch );
+ SG_LOG( SG_IO, SG_INFO, "p " << roll << " " << pitch );
return true;
}
// parse RUL message
bool FGRUL::parse_message() {
- FG_LOG( FG_IO, FG_ALERT, "RUL input not supported" );
+ SG_LOG( SG_IO, SG_ALERT, "RUL input not supported" );
return false;
}
if ( get_direction() == SG_IO_OUT ) {
gen_message();
if ( ! io->write( buf, length ) ) {
- FG_LOG( FG_IO, FG_ALERT, "Error writing data." );
+ SG_LOG( SG_IO, SG_ALERT, "Error writing data." );
return false;
}
} else if ( get_direction() == SG_IO_IN ) {
- FG_LOG( FG_IO, FG_ALERT, "in direction not supported for RUL." );
+ SG_LOG( SG_IO, SG_ALERT, "in direction not supported for RUL." );
return false;
}
fg_gzifstream in( mpath );
if ( ! in.is_open() ) {
- FG_LOG( FG_GENERAL, FG_ALERT, "Cannot open file: " << mpath );
+ SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << mpath );
exit(-1);
}
if ( material_name == "alias" ) {
string src_mat, dst_mat;
in >> dst_mat >> src_mat;
- FG_LOG( FG_GENERAL, FG_INFO, " Material alias: " << dst_mat <<
+ SG_LOG( SG_GENERAL, SG_INFO, " Material alias: " << dst_mat <<
" mapped to " << src_mat );
FGNewMat m = matlib[src_mat];
matlib[dst_mat] = m;
tex_path.append( "Textures" );
}
- FG_LOG( FG_TERRAIN, FG_INFO, " Loading material "
+ SG_LOG( SG_TERRAIN, SG_INFO, " Loading material "
<< material_name << " (" << tex_path.c_str() << ")");
GLenum shade_model = GL_SMOOTH;
FGNewMat m( mat_name, tex_name );
- FG_LOG( FG_TERRAIN, FG_INFO, " Loading material "
+ SG_LOG( SG_TERRAIN, SG_INFO, " Loading material "
<< mat_name << " (" << tex_path << ")");
#if EXTRA_DEBUG
FGNewMat m( mat_name );
m.set_ssg_state( state );
- FG_LOG( FG_TERRAIN, FG_INFO, " Loading material given a premade "
+ SG_LOG( SG_TERRAIN, SG_INFO, " Loading material given a premade "
<< "ssgSimpleState = " << mat_name );
#if EXTRA_DEBUG
// container::iterator it = begin();
for ( material_map_iterator it = begin(); it != end(); it++ ) {
const string &key = it->first;
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Updating material " << key << " to step " << step );
FGNewMat &slot = it->second;
slot.get_state()->selectStep(step);
void FGNewMat::dump_info () {
- FG_LOG( FG_TERRAIN, FG_INFO, "{" << endl << " texture = "
+ SG_LOG( SG_TERRAIN, SG_INFO, "{" << endl << " texture = "
<< texture_name );
- FG_LOG( FG_TERRAIN, FG_INFO, " xsize = " << xsize );
- FG_LOG( FG_TERRAIN, FG_INFO, " ysize = " << ysize );
- FG_LOG( FG_TERRAIN, FG_INFO, " ambient = " << ambient[0] << " "
+ SG_LOG( SG_TERRAIN, SG_INFO, " xsize = " << xsize );
+ SG_LOG( SG_TERRAIN, SG_INFO, " ysize = " << ysize );
+ SG_LOG( SG_TERRAIN, SG_INFO, " ambient = " << ambient[0] << " "
<< ambient[1] <<" "<< ambient[2] <<" "<< ambient[3] );
- FG_LOG( FG_TERRAIN, FG_INFO, " diffuse = " << diffuse[0] << " "
+ SG_LOG( SG_TERRAIN, SG_INFO, " diffuse = " << diffuse[0] << " "
<< diffuse[1] << " " << diffuse[2] << " " << diffuse[3] );
- FG_LOG( FG_TERRAIN, FG_INFO, " specular = " << specular[0] << " "
+ SG_LOG( SG_TERRAIN, SG_INFO, " specular = " << specular[0] << " "
<< specular[1] << " " << specular[2] << " " << specular[3]);
- FG_LOG( FG_TERRAIN, FG_INFO, " emission = " << emission[0] << " "
+ SG_LOG( SG_TERRAIN, SG_INFO, " emission = " << emission[0] << " "
<< emission[1] << " " << emission[2] << " " << emission[3]);
- FG_LOG( FG_TERRAIN, FG_INFO, " alpha = " << alpha << endl <<"}" );
+ SG_LOG( SG_TERRAIN, SG_INFO, " alpha = " << alpha << endl <<"}" );
}
} else if ( token == "no" ) {
m.alpha = 0;
} else {
- FG_LOG( FG_TERRAIN, FG_INFO, "Bad alpha value " << token );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Bad alpha value " << token );
}
} else if ( token == "light-coverage" ) {
in >> token >> m.light_coverage;
// set ssgState
state = newmat->get_state();
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Ack! unknown usemtl name = " << "Ocean"
<< " in " << path );
}
// Attempt to open "path.gz" or "path"
fg_gzifstream in( path );
if ( ! in.is_open() ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG, "Cannot open file: " << path );
- FG_LOG( FG_TERRAIN, FG_DEBUG, "default to ocean tile: " << path );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "Cannot open file: " << path );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "default to ocean tile: " << path );
return NULL;
}
in >> scenery_version;
// cout << "scenery_version = " << scenery_version << endl;
if ( scenery_version > 0.4 ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"\nYou are attempting to load a tile format that\n"
<< "is newer than this version of flightgear can\n"
<< "handle. You should upgrade your copy of\n"
if ( ! shared_done ) {
// sanity check
if ( (int)nodes.size() != vncount ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Tile has mismatched nodes = " << nodes.size()
<< " and normals = " << vncount << " : "
<< path );
file += material;
cout << "current file = " << file << endl;
if ( ! material_lib.add_item( file ) ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Ack! unknown usemtl name = " << material
<< " in " << path );
} else {
// locate our newly created material
newmat = material_lib.find( material );
if ( newmat == NULL ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Ack! bad on the fly materia create = "
<< material << " in " << path );
}
>> normals[vncount][2];
vncount++;
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Read too many vertex normals in " << path
<< " ... dying :-(" );
exit(-1);
>> tex_coords[vtcount][1];
vtcount++;
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Read too many vertex texture coords in " << path
<< " ... dying :-("
);
t->ncount++;
}
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Read too many nodes in " << path
<< " ... dying :-(");
exit(-1);
}
} else if ( (token == "tf") || (token == "ts") || (token == "f") ) {
// triangle fan, strip, or individual face
- // FG_LOG( FG_TERRAIN, FG_INFO, "new fan or strip");
+ // SG_LOG( SG_TERRAIN, SG_INFO, "new fan or strip");
fan_vertices.clear();
fan_tex_coords.clear();
if ( is_base ) {
if ( coverage > 0.0 ) {
if ( coverage < 10000.0 ) {
- FG_LOG(FG_INPUT, FG_ALERT, "Light coverage is "
+ SG_LOG(SG_INPUT, SG_ALERT, "Light coverage is "
<< coverage << ", pushing up to 10000");
coverage = 10000;
}
}
}
} else {
- FG_LOG( FG_TERRAIN, FG_WARN, "Unknown token in "
+ SG_LOG( SG_TERRAIN, SG_WARN, "Unknown token in "
<< path << " = " << token );
}
}
stopwatch.stop();
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
"Loaded " << path << " in "
<< stopwatch.elapsedSeconds() << " seconds" );
file += material;
cout << "current file = " << file << endl;
if ( ! material_lib.add_item( file ) ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Ack! unknown usemtl name = " << material
<< " in " << path );
} else {
// locate our newly created material
newmat = material_lib.find( material );
if ( newmat == NULL ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Ack! bad on the fly materia create = "
<< material << " in " << path );
}
if ( calc_lights ) {
if ( coverage > 0.0 ) {
if ( coverage < 10000.0 ) {
- FG_LOG(FG_INPUT, FG_ALERT, "Light coverage is "
+ SG_LOG(SG_INPUT, SG_ALERT, "Light coverage is "
<< coverage << ", pushing up to 10000");
coverage = 10000;
}
// Free a tile cache entry
void FGNewCache::entry_free( long cache_index ) {
- FG_LOG( FG_TERRAIN, FG_INFO, "FREEING CACHE ENTRY = " << cache_index );
+ SG_LOG( SG_TERRAIN, SG_INFO, "FREEING CACHE ENTRY = " << cache_index );
FGTileEntry *e = tile_cache[cache_index];
e->free_tile();
delete( e );
// Initialize the tile cache subsystem
void FGNewCache::init( void ) {
- FG_LOG( FG_TERRAIN, FG_INFO, "Initializing the tile cache." );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Initializing the tile cache." );
// expand cache if needed. For best results ... i.e. to avoid
// tile load problems and blank areas:
max_cache_size = 50; // a random number to start with
- FG_LOG( FG_TERRAIN, FG_INFO, " max cache size = "
+ SG_LOG( SG_TERRAIN, SG_INFO, " max cache size = "
<< max_cache_size );
- FG_LOG( FG_TERRAIN, FG_INFO, " current cache size = "
+ SG_LOG( SG_TERRAIN, SG_INFO, " current cache size = "
<< tile_cache.size() );
tile_map_iterator current = tile_cache.begin();
for ( ; current != end; ++current ) {
long index = current->first;
- FG_LOG( FG_TERRAIN, FG_DEBUG, "clearing " << index );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "clearing " << index );
FGTileEntry *e = current->second;
e->tile_bucket.make_bad();
entry_free(index);
// and ... just in case we missed something ...
terrain->removeAllKids();
- FG_LOG( FG_TERRAIN, FG_INFO, " done with init()" );
+ SG_LOG( SG_TERRAIN, SG_INFO, " done with init()" );
}
// Fill in a tile cache entry with real data for the specified bucket
void FGNewCache::fill_in( const SGBucket& b ) {
- FG_LOG( FG_TERRAIN, FG_INFO, "FILL IN CACHE ENTRY = " << b.gen_index() );
+ SG_LOG( SG_TERRAIN, SG_INFO, "FILL IN CACHE ENTRY = " << b.gen_index() );
// clear out a distant entry in the cache if needed.
make_space();
// update the contents
e->center = Point3D( 0.0 );
if ( e->vec3_ptrs.size() || e->vec2_ptrs.size() || e->index_ptrs.size() ) {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Attempting to overwrite existing or"
<< " not properly freed leaf data." );
exit(-1);
}
// load custom objects
- FG_LOG( FG_TERRAIN, FG_DEBUG, "CUSTOM OBJECTS" );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "CUSTOM OBJECTS" );
FGPath index_path = tile_path;
index_path.append( b.gen_index_str() );
index_path.concat( ".ind" );
- FG_LOG( FG_TERRAIN, FG_DEBUG, "Looking in " << index_path.str() );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "Looking in " << index_path.str() );
fg_gzifstream in( index_path.str() );
#else
in >> skipws;
#endif
- FG_LOG( FG_TERRAIN, FG_DEBUG, "token = " << token
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "token = " << token
<< " name = " << name );
FGPath custom_path = tile_path;
e->lights_range = NULL;
/* uncomment this section for testing ground lights */
if ( light_pts->getNum() ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG, "generating lights" );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "generating lights" );
e->lights_transform = new ssgTransform;
e->lights_range = new ssgRangeSelector;
e->lights_brightness = new ssgSelector;
// Ensure at least one entry is free in the cache
void FGNewCache::make_space() {
- FG_LOG( FG_TERRAIN, FG_INFO, "Make space in cache" );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Make space in cache" );
- FG_LOG( FG_TERRAIN, FG_DEBUG, "cache entries = " << tile_cache.size() );
- FG_LOG( FG_TERRAIN, FG_INFO, "max size = " << max_cache_size );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "cache entries = " << tile_cache.size() );
+ SG_LOG( SG_TERRAIN, SG_INFO, "max size = " << max_cache_size );
if ( (int)tile_cache.size() < max_cache_size ) {
// space in the cache, return
sgdCopyVec3( abs_view_pos,
globals->get_current_view()->get_abs_view_pos() );
- FG_LOG( FG_TERRAIN, FG_DEBUG, "DIST Abs view pos = "
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "DIST Abs view pos = "
<< abs_view_pos[0] << ","
<< abs_view_pos[1] << ","
<< abs_view_pos[2] );
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
" ref point = " << e->center );
sgdVec3 center;
sgdSetVec3( center, e->center.x(), e->center.y(), e->center.z() );
dist = sgdDistanceVec3( center, abs_view_pos );
- FG_LOG( FG_TERRAIN, FG_DEBUG, " distance = " << dist );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, " distance = " << dist );
if ( dist > max_dist ) {
max_dist = dist;
// index.
if ( max_index >= 0 ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG, " max_dist = " << max_dist );
- FG_LOG( FG_TERRAIN, FG_DEBUG, " index = " << max_index );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, " max_dist = " << max_dist );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, " index = " << max_index );
entry_free( max_index );
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT, "WHOOPS!!! Dying in next_avail()" );
+ SG_LOG( SG_TERRAIN, SG_ALERT, "WHOOPS!!! Dying in next_avail()" );
exit( -1 );
}
}
// Initialize the Scenery Management system
int fgSceneryInit( void ) {
- FG_LOG( FG_TERRAIN, FG_INFO, "Initializing scenery subsystem" );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Initializing scenery subsystem" );
scenery.center = Point3D(0.0);
scenery.cur_elev = -9999;
// ssg as well as the whole ssg branch
void FGTileEntry::free_tile() {
int i;
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
"FREEING TILE = (" << tile_bucket << ")" );
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
" deleting " << nodes.size() << " nodes" );
nodes.clear();
// delete the ssg structures
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
" deleting (leaf data) vertex, normal, and "
<< " texture coordinate arrays" );
parent->removeKid( terra_transform );
terra_transform = NULL;
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"parent pointer is NULL! Dying" );
exit(-1);
}
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Parent count is zero for an ssg tile! Dying" );
exit(-1);
}
parent->removeKid( lights_transform );
lights_transform = NULL;
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"parent pointer is NULL! Dying" );
exit(-1);
}
} else {
- FG_LOG( FG_TERRAIN, FG_ALERT,
+ SG_LOG( SG_TERRAIN, SG_ALERT,
"Parent count is zero for an ssg light tile! Dying" );
exit(-1);
}
// Initialize the Tile Manager subsystem
int FGTileMgr::init() {
- FG_LOG( FG_TERRAIN, FG_INFO, "Initializing Tile Manager subsystem." );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Initializing Tile Manager subsystem." );
if ( state != Start ) {
- FG_LOG( FG_TERRAIN, FG_INFO,
+ SG_LOG( SG_TERRAIN, SG_INFO,
"... Reinitializing." );
destroy_queue();
} else {
- FG_LOG( FG_TERRAIN, FG_INFO,
+ SG_LOG( SG_TERRAIN, SG_INFO,
"... First time through." );
global_tile_cache.init();
}
FGTileEntry *t = global_tile_cache.get_tile( b );
if ( t == NULL ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG, "Loading tile " << b );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "Loading tile " << b );
global_tile_cache.fill_in( b );
t = global_tile_cache.get_tile( b );
t->prep_ssg_node( scenery.center, vis);
} else {
- FG_LOG( FG_TERRAIN, FG_DEBUG, "Tile already in cache " << b );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "Tile already in cache " << b );
}
}
// cout << "NED: " << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
return true;
} else {
- FG_LOG( FG_TERRAIN, FG_INFO, "no terrain intersection" );
+ SG_LOG( SG_TERRAIN, SG_INFO, "no terrain intersection" );
*terrain_elev = 0.0;
float *up = globals->get_current_view()->get_world_up();
sgdSetVec3(scenery.cur_normal, up[0], up[1], up[2]);
// First time through or we have teleported, initialize the
// system and load all relavant tiles
- FG_LOG( FG_TERRAIN, FG_INFO, "Updating Tile list for " << current_bucket );
+ SG_LOG( SG_TERRAIN, SG_INFO, "Updating Tile list for " << current_bucket );
cout << "tile cache size = " << global_tile_cache.get_size() << endl;
int i;
// have something to see in our first frame.
for ( i = 0; i < 9; ++i ) {
if ( load_queue.size() ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG,
+ SG_LOG( SG_TERRAIN, SG_DEBUG,
"Load queue not empty, loading a tile" );
SGBucket pending = load_queue.front();
// chunks. If the chunk isn't already in the cache, then read it from
// disk.
int FGTileMgr::update( double lon, double lat ) {
- FG_LOG( FG_TERRAIN, FG_DEBUG, "FGTileMgr::update()" );
+ SG_LOG( SG_TERRAIN, SG_DEBUG, "FGTileMgr::update()" );
// FGInterface *f = current_aircraft.fdm_state;
// latitude = f->get_Latitude() * SGD_RADIANS_TO_DEGREES;
longitude = lon;
latitude = lat;
- // FG_LOG( FG_TERRAIN, FG_DEBUG, "lon "<< lonlat[LON] <<
+ // SG_LOG( SG_TERRAIN, SG_DEBUG, "lon "<< lonlat[LON] <<
// " lat " << lonlat[LAT] );
current_bucket.set_bucket( longitude, latitude );
- // FG_LOG( FG_TERRAIN, FG_DEBUG, "Updating Tile list for " << current_bucket );
+ // SG_LOG( SG_TERRAIN, SG_DEBUG, "Updating Tile list for " << current_bucket );
if ( global_tile_cache.exists( current_bucket ) ) {
current_tile = global_tile_cache.get_tile( current_bucket );
scenery.next_center = current_tile->center;
} else {
- FG_LOG( FG_TERRAIN, FG_WARN, "Tile not found (Ok if initializing)" );
+ SG_LOG( SG_TERRAIN, SG_WARN, "Tile not found (Ok if initializing)" );
}
if ( state == Running ) {
}
if ( load_queue.size() ) {
- FG_LOG( FG_TERRAIN, FG_INFO, "Load queue size = " << load_queue.size()
+ SG_LOG( SG_TERRAIN, SG_INFO, "Load queue size = " << load_queue.size()
<< " loading a tile" );
SGBucket pending = load_queue.front();
audio_sched = new slScheduler( 8000 );
audio_mixer = new smMixer;
- FG_LOG( FG_GENERAL, FG_INFO,
+ SG_LOG( SG_GENERAL, SG_INFO,
"Rate = " << audio_sched->getRate()
<< " Bps = " << audio_sched->getBps()
<< " Stereo = " << audio_sched->getStereo() );
void
fgEVENT::run()
{
- FG_LOG(FG_EVENT, FG_DEBUG, "Running " << description );
+ SG_LOG(SG_EVENT, SG_DEBUG, "Running " << description );
// record starting time
last_run.stamp();
int
fgEVENT::PrintStats() const
{
- FG_LOG( FG_EVENT, FG_INFO,
+ SG_LOG( SG_EVENT, SG_INFO,
" " << description
<< " int=" << interval / 1000.0
<< " cum=" << cum_time
// Initialize the scheduling subsystem
void fgEVENT_MGR::Init( void ) {
- FG_LOG(FG_EVENT, FG_INFO, "Initializing event manager" );
+ SG_LOG(SG_EVENT, SG_INFO, "Initializing event manager" );
run_queue.erase( run_queue.begin(), run_queue.end() );
event_table.erase( event_table.begin(), event_table.end() );
// convert interval specified in milleseconds to usec
fgEVENT* e = new fgEVENT( desc, cb, status, interval * 1000 );
- FG_LOG( FG_EVENT, FG_INFO, "Registering event: " << desc );
+ SG_LOG( SG_EVENT, SG_INFO, "Registering event: " << desc );
// Actually run the event
e->run();
void
fgEVENT_MGR::PrintStats()
{
- FG_LOG( FG_EVENT, FG_INFO, "" );
- FG_LOG( FG_EVENT, FG_INFO, "Event Stats" );
- FG_LOG( FG_EVENT, FG_INFO, "-----------" );
+ SG_LOG( SG_EVENT, SG_INFO, "" );
+ SG_LOG( SG_EVENT, SG_INFO, "Event Stats" );
+ SG_LOG( SG_EVENT, SG_INFO, "-----------" );
ConstEventIterator first = event_table.begin();
ConstEventIterator last = event_table.end();
event_table.end(),
mem_fun( &fgEVENT::PrintStats ) );
#endif
- FG_LOG( FG_EVENT, FG_INFO, "");
+ SG_LOG( SG_EVENT, SG_INFO, "");
}
SGTimeStamp cur_time;
unsigned int i, size;
- FG_LOG( FG_EVENT, FG_DEBUG, "Processing events" );
+ SG_LOG( SG_EVENT, SG_DEBUG, "Processing events" );
// get the current time
cur_time.stamp();
- FG_LOG( FG_EVENT, FG_DEBUG,
+ SG_LOG( SG_EVENT, SG_DEBUG,
" Current timestamp = " << cur_time.get_seconds() );
// printf("Checking if anything is ready to move to the run queue\n");
// e = *current++;
e_ptr = event_table[i];
if ( e_ptr->status == fgEVENT::FG_EVENT_READY ) {
- FG_LOG( FG_EVENT, FG_DEBUG,
+ SG_LOG( SG_EVENT, SG_DEBUG,
" Item " << i << " current " << cur_time.get_seconds()
<< " next run @ " << e_ptr->next_run.get_seconds() );
if ( ( e_ptr->next_run - cur_time ) <= 0 ) {
// initialize lighting tables
void fgLIGHT::Init( void ) {
- FG_LOG( FG_EVENT, FG_INFO,
+ SG_LOG( SG_EVENT, SG_INFO,
"Initializing Lighting interpolation tables." );
// build the path name to the ambient lookup table
f = current_aircraft.fdm_state;
- FG_LOG( FG_EVENT, FG_INFO, "Updating light parameters." );
+ SG_LOG( SG_EVENT, SG_INFO, "Updating light parameters." );
// calculate lighting parameters based on sun's relative angle to
// local up
deg = sun_angle * SGD_RADIANS_TO_DEGREES;
- FG_LOG( FG_EVENT, FG_INFO, " Sun angle = " << deg );
+ SG_LOG( SG_EVENT, SG_INFO, " Sun angle = " << deg );
ambient = ambient_tbl->interpolate( deg );
diffuse = diffuse_tbl->interpolate( deg );
sky_brightness = sky_tbl->interpolate( deg );
- FG_LOG( FG_EVENT, FG_INFO,
+ SG_LOG( SG_EVENT, SG_INFO,
" ambient = " << ambient << " diffuse = " << diffuse
<< " sky = " << sky_brightness );
f = current_aircraft.fdm_state;
- FG_LOG( FG_EVENT, FG_DEBUG, "Updating adjusted fog parameters." );
+ SG_LOG( SG_EVENT, SG_DEBUG, "Updating adjusted fog parameters." );
// set fog color (we'll try to match the sunset color in the
// direction we are looking
rotation -= SGD_2PI;
}
rotation *= SGD_RADIANS_TO_DEGREES;
- // fgPrintf( FG_EVENT, FG_INFO,
+ // fgPrintf( SG_EVENT, SG_INFO,
// " View to sun difference in degrees = %.2f\n", rotation);
// next check if we are in a sunset/sunrise situation
/* lazy test to ensure gregorian calendar */
if (y < 1583) {
- FG_LOG( FG_EVENT, FG_ALERT,
+ SG_LOG( SG_EVENT, SG_ALERT,
"WHOOPS! Julian dates only valid for 1582 oct 15 or later" );
}
SGTime *t = globals->get_time_params();
v = (FGViewerRPH *)globals->get_current_view();
- FG_LOG( FG_EVENT, FG_INFO, " Updating Moon position" );
+ SG_LOG( SG_EVENT, SG_INFO, " Updating Moon position" );
// (not sure why there was two)
// fgMoonPosition(t->cur_time, &l->moon_lon, &moon_gd_lat);
p = Point3D( l->moon_lon, l->moon_gc_lat, sl_radius );
l->fg_moonpos = sgPolarToCart3d(p);
- FG_LOG( FG_EVENT, FG_INFO, " t->cur_time = " << t->get_cur_time() );
- FG_LOG( FG_EVENT, FG_INFO,
+ SG_LOG( SG_EVENT, SG_INFO, " t->cur_time = " << t->get_cur_time() );
+ SG_LOG( SG_EVENT, SG_INFO,
" Moon Geodetic lat = " << moon_gd_lat
<< " Geocentric lat = " << l->moon_gc_lat );
// << nmoon[2] << endl;
l->moon_angle = acos( sgScalarProductVec3( nup, nmoon ) );
- FG_LOG( FG_EVENT, FG_INFO, "moon angle relative to current location = "
+ SG_LOG( SG_EVENT, SG_INFO, "moon angle relative to current location = "
<< l->moon_angle );
// calculate vector to moon's position on the earth's surface
/* lazy test to ensure gregorian calendar */
if (y < 1583) {
- FG_LOG( FG_EVENT, FG_ALERT,
+ SG_LOG( SG_EVENT, SG_ALERT,
"WHOOPS! Julian dates only valid for 1582 oct 15 or later" );
}
SGTime *t = globals->get_time_params();
v = (FGViewerRPH *)globals->get_current_view();
- FG_LOG( FG_EVENT, FG_INFO, " Updating Sun position" );
- FG_LOG( FG_EVENT, FG_INFO, " Gst = " << t->getGst() );
+ SG_LOG( SG_EVENT, SG_INFO, " Updating Sun position" );
+ SG_LOG( SG_EVENT, SG_INFO, " Gst = " << t->getGst() );
fgSunPositionGST(t->getGst(), &l->sun_lon, &sun_gd_lat);
p = Point3D( l->sun_lon, l->sun_gc_lat, sl_radius );
l->fg_sunpos = sgPolarToCart3d(p);
- FG_LOG( FG_EVENT, FG_INFO, " t->cur_time = " << t->get_cur_time() );
- FG_LOG( FG_EVENT, FG_INFO,
+ SG_LOG( SG_EVENT, SG_INFO, " t->cur_time = " << t->get_cur_time() );
+ SG_LOG( SG_EVENT, SG_INFO,
" Sun Geodetic lat = " << sun_gd_lat
<< " Geocentric lat = " << l->sun_gc_lat );
// << nsun[2] << endl;
l->sun_angle = acos( sgScalarProductVec3 ( nup, nsun ) );
- FG_LOG( FG_EVENT, FG_INFO, "sun angle relative to current location = "
+ SG_LOG( SG_EVENT, SG_INFO, "sun angle relative to current location = "
<< l->sun_angle );
// calculate vector to sun's position on the earth's surface
// Initialize the weather modeling subsystem
void FGWeather::Init( ) {
- FG_LOG( FG_GENERAL, FG_INFO, "Initializing weather subsystem");
+ SG_LOG( SG_GENERAL, SG_INFO, "Initializing weather subsystem");
// Configure some wind
// FG_V_north_airmass = 15; // ft/s =~ 10mph
xglFogf (GL_FOG_DENSITY, fog_exp2_density);
xglFogi( GL_FOG_MODE, GL_EXP2 );
- // FG_LOG( FG_INPUT, FG_DEBUG, "Fog density = " << fog_density );
- // FG_LOG( FG_INPUT, FG_INFO,
+ // SG_LOG( SG_INPUT, SG_DEBUG, "Fog density = " << fog_density );
+ // SG_LOG( SG_INPUT, SG_INFO,
// "Fog exp2 density = " << fog_exp2_density );
}
};
projects / flightgear.git / commitdiff