XPMPMultiplayer.h

Go to the documentation of this file.

 
 
#ifndef _XPLMMultiplayer_h_
#define _XPLMMultiplayer_h_
 
#include <string>
#include <cmath>
#include "XPLMDefs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// defined in XPMPAircraft
namespace XPMP2 { class Aircraft; }
 
/************************************************************************************
 * MARK: PLANE DATA TYPES
 ************************************************************************************/
 
struct XPMPPlanePosition_t {
    long    size            = sizeof(XPMPPlanePosition_t);  
    double  lat             = 0.0;                      
    double  lon             = 0.0;                      
    double  elevation       = 0.0;                      
    float   pitch           = 0.0f;                     
    float   roll            = 0.0f;                     
    float   heading         = 0.0f;                     
    char    label[32]       = "";                       
    float   offsetScale     = 1.0f;                     
    bool    clampToGround   = false;                    
    int     aiPrio          = 1;                        
    float   label_color[4]  = {1.0f,1.0f,0.0f,1.0f};    
    int     multiIdx        = 0;                        
};
 
 
enum {
    xpmp_Lights_Pattern_Default     = 0,    
    xpmp_Lights_Pattern_EADS        = 1,    
    xpmp_Lights_Pattern_GA          = 2     
};
typedef unsigned int XPMPLightsPattern;     
 
 
#if __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic" // because we don't want to change the anonymous structure following here as that would require code change in legacy plugins
#elif _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4202 4201)
#endif
union xpmp_LightStatus {
    unsigned int lightFlags = 0x150000;     
    struct {
        unsigned int timeOffset : 16;       
        
        unsigned int taxiLights : 1;        
        unsigned int landLights : 1;        
        unsigned int bcnLights  : 1;        
        unsigned int strbLights : 1;        
        unsigned int navLights  : 1;        
        
        XPMPLightsPattern flashPattern   : 4;
    };
};
#if __GNUC__
#pragma GCC diagnostic pop
#elif _MSC_VER
#pragma warning(pop)
#endif
 
 
struct XPMPPlaneSurfaces_t {
    long                  size = sizeof(XPMPPlaneSurfaces_t);   
    float                 gearPosition      = 0.0f;             
    float                 flapRatio         = 0.0f;             
    float                 spoilerRatio      = 0.0f;             
    float                 speedBrakeRatio   = 0.0f;             
    float                 slatRatio         = 0.0f;             
    float                 wingSweep         = 0.0f;             
    float                 thrust            = 0.0f;             
    float                 yokePitch         = 0.0f;             
    float                 yokeHeading       = 0.0f;             
    float                 yokeRoll          = 0.0f;             
    
    xpmp_LightStatus      lights;                               
    
    float                 tireDeflect       = 0.0f;             
    float                 tireRotDegree     = 0.0f;             
    float                 tireRotRpm        = 0.0f;             
    
    float                 engRotDegree      = 0.0f;             
    float                 engRotRpm         = 0.0f;             
    float                 propRotDegree     = 0.0f;             
    float                 propRotRpm        = 0.0f;             
    float                 reversRatio       = 0.0f;             
    
