LTAPI.h

Go to the documentation of this file.

 
 
#ifndef LTAPI_h
#define LTAPI_h
 
#include <cstring>
#include <memory>
#include <string>
#include <list>
#include <map>
#include <chrono>
 
#include "XPLMDataAccess.h"
#include "XPLMGraphics.h"
 
class LTDataRef;
class LTAPIAircraft;
 
typedef std::shared_ptr<LTAPIAircraft> SPtrLTAPIAircraft;
 
class LTAPIAircraft
{
private:
    unsigned        keyNum = 0;
    std::string     key;
 
public:
    
    enum LTFlightPhase {
        FPH_UNKNOWN     = 0,            
        FPH_PARKED      = 5,            
        FPH_TAXI        = 10,           
        FPH_TAKE_OFF    = 20,           
        FPH_TO_ROLL,                    
        FPH_ROTATE,                     
        FPH_LIFT_OFF,                   
        FPH_INITIAL_CLIMB,              
        FPH_CLIMB       = 30,           
        FPH_CRUISE      = 40,           
        FPH_DESCEND     = 50,           
        FPH_APPROACH    = 60,           
        FPH_FINAL,                      
        FPH_LANDING     = 70,           
        FPH_FLARE,                      
        FPH_TOUCH_DOWN,                 
        FPH_ROLL_OUT,                   
        FPH_STOPPED_ON_RWY              
    };
 
    struct LTAPIBulkData {
    public:
        // identification
        uint64_t        keyNum          = 0;  
        // position, attitude
        float           lat_f           = 0.0f; 
        float           lon_f           = 0.0f; 
        float           alt_ft_f        = 0.0f; 
        float           heading         = 0.0f; 
        float           track           = 0.0f; 
        float           roll            = 0.0f; 
        float           pitch           = 0.0f; 
        float           speed_kt        = 0.0f; 
        float           vsi_ft          = 0.0f; 
        float           terrainAlt_ft   = 0.0f; 
        float           height_ft       = 0.0f; 
        // configuration
        float           flaps           = 0.0f; 
        float           gear            = 0.0f; 
        float           reversers       = 0.0f; 
        // simulation
        float           bearing         = 0.0f; 
        float           dist_nm         = 0.0f; 
        
        struct BulkBitsTy {
            LTFlightPhase phase : 8;        
            bool        onGnd : 1;          
            // Lights:
            bool        taxi       : 1;     
            bool        land       : 1;     
            bool        bcn        : 1;     
            bool        strb       : 1;     
            bool        nav        : 1;     
            unsigned    hidden     : 1;     
            bool        camera     : 1;     
            // Misc
            int         multiIdx    : 8;    
            // Filler for 8-byte alignment
            unsigned    filler2     : 8;
            unsigned    filler3     : 32;
        } bits;                             
        
        // V1.22 additions
        double          lat             = 0.0f; 
        double          lon             = 0.0f; 
        double          alt_ft          = 0.0f; 
 
        
        LTAPIBulkData()
        { memset(&bits, 0, sizeof(bits)); }
    };
    
    struct LTAPIBulkInfoTexts {
    public:
        // identification
        uint64_t        keyNum;             
        char            registration[8];    
        // aircraft model/operator
        char            modelIcao[8];       
        char            acClass[4];         
        char            wtc[4];             
        char            opIcao[8];          
        char            man[40];            
        char            model[40];          
        char            catDescr[40];       
        char            op[40];             
        // flight data
        char            callSign[8];        
        char            squawk[8];          
        char            flightNumber[8];    
        char            origin[8];          
        char            destination[8];     
        char            trackedBy[24];      
 
        // V1.22 additions, in V2.40 extended from 24 to 40 chars
        char            cslModel[40];       
 
        LTAPIBulkInfoTexts()
        { memset(this, 0, sizeof(*this)); }
    };
    
    struct LTLights {
        bool beacon     : 1;                
        bool strobe     : 1;                
        bool nav        : 1;                
        bool landing    : 1;                
        bool taxi       : 1;                
        
