XPMPAircraft.h

Go to the documentation of this file.

 
#ifndef _XPMPAircraft_h_
#define _XPMPAircraft_h_
 
#include "XPMPMultiplayer.h"
#include "XPLMInstance.h"
#include "XPLMCamera.h"
#include "XPLMMap.h"
 
#include <cstdint>
#include <cmath>
#include <stdexcept>
#include <string>
#include <vector>
#include <list>
 
//
// MARK: XPMP2 New Definitions
//
 
namespace XPMP2 {
 
class CSLModel;                                 
 
constexpr float RPM_to_RADs = 0.10471975511966f;
constexpr double M_per_FT   = 0.3048;   // meter per 1 foot
constexpr int M_per_NM      = 1852;     // meter per one nautical mile
constexpr double KT_per_M_per_S = 1.94384;  // 1m/s = 1.94384kt
constexpr float G_EARTH     = 9.80665f;
 
enum DR_VALS : std::uint8_t {
    V_CONTROLS_GEAR_RATIO = 0,                  
    V_CONTROLS_NWS_RATIO,                       
    V_CONTROLS_FLAP_RATIO,                      
    V_CONTROLS_SPOILER_RATIO,                   
    V_CONTROLS_SPEED_BRAKE_RATIO,               
    V_CONTROLS_SLAT_RATIO,                      
    V_CONTROLS_WING_SWEEP_RATIO,                
    V_CONTROLS_THRUST_RATIO,                    
    V_CONTROLS_YOKE_PITCH_RATIO,                
    V_CONTROLS_YOKE_HEADING_RATIO,              
    V_CONTROLS_YOKE_ROLL_RATIO,                 
    V_CONTROLS_THRUST_REVERS,                   
    
    V_CONTROLS_TAXI_LITES_ON,                   
    V_CONTROLS_LANDING_LITES_ON,                
    V_CONTROLS_BEACON_LITES_ON,                 
    V_CONTROLS_STROBE_LITES_ON,                 
    V_CONTROLS_NAV_LITES_ON,                    
    
    V_GEAR_NOSE_GEAR_DEFLECTION_MTR,            
    V_GEAR_TIRE_VERTICAL_DEFLECTION_MTR,        
    V_GEAR_TIRE_ROTATION_ANGLE_DEG,             
    V_GEAR_TIRE_ROTATION_SPEED_RPM,             
    V_GEAR_TIRE_ROTATION_SPEED_RAD_SEC,         
    
    V_ENGINES_ENGINE_ROTATION_ANGLE_DEG,        
    V_ENGINES_ENGINE_ROTATION_SPEED_RPM,        
    V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC,    
    V_ENGINES_PROP_ROTATION_ANGLE_DEG,          
    V_ENGINES_PROP_ROTATION_SPEED_RPM,          
    V_ENGINES_PROP_ROTATION_SPEED_RAD_SEC,      
    V_ENGINES_THRUST_REVERSER_DEPLOY_RATIO,     
    
    V_ENGINES_ENGINE_ROTATION_ANGLE_DEG1,       
    V_ENGINES_ENGINE_ROTATION_ANGLE_DEG2,       
    V_ENGINES_ENGINE_ROTATION_ANGLE_DEG3,       
    V_ENGINES_ENGINE_ROTATION_ANGLE_DEG4,       
    V_ENGINES_ENGINE_ROTATION_SPEED_RPM1,       
    V_ENGINES_ENGINE_ROTATION_SPEED_RPM2,       
    V_ENGINES_ENGINE_ROTATION_SPEED_RPM3,       
    V_ENGINES_ENGINE_ROTATION_SPEED_RPM4,       
    V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC1,   
    V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC2,   
    V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC3,   
    V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC4,   
 
    
    V_MISC_TOUCH_DOWN,                          
    
    V_COUNT                                     
};
 
struct CSLModelInfo_t {
    std::string         cslId;
    std::string         modelName;
    std::string         xsbAircraftPath;
    int                 xsbAircraftLn = 0;
    std::string         icaoType;
    std::string         doc8643Classification;
    std::string         doc8643WTC;
 