    bool                  touchDown = false;                    
};
 
 
enum XPMPTransponderMode {
    xpmpTransponderMode_Off = 0,        
    xpmpTransponderMode_Standby,        
    xpmpTransponderMode_ModeA,          
    xpmpTransponderMode_ModeC,          
    xpmpTransponderMode_Test,           
    xpmpTransponderMode_ModeS_Gnd,      
    xpmpTransponderMode_ModeS_TAOnly,   
    xpmpTransponderMode_ModeS_TARA,     
};
 
 
struct XPMPPlaneRadar_t {
    long                    size = sizeof(XPMPPlaneRadar_t);    
    long                    code = 0;                           
    XPMPTransponderMode     mode = xpmpTransponderMode_ModeC;   
    const char*             GetModeStr() const;                 
};
 
 
struct XPMPInfoTexts_t {
    long size = sizeof(XPMPInfoTexts_t);
    char tailNum[10]       = {0};       
    char icaoAcType[5]     = {0};       
    char manufacturer[40]  = {0};       
    char model[40]         = {0};       
    char icaoAirline[4]    = {0};       
    char airline[40]       = {0};       
    char flightNum [10]    = {0};       
    char aptFrom [5]       = {0};       
    char aptTo [5]         = {0};       
};
 
 
enum XPMPPlaneDataType {
    xpmpDataType_Position   = 1L << 1,  
    xpmpDataType_Surfaces   = 1L << 2,  
    xpmpDataType_Radar      = 1L << 3,  
    xpmpDataType_InfoTexts  = 1L << 4,  
};
 
 
enum XPMPPlaneCallbackResult {
    xpmpData_Unavailable = 0,   /* The information has never been specified. */
    xpmpData_Unchanged = 1,     /* The information from the last time the plug-in was asked. */
    xpmpData_NewData = 2        /* The information has changed this sim cycle. */
};
 
 
typedef unsigned XPMPPlaneID;
 
constexpr XPMPPlaneID MIN_MODE_S_ID = 0x00000001;
constexpr XPMPPlaneID MAX_MODE_S_ID = 0x00FFFFFF;
 
 
/************************************************************************************
* MARK: INITIALIZATION
************************************************************************************/
 
#define XPMP_CFG_SEC_MODELS          "models"               
#define XPMP_CFG_SEC_PLANES          "planes"               
#define XPMP_CFG_SEC_SOUND           "sound"                
#define XPMP_CFG_SEC_DEBUG           "debug"                
 
#define XPMP_CFG_ITM_REPLDATAREFS    "replace_datarefs"     
#define XPMP_CFG_ITM_REPLTEXTURE     "replace_texture"      
#define XPMP_CFG_ITM_CLAMPALL        "clamp_all_to_ground"  
#define XPMP_CFG_ITM_HANDLE_DUP_ID   "handle_dup_id"        
#define XPMP_CFG_ITM_SUPPORT_REMOTE  "support_remote"       
#define XPMP_CFG_ITM_CONTR_MIN_ALT   "contrail_min_alt"     
#define XPMP_CFG_ITM_CONTR_MAX_ALT   "contrail_max_alt"     
#define XPMP_CFG_ITM_CONTR_LIFE      "contrail_life_time"   
#define XPMP_CFG_ITM_CONTR_MULTI     "contrail_multiple"    
#define XPMP_CFG_ITM_ACTIVATE_SOUND  "activate_sound"       
#define XPMP_CFG_ITM_FMOD_INSTANCE   "force_fmod_instance"  
#define XPMP_CFG_ITM_MUTE_ON_PAUSE   "mute_on_pause"        
#define XPMP_CFG_ITM_LOGLEVEL        "log_level"            
#define XPMP_CFG_ITM_MODELMATCHING   "model_matching"       
 
typedef int (*XPMPIntPrefsFuncTy)(const char* _section, const char* _key, int _default);
 
 
[[deprecated("Use XPMPMultiplayerInit and XPMPLoadCSLPackages")]]
const char *    XPMPMultiplayerInitLegacyData(const char* inCSLFolder,
                                              const char* inPluginName,
                                              const char* resourceDir,
                                              XPMPIntPrefsFuncTy inIntPrefsFunc   = nullptr,
                                              const char* inDefaultICAO           = nullptr,
                                              const char* inPluginLogAcronym      = nullptr);
 
const char *    XPMPMultiplayerInit(const char* inPluginName,
                                    const char* resourceDir,
                                    XPMPIntPrefsFuncTy inIntPrefsFunc   = nullptr,
                                    const char* inDefaultICAO           = nullptr,
                                    const char* inPluginLogAcronym      = nullptr);
 
void XPMPSetPluginName (const char* inPluginName,
                        const char* inPluginLogAcronym      = nullptr);
 
 
