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()
// $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
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 )
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 )
fgFLIGHT *f;
f = current_aircraft.flight;
- return( FG_Phi * RAD_TO_DEG );
+ return( f->get_Phi() * RAD_TO_DEG );
}
static double get_pitch( void )
fgFLIGHT *f;
f = current_aircraft.flight;
- return( FG_Theta );
+ return( f->get_Theta() );
}
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 )
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 )
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 )
f = current_aircraft.flight;
- return( FG_Beta );
+ return( f->get_Beta() );
}
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 );
}
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;
f = current_aircraft.flight;
- a = FG_Latitude * RAD_TO_DEG;
+ a = f->get_Latitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
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 )
{
f = current_aircraft.flight;
- a = FG_Longitude * RAD_TO_DEG;
+ a = f->get_Longitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
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 )
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 )
fgFLIGHT *f;
f = current_aircraft.flight;
- return( FG_Phi );
+ return( f->get_Phi() );
}
double get_pitch( void )
fgFLIGHT *f;
f = current_aircraft.flight;
- return( FG_Theta );
+ return( f->get_Theta() );
}
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 )
// 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;
}
}
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;
}
}
f = current_aircraft.flight;
- return( FG_Beta );
+ return( f->get_Beta() );
}
double get_frame_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;
}
}
// $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.
//
// 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
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;
// 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();
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.
//
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 ...
//
/* 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;
// 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,
/* 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);
"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;
/* 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.
#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
-
- 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]
-
- 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]
+ // 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; }
+
+ // 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]; }
+
+ // 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_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_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_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;
-#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 ================================*/
+ 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;
+ 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;
+ 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_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]; }
+
+ /*================================ 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
-
-} fgFLIGHT, *pfgFlight;
+ inline double get_Climb_Rate() const { return climb_rate; }
+ inline void set_Climb_Rate(double rate) { climb_rate = rate; }
+
+ // 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;
/* 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.
//
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;
// $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
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
}
}
- 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;
}
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",
// 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;
// $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.
//
$(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) \
"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);
}
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();
// 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
// $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.
//
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';
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';
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",
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';
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';
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",
// $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.
//
// 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);
// 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 );
}
// 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;
// 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);
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);
// 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);
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);
} 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;
// 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);
// $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.
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.
//
// 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;
}
// $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.
//
projects / flightgear.git / commitdiff