BVB Source Codes

CRYENGINE Show FlowEnvironmentNodes.cpp Source code

Return Download CRYENGINE: download FlowEnvironmentNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4.  
  5. #include <CryFlowGraph/IFlowBaseNode.h>
  6. #include <Cry3DEngine/I3DEngine.h>
  7. #include <Cry3DEngine/ITimeOfDay.h>
  8. #include <CrySystem/IStreamEngine.h>
  9.  
  10. class CFlowNode_EnvMoonDirection : public CFlowBaseNode<eNCT_Singleton>
  11. {
  12. public:
  13.         CFlowNode_EnvMoonDirection(SActivationInfo* pActInfo)
  14.         {
  15.         }
  16.  
  17.         enum EInputPorts
  18.         {
  19.                 eIP_Get = 0,
  20.                 eIP_Set,
  21.                 eIP_Latitude,
  22.                 eIP_Longitude,
  23.                 eIP_ForceUpdate,
  24.         };
  25.  
  26.         enum EOutputPorts
  27.         {
  28.                 eOP_Latitude = 0,
  29.                 eOP_Longitude,
  30.         };
  31.  
  32.         void GetConfiguration(SFlowNodeConfig& config)
  33.         {
  34.                 static const SInputPortConfig in_config[] = {
  35.                         InputPortConfig_Void("Get",          _HELP("Get the current Latitude/Longitude")),
  36.                         InputPortConfig_Void("Set",          _HELP("Set the Latitude/Longitude")),
  37.                         InputPortConfig<float>("Latitude",   0.0f,                                        _HELP("Latitude to be set")),
  38.                         InputPortConfig<float>("Longitude",  35.0f,                                       _HELP("Longitude to be set")),
  39.                         InputPortConfig<bool>("ForceUpdate", false,                                       _HELP("Force Immediate Update of Sky if true. USE ONLY IN SPECIAL CASES, is heavy on performance!")),
  40.                         { 0 }
  41.                 };
  42.                 static const SOutputPortConfig out_config[] = {
  43.                         OutputPortConfig<float>("Latitude",  _HELP("Current Latitude")),
  44.                         OutputPortConfig<float>("Longitude", _HELP("Current Longitude")),
  45.                         { 0 }
  46.                 };
  47.                 config.pInputPorts = in_config;
  48.                 config.pOutputPorts = out_config;
  49.                 config.sDescription = _HELP("Set the 3DEngine's Moon Direction");
  50.                 config.SetCategory(EFLN_APPROVED);
  51.         }
  52.  
  53.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  54.         {
  55.                 switch (event)
  56.                 {
  57.                 case eFE_Activate:
  58.                         if (IsPortActive(pActInfo, eIP_Get))
  59.                         {
  60.                                 Vec3 v;
  61.                                 gEnv->p3DEngine->GetGlobalParameter(E3DPARAM_SKY_MOONROTATION, v);
  62.                                 ActivateOutput(pActInfo, eOP_Latitude, v.x);
  63.                                 ActivateOutput(pActInfo, eOP_Longitude, v.y);
  64.                         }
  65.                         if (IsPortActive(pActInfo, eIP_Set))
  66.                         {
  67.                                 Vec3 v(ZERO);
  68.                                 v.x = GetPortFloat(pActInfo, eIP_Latitude);
  69.                                 v.y = GetPortFloat(pActInfo, eIP_Longitude);
  70.                                 gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_SKY_MOONROTATION, v);
  71.                                 ActivateOutput(pActInfo, eOP_Latitude, v.x);
  72.                                 ActivateOutput(pActInfo, eOP_Longitude, v.y);
  73.                                 bool forceUpdate = GetPortBool(pActInfo, eIP_ForceUpdate);
  74.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  75.                                 if (forceUpdate && pTOD)
  76.                                         pTOD->Update(true, true);
  77.                         }
  78.                 }
  79.         }
  80.  
  81.         virtual void GetMemoryUsage(ICrySizer* s) const
  82.         {
  83.                 s->Add(*this);
  84.         }
  85.  
  86. };
  87.  
  88. class CFlowNode_EnvSun : public CFlowBaseNode<eNCT_Singleton>
  89. {
  90. public:
  91.         CFlowNode_EnvSun(SActivationInfo* pActInfo)
  92.         {
  93.         }
  94.  
  95.         enum EInputPorts
  96.         {
  97.                 eIP_Get = 0,
  98.                 eIP_Set,
  99.                 eIP_Latitude,
  100.                 eIP_Longitude,
  101.                 eIP_ForceUpdate,
  102.         };
  103.  
  104.         enum EOutputPorts
  105.         {
  106.                 eOP_Latitude = 0,
  107.                 eOP_Longitude,
  108.         };
  109.  
  110.         void GetConfiguration(SFlowNodeConfig& config)
  111.         {
  112.                 static const SInputPortConfig in_config[] = {
  113.                         InputPortConfig_Void("Get",          _HELP("Get the current Latitude/Longitude")),
  114.                         InputPortConfig_Void("Set",          _HELP("Set the Latitude/Longitude")),
  115.                         InputPortConfig<float>("Latitude",   0.0f,                                        _HELP("Latitude to be set")),
  116.                         InputPortConfig<float>("Longitude",  35.0f,                                       _HELP("Longitude to be set")),
  117.                         InputPortConfig<bool>("ForceUpdate", false,                                       _HELP("Force Immediate Update of Sky if true. USE ONLY IN SPECIAL CASES, is heavy on performance!")),
  118.                         { 0 }
  119.                 };
  120.                 static const SOutputPortConfig out_config[] = {
  121.                         OutputPortConfig<float>("Latitude",  _HELP("Current Latitude")),
  122.                         OutputPortConfig<float>("Longitude", _HELP("Current Longitude")),
  123.                         { 0 }
  124.                 };
  125.                 config.pInputPorts = in_config;
  126.                 config.pOutputPorts = out_config;
  127.                 config.sDescription = _HELP("Set the 3DEngine's Sun Data");
  128.                 config.SetCategory(EFLN_APPROVED);
  129.         }
  130.  
  131.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  132.         {
  133.                 switch (event)
  134.                 {
  135.                 case eFE_Activate:
  136.                         if (IsPortActive(pActInfo, eIP_Get))
  137.                         {
  138.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  139.                                 if (pTOD)
  140.                                 {
  141.                                         ActivateOutput(pActInfo, eOP_Latitude, pTOD->GetSunLatitude());
  142.                                         ActivateOutput(pActInfo, eOP_Longitude, pTOD->GetSunLongitude());
  143.                                 }
  144.                         }
  145.                         if (IsPortActive(pActInfo, eIP_Set))
  146.                         {
  147.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  148.                                 if (pTOD)
  149.                                 {
  150.                                         float latitude = GetPortFloat(pActInfo, eIP_Latitude);
  151.                                         float longitude = GetPortFloat(pActInfo, eIP_Longitude);
  152.  
  153.                                         pTOD->SetSunPos(longitude, latitude);
  154.                                         bool forceUpdate = GetPortBool(pActInfo, eIP_ForceUpdate);
  155.                                         pTOD->Update(true, forceUpdate);
  156.  
  157.                                         ActivateOutput(pActInfo, eOP_Latitude, latitude);
  158.                                         ActivateOutput(pActInfo, eOP_Longitude, longitude);
  159.                                 }
  160.                         }
  161.                         break;
  162.                 }
  163.         }
  164.  
  165.         virtual void GetMemoryUsage(ICrySizer* s) const
  166.         {
  167.                 s->Add(*this);
  168.         }
  169.  
  170. };
  171.  
  172. //////////////////////////////////////////////////////////////////////////
  173. class CFlowNode_TimeOfDayTransitionTrigger : public CFlowBaseNode<eNCT_Instanced>
  174. {
  175.         typedef uint32 InternalID;  // InternalID is used to control that only 1 of those nodes is active at any time
  176.  
  177.         float             m_startTOD;
  178.         float             m_startSunLatitude;
  179.         float             m_startSunLongitude;
  180.         float             m_durationLeft;
  181.         float             m_TODTimeToUpdate; // used when update is not every frame
  182.         float             m_sunTimeToUpdate; // used when update is not every frame
  183.         InternalID        m_ID;
  184.         bool              m_blending;
  185.         bool              m_paused;
  186.  
  187.         static InternalID m_IDCounter;
  188.         static InternalID m_activeID;
  189.  
  190. public:
  191.         enum EInputs
  192.         {
  193.                 IN_TOD = 0,
  194.                 IN_DURATION,
  195.                 IN_SUN_LATITUDE,
  196.                 IN_SUN_LONGITUDE,
  197.                 IN_SUN_POSITION_UPDATE_INTERVAL,
  198.                 IN_TOD_FORCE_UPDATE_INTERVAL,
  199.                 IN_START,
  200.                 IN_PAUSE
  201.         };
  202.         enum EOutputs
  203.         {
  204.                 OUT_DONE = 0,
  205.         };
  206.  
  207.         CFlowNode_TimeOfDayTransitionTrigger(SActivationInfo* pActInfo)
  208.                 : m_startTOD(0.0f)
  209.                 , m_startSunLatitude(0.0f)
  210.                 , m_startSunLongitude(0.0f)
  211.                 , m_durationLeft(0.0f)
  212.                 , m_TODTimeToUpdate(0.0f)
  213.                 , m_sunTimeToUpdate(0.0f)
  214.                 , m_ID(m_IDCounter++)
  215.                 , m_blending(false)
  216.                 , m_paused(false)
  217.         {
  218.         }
  219.  
  220.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  221.         {
  222.                 return new CFlowNode_TimeOfDayTransitionTrigger(pActInfo);
  223.         }
  224.  
  225.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  226.         {
  227.                 ser.Value("blending", m_blending);
  228.                 ser.Value("IDCounter", m_IDCounter); // those statics will get serialized more than once (once for each node), but does not matter much
  229.                 ser.Value("activeID", m_activeID);
  230.                 if (m_blending)
  231.                 {
  232.                         ser.Value("paused", m_paused);
  233.                         ser.Value("startTOD", m_startTOD);
  234.                         ser.Value("startSunLatitude", m_startSunLatitude);
  235.                         ser.Value("startSunLongitude", m_startSunLongitude);
  236.                         ser.Value("durationLeft", m_durationLeft);
  237.                         ser.Value("TODTimeToUpdate", m_TODTimeToUpdate);
  238.                         ser.Value("sunTimeToUpdate", m_sunTimeToUpdate);
  239.                 }
  240.         }
  241.  
  242.         void GetConfiguration(SFlowNodeConfig& config)
  243.         {
  244.                 static const SInputPortConfig in_config[] = {
  245.                         InputPortConfig<float>("Time",                      -1.0f,                                  _HELP("Blend from the current time in the level to this new specified time. (24 hours value. -1 = no TOD blending)")),
  246.                         InputPortConfig<float>("Duration",                  0.f,                                    _HELP("Blend duration in seconds")),
  247.                         InputPortConfig<float>("SunLatitude",               -1.f,                                   _HELP("Blend from the current sun latitude in the level to this new specified latitude (value in degrees. -1=no latitude blending)")),
  248.                         InputPortConfig<float>("SunLongitude",              -1.f,                                   _HELP("blend from the current sun longitude in the level to this new specified longitude (value in degrees. -1=no longitude blending)")),
  249.                         InputPortConfig<float>("SunPositionUpdateInterval", 1.f,                                    _HELP("Amount of time in seconds between every update for the repositioning of the sun (0 second means the sun position is constantly updated during the transition) ")),
  250.                         InputPortConfig<float>("ForceUpdateInterval",       1.0f,                                   _HELP("amount of time in seconds between every update of the time of day (0 second means the time of day is constantly updated during the transition, not recommended for low spec) ")),
  251.                         InputPortConfig_Void("Start",                       _HELP("Starts the transition")),
  252.                         InputPortConfig_Void("Pause",                       _HELP("Pause/Unpause the transition")),
  253.                         { 0 }
  254.                 };
  255.                 static const SOutputPortConfig out_config[] = {
  256.                         OutputPortConfig_Void("Done", _HELP("triggers when transition is finished")),
  257.                         { 0 }
  258.                 };
  259.  
  260.                 config.sDescription = _HELP("Time of Day and sun position transitions.");
  261.                 config.pInputPorts = in_config;
  262.                 config.pOutputPorts = out_config;
  263.                 config.SetCategory(EFLN_APPROVED);
  264.         }
  265.  
  266.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  267.         {
  268.                 switch (event)
  269.                 {
  270.                 case eFE_Initialize:
  271.                         {
  272.                                 m_blending = false;
  273.                                 m_paused = false;
  274.                                 break;
  275.                         }
  276.  
  277.                 case eFE_Activate:
  278.                         {
  279.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  280.                                 if (!pTOD)
  281.                                         break;
  282.  
  283.                                 if (IsPortActive(pActInfo, IN_START))
  284.                                 {
  285.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  286.                                         m_durationLeft = GetPortFloat(pActInfo, IN_DURATION);
  287.                                         m_sunTimeToUpdate = GetPortFloat(pActInfo, IN_SUN_POSITION_UPDATE_INTERVAL);
  288.                                         m_TODTimeToUpdate = GetPortFloat(pActInfo, IN_TOD_FORCE_UPDATE_INTERVAL);
  289.                                         m_startSunLongitude = pTOD->GetSunLongitude();
  290.                                         m_startSunLatitude = pTOD->GetSunLatitude();
  291.                                         m_startTOD = pTOD->GetTime();
  292.                                         m_blending = true;
  293.                                         m_paused = false;
  294.                                         m_activeID = m_ID;
  295.                                 }
  296.                                 if (IsPortActive(pActInfo, IN_PAUSE))
  297.                                 {
  298.                                         if (m_blending)
  299.                                         {
  300.                                                 m_paused = !m_paused;
  301.                                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, !m_paused);
  302.                                         }
  303.                                 }
  304.                                 break;
  305.                         }
  306.  
  307.                 case eFE_Update:
  308.                         {
  309.                                 if (m_activeID != m_ID)
  310.                                 {
  311.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  312.                                         m_blending = false;
  313.                                         break;
  314.                                 }
  315.  
  316.                                 ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  317.                                 if (!pTOD)
  318.                                         break;
  319.  
  320.                                 m_durationLeft -= gEnv->pTimer->GetFrameTime();
  321.                                 bool forceUpdate = false;
  322.                                 if (m_durationLeft <= 0)
  323.                                 {
  324.                                         m_durationLeft = 0;
  325.                                         m_blending = false;
  326.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  327.                                         ActivateOutput(pActInfo, OUT_DONE, true);
  328.                                         forceUpdate = true;
  329.                                         m_activeID = 0xffffffff;
  330.                                 }
  331.                                 float totalDuration = GetPortFloat(pActInfo, IN_DURATION);
  332.                                 float blendPos = totalDuration == 0 ? 1.f : 1.f - (m_durationLeft / totalDuration);
  333.  
  334.                                 bool needUpdate = UpdateTOD(blendPos, pActInfo, pTOD, forceUpdate);
  335.                                 needUpdate |= UpdateSun(blendPos, pActInfo, pTOD, forceUpdate);
  336.  
  337.                                 if (needUpdate)
  338.                                         pTOD->Update(true, true);
  339.                                 break;
  340.                         }
  341.                 }
  342.         }
  343.  
  344.         bool UpdateTOD(float blendPos, SActivationInfo* pActInfo, ITimeOfDay* pTOD, bool forceUpdate)
  345.         {
  346.                 bool needUpdate = forceUpdate;
  347.                 float endTOD = GetPortFloat(pActInfo, IN_TOD);
  348.                 if (endTOD < 0)
  349.                         return needUpdate;
  350.  
  351.                 m_TODTimeToUpdate -= gEnv->pTimer->GetFrameTime();
  352.                 if (m_TODTimeToUpdate <= 0 || forceUpdate)
  353.                 {
  354.                         m_TODTimeToUpdate = GetPortFloat(pActInfo, IN_TOD_FORCE_UPDATE_INTERVAL);
  355.                         float currTime = m_startTOD + (endTOD - m_startTOD) * blendPos;
  356.                         pTOD->SetTime(currTime, false);
  357.                         needUpdate = true;
  358.                 }
  359.                 return needUpdate;
  360.         }
  361.  
  362.         bool UpdateSun(float blendPos, SActivationInfo* pActInfo, ITimeOfDay* pTOD, bool forceUpdate)
  363.         {
  364.                 bool needUpdate = forceUpdate;
  365.                 m_sunTimeToUpdate -= gEnv->pTimer->GetFrameTime();
  366.                 if (m_sunTimeToUpdate > 0 && !forceUpdate)
  367.                         return needUpdate;
  368.  
  369.                 m_sunTimeToUpdate = GetPortFloat(pActInfo, IN_SUN_POSITION_UPDATE_INTERVAL);
  370.  
  371.                 float endLatitude = GetPortFloat(pActInfo, IN_SUN_LATITUDE);
  372.                 float currLatitude = pTOD->GetSunLatitude();
  373.                 if (endLatitude >= 0)
  374.                 {
  375.                         currLatitude = m_startSunLatitude + (endLatitude - m_startSunLatitude) * blendPos;
  376.                         needUpdate = true;
  377.                 }
  378.  
  379.                 float endLongitude = GetPortFloat(pActInfo, IN_SUN_LONGITUDE);
  380.                 float currLongitude = pTOD->GetSunLongitude();
  381.                 if (endLongitude >= 0)
  382.                 {
  383.                         currLongitude = m_startSunLongitude + (endLongitude - m_startSunLongitude) * blendPos;
  384.                         needUpdate = true;
  385.                 }
  386.                 if (needUpdate)
  387.                         pTOD->SetSunPos(currLongitude, currLatitude);
  388.                 return needUpdate;
  389.         }
  390.  
  391.         virtual void GetMemoryUsage(ICrySizer* s) const
  392.         {
  393.                 s->Add(*this);
  394.         }
  395. };
  396.  
  397. CFlowNode_TimeOfDayTransitionTrigger::InternalID CFlowNode_TimeOfDayTransitionTrigger::m_IDCounter = 0;
  398. CFlowNode_TimeOfDayTransitionTrigger::InternalID CFlowNode_TimeOfDayTransitionTrigger::m_activeID = 0xffffffff;
  399.  
  400. class CFlowNode_EnvWind : public CFlowBaseNode<eNCT_Singleton>
  401. {
  402. public:
  403.         CFlowNode_EnvWind(SActivationInfo* pActInfo)
  404.         {
  405.         }
  406.  
  407.         enum EInputPorts
  408.         {
  409.                 eIP_Get = 0,
  410.         };
  411.  
  412.         enum EOutputPorts
  413.         {
  414.                 eOP_WindVector,
  415.         };
  416.  
  417.         void GetConfiguration(SFlowNodeConfig& config)
  418.         {
  419.                 static const SInputPortConfig in_config[] = {
  420.                         InputPortConfig_Void("Get", _HELP("Get the Current Environment Wind Vector")),
  421.                         { 0 }
  422.                 };
  423.                 static const SOutputPortConfig out_config[] = {
  424.                         OutputPortConfig<Vec3>("WindVector", _HELP("Current Environment Wind Vector")),
  425.                         { 0 }
  426.                 };
  427.                 config.pInputPorts = in_config;
  428.                 config.pOutputPorts = out_config;
  429.                 config.sDescription = _HELP("Get the Environment's Wind Data");
  430.                 config.SetCategory(EFLN_APPROVED);
  431.         }
  432.  
  433.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  434.         {
  435.                 switch (event)
  436.                 {
  437.                 case eFE_Activate:
  438.                         if (IsPortActive(pActInfo, eIP_Get))
  439.                         {
  440.                                 ActivateOutput(pActInfo, eOP_WindVector, gEnv->p3DEngine->GetGlobalWind(false));
  441.                         }
  442.                         break;
  443.                 }
  444.         }
  445.  
  446.         virtual void GetMemoryUsage(ICrySizer* s) const
  447.         {
  448.                 s->Add(*this);
  449.         }
  450.  
  451. };
  452.  
  453. //////////////////////////////////////////////////////////////////////////
  454. class CFlowNode_SetOceanMat : public CFlowBaseNode<eNCT_Singleton>
  455. {
  456. public:
  457.         CFlowNode_SetOceanMat(SActivationInfo* pActInfo)
  458.         {
  459.         }
  460.  
  461.         enum EInputPorts
  462.         {
  463.                 eIP_Set = 0,
  464.                 eIP_Material,
  465.         };
  466.  
  467.         enum EOutputPorts
  468.         {
  469.                 eOP_Success = 0,
  470.                 eOP_Failed,
  471.         };
  472.  
  473.         void GetConfiguration(SFlowNodeConfig& config)
  474.         {
  475.                 static const SInputPortConfig in_config[] = {
  476.                         InputPortConfig_Void("Set",         _HELP("Sets the material on the ocean")),
  477.                         InputPortConfig<string>("Material", _HELP("Material of choice to be set"),   0,_UICONFIG("dt=mat")),
  478.                         { 0 }
  479.                 };
  480.                 static const SOutputPortConfig out_config[] = {
  481.                         OutputPortConfig_Void("Success", _HELP("Triggered when successfully finished")),
  482.                         OutputPortConfig_Void("Failed",  _HELP("Triggered when something went wrong")),
  483.                         { 0 }
  484.                 };
  485.                 config.pInputPorts = in_config;
  486.                 config.pOutputPorts = out_config;
  487.                 config.sDescription = _HELP("Set the ocean material");
  488.                 config.SetCategory(EFLN_APPROVED);
  489.         }
  490.  
  491.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  492.         {
  493.                 switch (event)
  494.                 {
  495.                 case eFE_Activate:
  496.                         if (IsPortActive(pActInfo, eIP_Set))
  497.                         {
  498.                                 string mat = GetPortString(pActInfo, eIP_Material);
  499.                                 IMaterial* pMat = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(mat.c_str(), false);
  500.                                 if (pMat)
  501.                                 {
  502.                                         gEnv->p3DEngine->GetITerrain()->ChangeOceanMaterial(pMat);
  503.                                         ActivateOutput(pActInfo, eOP_Success, 0);
  504.                                 }
  505.                                 else
  506.                                 {
  507.                                         ActivateOutput(pActInfo, eOP_Failed, 0);
  508.                                 }
  509.                         }
  510.                         break;
  511.                 }
  512.         }
  513.  
  514.         virtual void GetMemoryUsage(ICrySizer* s) const
  515.         {
  516.                 s->Add(*this);
  517.         }
  518.  
  519. };
  520.  
  521. class CFlowNode_SkyMaterialSwitch : public CFlowBaseNode<eNCT_Singleton>
  522. {
  523. public:
  524.         CFlowNode_SkyMaterialSwitch(SActivationInfo* pActInfo){};
  525.         virtual void GetMemoryUsage(ICrySizer* s) const;
  526.         void         GetConfiguration(SFlowNodeConfig& config);
  527.         void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  528. };
  529.  
  530. void CFlowNode_SkyMaterialSwitch::GetMemoryUsage(ICrySizer* s) const
  531. {
  532.         s->Add(*this);
  533. }
  534.  
  535. void CFlowNode_SkyMaterialSwitch::GetConfiguration(SFlowNodeConfig& config)
  536. {
  537.         static const SInputPortConfig in_config[] = {
  538.                 InputPortConfig<string>("mat_Material", _HELP("Skybox material name")),
  539.                 InputPortConfig<bool>("Start",          false,                         _HELP("Trigger to start the loading")),
  540.                 InputPortConfig<float>("Angle",         1.f,                           _HELP("Sky box rotation")),
  541.                 InputPortConfig<float>("Stretching",    1.f,                           _HELP("Sky box stretching")),
  542.                 { 0 }
  543.         };
  544.  
  545.         config.pInputPorts = in_config;
  546.         config.sDescription = _HELP("Node for sky box switching");
  547.         config.SetCategory(EFLN_ADVANCED);
  548. }
  549.  
  550. void CFlowNode_SkyMaterialSwitch::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  551. {
  552.         switch (event)
  553.         {
  554.         case eFE_Activate:
  555.                 if (IsPortActive(pActInfo, 1))
  556.                 {
  557.                         gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_SKY_SKYBOX_ANGLE, GetPortFloat(pActInfo, 2));
  558.                         gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_SKY_SKYBOX_STRETCHING, GetPortFloat(pActInfo, 3));
  559.  
  560.                         string mat = GetPortString(pActInfo, 0);
  561.  
  562.                         IMaterial* pSkyMtl = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(mat, false, false, IMaterialManager::ELoadingFlagsPreviewMode);
  563.  
  564.                         if (pSkyMtl != NULL)
  565.                         {
  566.                                 gEnv->p3DEngine->SetSkyMaterial(pSkyMtl);
  567.                                 gEnv->pLog->Log("Sky box switched");
  568.                         }
  569.                         else
  570.                         {
  571.                                 gEnv->pLog->LogError("Error switching sky box: can't find material");
  572.                         }
  573.                 }
  574.                 break;
  575.         }
  576. }
  577.  
  578. //////////////////////////////////////////////////////////////////////////
  579. class CFlowNode_SetVolumetricCloudSwitch : public CFlowBaseNode<eNCT_Singleton>, public IStreamCallback
  580. {
  581. private:
  582.         const static bool AsyncLoad = true;
  583.  
  584.         IReadStreamPtr    m_Job;
  585.  
  586. public:
  587.         enum EInputPorts
  588.         {
  589.                 eIP_Texture = 0,
  590.                 eIP_TilingSize,
  591.                 eIP_TilingOffset,
  592.         };
  593.  
  594.         enum EOutputPorts
  595.         {
  596.                 eOP_Success = 0,
  597.                 eOP_Failed,
  598.         };
  599.  
  600.         CFlowNode_SetVolumetricCloudSwitch(SActivationInfo* pActInfo) : m_Job(nullptr)
  601.         {
  602.         }
  603.  
  604.         void GetConfiguration(SFlowNodeConfig& config) override
  605.         {
  606.                 static const SInputPortConfig in_config[] = {
  607.                         InputPortConfig<string>("Texture",    "",            _HELP("Set the volumetric cloud texture")),
  608.                         InputPortConfig<Vec3>("TilingSize",   Vec3(64000.0f, 64000.0f,                                  4000.0f),_HELP("Set the tiling size of volumetric cloud")),
  609.                         InputPortConfig<Vec3>("TilingOffset", Vec3(0.0f,     0.0f,                                      0.0f),  _HELP("Set the tiling offset of volumetric cloud")),
  610.                         { 0 }
  611.                 };
  612.                 static const SOutputPortConfig out_config[] = {
  613.                         OutputPortConfig_Void("Success", _HELP("Triggered when setting the texture successfully finished")),
  614.                         OutputPortConfig_Void("Failed",  _HELP("Triggered when setting the texture went wrong")),
  615.                         { 0 }
  616.                 };
  617.                 config.pInputPorts = in_config;
  618.                 config.pOutputPorts = out_config;
  619.                 config.sDescription = _HELP("Set the volumetric cloud texture");
  620.                 config.SetCategory(EFLN_APPROVED);
  621.         }
  622.  
  623.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) override
  624.         {
  625.                 switch (event)
  626.                 {
  627.                 case eFE_Activate:
  628.                         if (IsPortActive(pActInfo, eIP_TilingSize))
  629.                         {
  630.                                 gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_TILING_SIZE, GetPortVec3(pActInfo, eIP_TilingSize));
  631.                         }
  632.                         if (IsPortActive(pActInfo, eIP_TilingOffset))
  633.                         {
  634.                                 gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_VOLCLOUD_TILING_OFFSET, -GetPortVec3(pActInfo, eIP_TilingOffset));
  635.                         }
  636.                         if (IsPortActive(pActInfo, eIP_Texture) && (m_Job == nullptr))
  637.                         {
  638.                                 bool success = false;
  639.                                 if (AsyncLoad)
  640.                                 {
  641.                                         string szNameTex = GetPortString(pActInfo, eIP_Texture);
  642.                                         if (szNameTex.empty())
  643.                                         {
  644.                                                 gEnv->pRenderer->SetVolumetricCloudParams(0);
  645.                                                 success = true;
  646.                                         }
  647.                                         else if (gEnv->pCryPak->IsFileExist(szNameTex.c_str()))
  648.                                         {
  649.                                                 m_Job = gEnv->pSystem->GetStreamEngine()->StartRead(eStreamTaskTypeTexture, szNameTex, this);
  650.                                                 success = true;
  651.                                         }
  652.                                         else
  653.                                         {
  654.                                                 gEnv->pLog->LogError("Volumetric cloud texture not found: %s", szNameTex.c_str());
  655.                                                 success = false;
  656.                                         }
  657.                                 }
  658.                                 else
  659.                                 {
  660.                                         int texId = 0;
  661.                                         string szNameTex = GetPortString(pActInfo, eIP_Texture);
  662.                                         if (szNameTex.empty())
  663.                                         {
  664.                                                 gEnv->pRenderer->SetVolumetricCloudParams(0);
  665.                                                 success = true;
  666.                                         }
  667.                                         else if (gEnv->pCryPak->IsFileExist(szNameTex.c_str()))
  668.                                         {
  669.                                                 ITexture* pTex = gEnv->pRenderer->EF_LoadTexture(szNameTex.c_str());
  670.                                                 if (pTex)
  671.                                                 {
  672.                                                         texId = pTex->GetTextureID();
  673.                                                         if (texId > 0)
  674.                                                         {
  675.                                                                 gEnv->pRenderer->SetVolumetricCloudParams(texId);
  676.                                                         }
  677.                                                 }
  678.  
  679.                                                 if (!pTex || texId <= 0)
  680.                                                 {
  681.                                                         gEnv->pLog->LogError("Error loading volumetric cloud texture: %s", szNameTex.c_str());
  682.                                                         success = false;
  683.                                                 }
  684.                                                 else
  685.                                                 {
  686.                                                         success = true;
  687.                                                 }
  688.                                         }
  689.                                         else
  690.                                         {
  691.                                                 gEnv->pLog->LogError("Volumetric cloud texture not found: %s", szNameTex.c_str());
  692.                                                 success = false;
  693.                                         }
  694.                                 }
  695.  
  696.                                 if (success)
  697.                                 {
  698.                                         ActivateOutput(pActInfo, eOP_Success, 0);
  699.                                 }
  700.                                 else
  701.                                 {
  702.                                         ActivateOutput(pActInfo, eOP_Failed, 0);
  703.                                 }
  704.                         }
  705.                         break;
  706.                 }
  707.         }
  708.  
  709.         virtual void GetMemoryUsage(ICrySizer* s) const override
  710.         {
  711.                 s->Add(*this);
  712.         }
  713.  
  714.         virtual void StreamOnComplete(IReadStream* pStream, unsigned nError) override
  715.         {
  716.                 if (pStream->IsError())
  717.                 {
  718.                         gEnv->pLog->LogError("Error loading volumetric cloud texture: %s", pStream->GetName());
  719.                         CRY_ASSERT(0);
  720.                         m_Job = nullptr;
  721.                         return;
  722.                 }
  723.  
  724.                 int texId = 0;
  725.                 const char* pNameTex = pStream->GetName();
  726.                 if (pNameTex && gEnv->pCryPak->IsFileExist(pNameTex))
  727.                 {
  728.                         ITexture* pTex = gEnv->pRenderer->EF_LoadTexture(pNameTex, FT_DONT_STREAM);
  729.                         if (pTex)
  730.                         {
  731.                                 texId = pTex->GetTextureID();
  732.                                 if (texId > 0)
  733.                                 {
  734.                                         gEnv->pRenderer->SetVolumetricCloudParams(texId);
  735.                                 }
  736.                         }
  737.  
  738.                         if (!pTex || texId <= 0)
  739.                         {
  740.                                 gEnv->pLog->LogError("Error loading volumetric cloud texture: %s", pNameTex);
  741.                         }
  742.                 }
  743.                 else
  744.                 {
  745.                         gEnv->pLog->LogError("Volumetric cloud texture not found: %s", pNameTex);
  746.                 }
  747.  
  748.                 m_Job = nullptr;
  749.         }
  750. };
  751.  
  752. class CFlowNode_PresetSwitch : public CFlowBaseNode<eNCT_Singleton>
  753. {
  754. public:
  755.         CFlowNode_PresetSwitch(SActivationInfo* pActInfo)
  756.         {
  757.         }
  758.  
  759.         virtual void GetMemoryUsage(ICrySizer* s) const
  760.         {
  761.                 s->Add(*this);
  762.         }
  763.  
  764.         enum EInputs
  765.         {
  766.                 eIN_Activate = 0,
  767.                 eIN_PresetName,
  768.         };
  769.  
  770.         enum EOutputPorts
  771.         {
  772.                 eOP_Success = 0,
  773.                 eOP_Failed,
  774.         };
  775.  
  776.         void GetConfiguration(SFlowNodeConfig& config)
  777.         {
  778.                 static const SInputPortConfig in_config[] = {
  779.                         InputPortConfig_Void("Activate",  _HELP("Input for switching time of day to this preset")),
  780.                         InputPortConfig<string>("Preset", _HELP("Preset name")),
  781.                         //blend time might be here
  782.                         { 0 }
  783.                 };
  784.  
  785.                 static const SOutputPortConfig out_config[] = {
  786.                         OutputPortConfig_Void("Success", _HELP("Triggered when successfully finished")),
  787.                         OutputPortConfig_Void("Failed",  _HELP("Triggered when something went wrong")),
  788.                         { 0 }
  789.                 };
  790.  
  791.                 config.pInputPorts = in_config;
  792.                 config.pOutputPorts = out_config;
  793.                 config.sDescription = _HELP("Switch environment preset");
  794.                 config.SetCategory(EFLN_ADVANCED);
  795.         }
  796.  
  797.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  798.         {
  799.                 switch (event)
  800.                 {
  801.                 case eFE_Activate:
  802.                         {
  803.                                 if (IsPortActive(pActInfo, eIN_Activate))
  804.                                 {
  805.                                         const string& sPresetName = GetPortString(pActInfo, eIN_PresetName);
  806.                                         ITimeOfDay* pTOD = gEnv->p3DEngine->GetTimeOfDay();
  807.                                         bool bResult = false;
  808.  
  809.                                         if (pTOD)
  810.                                         {
  811.                                                 bResult = pTOD->SetCurrentPreset(sPresetName.c_str());
  812.                                         }
  813.  
  814.                                         ActivateOutput(pActInfo, bResult ? eOP_Success : eOP_Failed, 0);
  815.                                 }
  816.                         }
  817.                         break;
  818.                 }
  819.         }
  820. };
  821.  
  822. REGISTER_FLOW_NODE("Environment:MoonDirection", CFlowNode_EnvMoonDirection);
  823. REGISTER_FLOW_NODE("Environment:Sun", CFlowNode_EnvSun);
  824. REGISTER_FLOW_NODE("Time:TimeOfDayTransitionTrigger", CFlowNode_TimeOfDayTransitionTrigger)
  825. REGISTER_FLOW_NODE("Environment:Wind", CFlowNode_EnvWind)
  826. REGISTER_FLOW_NODE("Environment:SetOceanMaterial", CFlowNode_SetOceanMat)
  827. REGISTER_FLOW_NODE("Environment:SkyMaterialSwitch", CFlowNode_SkyMaterialSwitch);
  828. REGISTER_FLOW_NODE("Environment:VolumetericCloudSwitch", CFlowNode_SetVolumetricCloudSwitch);
  829. REGISTER_FLOW_NODE("Environment:PresetSwitch", CFlowNode_PresetSwitch);
  830.  
downloadFlowEnvironmentNodes.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