BVB Source Codes

CRYENGINE Show ActionController.h Source code

Return Download CRYENGINE: download ActionController.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5. #ifndef __ACTIONCONTROLLER_H__
  6. #define __ACTIONCONTROLLER_H__
  7.  
  8. #include "ICryMannequin.h"
  9. struct SScopeContext;
  10. class CActionScope;
  11.  
  12. #ifdef _RELEASE
  13.         #define CRYMANNEQUIN_WARN_ABOUT_VALIDITY() 0
  14. #else
  15.         #define CRYMANNEQUIN_WARN_ABOUT_VALIDITY() 1
  16. #endif
  17.  
  18. enum EFlushMethod
  19. {
  20.         FM_Normal,
  21.         FM_NormalLeaveAnimations,
  22.         FM_Failure,
  23. };
  24.  
  25. ILINE uint64 GetLeastSignificantBit(ActionScopes scopeMask)
  26. {
  27.         const uint64 mask = (uint64)scopeMask;
  28.         static const uint64 MultiplyDeBruijnBitPosition[64] =
  29.         {
  30.                 0,  1,  2, 53,  3,  7, 54, 27,
  31.                 4, 38, 41,  8, 34, 55, 48, 28,
  32.                 62,  5, 39, 46, 44, 42, 22,  9,
  33.                 24, 35, 59, 56, 49, 18, 29, 11,
  34.                 63, 52,  6, 26, 37, 40, 33, 47,
  35.                 61, 45, 43, 21, 23, 58, 17, 10,
  36.                 51, 25, 36, 32, 60, 20, 57, 16,
  37.                 50, 31, 19, 15, 30, 14, 13, 12,
  38.         };
  39.         return MultiplyDeBruijnBitPosition[((uint64)((mask & ~(mask-1)) * 0x022fdd63cc95386d)) >> 58];
  40. }
  41.  
  42. class CActionController : public IActionController
  43. {
  44. public:
  45.         typedef std::vector<CActionController*> TActionControllerList;
  46.  
  47.         CActionController(IEntity* pEntity, SAnimationContext& context);
  48.  
  49.         // -- IActionController implementation --------------------------------------
  50.  
  51.         ~CActionController();
  52.  
  53.         virtual void   OnEvent(const SGameObjectEvent& event) override;
  54.         virtual void   OnAnimationEvent(ICharacterInstance* pCharacter, const AnimEventInstance& event) override;
  55.  
  56.         virtual void   Reset() override;
  57.         virtual void   Flush() override;
  58.  
  59.         virtual uint32 GetTotalScopes() const override
  60.         {
  61.                 return m_scopeCount;
  62.         }
  63.         virtual void SetScopeContext(uint32 scopeContextID, IEntity& entity, ICharacterInstance* pCharacter, const IAnimationDatabase* animDatabase) override;
  64.         virtual void ClearScopeContext(uint32 scopeContextID, bool flushAnimations = true) override;
  65.  
  66.         virtual bool IsScopeActive(uint32 scopeID) const override
  67.         {
  68.                 CRY_ASSERT_MESSAGE((scopeID < m_scopeCount), "Invalid scope id");
  69.  
  70.                 return ((m_activeScopes & BIT64(scopeID)) != 0);
  71.         }
  72.         virtual ActionScopes GetActiveScopeMask() const override
  73.         {
  74.                 return m_activeScopes;
  75.         }
  76.  
  77.         virtual IEntity& GetEntity() const override
  78.         {
  79.                 CRY_ASSERT(m_cachedEntity);
  80.                 return *m_cachedEntity;
  81.         }
  82.  
  83.         virtual EntityId GetEntityId() const override
  84.         {
  85.                 return m_entityId;
  86.         }
  87.  
  88.         virtual IScope*       GetScope(uint32 scopeID) override;
  89.         virtual const IScope* GetScope(uint32 scopeID) const override;
  90.  
  91.         virtual uint32        GetScopeID(const char* name) const override
  92.         {
  93.                 int scopeID = m_context.controllerDef.m_scopeIDs.Find(name);
  94.  
  95.                 if (scopeID >= 0)
  96.                 {
  97.                         return scopeID;
  98.                 }
  99.                 else
  100.                 {
  101.                         return SCOPE_ID_INVALID;
  102.                 }
  103.         }
  104.  
  105.         virtual TagID GetGlobalTagID(uint32 crc) const override
  106.         {
  107.                 return GetContext().state.GetDef().Find(crc);
  108.         }
  109.  
  110.         virtual TagID GetFragTagID(FragmentID fragID, uint32 crc) const override
  111.         {
  112.                 if (fragID != FRAGMENT_ID_INVALID)
  113.                 {
  114.                         return m_context.controllerDef.GetFragmentTagDef(fragID)->Find(crc);
  115.                 }
  116.                 return TAG_ID_INVALID;
  117.         }
  118.  
  119.         virtual FragmentID GetFragID(uint32 crc) const override
  120.         {
  121.                 return m_context.controllerDef.m_fragmentIDs.Find(crc);
  122.         }
  123.  
  124.         virtual const CTagDefinition* GetTagDefinition(FragmentID fragID) const override
  125.         {
  126.                 if (fragID != FRAGMENT_ID_INVALID)
  127.                 {
  128.                         return m_context.controllerDef.GetFragmentTagDef(fragID);
  129.                 }
  130.                 return NULL;
  131.         }
  132.  
  133.         virtual void               Queue(IAction& action, float time = -1.0f) override;
  134.         virtual void               Requeue(IAction& action) override;
  135.  
  136.         virtual void               Update(float timePassed) override;
  137.  
  138.         virtual SAnimationContext& GetContext() override
  139.         {
  140.                 return m_context;
  141.         }
  142.  
  143.         virtual const SAnimationContext& GetContext() const override
  144.         {
  145.                 return m_context;
  146.         }
  147.  
  148.         virtual void Pause() override;
  149.         virtual void Resume(uint32 resumeFlags = IActionController::ERF_Default) override;
  150.  
  151.         virtual void SetFlag(EActionControllerFlags flag, bool enable) override
  152.         {
  153.                 if (enable)
  154.                         m_flags |= flag;
  155.                 else
  156.                         m_flags &= ~flag;
  157.         }
  158.  
  159.         bool GetFlag(EActionControllerFlags flag) const
  160.         {
  161.                 return (m_flags & flag) != 0;
  162.         }
  163.  
  164.         virtual void  SetTimeScale(float timeScale) override;
  165.         virtual float GetTimeScale() const override { return m_timeScale; }
  166.  
  167. #ifndef _RELEASE
  168.  
  169.         bool DebugFragments(bool isRootScope)
  170.         {
  171.                 return ((s_mnDebugFragments > 0) && GetFlag(AC_DebugDraw) && (isRootScope || (s_mnDebugFragments == 2)));
  172.         }
  173.  
  174.         void GetStateString(string& state) const;
  175.  
  176. #endif   //_RELEASE
  177.  
  178.         // Only needed for animationgraph?
  179.         virtual bool                      IsActionPending(uint32 userToken) const override;
  180.  
  181.         virtual bool                      CanInstall(const IAction& action, const ActionScopes& scopeMask, float timeStep, float& timeTillInstall) const override;
  182.  
  183.         virtual bool                      QueryDuration(IAction& action, float& fragmentDuration, float& transitionDuration) const override;
  184.  
  185.         virtual void                      SetSlaveController(IActionController& target, uint32 targetContext, bool enslave, const IAnimationDatabase* piOptionTargetDatabase) override;
  186.         void                              FlushSlaveController(IActionController& target);
  187.  
  188.         virtual void                      RegisterListener(IMannequinListener* listener) override;
  189.         virtual void                      UnregisterListener(IMannequinListener* listener) override;
  190.  
  191.         virtual IProceduralContext*       FindOrCreateProceduralContext(const char* contextName) override;
  192.         virtual const IProceduralContext* FindProceduralContext(const char* contextName) const override;
  193.         virtual IProceduralContext*       FindProceduralContext(const char* contextName) override;
  194.         virtual IProceduralContext*       CreateProceduralContext(const char* contextName) override;
  195.  
  196.         virtual QuatT                     ExtractLocalAnimLocation(FragmentID fragID, TagState fragTags, uint32 scopeID, uint32 optionIdx) override;
  197.  
  198.         virtual void                      Release() override;
  199.  
  200.         virtual const SMannParameter*     GetParam(const char* paramName) const override
  201.         {
  202.                 return GetParam(MannGenCRC(paramName));
  203.         }
  204.         virtual const SMannParameter* GetParam(uint32 paramNameCRC) const override
  205.         {
  206.                 const SMannParameter* pRet = m_mannequinParams.FindParam(paramNameCRC);
  207.                 for (TOwningControllerList::const_iterator iter = m_owningControllers.begin(); (iter != m_owningControllers.end()) && (pRet == NULL); ++iter)
  208.                 {
  209.                         const CActionController* pActionControllerParent = *iter;
  210.                         pRet = pActionControllerParent->GetParam(paramNameCRC);
  211.                 }
  212.                 return pRet;
  213.         }
  214.         virtual bool RemoveParam(const char* paramName) override
  215.         {
  216.                 return m_mannequinParams.RemoveParam(paramName);
  217.         }
  218.         virtual bool RemoveParam(uint32 paramNameCRC) override
  219.         {
  220.                 return m_mannequinParams.RemoveParam(paramNameCRC);
  221.         }
  222.         virtual void SetParam(const char* paramName, const SMannParameter& param) override
  223.         {
  224.                 m_mannequinParams.SetParam(param.crc, param.value);
  225.         }
  226.         virtual void SetParam(const SMannParameter& param) override
  227.         {
  228.                 m_mannequinParams.SetParam(param.crc, param.value);
  229.         }
  230.         virtual void ResetParams() override
  231.         {
  232.                 m_mannequinParams.Reset();
  233.         }
  234.  
  235.         // -- ~IActionController implementation --------------------------------------
  236.  
  237.         ActionScopes FlushScopesByScopeContext(uint32 scopeContextID, EFlushMethod flushMethod = FM_Normal); // returns the ActionScopes using this scopeContext
  238.  
  239.         void         ReleaseScopes();
  240.         void         ReleaseScopeContexts();
  241.  
  242. #ifdef _DEBUG
  243.         void ValidateActions();
  244. #endif //_DEBUG
  245.  
  246.         const char* GetSafeEntityName() const // NOTE: should be safe to build a filename out of!
  247.         {
  248.                 if (m_entityId == 0)
  249.                 {
  250.                         return "no entity";
  251.                 }
  252.  
  253.                 IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_entityId);
  254.                 CRY_ASSERT(pEntity);
  255.                 return pEntity ? pEntity->GetName() : "invalid";
  256.         }
  257.  
  258.         IProceduralContext* FindProceduralContext(uint32 contextNameCRC) const;
  259.  
  260.         void                OnEntityReturnedToPool(EntityId entityId, IEntity* pEntity);
  261.  
  262.         void                StartAction(IAction& action);
  263.         void                EndAction(IAction& action, EFlushMethod flushMethod = FM_Normal);
  264.  
  265.         void                RegisterOwner(CActionController& owner)
  266.         {
  267.                 m_owningControllers.push_back(&owner);
  268.         }
  269.  
  270.         void UnregisterOwner(CActionController& owner)
  271.         {
  272.                 TOwningControllerList::iterator iter = std::find(m_owningControllers.begin(), m_owningControllers.end(), &owner);
  273.  
  274.                 if (iter != m_owningControllers.end())
  275.                 {
  276.                         m_owningControllers.erase(iter);
  277.                 }
  278.                 else
  279.                 {
  280.                         CryFatalError("Releasing reference to parent that does not exist!");
  281.                 }
  282.         }
  283.  
  284. #ifndef _RELEASE
  285.         static void                         ChangeDebug(const char* entName);
  286.         static void                         DumpSequence(const char* entName, float dumpTime);
  287. #endif //!_RELEASE
  288.         static const TActionControllerList& GetGlobalActionControllers() { return s_actionControllers; }
  289.         static IActionController*           FindActionController(const IEntity& entity);
  290.         static void                         OnShutdown();
  291.  
  292. private:
  293.  
  294.         static void RegisterCVars();
  295.         static void UnregisterCVars();
  296.         static void Register(CActionController* ac);
  297.         static void Unregister(CActionController* ac);
  298.  
  299. #ifndef _RELEASE
  300.         void ValidateScopeContext(uint32 scopeContextID) const;
  301.         void ValidateScopeContexts() const;
  302.         void DebugDraw() const;
  303.         void DebugDrawLocation(const QuatT& location, ColorB colorPos, ColorB colorX, ColorB colorY, ColorB colorZ) const;
  304. #endif //!_RELEASE
  305.  
  306.         void         FlushScope(uint32 scopeID, ActionScopes scopeFlag, EFlushMethod flushMethod = FM_Normal);
  307.         void         FlushProceduralContexts();
  308.  
  309.         bool         ResolveActionInstallations(float timePassed);
  310.         void         ResolveActionStates();
  311.         bool         BlendOffActions(float timePassed);
  312.         void         PruneQueue();
  313.         ActionScopes EndActionsOnScope(ActionScopes scopeMask, IAction* pPendingAction, bool blendOut = false, EFlushMethod flushMethod = FM_Normal);
  314.         bool         TryInstalling(IAction& action, float timePassed);
  315.         bool         CanInstall(const IAction& action, TagID subContext, const ActionScopes& scopeMask, float timeStep, float& timeTillInstall) const;
  316.         void         Install(IAction& action, float timePassed);
  317.         void         PushOntoQueue(IAction& action);
  318.         bool         IsDifferent(const FragmentID fragID, const TagState& fragmentTags, const ActionScopes& scopeMask) const override;
  319.         void         RequestInstall(const IAction& action, const ActionScopes& scopeMask);
  320.  
  321.         ActionScopes QueryScopeMask(FragmentID fragID, const TagState& fragTags, const TagID tagContext) const;
  322.         ActionScopes ExpandOverlappingScopes(ActionScopes scopeMask) const;
  323.         void         InsertEndingAction(IAction& action);
  324.         void         SynchTagsToSlave(SScopeContext& scopeContext, bool enable);
  325.  
  326.         EntityId            m_entityId;
  327.         IEntity*            m_cachedEntity;
  328.         SAnimationContext&  m_context;
  329.  
  330.         SScopeContext*      m_scopeContexts;
  331.  
  332.         const uint32        m_scopeCount;
  333.         CActionScope* const m_scopeArray;
  334.         ActionScopes        m_activeScopes;
  335.  
  336.         typedef std::vector<IActionPtr> TActionList;
  337.         TActionList m_queuedActions;
  338.  
  339.         struct SProcContext
  340.         {
  341.                 uint32                              nameCRC;
  342.                 std::shared_ptr<IProceduralContext> pContext;
  343.         };
  344.         std::vector<SProcContext> m_procContexts;
  345.  
  346.         uint32                    m_flags;
  347.         float                     m_timeScale;
  348.  
  349.         ActionScopes              m_scopeFlushMask;
  350.  
  351.         typedef std::vector<CActionController*> TOwningControllerList;
  352.         TOwningControllerList m_owningControllers;
  353.  
  354.         void Record(const SMannHistoryItem& item);
  355.         void RecordTagState();
  356.  
  357.         void UpdateValidity();
  358.         bool UpdateRootEntityValidity();                        // returns true when root entity is present and valid
  359.         bool UpdateScopeContextValidity(uint32 scopeContextId); // returns true when scopecontext is valid
  360. #ifndef _RELEASE
  361.         void DumpHistory(const char* filename, float earliestTime = 0.0f) const;
  362.         static const int TOTAL_HISTORY_SLOTS = 200;
  363.         SMannHistoryItem m_history[TOTAL_HISTORY_SLOTS];
  364.         uint32           m_historySlot;
  365. #endif //!_RELEASE
  366.         TagState         m_lastTagStateRecorded;
  367.  
  368.         typedef std::vector<IMannequinListener*> TListenerList;
  369.         TListenerList                            m_listeners;
  370.  
  371.         TActionList                              m_endedActions;
  372.         std::vector<std::pair<IActionPtr, bool>> m_triggeredActions;
  373.  
  374.         CMannequinParams                         m_mannequinParams;
  375.  
  376.         static uint32                            s_blendChannelCRCs[MANN_NUMBER_BLEND_CHANNELS];
  377.         static TActionControllerList             s_actionControllers;
  378.         static CActionController::TActionList    s_actionList;
  379.         static CActionController::TActionList    s_tickedActions;
  380.  
  381.         static bool                              s_registeredCVars;
  382. #ifndef _RELEASE
  383.         static ICVar*                            s_cvarMnDebug;
  384.         static CActionController*                s_debugAC;
  385.         static int                               s_mnDebugFragments;
  386. #endif //!_RELEASE
  387. #if CRYMANNEQUIN_WARN_ABOUT_VALIDITY()
  388.         static int s_mnFatalErrorOnInvalidEntity;
  389.         static int s_mnFatalErrorOnInvalidCharInst;
  390. #endif // !CRYMANNEQUIN_WARN_ABOUT_VALIDITY()
  391. };
  392.  
  393. #endif //!__ACTIONCONTROLLER_H__
  394.  
downloadActionController.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