BVB Source Codes

CRYENGINE Show ComputeLightingNode.cpp Source code

Return Download CRYENGINE: download ComputeLightingNode.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.  
  7. class CComputeLighting_Node : public CFlowBaseNode<eNCT_Singleton>
  8. {
  9.  
  10. public:
  11.         CComputeLighting_Node(SActivationInfo* pActInfo)
  12.         {
  13.         };
  14.         virtual void GetMemoryUsage(ICrySizer* s) const
  15.         {
  16.                 s->Add(*this);
  17.         }
  18.         virtual void GetConfiguration(SFlowNodeConfig& config)
  19.         {
  20.                 static const SInputPortConfig in_config[] = {
  21.                         InputPortConfig<Vec3>("Position", _HELP("Position to compute lighting at")),
  22.                         InputPortConfig<float>("Radius",  1.0f,                                       _HELP("Radius around the position")),
  23.                         InputPortConfig<bool>("Accuracy", _HELP("TRUE for accurate, FALSE for fast")),
  24.                         { 0 }
  25.                 };
  26.                 static const SOutputPortConfig out_config[] = {
  27.                         OutputPortConfig<float>("Light", _HELP("Light output")),
  28.                         { 0 }
  29.                 };
  30.                 config.sDescription = _HELP("Compute the amount of light at a given point");
  31.                 config.pInputPorts = in_config;
  32.                 config.pOutputPorts = out_config;
  33.                 config.SetCategory(EFLN_APPROVED);
  34.         }
  35.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  36.         {
  37.                 switch (event)
  38.                 {
  39.                 case eFE_Activate:
  40.                         {
  41.                                 float r = gEnv->p3DEngine->GetLightAmountInRange(
  42.                                   GetPortVec3(pActInfo, 0),
  43.                                   GetPortFloat(pActInfo, 1),
  44.                                   GetPortBool(pActInfo, 2));
  45.                                 ActivateOutput(pActInfo, 0, r);
  46.                                 break;
  47.                         }
  48.  
  49.                 case eFE_Initialize:
  50.                         {
  51.                                 ActivateOutput(pActInfo, 0, 0.0f);
  52.                         }
  53.  
  54.                 case eFE_Update:
  55.                         {
  56.                                 break;
  57.                         }
  58.                 }
  59.                 ;
  60.         };
  61. };
  62.  
  63. class CComputeStaticShadows_Node : public CFlowBaseNode<eNCT_Singleton>
  64. {
  65. public:
  66.         CComputeStaticShadows_Node(SActivationInfo* pActInfo)
  67.         {
  68.         }
  69.  
  70.         enum EInputs
  71.         {
  72.                 eI_Trigger = 0,
  73.                 eI_Min,
  74.                 eI_Max,
  75.                 eI_NextCascadeScale
  76.         };
  77.  
  78.         virtual void GetConfiguration(SFlowNodeConfig& config)
  79.         {
  80.                 static const SInputPortConfig inputs[] = {
  81.                         InputPortConfig_Void("Trigger",             _HELP("Trigger this to recompute all cached shadows")),
  82.                         InputPortConfig<Vec3>("Min",                Vec3(ZERO),                                            _HELP("Minimum position of shadowed area")),
  83.                         InputPortConfig<Vec3>("Max",                Vec3(ZERO),                                            _HELP("Maximum position of shadowed area")),
  84.                         InputPortConfig<float>("NextCascadesScale", 2.f,                                                   _HELP("Scale factor for subsequent cached shadow cascades")),
  85.                         { 0 }
  86.                 };
  87.                 static const SOutputPortConfig outputs[] = {
  88.                         { 0 }
  89.                 };
  90.                 config.pInputPorts = inputs;
  91.                 config.pOutputPorts = outputs;
  92.                 config.sDescription = _HELP("Triggers recalculation of cached shadow maps");
  93.                 config.SetCategory(EFLN_APPROVED);
  94.         }
  95.  
  96.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  97.         {
  98.                 EFlowEvent eventType = event;
  99.  
  100.                 switch (event)
  101.                 {
  102.                 case eFE_Activate:
  103.                         {
  104.                                 if (IsPortActive(pActInfo, eI_Trigger))
  105.                                 {
  106.                                         pActInfo->pGraph->RequestFinalActivation(pActInfo->myID);
  107.                                 }
  108.  
  109.                                 break;
  110.                         }
  111.  
  112.                 case eFE_FinalActivate:
  113.                         {
  114.                                 Vec3 minCorner = GetPortVec3(pActInfo, eI_Min);
  115.                                 Vec3 maxCorner = GetPortVec3(pActInfo, eI_Max);
  116.                                 float nextCascadeScale = GetPortFloat(pActInfo, eI_NextCascadeScale);
  117.  
  118.                                 gEnv->p3DEngine->SetCachedShadowBounds(AABB(minCorner, maxCorner), nextCascadeScale);
  119.                                 break;
  120.                         }
  121.                 }
  122.         }
  123.  
  124.         virtual void GetMemoryUsage(ICrySizer* s) const
  125.         {
  126.                 s->Add(*this);
  127.         }
  128. };
  129.  
  130. class CPerEntityShadow_Node : public CFlowBaseNode<eNCT_Instanced>
  131. {
  132.  
  133. public:
  134.         CPerEntityShadow_Node(SActivationInfo* pActInfo)
  135.         {
  136.         }
  137.  
  138.         enum EInputs
  139.         {
  140.                 eI_Enable = 0,
  141.                 eI_Trigger,
  142.                 eI_ConstBias,
  143.                 eI_SlopeBias,
  144.                 eI_Jittering,
  145.                 eI_BBoxScale,
  146.                 eI_ShadowMapSize,
  147.         };
  148.  
  149.         virtual void GetConfiguration(SFlowNodeConfig& config)
  150.         {
  151.                 static const SInputPortConfig inputs[] = {
  152.                         InputPortConfig<bool>("Enabled",      true,                        "Enables node",            "Enabled"),
  153.                         InputPortConfig_Void("Trigger",       _HELP("Update the engine")),
  154.                         InputPortConfig<float>("ConstBias",   0.001f,                      _HELP("Constant Bias")),
  155.                         InputPortConfig<float>("SlopeBias",   0.01f,                       _HELP("Slope Bias")),
  156.                         InputPortConfig<float>("Jittering",   0.01f,                       _HELP("Jittering")),
  157.                         InputPortConfig<Vec3>("BBoxScale",    Vec3(1,                      1,                         1),        _HELP("Object Bounding box scale")),
  158.                         InputPortConfig<int>("ShadowMapSize", 1024,                        _HELP("Shadow Map size")),
  159.                         { 0 }
  160.                 };
  161.                 static const SOutputPortConfig outputs[] = {
  162.                         { 0 }
  163.                 };
  164.                 config.nFlags |= EFLN_TARGET_ENTITY;
  165.                 config.pInputPorts = inputs;
  166.                 config.pOutputPorts = outputs;
  167.                 config.sDescription = _HELP("Per Entity Shadows");
  168.                 config.SetCategory(EFLN_APPROVED);
  169.         }
  170.  
  171.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  172.         {
  173.                 EFlowEvent eventType = event;
  174.  
  175.                 switch (event)
  176.                 {
  177.                 case eFE_Activate:
  178.                         {
  179.                                 if (IsPortActive(pActInfo, eI_Trigger) && gEnv->pAISystem->IsEnabled())
  180.                                 {
  181.                                         pActInfo->pGraph->RequestFinalActivation(pActInfo->myID);
  182.                                 }
  183.  
  184.                                 break;
  185.                         }
  186.  
  187.                 case eFE_FinalActivate:
  188.                         {
  189.                                 if (!pActInfo->pEntity)
  190.                                         break;
  191.  
  192.                                 if (pActInfo->pEntity->GetId() != INVALID_ENTITYID)
  193.                                 {
  194.                                         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(pActInfo->pEntity->GetId());
  195.                                         if (pEntity && pEntity->GetRenderInterface())
  196.                                         {
  197.                                                 IEntityRender* pIEntityRender = pEntity->GetRenderInterface();
  198.                                                 if (IRenderNode* pRenderNode = pIEntityRender->GetRenderNode())
  199.                                                 {
  200.                                                         const bool bActivate = GetPortBool(pActInfo, eI_Enable);
  201.                                                         if (bActivate)
  202.                                                         {
  203.                                                                 float fConstBias = GetPortFloat(pActInfo, eI_ConstBias);
  204.                                                                 float fSlopeBias = GetPortFloat(pActInfo, eI_SlopeBias);
  205.                                                                 float fJittering = GetPortFloat(pActInfo, eI_Jittering);
  206.                                                                 Vec3 vBBoxScale = GetPortVec3(pActInfo, eI_BBoxScale);
  207.                                                                 uint nShadowMapSize = GetPortInt(pActInfo, eI_ShadowMapSize);
  208.  
  209.                                                                 gEnv->p3DEngine->AddPerObjectShadow(pRenderNode, fConstBias, fSlopeBias, fJittering, vBBoxScale, nShadowMapSize);
  210.                                                         }
  211.                                                         else
  212.                                                         {
  213.                                                                 gEnv->p3DEngine->RemovePerObjectShadow(pRenderNode);
  214.                                                         }
  215.                                                 }
  216.                                         }
  217.                                 }
  218.                                 break;
  219.                         }
  220.                 }
  221.         }
  222.  
  223.         virtual void GetMemoryUsage(ICrySizer* s) const
  224.         {
  225.                 s->Add(*this);
  226.         }
  227.  
  228.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CPerEntityShadow_Node(pActInfo); }
  229.  
  230. };
  231.  
  232. REGISTER_FLOW_NODE("Environment:ComputeLighting", CComputeLighting_Node);
  233. REGISTER_FLOW_NODE("Environment:RecomputeStaticShadows", CComputeStaticShadows_Node);
  234. REGISTER_FLOW_NODE("Environment:PerEntityShadows", CPerEntityShadow_Node);
  235.  
downloadComputeLightingNode.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