BVB Source Codes

CRYENGINE Show ActionMapManager.h Source code

Return Download CRYENGINE: download ActionMapManager.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: Action manager and dispatcher.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 7:9:2004   17:36 : Created by M谩rcio Martins
  12.    - 15:9:2010  12:30 : Revised by Dean Claassen
  13.  
  14. *************************************************************************/
  15. #ifndef __ACTIONMAPMANAGER_H__
  16. #define __ACTIONMAPMANAGER_H__
  17.  
  18. #if _MSC_VER > 1000
  19.         #pragma once
  20. #endif
  21.  
  22. #include "IActionMapManager.h"
  23.  
  24. class CActionMapAction;
  25.  
  26. typedef std::map<string, class CActionMap*>    TActionMapMap;
  27. typedef std::map<string, class CActionFilter*> TActionFilterMap;
  28. typedef std::map<string, XmlNodeRef>           TControllerLayouts;
  29.  
  30. //------------------------------------------------------------------------
  31.  
  32. class CConsoleActionListener : public IActionListener
  33. {
  34. public:
  35.         void OnAction(const ActionId& actionId, int activationMode, float value)
  36.         {
  37.                 IConsole* pCons = gEnv->pConsole;
  38.                 pCons->ExecuteString(actionId.c_str());
  39.         }
  40. };
  41.  
  42. class CActionMapManager :
  43.         public IActionMapManager,
  44.         public IInputEventListener
  45. {
  46. public:
  47.         CActionMapManager(IInput* pInput);
  48.  
  49.         void Release() { delete this; };
  50.  
  51.         // IInputEventListener
  52.         virtual bool OnInputEvent(const SInputEvent& event);
  53.         // ~IInputEventListener
  54.  
  55.         // IActionMapManager
  56.         virtual void                          Update();
  57.         virtual void                          Reset();
  58.         virtual void                          Clear();
  59.  
  60.         virtual bool                          InitActionMaps(const char* filename);
  61.         virtual void                          SetLoadFromXMLPath(const char* szPath) { m_loadedXMLPath = szPath; };
  62.         virtual const char*                   GetLoadFromXMLPath() const             { return m_loadedXMLPath; };
  63.         virtual bool                          LoadFromXML(const XmlNodeRef& node);
  64.         virtual bool                          LoadRebindDataFromXML(const XmlNodeRef& node);
  65.         virtual bool                          SaveRebindDataToXML(XmlNodeRef& node);
  66.  
  67.         virtual bool                          AddExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL);
  68.         virtual bool                          RemoveExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL);
  69.         virtual const TActionListeners&       GetExtraActionListeners() const;
  70.  
  71.         virtual bool                          AddFlowgraphNodeActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL);
  72.         virtual bool                          RemoveFlowgraphNodeActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL);
  73.  
  74.         virtual void                          AddAlwaysActionListener(TBlockingActionListener pActionListener); // TODO: Remove always action listeners and integrate into 1 prioritized type
  75.         virtual void                          RemoveAlwaysActionListener(TBlockingActionListener pActionListener);
  76.         virtual void                          RemoveAllAlwaysActionListeners();
  77.  
  78.         virtual IActionMap*                   CreateActionMap(const char* name);
  79.         virtual bool                          RemoveActionMap(const char* name);
  80.         virtual void                          RemoveAllActionMaps();
  81.         virtual IActionMap*                   GetActionMap(const char* name);
  82.         virtual const IActionMap*             GetActionMap(const char* name) const;
  83.         virtual IActionFilter*                CreateActionFilter(const char* name, EActionFilterType type = eAFT_ActionFail);
  84.         virtual IActionFilter*                GetActionFilter(const char* name);
  85.         virtual IActionMapIteratorPtr         CreateActionMapIterator();
  86.         virtual IActionFilterIteratorPtr      CreateActionFilterIterator();
  87.  
  88.         virtual void                          Enable(const bool enable, const bool resetStateOnDisable = false);
  89.         virtual void                          EnableActionMap(const char* name, bool enable);
  90.         virtual void                          EnableFilter(const char* name, bool enable);
  91.         virtual bool                          IsFilterEnabled(const char* name);
  92.         virtual void                          RemoveAllFilters();
  93.         virtual void                          ReleaseFilteredActions();
  94.         virtual void                          ClearStoredCurrentInputData();
  95.  
  96.         virtual bool                          ReBindActionInput(const char* actionMapName, const ActionId& actionId, const char* szCurrentInput, const char* szNewInput);
  97.  
  98.         virtual const SActionInput*           GetActionInput(const char* actionMapName, const ActionId& actionId, const EActionInputDevice device, const int iByDeviceIndex) const;
  99.  
  100.         virtual int                           GetVersion() const      { return m_version; }
  101.         virtual void                          SetVersion(int version) { m_version = version; }
  102.         virtual void                          EnumerateActions(IActionMapPopulateCallBack* pCallBack) const;
  103.         virtual int                           GetActionsCount() const;
  104.         virtual int                           GetActionMapsCount() const { return m_actionMaps.size(); }
  105.  
  106.         virtual bool                          AddInputDeviceMapping(const EActionInputDevice deviceType, const char* szDeviceTypeStr);
  107.         virtual bool                          RemoveInputDeviceMapping(const EActionInputDevice deviceType);
  108.         virtual void                          ClearInputDevicesMappings();
  109.         virtual int                           GetNumInputDeviceData() const;
  110.         virtual const SActionInputDeviceData* GetInputDeviceDataByIndex(const int iIndex);
  111.         virtual const SActionInputDeviceData* GetInputDeviceDataByType(const EActionInputDevice deviceType);
  112.         virtual const SActionInputDeviceData* GetInputDeviceDataByType(const char* szDeviceType);
  113.  
  114.         virtual void                          RemoveAllRefireData();
  115.         virtual bool                          LoadControllerLayoutFile(const char* szLayoutKeyName);
  116.  
  117.         virtual void                          SetDefaultActionEntity(EntityId id, bool bUpdateAll = true);
  118.         virtual EntityId                      GetDefaultActionEntity() const { return m_defaultEntityId; };
  119.  
  120.         virtual void                          RegisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener);
  121.         virtual void                          UnregisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener);
  122.         // ~IActionMapManager
  123.  
  124.         void         BroadcastActionMapEvent(const SActionMapEvent& event);
  125.  
  126.         bool         ActionFiltered(const ActionId& action);
  127.  
  128.         void         RemoveActionFilter(CActionFilter* pActionFilter);
  129.  
  130.         void         ReleaseActionIfActive(const ActionId& actionId);
  131.  
  132.         bool         AddBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput);
  133.         bool         RemoveBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput);
  134.         void         RemoveBind(CActionMap* pActionMap);
  135.         void         RemoveBind(CActionMapAction* pAction);
  136.         bool         HasBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput) const;
  137.  
  138.         bool         UpdateRefireData(const SInputEvent& event, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput);
  139.         bool         RemoveRefireData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput);
  140.         void         RemoveRefireData(CActionMap* pActionMap);
  141.         void         RemoveRefireData(CActionMapAction* pAction);
  142.         bool         SetRefireDataDelayedPressNeedsRelease(const SInputEvent& event, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput, const bool bDelayedPressNeedsRelease);
  143.         void         RemoveAllDelayedPressRefireData();
  144.         int          GetHighestPressDelayPriority() const;
  145.  
  146.         static void  ReloadActionMaps(IConsoleCmdArgs* pArgs);
  147.  
  148.         void         GetMemoryStatistics(ICrySizer* s);
  149.  
  150.         ILINE bool   IsCurrentlyRefiringInput() const                    { return m_bRefiringInputs; }
  151.         ILINE bool   IsIncomingInputRepeated() const                     { return m_bIncomingInputRepeated; }
  152.         ILINE EKeyId GetIncomingInputKeyID() const                       { return m_currentInputKeyID; }
  153.         ILINE void   SetRepeatedInputHoldTriggerFired(const bool bFired) { m_bRepeatedInputHoldTriggerFired = bFired; }
  154.         ILINE bool   IsRepeatedInputHoldTriggerFired() const             { return m_bRepeatedInputHoldTriggerFired; }
  155.  
  156. protected:
  157.         virtual ~CActionMapManager();
  158.  
  159. private:
  160.  
  161.         TActionListeners m_ExtraActionListeners;
  162.  
  163.         bool PreloadControllerLayout(const XmlNodeRef& controllerLayout);
  164.  
  165.         struct SBindData
  166.         {
  167.                 SBindData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  168.                         : m_pActionMap(pActionMap)
  169.                         , m_pAction(pAction)
  170.                         , m_pActionInput(pActionInput)
  171.                 {
  172.                 }
  173.  
  174.                 SActionInput*     m_pActionInput;
  175.                 CActionMapAction* m_pAction;
  176.                 CActionMap*       m_pActionMap;
  177.         };
  178.  
  179.         struct SRefireBindData
  180.         {
  181.                 SRefireBindData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  182.                         : m_bindData(pActionMap, pAction, pActionInput)
  183.                         , m_bIgnoreNextUpdate(false)
  184.                         , m_bDelayedPressNeedsRelease(false)
  185.                 {
  186.                 }
  187.  
  188.                 SBindData m_bindData;
  189.                 bool      m_bIgnoreNextUpdate;         // Only used for refiring data since don't want to fire right after was added
  190.                 bool      m_bDelayedPressNeedsRelease;
  191.         };
  192.  
  193.         typedef std::vector<SRefireBindData> TRefireBindData;
  194.         struct SRefireData
  195.         {
  196.                 SRefireData(const SInputEvent& event, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  197.                         : m_inputCRC(pActionInput->inputCRC)
  198.                         , m_inputEvent(event)
  199.                 {
  200.                         m_refireBindData.push_back(SRefireBindData(pActionMap, pAction, pActionInput));
  201.                 }
  202.  
  203.                 uint32          m_inputCRC;
  204.                 SInputEvent     m_inputEvent;   // Copy of actual event
  205.                 TRefireBindData m_refireBindData;
  206.         };
  207.  
  208.         typedef std::multimap<uint32, SBindData>    TInputCRCToBind;
  209.         typedef std::list<const SBindData*>         TBindPriorityList;
  210.         typedef std::list<TBlockingActionListener>  TBlockingActionListeners;
  211.         typedef std::vector<SActionInputDeviceData> TInputDeviceData;
  212.         typedef std::map<uint32, SRefireData*>      TInputCRCToRefireData;
  213.  
  214.         struct SRefireReleaseListData
  215.         {
  216.                 SInputEvent       m_inputEvent;
  217.                 TBindPriorityList m_inputsList;
  218.         };
  219.  
  220.         bool       HandleAcceptedEvents(const SInputEvent& event, TBindPriorityList& priorityList);
  221.         void       HandleInputBlocking(const SInputEvent& event, const SActionInput* pActionInput, const float fCurrTime);
  222.         SBindData* GetBindData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput);
  223.         bool       CreateEventPriorityList(const SInputEvent& inputEvent, TBindPriorityList& priorityList);
  224.         bool       CreateRefiredEventPriorityList(SRefireData* pRefireData,
  225.                                                   TBindPriorityList& priorityList,
  226.                                                   TBindPriorityList& removeList,
  227.                                                   TBindPriorityList& delayPressNeedsReleaseList);
  228.         bool ProcessAlwaysListeners(const ActionId& action, int activationMode, float value, const SInputEvent& inputEvent);
  229.         void SetCurrentlyRefiringInput(bool bRefiringInput) { m_bRefiringInputs = bRefiringInput; }
  230.         void UpdateRefiringInputs();
  231.  
  232.         string                   m_loadedXMLPath;
  233.         IInput*                  m_pInput;
  234.         TActionMapMap            m_actionMaps;
  235.         TActionFilterMap         m_actionFilters;
  236.         TInputCRCToBind          m_inputCRCToBind;
  237.         TInputCRCToRefireData    m_inputCRCToRefireData;
  238.         TBlockingActionListeners m_alwaysActionListeners;
  239.         TControllerLayouts       m_preloadedControllerLayouts;
  240.         TInputDeviceData         m_inputDeviceData;
  241.         EKeyId                   m_currentInputKeyID;  // Keep track to determine if is a repeated input
  242.         int                      m_version;
  243.  
  244. #ifndef _RELEASE
  245.         int i_listActionMaps;                       // cvar
  246. #endif
  247.  
  248.         bool m_enabled;
  249.         bool m_bRefiringInputs;
  250.         bool m_bDelayedRemoveAllRefiringData;               // This only gets set true while m_bRefiringInputs == true and something is disabling an action filter based on a refired input (Crashes if try to do this while iterating data)
  251.         bool m_bIncomingInputRepeated;                      // Input currently incoming is a repeated input
  252.         bool m_bRepeatedInputHoldTriggerFired;              // Input currently incoming already fired initial hold trigger
  253.  
  254.         typedef std::list<IActionMapEventListener*> TActionMapEventListeners;
  255.         TActionMapEventListeners  m_actionMapEventListeners;
  256.         EntityId                  m_defaultEntityId;
  257.  
  258.         static CActionMapManager* s_pThis;
  259. };
  260.  
  261. #endif //__ACTIONMAPMANAGER_H__
  262.  
downloadActionMapManager.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