        LTLights ( const LTAPIBulkData::BulkBitsTy b ) :
        beacon(b.bcn), strobe(b.strb), nav(b.nav), landing(b.land), taxi(b.taxi){}
    };
    
protected:
    LTAPIBulkData       bulk;               
    LTAPIBulkInfoTexts  info;               
    
    bool            bUpdated = false;
    
public:
    LTAPIAircraft();
    virtual ~LTAPIAircraft();
    
    // Updates an aircraft. If our key is defined it first verifies that the
    // key matches with the one currently available in the dataRefs.
    // Returns false if not.
    // If our key is not defined it just accepts anything available.
    // Updates all fields, set bUpdated and returns true.
    virtual bool updateAircraft(const LTAPIBulkData& __bulk, size_t __inSize);
    virtual bool updateAircraft(const LTAPIBulkInfoTexts& __info, size_t __inSize);
    bool isUpdated () const { return bUpdated; }
    void resetUpdated ()    { bUpdated = false; }
    
    virtual void toggleCamera ([[maybe_unused]] bool bCameraActive,
                               [[maybe_unused]] SPtrLTAPIAircraft spPrevAc) {}
    
    void setCameraAc ();
    
    // data access
public:
    std::string     getKey()            const { return key; }                   
    // identification
    std::string     getRegistration()   const { return info.registration; }     
    // aircraft model/operator
    std::string     getModelIcao()      const { return info.modelIcao; }        
    std::string     getAcClass()        const { return info.acClass; }          
    std::string     getWtc()            const { return info.wtc; }              
    std::string     getOpIcao()         const { return info.opIcao; }           
    std::string     getMan()            const { return info.man; }              
    std::string     getModel()          const { return info.model; }            
    std::string     getCatDescr()       const { return info.catDescr; }         
    std::string     getOp()             const { return info.op; }               
    std::string     getCslModel()       const { return info.cslModel; }         
    // flight data
    std::string     getCallSign()       const { return info.callSign; }         
    std::string     getSquawk()         const { return info.squawk; }           
    std::string     getFlightNumber()   const { return info.flightNumber; }     
    std::string     getOrigin()         const { return info.origin; }           
    std::string     getDestination()    const { return info.destination; }      
    std::string     getTrackedBy()      const { return info.trackedBy; }        
    // combined info
    std::string     getDescription()    const;                                  
    // position, attitude
    double          getLat()            const { return bulk.lat; }              
    double          getLon()            const { return bulk.lon; }              
    double          getAltFt()          const { return bulk.alt_ft; }           
    float           getHeading()        const { return bulk.heading; }          
    float           getTrack()          const { return bulk.track; }            
    float           getRoll()           const { return bulk.roll; }             
    float           getPitch()          const { return bulk.pitch; }            
    float           getSpeedKn()        const { return bulk.speed_kt; }         
    float           getVSIft()          const { return bulk.vsi_ft; }           
    float           getTerrainFt()      const { return bulk.terrainAlt_ft; }    
    float           getHeightFt()       const { return bulk.height_ft; }        
    bool            isOnGnd()           const { return bulk.bits.onGnd; }       
    LTFlightPhase   getPhase()          const { return bulk.bits.phase; }       
    std::string     getPhaseStr()       const;                                  
    bool            isVisible()         const { return !bulk.bits.hidden; }     
    // configuration
    float           getFlaps()          const { return bulk.flaps; }            
    float           getGear()           const { return bulk.gear; }             
    float           getReversers()      const { return bulk.reversers; }        
    LTLights        getLights()         const { return bulk.bits; }             
    bool            isOnCamera()        const { return bulk.bits.camera; }      
    // simulation
    float           getBearing()        const { return bulk.bearing; }          
    float           getDistNm()         const { return bulk.dist_nm; }          
    int             getMultiIdx()       const { return bulk.bits.multiIdx; }    
 
