BVB Source Codes

CRYENGINE Show FlowMathNodes.cpp Source code

Return Download CRYENGINE: download FlowMathNodes.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:   FlowMathNodes.h
  5. //  Version:     v1.00
  6. //  Created:     7/6/2005 by Timur.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15.  
  16. #include <CryFlowGraph/IFlowBaseNode.h>
  17.  
  18. //////////////////////////////////////////////////////////////////////////
  19. // Math nodes.
  20. //////////////////////////////////////////////////////////////////////////
  21.  
  22. //////////////////////////////////////////////////////////////////////////
  23. class CFlowNode_Calculate : public CFlowBaseNode<eNCT_Singleton>
  24. {
  25.         enum
  26.         {
  27.                 INP_DoCalc,
  28.                 INP_Operation,
  29.                 INP_A,
  30.                 INP_B
  31.         };
  32.         enum EOperation
  33.         {
  34.                 EOP_ADD = 0,
  35.                 EOP_SUB,
  36.                 EOP_MUL,
  37.                 EOP_DIV
  38.         };
  39.  
  40. public:
  41.         CFlowNode_Calculate(SActivationInfo* pActInfo) {};
  42.  
  43.         virtual void GetConfiguration(SFlowNodeConfig& config)
  44.         {
  45.                 static const SInputPortConfig in_config[] = {
  46.                         InputPortConfig_Void("DoCalc", _HELP("Do the calc and send the result to the output when receiving event on this port")),
  47.                         InputPortConfig<int>("Op",     EOP_ADD,                                                                                  _HELP("Operation"),_HELP("Operation"), _UICONFIG("enum_int:Add=0,Sub=1,Mul=2,Div=3")),
  48.                         InputPortConfig<float>("A",    _HELP(" ")),
  49.                         InputPortConfig<float>("B",    _HELP(" ")),
  50.                         { 0 }
  51.                 };
  52.                 static const SOutputPortConfig out_config[] = {
  53.                         OutputPortConfig<float>("out"),
  54.                         { 0 }
  55.                 };
  56.                 config.sDescription = _HELP("[out] = result of the specified operation with [A] and [B]");
  57.                 config.pInputPorts = in_config;
  58.                 config.pOutputPorts = out_config;
  59.                 config.SetCategory(EFLN_APPROVED);
  60.         }
  61.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  62.         {
  63.                 switch (event)
  64.                 {
  65.                 case eFE_Activate:
  66.                         {
  67.                                 if (IsPortActive(pActInfo, INP_DoCalc))
  68.                                 {
  69.                                         float a = GetPortFloat(pActInfo, INP_A);
  70.                                         float b = GetPortFloat(pActInfo, INP_B);
  71.                                         int op = GetPortInt(pActInfo, INP_Operation);
  72.                                         float out = 0;
  73.                                         switch (op)
  74.                                         {
  75.                                         case EOP_ADD:
  76.                                                 out = a + b;
  77.                                                 break;
  78.  
  79.                                         case EOP_SUB:
  80.                                                 out = a - b;
  81.                                                 break;
  82.  
  83.                                         case EOP_MUL:
  84.                                                 out = a * b;
  85.                                                 break;
  86.  
  87.                                         case EOP_DIV:
  88.                                                 if (!iszero(b))
  89.                                                         out = a / b;
  90.                                                 break;
  91.                                         }
  92.  
  93.                                         ActivateOutput(pActInfo, 0, out);
  94.                                 }
  95.                                 break;
  96.                         }
  97.                 }
  98.         };
  99.  
  100.         virtual void GetMemoryUsage(ICrySizer* s) const
  101.         {
  102.                 s->Add(*this);
  103.         }
  104. };
  105.  
  106. //////////////////////////////////////////////////////////////////////////
  107. class CFlowNode_Round : public CFlowBaseNode<eNCT_Singleton>
  108. {
  109. public:
  110.         CFlowNode_Round(SActivationInfo* pActInfo) {}
  111.  
  112.         virtual void GetConfiguration(SFlowNodeConfig& config)
  113.         {
  114.                 static const SInputPortConfig in_config[] = {
  115.                         InputPortConfig<float>("In"),
  116.                         { 0 }
  117.                 };
  118.                 static const SOutputPortConfig out_config[] = {
  119.                         OutputPortConfig<int>("outRounded"),
  120.                         { 0 }
  121.                 };
  122.                 config.sDescription = _HELP("Rounds an input float value to an integer value");
  123.                 config.pInputPorts = in_config;
  124.                 config.pOutputPorts = out_config;
  125.                 config.SetCategory(EFLN_APPROVED);
  126.         }
  127.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  128.         {
  129.                 switch (event)
  130.                 {
  131.                 case eFE_Activate:
  132.                 case eFE_Initialize:
  133.                         float inpVal = GetPortFloat(pActInfo, 0);
  134.                         int out = int_round(inpVal);
  135.                         ActivateOutput(pActInfo, 0, out);
  136.                         break;
  137.                 }
  138.         };
  139.  
  140.         virtual void GetMemoryUsage(ICrySizer* s) const
  141.         {
  142.                 s->Add(*this);
  143.         }
  144. };
  145.  
  146. //////////////////////////////////////////////////////////////////////////
  147. class CFlowNode_FloatToString : public CFlowBaseNode<eNCT_Singleton>
  148. {
  149.         enum INP
  150.         {
  151.                 IN_NUMBER = 0,
  152.                 IN_AMOUNT_OF_DECIMALS,
  153.         };
  154.  
  155. public:
  156.         CFlowNode_FloatToString(SActivationInfo* pActInfo) {}
  157.  
  158.         virtual void GetConfiguration(SFlowNodeConfig& config)
  159.         {
  160.                 static const SInputPortConfig in_config[] = {
  161.                         InputPortConfig<float>("Number"),
  162.                         InputPortConfig<int>("AmountOfDecimals"),
  163.                         { 0 }
  164.                 };
  165.                 static const SOutputPortConfig out_config[] = {
  166.                         OutputPortConfig<string>("out"),
  167.                         { 0 }
  168.                 };
  169.                 config.sDescription = _HELP("Outputs a float in string format, with limited amount of decimals. Used for debug visualization");
  170.                 config.pInputPorts = in_config;
  171.                 config.pOutputPorts = out_config;
  172.                 config.SetCategory(EFLN_DEBUG);
  173.         }
  174.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  175.         {
  176.                 switch (event)
  177.                 {
  178.                 case eFE_Activate:
  179.                 case eFE_Initialize:
  180.                         float inpVal = GetPortFloat(pActInfo, IN_NUMBER);
  181.                         int decimals = GetPortInt(pActInfo, IN_AMOUNT_OF_DECIMALS);
  182.                         stack_string formatStr;
  183.                         formatStr.Format("%%.%df", decimals);
  184.                         string tempstr;
  185.                         tempstr.Format(formatStr.c_str(), inpVal);
  186.                         ActivateOutput(pActInfo, 0, tempstr);
  187.                         break;
  188.                 }
  189.         };
  190.  
  191.         virtual void GetMemoryUsage(ICrySizer* s) const
  192.         {
  193.                 s->Add(*this);
  194.         }
  195. };
  196.  
  197. //////////////////////////////////////////////////////////////////////////
  198. class CFlowNode_Add : public CFlowBaseNode<eNCT_Singleton>
  199. {
  200. public:
  201.         CFlowNode_Add(SActivationInfo* pActInfo) {}
  202.  
  203.         virtual void GetConfiguration(SFlowNodeConfig& config)
  204.         {
  205.                 static const SInputPortConfig in_config[] = {
  206.                         InputPortConfig<float>("A"),
  207.                         InputPortConfig<float>("B"),
  208.                         { 0 }
  209.                 };
  210.                 static const SOutputPortConfig out_config[] = {
  211.                         OutputPortConfig<float>("out"),
  212.                         { 0 }
  213.                 };
  214.                 config.sDescription = _HELP("[out] = [A] + [B]");
  215.                 config.pInputPorts = in_config;
  216.                 config.pOutputPorts = out_config;
  217.                 config.SetCategory(EFLN_APPROVED);
  218.         }
  219.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  220.         {
  221.                 switch (event)
  222.                 {
  223.                 case eFE_Activate:
  224.                 case eFE_Initialize:
  225.                         float a = GetPortFloat(pActInfo, 0);
  226.                         float b = GetPortFloat(pActInfo, 1);
  227.                         float out = a + b;
  228.                         ActivateOutput(pActInfo, 0, out);
  229.                         break;
  230.                 }
  231.         };
  232.  
  233.         virtual void GetMemoryUsage(ICrySizer* s) const
  234.         {
  235.                 s->Add(*this);
  236.         }
  237. };
  238. //////////////////////////////////////////////////////////////////////////
  239. class CFlowNode_Sub : public CFlowBaseNode<eNCT_Singleton>
  240. {
  241. public:
  242.         CFlowNode_Sub(SActivationInfo* pActInfo) {}
  243.  
  244.         virtual void GetConfiguration(SFlowNodeConfig& config)
  245.         {
  246.                 static const SInputPortConfig in_config[] = {
  247.                         InputPortConfig<float>("A"),
  248.                         InputPortConfig<float>("B"),
  249.                         { 0 }
  250.                 };
  251.                 static const SOutputPortConfig out_config[] = {
  252.                         OutputPortConfig<float>("out"),
  253.                         { 0 }
  254.                 };
  255.                 config.sDescription = _HELP("[out] = [A] - [B]");
  256.                 config.pInputPorts = in_config;
  257.                 config.pOutputPorts = out_config;
  258.                 config.SetCategory(EFLN_APPROVED);
  259.         }
  260.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  261.         {
  262.                 switch (event)
  263.                 {
  264.                 case eFE_Activate:
  265.                 case eFE_Initialize:
  266.                         float a = GetPortFloat(pActInfo, 0);
  267.                         float b = GetPortFloat(pActInfo, 1);
  268.                         float out = a - b;
  269.                         ActivateOutput(pActInfo, 0, out);
  270.                         break;
  271.                 }
  272.         };
  273.  
  274.         virtual void GetMemoryUsage(ICrySizer* s) const
  275.         {
  276.                 s->Add(*this);
  277.         }
  278. };
  279. //////////////////////////////////////////////////////////////////////////
  280. class CFlowNode_Mul : public CFlowBaseNode<eNCT_Singleton>
  281. {
  282. public:
  283.         CFlowNode_Mul(SActivationInfo* pActInfo) {}
  284.  
  285.         virtual void GetConfiguration(SFlowNodeConfig& config)
  286.         {
  287.                 static const SInputPortConfig in_config[] = {
  288.                         InputPortConfig<float>("A"),
  289.                         InputPortConfig<float>("B"),
  290.                         { 0 }
  291.                 };
  292.                 static const SOutputPortConfig out_config[] = {
  293.                         OutputPortConfig<float>("out"),
  294.                         { 0 }
  295.                 };
  296.                 config.sDescription = _HELP("[out] = [A] * [B]");
  297.                 config.pInputPorts = in_config;
  298.                 config.pOutputPorts = out_config;
  299.                 config.SetCategory(EFLN_APPROVED);
  300.         }
  301.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  302.         {
  303.                 switch (event)
  304.                 {
  305.                 case eFE_Activate:
  306.                 case eFE_Initialize:
  307.                         float a = GetPortFloat(pActInfo, 0);
  308.                         float b = GetPortFloat(pActInfo, 1);
  309.                         float out = a * b;
  310.                         ActivateOutput(pActInfo, 0, out);
  311.                         break;
  312.                 }
  313.         };
  314.  
  315.         virtual void GetMemoryUsage(ICrySizer* s) const
  316.         {
  317.                 s->Add(*this);
  318.         }
  319. };
  320.  
  321. //////////////////////////////////////////////////////////////////////////
  322. class CFlowNode_CalculateVec3 : public CFlowBaseNode<eNCT_Singleton>
  323. {
  324.         enum
  325.         {
  326.                 INP_DoCalc,
  327.                 INP_Operation,
  328.                 INP_A,
  329.                 INP_B
  330.         };
  331.         enum EOperation
  332.         {
  333.                 EOP_ADD = 0,
  334.                 EOP_SUB,
  335.                 EOP_MUL,
  336.                 EOP_CROSS,
  337.                 EOP_DOT
  338.         };
  339.  
  340. public:
  341.         CFlowNode_CalculateVec3(SActivationInfo* pActInfo) {}
  342.  
  343.         virtual void GetConfiguration(SFlowNodeConfig& config)
  344.         {
  345.                 static const SInputPortConfig in_config[] = {
  346.                         InputPortConfig_Void("DoCalc", _HELP("Do the calc and send the result to the output when receiving event on this port")),
  347.                         InputPortConfig<int>("Op",     EOP_ADD,                                                                                  _HELP("Operation"),_HELP("Operation"), _UICONFIG("enum_int:Add=0,Sub=1,Mul=2,Cross=3,Dot=4")),
  348.                         InputPortConfig<Vec3>("A",     _HELP("Vector A")),
  349.                         InputPortConfig<Vec3>("B",     _HELP("Vector B")),
  350.                         { 0 }
  351.                 };
  352.                 static const SOutputPortConfig out_config[] = {
  353.                         OutputPortConfig_AnyType("out", _HELP("A Vec3 with the result of the operation or a float for a Dot product")),
  354.                         { 0 }
  355.                 };
  356.                 config.sDescription = _HELP("[out] = result of the specified operation with [A] and [B]");
  357.                 config.pInputPorts = in_config;
  358.                 config.pOutputPorts = out_config;
  359.                 config.SetCategory(EFLN_APPROVED);
  360.         }
  361.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  362.         {
  363.                 switch (event)
  364.                 {
  365.                 case eFE_Activate:
  366.                         {
  367.                                 if (IsPortActive(pActInfo, INP_DoCalc))
  368.                                 {
  369.                                         Vec3 a = GetPortVec3(pActInfo, INP_A);
  370.                                         Vec3 b = GetPortVec3(pActInfo, INP_B);
  371.                                         int op = GetPortInt(pActInfo, INP_Operation);
  372.  
  373.                                         if (op == EOP_DOT)
  374.                                         {
  375.                                                 float out = a.Dot(b);
  376.                                                 ActivateOutput(pActInfo, 0, out);
  377.                                         }
  378.                                         else
  379.                                         {
  380.                                                 Vec3 out(0, 0, 0);
  381.                                                 switch (op)
  382.                                                 {
  383.                                                 case EOP_ADD:
  384.                                                         out = a + b;
  385.                                                         break;
  386.  
  387.                                                 case EOP_SUB:
  388.                                                         out = a - b;
  389.                                                         break;
  390.  
  391.                                                 case EOP_MUL:
  392.                                                         out.x = a.x * b.x;
  393.                                                         out.y = a.y * b.y;
  394.                                                         out.z = a.z * b.z;
  395.                                                         break;
  396.  
  397.                                                 case EOP_CROSS:
  398.                                                         out = a.Cross(b);
  399.                                                         break;
  400.                                                 }
  401.                                                 ActivateOutput(pActInfo, 0, out);
  402.                                         }
  403.  
  404.                                 }
  405.                                 break;
  406.                         }
  407.                 }
  408.         };
  409.  
  410.         virtual void GetMemoryUsage(ICrySizer* s) const
  411.         {
  412.                 s->Add(*this);
  413.         }
  414. };
  415.  
  416. //////////////////////////////////////////////////////////////////////////
  417. class CFlowNode_AddVec3 : public CFlowBaseNode<eNCT_Singleton>
  418. {
  419. public:
  420.         CFlowNode_AddVec3(SActivationInfo* pActInfo) {}
  421.  
  422.         virtual void GetConfiguration(SFlowNodeConfig& config)
  423.         {
  424.                 static const SInputPortConfig in_config[] = {
  425.                         InputPortConfig<Vec3>("A", _HELP("out=A+B")),
  426.                         InputPortConfig<Vec3>("B", _HELP("out=A+B")),
  427.                         { 0 }
  428.                 };
  429.                 static const SOutputPortConfig out_config[] = {
  430.                         OutputPortConfig<Vec3>("out", _HELP("out=A+B")),
  431.                         { 0 }
  432.                 };
  433.                 config.pInputPorts = in_config;
  434.                 config.pOutputPorts = out_config;
  435.                 config.SetCategory(EFLN_APPROVED);
  436.         }
  437.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  438.         {
  439.                 switch (event)
  440.                 {
  441.                 case eFE_Activate:
  442.                 case eFE_Initialize:
  443.                         Vec3 a = GetPortVec3(pActInfo, 0);
  444.                         Vec3 b = GetPortVec3(pActInfo, 1);
  445.                         Vec3 out = a + b;
  446.                         ActivateOutput(pActInfo, 0, out);
  447.                         break;
  448.                 }
  449.         };
  450.  
  451.         virtual void GetMemoryUsage(ICrySizer* s) const
  452.         {
  453.                 s->Add(*this);
  454.         }
  455. };
  456. //////////////////////////////////////////////////////////////////////////
  457. class CFlowNode_SubVec3 : public CFlowBaseNode<eNCT_Singleton>
  458. {
  459. public:
  460.         CFlowNode_SubVec3(SActivationInfo* pActInfo) {}
  461.  
  462.         virtual void GetConfiguration(SFlowNodeConfig& config)
  463.         {
  464.                 static const SInputPortConfig in_config[] = {
  465.                         InputPortConfig<Vec3>("A", _HELP("out=A-B")),
  466.                         InputPortConfig<Vec3>("B", _HELP("out=A-B")),
  467.                         { 0 }
  468.                 };
  469.                 static const SOutputPortConfig out_config[] = {
  470.                         OutputPortConfig<Vec3>("out", _HELP("out=A-B")),
  471.                         { 0 }
  472.                 };
  473.                 config.pInputPorts = in_config;
  474.                 config.pOutputPorts = out_config;
  475.                 config.SetCategory(EFLN_APPROVED);
  476.         }
  477.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  478.         {
  479.                 switch (event)
  480.                 {
  481.                 case eFE_Activate:
  482.                 case eFE_Initialize:
  483.                         Vec3 a = GetPortVec3(pActInfo, 0);
  484.                         Vec3 b = GetPortVec3(pActInfo, 1);
  485.                         Vec3 out = a - b;
  486.                         ActivateOutput(pActInfo, 0, out);
  487.                         break;
  488.                 }
  489.         };
  490.  
  491.         virtual void GetMemoryUsage(ICrySizer* s) const
  492.         {
  493.                 s->Add(*this);
  494.         }
  495. };
  496. //////////////////////////////////////////////////////////////////////////
  497. class CFlowNode_MulVec3 : public CFlowBaseNode<eNCT_Singleton>
  498. {
  499. public:
  500.         CFlowNode_MulVec3(SActivationInfo* pActInfo) {}
  501.  
  502.         virtual void GetConfiguration(SFlowNodeConfig& config)
  503.         {
  504.                 static const SInputPortConfig in_config[] = {
  505.                         InputPortConfig<Vec3>("A", _HELP("out=A*B")),
  506.                         InputPortConfig<Vec3>("B", _HELP("out=A*B")),
  507.                         { 0 }
  508.                 };
  509.                 static const SOutputPortConfig out_config[] = {
  510.                         OutputPortConfig<Vec3>("out", _HELP("out=A*B")),
  511.                         { 0 }
  512.                 };
  513.                 config.pInputPorts = in_config;
  514.                 config.pOutputPorts = out_config;
  515.                 config.SetCategory(EFLN_APPROVED);
  516.         }
  517.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  518.         {
  519.                 switch (event)
  520.                 {
  521.                 case eFE_Activate:
  522.                 case eFE_Initialize:
  523.                         Vec3 a = GetPortVec3(pActInfo, 0);
  524.                         Vec3 b = GetPortVec3(pActInfo, 1);
  525.                         Vec3 out(a.x * b.x, a.y * b.y, a.z * b.z);
  526.                         ActivateOutput(pActInfo, 0, out);
  527.                         break;
  528.                 }
  529.         };
  530.  
  531.         virtual void GetMemoryUsage(ICrySizer* s) const
  532.         {
  533.                 s->Add(*this);
  534.         }
  535. };
  536.  
  537. //////////////////////////////////////////////////////////////////////////
  538. class CFlowNode_CrossVec3 : public CFlowBaseNode<eNCT_Singleton>
  539. {
  540. public:
  541.         CFlowNode_CrossVec3(SActivationInfo* pActInfo) {}
  542.  
  543.         virtual void GetConfiguration(SFlowNodeConfig& config)
  544.         {
  545.                 static const SInputPortConfig in_config[] = {
  546.                         InputPortConfig<Vec3>("A", _HELP("out=A^B")),
  547.                         InputPortConfig<Vec3>("B", _HELP("out=A^B")),
  548.                         { 0 }
  549.                 };
  550.                 static const SOutputPortConfig out_config[] = {
  551.                         OutputPortConfig<Vec3>("out", _HELP("out=A^B")),
  552.                         { 0 }
  553.                 };
  554.                 config.pInputPorts = in_config;
  555.                 config.pOutputPorts = out_config;
  556.                 config.SetCategory(EFLN_APPROVED);
  557.         }
  558.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  559.         {
  560.                 switch (event)
  561.                 {
  562.                 case eFE_Activate:
  563.                 case eFE_Initialize:
  564.                         Vec3 a = GetPortVec3(pActInfo, 0);
  565.                         Vec3 b = GetPortVec3(pActInfo, 1);
  566.                         Vec3 out = a.Cross(b);
  567.                         ActivateOutput(pActInfo, 0, out);
  568.                         break;
  569.                 }
  570.         };
  571.  
  572.         virtual void GetMemoryUsage(ICrySizer* s) const
  573.         {
  574.                 s->Add(*this);
  575.         }
  576. };
  577.  
  578. //////////////////////////////////////////////////////////////////////////
  579. class CFlowNode_DotVec3 : public CFlowBaseNode<eNCT_Singleton>
  580. {
  581. public:
  582.         CFlowNode_DotVec3(SActivationInfo* pActInfo) {}
  583.  
  584.         virtual void GetConfiguration(SFlowNodeConfig& config)
  585.         {
  586.                 static const SInputPortConfig in_config[] = {
  587.                         InputPortConfig<Vec3>("A", _HELP("out=A.B")),
  588.                         InputPortConfig<Vec3>("B", _HELP("out=A.B")),
  589.                         { 0 }
  590.                 };
  591.                 static const SOutputPortConfig out_config[] = {
  592.                         OutputPortConfig<float>("out", "out=A.B"),
  593.                         { 0 }
  594.                 };
  595.                 config.pInputPorts = in_config;
  596.                 config.pOutputPorts = out_config;
  597.                 config.SetCategory(EFLN_APPROVED);
  598.         }
  599.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  600.         {
  601.                 switch (event)
  602.                 {
  603.                 case eFE_Activate:
  604.                 case eFE_Initialize:
  605.                         Vec3 a = GetPortVec3(pActInfo, 0);
  606.                         Vec3 b = GetPortVec3(pActInfo, 1);
  607.                         float out = a.Dot(b);
  608.                         ActivateOutput(pActInfo, 0, out);
  609.                         break;
  610.                 }
  611.         };
  612.  
  613.         virtual void GetMemoryUsage(ICrySizer* s) const
  614.         {
  615.                 s->Add(*this);
  616.         }
  617. };
  618.  
  619. //////////////////////////////////////////////////////////////////////////
  620. class CFlowNode_MagnitudeVec3 : public CFlowBaseNode<eNCT_Singleton>
  621. {
  622. public:
  623.         CFlowNode_MagnitudeVec3(SActivationInfo* pActInfo) {}
  624.  
  625.         virtual void GetConfiguration(SFlowNodeConfig& config)
  626.         {
  627.                 static const SInputPortConfig in_config[] = {
  628.                         InputPortConfig<Vec3>("vector"),
  629.                         { 0 }
  630.                 };
  631.                 static const SOutputPortConfig out_config[] = {
  632.                         OutputPortConfig<float>("length"),
  633.                         { 0 }
  634.                 };
  635.                 config.pInputPorts = in_config;
  636.                 config.pOutputPorts = out_config;
  637.                 config.SetCategory(EFLN_APPROVED);
  638.         }
  639.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  640.         {
  641.                 switch (event)
  642.                 {
  643.                 case eFE_Activate:
  644.                 case eFE_Initialize:
  645.                         ActivateOutput(pActInfo, 0, GetPortVec3(pActInfo, 0).GetLength());
  646.                 }
  647.                 ;
  648.         };
  649.  
  650.         virtual void GetMemoryUsage(ICrySizer* s) const
  651.         {
  652.                 s->Add(*this);
  653.         }
  654. };
  655.  
  656. //////////////////////////////////////////////////////////////////////////
  657. class CFlowNode_ReciprocalVec3 : public CFlowBaseNode<eNCT_Singleton>
  658. {
  659. public:
  660.         CFlowNode_ReciprocalVec3(SActivationInfo* pActInfo) {}
  661.  
  662.         virtual void GetConfiguration(SFlowNodeConfig& config)
  663.         {
  664.                 static const SInputPortConfig in_config[] = {
  665.                         InputPortConfig<Vec3>("vector"),
  666.                         { 0 }
  667.                 };
  668.                 static const SOutputPortConfig out_config[] = {
  669.                         OutputPortConfig<float>("length", _HELP("1.0 / length[vector]")),
  670.                         { 0 }
  671.                 };
  672.                 config.pInputPorts = in_config;
  673.                 config.pOutputPorts = out_config;
  674.                 config.SetCategory(EFLN_APPROVED);
  675.         }
  676.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  677.         {
  678.                 switch (event)
  679.                 {
  680.                 case eFE_Activate:
  681.                 case eFE_Initialize:
  682.                         Vec3 in(GetPortVec3(pActInfo, 0));
  683.                         Vec3 out(abs(in.x) > 0.0001f ? 1.0f / in.x : 0.0f,
  684.                                  abs(in.y) > 0.0001f ? 1.0f / in.y : 0.0f,
  685.                                  abs(in.z) > 0.0001f ? 1.0f / in.z : 0.0f);
  686.                         ActivateOutput(pActInfo, 0, out);
  687.                 }
  688.                 ;
  689.         };
  690.  
  691.         virtual void GetMemoryUsage(ICrySizer* s) const
  692.         {
  693.                 s->Add(*this);
  694.         }
  695. };
  696.  
  697. //////////////////////////////////////////////////////////////////////////
  698. class CFlowNode_ScaleVec3 : public CFlowBaseNode<eNCT_Singleton>
  699. {
  700. public:
  701.         CFlowNode_ScaleVec3(SActivationInfo* pActInfo) {}
  702.  
  703.         virtual void GetConfiguration(SFlowNodeConfig& config)
  704.         {
  705.                 static const SInputPortConfig in_config[] = {
  706.                         InputPortConfig<Vec3>("vector"),
  707.                         InputPortConfig<float>("scale"),
  708.                         { 0 }
  709.                 };
  710.                 static const SOutputPortConfig out_config[] = {
  711.                         OutputPortConfig<Vec3>("out"),
  712.                         { 0 }
  713.                 };
  714.                 config.sDescription = _HELP("[out] = [vector] * [scale]");
  715.                 config.pInputPorts = in_config;
  716.                 config.pOutputPorts = out_config;
  717.                 config.SetCategory(EFLN_APPROVED);
  718.         }
  719.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  720.         {
  721.                 switch (event)
  722.                 {
  723.                 case eFE_Activate:
  724.                 case eFE_Initialize:
  725.                         Vec3 a = GetPortVec3(pActInfo, 0);
  726.                         float b = GetPortFloat(pActInfo, 1);
  727.                         Vec3 out = a * b;
  728.                         ActivateOutput(pActInfo, 0, out);
  729.                         break;
  730.                 }
  731.         };
  732.  
  733.         virtual void GetMemoryUsage(ICrySizer* s) const
  734.         {
  735.                 s->Add(*this);
  736.         }
  737. };
  738.  
  739. //////////////////////////////////////////////////////////////////////////
  740. class CFlowNode_NormalizeVec3 : public CFlowBaseNode<eNCT_Singleton>
  741. {
  742. public:
  743.         CFlowNode_NormalizeVec3(SActivationInfo* pActInfo) {}
  744.  
  745.         virtual void GetConfiguration(SFlowNodeConfig& config)
  746.         {
  747.                 static const SInputPortConfig in_config[] = {
  748.                         InputPortConfig<Vec3>("vector", _HELP("||out||=1")),
  749.                         { 0 }
  750.                 };
  751.                 static const SOutputPortConfig out_config[] = {
  752.                         OutputPortConfig<Vec3>("out",     _HELP("||out||=1")),
  753.                         OutputPortConfig<float>("lenght", _HELP("||out||=1"), _HELP("length")),
  754.                         { 0 }
  755.                 };
  756.                 config.pInputPorts = in_config;
  757.                 config.pOutputPorts = out_config;
  758.                 config.SetCategory(EFLN_APPROVED);
  759.         }
  760.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  761.         {
  762.                 switch (event)
  763.                 {
  764.                 case eFE_Activate:
  765.                 case eFE_Initialize:
  766.                         Vec3 a = GetPortVec3(pActInfo, 0);
  767.                         float l = a.len();
  768.  
  769.                         if (l > 0)
  770.                                 ActivateOutput(pActInfo, 0, a * (1.0f / l));
  771.                         ActivateOutput(pActInfo, 1, l);
  772.                         break;
  773.                 }
  774.         };
  775.  
  776.         virtual void GetMemoryUsage(ICrySizer* s) const
  777.         {
  778.                 s->Add(*this);
  779.         }
  780. };
  781.  
  782. //////////////////////////////////////////////////////////////////////////
  783. class CFlowNode_EqualVec3 : public CFlowBaseNode<eNCT_Singleton>
  784. {
  785. public:
  786.         CFlowNode_EqualVec3(SActivationInfo* pActInfo) {}
  787.  
  788.         virtual void GetConfiguration(SFlowNodeConfig& config)
  789.         {
  790.                 static const SInputPortConfig in_config[] = {
  791.                         InputPortConfig<Vec3>("A", _HELP("out triggered when A==B")),
  792.                         InputPortConfig<Vec3>("B", _HELP("out triggered when A==B")),
  793.                         { 0 }
  794.                 };
  795.                 static const SOutputPortConfig out_config[] = {
  796.                         OutputPortConfig<bool>("out"),
  797.                         { 0 }
  798.                 };
  799.                 config.pInputPorts = in_config;
  800.                 config.pOutputPorts = out_config;
  801.                 config.SetCategory(EFLN_APPROVED);
  802.         }
  803.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  804.         {
  805.                 switch (event)
  806.                 {
  807.                 case eFE_Activate:
  808.                 case eFE_Initialize:
  809.                         Vec3 a = GetPortVec3(pActInfo, 0);
  810.                         Vec3 b = GetPortVec3(pActInfo, 1);
  811.                         if (a.IsEquivalent(b))
  812.                                 ActivateOutput(pActInfo, 0, true);
  813.                         else
  814.                                 ActivateOutput(pActInfo, 0, false);
  815.                         break;
  816.                 }
  817.         };
  818.  
  819.         virtual void GetMemoryUsage(ICrySizer* s) const
  820.         {
  821.                 s->Add(*this);
  822.         }
  823. };
  824.  
  825. //////////////////////////////////////////////////////////////////////////
  826. class CFlowNode_Reciprocal : public CFlowBaseNode<eNCT_Singleton>
  827. {
  828. public:
  829.         CFlowNode_Reciprocal(SActivationInfo* pActInfo) {}
  830.  
  831.         virtual void GetConfiguration(SFlowNodeConfig& config)
  832.         {
  833.                 static const SInputPortConfig in_config[] = {
  834.                         InputPortConfig<float>("A", _HELP("out=1/A")),
  835.                         { 0 }
  836.                 };
  837.                 static const SOutputPortConfig out_config[] = {
  838.                         OutputPortConfig<float>("out", _HELP("out=1/A")),
  839.                         { 0 }
  840.                 };
  841.                 config.pInputPorts = in_config;
  842.                 config.pOutputPorts = out_config;
  843.                 config.SetCategory(EFLN_APPROVED);
  844.         }
  845.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  846.         {
  847.                 switch (event)
  848.                 {
  849.                 case eFE_Activate:
  850.                 case eFE_Initialize:
  851.                         float a = GetPortFloat(pActInfo, 0);
  852.                         float out = abs(a) > 0.0001f ? 1.0f / a : 0.0f;
  853.                         ActivateOutput(pActInfo, 0, out);
  854.                         break;
  855.                 }
  856.         };
  857.  
  858.         virtual void GetMemoryUsage(ICrySizer* s) const
  859.         {
  860.                 s->Add(*this);
  861.         }
  862. };
  863.  
  864. //////////////////////////////////////////////////////////////////////////
  865. class CFlowNode_Power : public CFlowBaseNode<eNCT_Singleton>
  866. {
  867. public:
  868.         CFlowNode_Power(SActivationInfo* pActInfo) {}
  869.  
  870.         virtual void GetConfiguration(SFlowNodeConfig& config)
  871.         {
  872.                 static const SInputPortConfig in_config[] = {
  873.                         InputPortConfig<float>("base",  _HELP("out=base^power")),
  874.                         InputPortConfig<float>("power", _HELP("out=base^power")),
  875.                         { 0 }
  876.                 };
  877.                 static const SOutputPortConfig out_config[] = {
  878.                         OutputPortConfig<float>("out", "out=base^power"),
  879.                         { 0 }
  880.                 };
  881.                 config.pInputPorts = in_config;
  882.                 config.pOutputPorts = out_config;
  883.                 config.SetCategory(EFLN_APPROVED);
  884.         }
  885.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  886.         {
  887.                 switch (event)
  888.                 {
  889.                 case eFE_Activate:
  890.                 case eFE_Initialize:
  891.                         float a = GetPortFloat(pActInfo, 0);
  892.                         float b = GetPortFloat(pActInfo, 1);
  893.                         float out = pow(a, b);
  894.                         ActivateOutput(pActInfo, 0, out);
  895.                         break;
  896.                 }
  897.         };
  898.  
  899.         virtual void GetMemoryUsage(ICrySizer* s) const
  900.         {
  901.                 s->Add(*this);
  902.         }
  903. };
  904.  
  905. //////////////////////////////////////////////////////////////////////////
  906. class CFlowNode_Sqrt : public CFlowBaseNode<eNCT_Singleton>
  907. {
  908. public:
  909.         CFlowNode_Sqrt(SActivationInfo* pActInfo) {}
  910.  
  911.         virtual void GetConfiguration(SFlowNodeConfig& config)
  912.         {
  913.                 static const SInputPortConfig in_config[] = {
  914.                         InputPortConfig<float>("A", _HELP("out=sqrt(A)")),
  915.                         { 0 }
  916.                 };
  917.                 static const SOutputPortConfig out_config[] = {
  918.                         OutputPortConfig<float>("out", _HELP("out=sqrt(A)")),
  919.                         { 0 }
  920.                 };
  921.                 config.pInputPorts = in_config;
  922.                 config.pOutputPorts = out_config;
  923.                 config.SetCategory(EFLN_APPROVED);
  924.         }
  925.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  926.         {
  927.                 switch (event)
  928.                 {
  929.                 case eFE_Activate:
  930.                 case eFE_Initialize:
  931.                         float a = GetPortFloat(pActInfo, 0);
  932.                         float out = sqrtf(a);
  933.                         ActivateOutput(pActInfo, 0, out);
  934.                         break;
  935.                 }
  936.         };
  937.  
  938.         virtual void GetMemoryUsage(ICrySizer* s) const
  939.         {
  940.                 s->Add(*this);
  941.         }
  942. };
  943.  
  944. //////////////////////////////////////////////////////////////////////////
  945. class CFlowNode_Abs : public CFlowBaseNode<eNCT_Singleton>
  946. {
  947. public:
  948.         CFlowNode_Abs(SActivationInfo* pActInfo) {}
  949.  
  950.         virtual void GetConfiguration(SFlowNodeConfig& config)
  951.         {
  952.                 static const SInputPortConfig in_config[] = {
  953.                         InputPortConfig<float>("A", _HELP("out=|A|")),
  954.                         { 0 }
  955.                 };
  956.                 static const SOutputPortConfig out_config[] = {
  957.                         OutputPortConfig<float>("out", _HELP("out=|A|")),
  958.                         { 0 }
  959.                 };
  960.                 config.pInputPorts = in_config;
  961.                 config.pOutputPorts = out_config;
  962.                 config.SetCategory(EFLN_APPROVED);
  963.         }
  964.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  965.         {
  966.                 switch (event)
  967.                 {
  968.                 case eFE_Activate:
  969.                 case eFE_Initialize:
  970.                         float a = GetPortFloat(pActInfo, 0);
  971.                         float out = abs(a);
  972.                         ActivateOutput(pActInfo, 0, out);
  973.                         break;
  974.                 }
  975.         };
  976.  
  977.         virtual void GetMemoryUsage(ICrySizer* s) const
  978.         {
  979.                 s->Add(*this);
  980.         }
  981. };
  982.  
  983. //////////////////////////////////////////////////////////////////////////
  984. class CFlowNode_Div : public CFlowBaseNode<eNCT_Singleton>
  985. {
  986. public:
  987.         CFlowNode_Div(SActivationInfo* pActInfo) {}
  988.  
  989.         virtual void GetConfiguration(SFlowNodeConfig& config)
  990.         {
  991.                 static const SInputPortConfig in_config[] = {
  992.                         InputPortConfig<float>("A"),
  993.                         InputPortConfig<float>("B"),
  994.                         { 0 }
  995.                 };
  996.                 static const SOutputPortConfig out_config[] = {
  997.                         OutputPortConfig<float>("out"),
  998.                         { 0 }
  999.                 };
  1000.                 config.sDescription = _HELP("[out] = [A] / [B]");
  1001.                 config.pInputPorts = in_config;
  1002.                 config.pOutputPorts = out_config;
  1003.                 config.SetCategory(EFLN_APPROVED);
  1004.         }
  1005.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1006.         {
  1007.                 switch (event)
  1008.                 {
  1009.                 case eFE_Activate:
  1010.                 case eFE_Initialize:
  1011.                         float a = GetPortFloat(pActInfo, 0);
  1012.                         float b = GetPortFloat(pActInfo, 1);
  1013.                         float out = 0.0f;
  1014.                         if (!iszero(b))
  1015.                                 out = a / b;
  1016.                         ActivateOutput(pActInfo, 0, out);
  1017.                         break;
  1018.                 }
  1019.         };
  1020.  
  1021.         virtual void GetMemoryUsage(ICrySizer* s) const
  1022.         {
  1023.                 s->Add(*this);
  1024.         }
  1025. };
  1026. //////////////////////////////////////////////////////////////////////////
  1027. class CFlowNode_Remainder : public CFlowBaseNode<eNCT_Singleton>
  1028. {
  1029. public:
  1030.         CFlowNode_Remainder(SActivationInfo* pActInfo) {}
  1031.  
  1032.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1033.         {
  1034.                 static const SInputPortConfig in_config[] = {
  1035.                         InputPortConfig<float>("A"),
  1036.                         InputPortConfig<float>("B"),
  1037.                         { 0 }
  1038.                 };
  1039.                 static const SOutputPortConfig out_config[] = {
  1040.                         OutputPortConfig<int>("out"),
  1041.                         { 0 }
  1042.                 };
  1043.                 config.sDescription = _HELP("[out] = remainder of [A]/[B]");
  1044.                 config.pInputPorts = in_config;
  1045.                 config.pOutputPorts = out_config;
  1046.                 config.SetCategory(EFLN_APPROVED);
  1047.         }
  1048.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1049.         {
  1050.                 switch (event)
  1051.                 {
  1052.                 case eFE_Activate:
  1053.                 case eFE_Initialize:
  1054.                         float a = GetPortFloat(pActInfo, 0);
  1055.                         float b = GetPortFloat(pActInfo, 1);
  1056.                         int ia = FtoI(a);
  1057.                         int ib = FtoI(b);
  1058.                         int out;
  1059.                         if (ib != 0)
  1060.                                 out = ia % ib;
  1061.                         else
  1062.                                 out = 0;
  1063.                         ActivateOutput(pActInfo, 0, out);
  1064.                         break;
  1065.                 }
  1066.         };
  1067.  
  1068.         virtual void GetMemoryUsage(ICrySizer* s) const
  1069.         {
  1070.                 s->Add(*this);
  1071.         }
  1072. };
  1073.  
  1074. //////////////////////////////////////////////////////////////////////////
  1075. class CFlowNode_InRange : public CFlowBaseNode<eNCT_Singleton>
  1076. {
  1077. public:
  1078.         CFlowNode_InRange(SActivationInfo* pActInfo) {}
  1079.  
  1080.         enum
  1081.         {
  1082.                 INP_In = 0,
  1083.                 INP_Min,
  1084.                 INP_Max,
  1085.         };
  1086.         enum EOperation
  1087.         {
  1088.                 EOP_Out = 0,
  1089.                 EOP_True,
  1090.                 EOP_False,
  1091.         };
  1092.  
  1093.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1094.         {
  1095.                 static const SInputPortConfig in_config[] = {
  1096.                         InputPortConfig<float>("In"),
  1097.                         InputPortConfig<float>("Min"),
  1098.                         InputPortConfig<float>("Max"),
  1099.                         { 0 }
  1100.                 };
  1101.                 static const SOutputPortConfig out_config[] = {
  1102.                         OutputPortConfig<bool>("out",  _HELP("true when [in]>=[Min] and [in]<=[Max], false otherwise")),
  1103.                         OutputPortConfig_Void("true",  _HELP("triggered if In is in range (>=min and <=max)")),
  1104.                         OutputPortConfig_Void("false", _HELP("triggered if In is in range (>=min and <=max)")),
  1105.                         { 0 }
  1106.                 };
  1107.                 config.sDescription = _HELP("[out] is true when [in]>=[Min] and [in]<=[Max], false otherwise");
  1108.                 config.pInputPorts = in_config;
  1109.                 config.pOutputPorts = out_config;
  1110.                 config.SetCategory(EFLN_APPROVED);
  1111.         }
  1112.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1113.         {
  1114.                 bool bOut = false;
  1115.                 switch (event)
  1116.                 {
  1117.                 case eFE_Activate:
  1118.                 case eFE_Initialize:
  1119.                         float in = GetPortFloat(pActInfo, INP_In);
  1120.                         float v_min = GetPortFloat(pActInfo, INP_Min);
  1121.                         float v_max = GetPortFloat(pActInfo, INP_Max);
  1122.                         bOut = (in >= v_min && in <= v_max) ? true : false;
  1123.  
  1124.                         if (bOut)
  1125.                                 ActivateOutput(pActInfo, EOP_True, true);
  1126.                         else
  1127.                                 ActivateOutput(pActInfo, EOP_False, true);
  1128.  
  1129.                         ActivateOutput(pActInfo, EOP_Out, bOut);
  1130.                         break;
  1131.                 }
  1132.         };
  1133.  
  1134.         virtual void GetMemoryUsage(ICrySizer* s) const
  1135.         {
  1136.                 s->Add(*this);
  1137.         }
  1138. };
  1139.  
  1140. //////////////////////////////////////////////////////////////////////////
  1141. class CFlowNode_Equal : public CFlowBaseNode<eNCT_Singleton>
  1142. {
  1143. public:
  1144.         CFlowNode_Equal(SActivationInfo* pActInfo) {}
  1145.  
  1146.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1147.         {
  1148.                 static const SInputPortConfig in_config[] = {
  1149.                         InputPortConfig<float>("A"),
  1150.                         InputPortConfig<float>("B"),
  1151.                         { 0 }
  1152.                 };
  1153.                 static const SOutputPortConfig out_config[] = {
  1154.                         OutputPortConfig<bool>("out"),
  1155.                         OutputPortConfig_Void("true", _HELP("triggered if out is true")),
  1156.                         OutputPortConfig_Void("false",_HELP("triggered if out is false")),
  1157.                         { 0 }
  1158.                 };
  1159.                 config.sDescription = _HELP("[out] is true when [A]==[B], false otherwise");
  1160.                 config.pInputPorts = in_config;
  1161.                 config.pOutputPorts = out_config;
  1162.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  1163.                 config.SetCategory(EFLN_APPROVED);
  1164.         }
  1165.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1166.         {
  1167.                 bool bOut = false;
  1168.                 switch (event)
  1169.                 {
  1170.                 case eFE_Activate:
  1171.                 case eFE_Initialize:
  1172.                         float a = GetPortFloat(pActInfo, 0);
  1173.                         float b = GetPortFloat(pActInfo, 1);
  1174.                         bOut = (fabs(a - b) < 0.00001f) ? true : false;
  1175.  
  1176.                         if (bOut)
  1177.                                 ActivateOutput(pActInfo, 1, true);
  1178.                         else
  1179.                                 ActivateOutput(pActInfo, 2, true);
  1180.  
  1181.                         ActivateOutput(pActInfo, 0, bOut);
  1182.                         break;
  1183.                 }
  1184.         };
  1185.  
  1186.         virtual void GetMemoryUsage(ICrySizer* s) const
  1187.         {
  1188.                 s->Add(*this);
  1189.         }
  1190. };
  1191.  
  1192. //////////////////////////////////////////////////////////////////////////
  1193. class CFlowNode_EqualCheck : public CFlowBaseNode<eNCT_Singleton>
  1194. {
  1195.         enum EInPorts
  1196.         {
  1197.                 IN_A = 0,
  1198.                 IN_B,
  1199.                 IN_CHECK
  1200.         };
  1201.  
  1202. public:
  1203.         CFlowNode_EqualCheck(SActivationInfo* pActInfo) {}
  1204.  
  1205.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1206.         {
  1207.                 static const SInputPortConfig in_config[] = {
  1208.                         InputPortConfig<float>("A"),
  1209.                         InputPortConfig<float>("B"),
  1210.                         InputPortConfig_Void("Check"),
  1211.                         { 0 }
  1212.                 };
  1213.                 static const SOutputPortConfig out_config[] = {
  1214.                         OutputPortConfig<bool>("out"),
  1215.                         OutputPortConfig_Void("true", _HELP("triggered if out is true")),
  1216.                         OutputPortConfig_Void("false",_HELP("triggered if out is false")),
  1217.                         { 0 }
  1218.                 };
  1219.                 config.sDescription = _HELP("[out] is true when [A]==[B], false otherwise. The check is only performed when the 'Check' input is triggered");
  1220.                 config.pInputPorts = in_config;
  1221.                 config.pOutputPorts = out_config;
  1222.                 config.SetCategory(EFLN_APPROVED);
  1223.         }
  1224.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1225.         {
  1226.                 bool bOut = false;
  1227.                 switch (event)
  1228.                 {
  1229.                 case eFE_Activate:
  1230.                         {
  1231.                                 if (IsPortActive(pActInfo, IN_CHECK))
  1232.                                 {
  1233.                                         float a = GetPortFloat(pActInfo, 0);
  1234.                                         float b = GetPortFloat(pActInfo, 1);
  1235.                                         bOut = (fabs(a - b) < 0.00001f) ? true : false;
  1236.  
  1237.                                         if (bOut)
  1238.                                                 ActivateOutput(pActInfo, 1, true);
  1239.                                         else
  1240.                                                 ActivateOutput(pActInfo, 2, true);
  1241.  
  1242.                                         ActivateOutput(pActInfo, 0, bOut);
  1243.                                 }
  1244.                                 break;
  1245.                         }
  1246.                 }
  1247.         }
  1248.  
  1249.         virtual void GetMemoryUsage(ICrySizer* s) const
  1250.         {
  1251.                 s->Add(*this);
  1252.         }
  1253. };
  1254.  
  1255. //////////////////////////////////////////////////////////////////////////
  1256. class CFlowNode_Less : public CFlowBaseNode<eNCT_Singleton>
  1257. {
  1258. public:
  1259.         CFlowNode_Less(SActivationInfo* pActInfo) {}
  1260.  
  1261.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1262.         {
  1263.                 static const SInputPortConfig in_config[] = {
  1264.                         InputPortConfig<float>("A"),
  1265.                         InputPortConfig<float>("B"),
  1266.                         { 0 }
  1267.                 };
  1268.                 static const SOutputPortConfig out_config[] = {
  1269.                         OutputPortConfig<bool>("out"),
  1270.                         OutputPortConfig_Void("true", _HELP("triggered if out is true")),
  1271.                         OutputPortConfig_Void("false",_HELP("triggered if out is false")),
  1272.                         { 0 }
  1273.                 };
  1274.                 config.sDescription = _HELP("[out] is true when [A] < [B], false otherwise");
  1275.                 config.pInputPorts = in_config;
  1276.                 config.pOutputPorts = out_config;
  1277.                 config.SetCategory(EFLN_APPROVED);
  1278.         }
  1279.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1280.         {
  1281.                 bool bOut = false;
  1282.                 switch (event)
  1283.                 {
  1284.                 case eFE_Activate:
  1285.                 case eFE_Initialize:
  1286.                         float a = GetPortFloat(pActInfo, 0);
  1287.                         float b = GetPortFloat(pActInfo, 1);
  1288.                         bOut = (a < b) ? true : false;
  1289.  
  1290.                         if (bOut)
  1291.                                 ActivateOutput(pActInfo, 1, true);
  1292.                         else
  1293.                                 ActivateOutput(pActInfo, 2, true);
  1294.  
  1295.                         ActivateOutput(pActInfo, 0, bOut);
  1296.  
  1297.                         break;
  1298.                 }
  1299.         };
  1300.  
  1301.         virtual void GetMemoryUsage(ICrySizer* s) const
  1302.         {
  1303.                 s->Add(*this);
  1304.         }
  1305. };
  1306.  
  1307. //////////////////////////////////////////////////////////////////////////
  1308. class CFlowNode_LessCheck : public CFlowBaseNode<eNCT_Singleton>
  1309. {
  1310.         enum EInPorts
  1311.         {
  1312.                 IN_A = 0,
  1313.                 IN_B,
  1314.                 IN_CHECK
  1315.         };
  1316.  
  1317. public:
  1318.         CFlowNode_LessCheck(SActivationInfo* pActInfo) {}
  1319.  
  1320.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1321.         {
  1322.                 static const SInputPortConfig in_config[] = {
  1323.                         InputPortConfig<float>("A"),
  1324.                         InputPortConfig<float>("B"),
  1325.                         InputPortConfig_Void("Check"),
  1326.                         { 0 }
  1327.                 };
  1328.                 static const SOutputPortConfig out_config[] = {
  1329.                         OutputPortConfig<bool>("out"),
  1330.                         OutputPortConfig_Void("true", _HELP("triggered if out is true")),
  1331.                         OutputPortConfig_Void("false",_HELP("triggered if out is false")),
  1332.                         { 0 }
  1333.                 };
  1334.                 config.sDescription = _HELP("[out] is true when [A] < [B], false otherwise. The check is only performed when the 'Check' input is triggered");
  1335.                 config.pInputPorts = in_config;
  1336.                 config.pOutputPorts = out_config;
  1337.                 config.SetCategory(EFLN_APPROVED);
  1338.         }
  1339.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1340.         {
  1341.                 switch (event)
  1342.                 {
  1343.                 case eFE_Activate:
  1344.                         {
  1345.                                 if (IsPortActive(pActInfo, IN_CHECK))
  1346.                                 {
  1347.                                         float a = GetPortFloat(pActInfo, IN_A);
  1348.                                         float b = GetPortFloat(pActInfo, IN_B);
  1349.                                         bool bOut = (a < b) ? true : false;
  1350.  
  1351.                                         if (bOut)
  1352.                                                 ActivateOutput(pActInfo, 1, true);
  1353.                                         else
  1354.                                                 ActivateOutput(pActInfo, 2, true);
  1355.  
  1356.                                         ActivateOutput(pActInfo, 0, bOut);
  1357.                                 }
  1358.                                 break;
  1359.                         }
  1360.                 }
  1361.         }
  1362.  
  1363.         virtual void GetMemoryUsage(ICrySizer* s) const
  1364.         {
  1365.                 s->Add(*this);
  1366.         }
  1367. };
  1368. //////////////////////////////////////////////////////////////////////////
  1369. class CFlowNode_Counter : public CFlowBaseNode<eNCT_Instanced>
  1370. {
  1371. public:
  1372.         CFlowNode_Counter(SActivationInfo* pActInfo) { m_nCounter = 0; }
  1373.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_Counter(pActInfo); }
  1374.  
  1375.         virtual void         Serialize(SActivationInfo* pActInfo, TSerialize ser)
  1376.         {
  1377.                 ser.Value("m_nCounter", m_nCounter);
  1378.         }
  1379.  
  1380.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1381.         {
  1382.                 static const SInputPortConfig in_config[] = {
  1383.                         InputPortConfig_Void("in"),
  1384.                         InputPortConfig_Void("reset"),
  1385.                         InputPortConfig<int>("max"),
  1386.                         { 0 }
  1387.                 };
  1388.                 static const SOutputPortConfig out_config[] = {
  1389.                         OutputPortConfig<int>("count"),
  1390.                         { 0 }
  1391.                 };
  1392.                 config.sDescription = _HELP("When [in] port is triggered, internal counter is increased and sent to [out], when count reaches [max] counter is set to 0");
  1393.                 config.pInputPorts = in_config;
  1394.                 config.pOutputPorts = out_config;
  1395.                 config.SetCategory(EFLN_APPROVED);
  1396.         }
  1397.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1398.         {
  1399.                 switch (event)
  1400.                 {
  1401.                 case eFE_Initialize:
  1402.                         m_nCounter = 0;
  1403.                         ActivateOutput(pActInfo, 0, m_nCounter);
  1404.                         break;
  1405.  
  1406.                 case eFE_Activate:
  1407.                         int nMax = GetPortInt(pActInfo, 2);
  1408.                         int nCounter = m_nCounter;
  1409.                         if (IsPortActive(pActInfo, 0))
  1410.                                 nCounter++;
  1411.                         if (IsPortActive(pActInfo, 1))
  1412.                                 nCounter = 0;
  1413.  
  1414.                         if (nMax > 0 && nCounter >= nMax)
  1415.                                 nCounter = 0;
  1416.  
  1417.                         if (nCounter != m_nCounter || event == eFE_Initialize)
  1418.                         {
  1419.                                 m_nCounter = nCounter;
  1420.                                 ActivateOutput(pActInfo, 0, m_nCounter);
  1421.                         }
  1422.                         break;
  1423.                 }
  1424.         };
  1425.  
  1426.         virtual void GetMemoryUsage(ICrySizer* s) const
  1427.         {
  1428.                 s->Add(*this);
  1429.         }
  1430. private:
  1431.         int m_nCounter;
  1432. };
  1433.  
  1434. //////////////////////////////////////////////////////////////////////////
  1435. class CFlowNode_PortCounter : public CFlowBaseNode<eNCT_Instanced>
  1436. {
  1437.         static const int PORT_COUNT = 16;
  1438.  
  1439. public:
  1440.         CFlowNode_PortCounter(SActivationInfo* pActInfo) { Reset(); }
  1441.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_PortCounter(pActInfo); }
  1442.  
  1443.         virtual void         GetConfiguration(SFlowNodeConfig& config)
  1444.         {
  1445.                 static const SInputPortConfig in_config[] = {
  1446.                         InputPortConfig_AnyType("reset",       _HELP("Trigger this to reset the total and port counters")),
  1447.                         InputPortConfig<int>("portThreshold",  0,                                                          _HELP("When portCount reaches portThreshold, portTrigger is activated")),
  1448.                         InputPortConfig<int>("totalThreshold", 0,                                                          _HELP("When totalCount reaches totalThreshold, totalTrigger is activated")),
  1449.                         InputPortConfig_AnyType("in01"),
  1450.                         InputPortConfig_AnyType("in02"),
  1451.                         InputPortConfig_AnyType("in03"),
  1452.                         InputPortConfig_AnyType("in04"),
  1453.                         InputPortConfig_AnyType("in05"),
  1454.                         InputPortConfig_AnyType("in06"),
  1455.                         InputPortConfig_AnyType("in07"),
  1456.                         InputPortConfig_AnyType("in08"),
  1457.                         InputPortConfig_AnyType("in09"),
  1458.                         InputPortConfig_AnyType("in10"),
  1459.                         InputPortConfig_AnyType("in11"),
  1460.                         InputPortConfig_AnyType("in12"),
  1461.                         InputPortConfig_AnyType("in13"),
  1462.                         InputPortConfig_AnyType("in14"),
  1463.                         InputPortConfig_AnyType("in15"),
  1464.                         InputPortConfig_AnyType("in16"),
  1465.                         { 0 }
  1466.                 };
  1467.                 static const SOutputPortConfig out_config[] = {
  1468.                         OutputPortConfig<int>("portCount",     _HELP("Total number of ports that have been set since last reset. Only counts each port once. (0 to 16)")),
  1469.                         OutputPortConfig<int>("totalCount",    _HELP("Sum of all the times any of the ports have been set, since last reset.")),
  1470.                         OutputPortConfig<bool>("portTrigger",  _HELP("triggered when port count reaches port threshold.")),
  1471.                         OutputPortConfig<bool>("totalTrigger", _HELP("triggered when total count reaches total threshold.")),
  1472.                         { 0 }
  1473.                 };
  1474.                 config.sDescription = _HELP("Counts the number of activated 'in' ports. Allows designers to, for example, trigger an action when 7 out of 12 entities have died");
  1475.                 config.pInputPorts = in_config;
  1476.                 config.pOutputPorts = out_config;
  1477.                 config.SetCategory(EFLN_ADVANCED);
  1478.         }
  1479.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1480.         {
  1481.                 switch (event)
  1482.                 {
  1483.                 case eFE_Initialize:
  1484.                 case eFE_Activate:
  1485.  
  1486.                         //--- Reset?
  1487.                         if (IsPortActive(pActInfo, 0) || (event == eFE_Initialize))
  1488.                         {
  1489.                                 Reset();
  1490.                         }
  1491.  
  1492.                         //--- Any in ports activated?
  1493.                         int iPort;
  1494.                         int nPorts = m_nPorts;
  1495.                         int nTotal = m_nTotal;
  1496.                         for (iPort = 0; iPort < PORT_COUNT; ++iPort)
  1497.                         {
  1498.                                 if (IsPortActive(pActInfo, iPort + 3))
  1499.                                 {
  1500.                                         if (!m_abPorts[iPort])
  1501.                                         {
  1502.                                                 m_abPorts[iPort] = true;
  1503.                                                 ++nPorts;
  1504.                                         }
  1505.                                         ++nTotal;
  1506.                                 }
  1507.                         }
  1508.  
  1509.                         //--- Check triggers
  1510.                         if (!m_bPortTriggered && (nPorts >= GetPortInt(pActInfo, 1)))
  1511.                         {
  1512.                                 m_bPortTriggered = true;
  1513.                                 ActivateOutput(pActInfo, 2, m_bPortTriggered);
  1514.                         }
  1515.                         if (!m_bTotalTriggered && (nTotal >= GetPortInt(pActInfo, 2)))
  1516.                         {
  1517.                                 m_bTotalTriggered = true;
  1518.                                 ActivateOutput(pActInfo, 3, m_bTotalTriggered);
  1519.                         }
  1520.                         //--- Output any changed totals
  1521.                         if (nPorts != m_nPorts)
  1522.                         {
  1523.                                 m_nPorts = nPorts;
  1524.                                 ActivateOutput(pActInfo, 0, m_nPorts);
  1525.                         }
  1526.                         if (nTotal != m_nTotal)
  1527.                         {
  1528.                                 m_nTotal = nTotal;
  1529.                                 ActivateOutput(pActInfo, 1, m_nTotal);
  1530.                         }
  1531.                         break;
  1532.                 }
  1533.         };
  1534.  
  1535.         void Serialize(SActivationInfo*, TSerialize ser)
  1536.         {
  1537.                 ser.BeginGroup("Local");
  1538.                 ser.Value("m_nPorts", m_nPorts);
  1539.                 ser.Value("m_nTotal", m_nTotal);
  1540.                 ser.Value("m_bPortTriggered", m_bPortTriggered);
  1541.                 ser.Value("m_bTotalTriggered", m_bTotalTriggered);
  1542.                 if (ser.IsWriting())
  1543.                 {
  1544.                         std::vector<bool> ab(m_abPorts, m_abPorts + PORT_COUNT);
  1545.                         ser.Value("m_abPorts", ab);
  1546.                 }
  1547.                 else
  1548.                 {
  1549.                         memset((void*)m_abPorts, 0, sizeof(m_abPorts)); // clear them in case we can't read all values
  1550.                         std::vector<bool> ab;
  1551.                         ser.Value("m_abPorts", ab);
  1552.                         std::copy(ab.begin(), ab.end(), m_abPorts);
  1553.                 }
  1554.                 ser.EndGroup();
  1555.         }
  1556.  
  1557.         virtual void GetMemoryUsage(ICrySizer* s) const
  1558.         {
  1559.                 s->Add(*this);
  1560.         }
  1561.  
  1562. private:
  1563.         int  m_nPorts;
  1564.         int  m_nTotal;
  1565.         bool m_bPortTriggered;
  1566.         bool m_bTotalTriggered;
  1567.         bool m_abPorts[PORT_COUNT];
  1568.  
  1569.         void Reset()
  1570.         {
  1571.                 m_nPorts = 0;
  1572.                 m_nTotal = 0;
  1573.                 m_bPortTriggered = false;
  1574.                 m_bTotalTriggered = false;
  1575.                 memset((void*)m_abPorts, 0, sizeof(m_abPorts));
  1576.         }
  1577. };
  1578. //////////////////////////////////////////////////////////////////////////
  1579. class CFlowNode_Random : public CFlowBaseNode<eNCT_Singleton>
  1580. {
  1581. public:
  1582.         CFlowNode_Random(SActivationInfo* pActInfo) {}
  1583.  
  1584.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1585.         {
  1586.                 static const SInputPortConfig in_config[] = {
  1587.                         InputPortConfig_Void("generate", _HELP("generate a random number between min and max")),
  1588.                         InputPortConfig<float>("min",    _HELP("minimum value of the random number")),
  1589.                         InputPortConfig<float>("max",    _HELP("maximum value of the random number")),
  1590.                         { 0 }
  1591.                 };
  1592.                 static const SOutputPortConfig out_config[] = {
  1593.                         OutputPortConfig<float>("out",      _HELP("random number between min and max")),
  1594.                         OutputPortConfig<int>("outRounded", _HELP("[out] but rounded to next integer value")),
  1595.                         { 0 }
  1596.                 };
  1597.                 config.pInputPorts = in_config;
  1598.                 config.pOutputPorts = out_config;
  1599.                 config.SetCategory(EFLN_APPROVED);
  1600.         }
  1601.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1602.         {
  1603.                 switch (event)
  1604.                 {
  1605.                 case eFE_Activate:
  1606.                         if (IsPortActive(pActInfo, 0))
  1607.                         {
  1608.                         case eFE_Initialize:
  1609.                                 float min = GetPortFloat(pActInfo, 1);
  1610.                                 float max = GetPortFloat(pActInfo, 2);
  1611.                                 float f = cry_random(min, max);
  1612.                                 ActivateOutput(pActInfo, 0, f);
  1613.                                 ActivateOutput(pActInfo, 1, int_round(f));
  1614.                         }
  1615.                         break;
  1616.                 }
  1617.         };
  1618.  
  1619.         virtual void GetMemoryUsage(ICrySizer* s) const
  1620.         {
  1621.                 s->Add(*this);
  1622.         }
  1623. };
  1624.  
  1625. //////////////////////////////////////////////////////////////////////////
  1626. class CFlowNode_Clamp : public CFlowBaseNode<eNCT_Singleton>
  1627. {
  1628. public:
  1629.         CFlowNode_Clamp(SActivationInfo* pActInfo) {}
  1630.  
  1631.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1632.         {
  1633.                 static const SInputPortConfig in_config[] = {
  1634.                         InputPortConfig<float>("in"),
  1635.                         InputPortConfig<float>("min"),
  1636.                         InputPortConfig<float>("max"),
  1637.                         { 0 }
  1638.                 };
  1639.                 static const SOutputPortConfig out_config[] = {
  1640.                         OutputPortConfig<float>("out"),
  1641.                         { 0 }
  1642.                 };
  1643.                 config.pInputPorts = in_config;
  1644.                 config.pOutputPorts = out_config;
  1645.                 config.SetCategory(EFLN_APPROVED);
  1646.         }
  1647.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1648.         {
  1649.                 switch (event)
  1650.                 {
  1651.                 case eFE_Initialize:
  1652.                 case eFE_Activate:
  1653.                         {
  1654.                                 float in = GetPortFloat(pActInfo, 0);
  1655.                                 float min = GetPortFloat(pActInfo, 1);
  1656.                                 float max = GetPortFloat(pActInfo, 2);
  1657.                                 ActivateOutput(pActInfo, 0, clamp_tpl(in, min, max));
  1658.                         }
  1659.                         break;
  1660.                 }
  1661.         };
  1662.  
  1663.         virtual void GetMemoryUsage(ICrySizer* s) const
  1664.         {
  1665.                 s->Add(*this);
  1666.         }
  1667. };
  1668.  
  1669. //////////////////////////////////////////////////////////////////////////
  1670. class CFlowNode_ClampVec3 : public CFlowBaseNode<eNCT_Singleton>
  1671. {
  1672. public:
  1673.         CFlowNode_ClampVec3(SActivationInfo* pActInfo) {}
  1674.  
  1675.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1676.         {
  1677.                 static const SInputPortConfig in_config[] = {
  1678.                         InputPortConfig<Vec3>("in"),
  1679.                         InputPortConfig<Vec3>("min"),
  1680.                         InputPortConfig<Vec3>("max"),
  1681.                         { 0 }
  1682.                 };
  1683.                 static const SOutputPortConfig out_config[] = {
  1684.                         OutputPortConfig<Vec3>("out"),
  1685.                         { 0 }
  1686.                 };
  1687.                 config.pInputPorts = in_config;
  1688.                 config.pOutputPorts = out_config;
  1689.                 config.SetCategory(EFLN_APPROVED);
  1690.         }
  1691.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1692.         {
  1693.                 switch (event)
  1694.                 {
  1695.                 case eFE_Initialize:
  1696.                 case eFE_Activate:
  1697.                         {
  1698.                                 Vec3 in = GetPortVec3(pActInfo, 0);
  1699.                                 Vec3 min = GetPortVec3(pActInfo, 1);
  1700.                                 Vec3 max = GetPortVec3(pActInfo, 2);
  1701.                                 ActivateOutput(pActInfo, 0, Vec3(clamp_tpl(in.x, min.x, max.x), clamp_tpl(in.y, min.y, max.y), clamp_tpl(in.z, min.z, max.z)));
  1702.                         }
  1703.                         break;
  1704.                 }
  1705.         };
  1706.  
  1707.         virtual void GetMemoryUsage(ICrySizer* s) const
  1708.         {
  1709.                 s->Add(*this);
  1710.         }
  1711. };
  1712.  
  1713. //////////////////////////////////////////////////////////////////////////
  1714. class CFlowNode_SetVec3 : public CFlowBaseNode<eNCT_Singleton>
  1715. {
  1716. public:
  1717.         CFlowNode_SetVec3(SActivationInfo* pActInfo) {}
  1718.  
  1719.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1720.         {
  1721.                 static const SInputPortConfig in_config[] = {
  1722.                         InputPortConfig_Void("Set", _HELP("Trigger to output")),
  1723.                         InputPortConfig<Vec3>("In", _HELP("Value to be set on output")),
  1724.                         { 0 }
  1725.                 };
  1726.                 static const SOutputPortConfig out_config[] = {
  1727.                         OutputPortConfig<Vec3>("Out"),
  1728.                         { 0 }
  1729.                 };
  1730.                 config.sDescription = _HELP("Send input value to the output when event on set port is received.");
  1731.                 config.pInputPorts = in_config;
  1732.                 config.pOutputPorts = out_config;
  1733.                 config.SetCategory(EFLN_APPROVED); // POLICY-CHANGE: don't send to output on initialize
  1734.         }
  1735.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  1736.         {
  1737.                 switch (evt)
  1738.                 {
  1739.                 case eFE_Activate:
  1740.                         if (IsPortActive(pActInfo, 0))
  1741.                         {
  1742.                                 ActivateOutput(pActInfo, 0, GetPortVec3(pActInfo, 1));
  1743.                         }
  1744.                         break;
  1745.                 }
  1746.         };
  1747.  
  1748.         virtual void GetMemoryUsage(ICrySizer* s) const
  1749.         {
  1750.                 s->Add(*this);
  1751.         }
  1752. };
  1753.  
  1754. //////////////////////////////////////////////////////////////////////////
  1755. class CFlowNode_SetColor : public CFlowBaseNode<eNCT_Singleton>
  1756. {
  1757. public:
  1758.         CFlowNode_SetColor(SActivationInfo* pActInfo) {}
  1759.  
  1760.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1761.         {
  1762.                 static const SInputPortConfig in_config[] = {
  1763.                         InputPortConfig_Void("Set",       _HELP("Trigger to output")),
  1764.                         InputPortConfig<Vec3>("color_In", _HELP("Color to be set on output")),
  1765.                         { 0 }
  1766.                 };
  1767.                 static const SOutputPortConfig out_config[] = {
  1768.                         OutputPortConfig<Vec3>("Out"),
  1769.                         { 0 }
  1770.                 };
  1771.                 config.sDescription = _HELP("Send input value to the output when event on set port is received.");
  1772.                 config.pInputPorts = in_config;
  1773.                 config.pOutputPorts = out_config;
  1774.                 config.SetCategory(EFLN_APPROVED);
  1775.         }
  1776.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  1777.         {
  1778.                 switch (evt)
  1779.                 {
  1780.                 case eFE_Activate:
  1781.                 case eFE_Initialize:
  1782.                         if (IsPortActive(pActInfo, 0))
  1783.                         {
  1784.                                 ActivateOutput(pActInfo, 0, GetPortVec3(pActInfo, 1));
  1785.                         }
  1786.                         break;
  1787.                 }
  1788.         };
  1789.  
  1790.         virtual void GetMemoryUsage(ICrySizer* s) const
  1791.         {
  1792.                 s->Add(*this);
  1793.         }
  1794. };
  1795.  
  1796. //////////////////////////////////////////////////////////////////////////
  1797. class CFlowNode_ToVec3 : public CFlowBaseNode<eNCT_Singleton>
  1798. {
  1799. public:
  1800.         CFlowNode_ToVec3(SActivationInfo* pActInfo) {}
  1801.  
  1802.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1803.         {
  1804.                 static const SInputPortConfig in_config[] = {
  1805.                         InputPortConfig<float>("x"),
  1806.                         InputPortConfig<float>("y"),
  1807.                         InputPortConfig<float>("z"),
  1808.                         { 0 }
  1809.                 };
  1810.                 static const SOutputPortConfig out_config[] = {
  1811.                         OutputPortConfig<Vec3>("vec3"),
  1812.                         { 0 }
  1813.                 };
  1814.                 config.pInputPorts = in_config;
  1815.                 config.pOutputPorts = out_config;
  1816.                 config.SetCategory(EFLN_APPROVED);
  1817.         }
  1818.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1819.         {
  1820.                 switch (event)
  1821.                 {
  1822.                 case eFE_Activate:
  1823.                 case eFE_Initialize:
  1824.                         float x = GetPortFloat(pActInfo, 0);
  1825.                         float y = GetPortFloat(pActInfo, 1);
  1826.                         float z = GetPortFloat(pActInfo, 2);
  1827.                         ActivateOutput(pActInfo, 0, Vec3(x, y, z));
  1828.                         break;
  1829.                 }
  1830.         };
  1831.  
  1832.         virtual void GetMemoryUsage(ICrySizer* s) const
  1833.         {
  1834.                 s->Add(*this);
  1835.         }
  1836. };
  1837.  
  1838. //////////////////////////////////////////////////////////////////////////
  1839. class CFlowNode_ToBoolean : public CFlowBaseNode<eNCT_Singleton>
  1840. {
  1841. public:
  1842.         CFlowNode_ToBoolean(SActivationInfo* pActInfo) {}
  1843.  
  1844.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1845.         {
  1846.                 static const SInputPortConfig in_config[] = {
  1847.                         InputPortConfig_Void("true",  _HELP("Will output true when event on this port received")),
  1848.                         InputPortConfig_Void("false", _HELP("Will output false when event on this port received")),
  1849.                         { 0 }
  1850.                 };
  1851.                 static const SOutputPortConfig out_config[] = {
  1852.                         OutputPortConfig<bool>("out", _HELP("Output true or false depending on the input ports")),
  1853.                         { 0 }
  1854.                 };
  1855.                 config.sDescription = _HELP("Output true or false depending on the input ports");
  1856.                 config.pInputPorts = in_config;
  1857.                 config.pOutputPorts = out_config;
  1858.                 config.SetCategory(EFLN_APPROVED); // No Longer output false on Initialize
  1859.         }
  1860.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1861.         {
  1862.                 switch (event)
  1863.                 {
  1864.                 case eFE_Activate:
  1865.                         if (IsPortActive(pActInfo, 0))
  1866.                                 ActivateOutput(pActInfo, 0, true);
  1867.                         else if (IsPortActive(pActInfo, 1))
  1868.                                 ActivateOutput(pActInfo, 0, false);
  1869.                         break;
  1870.                 }
  1871.         };
  1872.  
  1873.         virtual void GetMemoryUsage(ICrySizer* s) const
  1874.         {
  1875.                 s->Add(*this);
  1876.         }
  1877. };
  1878.  
  1879. //////////////////////////////////////////////////////////////////////////
  1880. class CFlowNode_FromBoolean : public CFlowBaseNode<eNCT_Singleton>
  1881. {
  1882. public:
  1883.         CFlowNode_FromBoolean(SActivationInfo* pActInfo) {}
  1884.  
  1885.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1886.         {
  1887.                 static const SInputPortConfig in_config[] = {
  1888.                         InputPortConfig<bool>("Value", _HELP("Boolean value")),
  1889.                         { 0 }
  1890.                 };
  1891.                 static const SOutputPortConfig out_config[] = {
  1892.                         OutputPortConfig_Void("False", _HELP("Triggered if Boolean was False")),
  1893.                         OutputPortConfig_Void("True",  _HELP("Triggered if Boolean was True")),
  1894.                         { 0 }
  1895.                 };
  1896.                 config.sDescription = _HELP("Boolean switch");
  1897.                 config.pInputPorts = in_config;
  1898.                 config.pOutputPorts = out_config;
  1899.                 config.SetCategory(EFLN_APPROVED); // No Longer output false on Initialize
  1900.         }
  1901.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1902.         {
  1903.                 switch (event)
  1904.                 {
  1905.                 case eFE_Activate:
  1906.                         const bool bValue = GetPortBool(pActInfo, 0);
  1907.                         ActivateOutput(pActInfo, bValue ? 1 : 0, true);
  1908.                         break;
  1909.                 }
  1910.         };
  1911.  
  1912.         virtual void GetMemoryUsage(ICrySizer* s) const
  1913.         {
  1914.                 s->Add(*this);
  1915.         }
  1916. };
  1917.  
  1918. //////////////////////////////////////////////////////////////////////////
  1919. class CFlowNode_FromVec3 : public CFlowBaseNode<eNCT_Singleton>
  1920. {
  1921. public:
  1922.         CFlowNode_FromVec3(SActivationInfo* pActInfo) {}
  1923.  
  1924.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1925.         {
  1926.                 static const SInputPortConfig in_config[] = {
  1927.                         InputPortConfig<Vec3>("vec3"),
  1928.                         { 0 }
  1929.                 };
  1930.                 static const SOutputPortConfig out_config[] = {
  1931.                         OutputPortConfig<float>("x"),
  1932.                         OutputPortConfig<float>("y"),
  1933.                         OutputPortConfig<float>("z"),
  1934.                         { 0 }
  1935.                 };
  1936.                 config.pInputPorts = in_config;
  1937.                 config.pOutputPorts = out_config;
  1938.                 config.SetCategory(EFLN_APPROVED);
  1939.         }
  1940.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1941.         {
  1942.                 switch (event)
  1943.                 {
  1944.                 case eFE_Activate:
  1945.                 case eFE_Initialize:
  1946.                         Vec3 v = GetPortVec3(pActInfo, 0);
  1947.                         ActivateOutput(pActInfo, 0, v.x);
  1948.                         ActivateOutput(pActInfo, 1, v.y);
  1949.                         ActivateOutput(pActInfo, 2, v.z);
  1950.                         break;
  1951.                 }
  1952.         };
  1953.  
  1954.         virtual void GetMemoryUsage(ICrySizer* s) const
  1955.         {
  1956.                 s->Add(*this);
  1957.         }
  1958. };
  1959. //////////////////////////////////////////////////////////////////////////
  1960. class CFlowNode_SinCos : public CFlowBaseNode<eNCT_Singleton>
  1961. {
  1962. public:
  1963.         CFlowNode_SinCos(SActivationInfo* pActInfo) {}
  1964.  
  1965.         virtual void GetConfiguration(SFlowNodeConfig& config)
  1966.         {
  1967.                 static const SInputPortConfig in_config[] = {
  1968.                         InputPortConfig<float>("in"),
  1969.                         { 0 }
  1970.                 };
  1971.                 static const SOutputPortConfig out_config[] = {
  1972.                         OutputPortConfig<float>("sin"),
  1973.                         OutputPortConfig<float>("cos"),
  1974.                         { 0 }
  1975.                 };
  1976.                 config.pInputPorts = in_config;
  1977.                 config.pOutputPorts = out_config;
  1978.                 config.SetCategory(EFLN_APPROVED);
  1979.         }
  1980.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  1981.         {
  1982.                 switch (event)
  1983.                 {
  1984.                 case eFE_Activate:
  1985.                 case eFE_Initialize:
  1986.                         float x = GetPortFloat(pActInfo, 0);
  1987.                         ActivateOutput(pActInfo, 0, sinf(x));
  1988.                         ActivateOutput(pActInfo, 1, cosf(x));
  1989.                         break;
  1990.                 }
  1991.         };
  1992.  
  1993.         virtual void GetMemoryUsage(ICrySizer* s) const
  1994.         {
  1995.                 s->Add(*this);
  1996.         }
  1997. };
  1998.  
  1999. //////////////////////////////////////////////////////////////////////////
  2000. class CFlowNode_AnglesToDir : public CFlowBaseNode<eNCT_Singleton>
  2001. {
  2002. public:
  2003.         CFlowNode_AnglesToDir(SActivationInfo* pActInfo) {}
  2004.  
  2005.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2006.         {
  2007.                 static const SInputPortConfig in_config[] = {
  2008.                         InputPortConfig<Vec3>("angles", _HELP("Input angles.")),
  2009.                         { 0 }
  2010.                 };
  2011.                 static const SOutputPortConfig out_config[] = {
  2012.                         OutputPortConfig<Vec3>("dir",   _HELP("Output direction vector.")),
  2013.                         OutputPortConfig<float>("roll", _HELP("Output roll.")),
  2014.                         { 0 }
  2015.                 };
  2016.                 config.pInputPorts = in_config;
  2017.                 config.pOutputPorts = out_config;
  2018.                 config.SetCategory(EFLN_APPROVED);
  2019.         }
  2020.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2021.         {
  2022.                 switch (event)
  2023.                 {
  2024.                 case eFE_Activate:
  2025.                 case eFE_Initialize:
  2026.                         {
  2027.                                 Ang3 angles(DEG2RAD(GetPortVec3(pActInfo, 0)));
  2028.                                 Vec3 dir(Matrix33::CreateRotationXYZ(angles).GetColumn(1));
  2029.  
  2030.                                 ActivateOutput(pActInfo, 0, dir);
  2031.                                 ActivateOutput(pActInfo, 1, angles.y);
  2032.                         }
  2033.                 }
  2034.         };
  2035.  
  2036.         virtual void GetMemoryUsage(ICrySizer* s) const
  2037.         {
  2038.                 s->Add(*this);
  2039.         }
  2040. };
  2041. //////////////////////////////////////////////////////////////////////////
  2042. class CFlowNode_DirToAngles : public CFlowBaseNode<eNCT_Singleton>
  2043. {
  2044. public:
  2045.         CFlowNode_DirToAngles(SActivationInfo* pActInfo) {}
  2046.  
  2047.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2048.         {
  2049.                 static const SInputPortConfig in_config[] = {
  2050.                         InputPortConfig<Vec3>("dir",   _HELP("Input direction.")),
  2051.                         InputPortConfig<float>("roll", _HELP("Input roll.")),
  2052.                         { 0 }
  2053.                 };
  2054.                 static const SOutputPortConfig out_config[] = {
  2055.                         OutputPortConfig<Vec3>("angles", "Output angles."),
  2056.                         { 0 }
  2057.                 };
  2058.                 config.pInputPorts = in_config;
  2059.                 config.pOutputPorts = out_config;
  2060.                 config.SetCategory(EFLN_APPROVED);
  2061.         }
  2062.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2063.         {
  2064.                 switch (event)
  2065.                 {
  2066.                 case eFE_Activate:
  2067.                 case eFE_Initialize:
  2068.                         {
  2069.                                 Vec3 dir(GetPortVec3(pActInfo, 0));
  2070.                                 float roll(DEG2RAD(GetPortFloat(pActInfo, 1)));
  2071.                                 Ang3 angles(Ang3::GetAnglesXYZ(Matrix33::CreateOrientation(dir, Vec3(0, 0, 1), roll)));
  2072.                                 ActivateOutput(pActInfo, 0, RAD2DEG(Vec3(angles)));
  2073.                         }
  2074.                 }
  2075.         };
  2076.  
  2077.         virtual void GetMemoryUsage(ICrySizer* s) const
  2078.         {
  2079.                 s->Add(*this);
  2080.         }
  2081. };
  2082.  
  2083. //////////////////////////////////////////////////////////////////////////
  2084. class CFlowNode_SetNumber : public CFlowBaseNode<eNCT_Singleton>
  2085. {
  2086. public:
  2087.         CFlowNode_SetNumber(SActivationInfo* pActInfo) {}
  2088.  
  2089.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2090.         {
  2091.                 static const SInputPortConfig in_config[] = {
  2092.                         InputPortConfig_Void("set",  _HELP("Send value to output when receiving event on this port")),
  2093.                         InputPortConfig<float>("in", _HELP("Value to be set on output")),
  2094.                         { 0 }
  2095.                 };
  2096.                 static const SOutputPortConfig out_config[] = {
  2097.                         OutputPortConfig<float>("out"),
  2098.                         { 0 }
  2099.                 };
  2100.                 config.sDescription = _HELP("Send a float input value to the output when event on set port is received");
  2101.                 config.pInputPorts = in_config;
  2102.                 config.pOutputPorts = out_config;
  2103.                 config.SetCategory(EFLN_APPROVED); // POLICY-CHANGE: don't send to output on initialize
  2104.         }
  2105.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  2106.         {
  2107.                 switch (evt)
  2108.                 {
  2109.                 case eFE_Activate:
  2110.                         if (IsPortActive(pActInfo, 0))
  2111.                         {
  2112.                                 ActivateOutput(pActInfo, 0, GetPortFloat(pActInfo, 1));
  2113.                         }
  2114.                         break;
  2115.                 }
  2116.         };
  2117.  
  2118.         virtual void GetMemoryUsage(ICrySizer* s) const
  2119.         {
  2120.                 s->Add(*this);
  2121.         }
  2122. };
  2123.  
  2124. //////////////////////////////////////////////////////////////////////////
  2125. class CFlowNode_SetInteger : public CFlowBaseNode<eNCT_Singleton>
  2126. {
  2127. public:
  2128.         CFlowNode_SetInteger(SActivationInfo* pActInfo) {}
  2129.  
  2130.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2131.         {
  2132.                 static const SInputPortConfig in_config[] = {
  2133.                         InputPortConfig_Void("set", _HELP("Send value to output when receiving event on this port")),
  2134.                         InputPortConfig<int>("in",  _HELP("Value to be set on output")),
  2135.                         { 0 }
  2136.                 };
  2137.                 static const SOutputPortConfig out_config[] = {
  2138.                         OutputPortConfig<int>("out"),
  2139.                         { 0 }
  2140.                 };
  2141.                 config.sDescription = _HELP("Send an integer input value to the output when event on set port is received");
  2142.                 config.pInputPorts = in_config;
  2143.                 config.pOutputPorts = out_config;
  2144.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  2145.                 config.SetCategory(EFLN_APPROVED); // POLICY-CHANGE: don't send to output on initialize
  2146.         }
  2147.         virtual void ProcessEvent(EFlowEvent evt, SActivationInfo* pActInfo)
  2148.         {
  2149.                 switch (evt)
  2150.                 {
  2151.                 case eFE_Activate:
  2152.                         if (IsPortActive(pActInfo, 0))
  2153.                         {
  2154.                                 ActivateOutput(pActInfo, 0, GetPortInt(pActInfo, 1));
  2155.                         }
  2156.                         break;
  2157.                 }
  2158.         };
  2159.  
  2160.         virtual void GetMemoryUsage(ICrySizer* s) const
  2161.         {
  2162.                 s->Add(*this);
  2163.         }
  2164. };
  2165.  
  2166. //////////////////////////////////////////////////////////////////////////
  2167. class CFlowNode_Sin : public CFlowBaseNode<eNCT_Singleton>
  2168. {
  2169. public:
  2170.         CFlowNode_Sin(SActivationInfo* pActInfo) {}
  2171.  
  2172.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2173.         {
  2174.                 static const SInputPortConfig in_config[] = {
  2175.                         InputPortConfig<float>("in", _HELP("out=sinus(in) in degrees")),
  2176.                         { 0 }
  2177.                 };
  2178.                 static const SOutputPortConfig out_config[] = {
  2179.                         OutputPortConfig<float>("out", _HELP("out=sinus(in) in degrees")),
  2180.                         { 0 }
  2181.                 };
  2182.                 config.sDescription = _HELP("Outputs sinus of the input in degrees");
  2183.                 config.pInputPorts = in_config;
  2184.                 config.pOutputPorts = out_config;
  2185.                 config.SetCategory(EFLN_APPROVED);
  2186.         }
  2187.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2188.         {
  2189.                 switch (event)
  2190.                 {
  2191.                 case eFE_Activate:
  2192.                 case eFE_Initialize:
  2193.                         {
  2194.                                 float a = GetPortFloat(pActInfo, 0);
  2195.                                 float out = sinf(DEG2RAD(a));
  2196.                                 ActivateOutput(pActInfo, 0, out);
  2197.                         }
  2198.                 }
  2199.         };
  2200.  
  2201.         virtual void GetMemoryUsage(ICrySizer* s) const
  2202.         {
  2203.                 s->Add(*this);
  2204.         }
  2205. };
  2206. //////////////////////////////////////////////////////////////////////////
  2207. class CFlowNode_Cos : public CFlowBaseNode<eNCT_Singleton>
  2208. {
  2209. public:
  2210.         CFlowNode_Cos(SActivationInfo* pActInfo) {}
  2211.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2212.         {
  2213.                 static const SInputPortConfig in_config[] = {
  2214.                         InputPortConfig<float>("in", _HELP("out=cosinus(in) in degrees")),
  2215.                         { 0 }
  2216.                 };
  2217.                 static const SOutputPortConfig out_config[] = {
  2218.                         OutputPortConfig<float>("out", _HELP("out=cosinus(in) in degrees")),
  2219.                         { 0 }
  2220.                 };
  2221.                 config.sDescription = _HELP("Outputs cosinus of the input in degrees");
  2222.                 config.pInputPorts = in_config;
  2223.                 config.pOutputPorts = out_config;
  2224.                 config.SetCategory(EFLN_APPROVED);
  2225.         }
  2226.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2227.         {
  2228.                 switch (event)
  2229.                 {
  2230.                 case eFE_Activate:
  2231.                 case eFE_Initialize:
  2232.                         {
  2233.                                 float a = GetPortFloat(pActInfo, 0);
  2234.                                 float out = cos(DEG2RAD(a));
  2235.                                 ActivateOutput(pActInfo, 0, out);
  2236.                         }
  2237.                 }
  2238.         };
  2239.  
  2240.         virtual void GetMemoryUsage(ICrySizer* s) const
  2241.         {
  2242.                 s->Add(*this);
  2243.         }
  2244. };
  2245. //////////////////////////////////////////////////////////////////////////
  2246. class CFlowNode_Tan : public CFlowBaseNode<eNCT_Singleton>
  2247. {
  2248. public:
  2249.         CFlowNode_Tan(SActivationInfo* pActInfo) {}
  2250.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2251.         {
  2252.                 static const SInputPortConfig in_config[] = {
  2253.                         InputPortConfig<float>("in", _HELP("out=tangent(in) in degrees")),
  2254.                         { 0 }
  2255.                 };
  2256.                 static const SOutputPortConfig out_config[] = {
  2257.                         OutputPortConfig<float>("out", _HELP("out=tangent(in) in degrees")),
  2258.                         { 0 }
  2259.                 };
  2260.                 config.sDescription = _HELP("Outputs tangent of the input in degrees");
  2261.                 config.pInputPorts = in_config;
  2262.                 config.pOutputPorts = out_config;
  2263.                 config.SetCategory(EFLN_APPROVED);
  2264.         }
  2265.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2266.         {
  2267.                 switch (event)
  2268.                 {
  2269.                 case eFE_Activate:
  2270.                 case eFE_Initialize:
  2271.                         {
  2272.                                 float a = GetPortFloat(pActInfo, 0);
  2273.                                 float out = tanf(DEG2RAD(a));
  2274.                                 ActivateOutput(pActInfo, 0, out);
  2275.                         }
  2276.                 }
  2277.         };
  2278.  
  2279.         virtual void GetMemoryUsage(ICrySizer* s) const
  2280.         {
  2281.                 s->Add(*this);
  2282.         }
  2283. };
  2284.  
  2285. //////////////////////////////////////////////////////////////////////////
  2286. class CFlowNode_SinInverse : public CFlowBaseNode<eNCT_Singleton>
  2287. {
  2288. public:
  2289.         CFlowNode_SinInverse(SActivationInfo* pActInfo) {}
  2290.  
  2291.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2292.         {
  2293.                 static const SInputPortConfig in_config[] = {
  2294.                         InputPortConfig<float>("in", _HELP("out=sinus_inverse(in) in degrees")),
  2295.                         { 0 }
  2296.                 };
  2297.                 static const SOutputPortConfig out_config[] = {
  2298.                         OutputPortConfig<float>("out", _HELP("out=sinus_inverse(in) in degrees")),
  2299.                         { 0 }
  2300.                 };
  2301.                 config.sDescription = _HELP("Outputs sinus inverse (arcsin) of the input in degrees");
  2302.                 config.pInputPorts = in_config;
  2303.                 config.pOutputPorts = out_config;
  2304.                 config.SetCategory(EFLN_APPROVED);
  2305.         }
  2306.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2307.         {
  2308.                 switch (event)
  2309.                 {
  2310.                 case eFE_Activate:
  2311.                 case eFE_Initialize:
  2312.                         {
  2313.                                 float a = clamp_tpl(GetPortFloat(pActInfo, 0), -1.0f, 1.0f);
  2314.                                 float out = RAD2DEG(asinf(a));
  2315.                                 ActivateOutput(pActInfo, 0, out);
  2316.                         }
  2317.                 }
  2318.         };
  2319.  
  2320.         virtual void GetMemoryUsage(ICrySizer* s) const
  2321.         {
  2322.                 s->Add(*this);
  2323.         }
  2324. };
  2325. //////////////////////////////////////////////////////////////////////////
  2326. class CFlowNode_CosInverse : public CFlowBaseNode<eNCT_Singleton>
  2327. {
  2328. public:
  2329.         CFlowNode_CosInverse(SActivationInfo* pActInfo) {}
  2330.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2331.         {
  2332.                 static const SInputPortConfig in_config[] = {
  2333.                         InputPortConfig<float>("in", _HELP("out=cosinus(in) in degrees")),
  2334.                         { 0 }
  2335.                 };
  2336.                 static const SOutputPortConfig out_config[] = {
  2337.                         OutputPortConfig<float>("out", _HELP("out=cosinus(in) in degrees")),
  2338.                         { 0 }
  2339.                 };
  2340.                 config.sDescription = _HELP("Outputs cosinus inverse (arccos) of the input in degrees");
  2341.                 config.pInputPorts = in_config;
  2342.                 config.pOutputPorts = out_config;
  2343.                 config.SetCategory(EFLN_APPROVED);
  2344.         }
  2345.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2346.         {
  2347.                 switch (event)
  2348.                 {
  2349.                 case eFE_Activate:
  2350.                 case eFE_Initialize:
  2351.                         {
  2352.                                 float a = clamp_tpl(GetPortFloat(pActInfo, 0), -1.0f, 1.0f);
  2353.                                 float out = RAD2DEG(acosf(a));
  2354.                                 ActivateOutput(pActInfo, 0, out);
  2355.                         }
  2356.                 }
  2357.         };
  2358.  
  2359.         virtual void GetMemoryUsage(ICrySizer* s) const
  2360.         {
  2361.                 s->Add(*this);
  2362.         }
  2363. };
  2364. //////////////////////////////////////////////////////////////////////////
  2365. class CFlowNode_TanInverse : public CFlowBaseNode<eNCT_Singleton>
  2366. {
  2367. public:
  2368.         CFlowNode_TanInverse(SActivationInfo* pActInfo) {}
  2369.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2370.         {
  2371.                 static const SInputPortConfig in_config[] = {
  2372.                         InputPortConfig<float>("in", _HELP("out=tangent_inverse(in) in degrees")),
  2373.                         { 0 }
  2374.                 };
  2375.                 static const SOutputPortConfig out_config[] = {
  2376.                         OutputPortConfig<float>("out", _HELP("out=tangent_inverse(in) in degrees")),
  2377.                         { 0 }
  2378.                 };
  2379.                 config.sDescription = _HELP("Outputs tangent inverse (arctan) of the input in degrees");
  2380.                 config.pInputPorts = in_config;
  2381.                 config.pOutputPorts = out_config;
  2382.                 config.SetCategory(EFLN_APPROVED);
  2383.         }
  2384.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2385.         {
  2386.                 switch (event)
  2387.                 {
  2388.                 case eFE_Activate:
  2389.                 case eFE_Initialize:
  2390.                         {
  2391.                                 float a = GetPortFloat(pActInfo, 0);
  2392.                                 float out = RAD2DEG(atanf(a));
  2393.                                 ActivateOutput(pActInfo, 0, out);
  2394.                         }
  2395.                 }
  2396.         };
  2397.  
  2398.         virtual void GetMemoryUsage(ICrySizer* s) const
  2399.         {
  2400.                 s->Add(*this);
  2401.         }
  2402. };
  2403.  
  2404. //////////////////////////////////////////////////////////////////////////
  2405. class CFlowNode_UpDownCounter : public CFlowBaseNode<eNCT_Instanced>
  2406. {
  2407.         int m_counter;
  2408.         int m_highLimit;
  2409.         int m_lowLimit;
  2410.  
  2411. public:
  2412.         CFlowNode_UpDownCounter(SActivationInfo* pActInfo)
  2413.         {
  2414.                 m_counter = 0;
  2415.                 m_highLimit = 10;
  2416.                 m_lowLimit = 0;
  2417.         }
  2418.  
  2419.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_UpDownCounter(pActInfo); }
  2420.  
  2421.         virtual void         Serialize(SActivationInfo* pActInfo, TSerialize ser)
  2422.         {
  2423.                 ser.Value("m_counter", m_counter);
  2424.                 ser.Value("m_lowLimit", m_lowLimit);
  2425.                 ser.Value("m_highLimit", m_highLimit);
  2426.         }
  2427.  
  2428.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2429.         {
  2430.                 static const SInputPortConfig in_config[] = {
  2431.                         InputPortConfig<int>("Preset",    _HELP("Preset value")),
  2432.                         InputPortConfig<int>("HighLimit", _HELP("Upper limit")),
  2433.                         InputPortConfig<int>("LowLimit",  _HELP("Low limit")),
  2434.                         InputPortConfig<bool>("Dec",      _HELP("Decrement")),
  2435.                         InputPortConfig<bool>("Inc",      _HELP("Increment")),
  2436.                         InputPortConfig<bool>("Wrap",     _HELP("The counter will wrap if TRUE")),
  2437.                         { 0 }
  2438.                 };
  2439.                 static const SOutputPortConfig out_config[] = {
  2440.                         OutputPortConfig<float>("out", _HELP("counter output")),
  2441.                         { 0 }
  2442.                 };
  2443.                 config.sDescription = _HELP("Implements an up/down counter");
  2444.                 config.pInputPorts = in_config;
  2445.                 config.pOutputPorts = out_config;
  2446.                 config.SetCategory(EFLN_ADVANCED);
  2447.         }
  2448.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2449.         {
  2450.                 switch (event)
  2451.                 {
  2452.                 case eFE_Activate:
  2453.                 case eFE_Initialize:
  2454.                         {
  2455.                                 if (IsPortActive(pActInfo, 0) || event == eFE_Initialize)
  2456.                                 {
  2457.                                         m_counter = GetPortInt(pActInfo, 0);
  2458.                                 }
  2459.                                 else
  2460.                                 {
  2461.                                         if (IsPortActive(pActInfo, 3))
  2462.                                                 m_counter--;
  2463.                                         if (IsPortActive(pActInfo, 4))
  2464.                                                 m_counter++;
  2465.                                 }
  2466.                                 if (IsPortActive(pActInfo, 1))
  2467.                                         m_highLimit = GetPortInt(pActInfo, 1);
  2468.                                 if (IsPortActive(pActInfo, 2))
  2469.                                         m_lowLimit = GetPortInt(pActInfo, 2);
  2470.                                 if (m_counter > m_highLimit)
  2471.                                 {
  2472.                                         if (GetPortBool(pActInfo, 5) == true)
  2473.                                                 m_counter = m_lowLimit;
  2474.                                         else
  2475.                                                 m_counter = m_highLimit;
  2476.                                 }
  2477.                                 if (m_counter < m_lowLimit)
  2478.                                 {
  2479.                                         if (GetPortBool(pActInfo, 5) == true)
  2480.                                                 m_counter = m_highLimit;
  2481.                                         else
  2482.                                                 m_counter = m_lowLimit;
  2483.                                 }
  2484.                                 ActivateOutput(pActInfo, 0, m_counter);
  2485.                         }
  2486.                         break;
  2487.                 }
  2488.         }
  2489.  
  2490.         virtual void GetMemoryUsage(ICrySizer* s) const
  2491.         {
  2492.                 s->Add(*this);
  2493.         }
  2494. };
  2495.  
  2496. class CFlowNode_TrigArcSin : public CFlowBaseNode<eNCT_Singleton>
  2497. {
  2498.         enum EInputPorts
  2499.         {
  2500.                 EIP_In,
  2501.         };
  2502.  
  2503.         enum EOutputPorts
  2504.         {
  2505.                 EOP_Out,
  2506.         };
  2507.  
  2508. public:
  2509.         CFlowNode_TrigArcSin(SActivationInfo* pActInfo) {}
  2510.  
  2511.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2512.         {
  2513.                 static const SInputPortConfig inputs[] = {
  2514.                         InputPortConfig<float>("in", 0.0f, _HELP("out = arcsinus(in) in degrees")),
  2515.                         { 0 }
  2516.                 };
  2517.  
  2518.                 static const SOutputPortConfig outputs[] = {
  2519.                         OutputPortConfig<float>("out", _HELP("out = arcsinus(in) in degrees")),
  2520.                         { 0 }
  2521.                 };
  2522.  
  2523.                 // Fill in configuration
  2524.                 config.pInputPorts = inputs;
  2525.                 config.pOutputPorts = outputs;
  2526.                 config.sDescription = _HELP("Outputs arcsinus of the input in degrees");
  2527.                 config.SetCategory(EFLN_APPROVED);
  2528.         }
  2529.  
  2530.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2531.         {
  2532.                 switch (event)
  2533.                 {
  2534.                 case eFE_Activate:
  2535.                         {
  2536.                                 // Check which port was activated
  2537.                                 if (IsPortActive(pActInfo, EIP_In))
  2538.                                 {
  2539.                                         float answer = asin_tpl(DEG2RAD(GetPortFloat(pActInfo, EIP_In)));
  2540.                                         if (_isnan(answer)) answer = 0.0f;
  2541.                                         ActivateOutput(pActInfo, EOP_Out, RAD2DEG(answer));
  2542.                                 }
  2543.                         }
  2544.                         break;
  2545.                 }
  2546.         }
  2547.  
  2548.         virtual void GetMemoryUsage(ICrySizer* s) const
  2549.         {
  2550.                 s->Add(*this);
  2551.         }
  2552. };
  2553.  
  2554. ////////////////////////////////////////////////////
  2555. class CFlowNode_TrigArcCos : public CFlowBaseNode<eNCT_Singleton>
  2556. {
  2557.         enum EInputPorts
  2558.         {
  2559.                 EIP_In,
  2560.         };
  2561.  
  2562.         enum EOutputPorts
  2563.         {
  2564.                 EOP_Out,
  2565.         };
  2566.  
  2567. public:
  2568.         CFlowNode_TrigArcCos(SActivationInfo* pActInfo) {}
  2569.  
  2570.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2571.         {
  2572.                 static const SInputPortConfig inputs[] = {
  2573.                         InputPortConfig<float>("in", 0.0f, _HELP("out = arccosinus(in) in degrees")),
  2574.                         { 0 }
  2575.                 };
  2576.  
  2577.                 static const SOutputPortConfig outputs[] = {
  2578.                         OutputPortConfig<float>("out", _HELP("out = arccosinus(in) in degrees")),
  2579.                         { 0 }
  2580.                 };
  2581.  
  2582.                 // Fill in configuration
  2583.                 config.pInputPorts = inputs;
  2584.                 config.pOutputPorts = outputs;
  2585.                 config.sDescription = _HELP("Outputs arccosinus of the input in degrees");
  2586.                 config.SetCategory(EFLN_APPROVED);
  2587.         }
  2588.  
  2589.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2590.         {
  2591.                 switch (event)
  2592.                 {
  2593.                 case eFE_Activate:
  2594.                         {
  2595.                                 // Check which port was activated
  2596.                                 if (IsPortActive(pActInfo, EIP_In))
  2597.                                 {
  2598.                                         float answer = acos_tpl(DEG2RAD(GetPortFloat(pActInfo, EIP_In)));
  2599.                                         if (_isnan(answer)) answer = 0.0f;
  2600.                                         ActivateOutput(pActInfo, EOP_Out, RAD2DEG(answer));
  2601.                                 }
  2602.                         }
  2603.                         break;
  2604.                 }
  2605.         }
  2606.  
  2607.         virtual void GetMemoryUsage(ICrySizer* s) const
  2608.         {
  2609.                 s->Add(*this);
  2610.         }
  2611. };
  2612.  
  2613. ////////////////////////////////////////////////////
  2614. class CFlowNode_TrigArcTan : public CFlowBaseNode<eNCT_Singleton>
  2615. {
  2616.         enum EInputPorts
  2617.         {
  2618.                 EIP_In,
  2619.         };
  2620.  
  2621.         enum EOutputPorts
  2622.         {
  2623.                 EOP_Out,
  2624.         };
  2625.  
  2626. public:
  2627.         CFlowNode_TrigArcTan(SActivationInfo* pActInfo) {}
  2628.  
  2629.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2630.         {
  2631.                 static const SInputPortConfig inputs[] = {
  2632.                         InputPortConfig<float>("in", 0.0f, _HELP("out = arctangens(in) in degrees")),
  2633.                         { 0 }
  2634.                 };
  2635.  
  2636.                 static const SOutputPortConfig outputs[] = {
  2637.                         OutputPortConfig<float>("out", _HELP("out = arctangens(in) in degrees")),
  2638.                         { 0 }
  2639.                 };
  2640.  
  2641.                 config.pInputPorts = inputs;
  2642.                 config.pOutputPorts = outputs;
  2643.                 config.sDescription = _HELP("Outputs arctangens of the input in degrees");
  2644.                 config.SetCategory(EFLN_APPROVED);
  2645.         }
  2646.  
  2647.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2648.         {
  2649.                 switch (event)
  2650.                 {
  2651.                 case eFE_Activate:
  2652.                         {
  2653.                                 // Check which port was activated
  2654.                                 if (IsPortActive(pActInfo, EIP_In))
  2655.                                 {
  2656.                                         float answer = atan_tpl(DEG2RAD(GetPortFloat(pActInfo, EIP_In)));
  2657.                                         if (_isnan(answer)) answer = 0.0f;
  2658.                                         ActivateOutput(pActInfo, EOP_Out, RAD2DEG(answer));
  2659.                                 }
  2660.                         }
  2661.                         break;
  2662.                 }
  2663.         }
  2664.  
  2665.         virtual void GetMemoryUsage(ICrySizer* s) const
  2666.         {
  2667.                 s->Add(*this);
  2668.         }
  2669. };
  2670.  
  2671. ////////////////////////////////////////////////////
  2672. class CFlowNode_Ceil : public CFlowBaseNode<eNCT_Singleton>
  2673. {
  2674.         enum EInputPorts
  2675.         {
  2676.                 EIP_In,
  2677.         };
  2678.  
  2679.         enum EOutputPorts
  2680.         {
  2681.                 EOP_Out,
  2682.         };
  2683.  
  2684. public:
  2685.         CFlowNode_Ceil(SActivationInfo* pActInfo) {}
  2686.  
  2687.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2688.         {
  2689.                 static const SInputPortConfig inputs[] = {
  2690.                         InputPortConfig<float>("A", 0.0f, _HELP("out = ceil(A)")),
  2691.                         { 0 }
  2692.                 };
  2693.  
  2694.                 static const SOutputPortConfig outputs[] = {
  2695.                         OutputPortConfig<float>("out", _HELP("out = ceil(A)")),
  2696.                         { 0 }
  2697.                 };
  2698.  
  2699.                 config.pInputPorts = inputs;
  2700.                 config.pOutputPorts = outputs;
  2701.                 config.sDescription = _HELP("Outputs ceiling of A");
  2702.                 config.SetCategory(EFLN_APPROVED);
  2703.         }
  2704.  
  2705.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2706.         {
  2707.                 switch (event)
  2708.                 {
  2709.                 case eFE_Activate:
  2710.                         {
  2711.                                 // Check which port was activated
  2712.                                 if (IsPortActive(pActInfo, EIP_In))
  2713.                                 {
  2714.                                         float answer = ceil_tpl(GetPortFloat(pActInfo, EIP_In));
  2715.                                         ActivateOutput(pActInfo, EOP_Out, answer);
  2716.                                 }
  2717.                         }
  2718.                         break;
  2719.                 }
  2720.         }
  2721.  
  2722.         virtual void GetMemoryUsage(ICrySizer* s) const
  2723.         {
  2724.                 s->Add(*this);
  2725.         }
  2726. };
  2727.  
  2728. ////////////////////////////////////////////////////
  2729. class CFlowNode_Floor : public CFlowBaseNode<eNCT_Singleton>
  2730. {
  2731.         enum EInputPorts
  2732.         {
  2733.                 EIP_In,
  2734.         };
  2735.  
  2736.         enum EOutputPorts
  2737.         {
  2738.                 EOP_Out,
  2739.         };
  2740.  
  2741. public:
  2742.         CFlowNode_Floor(SActivationInfo* pActInfo) {}
  2743.  
  2744.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2745.         {
  2746.                 static const SInputPortConfig inputs[] = {
  2747.                         InputPortConfig<float>("A", 0.0f, _HELP("out = floor(A)")),
  2748.                         { 0 }
  2749.                 };
  2750.  
  2751.                 static const SOutputPortConfig outputs[] = {
  2752.                         OutputPortConfig<float>("out", _HELP("out = floor(A)")),
  2753.                         { 0 }
  2754.                 };
  2755.  
  2756.                 config.pInputPorts = inputs;
  2757.                 config.pOutputPorts = outputs;
  2758.                 config.sDescription = _HELP("Outputs floor of A");
  2759.                 config.SetCategory(EFLN_APPROVED);
  2760.         }
  2761.  
  2762.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  2763.         {
  2764.                 switch (event)
  2765.                 {
  2766.                 case eFE_Activate:
  2767.                         {
  2768.                                 // Check which port was activated
  2769.                                 if (IsPortActive(pActInfo, EIP_In))
  2770.                                 {
  2771.                                         float answer = floor_tpl(GetPortFloat(pActInfo, EIP_In));
  2772.                                         ActivateOutput(pActInfo, EOP_Out, answer);
  2773.                                 }
  2774.                         }
  2775.                         break;
  2776.                 }
  2777.         }
  2778.  
  2779.         virtual void GetMemoryUsage(ICrySizer* s) const
  2780.         {
  2781.                 s->Add(*this);
  2782.         }
  2783. };
  2784.  
  2785. class CFlowNode_Modulo : public CFlowBaseNode<eNCT_Singleton>
  2786. {
  2787. public:
  2788.         CFlowNode_Modulo(SActivationInfo* pActInfo) {};
  2789.  
  2790.         virtual void GetConfiguration(SFlowNodeConfig& config)
  2791.         {
  2792.                 static const SInputPortConfig in_config[] = {
  2793.                         InputPortConfig<float>("A"),
  2794.                         InputPortConfig<float>("B"),
  2795.                         { 0 }
  2796.