BVB Source Codes

CRYENGINE Show BreakReplicator_Simple.h Source code

Return Download CRYENGINE: download BreakReplicator_Simple.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __BREAKREPLICATOR_SIMPLE_H__
  4. #define __BREAKREPLICATOR_SIMPLE_H__
  5.  
  6. #pragma once
  7.  
  8. #include "BreakReplicator.h"
  9. #include "SerializeBits.h"
  10. #include "ActionGame.h"
  11.  
  12. #if NET_USE_SIMPLE_BREAKAGE
  13.  
  14. struct SBreakEvent;
  15. struct IProtocolBuilder;
  16. //class CBitArray;
  17. //class BreakStream;
  18.  
  19. class CObjectIdentifier
  20. {
  21. public:
  22.         enum ObjType { k_unknown = 0, k_entity, k_static_entity };
  23.  
  24. public:
  25.         void             Reset();
  26.         void             SerializeWith(CBitArray& array, bool includeObjCenter);
  27.         void             CreateFromPhysicalEntity(const EventPhysMono* pMono);
  28.         IPhysicalEntity* FindPhysicalEntity();
  29.         IPhysicalEntity* GetPhysicsFromHoldingEntity();
  30.  
  31. public:
  32.         ObjType m_objType;
  33.  
  34.         Vec3    m_objCenter;
  35.         uint32  m_objHash;
  36.  
  37.         // When a static is first broken, the remaining pieces get placed into a temporary, holding
  38.         // entity. This points to that entity. But we continue to identify the static object via
  39.         // the pos+cent+vol+hash method, and then resolve the holding entity on the client through
  40.         // the corresponding CObjectIdentifier. That way we dont have to have a net-bound entity, which
  41.         // clogs the internal message queue in the low level network code.
  42.         EntityId m_holdingEntity;
  43. };
  44.  
  45. /*
  46.    =======================================================================
  47.    Plane BreakStream
  48.    =======================================================================
  49.  */
  50.  
  51. class BreakStream : public IBreakDescriptionInfo
  52. {
  53. public:
  54.         enum EMode {k_invalid = 0, k_recording, k_playing, k_finished, k_numModes};
  55.         enum EBreakType { k_unknown = 0, k_partBreak, k_planeBreak, k_deformBreak, k_numTypes };
  56.  
  57. public:
  58.         BreakStream();
  59.         virtual ~BreakStream();
  60.         virtual void Init(EMode mode);
  61.  
  62.         /* IBreakDescriptionInfo */
  63.         virtual void GetAffectedRegion(AABB& aabb);
  64.         virtual void AddSendables(INetSendableSink* pSink, int32 brkId) {}
  65.         /* IBreakDescriptionInfo */
  66.  
  67.         virtual void SerialiseSimpleBreakage(TSerialize ser);
  68.  
  69.         void         SerializeWith_Begin(CBitArray& array, bool includeObjCenter);
  70.         virtual void SerializeWith(CBitArray& array)                                   {}
  71.  
  72.         virtual bool OnCreatePhysEntityPart(const EventPhysCreateEntityPart* pEvent)   { return pEvent->pEntity == m_pent; }
  73.         virtual bool OnRemovePhysEntityParts(const EventPhysRemoveEntityParts* pEvent) { return pEvent->pEntity == m_pent; }
  74.         virtual bool OnJointBroken(const EventPhysJointBroken* pEvent)                 { return pEvent->pEntity[0] == m_pent; }
  75.         virtual void OnEndFrame();
  76.         virtual void OnSpawnEntity(IEntity* pEntity)                                   {}
  77.         virtual void OnSend(SNetBreakDescription& desc)                                {}
  78.         virtual void Playback()                                                        {}
  79.         virtual bool IsWaitinOnRenderMesh()                                            { return false; }
  80.         virtual bool IsRenderMeshReady()                                               { return true; }
  81.  
  82.         void         LogHostMigrationInfo();
  83.  
  84.         bool         CanSendPayload();
  85.         bool         IsIdentifierEqual(const CObjectIdentifier& identifier);
  86.  
  87. public:
  88.  
  89.         INetBreakageSimplePlaybackPtr m_collector;  // Low level class used to collect any spawned entities that need to be net bound
  90.  
  91.         CObjectIdentifier             m_identifier; // Shame to have a full copy here
  92.         IPhysicalEntity*              m_pent;       // The active ent we are recording
  93.  
  94.         uint16                        m_breakIdx;    // Global break index
  95.         uint16                        m_subBreakIdx; // Incrementing break idx for a particular entity (breaks for one entity should be done in this order)
  96.         uint8                         m_mode;        /* EMode */
  97.         uint8                         m_type;
  98.         uint8                         m_numFramesLeft;        // Count down to being able to send, or finish playback
  99.         uint8                         m_invalidFindCount;     // If the physics entity can't be found, increase this counter
  100.         uint8                         m_waitForDependent;     // How many frames we waited for the dependency subIndex (on clients)
  101.         uint8                         m_logHostMigrationInfo; // On playback, log host migration info for this stream;
  102. };
  103.  
  104. class PlaneBreak : public BreakStream
  105. {
  106. public:
  107.         PlaneBreak();
  108.         virtual ~PlaneBreak();
  109.  
  110.         virtual void SerializeWith(CBitArray& array);
  111.  
  112.         virtual void OnSend(SNetBreakDescription& desc);
  113.  
  114.         virtual void Playback();
  115.  
  116.         virtual bool IsWaitinOnRenderMesh();
  117.  
  118.         virtual bool IsRenderMeshReady();
  119.  
  120. public:
  121.         SBreakEvent m_be;
  122.         IStatObj*   m_pStatObj;
  123. };
  124.  
  125. /*
  126.    =====================================================================
  127.    SClientGlassBreak
  128.    =====================================================================
  129.    used to inform the server that the client
  130.    broke the glass
  131.  */
  132.  
  133. struct SClientGlassBreak
  134. {
  135.         void SerializeWith(TSerialize ser)
  136.         {
  137.                 CBitArray array(&ser);
  138.                 m_planeBreak.SerializeWith(array);
  139.                 if (!array.IsReading())
  140.                         array.WriteToSerializer();
  141.         }
  142.  
  143.         PlaneBreak m_planeBreak;
  144. };
  145.  
  146.         #define NET_MAX_PENDING_BREAKAGE_STREAMS 1024
  147.  
  148. class CBreakReplicator : public CNetMessageSinkHelper<CBreakReplicator, INetMessageSink>, public IBreakReplicator, public ISystemEventListener
  149. {
  150. public:
  151.         bool m_bDefineProtocolMode_server;
  152.         void DefineProtocol(IProtocolBuilder* pBuilder);
  153. public:
  154.         CBreakReplicator(CGameContext* pGameCtx);
  155.         virtual ~CBreakReplicator();
  156.         void Reset();
  157.  
  158.         // ISystemEventListener
  159.         virtual void                              OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam);
  160.  
  161.         bool                                      OnCreatePhysEntityPart(const EventPhysCreateEntityPart* pEvent);
  162.         bool                                      OnRemovePhysEntityParts(const EventPhysRemoveEntityParts* pEvent);
  163.         bool                                      OnRevealEntityPart(const EventPhysRevealEntityPart* pEvent);
  164.         bool                                      OnJointBroken(const EventPhysJointBroken* pEvent);
  165.         void                                      BeginRecordingPlaneBreak(const SBreakEvent& be, EventPhysMono* pMono);
  166.         void                                      BeginRecordingDeforminBreak(const SBreakEvent& be, EventPhysMono* pMono);
  167.         void                                      OnBrokeSomething(const SBreakEvent& be, EventPhysMono* pMono, bool isPlane);
  168.  
  169.         void                                      OnEndFrame();
  170.         void                                      OnSpawn(IEntity* pEntity, SEntitySpawnParams& params);
  171.         void                                      OnSpawn(IEntity* pEntity, IPhysicalEntity* pPhysEntity, IPhysicalEntity* pSrcPhysEntity);
  172.         void                                      OnRemove(IEntity* pEntity);
  173.         void                                      RemoveEntity(IEntity* pEntity);
  174.         void                                      SendPayloads();
  175.         void                                      PushPlayback(BreakStream* pStream);
  176.         int                                       PlaybackStream(BreakStream* pStream);
  177.         void                                      PlaybackBreakage();
  178.         void*                                     ReceiveSimpleBreakage(TSerialize ser);        // Serialise a received a stream
  179.         void*                                     SerialiseBreakage(TSerialize ser, BreakStream* pStream);
  180.         void                                      PlaybackSimpleBreakage(void* userData, INetBreakageSimplePlaybackPtr pBreakage); // Callback from low levek to push a stream for pending playback
  181.         virtual const EventPhysRemoveEntityParts* GetRemovePartEvents(int& iNumEvents);
  182.  
  183.         static void                               SerialisePosition(CBitArray& array, Vec3& pos, float range, int numBits);
  184.  
  185.         int                                       PushBackNewStream(const EventPhysMono* pMono, BreakStream* pStream);
  186.         int                                       GetBreakIndex(const EventPhysMono* pMono, bool add);
  187.         int                                       GetIdentifier(CObjectIdentifier* identifier, const IPhysicalEntity* pent, bool add);
  188.  
  189.         void                                      OnReuse(IEntity* pEntity, SEntitySpawnParams& params)            {}
  190.         void                                      OnStartFrame()                                                   {}
  191.         void                                      PlaybackBreakage(int breakId, INetBreakagePlaybackPtr pBreakage) { PlaybackBreakage(); }
  192.         void                                      GetMemoryStatistics(ICrySizer* s)                                {}
  193.  
  194.         static CBreakReplicator*                  Get()                                                            { return m_pThis; }
  195.         static IBreakReplicator*                  GetIBreakReplicator()                                            { return static_cast<IBreakReplicator*>(m_pThis); }
  196.         static void                               RegisterClasses();
  197.         static int                                OnRevealEntityPart(const EventPhys* pEvent);
  198.         static int                                OnJointBroken(const EventPhys* pEvent);
  199.         static int                                OnCreatePhysEntityPart(const EventPhys* pEvent);
  200.         static int                                OnRemovePhysEntityParts(const EventPhys* pEvent);
  201.  
  202.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE_WITHOUT_SEND(SvRecvGlassBreak, SClientGlassBreak);
  203.  
  204. public:
  205.  
  206.         // A list of streams, indexed by the breakIdx
  207.         DynArray<BreakStream*>                  m_streams;
  208.  
  209.         DynArray<CObjectIdentifier>             m_identifiers; // We need to keep a list of identifiers on all machines for entity syncing purposes (instead of using CryNetwork)
  210.  
  211.         int                                     m_activeStartIdx; // The index of the first active stream that is recording/playing
  212.  
  213.         int                                     m_numPendingStreams;
  214.         BreakStream*                            m_pendingStreams[NET_MAX_PENDING_BREAKAGE_STREAMS]; // For playback, only pop one stream at a time for a physics entity
  215.  
  216.         std::vector<EventPhysRemoveEntityParts> m_removePartEvents;
  217.         std::vector<EntityId>                   m_entitiesToRemove;
  218.  
  219.         float                                   m_timeSinceLevelLoaded;
  220.  
  221.         static CBreakReplicator*                m_pThis;
  222.         static int                              m_accurateWorldPosNumBits;
  223.         static int                              m_inaccurateWorldPosNumBits;
  224. };
  225.  
  226. #endif // NET_USE_SIMPLE_BREAKAGE
  227.  
  228. #endif
  229.  
downloadBreakReplicator_Simple.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