XPMPRemote.h

Go to the documentation of this file.

 
 
#ifndef _XPMPRemote_h_
#define _XPMPRemote_h_
 
#include <cassert>
#include <cstdint>
#include <cstring>
#include <cmath>
#include <array>
#include <algorithm>
 
namespace XPMP2 {
 
constexpr const char* REMOTE_SIGNATURE      =  "TwinFan.plugin.XPMP2.Remote";
 
//
// MARK: Global Helpers
//
 
std::uint16_t PJWHash16 (const char *s);
 
CSLModel* CSLModelByPkgShortId (std::uint16_t _pkgHash,
                                const std::string& _shortId);
 
template<class T>
constexpr const T& clamp( const T& v, const T& lo, const T& hi )
{
    assert( !(hi < lo) );
    return (v < lo) ? lo : (hi < v) ? hi : v;
}
 
//
// MARK: Network Data Definitions
//
 
enum RemoteMsgTy : std::uint8_t {
    RMT_MSG_INTEREST_BEACON = 0,    
    RMT_MSG_SEND,                   
    RMT_MSG_SETTINGS,               
    RMT_MSG_AC_DETAILED,            
    RMT_MSG_AC_POS_UPDATE,          
    RMT_MSG_AC_ANIM,                
    RMT_MSG_AC_REMOVE,              
};
 
struct RemoteDataRefPackTy {
    float       minV  = 0.0f;       
    float       range = 0.0f;       
 
    RemoteDataRefPackTy (float _min, float _max) : minV(_min), range(_max - _min) { assert(range != 0.0f); }
    
    std::uint8_t pack (float f) const   { return std::uint8_t(clamp<float>(f-minV,0.0f,range) * UINT8_MAX / range); }
    float unpack (std::uint8_t i) const { return minV + range*float(i)/255.0f; }
};
 
extern const std::array<RemoteDataRefPackTy,V_COUNT> REMOTE_DR_DEF;
 
//
// MARK: Message Header (Base)
//
 
// To ensure best network capacity usage as well as identical alignment across platform we enforce tightly packed structures.
// The approach is very different between Visual C++ and clang / gcc, though:
#ifdef _MSC_VER                                 // Visual C++
#pragma pack(push,1)                            // set packing once (ie. not per struct)
#define PACKED
#elif defined(__clang__) || defined(__GNUC__)   // Clang (Mac XCode etc) or GNU (Linux)
#define PACKED __attribute__ ((__packed__))
#else
#error Unhandled Compiler!
#endif
 
struct RemoteMsgBaseTy {
    RemoteMsgTy  msgTy  : 4;        
    std::uint8_t msgVer : 4;        
    bool         bLocalSender : 1;  
    std::uint8_t filler1      : 7;  
    std::uint16_t pluginId = 0;     
    std::uint32_t filler2 = 0;      
    RemoteMsgBaseTy (RemoteMsgTy _ty, std::uint8_t _ver);
} PACKED;
 
//
// MARK: Beacon of Interest
//
 
constexpr std::uint8_t RMT_VER_BEACON = 0;
struct RemoteMsgBeaconTy : public RemoteMsgBaseTy {
    // don't need additional data fields
    RemoteMsgBeaconTy();
} PACKED;
 
//
// MARK: Settings
//
 
constexpr int   REMOTE_SEND_SETTINGS_INTVL  = 20;
 
constexpr std::uint8_t RMT_VER_SETTINGS = 0;
struct RemoteMsgSettingsTy : public RemoteMsgBaseTy {
    char            name[16];           
    float           maxLabelDist;       
    char            defaultIcao[4];     
    char            carIcaoType[4];     
    std::uint8_t logLvl             :3; 
    bool bLogMdlMatch               :1; 
    bool bObjReplDataRefs           :1; 
    bool bObjReplTextures           :1; 
    bool bLabelCutOffAtVisibility   :1; 
    bool bMapEnabled                :1; 
    bool bMapLabels                 :1; 
    bool bHaveTCASControl           :1; 
    std::uint16_t filler;               
    
    RemoteMsgSettingsTy ();
    
} PACKED;
 
//
// MARK: A/C Details
//
 
constexpr std::uint8_t RMT_VER_AC_DETAIL = 3;
constexpr std::uint8_t RMT_VER_AC_DETAIL_2 = 2;
constexpr std::uint8_t RMT_VER_AC_DETAIL_1 = 1;
constexpr std::uint8_t RMT_VER_AC_DETAIL_0 = 0;
struct RemoteAcDetailTy {
    std::uint32_t   modeS_id;           
    char            icaoType[4];        
    char            icaoOp[4];          
    char            sShortId[20];       
    std::uint16_t   pkgHash;            
    char            label[23];          
    std::uint8_t    labelCol[3];        
    float           alt_ft;             
    // ^ the above has 64 bytes, so that these doubles start on an 8-byte bounday:
    double          lat;                
    double          lon;                
    std::int16_t    pitch;              
    std::uint16_t   heading;            
    std::int16_t    roll;               
    
