BVB Source Codes

CRYENGINE Show FlowTimeNode.cpp Source code

Return Download CRYENGINE: download FlowTimeNode.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "TimeOfDayScheduler.h"
  5.  
  6. #include <time.h>
  7. #include <ILevelSystem.h>
  8. #include <Cry3DEngine/I3DEngine.h>
  9. #include <Cry3DEngine/ITimeOfDay.h>
  10. #include <CryFlowGraph/IFlowBaseNode.h>
  11.  
  12. //////////////////////////////////////////////////////////////////////////
  13. class CFlowTimeNode : public CFlowBaseNode<eNCT_Singleton>
  14. {
  15. public:
  16.         enum EInputs
  17.         {
  18.                 IN_PAUSED
  19.         };
  20.         enum EOutputs
  21.         {
  22.                 OUT_SECONDS,
  23.                 OUT_TICK,
  24.         };
  25.         CFlowTimeNode(SActivationInfo* pActInfo)
  26.         {
  27.                 //              pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true );
  28.         }
  29.         virtual void GetConfiguration(SFlowNodeConfig& config)
  30.         {
  31.                 static const SInputPortConfig in_config[] = {
  32.                         InputPortConfig<bool>("paused", false, _HELP("When set to true will pause time output")),
  33.                         { 0 }
  34.                 };
  35.                 static const SOutputPortConfig out_config[] = {
  36.                         OutputPortConfig<float>("seconds", _HELP("Outputs the current time in seconds.")),
  37.                         OutputPortConfig_Void("tick",      _HELP("Outputs event at this port every frame.")),
  38.                         { 0 }
  39.                 };
  40.  
  41.                 config.pInputPorts = in_config;
  42.                 config.pOutputPorts = out_config;
  43.                 config.SetCategory(EFLN_APPROVED);
  44.         }
  45.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  46.         {
  47.                 switch (event)
  48.                 {
  49.                 case eFE_Update:
  50.                         {
  51.                                 bool bPaused = GetPortBool(pActInfo, IN_PAUSED);
  52.                                 if (!bPaused)
  53.                                 {
  54.                                         float fSeconds = gEnv->pTimer->GetFrameStartTime().GetSeconds();
  55.                                         ActivateOutput(pActInfo, OUT_SECONDS, fSeconds);
  56.                                         ActivateOutput(pActInfo, OUT_TICK, 0);
  57.                                 }
  58.                         }
  59.                         break;
  60.                 case eFE_Initialize:
  61.                         {
  62.                                 bool bPaused = GetPortBool(pActInfo, IN_PAUSED);
  63.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, !bPaused);
  64.                                 break;
  65.                         }
  66.                 case eFE_Activate:
  67.                         if (IsPortActive(pActInfo, IN_PAUSED))
  68.                         {
  69.                                 bool bPaused = GetPortBool(pActInfo, IN_PAUSED);
  70.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, !bPaused);
  71.                         }
  72.                         break;
  73.                 }
  74.         }
  75.  
  76.         virtual void GetMemoryUsage(ICrySizer* s) const
  77.         {
  78.                 s->Add(*this);
  79.         }
  80. };
  81.  
  82. //////////////////////////////////////////////////////////////////////////
  83. class CFlowNode_TimeOfDay_LoadDefinitionFile : public CFlowBaseNode<eNCT_Singleton>
  84. {
  85. public:
  86.         enum EInputs
  87.         {
  88.                 EIP_Load = 0,
  89.                 EIP_FileName,
  90.         };
  91.         enum EOutputs
  92.         {
  93.                 EOP_Success = 0,
  94.                 EOP_Fail,
  95.         };
  96.  
  97.         CFlowNode_TimeOfDay_LoadDefinitionFile(SActivationInfo* pActInfo) {}
  98.  
  99.         ~CFlowNode_TimeOfDay_LoadDefinitionFile() {}
  100.  
  101.         virtual void GetConfiguration(SFlowNodeConfig& config)
  102.         {
  103.                 static const SInputPortConfig in_config[] = {
  104.                         InputPortConfig_Void("Load",        _HELP("Triggers the TOD file to be read")),
  105.                         InputPortConfig<string>("FileName", _HELP("Name of the xml file to be read (must be in level folder)"),_HELP("Filename")),
  106.                         { 0 }
  107.                 };
  108.                 static const SOutputPortConfig out_config[] = {
  109.                         OutputPortConfig_Void("Success", _HELP("Triggered when file has successfully loaded")),
  110.                         OutputPortConfig_Void("Fail",    _HELP("Triggered if file was not successfully loaded")),
  111.                         { 0 }
  112.                 };
  113.  
  114.                 config.sDescription = _HELP("Loads a TOD (Time of Day definition file)");
  115.                 config.pInputPorts = in_config;
  116.                 config.pOutputPorts = out_config;
  117.                 config.SetCategory(EFLN_APPROVED);
  118.         }
  119.  
  120.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  121.         {
  122.                 switch (event)
  123.                 {
  124.                 case eFE_Initialize:
  125.                         break;
  126.                 case eFE_Activate:
  127.                         {
  128.                                 if (!IsPortActive(pActInfo, EIP_Load))
  129.                                         return;
  130.  
  131.                                 // get the file name
  132.                                 string pathAndfileName;
  133.                                 const string fileName = GetPortString(pActInfo, EIP_FileName);
  134.                                 if (fileName.empty())
  135.                                         return;
  136.  
  137.                                 ILevelInfo* pCurrentLevel = gEnv->pGameFramework->GetILevelSystem()->GetCurrentLevel();
  138.                                 string path = pCurrentLevel ? pCurrentLevel->GetPath() : "";
  139.                                 pathAndfileName.Format("%s/%s", path.c_str(), fileName.c_str());
  140.  
  141.                                 // try to load it
  142.                                 XmlNodeRef root = GetISystem()->LoadXmlFromFile(pathAndfileName);
  143.                                 if (root == NULL)
  144.                                 {
  145.                                         CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "FlowGraph: TimeOfDay Loading Node: Could not load tod file %s. Aborting.", pathAndfileName.c_str());
  146.                                         ActivateOutput(pActInfo, EOP_Fail, true);
  147.                                         return;
  148.                                 }
  149.  
  150.                                 // get the TimeofDay interface
  151.                                 ITimeOfDay* pTimeOfDay = gEnv->p3DEngine->GetTimeOfDay();
  152.                                 if (pTimeOfDay == NULL)
  153.                                 {
  154.                                         CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "FlowGraph: TimeOfDay Loading Node: Could not obtain ITimeOfDay interface from engine. Aborting.");
  155.                                         ActivateOutput(pActInfo, EOP_Fail, true);
  156.                                         return;
  157.                                 }
  158.  
  159.                                 // try to serialize from that file
  160.                                 pTimeOfDay->Serialize(root, true);
  161.                                 pTimeOfDay->Update(true, true);
  162.  
  163.                                 ActivateOutput(pActInfo, EOP_Success, true);
  164.                         }
  165.                         break;
  166.                 }
  167.         }
  168.  
  169.         virtual void GetMemoryUsage(ICrySizer* s) const
  170.         {
  171.                 s->Add(*this);
  172.         }
  173.  
  174. };
  175.  
  176. //////////////////////////////////////////////////////////////////////////
  177. // Time of day node.
  178. //////////////////////////////////////////////////////////////////////////
  179. class CFlowNode_RealTime : public CFlowBaseNode<eNCT_Instanced>
  180. {
  181. public:
  182.         enum Inputs
  183.         {
  184.                 FORCE_UPDATE
  185.         };
  186.         enum Outputs
  187.         {
  188.                 OUT_HOURS,
  189.                 OUT_MINUTES,
  190.                 OUT_SECONDS,
  191.         };
  192.         CFlowNode_RealTime(SActivationInfo* pActInfo)
  193.         {
  194.                 memset(&m_lasttime, 0, sizeof(m_lasttime));
  195.         }
  196.  
  197.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  198.         {
  199.                 return new CFlowNode_RealTime(pActInfo);
  200.         }
  201.  
  202.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  203.         {
  204.                 if (ser.IsReading())
  205.                 {
  206.                         // forces output on loading
  207.                         m_lasttime.tm_hour = -1;
  208.                         m_lasttime.tm_min = -1;
  209.                         m_lasttime.tm_sec = -1;
  210.                 }
  211.         }
  212.  
  213.         virtual void GetConfiguration(SFlowNodeConfig& config)
  214.         {
  215.                 static const SInputPortConfig in_config[] = {
  216.                         InputPortConfig_Void("force_update"),
  217.                         { 0 }
  218.                 };
  219.                 static const SOutputPortConfig out_config[] = {
  220.                         OutputPortConfig<int>("hours"),
  221.                         OutputPortConfig<int>("minutes"),
  222.                         OutputPortConfig<int>("seconds"),
  223.                         { 0 }
  224.                 };
  225.  
  226.                 config.pInputPorts = in_config;
  227.                 config.pOutputPorts = out_config;
  228.                 config.SetCategory(EFLN_APPROVED);
  229.         }
  230.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  231.         {
  232.                 switch (event)
  233.                 {
  234.                 case eFE_Initialize:
  235.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  236.                         break;
  237.                 case eFE_Update:
  238.                         {
  239.                                 Update(pActInfo, false);
  240.                         }
  241.                         break;
  242.                 case eFE_Activate:
  243.                         {
  244.                                 if (IsPortActive(pActInfo, FORCE_UPDATE))
  245.                                 {
  246.                                         Update(pActInfo, true);
  247.                                 }
  248.                         }
  249.                         break;
  250.                 }
  251.         }
  252.  
  253.         virtual void GetMemoryUsage(ICrySizer* s) const
  254.         {
  255.                 s->Add(*this);
  256.         }
  257. private:
  258.         void Update(SActivationInfo* pActInfo, bool forceUpdate)
  259.         {
  260.                 time_t long_time = time(NULL);
  261.                 tm* newtime = localtime(&long_time);
  262.                 if ((forceUpdate == true) || (newtime->tm_hour != m_lasttime.tm_hour))
  263.                         ActivateOutput(pActInfo, OUT_HOURS, newtime->tm_hour);
  264.                 if ((forceUpdate == true) || (newtime->tm_min != m_lasttime.tm_min))
  265.                         ActivateOutput(pActInfo, OUT_MINUTES, newtime->tm_min);
  266.                 if ((forceUpdate == true) || (newtime->tm_sec != m_lasttime.tm_sec))
  267.                         ActivateOutput(pActInfo, OUT_SECONDS, newtime->tm_sec);
  268.                 m_lasttime = *newtime;
  269.         }
  270.  
  271.         tm m_lasttime;
  272. };
  273.  
  274. //////////////////////////////////////////////////////////////////////////
  275. // Timer node.
  276. //////////////////////////////////////////////////////////////////////////
  277. class CFlowNode_Timer : public CFlowBaseNode<eNCT_Instanced>
  278. {
  279. public:
  280.         enum EInputs
  281.         {
  282.                 IN_PERIOD,
  283.                 IN_MIN,
  284.                 IN_MAX,
  285.                 IN_PAUSED
  286.         };
  287.         enum EOutputs
  288.         {
  289.                 OUT_OUT,
  290.         };
  291.         CFlowNode_Timer(SActivationInfo* pActInfo)
  292.         {
  293.                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  294.                 m_nCurrentCount = -100000;
  295.         }
  296.  
  297.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  298.         {
  299.                 return new CFlowNode_Timer(pActInfo);
  300.         }
  301.  
  302.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  303.         {
  304.                 ser.BeginGroup("Local");
  305.                 ser.Value("m_last", m_last);
  306.                 ser.Value("m_nCurrentCount", m_nCurrentCount);
  307.                 ser.EndGroup();
  308.         }
  309.  
  310.         virtual void GetConfiguration(SFlowNodeConfig& config)
  311.         {
  312.                 static const SInputPortConfig in_config[] = {
  313.                         InputPortConfig<float>("period", _HELP("Tick period in seconds")),
  314.                         InputPortConfig<int>("min",      _HELP("Minimal timer output value")),
  315.                         InputPortConfig<int>("max",      _HELP("Maximal timer output value")),
  316.                         InputPortConfig<bool>("paused",  _HELP("Timer will be paused when set to true")),
  317.                         { 0 }
  318.                 };
  319.                 static const SOutputPortConfig out_config[] = {
  320.                         OutputPortConfig<int>("out"),
  321.                         { 0 }
  322.                 };
  323.  
  324.                 config.sDescription = _HELP("Timer node will output count from min to max, ticking at the specified period of time");
  325.                 config.pInputPorts = in_config;
  326.                 config.pOutputPorts = out_config;
  327.                 config.SetCategory(EFLN_APPROVED);
  328.         }
  329.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  330.         {
  331.                 switch (event)
  332.                 {
  333.                 case eFE_Initialize:
  334.                         {
  335.                                 bool bPaused = GetPortBool(pActInfo, IN_PAUSED);
  336.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, !bPaused);
  337.                                 m_last = gEnv->pTimer->GetFrameStartTime();
  338.                         }
  339.                         break;
  340.  
  341.                 case eFE_Update:
  342.                         {
  343.                                 if (GetPortBool(pActInfo, IN_PAUSED))
  344.                                         return;
  345.  
  346.                                 float fPeriod = GetPortFloat(pActInfo, IN_PERIOD);
  347.                                 CTimeValue time = gEnv->pTimer->GetFrameStartTime();
  348.                                 CTimeValue dt = time - m_last;
  349.                                 if (dt.GetSeconds() >= fPeriod)
  350.                                 {
  351.                                         m_last = time;
  352.                                         int nMin = GetPortInt(pActInfo, IN_MIN);
  353.                                         int nMax = GetPortInt(pActInfo, IN_MAX);
  354.                                         m_nCurrentCount++;
  355.                                         if (m_nCurrentCount < nMin)
  356.                                                 m_nCurrentCount = nMin;
  357.                                         if (m_nCurrentCount > nMax)
  358.                                         {
  359.                                                 m_nCurrentCount = nMin;
  360.                                         }
  361.                                         ActivateOutput(pActInfo, OUT_OUT, m_nCurrentCount);
  362.                                 }
  363.                         }
  364.                         break;
  365.                 case eFE_Activate:
  366.                         {
  367.                                 if (IsPortActive(pActInfo, IN_PAUSED))
  368.                                 {
  369.                                         bool bPaused = GetPortBool(pActInfo, IN_PAUSED);
  370.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, !bPaused);
  371.                                 }
  372.                         }
  373.                         break;
  374.                 }
  375.         }
  376.  
  377.         virtual void GetMemoryUsage(ICrySizer* s) const
  378.         {
  379.                 s->Add(*this);
  380.         }
  381. private:
  382.         CTimeValue m_last;
  383.         int        m_nCurrentCount;
  384. };
  385.  
  386. //////////////////////////////////////////////////////////////////////////
  387. class CFlowNode_TimedCounter : public CFlowBaseNode<eNCT_Instanced>
  388. {
  389. public:
  390.         enum EInputs
  391.         {
  392.                 IN_START = 0,
  393.                 IN_STOP,
  394.                 IN_CONTINUE,
  395.                 IN_PERIOD,
  396.                 IN_LIMIT
  397.         };
  398.         enum EOutputs
  399.         {
  400.                 OUT_FINISHED = 0,
  401.                 OUT_COUNT
  402.         };
  403.         CFlowNode_TimedCounter(SActivationInfo* pActInfo) : m_count(0)
  404.         {
  405.         }
  406.  
  407.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  408.         {
  409.                 return new CFlowNode_TimedCounter(pActInfo);
  410.         }
  411.  
  412.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  413.         {
  414.                 ser.BeginGroup("Local");
  415.                 ser.Value("lastTickTime", m_lastTickTime);
  416.                 ser.Value("count", m_count);
  417.                 ser.EndGroup();
  418.         }
  419.  
  420.         virtual void GetConfiguration(SFlowNodeConfig& config)
  421.         {
  422.                 static const SInputPortConfig in_config[] = {
  423.                         InputPortConfig_AnyType("start",    _HELP("Triggers the start of the counter. If it is counting already, it resets it. Also, wathever was input here, will be output as 'finished' when the counting is done")),
  424.                         InputPortConfig_AnyType("stop",     _HELP("Stops counting")),
  425.                         InputPortConfig_AnyType("continue", _HELP("Continues counting")),
  426.                         InputPortConfig<float>("period",    1.f,                                                                                                                                                                        _HELP("Tick period in seconds")),
  427.                         InputPortConfig<int>("limit",       _HELP("How many ticks the counter will do before finish")),
  428.                         { 0 }
  429.                 };
  430.                 static const SOutputPortConfig out_config[] = {
  431.                         OutputPortConfig_AnyType("finished", _HELP("triggered when the counting is done. The value will be the same than the 'start' input")),
  432.                         OutputPortConfig<int>("count",       _HELP("outputs the tick counter value")),
  433.                         { 0 }
  434.                 };
  435.  
  436.                 config.sDescription = _HELP("counts a number of ticks specified by 'limit', and then outputs 'finished' with the value the input 'start' had when it was triggered");
  437.                 config.pInputPorts = in_config;
  438.                 config.pOutputPorts = out_config;
  439.                 config.SetCategory(EFLN_APPROVED);
  440.         }
  441.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  442.         {
  443.                 switch (event)
  444.                 {
  445.                 case eFE_Initialize:
  446.                         {
  447.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  448.                         }
  449.                         break;
  450.  
  451.                 case eFE_Update:
  452.                         {
  453.                                 float fPeriod = GetPortFloat(pActInfo, IN_PERIOD);
  454.                                 CTimeValue time = gEnv->pTimer->GetFrameStartTime();
  455.                                 CTimeValue dt = time - m_lastTickTime;
  456.                                 if (dt.GetSeconds() >= fPeriod)
  457.                                 {
  458.                                         m_lastTickTime = time;
  459.                                         ++m_count;
  460.                                         ActivateOutput(pActInfo, OUT_COUNT, m_count);
  461.                                         if (m_count >= GetPortInt(pActInfo, IN_LIMIT))
  462.                                         {
  463.                                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  464.                                                 ActivateOutput(pActInfo, OUT_FINISHED, GetPortAny(pActInfo, IN_START));
  465.                                         }
  466.                                 }
  467.                         }
  468.                         break;
  469.                 case eFE_Activate:
  470.                         {
  471.                                 if (IsPortActive(pActInfo, IN_START))
  472.                                 {
  473.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  474.                                         m_count = 0;
  475.                                         m_lastTickTime = gEnv->pTimer->GetFrameStartTime();
  476.                                 }
  477.  
  478.                                 if (IsPortActive(pActInfo, IN_STOP))
  479.                                 {
  480.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  481.                                 }
  482.  
  483.                                 if (IsPortActive(pActInfo, IN_CONTINUE))
  484.                                 {
  485.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  486.                                 }
  487.                         }
  488.                         break;
  489.                 }
  490.         }
  491.  
  492.         virtual void GetMemoryUsage(ICrySizer* s) const
  493.         {
  494.                 s->Add(*this);
  495.         }
  496. private:
  497.         CTimeValue m_lastTickTime;
  498.         int        m_count;
  499. };
  500.  
  501. //////////////////////////////////////////////////////////////////////////
  502. class CFlowNode_TimeOfDay : public CFlowBaseNode<eNCT_Singleton>
  503. {
  504. public:
  505.         enum EInputs
  506.         {
  507.                 IN_TIME = 0,
  508.                 IN_SET,
  509.                 IN_FORCEUPDATE,
  510.                 IN_GET,
  511.                 IN_SPEED,
  512.                 IN_SET_SPEED,
  513.                 IN_GET_SPEED
  514.         };
  515.         enum EOutputs
  516.         {
  517.                 OUT_CURTIME = 0,
  518.                 OUT_CURSPEED
  519.         };
  520.  
  521.         CFlowNode_TimeOfDay(SActivationInfo* /* pActInfo */) {}
  522.  
  523.         virtual void GetConfiguration(SFlowNodeConfig& config)
  524.         {
  525.                 static const SInputPortConfig in_config[] = {
  526.                         InputPortConfig<float>("Time",       0.0f,                                                   _HELP("TimeOfDay to set (in hours 0-24)")),
  527.                         InputPortConfig_Void("Set",          _HELP("Trigger to Set TimeOfDay to [Time]"),            _HELP("SetTime")),
  528.                         InputPortConfig<bool>("ForceUpdate", false,                                                  _HELP("Force Immediate Update of Sky if true. Only in Special Cases!")),
  529.                         InputPortConfig_Void("Get",          _HELP("Trigger to Get TimeOfDay to [CurTime]"),         _HELP("GetTime")),
  530.                         InputPortConfig<float>("Speed",      1.0f,                                                   _HELP("Speed to bet set (via [SetSpeed]")),
  531.                         InputPortConfig_Void("SetSpeed",     _HELP("Trigger to set TimeOfDay Speed to [Speed]")),
  532.                         InputPortConfig_Void("GetSpeed",     _HELP("Trigger to get TimeOfDay Speed to [CurSpeed]")),
  533.                         { 0 }
  534.                 };
  535.                 static const SOutputPortConfig out_config[] = {
  536.                         OutputPortConfig<float>("CurTime",  _HELP("Current TimeOfDay (set when [GetTime] is triggered)")),
  537.                         OutputPortConfig<float>("CurSpeed", _HELP("Current TimeOfDay Speed (set when [GetSpeed] is triggered)")),
  538.                         { 0 }
  539.                 };
  540.  
  541.                 config.sDescription = _HELP("Set/Get TimeOfDay and Speed");
  542.                 config.pInputPorts = in_config;
  543.                 config.pOutputPorts = out_config;
  544.                 config.SetCategory(EFLN_APPROVED);
  545.         }
  546.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  547.         {
  548.                 switch (event)
  549.                 {
  550.                 case eFE_Activate:
  551.                         {
  552.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  553.                                 if (pTOD == 0)
  554.                                         return;
  555.  
  556.                                 if (IsPortActive(pActInfo, IN_SET))
  557.                                 {
  558.                                         const bool bForceUpdate = GetPortBool(pActInfo, IN_FORCEUPDATE);
  559.                                         pTOD->SetTime(GetPortFloat(pActInfo, IN_TIME), bForceUpdate);
  560.                                         ActivateOutput(pActInfo, OUT_CURTIME, pTOD->GetTime());
  561.                                 }
  562.                                 if (IsPortActive(pActInfo, IN_GET))
  563.                                 {
  564.                                         ActivateOutput(pActInfo, OUT_CURTIME, pTOD->GetTime());
  565.                                 }
  566.                                 if (IsPortActive(pActInfo, IN_SET_SPEED))
  567.                                 {
  568.                                         ITimeOfDay::SAdvancedInfo info;
  569.                                         pTOD->GetAdvancedInfo(info);
  570.                                         info.fAnimSpeed = GetPortFloat(pActInfo, IN_SPEED);
  571.                                         pTOD->SetAdvancedInfo(info);
  572.                                         ActivateOutput(pActInfo, OUT_CURSPEED, info.fAnimSpeed);
  573.                                 }
  574.                                 if (IsPortActive(pActInfo, IN_GET_SPEED))
  575.                                 {
  576.                                         ITimeOfDay::SAdvancedInfo info;
  577.                                         pTOD->GetAdvancedInfo(info);
  578.                                         ActivateOutput(pActInfo, OUT_CURSPEED, info.fAnimSpeed);
  579.                                 }
  580.                         }
  581.                         break;
  582.                 }
  583.         }
  584.  
  585.         virtual void GetMemoryUsage(ICrySizer* s) const
  586.         {
  587.                 s->Add(*this);
  588.         }
  589. };
  590.  
  591. //////////////////////////////////////////////////////////////////////////
  592. // Timer node.
  593. //////////////////////////////////////////////////////////////////////////
  594. class CFlowNode_MeasureTime : public CFlowBaseNode<eNCT_Instanced>
  595. {
  596. public:
  597.         enum EInputs
  598.         {
  599.                 EIP_Start = 0,
  600.                 EIP_Stop
  601.         };
  602.         enum EOutputs
  603.         {
  604.                 EOP_Started = 0,
  605.                 EOP_Stopped,
  606.                 EOP_Time,
  607.         };
  608.  
  609.         CFlowNode_MeasureTime(SActivationInfo* pActInfo)
  610.         {
  611.                 m_last = 0.0f;
  612.         }
  613.  
  614.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  615.         {
  616.                 return new CFlowNode_MeasureTime(pActInfo);
  617.         }
  618.  
  619.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  620.         {
  621.                 ser.Value("m_last", m_last);
  622.         }
  623.  
  624.         virtual void GetConfiguration(SFlowNodeConfig& config)
  625.         {
  626.                 static const SInputPortConfig in_config[] = {
  627.                         InputPortConfig_Void("Start", _HELP("Trigger to start measuring")),
  628.                         InputPortConfig_Void("Stop",  _HELP("Trigger to stop measuring")),
  629.                         { 0 }
  630.                 };
  631.                 static const SOutputPortConfig out_config[] = {
  632.                         OutputPortConfig_Void("Started",   _HELP("Triggered on Start")),
  633.                         OutputPortConfig_Void("Stopped",   _HELP("Triggered on Stop")),
  634.                         OutputPortConfig<float>("Elapsed", _HELP("Elapsed time in seconds")),
  635.                         { 0 }
  636.                 };
  637.  
  638.                 config.sDescription = _HELP("Node to measure elapsed time.");
  639.                 config.pInputPorts = in_config;
  640.                 config.pOutputPorts = out_config;
  641.                 config.SetCategory(EFLN_APPROVED);
  642.         }
  643.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  644.         {
  645.                 switch (event)
  646.                 {
  647.                 case eFE_Activate:
  648.                         if (IsPortActive(pActInfo, EIP_Start))
  649.                         {
  650.                                 m_last = gEnv->pTimer->GetFrameStartTime();
  651.                                 ActivateOutput(pActInfo, EOP_Started, true);
  652.                         }
  653.                         if (IsPortActive(pActInfo, EIP_Stop))
  654.                         {
  655.                                 CTimeValue dt = gEnv->pTimer->GetFrameStartTime();
  656.                                 dt -= m_last;
  657.                                 m_last = 0.0f;
  658.                                 ActivateOutput(pActInfo, EOP_Stopped, true);
  659.                                 ActivateOutput(pActInfo, EOP_Time, dt.GetSeconds());
  660.                         }
  661.                         break;
  662.                 }
  663.         }
  664.  
  665.         virtual void GetMemoryUsage(ICrySizer* s) const
  666.         {
  667.                 s->Add(*this);
  668.         }
  669. private:
  670.         CTimeValue m_last;
  671. };
  672.  
  673. //////////////////////////////////////////////////////////////////////////
  674. class CFlowNode_TimeOfDayTrigger : public CFlowBaseNode<eNCT_Instanced>
  675. {
  676. public:
  677.         enum EInputs
  678.         {
  679.                 EIP_Enabled = 0,
  680.                 EIP_Time,
  681.         };
  682.         enum EOutputs
  683.         {
  684.                 EOP_Trigger = 0,
  685.         };
  686.  
  687.         CFlowNode_TimeOfDayTrigger(SActivationInfo* /* pActInfo */)
  688.         {
  689.                 m_timerId = CTimeOfDayScheduler::InvalidTimerId;
  690.         }
  691.  
  692.         ~CFlowNode_TimeOfDayTrigger()
  693.         {
  694.                 ResetTimer();
  695.         }
  696.  
  697.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo)
  698.         {
  699.                 return new CFlowNode_TimeOfDayTrigger(pActInfo);
  700.         }
  701.  
  702.         virtual void GetConfiguration(SFlowNodeConfig& config)
  703.         {
  704.                 static const SInputPortConfig in_config[] = {
  705.                         InputPortConfig<bool>("Active", true, _HELP("Whether trigger is enabled")),
  706.                         InputPortConfig<float>("Time",  0.0f, _HELP("Time when to trigger")),
  707.                         { 0 }
  708.                 };
  709.                 static const SOutputPortConfig out_config[] = {
  710.                         OutputPortConfig<float>("Trigger", _HELP("Triggered when TimeOfDay has been reached. Outputs current timeofday")),
  711.                         { 0 }
  712.                 };
  713.  
  714.                 config.sDescription = _HELP("TimeOfDay Trigger");
  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_Initialize:
  724.                 case eFE_Activate:
  725.                         {
  726.                                 ResetTimer();
  727.                                 m_actInfo = *pActInfo;
  728.                                 const bool bEnabled = IsBoolPortActive(pActInfo, EIP_Enabled);
  729.                                 if (bEnabled)
  730.                                         RegisterTimer(pActInfo);
  731.                         }
  732.                         break;
  733.                 }
  734.         }
  735.  
  736.         void ResetTimer()
  737.         {
  738.                 if (m_timerId != CTimeOfDayScheduler::InvalidTimerId)
  739.                 {
  740.                         CCryAction::GetCryAction()->GetTimeOfDayScheduler()->RemoveTimer(m_timerId);
  741.                         m_timerId = CTimeOfDayScheduler::InvalidTimerId;
  742.                 }
  743.         }
  744.  
  745.         void RegisterTimer(SActivationInfo* pActInfo)
  746.         {
  747.                 assert(m_timerId == CTimeOfDayScheduler::InvalidTimerId);
  748.                 const float time = GetPortFloat(pActInfo, EIP_Time);
  749.                 m_timerId = CCryAction::GetCryAction()->GetTimeOfDayScheduler()->AddTimer(time, OnTODCallback, (void*)this);
  750.         }
  751.  
  752.         virtual void GetMemoryUsage(ICrySizer* s) const
  753.         {
  754.                 s->Add(*this);
  755.         }
  756.  
  757.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  758.         {
  759.                 if (ser.IsReading())
  760.                 {
  761.                         ResetTimer();
  762.                         // re-enable if it's enabled
  763.                         const bool bEnabled = GetPortBool(pActInfo, EIP_Enabled);
  764.                         if (bEnabled)
  765.                                 RegisterTimer(pActInfo);
  766.                 }
  767.         }
  768.  
  769. protected:
  770.         static void OnTODCallback(CTimeOfDayScheduler::TimeOfDayTimerId timerId, void* pUserData, float curTime)
  771.         {
  772.                 CFlowNode_TimeOfDayTrigger* pThis = reinterpret_cast<CFlowNode_TimeOfDayTrigger*>(pUserData);
  773.                 if (timerId != pThis->m_timerId)
  774.                         return;
  775.                 ActivateOutput(&pThis->m_actInfo, EOP_Trigger, curTime);
  776.         }
  777.  
  778.         SActivationInfo                       m_actInfo;
  779.         CTimeOfDayScheduler::TimeOfDayTimerId m_timerId;
  780. };
  781.  
  782. //////////////////////////////////////////////////////////////////////////
  783. // Time of day node.
  784. //////////////////////////////////////////////////////////////////////////
  785. class CFlowNode_ServerTime : public CFlowBaseNode<eNCT_Instanced>
  786. {
  787. public:
  788.         enum Inputs
  789.         {
  790.                 IN_BASETIME,
  791.                 IN_PERIOD,
  792.         };
  793.         enum Outputs
  794.         {
  795.                 OUT_SECS,
  796.                 OUT_MSECS,
  797.                 OUT_PERIOD,
  798.         };
  799.         CFlowNode_ServerTime(SActivationInfo* pActInfo) : m_lasttime(0.0f), m_basetime(0.0f)
  800.         {
  801.         }
  802.  
  803.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  804.         {
  805.                 return new CFlowNode_ServerTime(pActInfo);
  806.         }
  807.  
  808.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  809.         {
  810.                 if (ser.IsReading())
  811.                 {
  812.                         ser.Value("lasttime", m_lasttime);
  813.                         ser.Value("basetime", m_basetime);
  814.                         ser.Value("period", m_period);
  815.                 }
  816.         }
  817.  
  818.         virtual void GetConfiguration(SFlowNodeConfig& config)
  819.         {
  820.                 static const SInputPortConfig in_config[] = {
  821.                         InputPortConfig<float>("basetime", 0.0f, _HELP("Set base time in seconds. All values output will be relative to this time.")),
  822.                         InputPortConfig<float>("period",   0.0f, _HELP("Set period of the timer in seconds. Timer will reset each time after reaching this value.")),
  823.                         { 0 }
  824.                 };
  825.  
  826.                 static const SOutputPortConfig out_config[] = {
  827.                         OutputPortConfig<int>("secs"),
  828.                         OutputPortConfig<int>("msecs"),
  829.                         OutputPortConfig<bool>("period"),
  830.                         { 0 }
  831.                 };
  832.  
  833.                 config.pInputPorts = in_config;
  834.                 config.pOutputPorts = out_config;
  835.                 config.SetCategory(EFLN_APPROVED);
  836.         }
  837.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  838.         {
  839.                 switch (event)
  840.                 {
  841.                 case eFE_Initialize:
  842.                         {
  843.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  844.                                 if (IsPortActive(pActInfo, IN_BASETIME))
  845.                                         m_basetime = GetPortFloat(pActInfo, IN_BASETIME);
  846.  
  847.                                 if (IsPortActive(pActInfo, IN_PERIOD))
  848.                                         m_period = GetPortFloat(pActInfo, IN_PERIOD);
  849.  
  850.                                 m_msec = 0;
  851.                         }
  852.                         break;
  853.                 case eFE_Update:
  854.                         {
  855.                                 CTimeValue now = CCryAction::GetCryAction()->GetServerTime();
  856.  
  857.                                 if (now != m_lasttime)
  858.                                 {
  859.                                         uint32 msec = (uint32)((now - m_basetime).GetMilliSeconds());
  860.                                         uint32 period = (uint32)(m_period.GetMilliSeconds());
  861.  
  862.                                         if (period > 0)
  863.                                         {
  864.                                                 msec = msec % period;
  865.                                                 if (msec < m_msec)
  866.                                                         ActivateOutput(pActInfo, OUT_PERIOD, 1);
  867.  
  868.                                                 m_msec = msec;
  869.                                         }
  870.                                         ActivateOutput(pActInfo, OUT_MSECS, msec);
  871.                                 }
  872.                                 if (now.GetSeconds() != m_lasttime.GetSeconds())
  873.                                 {
  874.                                         float secs = (now - m_basetime).GetSeconds();
  875.                                         float period = m_period.GetSeconds();
  876.  
  877.                                         if (period > 0.00001f)
  878.                                                 secs = fmod_tpl(secs, period);
  879.  
  880.                                         ActivateOutput(pActInfo, OUT_SECS, secs);
  881.                                 }
  882.  
  883.                                 m_lasttime = now;
  884.                         }
  885.                         break;
  886.                 }
  887.         }
  888.  
  889.         virtual void GetMemoryUsage(ICrySizer* s) const
  890.         {
  891.                 s->Add(*this);
  892.         }
  893. private:
  894.         CTimeValue m_lasttime;
  895.         CTimeValue m_basetime;
  896.         CTimeValue m_period;
  897.         uint32     m_msec;
  898. };
  899.  
  900. REGISTER_FLOW_NODE("Time:Time", CFlowTimeNode)
  901. REGISTER_FLOW_NODE("Time:RealTime", CFlowNode_RealTime)
  902. REGISTER_FLOW_NODE("Time:Timer", CFlowNode_Timer)
  903. REGISTER_FLOW_NODE("Time:TimeOfDayLoadDefinitionFile", CFlowNode_TimeOfDay_LoadDefinitionFile)
  904. REGISTER_FLOW_NODE("Time:TimeOfDay", CFlowNode_TimeOfDay)
  905. REGISTER_FLOW_NODE("Time:MeasureTime", CFlowNode_MeasureTime)
  906. REGISTER_FLOW_NODE("Time:TimeOfDayTrigger", CFlowNode_TimeOfDayTrigger)
  907. REGISTER_FLOW_NODE("Time:ServerTime", CFlowNode_ServerTime)
  908. REGISTER_FLOW_NODE("Time:TimedCounter", CFlowNode_TimedCounter)
  909.  
downloadFlowTimeNode.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top