    struct MatchCrit_t {
        std::string     icaoAirline;    
        std::string     livery;         
    };
    typedef std::vector<MatchCrit_t> vecMatchCrit_t;
    // List of match criteria defined for the model, can be empty
    vecMatchCrit_t      vecMatchCrit;
 
    CSLModelInfo_t() {}
    CSLModelInfo_t(const XPMP2::CSLModel& csl);
};
 
class Aircraft {
    
public:
    
protected:
    XPMPPlaneID modeS_id = 0;
    
public:
    std::string acIcaoType;
    std::string acIcaoAirline;          
    std::string acLivery;               
    
    XPLMDrawInfo_t drawInfo;
    
    float               v_x = 0.0f, v_y = 0.0f, v_z = 0.0f;
 
    bool        bOnGrnd = false;
 
    std::vector<float> v;
    
    std::string label;
    float       colLabel[4]  = {1.0f,1.0f,0.0f,1.0f};   
    bool        bDrawLabel   = true;                    
    
    float       vertOfsRatio = 1.0f;
    
    float       gearDeflectRatio = 0.5f;
    
    bool        bClampToGround = false;
    
    int         aiPrio      = 1;
    
    XPMPPlaneRadar_t acRadar;
    
    std::list<XPLMInstanceRef> listContrail;
    unsigned contrailNum = 0;               
    unsigned contrailDist_m = 5;            
    unsigned contrailLifeTime = 25;         
    
    struct wakeTy {
        float wingSpan_m = NAN;             
        float wingArea_m2 = NAN;            
        float mass_kg = NAN;                
        
        void clear() { *this = wakeTy(); }  
        bool needsDefaults() const;         
        void applyDefaults(const std::string& _wtc, bool _bOverwriteAllFields = true);
        void fillUpFrom(const wakeTy& o);
    } wake;                                 
    
    XPMPInfoTexts_t acInfoTexts;
    
protected:
    bool bValid                 = true;     
    bool bVisible               = true;     
    bool bRender                = true;     
    
    XPMP2::CSLModel*    pCSLMdl = nullptr;  
    int                 matchQuality = -1;  
    int                 acRelGrp = 0;       
    
    // this is data from about a second ago to calculate cartesian velocities
    float               prev_x = 0.0f, prev_y = 0.0f, prev_z = 0.0f;
    float               prev_ts = 0.0f;     
    float               gs_kn = 0.0f;       
    
    double lat1s = NAN, lon1s = NAN, alt1s_ft = NAN;
    
    float               tsResetTouchDown = NAN;
    
    std::list<XPLMInstanceRef> listInst;
    int                 tcasTargetIdx = -1;
    
    float               camTimLstUpd = 0.0f;
    float               camDist = 0.0f;
    float               camBearing = 0.0f;
    
    XPLMProbeRef        hProbe = nullptr;
    
    // Data used for drawing icons in X-Plane's map
    int                 mapIconRow = 0;     
    int                 mapIconCol = 0;     
    float               mapX = 0.0f;        
    float               mapY = 0.0f;        
    std::string         mapLabel;           
    
    // *** Sound support ***
public:
    enum SoundEventsTy {
        SND_ENG = 0,                        
        SND_REVERSE_THRUST,                 
        SND_TIRE,                           
        SND_GEAR,                           
        SND_FLAPS,                          
        SND_NUM_EVENTS                      
    };
    typedef std::list<uint64_t> ChnListTy;
    
    struct SndChTy {
        bool bAuto = true;                  
        uint64_t chnId = 0;                 
        float lastDRVal = NAN;              
        float volAdj = 1.0f;                
    };
 
    int sndMinDist = 50;
    
protected:
    SndChTy aSndCh[SND_NUM_EVENTS];
    bool                bChnMuted = false;
    ChnListTy           chnList;
    int                 skipCounter = 0;
    
private:
    bool bDestroyInst           = false;    
public:
    
    
    Aircraft (const std::string& _icaoType,
              const std::string& _icaoAirline,
              const std::string& _livery,
              XPMPPlaneID _modeS_id = 0,
              const std::string& _cslId = "");
    Aircraft ();
    virtual ~Aircraft();
    
