BVB Source Codes

CRYENGINE Show FlashUIDisplayNodes.cpp Source code

Return Download CRYENGINE: download FlashUIDisplayNodes.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:   FlashUIDisplayNodes.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 "FlashUIDisplayNodes.h"
  14. #include "FlashUI.h"
  15.  
  16. // --------------------------------------------------------------
  17. void CFlashUIDisplayNode::GetConfiguration(SFlowNodeConfig& config)
  18. {
  19.         static const SInputPortConfig in_config[] = {
  20.                 CreateElementsPort(),
  21.                 CreateInstanceIdPort(),
  22.                 InputPortConfig_Void("show",              "Display UI element"),
  23.                 InputPortConfig_Void("hide",              "Hide UI element"),
  24.                 InputPortConfig_Void("unload",            "Unload UI element"),
  25.                 InputPortConfig_Void("requestHide",       "Send request for hide to flash asset, to allow fade out"),
  26.                 InputPortConfig_Void("init",              "Inits the flash file"),
  27.                 InputPortConfig_Void("reload",            "Reloads the flash file"),
  28.                 InputPortConfig_Void("unloadBootstrapper","Unloads the bootstrapper for this UI Element. Will unload all Instances of this element"),
  29.                 InputPortConfig_Void("reloadBootstrapper","Reloads the bootstrapper for this UI Element. Will reload all Instances of this element"),
  30.                 { 0 }
  31.         };
  32.  
  33.         static const SOutputPortConfig out_config[] = {
  34.                 OutputPortConfig_Void("onShow",               "Triggered when display was called"),
  35.                 OutputPortConfig_Void("onHide",               "Triggered when hide was called"),
  36.                 OutputPortConfig_Void("onUnload",             "Triggered when unload was called"),
  37.                 OutputPortConfig_Void("onRequestHide",        "Triggered when hide was requested"),
  38.                 OutputPortConfig_Void("onInit",               "Triggered when init was called"),
  39.                 OutputPortConfig_Void("onReload",             "Triggered when reload was called"),
  40.                 OutputPortConfig_Void("onUnloadBootstrapper", "Triggered when unload bootstrapper was called"),
  41.                 OutputPortConfig_Void("onReloadBootstrapper", "Triggered when reload bootstrapper was called"),
  42.                 { 0 }
  43.         };
  44.  
  45.         config.sDescription = "Node to display/hide/reload UIElements";
  46.         config.pInputPorts = in_config;
  47.         config.pOutputPorts = out_config;
  48.         config.SetCategory(EFLN_APPROVED);
  49. }
  50.  
  51. void CFlashUIDisplayNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  52. {
  53.         if (event == eFE_Initialize)
  54.         {
  55.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  56.         }
  57.         else if (event == eFE_Activate)
  58.         {
  59.                 if (IsPortActive(pActInfo, eI_UIElement))
  60.                 {
  61.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  62.                 }
  63.  
  64.                 const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  65.  
  66.                 if (IsPortActive(pActInfo, eI_Show))
  67.                 {
  68.                         SPerInstanceCall1<bool> caller;
  69.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::SetVisible), true);
  70.                         ActivateOutput(pActInfo, eO_OnShow, true);
  71.                 }
  72.  
  73.                 if (IsPortActive(pActInfo, eI_Hide))
  74.                 {
  75.                         SPerInstanceCall1<bool> caller;
  76.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::SetVisible), false);
  77.                         ActivateOutput(pActInfo, eO_OnHide, true);
  78.                 }
  79.  
  80.                 if (IsPortActive(pActInfo, eI_Unload))
  81.                 {
  82.                         SPerInstanceCall0 caller;
  83.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::Unload));
  84.                         ActivateOutput(pActInfo, eO_OnUnload, true);
  85.                 }
  86.  
  87.                 if (IsPortActive(pActInfo, eI_RequestHide))
  88.                 {
  89.                         SPerInstanceCall0 caller;
  90.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::RequestHide));
  91.                         ActivateOutput(pActInfo, eO_OnRequestHide, true);
  92.                 }
  93.  
  94.                 if (IsPortActive(pActInfo, eI_Init))
  95.                 {
  96.                         SPerInstanceCall0 caller;
  97.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::Init));
  98.                         ActivateOutput(pActInfo, eO_OnInit, true);
  99.                 }
  100.  
  101.                 if (IsPortActive(pActInfo, eI_Reload))
  102.                 {
  103.                         SPerInstanceCall0 caller;
  104.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayNode::Reload));
  105.                         ActivateOutput(pActInfo, eO_OnReload, true);
  106.                 }
  107.  
  108.                 if (IsPortActive(pActInfo, eI_UnloadBootstrapper))
  109.                 {
  110.                         if (GetElement()) GetElement()->UnloadBootStrapper();
  111.                         ActivateOutput(pActInfo, eO_OnUnloadBootstrapper, true);
  112.                 }
  113.  
  114.                 if (IsPortActive(pActInfo, eI_ReloadBootstrapper))
  115.                 {
  116.                         if (GetElement()) GetElement()->ReloadBootStrapper();
  117.                         ActivateOutput(pActInfo, eO_OnReloadBootstrapper, true);
  118.                 }
  119.         }
  120. }
  121.  
  122. //------------------------------------------------------------------------------------------------------
  123. void CFlashUIAdvanceNode::GetConfiguration(SFlowNodeConfig& config)
  124. {
  125.         static const SInputPortConfig in_config[] = {
  126.                 CreateElementsPort(),
  127.                 CreateInstanceIdPort(),
  128.                 InputPortConfig_Void("Advance","Advance the flash player"),
  129.                 InputPortConfig<float>("Delta",0,                           "Delta time for advance"),
  130.                 { 0 }
  131.         };
  132.         static const SOutputPortConfig out_config[] = {
  133.                 OutputPortConfig_Void("onAdvance", "Triggered when advance was called"),
  134.                 { 0 }
  135.         };
  136.         config.sDescription = "Node to advance a UIElement";
  137.         config.pInputPorts = in_config;
  138.         config.pOutputPorts = out_config;
  139.         config.SetCategory(EFLN_APPROVED);
  140. }
  141.  
  142. void CFlashUIAdvanceNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  143. {
  144.         if (event == eFE_Initialize)
  145.         {
  146.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  147.         }
  148.         else if (event == eFE_Activate)
  149.         {
  150.                 if (IsPortActive(pActInfo, eI_UIElement))
  151.                 {
  152.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  153.                 }
  154.  
  155.                 if (IsPortActive(pActInfo, eI_Advance))
  156.                 {
  157.                         const float delta = GetPortFloat(pActInfo, eI_Delta);
  158.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  159.  
  160.                         SPerInstanceCall1<float> caller1;
  161.                         caller1.Execute(GetElement(), instanceId, functor(*this, &CFlashUIAdvanceNode::Advance), delta);
  162.  
  163.                         ActivateOutput(pActInfo, eO_OnAdvance, true);
  164.                 }
  165.         }
  166. }
  167.  
  168. void CFlashUIAdvanceNode::Advance(IUIElement* pInstance, float delta)
  169. {
  170.         // update call will not lazy init! so do it here
  171.         if (!pInstance->IsInit())
  172.                 pInstance->Init();
  173.         pInstance->Update(delta);
  174. }
  175.  
  176. //------------------------------------------------------------------------------------------------------
  177. void CFlashUIScreenPosNode::GetConfiguration(SFlowNodeConfig& config)
  178. {
  179.         static const SInputPortConfig in_config[] = {
  180.                 CreateElementsPort(),
  181.                 CreateInstanceIdPort(),
  182.                 InputPortConfig_Void("Get",            "Trigger the node"),
  183.                 InputPortConfig<float>("PX",           0,                   "Input screen x-pos (0-1)"),
  184.                 InputPortConfig<float>("PY",           0,                   "Input screen y-pos (0-1)"),
  185.                 InputPortConfig<bool>("StageScaleMode",false,               "If flash asset uses stage.scaleMode this must be true,\nthe movieclip must sit in another mc that is manually located in the center of the screen"),
  186.                 { 0 }
  187.         };
  188.         static const SOutputPortConfig out_config[] = {
  189.                 OutputPortConfig_Void("onGet", "Triggered when advance was called"),
  190.                 OutputPortConfig<float>("PX",  "Screen x-pos for selected Flash asset"),
  191.                 OutputPortConfig<float>("PY",  "Screen y-pos for selected Flash asset"),
  192.                 { 0 }
  193.         };
  194.         config.sDescription = "Node to convert a screen position (Value 0-1) to a actual X,Y position in the flash asset";
  195.         config.pInputPorts = in_config;
  196.         config.pOutputPorts = out_config;
  197.         config.SetCategory(EFLN_APPROVED);
  198. }
  199.  
  200. void CFlashUIScreenPosNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  201. {
  202.         if (event == eFE_Initialize)
  203.         {
  204.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  205.         }
  206.         else if (event == eFE_Activate)
  207.         {
  208.                 if (IsPortActive(pActInfo, eI_UIElement))
  209.                 {
  210.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  211.                 }
  212.  
  213.                 if (IsPortActive(pActInfo, eI_Get))
  214.                 {
  215.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  216.                         float px = GetPortFloat(pActInfo, eI_PX);
  217.                         float py = GetPortFloat(pActInfo, eI_PY);
  218.                         const bool scaleMode = GetPortBool(pActInfo, eI_ScaleMode);
  219.  
  220.                         SPerInstanceCall3<float&, float&, bool> caller;
  221.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIScreenPosNode::GetScreenPos), px, py, scaleMode, false))
  222.                         {
  223.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get screenpos for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  224.                         }
  225.  
  226.                         ActivateOutput(pActInfo, eO_OnGet, true);
  227.                         ActivateOutput(pActInfo, eO_PX, px);
  228.                         ActivateOutput(pActInfo, eO_PY, py);
  229.                 }
  230.         }
  231. }
  232.  
  233. void CFlashUIScreenPosNode::GetScreenPos(IUIElement* pInstance, float& px /*in/out*/, float& py /*in/out*/, bool bScaleMode)
  234. {
  235.         pInstance->ScreenToFlash(px, py, px, py, bScaleMode);
  236. }
  237.  
  238. //------------------------------------------------------------------------------------------------------
  239. void CFlashUIWorldScreenPosNode::GetConfiguration(SFlowNodeConfig& config)
  240. {
  241.         static const SInputPortConfig in_config[] = {
  242.                 CreateElementsPort(),
  243.                 CreateInstanceIdPort(),
  244.                 InputPortConfig_Void("Get",            "Trigger the node"),
  245.                 InputPortConfig<Vec3>("WorldPos",      "Input world pos"),
  246.                 InputPortConfig<Vec3>("Offset",        "Offset of the world pos"),
  247.                 InputPortConfig<bool>("StageScaleMode",false,                      "If flash asset uses stage.scaleMode this must be true,\nthe movieclip must sit in another mc that is manually located in the center of the screen"),
  248.                 { 0 }
  249.         };
  250.         static const SOutputPortConfig out_config[] = {
  251.                 OutputPortConfig_Void("onGet",      "Triggered when advance was called"),
  252.                 OutputPortConfig<Vec3>("ScreenPos", "Screen in selected selected Flash asset"),
  253.                 OutputPortConfig<float>("Scale",    "If you use 2.5D mode this will return scale for your movieclip simulate the depth."),
  254.                 OutputPortConfig<bool>("OnScreen",  "True if on screen otherwise false"),
  255.                 OutputPortConfig<Vec3>("Border",    "If not on screen x=-1 means left from screen x=1 right from screen, y=-1 top of screen y=1 below the screen"),
  256.                 { 0 }
  257.         };
  258.         config.sDescription = "Node to convert a world position to a actual X,Y,Z and Scale value in the flash asset";
  259.         config.pInputPorts = in_config;
  260.         config.pOutputPorts = out_config;
  261.         config.SetCategory(EFLN_APPROVED);
  262. }
  263.  
  264. void CFlashUIWorldScreenPosNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  265. {
  266.         if (event == eFE_Initialize)
  267.         {
  268.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  269.         }
  270.         else if (event == eFE_Activate)
  271.         {
  272.                 if (IsPortActive(pActInfo, eI_UIElement))
  273.                 {
  274.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  275.                 }
  276.  
  277.                 if (IsPortActive(pActInfo, eI_Get))
  278.                 {
  279.                         const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  280.                         Vec3 worldPos = GetPortVec3(pActInfo, eI_WorldPos);
  281.                         Vec3 offset = GetPortVec3(pActInfo, eI_Offset);
  282.                         const bool scaleMode = GetPortBool(pActInfo, eI_ScaleMode);
  283.  
  284.                         SPerInstanceCall3<Vec3&, Vec3&, bool> caller;
  285.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIWorldScreenPosNode::GetScreenPosFromWorld), worldPos, offset, scaleMode, false))
  286.                         {
  287.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get screenpos for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  288.                         }
  289.  
  290.                         ActivateOutput(pActInfo, eO_ScreenPos, worldPos);
  291.                         ActivateOutput(pActInfo, eO_Scale, offset.z);
  292.                         ActivateOutput(pActInfo, eO_IsOnScreen, offset.x == 0 && offset.y == 0);
  293.                         offset.z = 0;
  294.                         ActivateOutput(pActInfo, eO_OverScanBorder, offset);
  295.                         ActivateOutput(pActInfo, eO_OnGet, true);
  296.                 }
  297.         }
  298. }
  299.  
  300. void CFlashUIWorldScreenPosNode::GetScreenPosFromWorld(IUIElement* pInstance, Vec3& pos /*in/out*/, Vec3& offset /*in/out*/, bool bScaleMode)
  301. {
  302.         // get current camera matrix
  303.         const CCamera& cam = GetISystem()->GetViewCamera();
  304.         const Matrix34& camMat = cam.GetMatrix();
  305.  
  306.         // add offset to position
  307.         const Vec3 vFaceingPos = camMat.GetTranslation() - camMat.GetColumn1() * 1000.f;
  308.         const Vec3 vDir = (pos - vFaceingPos).GetNormalizedFast();
  309.         const Vec3 vOffsetX = vDir.Cross(Vec3Constants<float>::fVec3_OneZ).GetNormalizedFast() * offset.x;
  310.         const Vec3 vOffsetY = vDir * offset.y;
  311.         const Vec3 vOffsetZ = Vec3(0, 0, offset.z);
  312.         const Vec3 vOffset = vOffsetX + vOffsetY + vOffsetZ;
  313.         pos += vOffset;
  314.  
  315.         Vec2 borders;
  316.         float scale;
  317.         Vec3 flashPos;
  318.         pInstance->WorldToFlash(camMat, pos, flashPos, borders, scale, bScaleMode);
  319.  
  320.         // return flashpos in pos
  321.         pos = flashPos;
  322.  
  323.         // store overflow in offset x/y and scale in z
  324.         offset.x = borders.x;
  325.         offset.y = borders.y;
  326.         offset.z = scale;
  327. }
  328.  
  329. //------------------------------------------------------------------------------------------------------
  330. void CFlashUIDisplayConfigNode::GetConfiguration(SFlowNodeConfig& config)
  331. {
  332.         static const SInputPortConfig in_config[] = {
  333.                 CreateElementsPort(),
  334.                 CreateInstanceIdPort(),
  335.                 InputPortConfig_Void("get",             "Get configuration"),
  336.                 InputPortConfig_Void("set",             "set configuration"),
  337.  
  338.                 InputPortConfig<bool>("cursor",         "Enables mouse cursor"),
  339.                 InputPortConfig<bool>("mouseEvents",    "Enables mouse events"),
  340.                 InputPortConfig<bool>("keyEvents",      "Enables mouse events"),
  341.                 InputPortConfig<bool>("consoleMouse",   "Enables use controller stick as mouse on console (only if \"mouseEvents\" is enabled)"),
  342.                 InputPortConfig<bool>("consoleCursor",  "Enables cursor on console (only if \"cursor\" is enabled)"),
  343.                 InputPortConfig<bool>("controllerInput","Enables controller input"),
  344.                 InputPortConfig<bool>("eventsExclusive","If set to true no other elements will receive events if this element receives them first"),
  345.                 InputPortConfig<bool>("fixedProjDepth", "If set to true this element will use pseudo 3D mode. The _z value of each movieclip will only affect its size to give the feeling of \"correct\" depth"),
  346.  
  347.                 InputPortConfig<bool>("forceNoUnload",  "If set to true this element will not be unloaded on level unload (flag will be applied to all instances!)"),
  348.  
  349.                 InputPortConfig<float>("alpha",         "Alpha"),
  350.                 InputPortConfig<int>("layer",           "layer of the element"),
  351.                 { 0 }
  352.         };
  353.  
  354.         static const SOutputPortConfig out_config[] = {
  355.                 OutputPortConfig_Void("OnSet",              _HELP("Triggered on set")),
  356.                 OutputPortConfig_Void("OnGet",              _HELP("Triggered on get")),
  357.                 OutputPortConfig<bool>("isVisible",         "Current menu state"),
  358.  
  359.                 OutputPortConfig<bool>("hasCursor",         "Current cursor state"),
  360.                 OutputPortConfig<bool>("hasMouseEvents",    "Current mouse event state"),
  361.                 OutputPortConfig<bool>("hasKeyEvents",      "Current key event state"),
  362.                 OutputPortConfig<bool>("isConsoleMouse",    "Current console mouse state"),
  363.                 OutputPortConfig<bool>("isConsoleCursor",   "Current console cursor state"),
  364.                 OutputPortConfig<bool>("isControllerInput", "Current controller input state"),
  365.                 OutputPortConfig<bool>("isEventsExclusive", "Current event exclusive state"),
  366.                 OutputPortConfig<bool>("isFixedProjDepth",  "Current fixedProjDepth state"),
  367.  
  368.                 OutputPortConfig<bool>("isForceNoUnload",   "Current forceNoUnload state"),
  369.  
  370.                 OutputPortConfig<float>("alpha",            "Current alpha value"),
  371.                 OutputPortConfig<int>("layer",              "layer of the element"),
  372.                 { 0 }
  373.         };
  374.  
  375.         config.sDescription = "Node to setup flags for UIElements";
  376.         config.pInputPorts = in_config;
  377.         config.pOutputPorts = out_config;
  378.         config.SetCategory(EFLN_APPROVED);
  379. }
  380.  
  381. void CFlashUIDisplayConfigNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  382. {
  383.         if (event == eFE_Initialize)
  384.         {
  385.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  386.         }
  387.         else if (event == eFE_Activate)
  388.         {
  389.                 if (IsPortActive(pActInfo, eI_UIElement))
  390.                 {
  391.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  392.                 }
  393.  
  394.                 const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  395.  
  396.                 if (IsPortActive(pActInfo, eI_Get))
  397.                 {
  398.                         SPerInstanceCall1<SActivationInfo*> caller;
  399.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayConfigNode::GetFromInstance), pActInfo, false))
  400.                         {
  401.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get flags for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  402.                         }
  403.                         ActivateOutput(pActInfo, eO_OnGet, true);
  404.                 }
  405.  
  406.                 if (IsPortActive(pActInfo, eI_Set))
  407.                 {
  408.                         const float alpha = GetPortFloat(pActInfo, eI_Alpha);
  409.                         const int layer = GetPortInt(pActInfo, eI_Layer);
  410.                         const uint64 flags = GetFlags(pActInfo);
  411.  
  412.                         SPerInstanceCall3<uint64, float, int> caller;
  413.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIDisplayConfigNode::SetToInstance), flags, alpha, layer);
  414.                         ActivateOutput(pActInfo, eO_OnSet, true);
  415.                 }
  416.         }
  417. }
  418.  
  419. void CFlashUIDisplayConfigNode::GetFromInstance(IUIElement* pInstance, SActivationInfo* pActInfo)
  420. {
  421.         ActivateOutput(pActInfo, eO_IsCursorEnabled, pInstance->HasFlag(IUIElement::eFUI_HARDWARECURSOR));
  422.         ActivateOutput(pActInfo, eO_IsMouseEvents, pInstance->HasFlag(IUIElement::eFUI_MOUSEEVENTS));
  423.         ActivateOutput(pActInfo, eO_IsKeyEvents, pInstance->HasFlag(IUIElement::eFUI_KEYEVENTS));
  424.         ActivateOutput(pActInfo, eO_IsConsole_Mouse, pInstance->HasFlag(IUIElement::eFUI_CONSOLE_MOUSE));
  425.         ActivateOutput(pActInfo, eO_IsConsole_Cursor, pInstance->HasFlag(IUIElement::eFUI_CONSOLE_CURSOR));
  426.         ActivateOutput(pActInfo, eO_IsController_Input, pInstance->HasFlag(IUIElement::eFUI_CONTROLLER_INPUT));
  427.         ActivateOutput(pActInfo, eO_IsEvents_Exclusive, pInstance->HasFlag(IUIElement::eFUI_EVENTS_EXCLUSIVE));
  428.         ActivateOutput(pActInfo, eO_IsFixedProjDepth, pInstance->HasFlag(IUIElement::eFUI_FIXED_PROJ_DEPTH));
  429.  
  430.         ActivateOutput(pActInfo, eO_IsForce_NoUnload, pInstance->HasFlag(IUIElement::eFUI_FORCE_NO_UNLOAD));
  431.  
  432.         ActivateOutput(pActInfo, eO_IsVisible, pInstance->IsVisible());
  433.         ActivateOutput(pActInfo, eO_Alpha, pInstance->GetAlpha());
  434.         ActivateOutput(pActInfo, eO_Layer, pInstance->GetLayer());
  435. }
  436.  
  437. void CFlashUIDisplayConfigNode::SetToInstance(IUIElement* pInstance, uint64 flags, float alpha, int layer)
  438. {
  439.         // todo: optimize don't call GetPortBool for each instance!
  440.         pInstance->SetFlag(IUIElement::eFUI_HARDWARECURSOR, (flags& IUIElement::eFUI_HARDWARECURSOR) != 0);
  441.         pInstance->SetFlag(IUIElement::eFUI_MOUSEEVENTS, (flags& IUIElement::eFUI_MOUSEEVENTS) != 0);
  442.         pInstance->SetFlag(IUIElement::eFUI_KEYEVENTS, (flags& IUIElement::eFUI_KEYEVENTS) != 0);
  443.         pInstance->SetFlag(IUIElement::eFUI_CONSOLE_MOUSE, (flags& IUIElement::eFUI_CONSOLE_MOUSE) != 0);
  444.         pInstance->SetFlag(IUIElement::eFUI_CONSOLE_CURSOR, (flags& IUIElement::eFUI_CONSOLE_CURSOR) != 0);
  445.         pInstance->SetFlag(IUIElement::eFUI_CONTROLLER_INPUT, (flags& IUIElement::eFUI_CONTROLLER_INPUT) != 0);
  446.         pInstance->SetFlag(IUIElement::eFUI_EVENTS_EXCLUSIVE, (flags& IUIElement::eFUI_EVENTS_EXCLUSIVE) != 0);
  447.         pInstance->SetFlag(IUIElement::eFUI_FIXED_PROJ_DEPTH, (flags& IUIElement::eFUI_FIXED_PROJ_DEPTH) != 0);
  448.  
  449.         pInstance->SetFlag(IUIElement::eFUI_FORCE_NO_UNLOAD, (flags& IUIElement::eFUI_FORCE_NO_UNLOAD) != 0);
  450.  
  451.         pInstance->SetAlpha(alpha);
  452.         pInstance->SetLayer(layer);
  453. }
  454.  
  455. uint64 CFlashUIDisplayConfigNode::GetFlags(SActivationInfo* pActInfo)
  456. {
  457.         uint64 flags = 0;
  458.         flags |= GetPortBool(pActInfo, eI_CursorEnabled) ? IUIElement::eFUI_HARDWARECURSOR : 0;
  459.         flags |= GetPortBool(pActInfo, eI_MouseEventsEnabled) ? IUIElement::eFUI_MOUSEEVENTS : 0;
  460.         flags |= GetPortBool(pActInfo, eI_KeyEventsEnabled) ? IUIElement::eFUI_KEYEVENTS : 0;
  461.         flags |= GetPortBool(pActInfo, eI_Console_Mouse) ? IUIElement::eFUI_CONSOLE_MOUSE : 0;
  462.         flags |= GetPortBool(pActInfo, eI_Console_Cursor) ? IUIElement::eFUI_CONSOLE_CURSOR : 0;
  463.         flags |= GetPortBool(pActInfo, eI_Controller_Input) ? IUIElement::eFUI_CONTROLLER_INPUT : 0;
  464.         flags |= GetPortBool(pActInfo, eI_Events_Exclusive) ? IUIElement::eFUI_EVENTS_EXCLUSIVE : 0;
  465.         flags |= GetPortBool(pActInfo, eI_FixedProjDepth) ? IUIElement::eFUI_FIXED_PROJ_DEPTH : 0;
  466.  
  467.         flags |= GetPortBool(pActInfo, eI_Force_NoUnload) ? IUIElement::eFUI_FORCE_NO_UNLOAD : 0;
  468.  
  469.         return flags;
  470. }
  471.  
  472. //------------------------------------------------------------------------------------------------------
  473. void CFlashUILayerNode::GetConfiguration(SFlowNodeConfig& config)
  474. {
  475.         static const SInputPortConfig in_config[] = {
  476.                 CreateElementsPort(),
  477.                 CreateInstanceIdPort(),
  478.                 InputPortConfig_Void("get",  "Get configuration"),
  479.                 InputPortConfig_Void("set",  "set configuration"),
  480.                 InputPortConfig<int>("layer","layer of the element"),
  481.                 { 0 }
  482.         };
  483.  
  484.         static const SOutputPortConfig out_config[] = {
  485.                 OutputPortConfig_Void("OnSet", _HELP("Triggered on set")),
  486.                 OutputPortConfig_Void("OnGet", _HELP("Triggered on get")),
  487.                 OutputPortConfig<int>("layer", "layer of the element"),
  488.                 { 0 }
  489.         };
  490.  
  491.         config.sDescription = "Node to setup layer of UIElements";
  492.         config.pInputPorts = in_config;
  493.         config.pOutputPorts = out_config;
  494.         config.SetCategory(EFLN_APPROVED);
  495. }
  496.  
  497. void CFlashUILayerNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  498. {
  499.         if (event == eFE_Initialize)
  500.         {
  501.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  502.         }
  503.         else if (event == eFE_Activate)
  504.         {
  505.                 if (IsPortActive(pActInfo, eI_UIElement))
  506.                 {
  507.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  508.                 }
  509.  
  510.                 const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  511.  
  512.                 if (IsPortActive(pActInfo, eI_Get))
  513.                 {
  514.                         int layer = 0;
  515.  
  516.                         SPerInstanceCall1<int&> caller;
  517.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUILayerNode::GetLayer), layer, false))
  518.                         {
  519.                                 UIACTION_WARNING("FG: UIElement \"%s\" called get layer for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  520.                         }
  521.  
  522.                         ActivateOutput(pActInfo, eO_Layer, layer);
  523.                         ActivateOutput(pActInfo, eO_OnGet, true);
  524.                 }
  525.  
  526.                 if (IsPortActive(pActInfo, eI_Set))
  527.                 {
  528.                         const int layer = GetPortInt(pActInfo, eI_Layer);
  529.  
  530.                         SPerInstanceCall1<int> caller;
  531.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUILayerNode::SetLayer), layer);
  532.  
  533.                         ActivateOutput(pActInfo, eO_OnSet, true);
  534.                 }
  535.         }
  536. }
  537.  
  538. //------------------------------------------------------------------------------------------------------
  539. void CFlashUIConstraintsNode::GetConfiguration(SFlowNodeConfig& config)
  540. {
  541.         static const SInputPortConfig in_config[] = {
  542.                 CreateElementsPort(),
  543.                 CreateInstanceIdPort(),
  544.                 InputPortConfig_Void("set",      "Set configuration"),
  545.                 InputPortConfig_Void("get",      "Get configuration"),
  546.                 InputPortConfig<int>("type",     1,                                             _HELP("Set positioning type (fixed=fixed position, dynamic=fit screen but keep aspect ratio, fullscreen=scale to fullscreen) "),0, _UICONFIG("enum_int:Fixed=0,Fullscreen=1,Dynamic=2")),
  547.                 InputPortConfig<int>("left",     "Set left position (fixed mode)"),
  548.                 InputPortConfig<int>("top",      "Set top position (fixed mode)"),
  549.                 InputPortConfig<int>("width",    "Set width (fixed mode)"),
  550.                 InputPortConfig<int>("height",   "Set height (fixed mode)"),
  551.                 InputPortConfig<bool>("scale",   "Set scale"),
  552.                 InputPortConfig<int>("hAlign",   1,                                             _HELP("Set horizontal align (dynamic mode)"),                                                                  0, _UICONFIG("enum_int:Left=0,Middle=1,Right=2")),
  553.                 InputPortConfig<int>("vAlign",   1,                                             _HELP("Set vertical align (dynamic mode)"),                                                                    0, _UICONFIG("enum_int:Top=0,Middle=1,Bottom=2")),
  554.                 InputPortConfig<bool>("maximize","Set if element is maximized (dynamic mode)"),
  555.                 { 0 }
  556.         };
  557.  
  558.         static const SOutputPortConfig out_config[] = {
  559.                 OutputPortConfig_Void("OnSet",     _HELP("Triggered on set")),
  560.                 OutputPortConfig_Void("OnGet",     _HELP("Triggered on get")),
  561.                 OutputPortConfig<int>("type",      _HELP("Get positioning type (0=fixed position, 1=scaled to fit screen)")),
  562.                 OutputPortConfig<int>("left",      "Get left position"),
  563.                 OutputPortConfig<int>("top",       "Get top position"),
  564.                 OutputPortConfig<int>("width",     "Get width"),
  565.                 OutputPortConfig<int>("height",    "Get height"),
  566.                 OutputPortConfig<bool>("scale",    "Get scale"),
  567.                 OutputPortConfig<int>("hAlign",    "Get horizontal align (0:Left, 1:Middle, 2:Right)"),
  568.                 OutputPortConfig<int>("vAlign",    "Get vertical align (0:Bottom, 1:Middle 2:Top"),
  569.                 OutputPortConfig<bool>("maximize", "Get maximize"),
  570.                 { 0 }
  571.         };
  572.  
  573.         config.sDescription = "Node to setup constraints for UIElements";
  574.         config.pInputPorts = in_config;
  575.         config.pOutputPorts = out_config;
  576.         config.SetCategory(EFLN_APPROVED);
  577. }
  578.  
  579. void CFlashUIConstraintsNode::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  580. {
  581.         if (event == eFE_Initialize)
  582.         {
  583.                 UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  584.         }
  585.         else if (event == eFE_Activate)
  586.         {
  587.                 if (IsPortActive(pActInfo, eI_UIElement))
  588.                 {
  589.                         UpdateUIElement(GetPortString(pActInfo, eI_UIElement), pActInfo);
  590.                 }
  591.  
  592.                 const int instanceId = GetPortInt(pActInfo, eI_InstanceID);
  593.                 if (IsPortActive(pActInfo, eI_Get))
  594.                 {
  595.                         IUIElement::SUIConstraints constraints;
  596.                         SPerInstanceCall1<IUIElement::SUIConstraints&> caller;
  597.                         if (!caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIConstraintsNode::GetConstraints), constraints, false))
  598.                         {
  599.                                 UIACTION_WARNING("FG: UIElement \"%s\" can't get Constraints for multiple instances! (passed instanceId %i), referenced at node \"%s\"", GetPortString(pActInfo, eI_UIElement).c_str(), instanceId, pActInfo->pGraph->GetNodeTypeName(pActInfo->myID));
  600.                         }
  601.                         ActivateOutput(pActInfo, eO_PosType, (int) constraints.eType);
  602.                         ActivateOutput(pActInfo, eO_Left, constraints.iLeft);
  603.                         ActivateOutput(pActInfo, eO_Top, constraints.iTop);
  604.                         ActivateOutput(pActInfo, eO_Width, constraints.iWidth);
  605.                         ActivateOutput(pActInfo, eO_Height, constraints.iHeight);
  606.                         ActivateOutput(pActInfo, eO_Scale, constraints.bScale);
  607.                         ActivateOutput(pActInfo, eO_HAlign, (int) constraints.eHAlign);
  608.                         ActivateOutput(pActInfo, eO_VAlign, (int) constraints.eVAlign);
  609.                         ActivateOutput(pActInfo, eO_Maximize, constraints.bMax);
  610.                         ActivateOutput(pActInfo, eO_OnGet, true);
  611.                 }
  612.  
  613.                 if (IsPortActive(pActInfo, eI_Set))
  614.                 {
  615.                         IUIElement::SUIConstraints constraints;
  616.                         constraints.eType = (IUIElement::SUIConstraints::EPositionType) GetPortInt(pActInfo, eI_PosType);
  617.                         constraints.iLeft = GetPortInt(pActInfo, eI_Left);
  618.                         constraints.iTop = GetPortInt(pActInfo, eI_Top);
  619.                         constraints.iWidth = GetPortInt(pActInfo, eI_Width);
  620.                         constraints.iHeight = GetPortInt(pActInfo, eI_Height);
  621.                         constraints.eHAlign = (IUIElement::SUIConstraints::EPositionAlign) GetPortInt(pActInfo, eI_HAlign);
  622.                         constraints.eVAlign = (IUIElement::SUIConstraints::EPositionAlign) GetPortInt(pActInfo, eI_VAlign);
  623.                         constraints.bScale = GetPortBool(pActInfo, eI_Scale);
  624.                         constraints.bMax = GetPortBool(pActInfo, eI_Maximize);
  625.  
  626.                         SPerInstanceCall1<const IUIElement::SUIConstraints&> caller;
  627.                         caller.Execute(GetElement(), instanceId, functor(*this, &CFlashUIConstraintsNode::SetConstraints), constraints);
  628.  
  629.                         ActivateOutput(pActInfo, eO_OnSet, true);
  630.                 }
  631.         }
  632. }
  633.  
  634. //////////////////////////////////////////////////////////////////////////
  635. class CFlowRayToFlashSpace : public CFlowBaseNode<eNCT_Instanced>
  636. {
  637. public:
  638.         CFlowRayToFlashSpace(SActivationInfo* pActInfo) {}
  639.  
  640.         virtual ~CFlowRayToFlashSpace() {}
  641.  
  642.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  643.         {
  644.                 return new CFlowRayToFlashSpace(pActInfo);
  645.         }
  646.  
  647.         void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  648.         {
  649.         }
  650.  
  651.         enum EInputPorts
  652.         {
  653.                 EIP_Cast = 0,
  654.                 EIP_RayPos,
  655.                 EIP_RayDir,
  656.                 EIP_CallFunction,
  657.                 EIP_SkipEntity,
  658.         };
  659.  
  660.         enum EOutputPorts
  661.         {
  662.                 EOP_Success = 0,
  663.                 EOP_Failed,
  664.         };
  665.  
  666.         virtual void GetConfiguration(SFlowNodeConfig& config)
  667.         {
  668.                 static const SInputPortConfig inputs[] = {
  669.                         InputPortConfig_Void("Cast",            _HELP("Cast test ray")),
  670.                         InputPortConfig<Vec3>("Pos",            _HELP("Ray pos")),
  671.                         InputPortConfig<Vec3>("Dir",            _HELP("Ray Dir")),
  672.                         InputPortConfig<string>("FunctionName", _HELP("This function will be called in ActionScript (signature: myFunc = function(int, int))")),
  673.                         InputPortConfig<EntityId>("SkipEntity", _HELP("Optional: Entity to skip")),
  674.                         { 0 }
  675.                 };
  676.  
  677.                 static const SOutputPortConfig outputs[] = {
  678.                         OutputPortConfig_Void("Success", _HELP("Triggers if succeeded")),
  679.                         OutputPortConfig_Void("Failed",  _HELP("Triggers if something went wrong(no hit or wrong entity)")),
  680.                         { 0 }
  681.                 };
  682.  
  683.                 config.pInputPorts = inputs;
  684.                 config.pOutputPorts = outputs;
  685.                 config.sDescription = _HELP("Casts a ray, finds the hitposition in flash space and calls a function");
  686.                 config.SetCategory(EFLN_ADVANCED);
  687.         }
  688.  
  689.         bool RayIntersectMesh(IRenderMesh* pMesh, IMaterial* pMaterial, IUIElement* pElement, const Ray& ray, Vec3& hitpos, Vec3& p0, Vec3& p1, Vec3& p2, Vec2& uv0, Vec2& uv1, Vec2& uv2)
  690.         {
  691.                 bool hasHit = false;
  692.                 // get triangle that was hit
  693.                 pMesh->LockForThreadAccess();
  694.                 const int numIndices = pMesh->GetIndicesCount();
  695.                 const int numVertices = pMesh->GetVerticesCount();
  696.                 if (numIndices || numVertices)
  697.                 {
  698.                         // TODO: this could be optimized, e.g cache triangles and uv's and use octree to find triangles
  699.                         strided_pointer<Vec3> pPos;
  700.                         strided_pointer<Vec2> pUV;
  701.                         pPos.data = (Vec3*)pMesh->GetPosPtr(pPos.iStride, FSL_READ);
  702.                         pUV.data = (Vec2*)pMesh->GetUVPtr(pUV.iStride, FSL_READ);
  703.                         const vtx_idx* pIndices = pMesh->GetIndexPtr(FSL_READ);
  704.  
  705.                         const TRenderChunkArray& Chunks = pMesh->GetChunks();
  706.                         const int nChunkCount = Chunks.size();
  707.                         for (int nChunkId = 0; nChunkId < nChunkCount; nChunkId++)
  708.                         {
  709.                                 const CRenderChunk* pChunk = &Chunks[nChunkId];
  710.                                 if ((pChunk->m_nMatFlags & MTL_FLAG_NODRAW))
  711.                                         continue;
  712.  
  713.                                 int lastIndex = pChunk->nFirstIndexId + pChunk->nNumIndices;
  714.                                 for (int i = pChunk->nFirstIndexId; i < lastIndex; i += 3)
  715.                                 {
  716.                                         const Vec3& v0 = pPos[pIndices[i]];
  717.                                         const Vec3& v1 = pPos[pIndices[i + 1]];
  718.                                         const Vec3& v2 = pPos[pIndices[i + 2]];
  719.  
  720.                                         if (Intersect::Ray_Triangle(ray, v0, v2, v1, hitpos))  // only front face
  721.                                         {
  722.                                                 uv0 = pUV[pIndices[i]];
  723.                                                 uv1 = pUV[pIndices[i + 1]];
  724.                                                 uv2 = pUV[pIndices[i + 2]];
  725.                                                 p0 = v0;
  726.                                                 p1 = v1;
  727.                                                 p2 = v2;
  728.                                                 hasHit = true;
  729.                                                 nChunkId = nChunkCount; // break outer loop
  730.                                                 break;
  731.                                         }
  732.                                 }
  733.                         }
  734.                 }
  735.  
  736.                 pMesh->UnlockStream(VSF_GENERAL);
  737.                 pMesh->UnlockIndexStream();
  738.                 pMesh->UnLockForThreadAccess();
  739.  
  740.                 return hasHit;
  741.         }
  742.  
  743.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  744.         {
  745.                 switch (event)
  746.                 {
  747.                 case eFE_Initialize:
  748.                         break;
  749.                 case eFE_Activate:
  750.                         IGameFramework* pGameFramework = gEnv->pGameFramework;
  751.  
  752.                         if (IsPortActive(pActInfo, EIP_Cast))
  753.                         {
  754.                                 // setup ray + optionally skip 1 entity
  755.                                 ray_hit rayHit;
  756.                                 static const float maxRayDist = 100.f;
  757.                                 const unsigned int flags = rwi_stop_at_pierceable | rwi_colltype_any;
  758.                                 IPhysicalEntity* skipList[1];
  759.                                 int skipCount = 0;
  760.                                 IEntity* skipEntity = gEnv->pEntitySystem->GetEntity(GetPortEntityId(pActInfo, EIP_SkipEntity));
  761.                                 if (skipEntity)
  762.                                 {
  763.                                         skipList[0] = skipEntity->GetPhysics();
  764.                                         skipCount = 1;
  765.                                 }
  766.  
  767.                                 Vec3 rayPos = GetPortVec3(pActInfo, EIP_RayPos);
  768.                                 Vec3 rayDir = GetPortVec3(pActInfo, EIP_RayDir);
  769.  
  770.                                 // Check if the ray hits an entity
  771.                                 if (gEnv->pSystem->GetIPhysicalWorld()->RayWorldIntersection(rayPos, rayDir * 100, ent_all, flags, &rayHit, 1, skipList, skipCount))
  772.                                 {
  773.                                         int type = rayHit.pCollider->GetiForeignData();
  774.  
  775.                                         if (type == PHYS_FOREIGN_ID_ENTITY)
  776.                                         {
  777.                                                 IEntity* pEntity = (IEntity*)rayHit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
  778.                                                 IEntityRender* pIEntityRender = pEntity ? pEntity->GetRenderInterface() : 0;
  779.  
  780.                                                 // Get the renderproxy, and use it to check if the material is a DynTex, and get the UIElement if so
  781.                                                
  782.                                                 {
  783.                                                         IRenderNode* pRenderNode = pIEntityRender->GetRenderNode();
  784.                                                         IMaterial* pMaterial = pIEntityRender->GetRenderMaterial();
  785.                                                         SEfResTexture* texture = 0;
  786.                                                         if (pMaterial && pMaterial->GetShaderItem().m_pShaderResources)
  787.                                                                 texture = pMaterial->GetShaderItem().m_pShaderResources->GetTexture(EFTT_DIFFUSE);
  788.                                                         IUIElement* pElement = texture ? gEnv->pFlashUI->GetUIElementByInstanceStr(texture->m_Name) : 0;
  789.  
  790.                                                         if (pElement && pRenderNode)
  791.                                                         {
  792.                                                                 int m_dynTexGeomSlot = 0;
  793.                                                                 IStatObj* pObj = pRenderNode->GetEntityStatObj(m_dynTexGeomSlot);
  794.  
  795.                                                                 // result
  796.                                                                 bool hasHit = false;
  797.                                                                 Vec2 uv0, uv1, uv2;
  798.                                                                 Vec3 p0, p1, p2;
  799.                                                                 Vec3 hitpos;
  800.  
  801.                                                                 // calculate ray dir
  802.                                                                 CCamera cam = gEnv->pRenderer->GetCamera();
  803.                                                                 if (pEntity->GetSlotFlags(m_dynTexGeomSlot) & ENTITY_SLOT_RENDER_NEAREST)
  804.                                                                 {
  805.                                                                         ICVar* r_drawnearfov = gEnv->pConsole->GetCVar("r_DrawNearFoV");
  806.                                                                         assert(r_drawnearfov);
  807.                                                                         cam.SetFrustum(cam.GetViewSurfaceX(), cam.GetViewSurfaceZ(), DEG2RAD(r_drawnearfov->GetFVal()), cam.GetNearPlane(), cam.GetFarPlane(), cam.GetPixelAspectRatio());
  808.                                                                 }
  809.  
  810.                                                                 Vec3 vPos0 = rayPos;
  811.                                                                 Vec3 vPos1 = rayPos + rayDir;
  812.  
  813.                                                                 // translate into object space
  814.                                                                 const Matrix34 m = pEntity->GetWorldTM().GetInverted();
  815.                                                                 vPos0 = m * vPos0;
  816.                                                                 vPos1 = m * vPos1;
  817.  
  818.                                                                 // walk through all sub objects
  819.                                                                 const int objCount = pObj->GetSubObjectCount();
  820.                                                                 for (int obj = 0; obj <= objCount && !hasHit; ++obj)
  821.                                                                 {
  822.                                                                         Vec3 vP0, vP1;
  823.                                                                         IStatObj* pSubObj = NULL;
  824.  
  825.                                                                         if (obj == objCount)
  826.                                                                         {
  827.                                                                                 vP0 = vPos0;
  828.                                                                                 vP1 = vPos1;
  829.                                                                                 pSubObj = pObj;
  830.                                                                         }
  831.                                                                         else
  832.                                                                         {
  833.                                                                                 IStatObj::SSubObject* pSub = pObj->GetSubObject(obj);
  834.                                                                                 const Matrix34 mm = pSub->tm.GetInverted();
  835.                                                                                 vP0 = mm * vPos0;
  836.                                                                                 vP1 = mm * vPos1;
  837.                                                                                 pSubObj = pSub->pStatObj;
  838.                                                                         }
  839.  
  840.                                                                         IRenderMesh* pMesh = pSubObj ? pSubObj->GetRenderMesh() : NULL;
  841.                                                                         if (pMesh)
  842.                                                                         {
  843.                                                                                 const Ray ray(vP0, (vP1 - vP0).GetNormalized() * maxRayDist);
  844.                                                                                 hasHit = RayIntersectMesh(pMesh, pMaterial, pElement, ray, hitpos, p0, p1, p2, uv0, uv1, uv2);
  845.                                                                         }
  846.                                                                 }
  847.  
  848.                                                                 // skip if not hit
  849.                                                                 if (!hasHit)
  850.                                                                 {
  851.                                                                         ActivateOutput(pActInfo, EOP_Failed, 1);
  852.                                                                         return;
  853.                                                                 }
  854.  
  855.                                                                 // calculate vectors from hitpos to vertices p0, p1 and p2:
  856.                                                                 const Vec3 v0 = p0 - hitpos;
  857.                                                                 const Vec3 v1 = p1 - hitpos;
  858.                                                                 const Vec3 v2 = p2 - hitpos;
  859.  
  860.                                                                 // calculate factors
  861.                                                                 const float h = (p0 - p1).Cross(p0 - p2).GetLength();
  862.                                                                 const float f0 = v1.Cross(v2).GetLength() / h;
  863.                                                                 const float f1 = v2.Cross(v0).GetLength() / h;
  864.                                                                 const float f2 = v0.Cross(v1).GetLength() / h;
  865.  
  866.                                                                 // find the uv corresponding to hitpos
  867.                                                                 Vec3 uv = uv0 * f0 + uv1 * f1 + uv2 * f2;
  868.  
  869.                                                                 // translate to flash space
  870.                                                                 int x, y, width, height;
  871.                                                                 float aspect;
  872.                                                                 pElement->GetFlashPlayer()->GetViewport(x, y, width, height, aspect);
  873.                                                                 int iX = int_round(uv.x * (float)width);
  874.                                                                 int iY = int_round(uv.y * (float)height);
  875.  
  876.                                                                 // call the function provided if it is present in the UIElement description
  877.                                                                 string funcName = GetPortString(pActInfo, EIP_CallFunction);
  878.                                                                 const SUIEventDesc* eventDesc = pElement->GetFunctionDesc(funcName);
  879.                                                                 if (eventDesc)
  880.                                                                 {
  881.                                                                         SUIArguments arg;
  882.                                                                         arg.AddArgument(iX);
  883.                                                                         arg.AddArgument(iY);
  884.                                                                         pElement->CallFunction(eventDesc->sName, arg);
  885.                                                                 }
  886.  
  887.                                                                 ActivateOutput(pActInfo, EOP_Success, 1);
  888.                                                         }
  889.                                                 }
  890.                                         }
  891.                                 }
  892.  
  893.                                 ActivateOutput(pActInfo, EOP_Failed, 1);
  894.                         }
  895.  
  896.                         break;
  897.                 }
  898.         }
  899.  
  900.         virtual void GetMemoryUsage(ICrySizer* s) const
  901.         {
  902.                 s->Add(*this);
  903.         }
  904. };
  905.  
  906. //------------------------------------------------------------------------------------------------------
  907. REGISTER_FLOW_NODE("UI:Display:Display", CFlashUIDisplayNode);
  908. REGISTER_FLOW_NODE("UI:Display:Advance", CFlashUIAdvanceNode);
  909. REGISTER_FLOW_NODE("UI:Display:ScreenPos", CFlashUIScreenPosNode);
  910. REGISTER_FLOW_NODE("UI:Display:WorldScreenPos", CFlashUIWorldScreenPosNode);
  911. REGISTER_FLOW_NODE("UI:Display:Config", CFlashUIDisplayConfigNode);
  912. REGISTER_FLOW_NODE("UI:Display:Constraints", CFlashUIConstraintsNode);
  913. REGISTER_FLOW_NODE("UI:Display:Layer", CFlashUILayerNode);
  914. REGISTER_FLOW_NODE("UI:Display:RayToFlashSpace", CFlowRayToFlashSpace);
  915.  
downloadFlashUIDisplayNodes.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