BVB Source Codes

CRYENGINE Show FlashUIElementNodes.cpp Source code

Return Download CRYENGINE: download FlashUIElementNodes.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:   FlashUIElementNodes.cpp
  5. //  Version:     v1.00
  6. //  Created:     10/9/2010 by Paul Reindell.
  7. //  Description:
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12. #include "StdAfx.h"
  13. #include "FlashUIElementNodes.h"
  14. #include "FlashUIElement.h"
  15. #include "FlashUI.h"
  16.  
  17. ////////////////////////////////////////////////////////////////////////////
  18. ////////////////////////////////////////////////////////////////////////////
  19. ////////////////////////////////////////////////////////////////////////////
  20. void CFlashUIVariableBaseNode::GetConfiguration(SFlowNodeConfig& config)
  21. {
  22.         static const SInputPortConfig in_config[] = {
  23.                 CreateVariablesPort(),
  24.                 CreateInstanceIdPort(),
  25.                 InputPortConfig_Void("Set",     "Set value"),
  26.                 InputPortConfig_Void("Get",     "Get value"),
  27.                 InputPortConfig_AnyType("Value","Value to set"),
  28.                 InputPortConfig_Void(0),
  29.                 { 0 }
  30.         };
  31.  
  32.         static const SInputPortConfig in_config_tmpl[] = {
  33.                 CreateVariablesForTmplPort(),
  34.                 CreateInstanceIdPort(),
  35.                 CreateTmplInstanceNamePort(),
  36.                 InputPortConfig_Void("Set",     "Set value"),
  37.                 InputPortConfig_Void("Get",     "Get value"),
  38.                 InputPortConfig_AnyType("Value","Value to set"),
  39.                 InputPortConfig_Void(0),
  40.         };
  41.  
  42.         static const SOutputPortConfig out_config[] = {
  43.                 OutputPortConfig_Void("OnSet",    "On set value"),
  44.                 OutputPortConfig_AnyType("Value", "Value"),
  45.                 { 0 }
  46.         };
  47.  
  48.         config.pInputPorts = IsTemplate() ? in_config_tmpl : in_config;
  49.         config.pOutputPorts = out_config;
  50.         config.sDescription = "Access to Variables";
  51.         config.SetCategory(EFLN_APPROVED);
  52. }
  53.  
  54. ////////////////////////////////////////////////////////////////////////////
  55. void CFlashUIVariableBaseNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  56. {
  57.         if (event == eFE_Initialize)
  58.         {
  59.                 UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIVariable)), pActInfo, m_isTemplate);
  60.         }
  61.         else if (event == eFE_Activate)
  62.         {
  63.                 if (IsPortActive(pActInfo, GetInputPort(eI_UIVariable)))
  64.                 {
  65.                         UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIVariable)), pActInfo, m_isTemplate);
  66.                 }
  67.  
  68.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo))
  69.                         return;
  70.  
  71.                 const int instanceId = GetPortInt(pActInfo, GetInputPort(eI_InstanceID));
  72.                 if (IsPortActive(pActInfo, GetInputPort(eI_Set)))
  73.                 {
  74.                         const TFlowInputData& data = GetPortAny(pActInfo, GetInputPort(eI_Value));
  75.                         TUIData value;
  76.                         ConvertToUIData(data, value, pActInfo);
  77.  
  78.                         SPerInstanceCall1<const TUIData&> caller;
  79.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIVariableBaseNode::SetVariable), value);
  80.  
  81.                         ActivateOutput(pActInfo, eO_OnSet, true);
  82.                 }
  83.                 if (IsPortActive(pActInfo, GetInputPort(eI_Get)))
  84.                 {
  85.                         TUIData out;
  86.  
  87.                         SPerInstanceCall1<TUIData&> caller;
  88.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIVariableBaseNode::GetVariable), out, false))
  89.                         {
  90.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get Variable for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  91.                         }
  92.  
  93.                         string res;
  94.                         out.GetValueWithConversion(res);
  95.                         ActivateOutput(pActInfo, eO_Value, res);
  96.                 }
  97.         }
  98.  
  99. }
  100.  
  101. ////////////////////////////////////////////////////////////////////////////
  102. void CFlashUIVariableBaseNode::ConvertToUIData(const TFlowInputData& in, TUIData& out, SActivationInfo* pActInfo)
  103. {
  104.         if (!GetObjectDesc())
  105.         {
  106.                 UIACTION_WARNING("FG: No valid Variable \"%s\"! (Referenced at node \"%s\")", GetPortString(pActInfo, GetInputPort(eI_UIVariable)).c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  107.                 return;
  108.         }
  109.  
  110.         bool ok = false;
  111.         const char* vartype = "any";
  112.         switch (GetObjectDesc()->eType)
  113.         {
  114.         case SUIParameterDesc::eUIPT_Bool:
  115.                 {
  116.                         bool value;
  117.                         ok = in.GetValueWithConversion(value);
  118.                         out = TUIData(value);
  119.                         vartype = "bool";
  120.                 }
  121.                 break;
  122.         case SUIParameterDesc::eUIPT_Int:
  123.                 {
  124.                         int value;
  125.                         ok = in.GetValueWithConversion(value);
  126.                         out = TUIData(value);
  127.                         vartype = "int";
  128.                 }
  129.                 break;
  130.         case SUIParameterDesc::eUIPT_Float:
  131.                 {
  132.                         float value;
  133.                         ok = in.GetValueWithConversion(value);
  134.                         out = TUIData(value);
  135.                         vartype = "float";
  136.                 }
  137.                 break;
  138.         case SUIParameterDesc::eUIPT_String: // fall through, just change the type desc
  139.                 vartype = "string";
  140.         case SUIParameterDesc::eUIPT_Any:
  141.         default:
  142.                 {
  143.                         string value;
  144.                         ok = in.GetValueWithConversion(value);
  145.                         out = TUIData(value);
  146.                 }
  147.                 break;
  148.         }
  149.  
  150.         if (!ok)
  151.         {
  152.                 UIACTION_WARNING("FG: UIElement \"%s\" Variable \"%s\" expected type \"%s\" given value was not compatible! (Referenced at node \"%s\")", GetElement()->GetName(), GetObjectDesc()->sDisplayName, vartype, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  153.         }
  154. }
  155.  
  156. ////////////////////////////////////////////////////////////////////////////
  157. ////////////////////////////////////////////////////////////////////////////
  158. ////////////////////////////////////////////////////////////////////////////
  159. void CFlashUIArrayBaseNode::GetConfiguration(SFlowNodeConfig& config)
  160. {
  161.         static const SInputPortConfig in_config[] = {
  162.                 CreateArraysPort(),
  163.                 CreateInstanceIdPort(),
  164.                 InputPortConfig_Void("Set",     "Set value"),
  165.                 InputPortConfig_Void("Get",     "Get value"),
  166.                 InputPortConfig<string>("Value","Value to set as string list"),
  167.                 InputPortConfig_Void(0),
  168.                 { 0 }
  169.         };
  170.  
  171.         static const SInputPortConfig in_config_tmpl[] = {
  172.                 CreateArraysForTmplPort(),
  173.                 CreateInstanceIdPort(),
  174.                 CreateTmplInstanceNamePort(),
  175.                 InputPortConfig_Void("Set",     "Set value"),
  176.                 InputPortConfig_Void("Get",     "Get value"),
  177.                 InputPortConfig<string>("Value","Value to set as string list"),
  178.                 InputPortConfig_Void(0),
  179.                 { 0 }
  180.         };
  181.  
  182.         static const SOutputPortConfig out_config[] = {
  183.                 OutputPortConfig_Void("OnSet",    "On set value"),
  184.                 OutputPortConfig<string>("Value", "Value as string list"),
  185.                 { 0 }
  186.         };
  187.  
  188.         config.pInputPorts = IsTemplate() ? in_config_tmpl : in_config;
  189.         config.pOutputPorts = out_config;
  190.         config.sDescription = "Access to Arrays";
  191.         config.SetCategory(EFLN_APPROVED);
  192. }
  193.  
  194. ////////////////////////////////////////////////////////////////////////////
  195. void CFlashUIArrayBaseNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  196. {
  197.         if (event == eFE_Initialize)
  198.         {
  199.                 UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIArray)), pActInfo, m_isTemplate);
  200.         }
  201.         else if (event == eFE_Activate)
  202.         {
  203.                 if (IsPortActive(pActInfo, GetInputPort(eI_UIArray)))
  204.                 {
  205.                         UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIArray)), pActInfo, m_isTemplate);
  206.                 }
  207.  
  208.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo))
  209.                         return;
  210.  
  211.                 if (GetElement())
  212.                 {
  213.                         const int instanceId = GetPortInt(pActInfo, GetInputPort(eI_InstanceID));
  214.                         if (IsPortActive(pActInfo, GetInputPort(eI_Set)))
  215.                         {
  216.                                 SUIArguments values(GetPortString(pActInfo, GetInputPort(eI_Value)).c_str());
  217.  
  218.                                 SPerInstanceCall1<const SUIArguments&> caller;
  219.                                 caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIArrayBaseNode::SetArray), values);
  220.  
  221.                                 ActivateOutput(pActInfo, eO_OnSet, true);
  222.                         }
  223.                         else if (IsPortActive(pActInfo, GetInputPort(eI_Get)))
  224.                         {
  225.                                 SUIArguments out;
  226.  
  227.                                 SPerInstanceCall1<SUIArguments&> caller;
  228.                                 if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIArrayBaseNode::GetArray), out, false))
  229.                                 {
  230.                                         UIACTION_WARNING("FG: UIElement \"%s\" called get Array for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  231.                                 }
  232.  
  233.                                 ActivateOutput(pActInfo, eO_Value, string(out.GetAsString()));
  234.                         }
  235.                 }
  236.         }
  237. }
  238.  
  239. ////////////////////////////////////////////////////////////////////////////
  240. REGISTER_FLOW_NODE("UI:Variable:Var", CFlashUIVariableNode);
  241. REGISTER_FLOW_NODE("UI:Variable:Array", CFlashUIArrayNode);
  242. REGISTER_FLOW_NODE("UI:Template:Variable:Var", CFlashUITmplVariableNode);
  243. REGISTER_FLOW_NODE("UI:Template:Variable:Array", CFlashUITmplArrayNode);
  244.  
  245. ////////////////////////////////////////////////////////////////////////////
  246. ////////////////////////////////////////////////////////////////////////////
  247. ////////////////////////////////////////////////////////////////////////////
  248. void CFlashUIGotoAndPlayBaseNode::GetConfiguration(SFlowNodeConfig& config)
  249. {
  250.         static const SInputPortConfig in_config[] = {
  251.                 CreateMovieClipsPort(),
  252.                 CreateInstanceIdPort(),
  253.                 InputPortConfig_Void("GotoAndPlay", "GotoAndPlay to frame"),
  254.                 InputPortConfig_Void("GotoAndStop", "GotoAndStop to frame"),
  255.                 InputPortConfig<int>("FrameId",     -1,                                              "Frame Number, -1 = use FrameName"),
  256.                 InputPortConfig<string>("FrameName","FrameName, only used if FrameId is set to -1"),
  257.                 InputPortConfig_Void(0),
  258.                 { 0 }
  259.         };
  260.  
  261.         static const SInputPortConfig in_config_tmpl[] = {
  262.                 CreateMovieClipsForTmplPort(),
  263.                 CreateInstanceIdPort(),
  264.                 CreateTmplInstanceNamePort(),
  265.                 InputPortConfig_Void("GotoAndPlay", "GotoAndPlay to frame"),
  266.                 InputPortConfig_Void("GotoAndStop", "GotoAndStop to frame"),
  267.                 InputPortConfig<int>("FrameId",     -1,                                              "Frame Number, -1 = use FrameName"),
  268.                 InputPortConfig<string>("FrameName","FrameName, only used if FrameId is set to -1"),
  269.                 InputPortConfig_Void(0),
  270.         };
  271.  
  272.         static const SOutputPortConfig out_config[] = {
  273.                 OutputPortConfig_Void("OnGotoAndPlay", "On GotoAndPlay"),
  274.                 OutputPortConfig_Void("OnGotoAndStop", "On GotoAndStop"),
  275.                 { 0 }
  276.         };
  277.  
  278.         config.pInputPorts = IsTemplate() ? in_config_tmpl : in_config;
  279.         config.pOutputPorts = out_config;
  280.         config.sDescription = "Access to MovieClips";
  281.         config.SetCategory(EFLN_APPROVED);
  282. }
  283.  
  284. ////////////////////////////////////////////////////////////////////////////
  285. void CFlashUIGotoAndPlayBaseNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  286. {
  287.         if (event == eFE_Initialize)
  288.         {
  289.                 UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  290.         }
  291.         else if (event == eFE_Activate)
  292.         {
  293.                 if (IsPortActive(pActInfo, GetInputPort(eI_UIMovieClip)))
  294.                 {
  295.                         UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  296.                 }
  297.  
  298.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo))
  299.                         return;
  300.  
  301.                 if (GetElement())
  302.                 {
  303.                         const int frameId = GetPortInt(pActInfo, GetInputPort(eI_FrameNum));
  304.                         const string frameName = GetPortString(pActInfo, GetInputPort(eI_FrameName));
  305.                         const int instanceId = GetPortInt(pActInfo, GetInputPort(eI_InstanceID));
  306.                         if (IsPortActive(pActInfo, GetInputPort(eI_GotoAndPlay)))
  307.                         {
  308.                                 SPerInstanceCall2<int, const char*> caller;
  309.                                 caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIGotoAndPlayBaseNode::GotoAndPlay), frameId, frameName);
  310.  
  311.                                 ActivateOutput(pActInfo, eO_OnGotoAndPlay, true);
  312.                         }
  313.                         else if (IsPortActive(pActInfo, GetInputPort(eI_GotoAndStop)))
  314.                         {
  315.                                 SPerInstanceCall2<int, const char*> caller;
  316.                                 caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIGotoAndPlayBaseNode::GotoAndStop), frameId, frameName);
  317.  
  318.                                 ActivateOutput(pActInfo, eO_OnGotoAndStop, true);
  319.                         }
  320.                 }
  321.         }
  322. }
  323.  
  324. ////////////////////////////////////////////////////////////////////////////
  325. void CFlashUIGotoAndPlayBaseNode::GotoAndPlay(IUIElement* pElement, int frameId, const char* frameName)
  326. {
  327.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  328.         if (pMc)
  329.         {
  330.                 if (frameId > -1)
  331.                         pMc->GotoAndPlay(frameId);
  332.                 else
  333.                         pMc->GotoAndPlay(frameName);
  334.         }
  335. }
  336.  
  337. ////////////////////////////////////////////////////////////////////////////
  338. void CFlashUIGotoAndPlayBaseNode::GotoAndStop(IUIElement* pElement, int frameId, const char* frameName)
  339. {
  340.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  341.         if (pMc)
  342.         {
  343.                 if (frameId > -1)
  344.                         pMc->GotoAndStop(frameId);
  345.                 else
  346.                         pMc->GotoAndStop(frameName);
  347.         }
  348. }
  349.  
  350. ////////////////////////////////////////////////////////////////////////////
  351. ////////////////////////////////////////////////////////////////////////////
  352. ////////////////////////////////////////////////////////////////////////////
  353. void CFlashUIMCVisibleBaseNode::GetConfiguration(SFlowNodeConfig& config)
  354. {
  355.         static const SInputPortConfig in_config[] = {
  356.                 CreateMovieClipsPort(),
  357.                 CreateInstanceIdPort(),
  358.                 InputPortConfig_Void("Set",     "Set visible/alpha state"),
  359.                 InputPortConfig_Void("Get",     "Get visible/alpha state"),
  360.                 InputPortConfig<bool>("Visible",true,                       "Visible true/false"),
  361.                 InputPortConfig<float>("Alpha", "Alpha (0-1)"),
  362.                 InputPortConfig_Void(0),
  363.                 { 0 }
  364.         };
  365.  
  366.         static const SInputPortConfig in_config_tmpl[] = {
  367.                 CreateMovieClipsForTmplPort(),
  368.                 CreateInstanceIdPort(),
  369.                 CreateTmplInstanceNamePort(),
  370.                 InputPortConfig_Void("Set",     "Set visible/alpha state"),
  371.                 InputPortConfig_Void("Get",     "Get visible/alpha state"),
  372.                 InputPortConfig<bool>("Visible",true,                       "Visible true/false"),
  373.                 InputPortConfig<float>("Alpha", "Alpha (0-1)"),
  374.                 InputPortConfig_Void(0),
  375.                 { 0 }
  376.         };
  377.  
  378.         static const SOutputPortConfig out_config[] = {
  379.                 OutputPortConfig_Void("OnSet",      "On set visible/alpha state"),
  380.                 OutputPortConfig<bool>("IsVisible", "Visible true/false"),
  381.                 OutputPortConfig<float>("AlphaVal", "Current Alpha value (0-1)"),
  382.                 { 0 }
  383.         };
  384.  
  385.         config.pInputPorts = IsTemplate() ? in_config_tmpl : in_config;
  386.         config.pOutputPorts = out_config;
  387.         config.sDescription = "Visible/Alpha access to MovieClips";
  388.         config.SetCategory(EFLN_APPROVED);
  389. }
  390.  
  391. ////////////////////////////////////////////////////////////////////////////
  392. void CFlashUIMCVisibleBaseNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  393. {
  394.         if (event == eFE_Initialize)
  395.         {
  396.                 UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  397.         }
  398.         else if (event == eFE_Activate)
  399.         {
  400.                 if (IsPortActive(pActInfo, GetInputPort(eI_UIMovieClip)))
  401.                 {
  402.                         UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  403.                 }
  404.  
  405.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo))
  406.                         return;
  407.  
  408.                 if (GetElement())
  409.                 {
  410.                         const int instanceId = GetPortInt(pActInfo, GetInputPort(eI_InstanceID));
  411.                         if (IsPortActive(pActInfo, GetInputPort(eI_Set)))
  412.                         {
  413.                                 const bool bVis = GetPortBool(pActInfo, GetInputPort(eI_Visible));
  414.                                 const float alpha = clamp_tpl(GetPortFloat(pActInfo, GetInputPort(eI_Alpha)), 0.0f, 1.f);
  415.  
  416.                                 SPerInstanceCall2<bool, float> caller;
  417.                                 caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCVisibleBaseNode::SetValues), bVis, alpha);
  418.  
  419.                                 ActivateOutput(pActInfo, eO_OnSet, true);
  420.                                 ActivateOutput(pActInfo, eO_Visible, bVis);
  421.                                 ActivateOutput(pActInfo, eO_Alpha, alpha);
  422.                         }
  423.                         else if (IsPortActive(pActInfo, GetInputPort(eI_Get)))
  424.                         {
  425.                                 bool bVis = false;
  426.                                 float alpha = 0.f;
  427.  
  428.                                 SPerInstanceCall2<bool&, float&> caller;
  429.                                 if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCVisibleBaseNode::GetValues), bVis, alpha, false))
  430.                                 {
  431.                                         UIACTION_WARNING("FG: UIElement \"%s\" called get Array for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  432.                                 }
  433.  
  434.                                 ActivateOutput(pActInfo, eO_Visible, bVis);
  435.                                 ActivateOutput(pActInfo, eO_Alpha, alpha);
  436.                         }
  437.                 }
  438.         }
  439. }
  440.  
  441. ////////////////////////////////////////////////////////////////////////////
  442. void CFlashUIMCVisibleBaseNode::SetValues(IUIElement* pElement, bool bVisible, float alpha)
  443. {
  444.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  445.         if (pMc)
  446.         {
  447.                 SFlashDisplayInfo info;
  448.                 pMc->GetDisplayInfo(info);
  449.                 info.SetVisible(bVisible);
  450.                 info.SetAlpha(alpha * 100.f);
  451.                 pMc->SetDisplayInfo(info);
  452.         }
  453. }
  454.  
  455. ////////////////////////////////////////////////////////////////////////////
  456. void CFlashUIMCVisibleBaseNode::GetValues(IUIElement* pElement, bool& bVisible, float& alpha)
  457. {
  458.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  459.         if (pMc)
  460.         {
  461.                 SFlashDisplayInfo info;
  462.                 pMc->GetDisplayInfo(info);
  463.                 bVisible = info.GetVisible();
  464.                 alpha = info.GetAlpha() / 100.f;
  465.         }
  466. }
  467.  
  468. ////////////////////////////////////////////////////////////////////////////
  469. ////////////////////////////////////////////////////////////////////////////
  470. ////////////////////////////////////////////////////////////////////////////
  471. void CFlashUIMCPosRotScaleBaseNode::GetConfiguration(SFlowNodeConfig& config)
  472. {
  473.         static const SInputPortConfig in_config[] = {
  474.                 CreateMovieClipsPort(),
  475.                 CreateInstanceIdPort(),
  476.                 InputPortConfig_Void("Set",   "Set visible/alpha state"),
  477.                 InputPortConfig_Void("Get",   "Get visible/alpha state"),
  478.                 InputPortConfig<Vec3>("Pos",  Vec3(0,                     0,  0), "Position"),
  479.                 InputPortConfig<Vec3>("Rot",  Vec3(0,                     0,  0), "Rotation"),
  480.                 InputPortConfig<Vec3>("Scale",Vec3(1,                     1,  1), "Scale"),
  481.                 InputPortConfig_Void(0),
  482.                 { 0 }
  483.         };
  484.  
  485.         static const SInputPortConfig in_config_tmpl[] = {
  486.                 CreateMovieClipsForTmplPort(),
  487.                 CreateInstanceIdPort(),
  488.                 CreateTmplInstanceNamePort(),
  489.                 InputPortConfig_Void("Set",   "Set visible/alpha state"),
  490.                 InputPortConfig_Void("Get",   "Get visible/alpha state"),
  491.                 InputPortConfig<Vec3>("Pos",  Vec3(0,                     0,  0), "Position"),
  492.                 InputPortConfig<Vec3>("Rot",  Vec3(0,                     0,  0), "Rotation"),
  493.                 InputPortConfig<Vec3>("Scale",Vec3(1,                     1,  1), "Scale"),
  494.                 InputPortConfig_Void(0),
  495.                 { 0 }
  496.         };
  497.  
  498.         static const SOutputPortConfig out_config[] = {
  499.                 OutputPortConfig_Void("OnSet",  "On set visible/alpha state"),
  500.                 OutputPortConfig<Vec3>("Pos",   "Position"),
  501.                 OutputPortConfig<Vec3>("Rot",   "Rotation"),
  502.                 OutputPortConfig<Vec3>("Scale", "Scale"),
  503.                 { 0 }
  504.         };
  505.  
  506.         config.pInputPorts = IsTemplate() ? in_config_tmpl : in_config;
  507.         config.pOutputPorts = out_config;
  508.         config.sDescription = "Pos/Rot/Scale access to MovieClips";
  509.         config.SetCategory(EFLN_APPROVED);
  510. }
  511.  
  512. ////////////////////////////////////////////////////////////////////////////
  513. void CFlashUIMCPosRotScaleBaseNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  514. {
  515.         if (event == eFE_Initialize)
  516.         {
  517.                 UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  518.         }
  519.         else if (event == eFE_Activate)
  520.         {
  521.                 if (IsPortActive(pActInfo, GetInputPort(eI_UIMovieClip)))
  522.                 {
  523.                         UpdateObjectDesc(GetPortString(pActInfo, GetInputPort(eI_UIMovieClip)), pActInfo, m_isTemplate);
  524.                 }
  525.  
  526.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, GetInputPort(eI_TemplateInstanceName)), pActInfo))
  527.                         return;
  528.  
  529.                 if (GetElement())
  530.                 {
  531.                         const int instanceId = GetPortInt(pActInfo, GetInputPort(eI_InstanceID));
  532.                         if (IsPortActive(pActInfo, GetInputPort(eI_Set)))
  533.                         {
  534.                                 const Vec3 pos = GetPortVec3(pActInfo, GetInputPort(eI_Pos));
  535.                                 const Vec3 rot = GetPortVec3(pActInfo, GetInputPort(eI_Rot));
  536.                                 const Vec3 scale = GetPortVec3(pActInfo, GetInputPort(eI_Scale));
  537.  
  538.                                 SPerInstanceCall3<const Vec3&, const Vec3&, const Vec3&> caller;
  539.                                 caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCPosRotScaleBaseNode::SetValues), pos, rot, scale);
  540.  
  541.                                 ActivateOutput(pActInfo, eO_OnSet, true);
  542.                                 ActivateOutput(pActInfo, eO_Pos, pos);
  543.                                 ActivateOutput(pActInfo, eO_Rot, rot);
  544.                                 ActivateOutput(pActInfo, eO_Scale, scale);
  545.                         }
  546.                         else if (IsPortActive(pActInfo, GetInputPort(eI_Get)))
  547.                         {
  548.                                 Vec3 pos;
  549.                                 Vec3 rot;
  550.                                 Vec3 scale;
  551.  
  552.                                 SPerInstanceCall3<Vec3&, Vec3&, Vec3&> caller;
  553.                                 if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCPosRotScaleBaseNode::GetValues), pos, rot, scale, false))
  554.                                 {
  555.                                         UIACTION_WARNING("FG: UIElement \"%s\" called get PosRotScale for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  556.                                 }
  557.  
  558.                                 ActivateOutput(pActInfo, eO_Pos, pos);
  559.                                 ActivateOutput(pActInfo, eO_Rot, rot);
  560.                                 ActivateOutput(pActInfo, eO_Scale, scale);
  561.                         }
  562.                 }
  563.         }
  564. }
  565.  
  566. ////////////////////////////////////////////////////////////////////////////
  567. void CFlashUIMCPosRotScaleBaseNode::SetValues(IUIElement* pElement, const Vec3& vPos, const Vec3& vRot, const Vec3& vScale)
  568. {
  569.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  570.         if (pMc)
  571.         {
  572.                 SFlashDisplayInfo info;
  573.                 pMc->GetDisplayInfo(info);
  574.  
  575.                 info.SetX(vPos.x);
  576.                 info.SetY(vPos.y);
  577.                 info.SetZ(vPos.z);
  578.  
  579.                 info.SetRotation(vRot.z);
  580.                 info.SetXRotation(vRot.x);
  581.                 info.SetYRotation(vRot.y);
  582.  
  583.                 info.SetXScale(vScale.x * 100.f);
  584.                 info.SetYScale(vScale.y * 100.f);
  585.                 info.SetZScale(vScale.z * 100.f);
  586.  
  587.                 pMc->SetDisplayInfo(info);
  588.         }
  589. }
  590.  
  591. ////////////////////////////////////////////////////////////////////////////
  592. void CFlashUIMCPosRotScaleBaseNode::GetValues(IUIElement* pElement, Vec3& vPos, Vec3& vRot, Vec3& vScale)
  593. {
  594.         IFlashVariableObject* pMc = pElement->GetMovieClip(GetObjectDesc(), GetTmplDesc());
  595.         if (pMc)
  596.         {
  597.                 SFlashDisplayInfo info;
  598.                 pMc->GetDisplayInfo(info);
  599.  
  600.                 vPos.x = info.GetX();
  601.                 vPos.y = info.GetY();
  602.                 vPos.z = info.GetZ();
  603.  
  604.                 vRot.x = info.GetXRotation();
  605.                 vRot.y = info.GetYRotation();
  606.                 vRot.z = info.GetRotation();
  607.  
  608.                 vScale.x = info.GetXScale() / 100.f;
  609.                 vScale.y = info.GetYScale() / 100.f;
  610.                 vScale.z = info.GetZScale() / 100.f;
  611.         }
  612. }
  613.  
  614. ////////////////////////////////////////////////////////////////////////////
  615. REGISTER_FLOW_NODE("UI:MovieClip:GotoAndPlay", CFlashUIGotoAndPlayNode);
  616. REGISTER_FLOW_NODE("UI:MovieClip:Visible", CFlashUIMCVisibleNode);
  617. REGISTER_FLOW_NODE("UI:MovieClip:PosRotScale", CFlashUIMCPosRotScaleNode);
  618. REGISTER_FLOW_NODE("UI:Template:MovieClip:GotoAndPlay", CFlashUIGotoAndPlayTmplNode);
  619. REGISTER_FLOW_NODE("UI:Template:MovieClip:Visible", CFlashUIMCVisibleTmplNode);
  620. REGISTER_FLOW_NODE("UI:Template:MovieClip:PosRotScale", CFlashUIMCPosRotScaleTmplNode);
  621.  
  622. ////////////////////////////////////////////////////////////////////////////
  623. ////////////////////////////////////////////////////////////////////////////
  624. ////////////////////////////////////////////////////////////////////////////
  625. void CFlashUIMCTemplateCreateNode::GetConfiguration(SFlowNodeConfig& config)
  626. {
  627.         static const SInputPortConfig in_config[] = {
  628.                 CFlashUIBaseNode::CreateMovieClipTmplPort(),
  629.                 CFlashUIBaseNode::CreateMovieClipsParentPort(),
  630.                 CFlashUIBaseNode::CreateInstanceIdPort(),
  631.                 InputPortConfig<string>("InstanceName",        "New instance name for this MC (if empty it will auto create a new name)"),
  632.                 InputPortConfig_Void("Create",                 "Creates a new MovieClip"),
  633.                 InputPortConfig_Void(0),
  634.                 { 0 }
  635.         };
  636.  
  637.         static const SOutputPortConfig out_config[] = {
  638.                 OutputPortConfig_Void("OnCreated",       "Triggered once the MovieClip was removed"),
  639.                 OutputPortConfig<string>("InstanceName", "The new name of the instance"),
  640.                 { 0 }
  641.         };
  642.  
  643.         config.pInputPorts = in_config;
  644.         config.pOutputPorts = out_config;
  645.         config.sDescription = "Create a MovieClip and attaches it to the given Parent MovieClip";
  646.         config.SetCategory(EFLN_APPROVED);
  647. }
  648.  
  649. ////////////////////////////////////////////////////////////////////////////
  650. void CFlashUIMCTemplateCreateNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  651. {
  652.         if (event == eFE_Initialize)
  653.         {
  654.                 m_TmplDescHelper.UpdateObjectDesc(GetPortString(pActInfo, eI_UIMovieClipTmpl), pActInfo, true);
  655.                 m_ParentDescHelper.UpdateObjectDesc(GetPortString(pActInfo, eI_UIParentMovieClip), pActInfo, false);
  656.  
  657.                 if (GetParentDesc() && m_TmplDescHelper.GetElement() != m_ParentDescHelper.GetElement())
  658.                 {
  659.                         UIACTION_WARNING("FG: Can't attach \"%s\" on parent MC \"%s\" (they must be part of the same UIElement!), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIMovieClipTmpl).c_str(), GetPortString(pActInfo, eI_UIParentMovieClip).c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  660.                         m_ParentDescHelper.Reset();
  661.                 }
  662.         }
  663.         else if (event == eFE_Activate)
  664.         {
  665.                 if (IsPortActive(pActInfo, eI_UIMovieClipTmpl))
  666.                 {
  667.                         m_TmplDescHelper.UpdateObjectDesc(GetPortString(pActInfo, eI_UIMovieClipTmpl), pActInfo, true);
  668.                 }
  669.  
  670.                 IUIElement* pElement = GetElement();
  671.                 if (IsPortActive(pActInfo, eI_UIParentMovieClip))
  672.                 {
  673.                         m_ParentDescHelper.UpdateObjectDesc(GetPortString(pActInfo, eI_UIParentMovieClip), pActInfo, false);
  674.  
  675.                         if (GetParentDesc() && m_TmplDescHelper.GetElement() != m_ParentDescHelper.GetElement())
  676.                         {
  677.                                 UIACTION_WARNING("FG: Can't attach \"%s\" on parent MC \"%s\" (they must be part of the same UIElement!), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIMovieClipTmpl).c_str(), GetPortString(pActInfo, eI_UIParentMovieClip).c_str(), pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  678.                                 m_ParentDescHelper.Reset();
  679.                         }
  680.                 }
  681.  
  682.                 // if m_pCurrentParen was null we also allow to pass a template name!
  683.                 if (GetParentDesc() == NULL)
  684.                 {
  685.                         if (!m_ParentDescHelper.UpdateTmplDesc(GetPortString(pActInfo, eI_UIParentMovieClip), pActInfo))
  686.                                 return;
  687.                 }
  688.  
  689.                 if (GetElement() && IsPortActive(pActInfo, eI_Create))
  690.                 {
  691.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  692.                         string name = GetPortString(pActInfo, eI_NewInstanceName);
  693.  
  694.                         SPerInstanceCall3<const SUIMovieClipDesc*, const SUIMovieClipDesc*, string&> caller;
  695.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCTemplateCreateNode::CreateMoviclip), GetTemplateDesc(), GetParentDesc(), name, false))
  696.                         {
  697.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get CreateMovieClip for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetElement()->GetName(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  698.                         }
  699.  
  700.                         ActivateOutput(pActInfo, eO_InstanceName, name);
  701.                         ActivateOutput(pActInfo, eO_OnCreate, true);
  702.                 }
  703.         }
  704.  
  705. }
  706.  
  707. ////////////////////////////////////////////////////////////////////////////
  708. void CFlashUIMCTemplateCreateNode::CreateMoviclip(IUIElement* pElement, const SUIMovieClipDesc* pTemplate, const SUIMovieClipDesc* pParent, string& newname)
  709. {
  710.         const SUIMovieClipDesc* pNewMC = NULL;
  711.         pElement->CreateMovieClip(pNewMC, pTemplate, pParent, newname.length() > 0 ? newname.c_str() : NULL);
  712.         if (pNewMC)
  713.         {
  714.                 newname = pNewMC->sDisplayName;
  715.         }
  716.         else
  717.         {
  718.                 UIACTION_WARNING("FG: UIElement \"%s\" could not create MovieClip with name \"%s\" (MovieClip with same name already exists!)", pElement->GetName(), newname.c_str());
  719.         }
  720. }
  721.  
  722. ////////////////////////////////////////////////////////////////////////////
  723. ////////////////////////////////////////////////////////////////////////////
  724. ////////////////////////////////////////////////////////////////////////////
  725. void CFlashUIMCTemplateRemoveNode::GetConfiguration(SFlowNodeConfig& config)
  726. {
  727.         static const SInputPortConfig in_config[] = {
  728.                 CreateElementsPort(),
  729.                 CreateInstanceIdPort(),
  730.                 CreateTmplInstanceNamePort(),
  731.                 InputPortConfig_Void("Remove","Removes the given MovieClip"),
  732.                 InputPortConfig_Void(0),
  733.                 { 0 }
  734.         };
  735.  
  736.         static const SOutputPortConfig out_config[] = {
  737.                 OutputPortConfig_Void("OnRemove", "Triggered once the MovieClip was removed"),
  738.                 { 0 }
  739.         };
  740.  
  741.         config.pInputPorts = in_config;
  742.         config.pOutputPorts = out_config;
  743.         config.sDescription = "Removes a MovieClip";
  744.         config.SetCategory(EFLN_APPROVED);
  745. }
  746.  
  747. ////////////////////////////////////////////////////////////////////////////
  748. void CFlashUIMCTemplateRemoveNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  749. {
  750.         if (event == eFE_Initialize)
  751.         {
  752.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  753.         }
  754.         else if (event == eFE_Activate)
  755.         {
  756.                 if (IsPortActive(pActInfo, eI_UIElement))
  757.                 {
  758.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  759.                 }
  760.  
  761.                 if (!UpdateTmplDesc(GetPortString(pActInfo, eI_TemplateInstanceName), pActInfo))
  762.                         return;
  763.  
  764.                 if (GetElement() && IsPortActive(pActInfo, eI_Remove))
  765.                 {
  766.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  767.  
  768.                         SPerInstanceCall1<const SUIMovieClipDesc*> caller;
  769.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIMCTemplateRemoveNode::RemoveMoviclip), GetTmplDesc(true), false);
  770.  
  771.                         ActivateOutput(pActInfo, eO_OnRemove, true);
  772.                 }
  773.         }
  774.  
  775. }
  776.  
  777. ////////////////////////////////////////////////////////////////////////////
  778. REGISTER_FLOW_NODE("UI:Template:CreateMovieClip", CFlashUIMCTemplateCreateNode);
  779. REGISTER_FLOW_NODE("UI:Template:RemoveMovieClip", CFlashUIMCTemplateRemoveNode);
  780.  
  781. ////////////////////////////////////////////////////////////////////////////
  782. ////////////////////////////////////////////////////////////////////////////
  783. ////////////////////////////////////////////////////////////////////////////
  784. CFlashUIEventNode::CFlashUIEventNode(IUIElement* pUIElement, string sCategory, const SUIEventDesc* pEventDesc)
  785.         : CFlashUIBaseElementNode(pUIElement, sCategory)
  786.         , m_iCurrInstanceId(-1)
  787. {
  788.         CRY_ASSERT_MESSAGE(pEventDesc, "NULL pointer passed!");
  789.         m_eventDesc = *pEventDesc;
  790.  
  791.         //inputs
  792.         m_inPorts.push_back(CFlashUIBaseNode::CreateInstanceIdPort());
  793.         AddCheckPorts(m_eventDesc.InputParams, m_inPorts);
  794.         m_inPorts.push_back(InputPortConfig_Void(NULL));
  795.  
  796.         // outputs
  797.         m_outPorts.push_back(OutputPortConfig_Void("onEvent", "Event trigger"));
  798.         m_outPorts.push_back(OutputPortConfig<int>("instanceID", "The instance ID of the element that raised the event"));
  799.         AddParamOutputPorts(m_eventDesc.InputParams, m_outPorts);
  800.         if (m_eventDesc.InputParams.IsDynamic)
  801.                 m_outPorts.push_back(OutputPortConfig<string>("Array", m_eventDesc.InputParams.sDynamicDesc, m_eventDesc.InputParams.sDynamicName));
  802.         m_outPorts.push_back(OutputPortConfig_Void(NULL));
  803. }
  804.  
  805. ////////////////////////////////////////////////////////////////////////////
  806. IFlowNodePtr CFlashUIEventNode::Clone(SActivationInfo* pActInfo)
  807. {
  808.         return IFlowNodePtr(new CFlashUIEventNode(m_pElement, GetCategory(), &m_eventDesc));
  809. }
  810.  
  811. ////////////////////////////////////////////////////////////////////////////
  812. CFlashUIEventNode::~CFlashUIEventNode()
  813. {
  814.         m_events.clear();
  815.         ClearListener();
  816. }
  817.  
  818. ////////////////////////////////////////////////////////////////////////////
  819. void CFlashUIEventNode::GetConfiguration(SFlowNodeConfig& config)
  820. {
  821.         config.pInputPorts = &m_inPorts[0];
  822.         config.pOutputPorts = &m_outPorts[0];
  823.         config.sDescription = m_eventDesc.sDesc;
  824.         config.SetCategory(EFLN_APPROVED);
  825. }
  826.  
  827. ////////////////////////////////////////////////////////////////////////////
  828. void CFlashUIEventNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  829. {
  830.         switch (event)
  831.         {
  832.         case eFE_Initialize:
  833.                 {
  834.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  835.                         m_events.clear();
  836.                         m_events.init(pActInfo->pGraph);
  837.                         ClearListener();
  838.                         m_iCurrInstanceId = GetPortInt(pActInfo, eI_InstanceID);
  839.                         if (m_iCurrInstanceId < -1)
  840.                                 m_iCurrInstanceId = -1;
  841.  
  842.                         SPerInstanceCall0 caller;
  843.                         caller.Execute(m_pElement, m_iCurrInstanceId, functor(*this, &CFlashUIEventNode::RegisterAsListener));
  844.                 }
  845.                 break;
  846.         case eFE_Activate:
  847.                 if (IsPortActive(pActInfo, eI_InstanceID))
  848.                 {
  849.                         m_iCurrInstanceId = GetPortInt(pActInfo, eI_InstanceID);
  850.                         if (m_iCurrInstanceId < -1)
  851.                                 m_iCurrInstanceId = -1;
  852.                         ClearListener();
  853.  
  854.                         SPerInstanceCall0 caller;
  855.                         caller.Execute(m_pElement, m_iCurrInstanceId, functor(*this, &CFlashUIEventNode::RegisterAsListener));
  856.                 }
  857.                 break;
  858.         case eFE_Update:
  859.                 FlushNextEvent(pActInfo);
  860.                 break;
  861.         }
  862. }
  863.  
  864. ////////////////////////////////////////////////////////////////////////////
  865. void CFlashUIEventNode::OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance)
  866. {
  867.         if (m_iCurrInstanceId < 0)
  868.                 RegisterAsListener(pNewInstance);
  869. }
  870.  
  871. ////////////////////////////////////////////////////////////////////////////
  872. void CFlashUIEventNode::OnUIEvent(IUIElement* pSender, const SUIEventDesc& event, const SUIArguments& args)
  873. {
  874.         if (m_eventDesc == event)
  875.         {
  876.                 UI_STACK_PUSH(m_events, std::make_pair(args, pSender->GetInstanceID()), "OnFlashEvent %s@%i %s (%s)", pSender->GetName(), pSender->GetInstanceID(), event.sDisplayName, args.GetAsString());
  877.         }
  878. }
  879.  
  880. ////////////////////////////////////////////////////////////////////////////
  881. void CFlashUIEventNode::ClearListener()
  882. {
  883.         IUIElementIteratorPtr elements = m_pElement->GetInstances();
  884.         while (IUIElement* pElement = elements->Next())
  885.                 pElement->RemoveEventListener(this);
  886. }
  887.  
  888. ////////////////////////////////////////////////////////////////////////////
  889. void CFlashUIEventNode::FlushNextEvent(SActivationInfo* pActInfo)
  890. {
  891.         if (m_events.size() > 0)
  892.         {
  893.                 const std::pair<SUIArguments, int>& data = m_events.get();
  894.                 const SUIArguments& args = data.first;
  895.                 bool bTriggerEvent = true;
  896.                 const int checkValue = GetPortInt(pActInfo, eI_CheckPort);
  897.  
  898.                 if (checkValue >= 0)
  899.                 {
  900.                         bTriggerEvent = false;
  901.                         CRY_ASSERT_MESSAGE(checkValue < args.GetArgCount(), "Port does not exist!");
  902.                         if (checkValue < args.GetArgCount())
  903.                         {
  904.                                 string val = GetPortString(pActInfo, eI_CheckValue);
  905.                                 string compstr;
  906.                                 args.GetArg(checkValue).GetValueWithConversion(compstr);
  907.                                 bTriggerEvent = val == compstr;
  908.                         }
  909.                 }
  910.  
  911.                 if (bTriggerEvent)
  912.                 {
  913.                         int end = m_eventDesc.InputParams.Params.size();
  914.                         string val;
  915.  
  916.                         int i = 0;
  917.                         for (; i < end; ++i)
  918.                         {
  919.                                 CRY_ASSERT_MESSAGE(i < args.GetArgCount(), "UIEvent received wrong number of arguments!");
  920.                                 ActivateDynOutput(i < args.GetArgCount() ? args.GetArg(i) : TUIData(string("")), m_eventDesc.InputParams.Params[i], pActInfo, i + 2);
  921.                         }
  922.                         if (m_eventDesc.InputParams.IsDynamic)
  923.                         {
  924.                                 SUIArguments dynarg;
  925.                                 for (; i < args.GetArgCount(); ++i)
  926.                                 {
  927.                                         if (args.GetArg(i, val))
  928.                                                 dynarg.AddArgument(val);
  929.                                 }
  930.                                 ActivateOutput(pActInfo, end + eO_DynamicPorts, string(dynarg.GetAsString()));
  931.                         }
  932.                         ActivateOutput(pActInfo, eO_OnEvent, true);
  933.                         ActivateOutput(pActInfo, eO_OnInstanceId, data.second);
  934.                 }
  935.                 m_events.pop();
  936.         }
  937. }
  938.  
  939. ////////////////////////////////////////////////////////////////////////////
  940. ////////////////////////////////////////////////////////////////////////////
  941. ////////////////////////////////////////////////////////////////////////////
  942. CFlashUIFunctionNode::CFlashUIFunctionNode(IUIElement* pUIElement, string sCategory, const SUIEventDesc* pFuncDesc, bool isTemplate)
  943.         : CFlashUIBaseElementNode(pUIElement, sCategory)
  944.         , m_pTmplDesc(NULL)
  945.         , m_isTemplate(isTemplate)
  946. {
  947.         CRY_ASSERT_MESSAGE(pFuncDesc, "NULL pointer passed!");
  948.         m_funcDesc = *pFuncDesc;
  949.  
  950.         m_inPorts.push_back(InputPortConfig_Void("Call", "Calls the function"));
  951.         m_inPorts.push_back(CFlashUIBaseNode::CreateInstanceIdPort());
  952.         if (isTemplate)
  953.                 m_inPorts.push_back(CFlashUIBaseNode::CreateTmplInstanceNamePort());
  954.  
  955.         AddParamInputPorts(m_funcDesc.InputParams, m_inPorts);
  956.  
  957.         m_inPorts.push_back(InputPortConfig_Void(NULL));
  958.  
  959. }
  960.  
  961. ////////////////////////////////////////////////////////////////////////////
  962. IFlowNodePtr CFlashUIFunctionNode::Clone(SActivationInfo* pActInfo)
  963. {
  964.         return IFlowNodePtr(new CFlashUIFunctionNode(m_pElement, GetCategory(), &m_funcDesc, m_isTemplate));
  965. }
  966.  
  967. ////////////////////////////////////////////////////////////////////////////
  968. void CFlashUIFunctionNode::GetConfiguration(SFlowNodeConfig& config)
  969. {
  970.         static const SOutputPortConfig out_config[] = {
  971.                 OutputPortConfig_Void("OnCall",       "On call"),
  972.                 OutputPortConfig_AnyType("ReturnVal", "Return value of this function"),
  973.                 { 0 }
  974.         };
  975.  
  976.         config.pInputPorts = &m_inPorts[0];
  977.         config.pOutputPorts = out_config;
  978.         config.sDescription = m_funcDesc.sDesc;
  979.         config.SetCategory(EFLN_APPROVED);
  980. }
  981.  
  982. ////////////////////////////////////////////////////////////////////////////
  983. void CFlashUIFunctionNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  984. {
  985.         if (event == eFE_Activate && IsPortActive(pActInfo, eI_Call))
  986.         {
  987.                 int port = GetDynStartPort();
  988.                 SUIArguments args;
  989.                 for (TUIParams::const_iterator iter = m_funcDesc.InputParams.Params.begin(); iter != m_funcDesc.InputParams.Params.end(); ++iter)
  990.                         GetDynInput(args, *iter, pActInfo, port++);
  991.  
  992.                 TUIData res;
  993.                 res.Set(string());
  994.                 const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  995.  
  996.                 if (IsTemplate() && !UpdateTmplDesc(GetPortString(pActInfo, eI_TemplateInstanceName), pActInfo))
  997.                         return;
  998.  
  999.                 SPerInstanceCall2<const SUIArguments&, TUIData&> caller;
  1000.                 caller.Execute(m_pElement, instanceId, functor(*this, &CFlashUIFunctionNode::CallFunction), args, res);
  1001.  
  1002.                 string out;
  1003.                 res.GetValueWithConversion(out);
  1004.                 ActivateOutput(pActInfo, eO_RetVal, out);
  1005.  
  1006.                 ActivateOutput(pActInfo, eO_OnCall, true);
  1007.         }
  1008. }
  1009.  
  1010. ////////////////////////////////////////////////////////////////////////////
  1011. CFlashUIFunctionNode::~CFlashUIFunctionNode()
  1012. {
  1013.         // Note: m_funcDesc is invalid if this is called due to a reload in the editor
  1014.         // Do not try to access it here (points to old UIElement-memory)
  1015. }
  1016.  
  1017. ////////////////////////////////////////////////////////////////////////////
  1018. ////////////////////////////////////////////////////////////////////////////
  1019. ////////////////////////////////////////////////////////////////////////////
  1020. CFlashUIElementListenerNode::CFlashUIElementListenerNode(SActivationInfo* pActInfo)
  1021.         : m_iCurrInstanceId(-1)
  1022. {
  1023. }
  1024.  
  1025. ////////////////////////////////////////////////////////////////////////////
  1026. CFlashUIElementListenerNode::~CFlashUIElementListenerNode()
  1027. {
  1028.         m_events.clear();
  1029.         ClearListener();
  1030. }
  1031.  
  1032. ////////////////////////////////////////////////////////////////////////////
  1033. void CFlashUIElementListenerNode::GetConfiguration(SFlowNodeConfig& config)
  1034. {
  1035.         static const SInputPortConfig in_config[] = {
  1036.                 CreateElementsPort(),
  1037.                 CreateInstanceIdPort(),
  1038.                 { 0 }
  1039.         };
  1040.  
  1041.         static const SOutputPortConfig out_config[] = {
  1042.                 OutputPortConfig<int>("instanceID",          "Instance ID for the element that fired the event"),
  1043.                 OutputPortConfig_Void("onInit",              "Triggered when flash element was initialized"),
  1044.                 OutputPortConfig_Void("onUnload",            "Triggered when unloaded"),
  1045.                 OutputPortConfig_Void("onShow",              "Triggered when displayed"),
  1046.                 OutputPortConfig_Void("onHide",              "Triggered when hided"),
  1047.                 OutputPortConfig_Void("onNewInstance",       "Triggered when new instance was created"),
  1048.                 OutputPortConfig_Void("onInstanceDestroyed", "Triggered when instance was destroyed"),
  1049.                 { 0 }
  1050.         };
  1051.  
  1052.         config.sDescription = "Node receive notifications about display/hide/load/unload of an UIElements";
  1053.         config.pInputPorts = in_config;
  1054.         config.pOutputPorts = out_config;
  1055.         config.SetCategory(EFLN_APPROVED);
  1056. }
  1057.  
  1058. ////////////////////////////////////////////////////////////////////////////
  1059. void CFlashUIElementListenerNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1060. {
  1061.         switch (event)
  1062.         {
  1063.         case eFE_Initialize:
  1064.                 {
  1065.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  1066.                         m_events.clear();
  1067.                         m_events.init(pActInfo->pGraph);
  1068.                         ClearListener();
  1069.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  1070.                         m_iCurrInstanceId = GetPortInt(pActInfo, eI_InstanceID);
  1071.                         if (m_iCurrInstanceId < -1)
  1072.                                 m_iCurrInstanceId = -1;
  1073.  
  1074.                         SPerInstanceCall0 caller;
  1075.                         caller.Execute(GetElement(), m_iCurrInstanceId, functor(*this, &CFlashUIElementListenerNode::RegisterAsListener));
  1076.                 }
  1077.                 break;
  1078.         case eFE_Activate:
  1079.                 if (IsPortActive(pActInfo, eI_InstanceID) || IsPortActive(pActInfo, eI_UIElement))
  1080.                 {
  1081.                         ClearListener();
  1082.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  1083.                         m_iCurrInstanceId = GetPortInt(pActInfo, eI_InstanceID);
  1084.                         if (m_iCurrInstanceId < -1)
  1085.                                 m_iCurrInstanceId = -1;
  1086.  
  1087.                         SPerInstanceCall0 caller;
  1088.                         caller.Execute(GetElement(), m_iCurrInstanceId, functor(*this, &CFlashUIElementListenerNode::RegisterAsListener));
  1089.                 }
  1090.                 break;
  1091.         case eFE_Update:
  1092.                 FlushNextEvent(pActInfo);
  1093.                 break;
  1094.         }
  1095. }
  1096.  
  1097. ////////////////////////////////////////////////////////////////////////////
  1098. void CFlashUIElementListenerNode::FlushNextEvent(SActivationInfo* pActInfo)
  1099. {
  1100.         if (m_events.size() > 0)
  1101.         {
  1102.                 const std::pair<EOutputs, int>& data = m_events.get();
  1103.                 ActivateOutput(pActInfo, eO_InstanceId, data.second);
  1104.                 ActivateOutput(pActInfo, data.first, true);
  1105.                 m_events.pop();
  1106.         }
  1107. }
  1108.  
  1109. ////////////////////////////////////////////////////////////////////////////
  1110. void CFlashUIElementListenerNode::OnInit(IUIElement* pSender, IFlashPlayer* pFlashPlayer)
  1111. {
  1112.         UI_STACK_PUSH(m_events, std::make_pair(eO_OnInit, pSender->GetInstanceID()), "OnInit %s@%i", pSender->GetName(), pSender->GetInstanceID());
  1113. }
  1114.  
  1115. ////////////////////////////////////////////////////////////////////////////
  1116. void CFlashUIElementListenerNode::OnUnload(IUIElement* pSender)
  1117. {
  1118.         UI_STACK_PUSH(m_events, std::make_pair(eO_OnUnload, pSender->GetInstanceID()), "OnUnload %s@%i", pSender->GetName(), pSender->GetInstanceID());
  1119. }
  1120.  
  1121. ////////////////////////////////////////////////////////////////////////////
  1122. void CFlashUIElementListenerNode::OnSetVisible(IUIElement* pSender, bool bVisible)
  1123. {
  1124.         EOutputs port = bVisible ? eO_OnShow : eO_OnHide;
  1125.         UI_STACK_PUSH(m_events, std::make_pair(port, pSender->GetInstanceID()), "OnSetVisible %s@%i %s", pSender->GetName(), pSender->GetInstanceID(), bVisible ? "visible" : "hide");
  1126. }
  1127.  
  1128. ////////////////////////////////////////////////////////////////////////////
  1129. void CFlashUIElementListenerNode::OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance)
  1130. {
  1131.         RegisterAsListener(pNewInstance);
  1132. }
  1133.  
  1134. ////////////////////////////////////////////////////////////////////////////
  1135. void CFlashUIElementListenerNode::ClearListener()
  1136. {
  1137.         if (GetElement())
  1138.         {
  1139.                 IUIElementIteratorPtr elements = GetElement()->GetInstances();
  1140.                 while (IUIElement* pElement = elements->Next())
  1141.                         pElement->RemoveEventListener(this);
  1142.         }
  1143. }
  1144.  
  1145. ////////////////////////////////////////////////////////////////////////////
  1146. ////////////////////////////////////////////////////////////////////////////
  1147. ////////////////////////////////////////////////////////////////////////////
  1148. CFlashUIElementInstanceNode::~CFlashUIElementInstanceNode()
  1149. {
  1150.         m_events.clear();
  1151.         if (GetElement()) GetElement()->RemoveEventListener(this);
  1152. }
  1153.  
  1154. ////////////////////////////////////////////////////////////////////////////
  1155. void CFlashUIElementInstanceNode::GetConfiguration(SFlowNodeConfig& config)
  1156. {
  1157.         static const SInputPortConfig in_config[] = {
  1158.                 CreateElementsPort(),
  1159.                 CreateInstanceIdPort(),
  1160.                 InputPortConfig_Void("Destroy","Destroy UIElement instance"),
  1161.                 { 0 }
  1162.         };
  1163.  
  1164.         static const SOutputPortConfig out_config[] = {
  1165.                 OutputPortConfig<int>("instanceID",          "Instance ID for the element that fired the event"),
  1166.                 OutputPortConfig_Void("onNewInstance",       "Triggered when new instance was created"),
  1167.                 OutputPortConfig_Void("onInstanceDestroyed", "Triggered when instance was destroyed"),
  1168.                 { 0 }
  1169.         };
  1170.  
  1171.         config.sDescription = "Node to delete instances of UIElements and receive notifications about new/destroyed instances of an UIElements";
  1172.         config.pInputPorts = in_config;
  1173.         config.pOutputPorts = out_config;
  1174.         config.SetCategory(EFLN_APPROVED);
  1175. }
  1176.  
  1177. ////////////////////////////////////////////////////////////////////////////
  1178. void CFlashUIElementInstanceNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1179. {
  1180.         switch (event)
  1181.         {
  1182.         case eFE_Initialize:
  1183.                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  1184.                 m_events.clear();
  1185.                 m_events.init(pActInfo->pGraph);
  1186.                 if (GetElement()) GetElement()->RemoveEventListener(this);
  1187.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  1188.                 if (GetElement()) GetElement()->AddEventListener(this, "CFlashUIElementInstanceNode");
  1189.                 break;
  1190.         case eFE_Activate:
  1191.                 if (IsPortActive(pActInfo, eI_InstanceID) || IsPortActive(pActInfo, eI_UIElement))
  1192.                 {
  1193.                         if (GetElement()) GetElement()->RemoveEventListener(this);
  1194.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  1195.                         if (GetElement()) GetElement()->AddEventListener(this, "CFlashUIElementInstanceNode");
  1196.                 }
  1197.                 if (IsPortActive(pActInfo, eI_DestroyInstance))
  1198.                 {
  1199.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  1200.                         SPerInstanceCall0 caller;
  1201.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIElementInstanceNode::DestroyInstance));
  1202.                 }
  1203.                 break;
  1204.         case eFE_Update:
  1205.                 FlushNextEvent(pActInfo);
  1206.                 break;
  1207.         }
  1208. }
  1209.  
  1210. ////////////////////////////////////////////////////////////////////////////
  1211. void CFlashUIElementInstanceNode::FlushNextEvent(SActivationInfo* pActInfo)
  1212. {
  1213.         if (m_events.size() > 0)
  1214.         {
  1215.                 const std::pair<EOutputs, int>& data = m_events.get();
  1216.                 ActivateOutput(pActInfo, eO_InstanceId, data.second);
  1217.                 ActivateOutput(pActInfo, data.first, true);
  1218.                 m_events.pop();
  1219.         }
  1220. }
  1221.  
  1222. ////////////////////////////////////////////////////////////////////////////
  1223. void CFlashUIElementInstanceNode::OnInstanceCreated(IUIElement* pSender, IUIElement* pNewInstance)
  1224. {
  1225.         pNewInstance->AddEventListener(this, "CFlashUIElementInstanceNode");
  1226.         UI_STACK_PUSH(m_events, std::make_pair(eO_OnNewInstance, pNewInstance->GetInstanceID()), "OnInstanceCreated %s@%i", pSender->GetName(), pNewInstance->GetInstanceID());
  1227. }
  1228.  
  1229. ////////////////////////////////////////////////////////////////////////////
  1230. void CFlashUIElementInstanceNode::OnInstanceDestroyed(IUIElement* pSender, IUIElement* pDeletedInstance)
  1231. {
  1232.         UI_STACK_PUSH(m_events, std::make_pair(eO_OnInstanceDestroyed, pDeletedInstance->GetInstanceID()), "OnInstanceDestroyed %s@%i", pSender->GetName(), pDeletedInstance->GetInstanceID());
  1233. }
  1234.  
  1235. ////////////////////////////////////////////////////////////////////////////
  1236. REGISTER_FLOW_NODE("UI:Display:UIElementListener", CFlashUIElementListenerNode);
  1237. REGISTER_FLOW_NODE("UI:Display:UIElementInstance", CFlashUIElementInstanceNode);
  1238.  
downloadFlashUIElementNodes.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