    Aircraft (const Aircraft&) = delete;
    Aircraft& operator=(const Aircraft&) = delete;
    
    void Create (const std::string& _icaoType,
                 const std::string& _icaoAirline,
                 const std::string& _livery,
                 XPMPPlaneID _modeS_id = 0,
                 const std::string& _cslId = "",
                 CSLModel* _pCSLModel = nullptr);
 
    XPMPPlaneID GetModeS_ID () const { return modeS_id; }
    bool        IsRelatedTo (const std::string& _icaoType) const;
    bool        IsGroundVehicle() const;
    bool        IsGlider() const { return IsRelatedTo("GLID"); }
    int         GetTcasTargetIdx () const { return tcasTargetIdx; }
    bool        IsCurrentlyShownAsTcasTarget () const { return tcasTargetIdx >= 1; }
    bool        IsCurrentlyShownAsAI () const;
    bool        ShowAsAIPlane () const { return IsVisible() && acRadar.mode != xpmpTransponderMode_Standby; }
    void        ResetTcasTargetIdx () { tcasTargetIdx = -1; }
    
    virtual std::string GetFlightId() const;
    
 
    int ChangeModel (const std::string& _icaoType,
                     const std::string& _icaoAirline,
                     const std::string& _livery);
    
    int ReMatchModel () { return ChangeModel(acIcaoType,acIcaoAirline,acLivery); }
    
    bool AssignModel (const std::string& _cslId,
                      CSLModel* _pCSLModel = nullptr);
    
    XPMP2::CSLModel* GetModel () const { return pCSLMdl; }
    const std::string& GetModelName () const;
    CSLModelInfo_t GetModelInfo() const { return pCSLMdl ? CSLModelInfo_t(*pCSLMdl) : CSLModelInfo_t();  }
    int         GetMatchQuality () const { return matchQuality; }
 
 
    float       GetVertOfs () const;
    
    bool IsValid() const { return bValid; }
    virtual void SetInvalid();
    
    virtual void SetVisible (bool _bVisible);
    bool IsVisible () const { return bVisible && bValid; }
    
    virtual void SetRender (bool _bRender);
    bool IsRendered () const { return bRender && IsVisible(); }
    
    bool IsInstanciated () const { return !listInst.empty(); }
    
    void SetDrawLabel (bool _b) { bDrawLabel = _b; }
    bool ShallDrawLabel () const { return bDrawLabel; }
    
    float GetCameraDist () const { return camDist; }
    float GetCameraBearing () const { return camBearing; }
 
    virtual void UpdatePosition (float _elapsedSinceLastCall, int _flCounter) = 0;
    
    bool IsOnGrnd () const { return bOnGrnd; }
    void SetOnGrnd (bool on_grnd, float setTouchDownTime = NAN);
    
 
    void SetLocation (double lat, double lon, double alt_ft, bool on_grnd, float setTouchDownTime = NAN) {
        SetLocation(lat, lon, alt_ft);
        SetOnGrnd(on_grnd, setTouchDownTime);
    }
 
    void SetLocation (double lat, double lon, double alt_ft);
    
    void GetLocation (double& lat, double& lon, double& alt_ft) const;
    
    void SetLocalLoc (float _x, float _y, float _z) { drawInfo.x = _x; drawInfo.y = _y; drawInfo.z = _z; }
    const XPLMDrawInfo_t& GetLocation () const { return drawInfo; }
 
    float GetPitch () const              { return drawInfo.pitch; }                     
    void  SetPitch (float _deg)          { drawInfo.pitch = _deg; }                     
    float GetHeading () const            { return drawInfo.heading; }                   
    void  SetHeading (float _deg)        { drawInfo.heading = _deg; }                   
    float GetRoll () const               { return drawInfo.roll; }                      
    void  SetRoll (float _deg)           { drawInfo.roll = _deg; }                      
 