    std::int16_t    aiPrio;             
    std::uint16_t   dTime;              
    bool            bValid : 1;         
    bool            bVisible : 1;       
    bool            bRender : 1;        
    bool            bDrawLabel : 1;     
    bool            bOnGrnd : 1;        
    std::uint8_t    contrailNum : 3;    
 
    // selectively taken from XPMPInfoTexts_t and packed:
    char            tailNum[10];        
    char            manufacturer[40];   
    char            model[40];          
    char            airline[40];        
    char            flightNum [10];     
    char            aptFrom [5];        
    char            aptTo [5];          
    
    std::uint8_t    contrailDist_m;     
    std::uint8_t    contrailLifeTime;   
    std::uint8_t    filler[3];          
    
    std::uint8_t    v[XPMP2::V_COUNT];    // 42
 
    RemoteAcDetailTy ();
    RemoteAcDetailTy (const Aircraft& _ac, double _lat, double _lon, float _alt_ft, std::uint16_t _dTime);
    void CopyFrom (const Aircraft& _ac, double _lat, double _lon, float _alt_ft, std::uint16_t _dTime);
    
    void SetLabelCol (const float _col[4]);     
    void GetLabelCol (float _col[4]) const;     
    
    void SetPitch (float _p) { pitch = std::int16_t(_p*100.0f); }  
    float GetPitch () const { return float(pitch) / 100.0f; }                   
 
    void SetHeading (float _h);
    float GetHeading () const { return float(heading) / 100.0f; }               
 
    void SetRoll (float _r) { roll = std::int16_t(std::lround(_r*100.0f)); }  
    float GetRoll () const { return float(roll) / 100.0f; }                   
 
    static constexpr size_t msgSize () { return sizeof(RemoteAcDetailTy); }   
} PACKED;
 
struct RemoteMsgAcDetailTy : public RemoteMsgBaseTy {
    RemoteAcDetailTy arr[1];                
    
    RemoteMsgAcDetailTy () : RemoteMsgBaseTy(RMT_MSG_AC_DETAILED, RMT_VER_AC_DETAIL) {}
    static constexpr size_t NumElem (size_t _msgLen) { return (_msgLen - sizeof(RemoteMsgBaseTy)) / sizeof(RemoteAcDetailTy); }
} PACKED;
 
//
// MARK: A/C Position Update
//
 
constexpr std::uint8_t RMT_VER_AC_POS_UPDATE = 0;
 
constexpr double REMOTE_DEGREE_RES          = 0.00000001;                   
constexpr double REMOTE_MAX_DIFF_DEGREE     = REMOTE_DEGREE_RES * INT16_MAX;
constexpr double REMOTE_ALT_FT_RES          = 0.01;                         
constexpr double REMOTE_MAX_DIFF_ALT_FT     = REMOTE_ALT_FT_RES * INT16_MAX;
constexpr float  REMOTE_TIME_RES            = 0.0001f;                      
constexpr float  REMOTE_MAX_DIFF_TIME       = REMOTE_TIME_RES * UINT16_MAX; 
 
struct RemoteAcPosUpdateTy {
    std::uint32_t   modeS_id;           
    std::int16_t    dLat;               
    std::int16_t    dLon;               
    std::int16_t    dAlt_ft;            
    std::uint16_t   dTime;              
    std::int16_t    pitch;              
    std::uint16_t   heading;            
    std::int16_t    roll;               
    std::uint16_t   filler1;            
    
    RemoteAcPosUpdateTy () { std::memset(this,0,sizeof(*this)); }
    RemoteAcPosUpdateTy (XPMPPlaneID _modeS_id,
                         std::int16_t _dLat, std::int16_t _dLon,
                         std::int16_t _dAlt_ft, std::uint16_t _dTime,
                         float _pitch, float _heading, float _roll);
    
    void SetPitch (float _p) { pitch = std::int16_t(_p*100.0f); }  
    float GetPitch () const { return float(pitch) / 100.0f; }               
 
    void SetHeading (float _h);
    float GetHeading () const { return float(heading) / 100.0f; }           
 
    void SetRoll (float _r) { roll = std::int16_t(std::lround(_r*100.0f)); }
    float GetRoll () const { return float(roll) / 100.0f; }                 
 
    static constexpr size_t msgSize () { return sizeof(RemoteAcPosUpdateTy); }    
} PACKED;
 
struct RemoteMsgAcPosUpdateTy : public RemoteMsgBaseTy {
    RemoteAcPosUpdateTy arr[1];         
    
    RemoteMsgAcPosUpdateTy () : RemoteMsgBaseTy(RMT_MSG_AC_POS_UPDATE, RMT_VER_AC_POS_UPDATE) {}
    static constexpr size_t NumElem (size_t _msgLen) { return (_msgLen - sizeof(RemoteMsgBaseTy)) / sizeof(RemoteAcPosUpdateTy); }
} PACKED;
 
//
// MARK: A/C animation dataRefs
//
 
constexpr std::uint8_t RMT_VER_AC_ANIM = 0;
 
struct RemoteAcAnimTy {
    std::uint32_t   modeS_id = 0;       
    std::uint8_t    numVals = 0;        
    std::uint8_t    filler = 0;         
    
