XPMP2.h

Go to the documentation of this file.

 
#ifndef _XPMP2_h_
#define _XPMP2_h_
 
#if IBM
// In MINGW winsock2 must be included before windows.h, which is included by the mingw.*.h headers
#include <winsock2.h>
#include <ws2ipdef.h>           // required for sockaddr_in6 (?)
#include <iphlpapi.h>           // for GetAdaptersAddresses
#include <ws2tcpip.h>
// On Windows, 'max' and 'min' are defined macros in conflict with C++ library. Let's undefine them!
#include <direct.h>
#undef max
#undef min
#endif
 
// XPlaneMP 2 - Public Header Files
#include "XPMPMultiplayer.h"
#include "XPMPAircraft.h"
#include "XPCAircraft.h"
#include "XPMPPlaneRenderer.h"
#include "XPMPRemote.h"
 
// Standard C
#include <sys/stat.h>
#include <cmath>
#include <cstdarg>
#include <cassert>
 
// Standard C++
#include <string>
#include <list>
#include <map>
#include <set>
#include <array>
#include <vector>
#include <queue>
#include <valarray>
#include <algorithm>
#include <numeric>
#include <fstream>
#include <future>
#include <thread>
#include <shared_mutex>
#include <regex>
#include <bitset>
 
// FMOD Sound, must be included before XPLMSound.h
#if INCLUDE_FMOD_SOUND + 0 >= 1
#include "fmod_errors.h"            // This one includes everything for the CORE API
#include "fmod_studio.h"
#endif
 
// X-Plane SDK
#include "XPLMUtilities.h"
#include "XPLMScenery.h"
#include "XPLMProcessing.h"
#include "XPLMGraphics.h"
#include "XPLMDataAccess.h"
#include "XPLMPlugin.h"
#include "XPLMDisplay.h"
#include "XPLMCamera.h"
#include "XPLMPlanes.h"
#include "XPLMMap.h"
#include "XPLMSound.h"
 
// XPlaneMP 2 - Internal Header Files
#include "Utilities.h"
#include "RelatedDoc8643.h"
#include "CSLModels.h"
#include "Aircraft.h"
#include "Contrail.h"
#include "2D.h"
#include "AIMultiplayer.h"
#include "Map.h"
#include "Network.h"
#include "Remote.h"
#include "Sound.h"
#if INCLUDE_FMOD_SOUND + 0 >= 1
#include "SoundFMOD.h"
#endif
 
//
// MARK: Global Configurations and variables
//
 
#define UNKNOWN_PLUGIN_NAME "(unknown)"
 
namespace XPMP2 {
 
enum ThreeWaySwitchTy : int {
    SWITCH_CFG_OFF = -1,            
    SWITCH_CFG_AUTO = 0,            
    SWITCH_CFG_ON = 1,              
};
 
struct XPMPPlaneNotifierTy {
    XPMPPlaneNotifier_f func    = nullptr;
    void*               refcon  = nullptr;
    
    XPMPPlaneNotifierTy (XPMPPlaneNotifier_f _func = nullptr, void* _refcon = nullptr) :
    func(_func), refcon(_refcon) {}
    
    bool operator == (const XPMPPlaneNotifierTy& o)
    { return func == o.func && refcon == o.refcon; }
};
 
typedef std::list<XPMPPlaneNotifierTy> listXPMPPlaneNotifierTy;
 
void XPMPSendNotification (const Aircraft& plane, XPMPPlaneNotification _notification);
 
struct GlobVars {
public:
    // Settings:
    logLevelTy      logLvl      = logINFO;
    bool            bLogMdlMatch= false;
    bool            bClampAll   = false;
    bool            bHandleDupId= false;
    
    bool            bObjReplDataRefs = false;
    bool            bObjReplTextures = true;
    std::string     pathObj8DataRefs;
    listObj8DataRefsTy listObj8DataRefs;
    
    std::string     pluginName  = UNKNOWN_PLUGIN_NAME;
    std::string     logAcronym  = UNKNOWN_PLUGIN_NAME;
 
