-// mk_viii.cxx -- Honeywell MK VIII EGPWS emulation
+// mk_viii.hxx -- Honeywell MK VIII EGPWS emulation
//
// Written by Jean-Yves Lefort, started September 2005.
//
#include <simgear/sound/sample_openal.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
-SG_USING_STD(vector);
-SG_USING_STD(deque);
-SG_USING_STD(map);
+using std::vector;
+using std::deque;
+using std::map;
-#include "Airports/runways.hxx"
-#include "Airports/simple.hxx"
-#include "Main/globals.hxx"
+class SGSampleGroup;
+
+#include <Airports/runways.hxx>
+#include <Airports/simple.hxx>
+#include <Main/globals.hxx>
+
+#ifdef _MSC_VER
+# pragma warning( push )
+# pragma warning( disable: 4355 )
+#endif
///////////////////////////////////////////////////////////////////////////////
// MK_VIII ////////////////////////////////////////////////////////////////////
class MK_VIII : public SGSubsystem
{
// keep in sync with Mode6Handler::altitude_callout_definitions[]
- static const int n_altitude_callouts = 11;
+ static const unsigned n_altitude_callouts = 11;
/////////////////////////////////////////////////////////////////////////////
// MK_VIII::RawValueMethodsData /////////////////////////////////////////////
if (_getter)
return (_obj.*_getter)(_data);
else
- return SGRawValue<VT>::DefaultValue;
+ return SGRawValue<VT>::DefaultValue();
}
virtual bool setValue (VT value)
{
SGPropertyNode_ptr altimeter_serviceable;
SGPropertyNode_ptr altitude;
SGPropertyNode_ptr altitude_agl;
+ SGPropertyNode_ptr altitude_gear_agl;
+ SGPropertyNode_ptr altitude_radar_agl;
+ SGPropertyNode_ptr orientation_roll;
SGPropertyNode_ptr asi_serviceable;
SGPropertyNode_ptr asi_speed;
SGPropertyNode_ptr autopilot_heading_lock;
bool alternate_steep_approach;
bool use_internal_gps;
bool localizer_enabled;
+ int altitude_source;
+ bool use_attitude_indicator;
} conf;
struct _s_input_feeders
void update_egpws_alert_discrete_2 ();
void update_egpwc_alert_discrete_3 ();
void update_outputs ();
+ void reposition ();
void update_lamps ();
void set_lamp (Lamp lamp);
typedef deque< Sample<double> > samples_type;
samples_type samples;
double value;
+ double last_update;
public:
inline TerrainClearanceFilter ()
- : value(0) {}
+ : value(0.0), last_update(-1.0) {}
double update (double agl);
void reset ();
public:
bool silence;
- virtual inline void play (double volume) {}
+ virtual inline void play (float volume) {}
virtual inline void stop () {}
virtual bool is_playing () = 0;
- virtual inline void set_volume (double volume) {}
+ virtual inline void set_volume (float volume) {}
};
/////////////////////////////////////////////////////////////////////////
class SampleElement : public Element
{
- SGSoundSample *_sample;
- double _volume;
+ SGSharedPtr<SGSoundSample> _sample;
+ float _volume;
public:
- inline SampleElement (SGSoundSample *sample, double volume = 1.0)
+ inline SampleElement (SGSharedPtr<SGSoundSample> sample, float volume = 1.0)
: _sample(sample), _volume(volume) { silence = false; }
- virtual inline void play (double volume) { if (_sample) { set_volume(volume); _sample->play_once(); } }
+ virtual inline void play (float volume) { if (_sample && (volume > 0.05)) { set_volume(volume); _sample->play_once(); } }
virtual inline void stop () { if (_sample) _sample->stop(); }
virtual inline bool is_playing () { return _sample ? _sample->is_playing() : false; }
- virtual inline void set_volume (double volume) { if (_sample) _sample->set_volume(volume * _volume); }
+ virtual inline void set_volume (float volume) { if (_sample) _sample->set_volume(volume * _volume); }
};
/////////////////////////////////////////////////////////////////////////
inline SilenceElement (double duration)
: _duration(duration) { silence = true; }
- virtual inline void play (double volume) { start_time = globals->get_sim_time_sec(); }
+ virtual inline void play (float volume) { start_time = globals->get_sim_time_sec(); }
virtual inline bool is_playing () { return globals->get_sim_time_sec() - start_time < _duration; }
};
Element *element;
inline Voice (VoicePlayer *_player)
- : player(_player), volume(1.0), element(NULL) {}
+ : element(NULL), player(_player), volume(1.0) {}
~Voice ();
void play ();
void stop (bool now);
- void set_volume (double _volume);
+ void set_volume (float _volume);
void volume_changed ();
void update ();
private:
VoicePlayer *player;
- double volume;
+ float volume;
vector<Element *> elements;
vector<Element *>::iterator iter;
- inline double get_volume () const { return player->volume * player->speaker.volume * volume; }
+ inline float get_volume () const { return player->volume * player->speaker.volume * volume; }
};
///////////////////////////////////////////////////////////////////////////
struct
{
- double volume;
+ float volume;
} conf;
- double volume;
+ float volume;
Voice *voice;
Voice *next_voice;
} voices;
inline VoicePlayer (MK_VIII *device)
- : mk(device), speaker(this), voice(NULL), next_voice(NULL) {}
+ : voice(NULL), next_voice(NULL), mk(device), speaker(this) {}
~VoicePlayer ();
};
void stop (unsigned int flags = 0);
- void set_volume (double _volume);
+ void set_volume (float _volume);
void update ();
inline void bind (SGPropertyNode *node) { speaker.bind(node); }
VoicePlayer *player;
double pitch;
- float position[3];
- float orientation[3];
- float inner_cone;
- float outer_cone;
- float outer_gain;
- float reference_dist;
- float max_dist;
template <class T>
inline void tie (SGPropertyNode *node, const char *name, T *ptr)
template <class T>
inline T get_property (T *ptr) const { return *ptr; }
- double volume;
+ float volume;
inline Speaker (VoicePlayer *_player)
: player(_player),
- volume(1),
pitch(1),
- inner_cone(360),
- outer_cone(360),
- outer_gain(0),
- reference_dist(3),
- max_dist(10)
+ volume(1)
{
- position[0] = 0; position[1] = 0; position[2] = 0;
- orientation[0] = 0; orientation[1] = 0; orientation[2] = 0;
}
void bind (SGPropertyNode *node);
MK_VIII *mk;
+ SGSharedPtr<SGSampleGroup> _sgr;
Speaker speaker;
- map<string, SGSoundSample *> samples;
+ map< string, SGSharedPtr<SGSoundSample> > samples;
vector<Voice *> _voices;
bool looped;
State state;
inline SelfTestHandler (MK_VIII *device)
- : mk(device), state(STATE_NONE), button_pressed(false) {}
+ : mk(device), button_pressed(false), state(STATE_NONE) {}
inline void power_off () { stop(); }
inline void set_inop () { stop(); }
} conf;
inline Mode4Handler (MK_VIII *device)
- : mk(device) {}
+ : mk(device),ab_bias(0.0),ab_expanded_bias(0.0),c_bias(0.0) {}
double get_upper_agl (const EnvelopesConfiguration *c);
void update ();
public:
inline Mode5Handler (MK_VIII *device)
- : mk(device) {}
+ : mk(device), soft_bias(0.0) {}
void update ();
};
void power_off ();
void enter_takeoff ();
void leave_takeoff ();
- void set_volume (double volume);
+ void set_volume (float volume);
bool altitude_callouts_enabled ();
void update ();
bool is_high_bank_angle ();
unsigned int get_bank_angle_alerts ();
void update_bank_angle ();
+
+ class AirportFilter : public FGAirport::AirportFilter
+ {
+ public:
+ AirportFilter(Mode6Handler *s)
+ : self(s) {}
+
+ virtual bool passAirport(FGAirport *a) const;
+
+ virtual FGPositioned::Type maxType() const {
+ return FGPositioned::AIRPORT;
+ }
+
+ private:
+ Mode6Handler* self;
+ };
};
/////////////////////////////////////////////////////////////////////////////
double to_heading);
double get_azimuth_difference (const FGRunway *_runway);
- void select_runway (const FGAirport *airport, FGRunway *_runway);
- bool test_airport (const FGAirport *airport);
+ FGRunway* select_runway (const FGAirport *airport);
void update_runway ();
void get_bias_area_edges (Position *edge,
bool is_tcf ();
bool is_rfcf ();
+ class AirportFilter : public FGAirport::AirportFilter
+ {
+ public:
+ AirportFilter(MK_VIII *device)
+ : mk(device) {}
+
+ virtual bool passAirport(FGAirport *a) const;
+ private:
+ MK_VIII* mk;
+ };
public:
struct
{
virtual void update (double dt);
};
+#ifdef _MSC_VER
+# pragma warning( pop )
+#endif
+
#endif // __INSTRUMENTS_MK_VIII_HXX
projects / flightgear.git / blobdiff