BVB Source Codes

CRYENGINE Show FlowEngineNodes.cpp Source code

Return Download CRYENGINE: download FlowEngineNodes.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 "ILevelSystem.h"
  5.  
  6. #include <CrySystem/IStreamEngine.h>
  7. #include <CryFlowGraph/IFlowBaseNode.h>
  8. #include <CryEntitySystem/IEntityLayer.h>
  9.  
  10. class CFlowNode_PortalSwitch : public CFlowBaseNode<eNCT_Instanced>
  11. {
  12. public:
  13.         CFlowNode_PortalSwitch(SActivationInfo* pActInfo)
  14.                 : m_bActivated(false)
  15.         {
  16.         }
  17.  
  18.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_PortalSwitch(pActInfo); }
  19.  
  20.         virtual void         GetMemoryUsage(ICrySizer* s) const
  21.         {
  22.                 s->Add(*this);
  23.         }
  24.  
  25.         void GetConfiguration(SFlowNodeConfig& config)
  26.         {
  27.                 static const SInputPortConfig in_config[] = {
  28.                         InputPortConfig<SFlowSystemVoid>("Activate"),
  29.                         InputPortConfig<SFlowSystemVoid>("Deactivate"),
  30.                         { 0 }
  31.                 };
  32.                 config.nFlags |= EFLN_TARGET_ENTITY;
  33.                 config.pInputPorts = in_config;
  34.                 config.SetCategory(EFLN_ADVANCED);
  35.         }
  36.  
  37.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  38.         {
  39.                 ser.Value("activated", m_bActivated);
  40.  
  41.                 if (ser.IsReading())
  42.                         ActivatePortal(pActInfo, m_bActivated);
  43.         }
  44.  
  45.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  46.         {
  47.                 switch (event)
  48.                 {
  49.                 case eFE_SetEntityId:
  50.                         {
  51.                                 if (!pActInfo->pEntity)
  52.                                         return;
  53.                                 // don't disable here, because it will trigger on QL as well
  54.                                 //gEnv->p3DEngine->ActivatePortal( pActInfo->pEntity->GetWorldPos(), false, pActInfo->pEntity->GetName() );
  55.                         }
  56.                         break;
  57.  
  58.                 case eFE_Initialize:
  59.                         {
  60.                                 ActivatePortal(pActInfo, false);    // i think this one is not needed anymore, but im keeping it just in case
  61.                         }
  62.                         break;
  63.                 case eFE_Activate:
  64.                         {
  65.                                 if (!pActInfo->pEntity)
  66.                                 {
  67.                                         GameWarning("[flow] Trying to activate a portal at a non-existent entity");
  68.                                         return;
  69.                                 }
  70.                                 bool doAnything = false;
  71.                                 bool activate = false;
  72.                                 if (IsPortActive(pActInfo, 0))
  73.                                 {
  74.                                         doAnything = true;
  75.                                         activate = true;
  76.                                 }
  77.                                 else if (IsPortActive(pActInfo, 1))
  78.                                 {
  79.                                         doAnything = true;
  80.                                         activate = false;
  81.                                 }
  82.                                 if (doAnything)
  83.                                 {
  84.                                         ActivatePortal(pActInfo, activate);
  85.                                 }
  86.                         }
  87.                         break;
  88.                 }
  89.         }
  90.  
  91.         void ActivatePortal(SActivationInfo* pActInfo, bool bActivate)
  92.         {
  93.                 if (pActInfo->pEntity)
  94.                 {
  95.                         gEnv->p3DEngine->ActivatePortal(pActInfo->pEntity->GetWorldPos(), bActivate, pActInfo->pEntity->GetName());
  96.                         m_bActivated = bActivate;
  97.                 }
  98.         }
  99.  
  100. private:
  101.         bool m_bActivated;
  102.  
  103. };
  104.  
  105. //////////////////////////////////////////////////////////////////////////////////////
  106. // Node for ocean rendering management ///////////////////////////////////////////////
  107. //////////////////////////////////////////////////////////////////////////////////////
  108.  
  109. class CFlowNode_OceanSwitch : public CFlowBaseNode<eNCT_Singleton>
  110. {
  111. public:
  112.         CFlowNode_OceanSwitch(SActivationInfo* pActInfo)
  113.         {
  114.         }
  115.  
  116.         virtual void GetMemoryUsage(ICrySizer* s) const
  117.         {
  118.                 s->Add(*this);
  119.         }
  120.  
  121.         void GetConfiguration(SFlowNodeConfig& config)
  122.         {
  123.                 static const SInputPortConfig in_config[] = {
  124.                         InputPortConfig<bool>("Enable", true, _HELP("Input for enabling/disabling ocean rendering")),
  125.                         { 0 }
  126.                 };
  127.                 config.pInputPorts = in_config;
  128.                 config.sDescription = _HELP("Enabling ocean rendering on demand");
  129.                 config.SetCategory(EFLN_ADVANCED);
  130.         }
  131.  
  132.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  133.         {
  134.                 switch (event)
  135.                 {
  136.                 case eFE_Activate:
  137.                         if (IsPortActive(pActInfo, 0))
  138.                         {
  139.                                 bool bEnabled = GetPortBool(pActInfo, 0);
  140.                                 gEnv->p3DEngine->EnableOceanRendering(bEnabled);
  141.                         }
  142.                         break;
  143.                 }
  144.         }
  145. };
  146.  
  147. //////////////////////////////////////////////////////////////////////////////////////
  148. //  Sky box asynchronous loading /////////////////////////////////////////////////////
  149. //! [GDC09]: Async change SkyBox material[deprecated]   //////////////////////////////
  150. //////////////////////////////////////////////////////////////////////////////////////
  151. namespace SkyBoxLoading
  152. {
  153. class CSkyBoxLoadingCallback;
  154. };
  155.  
  156. class CFlowNode_SkyboxSwitch : public CFlowBaseNode<eNCT_Instanced>
  157. {
  158.         friend class SkyBoxLoading::CSkyBoxLoadingCallback;
  159. protected:
  160.         IReadStreamPtr m_Job;
  161. public:
  162.         CFlowNode_SkyboxSwitch(SActivationInfo* pActInfo);
  163.         virtual void         GetMemoryUsage(ICrySizer* s) const;
  164.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_SkyboxSwitch(pActInfo); }
  165.         void                 GetConfiguration(SFlowNodeConfig& config);
  166.         void                 ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  167. };
  168.  
  169. namespace SkyBoxLoading
  170. {
  171. class CSkyBoxLoadingCallback : public IStreamCallback
  172. {
  173.         virtual void StreamAsyncOnComplete(IReadStream* pStream, unsigned nError);
  174.         virtual void StreamOnComplete(IReadStream* pStream, unsigned nError);
  175. };
  176.  
  177. struct SSkyboxLoadingInfo
  178. {
  179.         uint32                        nSelfSize;
  180.         string                        sSkyTextureName;
  181.         ITexture*                     pTextures[3];
  182.         class CFlowNode_SkyboxSwitch* pParentNode;
  183.         CSkyBoxLoadingCallback        pCallBack;
  184.  
  185.         SSkyboxLoadingInfo(class CFlowNode_SkyboxSwitch* _pParent)
  186.         {
  187.                 pTextures[0] = NULL;
  188.                 pTextures[1] = NULL;
  189.                 pTextures[2] = NULL;
  190.                 pParentNode = _pParent;
  191.                 nSelfSize = sizeof(SSkyboxLoadingInfo);
  192.         }
  193. };
  194.  
  195. void CSkyBoxLoadingCallback::StreamAsyncOnComplete(IReadStream* pStream, unsigned nError)
  196. {
  197.         CRY_ASSERT(nError == 0);
  198.         SSkyboxLoadingInfo* pSkyboxLoadingInfo = (SSkyboxLoadingInfo*)pStream->GetParams().dwUserData;
  199.         if (!pSkyboxLoadingInfo || pSkyboxLoadingInfo->nSelfSize != sizeof(SSkyboxLoadingInfo))
  200.         {
  201.                 CRY_ASSERT(0);
  202.                 return;
  203.         }
  204.  
  205.         static const char* pNameSuffixes[] = { "box_12.dds", "box_34.dds", "box_5.dds" };
  206.         string szNameBump;
  207.         for (uint32 i = 0; i < 3; ++i)
  208.         {
  209.                 szNameBump = PathUtil::Make(pSkyboxLoadingInfo->sSkyTextureName, pNameSuffixes[i]);
  210.                 // check if the texture exists
  211.                 if (gEnv->pCryPak->IsFileExist(szNameBump))
  212.                         pSkyboxLoadingInfo->pTextures[i] = gEnv->pRenderer->EF_LoadTexture(szNameBump, FT_DONT_STREAM);
  213.                 else
  214.                 {
  215.                         gEnv->pLog->LogError("Sky box texture not found: %s", szNameBump.c_str());
  216.                         for (uint32 j = i; j < 3; ++j)
  217.                         {
  218.                                 SAFE_RELEASE(pSkyboxLoadingInfo->pTextures[i]);
  219.                         }
  220.                         return;
  221.                 }
  222.                 // in case of error release the rest textures
  223.                 if (!pSkyboxLoadingInfo->pTextures[i])
  224.                 {
  225.                         gEnv->pLog->LogError("Error loading sky box texture: %s", szNameBump.c_str());
  226.                         CRY_ASSERT(0);
  227.                         for (uint32 j = i; j < 3; ++j)
  228.                         {
  229.                                 SAFE_RELEASE(pSkyboxLoadingInfo->pTextures[i]);
  230.                         }
  231.                         return;
  232.                 }
  233.         }
  234. }
  235.  
  236. void CSkyBoxLoadingCallback::StreamOnComplete(IReadStream* pStream, unsigned nError)
  237. {
  238.         CRY_ASSERT(nError == 0);
  239.         SSkyboxLoadingInfo* pSkyboxLoadingInfo = (SSkyboxLoadingInfo*)pStream->GetParams().dwUserData;
  240.         if (!pSkyboxLoadingInfo || pSkyboxLoadingInfo->nSelfSize != sizeof(SSkyboxLoadingInfo) || !pSkyboxLoadingInfo->pTextures[0])
  241.         {
  242.                 CRY_ASSERT(0);
  243.                 gEnv->pLog->LogError("Error switching sky box");
  244.                 if (pSkyboxLoadingInfo != nullptr && pSkyboxLoadingInfo->pParentNode != nullptr)
  245.                 {
  246.                         pSkyboxLoadingInfo->pParentNode->m_Job = nullptr;
  247.                 }
  248.                 return;
  249.         }
  250.  
  251.         IMaterial* pSkyMat = gEnv->p3DEngine->GetSkyMaterial();
  252.  
  253.         bool bSucceeded = false;
  254.         if (pSkyMat && !(pSkyMat->GetFlags() & EF_SKY))
  255.         {
  256.                 SShaderItem& rShaderItem = pSkyMat->GetShaderItem();
  257.                 if (rShaderItem.m_pShaderResources)
  258.                 {
  259.                         SSkyInfo* pSkyInfo = rShaderItem.m_pShaderResources->GetSkyInfo();
  260.  
  261.                         if (pSkyInfo)
  262.                         {
  263.                                 for (int i = 0; i < 3; ++i)
  264.                                 {
  265.                                         SAFE_RELEASE(pSkyInfo->m_SkyBox[i]);
  266.                                         pSkyInfo->m_SkyBox[i] = pSkyboxLoadingInfo->pTextures[i];
  267.                                 }
  268.                                 bSucceeded = true;
  269.                         }
  270.                 }
  271.         }
  272.  
  273.         // remove job
  274.         pSkyboxLoadingInfo->pParentNode->m_Job = NULL;
  275.  
  276.         if (!bSucceeded)
  277.         {
  278.                 gEnv->pLog->LogError("Error switching sky box: HDR sky box is not supported [deprecated]");
  279.                 for (int i = 0; i < 3; ++i)
  280.                         SAFE_RELEASE(pSkyboxLoadingInfo->pTextures[i]);
  281.         }
  282.         else
  283.         {
  284.                 gEnv->pLog->Log("Sky box switched [deprecated]");
  285.         }
  286. }
  287. }
  288.  
  289. CFlowNode_SkyboxSwitch::CFlowNode_SkyboxSwitch(SActivationInfo* pActInfo)
  290. {
  291.         m_Job = NULL;
  292. }
  293.  
  294. void CFlowNode_SkyboxSwitch::GetMemoryUsage(ICrySizer* s) const
  295. {
  296.         s->Add(*this);
  297. }
  298.  
  299. void CFlowNode_SkyboxSwitch::GetConfiguration(SFlowNodeConfig& config)
  300. {
  301.         static const SInputPortConfig in_config[] = {
  302.                 InputPortConfig<string>("Texture",   "",    _HELP("Skybox texture name")),
  303.                 InputPortConfig<bool>("Start",       false, _HELP("Trigger to start the loading")),
  304.                 InputPortConfig<float>("Angle",      1.f,   _HELP("Sky box rotation")),
  305.                 InputPortConfig<float>("Stretching", 1.f,   _HELP("Sky box stretching")),
  306.                 { 0 }
  307.         };
  308.  
  309.         config.pInputPorts = in_config;
  310.         config.sDescription = _HELP("Node for asynchronous sky box switching");
  311.         config.SetCategory(EFLN_ADVANCED);
  312. }
  313.  
  314. void CFlowNode_SkyboxSwitch::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  315. {
  316.         switch (event)
  317.         {
  318.         case eFE_Activate:
  319.                 // start loading signal
  320.                 if (IsPortActive(pActInfo, 1) && !m_Job)
  321.                 {
  322.                         // set up sky box size and angle
  323.                         gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_SKY_SKYBOX_ANGLE, GetPortFloat(pActInfo, 2));
  324.                         gEnv->p3DEngine->SetGlobalParameter(E3DPARAM_SKY_SKYBOX_STRETCHING, GetPortFloat(pActInfo, 3));
  325.  
  326.                         string sTextureName = GetPortString(pActInfo, 0);
  327.                         // start asynchronous job
  328.                         {
  329.                                 // fill streaming params
  330.                                 SkyBoxLoading::SSkyboxLoadingInfo* pSkyboxLoadingInfo = new SkyBoxLoading::SSkyboxLoadingInfo(this);
  331.                                 pSkyboxLoadingInfo->sSkyTextureName = sTextureName;
  332.                                 StreamReadParams pStreamParams;
  333.                                 pStreamParams.nFlags = 0;
  334.                                 pStreamParams.dwUserData = (DWORD_PTR)pSkyboxLoadingInfo;
  335.                                 //                              pStreamParams.nPriority = 0;
  336.                                 pStreamParams.pBuffer = NULL;
  337.                                 pStreamParams.nOffset = 0;
  338.                                 pStreamParams.nSize = 0;
  339.                                 m_Job = gEnv->pSystem->GetStreamEngine()->StartRead(eStreamTaskTypeTexture, sTextureName, &pSkyboxLoadingInfo->pCallBack, &pStreamParams);
  340.                         }
  341.                 }
  342.                 break;
  343.         }
  344. }
  345.  
  346. //////////////////////////////////////////////////////////////////////////////////////
  347. // Node for layer switching rendering management ///////////////////////////////////////////////
  348. //////////////////////////////////////////////////////////////////////////////////////
  349.  
  350. class CFlowNode_LayerSwitch : public CFlowBaseNode<eNCT_Singleton>
  351. {
  352. public:
  353.         CFlowNode_LayerSwitch(SActivationInfo* pActInfo)
  354.         {
  355.         }
  356.  
  357.         virtual void GetMemoryUsage(ICrySizer* s) const
  358.         {
  359.                 s->Add(*this);
  360.         }
  361.  
  362.         enum EInputs
  363.         {
  364.                 eIN_LAYER_NAME = 0,
  365.                 eIN_HIDE,
  366.                 eIN_UNHIDE,
  367.                 eIN_SERIALIZE,
  368.                 eIN_DONT_SERIALIZE
  369.         };
  370.  
  371.         void GetConfiguration(SFlowNodeConfig& config)
  372.         {
  373.                 static const SInputPortConfig in_config[] = {
  374.                         InputPortConfig<string>("Layer",             _HELP("Layer name")),
  375.                         InputPortConfig_Void("Hide",                 _HELP("Input for enabling objects in layer rendering")),
  376.                         InputPortConfig_Void("Unhide",               _HELP("Input for disabling objects in layer rendering")),
  377.                         InputPortConfig_Void("EnableSerialization",  _HELP("Input for enabling objects in this layer being saved/loaded.")),
  378.                         InputPortConfig_Void("DisableSerialization", _HELP("Input for disabling objects in this layer being saved/loaded.")),
  379.                         { 0 }
  380.                 };
  381.  
  382.                 static const SOutputPortConfig out_config[] = {
  383.                         OutputPortConfig_Void("Hidden",   _HELP("Triggered if Boolean was False")),
  384.                         OutputPortConfig_Void("Unhidden", _HELP("Triggered if Boolean was True")),
  385.                         { 0 }
  386.                 };
  387.  
  388.                 config.pInputPorts = in_config;
  389.                 config.pOutputPorts = out_config;
  390.                 config.sDescription = _HELP("Activate/Deactivate objects in layer");
  391.                 config.SetCategory(EFLN_ADVANCED);
  392.         }
  393.  
  394.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  395.         {
  396.                 switch (event)
  397.                 {
  398.                 case eFE_Activate:
  399.                         {
  400.                                 const string& szLayerName = GetPortString(pActInfo, eIN_LAYER_NAME);
  401.                                 const IEntityLayer* const pLayer = gEnv->pEntitySystem->FindLayer(szLayerName.c_str());
  402.  
  403.                                 if (IsPortActive(pActInfo, eIN_UNHIDE))
  404.                                 {
  405.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  406.                                         if (pLayer)
  407.                                         {
  408.                                                 EnableLayer(pActInfo, true, pLayer->IsSerialized());
  409.                                         }
  410.                                 }
  411.                                 else
  412.                                 {
  413.                                         bool bEnabled = true;
  414.                                         bool bSave = true;
  415.                                         if (IsPortActive(pActInfo, eIN_HIDE))
  416.                                         {
  417.                                                 bEnabled = false;
  418.                                         }
  419.                                         else if (pLayer)
  420.                                         {
  421.                                                 bEnabled = pLayer->IsEnabled();
  422.                                         }
  423.  
  424.                                         if (IsPortActive(pActInfo, eIN_SERIALIZE))
  425.                                         {
  426.                                                 bSave = true;
  427.                                         }
  428.                                         else if (IsPortActive(pActInfo, eIN_DONT_SERIALIZE))
  429.                                         {
  430.                                                 bSave = false;
  431.                                         }
  432.                                         else if (pLayer)
  433.                                         {
  434.                                                 bSave = pLayer->IsSerialized();
  435.                                         }
  436.  
  437.                                         EnableLayer(pActInfo, bEnabled, bSave);
  438.                                 }
  439.                                 break;
  440.                         }
  441.  
  442.                 case eFE_Update:
  443.                         {
  444.                                 EnableLayer(pActInfo, true, true);
  445.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  446.                                 break;
  447.                         }
  448.                 }
  449.         }
  450.  
  451.         void EnableLayer(SActivationInfo* pActInfo, bool bEnable, bool bSave)
  452.         {
  453.                 stack_string layer = GetPortString(pActInfo, eIN_LAYER_NAME);
  454.  
  455.                 if (gEnv->pEntitySystem)
  456.                 {
  457.                         gEnv->pEntitySystem->EnableLayer(layer, bEnable, bSave);
  458.                         if (bEnable && gEnv->pAISystem)
  459.                                 gEnv->pAISystem->LayerEnabled(layer.c_str(), bEnable, bSave);
  460.                 }
  461.                 ActivateOutput(pActInfo, bEnable ? 1 : 0, true);
  462.         }
  463. };
  464.  
  465. //////////////////////////////////////////////////////////////////////////////////////
  466. // FlowNode to set material on object in specified position  /////////////////////////////
  467. //////////////////////////////////////////////////////////////////////////////////////
  468.  
  469. class CFlowNode_SetObjectMaterial : public CFlowBaseNode<eNCT_Instanced>
  470. {
  471. public:
  472.         CFlowNode_SetObjectMaterial(SActivationInfo* pActInfo) :
  473.                 m_ppObjects(0),
  474.                 m_nObjType(0)
  475.         {
  476.                 //STATIC_CHECK(eERType_TypesNum == 26, Sync_enum_in_GetConfiguration_ObjectType_port_with_new_entries_on_EERType);
  477.         }
  478.  
  479.         ~CFlowNode_SetObjectMaterial()
  480.         {
  481.                 RestoreMaterials();
  482.         }
  483.  
  484.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_SetObjectMaterial(pActInfo); }
  485.  
  486.         virtual void         GetMemoryUsage(ICrySizer* s) const
  487.         {
  488.                 s->Add(*this);
  489.         }
  490.  
  491.         enum EInputs
  492.         {
  493.                 eIn_Material = 0,
  494.                 eIn_ObjectType,
  495.                 eIn_Position,
  496.                 eIn_Activate,
  497.         };
  498.  
  499.         void GetConfiguration(SFlowNodeConfig& config)
  500.         {
  501.                 static const SInputPortConfig in_config[] = {
  502.                         InputPortConfig<string>("mat_Material", _HELP("Material name")),
  503.                         InputPortConfig<int>("ObjectType", 0, _HELP("Object type (render node type)"), NULL,
  504.                                 _UICONFIG("enum_int:<choose>=0,Brush=1,Vegetation=2,Light=3,Cloud=4,FogVolume=6,Decal=7,ParticleEmitter=8,WaterVolume=9,WaterWave=10,Road=11,DistanceCloud=12,VolumeObject=13,Rope=15,PrismObject=16,RenderProxy=19,GameEffect=20,BreakableGlass=21,MergedMesh=23,GeomCache=24")),
  505.                         InputPortConfig<Vec3>("Position", _HELP("Position")),
  506.                         InputPortConfig_Void("Activate", _HELP("Activate set material event")),
  507.                         { 0 }
  508.                 };
  509.  
  510.                 static const SOutputPortConfig out_config[] = {
  511.                         { 0 }
  512.                 };
  513.  
  514.                 config.pInputPorts = in_config;
  515.                 config.pOutputPorts = out_config;
  516.                 config.sDescription = _HELP("Set material to object (render node) at position");
  517.                 config.SetCategory(EFLN_APPROVED);
  518.         }
  519.  
  520.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  521.         {
  522.                 switch (event)
  523.                 {
  524.                 case eFE_Initialize:
  525.                         {
  526.                                 RestoreMaterials();
  527.                         }
  528.                         break;
  529.                 case eFE_Activate:
  530.                         {
  531.                                 if (IsPortActive(pActInfo, eIn_Activate))
  532.                                 {
  533.                                         m_pos = GetPortVec3(pActInfo, eIn_Position);
  534.                                         m_nObjType = GetPortInt(pActInfo, eIn_ObjectType);
  535.                                         RestoreMaterials();
  536.                                         SetMaterial(GetPortString(pActInfo, eIn_Material));
  537.                                 }
  538.                         }
  539.                         break;
  540.                 }
  541.         }
  542.  
  543.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  544.         {
  545.                 if (ser.IsReading())
  546.                 {
  547.                         RestoreMaterials();
  548.                         string mtlName;
  549.                         ser.Value("mtlName", mtlName);
  550.                         if (!mtlName.empty())
  551.                         {
  552.                                 SetMaterial(mtlName);
  553.                         }
  554.                 }
  555.                 else // saving
  556.                 {
  557.                         if (m_ppObjects && m_ppObjects[0] && m_ppObjects[0]->GetMaterial())
  558.                         {
  559.                                 ser.Value("mtlName", m_ppObjects[0]->GetMaterial()->GetName());
  560.                         }
  561.                 }
  562.         }
  563.  
  564. private:
  565.         void SetMaterial(const string& mtlName)
  566.         {
  567.                 _smart_ptr<IMaterial> pMtl = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(mtlName.c_str());
  568.                 if (pMtl && m_nObjType > 0)
  569.                 {
  570.                         AABB aabbPos(m_pos - Vec3(.1f, .1f, .1f), m_pos + Vec3(.1f, .1f, .1f));
  571.                         // Get count of render nodes first
  572.                         uint32 nCnt = gEnv->p3DEngine->GetObjectsByTypeInBox((EERType) m_nObjType, aabbPos);
  573.                         if (nCnt)
  574.                         {
  575.                                 m_ppObjects = new IRenderNode*[nCnt];
  576.                                 gEnv->p3DEngine->GetObjectsByTypeInBox((EERType) m_nObjType, aabbPos, m_ppObjects);
  577.                                 for (uint32 i = 0; i < nCnt; ++i)
  578.                                 {
  579.                                         m_materials.push_back(m_ppObjects[i]->GetMaterial());
  580.                                         m_ppObjects[i]->SetMaterial(pMtl);
  581.                                 }
  582.                         }
  583.                 }
  584.         }
  585.  
  586.         void RestoreMaterials()
  587.         {
  588.                 if (m_ppObjects)
  589.                 {
  590.                         size_t size = m_materials.size();
  591.                         for (size_t i = 0; i < size; ++i)
  592.                         {
  593.                                 m_ppObjects[i]->SetMaterial(m_materials[i]);
  594.                         }
  595.                         SAFE_DELETE_ARRAY(m_ppObjects)
  596.                         m_materials.clear();
  597.                 }
  598.         }
  599.  
  600. private:
  601.         IRenderNode**                      m_ppObjects;
  602.         std::vector<_smart_ptr<IMaterial>> m_materials;
  603.         Vec3                               m_pos;
  604.         int                                m_nObjType;
  605. };
  606.  
  607. //////////////////////////////////////////////////////////////////////////////////////
  608. // FlowNode to precache area at specified position  ///////////////////////////////////////
  609. //////////////////////////////////////////////////////////////////////////////////////
  610.  
  611. class CFlowNode_PrecacheArea : public CFlowBaseNode<eNCT_Singleton>
  612. {
  613. public:
  614.         CFlowNode_PrecacheArea(SActivationInfo* pActInfo)
  615.         {
  616.         }
  617.  
  618.         virtual void GetMemoryUsage(ICrySizer* s) const
  619.         {
  620.                 s->Add(*this);
  621.         }
  622.  
  623.         enum EInputs
  624.         {
  625.                 eIn_Position = 0,
  626.                 eIn_Timeout,
  627.                 eIn_Activate,
  628.         };
  629.  
  630.         void GetConfiguration(SFlowNodeConfig& config)
  631.         {
  632.                 static const SInputPortConfig in_config[] = {
  633.                         InputPortConfig<Vec3>("Position", _HELP("Position")),
  634.                         InputPortConfig<float>("Timeout", 3.0f,                               _HELP("Time out in seconds")),
  635.                         InputPortConfig_Void("Activate",  _HELP("Activate precaching event")),
  636.                         { 0 }
  637.                 };
  638.  
  639.                 static const SOutputPortConfig out_config[] = {
  640.                         { 0 }
  641.                 };
  642.  
  643.                 config.pInputPorts = in_config;
  644.                 config.pOutputPorts = out_config;
  645.                 config.sDescription = _HELP("Precache area at specified position");
  646.                 config.SetCategory(EFLN_APPROVED);
  647.         }
  648.  
  649.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  650.         {
  651.                 switch (event)
  652.                 {
  653.                 case eFE_Activate:
  654.                         {
  655.                                 if (IsPortActive(pActInfo, eIn_Activate))
  656.                                 {
  657.                                         gEnv->p3DEngine->OverrideCameraPrecachePoint(GetPortVec3(pActInfo, eIn_Position));
  658.                                 }
  659.                         }
  660.                         break;
  661.                 }
  662.         }
  663. };
  664.  
  665. class CFlowNode_Viewport : public CFlowBaseNode<eNCT_Singleton>
  666. {
  667. public:
  668.         CFlowNode_Viewport(SActivationInfo* pActInfo)
  669.         {
  670.         }
  671.  
  672.         virtual void GetMemoryUsage(ICrySizer* s) const
  673.         {
  674.                 s->Add(*this);
  675.         }
  676.  
  677.         enum EInputs
  678.         {
  679.                 eIn_Get,
  680.         };
  681.  
  682.         enum EOutputs
  683.         {
  684.                 eOut_X,
  685.                 eOut_Y,
  686.                 eOut_Width,
  687.                 eOut_Height
  688.         };
  689.  
  690.         void GetConfiguration(SFlowNodeConfig& config)
  691.         {
  692.                 static const SInputPortConfig in_config[] = {
  693.                         InputPortConfig_Void("Get", _HELP("Get current viewport information")),
  694.                         { 0 }
  695.                 };
  696.  
  697.                 static const SOutputPortConfig out_config[] = {
  698.                         OutputPortConfig<int>("x",      "Current top left x position of the viewport."),
  699.                         OutputPortConfig<int>("y",      "Current top left y position of the viewport."),
  700.                         OutputPortConfig<int>("width",  "Current width of the viewport."),
  701.                         OutputPortConfig<int>("height", "Current height of the viewport."),
  702.                         { 0 }
  703.                 };
  704.  
  705.                 config.pInputPorts = in_config;
  706.                 config.pOutputPorts = out_config;
  707.                 config.sDescription = _HELP("Gets current rendering viewport information.");
  708.                 config.SetCategory(EFLN_APPROVED);
  709.         }
  710.  
  711.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  712.         {
  713.                 switch (event)
  714.                 {
  715.                 case eFE_Activate:
  716.                         {
  717.                                 if (IsPortActive(pActInfo, eIn_Get))
  718.                                 {
  719.                                         int x = 0;
  720.                                         int y = 0;
  721.                                         int width = 0;
  722.                                         int height = 0;
  723.                                         gEnv->pRenderer->GetViewport(&x, &y, &width, &height);
  724.  
  725.                                         ActivateOutput(pActInfo, eOut_X, x);
  726.                                         ActivateOutput(pActInfo, eOut_Y, y);
  727.                                         ActivateOutput(pActInfo, eOut_Width, width);
  728.                                         ActivateOutput(pActInfo, eOut_Height, height);
  729.                                 }
  730.                         }
  731.                         break;
  732.                 }
  733.         }
  734. };
  735.  
  736. //////////////////////////////////////////////////////////////////////////////////////
  737.  
  738. REGISTER_FLOW_NODE("Engine:PortalSwitch", CFlowNode_PortalSwitch);
  739. REGISTER_FLOW_NODE("Environment:OceanSwitch", CFlowNode_OceanSwitch);
  740. REGISTER_FLOW_NODE("Environment:SkyboxSwitch", CFlowNode_SkyboxSwitch);
  741. REGISTER_FLOW_NODE("Engine:LayerSwitch", CFlowNode_LayerSwitch);
  742. REGISTER_FLOW_NODE("Material:SetObjectMaterial", CFlowNode_SetObjectMaterial);
  743. REGISTER_FLOW_NODE("Engine:PrecacheArea", CFlowNode_PrecacheArea);
  744. REGISTER_FLOW_NODE("Engine:Viewport", CFlowNode_Viewport);
  745.  
downloadFlowEngineNodes.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