BVB Source Codes

CRYENGINE Show NetMsgDispatcher.h Source code

Return Download CRYENGINE: download NetMsgDispatcher.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   NetMsgDispatcher.h
  5. //  Description: Central Hub for bidirectional communication of simple messages
  6. //  Uses: Can be used to send messages from client to server and vice versa.
  7. //  - Thread Safety:
  8. //              * Listeners
  9. //                      - Are all local.
  10. //                      - Registration / de-registration / OnMessage callback must happen on the same thread
  11. //              * Received messages through the network (m_receivedNetMsgQueue)
  12. //                      - Thread safe via m_criticalSectionReceivedQueue
  13. //              * Messages sent through the network
  14. //                      - Only the stats are not thread safe (but they are debug only)
  15. //                      - If needed they could be guarded but currently all messages are sent from main thread (Flow Graph)
  16. // -------------------------------------------------------------------------
  17. //  History: Dario Sancho. 15.10.2014. Created
  18. //
  19. ////////////////////////////////////////////////////////////////////////////
  20.  
  21. #ifndef __NETMSGDISPATCHER__
  22. #define __NETMSGDISPATCHER__
  23.  
  24. #if _MSC_VER > 1000
  25.         #pragma once
  26. #endif
  27.  
  28. #include <CryCore/Containers/CryListenerSet.h>
  29. #include <CryNetwork/INetwork.h>
  30.  
  31. #if !defined(_RELEASE)
  32.         #define NET_MSG_DISPATCHER_LOG(...) CNetMessageDistpatcher::Log(stack_string().Format("[NetMsg] " __VA_ARGS__).c_str())
  33. #else
  34.         #define NET_MSG_DISPATCHER_LOG(...) ((void)0)
  35. #endif
  36.  
  37. // ------------------------------------------------------------------------
  38. // Data to send over the network
  39. // ------------------------------------------------------------------------
  40. struct SNetMsgData : public ISerializable
  41. {
  42.         enum ELocation
  43.         {
  44.                 eL_Server = 0,
  45.                 eL_DedicatedServer,
  46.                 eL_Client,
  47.                 eL_Unknown,
  48.         };
  49.  
  50.         enum ETarget
  51.         {
  52.                 eT_Default = 0,
  53.                 eT_All,
  54.                 eT_Invalid
  55.         };
  56.  
  57.         SNetMsgData() : src(eL_Unknown), tgt(eT_Invalid) {}
  58.         SNetMsgData(ELocation src_, ETarget tgt_, const string& key_, const string& value_) : src(src_), tgt(tgt_), key(key_), value(value_) {}
  59.  
  60.         ELocation src;
  61.         ETarget   tgt;
  62.         string    key, value;
  63.  
  64.         virtual void SerializeWith(TSerialize ser)
  65.         {
  66.                 ser.EnumValue("src", src, eL_Server, eL_Unknown);
  67.                 ser.EnumValue("tgt", tgt, eT_Default, eT_All);
  68.                 ser.Value("key", key, 'stab'); // 'stab' we assume here that there are not many different string values
  69.                 ser.Value("value", value);     // 'stab' we assume here that there are not many different string values
  70.         }
  71.  
  72.         static ETarget ConvertTargetIntToEnum(int i)
  73.         {
  74.                 if (i >= eT_Default && i <= eT_All)
  75.                 {
  76.                         return static_cast<ETarget>(i);
  77.                 }
  78.                 else
  79.                 {
  80.                         CryWarning(VALIDATOR_MODULE_NETWORK, VALIDATOR_ERROR, "Invalid conversion from int to ETarget");
  81.                         return eT_Invalid;
  82.                 }
  83.         }
  84.  
  85.         const char* DbgTranslateTargetToString() const
  86.         {
  87.                 return tgt == eT_Default ? "Default" :
  88.                        tgt == eT_All ? "All" :
  89.                        tgt == eT_Invalid ? "Invalid" :
  90.                        "Error";
  91.         }
  92.  
  93.         const char* DbgTranslateSourceToString() const
  94.         {
  95.                 return src == SNetMsgData::eL_Server ? "Server" :
  96.                        src == SNetMsgData::eL_DedicatedServer ? "Dedicated Server" :
  97.                        src == SNetMsgData::eL_Client ? "Client" :
  98.                        src == SNetMsgData::eL_Unknown ? "Unknown" :
  99.                        "Error";
  100.         }
  101. };
  102.  
  103. // ------------------------------------------------------------------------
  104. // INetMsgListener
  105. // ------------------------------------------------------------------------
  106. struct INetMsgListener
  107. {
  108.         virtual void OnMessage(const SNetMsgData& data) = 0;
  109. };
  110.  
  111. // ------------------------------------------------------------------------
  112. // NetMsgDispatcher
  113. // ------------------------------------------------------------------------
  114.  
  115. class CNetMessageDistpatcher :
  116.         public CNetMessageSinkHelper<CNetMessageDistpatcher, INetMessageSink>
  117. {
  118. public:
  119.         CNetMessageDistpatcher();
  120.         virtual ~CNetMessageDistpatcher();
  121.  
  122.         // INetMessageSink
  123.         virtual void DefineProtocol(IProtocolBuilder* pBuilder) override;
  124.         // ~INetMessageSink
  125.  
  126.         void Update();
  127.         void SendMessage(const SNetMsgData& msg);
  128.  
  129.         void RegisterListener(INetMsgListener* pListener, const char* name = NULL);
  130.         void UnRegisterListener(INetMsgListener* pListener);
  131.         void ClearListeners();
  132.         void ClearStatsCommand() { m_stats.ClearStats(); }
  133.  
  134.         // exposed methods that can be called through the network
  135.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(OnIncomingMessage, SNetMsgData);
  136.  
  137.         // static functions
  138.         static SNetMsgData::ELocation GetLocation();
  139.         static const char*            DbgTranslateLocationToString();
  140.         static void                   Log(const char* szMessage);
  141.  
  142.         // ------------------------------------------------------------------------
  143.         class CNetStats
  144.         {
  145.                 struct SStats
  146.                 {
  147.                         SStats() { Clear(); }
  148.                         void Clear()           { m_max = 0; m_total = 0; m_cntInFrame = 0; }
  149.                         void ClearFrame()      { m_cntInFrame = 0; }
  150.                         void Add(uint32 value) { m_total += value; m_cntInFrame += value; m_max = m_cntInFrame > m_max ? m_cntInFrame : m_max; }
  151.  
  152.                         uint32 m_cntInFrame, m_max;
  153.                         uint64 m_total;
  154.                 };
  155.  
  156.         public:
  157.                 enum ETypes { eT_Sent = 0, eT_Received };
  158.                 CNetStats() { ClearStats(); }
  159.  
  160.                 void          Add(ETypes type, uint32 value);
  161.                 void          ClearFrameStats()    { m_sent.ClearFrame(); }
  162.                 void          ClearStats()         { m_sent.Clear(); }
  163.                 const SStats& GetSentStats() const { return m_sent; }
  164.  
  165.         private:
  166.                 SStats m_sent;
  167.         };
  168.  
  169. private:
  170.         struct CVars
  171.         {
  172.                 static int  net_netMsgDispatcherDebug;
  173.                 static int  net_netMsgDispatcherLogging;
  174.                 static int  net_netMsgDispatcherWarnThreshold;
  175.                 static void Register();
  176.                 static void UnRegister();
  177.                 static void ClearStatsCommand(IConsoleCmdArgs* pArgs);
  178.         };
  179.  
  180.         enum ENetMsgSrc { eNMS_Local = 0, eNMS_Network };
  181.         void DispatchQueuedMessagesToLocalListeners();
  182.         void AddReceivedNetMsgToQueue(const SNetMsgData& msg, ENetMsgSrc src);
  183.         void DebugDraw();
  184.  
  185.         typedef CListenerSet<INetMsgListener*> TNetMsgListener;
  186.         TNetMsgListener                m_listeners;
  187.         std::vector<SNetMsgData>       m_receivedNetMsgQueue;
  188.         std::vector<SNetMsgData>       m_copyOfReceivedNetMsgQueue;
  189.  
  190.         CryCriticalSectionNonRecursive m_criticalSectionReceivedQueue;
  191.         CNetStats                      m_stats;
  192. };
  193.  
  194. #endif
  195.  
downloadNetMsgDispatcher.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top