    int (*prefsFuncInt)(const char *, const char *, int) = XPMP2::PrefsFuncIntDefault;
    listXPMPPlaneNotifierTy listObservers;
    
    std::string     pathDoc8643;
    mapDoc8643Ty    mapDoc8643;
    std::array<std::string,REL_TXT_NUM> pathRelated = {};
    std::array<mapRelatedTy,REL_TXT_NUM> mapRelated = {};
 
    mapCSLPackageTy mapCSLPkgs;
    mapCSLModelTy   mapCSLModels;
    std::string     defaultICAO = "A320";
    std::string     carIcaoType = "ZZZC";
    std::string     resourceDir;
    
    mapAcTy         mapAc;
    bool            bDrawLabels = true;
    ThreeWaySwitchTy eLabelOverride = SWITCH_CFG_AUTO;
    float           maxLabelDist = 5556.0f;
    bool            bLabelCutOffAtVisibility = true;
    float           labelFontScaling = 1.0f;
    
    bool            bHasControlOfAIAircraft = false;
    ThreeWaySwitchTy eAIOverride = SWITCH_CFG_AUTO;
 
    bool            bMapEnabled = true;
    bool            bMapLabels = true;
    mapMapLayerIDTy mapMapLayers;
    std::string     pathMapIcons;
    
    std::string     remoteMCGroup = "239.255.1.1";    // for IPv6 try "FF02::1"
    int             remotePort      = 49788;
    std::string     remoteSendIntf;
    bool            remoteAutoDiscovery() const { return remoteSendIntf.empty(); }
    int             remoteTTL       = 8;
    size_t          remoteBufSize   = 8192;
    int             remoteTxfFrequ  = 5;
    ThreeWaySwitchTy     remoteCfg       = SWITCH_CFG_AUTO;
    ThreeWaySwitchTy     remoteCfgFromIni= SWITCH_CFG_AUTO;
    RemoteStatusTy  remoteStatus    = REMOTE_OFF;
    bool RemoteIsListener() const { return remoteStatus == REMOTE_RECEIVING || remoteStatus == REMOTE_RECV_WAITING; }
    bool RemoteIsSender() const { return remoteStatus == REMOTE_SENDING || remoteStatus == REMOTE_SEND_WAITING; }
 
    // Contrails
    int             contrailAltMin_ft   = 25000;    
    int             contrailAltMax_ft   = 45000;    
    int             contrailLifeTime    = 25;       
    bool            contrailMulti       = false;    
 
    bool bSoundOnStartup = true;
    bool bSoundForceFmodInstance = false;
    bool bSoundMuteOnPause = true;
    bool bSoundAvail = false;
    float sndMasterVol = 1.0f;
    bool bSoundAutoMuted = false;
    
    int             verXPlane = -1;
    int             verXPLM = -1;
    bool            bXPUsingModernGraphicsDriver = false;
    bool            bXPNetworkedSetup = false;
    XPLMPluginID    pluginId = 0;
    std::thread::id xpThread;
 
    XPLMCameraPosition_t posCamera = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
    XPLMCameraPosition_t prevCamera = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
    float vCam_x = 0.0f, vCam_y = 0.0f, vCam_z = 0.0f;
    float prevCamera_ts = 0.0f;
 
    int             xpCycleNum = 0;
    
protected:
    XPMPPlaneID  planeId = 0;
public:
    XPMPPlaneID NextPlaneId ();
 
public:
    GlobVars (logLevelTy _logLvl = logINFO, bool _logMdlMatch = false) :
    logLvl(_logLvl), bLogMdlMatch(_logMdlMatch) {}
    void ReadConfigFile ();
    void UpdateCfgVals ();
    void ReadVersions ();
    bool UsingModernGraphicsDriver() const { return bXPUsingModernGraphicsDriver; }
    void ThisThreadIsXP()
    { xpThread = std::this_thread::get_id(); pluginId = XPLMGetMyID(); }
    bool IsXPThread() const { return std::this_thread::get_id() == xpThread; }
 
    void UpdateCameraPos ();
};
 
extern GlobVars glob;
 
}       // namespace XPMP2
 
 
 
#endif