BVB Source Codes

CRYENGINE Show Tile.cpp Source code

Return Download CRYENGINE: download Tile.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 "Tile.h"
  5. #include <CryCore/TypeInfo_impl.h>
  6. #include "DebugDrawContext.h"
  7.  
  8. STRUCT_INFO_BEGIN(MNM::Tile::STriangle)
  9. STRUCT_VAR_INFO(vertex, TYPE_ARRAY(3, TYPE_INFO(Index)))
  10. STRUCT_BITFIELD_INFO(linkCount, TYPE_INFO(uint16), 4)
  11. STRUCT_BITFIELD_INFO(firstLink, TYPE_INFO(uint16), 12)
  12. STRUCT_VAR_INFO(islandID, TYPE_INFO(StaticIslandID))
  13. STRUCT_INFO_END(MNM::Tile::STriangle)
  14.  
  15. STRUCT_INFO_BEGIN(MNM::Tile::SBVNode)
  16. STRUCT_BITFIELD_INFO(leaf, TYPE_INFO(uint16), 1)
  17. STRUCT_BITFIELD_INFO(offset, TYPE_INFO(uint16), 15)
  18. STRUCT_VAR_INFO(aabb, TYPE_INFO(AABB))
  19. STRUCT_INFO_END(MNM::Tile::SBVNode)
  20.  
  21. STRUCT_INFO_BEGIN(MNM::Tile::SLink)
  22. STRUCT_BITFIELD_INFO(side, TYPE_INFO(uint32), 4)
  23. STRUCT_BITFIELD_INFO(edge, TYPE_INFO(uint32), 2)
  24. STRUCT_BITFIELD_INFO(triangle, TYPE_INFO(uint32), 10)
  25. STRUCT_INFO_END(MNM::Tile::SLink)
  26.  
  27. #if DEBUG_MNM_DATA_CONSISTENCY_ENABLED
  28.         #define TILE_VALIDATE() ValidateTriangleLinks()
  29. #else
  30.         #define TILE_VALIDATE()
  31. #endif
  32.  
  33. namespace MNM
  34. {
  35. STile::STile()
  36.         : triangles(nullptr)
  37.         , vertices(nullptr)
  38.         , nodes(nullptr)
  39.         , links(nullptr)
  40.         , triangleCount(0)
  41.         , vertexCount(0)
  42.         , nodeCount(0)
  43.         , linkCount(0)
  44.         , hashValue(0)
  45. #if MNM_USE_EXPORT_INFORMATION
  46.         , connectivity()
  47. #endif
  48. {
  49. }
  50.  
  51. void STile::GetTileData(Tile::STileData& outTileData) const
  52. {
  53.         outTileData.pTriangles = GetTriangles();
  54.         outTileData.pVertices = GetVertices();
  55.         outTileData.pLinks = GetLinks();
  56.         outTileData.pNodes = GetBVNodes();
  57.  
  58.         outTileData.trianglesCount = triangleCount;
  59.         outTileData.verticesCount = vertexCount;
  60.         outTileData.linksCount = linkCount;
  61.         outTileData.bvNodesCount = nodeCount;
  62.  
  63.         outTileData.hashValue = hashValue;
  64. }
  65.  
  66. void STile::SetTriangles(std::unique_ptr<Tile::STriangle[]>&& pTriangles_, uint16 count)
  67. {
  68.         triangles = pTriangles_.release();
  69.         triangleCount = count;
  70. }
  71.  
  72. void STile::SetVertices(std::unique_ptr<Tile::Vertex[]>&& pVertices_, uint16 count)
  73. {
  74.         vertices = pVertices_.release();
  75.         vertexCount = count;
  76. }
  77.  
  78. void STile::SetNodes(std::unique_ptr<Tile::SBVNode[]>&& pNodes_, uint16 count)
  79. {
  80.         nodes = pNodes_.release();
  81.         nodeCount = count;
  82. }
  83.  
  84. void STile::SetLinks(std::unique_ptr<Tile::SLink[]>&& pLinks_, uint16 count)
  85. {
  86.         links = pLinks_.release();
  87.         linkCount = count;
  88. }
  89.  
  90. void STile::SetHashValue(uint32 value)
  91. {
  92.         hashValue = value;
  93. }
  94.  
  95. template<typename TData, typename TCount>
  96. void CopyTileData(const TData* pNewData, const TCount newCount, TData*& pOutData, TCount& outCount)
  97. {
  98.         if (outCount != newCount)
  99.         {
  100.                 delete[] pOutData;
  101.                 pOutData = nullptr;
  102.  
  103.                 outCount = newCount;
  104.  
  105.                 if (newCount)
  106.                 {
  107.                         pOutData = new TData[newCount];
  108.                 }
  109.         }
  110.  
  111.         if (newCount)
  112.         {
  113.                 // #MNM_TODO pavloi 2016.07.26: assert fails for Tile::Vertex and Tile::SBVNode
  114.                 // #MNM_TODO pavloi 2016.07.26: can't use std::is_trivially_copyable - unexpectedly it's not implemented for clang/gcc in our build configurations
  115.                 //COMPILE_TIME_ASSERT(std::is_trivially_copyable<TData>::value);
  116.                 memcpy(pOutData, pNewData, sizeof(TData) * newCount);
  117.         }
  118. }
  119.  
  120. void STile::CopyTriangles(const Tile::STriangle* _triangles, uint16 count)
  121. {
  122. #if MNM_USE_EXPORT_INFORMATION
  123.         InitConnectivity(triangleCount, count);
  124. #endif
  125.  
  126.         CopyTileData(_triangles, count, triangles, triangleCount);
  127. }
  128.  
  129. void STile::CopyVertices(const Tile::Vertex* _vertices, uint16 count)
  130. {
  131.         CopyTileData(_vertices, count, vertices, vertexCount);
  132.  
  133.         TILE_VALIDATE();
  134. }
  135.  
  136. void STile::CopyNodes(const Tile::SBVNode* _nodes, uint16 count)
  137. {
  138.         CopyTileData(_nodes, count, nodes, nodeCount);
  139. }
  140.  
  141. void STile::CopyLinks(const Tile::SLink* _links, uint16 count)
  142. {
  143.         CopyTileData(_links, count, links, linkCount);
  144. }
  145.  
  146. void STile::AddOffMeshLink(const TriangleID triangleID, const uint16 offMeshIndex)
  147. {
  148.         TILE_VALIDATE();
  149.  
  150.         uint16 triangleIdx = ComputeTriangleIndex(triangleID);
  151.         assert(triangleIdx < triangleCount);
  152.         if (triangleIdx < triangleCount)
  153.         {
  154.                 //Figure out if this triangle has already off-mesh connections
  155.                 //Off-mesh link is always the first if exists
  156.                 Tile::STriangle& triangle = triangles[triangleIdx];
  157.  
  158.                 const size_t MaxLinkCount = 1024 * 6;
  159.                 Tile::SLink tempLinks[MaxLinkCount];
  160.  
  161.                 bool hasOffMeshLink = links && (triangle.linkCount > 0) && (triangle.firstLink < linkCount) && (links[triangle.firstLink].side == Tile::SLink::OffMesh);
  162.  
  163.                 // Try enabling DEBUG_MNM_DATA_CONSISTENCY_ENABLED if you get this
  164.                 CRY_ASSERT_MESSAGE(!hasOffMeshLink, "Not adding offmesh link, already exists");
  165.  
  166.                 if (!hasOffMeshLink)
  167.                 {
  168.                         //Add off-mesh link for triangle
  169.                         {
  170.                                 if (triangle.firstLink)
  171.                                 {
  172.                                         assert(links);
  173.                                         PREFAST_ASSUME(links);
  174.                                         memcpy(tempLinks, links, sizeof(Tile::SLink) * triangle.firstLink);
  175.                                 }
  176.  
  177.                                 tempLinks[triangle.firstLink].side = Tile::SLink::OffMesh;
  178.                                 tempLinks[triangle.firstLink].triangle = offMeshIndex;
  179.  
  180.                                 //Note this is not used
  181.                                 tempLinks[triangle.firstLink].edge = 0;
  182.  
  183.                                 const int countDiff = linkCount - triangle.firstLink;
  184.                                 if (countDiff > 0)
  185.                                 {
  186.                                         assert(links);
  187.                                         memcpy(&tempLinks[triangle.firstLink + 1], &links[triangle.firstLink], sizeof(Tile::SLink) * countDiff);
  188.                                 }
  189.                         }
  190.  
  191.                         CopyLinks(tempLinks, linkCount + 1);
  192.  
  193.                         //Re-arrange link indices for triangles
  194.                         triangle.linkCount++;
  195.  
  196.                         for (uint16 tIdx = (triangleIdx + 1); tIdx < triangleCount; ++tIdx)
  197.                         {
  198.                                 triangles[tIdx].firstLink++;
  199.                         }
  200.                 }
  201.         }
  202.  
  203.         TILE_VALIDATE();
  204. }
  205.  
  206. void STile::UpdateOffMeshLink(const TriangleID triangleID, const uint16 offMeshIndex)
  207. {
  208.         TILE_VALIDATE();
  209.  
  210.         uint16 triangleIndex = ComputeTriangleIndex(triangleID);
  211.         assert(triangleIndex < triangleCount);
  212.         if (triangleIndex < triangleCount)
  213.         {
  214.                 //First link is always off-mesh if exists
  215.                 const uint16 linkIdx = triangles[triangleIndex].firstLink;
  216.                 assert(linkIdx < linkCount);
  217.                 if (linkIdx < linkCount)
  218.                 {
  219.                         Tile::SLink& link = links[linkIdx];
  220.                         assert(link.side == Tile::SLink::OffMesh);
  221.                         if (link.side == Tile::SLink::OffMesh)
  222.                         {
  223.                                 link.triangle = offMeshIndex;
  224.                         }
  225.                 }
  226.         }
  227.  
  228.         TILE_VALIDATE();
  229. }
  230.  
  231. void STile::RemoveOffMeshLink(const TriangleID triangleID)
  232. {
  233.         TILE_VALIDATE();
  234.  
  235.         // Find link to be removed
  236.         uint16 linkToRemoveIdx = 0xFFFF;
  237.         uint16 boundTriangleIdx = ComputeTriangleIndex(triangleID);
  238.         if (boundTriangleIdx < triangleCount)
  239.         {
  240.                 const uint16 firstLink = triangles[boundTriangleIdx].firstLink;
  241.                 if ((triangles[boundTriangleIdx].linkCount > 0) && (firstLink < linkCount) && (links[firstLink].side == Tile::SLink::OffMesh))
  242.                         linkToRemoveIdx = firstLink;
  243.         }
  244.  
  245.         // Try enabling DEBUG_MNM_DATA_CONSISTENCY_ENABLED if you get this
  246.         CRY_ASSERT_MESSAGE(linkToRemoveIdx != 0xFFFF, "Trying to remove off mesh link that doesn't exist");
  247.  
  248.         if (linkToRemoveIdx != 0xFFFF)
  249.         {
  250.                 assert(linkCount > 1);
  251.  
  252.                 const size_t MaxLinkCount = 1024 * 6;
  253.                 Tile::SLink tempLinks[MaxLinkCount];
  254.  
  255.                 if (linkToRemoveIdx)
  256.                         memcpy(tempLinks, links, sizeof(Tile::SLink) * linkToRemoveIdx);
  257.  
  258.                 const int diffCount = linkCount - (linkToRemoveIdx + 1);
  259.                 if (diffCount > 0)
  260.                 {
  261.                         memcpy(&tempLinks[linkToRemoveIdx], &links[linkToRemoveIdx + 1], sizeof(Tile::SLink) * diffCount);
  262.                 }
  263.  
  264.                 CopyLinks(tempLinks, linkCount - 1);
  265.  
  266.                 //Re-arrange link indices for triangles
  267.                 triangles[boundTriangleIdx].linkCount--;
  268.  
  269.                 for (uint16 tIdx = (boundTriangleIdx + 1); tIdx < triangleCount; ++tIdx)
  270.                 {
  271.                         triangles[tIdx].firstLink--;
  272.                 }
  273.         }
  274.  
  275.         TILE_VALIDATE();
  276. }
  277.  
  278. void STile::Swap(STile& other)
  279. {
  280.         std::swap(triangles, other.triangles);
  281.         std::swap(vertices, other.vertices);
  282.         std::swap(nodes, other.nodes);
  283.         std::swap(links, other.links);
  284.  
  285. #if MNM_USE_EXPORT_INFORMATION
  286.         InitConnectivity(triangleCount, other.triangleCount);
  287. #endif
  288.  
  289.         std::swap(triangleCount, other.triangleCount);
  290.         std::swap(vertexCount, other.vertexCount);
  291.         std::swap(nodeCount, other.nodeCount);
  292.         std::swap(linkCount, other.linkCount);
  293.         std::swap(hashValue, other.hashValue);
  294.  
  295.         TILE_VALIDATE();
  296. }
  297.  
  298. void STile::Destroy()
  299. {
  300.         delete[] triangles;
  301.         triangles = 0;
  302.  
  303.         delete[] vertices;
  304.         vertices = 0;
  305.  
  306.         delete[] nodes;
  307.         nodes = 0;
  308.  
  309.         delete[] links;
  310.         links = 0;
  311.  
  312. #if MNM_USE_EXPORT_INFORMATION
  313.         SAFE_DELETE_ARRAY(connectivity.trianglesAccessible);
  314.         connectivity.tileAccessible = 0;
  315. #endif
  316.  
  317.         triangleCount = 0;
  318.         vertexCount = 0;
  319.         nodeCount = 0;
  320.         linkCount = 0;
  321.         hashValue = 0;
  322. }
  323.  
  324. ColorF CalculateColorForIsland(StaticIslandID islandID, uint16 totalIslands)
  325. {
  326.         if (totalIslands == 0)
  327.                 return Col_White;
  328.  
  329.         const float hueValue = islandID / (float) totalIslands;
  330.  
  331.         ColorF color;
  332.         color.fromHSV(hueValue, 1.0f, 1.0f);
  333.         color.a = 1.0f;
  334.         return color;
  335. }
  336.  
  337. void STile::Draw(size_t drawFlags, vector3_t origin, TileID tileID, const std::vector<float>& islandAreas) const
  338. {
  339.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  340.  
  341.         const ColorB triangleColorConnected(Col_Azure, 0.65f);
  342.         const ColorB triangleColorExternalMesh(Col_LimeGreen, 0.5f);
  343.         const ColorB triangleColorBackface(Col_Gray, 0.65f);
  344.         const ColorB triangleColorDisconnected(Col_Red, 0.65f);
  345.         const ColorB boundaryColor(Col_Black);
  346.  
  347.         const Vec3 offset = origin.GetVec3() + Vec3(0.0f, 0.0f, 0.05f);
  348.         const Vec3 loffset(offset + Vec3(0.0f, 0.0f, 0.0005f));
  349.  
  350.         SAuxGeomRenderFlags oldFlags = renderAuxGeom->GetRenderFlags();
  351.  
  352.         SAuxGeomRenderFlags renderFlags(e_Def3DPublicRenderflags);
  353.         renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  354.  
  355.         if (!(drawFlags & DrawTriangleBackfaces))
  356.         {
  357.                 renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  358.         }
  359.  
  360.         renderAuxGeom->SetRenderFlags(renderFlags);
  361.  
  362.         if (drawFlags & DrawTriangles)
  363.         {
  364.                 for (size_t i = 0; i < triangleCount; ++i)
  365.                 {
  366.                         const Tile::STriangle& triangle = triangles[i];
  367.  
  368.                         const Vec3 v0 = vertices[triangle.vertex[0]].GetVec3() + offset;
  369.                         const Vec3 v1 = vertices[triangle.vertex[1]].GetVec3() + offset;
  370.                         const Vec3 v2 = vertices[triangle.vertex[2]].GetVec3() + offset;
  371.  
  372. #if MNM_USE_EXPORT_INFORMATION
  373.                         ColorB triangleColor = ((drawFlags & DrawAccessibility) && (connectivity.trianglesAccessible != NULL) && !connectivity.trianglesAccessible[i]) ? triangleColorDisconnected : triangleColorConnected;
  374. #else
  375.                         ColorB triangleColor = triangleColorConnected;
  376. #endif
  377.  
  378.                         if (!(drawFlags & DrawAccessibility))
  379.                         {
  380.                                 // #MNM_TODO pavloi 2016.07.21: implement flag to color table lookup, which can be set from outside of the system.
  381.                                 if (triangle.triangleFlags & Tile::STriangle::eFlags_ExternalMesh)
  382.                                 {
  383.                                         triangleColor = triangleColorExternalMesh;
  384.                                 }
  385.                         }
  386.  
  387.                         // Islands
  388.                         bool drawIslandData = ((drawFlags & DrawIslandsId) && triangle.islandID > MNM::Constants::eStaticIsland_InvalidIslandID && triangle.islandID < islandAreas.size());
  389.                         if (drawFlags & DrawIslandsId)
  390.                         {
  391.                                 triangleColor = CalculateColorForIsland(triangle.islandID, static_cast<uint16>(islandAreas.size()));
  392.                         }
  393.                         renderAuxGeom->DrawTriangle(v0, triangleColor, v1, triangleColor, v2, triangleColor);
  394.  
  395.                         if (drawFlags & DrawTriangleBackfaces)
  396.                         {
  397.                                 renderAuxGeom->DrawTriangle(v1, triangleColorBackface, v0, triangleColorBackface, v2, triangleColorBackface);
  398.                         }
  399.  
  400.                         if ((drawFlags & DrawTrianglesId) || drawIslandData)
  401.                         {
  402.                                 const Vec3 triCenter = ((v0 + v1 + v2) / 3.0f) + Vec3(.0f, .0f, .1f);
  403.  
  404.                                 stack_string text;
  405.                                 if ((drawFlags & DrawTrianglesId) && drawIslandData)
  406.                                 {
  407.                                         text.Format("id: %d, area: %f, islandID: %u", ComputeTriangleID(tileID, static_cast<uint16>(i)), static_cast<uint16>(islandAreas[triangle.islandID - 1]), triangle.islandID);
  408.                                 }
  409.                                 else if (drawFlags & DrawTrianglesId)
  410.                                 {
  411.                                         text.Format("id: %d", ComputeTriangleID(tileID, static_cast<uint16>(i)));
  412.                                 }
  413.                                 else
  414.                                 {
  415.                                         text.Format("area: %f, islandID: %u", islandAreas[triangle.islandID - 1], triangle.islandID);
  416.                                 }
  417.  
  418.                                 CDebugDrawContext dc;
  419.                                 dc->Draw3dLabelEx(triCenter, 1.2f, ColorB(255, 255, 255), true, true, true, false, "%s", text.c_str());
  420.                         }
  421.                 }
  422.         }
  423.  
  424.         renderAuxGeom->SetRenderFlags(oldFlags);
  425.  
  426.         for (size_t i = 0; i < triangleCount; ++i)
  427.         {
  428.                 const Tile::STriangle& triangle = triangles[i];
  429.                 size_t linkedEdges = 0;
  430.  
  431.                 for (size_t l = 0; l < triangle.linkCount; ++l)
  432.                 {
  433.                         const Tile::SLink& link = links[triangle.firstLink + l];
  434.                         const size_t edge = link.edge;
  435.                         linkedEdges |= static_cast<size_t>((size_t)1 << edge);
  436.  
  437.                         const uint16 vi0 = link.edge;
  438.                         const uint16 vi1 = (link.edge + 1) % 3;
  439.  
  440.                         assert(vi0 < 3);
  441.                         assert(vi1 < 3);
  442.  
  443.                         const Vec3 v0 = vertices[triangle.vertex[vi0]].GetVec3() + loffset;
  444.                         const Vec3 v1 = vertices[triangle.vertex[vi1]].GetVec3() + loffset;
  445.  
  446.                         if (link.side == Tile::SLink::OffMesh)
  447.                         {
  448.                                 if (drawFlags & DrawOffMeshLinks)
  449.                                 {
  450.                                         const Vec3 a = vertices[triangle.vertex[0]].GetVec3() + offset;
  451.                                         const Vec3 b = vertices[triangle.vertex[1]].GetVec3() + offset;
  452.                                         const Vec3 c = vertices[triangle.vertex[2]].GetVec3() + offset;
  453.  
  454.                                         renderAuxGeom->DrawLine(a, Col_Red, b, Col_Red, 8.0f);
  455.                                         renderAuxGeom->DrawLine(b, Col_Red, c, Col_Red, 8.0f);
  456.                                         renderAuxGeom->DrawLine(c, Col_Red, a, Col_Red, 8.0f);
  457.                                 }
  458.                         }
  459.                         else if (link.side != Tile::SLink::Internal)
  460.                         {
  461.                                 if (drawFlags & DrawExternalLinks)
  462.                                 {
  463.                                         // TODO: compute clipped edge
  464.                                         renderAuxGeom->DrawLine(v0, Col_White, v1, Col_White, 4.0f);
  465.                                 }
  466.                         }
  467.                         else
  468.                         {
  469.                                 if (drawFlags & DrawInternalLinks)
  470.                                         renderAuxGeom->DrawLine(v0, Col_White, v1, Col_White);
  471.                         }
  472.                 }
  473.  
  474.                 if (drawFlags & DrawMeshBoundaries)
  475.                 {
  476.                         for (size_t e = 0; e < 3; ++e)
  477.                         {
  478.                                 if ((linkedEdges & static_cast<size_t>((size_t)1 << e)) == 0)
  479.                                 {
  480.                                         const Vec3 a = vertices[triangle.vertex[e]].GetVec3() + loffset;
  481.                                         const Vec3 b = vertices[triangle.vertex[(e + 1) % 3]].GetVec3() + loffset;
  482.  
  483.                                         renderAuxGeom->DrawLine(a, Col_Black, b, Col_Black, 8.0f);
  484.                                 }
  485.                         }
  486.                 }
  487.         }
  488. }
  489.  
  490. #if DEBUG_MNM_DATA_CONSISTENCY_ENABLED
  491. void STile::ValidateTriangleLinks()
  492. {
  493.         uint16 nextLink = 0;
  494.  
  495.         for (uint16 i = 0; i < triangleCount; ++i)
  496.         {
  497.                 const Tile::STriangle& triangle = triangles[i];
  498.  
  499.                 CRY_ASSERT_MESSAGE(triangle.firstLink <= linkCount || linkCount == 0, "Out of range link");
  500.  
  501.                 CRY_ASSERT_MESSAGE(nextLink == triangle.firstLink, "Links are not contiguous");
  502.  
  503.                 nextLink += triangle.linkCount;
  504.  
  505.                 for (uint16 l = 0; l < triangle.linkCount; ++l)
  506.                 {
  507.                         uint16 linkIdx = triangle.firstLink + l;
  508.  
  509.                         CRY_ASSERT_MESSAGE(links[linkIdx].side != Tile::SLink::OffMesh || l == 0, "Off mesh links should always be first");
  510.                 }
  511.         }
  512.  
  513.         CRY_ASSERT(nextLink == linkCount);
  514. }
  515.  
  516. void STile::ValidateTriangles() const
  517. {
  518.         const Tile::VertexIndex verticesMaxIndex = vertexCount;
  519.         for (size_t triangleIdx = 0; triangleIdx < triangleCount; ++triangleIdx)
  520.         {
  521.                 const Tile::STriangle& tri = triangles[triangleIdx];
  522.                 for (int i = 0; i < 3; ++i)
  523.                 {
  524.                         if (tri.vertex[i] >= verticesMaxIndex)
  525.                         {
  526.                                 CRY_ASSERT_MESSAGE(tri.vertex[i] < verticesMaxIndex, "MNM traingle invalid vertex index");
  527.                         }
  528.                 }
  529.         }
  530. }
  531.  
  532. #endif
  533.  
  534. vector3_t::value_type STile::GetTriangleArea(const TriangleID triangleID) const
  535. {
  536.         const Tile::STriangle& triangle = triangles[ComputeTriangleIndex(triangleID)];
  537.  
  538.         const vector3_t v0 = vector3_t(vertices[triangle.vertex[0]]);
  539.         const vector3_t v1 = vector3_t(vertices[triangle.vertex[1]]);
  540.         const vector3_t v2 = vector3_t(vertices[triangle.vertex[2]]);
  541.  
  542.         const vector3_t::value_type len0 = (v0 - v1).len();
  543.         const vector3_t::value_type len1 = (v0 - v2).len();
  544.         const vector3_t::value_type len2 = (v1 - v2).len();
  545.  
  546.         const vector3_t::value_type s = (len0 + len1 + len2) / vector3_t::value_type(2);
  547.  
  548.         return sqrtf(s * (s - len0) * (s - len1) * (s - len2));
  549. }
  550.  
  551. //////////////////////////////////////////////////////////////////////////
  552.  
  553. #if MNM_USE_EXPORT_INFORMATION
  554.  
  555. bool STile::ConsiderExportInformation() const
  556. {
  557.         // TODO FrancescoR: Remove if it's not necessary anymore or refactor it.
  558.         return true;
  559. }
  560.  
  561. void STile::InitConnectivity(uint16 oldTriangleCount, uint16 newTriangleCount)
  562. {
  563.         if (ConsiderExportInformation())
  564.         {
  565.                 // By default all is accessible
  566.                 connectivity.tileAccessible = 1;
  567.                 if (oldTriangleCount != newTriangleCount)
  568.                 {
  569.                         SAFE_DELETE_ARRAY(connectivity.trianglesAccessible);
  570.  
  571.                         if (newTriangleCount)
  572.                         {
  573.                                 connectivity.trianglesAccessible = new uint8[newTriangleCount];
  574.                         }
  575.                 }
  576.  
  577.                 if (newTriangleCount)
  578.                 {
  579.                         memset(connectivity.trianglesAccessible, 1, sizeof(uint8) * newTriangleCount);
  580.                 }
  581.                 connectivity.triangleCount = newTriangleCount;
  582.         }
  583. }
  584.  
  585. void STile::ResetConnectivity(uint8 accessible)
  586. {
  587.         if (ConsiderExportInformation())
  588.         {
  589.                 assert(connectivity.triangleCount == triangleCount);
  590.  
  591.                 connectivity.tileAccessible = accessible;
  592.  
  593.                 if (connectivity.trianglesAccessible != NULL)
  594.                 {
  595.                         memset(connectivity.trianglesAccessible, accessible, sizeof(uint8) * connectivity.triangleCount);
  596.                 }
  597.         }
  598. }
  599.  
  600. #endif
  601. }
  602.  
downloadTile.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