BVB Source Codes

CRYENGINE Show FlowDebugNodes.cpp Source code

Return Download CRYENGINE: download FlowDebugNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4.  
  5. #include <CryGame/IGameFramework.h>
  6. #include <CryFlowGraph/IFlowBaseNode.h>
  7.  
  8. class CFlowNode_DrawSphere : public CFlowBaseNode<eNCT_Singleton>
  9. {
  10. public:
  11.         CFlowNode_DrawSphere(SActivationInfo* pActInfo)
  12.         {
  13.         }
  14.  
  15.         enum EInputPorts
  16.         {
  17.                 eIP_Draw = 0,
  18.                 eIP_Pos,
  19.                 eIP_Radius,
  20.                 eIP_Color,
  21.                 eIP_Time,
  22.         };
  23.  
  24.         virtual void GetConfiguration(SFlowNodeConfig& config)
  25.         {
  26.                 static const SInputPortConfig in_config[] =
  27.                 {
  28.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Sphere")),
  29.                         InputPortConfig<Vec3>("Pos",             _HELP("Position of Sphere")),
  30.                         InputPortConfig<float>("Radius",         _HELP("Radius of Sphere")),
  31.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Sphere"),                                               NULL,_UICONFIG("dt=color")),
  32.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  33.                         { 0 }
  34.                 };
  35.  
  36.                 config.sDescription = _HELP("Draws a sphere for debugging purposes");
  37.                 config.pInputPorts = in_config;
  38.                 config.SetCategory(EFLN_DEBUG);
  39.         }
  40.  
  41.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  42.         {
  43. #if !defined(_RELEASE)
  44.                 if (event == eFE_Activate)
  45.                 {
  46.                         if (IsPortActive(pActInfo, eIP_Draw))
  47.                         {
  48.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  49.                                 if (pPersistentDebug)
  50.                                 {
  51.                                         const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos);
  52.                                         const float radius = GetPortFloat(pActInfo, eIP_Radius);
  53.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  54.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  55.  
  56.                                         pPersistentDebug->Begin("FG_Sphere", false);
  57.                                         pPersistentDebug->AddSphere(pos, radius, color, time);
  58.                                 }
  59.                         }
  60.                 }
  61. #endif
  62.         }
  63.  
  64.         virtual void GetMemoryUsage(ICrySizer* s) const
  65.         {
  66.                 s->Add(this);
  67.         }
  68. };
  69.  
  70. class CFlowNode_DrawLine : public CFlowBaseNode<eNCT_Singleton>
  71. {
  72. public:
  73.         CFlowNode_DrawLine(SActivationInfo* pActInfo)
  74.         {
  75.         }
  76.  
  77.         enum EInputPorts
  78.         {
  79.                 eIP_Draw = 0,
  80.                 eIP_Pos1,
  81.                 eIP_Pos2,
  82.                 eIP_Dir,
  83.                 eIP_Length,
  84.                 eIP_Color,
  85.                 eIP_Time,
  86.         };
  87.  
  88.         virtual void GetConfiguration(SFlowNodeConfig& config)
  89.         {
  90.                 static const SInputPortConfig in_config[] =
  91.                 {
  92.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Line")),
  93.                         InputPortConfig<Vec3>("Pos1",            _HELP("Start position of Line")),
  94.                         InputPortConfig<Vec3>("Pos2",            _HELP("End position of Line")),
  95.                         InputPortConfig<Vec3>("Dir",             _HELP("Direction of Line")),
  96.                         InputPortConfig<float>("Length",         _HELP("Length of Line")),
  97.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Line"),                                                 NULL,_UICONFIG("dt=color")),
  98.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  99.                         { 0 }
  100.                 };
  101.  
  102.                 config.sDescription = _HELP("Draws a line for debugging purposes. Use either Pos1, Dir and Length or Pos1 and Pos2");
  103.                 config.pInputPorts = in_config;
  104.                 config.SetCategory(EFLN_DEBUG);
  105.         }
  106.  
  107.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  108.         {
  109. #if !defined(_RELEASE)
  110.                 switch (event)
  111.                 {
  112.                 case eFE_Activate:
  113.                         {
  114.                                 if (IsPortActive(pActInfo, eIP_Draw))
  115.                                 {
  116.                                         IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  117.                                         if (pPersistentDebug)
  118.                                         {
  119.                                                 const Vec3 pos1 = GetPortVec3(pActInfo, eIP_Pos1);
  120.                                                 const Vec3 pos2 = GetPortVec3(pActInfo, eIP_Pos2);
  121.                                                 const float time = GetPortFloat(pActInfo, eIP_Time);
  122.                                                 const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  123.  
  124.                                                 Vec3 offset(pos2);
  125.  
  126.                                                 if (pos2.IsZero())
  127.                                                 {
  128.                                                         offset = pos1 + (GetPortVec3(pActInfo, eIP_Dir) * GetPortFloat(pActInfo, eIP_Length));
  129.                                                 }
  130.  
  131.                                                 pPersistentDebug->Begin("FG_Line", false);
  132.                                                 pPersistentDebug->AddLine(pos1, offset, color, time);
  133.                                         }
  134.                                 }
  135.                                 break;
  136.                         }
  137.                 }
  138. #endif
  139.         }
  140.  
  141.         virtual void GetMemoryUsage(ICrySizer* s) const
  142.         {
  143.                 s->Add(this);
  144.         }
  145. };
  146.  
  147. class CFlowNode_DrawCylinder : public CFlowBaseNode<eNCT_Singleton>
  148. {
  149. public:
  150.         CFlowNode_DrawCylinder(SActivationInfo* pActInfo)
  151.         {
  152.         }
  153.  
  154.         enum EInputPorts
  155.         {
  156.                 eIP_Draw = 0,
  157.                 eIP_Pos,
  158.                 eIP_Dir,
  159.                 eIP_Radius,
  160.                 eIP_Height,
  161.                 eIP_Color,
  162.                 eIP_Time,
  163.         };
  164.  
  165.         virtual void GetConfiguration(SFlowNodeConfig& config)
  166.         {
  167.                 static const SInputPortConfig in_config[] =
  168.                 {
  169.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Cylinder")),
  170.                         InputPortConfig<Vec3>("Pos",             _HELP("Centre position of Cylinder")),
  171.                         InputPortConfig<Vec3>("Dir",             _HELP("Direction of Cylinder")),
  172.                         InputPortConfig<float>("Radius",         _HELP("Radius of Cylinder")),
  173.                         InputPortConfig<float>("Height",         _HELP("Height of Cylinder")),
  174.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Cylinder"),                                             NULL,_UICONFIG("dt=color")),
  175.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  176.                         { 0 }
  177.                 };
  178.  
  179.                 config.sDescription = _HELP("Draws a cylinder for debugging purposes");
  180.                 config.pInputPorts = in_config;
  181.                 config.SetCategory(EFLN_DEBUG);
  182.         }
  183.  
  184.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  185.         {
  186. #if !defined(_RELEASE)
  187.                 if (event == eFE_Activate)
  188.                 {
  189.                         if (IsPortActive(pActInfo, eIP_Draw))
  190.                         {
  191.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  192.                                 if (pPersistentDebug)
  193.                                 {
  194.                                         const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos);
  195.                                         const Vec3 dir = GetPortVec3(pActInfo, eIP_Dir);
  196.                                         const float radius = GetPortFloat(pActInfo, eIP_Radius);
  197.                                         const float height = GetPortFloat(pActInfo, eIP_Height);
  198.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  199.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  200.  
  201.                                         pPersistentDebug->Begin("FG_Cylinder", false);
  202.                                         pPersistentDebug->AddCylinder(pos, dir, radius, height, color, time);
  203.                                 }
  204.                         }
  205.                 }
  206. #endif
  207.         }
  208.  
  209.         virtual void GetMemoryUsage(ICrySizer* s) const
  210.         {
  211.                 s->Add(this);
  212.         }
  213. };
  214.  
  215. class CFlowNode_DrawDirection : public CFlowBaseNode<eNCT_Singleton>
  216. {
  217. public:
  218.         CFlowNode_DrawDirection(SActivationInfo* pActInfo)
  219.         {
  220.         }
  221.  
  222.         enum EInputPorts
  223.         {
  224.                 eIP_Draw = 0,
  225.                 eIP_Pos,
  226.                 eIP_Dir,
  227.                 eIP_Radius,
  228.                 eIP_Color,
  229.                 eIP_Time,
  230.         };
  231.  
  232.         virtual void GetConfiguration(SFlowNodeConfig& config)
  233.         {
  234.                 static const SInputPortConfig in_config[] =
  235.                 {
  236.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Direction (arrow)")),
  237.                         InputPortConfig<Vec3>("Pos",             _HELP("Centre position of Direction (arrow)")),
  238.                         InputPortConfig<Vec3>("Dir",             _HELP("Direction of Direction (arrow)")),
  239.                         InputPortConfig<float>("Radius",         _HELP("Radius of Direction (arrow)")),
  240.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Direction (arrow)"),                                    NULL,_UICONFIG("dt=color")),
  241.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  242.                         { 0 }
  243.                 };
  244.  
  245.                 config.sDescription = _HELP("Draws an arrow for debugging purposes");
  246.                 config.pInputPorts = in_config;
  247.                 config.SetCategory(EFLN_DEBUG);
  248.         }
  249.  
  250.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  251.         {
  252. #if !defined(_RELEASE)
  253.                 if (event == eFE_Activate)
  254.                 {
  255.                         if (IsPortActive(pActInfo, eIP_Draw))
  256.                         {
  257.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  258.                                 if (pPersistentDebug)
  259.                                 {
  260.                                         const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos);
  261.                                         const Vec3 dir = GetPortVec3(pActInfo, eIP_Dir);
  262.                                         const float radius = GetPortFloat(pActInfo, eIP_Radius);
  263.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  264.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  265.  
  266.                                         pPersistentDebug->Begin("FG_Direction", false);
  267.                                         pPersistentDebug->AddDirection(pos, radius, dir, color, time);
  268.                                 }
  269.                         }
  270.                 }
  271. #endif
  272.         }
  273.  
  274.         virtual void GetMemoryUsage(ICrySizer* s) const
  275.         {
  276.                 s->Add(this);
  277.         }
  278. };
  279.  
  280. class CFlowNode_DrawCone : public CFlowBaseNode<eNCT_Singleton>
  281. {
  282. public:
  283.         CFlowNode_DrawCone(SActivationInfo* pActInfo)
  284.         {
  285.         }
  286.  
  287.         enum EInputPorts
  288.         {
  289.                 eIP_Draw = 0,
  290.                 eIP_Pos,
  291.                 eIP_Dir,
  292.                 eIP_Radius,
  293.                 eIP_Height,
  294.                 eIP_Color,
  295.                 eIP_Time,
  296.         };
  297.  
  298.         virtual void GetConfiguration(SFlowNodeConfig& config)
  299.         {
  300.                 static const SInputPortConfig in_config[] =
  301.                 {
  302.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Cone")),
  303.                         InputPortConfig<Vec3>("Pos",             _HELP("Centre position of Cone")),
  304.                         InputPortConfig<Vec3>("Dir",             _HELP("Direction of Cone")),
  305.                         InputPortConfig<float>("Radius",         _HELP("Radius of Cone base")),
  306.                         InputPortConfig<float>("Height",         _HELP("Height of Cone")),
  307.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Cone"),                                                 NULL,_UICONFIG("dt=color")),
  308.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  309.                         { 0 }
  310.                 };
  311.  
  312.                 config.sDescription = _HELP("Draws a cone for debugging purposes");
  313.                 config.pInputPorts = in_config;
  314.                 config.SetCategory(EFLN_DEBUG);
  315.         }
  316.  
  317.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  318.         {
  319. #if !defined(_RELEASE)
  320.                 if (event == eFE_Activate)
  321.                 {
  322.                         if (IsPortActive(pActInfo, eIP_Draw))
  323.                         {
  324.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  325.                                 if (pPersistentDebug)
  326.                                 {
  327.                                         const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos);
  328.                                         const Vec3 dir = GetPortVec3(pActInfo, eIP_Dir);
  329.                                         const float radius = GetPortFloat(pActInfo, eIP_Radius);
  330.                                         const float height = GetPortFloat(pActInfo, eIP_Height);
  331.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  332.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  333.  
  334.                                         pPersistentDebug->Begin("FG_Cone", false);
  335.                                         pPersistentDebug->AddCone(pos, dir, radius, height, color, time);
  336.                                 }
  337.                         }
  338.                 }
  339. #endif
  340.         }
  341.  
  342.         virtual void GetMemoryUsage(ICrySizer* s) const
  343.         {
  344.                 s->Add(this);
  345.         }
  346. };
  347.  
  348. class CFlowNode_DrawAABB : public CFlowBaseNode<eNCT_Singleton>
  349. {
  350. public:
  351.         CFlowNode_DrawAABB(SActivationInfo* pActInfo)
  352.         {
  353.         }
  354.  
  355.         enum EInputPorts
  356.         {
  357.                 eIP_Draw = 0,
  358.                 eIP_MinPos,
  359.                 eIP_MaxPos,
  360.                 eIP_Color,
  361.                 eIP_Time,
  362.         };
  363.  
  364.         virtual void GetConfiguration(SFlowNodeConfig& config)
  365.         {
  366.                 static const SInputPortConfig in_config[] =
  367.                 {
  368.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the AABB")),
  369.                         InputPortConfig<Vec3>("MinPos",          _HELP("Minimum position of AABB")),
  370.                         InputPortConfig<Vec3>("MaxPos",          _HELP("Maximum position of AABB")),
  371.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the AABB"),                                                 NULL,_UICONFIG("dt=color")),
  372.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  373.                         { 0 }
  374.                 };
  375.  
  376.                 config.sDescription = _HELP("Draws an AABB for debugging purposes");
  377.                 config.pInputPorts = in_config;
  378.                 config.SetCategory(EFLN_DEBUG);
  379.         }
  380.  
  381.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  382.         {
  383. #if !defined(_RELEASE)
  384.                 if (event == eFE_Activate)
  385.                 {
  386.                         if (IsPortActive(pActInfo, eIP_Draw))
  387.                         {
  388.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  389.                                 if (pPersistentDebug)
  390.                                 {
  391.                                         const Vec3 minPos = GetPortVec3(pActInfo, eIP_MinPos);
  392.                                         const Vec3 maxPos = GetPortVec3(pActInfo, eIP_MaxPos);
  393.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  394.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  395.  
  396.                                         pPersistentDebug->Begin("FG_AABB", false);
  397.                                         pPersistentDebug->AddAABB(minPos, maxPos, color, time);
  398.                                 }
  399.                         }
  400.                 }
  401. #endif
  402.         }
  403.  
  404.         virtual void GetMemoryUsage(ICrySizer* s) const
  405.         {
  406.                 s->Add(this);
  407.         }
  408. };
  409.  
  410. class CFlowNode_DrawPlanarDisc : public CFlowBaseNode<eNCT_Singleton>
  411. {
  412. public:
  413.         CFlowNode_DrawPlanarDisc(SActivationInfo* pActInfo)
  414.         {
  415.         }
  416.  
  417.         enum EInputPorts
  418.         {
  419.                 eIP_Draw = 0,
  420.                 eIP_Pos,
  421.                 eIP_InnerRadius,
  422.                 eIP_OuterRadius,
  423.                 eIP_Color,
  424.                 eIP_Time,
  425.         };
  426.  
  427.         virtual void GetConfiguration(SFlowNodeConfig& config)
  428.         {
  429.                 static const SInputPortConfig in_config[] =
  430.                 {
  431.                         InputPortConfig<SFlowSystemVoid>("Draw", _HELP("Trigger to draw the Planar Disc")),
  432.                         InputPortConfig<Vec3>("Pos",             _HELP("Centre position of Planar Disc")),
  433.                         InputPortConfig<float>("InnerRadius",    _HELP("Inner radius of Planar Disc")),
  434.                         InputPortConfig<float>("OuterRadius",    _HELP("Outer radius of Planar Disc")),
  435.                         InputPortConfig<Vec3>("Color",           _HELP("Color of the Planar Disc"),                                          NULL,_UICONFIG("dt=color")),
  436.                         InputPortConfig<float>("Time",           _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  437.                         { 0 }
  438.                 };
  439.  
  440.                 config.sDescription = _HELP("Draws a Planar Disc for debugging purposes");
  441.                 config.pInputPorts = in_config;
  442.                 config.SetCategory(EFLN_DEBUG);
  443.         }
  444.  
  445.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  446.         {
  447. #if !defined(_RELEASE)
  448.                 if (event == eFE_Activate)
  449.                 {
  450.                         if (IsPortActive(pActInfo, eIP_Draw))
  451.                         {
  452.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  453.                                 if (pPersistentDebug)
  454.                                 {
  455.                                         const Vec3 pos = GetPortVec3(pActInfo, eIP_Pos);
  456.                                         const float innerRadius = GetPortFloat(pActInfo, eIP_InnerRadius);
  457.                                         const float outerRadius = GetPortFloat(pActInfo, eIP_OuterRadius);
  458.                                         const float time = GetPortFloat(pActInfo, eIP_Time);
  459.                                         const ColorF color = GetPortVec3(pActInfo, eIP_Color);
  460.  
  461.                                         pPersistentDebug->Begin("FG_PlanarDisc", false);
  462.                                         pPersistentDebug->AddPlanarDisc(pos, innerRadius, outerRadius, color, time);
  463.                                 }
  464.                         }
  465.                 }
  466. #endif
  467.         }
  468.  
  469.         virtual void GetMemoryUsage(ICrySizer* s) const
  470.         {
  471.                 s->Add(this);
  472.         }
  473. };
  474.  
  475. class CFlowNode_DrawEntityTag : public CFlowBaseNode<eNCT_Instanced>
  476. {
  477. public:
  478.         enum EInputPorts
  479.         {
  480.                 eIP_Draw = 0,
  481.                 eIP_Message,
  482.                 eIP_FontSize,
  483.                 eIP_Color,
  484.                 eIP_Time,
  485.         };
  486.  
  487.         enum EOutputPorts
  488.         {
  489.                 eOP_Done
  490.         };
  491.  
  492.         CFlowNode_DrawEntityTag(SActivationInfo* pActInfo)
  493.                 : m_waitTime(0.0f)
  494.         {
  495.         }
  496.  
  497.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  498.         {
  499.                 return new CFlowNode_DrawEntityTag(pActInfo);
  500.         }
  501.  
  502.         void GetConfiguration(SFlowNodeConfig& config)
  503.         {
  504.                 static const SEntityTagParams defaultTag;
  505.  
  506.                 static const SInputPortConfig in_ports[] =
  507.                 {
  508.                         InputPortConfig_Void("Draw",       _HELP("Draw Entity Tag")),
  509.                         InputPortConfig<string>("Message", _HELP("The message to display")),
  510.                         InputPortConfig<float>("FontSize", defaultTag.size,                 _HELP("Input font size")),
  511.                         InputPortConfig<Vec3>("Color",     Vec3(defaultTag.color.r,         defaultTag.color.g,                                                          defaultTag.color.b),_HELP("Text color"), NULL, _UICONFIG("dt=color")),
  512.                         InputPortConfig<float>("Time",     defaultTag.fadeTime,             _HELP("Duration of the display in seconds. Set to -1 for unlimited time.")),
  513.                         { 0 }
  514.                 };
  515.  
  516.                 static const SOutputPortConfig out_ports[] =
  517.                 {
  518.                         OutputPortConfig_AnyType("Done", _HELP("Tag has finished being displayed")),
  519.                         { 0 }
  520.                 };
  521.  
  522.                 config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_SUPPORTED;
  523.                 config.pInputPorts = in_ports;
  524.                 config.pOutputPorts = out_ports;
  525.                 config.sDescription = _HELP("Draws a text message above an entity");
  526.                 config.SetCategory(EFLN_DEBUG);
  527.         }
  528.  
  529.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  530.         {
  531. #if !defined(_RELEASE)
  532.                 if (event == eFE_Initialize && IsPortActive(pActInfo, eIP_Draw))
  533.                 {
  534.                         m_waitTime = 0.0f;
  535.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  536.                 }
  537.                 else if (event == eFE_Activate && IsPortActive(pActInfo, eIP_Draw))
  538.                 {
  539.                         IEntity* pEntity = pActInfo->pEntity;
  540.                         if (pEntity)
  541.                         {
  542.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  543.                                 if (pPersistentDebug)
  544.                                 {
  545.                                         SEntityTagParams params;
  546.                                         params.entity = pEntity->GetId();
  547.                                         params.text = GetPortString(pActInfo, eIP_Message);
  548.                                         params.size = GetPortFloat(pActInfo, eIP_FontSize);
  549.                                         params.color = ColorF(GetPortVec3(pActInfo, eIP_Color), 1.0f);
  550.                                         // the time input from this node goes to fade time but if it is unlimited time we need to set that in the visibleTime, not fade
  551.                                         if (GetPortFloat(pActInfo, eIP_Time) < 0.0f)
  552.                                         {
  553.                                                 params.fadeTime = 0.0f;
  554.                                                 params.visibleTime = -1.0f;
  555.                                                 m_waitTime = -1.0f;
  556.                                         }
  557.                                         else
  558.                                         {
  559.                                                 params.fadeTime = GetPortFloat(pActInfo, eIP_Time);
  560.                                                 params.visibleTime = 0.0f;
  561.                                         }
  562.                                         params.tagContext = "FG_DrawEntityTag";
  563.  
  564.                                         pPersistentDebug->AddEntityTag(params);
  565.  
  566.                                         if (m_waitTime != -1.0f)
  567.                                         {
  568.                                                 m_waitTime = gEnv->pTimer->GetFrameStartTime() + (params.fadeTime + params.visibleTime);
  569.                                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  570.                                         }
  571.                                 }
  572.                         }
  573.                 }
  574.                 else if (event == eFE_Update)
  575.                 {
  576.                         // unlimited time does not update the node, no need to test for that
  577.                         if (m_waitTime < gEnv->pTimer->GetFrameStartTime())
  578.                         {
  579.                                 m_waitTime.SetSeconds(0.0f);
  580.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  581.                                 ActivateOutput(pActInfo, eOP_Done, GetPortAny(pActInfo, eIP_Draw));
  582.                         }
  583.                 }
  584. #endif
  585.         }
  586.  
  587.         virtual void GetMemoryUsage(ICrySizer* s) const
  588.         {
  589.                 s->Add(*this);
  590.         }
  591.  
  592. private:
  593.         CTimeValue m_waitTime;
  594. };
  595.  
  596. class CFlowNode_DrawEntityTagAdvanced : public CFlowBaseNode<eNCT_Instanced>
  597. {
  598. public:
  599.         enum EInputPorts
  600.         {
  601.                 eIP_Draw = 0,
  602.                 eIP_Message,
  603.                 eIP_FadeTime,
  604.                 eIP_FontSize,
  605.                 eIP_ViewDistance,
  606.                 eIP_StaticID,
  607.                 eIP_Column,
  608.                 eIP_Color,
  609.                 eIP_Time
  610.         };
  611.  
  612.         enum EOutputPorts
  613.         {
  614.                 eOP_Done
  615.         };
  616.  
  617.         CFlowNode_DrawEntityTagAdvanced(SActivationInfo* pActInfo)
  618.                 : m_waitTime(0.0f)
  619.         {
  620.         }
  621.  
  622.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  623.         {
  624.                 return new CFlowNode_DrawEntityTagAdvanced(pActInfo);
  625.         }
  626.  
  627.         void GetConfiguration(SFlowNodeConfig& config)
  628.         {
  629.                 static const SEntityTagParams defaultTag;
  630.  
  631.                 static const SInputPortConfig in_ports[] =
  632.                 {
  633.                         InputPortConfig_Void("Draw",           _HELP("Draw advanced Entity Tag")),
  634.                         InputPortConfig<string>("Message",     _HELP("The message to display")),
  635.                         InputPortConfig<float>("FadeTime",     defaultTag.fadeTime,                            _HELP("Seconds for fade out")),
  636.                         InputPortConfig<float>("FontSize",     defaultTag.size,                                _HELP("Input font size")),
  637.                         InputPortConfig<float>("ViewDistance", defaultTag.viewDistance,                        _HELP("Distance from camera entity must be within")),
  638.                         InputPortConfig<string>("StaticID",    _HELP("Identifier for displaying static tags")),
  639.                         InputPortConfig<int>("ColumnNum",      defaultTag.column,                              _HELP("Which column to display on (usually 1)")),
  640.                         InputPortConfig<Vec3>("Color",         Vec3(defaultTag.color.r,                        defaultTag.color.g,                                                                        defaultTag.color.b),_HELP("Text color"), NULL, _UICONFIG("dt=color")),
  641.                         InputPortConfig<float>("Time",         defaultTag.visibleTime,                         _HELP("Duration of the display in full alpha in seconds. Set to -1 for unlimited time.")),
  642.                         { 0 }
  643.                 };
  644.  
  645.                 static const SOutputPortConfig out_ports[] =
  646.                 {
  647.                         OutputPortConfig_AnyType("Done", _HELP("Tag has finished being displayed")),
  648.                         { 0 }
  649.                 };
  650.  
  651.                 config.nFlags |= EFLN_TARGET_ENTITY | EFLN_AISEQUENCE_SUPPORTED;
  652.                 config.pInputPorts = in_ports;
  653.                 config.pOutputPorts = out_ports;
  654.                 config.sDescription = _HELP("Draws a text message above an entity");
  655.                 config.SetCategory(EFLN_DEBUG);
  656.         }
  657.  
  658.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  659.         {
  660. #if !defined(_RELEASE)
  661.                 if (event == eFE_Initialize && IsPortActive(pActInfo, eIP_Draw))
  662.                 {
  663.                         m_waitTime = 0.0f;
  664.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  665.                 }
  666.                 else if (event == eFE_Activate && IsPortActive(pActInfo, eIP_Draw))
  667.                 {
  668.                         IEntity* pEntity = pActInfo->pEntity;
  669.                         if (pEntity)
  670.                         {
  671.                                 IPersistantDebug* pPersistentDebug = CCryAction::GetCryAction()->GetIPersistantDebug();
  672.                                 if (pPersistentDebug)
  673.                                 {
  674.                                         SEntityTagParams params;
  675.                                         params.entity = pEntity->GetId();
  676.                                         params.text = GetPortString(pActInfo, eIP_Message);
  677.                                         params.size = GetPortFloat(pActInfo, eIP_FontSize);
  678.                                         params.color = ColorF(GetPortVec3(pActInfo, eIP_Color), 1.0f);
  679.                                         params.visibleTime = GetPortFloat(pActInfo, eIP_Time);
  680.                                         params.fadeTime = GetPortFloat(pActInfo, eIP_FadeTime);
  681.                                         params.viewDistance = GetPortFloat(pActInfo, eIP_ViewDistance);
  682.                                         params.staticId = GetPortString(pActInfo, eIP_StaticID);
  683.                                         params.column = GetPortInt(pActInfo, eIP_Column);
  684.                                         params.tagContext = "FG_DrawEntityTagAdvanced";
  685.  
  686.                                         pPersistentDebug->AddEntityTag(params);
  687.  
  688.                                         m_waitTime = gEnv->pTimer->GetFrameStartTime() + (params.fadeTime + params.visibleTime);
  689.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  690.                                 }
  691.                         }
  692.                 }
  693.                 else if (event == eFE_Update)
  694.                 {
  695.                         if (m_waitTime < gEnv->pTimer->GetFrameStartTime())
  696.                         {
  697.                                 m_waitTime.SetSeconds(0.0f);
  698.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  699.                                 ActivateOutput(pActInfo, eOP_Done, GetPortAny(pActInfo, eIP_Draw));
  700.                         }
  701.                 }
  702. #endif
  703.         }
  704.  
  705.         virtual void GetMemoryUsage(ICrySizer* s) const
  706.         {
  707.                 s->Add(*this);
  708.         }
  709.  
  710. private:
  711.         CTimeValue m_waitTime;
  712. };
  713.  
  714. REGISTER_FLOW_NODE("Debug:Draw:Direction", CFlowNode_DrawDirection);
  715. REGISTER_FLOW_NODE("Debug:Draw:Cone", CFlowNode_DrawCone);
  716. REGISTER_FLOW_NODE("Debug:Draw:Cylinder", CFlowNode_DrawCylinder);
  717. REGISTER_FLOW_NODE("Debug:Draw:Line", CFlowNode_DrawLine);
  718. REGISTER_FLOW_NODE("Debug:Draw:Sphere", CFlowNode_DrawSphere);
  719. REGISTER_FLOW_NODE("Debug:Draw:AABB", CFlowNode_DrawAABB);
  720. REGISTER_FLOW_NODE("Debug:Draw:PlanarDisc", CFlowNode_DrawPlanarDisc);
  721. REGISTER_FLOW_NODE("Debug:Draw:EntityTag", CFlowNode_DrawEntityTag);
  722. REGISTER_FLOW_NODE("Debug:Draw:EntityTagAdvanced", CFlowNode_DrawEntityTagAdvanced);
  723.  
downloadFlowDebugNodes.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