fly/flightgear
1
0
Fork 0
Code Activity

Converted fgFLIGHT to a class.

Browse source
This commit is contained in:
curt 1998-12-03 01:14:58 +00:00
parent 711080b063
commit 7fbb963a39
15 changed files with 916 additions and 753 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Aircraft/aircraft.cxx
View file

@ -50,14 +50,16 @@ void fgAircraftOutputCurrent(fgAIRCRAFT *a) {
FG_LOG( FG_FLIGHT, FG_DEBUG,
"Pos = ("
<< (FG_Longitude * 3600.0 * RAD_TO_DEG) << ","
<< (FG_Latitude * 3600.0 * RAD_TO_DEG) << ","
<< FG_Altitude
<< (f->get_Longitude() * 3600.0 * RAD_TO_DEG) << ","
<< (f->get_Latitude() * 3600.0 * RAD_TO_DEG) << ","
<< f->get_Altitude()
<< ") (Phi,Theta,Psi)=("
<< FG_Phi << "," << FG_Theta << "," << FG_Psi << ")" );
<< f->get_Phi() << ","
<< f->get_Theta() << ","
<< f->get_Psi() << ")" );
FG_LOG( FG_FLIGHT, FG_DEBUG,
"Kts = " << FG_V_equiv_kts
"Kts = " << f->get_V_equiv_kts()
<< " Elev = " << controls.get_elevator()
<< " Aileron = " << controls.get_aileron()
<< " Rudder = " << controls.get_rudder()
@ -66,6 +68,9 @@ void fgAircraftOutputCurrent(fgAIRCRAFT *a) {
// $Log$
// Revision 1.5 1998/12/03 01:14:58 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.4 1998/11/06 21:17:31 curt
// Converted to new logstream debugging facility. This allows release
// builds with no messages at all (and no performance impact) by using

18
Autopilot/autopilot.cxx
View file

@ -53,7 +53,7 @@ static double get_speed( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_V_equiv_kts ); // Make an explicit function call.
return( f->get_V_equiv_kts() ); // Make an explicit function call.
}
static double get_aoa( void )
@ -61,7 +61,7 @@ static double get_aoa( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Gamma_vert_rad * RAD_TO_DEG );
return( f->get_Gamma_vert_rad() * RAD_TO_DEG );
}
static double fgAPget_roll( void )
@ -69,7 +69,7 @@ static double fgAPget_roll( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Phi * RAD_TO_DEG );
return( f->get_Phi() * RAD_TO_DEG );
}
static double get_pitch( void )
@ -77,7 +77,7 @@ static double get_pitch( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Theta );
return( f->get_Theta() );
}
double fgAPget_heading( void )
@ -85,7 +85,7 @@ double fgAPget_heading( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Psi * RAD_TO_DEG );
return( f->get_Psi() * RAD_TO_DEG );
}
static double fgAPget_altitude( void )
@ -94,7 +94,7 @@ static double fgAPget_altitude( void )
f = current_aircraft.flight;
return( FG_Altitude * FEET_TO_METER /* -rough_elev */ );
return( f->get_Altitude() * FEET_TO_METER /* -rough_elev */ );
}
static double fgAPget_climb( void )
@ -104,7 +104,7 @@ static double fgAPget_climb( void )
f = current_aircraft.flight;
// return in meters per minute
return( FG_Climb_Rate * FEET_TO_METER * 60 );
return( f->get_Climb_Rate() * FEET_TO_METER * 60 );
}
static double get_sideslip( void )
@ -113,7 +113,7 @@ static double get_sideslip( void )
f = current_aircraft.flight;
return( FG_Beta );
return( f->get_Beta() );
}
static double fgAPget_agl( void )
@ -122,7 +122,7 @@ static double fgAPget_agl( void )
double agl;
f = current_aircraft.flight;
agl = FG_Altitude * FEET_TO_METER - scenery.cur_elev;
agl = f->get_Altitude() * FEET_TO_METER - scenery.cur_elev;
return( agl );
}

40
Cockpit/cockpit.cxx
View file

