BVB Source Codes

CRYENGINE Show MaterialHUDFXNodes.cpp Source code

Return Download CRYENGINE: download MaterialHUDFXNodes.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:   MaterialHUDFXNodes.cpp
  5. //  Version:     v1.00
  6. //  Created:     29-11-2006 by AlexL - Benito GR
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15. #include "MaterialEffects.h"
  16. #include <CryFlowGraph/IFlowBaseNode.h>
  17. #include <CrySystem/Scaleform/IFlashPlayer.h>
  18.  
  19. //CHUDStartFXNode
  20. //Special node that let us trigger a FlowGraph HUD effect related to
  21. //some kind of material, impact, explosion...
  22. class CHUDStartFXNode : public CFlowBaseNode<eNCT_Singleton>
  23. {
  24. public:
  25.         CHUDStartFXNode(SActivationInfo* pActInfo)
  26.         {
  27.         }
  28.  
  29.         ~CHUDStartFXNode()
  30.         {
  31.         }
  32.  
  33.         enum
  34.         {
  35.                 EIP_Trigger = 0,
  36.         };
  37.  
  38.         enum
  39.         {
  40.                 EOP_Started = 0,
  41.                 EOP_Distance,
  42.                 EOP_Param1,
  43.                 EOP_Param2,
  44.                 EOP_Intensity,
  45.         };
  46.  
  47.         virtual void GetMemoryUsage(ICrySizer* s) const
  48.         {
  49.                 s->Add(*this);
  50.         }
  51.  
  52.         void GetConfiguration(SFlowNodeConfig& config)
  53.         {
  54.                 static const SInputPortConfig in_config[] = {
  55.                         InputPortConfig_Void("Start", _HELP("Triggered automatically by MaterialEffects")),
  56.                         { 0 }
  57.                 };
  58.                 static const SOutputPortConfig out_config[] = {
  59.                         OutputPortConfig_Void("Started",        _HELP("Triggered when Effect is started.")),
  60.                         OutputPortConfig<float>("Distance",     _HELP("Distance to player")),
  61.                         OutputPortConfig<float>("Param1",       _HELP("MFX Custom Param 1")),
  62.                         OutputPortConfig<float>("Param2",       _HELP("MFX Custom Param 2")),
  63.                         OutputPortConfig<float>("Intensity",    _HELP("Dynamic value set from game code (0.0 - 1.0)")),
  64.                         OutputPortConfig<float>("BlendOutTime", _HELP("Outputs time value in seconds; request to blend out FX in that time")),
  65.                         { 0 }
  66.                 };
  67.                 config.sDescription = _HELP("MaterialFX StartNode");
  68.                 config.pInputPorts = in_config;
  69.                 config.pOutputPorts = out_config;
  70.                 config.SetCategory(EFLN_APPROVED);
  71.         }
  72.  
  73.         //Just activate the output when the input is activated
  74.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  75.         {
  76.                 switch (event)
  77.                 {
  78.                 case eFE_Initialize:
  79.                         break;
  80.                 case eFE_Activate:
  81.                         if (IsPortActive(pActInfo, EIP_Trigger))
  82.                                 ActivateOutput(pActInfo, EOP_Started, true);
  83.                         break;
  84.                 }
  85.         }
  86.  
  87. };
  88.  
  89. //CHUDEndFXNode
  90. //Special node that let us know when the FlowGraph HUD Effect has finish
  91. class CHUDEndFXNode : public CFlowBaseNode<eNCT_Singleton>
  92. {
  93. public:
  94.         CHUDEndFXNode(SActivationInfo* pActInfo)
  95.         {
  96.         }
  97.  
  98.         ~CHUDEndFXNode()
  99.         {
  100.         }
  101.  
  102.         enum
  103.         {
  104.                 EIP_Trigger = 0,
  105.         };
  106.  
  107.         void GetConfiguration(SFlowNodeConfig& config)
  108.         {
  109.                 static const SInputPortConfig in_config[] = {
  110.                         InputPortConfig_Void("Trigger", _HELP("Trigger to mark end of effect.")),
  111.                         { 0 }
  112.                 };
  113.                 config.sDescription = _HELP("MaterialFX EndNode");
  114.                 config.pInputPorts = in_config;
  115.                 config.pOutputPorts = 0;
  116.                 config.SetCategory(EFLN_APPROVED);
  117.         }
  118.  
  119.         //When activated, just notify the MaterialFGManager that the effect ended
  120.         //See MaterialFGManager.cpp
  121.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  122.         {
  123.                 switch (event)
  124.                 {
  125.                 case eFE_Initialize:
  126.                         break;
  127.                 case eFE_Activate:
  128.                         if (IsPortActive(pActInfo, EIP_Trigger))
  129.                         {
  130.                                 CMaterialEffects* pMatFX = static_cast<CMaterialEffects*>(gEnv->pGameFramework->GetIMaterialEffects());
  131.                                 if (pMatFX)
  132.                                 {
  133.                                         //const string& name = GetPortString(pActInfo, EIP_Name);
  134.                                         pMatFX->NotifyFGHudEffectEnd(pActInfo->pGraph);
  135.                                 }
  136.                         }
  137.                         break;
  138.                 }
  139.         }
  140.  
  141.         virtual void GetMemoryUsage(ICrySizer* s) const
  142.         {
  143.                 s->Add(*this);
  144.         }
  145. };
  146.  
  147. class CMaterialFlashInvokeNode : public CFlowBaseNode<eNCT_Singleton>
  148. {
  149. public:
  150.         CMaterialFlashInvokeNode(SActivationInfo* pActInfo)
  151.         {
  152.         }
  153.  
  154.         ~CMaterialFlashInvokeNode()
  155.         {
  156.         }
  157.  
  158.         enum
  159.         {
  160.                 EIP_Trigger = 0,
  161.                 EIP_Function,
  162.                 EIP_Int,
  163.                 EIP_Float,
  164.         };
  165.  
  166.         void GetConfiguration(SFlowNodeConfig& config)
  167.         {
  168.                 static const SInputPortConfig in_config[] = {
  169.                         InputPortConfig_Void("Trigger",     _HELP("Trigger the Invoke.")),
  170.                         InputPortConfig<string>("Function", _HELP("Function Name")),
  171.                         InputPortConfig<int>("Integer",     0,                            _HELP("INTEGER parameter")),
  172.                         InputPortConfig<float>("Float",     0.0f,                         _HELP("FLOAT parameter")),
  173.                         { 0 }
  174.                 };
  175.                 config.nFlags |= EFLN_TARGET_ENTITY;
  176.                 config.sDescription = _HELP("Material Flash Invoke");
  177.                 config.pInputPorts = in_config;
  178.                 config.pOutputPorts = 0;
  179.                 config.SetCategory(EFLN_APPROVED);
  180.         }
  181.  
  182.         static IFlashPlayer* GetFlashPlayerFromMaterial(IMaterial* pMaterial)
  183.         {
  184.                 IFlashPlayer* pRetFlashPlayer(NULL);
  185.                 const SShaderItem& shaderItem(pMaterial->GetShaderItem());
  186.                 if (shaderItem.m_pShaderResources)
  187.                 {
  188.                         SEfResTexture* pTex = shaderItem.m_pShaderResources->GetTexture(0);
  189.                         if (pTex)
  190.                         {
  191.                                 IDynTextureSource* pDynTexSrc = pTex->m_Sampler.m_pDynTexSource;
  192.                                 if (pDynTexSrc)
  193.                                         pRetFlashPlayer = (IFlashPlayer*) pDynTexSrc->GetSourceTemp(IDynTextureSource::DTS_I_FLASHPLAYER);
  194.                         }
  195.                 }
  196.  
  197.                 return pRetFlashPlayer;
  198.         }
  199.  
  200.         static IFlashPlayer* GetFlashPlayerFromMaterialIncludingSubMaterials(IMaterial* pMaterial)
  201.         {
  202.                 IFlashPlayer* pRetFlashPlayer = CMaterialFlashInvokeNode::GetFlashPlayerFromMaterial(pMaterial);
  203.  
  204.                 const int subMtlCount = pMaterial->GetSubMtlCount();
  205.                 for (int i = 0; i != subMtlCount; ++i)
  206.                 {
  207.                         IMaterial* pSubMat = pMaterial->GetSubMtl(i);
  208.                         if (!pSubMat)
  209.                         {
  210.                                 continue;
  211.                         }
  212.  
  213.                         IFlashPlayer* pFlashPlayer = CMaterialFlashInvokeNode::GetFlashPlayerFromMaterial(pSubMat);
  214.                         if (pFlashPlayer)
  215.                         {
  216.                                 if (pRetFlashPlayer)
  217.                                 {
  218.                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "GetFlashPlayerFromMaterialIncludingSubMaterials: Multiple flash players detected, returning last sub material one");
  219.                                         pRetFlashPlayer->Release();
  220.                                 }
  221.  
  222.                                 pRetFlashPlayer = pFlashPlayer;
  223.                         }
  224.                 }
  225.  
  226.                 return pRetFlashPlayer;
  227.         }
  228.  
  229.         //When activated, just notify the MaterialFGManager that the effect ended
  230.         //See MaterialFGManager.cpp
  231.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  232.         {
  233.                 switch (event)
  234.                 {
  235.                 case eFE_Initialize:
  236.                         break;
  237.                 case eFE_Activate:
  238.                         if (IsPortActive(pActInfo, EIP_Trigger))
  239.                         {
  240.                                 if (pActInfo->pEntity)
  241.                                 {
  242.                                         IEntityRender* pIEntityRender(pActInfo->pEntity->GetRenderInterface());
  243.  
  244.                                        
  245.                                         {
  246.                                                 IMaterial* pMtl(pIEntityRender->GetRenderMaterial(-1)); // material will be taken from the first renderable slot.
  247.                                                 if (pMtl)
  248.                                                 {
  249.                                                         IFlashPlayer* pFlashPlayer = CMaterialFlashInvokeNode::GetFlashPlayerFromMaterialIncludingSubMaterials(pMtl);
  250.                                                         if (pFlashPlayer)
  251.                                                         {
  252.                                                                 const string& funcName = GetPortString(pActInfo, EIP_Function);
  253.                                                                 SFlashVarValue args[2] = { GetPortInt(pActInfo, EIP_Int), GetPortFloat(pActInfo, EIP_Float) };
  254.                                                                 pFlashPlayer->Invoke(funcName.c_str(), args, 2);
  255.                                                                 pFlashPlayer->Release();
  256.                                                         }
  257.                                                 }
  258.                                         }
  259.                                 }
  260.                         }
  261.                         break;
  262.                 }
  263.         }
  264.  
  265.         virtual void GetMemoryUsage(ICrySizer* s) const
  266.         {
  267.                 s->Add(*this);
  268.         }
  269. };
  270.  
  271. class CMaterialFlashGotoAndPlayNode : public CFlowBaseNode<eNCT_Singleton>
  272. {
  273. public:
  274.         CMaterialFlashGotoAndPlayNode(SActivationInfo* pActInfo)
  275.         {
  276.         }
  277.  
  278.         ~CMaterialFlashGotoAndPlayNode()
  279.         {
  280.         }
  281.  
  282.         enum INPUTS
  283.         {
  284.                 EIP_Trigger = 0,
  285.                 EIP_ObjectPath,
  286.                 EIP_FrameName,
  287.                 EIP_FrameNumber,
  288.         };
  289.  
  290.         enum OUTPUTS
  291.         {
  292.                 EOP_Done = 0,
  293.         };
  294.  
  295.         void GetConfiguration(SFlowNodeConfig& config)
  296.         {
  297.                 static const SInputPortConfig in_ports[] = {
  298.                         InputPortConfig_Void("Trigger",       _HELP("Trigger the Invoke.")),
  299.                         InputPortConfig<string>("ObjectPath", _HELP("Full path to flash object")),
  300.                         InputPortConfig<string>("FrameName",  _HELP("Name of flash frame to goto")),
  301.                         InputPortConfig<int>("FrameNumber",   -1,                                   _HELP("Number of flash frame to goto (If not using FrameName)")),
  302.                         { 0 }
  303.                 };
  304.  
  305.                 static const SOutputPortConfig out_ports[] =
  306.                 {
  307.                         OutputPortConfig_Void("Done", _HELP("When triggered")),
  308.                         { 0 }
  309.                 };
  310.  
  311.                 config.nFlags |= EFLN_TARGET_ENTITY;
  312.                 config.sDescription = _HELP("Material Flash GotoAndPlay");
  313.                 config.pInputPorts = in_ports;
  314.                 config.pOutputPorts = out_ports;
  315.                 config.SetCategory(EFLN_APPROVED);
  316.         }
  317.  
  318.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  319.         {
  320.                 switch (event)
  321.                 {
  322.                 case eFE_Activate:
  323.                         if (IsPortActive(pActInfo, EIP_Trigger))
  324.                         {
  325.                                 if (pActInfo->pEntity)
  326.                                 {
  327.                                         IEntityRender* pIEntityRender(pActInfo->pEntity->GetRenderInterface());
  328.  
  329.                                        
  330.                                         {
  331.                                                 IMaterial* pMtl(pIEntityRender->GetRenderMaterial(-1)); // material will be taken from the first renderable slot.
  332.                                                 if (pMtl)
  333.                                                 {
  334.                                                         IFlashPlayer* pFlashPlayer = CMaterialFlashInvokeNode::GetFlashPlayerFromMaterialIncludingSubMaterials(pMtl);
  335.                                                         if (pFlashPlayer)
  336.                                                         {
  337.                                                                 const string& objectPath = GetPortString(pActInfo, EIP_ObjectPath);
  338.                                                                 if (!objectPath.empty())
  339.                                                                 {
  340.                                                                         IFlashVariableObject* pFlashObject = NULL;
  341.                                                                         pFlashPlayer->GetVariable(objectPath.c_str(), pFlashObject);
  342.                                                                         if (pFlashObject)
  343.                                                                         {
  344.                                                                                 const string& frameName = GetPortString(pActInfo, EIP_FrameName);
  345.                                                                                 if (!frameName.empty())
  346.                                                                                 {
  347.                                                                                         bool bResult = pFlashObject->GotoAndPlay(frameName);
  348.                                                                                         if (!bResult)
  349.                                                                                         {
  350.                                                                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CMaterialFlashGotoAndPlayNode::ProcessEvent: Failed on object: %s with framename: %s", objectPath.c_str(), frameName.c_str());
  351.                                                                                         }
  352.                                                                                 }
  353.                                                                                 else // Use number
  354.                                                                                 {
  355.                                                                                         const int iFrameNumber = GetPortInt(pActInfo, EIP_FrameNumber);
  356.                                                                                         bool bResult = pFlashObject->GotoAndPlay(iFrameNumber);
  357.                                                                                         if (!bResult)
  358.                                                                                         {
  359.                                                                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CMaterialFlashGotoAndPlayNode::ProcessEvent: Failed on object: %s with framenumber: %d", objectPath.c_str(), iFrameNumber);
  360.                                                                                         }
  361.                                                                                 }
  362.  
  363.                                                                                 SAFE_RELEASE(pFlashObject);
  364.                                                                         }
  365.                                                                         else
  366.                                                                         {
  367.                                                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CMaterialFlashGotoAndPlayNode::ProcessEvent: Failed finding object: %s", objectPath.c_str());
  368.                                                                         }
  369.                                                                 }
  370.                                                                 else
  371.                                                                 {
  372.                                                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CMaterialFlashGotoAndPlayNode::ProcessEvent: ObjectPath can't be empty");
  373.                                                                 }
  374.  
  375.                                                                 pFlashPlayer->Release();
  376.                                                         }
  377.                                                 }
  378.                                         }
  379.                                 }
  380.  
  381.                                 ActivateOutput(pActInfo, EOP_Done, true);
  382.                         }
  383.                         break;
  384.                 }
  385.         }
  386.  
  387.         virtual void GetMemoryUsage(ICrySizer* s) const
  388.         {
  389.                 s->Add(*this);
  390.         }
  391. };
  392.  
  393. class CMaterialFlashHandleFSCommandNode : public CFlowBaseNode<eNCT_Instanced>, public IFSCommandHandler
  394. {
  395.         enum INPUTS
  396.         {
  397.                 EIP_Enable = 0,
  398.                 EIP_Disable,
  399.                 EIP_DisableHandlingOnEvent,
  400.         };
  401.  
  402.         enum OUTPUTS
  403.         {
  404.                 EOP_OnEvent = 0,
  405.                 EOP_CommandName,
  406.                 EOP_CommandParam,
  407.         };
  408.  
  409. public:
  410.         CMaterialFlashHandleFSCommandNode(SActivationInfo* pActInfo)
  411.                 : m_bActive(false)
  412.         {
  413.         }
  414.  
  415.         ~CMaterialFlashHandleFSCommandNode()
  416.         {
  417.                 Deinit();
  418.         }
  419.  
  420.         virtual void GetMemoryUsage(ICrySizer* s) const
  421.         {
  422.                 s->Add(*this);
  423.         }
  424.  
  425.         void GetConfiguration(SFlowNodeConfig& config)
  426.         {
  427.                 static const SInputPortConfig in_ports[] =
  428.                 {
  429.                         InputPortConfig_Void("Enable",                  _HELP("Enables handling of event")),
  430.                         InputPortConfig_Void("Disable",                 _HELP("Disables handling of event")),
  431.                         InputPortConfig<bool>("DisableHandlingOnEvent", true,                                _HELP("Disables handling when event is received")),
  432.                         { 0 }
  433.                 };
  434.  
  435.                 static const SOutputPortConfig out_ports[] =
  436.                 {
  437.                         OutputPortConfig_Void("OnEvent",      _HELP("Triggers when event happens")),
  438.                         OutputPortConfig_Void("CommandName",  _HELP("Command name associated with event")),
  439.                         OutputPortConfig_Void("CommandParam", _HELP("Command param associated with event")),
  440.                         { 0 }
  441.                 };
  442.  
  443.                 config.nFlags |= EFLN_TARGET_ENTITY;
  444.                 config.pInputPorts = in_ports;
  445.                 config.pOutputPorts = out_ports;
  446.                 config.sDescription = _HELP("Handles flash FS command");
  447.                 config.SetCategory(EFLN_APPROVED);
  448.         }
  449.  
  450.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  451.         {
  452.                 if (event == eFE_Activate)
  453.                 {
  454.                         if (IsPortActive(pActInfo, EIP_Enable))
  455.                         {
  456.                                 bool bResult = SetFSCommandHandler(pActInfo->pEntity, true);
  457.                                 m_actInfo = *pActInfo;
  458.                                 m_bActive = true;
  459.                         }
  460.                         else if (IsPortActive(pActInfo, EIP_Disable))
  461.                         {
  462.                                 Deinit();
  463.                         }
  464.                 }
  465.         }
  466.  
  467.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  468.         {
  469.                 return new CMaterialFlashHandleFSCommandNode(pActInfo);
  470.         }
  471.  
  472. private:
  473.         void Deinit()
  474.         {
  475.                 if (m_bActive)
  476.                 {
  477.                         m_bActive = false;
  478.                         SetFSCommandHandler(m_actInfo.pEntity, false);
  479.                 }
  480.         }
  481.  
  482.         bool SetFSCommandHandler(IEntity* pEntity, const bool bEnable)
  483.         {
  484.                 IEntityRender* pIEntityRender = pEntity->GetRenderInterface();
  485.  
  486.                
  487.                 {
  488.                         IMaterial* pMtl(pIEntityRender->GetRenderMaterial(-1)); // material will be taken from the first renderable slot.
  489.                         if (pMtl)
  490.                         {
  491.                                 IFlashPlayer* pFlashPlayer = CMaterialFlashInvokeNode::GetFlashPlayerFromMaterialIncludingSubMaterials(pMtl);
  492.                                 if (pFlashPlayer)
  493.                                 {
  494.                                         if (bEnable)
  495.                                         {
  496.                                                 pFlashPlayer->SetFSCommandHandler(this);
  497.                                         }
  498.                                         else
  499.                                         {
  500.                                                 pFlashPlayer->SetFSCommandHandler(NULL);
  501.                                         }
  502.  
  503.                                         pFlashPlayer->Release();
  504.                                         return true;
  505.                                 }
  506.                         }
  507.                 }
  508.  
  509.                 return false;
  510.         }
  511.  
  512.         // IFSCommandHandler
  513.         void HandleFSCommand(const char* pCommand, const char* pArgs, void* pUserData)
  514.         {
  515.                 if (IsActive())
  516.                 {
  517.                         ActivateOutput(&m_actInfo, EOP_OnEvent, true);
  518.                         ActivateOutput(&m_actInfo, EOP_CommandName, string(pCommand));
  519.                         ActivateOutput(&m_actInfo, EOP_CommandParam, string(pArgs));
  520.  
  521.                         const bool bDisableHandlingOnEvent = GetPortBool(&m_actInfo, EIP_DisableHandlingOnEvent);
  522.                         if (bDisableHandlingOnEvent)
  523.                         {
  524.                                 Deinit();
  525.                         }
  526.                 }
  527.         }
  528.         // ~IFSCommandHandler
  529.  
  530.         ILINE bool IsActive() const { return m_bActive; }
  531.  
  532.         SActivationInfo m_actInfo;
  533.  
  534.         bool            m_bActive;
  535. };
  536.  
  537. REGISTER_FLOW_NODE("MaterialFX:HUDStartFX", CHUDStartFXNode);
  538. REGISTER_FLOW_NODE("MaterialFX:HUDEndFX", CHUDEndFXNode);
  539. REGISTER_FLOW_NODE("MaterialFX:FlashInvokeOnObject", CMaterialFlashInvokeNode);
  540. REGISTER_FLOW_NODE("MaterialFX:FlashGotoAndPlayOnObject", CMaterialFlashGotoAndPlayNode);
  541. REGISTER_FLOW_NODE("MaterialFX:FlashHandleFSCommand", CMaterialFlashHandleFSCommandNode);
  542.  
downloadMaterialHUDFXNodes.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