BVB Source Codes

CRYENGINE Show CloudRenderNode.cpp Source code

Return Download CRYENGINE: download CloudRenderNode.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   CloudRenderNode.h
  5. //  Version:     v1.00
  6. //  Created:     15/2/2005 by Timur.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15.  
  16. #include "CloudRenderNode.h"
  17. #include "CloudsManager.h"
  18. #include "VisAreas.h"
  19. #include "ObjMan.h"
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. CCloudRenderNode::CCloudRenderNode()
  23. {
  24.         GetInstCount(GetRenderNodeType())++;
  25.  
  26.         m_bounds.min = Vec3(-1, -1, -1);
  27.         m_bounds.max = Vec3(1, 1, 1);
  28.         m_fScale = 1.0f;
  29.         m_offsetedMatrix.SetIdentity();
  30.         m_matrix.SetIdentity();
  31.         m_vOffset.Set(0, 0, 0);
  32.         m_alpha = 1.f;
  33.  
  34.         m_pCloudRenderElement = (CREBaseCloud*)GetRenderer()->EF_CreateRE(eDATA_Cloud);
  35.         m_pREImposter = (CREImposter*) GetRenderer()->EF_CreateRE(eDATA_Imposter);
  36.  
  37.         GetCloudsManager()->AddCloudRenderNode(this);
  38.  
  39.         m_origin = Vec3(0, 0, 0);
  40. }
  41.  
  42. //////////////////////////////////////////////////////////////////////////
  43. CCloudRenderNode::~CCloudRenderNode()
  44. {
  45.         GetInstCount(GetRenderNodeType())--;
  46.  
  47.         GetCloudsManager()->RemoveCloudRenderNode(this);
  48.         m_pCloudRenderElement->Release(false);
  49.         m_pREImposter->Release(false);
  50.  
  51.         Get3DEngine()->FreeRenderNodeState(this);
  52. }
  53.  
  54. //////////////////////////////////////////////////////////////////////////
  55. bool CCloudRenderNode::LoadCloudFromXml(XmlNodeRef root)
  56. {
  57.         m_pCloudDesc = new SCloudDescription;
  58.         GetCloudsManager()->ParseCloudFromXml(root, m_pCloudDesc);
  59.  
  60.         SetCloudDesc(m_pCloudDesc);
  61.         return true;
  62. }
  63.  
  64. //////////////////////////////////////////////////////////////////////////
  65. bool CCloudRenderNode::LoadCloud(const char* sCloudFilename)
  66. {
  67.         m_bounds.min = Vec3(-1, -1, -1);
  68.         m_bounds.max = Vec3(1, 1, 1);
  69.  
  70.         SetCloudDesc(GetCloudsManager()->LoadCloud(sCloudFilename));
  71.  
  72.         return m_pCloudDesc != 0;
  73. }
  74.  
  75. //////////////////////////////////////////////////////////////////////////
  76. void CCloudRenderNode::SetMovementProperties(const SCloudMovementProperties& properties)
  77. {
  78.         m_moveProps = properties;
  79. }
  80.  
  81. //////////////////////////////////////////////////////////////////////////
  82. void CCloudRenderNode::SetCloudDesc(SCloudDescription* pCloud)
  83. {
  84.         m_pCloudDesc = pCloud;
  85.         if (m_pCloudDesc != NULL && m_pCloudDesc->m_particles.size() > 0)
  86.         {
  87.                 m_vOffset = m_pCloudDesc->m_offset;
  88.                 m_bounds.min = m_pCloudDesc->m_bounds.min - m_pCloudDesc->m_offset;
  89.                 m_bounds.max = m_pCloudDesc->m_bounds.max - m_pCloudDesc->m_offset;
  90.                 if (m_pCloudDesc->m_pMaterial)
  91.                         m_pMaterial = m_pCloudDesc->m_pMaterial;
  92.                 m_pCloudRenderElement->SetParticles(&m_pCloudDesc->m_particles[0], m_pCloudDesc->m_particles.size());
  93.  
  94.                 m_WSBBox.SetTransformedAABB(m_matrix, m_bounds);
  95.                 m_fScale = m_matrix.GetColumn(0).GetLength();
  96.                 // Offset matrix by the cloud bounds offset.
  97.                 m_offsetedMatrix = m_matrix * Matrix34::CreateTranslationMat(-m_vOffset);
  98.         }
  99. }
  100.  
  101. //////////////////////////////////////////////////////////////////////////
  102. void CCloudRenderNode::SetMatrix(const Matrix34& mat)
  103. {
  104.         SetMatrixInternal(mat, true);
  105. }
  106.  
  107. //////////////////////////////////////////////////////////////////////////
  108. void CCloudRenderNode::SetMatrixInternal(const Matrix34& mat, bool updateOrigin)
  109. {
  110.         m_dwRndFlags |= ERF_OUTDOORONLY;
  111.  
  112.         if (updateOrigin)
  113.                 m_origin = mat.GetTranslation();
  114.  
  115.         m_matrix = mat;
  116.         m_pos = mat.GetTranslation();
  117.         //      m_WSBBox.SetTransformedAABB( m_matrix,m_bounds );
  118.         m_fScale = mat.GetColumn(0).GetLength();
  119.         m_WSBBox.SetTransformedAABB(Matrix34::CreateTranslationMat(m_pos), AABB(m_bounds.min * m_fScale, m_bounds.max * m_fScale));
  120.  
  121.         // Offset matrix by the cloud bounds offset.
  122.         //      m_offsetedMatrix = m_matrix * Matrix34::CreateTranslationMat(-m_vOffset);
  123.         m_offsetedMatrix = Matrix34::CreateTranslationMat(m_pos - m_vOffset * m_fScale);
  124.         m_offsetedMatrix.ScaleColumn(Vec3(m_fScale, m_fScale, m_fScale));
  125.         Get3DEngine()->RegisterEntity(this);
  126. }
  127.  
  128. //////////////////////////////////////////////////////////////////////////
  129. void CCloudRenderNode::MoveCloud()
  130. {
  131.         FUNCTION_PROFILER_3DENGINE;
  132.  
  133.         Vec3 pos(m_matrix.GetTranslation());
  134.  
  135.         ITimer* pTimer(gEnv->pTimer);
  136.         if (m_moveProps.m_autoMove)
  137.         {
  138.                 // update position
  139.                 float deltaTime = pTimer->GetFrameTime();
  140.  
  141.                 assert(deltaTime >= 0);
  142.  
  143.                 pos += deltaTime * m_moveProps.m_speed;
  144.  
  145.                 // constrain movement to specified loop box
  146.                 Vec3 loopBoxMin(m_origin - m_moveProps.m_spaceLoopBox);
  147.                 Vec3 loopBoxMax(m_origin + m_moveProps.m_spaceLoopBox);
  148.  
  149.                 if (pos.x < loopBoxMin.x)
  150.                         pos.x = loopBoxMax.x;
  151.                 if (pos.y < loopBoxMin.y)
  152.                         pos.y = loopBoxMax.y;
  153.                 if (pos.z < loopBoxMin.z)
  154.                         pos.z = loopBoxMax.z;
  155.  
  156.                 if (pos.x > loopBoxMax.x)
  157.                         pos.x = loopBoxMin.x;
  158.                 if (pos.y > loopBoxMax.y)
  159.                         pos.y = loopBoxMin.y;
  160.                 if (pos.z > loopBoxMax.z)
  161.                         pos.z = loopBoxMin.z;
  162.  
  163.                 // set new position
  164.                 Matrix34 mat(m_matrix);
  165.                 mat.SetTranslation(pos);
  166.                 SetMatrixInternal(mat, false);
  167.  
  168.                 // fade out clouds at the borders of the loop box
  169.                 if (m_moveProps.m_fadeDistance > 0)
  170.                 {
  171.                         Vec3 fade(max(m_moveProps.m_spaceLoopBox.x, m_moveProps.m_fadeDistance),
  172.                                   max(m_moveProps.m_spaceLoopBox.y, m_moveProps.m_fadeDistance),
  173.                                   max(m_moveProps.m_spaceLoopBox.z, m_moveProps.m_fadeDistance));
  174.  
  175.                         fade -= Vec3(fabs(pos.x - m_origin.x), fabs(pos.y - m_origin.y), fabs(pos.z - m_origin.z));
  176.  
  177.                         m_alpha = clamp_tpl(min(min(fade.x, fade.y), fade.z) / m_moveProps.m_fadeDistance, 0.0f, 1.0f);
  178.                 }
  179.         }
  180.         else
  181.         {
  182.                 if ((m_origin - pos).GetLengthSquared() > 1e-4f)
  183.                 {
  184.                         Matrix34 mat(m_matrix);
  185.                         mat.SetTranslation(m_origin);
  186.                         SetMatrixInternal(mat, false);
  187.                 }
  188.         }
  189. }
  190.  
  191. //////////////////////////////////////////////////////////////////////////
  192. void CCloudRenderNode::Render(const SRendParams& rParams, const SRenderingPassInfo& passInfo)
  193. {
  194.         FUNCTION_PROFILER_3DENGINE;
  195.  
  196.         if (!m_pCloudDesc)
  197.                 return;
  198.  
  199.         IMaterial* pMaterial = (m_pMaterial) ? m_pMaterial : m_pCloudDesc->m_pMaterial;
  200.  
  201.         if (!pMaterial || !passInfo.RenderClouds())
  202.                 return;
  203.  
  204.         IRenderer* pRenderer(GetRenderer());
  205.  
  206.         // get render objects
  207.         CRenderObject* pRO = pRenderer->EF_GetObject_Temp(passInfo.ThreadID());
  208.         if (!pRO)
  209.                 return;
  210.  
  211.         SShaderItem& shaderItem = (rParams.pMaterial) ? rParams.pMaterial->GetShaderItem(0) : pMaterial->GetShaderItem(0);
  212.  
  213.         pRO->m_II.m_Matrix = m_offsetedMatrix;
  214.         pRO->m_ObjFlags |= FOB_TRANS_MASK;
  215.         SRenderObjData* pOD = pRO->GetObjData();
  216.         pRO->m_pRE = m_pREImposter;
  217.         pOD->m_fTempVars[0] = m_fScale;
  218.         pRO->m_fSort = 0;
  219.         pRO->m_fDistance = rParams.fDistance;
  220.         int nAfterWater = CObjManager::IsAfterWater(m_offsetedMatrix.GetTranslation(), passInfo.GetCamera().GetPosition(), passInfo, Get3DEngine()->GetWaterLevel()) ? 1 : 0;
  221.         pRO->m_II.m_AmbColor = rParams.AmbientColor;
  222.         pRO->m_fAlpha = rParams.fAlpha * m_alpha;
  223.  
  224.         float mvd(GetMaxViewDist());
  225.         float d((passInfo.GetCamera().GetPosition() - m_offsetedMatrix.GetTranslation()).GetLength());
  226.         if (d > 0.9f * mvd)
  227.         {
  228.                 float s(clamp_tpl(1.0f - (d - 0.9f * mvd) / (0.1f * mvd), 0.0f, 1.0f));
  229.                 pRO->m_fAlpha *= s;
  230.         }
  231.  
  232.         pRenderer->EF_AddEf(m_pCloudRenderElement, shaderItem, pRO, passInfo, EFSLIST_TRANSP, nAfterWater);
  233. }
  234.  
  235. //////////////////////////////////////////////////////////////////////////
  236. bool CCloudRenderNode::CheckIntersection(const Vec3& p1, const Vec3& p2)
  237. {
  238.         if (p1 == p2)
  239.                 return false;
  240.         if (m_pCloudDesc && m_pCloudDesc->m_pCloudTree)
  241.         {
  242.                 Vec3 outp;
  243.                 if (Intersect::Lineseg_AABB(Lineseg(p1, p2), m_WSBBox, outp))
  244.                 {
  245.                         Matrix34 pInv = m_offsetedMatrix.GetInverted();
  246.                         return m_pCloudDesc->m_pCloudTree->CheckIntersection(pInv * p1, pInv * p2);
  247.                 }
  248.         }
  249.         return false;
  250. }
  251.  
  252. void CCloudRenderNode::OffsetPosition(const Vec3& delta)
  253. {
  254.         if (m_pTempData) m_pTempData->OffsetPosition(delta);
  255.         m_pos += delta;
  256.         m_origin += delta;
  257.         m_matrix.SetTranslation(m_matrix.GetTranslation() + delta);
  258.         m_offsetedMatrix.SetTranslation(m_offsetedMatrix.GetTranslation() + delta);
  259.         m_WSBBox.Move(delta);
  260. }
  261.  
  262. void CCloudRenderNode::FillBBox(AABB& aabb)
  263. {
  264.         aabb = CCloudRenderNode::GetBBox();
  265. }
  266.  
  267. EERType CCloudRenderNode::GetRenderNodeType()
  268. {
  269.         return eERType_Cloud;
  270. }
  271.  
  272. float CCloudRenderNode::GetMaxViewDist()
  273. {
  274.         if (GetMinSpecFromRenderNodeFlags(m_dwRndFlags) == CONFIG_DETAIL_SPEC)
  275.                 return max(GetCVars()->e_ViewDistMin, CCloudRenderNode::GetBBox().GetRadius() * GetCVars()->e_ViewDistRatioDetail * GetViewDistRatioNormilized());
  276.  
  277.         return max(GetCVars()->e_ViewDistMin, CCloudRenderNode::GetBBox().GetRadius() * GetCVars()->e_ViewDistRatio * GetViewDistRatioNormilized());
  278. }
  279.  
  280. Vec3 CCloudRenderNode::GetPos(bool bWorldOnly) const
  281. {
  282.         return m_pos;
  283. }
  284.  
  285. IMaterial* CCloudRenderNode::GetMaterial(Vec3* pHitPos) const
  286. {
  287.         return m_pMaterial;
  288. }
  289.  
downloadCloudRenderNode.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