void XPMPMultiplayerCleanup();
 
 
bool XPMPContrailsAutoEnabled ();
 
bool XPMPContrailsAvailable ();
 
[[deprecated("Unsupported feature, will always return 'OBJ7 format is no longer supported'")]]
const char * XPMPMultiplayerOBJ7SupportEnable(const char * inTexturePath);
 
 
/************************************************************************************
* MARK: Sound
************************************************************************************/
 
 
bool XPMPSoundEnable (bool bEnable = true);
 
bool XPMPSoundIsEnabled ();
 
void XPMPSoundSetMasterVolume (float fVol = 1.0f);
 
void XPMPSoundMute (bool bMute);
 
const char* XPMPSoundAdd (const char* sName,
                          const char* filePath,
                          bool bLoop,
                          float coneDir = NAN, float conePitch = NAN,
                          float coneInAngle = NAN, float coneOutAngle = NAN,
                          float coneOutVol = NAN);
 
const char* XPMPSoundEnumerate (const char* prevName, const char** ppFilePath = nullptr);
 
 
 
// Standard sounds loaded by XPMP2 from XP's `Resource/sounds` folders
#define XP_SOUND_ELECTRIC       "Electric"
#define XP_SOUND_HIBYPASSJET    "HiBypassJet"
#define XP_SOUND_LOBYPASSJET    "LoBypassJet"
#define XP_SOUND_TURBOPROP      "Turboprop"
#define XP_SOUND_PROP_AIRPLANE  "PropAirplane"
#define XP_SOUND_PROP_HELI      "PropHeli"
#define XP_SOUND_REVERSE_THRUST "ReverseThrust"
#define XP_SOUND_ROLL_RUNWAY    "RollRunway"
#define XP_SOUND_FLAP           "Flap"
#define XP_SOUND_GEAR           "Gear"
 
 
/************************************************************************************
* MARK: AI / Multiplayer plane control
************************************************************************************/
 
 
const char *    XPMPMultiplayerEnable(void (*_callback)(void*)  = nullptr,
                                      void*  _refCon            = nullptr);
 
 
void XPMPMultiplayerDisable();
 
 
bool XPMPHasControlOfAIAircraft();
 
 
/************************************************************************************
* MARK: CSL Package Handling
************************************************************************************/
 
 
const char *    XPMPLoadCSLPackage(const char * inCSLFolder);
 
 
[[deprecated("No longer needed, does not do anything.")]]
void            XPMPLoadPlanesIfNecessary();
 
 
int XPMPGetNumberOfInstalledModels();
 
 
[[deprecated("Unsafe, use XPMPGetModelInfo2() instead.")]]
void XPMPGetModelInfo(int inIndex, const char **outModelName, const char **outIcao, const char **outAirline, const char **outLivery);
 
void XPMPGetModelInfo2(int inIndex, std::string& outModelName,  std::string& outIcao, std::string& outAirline, std::string& outLivery);
 
 
int         XPMPModelMatchQuality(const char *              inICAO,
                                  const char *              inAirline,
                                  const char *              inLivery);
 
 
bool            XPMPIsICAOValid(const char *                inICAO);
 
size_t XPMPAddModelDataRef (const std::string& dataRef);
 
 
/************************************************************************************
 * MARK: PLANE CREATION API
 ************************************************************************************/
 
 
typedef XPMPPlaneCallbackResult (* XPMPPlaneData_f)(XPMPPlaneID         inPlane,
                                                    XPMPPlaneDataType   inDataType,
                                                    void *              ioData,
                                                    void *              inRefcon);
 
 
[[deprecated("Subclass XPMP2::Aircraft instead")]]
XPMPPlaneID XPMPCreatePlane(const char *            inICAOCode,
                            const char *            inAirline,
                            const char *            inLivery,
                            XPMPPlaneData_f         inDataFunc,
                            void *                  inRefcon,
                            XPMPPlaneID             inModeS_id = 0);
 
