_set_Altitude_AGL( Altitude - Runway_altitude );
// Miscellaneous quantities
- _set_T_Local_to_Body(T_local_to_body_m);
// set_Gravity( Gravity );
// set_Centrifugal_relief( Centrifugal_relief );
// set_Cos_beta( Cos_beta );
// set_Sin_beta( Sin_beta );
- _set_Cos_phi( Cos_phi );
+ // _set_Cos_phi( Cos_phi );
// set_Sin_phi( Sin_phi );
- _set_Cos_theta( Cos_theta );
+ // _set_Cos_theta( Cos_theta );
// set_Sin_theta( Sin_theta );
// set_Cos_psi( Cos_psi );
// set_Sin_psi( Sin_psi );
// D_pilot_above_rwy );
// set_Pilot_Rwy_Rwy( X_pilot_rwy, Y_pilot_rwy, H_pilot_rwy );
- _set_sin_lat_geocentric(Lat_geocentric);
- _set_cos_lat_geocentric(Lat_geocentric);
- _set_sin_cos_longitude(Longitude);
- _set_sin_cos_latitude(Latitude);
-
// printf("sin_lat_geo %f cos_lat_geo %f\n", sin_Lat_geoc, cos_Lat_geoc);
// printf("sin_lat %f cos_lat %f\n",
// get_sin_latitude(), get_cos_latitude());
_set_Geocentric_Rates( Latitude_dot, Longitude_dot, Radius_dot );
_set_Earth_position_angle( Earth_position_angle );
- _set_sin_lat_geocentric(Lat_geocentric);
- _set_cos_lat_geocentric(Lat_geocentric);
- _set_sin_cos_longitude(Longitude);
- _set_sin_cos_latitude(Latitude);
// Velocities and accelerations for the pitch ladder and velocity vector
_set_Accels_Local( U_dot_local, V_dot_local, W_dot_local );
# include "config.h"
#endif
-#include <stdio.h>
-
-#include <plib/sg.h>
+#include "flight.hxx"
#include <simgear/constants.h>
#include <simgear/debug/logstream.hxx>
-#include <simgear/math/sg_geodesy.hxx>
-#include <simgear/scene/model/placement.hxx>
+#include <simgear/math/SGMath.hxx>
#include <simgear/scene/material/mat.hxx>
#include <simgear/timing/timestamp.hxx>
#include <Main/fg_props.hxx>
#include <FDM/groundcache.hxx>
-#include "flight.hxx"
+static inline void assign(double* ptr, const SGVec3d& vec)
+{
+ ptr[0] = vec[0];
+ ptr[1] = vec[1];
+ ptr[2] = vec[2];
+}
// base_fdm_state is the internal state that is updated in integer
// multiples of "dt". This leads to "jitter" with respect to the real
FGInterface *cur_fdm_state = 0;
FGInterface base_fdm_state;
-inline void init_vec(FG_VECTOR_3 vec) {
- vec[0] = 0.0; vec[1] = 0.0; vec[2] = 0.0;
-}
-
// Constructor
FGInterface::FGInterface()
: remainder(0)
inited = false;
bound = false;
- init_vec( d_pilot_rp_body_v );
- init_vec( d_cg_rp_body_v );
- init_vec( f_body_total_v );
- init_vec( f_local_total_v );
- init_vec( f_aero_v );
- init_vec( f_engine_v );
- init_vec( f_gear_v );
- init_vec( m_total_rp_v );
- init_vec( m_total_cg_v );
- init_vec( m_aero_v );
- init_vec( m_engine_v );
- init_vec( m_gear_v );
- init_vec( v_dot_local_v );
- init_vec( v_dot_body_v );
- init_vec( a_cg_body_v );
- init_vec( a_pilot_body_v );
- init_vec( n_cg_body_v );
- init_vec( n_pilot_body_v );
- init_vec( omega_dot_body_v );
- init_vec( v_local_v );
- init_vec( v_local_rel_ground_v );
- init_vec( v_local_airmass_v );
- init_vec( v_local_rel_airmass_v );
- init_vec( v_local_gust_v );
- init_vec( v_wind_body_v );
- init_vec( omega_body_v );
- init_vec( omega_local_v );
- init_vec( omega_total_v );
- init_vec( euler_rates_v );
- init_vec( geocentric_rates_v );
- init_vec( geocentric_position_v );
- init_vec( geodetic_position_v );
- init_vec( euler_angles_v );
- init_vec( d_cg_rwy_local_v );
- init_vec( d_cg_rwy_rwy_v );
- init_vec( d_pilot_rwy_local_v );
- init_vec( d_pilot_rwy_rwy_v );
- init_vec( t_local_to_body_m[0] );
- init_vec( t_local_to_body_m[1] );
- init_vec( t_local_to_body_m[2] );
-
+ d_cg_rp_body_v = SGVec3d::zeros();
+ v_dot_local_v = SGVec3d::zeros();
+ v_dot_body_v = SGVec3d::zeros();
+ a_cg_body_v = SGVec3d::zeros();
+ a_pilot_body_v = SGVec3d::zeros();
+ n_cg_body_v = SGVec3d::zeros();
+ v_local_v = SGVec3d::zeros();
+ v_local_rel_ground_v = SGVec3d::zeros();
+ v_local_airmass_v = SGVec3d::zeros();
+ v_wind_body_v = SGVec3d::zeros();
+ omega_body_v = SGVec3d::zeros();
+ euler_rates_v = SGVec3d::zeros();
+ geocentric_rates_v = SGVec3d::zeros();
+ geodetic_position_v = SGGeod::fromRadM(0, 0, 0);
+ cartesian_position_v = SGVec3d::fromGeod(geodetic_position_v);
+ geocentric_position_v = SGGeoc::fromCart(cartesian_position_v);
+ euler_angles_v = SGVec3d::zeros();
+
mass=i_xx=i_yy=i_zz=i_xz=0;
nlf=0;
- v_rel_wind=v_true_kts=v_rel_ground=v_inertial=0;
- v_ground_speed=v_equiv=v_equiv_kts=0;
- v_calibrated=v_calibrated_kts=0;
- gravity=0;
- centrifugal_relief=0;
- alpha=beta=alpha_dot=beta_dot=0;
- cos_alpha=sin_alpha=cos_beta=sin_beta=0;
- cos_phi=sin_phi=cos_theta=sin_theta=cos_psi=sin_psi=0;
- gamma_vert_rad=gamma_horiz_rad=0;
- sigma=density=v_sound=mach_number=0;
- static_pressure=total_pressure=impact_pressure=0;
+ v_rel_wind=v_true_kts=0;
+ v_ground_speed=v_equiv_kts=0;
+ v_calibrated_kts=0;
+ alpha=beta=0;
+ gamma_vert_rad=0;
+ density=mach_number=0;
+ static_pressure=total_pressure=0;
dynamic_pressure=0;
static_temperature=total_temperature=0;
sea_level_radius=earth_position_angle=0;
- runway_altitude=runway_latitude=runway_longitude=0;
- runway_heading=0;
- radius_to_rwy=0;
+ runway_altitude=0;
climb_rate=0;
- sin_lat_geocentric=cos_lat_geocentric=0;
- sin_latitude=cos_latitude=0;
- sin_longitude=cos_longitude=0;
altitude_agl=0;
}
SG_LOG( SG_FLIGHT, SG_INFO, " lat = "
<< fgGetDouble("/sim/presets/latitude-deg")
<< " alt = " << get_Altitude() );
- double sea_level_radius_meters;
- double lat_geoc;
- sgGeodToGeoc( fgGetDouble("/sim/presets/latitude-deg")
- * SGD_DEGREES_TO_RADIANS,
- get_Altitude() * SG_FEET_TO_METER,
- &sea_level_radius_meters, &lat_geoc );
- _set_Sea_level_radius( sea_level_radius_meters * SG_METER_TO_FEET );
+ double slr = SGGeodesy::SGGeodToSeaLevelRadius(geodetic_position_v);
+ _set_Sea_level_radius( slr * SG_METER_TO_FEET );
// Set initial velocities
SG_LOG( SG_FLIGHT, SG_INFO, "...initializing velocities..." );
}
-void FGInterface::_updateGeodeticPosition( double lat, double lon, double alt )
+void FGInterface::_updatePositionM(const SGVec3d& cartPos)
{
- double lat_geoc, sl_radius;
-
- // cout << "starting sea level rad = " << get_Sea_level_radius() << endl;
-
- sgGeodToGeoc( lat, alt * SG_FEET_TO_METER, &sl_radius, &lat_geoc );
-
- SG_LOG( SG_FLIGHT, SG_DEBUG, "lon = " << lon
- << " lat_geod = " << lat
- << " lat_geoc = " << lat_geoc
- << " alt = " << alt
- << " sl_radius = " << sl_radius * SG_METER_TO_FEET
- << " Equator = " << SG_EQUATORIAL_RADIUS_FT );
-
- _set_Geocentric_Position( lat_geoc, lon,
- sl_radius * SG_METER_TO_FEET + alt );
-
- _set_Geodetic_Position( lat, lon, alt );
-
- _set_Sea_level_radius( sl_radius * SG_METER_TO_FEET );
+ cartesian_position_v = cartPos;
+ geodetic_position_v = SGGeod::fromCart(cartesian_position_v);
+ geocentric_position_v = SGGeoc::fromCart(cartesian_position_v);
+ _set_Sea_level_radius( SGGeodesy::SGGeodToSeaLevelRadius(geodetic_position_v)*SG_METER_TO_FEET );
_update_ground_elev_at_pos();
-
- _set_sin_lat_geocentric( lat_geoc );
- _set_cos_lat_geocentric( lat_geoc );
-
- _set_sin_cos_longitude( lon );
-
- _set_sin_cos_latitude( lat );
}
-void FGInterface::_updateGeocentricPosition( double lat_geoc, double lon,
- double alt )
+void FGInterface::_updatePosition(const SGGeod& geod)
{
- double lat_geod, tmp_alt, sl_radius1, sl_radius2, tmp_lat_geoc;
-
- // cout << "starting sea level rad = " << get_Sea_level_radius() << endl;
+ geodetic_position_v = geod;
+ cartesian_position_v = SGVec3d::fromGeod(geodetic_position_v);
+ geocentric_position_v = SGGeoc::fromCart(cartesian_position_v);
- sgGeocToGeod( lat_geoc, ( get_Sea_level_radius() + alt ) * SG_FEET_TO_METER,
- &lat_geod, &tmp_alt, &sl_radius1 );
- sgGeodToGeoc( lat_geod, alt * SG_FEET_TO_METER, &sl_radius2, &tmp_lat_geoc );
+ _set_Sea_level_radius( SGGeodesy::SGGeodToSeaLevelRadius(geodetic_position_v)*SG_METER_TO_FEET );
+ _update_ground_elev_at_pos();
+}
- SG_LOG( SG_FLIGHT, SG_DEBUG, "lon = " << lon
- << " lat_geod = " << lat_geod
- << " lat_geoc = " << lat_geoc
- << " alt = " << alt
- << " tmp_alt = " << tmp_alt * SG_METER_TO_FEET
- << " sl_radius1 = " << sl_radius1 * SG_METER_TO_FEET
- << " sl_radius2 = " << sl_radius2 * SG_METER_TO_FEET
- << " Equator = " << SG_EQUATORIAL_RADIUS_FT );
- _set_Geocentric_Position( lat_geoc, lon,
- sl_radius2 * SG_METER_TO_FEET + alt );
-
- _set_Geodetic_Position( lat_geod, lon, alt );
+void FGInterface::_updatePosition(const SGGeoc& geoc)
+{
+ geocentric_position_v = geoc;
+ cartesian_position_v = SGVec3d::fromGeoc(geocentric_position_v);
+ geodetic_position_v = SGGeod::fromCart(cartesian_position_v);
- _set_Sea_level_radius( sl_radius2 * SG_METER_TO_FEET );
+ _set_Sea_level_radius( SGGeodesy::SGGeodToSeaLevelRadius(geodetic_position_v)*SG_METER_TO_FEET );
_update_ground_elev_at_pos();
+}
+
- _set_sin_lat_geocentric( lat_geoc );
- _set_cos_lat_geocentric( lat_geoc );
+void FGInterface::_updateGeodeticPosition( double lat, double lon, double alt )
+{
+ _updatePosition(SGGeod::fromRadFt(lon, lat, alt));
+}
- _set_sin_cos_longitude( lon );
- _set_sin_cos_latitude( lat_geod );
+void FGInterface::_updateGeocentricPosition( double lat, double lon,
+ double alt )
+{
+ _updatePosition(SGGeoc::fromRadFt(lon, lat, get_Sea_level_radius() + alt));
}
void FGInterface::_update_ground_elev_at_pos( void ) {
- double lat = get_Latitude();
- double lon = get_Longitude();
- double alt_m = get_Altitude()*SG_FEET_TO_METER;
- double groundlevel_m = get_groundlevel_m(lat, lon, alt_m);
+ double groundlevel_m = get_groundlevel_m(geodetic_position_v);
_set_Runway_altitude( groundlevel_m * SG_METER_TO_FEET );
}
-// Extrapolate fdm based on time_offset (in usec)
-void FGInterface::extrapolate( int time_offset ) {
- double dt = time_offset / 1000000.0;
-
- // -dw- metrowerks complains about ambiguous access, not critical
- // to keep this ;)
-#ifndef __MWERKS__
- SG_LOG(SG_FLIGHT, SG_INFO, "extrapolating FDM by dt = " << dt);
-#endif
-
- double lat = geodetic_position_v[0] + geocentric_rates_v[0] * dt;
- double lat_geoc = geocentric_position_v[0] + geocentric_rates_v[0] * dt;
-
- double lon = geodetic_position_v[1] + geocentric_rates_v[1] * dt;
- double lon_geoc = geocentric_position_v[1] + geocentric_rates_v[1] * dt;
-
- double alt = geodetic_position_v[2] + geocentric_rates_v[2] * dt;
- double radius = geocentric_position_v[2] + geocentric_rates_v[2] * dt;
-
- geodetic_position_v[0] = lat;
- geocentric_position_v[0] = lat_geoc;
-
- geodetic_position_v[1] = lon;
- geocentric_position_v[1] = lon_geoc;
-
- geodetic_position_v[2] = alt;
- geocentric_position_v[2] = radius;
-}
-
// Positions
void FGInterface::set_Latitude(double lat) {
- geodetic_position_v[0] = lat;
+ geodetic_position_v.setLatitudeRad(lat);
}
void FGInterface::set_Longitude(double lon) {
- geodetic_position_v[1] = lon;
+ geodetic_position_v.setLongitudeRad(lon);
}
void FGInterface::set_Altitude(double alt) {
- geodetic_position_v[2] = alt;
+ geodetic_position_v.setElevationFt(alt);
}
void FGInterface::set_AltitudeAGL(double altagl) {
void FGInterface::_busdump(void) {
- SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rp_body_v[3]: " << d_pilot_rp_body_v[0] << ", " << d_pilot_rp_body_v[1] << ", " << d_pilot_rp_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rp_body_v[3]: " << d_cg_rp_body_v[0] << ", " << d_cg_rp_body_v[1] << ", " << d_cg_rp_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"f_body_total_v[3]: " << f_body_total_v[0] << ", " << f_body_total_v[1] << ", " << f_body_total_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"f_local_total_v[3]: " << f_local_total_v[0] << ", " << f_local_total_v[1] << ", " << f_local_total_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"f_aero_v[3]: " << f_aero_v[0] << ", " << f_aero_v[1] << ", " << f_aero_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"f_engine_v[3]: " << f_engine_v[0] << ", " << f_engine_v[1] << ", " << f_engine_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"f_gear_v[3]: " << f_gear_v[0] << ", " << f_gear_v[1] << ", " << f_gear_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"m_total_rp_v[3]: " << m_total_rp_v[0] << ", " << m_total_rp_v[1] << ", " << m_total_rp_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"m_total_cg_v[3]: " << m_total_cg_v[0] << ", " << m_total_cg_v[1] << ", " << m_total_cg_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"m_aero_v[3]: " << m_aero_v[0] << ", " << m_aero_v[1] << ", " << m_aero_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"m_engine_v[3]: " << m_engine_v[0] << ", " << m_engine_v[1] << ", " << m_engine_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"m_gear_v[3]: " << m_gear_v[0] << ", " << m_gear_v[1] << ", " << m_gear_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_local_v[3]: " << v_dot_local_v[0] << ", " << v_dot_local_v[1] << ", " << v_dot_local_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_body_v[3]: " << v_dot_body_v[0] << ", " << v_dot_body_v[1] << ", " << v_dot_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"a_cg_body_v[3]: " << a_cg_body_v[0] << ", " << a_cg_body_v[1] << ", " << a_cg_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"a_pilot_body_v[3]: " << a_pilot_body_v[0] << ", " << a_pilot_body_v[1] << ", " << a_pilot_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"n_cg_body_v[3]: " << n_cg_body_v[0] << ", " << n_cg_body_v[1] << ", " << n_cg_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"n_pilot_body_v[3]: " << n_pilot_body_v[0] << ", " << n_pilot_body_v[1] << ", " << n_pilot_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"omega_dot_body_v[3]: " << omega_dot_body_v[0] << ", " << omega_dot_body_v[1] << ", " << omega_dot_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_local_v[3]: " << v_local_v[0] << ", " << v_local_v[1] << ", " << v_local_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_local_rel_ground_v[3]: " << v_local_rel_ground_v[0] << ", " << v_local_rel_ground_v[1] << ", " << v_local_rel_ground_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_local_airmass_v[3]: " << v_local_airmass_v[0] << ", " << v_local_airmass_v[1] << ", " << v_local_airmass_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_local_rel_airmass_v[3]: " << v_local_rel_airmass_v[0] << ", " << v_local_rel_airmass_v[1] << ", " << v_local_rel_airmass_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_local_gust_v[3]: " << v_local_gust_v[0] << ", " << v_local_gust_v[1] << ", " << v_local_gust_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"v_wind_body_v[3]: " << v_wind_body_v[0] << ", " << v_wind_body_v[1] << ", " << v_wind_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"omega_body_v[3]: " << omega_body_v[0] << ", " << omega_body_v[1] << ", " << omega_body_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"omega_local_v[3]: " << omega_local_v[0] << ", " << omega_local_v[1] << ", " << omega_local_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"omega_total_v[3]: " << omega_total_v[0] << ", " << omega_total_v[1] << ", " << omega_total_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"euler_rates_v[3]: " << euler_rates_v[0] << ", " << euler_rates_v[1] << ", " << euler_rates_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_rates_v[3]: " << geocentric_rates_v[0] << ", " << geocentric_rates_v[1] << ", " << geocentric_rates_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_position_v[3]: " << geocentric_position_v[0] << ", " << geocentric_position_v[1] << ", " << geocentric_position_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"geodetic_position_v[3]: " << geodetic_position_v[0] << ", " << geodetic_position_v[1] << ", " << geodetic_position_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"euler_angles_v[3]: " << euler_angles_v[0] << ", " << euler_angles_v[1] << ", " << euler_angles_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rwy_local_v[3]: " << d_cg_rwy_local_v[0] << ", " << d_cg_rwy_local_v[1] << ", " << d_cg_rwy_local_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rwy_rwy_v[3]: " << d_cg_rwy_rwy_v[0] << ", " << d_cg_rwy_rwy_v[1] << ", " << d_cg_rwy_rwy_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rwy_local_v[3]: " << d_pilot_rwy_local_v[0] << ", " << d_pilot_rwy_local_v[1] << ", " << d_pilot_rwy_local_v[2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"d_pilot_rwy_rwy_v[3]: " << d_pilot_rwy_rwy_v[0] << ", " << d_pilot_rwy_rwy_v[1] << ", " << d_pilot_rwy_rwy_v[2]);
-
- SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[0][3]: " << t_local_to_body_m[0][0] << ", " << t_local_to_body_m[0][1] << ", " << t_local_to_body_m[0][2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[1][3]: " << t_local_to_body_m[1][0] << ", " << t_local_to_body_m[1][1] << ", " << t_local_to_body_m[1][2]);
- SG_LOG(SG_FLIGHT,SG_INFO,"t_local_to_body_m[2][3]: " << t_local_to_body_m[2][0] << ", " << t_local_to_body_m[2][1] << ", " << t_local_to_body_m[2][2]);
+ SG_LOG(SG_FLIGHT,SG_INFO,"d_cg_rp_body_v: " << d_cg_rp_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_local_v: " << v_dot_local_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_dot_body_v: " << v_dot_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"a_cg_body_v: " << a_cg_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"a_pilot_body_v: " << a_pilot_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"n_cg_body_v: " << n_cg_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_v: " << v_local_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_rel_ground_v: " << v_local_rel_ground_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_local_airmass_v: " << v_local_airmass_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"v_wind_body_v: " << v_wind_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"omega_body_v: " << omega_body_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"euler_rates_v: " << euler_rates_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_rates_v: " << geocentric_rates_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geocentric_position_v: " << geocentric_position_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"geodetic_position_v: " << geodetic_position_v);
+ SG_LOG(SG_FLIGHT,SG_INFO,"euler_angles_v: " << euler_angles_v);
SG_LOG(SG_FLIGHT,SG_INFO,"mass: " << mass );
SG_LOG(SG_FLIGHT,SG_INFO,"i_xx: " << i_xx );
SG_LOG(SG_FLIGHT,SG_INFO,"nlf: " << nlf );
SG_LOG(SG_FLIGHT,SG_INFO,"v_rel_wind: " << v_rel_wind );
SG_LOG(SG_FLIGHT,SG_INFO,"v_true_kts: " << v_true_kts );
- SG_LOG(SG_FLIGHT,SG_INFO,"v_rel_ground: " << v_rel_ground );
- SG_LOG(SG_FLIGHT,SG_INFO,"v_inertial: " << v_inertial );
SG_LOG(SG_FLIGHT,SG_INFO,"v_ground_speed: " << v_ground_speed );
- SG_LOG(SG_FLIGHT,SG_INFO,"v_equiv: " << v_equiv );
SG_LOG(SG_FLIGHT,SG_INFO,"v_equiv_kts: " << v_equiv_kts );
- SG_LOG(SG_FLIGHT,SG_INFO,"v_calibrated: " << v_calibrated );
SG_LOG(SG_FLIGHT,SG_INFO,"v_calibrated_kts: " << v_calibrated_kts );
- SG_LOG(SG_FLIGHT,SG_INFO,"gravity: " << gravity );
- SG_LOG(SG_FLIGHT,SG_INFO,"centrifugal_relief: " << centrifugal_relief );
SG_LOG(SG_FLIGHT,SG_INFO,"alpha: " << alpha );
SG_LOG(SG_FLIGHT,SG_INFO,"beta: " << beta );
- SG_LOG(SG_FLIGHT,SG_INFO,"alpha_dot: " << alpha_dot );
- SG_LOG(SG_FLIGHT,SG_INFO,"beta_dot: " << beta_dot );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_alpha: " << cos_alpha );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_alpha: " << sin_alpha );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_beta: " << cos_beta );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_beta: " << sin_beta );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_phi: " << cos_phi );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_phi: " << sin_phi );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_theta: " << cos_theta );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_theta: " << sin_theta );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_psi: " << cos_psi );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_psi: " << sin_psi );
SG_LOG(SG_FLIGHT,SG_INFO,"gamma_vert_rad: " << gamma_vert_rad );
- SG_LOG(SG_FLIGHT,SG_INFO,"gamma_horiz_rad: " << gamma_horiz_rad );
- SG_LOG(SG_FLIGHT,SG_INFO,"sigma: " << sigma );
SG_LOG(SG_FLIGHT,SG_INFO,"density: " << density );
- SG_LOG(SG_FLIGHT,SG_INFO,"v_sound: " << v_sound );
SG_LOG(SG_FLIGHT,SG_INFO,"mach_number: " << mach_number );
SG_LOG(SG_FLIGHT,SG_INFO,"static_pressure: " << static_pressure );
SG_LOG(SG_FLIGHT,SG_INFO,"total_pressure: " << total_pressure );
- SG_LOG(SG_FLIGHT,SG_INFO,"impact_pressure: " << impact_pressure );
SG_LOG(SG_FLIGHT,SG_INFO,"dynamic_pressure: " << dynamic_pressure );
SG_LOG(SG_FLIGHT,SG_INFO,"static_temperature: " << static_temperature );
SG_LOG(SG_FLIGHT,SG_INFO,"total_temperature: " << total_temperature );
SG_LOG(SG_FLIGHT,SG_INFO,"sea_level_radius: " << sea_level_radius );
SG_LOG(SG_FLIGHT,SG_INFO,"earth_position_angle: " << earth_position_angle );
SG_LOG(SG_FLIGHT,SG_INFO,"runway_altitude: " << runway_altitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"runway_latitude: " << runway_latitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"runway_longitude: " << runway_longitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"runway_heading: " << runway_heading );
- SG_LOG(SG_FLIGHT,SG_INFO,"radius_to_rwy: " << radius_to_rwy );
SG_LOG(SG_FLIGHT,SG_INFO,"climb_rate: " << climb_rate );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_lat_geocentric: " << sin_lat_geocentric );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_lat_geocentric: " << cos_lat_geocentric );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_longitude: " << sin_longitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_longitude: " << cos_longitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"sin_latitude: " << sin_latitude );
- SG_LOG(SG_FLIGHT,SG_INFO,"cos_latitude: " << cos_latitude );
SG_LOG(SG_FLIGHT,SG_INFO,"altitude_agl: " << altitude_agl );
}
{
SGVec3d _pt;
bool valid = ground_cache.is_valid(*ref_time, _pt, *rad);
- sgdCopyVec3(pt, _pt.data());
+ assign(pt, _pt);
return valid;
}
// Convert units and do the real work.
SGVec3d _pt;
bool found_ground = ground_cache.is_valid(*ref_time, _pt, *rad);
- sgdScaleVec3(pt, _pt.data(), SG_METER_TO_FEET);
+ assign(pt, SG_METER_TO_FEET*_pt);
*rad *= SG_METER_TO_FEET;
return found_ground;
}
SGVec3d _end[2], _vel[2];
double dist = ground_cache.get_cat(t, SGVec3d(pt), _end, _vel);
for (int k=0; k<2; ++k) {
- sgdCopyVec3( end[k], _end[k].data() );
- sgdCopyVec3( vel[k], _vel[k].data() );
+ assign( end[k], _end[k] );
+ assign( vel[k], _vel[k] );
}
return dist;
}
SGVec3d _end[2], _vel[2];
double dist = ground_cache.get_cat(t, pt_m, _end, _vel);
for (int k=0; k<2; ++k) {
- sgdScaleVec3( end[k], _end[k].data(), SG_METER_TO_FEET );
- sgdScaleVec3( vel[k], _vel[k].data(), SG_METER_TO_FEET );
+ assign( end[k], SG_METER_TO_FEET*_end[k] );
+ assign( vel[k], SG_METER_TO_FEET*_vel[k] );
}
return dist*SG_METER_TO_FEET;
}
SGVec3d _contact, _normal, _vel;
bool ret = ground_cache.get_agl(t, SGVec3d(pt), 2.0, _contact, _normal,
_vel, type, &material, agl);
- sgdCopyVec3(contact, _contact.data());
- sgdCopyVec3(normal, _normal.data());
- sgdCopyVec3(vel, _vel.data());
+ assign(contact, _contact);
+ assign(normal, _normal);
+ assign(vel, _vel);
if (material) {
*loadCapacity = material->get_load_resistance();
*frictionFactor = material->get_friction_factor();
SGVec3d _contact, _normal, _vel;
bool ret = ground_cache.get_agl(t, SGVec3d(pt), 2.0, _contact, _normal,
_vel, type, material, agl);
- sgdCopyVec3(contact, _contact.data());
- sgdCopyVec3(normal, _normal.data());
- sgdCopyVec3(vel, _vel.data());
+ assign(contact, _contact);
+ assign(normal, _normal);
+ assign(vel, _vel);
return ret;
}
bool ret = ground_cache.get_agl(t, pt_m, 2.0, _contact, _normal, _vel,
type, &material, agl);
// Convert units back ...
- sgdScaleVec3( contact, _contact.data(), SG_METER_TO_FEET );
- sgdScaleVec3( vel, _vel.data(), SG_METER_TO_FEET );
- sgdCopyVec3( normal, _normal.data() );
+ assign( contact, SG_METER_TO_FEET*_contact );
+ assign( vel, SG_METER_TO_FEET*_vel );
+ assign( normal, _normal );
*agl *= SG_METER_TO_FEET;
// return material properties if available
SGVec3d _contact, _normal, _vel;
bool found = ground_cache.get_agl(t, SGVec3d(pt), max_altoff, _contact,
_normal, _vel, type, material, agl);
- sgdCopyVec3(contact, _contact.data());
- sgdCopyVec3(normal, _normal.data());
- sgdCopyVec3(vel, _vel.data());
+ assign(contact, _contact);
+ assign(normal, _normal);
+ assign(vel, _vel);
return found;
}
_contact, _normal, _vel,
type, material, agl);
// Convert units back ...
- sgdScaleVec3( contact, _contact.data(), SG_METER_TO_FEET );
- sgdScaleVec3( vel, _vel.data(), SG_METER_TO_FEET );
- sgdCopyVec3( normal, _normal.data() );
+ assign( contact, SG_METER_TO_FEET*_contact );
+ assign( vel, SG_METER_TO_FEET*_vel );
+ assign( normal, _normal );
*agl *= SG_METER_TO_FEET;
return ret;
}
-
double
FGInterface::get_groundlevel_m(double lat, double lon, double alt)
+{
+ return get_groundlevel_m(SGGeod::fromRadM(lon, lat, alt));
+}
+
+double
+FGInterface::get_groundlevel_m(const SGGeod& geod)
{
// Compute the cartesian position of the given lat/lon/alt.
- SGVec3d pos = SGVec3d::fromGeod(SGGeod::fromRadM(lon, lat, alt));
+ SGVec3d pos = SGVec3d::fromGeod(geod);
// FIXME: how to handle t - ref_time differences ???
SGVec3d cpos;
/// too low, try with a new altitude of 10000m, that should be
/// sufficient to find a ground level below everywhere on our planet
if (!ok) {
- pos = SGVec3d::fromGeod(SGGeod::fromRadM(lon, lat, 10000));
+ pos = SGVec3d::fromGeod(SGGeod::fromRadM(geod.getLongitudeRad(), geod.getLatitudeRad(), 10000));
/// If there is still no ground, return sea level radius
if (!prepare_ground_cache_m(ref_time, pos.data(), 10))
return 0;
/// too low, try with a new altitude of 10000m, that should be
/// sufficient to find a ground level below everywhere on our planet
if (!ok) {
- pos = SGVec3d::fromGeod(SGGeod::fromRadM(lon, lat, 10000));
+ pos = SGVec3d::fromGeod(SGGeod::fromRadM(geod.getLongitudeRad(), geod.getLatitudeRad(), 10000));
/// If there is still no ground, return sea level radius
if (!prepare_ground_cache_m(ref_time, pos.data(), radius))
return 0;
// computations below the groundcache. The contact point is still something
// valid, the normals and the other returns just contain some defaults.
get_agl_m(ref_time, pos.data(), 2.0, contact, normal, vel, &type, 0, &agl);
- SGGeod geod = SGGeod::fromCart(SGVec3d(contact));
- return geod.getElevationM();
+ return SGGeod::fromCart(SGVec3d(contact)).getElevationM();
}
bool
{
SGVec3d pt_m[4];
for (int i=0; i<4; ++i)
- sgdCopyVec3(pt_m[i].data(), pt[i]);
+ pt_m[i] = SGVec3d(pt[i]);
return ground_cache.caught_wire(t, pt_m);
}
// Convert units and do the real work.
SGVec3d pt_m[4];
for (int i=0; i<4; ++i)
- sgdScaleVec3(pt_m[i].data(), pt[i], SG_FEET_TO_METER);
+ pt_m[i] = SG_FEET_TO_METER*SGVec3d(pt[i]);
return ground_cache.caught_wire(t, pt_m);
}
SGVec3d _end[2], _vel[2];
bool ret = ground_cache.get_wire_ends(t, _end, _vel);
for (int k=0; k<2; ++k) {
- sgdCopyVec3( end[k], _end[k].data() );
- sgdCopyVec3( vel[k], _vel[k].data() );
+ assign( end[k], _end[k] );
+ assign( vel[k], _vel[k] );
}
return ret;
}
SGVec3d _end[2], _vel[2];
bool ret = ground_cache.get_wire_ends(t, _end, _vel);
for (int k=0; k<2; ++k) {
- sgdScaleVec3( end[k], _end[k].data(), SG_METER_TO_FEET );
- sgdScaleVec3( vel[k], _vel[k].data(), SG_METER_TO_FEET );
+ assign( end[k], SG_METER_TO_FEET*_end[k] );
+ assign( vel[k], SG_METER_TO_FEET*_vel[k] );
}
return ret;
}
`FGInterface::get_Dy_cg ()'
`FGInterface::get_Dz_cg ()'
- `FGInterface::get_T_local_to_body_11 ()' ... `FGInterface::get_T_local_to_body_33 ()'
-
`FGInterface::get_Radius_to_vehicle ()'
*/
SG_USING_STD(vector);
SG_USING_STD(string);
-typedef double FG_VECTOR_3[3];
-
// This is based heavily on LaRCsim/ls_generic.h
class FGInterface : public SGSubsystem {
// next elapsed time. This yields a small amount of temporal
// jitter ( < dt ) but in practice seems to work well.
-// double delta_t; // delta "t"
-// SGTimeStamp time_stamp; // time stamp of last run
-// long elapsed; // time elapsed since last run
double remainder; // remainder time from last run
-// int multi_loop; // number of iterations of "delta_t" to run
-
- // Pilot location rel to ref pt
- FG_VECTOR_3 d_pilot_rp_body_v;
// CG position w.r.t. ref. point
- FG_VECTOR_3 d_cg_rp_body_v;
-
- // Forces
- FG_VECTOR_3 f_body_total_v;
- FG_VECTOR_3 f_local_total_v;
- FG_VECTOR_3 f_aero_v;
- FG_VECTOR_3 f_engine_v;
- FG_VECTOR_3 f_gear_v;
-
- // Moments
- FG_VECTOR_3 m_total_rp_v;
- FG_VECTOR_3 m_total_cg_v;
- FG_VECTOR_3 m_aero_v;
- FG_VECTOR_3 m_engine_v;
- FG_VECTOR_3 m_gear_v;
+ SGVec3d d_cg_rp_body_v;
// Accelerations
- FG_VECTOR_3 v_dot_local_v;
- FG_VECTOR_3 v_dot_body_v;
- FG_VECTOR_3 a_cg_body_v;
- FG_VECTOR_3 a_pilot_body_v;
- FG_VECTOR_3 n_cg_body_v;
- FG_VECTOR_3 n_pilot_body_v;
- FG_VECTOR_3 omega_dot_body_v;
+ SGVec3d v_dot_local_v;
+ SGVec3d v_dot_body_v;
+ SGVec3d a_cg_body_v;
+ SGVec3d a_pilot_body_v;
+ SGVec3d n_cg_body_v;
+ SGVec3d omega_dot_body_v;
// Velocities
- FG_VECTOR_3 v_local_v;
- FG_VECTOR_3 v_local_rel_ground_v; // V rel w.r.t. earth surface
- FG_VECTOR_3 v_local_airmass_v; // velocity of airmass (steady winds)
- FG_VECTOR_3 v_local_rel_airmass_v; // velocity of veh. relative to airmass
- FG_VECTOR_3 v_local_gust_v; // linear turbulence components, L frame
- FG_VECTOR_3 v_wind_body_v; // Wind-relative velocities in body axis
-
- FG_VECTOR_3 omega_body_v; // Angular B rates
- FG_VECTOR_3 omega_local_v; // Angular L rates
- FG_VECTOR_3 omega_total_v; // Diff btw B & L
- FG_VECTOR_3 euler_rates_v;
- FG_VECTOR_3 geocentric_rates_v; // Geocentric linear velocities
+ SGVec3d v_local_v;
+ SGVec3d v_local_rel_ground_v; // V rel w.r.t. earth surface
+ SGVec3d v_local_airmass_v; // velocity of airmass (steady winds)
+ SGVec3d v_wind_body_v; // Wind-relative velocities in body axis
- // Positions
- FG_VECTOR_3 geocentric_position_v;
- FG_VECTOR_3 geodetic_position_v;
- FG_VECTOR_3 euler_angles_v;
+ SGVec3d omega_body_v; // Angular B rates
+ SGVec3d euler_rates_v;
+ SGVec3d geocentric_rates_v; // Geocentric linear velocities
- // Miscellaneous Quantities
- FG_VECTOR_3 d_cg_rwy_local_v; // CG rel. to rwy in local coords
- FG_VECTOR_3 d_cg_rwy_rwy_v; // CG relative to rwy, in rwy coordinates
- FG_VECTOR_3 d_pilot_rwy_local_v; // pilot rel. to rwy in local coords
- FG_VECTOR_3 d_pilot_rwy_rwy_v; // pilot rel. to rwy, in rwy coords.
+ // Positions
+ SGGeod geodetic_position_v;
+ SGVec3d cartesian_position_v;
+ SGGeoc geocentric_position_v;
+ SGVec3d euler_angles_v;
// Inertias
double mass, i_xx, i_yy, i_zz, i_xz;
double nlf;
// Velocities
- 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;
+ double v_rel_wind, v_true_kts;
+ double v_ground_speed, v_equiv_kts;
+ double v_calibrated_kts;
// Miscellaneious Quantities
- double t_local_to_body_m[3][3]; // Transformation matrix L to B
- double gravity; // Local acceleration due to G
- double centrifugal_relief; // load factor reduction due to speed
- double alpha, beta, alpha_dot, beta_dot; // in radians
- double cos_alpha, sin_alpha, cos_beta, sin_beta;
- double cos_phi, sin_phi, cos_theta, sin_theta, cos_psi, sin_psi;
- double gamma_vert_rad, gamma_horiz_rad; // Flight path angles
- double sigma, density, v_sound, mach_number;
- double static_pressure, total_pressure, impact_pressure;
+ double alpha, beta; // in radians
+ double gamma_vert_rad; // Flight path angles
+ double density, mach_number;
+ double static_pressure, total_pressure;
double dynamic_pressure;
double static_temperature, total_temperature;
double sea_level_radius, earth_position_angle;
- double runway_altitude, runway_latitude, runway_longitude;
- double runway_heading;
- double radius_to_rwy;
+ double runway_altitude;
double climb_rate; // in feet per second
- double sin_lat_geocentric, cos_lat_geocentric;
- double sin_longitude, cos_longitude;
- double sin_latitude, cos_latitude;
double altitude_agl;
double daux[16]; // auxilliary doubles
float faux[16]; // auxilliary floats
int iaux[16]; // auxilliary ints
- // SGTimeStamp valid_stamp; // time this record is valid
- // SGTimeStamp next_stamp; // time this record is valid
-
// the ground cache object itself.
FGGroundCache ground_cache;
void _setup();
void _busdump(void);
+ void _updatePositionM(const SGVec3d& cartPos);
+ void _updatePositionFt(const SGVec3d& cartPos) {
+ _updatePositionM(SG_FEET_TO_METER*cartPos);
+ }
+ void _updatePosition(const SGGeod& geod);
+ void _updatePosition(const SGGeoc& geoc);
+
void _updateGeodeticPosition( double lat, double lon, double alt );
void _updateGeocentricPosition( double lat_geoc, double lon, double alt );
void _update_ground_elev_at_pos( void );
- void _updateWeather( void );
inline void _set_Inertias( double m, double xx, double yy,
double zz, double xz)
geocentric_rates_v[1] = lon;
geocentric_rates_v[2] = rad;
}
-#if 0
- inline void _set_Radius_to_vehicle(double radius) {
- geocentric_position_v[2] = radius;
- }
-#endif
inline void _set_Geocentric_Position( double lat, double lon, double rad ) {
- geocentric_position_v[0] = lat;
- geocentric_position_v[1] = lon;
- geocentric_position_v[2] = rad;
+ geocentric_position_v.setLatitudeRad(lat);
+ geocentric_position_v.setLongitudeRad(lon);
+ geocentric_position_v.setRadiusFt(rad);
+ }
+ inline void _set_Latitude(double lat) {
+ geodetic_position_v.setLatitudeRad(lat);
+ }
+ inline void _set_Longitude(double lon) {
+ geodetic_position_v.setLongitudeRad(lon);
}
- inline void _set_Latitude(double lat) { geodetic_position_v[0] = lat; }
- inline void _set_Longitude(double lon) { geodetic_position_v[1] = lon; }
inline void _set_Altitude(double altitude) {
- geodetic_position_v[2] = altitude;
+ geodetic_position_v.setElevationFt(altitude);
}
inline void _set_Altitude_AGL(double agl) {
altitude_agl = agl;
}
inline void _set_Geodetic_Position( double lat, double lon, double alt ) {
- geodetic_position_v[0] = lat;
- geodetic_position_v[1] = lon;
- geodetic_position_v[2] = alt;
+ geodetic_position_v.setLatitudeRad(lat);
+ geodetic_position_v.setLongitudeRad(lon);
+ geodetic_position_v.setElevationFt(alt);
}
inline void _set_Euler_Angles( double phi, double theta, double psi ) {
euler_angles_v[0] = phi;
euler_angles_v[1] = theta;
euler_angles_v[2] = psi;
}
- inline void _set_T_Local_to_Body( int i, int j, double value) {
- t_local_to_body_m[i-1][j-1] = value;
- }
- inline void _set_T_Local_to_Body( double m[3][3] ) {
- int i, j;
- for ( i = 0; i < 3; i++ ) {
- for ( j = 0; j < 3; j++ ) {
- t_local_to_body_m[i][j] = m[i][j];
- }
- }
- }
+ // FIXME, for compatibility with JSBSim
+ inline void _set_T_Local_to_Body( int i, int j, double value) { }
inline void _set_Alpha( double a ) { alpha = a; }
inline void _set_Beta( double b ) { beta = b; }
- inline void _set_Cos_phi( double cp ) { cos_phi = cp; }
- inline void _set_Cos_theta( double ct ) { cos_theta = ct; }
inline void _set_Gamma_vert_rad( double gv ) { gamma_vert_rad = gv; }
inline void _set_Density( double d ) { density = d; }
inline void _set_Mach_number( double m ) { mach_number = m; }
inline void _set_Earth_position_angle(double a) { earth_position_angle = a; }
inline void _set_Runway_altitude( double alt ) { runway_altitude = alt; }
inline void _set_Climb_Rate(double rate) { climb_rate = rate; }
- inline void _set_sin_lat_geocentric(double parm) {
- sin_lat_geocentric = sin(parm);
- }
- inline void _set_cos_lat_geocentric(double parm) {
- cos_lat_geocentric = cos(parm);
- }
- inline void _set_sin_cos_longitude(double parm) {
- sin_longitude = sin(parm);
- cos_longitude = cos(parm);
- }
- inline void _set_sin_cos_latitude(double parm) {
- sin_latitude = sin(parm);
- cos_latitude = cos(parm);
- }
inline void _set_daux( int n, double value ) { daux[n] = value; }
inline void _set_faux( int n, float value ) { faux[n] = value; }
//perform initializion that is common to all FDM's
void common_init();
- // time and update management values
-// inline double get_delta_t() const { return delta_t; }
-// inline void set_delta_t( double dt ) { delta_t = dt; }
-// inline SGTimeStamp get_time_stamp() const { return time_stamp; }
-// inline void set_time_stamp( SGTimeStamp s ) { time_stamp = s; }
-// inline void stamp() { time_stamp.stamp(); }
-// inline long get_elapsed() const { return elapsed; }
-// inline void set_elapsed( long e ) { elapsed = e; }
-// inline long get_remainder() const { return remainder; }
-// inline void set_remainder( long r ) { remainder = r; }
-// inline int get_multi_loop() const { return multi_loop; }
-// inline void set_multi_loop( int ml ) { multi_loop = ml; }
-
// Positions
virtual void set_Latitude(double lat); // geocentric
virtual void set_Longitude(double lon);
inline double get_I_zz() const { return i_zz; }
inline double get_I_xz() const { return i_xz; }
- // Pilot location rel to ref pt
- // 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]; }
- /* inline void set_Pilot_Location( double dx, double dy, double dz ) {
- d_pilot_rp_body_v[0] = dx;
- d_pilot_rp_body_v[1] = dy;
- d_pilot_rp_body_v[2] = dz;
- } */
-
// CG position w.r.t. ref. point
- // 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 ==========
-
- // 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]; }
- /* inline void set_Forces_Body_Total( double x, double y, double z ) {
- f_body_total_v[0] = x;
- f_body_total_v[1] = y;
- f_body_total_v[2] = z;
- } */
-
- // 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]; }
- /* inline void set_Forces_Local_Total( double x, double y, double z ) {
- f_local_total_v[0] = x;
- f_local_total_v[1] = y;
- f_local_total_v[2] = z;
- } */
-
- // 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]; }
- /* inline void set_Forces_Aero( double x, double y, double z ) {
- f_aero_v[0] = x;
- f_aero_v[1] = y;
- f_aero_v[2] = z;
- } */
-
- // 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]; }
- /* inline void set_Forces_Engine( double x, double y, double z ) {
- f_engine_v[0] = x;
- f_engine_v[1] = y;
- f_engine_v[2] = z;
- } */
-
- // 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]; }
- /* inline void set_Forces_Gear( double x, double y, double z ) {
- f_gear_v[0] = x;
- f_gear_v[1] = y;
- f_gear_v[2] = z;
- } */
-
- // ========== Moments ==========
-
- // 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]; }
- /* inline void set_Moments_Total_RP( double l, double m, double n ) {
- m_total_rp_v[0] = l;
- m_total_rp_v[1] = m;
- m_total_rp_v[2] = n;
- } */
-
- // 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]; }
- /* inline void set_Moments_Total_CG( double l, double m, double n ) {
- m_total_cg_v[0] = l;
- m_total_cg_v[1] = m;
- m_total_cg_v[2] = n;
- } */
-
- // 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]; }
- /* inline void set_Moments_Aero( double l, double m, double n ) {
- m_aero_v[0] = l;
- m_aero_v[1] = m;
- m_aero_v[2] = n;
- } */
-
- // 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]; }
- /* inline void set_Moments_Engine( double l, double m, double n ) {
- m_engine_v[0] = l;
- m_engine_v[1] = m;
- m_engine_v[2] = n;
- } */
-
- // 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]; }
- /* inline void set_Moments_Gear( double l, double m, double n ) {
- m_gear_v[0] = l;
- m_gear_v[1] = m;
- m_gear_v[2] = n;
- } */
-
// ========== Accelerations ==========
- // 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]; }
- // 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]; }
- // 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]; }
- // 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]; }
- // 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]; }
- // 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]; }
- // inline void set_Accels_Pilot_Body_N( double x, double y, double z ) {
- // n_pilot_body_v[0] = x;
- // n_pilot_body_v[1] = y;
- // n_pilot_body_v[2] = z;
- // }
-
inline double get_Nlf(void) const { return nlf; }
- // 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]; }
- /* inline void set_Accels_Omega( double p, double q, double r ) {
- omega_dot_body_v[0] = p;
- omega_dot_body_v[1] = q;
- omega_dot_body_v[2] = r;
- } */
-
-
// ========== Velocities ==========
- // 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]; }
// Please dont comment these out. fdm=ada uses these (see
// cockpit.cxx) --->
- 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];
}
}
// <--- fdm=ada uses these (see cockpit.cxx)
- // 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]; }
- // 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];
- // }
- /* inline void set_Velocities_Local_Rel_Airmass( double north, double east,
- double down)
- {
- v_local_rel_airmass_v[0] = north;
- v_local_rel_airmass_v[1] = east;
- v_local_rel_airmass_v[2] = down;
- } */
-
- // 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]; }
- /* inline void set_Velocities_Gust( double u, double v, double w)
- {
- v_local_gust_v[0] = u;
- v_local_gust_v[1] = v;
- v_local_gust_v[2] = w;
- } */
-
- // 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]; }
inline double get_V_rel_wind() const { return v_rel_wind; }
- // inline void set_V_rel_wind(double wind) { v_rel_wind = wind; }
inline double get_V_true_kts() const { return v_true_kts; }
- // inline void set_V_true_kts(double kts) { v_true_kts = kts; }
-
- // inline double get_V_rel_ground() const { return v_rel_ground; }
- // inline void set_V_rel_ground( double v ) { v_rel_ground = v; }
-
- // inline double get_V_inertial() const { return v_inertial; }
- // inline void set_V_inertial(double v) { v_inertial = v; }
inline double get_V_ground_speed() const { return v_ground_speed; }
inline double get_V_ground_speed_kt() const { return v_ground_speed * SG_FEET_TO_METER * 3600 * SG_METER_TO_NM; }
- // inline double get_V_equiv() const { return v_equiv; }
- // inline void set_V_equiv( double v ) { v_equiv = v; }
-
inline double get_V_equiv_kts() const { return v_equiv_kts; }
- //inline double get_V_calibrated() const { return v_calibrated; }
- //inline void set_V_calibrated( double v ) { v_calibrated = v; }
-
inline double get_V_calibrated_kts() const { return v_calibrated_kts; }
- // 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]; }
- // 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]; }
- /* inline void set_Omega_Local( double p, double q, double r ) {
- omega_local_v[0] = p;
- omega_local_v[1] = q;
- omega_local_v[2] = r;
- } */
-
- // 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]; }
- /* inline void set_Omega_Total( double p, double q, double r ) {
- omega_total_v[0] = p;
- omega_total_v[1] = q;
- omega_total_v[2] = r;
- } */
-
- // 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]; }
inline double get_Theta_dot_degps() const { return euler_rates_v[1] * SGD_RADIANS_TO_DEGREES; }
inline double get_Psi_dot_degps() const { return euler_rates_v[2] * SGD_RADIANS_TO_DEGREES; }
- // 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 ==========
- // inline double * get_Geocentric_position_v() {
- // return geocentric_position_v;
- // }
inline double get_Lat_geocentric() const {
- return geocentric_position_v[0];
+ return geocentric_position_v.getLatitudeRad();
}
inline double get_Lon_geocentric() const {
- return geocentric_position_v[1];
+ return geocentric_position_v.getLongitudeRad();
}
inline double get_Radius_to_vehicle() const {
- return geocentric_position_v[2];
+ return geocentric_position_v.getRadiusFt();
}
- // inline double * get_Geodetic_position_v() { return geodetic_position_v; }
- inline double get_Latitude() const { return geodetic_position_v[0]; }
- inline double get_Longitude() const { return geodetic_position_v[1]; }
- inline double get_Altitude() const { return geodetic_position_v[2]; }
+ const SGGeod& getPosition() const { return geodetic_position_v; }
+ const SGGeoc& getGeocPosition() const { return geocentric_position_v; }
+ const SGVec3d& getCartPosition() const { return cartesian_position_v; }
+
+ inline double get_Latitude() const {
+ return geodetic_position_v.getLatitudeRad();
+ }
+ inline double get_Longitude() const {
+ return geodetic_position_v.getLongitudeRad();
+ }
+ inline double get_Altitude() const {
+ return geodetic_position_v.getElevationFt();
+ }
inline double get_Altitude_AGL(void) const { return altitude_agl; }
inline double get_Latitude_deg () const {
- return get_Latitude() * SGD_RADIANS_TO_DEGREES;
+ return geodetic_position_v.getLatitudeDeg();
}
inline double get_Longitude_deg () const {
- return get_Longitude() * SGD_RADIANS_TO_DEGREES;
+ return geodetic_position_v.getLongitudeDeg();
}
- // 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 ==========
- // 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];
- }
-
- // inline double get_Gravity() const { return gravity; }
- // inline void set_Gravity(double g) { gravity = g; }
-
- // inline double get_Centrifugal_relief() const {
- // return centrifugal_relief;
- // }
- // inline void set_Centrifugal_relief(double cr) {
- // centrifugal_relief = cr;
- // }
-
inline double get_Alpha() const { return alpha; }
inline double get_Alpha_deg() const { return alpha * SGD_RADIANS_TO_DEGREES; }
inline double get_Beta() const { return beta; }
inline double get_Beta_deg() const { return beta * SGD_RADIANS_TO_DEGREES; }
- inline double get_Alpha_dot() const { return alpha_dot; }
- // inline void set_Alpha_dot( double ad ) { alpha_dot = ad; }
- inline double get_Beta_dot() const { return beta_dot; }
- // inline void set_Beta_dot( double bd ) { beta_dot = bd; }
-
- // inline double get_Cos_alpha() const { return cos_alpha; }
- // inline void set_Cos_alpha( double ca ) { cos_alpha = ca; }
- // inline double get_Sin_alpha() const { return sin_alpha; }
- // inline void set_Sin_alpha( double sa ) { sin_alpha = sa; }
- // inline double get_Cos_beta() const { return cos_beta; }
- // inline void set_Cos_beta( double cb ) { cos_beta = cb; }
- // inline double get_Sin_beta() const { return sin_beta; }
- // inline void set_Sin_beta( double sb ) { sin_beta = sb; }
-
- inline double get_Cos_phi() const { return cos_phi; }
- // inline double get_Sin_phi() const { return sin_phi; }
- // inline void set_Sin_phi( double sp ) { sin_phi = sp; }
- inline double get_Cos_theta() const { return cos_theta; }
- // inline double get_Sin_theta() const { return sin_theta; }
- // inline void set_Sin_theta( double st ) { sin_theta = st; }
- // inline double get_Cos_psi() const { return cos_psi; }
- // inline void set_Cos_psi( double cp ) { cos_psi = cp; }
- // inline double get_Sin_psi() const { return sin_psi; }
- // inline void set_Sin_psi( double sp ) { sin_psi = sp; }
-
inline double get_Gamma_vert_rad() const { return gamma_vert_rad; }
- // inline double get_Gamma_horiz_rad() const { return gamma_horiz_rad; }
- // inline void set_Gamma_horiz_rad( double gh ) { gamma_horiz_rad = gh; }
- // inline double get_Sigma() const { return sigma; }
- // inline void set_Sigma( double s ) { sigma = s; }
inline double get_Density() const { return density; }
- // inline double get_V_sound() const { return v_sound; }
- // inline void set_V_sound( double v ) { v_sound = v; }
inline double get_Mach_number() const { return mach_number; }
inline double get_Static_pressure() const { return static_pressure; }
inline double get_Total_pressure() const { return total_pressure; }
- // inline void set_Total_pressure( double tp ) { total_pressure = tp; }
- // inline double get_Impact_pressure() const { return impact_pressure; }
- // inline void set_Impact_pressure( double ip ) { impact_pressure = ip; }
inline double get_Dynamic_pressure() const { return dynamic_pressure; }
- // inline void set_Dynamic_pressure( double dp ) { dynamic_pressure = dp; }
inline double get_Static_temperature() const { return static_temperature; }
inline double get_Total_temperature() const { return total_temperature; }
- // inline void set_Total_temperature( double t ) { total_temperature = t; }
inline double get_Sea_level_radius() const { return sea_level_radius; }
inline double get_Earth_position_angle() const {
inline double get_Runway_altitude() const { return runway_altitude; }
inline double get_Runway_altitude_m() const { return SG_FEET_TO_METER * runway_altitude; }
- // inline double get_Runway_latitude() const { return runway_latitude; }
- // inline void set_Runway_latitude( double lat ) { runway_latitude = lat; }
- // inline double get_Runway_longitude() const { return runway_longitude; }
- // inline void set_Runway_longitude( double lon ) {
- // runway_longitude = lon;
- // }
- // inline double get_Runway_heading() const { return runway_heading; }
- // inline void set_Runway_heading( double h ) { runway_heading = h; }
-
- // inline double get_Radius_to_rwy() const { return radius_to_rwy; }
- // inline void set_Radius_to_rwy( double r ) { radius_to_rwy = r; }
-
- // 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]; }
- /* inline void set_CG_Rwy_Local( double north, double east, double above )
- {
- d_cg_rwy_local_v[0] = north;
- d_cg_rwy_local_v[1] = east;
- d_cg_rwy_local_v[2] = above;
- } */
-
- // 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]; }
- /* inline void set_CG_Rwy_Rwy( double x, double y, double h )
- {
- d_cg_rwy_rwy_v[0] = x;
- d_cg_rwy_rwy_v[1] = y;
- d_cg_rwy_rwy_v[2] = h;
- } */
-
- // 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];
- // }
- /* inline void set_Pilot_Rwy_Local( double north, double east, double above )
- {
- d_pilot_rwy_local_v[0] = north;
- d_pilot_rwy_local_v[1] = east;
- d_pilot_rwy_local_v[2] = above;
- } */
-
- // 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]; }
- /* inline void set_Pilot_Rwy_Rwy( double x, double y, double h )
- {
- d_pilot_rwy_rwy_v[0] = x;
- d_pilot_rwy_rwy_v[1] = y;
- d_pilot_rwy_rwy_v[2] = h;
- } */
inline double get_Climb_Rate() const { return climb_rate; }
- // inline SGTimeStamp get_time_stamp() const { return valid_stamp; }
- // inline void stamp_time() { valid_stamp = next_stamp; next_stamp.stamp(); }
-
- // Extrapolate FDM based on time_offset (in usec)
- void extrapolate( int time_offset );
-
- // sin/cos lat_geocentric
- inline double get_sin_lat_geocentric(void) const {
- return sin_lat_geocentric;
- }
- inline double get_cos_lat_geocentric(void) const {
- return cos_lat_geocentric;
- }
-
- inline double get_sin_longitude(void) const {
- return sin_longitude;
- }
- inline double get_cos_longitude(void) const {
- return cos_longitude;
- }
-
- inline double get_sin_latitude(void) const {
- return sin_latitude;
- }
- inline double get_cos_latitude(void) const {
- return cos_latitude;
- }
-
// Auxilliary variables
inline double get_daux( int n ) const { return daux[n]; }
inline float get_faux( int n ) const { return faux[n]; }
double contact[3], double normal[3], double vel[3],
int *type, const SGMaterial** material, double *agl);
double get_groundlevel_m(double lat, double lon, double alt);
+ double get_groundlevel_m(const SGGeod& geod);
// Return 1 if the hook intersects with a wire.
FGScenery::get_elevation_m(double lat, double lon, double max_alt,
double& alt, const SGMaterial** material)
{
- SGGeod geod = SGGeod::fromDegM(lon, lat, max_alt);
+ return get_elevation_m(SGGeod::fromDegM(lon, lat, max_alt), alt, material);
+}
+
+bool
+FGScenery::get_elevation_m(const SGGeod& geod,
+ double& alt, const SGMaterial** material)
+{
SGVec3d pos = SGVec3d::fromGeod(geod);
return get_cart_elevation_m(pos, 0, alt, material);
}
/// All values are meant to be in meters or degrees.
bool get_elevation_m(double lat, double lon, double max_alt,
double& alt, const SGMaterial** material);
+ bool get_elevation_m(const SGGeod& geod, double& alt,
+ const SGMaterial** material);
/// Compute the elevation of the scenery beow the cartesian point pos.
/// you the returned scenery altitude is not higher than the position
projects / flightgear.git / commitdiff