    float GetGS_kn() const               { return gs_kn; }                              
    
 
    float GetGearRatio () const          { return v[V_CONTROLS_GEAR_RATIO]; }           
    void  SetGearRatio (float _f)        { v[V_CONTROLS_GEAR_RATIO] = _f;   }           
    float GetNoseWheelAngle () const     { return v[V_CONTROLS_NWS_RATIO]; }            
    void  SetNoseWheelAngle (float _f)   { v[V_CONTROLS_NWS_RATIO] = _f;   }            
    float GetFlapRatio () const          { return v[V_CONTROLS_FLAP_RATIO]; }           
    void  SetFlapRatio (float _f)        { v[V_CONTROLS_FLAP_RATIO] = _f;   }           
    float GetSpoilerRatio () const       { return v[V_CONTROLS_SPOILER_RATIO]; }        
    void  SetSpoilerRatio (float _f)     { v[V_CONTROLS_SPOILER_RATIO] = _f;   }        
    float GetSpeedbrakeRatio () const    { return v[V_CONTROLS_SPEED_BRAKE_RATIO]; }    
    void  SetSpeedbrakeRatio (float _f)  { v[V_CONTROLS_SPEED_BRAKE_RATIO] = _f;   }    
    float GetSlatRatio () const          { return v[V_CONTROLS_SLAT_RATIO]; }           
    void  SetSlatRatio (float _f)        { v[V_CONTROLS_SLAT_RATIO] = _f;   }           
    float GetWingSweepRatio () const     { return v[V_CONTROLS_WING_SWEEP_RATIO]; }     
    void  SetWingSweepRatio (float _f)   { v[V_CONTROLS_WING_SWEEP_RATIO] = _f;   }     
    float GetThrustRatio () const        { return v[V_CONTROLS_THRUST_RATIO]; }         
    void  SetThrustRatio (float _f)      { v[V_CONTROLS_THRUST_RATIO] = _f;   }         
    float GetYokePitchRatio () const     { return v[V_CONTROLS_YOKE_PITCH_RATIO]; }     
    void  SetYokePitchRatio (float _f)   { v[V_CONTROLS_YOKE_PITCH_RATIO] = _f;   }     
    float GetYokeHeadingRatio () const   { return v[V_CONTROLS_YOKE_HEADING_RATIO]; }   
    void  SetYokeHeadingRatio (float _f) { v[V_CONTROLS_YOKE_HEADING_RATIO] = _f;   }   
    float GetYokeRollRatio () const      { return v[V_CONTROLS_YOKE_ROLL_RATIO]; }      
    void  SetYokeRollRatio (float _f)    { v[V_CONTROLS_YOKE_ROLL_RATIO] = _f;   }      
    float GetThrustReversRatio () const  { return v[V_CONTROLS_THRUST_REVERS]; }        
    void  SetThrustReversRatio (float _f){ v[V_CONTROLS_THRUST_REVERS] = _f;   }        
 
    bool  GetLightsTaxi () const         { return v[V_CONTROLS_TAXI_LITES_ON] > 0.5f; }     
    void  SetLightsTaxi (bool _b)        { v[V_CONTROLS_TAXI_LITES_ON] = float(_b);   }     
    bool  GetLightsLanding () const      { return v[V_CONTROLS_LANDING_LITES_ON] > 0.5f; }  
    void  SetLightsLanding (bool _b)     { v[V_CONTROLS_LANDING_LITES_ON] = float(_b);   }  
    bool  GetLightsBeacon () const       { return v[V_CONTROLS_BEACON_LITES_ON] > 0.5f; }   
    void  SetLightsBeacon (bool _b)      { v[V_CONTROLS_BEACON_LITES_ON] = float(_b);   }   
    bool  GetLightsStrobe () const       { return v[V_CONTROLS_STROBE_LITES_ON] > 0.5f; }   
    void  SetLightsStrobe (bool _b)      { v[V_CONTROLS_STROBE_LITES_ON] = float(_b);   }   
    bool  GetLightsNav () const          { return v[V_CONTROLS_NAV_LITES_ON] > 0.5f; }      
    void  SetLightsNav (bool _b)         { v[V_CONTROLS_NAV_LITES_ON] = float(_b);   }      
 