    // calculated
    void            getLocalCoord (double& x, double& y, double& z) const
    { XPLMWorldToLocal(bulk.lat,bulk.lon,bulk.alt_ft*0.3048, &x,&y,&z); }
 
public:
    static LTAPIAircraft* CreateNewObject() { return new LTAPIAircraft(); }
};
 
//
// MapLTAPIAircraft
//
 
typedef std::map<std::string,SPtrLTAPIAircraft> MapLTAPIAircraft;
 
typedef std::list<SPtrLTAPIAircraft> ListLTAPIAircraft;
 
class LTAPIConnect
{
public:
    typedef LTAPIAircraft* fCreateAcObject();
    
    std::chrono::seconds sPeriodExpsv = std::chrono::seconds(3);
    
protected:
    const int iBulkAc = 50;
    std::unique_ptr<LTAPIAircraft::LTAPIBulkData[]> vBulkNum;
    std::unique_ptr<LTAPIAircraft::LTAPIBulkInfoTexts[]> vInfoTexts;
 
protected:
    fCreateAcObject* pfCreateAcObject = nullptr;
    
    MapLTAPIAircraft mapAc;
    
    std::chrono::time_point<std::chrono::steady_clock> lastExpsvFetch;
    
public:
    LTAPIConnect(fCreateAcObject* _pfCreateAcObject = LTAPIAircraft::CreateNewObject,
                 int numBulkAc = 50);
    virtual ~LTAPIConnect();
    
    static bool isLTAvail ();
 
    static int getLTVerNr();
 
    static int getLTVerDate();
 
    static bool doesLTDisplayAc ();
    
    static int getLTNumAc ();
    
    static bool doesLTControlAI ();
    
    static time_t getLTSimTime ();
 
    static std::chrono::system_clock::time_point getLTSimTimePoint ();
    
    const MapLTAPIAircraft& UpdateAcList (ListLTAPIAircraft* plistRemovedAc = nullptr);
    
    const MapLTAPIAircraft& getAcMap () const { return mapAc; }
    
    SPtrLTAPIAircraft getAcByMultIdx (int multiIdx) const;
 
    SPtrLTAPIAircraft getAcInCameraView () const;
    
    void clearCameraInfo ();
    
protected:
    template <class T>
    bool DoBulkFetch (int numAc, LTDataRef& DR, int& outSizeLT,
                      std::unique_ptr<T[]> &vBulk);
    
    static void CameraSharedDataCB (LTAPIConnect* me);
};
 
 
 
class LTDataRef {
protected:
    std::string     sDataRef;           
    XPLMDataRef     dataRef = NULL;     
    XPLMDataTypeID  dataTypes = xplmType_Unknown;   
    bool            bValid = true;      
public:
    LTDataRef (std::string _sDataRef);  
    inline bool needsInit () const { return bValid && !dataRef; }
    bool    isValid ();
    bool    FindDataRef ();
 
    // types
    XPLMDataTypeID getDataRefTypes() const { return dataTypes; }
    bool    hasInt ()   const { return dataTypes & xplmType_Int; }
    bool    hasFloat () const { return dataTypes & xplmType_Float; }
    static constexpr XPLMDataTypeID usefulTypes =
            xplmType_Int | xplmType_Float | xplmType_Data;
 
    int     getInt();
    float   getFloat();
    inline bool getBool() { return getInt() != 0; }
    int     getData(void* pOut, int inOffset, int inMaxBytes);
    
    void    set(int i);
    void    set(float f);
 
protected:
};
 
//
// Sizes for version compatibility comparison
//
 
constexpr size_t LTAPIBulkData_v120 = 80;
constexpr size_t LTAPIBulkData_v122 = sizeof(LTAPIAircraft::LTAPIBulkData);
 
constexpr size_t LTAPIBulkInfoTexts_v120 = 264;
constexpr size_t LTAPIBulkInfoTexts_v122 = 288;
constexpr size_t LTAPIBulkInfoTexts_v240 = sizeof(LTAPIAircraft::LTAPIBulkInfoTexts);
 
#endif /* LTAPI_h */