BVB Source Codes

CRYENGINE Show GameObject.h Source code

Return Download CRYENGINE: download GameObject.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 6:9:2004   12:44 : Created by M谩rcio Martins
  12.  
  13. *************************************************************************/
  14. #ifndef __GAMEOBJECT_H__
  15. #define __GAMEOBJECT_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <IViewSystem.h>
  22. #include <IActionMapManager.h>
  23. #include <IGameObject.h>
  24. #include <CryCore/BitFiddling.h>
  25.  
  26. class CGameObjectSystem;
  27. class CGameObject;
  28. struct SEntitySchedulingProfiles;
  29.  
  30. struct SBasicSpawnParams : public ISerializable
  31. {
  32.         string name;
  33.         uint16 classId;
  34.         Vec3   pos;
  35.         Quat   rotation;
  36.         Vec3   scale;
  37.         bool   bClientActor;
  38.         uint16 nChannelId;
  39.         uint32 flags;
  40.  
  41.         virtual void SerializeWith(TSerialize ser)
  42.         {
  43.                 if (ser.GetSerializationTarget() == eST_Network)
  44.                 {
  45.                         ser.Value("name", name, 'sstr');
  46.                         ser.Value("classId", classId, 'clas');
  47.                         ser.Value("pos", pos, 'spos');
  48.                         bool bHasScale = false;
  49.                         Vec3 vScale(1.0f, 1.0f, 1.0f);
  50.  
  51.                         if (ser.IsWriting())
  52.                         {
  53.                                 bHasScale = (scale.x != 1.0f) || (scale.y != 1.0f) || (scale.z != 1.0f);
  54.                                 vScale = scale;
  55.                         }
  56.  
  57.                         //As this is used in an RMI, we can branch on bHasScale and save ourselves 96bits in the
  58.                         //      vast majority of cases, at the cost of a single bit.
  59.                         ser.Value("hasScale", bHasScale, 'bool');
  60.  
  61.                         if (bHasScale)
  62.                         {
  63.                                 //We can't just use a scalar here. Some (very few) objects have non-uniform scaling.
  64.                                 ser.Value("scale", vScale, 'sscl');
  65.                         }
  66.  
  67.                         scale = vScale;
  68.  
  69.                         ser.Value("rotation", rotation, 'srot');
  70.                         ser.Value("bClientActor", bClientActor, 'bool');
  71.                         ser.Value("nChannelId", nChannelId, 'schl');
  72.                         ser.Value("flags", flags, 'ui32');
  73.                 }
  74.                 else
  75.                 {
  76.                         ser.Value("name", name);
  77.                         ser.Value("classId", classId);
  78.                         ser.Value("pos", pos);
  79.                         ser.Value("scale", scale);
  80.                         ser.Value("rotation", rotation);
  81.                         ser.Value("bClientActor", bClientActor);
  82.                         ser.Value("nChannelId", nChannelId);
  83.                         ser.Value("flags", flags, 'ui32');
  84.                 }
  85.         }
  86. };
  87.  
  88. #if 0
  89. // deprecated and won't compile at all...
  90.  
  91. struct SDistanceChecker
  92. {
  93.         SDistanceChecker()
  94.                 : m_distanceChecker(0)
  95.                 , m_distanceCheckerTimer(0.0f)
  96.         {
  97.  
  98.         }
  99.  
  100.         void           Init(CGameObjectSystem* pGameObjectSystem, EntityId receiverId);
  101.         void           Reset();
  102.         void           Update(CGameObject& owner, float frameTime);
  103.  
  104.         ILINE EntityId GetDistanceChecker() const { return m_distanceChecker; }
  105.  
  106. private:
  107.         EntityId m_distanceChecker;
  108.         float    m_distanceCheckerTimer;
  109. };
  110. #else
  111. struct SDistanceChecker
  112. {
  113.         ILINE void     Init(CGameObjectSystem* pGameObjectSystem, EntityId receiverId) {};
  114.         ILINE void     Reset()                                                         {};
  115.         ILINE void     Update(CGameObject& owner, float frameTime)                     {};
  116.  
  117.         ILINE EntityId GetDistanceChecker() const                                      { return 0; }
  118. };
  119. #endif
  120.  
  121. struct IGOUpdateDbg;
  122.  
  123. class CGameObject : public IGameObject
  124. {
  125.         CRY_ENTITY_COMPONENT_INTERFACE(CGameObject,0xEC4E2FDCDCFF4AB3,0xA691B9CC4ECE5788)
  126.  
  127. public:
  128.         CGameObject();
  129.         virtual ~CGameObject();
  130.  
  131.         static void CreateCVars();
  132.  
  133.         void OnInitEvent();
  134.         virtual void Update(SEntityUpdateContext& ctx);
  135.  
  136.         // IEntityComponent
  137.         virtual EEntityProxy GetProxyType() const final { return ENTITY_PROXY_USER; };
  138.         virtual void         Initialize() final;
  139.         virtual void         OnShutDown() final;
  140.         virtual void         Release() final;
  141.         virtual void         ProcessEvent(SEntityEvent& event) final;
  142.         virtual uint64       GetEventMask() const final;
  143.         virtual void         GameSerialize(TSerialize ser) final;
  144.         virtual bool         NeedGameSerialize() final;
  145.         // ~IEntityComponent
  146.  
  147.         // IActionListener
  148.         virtual void OnAction(const ActionId& actionId, int activationMode, float value);
  149.         virtual void AfterAction();
  150.         // ~IActionListener
  151.  
  152.         // IGameObject
  153.         virtual bool BindToNetwork(EBindToNetworkMode);
  154.         virtual bool                  BindToNetworkWithParent(EBindToNetworkMode mode, EntityId parentId);
  155.         virtual void                  ChangedNetworkState(NetworkAspectType aspects);
  156.         virtual void                  EnableAspect(NetworkAspectType aspects, bool enable);
  157.         virtual void                  EnableDelegatableAspect(NetworkAspectType aspects, bool enable);
  158.         virtual IGameObjectExtension* QueryExtension(const char* extension) const;
  159.         virtual IGameObjectExtension* QueryExtension(IGameObjectSystem::ExtensionID id) const;
  160.  
  161.         virtual bool                  SetExtensionParams(const char* extension, SmartScriptTable params);
  162.         virtual bool                  GetExtensionParams(const char* extension, SmartScriptTable params);
  163.         virtual IGameObjectExtension* ChangeExtension(const char* extension, EChangeExtension change, TSerialize* pSpawnSerializer = nullptr);
  164.         virtual void                  SendEvent(const SGameObjectEvent&);
  165.         virtual void                  SetChannelId(uint16 id);
  166.         virtual uint16                GetChannelId() const { return m_channelId; }
  167.         virtual INetChannel*          GetNetChannel() const;
  168.         virtual bool                  CaptureView(IGameObjectView* pGOV);
  169.         virtual void                  ReleaseView(IGameObjectView* pGOV);
  170.         virtual bool                  CaptureActions(IActionListener* pAL);
  171.         virtual void                  ReleaseActions(IActionListener* pAL);
  172.         virtual bool                  CaptureProfileManager(IGameObjectProfileManager* pPH);
  173.         virtual void                  ReleaseProfileManager(IGameObjectProfileManager* pPH);
  174.         virtual void                  EnableUpdateSlot(IGameObjectExtension* pExtension, int slot);
  175.         virtual void                  DisableUpdateSlot(IGameObjectExtension* pExtension, int slot);
  176.         virtual uint8                 GetUpdateSlotEnables(IGameObjectExtension* pExtension, int slot);
  177.         virtual void                  EnablePostUpdates(IGameObjectExtension* pExtension);
  178.         virtual void                  DisablePostUpdates(IGameObjectExtension* pExtension);
  179.         virtual void                  PostUpdate(float frameTime);
  180.         virtual void                  FullSerialize(TSerialize ser);
  181.         virtual bool                  NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags);
  182.         virtual NetworkAspectType     GetNetSerializeAspects();
  183.         virtual void                  PostSerialize();
  184.         virtual void                  SetUpdateSlotEnableCondition(IGameObjectExtension* pExtension, int slot, EUpdateEnableCondition condition);
  185.         virtual bool                  IsProbablyVisible();
  186.         virtual bool                  IsProbablyDistant();
  187.         virtual bool                  SetAspectProfile(EEntityAspects aspect, uint8 profile, bool fromNetwork);
  188.         virtual uint8                 GetAspectProfile(EEntityAspects aspect);
  189.         virtual IWorldQuery*          GetWorldQuery();
  190.         virtual IMovementController*  GetMovementController();
  191.         virtual IGameObjectExtension* GetExtensionWithRMIBase(const void* pBase);
  192.         virtual void                  AttachDistanceChecker();
  193.         virtual void                  ForceUpdate(bool force);
  194.         virtual void                  ForceUpdateExtension(IGameObjectExtension* pExt, int slot);
  195.         virtual void                  Pulse(uint32 pulse);
  196.         virtual void                  RegisterAsPredicted();
  197.         virtual void                  RegisterAsValidated(IGameObject* pGO, int predictionHandle);
  198.         virtual int                   GetPredictionHandle();
  199.         virtual void                  RequestRemoteUpdate(NetworkAspectType aspectMask);
  200.         virtual void                  RegisterExtForEvents(IGameObjectExtension* piExtention, const int* pEvents, const int numEvents);
  201.         virtual void                  UnRegisterExtForEvents(IGameObjectExtension* piExtention, const int* pEvents, const int numEvents);
  202.  
  203.         virtual void                  EnablePhysicsEvent(bool enable, int event)
  204.         {
  205.                 if (enable)
  206.                         m_enabledPhysicsEvents = m_enabledPhysicsEvents | event;
  207.                 else
  208.                         m_enabledPhysicsEvents = m_enabledPhysicsEvents & (~event);
  209.         }
  210.         virtual bool WantsPhysicsEvent(int event) { return (m_enabledPhysicsEvents & event) != 0; };
  211.         virtual void SetNetworkParent(EntityId id);
  212.  
  213.         virtual bool IsJustExchanging() { return m_justExchanging; };
  214.         virtual bool SetAIActivation(EGameObjectAIActivationMode mode);
  215.         virtual void SetAutoDisablePhysicsMode(EAutoDisablePhysicsMode mode);
  216.         virtual void EnablePrePhysicsUpdate(EPrePhysicsUpdate updateRule);
  217.         // needed for debug
  218.         virtual bool ShouldUpdate();
  219.         // ~IGameObject
  220.  
  221.         virtual void     UpdateView(SViewParams& viewParams);
  222.         virtual void     PostUpdateView(SViewParams& viewParams);
  223.         virtual void     HandleEvent(const SGameObjectEvent& evt);
  224.         virtual bool     CanUpdateView() const { return m_pViewDelegate != NULL; }
  225.         IGameObjectView* GetViewDelegate()     { return m_pViewDelegate; }
  226.  
  227. #if GAME_OBJECT_SUPPORTS_CUSTOM_USER_DATA
  228.         virtual void* GetUserData() const;
  229.         virtual void  SetUserData(void* ptr);
  230. #endif
  231.  
  232.         bool IsAspectDelegatable(NetworkAspectType aspect);
  233.  
  234.         //----------------------------------------------------------------------
  235.         // Network related functions
  236.  
  237.         // we have gained (or lost) control of this object
  238.         virtual void         SetAuthority(bool auth);
  239.         virtual void         InitClient(int channelId);
  240.         virtual void         PostInitClient(int channelId);
  241.  
  242.         ISerializableInfoPtr GetSpawnInfo();
  243.  
  244.         NetworkAspectType    GetEnabledAspects() const { return m_enabledAspects; }
  245.         uint8                GetDefaultProfile(EEntityAspects aspect);
  246.  
  247.         // called from CGameObject::BoundObject -- we have become bound on a client
  248.         void         BecomeBound()                { m_isBoundToNetwork = true; }
  249.         bool         IsBoundToNetwork()           { return m_isBoundToNetwork; }
  250.  
  251.         void         FlushActivatableExtensions() { FlushExtensions(false); }
  252.  
  253.         void         PostRemoteSpawn();
  254.  
  255.         void         GetMemoryUsage(ICrySizer* s) const;
  256.  
  257.         static void  UpdateSchedulingProfiles();
  258.  
  259.         virtual void DontSyncPhysics() { m_bNoSyncPhysics = true; }
  260.  
  261.         void         AcquireMutex();
  262.         void         ReleaseMutex();
  263.  
  264. private:
  265.         IActionListener*           m_pActionDelegate;
  266.  
  267.         IGameObjectView*           m_pViewDelegate;
  268.         IView*                     m_pView;
  269.  
  270.         IGameObjectProfileManager* m_pProfileManager;
  271.  
  272.         uint8                      m_profiles[NUM_ASPECTS];
  273.  
  274. #if GAME_OBJECT_SUPPORTS_CUSTOM_USER_DATA
  275.         void* m_pUserData;
  276. #endif
  277.  
  278.         // Need a mutex to defend shutdown against event handling.
  279.         CryMutex m_mutex;
  280.  
  281.         template<class T> bool DoGetSetExtensionParams(const char* extension, SmartScriptTable params);
  282.  
  283.         // any extensions (extra GameObject functionality) goes here
  284.         struct SExtension
  285.         {
  286.                 SExtension()
  287.                         : pExtension()
  288.                         , id(0)
  289.                         , refCount(0)
  290.                         , activated(false)
  291.                         , sticky(false)
  292.                         , postUpdate(false)
  293.                         , flagUpdateWhenVisible(0)
  294.                         , flagUpdateWhenInRange(0)
  295.                         , flagUpdateCombineOr(0)
  296.                         , flagDisableWithAI(0)
  297.                         , flagNeverUpdate(0)
  298.                         , eventReg(0)
  299.                 {
  300.                         uint32 slotbit = 1;
  301.                         for (uint32 i = 0; i < MAX_UPDATE_SLOTS_PER_EXTENSION; ++i)
  302.                         {
  303.                                 updateEnables[i] = forceEnables[i] = 0;
  304.                                 flagDisableWithAI += slotbit;
  305.                                 slotbit <<= 1;
  306.                         }
  307.                 }
  308.  
  309.                 // extension by flag event registration
  310.                 uint64                         eventReg;
  311.                 IGameObjectExtension*        pExtension;
  312.                 IGameObjectSystem::ExtensionID id;
  313.                 // refCount is the number of AcquireExtensions pending ReleaseExtensions
  314.                 uint8                          refCount;
  315.                 uint8                          updateEnables[MAX_UPDATE_SLOTS_PER_EXTENSION];
  316.                 uint8                          forceEnables[MAX_UPDATE_SLOTS_PER_EXTENSION];
  317.                 // upper layers only get to activate/deactivate extensions
  318.                 uint8                          flagUpdateWhenVisible: MAX_UPDATE_SLOTS_PER_EXTENSION;
  319.                 uint8                          flagUpdateWhenInRange: MAX_UPDATE_SLOTS_PER_EXTENSION;
  320.                 uint8                          flagUpdateCombineOr: MAX_UPDATE_SLOTS_PER_EXTENSION;
  321.                 uint8                          flagDisableWithAI: MAX_UPDATE_SLOTS_PER_EXTENSION;
  322.                 uint8                          flagNeverUpdate: MAX_UPDATE_SLOTS_PER_EXTENSION;
  323.                 bool                           activated  : 1;
  324.                 bool                           sticky     : 1;
  325.                 bool                           postUpdate : 1;
  326.  
  327.                 bool operator<(const SExtension& rhs) const
  328.                 {
  329.                         return id < rhs.id;
  330.                 }
  331.  
  332.                 void GetMemoryUsage(ICrySizer* pSizer) const
  333.                 {
  334.                         pSizer->AddObject(pExtension);
  335.                 }
  336.         };
  337.  
  338.         static const int  MAX_ADDING_EXTENSIONS = 8;
  339.         static SExtension m_addingExtensions[MAX_ADDING_EXTENSIONS];
  340.         static int        m_nAddingExtension;
  341.  
  342.         typedef std::vector<SExtension> TExtensions;
  343.         TExtensions       m_extensions;
  344.         uint16            m_channelId;
  345.         NetworkAspectType m_enabledAspects;
  346.         NetworkAspectType m_delegatableAspects;
  347.         bool              m_inRange             : 1;
  348.         bool              m_isBoundToNetwork    : 1;
  349.         bool              m_justExchanging      : 1;
  350.         bool              m_bVisible            : 1;
  351.         bool              m_bPrePhysicsEnabled  : 1;
  352.         bool              m_bPhysicsDisabled    : 1;
  353.         bool              m_bNoSyncPhysics      : 1;
  354.         bool              m_bNeedsNetworkRebind : 1;
  355.         bool              m_bOnInitEventCalled  : 1;
  356.         enum EUpdateState
  357.         {
  358.                 eUS_Visible_Close = 0,
  359.                 eUS_Visible_FarAway,
  360.                 eUS_NotVisible_Close,
  361.                 eUS_NotVisible_FarAway,
  362.                 eUS_CheckVisibility_Close,
  363.                 eUS_CheckVisibility_FarAway,
  364.                 eUS_COUNT_STATES,
  365.                 eUS_INVALID = eUS_COUNT_STATES
  366.         };
  367.         uint                    m_updateState: CompileTimeIntegerLog2_RoundUp<eUS_COUNT_STATES>::result;
  368.         uint                    m_aiMode: CompileTimeIntegerLog2_RoundUp<eGOAIAM_COUNT_STATES>::result;
  369.         uint                    m_physDisableMode: CompileTimeIntegerLog2_RoundUp<eADPM_COUNT_STATES>::result;
  370.  
  371.         IGameObjectExtension* m_pGameObjectExtensionCachedKey;
  372.         SExtension*             m_pGameObjectExtensionCachedValue;
  373.         void        ClearCache() { m_pGameObjectExtensionCachedKey = nullptr; m_pGameObjectExtensionCachedValue = nullptr; }
  374.         SExtension* GetExtensionInfo(IGameObjectExtension* pExt)
  375.         {
  376.                 CRY_ASSERT(pExt);
  377.                 if (m_pGameObjectExtensionCachedKey == pExt)
  378.                 {
  379.                         CRY_ASSERT(m_pGameObjectExtensionCachedValue->pExtension == pExt);
  380.                         return m_pGameObjectExtensionCachedValue;
  381.                 }
  382.                 for (TExtensions::iterator iter = m_extensions.begin(); iter != m_extensions.end(); ++iter)
  383.                 {
  384.                         if (iter->pExtension == pExt)
  385.                         {
  386.                                 m_pGameObjectExtensionCachedKey = iter->pExtension;
  387.                                 m_pGameObjectExtensionCachedValue = &*iter;
  388.                                 return &*iter;
  389.                         }
  390.                 }
  391.                 return 0;
  392.         }
  393.  
  394.         enum EUpdateStateEvent
  395.         {
  396.                 eUSE_BecomeVisible = 0,
  397.                 eUSE_BecomeClose,
  398.                 eUSE_BecomeFarAway,
  399.                 eUSE_Timeout,
  400.                 eUSE_COUNT_EVENTS,
  401.         };
  402.         float                            m_updateTimer;
  403.  
  404.         SDistanceChecker                 m_distanceChecker;
  405.  
  406.         int                              m_enabledPhysicsEvents;
  407.         int                              m_forceUpdate;
  408.         int                              m_predictionHandle;
  409.  
  410.         EPrePhysicsUpdate                m_prePhysicsUpdateRule;
  411.  
  412.         const SEntitySchedulingProfiles* m_pSchedulingProfiles;
  413.         uint32                           m_currentSchedulingProfile;
  414.         EntityId                         m_cachedParentId;
  415.  
  416.         void FlushExtensions(bool includeStickyBits);
  417.         void DoInvokeRMI(_smart_ptr<CRMIBody> pBody, unsigned, int);
  418.         bool ShouldUpdateSlot(const SExtension* pExt, uint32 slot, uint32 slotbit, bool checkAIDisable);
  419.         void EvaluateUpdateActivation();
  420.         void DebugUpdateState();
  421.         bool ShouldUpdateAI();
  422.         void RemoveExtension(const TExtensions::iterator& iter);
  423.         void UpdateStateEvent(EUpdateStateEvent evt);
  424.         bool TestIsProbablyVisible(uint state);
  425.         bool TestIsProbablyDistant(uint state);
  426.         bool DoSetAspectProfile(EEntityAspects aspect, uint8 profile, bool fromNetwork);
  427.         void SetActivation(bool activate);
  428.         void SetPhysicsDisable(bool disablePhysics);
  429.  
  430.         void UpdateSchedulingProfile();
  431.  
  432.         static const float        UpdateTimeouts[eUS_COUNT_STATES];
  433.         static const EUpdateState UpdateTransitions[eUS_COUNT_STATES][eUSE_COUNT_EVENTS];
  434.         static const char*        UpdateNames[eUS_COUNT_STATES];
  435.         static const char*        EventNames[eUSE_COUNT_EVENTS];
  436.  
  437.         static CGameObjectSystem* m_pGOS;
  438. };
  439.  
  440. #endif //__GAMEOBJECT_H__
  441.  
downloadGameObject.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