BVB Source Codes

CRYENGINE Show FlowActionMapNodes.cpp Source code

Return Download CRYENGINE: download FlowActionMapNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5.  
  6. #include "StdAfx.h"
  7.  
  8. #include <CryFlowGraph/IFlowBaseNode.h>
  9. #include <CryCore/Containers/VectorMap.h>
  10.  
  11. //////////////////////////////////////////////////////////////////////
  12. class CFlowNode_SetDefaultActionEntity : public CFlowBaseNode<eNCT_Singleton>
  13. {
  14.         enum Inputs
  15.         {
  16.                 EIP_SET,
  17.                 EIP_UPDATE
  18.         };
  19.  
  20.         enum Outputs
  21.         {
  22.                 EOP_ONSET
  23.         };
  24.  
  25. public:
  26.         CFlowNode_SetDefaultActionEntity(SActivationInfo* pActInfo)
  27.         {
  28.         }
  29.  
  30.         void GetConfiguration(SFlowNodeConfig& config)
  31.         {
  32.                 static const SInputPortConfig inputs[] =
  33.                 {
  34.                         InputPortConfig_AnyType("Set", _HELP("Set assigned Entity as default action entity")),
  35.                         InputPortConfig<bool>("UpdateExisting", true, _HELP("If set to true, Set will update all existing action map assignments")),
  36.                         { 0 }
  37.                 };
  38.  
  39.                 static const SOutputPortConfig outputs[] =
  40.                 {
  41.                         OutputPortConfig_AnyType("OnSet", _HELP("Gets triggered when default action entity gets set/changed")),
  42.                         { 0 }
  43.                 };
  44.  
  45.                 config.nFlags |= EFLN_TARGET_ENTITY;
  46.                 config.pInputPorts = inputs;
  47.                 config.pOutputPorts = outputs;
  48.                 config.sDescription = _HELP("");
  49.                 config.SetCategory(EFLN_APPROVED);
  50.         }
  51.  
  52.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  53.         {
  54.                 switch (event)
  55.                 {
  56.                 case eFE_Activate:
  57.                         {
  58.                                 if (IsPortActive(pActInfo, EIP_SET))
  59.                                 {
  60.                                         if (pActInfo->pEntity)
  61.                                         {
  62.                                                 const bool bUpdate = GetPortBool(pActInfo, EIP_UPDATE);
  63.                                                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  64.                                                 if (pActionMapMgr && bUpdate)
  65.                                                 {
  66.                                                         pActionMapMgr->SetDefaultActionEntity(pActInfo->pEntity->GetId(), bUpdate);
  67.                                                 }
  68.                                                 ActivateOutput(pActInfo, EOP_ONSET, 1);
  69.                                         }
  70.                                 }
  71.                                 break;
  72.                         }
  73.                 }
  74.         }
  75.  
  76.         virtual void GetMemoryUsage(ICrySizer* s) const
  77.         {
  78.                 s->Add(*this);
  79.         }
  80. };
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. class CFlowNode_GetDefaultActionEntity : public CFlowBaseNode<eNCT_Instanced>, IActionMapEventListener
  84. {
  85.         enum EInputs
  86.         {
  87.                 EIP_GET,
  88.                 EIP_AUTOUPDATE
  89.         };
  90.  
  91.         enum EOutputs
  92.         {
  93.                 EOP_ENTITYID
  94.         };
  95.  
  96. public:
  97.         CFlowNode_GetDefaultActionEntity(SActivationInfo* pActInfo)
  98.                 : m_bAutoUpdate(false), m_currentEntityId(INVALID_ENTITYID)
  99.         {
  100.         }
  101.  
  102.         ~CFlowNode_GetDefaultActionEntity()
  103.         {
  104.                 Register(false);
  105.         }
  106.  
  107.         void GetConfiguration(SFlowNodeConfig& config)
  108.         {
  109.                 static const SInputPortConfig inputs[] =
  110.                 {
  111.                         InputPortConfig_AnyType("Get", _HELP("Get current default action entity")),
  112.                         InputPortConfig<bool>("AutoUpdate", true, _HELP("outputs the new default entity whenever it changes")),
  113.                         { 0 }
  114.                 };
  115.  
  116.                 static const SOutputPortConfig outputs[] =
  117.                 {
  118.                         OutputPortConfig<EntityId>("EntityId", _HELP("")),
  119.                         { 0 }
  120.                 };
  121.  
  122.                 config.pInputPorts = inputs;
  123.                 config.pOutputPorts = outputs;
  124.                 config.sDescription = _HELP("");
  125.                 config.SetCategory(EFLN_APPROVED);
  126.         }
  127.  
  128.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  129.         {
  130.                 return new CFlowNode_GetDefaultActionEntity(pActInfo);
  131.         }
  132.  
  133.         void Serialize(SActivationInfo* pActivationInfo, TSerialize ser)
  134.         {
  135.                 if (ser.IsReading())
  136.                 {
  137.                         Register(false);
  138.                 }
  139.  
  140.                 ser.Value("m_currentEntityId", m_currentEntityId, 'eid');
  141.                 ser.Value("m_bAutoUpdate", m_bAutoUpdate, 'bool');
  142.  
  143.                 if (ser.IsReading())
  144.                 {
  145.                         if (m_currentEntityId != 0 && m_bAutoUpdate)
  146.                         {
  147.                                 Register(true);
  148.                         }
  149.                 }
  150.         }
  151.  
  152.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  153.         {
  154.                 m_pActInfo = *pActInfo;
  155.  
  156.                 switch (event)
  157.                 {
  158.                 case eFE_Activate:
  159.                         {
  160.                                 const bool bAutoUpdate = GetPortBool(pActInfo, EIP_AUTOUPDATE);
  161.  
  162.                                 if (m_bAutoUpdate != bAutoUpdate)
  163.                                 {
  164.                                         Register(bAutoUpdate);
  165.                                 }
  166.  
  167.                                 if (IsPortActive(pActInfo, EIP_GET))
  168.                                 {
  169.                                         IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  170.                                         ActivateOutput(pActInfo, EOP_ENTITYID, pActionMapMgr->GetDefaultActionEntity());
  171.                                 }
  172.                                 break;
  173.                         }
  174.                 }
  175.         }
  176.  
  177.         void Register(bool bEnable)
  178.         {
  179.                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  180.  
  181.                 if (pActionMapMgr)
  182.                 {
  183.                         if (bEnable)
  184.                         {
  185.                                 pActionMapMgr->RegisterActionMapEventListener(this);
  186.                         }
  187.                         else
  188.                         {
  189.                                 pActionMapMgr->UnregisterActionMapEventListener(this);
  190.                         }
  191.  
  192.                         m_bAutoUpdate = bEnable;
  193.                 }
  194.         }
  195.  
  196.         void OnActionMapEvent(const SActionMapEvent& event)
  197.         {
  198.                 if (event.event == SActionMapEvent::eActionMapManagerEvent_DefaultActionEntityChanged)
  199.                 {
  200.                         ActivateOutput(&m_pActInfo, EOP_ENTITYID, (EntityId)event.wparam);
  201.                 }
  202.         }
  203.  
  204.         virtual void GetMemoryUsage(ICrySizer* s) const
  205.         {
  206.                 s->Add(*this);
  207.         }
  208.  
  209.         bool            m_bAutoUpdate;
  210.         EntityId        m_currentEntityId;
  211.         SActivationInfo m_pActInfo;
  212. };
  213.  
  214. //////////////////////////////////////////////////////////////////////
  215. class CFlowNode_InputActionListener : public CFlowBaseNode<eNCT_Instanced>, public IInputEventListener, public IActionListener
  216. {
  217.         typedef VectorMap<uint32, bool> TAnalogInputsPressed;
  218.  
  219.         enum EInputs
  220.         {
  221.                 EIP_ENABLE = 0,
  222.                 EIP_DISABLE,
  223.                 EIP_ACTION
  224.         };
  225.  
  226.         enum EOutputs
  227.         {
  228.                 EOP_ENABLED,
  229.                 EOP_DISABLED,
  230.                 EOP_PRESSED,
  231.                 EOP_RELEASED,
  232.                 EOP_HOLD
  233.         };
  234.  
  235. public:
  236.         CFlowNode_InputActionListener(SActivationInfo* pActInfo)
  237.                 : m_bEnabled(false)
  238.                 , m_pAction(nullptr)
  239.                 , m_pActionMap(nullptr)
  240.                 , m_filterEntityId(INVALID_ENTITYID)
  241.         {
  242.         }
  243.  
  244.         ~CFlowNode_InputActionListener()
  245.         {
  246.                 Unregister();
  247.         }
  248.  
  249.         void GetConfiguration(SFlowNodeConfig& config)
  250.         {
  251.                 static const SInputPortConfig inputs[] =
  252.                 {
  253.                         InputPortConfig_Void("Enable",                     _HELP("Trigger to enable")),
  254.                         InputPortConfig_Void("Disable",                    _HELP("Trigger to disable")),
  255.                         InputPortConfig<string>("actionMapActions_Action", _HELP("Action input to trigger"),_HELP("Action")),
  256.                         { 0 }
  257.                 };
  258.  
  259.                 static const SOutputPortConfig outputs[] =
  260.                 {
  261.                         OutputPortConfig_Void("Enabled",     _HELP("Action Listener set")),
  262.                         OutputPortConfig_Void("Disabled",    _HELP("Action Listener removed")),
  263.                         OutputPortConfig<string>("Pressed",  _HELP("Action trigger pressed.")),
  264.                         OutputPortConfig<string>("Released", _HELP("Action trigger released.")),
  265.                         OutputPortConfig<string>("Hold",     _HELP("Action trigger hold. Make sure the action map is enabled, since this port goes properly through the action manager.")),
  266.                         { 0 }
  267.                 };
  268.  
  269.                 config.nFlags |= EFLN_TARGET_ENTITY;
  270.                 config.pInputPorts = inputs;
  271.                 config.pOutputPorts = outputs;
  272.                 config.sDescription = _HELP("FlowNode to catch input events via their action name. Entity Input will listen for specified entity only");
  273.                 config.SetCategory(EFLN_APPROVED);
  274.         }
  275.  
  276.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  277.         {
  278.                 return new CFlowNode_InputActionListener(pActInfo);
  279.         }
  280.  
  281.         void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  282.         {
  283.                 ser.Value("m_bActive", m_bEnabled);
  284.                 ser.Value("m_actionInputStr", m_actionInputStr);
  285.                 if (ser.IsReading())
  286.                 {
  287.                         Register();
  288.                 }
  289.         }
  290.  
  291.         void Register()
  292.         {
  293.                 IInput* pInput = gEnv->pInput;
  294.                 if (!pInput)
  295.                         return;
  296.  
  297.                 if (m_bEnabled)
  298.                         return;
  299.  
  300.                 pInput->AddEventListener(this);
  301.  
  302.                 const size_t colonIndex = m_actionInputStr.find_first_of(":");
  303.                 const string& actionMapName = m_actionInputStr.substr(0, colonIndex);
  304.                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  305.                 if (pActionMapMgr)
  306.                 {
  307.                         pActionMapMgr->AddFlowgraphNodeActionListener(this, actionMapName.c_str());
  308.  
  309.                         const string& actionName = &m_actionInputStr.c_str()[colonIndex + 1];
  310.                         m_pActionMap = pActionMapMgr->GetActionMap(actionMapName);
  311.                         if (m_pActionMap)
  312.                         {
  313.                                 m_pAction = m_pActionMap->GetAction(ActionId(actionName));
  314.                         }
  315.                 }
  316.  
  317.                 m_bEnabled = true;
  318.         }
  319.  
  320.         void Unregister()
  321.         {
  322.                 IInput* pInput = gEnv->pInput;
  323.                 if (!pInput)
  324.                         return;
  325.  
  326.                 if (!m_bEnabled)
  327.                         return;
  328.  
  329.                 pInput->RemoveEventListener(this);
  330.  
  331.                 const string& actionMapName = m_actionInputStr.substr(0, m_actionInputStr.find_first_of(":"));
  332.                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  333.                 if (pActionMapMgr)
  334.                 {
  335.                         pActionMapMgr->RemoveFlowgraphNodeActionListener(this, actionMapName);
  336.                 }
  337.                 m_pActionMap = nullptr;
  338.                 m_pAction = nullptr;
  339.  
  340.                 m_bEnabled = false;
  341.         }
  342.  
  343.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  344.         {
  345.                 switch (event)
  346.                 {
  347.                 case eFE_Initialize:
  348.                         {
  349.                                 m_pActInfo = *pActInfo;
  350.                                 m_actionInputStr = GetPortString(pActInfo, EIP_ACTION);
  351.                                 Unregister();
  352.                                 break;
  353.                         }
  354.  
  355.                 case eFE_SetEntityId:
  356.                         {
  357.                                 m_filterEntityId = pActInfo && pActInfo->pEntity ? pActInfo->pEntity->GetId() : INVALID_ENTITYID;
  358.                                 break;
  359.                         }
  360.  
  361.                 case eFE_Activate:
  362.                         {
  363.                                 m_pActInfo = *pActInfo;
  364.  
  365.                                 if (IsPortActive(pActInfo, EIP_ACTION))
  366.                                 {
  367.                                         if (m_bEnabled)
  368.                                         {
  369.                                                 Unregister();
  370.                                                 m_actionInputStr = GetPortString(pActInfo, EIP_ACTION);
  371.                                                 Register();
  372.                                         }
  373.                                         else
  374.                                         {
  375.                                                 m_actionInputStr = GetPortString(pActInfo, EIP_ACTION);
  376.                                         }
  377.                                 }
  378.  
  379.                                 if (IsPortActive(pActInfo, EIP_DISABLE))
  380.                                 {
  381.                                         Unregister();
  382.                                 }
  383.  
  384.                                 if (IsPortActive(pActInfo, EIP_ENABLE))
  385.                                 {
  386.                                         Register();
  387.                                 }
  388.  
  389.                                 break;
  390.                         }
  391.                 }
  392.         }
  393.  
  394.         virtual bool OnInputEvent(const SInputEvent& event)
  395.         {
  396.                 if (gEnv->pConsole->IsOpened() || CCryAction::GetCryAction()->IsGamePaused())
  397.                         return false;
  398.  
  399.                 if (m_pActionMap && m_pActionMap->Enabled() && (m_filterEntityId == INVALID_ENTITYID || m_filterEntityId == m_pActionMap->GetActionListener()))
  400.                 {
  401.                         if (m_pAction)
  402.                         {
  403.                                 const char* eventKeyNameCStr = event.keyName.c_str();
  404.  
  405.                                 const int iNumInputData = m_pAction->GetNumActionInputs();
  406.                                 for (int i = 0; i < iNumInputData; ++i)
  407.                                 {
  408.                                         const SActionInput* pActionInput = m_pAction->GetActionInput(i);
  409.  
  410.                                         if (!stricmp(pActionInput->input, eventKeyNameCStr))
  411.                                         {
  412.                                                 // Handle analog inputs
  413.                                                 if (pActionInput->analogCompareOp != eAACO_None)
  414.                                                 {
  415.                                                         if (pActionInput->bAnalogConditionFulfilled && !GetAnalogInputPressed(pActionInput->inputCRC))
  416.                                                         {
  417.                                                                 ActivateOutput(&m_pActInfo, EOP_PRESSED, string(m_pAction->GetActionId().c_str()));
  418.                                                                 SetAnalogInputPressed(pActionInput->inputCRC, true);
  419.                                                         }
  420.                                                         else if (!pActionInput->bAnalogConditionFulfilled && GetAnalogInputPressed(pActionInput->inputCRC))
  421.                                                         {
  422.                                                                 ActivateOutput(&m_pActInfo, EOP_RELEASED, string(m_pAction->GetActionId().c_str()));
  423.                                                                 SetAnalogInputPressed(pActionInput->inputCRC, false);
  424.                                                         }
  425.                                                         break;
  426.                                                 }
  427.  
  428.                                                 const bool nullInputValue = (fabs_tpl(event.value) < 0.02f);
  429.                                                 if ((event.state == eIS_Pressed) || ((event.state == eIS_Changed) && !nullInputValue))
  430.                                                 {
  431.                                                         const string eventKeyName(eventKeyNameCStr);
  432.                                                         ActivateOutput(&m_pActInfo, EOP_PRESSED, eventKeyName);
  433.                                                 }
  434.                                                 else if ((event.state == eIS_Released) || ((event.state == eIS_Changed) && nullInputValue))
  435.                                                 {
  436.                                                         const string eventKeyName(eventKeyNameCStr);
  437.                                                         ActivateOutput(&m_pActInfo, EOP_RELEASED, eventKeyName);
  438.                                                 }
  439.  
  440.                                                 break;
  441.  
  442.                                         }
  443.                                 }
  444.                         }
  445.                 }
  446.  
  447.                 // return false, so other listeners get notification as well
  448.                 return false;
  449.         }
  450.  
  451.         virtual void GetMemoryUsage(ICrySizer* s) const
  452.         {
  453.                 s->Add(*this);
  454.         }
  455.  
  456.         virtual void OnAction(const ActionId& action, int activationMode, float value)
  457.         {
  458.                 const string& actionInput = GetPortString(&m_pActInfo, EIP_ACTION);
  459.                 const size_t colonIndex = actionInput.find_first_of(":");
  460.                 const string& actionMapName = actionInput.substr(0, colonIndex);
  461.                 const string& actionName = actionInput.substr(colonIndex + 1, (actionInput.length() - colonIndex));
  462.  
  463.                 const EntityId filterEntityId = m_pActInfo.pEntity ? m_pActInfo.pEntity->GetId() : INVALID_ENTITYID;
  464.  
  465.                 if (!actionMapName.empty() && !actionName.empty())
  466.                 {
  467.                         IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  468.                         if (pActionMapMgr)
  469.                         {
  470.                                 const IActionMap* pActionMap = pActionMapMgr->GetActionMap(actionMapName);
  471.                                 if (pActionMap && (filterEntityId == INVALID_ENTITYID || filterEntityId == pActionMap->GetActionListener()))
  472.                                 {
  473.                                         const IActionMapAction* pAction = pActionMap->GetAction(ActionId(actionName));
  474.                                         if (pAction && pAction->GetActionId() == action && (activationMode & (eAAM_Always | eAAM_OnHold)))
  475.                                         {
  476.                                                 ActivateOutput(&m_pActInfo, EOP_HOLD, actionName);
  477.                                         }
  478.                                 }
  479.                         }
  480.                 }
  481.         }
  482.  
  483.         bool GetAnalogInputPressed(uint32 actionCrc) const
  484.         {
  485.                 TAnalogInputsPressed::const_iterator it = m_analogInputPressed.find(actionCrc);
  486.                 if (it == m_analogInputPressed.end())
  487.                 {
  488.                         return false;
  489.                 }
  490.  
  491.                 return it->second;
  492.         }
  493.  
  494.         void SetAnalogInputPressed(uint32 actionCrc, bool state)
  495.         {
  496.                 m_analogInputPressed[actionCrc] = state;
  497.         }
  498.  
  499.         TAnalogInputsPressed m_analogInputPressed;
  500.         SActivationInfo      m_pActInfo;
  501.         bool                 m_bEnabled;
  502.         string               m_actionInputStr;
  503.         IActionMap*          m_pActionMap;
  504.         IActionMapAction*    m_pAction;
  505.         EntityId             m_filterEntityId;
  506. };
  507.  
  508. //////////////////////////////////////////////////////////////////////
  509. class CFlowNode_ActionMapManager : public CFlowBaseNode<eNCT_Instanced>
  510. {
  511.         enum EInputs
  512.         {
  513.                 EIP_ENABLE = 0,
  514.                 EIP_DISABLE,
  515.                 EIP_RESET
  516.         };
  517.  
  518.         enum EOutputs
  519.         {
  520.                 EOP_ENABLED = 0,
  521.                 EOP_DISABLED,
  522.         };
  523.  
  524. public:
  525.         CFlowNode_ActionMapManager(SActivationInfo* pActInfo)
  526.                 : m_pActInfo(pActInfo)
  527.         {
  528.         }
  529.  
  530.         ~CFlowNode_ActionMapManager()
  531.         {
  532.         }
  533.  
  534.         void GetConfiguration(SFlowNodeConfig& config)
  535.         {
  536.                 static const SInputPortConfig inputs[] =
  537.                 {
  538.                         InputPortConfig_Void("Enable",      _HELP("Trigger to enable action map manager")),
  539.                         InputPortConfig_Void("Disable",     _HELP("Trigger to disable action map manager")),
  540.                         InputPortConfig<bool>("ResetState", false,                                          _HELP("Reset state on disable")),
  541.                         { 0 }
  542.                 };
  543.  
  544.                 static const SOutputPortConfig outputs[] =
  545.                 {
  546.                         OutputPortConfig_Void("Enabled",  _HELP("Triggered when action map(s) got enabled")),
  547.                         OutputPortConfig_Void("Disabled", _HELP("Triggered when action map(s) got disabled")),
  548.                         { 0 }
  549.                 };
  550.  
  551.                 config.pInputPorts = inputs;
  552.                 config.pOutputPorts = outputs;
  553.                 config.sDescription = _HELP("FlowNode to enable/disable action map manager");
  554.                 config.SetCategory(EFLN_APPROVED);
  555.         }
  556.  
  557.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  558.         {
  559.                 return new CFlowNode_ActionMapManager(pActInfo);
  560.         }
  561.  
  562.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  563.         {
  564.                 m_pActInfo = pActInfo;
  565.                 switch (event)
  566.                 {
  567.                 case eFE_Activate:
  568.                         if (IsPortActive(pActInfo, EIP_ENABLE) || IsPortActive(pActInfo, EIP_DISABLE))
  569.                         {
  570.                                 const bool bReset = GetPortBool(pActInfo, EIP_RESET);
  571.                                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  572.  
  573.                                 if (pActionMapMgr)
  574.                                 {
  575.                                         pActionMapMgr->Enable(IsPortActive(pActInfo, EIP_ENABLE), bReset);
  576.                                 }
  577.                         }
  578.                         break;
  579.                 }
  580.         }
  581.  
  582.         virtual void GetMemoryUsage(ICrySizer* s) const
  583.         {
  584.                 s->Add(*this);
  585.         }
  586.  
  587. protected:
  588.         SActivationInfo* m_pActInfo;
  589. };
  590.  
  591. //////////////////////////////////////////////////////////////////////
  592. class CFlowNode_InputActionFilter : public CFlowBaseNode<eNCT_Instanced>
  593. {
  594.         enum EInputs
  595.         {
  596.                 EIP_ENABLE = 0,
  597.                 EIP_DISABLE,
  598.                 EIP_FILTER
  599.         };
  600.  
  601.         enum EOutputs
  602.         {
  603.                 EOP_ENABLED,
  604.                 EOP_DISABLED,
  605.         };
  606.  
  607. public:
  608.         CFlowNode_InputActionFilter(SActivationInfo* pActInfo)
  609.                 : m_bEnabled(false), m_pActInfo(pActInfo)
  610.         {
  611.         }
  612.  
  613.         ~CFlowNode_InputActionFilter()
  614.         {
  615.                 EnableFilter(false, false);
  616.         }
  617.  
  618.         void GetConfiguration(SFlowNodeConfig& config)
  619.         {
  620.                 static const SInputPortConfig inputs[] =
  621.                 {
  622.                         InputPortConfig_Void("Enable",                 _HELP("Trigger to enable ActionFilter")),
  623.                         InputPortConfig_Void("Disable",                _HELP("Trigger to disable ActionFilter")),
  624.                         InputPortConfig<string>("actionFilter_Filter", _HELP("Select Action Filter"),            0),
  625.                         { 0 }
  626.                 };
  627.                 static const SOutputPortConfig outputs[] =
  628.                 {
  629.                         OutputPortConfig_Void("Enabled",  _HELP("Triggered when enabled.")),
  630.                         OutputPortConfig_Void("Disabled", _HELP("Triggered when disabled.")),
  631.                         { 0 }
  632.                 };
  633.  
  634.                 config.pInputPorts = inputs;
  635.                 config.pOutputPorts = outputs;
  636.                 config.sDescription = _HELP("FlowNode to enable/disable ActionFilters");
  637.                 config.SetCategory(EFLN_ADVANCED);
  638.         }
  639.  
  640.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  641.         {
  642.                 return new CFlowNode_InputActionFilter(pActInfo);
  643.         }
  644.  
  645.         void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  646.         {
  647.                 m_pActInfo = pActInfo;
  648.                 // disable on reading
  649.                 if (ser.IsReading())
  650.                         EnableFilter(false);
  651.                 ser.Value("m_filterName", m_filterName);
  652.                 // on saving we ask the ActionMapManager if the filter is enabled
  653.                 // so, all basically all nodes referring to the same filter will write the correct (current) value
  654.                 // on quickload, all of them or none of them will enable/disable the filter again
  655.                 // maybe use a more central location for this
  656.                 if (ser.IsWriting())
  657.                 {
  658.                         bool bWroteIt = false;
  659.                         IActionMapManager* pAMMgr = gEnv->pGameFramework->GetIActionMapManager();
  660.                         if (pAMMgr && m_filterName.empty() == false)
  661.                         {
  662.                                 IActionFilter* pFilter = pAMMgr->GetActionFilter(m_filterName.c_str());
  663.                                 if (pFilter)
  664.                                 {
  665.                                         bool bIsEnabled = pAMMgr->IsFilterEnabled(m_filterName.c_str());
  666.                                         ser.Value("m_bEnabled", bIsEnabled);
  667.                                         bWroteIt = true;
  668.                                 }
  669.                         }
  670.                         if (!bWroteIt)
  671.                                 ser.Value("m_bEnabled", m_bEnabled);
  672.                 }
  673.                 else
  674.                 {
  675.                         ser.Value("m_bEnabled", m_bEnabled);
  676.                 }
  677.                 // re-enable
  678.                 if (ser.IsReading())
  679.                         EnableFilter(m_bEnabled);
  680.         }
  681.  
  682.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  683.         {
  684.                 m_pActInfo = pActInfo;
  685.  
  686.                 switch (event)
  687.                 {
  688.                 case eFE_Initialize:
  689.                         {
  690.                                 EnableFilter(false);
  691.                                 m_filterName = GetPortString(pActInfo, EIP_FILTER);
  692.                         }
  693.                         break;
  694.  
  695.                 case eFE_Activate:
  696.                         {
  697.                                 if (IsPortActive(pActInfo, EIP_FILTER))
  698.                                 {
  699.                                         m_filterName = GetPortString(pActInfo, EIP_FILTER);
  700.                                 }
  701.                                 else
  702.                                 {
  703.                                         EnableFilter(IsPortActive(pActInfo, EIP_ENABLE));
  704.                                 }
  705.                         }
  706.                         break;
  707.                 }
  708.         }
  709.  
  710.         void EnableFilter(bool bEnable, bool bActivateOutput = true)
  711.         {
  712.                 if (m_filterName.empty())
  713.                         return;
  714.  
  715.                 m_bEnabled = bEnable;
  716.  
  717.                 IActionMapManager* pAMMgr = gEnv->pGameFramework->GetIActionMapManager();
  718.                 if (pAMMgr)
  719.                 {
  720.                         pAMMgr->EnableFilter(m_filterName, bEnable);
  721.                         if (bActivateOutput && m_pActInfo && m_pActInfo->pGraph)
  722.                         {
  723.                                 ActivateOutput(m_pActInfo, bEnable ? EOP_ENABLED : EOP_DISABLED, 1);
  724.                         }
  725.                 }
  726.         }
  727.  
  728.         virtual void GetMemoryUsage(ICrySizer* s) const
  729.         {
  730.                 s->Add(*this);
  731.         }
  732.  
  733. protected:
  734.         bool             m_bEnabled;
  735.         string           m_filterName; // we need to store this name, as it the d'tor we need to disable the filter, but don't have access to port names
  736.         SActivationInfo* m_pActInfo;
  737. };
  738.  
  739. //////////////////////////////////////////////////////////////////////
  740. class CFlowNode_ActionMap : public CFlowBaseNode<eNCT_Instanced>
  741. {
  742.         enum INPUTS
  743.         {
  744.                 EIP_ENABLE = 0,
  745.                 EIP_DISABLE,
  746.                 EIP_EXCEPT,
  747.                 EIP_ACTIONMAP
  748.         };
  749.  
  750.         enum OUTPUTS
  751.         {
  752.                 EOP_ENABLED = 0,
  753.                 EOP_DISABLED,
  754.         };
  755.  
  756. public:
  757.         CFlowNode_ActionMap(SActivationInfo* pActInfo)
  758.                 : m_pActInfo(pActInfo)
  759.         {
  760.         }
  761.  
  762.         ~CFlowNode_ActionMap()
  763.         {
  764.         }
  765.  
  766.         void GetConfiguration(SFlowNodeConfig& config)
  767.         {
  768.                 static const SInputPortConfig inputs[] =
  769.                 {
  770.                         InputPortConfig_Void("Enable",                  _HELP("Enable selected action map")),
  771.                         InputPortConfig_Void("Disable",                 _HELP("Disable selected action map")),
  772.                         InputPortConfig<bool>("Except",                 true,                                 _HELP("disables all other existing action maps if set to true")),
  773.                         InputPortConfig<string>("actionMaps_ActionMap", _HELP("Action Map"),                  _HELP("ActionMap")),
  774.                         { 0 }
  775.                 };
  776.  
  777.                 static const SOutputPortConfig outputs[] =
  778.                 {
  779.                         OutputPortConfig_Void("Enabled",  _HELP("Triggered when action map got enabled")),
  780.                         OutputPortConfig_Void("Disabled", _HELP("Triggered when action map got disabled")),
  781.                         { 0 }
  782.                 };
  783.  
  784.                 config.nFlags |= EFLN_TARGET_ENTITY;
  785.                 config.pInputPorts = inputs;
  786.                 config.pOutputPorts = outputs;
  787.                 config.sDescription = _HELP("FlowNode to enable/disable actionmaps");
  788.                 config.SetCategory(EFLN_APPROVED);
  789.         }
  790.  
  791.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  792.         {
  793.                 return new CFlowNode_ActionMap(pActInfo);
  794.         }
  795.  
  796.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  797.         {
  798.                 m_pActInfo = pActInfo;
  799.                 switch (event)
  800.                 {
  801.                 case eFE_Activate:
  802.                         if (IsPortActive(pActInfo, EIP_ENABLE) || IsPortActive(pActInfo, EIP_DISABLE))
  803.                         {
  804.                                 const bool bExcept = GetPortBool(pActInfo, EIP_EXCEPT);
  805.                                 const bool bEnable = IsPortActive(pActInfo, EIP_ENABLE);
  806.                                 const string actionMapName = GetPortString(pActInfo, EIP_ACTIONMAP);
  807.                                 IActionMapManager* pActionMapMgr = CCryAction::GetCryAction()->GetIActionMapManager();
  808.  
  809.                                 if (bExcept)
  810.                                 {
  811.                                         IActionMapIteratorPtr pActionMapIter = pActionMapMgr->CreateActionMapIterator();
  812.                                         while (IActionMap* pActionMap = pActionMapIter->Next())
  813.                                         {
  814.                                                 if (!strcmp(pActionMap->GetName(), actionMapName))
  815.                                                 {
  816.                                                         pActionMap->Enable(bEnable);
  817.                                                 }
  818.                                                 else
  819.                                                 {
  820.                                                         pActionMap->Enable(false);
  821.                                                 }
  822.                                         }
  823.                                 }
  824.  
  825.                                 if (pActionMapMgr && !actionMapName.empty())
  826.                                 {
  827.                                         if (IActionMap* pActionMap = pActionMapMgr->GetActionMap(actionMapName))
  828.                                         {
  829.                                                 pActionMap->Enable(bEnable);
  830.  
  831.                                                 if (pActInfo->pEntity)
  832.                                                 {
  833.                                                         pActionMap->SetActionListener(pActInfo->pEntity->GetId());
  834.                                                 }
  835.  
  836.                                                 if (bEnable)
  837.                                                 {
  838.                                                         ActivateOutput(pActInfo, EOP_ENABLED, 1);
  839.                                                 }
  840.                                                 else
  841.                                                 {
  842.                                                         ActivateOutput(pActInfo, EOP_DISABLED, 1);
  843.                                                 }
  844.                                         }
  845.                                 }
  846.                         }
  847.                         break;
  848.                 }
  849.         }
  850.  
  851.         virtual void GetMemoryUsage(ICrySizer* s) const
  852.         {
  853.                 s->Add(*this);
  854.         }
  855.  
  856. protected:
  857.         SActivationInfo* m_pActInfo;
  858. };
  859.  
  860. REGISTER_FLOW_NODE("Input:ActionMaps:SetDefaultActionEntity", CFlowNode_SetDefaultActionEntity);
  861. REGISTER_FLOW_NODE("Input:ActionMaps:GetDefaultActionEntity", CFlowNode_GetDefaultActionEntity);
  862. REGISTER_FLOW_NODE("Input:ActionMaps:ActionListener", CFlowNode_InputActionListener);
  863. REGISTER_FLOW_NODE("Input:ActionMaps:ActionMapManager", CFlowNode_ActionMapManager);
  864. REGISTER_FLOW_NODE("Input:ActionMaps:ActionFilter", CFlowNode_InputActionFilter);
  865. REGISTER_FLOW_NODE("Input:ActionMaps:ActionMap", CFlowNode_ActionMap);
  866.  
downloadFlowActionMapNodes.cpp 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