LTAPI/html/LTAPI_8h_source.html

#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

{

private:

    unsigned        keyNum = 0;

    std::string     key;


public:


    enum LTFlightPhase {

        FPH_UNKNOWN     = 0,

        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    filler1    : 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; }


    // 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;

    // 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, &x,&y,&z); }


public:

    static LTAPIAircraft* CreateNewObject() { return new LTAPIAircraft(); }

};


//

// MapLTAPIAircraft

//


typedef std::shared_ptr<LTAPIAircraft> SPtrLTAPIAircraft;


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;


protected:

    template <class T>

    bool DoBulkFetch (int numAc, LTDataRef& DR, int& outSizeLT,

                      std::unique_ptr<T[]> &vBulk);


};


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 */