BVB Source Codes

CRYENGINE Show IActionMapManager.h Source code

Return Download CRYENGINE: download IActionMapManager.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 Map Manager interfaces.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 8:9:2004   10:20 : Created by M谩rcio Martins
  12.    - 15:9:2010  12:30 : Revised by Dean Claassen
  13.  
  14. *************************************************************************/
  15.  
  16. #ifndef __IACTIONMAPMANAGER_H__
  17. #define __IACTIONMAPMANAGER_H__
  18.  
  19. #if _MSC_VER > 1000
  20.         #pragma once
  21. #endif
  22.  
  23. #include <CryInput/IInput.h>
  24. #include <CryEntitySystem/IEntitySystem.h>
  25. #include <CryString/CryName.h>            // CCryName
  26. #include <CryCore/smartptr.h>
  27.  
  28. typedef CCryName ActionId;
  29. struct SInputEvent;
  30.  
  31. // Summary
  32. //   Enumeration all all the possible activation mode used for the actions
  33. enum EActionActivationMode // Value for onpress, onrelease, onhold must match EInputState
  34. {
  35.         eAAM_Invalid   = 0,
  36.         eAAM_OnPress   = BIT(0),        // Used when the action key is pressed
  37.         eAAM_OnRelease = BIT(1),        // Used when the action key is released
  38.         eAAM_OnHold    = BIT(2),        // Used when the action key is held
  39.         eAAM_Always    = BIT(3),
  40.  
  41.         // Special modifiers.
  42.         eAAM_Retriggerable = BIT(4),
  43.         eAAM_NoModifiers   = BIT(5),
  44.         eAAM_ConsoleCmd    = BIT(6),
  45.         eAAM_AnalogCompare = BIT(7),    // Used when analog compare op succeeds
  46.  
  47. };
  48.  
  49. // Summary
  50. //  Input blocking action to perform when input is triggered
  51. enum EActionInputBlockType
  52. {
  53.         eAIBT_None = 0,
  54.         eAIBT_BlockInputs,
  55.         eAIBT_Clear,
  56. };
  57.  
  58. struct SActionInputBlocker
  59. {
  60.         // Summary:
  61.         //       Data used to block input symbol from firing event if matched
  62.  
  63.         SActionInputBlocker()
  64.                 : keyId(eKI_Unknown)
  65.         {
  66.         }
  67.  
  68.         SActionInputBlocker(const EKeyId keyId_)
  69.                 : keyId(keyId_)
  70.         {
  71.         }
  72.  
  73.         SActionInputBlocker& operator=(const SActionInputBlocker& rhs)
  74.         {
  75.                 keyId = rhs.keyId;
  76.  
  77.                 return *this;
  78.         }
  79.  
  80.         EKeyId keyId;                       // External id for fast comparison.
  81. };
  82.  
  83. typedef DynArray<SActionInputBlocker> TActionInputBlockers;
  84.  
  85. // Summary
  86. //  Input blocking data
  87. struct SActionInputBlockData
  88. {
  89.         SActionInputBlockData()
  90.                 : blockType(eAIBT_None)
  91.                 , fBlockDuration(0.0f)
  92.                 , activationMode(eAAM_Invalid)
  93.                 , deviceIndex(0)
  94.                 , bAllDeviceIndices(true)
  95.         {
  96.         }
  97.  
  98.         EActionInputBlockType blockType;
  99.         TActionInputBlockers  inputs;
  100.         float                 fBlockDuration;
  101.         int                   activationMode;
  102.         uint8                 deviceIndex;        // Device index - controller 1/2 etc
  103.         bool                  bAllDeviceIndices;  // True to block all device indices of deviceID type, otherwise uses deviceIndex
  104. };
  105.  
  106. enum EActionFilterType
  107. {
  108.         eAFT_ActionPass,
  109.         eAFT_ActionFail,
  110. };
  111.  
  112. enum EActionInputDevice
  113. {
  114.         eAID_Unknown       = 0,
  115.         eAID_KeyboardMouse = BIT(0),
  116.         eAID_XboxPad       = BIT(1),
  117.         eAID_PS4Pad        = BIT(2),
  118.         eAID_OculusTouch   = BIT(3),
  119. };
  120.  
  121. struct SActionInputDeviceData
  122. {
  123.         SActionInputDeviceData(const EActionInputDevice type, const char* szTypeStr)
  124.                 : m_type(type)
  125.                 , m_typeStr(szTypeStr)
  126.         {
  127.         }
  128.         EActionInputDevice  m_type;
  129.         CryFixedStringT<16> m_typeStr;
  130. };
  131.  
  132. //------------------------------------------------------------------------
  133. struct IActionListener
  134. {
  135.         virtual ~IActionListener(){}
  136.         virtual void OnAction(const ActionId& action, int activationMode, float value) = 0;
  137.         virtual void AfterAction() {};
  138. };
  139. typedef std::vector<IActionListener*> TActionListeners;
  140.  
  141. // Blocking action listener (Improved, left old one to avoid huge refactor)
  142. //------------------------------------------------------------------------
  143. struct IBlockingActionListener
  144. {
  145.         virtual ~IBlockingActionListener(){}
  146.         virtual bool OnAction(const ActionId& action, int activationMode, float value, const SInputEvent& inputEvent) = 0;
  147.         virtual void AfterAction() {};
  148. };
  149.  
  150. typedef std::shared_ptr<IBlockingActionListener> TBlockingActionListener;
  151.  
  152. enum EActionAnalogCompareOperation
  153. {
  154.         eAACO_None = 0,
  155.         eAACO_Equals,
  156.         eAACO_NotEquals,
  157.         eAACO_GreaterThan,
  158.         eAACO_LessThan,
  159. };
  160.  
  161. typedef CryFixedStringT<32> TActionInputString;
  162.  
  163. struct SActionInput
  164. {
  165.         SActionInput()
  166.                 : inputDevice(eAID_Unknown)
  167.                 , input("")
  168.                 , defaultInput("")
  169.                 , inputCRC(0)
  170.                 , fPressedTime(0.0f)
  171.                 , fPressTriggerDelay(0.0f)
  172.                 , fPressTriggerDelayRepeatOverride(-1.0f)
  173.                 , fLastRepeatTime(0.0f)
  174.                 , fAnalogCompareVal(0.0f)
  175.                 , fHoldTriggerDelay(0.0f)
  176.                 , fCurrentHoldValue(0.0f)
  177.                 , fReleaseTriggerThreshold(-1.0f)
  178.                 , fHoldRepeatDelay(0.0f)
  179.                 , fHoldTriggerDelayRepeatOverride(-1.0f)
  180.                 , activationMode(eAAM_Invalid)
  181.                 , iPressDelayPriority(0)
  182.                 , currentState(eIS_Unknown)
  183.                 , analogCompareOp(eAACO_None)
  184.                 , bHoldTriggerFired(false)
  185.                 , bAnalogConditionFulfilled(false)
  186.         {
  187.         }
  188.  
  189.         EActionInputDevice            inputDevice;
  190.         TActionInputString            input;
  191.         TActionInputString            defaultInput;
  192.         SActionInputBlockData         inputBlockData;
  193.         uint32                        inputCRC;
  194.         float                         fPressedTime;
  195.         float                         fPressTriggerDelay;
  196.         float                         fPressTriggerDelayRepeatOverride;
  197.         float                         fLastRepeatTime;
  198.         float                         fAnalogCompareVal;
  199.         float                         fHoldTriggerDelay;
  200.         float                         fCurrentHoldValue;   // A normalized amount for the current hold before triggering at the hold delay. Is 1 when hold is hit, & it does not reset when repeating
  201.         float                         fReleaseTriggerThreshold;
  202.         float                         fHoldRepeatDelay;
  203.         float                         fHoldTriggerDelayRepeatOverride;
  204.         int                           activationMode;
  205.         int                           iPressDelayPriority;   // If priority is higher than the current
  206.         EInputState                   currentState;
  207.         EActionAnalogCompareOperation analogCompareOp;
  208.         bool                          bHoldTriggerFired;
  209.         bool                          bAnalogConditionFulfilled;
  210.  
  211.         void                          GetMemoryUsage(ICrySizer* pSizer) const
  212.         {
  213.                 pSizer->AddObject(input);
  214.         }
  215. };
  216.  
  217. //------------------------------------------------------------------------
  218.  
  219. struct IActionMapPopulateCallBack
  220. {
  221.         virtual ~IActionMapPopulateCallBack(){}
  222.         // Description:
  223.         //                      Callback function to retrieve all action names
  224.         //                      Use it in conjunction with IActionMapManager::EnumerateActions / IActionMapManager::GetActionsCount
  225.         // Arguments:
  226.         //     pName - Name of one of the effects retrieved
  227.         virtual void AddActionName(const char* const pName) = 0;
  228. };
  229.  
  230. struct IActionMapAction
  231. {
  232.         virtual ~IActionMapAction(){}
  233.         virtual void                GetMemoryUsage(ICrySizer*) const = 0;
  234.         virtual void                Release() = 0;
  235.         virtual int                 GetNumActionInputs() const = 0;
  236.         virtual const SActionInput* FindActionInput(const char* szInput) const = 0;
  237.         virtual const SActionInput* GetActionInput(const int iIndex) const = 0;
  238.         virtual const SActionInput* GetActionInput(const EActionInputDevice device, const int iIndex) const = 0;
  239.         virtual const ActionId&     GetActionId() const = 0;
  240.         virtual const char*         GetTriggeredActionInput() const = 0;
  241. };
  242.  
  243. //------------------------------------------------------------------------
  244. struct IActionMapActionIterator
  245. {
  246.         virtual ~IActionMapActionIterator(){}
  247.         virtual const IActionMapAction* Next() = 0; // Returns the same pointer every call, 0 if no more info available.
  248.         virtual void                    AddRef() = 0;
  249.         virtual void                    Release() = 0;
  250. };
  251. typedef _smart_ptr<IActionMapActionIterator> IActionMapActionIteratorPtr;
  252.  
  253. struct IActionMap
  254. {
  255.         virtual ~IActionMap(){}
  256.         virtual void                    GetMemoryUsage(ICrySizer*) const = 0;
  257.         virtual void                    Release() = 0;
  258.         virtual void                    Clear() = 0;
  259.         virtual const IActionMapAction* GetAction(const ActionId& actionId) const = 0;
  260.         virtual IActionMapAction*       GetAction(const ActionId& actionId) = 0;
  261.         virtual bool                    CreateAction(const ActionId& actionId) = 0;
  262.         virtual bool                    RemoveAction(const ActionId& actionId) = 0;
  263.         virtual int                     GetActionsCount() const = 0;
  264.         virtual bool                    AddActionInput(const ActionId& actionId, const SActionInput& actionInput, const int iByDeviceIndex = -1) = 0;
  265.         virtual bool                    AddAndBindActionInput(const ActionId& actionId, const SActionInput& actionInput) = 0;
  266.         virtual bool                    RemoveActionInput(const ActionId& actionId, const char* szInput) = 0;
  267.         virtual bool                    ReBindActionInput(const ActionId& actionId, const char* szCurrentInput, const char* szNewInput) = 0;
  268.         virtual bool                    ReBindActionInput(const ActionId& actionId,
  269.                                                           const char* szNewInput,
  270.                                                           const EActionInputDevice device,
  271.                                                           const int iByDeviceIndex) = 0;
  272.         virtual int                         GetNumRebindedInputs() = 0;
  273.         virtual bool                        Reset() = 0;
  274.         virtual bool                        LoadFromXML(const XmlNodeRef& actionMapNode) = 0;
  275.         virtual bool                        LoadRebindingDataFromXML(const XmlNodeRef& actionMapNode) = 0;
  276.         virtual bool                        SaveRebindingDataToXML(XmlNodeRef& actionMapNode) const = 0;
  277.         virtual IActionMapActionIteratorPtr CreateActionIterator() = 0;
  278.         virtual void                        SetActionListener(EntityId id) = 0;
  279.         virtual EntityId                    GetActionListener() const = 0;
  280.         virtual const char*                 GetName() = 0;
  281.         virtual void                        Enable(bool enable) = 0;
  282.         virtual bool                        Enabled() const = 0;
  283. };
  284.  
  285. //------------------------------------------------------------------------
  286. struct IActionMapIterator
  287. {
  288.         virtual ~IActionMapIterator(){}
  289.         virtual IActionMap* Next() = 0;
  290.         virtual void        AddRef() = 0;
  291.         virtual void        Release() = 0;
  292. };
  293. typedef _smart_ptr<IActionMapIterator> IActionMapIteratorPtr;
  294.  
  295. //------------------------------------------------------------------------
  296. struct IActionFilter
  297. {
  298.         virtual ~IActionFilter(){}
  299.         virtual void        GetMemoryUsage(ICrySizer*) const = 0;
  300.         virtual void        Release() = 0;
  301.         virtual void        Filter(const ActionId& action) = 0;
  302.         virtual bool        SerializeXML(const XmlNodeRef& root, bool bLoading) = 0;
  303.         virtual const char* GetName() = 0;
  304.         virtual void        Enable(bool enable) = 0;
  305.         virtual bool        Enabled() = 0;
  306. };
  307.  
  308. //------------------------------------------------------------------------
  309. struct IActionFilterIterator
  310. {
  311.         virtual ~IActionFilterIterator(){}
  312.         virtual IActionFilter* Next() = 0;
  313.         virtual void           AddRef() = 0;
  314.         virtual void           Release() = 0;
  315. };
  316. typedef _smart_ptr<IActionFilterIterator> IActionFilterIteratorPtr;
  317.  
  318. struct SActionMapEvent
  319. {
  320.         enum EActionMapManagerEvent
  321.         {
  322.                 eActionMapManagerEvent_ActionMapsInitialized = 0,
  323.                 eActionMapManagerEvent_DefaultActionEntityChanged,
  324.                 eActionMapManagerEvent_FilterStatusChanged,
  325.                 eActionMapManagerEvent_ActionMapStatusChanged
  326.         };
  327.  
  328.         SActionMapEvent(EActionMapManagerEvent event, UINT_PTR wparam, UINT_PTR lparam = 0) :
  329.                 event(event),
  330.                 wparam(wparam),
  331.                 lparam(lparam)
  332.         {}
  333.  
  334.         EActionMapManagerEvent event;
  335.         UINT_PTR               wparam;
  336.         UINT_PTR               lparam;
  337. };
  338.  
  339. struct IActionMapEventListener
  340. {
  341.         virtual ~IActionMapEventListener() {};
  342.         virtual void OnActionMapEvent(const SActionMapEvent& event) = 0;
  343. };
  344.  
  345. //------------------------------------------------------------------------
  346.  
  347. struct IActionMapManager
  348. {
  349.         virtual ~IActionMapManager(){}
  350.         virtual void                          Update() = 0;
  351.         virtual void                          Reset() = 0;
  352.         virtual void                          Clear() = 0;
  353.  
  354.         virtual bool                          InitActionMaps(const char* filename) = 0;
  355.         virtual void                          SetLoadFromXMLPath(const char* szPath) = 0;
  356.         virtual const char*                   GetLoadFromXMLPath() const = 0;
  357.         virtual bool                          LoadFromXML(const XmlNodeRef& node) = 0;
  358.         virtual bool                          LoadRebindDataFromXML(const XmlNodeRef& node) = 0;
  359.         virtual bool                          SaveRebindDataToXML(XmlNodeRef& node) = 0;
  360.  
  361.         virtual bool                          AddExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL) = 0;
  362.         virtual bool                          RemoveExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap = NULL) = 0;
  363.         virtual const TActionListeners&       GetExtraActionListeners() const = 0;
  364.  
  365.         virtual bool                          AddFlowgraphNodeActionListener(IActionListener* pFlowgraphActionListener, const char* actionMap = NULL) = 0;
  366.         virtual bool                          RemoveFlowgraphNodeActionListener(IActionListener* pFlowgraphActionListener, const char* actionMap = NULL) = 0;
  367.  
  368.         virtual void                          AddAlwaysActionListener(TBlockingActionListener pActionListener) = 0;
  369.         virtual void                          RemoveAlwaysActionListener(TBlockingActionListener pActionListener) = 0;
  370.         virtual void                          RemoveAllAlwaysActionListeners() = 0;
  371.  
  372.         virtual IActionMap*                   CreateActionMap(const char* name) = 0;
  373.         virtual bool                          RemoveActionMap(const char* name) = 0;
  374.         virtual void                          RemoveAllActionMaps() = 0;
  375.         virtual IActionMap*                   GetActionMap(const char* name) = 0;
  376.         virtual IActionFilter*                CreateActionFilter(const char* name, EActionFilterType type) = 0;
  377.         virtual IActionFilter*                GetActionFilter(const char* name) = 0;
  378.         virtual IActionMapIteratorPtr         CreateActionMapIterator() = 0;
  379.         virtual IActionFilterIteratorPtr      CreateActionFilterIterator() = 0;
  380.  
  381.         virtual const SActionInput*           GetActionInput(const char* actionMapName, const ActionId& actionId, const EActionInputDevice device, const int iByDeviceIndex) const = 0;
  382.  
  383.         virtual void                          Enable(const bool enable, const bool resetStateOnDisable = false) = 0;
  384.         virtual void                          EnableActionMap(const char* name, bool enable) = 0;
  385.         virtual void                          EnableFilter(const char* name, bool enable) = 0;
  386.         virtual bool                          IsFilterEnabled(const char* name) = 0;
  387.         virtual void                          ReleaseFilteredActions() = 0;
  388.         virtual void                          ClearStoredCurrentInputData() = 0;
  389.  
  390.         virtual bool                          ReBindActionInput(const char* actionMapName, const ActionId& actionId, const char* szCurrentInput, const char* szNewInput) = 0;
  391.  
  392.         virtual int                           GetVersion() const = 0;
  393.         virtual void                          SetVersion(int version) = 0;
  394.  
  395.         virtual void                          EnumerateActions(IActionMapPopulateCallBack* pCallBack) const = 0;
  396.         virtual int                           GetActionsCount() const = 0;
  397.         virtual int                           GetActionMapsCount() const = 0;
  398.  
  399.         virtual bool                          AddInputDeviceMapping(const EActionInputDevice deviceType, const char* szDeviceTypeStr) = 0;
  400.         virtual bool                          RemoveInputDeviceMapping(const EActionInputDevice deviceType) = 0;
  401.         virtual void                          ClearInputDevicesMappings() = 0;
  402.         virtual int                           GetNumInputDeviceData() const = 0;
  403.         virtual const SActionInputDeviceData* GetInputDeviceDataByIndex(const int iIndex) = 0;
  404.         virtual const SActionInputDeviceData* GetInputDeviceDataByType(const EActionInputDevice deviceType) = 0;
  405.         virtual const SActionInputDeviceData* GetInputDeviceDataByType(const char* szDeviceType) = 0;
  406.  
  407.         virtual void                          RemoveAllRefireData() = 0;
  408.         virtual bool                          LoadControllerLayoutFile(const char* szLayoutKeyName) = 0;
  409.  
  410.         virtual EntityId                      GetDefaultActionEntity() const = 0;
  411.         virtual void                          SetDefaultActionEntity(EntityId id, bool bUpdateAll = true) = 0;
  412.         virtual void                          RegisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener) = 0;
  413.         virtual void                          UnregisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener) = 0;
  414. };
  415.  
  416. template<class T>
  417. class TActionHandler
  418. {
  419. public:
  420.         // Returns true if the action should also be forwarded to scripts
  421.         typedef bool (T::* TOnActionHandler)(EntityId entityId, const ActionId& actionId, int activationMode, float value);
  422.  
  423.         // setup action handlers
  424.         void AddHandler(const ActionId& actionId, TOnActionHandler fnHandler)
  425.         {
  426.                 m_actionHandlers.insert(std::make_pair(actionId, fnHandler));
  427.         }
  428.  
  429.         size_t GetNumHandlers() const
  430.         {
  431.                 return m_actionHandlers.size();
  432.         }
  433.  
  434.         // call action handler
  435.         bool Dispatch(T* pThis, EntityId entityId, const ActionId& actionId, int activationMode, float value)
  436.         {
  437.                 bool rVal = false;
  438.                 return Dispatch(pThis, entityId, actionId, activationMode, value, rVal);
  439.         }
  440.  
  441.         // call action handler
  442.         bool Dispatch(T* pThis, EntityId entityId, const ActionId& actionId, int activationMode, float value, bool& rVal)
  443.         {
  444.                 rVal = false;
  445.  
  446.                 TOnActionHandler fnHandler = GetHandler(actionId);
  447.                 if (fnHandler && pThis)
  448.                 {
  449.                         rVal = (pThis->*fnHandler)(entityId, actionId, activationMode, value);
  450.                         return true;
  451.                 }
  452.                 else
  453.                         return false;
  454.         }
  455.  
  456.         // get action handler
  457.         TOnActionHandler GetHandler(const ActionId& actionId)
  458.         {
  459.                 typename TActionHandlerMap::iterator handler = m_actionHandlers.find(actionId);
  460.  
  461.                 if (handler != m_actionHandlers.end())
  462.                 {
  463.                         return handler->second;
  464.                 }
  465.                 return 0;
  466.         }
  467.  
  468.         void Clear()
  469.         {
  470.                 m_actionHandlers.clear();
  471.         }
  472.  
  473. private:
  474.         typedef std::multimap<ActionId, TOnActionHandler> TActionHandlerMap;
  475.  
  476.         TActionHandlerMap m_actionHandlers;
  477. };
  478.  
  479. #endif //__IACTIONMAPMANAGER_H__
  480.  
downloadIActionMapManager.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