BVB Source Codes

CRYENGINE Show CloudsManager.cpp Source code

Return Download CRYENGINE: download CloudsManager.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:   CloudsManager.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 "MatMan.h"
  19.  
  20. //////////////////////////////////////////////////////////////////////////
  21. SCloudDescription::~SCloudDescription()
  22. {
  23.         delete m_pCloudTree;
  24.         m_pCloudTree = 0;
  25.         // Unregister itself from clouds manager.
  26.         if (!filename.empty())
  27.                 Get3DEngine()->GetCloudsManager()->Unregister(this);
  28. }
  29.  
  30. //////////////////////////////////////////////////////////////////////////
  31. SCloudDescription* CCloudsManager::LoadCloud(const char* sFilename)
  32. {
  33.         string filename = PathUtil::ToUnixPath(sFilename);
  34.  
  35.         SCloudDescription* pCloud = stl::find_in_map(m_cloudsMap, filename, NULL);
  36.         if (!pCloud)
  37.         {
  38.                 XmlNodeRef root = GetISystem()->LoadXmlFromFile(filename);
  39.                 if (root)
  40.                 {
  41.                         pCloud = new SCloudDescription;
  42.                         pCloud->filename = filename;
  43.                         ParseCloudFromXml(root, pCloud);
  44.  
  45.                         CloudParticles particles;
  46.                         particles.resize(pCloud->m_particles.size());
  47.                         for (uint32 i = 0; i < particles.size(); i++)
  48.                                 particles[i] = &pCloud->m_particles[i];
  49.                         pCloud->m_pCloudTree = new SCloudQuadTree();
  50.                         pCloud->m_pCloudTree->Init(pCloud->m_bounds, particles);
  51.  
  52.                         Register(pCloud);
  53.                 }
  54.         }
  55.  
  56.         return pCloud;
  57. }
  58.  
  59. //////////////////////////////////////////////////////////////////////////
  60. void CCloudsManager::ParseCloudFromXml(XmlNodeRef root, SCloudDescription* pCloud)
  61. {
  62.         assert(pCloud);
  63.  
  64.         pCloud->m_bounds.min = Vec3(0, 0, 0);
  65.         pCloud->m_bounds.max = Vec3(0, 0, 0);
  66.         pCloud->m_pMaterial = 0;
  67.         const char* sMtlName = root->getAttr("Material");
  68.         if (sMtlName && sMtlName[0] != '\0')
  69.         {
  70.                 pCloud->m_pMaterial = GetMatMan()->LoadMaterial(sMtlName);
  71.  
  72.                 if (!pCloud->m_pMaterial)
  73.                         CryWarning(VALIDATOR_MODULE_3DENGINE, VALIDATOR_ERROR, "Error: Failed to load cloud material" /*,sMtlName*/);
  74.         }
  75.  
  76.         int numRows = 1;
  77.         int numCols = 1;
  78.         root->getAttr("TextureNumRows", numRows);
  79.         root->getAttr("TextureNumCols", numCols);
  80.         if (numRows < 1)
  81.                 numRows = 1;
  82.         if (numCols < 1)
  83.                 numCols = 1;
  84.  
  85.         pCloud->m_textureRows = numRows;
  86.         pCloud->m_textureCols = numCols;
  87.  
  88.         pCloud->m_numSprites = root->getChildCount();
  89.         pCloud->m_particles.reserve(pCloud->m_numSprites);
  90.         pCloud->m_particles.clear();
  91.  
  92.         float xTextureStep = 1.0f / numCols;
  93.         float yTextureStep = 1.0f / numRows;
  94.  
  95.         Vec3 pos(0, 0, 0);
  96.         int texID = 0;
  97.         float angle = 0;
  98.         float radius = 0;
  99.         Vec2 uv[2];
  100.         if (pCloud->m_numSprites > 0)
  101.                 pCloud->m_bounds.Reset();
  102.         for (int i = 0; i < root->getChildCount(); i++)
  103.         {
  104.                 XmlNodeRef child = root->getChild(i);
  105.                 child->getAttr("Pos", pos);
  106.                 child->getAttr("texID", texID);
  107.                 child->getAttr("Radius", radius);
  108.                 if (!child->getAttr("Angle", angle))
  109.                         angle = 0;
  110.  
  111.                 int x = texID % numCols;
  112.                 int y = texID / numCols;
  113.  
  114.                 uv[0].x = x * xTextureStep;
  115.                 uv[0].y = y * yTextureStep;
  116.                 uv[1].x = (x + 1) * xTextureStep;
  117.                 uv[1].y = (y + 1) * yTextureStep;
  118.  
  119.                 SCloudParticle sprite(pos, radius, radius, 0, 0, uv);
  120.                 pCloud->m_particles.push_back(sprite);
  121.  
  122.                 pCloud->m_bounds.Add(pos - Vec3(radius, radius, radius));
  123.                 pCloud->m_bounds.Add(pos + Vec3(radius, radius, radius));
  124.         }
  125.  
  126.         // Offset particles so that bounding box is centered at origin.
  127.         pCloud->m_offset = -pCloud->m_bounds.GetCenter();
  128.         pCloud->m_bounds.min += pCloud->m_offset;
  129.         pCloud->m_bounds.max += pCloud->m_offset;
  130.  
  131.         for (uint32 i = 0; i < pCloud->m_particles.size(); i++)
  132.         {
  133.                 pCloud->m_particles[i].SetPosition(pCloud->m_particles[i].GetPosition() + pCloud->m_offset);
  134.         }
  135. }
  136.  
  137. //////////////////////////////////////////////////////////////////////////
  138. void CCloudsManager::Register(SCloudDescription* desc)
  139. {
  140.         assert(desc);
  141.         m_cloudsMap[desc->filename] = desc;
  142. }
  143.  
  144. //////////////////////////////////////////////////////////////////////////
  145. void CCloudsManager::Unregister(SCloudDescription* desc)
  146. {
  147.         assert(desc);
  148.         m_cloudsMap.erase(desc->filename);
  149. }
  150.  
  151. //////////////////////////////////////////////////////////////////////////
  152. void CCloudsManager::AddCloudRenderNode(CCloudRenderNode* pNode)
  153. {
  154.         m_cloudNodes.push_back(pNode);
  155. }
  156.  
  157. //////////////////////////////////////////////////////////////////////////
  158. void CCloudsManager::RemoveCloudRenderNode(CCloudRenderNode* pNode)
  159. {
  160.         int size = m_cloudNodes.size();
  161.         for (int i = 0; i < size; i++)
  162.         {
  163.                 if (m_cloudNodes[i] == pNode)
  164.                 {
  165.                         if (i < size - 1)
  166.                                 m_cloudNodes[i] = m_cloudNodes[size - 1];
  167.                         m_cloudNodes.resize(size - 1);
  168.                         break;
  169.                 }
  170.         }
  171. }
  172.  
  173. //!!! WARNING
  174. //bool Sp_IsDraw = false;
  175. //Matrix34 Sp_Mat;
  176. //Vec3 Sp_Pos;
  177. //float Sp_Rad;
  178.  
  179. //////////////////////////////////////////////////////////////////////////
  180. bool CCloudsManager::CheckIntersectClouds(const Vec3& p1, const Vec3& p2)
  181. {
  182.         for (std::vector<CCloudRenderNode*>::iterator it = m_cloudNodes.begin(); it != m_cloudNodes.end(); ++it)
  183.         {
  184.                 //Sp_IsDraw = false;
  185.                 if ((*it)->CheckIntersection(p1, p2))
  186.                 {
  187.                         //Sp_Mat = (*it)->m_offsetedMatrix;
  188.                         //Sp_IsDraw = true;
  189.                         return true;
  190.                 }
  191.         }
  192.         return false;
  193. }
  194.  
  195. //////////////////////////////////////////////////////////////////////////
  196. void CCloudsManager::MoveClouds()
  197. {
  198.         FUNCTION_PROFILER_3DENGINE;
  199.  
  200.         std::vector<CCloudRenderNode*>::iterator it(m_cloudNodes.begin());
  201.         std::vector<CCloudRenderNode*>::iterator itEnd(m_cloudNodes.end());
  202.         for (; it != itEnd; ++it)
  203.         {
  204.                 (*it)->MoveCloud();
  205.         }
  206. }
  207.  
  208. //////////////////////////////////////////////////////////////////////////
  209. void SCloudQuadTree::Init(const AABB& bounds, const CloudParticles& particles, int maxlevel)
  210. {
  211.         m_bounds = bounds;
  212.  
  213.         if (m_level >= maxlevel)
  214.         {
  215.                 m_particles.resize(particles.size());
  216.                 memcpy(&m_particles[0], &particles[0], particles.size() * sizeof(SCloudParticle*));
  217.                 return;
  218.         }
  219.  
  220.         CloudParticles parts;
  221.         for (int k = 0; k < 4; k++)
  222.         {
  223.                 AABB bnds;
  224.                 parts.resize(0);
  225.  
  226.                 Vec3 centr = (bounds.min + bounds.max) / 2;
  227.  
  228.                 if (k == 0)
  229.                         bnds = AABB(bounds.min, Vec3(centr.x, centr.y, bounds.max.z));
  230.                 else if (k == 1)
  231.                         bnds = AABB(Vec3(bounds.min.x, centr.y, bounds.min.z), Vec3(centr.x, bounds.max.y, bounds.max.z));
  232.                 else if (k == 2)
  233.                         bnds = AABB(Vec3(centr.x, bounds.min.y, bounds.min.z), Vec3(bounds.max.x, centr.y, bounds.max.z));
  234.                 else if (k == 3)
  235.                         bnds = AABB(Vec3(centr.x, centr.y, bounds.min.z), bounds.max);
  236.                 for (uint32 i = 0; i < particles.size(); i++)
  237.                 {
  238.                         SCloudParticle* pPtcl = particles[i];
  239.                         if (bnds.IsOverlapSphereBounds(pPtcl->GetPosition(), pPtcl->GetRadiusX()) ||
  240.                             bnds.IsContainSphere(pPtcl->GetPosition(), pPtcl->GetRadiusX()))
  241.                         {
  242.                                 parts.push_back(pPtcl);
  243.                         }
  244.                 }
  245.                 if (!parts.empty())
  246.                 {
  247.                         m_pQuads[k] = new SCloudQuadTree(m_level + 1);
  248.                         m_pQuads[k]->Init(bnds, parts, maxlevel);
  249.                 }
  250.         }
  251.  
  252. }
  253.  
  254. //////////////////////////////////////////////////////////////////////////
  255. bool SCloudQuadTree::CheckIntersection(const Vec3& p1, const Vec3& p2)
  256. {
  257.         Vec3 outp, outp2;
  258.         if (Intersect::Lineseg_AABB(Lineseg(p1, p2), m_bounds, outp))
  259.         {
  260.                 if (m_pQuads[0] && m_pQuads[0]->CheckIntersection(p1, p2))
  261.                         return true;
  262.                 if (m_pQuads[1] && m_pQuads[1]->CheckIntersection(p1, p2))
  263.                         return true;
  264.                 if (m_pQuads[2] && m_pQuads[2]->CheckIntersection(p1, p2))
  265.                         return true;
  266.                 if (m_pQuads[3] && m_pQuads[3]->CheckIntersection(p1, p2))
  267.                         return true;
  268.                 if (!m_particles.empty())
  269.                 {
  270.                         for (uint32 i = 0; i < m_particles.size(); i++)
  271.                                 //if(Intersect::Lineseg_Sphere(Lineseg(p1, p2), Sphere (m_particles[i]->GetPosition(), m_particles[i]->GetRadiusX()*(2.0f/3)), outp, outp2))
  272.                                 if (Intersect::Lineseg_Sphere(Lineseg(p1, p2), Sphere(m_particles[i]->GetPosition(), m_particles[i]->GetRadiusX()), outp, outp2))
  273.                                 {
  274.                                         //Sp_Pos = m_particles[i]->GetPosition();
  275.                                         //Sp_Rad = m_particles[i]->GetRadiusX()/2;
  276.                                         return true;
  277.                                 }
  278.                 }
  279.         }
  280.         return false;
  281. }
  282.  
  283. /*
  284.    //!!! WARNING
  285.    extern bool Sp_IsDraw;
  286.    extern Matrix34 Sp_Mat;
  287.    extern Vec3 Sp_Pos;
  288.    extern float Sp_Rad;
  289.  
  290.  
  291.    void C3DEngine::Hack_GetSprite(bool & IsDraw, Matrix34 & Mat, Vec3 & Pos, float & Rad)
  292.    {
  293.    IsDraw = Sp_IsDraw;
  294.    Mat = Sp_Mat;
  295.    Pos = Sp_Pos;
  296.    Rad = Sp_Rad;
  297.    }
  298.  */
  299.  
downloadCloudsManager.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