    float GetNoseGearDeflection () const { return v[V_GEAR_NOSE_GEAR_DEFLECTION_MTR]; }     
    void  SetNoseGearDeflection (float _mtr) { v[V_GEAR_NOSE_GEAR_DEFLECTION_MTR] = _mtr; } 
    float GetTireDeflection () const     { return v[V_GEAR_TIRE_VERTICAL_DEFLECTION_MTR]; } 
    void  SetTireDeflection (float _mtr) { v[V_GEAR_TIRE_VERTICAL_DEFLECTION_MTR] = _mtr; } 
    float GetTireRotAngle () const       { return v[V_GEAR_TIRE_ROTATION_ANGLE_DEG]; }      
    void  SetTireRotAngle (float _deg)   { v[V_GEAR_TIRE_ROTATION_ANGLE_DEG] = _deg; }      
    float GetTireRotRpm () const         { return v[V_GEAR_TIRE_ROTATION_SPEED_RPM]; }      
    void  SetTireRotRpm (float _rpm)     { v[V_GEAR_TIRE_ROTATION_SPEED_RPM] = _rpm;        
                                           v[V_GEAR_TIRE_ROTATION_SPEED_RAD_SEC] = _rpm * RPM_to_RADs; }
    float GetTireRotRad () const         { return v[V_GEAR_TIRE_ROTATION_SPEED_RAD_SEC]; }  
    void  SetTireRotRad (float _rad)     { v[V_GEAR_TIRE_ROTATION_SPEED_RAD_SEC] = _rad;    
                                           v[V_GEAR_TIRE_ROTATION_SPEED_RPM] = _rad / RPM_to_RADs; }
    
    float GetEngineRotAngle () const     { return v[V_ENGINES_ENGINE_ROTATION_ANGLE_DEG]; }     
    void  SetEngineRotAngle (float _deg);                                                       
    float GetEngineRotRpm () const       { return v[V_ENGINES_ENGINE_ROTATION_SPEED_RPM]; }     
    void  SetEngineRotRpm (float _rpm);                                                         
    float GetEngineRotRad () const       { return v[V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC]; } 
    void  SetEngineRotRad (float _rad);                                                         
    
    float GetEngineRotAngle (size_t idx) const              
    { return 1 <= idx && idx <= 4 ? v[V_ENGINES_ENGINE_ROTATION_ANGLE_DEG1+idx-1] : 0.0f; }
    void  SetEngineRotAngle (size_t idx, float _deg);       
    float GetEngineRotRpm (size_t idx) const                
    { return 1 <= idx && idx <= 4 ? v[V_ENGINES_ENGINE_ROTATION_SPEED_RPM1+idx-1] : 0.0f; }
    void  SetEngineRotRpm (size_t idx, float _rpm);         
    float GetEngineRotRad (size_t idx) const                
    { return 1 <= idx && idx <= 4 ? v[V_ENGINES_ENGINE_ROTATION_SPEED_RAD_SEC+idx-1] : 0.0f; }
    void  SetEngineRotRad (size_t idx, float _rad);         
 
    float GetPropRotAngle () const       { return v[V_ENGINES_PROP_ROTATION_ANGLE_DEG]; }      
    void  SetPropRotAngle (float _deg)   { v[V_ENGINES_PROP_ROTATION_ANGLE_DEG] = _deg; }      
    float GetPropRotRpm () const         { return v[V_ENGINES_PROP_ROTATION_SPEED_RPM]; }      
    void  SetPropRotRpm (float _rpm)     { v[V_ENGINES_PROP_ROTATION_SPEED_RPM] = _rpm;        
                                           v[V_ENGINES_PROP_ROTATION_SPEED_RAD_SEC] = _rpm * RPM_to_RADs; }
    float GetPropRotRad () const         { return v[V_ENGINES_PROP_ROTATION_SPEED_RAD_SEC]; }  
    void  SetPropRotRad (float _rad)     { v[V_ENGINES_PROP_ROTATION_SPEED_RAD_SEC] = _rad;    
                                           v[V_ENGINES_PROP_ROTATION_SPEED_RPM] = _rad / RPM_to_RADs; }
 