[[deprecated("Subclass XPMP2::Aircraft instead")]]
XPMPPlaneID XPMPCreatePlaneWithModelName(const char *           inModelName,
                                         const char *           inICAOCode,
                                         const char *           inAirline,
                                         const char *           inLivery,
                                         XPMPPlaneData_f        inDataFunc,
                                         void *                 inRefcon,
                                         XPMPPlaneID            inModeS_id = 0);
 
[[deprecated("Delete subclassed XPMP2::Aircraft object instead")]]
void            XPMPDestroyPlane(XPMPPlaneID _id);
 
 
void            XPMPSetPlaneVisibility(XPMPPlaneID _id, bool _bVisible);
 
 
int     XPMPChangePlaneModel(XPMPPlaneID            inPlaneID,
                             const char *           inICAOCode,
                             const char *           inAirline,
                             const char *           inLivery);
 
 
int     XPMPGetPlaneModelName(XPMPPlaneID             inPlaneID,
                              char *                  outTxtBuf,
                              int                     outTxtBufSize);
 
 
[[deprecated("Unsafe pointer operations")]]
void            XPMPGetPlaneICAOAndLivery(XPMPPlaneID               inPlane,
                                          char *                    outICAOCode,    // Can be NULL
                                          char *                    outLivery);     // Can be NULL
 
 
[[deprecated("Unsupported")]]
XPMPPlaneCallbackResult XPMPGetPlaneData(XPMPPlaneID                    inPlane,
                                         XPMPPlaneDataType          inDataType,
                                         void *                     outData);
 
 
int         XPMPGetPlaneModelQuality(XPMPPlaneID                inPlane);
 
 
long        XPMPCountPlanes(void);
 
 
XPMPPlaneID XPMPGetNthPlane(long                    index);
 
 
XPMP2::Aircraft* XPMPGetAircraft (XPMPPlaneID _id);
 
 
void    XPMPSetDefaultPlaneICAO(const char* _acIcaoType,
                                const char* _carIcaoType = nullptr);
 
 
/************************************************************************************
 * MARK: PLANE OBSERVATION API
 ************************************************************************************/
 
 
enum XPMPPlaneNotification {
    xpmp_PlaneNotification_Created          = 1,    
    xpmp_PlaneNotification_ModelChanged     = 2,    
    xpmp_PlaneNotification_Destroyed        = 3,    
};
 
 
typedef void (*XPMPPlaneNotifier_f)(XPMPPlaneID            inPlaneID,
                                    XPMPPlaneNotification  inNotification,
                                    void *                 inRefcon);
 
 
void            XPMPRegisterPlaneNotifierFunc(XPMPPlaneNotifier_f       inFunc,
                                              void *                    inRefcon);
 
 
void            XPMPUnregisterPlaneNotifierFunc(XPMPPlaneNotifier_f     inFunc,
                                                void *                  inRefcon);
 
 
/************************************************************************************
 * MARK: PLANE RENDERING API (unsued in XPMP2)
 ************************************************************************************/
 
[[deprecated("Unsupported, will not be called")]]
typedef void (* XPMPRenderPlanes_f)(
                                    int                         inIsBlend,
                                    void *                      inRef);
 
 
[[deprecated("Unsupported, doesn't do anything")]]
void        XPMPSetPlaneRenderer(XPMPRenderPlanes_f         inRenderer,
                                 void *                         inRef);
 
 
[[deprecated("Unsupported, doesn't do anything")]]
void        XPMPDumpOneCycle(void);
 
 
void XPMPEnableAircraftLabels (bool _enable = true);
 
 
void XPMPDisableAircraftLabels();
 
 
bool XPMPDrawingAircraftLabels();
 
 
void XPMPSetAircraftLabelDist (float _dist_nm, bool _bCutOffAtVisibility = true);
 
//
// MARK: MAP
//       Enable or disable the drawing of icons on maps
//
 
void XPMPEnableMap (bool _bEnable, bool _bLabels = true);
 
 
#ifdef __cplusplus
}
#endif
 
 
#endif