XPMPMultiplayer.h

Go to the documentation of this file.

 
 
#ifndef _XPLMMultiplayer_h_
#define _XPLMMultiplayer_h_
 
#include <string>
#include <cmath>
#include "XPLMDefs.h"
#include "XPMPExport.h"
 
// Suppress warnings on member attributes needing to have dll-interface
#if _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251 4275)
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
// defined in XPMPAircraft
namespace XPMP2 { class Aircraft; }
 
/************************************************************************************
 * MARK: PLANE DATA TYPES
 ************************************************************************************/
 
struct XPMP2_EXPORT 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 XPMP2_EXPORT 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 XPMP2_EXPORT 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 XPMP2_EXPORT XPMPPlaneRadar_t {
    long                    size = sizeof(XPMPPlaneRadar_t);    
    long                    code = 0;                           
    XPMPTransponderMode     mode = xpmpTransponderMode_ModeC;   
    const char*             GetModeStr() const;                 
};
 
 
struct XPMP2_EXPORT 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")]]
XPMP2_EXPORT const char* XPMPMultiplayerInitLegacyData(const char* inCSLFolder,
                                                       const char* inPluginName,
                                                       const char* resourceDir,
                                                       XPMPIntPrefsFuncTy inIntPrefsFunc   = nullptr,
                                                       const char* inDefaultICAO           = nullptr,
                                                       const char* inPluginLogAcronym      = nullptr);
 
XPMP2_EXPORT const char* XPMPMultiplayerInit(const char* inPluginName,
                                             const char* resourceDir,
                                             XPMPIntPrefsFuncTy inIntPrefsFunc   = nullptr,
                                             const char* inDefaultICAO           = nullptr,
                                             const char* inPluginLogAcronym      = nullptr);
 
XPMP2_EXPORT void XPMPSetPluginName (const char* inPluginName,
                                     const char* inPluginLogAcronym      = nullptr);
 
 
XPMP2_EXPORT void XPMPMultiplayerCleanup();
 
 
XPMP2_EXPORT bool XPMPContrailsAutoEnabled ();
 
XPMP2_EXPORT bool XPMPContrailsAvailable ();
 
[[deprecated("Unsupported feature, will always return 'OBJ7 format is no longer supported'")]]
const char * XPMPMultiplayerOBJ7SupportEnable(const char * inTexturePath);
 
 
/************************************************************************************
* MARK: Sound
************************************************************************************/
 
 
XPMP2_EXPORT bool XPMPSoundEnable (bool bEnable = true);
 
XPMP2_EXPORT bool XPMPSoundIsEnabled ();
 
XPMP2_EXPORT void XPMPSoundSetMasterVolume (float fVol = 1.0f);
 
XPMP2_EXPORT void XPMPSoundMute (bool bMute);
 
XPMP2_EXPORT 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);
 
XPMP2_EXPORT const char* XPMPSoundEnumerate (const char* prevName, const char** ppFilePath = nullptr);
 
XPMP2_EXPORT bool XPMPSoundGetAudioDeviceName(int i, std::string& devName);
 
XPMP2_EXPORT bool XPMPSoundSetAudioDeviceName(const std::string& deviceName);
 
XPMP2_EXPORT bool XPMPSoundSetAudioDevice(int i);
 
XPMP2_EXPORT int XPMPSoundGetActiveAudioDevice (std::string* pDevName = 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
************************************************************************************/
 
 
XPMP2_EXPORT const char* XPMPMultiplayerEnable(void (*_callback)(void*)  = nullptr,
                                               void*  _refCon            = nullptr);
 
 
XPMP2_EXPORT void XPMPMultiplayerDisable();
 
 
XPMP2_EXPORT bool XPMPHasControlOfAIAircraft();
 
 
/************************************************************************************
* MARK: CSL Package Handling
************************************************************************************/
 
 
XPMP2_EXPORT const char *    XPMPLoadCSLPackage(const char * inCSLFolder);
 
 
[[deprecated("No longer needed, does not do anything.")]]
void XPMPLoadPlanesIfNecessary();
 
 
XPMP2_EXPORT int XPMPGetNumberOfInstalledModels();
 
 
[[deprecated("Unsafe, use XPMPGetModelInfo2() instead.")]]
XPMP2_EXPORT void XPMPGetModelInfo(int inIndex, const char **outModelName, const char **outIcao, const char **outAirline, const char **outLivery);
 
XPMP2_EXPORT void XPMPGetModelInfo2(int inIndex, std::string& outModelName,  std::string& outIcao, std::string& outAirline, std::string& outLivery);
 
 
XPMP2_EXPORT int XPMPModelMatchQuality(const char *              inICAO,
                                       const char *              inAirline,
                                       const char *              inLivery);
 
 
XPMP2_EXPORT bool XPMPIsICAOValid(const char *                inICAO);
 
XPMP2_EXPORT 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")]]
XPMP2_EXPORT 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")]]
XPMP2_EXPORT 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")]]
XPMP2_EXPORT void            XPMPDestroyPlane(XPMPPlaneID _id);
 
 
XPMP2_EXPORT void            XPMPSetPlaneVisibility(XPMPPlaneID _id, bool _bVisible);
 
 
XPMP2_EXPORT int     XPMPChangePlaneModel(XPMPPlaneID            inPlaneID,
                                          const char *           inICAOCode,
                                          const char *           inAirline,
                                          const char *           inLivery);
 
 
XPMP2_EXPORT 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);
 
 
XPMP2_EXPORT int         XPMPGetPlaneModelQuality(XPMPPlaneID                inPlane);
 
 
XPMP2_EXPORT long        XPMPCountPlanes(void);
 
 
XPMP2_EXPORT XPMPPlaneID XPMPGetNthPlane(long                    index);
 
 
XPMP2_EXPORT XPMP2::Aircraft* XPMPGetAircraft (XPMPPlaneID _id);
 
 
XPMP2_EXPORT 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);
 
 
XPMP2_EXPORT void XPMPRegisterPlaneNotifierFunc(XPMPPlaneNotifier_f       inFunc,
                                                void *                    inRefcon);
 
 
XPMP2_EXPORT 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);
 
 
XPMP2_EXPORT void XPMPEnableAircraftLabels (bool _enable = true);
 
 
XPMP2_EXPORT void XPMPDisableAircraftLabels();
 
 
XPMP2_EXPORT bool XPMPDrawingAircraftLabels();
 
 
XPMP2_EXPORT void XPMPSetAircraftLabelDist (float _dist_nm, bool _bCutOffAtVisibility = true);
 
//
// MARK: MAP
//       Enable or disable the drawing of icons on maps
//
 
XPMP2_EXPORT void XPMPEnableMap (bool _bEnable, bool _bLabels = true);
 
 
#ifdef __cplusplus
}
#endif
 
#if _MSC_VER
#pragma warning(pop)
#endif
 
#endif