    float GetReversDeployRatio () const  { return v[V_ENGINES_THRUST_REVERSER_DEPLOY_RATIO]; }  
    void  SetReversDeployRatio (float _f){ v[V_ENGINES_THRUST_REVERSER_DEPLOY_RATIO] = _f;   }  
 
    bool  GetTouchDown () const          { return v[V_MISC_TOUCH_DOWN] > 0.5f; }                
    void  SetTouchDown (bool _b)         { v[V_MISC_TOUCH_DOWN] = float(_b);   }                
 
                                                                                                
    void WakeApplyDefaults(bool _bOverwriteAllFields = true);
 
    float GetWingSpan () const          { return wake.wingSpan_m; }     
    void SetWingSpan (float _m)         { wake.wingSpan_m = _m; }       
 
    float GetWingArea() const           { return wake.wingArea_m2; }    
    void SetWingArea (float _m2)        { wake.wingArea_m2 = _m2; }     
 
    int GetWakeCat() const;                                             
 
    float GetMass() const               { return wake.mass_kg; }        
    void SetMass(float _kg)             { wake.mass_kg = _kg; }         
 
    // Overridables:
    virtual float GetAoA() const        { return GetPitch(); }          
    virtual float GetLift() const       { return GetMass() * G_EARTH; } 
 
 
    unsigned ContrailTrigger ();
    
    void ContrailRequest (unsigned num, unsigned dist_m = 0, unsigned lifeTime = 0);
 
    void ContrailRemove ();
    
 
    void MapFindIcon ();
    void MapPreparePos (XPLMMapProjectionID  projection,
                        const float boundsLTRB[4]);
    void MapDrawIcon (XPLMMapLayerID inLayer, float acSize);
    void MapDrawLabel (XPLMMapLayerID inLayer, float yOfs);
    
 
    uint64_t SoundPlay (const std::string& sndName, float vol = 1.0f);
    
    void SoundStop (uint64_t chnId);
    
    void SoundVolume (uint64_t chnId, float vol);
    
    void SoundMuteAll (bool bMute);
    bool SoundIsMuted() const { return bChnMuted; }
    
    virtual std::string SoundGetName (SoundEventsTy sndEvent, float& volAdj) const;
 
protected:
 
 
    static float FlightLoopCB (float, float, int, void*);
 
 
    void DoMove ();
    void DoEverySecondUpdates (float now);
    void ContrailMove ();
    void ContrailAutoUpdate ();
    void UpdateDistBearingCamera (const XPLMCameraPosition_t& posCam);
    void ClampToGround ();
    bool CreateInstances ();
    void DestroyInstances ();
    
    virtual void ComputeMapLabel ();
 
    // The following functions are implemented in AIMultiplayer.cpp:
    virtual void SetTcasTargetIdx (int _idx) { tcasTargetIdx = _idx; }
 
 
    // These functions perform the TCAS target / multiplayer data updates
    friend void AIMultiUpdate ();
    friend size_t AIUpdateTCASTargets ();
    friend size_t AIUpdateMultiplayerDataRefs ();
    
 
    virtual void SoundSetup ();
    virtual void SoundUpdate ();
    virtual void SoundRemoveAll ();
    
};
 
Aircraft* AcFindByID (XPMPPlaneID _id);
 
bool AcSetDefaultWakeData(const std::string& _wtc, const Aircraft::wakeTy& _wake);
 
//
// MARK: XPMP2 Exception class
//
 
class XPMP2Error : public std::logic_error {
protected:
    std::string fileName;           
    int ln;                         
    std::string funcName;           
    std::string msg;                
public:
    XPMP2Error (const char* szFile, int ln, const char* szFunc, const char* szMsg, ...);
public:
    virtual const char* what() const noexcept;
    
public:
    // copy/move constructor/assignment as per default
    XPMP2Error (const XPMP2Error& o) = default;
    XPMP2Error (XPMP2Error&& o) = default;
    XPMP2Error& operator = (const XPMP2Error& o) = default;
    XPMP2Error& operator = (XPMP2Error&& o) = default;
};
 
 
 
}   // namespace XPMP2
 
#endif