    struct DataRefValTy {
        DR_VALS         idx;            
        std::uint8_t    v;              
    } v[1];                             
    
    RemoteAcAnimTy (XPMPPlaneID _id) : modeS_id(_id) { v[0].idx = DR_VALS(0); v[0].v = 0; }
    
    static constexpr size_t msgSize (std::uint8_t num)
    { return sizeof(RemoteAcAnimTy) + (num-1) * sizeof(DataRefValTy); }
    size_t msgSize() const { return msgSize(numVals); }
} PACKED;
 
struct RemoteMsgAcAnimTy : public RemoteMsgBaseTy {
    RemoteAcAnimTy animData;            
    
    RemoteMsgAcAnimTy () : RemoteMsgBaseTy(RMT_MSG_AC_ANIM, RMT_VER_AC_ANIM), animData(0) {}
    
    const RemoteAcAnimTy* next (size_t _msgLen, const RemoteAcAnimTy* pCurr = nullptr) const;
} PACKED;
 
 
//
// MARK: A/C Removal
//
 
 
constexpr std::uint8_t RMT_VER_AC_REMOVE = 0;
 
struct RemoteAcRemoveTy {
    std::uint32_t   modeS_id;           
    
    RemoteAcRemoveTy (XPMPPlaneID _id = 0) : modeS_id(_id) {}
 
    static constexpr size_t msgSize () { return sizeof(RemoteAcRemoveTy); }    
} PACKED;
 
struct RemoteMsgAcRemoveTy : public RemoteMsgBaseTy {
    RemoteAcRemoveTy   arr[1];          
 
    RemoteMsgAcRemoveTy () : RemoteMsgBaseTy(RMT_MSG_AC_REMOVE, RMT_VER_AC_REMOVE) {}
    static constexpr size_t NumElem (size_t _msgLen) { return (_msgLen - sizeof(RemoteMsgBaseTy)) / sizeof(arr[0]); }
} PACKED;
 
#ifdef _MSC_VER                                 // Visual C++
#pragma pack(pop)                               // reseting packing
#endif
 
// A few static validations just to make sure that no compiler fiddles with my network message layout.
static_assert(sizeof(RemoteMsgBaseTy)       ==   8,     "RemoteMsgBaseTy doesn't have expected size");
static_assert(sizeof(RemoteMsgSettingsTy)   ==  40,     "RemoteMsgSettingsTy doesn't have expected size");
static_assert(sizeof(RemoteAcDetailTy)      == 246+42,  "RemoteAcDetailTy doesn't have expected size");
static_assert(sizeof(RemoteMsgAcDetailTy)   == 254+42,  "RemoteMsgAcDetailTy doesn't have expected size");
static_assert(sizeof(RemoteAcPosUpdateTy)   ==  20,     "RemoteAcPosUpdateTy doesn't have expected size");
static_assert(sizeof(RemoteMsgAcPosUpdateTy)==  28,     "RemoteMsgAcPosUpdateTy doesn't have expected size");
static_assert(sizeof(RemoteAcAnimTy)        ==   8,     "RemoteAcAnimTy doesn't have expected size");
static_assert(RemoteAcAnimTy::msgSize(V_COUNT) == 90,   "RemoteAcAnimTy for V_COUNT dataRefs doesn't have expected size");
static_assert(sizeof(RemoteMsgAcAnimTy)     ==  16,     "RemoteMsgAcAnimTy doesn't have expected size");
static_assert(sizeof(RemoteMsgAcRemoveTy)   ==  12,     "RemoteMsgAcRemoveTy doesn't have expected size");
 
//
// MARK: Miscellaneous
//
 
struct RemoteCBFctTy {
    void (*pfBeforeFirstAc)() = nullptr;
    void (*pfAfterLastAc)() = nullptr;
    void (*pfMsgSettings) (const std::uint32_t from[4],
                           const std::string& sFrom,
                           const RemoteMsgSettingsTy&) = nullptr;
    void (*pfMsgACDetails) (const std::uint32_t from[4], size_t msgLen,
                            const RemoteMsgAcDetailTy&) = nullptr;
    void (*pfMsgACPosUpdate) (const std::uint32_t from[4], size_t msgLen,
                              const RemoteMsgAcPosUpdateTy&) = nullptr;
    void (*pfMsgACAnim) (const std::uint32_t from[4], size_t msgLen,
                         const RemoteMsgAcAnimTy&) = nullptr;
    void (*pfMsgACRemove) (const std::uint32_t from[4], size_t msgLen,
                           const RemoteMsgAcRemoveTy&) = nullptr;
};
 
enum RemoteStatusTy : unsigned {
    REMOTE_OFF = 0,                 
    REMOTE_SEND_WAITING,            
    REMOTE_SENDING,                 
    REMOTE_RECV_WAITING,            
    REMOTE_RECEIVING,               
};
 
RemoteStatusTy RemoteGetStatus();
 
void RemoteRecvStart (const RemoteCBFctTy& _rmtCBFcts);
 
void RemoteRecvStop ();
 
}
 
 
#endif