@ -70,8 +70,9 @@ double get_latitude( void )
f = current_aircraft.flight;
// return( toDM(FG_Latitude * RAD_TO_DEG) );
return((double)((int)( FG_Latitude * RAD_TO_DEG)) );
return((double)((int)( f->get_Latitude() * RAD_TO_DEG)) );
}
double get_lat_min( void )
{
fgFLIGHT *f;
@ -79,7 +80,7 @@ double get_lat_min( void )
f = current_aircraft.flight;
a = FG_Latitude * RAD_TO_DEG;
a = f->get_Latitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
@ -94,7 +95,7 @@ double get_longitude( void )
f = current_aircraft.flight;
// return( toDM(FG_Longitude * RAD_TO_DEG) );
return((double)((int) (FG_Longitude * RAD_TO_DEG)) );
return((double)((int) (f->get_Longitude() * RAD_TO_DEG)) );
}
double get_long_min( void )
{
@ -103,7 +104,7 @@ double get_long_min( void )
f = current_aircraft.flight;
a = FG_Longitude * RAD_TO_DEG;
a = f->get_Longitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
@ -141,7 +142,7 @@ double get_speed( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_V_equiv_kts ); // Make an explicit function call.
return( f->get_V_equiv_kts() ); // Make an explicit function call.
}
double get_aoa( void )
@ -149,7 +150,7 @@ double get_aoa( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Gamma_vert_rad * RAD_TO_DEG );
return( f->get_Gamma_vert_rad() * RAD_TO_DEG );
}
double get_roll( void )
@ -157,7 +158,7 @@ double get_roll( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Phi );
return( f->get_Phi() );
}
double get_pitch( void )
@ -165,7 +166,7 @@ double get_pitch( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Theta );
return( f->get_Theta() );
}
double get_heading( void )
@ -173,7 +174,7 @@ double get_heading( void )
fgFLIGHT *f;
f = current_aircraft.flight;
return( FG_Psi * RAD_TO_DEG );
return( f->get_Psi() * RAD_TO_DEG );
}
double get_altitude( void )
@ -182,13 +183,13 @@ double get_altitude( void )
// double rough_elev;
f = current_aircraft.flight;
// rough_elev = mesh_altitude(FG_Longitude * RAD_TO_ARCSEC,
// FG_Latitude * RAD_TO_ARCSEC);
// rough_elev = mesh_altitude(f->get_Longitude() * RAD_TO_ARCSEC,
// f->get_Latitude() * RAD_TO_ARCSEC);
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return FG_Altitude;
return f->get_Altitude();
} else {
return FG_Altitude * FEET_TO_METER;
return f->get_Altitude() * FEET_TO_METER;
}
}
@ -199,9 +200,9 @@ double get_agl( void )
f = current_aircraft.flight;
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return FG_Altitude - scenery.cur_elev * METER_TO_FEET;
return f->get_Altitude() - scenery.cur_elev * METER_TO_FEET;
} else {
return FG_Altitude * FEET_TO_METER - scenery.cur_elev;
return f->get_Altitude() * FEET_TO_METER - scenery.cur_elev;
}
}
@ -211,7 +212,7 @@ double get_sideslip( void )
f = current_aircraft.flight;
return( FG_Beta );
return( f->get_Beta() );
}
double get_frame_rate( void )
@ -249,9 +250,9 @@ double get_climb_rate( void )
f = current_aircraft.flight;
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return FG_Climb_Rate * 60.0;
return f->get_Climb_Rate() * 60.0;
} else {
return FG_Climb_Rate * FEET_TO_METER * 60.0;
return f->get_Climb_Rate() * FEET_TO_METER * 60.0;
}
}
@ -311,6 +312,9 @@ void fgCockpitUpdate( void ) {
// $Log$
// Revision 1.24 1998/12/03 01:16:00 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.23 1998/11/09 23:38:50 curt
// Panel updates from Friedemann.
//

693
FDM/LaRCsim.cxx
View file

@ -42,13 +42,13 @@ int fgLaRCsimInit(double dt) {
// Run an iteration of the EOM (equations of motion)
int fgLaRCsimUpdate(fgFLIGHT *f, int multiloop) {
int fgLaRCsimUpdate(fgFLIGHT& f, int multiloop) {
double save_alt = 0.0;
// lets try to avoid really screwing up the LaRCsim model
if ( FG_Altitude < -9000 ) {
save_alt = FG_Altitude;
FG_Altitude = 0;
if ( f.get_Altitude() < -9000 ) {
save_alt = f.get_Altitude();
f.set_Altitude( 0.0 );
}
// translate FG to LaRCsim structure
@ -68,8 +68,8 @@ int fgLaRCsimUpdate(fgFLIGHT *f, int multiloop) {
fgLaRCsim_2_Flight(f);
// but lets restore our original bogus altitude when we are done
if ( save_alt < -9000 ) {
FG_Altitude = save_alt;
if ( save_alt < -9000.0 ) {
f.set_Altitude( save_alt );
}
return 1;
@ -77,7 +77,7 @@ int fgLaRCsimUpdate(fgFLIGHT *f, int multiloop) {
// Convert from the fgFLIGHT struct to the LaRCsim generic_ struct
int fgFlight_2_LaRCsim (fgFLIGHT *f) {
int fgFlight_2_LaRCsim (fgFLIGHT& f) {
Lat_control = controls.get_aileron();
Long_control = controls.get_elevator();
@ -86,357 +86,358 @@ int fgFlight_2_LaRCsim (fgFLIGHT *f) {
Throttle_pct = controls.get_throttle( 0 );
Brake_pct = controls.get_brake( 0 );
Mass = FG_Mass;
I_xx = FG_I_xx;
I_yy = FG_I_yy;
I_zz = FG_I_zz;
I_xz = FG_I_xz;
Dx_pilot = FG_Dx_pilot;
Dy_pilot = FG_Dy_pilot;
Dz_pilot = FG_Dz_pilot;
Dx_cg = FG_Dx_cg;
Dy_cg = FG_Dy_cg;
Dz_cg = FG_Dz_cg;
F_X = FG_F_X;
F_Y = FG_F_Y;
F_Z = FG_F_Z;
F_north = FG_F_north;
F_east = FG_F_east;
F_down = FG_F_down;
F_X_aero = FG_F_X_aero;
F_Y_aero = FG_F_Y_aero;
F_Z_aero = FG_F_Z_aero;
F_X_engine = FG_F_X_engine;
F_Y_engine = FG_F_Y_engine;
F_Z_engine = FG_F_Z_engine;
F_X_gear = FG_F_X_gear;
F_Y_gear = FG_F_Y_gear;
F_Z_gear = FG_F_Z_gear;
M_l_rp = FG_M_l_rp;
M_m_rp = FG_M_m_rp;
M_n_rp = FG_M_n_rp;
M_l_cg = FG_M_l_cg;
M_m_cg = FG_M_m_cg;
M_n_cg = FG_M_n_cg;
M_l_aero = FG_M_l_aero;
M_m_aero = FG_M_m_aero;
M_n_aero = FG_M_n_aero;
M_l_engine = FG_M_l_engine;
M_m_engine = FG_M_m_engine;
M_n_engine = FG_M_n_engine;
M_l_gear = FG_M_l_gear;
M_m_gear = FG_M_m_gear;
M_n_gear = FG_M_n_gear;
V_dot_north = FG_V_dot_north;
V_dot_east = FG_V_dot_east;
V_dot_down = FG_V_dot_down;
U_dot_body = FG_U_dot_body;
V_dot_body = FG_V_dot_body;
W_dot_body = FG_W_dot_body;
A_X_cg = FG_A_X_cg;
A_Y_cg = FG_A_Y_cg;
A_Z_cg = FG_A_Z_cg;
A_X_pilot = FG_A_X_pilot;
A_Y_pilot = FG_A_Y_pilot;
A_Z_pilot = FG_A_Z_pilot;
N_X_cg = FG_N_X_cg;
N_Y_cg = FG_N_Y_cg;
N_Z_cg = FG_N_Z_cg;
N_X_pilot = FG_N_X_pilot;
N_Y_pilot = FG_N_Y_pilot;
N_Z_pilot = FG_N_Z_pilot;
P_dot_body = FG_P_dot_body;
Q_dot_body = FG_Q_dot_body;
R_dot_body = FG_R_dot_body;
V_north = FG_V_north;
V_east = FG_V_east;
V_down = FG_V_down;
V_north_rel_ground = FG_V_north_rel_ground;
V_east_rel_ground = FG_V_east_rel_ground;
V_down_rel_ground = FG_V_down_rel_ground;
V_north_airmass = FG_V_north_airmass;
V_east_airmass = FG_V_east_airmass;
V_down_airmass = FG_V_down_airmass;
V_north_rel_airmass = FG_V_north_rel_airmass;
V_east_rel_airmass = FG_V_east_rel_airmass;
V_down_rel_airmass = FG_V_down_rel_airmass;
U_gust = FG_U_gust;
V_gust = FG_V_gust;
W_gust = FG_W_gust;
U_body = FG_U_body;
V_body = FG_V_body;
W_body = FG_W_body;
V_rel_wind = FG_V_rel_wind;
V_true_kts = FG_V_true_kts;
V_rel_ground = FG_V_rel_ground;
V_inertial = FG_V_inertial;
V_ground_speed = FG_V_ground_speed;
V_equiv = FG_V_equiv;
V_equiv_kts = FG_V_equiv_kts;
V_calibrated = FG_V_calibrated;
V_calibrated_kts = FG_V_calibrated_kts;
P_body = FG_P_body;
Q_body = FG_Q_body;
R_body = FG_R_body;
P_local = FG_P_local;
Q_local = FG_Q_local;
R_local = FG_R_local;
P_total = FG_P_total;
Q_total = FG_Q_total;
R_total = FG_R_total;
Phi_dot = FG_Phi_dot;
Theta_dot = FG_Theta_dot;
Psi_dot = FG_Psi_dot;
Latitude_dot = FG_Latitude_dot;
Longitude_dot = FG_Longitude_dot;
Radius_dot = FG_Radius_dot;
Lat_geocentric = FG_Lat_geocentric;
Lon_geocentric = FG_Lon_geocentric;
Radius_to_vehicle = FG_Radius_to_vehicle;
Latitude = FG_Latitude;
Longitude = FG_Longitude;
Altitude = FG_Altitude;
Phi = FG_Phi;
Theta = FG_Theta;
Psi = FG_Psi;
T_local_to_body_11 = FG_T_local_to_body_11;
T_local_to_body_12 = FG_T_local_to_body_12;
T_local_to_body_13 = FG_T_local_to_body_13;
T_local_to_body_21 = FG_T_local_to_body_21;
T_local_to_body_22 = FG_T_local_to_body_22;
T_local_to_body_23 = FG_T_local_to_body_23;
T_local_to_body_31 = FG_T_local_to_body_31;
T_local_to_body_32 = FG_T_local_to_body_32;
T_local_to_body_33 = FG_T_local_to_body_33;
Gravity = FG_Gravity;
Centrifugal_relief = FG_Centrifugal_relief;
Alpha = FG_Alpha;
Beta = FG_Beta;
Alpha_dot = FG_Alpha_dot;
Beta_dot = FG_Beta_dot;
Cos_alpha = FG_Cos_alpha;
Sin_alpha = FG_Sin_alpha;
Cos_beta = FG_Cos_beta;
Sin_beta = FG_Sin_beta;
Cos_phi = FG_Cos_phi;
Sin_phi = FG_Sin_phi;
Cos_theta = FG_Cos_theta;
Sin_theta = FG_Sin_theta;
Cos_psi = FG_Cos_psi;
Sin_psi = FG_Sin_psi;
Gamma_vert_rad = FG_Gamma_vert_rad;
Gamma_horiz_rad = FG_Gamma_horiz_rad;
Sigma = FG_Sigma;
Density = FG_Density;
V_sound = FG_V_sound;
Mach_number = FG_Mach_number;
Static_pressure = FG_Static_pressure;
Total_pressure = FG_Total_pressure;
Impact_pressure = FG_Impact_pressure;
Dynamic_pressure = FG_Dynamic_pressure;
Static_temperature = FG_Static_temperature;
Total_temperature = FG_Total_temperature;
Sea_level_radius = FG_Sea_level_radius;
Earth_position_angle = FG_Earth_position_angle;
Runway_altitude = FG_Runway_altitude;
Runway_latitude = FG_Runway_latitude;
Runway_longitude = FG_Runway_longitude;
Runway_heading = FG_Runway_heading;
Radius_to_rwy = FG_Radius_to_rwy;
D_cg_north_of_rwy = FG_D_cg_north_of_rwy;
D_cg_east_of_rwy = FG_D_cg_east_of_rwy;
D_cg_above_rwy = FG_D_cg_above_rwy;
X_cg_rwy = FG_X_cg_rwy;
Y_cg_rwy = FG_Y_cg_rwy;
H_cg_rwy = FG_H_cg_rwy;
D_pilot_north_of_rwy = FG_D_pilot_north_of_rwy;
D_pilot_east_of_rwy = FG_D_pilot_east_of_rwy;
D_pilot_above_rwy = FG_D_pilot_above_rwy;
X_pilot_rwy = FG_X_pilot_rwy;
Y_pilot_rwy = FG_Y_pilot_rwy;
H_pilot_rwy = FG_H_pilot_rwy;
Mass = f.get_Mass();
I_xx = f.get_I_xx();
I_yy = f.get_I_yy();
I_zz = f.get_I_zz();
I_xz = f.get_I_xz();
Dx_pilot = f.get_Dx_pilot();
Dy_pilot = f.get_Dy_pilot();
Dz_pilot = f.get_Dz_pilot();
Dx_cg = f.get_Dx_cg();
Dy_cg = f.get_Dy_cg();
Dz_cg = f.get_Dz_cg();
F_X = f.get_F_X();
F_Y = f.get_F_Y();
F_Z = f.get_F_Z();
F_north = f.get_F_north();
F_east = f.get_F_east();
F_down = f.get_F_down();
F_X_aero = f.get_F_X_aero();
F_Y_aero = f.get_F_Y_aero();
F_Z_aero = f.get_F_Z_aero();
F_X_engine = f.get_F_X_engine();
F_Y_engine = f.get_F_Y_engine();
F_Z_engine = f.get_F_Z_engine();
F_X_gear = f.get_F_X_gear();
F_Y_gear = f.get_F_Y_gear();
F_Z_gear = f.get_F_Z_gear();
M_l_rp = f.get_M_l_rp();
M_m_rp = f.get_M_m_rp();
M_n_rp = f.get_M_n_rp();
M_l_cg = f.get_M_l_cg();
M_m_cg = f.get_M_m_cg();
M_n_cg = f.get_M_n_cg();
M_l_aero = f.get_M_l_aero();
M_m_aero = f.get_M_m_aero();
M_n_aero = f.get_M_n_aero();
M_l_engine = f.get_M_l_engine();
M_m_engine = f.get_M_m_engine();
M_n_engine = f.get_M_n_engine();
M_l_gear = f.get_M_l_gear();
M_m_gear = f.get_M_m_gear();
M_n_gear = f.get_M_n_gear();
V_dot_north = f.get_V_dot_north();
V_dot_east = f.get_V_dot_east();
V_dot_down = f.get_V_dot_down();
U_dot_body = f.get_U_dot_body();
V_dot_body = f.get_V_dot_body();
W_dot_body = f.get_W_dot_body();
A_X_cg = f.get_A_X_cg();
A_Y_cg = f.get_A_Y_cg();
A_Z_cg = f.get_A_Z_cg();
A_X_pilot = f.get_A_X_pilot();
A_Y_pilot = f.get_A_Y_pilot();
A_Z_pilot = f.get_A_Z_pilot();
N_X_cg = f.get_N_X_cg();
N_Y_cg = f.get_N_Y_cg();
N_Z_cg = f.get_N_Z_cg();
N_X_pilot = f.get_N_X_pilot();
N_Y_pilot = f.get_N_Y_pilot();
N_Z_pilot = f.get_N_Z_pilot();
P_dot_body = f.get_P_dot_body();
Q_dot_body = f.get_Q_dot_body();
R_dot_body = f.get_R_dot_body();
V_north = f.get_V_north();
V_east = f.get_V_east();
V_down = f.get_V_down();
V_north_rel_ground = f.get_V_north_rel_ground();
V_east_rel_ground = f.get_V_east_rel_ground();
V_down_rel_ground = f.get_V_down_rel_ground();
V_north_airmass = f.get_V_north_airmass();
V_east_airmass = f.get_V_east_airmass();
V_down_airmass = f.get_V_down_airmass();
V_north_rel_airmass = f.get_V_north_rel_airmass();
V_east_rel_airmass = f.get_V_east_rel_airmass();
V_down_rel_airmass = f.get_V_down_rel_airmass();
U_gust = f.get_U_gust();
V_gust = f.get_V_gust();
W_gust = f.get_W_gust();
U_body = f.get_U_body();
V_body = f.get_V_body();
W_body = f.get_W_body();
V_rel_wind = f.get_V_rel_wind();
V_true_kts = f.get_V_true_kts();
V_rel_ground = f.get_V_rel_ground();
V_inertial = f.get_V_inertial();
V_ground_speed = f.get_V_ground_speed();
V_equiv = f.get_V_equiv();
V_equiv_kts = f.get_V_equiv_kts();
V_calibrated = f.get_V_calibrated();
V_calibrated_kts = f.get_V_calibrated_kts();
P_body = f.get_P_body();
Q_body = f.get_Q_body();
R_body = f.get_R_body();
P_local = f.get_P_local();
Q_local = f.get_Q_local();
R_local = f.get_R_local();
P_total = f.get_P_total();
Q_total = f.get_Q_total();
R_total = f.get_R_total();
Phi_dot = f.get_Phi_dot();
Theta_dot = f.get_Theta_dot();
Psi_dot = f.get_Psi_dot();
Latitude_dot = f.get_Latitude_dot();
Longitude_dot = f.get_Longitude_dot();
Radius_dot = f.get_Radius_dot();
Lat_geocentric = f.get_Lat_geocentric();
Lon_geocentric = f.get_Lon_geocentric();
Radius_to_vehicle = f.get_Radius_to_vehicle();
Latitude = f.get_Latitude();
Longitude = f.get_Longitude();
Altitude = f.get_Altitude();
Phi = f.get_Phi();
Theta = f.get_Theta();
Psi = f.get_Psi();
T_local_to_body_11 = f.get_T_local_to_body_11();
T_local_to_body_12 = f.get_T_local_to_body_12();
T_local_to_body_13 = f.get_T_local_to_body_13();
T_local_to_body_21 = f.get_T_local_to_body_21();
T_local_to_body_22 = f.get_T_local_to_body_22();
T_local_to_body_23 = f.get_T_local_to_body_23();
T_local_to_body_31 = f.get_T_local_to_body_31();
T_local_to_body_32 = f.get_T_local_to_body_32();
T_local_to_body_33 = f.get_T_local_to_body_33();
Gravity = f.get_Gravity();
Centrifugal_relief = f.get_Centrifugal_relief();
Alpha = f.get_Alpha();
Beta = f.get_Beta();
Alpha_dot = f.get_Alpha_dot();
Beta_dot = f.get_Beta_dot();
Cos_alpha = f.get_Cos_alpha();
Sin_alpha = f.get_Sin_alpha();
Cos_beta = f.get_Cos_beta();
Sin_beta = f.get_Sin_beta();
Cos_phi = f.get_Cos_phi();
Sin_phi = f.get_Sin_phi();
Cos_theta = f.get_Cos_theta();
Sin_theta = f.get_Sin_theta();
Cos_psi = f.get_Cos_psi();
Sin_psi = f.get_Sin_psi();
Gamma_vert_rad = f.get_Gamma_vert_rad();
Gamma_horiz_rad = f.get_Gamma_horiz_rad();
Sigma = f.get_Sigma();
Density = f.get_Density();
V_sound = f.get_V_sound();
Mach_number = f.get_Mach_number();
Static_pressure = f.get_Static_pressure();
Total_pressure = f.get_Total_pressure();
Impact_pressure = f.get_Impact_pressure();
Dynamic_pressure = f.get_Dynamic_pressure();
Static_temperature = f.get_Static_temperature();
Total_temperature = f.get_Total_temperature();
Sea_level_radius = f.get_Sea_level_radius();
Earth_position_angle = f.get_Earth_position_angle();
Runway_altitude = f.get_Runway_altitude();
Runway_latitude = f.get_Runway_latitude();
Runway_longitude = f.get_Runway_longitude();
Runway_heading = f.get_Runway_heading();
Radius_to_rwy = f.get_Radius_to_rwy();
D_cg_north_of_rwy = f.get_D_cg_north_of_rwy();
D_cg_east_of_rwy = f.get_D_cg_east_of_rwy();
D_cg_above_rwy = f.get_D_cg_above_rwy();
X_cg_rwy = f.get_X_cg_rwy();
Y_cg_rwy = f.get_Y_cg_rwy();
H_cg_rwy = f.get_H_cg_rwy();
D_pilot_north_of_rwy = f.get_D_pilot_north_of_rwy();
D_pilot_east_of_rwy = f.get_D_pilot_east_of_rwy();
D_pilot_above_rwy = f.get_D_pilot_above_rwy();
X_pilot_rwy = f.get_X_pilot_rwy();
Y_pilot_rwy = f.get_Y_pilot_rwy();
H_pilot_rwy = f.get_H_pilot_rwy();
return( 0 );
}
// Convert from the LaRCsim generic_ struct to the fgFLIGHT struct
int fgLaRCsim_2_Flight (fgFLIGHT *f) {
FG_Mass = Mass;
FG_I_xx = I_xx;
FG_I_yy = I_yy;
FG_I_zz = I_zz;
FG_I_xz = I_xz;
FG_Dx_pilot = Dx_pilot;
FG_Dy_pilot = Dy_pilot;
FG_Dz_pilot = Dz_pilot;
FG_Dx_cg = Dx_cg;
FG_Dy_cg = Dy_cg;
FG_Dz_cg = Dz_cg;
FG_F_X = F_X;
FG_F_Y = F_Y;
FG_F_Z = F_Z;
FG_F_north = F_north;
FG_F_east = F_east;
FG_F_down = F_down;
FG_F_X_aero = F_X_aero;
FG_F_Y_aero = F_Y_aero;
FG_F_Z_aero = F_Z_aero;
FG_F_X_engine = F_X_engine;
FG_F_Y_engine = F_Y_engine;
FG_F_Z_engine = F_Z_engine;
FG_F_X_gear = F_X_gear;
FG_F_Y_gear = F_Y_gear;
FG_F_Z_gear = F_Z_gear;
FG_M_l_rp = M_l_rp;
FG_M_m_rp = M_m_rp;
FG_M_n_rp = M_n_rp;
FG_M_l_cg = M_l_cg;
FG_M_m_cg = M_m_cg;
FG_M_n_cg = M_n_cg;
FG_M_l_aero = M_l_aero;
FG_M_m_aero = M_m_aero;
FG_M_n_aero = M_n_aero;
FG_M_l_engine = M_l_engine;
FG_M_m_engine = M_m_engine;
FG_M_n_engine = M_n_engine;
FG_M_l_gear = M_l_gear;
FG_M_m_gear = M_m_gear;
FG_M_n_gear = M_n_gear;
FG_V_dot_north = V_dot_north;
FG_V_dot_east = V_dot_east;
FG_V_dot_down = V_dot_down;
FG_U_dot_body = U_dot_body;
FG_V_dot_body = V_dot_body;
FG_W_dot_body = W_dot_body;
FG_A_X_cg = A_X_cg;
FG_A_Y_cg = A_Y_cg;
FG_A_Z_cg = A_Z_cg;
FG_A_X_pilot = A_X_pilot;
FG_A_Y_pilot = A_Y_pilot;
FG_A_Z_pilot = A_Z_pilot;
FG_N_X_cg = N_X_cg;
FG_N_Y_cg = N_Y_cg;
FG_N_Z_cg = N_Z_cg;
FG_N_X_pilot = N_X_pilot;
FG_N_Y_pilot = N_Y_pilot;
FG_N_Z_pilot = N_Z_pilot;
FG_P_dot_body = P_dot_body;
FG_Q_dot_body = Q_dot_body;
FG_R_dot_body = R_dot_body;
FG_V_north = V_north;
FG_V_east = V_east;
FG_V_down = V_down;
FG_V_north_rel_ground = V_north_rel_ground;
FG_V_east_rel_ground = V_east_rel_ground;
FG_V_down_rel_ground = V_down_rel_ground;
FG_V_north_airmass = V_north_airmass;
FG_V_east_airmass = V_east_airmass;
FG_V_down_airmass = V_down_airmass;
FG_V_north_rel_airmass = V_north_rel_airmass;
FG_V_east_rel_airmass = V_east_rel_airmass;
FG_V_down_rel_airmass = V_down_rel_airmass;
FG_U_gust = U_gust;
FG_V_gust = V_gust;
FG_W_gust = W_gust;
FG_U_body = U_body;
FG_V_body = V_body;
FG_W_body = W_body;
FG_V_rel_wind = V_rel_wind;
FG_V_true_kts = V_true_kts;
FG_V_rel_ground = V_rel_ground;
FG_V_inertial = V_inertial;
FG_V_ground_speed = V_ground_speed;
FG_V_equiv = V_equiv;
FG_V_equiv_kts = V_equiv_kts;
FG_V_calibrated = V_calibrated;
FG_V_calibrated_kts = V_calibrated_kts;
FG_P_body = P_body;
FG_Q_body = Q_body;
FG_R_body = R_body;
FG_P_local = P_local;
FG_Q_local = Q_local;
FG_R_local = R_local;
FG_P_total = P_total;
FG_Q_total = Q_total;
FG_R_total = R_total;
FG_Phi_dot = Phi_dot;
FG_Theta_dot = Theta_dot;
FG_Psi_dot = Psi_dot;
FG_Latitude_dot = Latitude_dot;
FG_Longitude_dot = Longitude_dot;
FG_Radius_dot = Radius_dot;
FG_Lat_geocentric = Lat_geocentric;
FG_Lon_geocentric = Lon_geocentric;
FG_Radius_to_vehicle = Radius_to_vehicle;
FG_Latitude = Latitude;
FG_Longitude = Longitude;
FG_Altitude = Altitude;
FG_Phi = Phi;
FG_Theta = Theta;
FG_Psi = Psi;
FG_T_local_to_body_11 = T_local_to_body_11;
FG_T_local_to_body_12 = T_local_to_body_12;
FG_T_local_to_body_13 = T_local_to_body_13;
FG_T_local_to_body_21 = T_local_to_body_21;
FG_T_local_to_body_22 = T_local_to_body_22;
FG_T_local_to_body_23 = T_local_to_body_23;
FG_T_local_to_body_31 = T_local_to_body_31;
FG_T_local_to_body_32 = T_local_to_body_32;
FG_T_local_to_body_33 = T_local_to_body_33;
FG_Gravity = Gravity;
FG_Centrifugal_relief = Centrifugal_relief;
FG_Alpha = Alpha;
FG_Beta = Beta;
FG_Alpha_dot = Alpha_dot;
FG_Beta_dot = Beta_dot;
FG_Cos_alpha = Cos_alpha;
FG_Sin_alpha = Sin_alpha;
FG_Cos_beta = Cos_beta;
FG_Sin_beta = Sin_beta;
FG_Cos_phi = Cos_phi;
FG_Sin_phi = Sin_phi;
FG_Cos_theta = Cos_theta;
FG_Sin_theta = Sin_theta;
FG_Cos_psi = Cos_psi;
FG_Sin_psi = Sin_psi;
FG_Gamma_vert_rad = Gamma_vert_rad;
FG_Gamma_horiz_rad = Gamma_horiz_rad;
FG_Sigma = Sigma;
FG_Density = Density;
FG_V_sound = V_sound;
FG_Mach_number = Mach_number;
FG_Static_pressure = Static_pressure;
FG_Total_pressure = Total_pressure;
FG_Impact_pressure = Impact_pressure;
FG_Dynamic_pressure = Dynamic_pressure;
FG_Static_temperature = Static_temperature;
FG_Total_temperature = Total_temperature;
FG_Sea_level_radius = Sea_level_radius;
FG_Earth_position_angle = Earth_position_angle;
FG_Runway_altitude = Runway_altitude;
FG_Runway_latitude = Runway_latitude;
FG_Runway_longitude = Runway_longitude;
FG_Runway_heading = Runway_heading;
FG_Radius_to_rwy = Radius_to_rwy;
FG_D_cg_north_of_rwy = D_cg_north_of_rwy;
FG_D_cg_east_of_rwy = D_cg_east_of_rwy;
FG_D_cg_above_rwy = D_cg_above_rwy;
FG_X_cg_rwy = X_cg_rwy;
FG_Y_cg_rwy = Y_cg_rwy;
FG_H_cg_rwy = H_cg_rwy;
FG_D_pilot_north_of_rwy = D_pilot_north_of_rwy;
FG_D_pilot_east_of_rwy = D_pilot_east_of_rwy;
FG_D_pilot_above_rwy = D_pilot_above_rwy;
FG_X_pilot_rwy = X_pilot_rwy;
FG_Y_pilot_rwy = Y_pilot_rwy;
FG_H_pilot_rwy = H_pilot_rwy;
int fgLaRCsim_2_Flight (fgFLIGHT& f) {
f.set_Inertias( Mass, I_xx, I_yy, I_zz, I_xz );
/*
f.get_Dx_pilot() = Dx_pilot;
f.get_Dy_pilot() = Dy_pilot;
f.get_Dz_pilot() = Dz_pilot;
f.get_Dx_cg() = Dx_cg;
f.get_Dy_cg() = Dy_cg;
f.get_Dz_cg() = Dz_cg;
f.get_F_X() = F_X;
f.get_F_Y() = F_Y;
f.get_F_Z() = F_Z;
f.get_F_north() = F_north;
f.get_F_east() = F_east;
f.get_F_down() = F_down;
f.get_F_X_aero() = F_X_aero;
f.get_F_Y_aero() = F_Y_aero;
f.get_F_Z_aero() = F_Z_aero;
f.get_F_X_engine() = F_X_engine;
f.get_F_Y_engine() = F_Y_engine;
f.get_F_Z_engine() = F_Z_engine;
f.get_F_X_gear() = F_X_gear;
f.get_F_Y_gear() = F_Y_gear;
f.get_F_Z_gear() = F_Z_gear;
f.get_M_l_rp() = M_l_rp;
f.get_M_m_rp() = M_m_rp;
f.get_M_n_rp() = M_n_rp;
f.get_M_l_cg() = M_l_cg;
f.get_M_m_cg() = M_m_cg;
f.get_M_n_cg() = M_n_cg;
f.get_M_l_aero() = M_l_aero;
f.get_M_m_aero() = M_m_aero;
f.get_M_n_aero() = M_n_aero;
f.get_M_l_engine() = M_l_engine;
f.get_M_m_engine() = M_m_engine;
f.get_M_n_engine() = M_n_engine;
f.get_M_l_gear() = M_l_gear;
f.get_M_m_gear() = M_m_gear;
f.get_M_n_gear() = M_n_gear;
f.get_V_dot_north() = V_dot_north;
f.get_V_dot_east() = V_dot_east;
f.get_V_dot_down() = V_dot_down;
f.get_U_dot_body() = U_dot_body;
f.get_V_dot_body() = V_dot_body;
f.get_W_dot_body() = W_dot_body;
f.get_A_X_cg() = A_X_cg;
f.get_A_Y_cg() = A_Y_cg;
f.get_A_Z_cg() = A_Z_cg;
f.get_A_X_pilot() = A_X_pilot;
f.get_A_Y_pilot() = A_Y_pilot;
f.get_A_Z_pilot() = A_Z_pilot;
f.get_N_X_cg() = N_X_cg;
f.get_N_Y_cg() = N_Y_cg;
f.get_N_Z_cg() = N_Z_cg;
f.get_N_X_pilot() = N_X_pilot;
f.get_N_Y_pilot() = N_Y_pilot;
f.get_N_Z_pilot() = N_Z_pilot;
f.get_P_dot_body() = P_dot_body;
f.get_Q_dot_body() = Q_dot_body;
f.get_R_dot_body() = R_dot_body;
f.get_V_north() = V_north;
f.get_V_east() = V_east;
f.get_V_down() = V_down;
f.get_V_north_rel_ground() = V_north_rel_ground;
f.get_V_east_rel_ground() = V_east_rel_ground;
f.get_V_down_rel_ground() = V_down_rel_ground;
f.get_V_north_airmass() = V_north_airmass;
f.get_V_east_airmass() = V_east_airmass;
f.get_V_down_airmass() = V_down_airmass;
f.get_V_north_rel_airmass() = V_north_rel_airmass;
f.get_V_east_rel_airmass() = V_east_rel_airmass;
f.get_V_down_rel_airmass() = V_down_rel_airmass;
f.get_U_gust() = U_gust;
f.get_V_gust() = V_gust;
f.get_W_gust() = W_gust;
f.get_U_body() = U_body;
f.get_V_body() = V_body;
f.get_W_body() = W_body;
f.get_V_rel_wind() = V_rel_wind;
f.get_V_true_kts() = V_true_kts;
f.get_V_rel_ground() = V_rel_ground;
f.get_V_inertial() = V_inertial;
f.get_V_ground_speed() = V_ground_speed;
f.get_V_equiv() = V_equiv;
f.get_V_equiv_kts() = V_equiv_kts;
f.get_V_calibrated() = V_calibrated;
f.get_V_calibrated_kts() = V_calibrated_kts;
f.get_P_body() = P_body;
f.get_Q_body() = Q_body;
f.get_R_body() = R_body;
f.get_P_local() = P_local;
f.get_Q_local() = Q_local;
f.get_R_local() = R_local;
f.get_P_total() = P_total;
f.get_Q_total() = Q_total;
f.get_R_total() = R_total;
f.get_Phi_dot() = Phi_dot;
f.get_Theta_dot() = Theta_dot;
f.get_Psi_dot() = Psi_dot;
f.get_Latitude_dot() = Latitude_dot;
f.get_Longitude_dot() = Longitude_dot;
f.get_Radius_dot() = Radius_dot;
f.get_Lat_geocentric() = Lat_geocentric;
f.get_Lon_geocentric() = Lon_geocentric;
f.get_Radius_to_vehicle() = Radius_to_vehicle;
f.get_Latitude() = Latitude;
f.get_Longitude() = Longitude;
f.get_Altitude() = Altitude;
f.get_Phi() = Phi;
f.get_Theta() = Theta;
f.get_Psi() = Psi;
f.get_T_local_to_body_11() = T_local_to_body_11;
f.get_T_local_to_body_12() = T_local_to_body_12;
f.get_T_local_to_body_13() = T_local_to_body_13;
f.get_T_local_to_body_21() = T_local_to_body_21;
f.get_T_local_to_body_22() = T_local_to_body_22;
f.get_T_local_to_body_23() = T_local_to_body_23;
f.get_T_local_to_body_31() = T_local_to_body_31;
f.get_T_local_to_body_32() = T_local_to_body_32;
f.get_T_local_to_body_33() = T_local_to_body_33;
f.get_Gravity() = Gravity;
f.get_Centrifugal_relief() = Centrifugal_relief;
f.get_Alpha() = Alpha;
f.get_Beta() = Beta;
f.get_Alpha_dot() = Alpha_dot;
f.get_Beta_dot() = Beta_dot;
f.get_Cos_alpha() = Cos_alpha;
f.get_Sin_alpha() = Sin_alpha;
f.get_Cos_beta() = Cos_beta;
f.get_Sin_beta() = Sin_beta;
f.get_Cos_phi() = Cos_phi;
f.get_Sin_phi() = Sin_phi;
f.get_Cos_theta() = Cos_theta;
f.get_Sin_theta() = Sin_theta;
f.get_Cos_psi() = Cos_psi;
f.get_Sin_psi() = Sin_psi;
f.get_Gamma_vert_rad() = Gamma_vert_rad;
f.get_Gamma_horiz_rad() = Gamma_horiz_rad;
f.get_Sigma() = Sigma;
f.get_Density() = Density;
f.get_V_sound() = V_sound;
f.get_Mach_number() = Mach_number;
f.get_Static_pressure() = Static_pressure;
f.get_Total_pressure() = Total_pressure;
f.get_Impact_pressure() = Impact_pressure;
f.get_Dynamic_pressure() = Dynamic_pressure;
f.get_Static_temperature() = Static_temperature;
f.get_Total_temperature() = Total_temperature;
f.get_Sea_level_radius() = Sea_level_radius;
f.get_Earth_position_angle() = Earth_position_angle;
f.get_Runway_altitude() = Runway_altitude;
f.get_Runway_latitude() = Runway_latitude;
f.get_Runway_longitude() = Runway_longitude;
f.get_Runway_heading() = Runway_heading;
f.get_Radius_to_rwy() = Radius_to_rwy;
f.get_D_cg_north_of_rwy() = D_cg_north_of_rwy;
f.get_D_cg_east_of_rwy() = D_cg_east_of_rwy;
f.get_D_cg_above_rwy() = D_cg_above_rwy;
f.get_X_cg_rwy() = X_cg_rwy;
f.get_Y_cg_rwy() = Y_cg_rwy;
f.get_H_cg_rwy() = H_cg_rwy;
f.get_D_pilot_north_of_rwy() = D_pilot_north_of_rwy;
f.get_D_pilot_east_of_rwy() = D_pilot_east_of_rwy;
f.get_D_pilot_above_rwy() = D_pilot_above_rwy;
f.get_X_pilot_rwy() = X_pilot_rwy;
f.get_Y_pilot_rwy() = Y_pilot_rwy;
f.get_H_pilot_rwy() = H_pilot_rwy;
*/
return ( 0 );
}
// $Log$
// Revision 1.4 1998/12/03 01:16:37 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.3 1998/10/25 14:08:43 curt
// Turned "struct fgCONTROLS" into a class, with inlined accessor functions.
//

9
FDM/LaRCsim.hxx
View file

@ -35,19 +35,22 @@
int fgLaRCsimInit(double dt);
// update position based on inputs, positions, velocities, etc.
int fgLaRCsimUpdate(fgFLIGHT *f, int multiloop);
int fgLaRCsimUpdate(fgFLIGHT& f, int multiloop);
// Convert from the fgFLIGHT struct to the LaRCsim generic_ struct
int fgFlight_2_LaRCsim (fgFLIGHT *f);
int fgFlight_2_LaRCsim (fgFLIGHT& f);
// Convert from the LaRCsim generic_ struct to the fgFLIGHT struct
int fgLaRCsim_2_Flight (fgFLIGHT *f);
int fgLaRCsim_2_Flight (fgFLIGHT& f);
#endif // _LARCSIM_HXX
// $Log$
// Revision 1.3 1998/12/03 01:16:38 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.2 1998/10/17 01:34:13 curt
// C++ ifying ...
//

40
FDM/flight.cxx
View file

@ -37,7 +37,7 @@ fgFLIGHT cur_flight_params;
/* Initialize the flight model parameters */
int fgFlightModelInit(int model, fgFLIGHT *f, double dt) {
int fgFlightModelInit(int model, fgFLIGHT& f, double dt) {
double save_alt = 0.0;
int result;
@ -47,19 +47,19 @@ int fgFlightModelInit(int model, fgFLIGHT *f, double dt) {
// fgSlewInit(dt);
} else if ( model == FG_LARCSIM ) {
/* lets try to avoid really screwing up the LaRCsim model */
if ( FG_Altitude < -9000 ) {
save_alt = FG_Altitude;
FG_Altitude = 0;
if ( f.get_Altitude() < -9000.0 ) {
save_alt = f.get_Altitude();
f.set_Altitude( 0.0 );
}
fgFlight_2_LaRCsim(f); /* translate FG to LaRCsim structure */
fgLaRCsimInit(dt);
FG_LOG( FG_FLIGHT, FG_INFO, "FG pos = " << FG_Latitude );
FG_LOG( FG_FLIGHT, FG_INFO, "FG pos = " << f.get_Latitude() );
fgLaRCsim_2_Flight(f); /* translate LaRCsim back to FG structure */
/* but lets restore our original bogus altitude when we are done */
if ( save_alt < -9000 ) {
FG_Altitude = save_alt;
if ( save_alt < -9000.0 ) {
f.set_Altitude( save_alt );
}
} else {
FG_LOG( FG_FLIGHT, FG_WARN,
@ -73,13 +73,13 @@ int fgFlightModelInit(int model, fgFLIGHT *f, double dt) {
/* Run multiloop iterations of the flight model */
int fgFlightModelUpdate(int model, fgFLIGHT *f, int multiloop) {
int fgFlightModelUpdate(int model, fgFLIGHT& f, int multiloop) {
double time_step, start_elev, end_elev;
int result;
// printf("Altitude = %.2f\n", FG_Altitude * 0.3048);
time_step = (1.0 / DEFAULT_MODEL_HZ) * multiloop;
start_elev = FG_Altitude;
start_elev = f.get_Altitude();
if ( model == FG_SLEW ) {
// fgSlewUpdate(f, multiloop);
@ -90,9 +90,10 @@ int fgFlightModelUpdate(int model, fgFLIGHT *f, int multiloop) {
"Unimplemented flight model == " << model );
}
end_elev = FG_Altitude;
end_elev = f.get_Altitude();
FG_Climb_Rate = (end_elev - start_elev) / time_step; /* feet per second */
// feet per second
f.set_Climb_Rate( (end_elev - start_elev) / time_step );
result = 1;
@ -101,30 +102,33 @@ int fgFlightModelUpdate(int model, fgFLIGHT *f, int multiloop) {
/* Set the altitude (force) */
void fgFlightModelSetAltitude(int model, fgFLIGHT *f, double alt_meters) {
void fgFlightModelSetAltitude(int model, fgFLIGHT& f, double alt_meters) {
double sea_level_radius_meters;
double lat_geoc;
// Set the FG variables first
fgGeodToGeoc( FG_Latitude, alt_meters,
fgGeodToGeoc( f.get_Latitude(), alt_meters,
&sea_level_radius_meters, &lat_geoc);
FG_Altitude = alt_meters * METER_TO_FEET;
FG_Radius_to_vehicle = FG_Altitude +
(sea_level_radius_meters * METER_TO_FEET);
f.set_Altitude( alt_meters * METER_TO_FEET );
f.set_Radius_to_vehicle( f.get_Altitude() +
(sea_level_radius_meters * METER_TO_FEET) );
/* additional work needed for some flight models */
if ( model == FG_LARCSIM ) {
ls_ForceAltitude(FG_Altitude);
ls_ForceAltitude( f.get_Altitude() );
}
}
// $Log$
// Revision 1.4 1998/12/03 01:16:40 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.3 1998/11/06 21:18:03 curt
// Converted to new logstream debugging facility. This allows release
// builds with no messages at all (and no performance impact) by using
// the -DFG_NDEBUG flag.
// the -DFG_NDEBUGNDEBUG flag.
//
// Revision 1.2 1998/10/16 23:27:40 curt
// C++-ifying.

610
FDM/flight.hxx
View file

@ -34,361 +34,484 @@
#endif
/* Define the various supported flight models (most not yet implemented) */
#define FG_SLEW 0 /* Slew (in MS terminology) */
#define FG_LARCSIM 1 /* The only "real" model that is currently
implemented */
#define FG_ACM 2
#define FG_SUPER_SONIC 3
#define FG_HELICOPTER 4
#define FG_AUTOGYRO 5
#define FG_BALLOON 6
#define FG_PARACHUTE 7
#define FG_EXTERN_GPS 8 /* Driven via a serially connected GPS */
#define FG_EXTERN_NET 9 /* Driven externally via the net */
#define FG_EXTERN_NASA 10 /* Track the space shuttle ? */
// Define the various supported flight models (most not yet implemented)
enum fgFlightModelKind {
// Slew (in MS terminology)
FG_SLEW = 0,
// The only "real" model that is currently implemented
FG_LARCSIM = 1,
FG_ACM = 2,
FG_SUPER_SONIC = 3,
FG_HELICOPTER = 4,
FG_AUTOGYRO = 5,
FG_BALLOON = 6,
FG_PARACHUTE = 7,
// Driven externally via a serial port, net, file, etc.
FG_EXTERN = 8
};
typedef double FG_VECTOR_3[3];
/* This is based heavily on LaRCsim/ls_generic.h */
typedef struct {
// This is based heavily on LaRCsim/ls_generic.h
class fgFLIGHT {
public:
/*================== Mass properties and geometry values ==================*/
double mass, i_xx, i_yy, i_zz, i_xz; /* Inertias */
#define FG_Mass f->mass
#define FG_I_xx f->i_xx
#define FG_I_yy f->i_yy
#define FG_I_zz f->i_zz
#define FG_I_xz f->i_xz
// Inertias
double mass, i_xx, i_yy, i_zz, i_xz;
inline double get_Mass() const { return mass; }
inline double get_I_xx() const { return i_xx; }
inline double get_I_yy() const { return i_yy; }
inline double get_I_zz() const { return i_zz; }
inline double get_I_xz() const { return i_xz; }
FG_VECTOR_3 d_pilot_rp_body_v; /* Pilot location rel to ref pt */
#define FG_D_pilot_rp_body_v f->d_pilot_rp_body_v
#define FG_Dx_pilot f->d_pilot_rp_body_v[0]
#define FG_Dy_pilot f->d_pilot_rp_body_v[1]
#define FG_Dz_pilot f->d_pilot_rp_body_v[2]
// Pilot location rel to ref pt
FG_VECTOR_3 d_pilot_rp_body_v;
inline double * get_D_pilot_rp_body_v() {
return d_pilot_rp_body_v;
}
inline double get_Dx_pilot() const { return d_pilot_rp_body_v[0]; }
inline double get_Dy_pilot() const { return d_pilot_rp_body_v[1]; }
inline double get_Dz_pilot() const { return d_pilot_rp_body_v[2]; }
FG_VECTOR_3 d_cg_rp_body_v; /* CG position w.r.t. ref. point */
#define FG_D_cg_rp_body_v f->d_cg_rp_body_v
#define FG_Dx_cg f->d_cg_rp_body_v[0]
#define FG_Dy_cg f->d_cg_rp_body_v[1]
#define FG_Dz_cg f->d_cg_rp_body_v[2]
// CG position w.r.t. ref. point
FG_VECTOR_3 d_cg_rp_body_v;
inline double * get_D_cg_rp_body_v() { return d_cg_rp_body_v; }
inline double get_Dx_cg() const { return d_cg_rp_body_v[0]; }
inline double get_Dy_cg() const { return d_cg_rp_body_v[1]; }
inline double get_Dz_cg() const { return d_cg_rp_body_v[2]; }
/*================================ Forces =================================*/
FG_VECTOR_3 f_body_total_v;
#define FG_F_body_total_v f->f_body_total_v
#define FG_F_X f->f_body_total_v[0]
#define FG_F_Y f->f_body_total_v[1]
#define FG_F_Z f->f_body_total_v[2]
FG_VECTOR_3 f_body_total_v;
inline double * get_F_body_total_v() { return f_body_total_v; }
inline double get_F_X() const { return f_body_total_v[0]; }
inline double get_F_Y() const { return f_body_total_v[1]; }
inline double get_F_Z() const { return f_body_total_v[2]; }
FG_VECTOR_3 f_local_total_v;
#define FG_F_local_total_v f->f_local_total_v
#define FG_F_north f->f_local_total_v[0]
#define FG_F_east f->f_local_total_v[1]
#define FG_F_down f->f_local_total_v[2]
FG_VECTOR_3 f_local_total_v;
inline double * get_F_local_total_v() { return f_local_total_v; }
inline double get_F_north() const { return f_local_total_v[0]; }
inline double get_F_east() const { return f_local_total_v[1]; }
inline double get_F_down() const { return f_local_total_v[2]; }
FG_VECTOR_3 f_aero_v;
#define FG_F_aero_v f->f_aero_v
#define FG_F_X_aero f->f_aero_v[0]
#define FG_F_Y_aero f->f_aero_v[1]
#define FG_F_Z_aero f->f_aero_v[2]
FG_VECTOR_3 f_aero_v;
inline double * get_F_aero_v() { return f_aero_v; }
inline double get_F_X_aero() const { return f_aero_v[0]; }
inline double get_F_Y_aero() const { return f_aero_v[1]; }
inline double get_F_Z_aero() const { return f_aero_v[2]; }
FG_VECTOR_3 f_engine_v;
inline double * get_F_engine_v() { return f_engine_v; }
inline double get_F_X_engine() const { return f_engine_v[0]; }
inline double get_F_Y_engine() const { return f_engine_v[1]; }
inline double get_F_Z_engine() const { return f_engine_v[2]; }
FG_VECTOR_3 f_engine_v;
#define FG_F_engine_v f->f_engine_v
#define FG_F_X_engine f->f_engine_v[0]
#define FG_F_Y_engine f->f_engine_v[1]
#define FG_F_Z_engine f->f_engine_v[2]
FG_VECTOR_3 f_gear_v;
inline double * get_F_gear_v() { return f_gear_v; }
inline double get_F_X_gear() const { return f_gear_v[0]; }
inline double get_F_Y_gear() const { return f_gear_v[1]; }
inline double get_F_Z_gear() const { return f_gear_v[2]; }
FG_VECTOR_3 f_gear_v;
#define FG_F_gear_v f->f_gear_v
#define FG_F_X_gear f->f_gear_v[0]
#define FG_F_Y_gear f->f_gear_v[1]
#define FG_F_Z_gear f->f_gear_v[2]
/*================================ Moments ================================*/
/*================================ Moments ================================*/
FG_VECTOR_3 m_total_rp_v;
#define FG_M_total_rp_v f->m_total_rp_v
#define FG_M_l_rp f->m_total_rp_v[0]
#define FG_M_m_rp f->m_total_rp_v[1]
#define FG_M_n_rp f->m_total_rp_v[2]
inline double * get_M_total_rp_v() { return m_total_rp_v; }
inline double get_M_l_rp() const { return m_total_rp_v[0]; }
inline double get_M_m_rp() const { return m_total_rp_v[1]; }
inline double get_M_n_rp() const { return m_total_rp_v[2]; }
FG_VECTOR_3 m_total_cg_v;
#define FG_M_total_cg_v f->m_total_cg_v
#define FG_M_l_cg f->m_total_cg_v[0]
#define FG_M_m_cg f->m_total_cg_v[1]
#define FG_M_n_cg f->m_total_cg_v[2]
inline double * get_M_total_cg_v() { return m_total_cg_v; }
inline double get_M_l_cg() const { return m_total_cg_v[0]; }
inline double get_M_m_cg() const { return m_total_cg_v[1]; }
inline double get_M_n_cg() const { return m_total_cg_v[2]; }
FG_VECTOR_3 m_aero_v;
#define FG_M_aero_v f->m_aero_v
#define FG_M_l_aero f->m_aero_v[0]
#define FG_M_m_aero f->m_aero_v[1]
#define FG_M_n_aero f->m_aero_v[2]
inline double * get_M_aero_v() { return m_aero_v; }
inline double get_M_l_aero() const { return m_aero_v[0]; }
inline double get_M_m_aero() const { return m_aero_v[1]; }
inline double get_M_n_aero() const { return m_aero_v[2]; }
FG_VECTOR_3 m_engine_v;
#define FG_M_engine_v f->m_engine_v
#define FG_M_l_engine f->m_engine_v[0]
#define FG_M_m_engine f->m_engine_v[1]
#define FG_M_n_engine f->m_engine_v[2]
inline double * get_M_engine_v() { return m_engine_v; }
inline double get_M_l_engine() const { return m_engine_v[0]; }
inline double get_M_m_engine() const { return m_engine_v[1]; }
inline double get_M_n_engine() const { return m_engine_v[2]; }
FG_VECTOR_3 m_gear_v;
#define FG_M_gear_v f->m_gear_v
#define FG_M_l_gear f->m_gear_v[0]
#define FG_M_m_gear f->m_gear_v[1]
#define FG_M_n_gear f->m_gear_v[2]
inline double * get_M_gear_v() { return m_gear_v; }
inline double get_M_l_gear() const { return m_gear_v[0]; }
inline double get_M_m_gear() const { return m_gear_v[1]; }
inline double get_M_n_gear() const { return m_gear_v[2]; }
/*============================== Accelerations ============================*/
/*============================== Accelerations ============================*/
FG_VECTOR_3 v_dot_local_v;
#define FG_V_dot_local_v f->v_dot_local_v
#define FG_V_dot_north f->v_dot_local_v[0]
#define FG_V_dot_east f->v_dot_local_v[1]
#define FG_V_dot_down f->v_dot_local_v[2]
inline double * get_V_dot_local_v() { return v_dot_local_v; }
inline double get_V_dot_north() const { return v_dot_local_v[0]; }
inline double get_V_dot_east() const { return v_dot_local_v[1]; }
inline double get_V_dot_down() const { return v_dot_local_v[2]; }
FG_VECTOR_3 v_dot_body_v;
#define FG_V_dot_body_v f->v_dot_body_v
#define FG_U_dot_body f->v_dot_body_v[0]
#define FG_V_dot_body f->v_dot_body_v[1]
#define FG_W_dot_body f->v_dot_body_v[2]
inline double * get_V_dot_body_v() { return v_dot_body_v; }
inline double get_U_dot_body() const { return v_dot_body_v[0]; }
inline double get_V_dot_body() const { return v_dot_body_v[1]; }
inline double get_W_dot_body() const { return v_dot_body_v[2]; }
FG_VECTOR_3 a_cg_body_v;
#define FG_A_cg_body_v f->a_cg_body_v
#define FG_A_X_cg f->a_cg_body_v[0]
#define FG_A_Y_cg f->a_cg_body_v[1]
#define FG_A_Z_cg f->a_cg_body_v[2]
inline double * get_A_cg_body_v() { return a_cg_body_v; }
inline double get_A_X_cg() const { return a_cg_body_v[0]; }
inline double get_A_Y_cg() const { return a_cg_body_v[1]; }
inline double get_A_Z_cg() const { return a_cg_body_v[2]; }
FG_VECTOR_3 a_pilot_body_v;
#define FG_A_pilot_body_v f->a_pilot_body_v
#define FG_A_X_pilot f->a_pilot_body_v[0]
#define FG_A_Y_pilot f->a_pilot_body_v[1]
#define FG_A_Z_pilot f->a_pilot_body_v[2]
inline double * get_A_pilot_body_v() { return a_pilot_body_v; }
inline double get_A_X_pilot() const { return a_pilot_body_v[0]; }
inline double get_A_Y_pilot() const { return a_pilot_body_v[1]; }
inline double get_A_Z_pilot() const { return a_pilot_body_v[2]; }
FG_VECTOR_3 n_cg_body_v;
#define FG_N_cg_body_v f->n_cg_body_v
#define FG_N_X_cg f->n_cg_body_v[0]
#define FG_N_Y_cg f->n_cg_body_v[1]
#define FG_N_Z_cg f->n_cg_body_v[2]
inline double * get_N_cg_body_v() { return n_cg_body_v; }
inline double get_N_X_cg() const { return n_cg_body_v[0]; }
inline double get_N_Y_cg() const { return n_cg_body_v[1]; }
inline double get_N_Z_cg() const { return n_cg_body_v[2]; }
FG_VECTOR_3 n_pilot_body_v;
#define FG_N_pilot_body_v f->n_pilot_body_v
#define FG_N_X_pilot f->n_pilot_body_v[0]
#define FG_N_Y_pilot f->n_pilot_body_v[1]
#define FG_N_Z_pilot f->n_pilot_body_v[2]
inline double * get_N_pilot_body_v() { return n_pilot_body_v; }
inline double get_N_X_pilot() const { return n_pilot_body_v[0]; }
inline double get_N_Y_pilot() const { return n_pilot_body_v[1]; }
inline double get_N_Z_pilot() const { return n_pilot_body_v[2]; }
FG_VECTOR_3 omega_dot_body_v;
#define FG_Omega_dot_body_v f->omega_dot_body_v
#define FG_P_dot_body f->omega_dot_body_v[0]
#define FG_Q_dot_body f->omega_dot_body_v[1]
#define FG_R_dot_body f->omega_dot_body_v[2]
inline double * get_Omega_dot_body_v() { return omega_dot_body_v; }
inline double get_P_dot_body() const { return omega_dot_body_v[0]; }
inline double get_Q_dot_body() const { return omega_dot_body_v[1]; }
inline double get_R_dot_body() const { return omega_dot_body_v[2]; }
/*============================== Velocities ===============================*/
/*============================== Velocities ===============================*/
FG_VECTOR_3 v_local_v;
#define FG_V_local_v f->v_local_v
#define FG_V_north f->v_local_v[0]
#define FG_V_east f->v_local_v[1]
#define FG_V_down f->v_local_v[2]
inline double * get_V_local_v() { return v_local_v; }
inline double get_V_north() const { return v_local_v[0]; }
inline double get_V_east() const { return v_local_v[1]; }
inline double get_V_down() const { return v_local_v[2]; }
FG_VECTOR_3 v_local_rel_ground_v; /* V rel w.r.t. earth surface */
#define FG_V_local_rel_ground_v f->v_local_rel_ground_v
#define FG_V_north_rel_ground f->v_local_rel_ground_v[0]
#define FG_V_east_rel_ground f->v_local_rel_ground_v[1]
#define FG_V_down_rel_ground f->v_local_rel_ground_v[2]
inline double * get_V_local_rel_ground_v() { return v_local_rel_ground_v; }
inline double get_V_north_rel_ground() const {
return v_local_rel_ground_v[0];
}
inline double get_V_east_rel_ground() const {
return v_local_rel_ground_v[1];
}
inline double get_V_down_rel_ground() const {
return v_local_rel_ground_v[2];
}
FG_VECTOR_3 v_local_airmass_v; /* velocity of airmass (steady winds) */
#define FG_V_local_airmass_v f->v_local_airmass_v
#define FG_V_north_airmass f->v_local_airmass_v[0]
#define FG_V_east_airmass f->v_local_airmass_v[1]
#define FG_V_down_airmass f->v_local_airmass_v[2]
inline double * get_V_local_airmass_v() { return v_local_airmass_v; }
inline double get_V_north_airmass() const { return v_local_airmass_v[0]; }
inline double get_V_east_airmass() const { return v_local_airmass_v[1]; }
inline double get_V_down_airmass() const { return v_local_airmass_v[2]; }
FG_VECTOR_3 v_local_rel_airmass_v; /* velocity of veh. relative to */
/* airmass */
#define FG_V_local_rel_airmass_v f->v_local_rel_airmass_v
#define FG_V_north_rel_airmass f->v_local_rel_airmass_v[0]
#define FG_V_east_rel_airmass f->v_local_rel_airmass_v[1]
#define FG_V_down_rel_airmass f->v_local_rel_airmass_v[2]
/* airmass */
inline double * get_V_local_rel_airmass_v() {
return v_local_rel_airmass_v;
}
inline double get_V_north_rel_airmass() const {
return v_local_rel_airmass_v[0];
}
inline double get_V_east_rel_airmass() const {
return v_local_rel_airmass_v[1];
}
inline double get_V_down_rel_airmass() const {
return v_local_rel_airmass_v[2];
}
FG_VECTOR_3 v_local_gust_v; /* linear turbulence components, L frame */
#define FG_V_local_gust_v f->v_local_gust_v
#define FG_U_gust f->v_local_gust_v[0]
#define FG_V_gust f->v_local_gust_v[1]
#define FG_W_gust f->v_local_gust_v[2]
inline double * get_V_local_gust_v() { return v_local_gust_v; }
inline double get_U_gust() const { return v_local_gust_v[0]; }
inline double get_V_gust() const { return v_local_gust_v[1]; }
inline double get_W_gust() const { return v_local_gust_v[2]; }
FG_VECTOR_3 v_wind_body_v; /* Wind-relative velocities in body axis */
#define FG_V_wind_body_v f->v_wind_body_v
#define FG_U_body f->v_wind_body_v[0]
#define FG_V_body f->v_wind_body_v[1]
#define FG_W_body f->v_wind_body_v[2]
inline double * get_V_wind_body_v() { return v_wind_body_v; }
inline double get_U_body() const { return v_wind_body_v[0]; }
inline double get_V_body() const { return v_wind_body_v[1]; }
inline double get_W_body() const { return v_wind_body_v[2]; }
double v_rel_wind, v_true_kts, v_rel_ground, v_inertial;
double v_ground_speed, v_equiv, v_equiv_kts;
double v_calibrated, v_calibrated_kts;
#define FG_V_rel_wind f->v_rel_wind
#define FG_V_true_kts f->v_true_kts
#define FG_V_rel_ground f->v_rel_ground
#define FG_V_inertial f->v_inertial
#define FG_V_ground_speed f->v_ground_speed
#define FG_V_equiv f->v_equiv
#define FG_V_equiv_kts f->v_equiv_kts
#define FG_V_calibrated f->v_calibrated
#define FG_V_calibrated_kts f->v_calibrated_kts
inline double get_V_rel_wind() const { return v_rel_wind; }
inline double get_V_true_kts() const { return v_true_kts; }
inline double get_V_rel_ground() const { return v_rel_ground; }
inline double get_V_inertial() const { return v_inertial; }
inline double get_V_ground_speed() const { return v_ground_speed; }
inline double get_V_equiv() const { return v_equiv; }
inline double get_V_equiv_kts() const { return v_equiv_kts; }
inline double get_V_calibrated() const { return v_calibrated; }
inline double get_V_calibrated_kts() const { return v_calibrated_kts; }
FG_VECTOR_3 omega_body_v; /* Angular B rates */
#define FG_Omega_body_v f->omega_body_v
#define FG_P_body f->omega_body_v[0]
#define FG_Q_body f->omega_body_v[1]
#define FG_R_body f->omega_body_v[2]
inline double * get_Omega_body_v() { return omega_body_v; }
inline double get_P_body() const { return omega_body_v[0]; }
inline double get_Q_body() const { return omega_body_v[1]; }
inline double get_R_body() const { return omega_body_v[2]; }
FG_VECTOR_3 omega_local_v; /* Angular L rates */
#define FG_Omega_local_v f->omega_local_v
#define FG_P_local f->omega_local_v[0]
#define FG_Q_local f->omega_local_v[1]
#define FG_R_local f->omega_local_v[2]
inline double * get_Omega_local_v() { return omega_local_v; }
inline double get_P_local() const { return omega_local_v[0]; }
inline double get_Q_local() const { return omega_local_v[1]; }
inline double get_R_local() const { return omega_local_v[2]; }
FG_VECTOR_3 omega_total_v; /* Diff btw B & L */
#define FG_Omega_total_v f->omega_total_v
#define FG_P_total f->omega_total_v[0]
#define FG_Q_total f->omega_total_v[1]
#define FG_R_total f->omega_total_v[2]
inline double * get_Omega_total_v() { return omega_total_v; }
inline double get_P_total() const { return omega_total_v[0]; }
inline double get_Q_total() const { return omega_total_v[1]; }
inline double get_R_total() const { return omega_total_v[2]; }
FG_VECTOR_3 euler_rates_v;
#define FG_Euler_rates_v f->euler_rates_v
#define FG_Phi_dot f->euler_rates_v[0]
#define FG_Theta_dot f->euler_rates_v[1]
#define FG_Psi_dot f->euler_rates_v[2]
inline double * get_Euler_rates_v() { return euler_rates_v; }
inline double get_Phi_dot() const { return euler_rates_v[0]; }
inline double get_Theta_dot() const { return euler_rates_v[1]; }
inline double get_Psi_dot() const { return euler_rates_v[2]; }
FG_VECTOR_3 geocentric_rates_v; /* Geocentric linear velocities */
#define FG_Geocentric_rates_v f->geocentric_rates_v
#define FG_Latitude_dot f->geocentric_rates_v[0]
#define FG_Longitude_dot f->geocentric_rates_v[1]
#define FG_Radius_dot f->geocentric_rates_v[2]
inline double * get_Geocentric_rates_v() { return geocentric_rates_v; }
inline double get_Latitude_dot() const { return geocentric_rates_v[0]; }
inline double get_Longitude_dot() const { return geocentric_rates_v[1]; }
inline double get_Radius_dot() const { return geocentric_rates_v[2]; }
/*=============================== Positions ===============================*/
/*=============================== Positions ===============================*/
FG_VECTOR_3 geocentric_position_v;
#define FG_Geocentric_position_v f->geocentric_position_v
#define FG_Lat_geocentric f->geocentric_position_v[0]
#define FG_Lon_geocentric f->geocentric_position_v[1]
#define FG_Radius_to_vehicle f->geocentric_position_v[2]
inline double * get_Geocentric_position_v() {
return geocentric_position_v;
}
inline double get_Lat_geocentric() const {
return geocentric_position_v[0];
}
inline double get_Lon_geocentric() const {
return geocentric_position_v[1];
}
inline double get_Radius_to_vehicle() const {
return geocentric_position_v[2];
}
inline void set_Radius_to_vehicle(double radius) {
geocentric_position_v[2] = radius;
}
FG_VECTOR_3 geodetic_position_v;
#define FG_Geodetic_position_v f->geodetic_position_v
#define FG_Latitude f->geodetic_position_v[0]
#define FG_Longitude f->geodetic_position_v[1]
#define FG_Altitude f->geodetic_position_v[2]
inline double * get_Geodetic_position_v() { return geodetic_position_v; }
inline double get_Latitude() const { return geodetic_position_v[0]; }
inline void set_Latitude(double lat) { geodetic_position_v[0] = lat; }
inline double get_Longitude() const { return geodetic_position_v[1]; }
inline void set_Longitude(double lon) { geodetic_position_v[0] = lon; }
inline double get_Altitude() const { return geodetic_position_v[2]; }
inline void set_Altitude(double altitude) {
geodetic_position_v[2] = altitude;
}
FG_VECTOR_3 euler_angles_v;
#define FG_Euler_angles_v f->euler_angles_v
#define FG_Phi f->euler_angles_v[0]
#define FG_Theta f->euler_angles_v[1]
#define FG_Psi f->euler_angles_v[2]
inline double * get_Euler_angles_v() { return euler_angles_v; }
inline double get_Phi() const { return euler_angles_v[0]; }
inline double get_Theta() const { return euler_angles_v[1]; }
inline double get_Psi() const { return euler_angles_v[2]; }
/*======================= Miscellaneous quantities ========================*/
/*======================= Miscellaneous quantities ========================*/
double t_local_to_body_m[3][3]; /* Transformation matrix L to B */
#define FG_T_local_to_body_m f->t_local_to_body_m
#define FG_T_local_to_body_11 f->t_local_to_body_m[0][0]
#define FG_T_local_to_body_12 f->t_local_to_body_m[0][1]
#define FG_T_local_to_body_13 f->t_local_to_body_m[0][2]
#define FG_T_local_to_body_21 f->t_local_to_body_m[1][0]
#define FG_T_local_to_body_22 f->t_local_to_body_m[1][1]
#define FG_T_local_to_body_23 f->t_local_to_body_m[1][2]
#define FG_T_local_to_body_31 f->t_local_to_body_m[2][0]
#define FG_T_local_to_body_32 f->t_local_to_body_m[2][1]
#define FG_T_local_to_body_33 f->t_local_to_body_m[2][2]
// inline double * get_T_local_to_body_m() { return t_local_to_body_m; }
inline double get_T_local_to_body_11() const {
return t_local_to_body_m[0][0];
}
inline double get_T_local_to_body_12() const {
return t_local_to_body_m[0][1];
}
inline double get_T_local_to_body_13() const {
return t_local_to_body_m[0][2];
}
inline double get_T_local_to_body_21() const {
return t_local_to_body_m[1][0];
}
inline double get_T_local_to_body_22() const {
return t_local_to_body_m[1][1];
}
inline double get_T_local_to_body_23() const {
return t_local_to_body_m[1][2];
}
inline double get_T_local_to_body_31() const {
return t_local_to_body_m[2][0];
}
inline double get_T_local_to_body_32() const {
return t_local_to_body_m[2][1];
}
inline double get_T_local_to_body_33() const {
return t_local_to_body_m[2][2];
}
double gravity; /* Local acceleration due to G */
#define FG_Gravity f->gravity
inline double get_Gravity() const { return gravity; }
double centrifugal_relief; /* load factor reduction due to speed */
#define FG_Centrifugal_relief f->centrifugal_relief
inline double get_Centrifugal_relief() const { return centrifugal_relief; }
double alpha, beta, alpha_dot, beta_dot; /* in radians */
#define FG_Alpha f->alpha
#define FG_Beta f->beta
#define FG_Alpha_dot f->alpha_dot
#define FG_Beta_dot f->beta_dot
inline double get_Alpha() const { return alpha; }
inline double get_Beta() const { return beta; }
inline double get_Alpha_dot() const { return alpha_dot; }
inline double get_Beta_dot() const { return beta_dot; }
double cos_alpha, sin_alpha, cos_beta, sin_beta;
#define FG_Cos_alpha f->cos_alpha
#define FG_Sin_alpha f->sin_alpha
#define FG_Cos_beta f->cos_beta
#define FG_Sin_beta f->sin_beta
inline double get_Cos_alpha() const { return cos_alpha; }
inline double get_Sin_alpha() const { return sin_alpha; }
inline double get_Cos_beta() const { return cos_beta; }
inline double get_Sin_beta() const { return sin_beta; }
double cos_phi, sin_phi, cos_theta, sin_theta, cos_psi, sin_psi;
#define FG_Cos_phi f->cos_phi
#define FG_Sin_phi f->sin_phi
#define FG_Cos_theta f->cos_theta
#define FG_Sin_theta f->sin_theta
#define FG_Cos_psi f->cos_psi
#define FG_Sin_psi f->sin_psi
inline double get_Cos_phi() const { return cos_phi; }
inline double get_Sin_phi() const { return sin_phi; }
inline double get_Cos_theta() const { return cos_theta; }
inline double get_Sin_theta() const { return sin_theta; }
inline double get_Cos_psi() const { return cos_psi; }
inline double get_Sin_psi() const { return sin_psi; }
double gamma_vert_rad, gamma_horiz_rad; /* Flight path angles */
#define FG_Gamma_vert_rad f->gamma_vert_rad
#define FG_Gamma_horiz_rad f->gamma_horiz_rad
inline double get_Gamma_vert_rad() const { return gamma_vert_rad; }
inline double get_Gamma_horiz_rad() const { return gamma_horiz_rad; }
double sigma, density, v_sound, mach_number;
#define FG_Sigma f->sigma
#define FG_Density f->density
#define FG_V_sound f->v_sound
#define FG_Mach_number f->mach_number
inline double get_Sigma() const { return sigma; }
inline double get_Density() const { return density; }
inline double get_V_sound() const { return v_sound; }
inline double get_Mach_number() const { return mach_number; }
double static_pressure, total_pressure, impact_pressure;
double dynamic_pressure;
#define FG_Static_pressure f->static_pressure
#define FG_Total_pressure f->total_pressure
#define FG_Impact_pressure f->impact_pressure
#define FG_Dynamic_pressure f->dynamic_pressure
inline double get_Static_pressure() const { return static_pressure; }
inline double get_Total_pressure() const { return total_pressure; }
inline double get_Impact_pressure() const { return impact_pressure; }
inline double get_Dynamic_pressure() const { return dynamic_pressure; }
double static_temperature, total_temperature;
#define FG_Static_temperature f->static_temperature
#define FG_Total_temperature f->total_temperature
inline double get_Static_temperature() const { return static_temperature; }
inline double get_Total_temperature() const { return total_temperature; }
double sea_level_radius, earth_position_angle;
#define FG_Sea_level_radius f->sea_level_radius
#define FG_Earth_position_angle f->earth_position_angle
inline double get_Sea_level_radius() const { return sea_level_radius; }
inline double get_Earth_position_angle() const {
return earth_position_angle;
}
inline void set_Earth_position_angle(double angle) {
earth_position_angle = angle;
}
double runway_altitude, runway_latitude, runway_longitude;
double runway_heading;
#define FG_Runway_altitude f->runway_altitude
#define FG_Runway_latitude f->runway_latitude
#define FG_Runway_longitude f->runway_longitude
#define FG_Runway_heading f->runway_heading
inline double get_Runway_altitude() const { return runway_altitude; }
inline void set_Runway_altitude( double alt ) { runway_altitude = alt; }
inline double get_Runway_latitude() const { return runway_latitude; }
inline double get_Runway_longitude() const { return runway_longitude; }
inline double get_Runway_heading() const { return runway_heading; }
double radius_to_rwy;
#define FG_Radius_to_rwy f->radius_to_rwy
inline double get_Radius_to_rwy() const { return radius_to_rwy; }
FG_VECTOR_3 d_cg_rwy_local_v; /* CG rel. to rwy in local coords */
#define FG_D_cg_rwy_local_v f->d_cg_rwy_local_v
#define FG_D_cg_north_of_rwy f->d_cg_rwy_local_v[0]
#define FG_D_cg_east_of_rwy f->d_cg_rwy_local_v[1]
#define FG_D_cg_above_rwy f->d_cg_rwy_local_v[2]
inline double * get_D_cg_rwy_local_v() { return d_cg_rwy_local_v; }
inline double get_D_cg_north_of_rwy() const { return d_cg_rwy_local_v[0]; }
inline double get_D_cg_east_of_rwy() const { return d_cg_rwy_local_v[1]; }
inline double get_D_cg_above_rwy() const { return d_cg_rwy_local_v[2]; }
FG_VECTOR_3 d_cg_rwy_rwy_v; /* CG relative to rwy, in rwy coordinates */
#define FG_D_cg_rwy_rwy_v f->d_cg_rwy_rwy_v
#define FG_X_cg_rwy f->d_cg_rwy_rwy_v[0]
#define FG_Y_cg_rwy f->d_cg_rwy_rwy_v[1]
#define FG_H_cg_rwy f->d_cg_rwy_rwy_v[2]
inline double * get_D_cg_rwy_rwy_v() { return d_cg_rwy_rwy_v; }
inline double get_X_cg_rwy() const { return d_cg_rwy_rwy_v[0]; }
inline double get_Y_cg_rwy() const { return d_cg_rwy_rwy_v[1]; }
inline double get_H_cg_rwy() const { return d_cg_rwy_rwy_v[2]; }
FG_VECTOR_3 d_pilot_rwy_local_v; /* pilot rel. to rwy in local coords */
#define FG_D_pilot_rwy_local_v f->d_pilot_rwy_local_v
#define FG_D_pilot_north_of_rwy f->d_pilot_rwy_local_v[0]
#define FG_D_pilot_east_of_rwy f->d_pilot_rwy_local_v[1]
#define FG_D_pilot_above_rwy f->d_pilot_rwy_local_v[2]
inline double * get_D_pilot_rwy_local_v() { return d_pilot_rwy_local_v; }
inline double get_D_pilot_north_of_rwy() const {
return d_pilot_rwy_local_v[0];
}
inline double get_D_pilot_east_of_rwy() const {
return d_pilot_rwy_local_v[1];
}
inline double get_D_pilot_above_rwy() const {
return d_pilot_rwy_local_v[2];
}
FG_VECTOR_3 d_pilot_rwy_rwy_v; /* pilot rel. to rwy, in rwy coords. */
#define FG_D_pilot_rwy_rwy_v f->d_pilot_rwy_rwy_v
#define FG_X_pilot_rwy f->d_pilot_rwy_rwy_v[0]
#define FG_Y_pilot_rwy f->d_pilot_rwy_rwy_v[1]
#define FG_H_pilot_rwy f->d_pilot_rwy_rwy_v[2]
inline double * get_D_pilot_rwy_rwy_v() { return d_pilot_rwy_rwy_v; }
inline double get_X_pilot_rwy() const { return d_pilot_rwy_rwy_v[0]; }
inline double get_Y_pilot_rwy() const { return d_pilot_rwy_rwy_v[1]; }
inline double get_H_pilot_rwy() const { return d_pilot_rwy_rwy_v[2]; }
double climb_rate; /* in feet per second */
#define FG_Climb_Rate f->climb_rate
inline double get_Climb_Rate() const { return climb_rate; }
inline void set_Climb_Rate(double rate) { climb_rate = rate; }
} fgFLIGHT, *pfgFlight;
// Additional convenience functions
// Inertias
inline void set_Inertias( double m, double xx, double yy,
double zz, double xz)
{
mass = m;
i_xx = xx;
i_yy = yy;
i_zz = zz;
i_xz = xz;
}
// Local velocities
inline void set_Local_Velocities( double v_north,
double v_east,
double v_down )
{
v_local_v[0] = v_north;
v_local_v[1] = v_east;
v_local_v[2] = v_down;
}
// Orientation
inline void set_Euler_Orientation( double phi,
double theta,
double psi )
{
euler_angles_v[0] = phi;
euler_angles_v[1] = theta;
euler_angles_v[2] = psi;
}
// Body Rates
inline void set_Body_Rates( double p_body, double q_body, double r_body )
{
omega_body_v[0] = p_body;
omega_body_v[1] = q_body;
omega_body_v[2] = r_body;
}
// Center of Gravity position w.r.t. ref. point
inline void set_CG_Position( double dx, double dy, double dz )
{
d_cg_rp_body_v[0] = dx;
d_cg_rp_body_v[1] = dy;
d_cg_rp_body_v[2] = dz;
}
};
extern fgFLIGHT cur_flight_params;
@ -397,19 +520,22 @@ extern fgFLIGHT cur_flight_params;
/* General interface to the flight model routines */
/* Initialize the flight model parameters */
int fgFlightModelInit(int model, fgFLIGHT *f, double dt);
int fgFlightModelInit(int model, fgFLIGHT& f, double dt);
/* Run multiloop iterations of the flight model */
int fgFlightModelUpdate(int model, fgFLIGHT *f, int multiloop);
int fgFlightModelUpdate(int model, fgFLIGHT& f, int multiloop);
/* Set the altitude (force) */
void fgFlightModelSetAltitude(int model, fgFLIGHT *f, double alt_meters);
void fgFlightModelSetAltitude(int model, fgFLIGHT& f, double alt_meters);
#endif /* _FLIGHT_H */
// $Log$
// Revision 1.3 1998/12/03 01:16:41 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.2 1998/10/16 23:27:41 curt
// C++-ifying.
//

15
Main/GLUTkey.cxx
View file

@ -231,13 +231,13 @@ void GLUTkey(unsigned char k, int x, int y) {
t->pause = !t->pause;
// printf position and attitude information
FG_LOG( FG_INPUT, FG_INFO,
"Lon = " << FG_Longitude * RAD_TO_DEG
<< " Lat = " << FG_Latitude * RAD_TO_DEG
<< " Altitude = " << FG_Altitude * FEET_TO_METER );
"Lon = " << f->get_Longitude() * RAD_TO_DEG
<< " Lat = " << f->get_Latitude() * RAD_TO_DEG
<< " Altitude = " << f->get_Altitude() * FEET_TO_METER );
FG_LOG( FG_INPUT, FG_INFO,
"Heading = " << FG_Psi * RAD_TO_DEG
<< " Roll = " << FG_Phi * RAD_TO_DEG
<< " Pitch = " << FG_Theta * RAD_TO_DEG );
"Heading = " << f->get_Psi() * RAD_TO_DEG
<< " Roll = " << f->get_Phi() * RAD_TO_DEG
<< " Pitch = " << f->get_Theta() * RAD_TO_DEG );
return;
case 116: // t key
t->warp_delta += 30;
@ -386,6 +386,9 @@ void GLUTspecialkey(int k, int x, int y) {
// $Log$
// Revision 1.33 1998/12/03 01:17:12 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.32 1998/11/06 21:18:06 curt
// Converted to new logstream debugging facility. This allows release
// builds with no messages at all (and no performance impact) by using

24
Main/GLUTmain.cxx
View file

@ -392,9 +392,11 @@ void fgUpdateTimeDepCalcs(int multi_loop) {
fgAPRun();
// printf("updating flight model x %d\n", multi_loop);
fgFlightModelUpdate(current_options.get_flight_model(), f, multi_loop);
fgFlightModelUpdate( current_options.get_flight_model(),
cur_flight_params, multi_loop );
} else {
fgFlightModelUpdate(current_options.get_flight_model(), f, 0);
fgFlightModelUpdate( current_options.get_flight_model(),
cur_flight_params, 0 );
}
// update the view angle
@ -425,7 +427,7 @@ void fgUpdateTimeDepCalcs(int multi_loop) {
}
}
double tmp = -(l->sun_rotation + FG_PI) - (FG_Psi - v->view_offset);
double tmp = -(l->sun_rotation + FG_PI) - (f->get_Psi() - v->view_offset);
while ( tmp < 0.0 ) {
tmp += FG_2PI;
}
@ -480,21 +482,22 @@ static void fgMainLoop( void ) {
FG_Altitude * FEET_TO_METER); */
if ( scenery.cur_elev > -9990 ) {
if ( FG_Altitude * FEET_TO_METER <
if ( f->get_Altitude() * FEET_TO_METER <
(scenery.cur_elev + alt_adjust_m - 3.0) ) {
// now set aircraft altitude above ground
printf("Current Altitude = %.2f < %.2f forcing to %.2f\n",
FG_Altitude * FEET_TO_METER,
f->get_Altitude() * FEET_TO_METER,
scenery.cur_elev + alt_adjust_m - 3.0,
scenery.cur_elev + alt_adjust_m );
fgFlightModelSetAltitude( current_options.get_flight_model(), f,
fgFlightModelSetAltitude( current_options.get_flight_model(),
cur_flight_params,
scenery.cur_elev + alt_adjust_m );
FG_LOG( FG_ALL, FG_BULK,
"<*> resetting altitude to "
<< FG_Altitude * FEET_TO_METER << " meters" );
<< f->get_Altitude() * FEET_TO_METER << " meters" );
}
FG_Runway_altitude = scenery.cur_elev * METER_TO_FEET;
f->set_Runway_altitude( scenery.cur_elev * METER_TO_FEET );
}
/* printf("Adjustment - ground = %.2f runway = %.2f alt = %.2f\n",
@ -606,7 +609,7 @@ static void fgMainLoop( void ) {
// Angle of Attack next... -x^3(e^x) is my best guess Just
// need to calculate some reasonable scaling factor and
// then clamp it on the positive aoa (neg adj) side
double aoa = FG_Gamma_vert_rad * 2.2;
double aoa = f->get_Gamma_vert_rad() * 2.2;
double tmp = 3.0;
double aoa_adj = pow(-aoa, tmp) * pow(M_E, aoa);
if (aoa_adj < -0.8) aoa_adj = -0.8;
@ -1011,6 +1014,9 @@ int main( int argc, char **argv ) {
// $Log$
// Revision 1.70 1998/12/03 01:17:14 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.69 1998/11/23 20:51:26 curt
// Fiddling with when I can get info from the opengl driver.
//

3
Main/Makefile.am
View file

@ -67,8 +67,7 @@ fgfs_LDADD = \
$(top_builddir)/Lib/PUI/libPUI.a \
$(top_builddir)/Lib/zlib/libz.a \
$(top_builddir)/Lib/Misc/libMisc.a \
$(opengl_LIBS) \
$(base_LIBS)
$(opengl_LIBS)
INCLUDES += \
-I$(top_builddir) \

88
Main/fg_init.cxx
View file

@ -96,26 +96,26 @@ int fgInitPosition( void ) {
"Failed to find " << id << " in database." );
exit(-1);
} else {
FG_Longitude = a.longitude * DEG_TO_RAD;
FG_Latitude = a.latitude * DEG_TO_RAD;
f->set_Longitude( a.longitude * DEG_TO_RAD );
f->set_Latitude( a.latitude * DEG_TO_RAD );
}
} else {
// set initial position from default or command line coordinates
FG_Longitude = current_options.get_lon() * DEG_TO_RAD;
FG_Latitude = current_options.get_lat() * DEG_TO_RAD;
f->set_Longitude( current_options.get_lon() * DEG_TO_RAD );
f->set_Latitude( current_options.get_lat() * DEG_TO_RAD );
}
FG_LOG( FG_GENERAL, FG_INFO,
"starting altitude is = " << current_options.get_altitude() );
FG_Altitude = current_options.get_altitude() * METER_TO_FEET;
FG_Runway_altitude = FG_Altitude - 3.758099;
f->set_Altitude( current_options.get_altitude() * METER_TO_FEET );
f->set_Runway_altitude( f->get_Altitude() - 3.758099 );
FG_LOG( FG_GENERAL, FG_INFO,
"Initial position is: ("
<< (FG_Longitude * RAD_TO_DEG) << ", "
<< (FG_Latitude * RAD_TO_DEG) << ", "
<< (FG_Altitude * FEET_TO_METER) << ")" );
<< (f->get_Longitude() * RAD_TO_DEG) << ", "
<< (f->get_Latitude() * RAD_TO_DEG) << ", "
<< (f->get_Altitude() * FEET_TO_METER) << ")" );
return(1);
}
@ -194,65 +194,60 @@ int fgInitSubsystems( void )
exit(-1);
}
// Calculate ground elevation at starting point (we didn't have
// abs_view_pos calculated when fgTileMgrUpdate() was called above
// calculalate a cartesian point somewhere along the line between
// the center of the earth and our view position. Doesn't have to
// be the exact elevation (this is good because we don't know it
// yet :-)
geod_pos = Point3D( FG_Longitude, FG_Latitude, 0.0);
geod_pos = Point3D( f->get_Longitude(), f->get_Latitude(), 0.0);
abs_view_pos = fgGeodToCart(geod_pos);
// Calculate ground elevation at starting point
FG_LOG( FG_GENERAL, FG_DEBUG,
"Altitude before update " << scenery.cur_elev );
"Altitude before update " << scenery.cur_elev );
scenery.cur_elev =
fgTileMgrCurElev( FG_Longitude, FG_Latitude, abs_view_pos );
fgTileMgrCurElevOLD( f->get_Longitude(),
f->get_Latitude(),
abs_view_pos );
FG_LOG( FG_GENERAL, FG_DEBUG,
"Altitude after update " << scenery.cur_elev );
FG_Runway_altitude = scenery.cur_elev * METER_TO_FEET;
f->set_Runway_altitude( scenery.cur_elev * METER_TO_FEET );
// Reset our altitude if we are below ground
if ( FG_Altitude < FG_Runway_altitude + 3.758099) {
FG_Altitude = FG_Runway_altitude + 3.758099;
if ( f->get_Altitude() < f->get_Runway_altitude() + 3.758099) {
f->set_Altitude( f->get_Runway_altitude() + 3.758099 );
}
FG_LOG( FG_GENERAL, FG_INFO,
"Updated position (after elevation adj): ("
<< (FG_Latitude * RAD_TO_DEG) << ", "
<< (FG_Longitude * RAD_TO_DEG) << ", "
<< (FG_Altitude * FEET_TO_METER) << ")" );
<< (f->get_Latitude() * RAD_TO_DEG) << ", "
<< (f->get_Longitude() * RAD_TO_DEG) << ", "
<< (f->get_Altitude() * FEET_TO_METER) << ")" );
// end of thing that I just stuck in that I should probably move
// The following section sets up the flight model EOM parameters
// and should really be read in from one or more files.
// Initial Velocity
FG_V_north = 0.0; // 7.287719E+00
FG_V_east = 0.0; // 1.521770E+03
FG_V_down = 0.0; // -1.265722E-05
f->set_Local_Velocities( 0.0, 0.0, 0.0 );
// Initial Orientation
FG_Phi = current_options.get_roll() * DEG_TO_RAD;
FG_Theta = current_options.get_pitch() * DEG_TO_RAD;
FG_Psi = current_options.get_heading() * DEG_TO_RAD;
f->set_Euler_Orientation( current_options.get_roll() * DEG_TO_RAD,
current_options.get_pitch() * DEG_TO_RAD,
current_options.get_heading() * DEG_TO_RAD );
// Initial Angular B rates
FG_P_body = 7.206685E-05;
FG_Q_body = 0.000000E+00;
FG_R_body = 9.492658E-05;
// Initial Angular Body rates
f->set_Body_Rates( 7.206685E-05, 0.000000E+00, 9.492658E-05 );
FG_Earth_position_angle = 0.000000E+00;
f->set_Earth_position_angle( 0.000000E+00 );
// Mass properties and geometry values
FG_Mass = 8.547270E+01;
FG_I_xx = 1.048000E+03;
FG_I_yy = 3.000000E+03;
FG_I_zz = 3.530000E+03;
FG_I_xz = 0.000000E+00;
f->set_Inertias( 8.547270E+01,
1.048000E+03, 3.000000E+03, 3.530000E+03, 0.000000E+00 );
// CG position w.r.t. ref. point
FG_Dx_cg = 0.000000E+00;
FG_Dy_cg = 0.000000E+00;
FG_Dz_cg = 0.000000E+00;
f->set_CG_Position( 0.0, 0.0, 0.0 );
// Initialize the event manager
global_events.Init();
@ -336,22 +331,22 @@ int fgInitSubsystems( void )
// Initialize the flight model subsystem data structures base on
// above values
fgFlightModelInit( current_options.get_flight_model(), f,
fgFlightModelInit( current_options.get_flight_model(), cur_flight_params,
1.0 / DEFAULT_MODEL_HZ );
// I'm just sticking this here for now, it should probably move
// eventually
scenery.cur_elev = FG_Runway_altitude * FEET_TO_METER;
scenery.cur_elev = f->get_Runway_altitude() * FEET_TO_METER;
if ( FG_Altitude < FG_Runway_altitude + 3.758099) {
FG_Altitude = FG_Runway_altitude + 3.758099;
if ( f->get_Altitude() < f->get_Runway_altitude() + 3.758099) {
f->set_Altitude( f->get_Runway_altitude() + 3.758099 );
}
FG_LOG( FG_GENERAL, FG_INFO,
"Updated position (after elevation adj): ("
<< (FG_Latitude * RAD_TO_DEG) << ", "
<< (FG_Longitude * RAD_TO_DEG) << ", "
<< (FG_Altitude * FEET_TO_METER) << ")" );
<< (f->get_Latitude() * RAD_TO_DEG) << ", "
<< (f->get_Longitude() * RAD_TO_DEG) << ", "
<< (f->get_Altitude() * FEET_TO_METER) << ")" );
// end of thing that I just stuck in that I should probably move
// Joystick support
@ -374,6 +369,9 @@ int fgInitSubsystems( void )
// $Log$
// Revision 1.52 1998/12/03 01:17:17 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.51 1998/11/20 01:02:37 curt
// Try to detect Mesa/Glide/Voodoo and chose the appropriate resolution.
//

27
Main/fg_serial.cxx
View file

@ -247,7 +247,7 @@ static void send_nmea_out( fgIOCHANNEL& p ) {
t->gmt->tm_hour, t->gmt->tm_min, t->gmt->tm_sec );
char lat[20];
double latd = FG_Latitude * RAD_TO_DEG;
double latd = f->get_Latitude() * RAD_TO_DEG;
if ( latd < 0.0 ) {
latd *= -1.0;
dir = 'S';
@ -259,7 +259,7 @@ static void send_nmea_out( fgIOCHANNEL& p ) {
sprintf( lat, "%02d%06.3f,%c", abs(deg), min, dir);
char lon[20];
double lond = FG_Longitude * RAD_TO_DEG;
double lond = f->get_Longitude() * RAD_TO_DEG;
if ( lond < 0.0 ) {
lond *= -1.0;
dir = 'W';
@ -271,16 +271,16 @@ static void send_nmea_out( fgIOCHANNEL& p ) {
sprintf( lon, "%03d%06.3f,%c", abs(deg), min, dir);
char speed[10];
sprintf( speed, "%05.1f", FG_V_equiv_kts );
sprintf( speed, "%05.1f", f->get_V_equiv_kts() );
char heading[10];
sprintf( heading, "%05.1f", FG_Psi * RAD_TO_DEG );
sprintf( heading, "%05.1f", f->get_Psi() * RAD_TO_DEG );
char altitude_m[10];
sprintf( altitude_m, "%02d", (int)(FG_Altitude * FEET_TO_METER) );
sprintf( altitude_m, "%02d", (int)(f->get_Altitude() * FEET_TO_METER) );
char altitude_ft[10];
sprintf( altitude_ft, "%02d", (int)FG_Altitude );
sprintf( altitude_ft, "%02d", (int)f->get_Altitude() );
char date[10];
sprintf( date, "%02d%02d%02d",
@ -346,7 +346,7 @@ static void send_garmin_out( fgIOCHANNEL& p ) {
t->gmt->tm_hour, t->gmt->tm_min, t->gmt->tm_sec );
char lat[20];
double latd = FG_Latitude * RAD_TO_DEG;
double latd = f->get_Latitude() * RAD_TO_DEG;
if ( latd < 0.0 ) {
latd *= -1.0;
dir = 'S';
@ -358,7 +358,7 @@ static void send_garmin_out( fgIOCHANNEL& p ) {
sprintf( lat, "%02d%06.3f,%c", abs(deg), min, dir);
char lon[20];
double lond = FG_Longitude * RAD_TO_DEG;
double lond = f->get_Longitude() * RAD_TO_DEG;
if ( lond < 0.0 ) {
lond *= -1.0;
dir = 'W';
@ -370,16 +370,16 @@ static void send_garmin_out( fgIOCHANNEL& p ) {
sprintf( lon, "%03d%06.3f,%c", abs(deg), min, dir);
char speed[10];
sprintf( speed, "%05.1f", FG_V_equiv_kts );
sprintf( speed, "%05.1f", f->get_V_equiv_kts() );
char heading[10];
sprintf( heading, "%05.1f", FG_Psi * RAD_TO_DEG );
sprintf( heading, "%05.1f", f->get_Psi() * RAD_TO_DEG );
char altitude_m[10];
sprintf( altitude_m, "%02d", (int)(FG_Altitude * FEET_TO_METER) );
sprintf( altitude_m, "%02d", (int)(f->get_Altitude() * FEET_TO_METER) );
char altitude_ft[10];
sprintf( altitude_ft, "%02d", (int)FG_Altitude );
sprintf( altitude_ft, "%02d", (int)f->get_Altitude() );
char date[10];
sprintf( date, "%02d%02d%02d",
@ -451,6 +451,9 @@ void fgSerialProcess() {
// $Log$
// Revision 1.6 1998/12/03 01:17:18 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.5 1998/11/30 17:43:32 curt
// Lots of tweaking to get serial output to actually work.
//

71
Main/views.cxx
View file

@ -216,7 +216,7 @@ void fgVIEW::UpdateViewParams( void ) {
// Tell GL we are about to modify the projection parameters
xglMatrixMode(GL_PROJECTION);
xglLoadIdentity();
if ( FG_Altitude * FEET_TO_METER - scenery.cur_elev > 10.0 ) {
if ( f->get_Altitude() * FEET_TO_METER - scenery.cur_elev > 10.0 ) {
gluPerspective(current_options.get_fov(), win_ratio, 10.0, 100000.0);
} else {
gluPerspective(current_options.get_fov(), win_ratio, 0.5, 100000.0);
@ -281,18 +281,18 @@ void fgVIEW::UpdateViewMath( fgFLIGHT *f ) {
// scenery.center.y, scenery.center.z);
// calculate the cartesion coords of the current lat/lon/0 elev
p = Point3D( FG_Longitude,
FG_Lat_geocentric,
FG_Sea_level_radius * FEET_TO_METER );
p = Point3D( f->get_Longitude(),
f->get_Lat_geocentric(),
f->get_Sea_level_radius() * FEET_TO_METER );
cur_zero_elev = fgPolarToCart3d(p) - scenery.center;
// calculate view position in current FG view coordinate system
// p.lon & p.lat are already defined earlier, p.radius was set to
// the sea level radius, so now we add in our altitude.
if ( FG_Altitude * FEET_TO_METER >
if ( f->get_Altitude() * FEET_TO_METER >
(scenery.cur_elev + 0.5 * METER_TO_FEET) ) {
p.setz( p.radius() + FG_Altitude * FEET_TO_METER );
p.setz( p.radius() + f->get_Altitude() * FEET_TO_METER );
} else {
p.setz( p.radius() + scenery.cur_elev + 0.5 * METER_TO_FEET );
}
@ -312,17 +312,17 @@ void fgVIEW::UpdateViewMath( fgFLIGHT *f ) {
// Question: Why is the LaRCsim matrix arranged so differently
// than the one we need???
LOCAL[0][0] = FG_T_local_to_body_33;
LOCAL[0][1] = -FG_T_local_to_body_32;
LOCAL[0][2] = -FG_T_local_to_body_31;
LOCAL[0][0] = f->get_T_local_to_body_33();
LOCAL[0][1] = -f->get_T_local_to_body_32();
LOCAL[0][2] = -f->get_T_local_to_body_31();
LOCAL[0][3] = 0.0;
LOCAL[1][0] = -FG_T_local_to_body_23;
LOCAL[1][1] = FG_T_local_to_body_22;
LOCAL[1][2] = FG_T_local_to_body_21;
LOCAL[1][0] = -f->get_T_local_to_body_23();
LOCAL[1][1] = f->get_T_local_to_body_22();
LOCAL[1][2] = f->get_T_local_to_body_21();
LOCAL[1][3] = 0.0;
LOCAL[2][0] = -FG_T_local_to_body_13;
LOCAL[2][1] = FG_T_local_to_body_12;
LOCAL[2][2] = FG_T_local_to_body_11;
LOCAL[2][0] = -f->get_T_local_to_body_13();
LOCAL[2][1] = f->get_T_local_to_body_12();
LOCAL[2][2] = f->get_T_local_to_body_11();
LOCAL[2][3] = 0.0;
LOCAL[3][0] = LOCAL[3][1] = LOCAL[3][2] = LOCAL[3][3] = 0.0;
LOCAL[3][3] = 1.0;
@ -334,13 +334,13 @@ void fgVIEW::UpdateViewMath( fgFLIGHT *f ) {
// Theta, and Psi (roll, pitch, yaw)
MAT3_SET_VEC(vec, 0.0, 0.0, 1.0);
MAT3rotate(R, vec, FG_Phi);
MAT3rotate(R, vec, f->get_Phi());
/* printf("Roll matrix\n"); */
/* MAT3print(R, stdout); */
MAT3_SET_VEC(vec, 0.0, 1.0, 0.0);
/* MAT3mult_vec(vec, vec, R); */
MAT3rotate(TMP, vec, FG_Theta);
MAT3rotate(TMP, vec, f->get_Theta());
/* printf("Pitch matrix\n"); */
/* MAT3print(TMP, stdout); */
MAT3mult(R, R, TMP);
@ -348,7 +348,7 @@ void fgVIEW::UpdateViewMath( fgFLIGHT *f ) {
MAT3_SET_VEC(vec, 1.0, 0.0, 0.0);
/* MAT3mult_vec(vec, vec, R); */
/* MAT3rotate(TMP, vec, FG_Psi - FG_PI_2); */
MAT3rotate(TMP, vec, -FG_Psi);
MAT3rotate(TMP, vec, -f->get_Psi());
/* printf("Yaw matrix\n");
MAT3print(TMP, stdout); */
MAT3mult(LOCAL, R, TMP);
@ -359,13 +359,13 @@ void fgVIEW::UpdateViewMath( fgFLIGHT *f ) {
// Derive the local UP transformation matrix based on *geodetic*
// coordinates
MAT3_SET_VEC(vec, 0.0, 0.0, 1.0);
MAT3rotate(R, vec, FG_Longitude); // R = rotate about Z axis
MAT3rotate(R, vec, f->get_Longitude()); // R = rotate about Z axis
// printf("Longitude matrix\n");
// MAT3print(R, stdout);
MAT3_SET_VEC(vec, 0.0, 1.0, 0.0);
MAT3mult_vec(vec, vec, R);
MAT3rotate(TMP, vec, -FG_Latitude); // TMP = rotate about X axis
MAT3rotate(TMP, vec, -f->get_Latitude()); // TMP = rotate about X axis
// printf("Latitude matrix\n");
// MAT3print(TMP, stdout);
@ -435,19 +435,19 @@ void fgVIEW::UpdateWorldToEye( fgFLIGHT *f ) {
if(fabs(view_offset)>FG_EPSILON){
// Roll Matrix
MAT3_SET_HVEC(vec, 0.0, 0.0, -1.0, 1.0);
MAT3rotate(R_Phi, vec, FG_Phi);
MAT3rotate(R_Phi, vec, f->get_Phi());
// printf("Roll matrix (Phi)\n");
// MAT3print(R_Phi, stdout);
// Pitch Matrix
MAT3_SET_HVEC(vec, 1.0, 0.0, 0.0, 1.0);
MAT3rotate(R_Theta, vec, FG_Theta);
MAT3rotate(R_Theta, vec, f->get_Theta());
// printf("\nPitch matrix (Theta)\n");
// MAT3print(R_Theta, stdout);
// Yaw Matrix
MAT3_SET_HVEC(vec, 0.0, -1.0, 0.0, 1.0);
MAT3rotate(R_Psi, vec, FG_Psi + FG_PI - view_offset );
MAT3rotate(R_Psi, vec, f->get_Psi() + FG_PI - view_offset );
// printf("\nYaw matrix (Psi)\n");
// MAT3print(R_Psi, stdout);
@ -458,17 +458,17 @@ void fgVIEW::UpdateWorldToEye( fgFLIGHT *f ) {
} else { // JUST USE LOCAL_TO_BODY NHV 5/25/98
// hey this is even different then LOCAL[][] above ??
AIRCRAFT[0][0] = -FG_T_local_to_body_22;
AIRCRAFT[0][1] = -FG_T_local_to_body_23;
AIRCRAFT[0][2] = FG_T_local_to_body_21;
AIRCRAFT[0][0] = -f->get_T_local_to_body_22();
AIRCRAFT[0][1] = -f->get_T_local_to_body_23();
AIRCRAFT[0][2] = f->get_T_local_to_body_21();
AIRCRAFT[0][3] = 0.0;
AIRCRAFT[1][0] = FG_T_local_to_body_32;
AIRCRAFT[1][1] = FG_T_local_to_body_33;
AIRCRAFT[1][2] = -FG_T_local_to_body_31;
AIRCRAFT[1][0] = f->get_T_local_to_body_32();
AIRCRAFT[1][1] = f->get_T_local_to_body_33();
AIRCRAFT[1][2] = -f->get_T_local_to_body_31();
AIRCRAFT[1][3] = 0.0;
AIRCRAFT[2][0] = FG_T_local_to_body_12;
AIRCRAFT[2][1] = FG_T_local_to_body_13;
AIRCRAFT[2][2] = -FG_T_local_to_body_11;
AIRCRAFT[2][0] = f->get_T_local_to_body_12();
AIRCRAFT[2][1] = f->get_T_local_to_body_13();
AIRCRAFT[2][2] = -f->get_T_local_to_body_11();
AIRCRAFT[2][3] = 0.0;
AIRCRAFT[3][0] = AIRCRAFT[3][1] = AIRCRAFT[3][2] = AIRCRAFT[3][3] = 0.0;
AIRCRAFT[3][3] = 1.0;
@ -492,14 +492,14 @@ void fgVIEW::UpdateWorldToEye( fgFLIGHT *f ) {
// Latitude
MAT3_SET_HVEC(vec, 1.0, 0.0, 0.0, 1.0);
// R_Lat = rotate about X axis
MAT3rotate(R_Lat, vec, FG_Latitude);
MAT3rotate(R_Lat, vec, f->get_Latitude());
// printf("\nLatitude matrix\n");
// MAT3print(R_Lat, stdout);
// Longitude
MAT3_SET_HVEC(vec, 0.0, 0.0, 1.0, 1.0);
// R_Lon = rotate about Z axis
MAT3rotate(R_Lon, vec, FG_Longitude - FG_PI_2 );
MAT3rotate(R_Lon, vec, f->get_Longitude() - FG_PI_2 );
// printf("\nLongitude matrix\n");
// MAT3print(R_Lon, stdout);
@ -599,6 +599,9 @@ fgVIEW::~fgVIEW( void ) {
// $Log$
// Revision 1.28 1998/12/03 01:17:20 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.27 1998/11/16 14:00:06 curt
// Added pow() macro bug work around.
// Added support for starting FGFS at various resolutions.

11
Time/fg_time.cxx
View file

@ -434,22 +434,27 @@ void fgTimeUpdate(fgFLIGHT *f, fgTIME *t) {
gst_course = sidereal_course(t, 0.00);
t->gst_diff = gst_precise - gst_course;
t->lst = sidereal_course(t, -(FG_Longitude * RAD_TO_DEG)) + t->gst_diff;
t->lst =
sidereal_course(t, -(f->get_Longitude() * RAD_TO_DEG)) + t->gst_diff;
} else {
// course + difference should drift off very slowly
t->gst = sidereal_course(t, 0.00) + t->gst_diff;
t->lst = sidereal_course(t, -(FG_Longitude * RAD_TO_DEG)) + t->gst_diff;
t->lst = sidereal_course(t, -(f->get_Longitude() * RAD_TO_DEG)) +
t->gst_diff;
}
FG_LOG( FG_EVENT, FG_DEBUG,
" Current lon=0.00 Sidereal Time = " << t->gst );
FG_LOG( FG_EVENT, FG_DEBUG,
" Current LOCAL Sidereal Time = " << t->lst << " ("
<< sidereal_precise(t->mjd, -(FG_Longitude * RAD_TO_DEG))
<< sidereal_precise(t->mjd, -(f->get_Longitude() * RAD_TO_DEG))
<< ") (diff = " << t->gst_diff << ")" );
}
// $Log$
// Revision 1.23 1998/12/03 01:18:40 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.22 1998/11/16 14:00:28 curt
// FG_LOG() message tweaks.
//

5
Time/light.cxx
View file

@ -164,7 +164,7 @@ void fgLIGHT::UpdateAdjFog( void ) {
// first determine the difference between our view angle and local
// direction to the sun
rotation = -(sun_rotation + FG_PI) - (FG_Psi - v->view_offset) ;
rotation = -(sun_rotation + FG_PI) - (f->get_Psi() - v->view_offset) ;
while ( rotation < 0 ) {
rotation += FG_2PI;
}
@ -217,6 +217,9 @@ fgLIGHT::~fgLIGHT( void ) {
// $Log$
// Revision 1.22 1998/12/03 01:18:42 curt
// Converted fgFLIGHT to a class.
//
// Revision 1.21 1998/11/23 21:49:09 curt
// Borland portability tweaks.
//