BVB Source Codes

CRYENGINE Show FlowInputNode.cpp Source code

Return Download CRYENGINE: download FlowInputNode.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   FlowInputNode.cpp
  5. //  Version:     v1.00
  6. //  Created:     13/10/2006 by AlexL.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //  24.09.2012 - Dario Sancho
  12. //               * Added new node ForceFeedbackTriggerTweaker (for Durango)
  13. //
  14. //  28.08.2015 - Marco Hopp
  15. //               * Deprecated Input:ActionMapManager, Input:ActionListener, Input:ActionFilter
  16. //               * new versions of those nodes can be found in FlowActionMapNodes.cpp
  17. //               * TODO: Remove this code at next major release
  18. //
  19. ////////////////////////////////////////////////////////////////////////////
  20.  
  21. #include "StdAfx.h"
  22. #include "ActionMap.h"
  23. #include "FlowFrameworkBaseNode.h"
  24. #include "ForceFeedbackSystem/ForceFeedbackSystem.h"
  25.  
  26. #include <CryAction.h>
  27. #include <CryActionCVars.h>
  28. #include <CryInput/IInput.h>
  29. #include <IGameObjectSystem.h>
  30. #include <CryString/StringUtils.h>
  31.  
  32. class CFlowNode_InputKey : public CFlowFrameworkBaseNode<eNCT_Instanced>, public IInputEventListener
  33. {
  34.         enum INPUTS
  35.         {
  36.                 EIP_ENABLE = 0,
  37.                 EIP_DISABLE,
  38.                 EIP_KEY,
  39.                 EIP_NONDEVMODE,
  40.         };
  41.  
  42.         enum OUTPUTS
  43.         {
  44.                 EOP_PRESSED,
  45.                 EOP_RELEASED,
  46.         };
  47.  
  48. public:
  49.         CFlowNode_InputKey(SActivationInfo* pActInfo) : m_bActive(false), m_bAllowedInNonDevMode(false)
  50.         {
  51.                 m_eventKeyName.resize(64); // avoid delete/re-newing during execution - assuming no action keys are longer than 64 char
  52.         }
  53.  
  54.         ~CFlowNode_InputKey()
  55.         {
  56.                 Register(false, 0);
  57.         }
  58.  
  59.         void GetConfiguration(SFlowNodeConfig& config)
  60.         {
  61.                 // declare input ports
  62.                 static const SInputPortConfig inputs[] =
  63.                 {
  64.                         InputPortConfig_Void("Enable",      _HELP("Trigger to enable. Default: Already enabled.")),
  65.                         InputPortConfig_Void("Disable",     _HELP("Trigger to disable")),
  66.                         InputPortConfig<string>("Key",      _HELP("Key name. Leave empty for any.")),
  67.                         InputPortConfig<bool>("NonDevMode", false,                                                 _HELP("If set to true, can be used in Non-Devmode as well [Debugging backdoor]")),
  68.                         { 0 }
  69.                 };
  70.                 static const SOutputPortConfig outputs[] =
  71.                 {
  72.                         OutputPortConfig<string>("Pressed",  _HELP("Key pressed.")),
  73.                         OutputPortConfig<string>("Released", _HELP("Key released.")),
  74.                         { 0 }
  75.                 };
  76.  
  77.                 config.nFlags |= EFLN_TARGET_ENTITY;
  78.                 config.pInputPorts = inputs;
  79.                 config.pOutputPorts = outputs;
  80.                 config.sDescription = _HELP("FlowNode to catch key inputs. Use only for debugging. It is enabled by default. Entity Input need to be used in multiplayer.");
  81.                 config.SetCategory(EFLN_DEBUG);
  82.         }
  83.  
  84.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  85.         {
  86.                 return new CFlowNode_InputKey(pActInfo);
  87.         }
  88.  
  89.         void Register(bool bRegister, SActivationInfo* pActInfo)
  90.         {
  91.                 IInput* pInput = gEnv->pInput;
  92.                 if (pInput)
  93.                 {
  94.                         if (bRegister)
  95.                         {
  96.                                 assert(pActInfo != 0);
  97.                                 m_bAllowedInNonDevMode = GetPortBool(pActInfo, EIP_NONDEVMODE);
  98.                                 if (gEnv->pSystem->IsDevMode() || m_bAllowedInNonDevMode)
  99.                                         pInput->AddEventListener(this);
  100.                         }
  101.                         else
  102.                                 pInput->RemoveEventListener(this);
  103.                 }
  104.                 m_bActive = bRegister;
  105.         }
  106.  
  107.         void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  108.         {
  109.                 ser.Value("m_bActive", m_bActive);
  110.                 if (ser.IsReading())
  111.                 {
  112.                         Register(m_bActive, pActInfo);
  113.                 }
  114.         }
  115.  
  116.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  117.         {
  118.                 if (InputEntityIsLocalPlayer(pActInfo))
  119.                 {
  120.                         switch (event)
  121.                         {
  122.                         case eFE_Initialize:
  123.                                 m_actInfo = *pActInfo;
  124.                                 Register(true, pActInfo);
  125.                                 break;
  126.                         case eFE_Activate:
  127.                                 m_actInfo = *pActInfo;
  128.                                 if (IsPortActive(pActInfo, EIP_DISABLE))
  129.                                         Register(false, pActInfo);
  130.                                 if (IsPortActive(pActInfo, EIP_ENABLE))
  131.                                         Register(true, pActInfo);
  132.                                 break;
  133.                         }
  134.                 }
  135.         }
  136.  
  137.         virtual bool OnInputEvent(const SInputEvent& event)
  138.         {
  139.                 // Kevin - Ignore if console is up
  140.                 if (gEnv->pConsole->IsOpened())
  141.                         return false;
  142.  
  143.                 m_eventKeyName = event.keyName.c_str();
  144.  
  145.                 const string& keyName = GetPortString(&m_actInfo, EIP_KEY);
  146.  
  147.                 if (keyName.empty() == false)
  148.                 {
  149.                         if (stricmp(keyName.c_str(), m_eventKeyName.c_str()) != 0)
  150.                                 return false;
  151.                 }
  152.  
  153.                 if (gEnv->pSystem->IsDevMode() && !gEnv->IsEditor() && CCryActionCVars::Get().g_disableInputKeyFlowNodeInDevMode != 0 && !m_bAllowedInNonDevMode)
  154.                         return false;
  155.  
  156.                 const bool nullInputValue = (fabs_tpl(event.value) < 0.02f);
  157.                 if ((event.state == eIS_Pressed) || ((event.state == eIS_Changed) && !nullInputValue))
  158.                         ActivateOutput(&m_actInfo, EOP_PRESSED, m_eventKeyName);
  159.                 else if ((event.state == eIS_Released) || ((event.state == eIS_Changed) && !nullInputValue))
  160.                         ActivateOutput(&m_actInfo, EOP_RELEASED, m_eventKeyName);
  161.  
  162.                 // return false, so other listeners get notification as well
  163.                 return false;
  164.         }
  165.  
  166.         virtual void GetMemoryUsage(ICrySizer* s) const
  167.         {
  168.                 s->Add(*this);
  169.         }
  170.  
  171.         SActivationInfo m_actInfo;
  172.         bool            m_bActive;
  173.         bool            m_bAllowedInNonDevMode;
  174.         string          m_eventKeyName; // string is necessary for ActivateOutput, and it allocates in heap - so we use a member var for it
  175. };
  176.  
  177. //////////////////////////////////////////////////////////////////////////
  178.  
  179. class CFlowNode_ForceFeedback : public CFlowFrameworkBaseNode<eNCT_Singleton>
  180. {
  181.         enum INPUTS
  182.         {
  183.                 eIP_EffectName = 0,
  184.                 eIP_Play,
  185.                 eIP_Intensity,
  186.                 eIP_Delay,
  187.                 eIP_Stop,
  188.                 eIP_StopAll
  189.         };
  190.  
  191. public:
  192.         CFlowNode_ForceFeedback(SActivationInfo* pActInfo){}
  193.  
  194.         void GetConfiguration(SFlowNodeConfig& config)
  195.         {
  196.                 // declare input ports
  197.                 static const SInputPortConfig inputs[] =
  198.                 {
  199.                         InputPortConfig<string>("EffectName", _HELP("Name of the force feedback effect to be played/stopped"), _HELP("Effect Name"),                                          _UICONFIG("enum_global:forceFeedback")),
  200.                         InputPortConfig_Void("Play",          _HELP("Play the specified effect")),
  201.                         InputPortConfig<float>("Intensity",   1.f,                                                             _HELP("Intensity factor applied to the effect being played")),
  202.                         InputPortConfig<float>("Delay",       0.f,                                                             _HELP("Time delay to start the effect")),
  203.                         InputPortConfig_Void("Stop",          _HELP("Stop the specified effect")),
  204.                         InputPortConfig_Void("StopAll",       _HELP("Stop all currently playing force feedback effects")),
  205.                         { 0 }
  206.                 };
  207.                 static const SOutputPortConfig outputs[] =
  208.                 {
  209.                         { 0 }
  210.                 };
  211.  
  212.                 config.nFlags |= EFLN_TARGET_ENTITY;
  213.                 config.pInputPorts = inputs;
  214.                 config.pOutputPorts = outputs;
  215.                 config.sDescription = _HELP("FlowNode to play/stop force feedback effects");
  216.                 config.SetCategory(EFLN_APPROVED);
  217.         }
  218.  
  219.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  220.         {
  221.                 switch (event)
  222.                 {
  223.                 case eFE_Activate:
  224.                         {
  225.                                 if (InputEntityIsLocalPlayer(pActInfo))
  226.                                 {
  227.                                         IForceFeedbackSystem* pForceFeedback = gEnv->pGameFramework->GetIForceFeedbackSystem();
  228.  
  229.                                         if (IsPortActive(pActInfo, eIP_Play))
  230.                                         {
  231.                                                 const string effectName = GetPortString(pActInfo, eIP_EffectName);
  232.                                                 ForceFeedbackFxId fxId = pForceFeedback->GetEffectIdByName(effectName);
  233.                                                 const float intensity = GetPortFloat(pActInfo, eIP_Intensity);
  234.                                                 const float delay = GetPortFloat(pActInfo, eIP_Delay);
  235.                                                 pForceFeedback->PlayForceFeedbackEffect(fxId, SForceFeedbackRuntimeParams(intensity, delay));
  236.                                         }
  237.                                         if (IsPortActive(pActInfo, eIP_Stop))
  238.                                         {
  239.                                                 const string effectName = GetPortString(pActInfo, eIP_EffectName);
  240.                                                 ForceFeedbackFxId fxId = pForceFeedback->GetEffectIdByName(effectName);
  241.                                                 pForceFeedback->StopForceFeedbackEffect(fxId);
  242.                                         }
  243.                                         if (IsPortActive(pActInfo, eIP_StopAll))
  244.                                         {
  245.                                                 pForceFeedback->StopAllEffects();
  246.                                         }
  247.                                 }
  248.                                 break;
  249.                         }
  250.                 }
  251.         }
  252.  
  253.         virtual void GetMemoryUsage(ICrySizer* s) const
  254.         {
  255.                 s->Add(*this);
  256.         }
  257. };
  258.  
  259. //////////////////////////////////////////////////////////////////////////
  260. class CFlowNode_ForceFeedbackTweaker : public CFlowBaseNode<eNCT_Singleton>
  261. {
  262.         enum INPUTS
  263.         {
  264.                 eIP_LowPassMultiplier,
  265.                 eIP_HighPassMultiplier,
  266.                 eIP_Start,
  267.                 eIP_Stop,
  268.         };
  269.  
  270. public:
  271.         CFlowNode_ForceFeedbackTweaker(SActivationInfo* pActInfo){}
  272.  
  273.         void GetConfiguration(SFlowNodeConfig& config)
  274.         {
  275.                 // declare input ports
  276.                 static const SInputPortConfig inputs[] =
  277.                 {
  278.                         InputPortConfig<float>("LowPass",     1.f,                                             _HELP("Multiplier applied to the low frequencey effect being played")),
  279.                         InputPortConfig<float>("HighPass",    1.f,                                             _HELP("Multiplier applied to the high frequencey effect being played")),
  280.                         InputPortConfig_AnyType("Activate",   _HELP("activate the forcefeedback tweaker")),
  281.                         InputPortConfig_AnyType("Deactivate", _HELP("deactivate the force feedback tweaker")),
  282.                         { 0 }
  283.                 };
  284.  
  285.                 config.nFlags |= EFLN_TARGET_ENTITY;
  286.                 config.pInputPorts = inputs;
  287.                 config.sDescription = _HELP("FlowNode to control individual high and low frequency force feedback effect");
  288.                 config.SetCategory(EFLN_APPROVED);
  289.         }
  290.  
  291.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  292.         {
  293.                 switch (event)
  294.                 {
  295.                 case eFE_Activate:
  296.                         {
  297.                                 if (IsPortActive(pActInfo, eIP_Start))
  298.                                 {
  299.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  300.                                 }
  301.                                 if (IsPortActive(pActInfo, eIP_Stop))
  302.                                 {
  303.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  304.                                 }
  305.                                 break;
  306.                         }
  307.  
  308.                 case eFE_Update:
  309.                         {
  310.                                 IForceFeedbackSystem* pForceFeedback = gEnv->pGameFramework->GetIForceFeedbackSystem();
  311.                                 if (pForceFeedback)
  312.                                 {
  313.                                         pForceFeedback->AddFrameCustomForceFeedback(GetPortFloat(pActInfo, eIP_HighPassMultiplier), GetPortFloat(pActInfo, eIP_LowPassMultiplier));
  314.                                 }
  315.                                 break;
  316.                         }
  317.                 }
  318.         }
  319.  
  320.         virtual void GetMemoryUsage(ICrySizer* s) const
  321.         {
  322.                 s->Add(*this);
  323.         }
  324. };
  325.  
  326. REGISTER_FLOW_NODE("Debug:InputKey", CFlowNode_InputKey);
  327. REGISTER_FLOW_NODE("Game:ForceFeedback", CFlowNode_ForceFeedback);
  328. REGISTER_FLOW_NODE("Game:ForceFeedbackTweaker", CFlowNode_ForceFeedbackTweaker);
  329.  
downloadFlowInputNode.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