BVB Source Codes

CRYENGINE Show TileGeneratorDraw.cpp Source code

Return Download CRYENGINE: download TileGeneratorDraw.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 "TileGenerator.h"
  5. #include <CryAISystem/IAIDebugRenderer.h>
  6.  
  7. namespace MNM
  8. {
  9. static bool IsOnScreen(const Vec3& worldPos)
  10. {
  11.         float x, y, z;
  12.         if (gEnv->pRenderer->ProjectToScreen(worldPos.x, worldPos.y, worldPos.z, &x, &y, &z))
  13.         {
  14.                 if ((z >= 0.0f) && (z <= 1.0f))
  15.                 {
  16.                         return true;
  17.                 }
  18.         }
  19.         return false;
  20. }
  21.  
  22. static bool IsOnScreen(const Vec3& worldPos, Vec2& outScreenPos)
  23. {
  24.         float x, y, z;
  25.         if (gEnv->pRenderer->ProjectToScreen(worldPos.x, worldPos.y, worldPos.z, &x, &y, &z))
  26.         {
  27.                 if ((z >= 0.0f) && (z <= 1.0f))
  28.                 {
  29.                         outScreenPos.x = x * (float)gEnv->pRenderer->GetWidth() * 0.01f;
  30.                         outScreenPos.y = y * (float)gEnv->pRenderer->GetHeight() * 0.01f;
  31.                         return true;
  32.                 }
  33.         }
  34.         return false;
  35. }
  36.  
  37. // TODO pavloi 2016.03.10: IRenderAuxGeom doesn't give an easy way of printing text
  38. static void RenderText(IRenderAuxGeom* const pRenderAuxGeom, const Vec3& pos, SDrawTextInfo& ti, const char* szFormat, ...)
  39. {
  40.         va_list args;
  41.         va_start(args, szFormat);
  42.         pRenderAuxGeom->RenderText(pos, ti, szFormat, args);
  43.         va_end(args);
  44. }
  45.  
  46. struct SEmptyInfoPrinter
  47. {
  48.         void operator()(const CompactSpanGrid::Span& /*span*/, const SSpanCoord& /*spanCoord*/, const Vec3& /*topCenter*/, IRenderAuxGeom* const /*pRenderAuxGeom*/) const
  49.         {
  50.                 // print nothing
  51.         }
  52. };
  53.  
  54. template<typename TyFilter, typename TyInfoPrinter>
  55. void DrawSpanGrid(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter, const ColorB& color, const TyInfoPrinter& printer) PREFAST_SUPPRESS_WARNING(6262)
  56. {
  57.         const size_t width = grid.GetWidth();
  58.         const size_t height = grid.GetHeight();
  59.         const size_t gridSize = width * height;
  60.  
  61.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  62.         size_t aabbCount = 0;
  63.  
  64.         const size_t MaxAABB = 1024;
  65.         AABB aabbs[MaxAABB];
  66.  
  67.         SAuxGeomRenderFlags oldFlags = renderAuxGeom->GetRenderFlags();
  68.         SAuxGeomRenderFlags renderFlags(oldFlags);
  69.  
  70.         renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  71.         renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  72.  
  73.         for (size_t y = 0; y < height; ++y)
  74.         {
  75.                 const float minY = volumeMin.y + y * voxelSize.y;
  76.  
  77.                 for (size_t x = 0; x < width; ++x)
  78.                 {
  79.                         const float minX = volumeMin.x + x * voxelSize.x;
  80.                         const float minZ = volumeMin.z;
  81.  
  82.                         if (const CompactSpanGrid::Cell cell = grid.GetCell(x, y))
  83.                         {
  84.                                 size_t count = cell.count;
  85.  
  86.                                 for (size_t s = 0; s < count; ++s)
  87.                                 {
  88.                                         const CompactSpanGrid::Span& span = grid.GetSpan(cell.index + s);
  89.  
  90.                                         if (filter(grid, cell.index + s))
  91.                                         {
  92.                                                 const AABB aabb(Vec3(minX, minY, minZ + span.bottom * voxelSize.z),
  93.                                                                 Vec3(minX + voxelSize.x, minY + voxelSize.y, minZ + (span.bottom + span.height) * voxelSize.z));
  94.  
  95.                                                 aabbs[aabbCount++] = aabb;
  96.  
  97.                                                 Vec3 topCenter(aabb.GetCenter());
  98.                                                 topCenter.z = aabb.max.z;
  99.                                                 printer(span, SSpanCoord(x, y, s, cell.index + s), topCenter, renderAuxGeom);
  100.  
  101.                                                 if (aabbCount == MaxAABB)
  102.                                                 {
  103.                                                         renderAuxGeom->DrawAABBs(aabbs, aabbCount, true, color, eBBD_Faceted);
  104.                                                         aabbCount = 0;
  105.                                                 }
  106.                                         }
  107.                                 }
  108.                         }
  109.                 }
  110.         }
  111.  
  112.         if (aabbCount)
  113.         {
  114.                 renderAuxGeom->DrawAABBs(aabbs, aabbCount, true, color, eBBD_Faceted);
  115.                 aabbCount = 0;
  116.         }
  117.  
  118.         renderAuxGeom->SetRenderFlags(oldFlags);
  119. }
  120.  
  121. template<typename TyFilter>
  122. void DrawSpanGrid(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter, const ColorB& color) PREFAST_SUPPRESS_WARNING(6262)
  123. {
  124.         DrawSpanGrid(volumeMin, voxelSize, grid, filter, color, SEmptyInfoPrinter());
  125. }
  126.  
  127. template<typename TyFilter, typename TyColorPicker, typename TyInfoPrinter>
  128. void DrawSpanGrid(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter,
  129.                   const TyColorPicker& color, const TyInfoPrinter& printer)
  130. {
  131.         const size_t width = grid.GetWidth();
  132.         const size_t height = grid.GetHeight();
  133.         const size_t gridSize = width * height;
  134.  
  135.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  136.  
  137.         SAuxGeomRenderFlags oldFlags = renderAuxGeom->GetRenderFlags();
  138.         SAuxGeomRenderFlags renderFlags(oldFlags);
  139.  
  140.         renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  141.         renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  142.  
  143.         for (size_t y = 0; y < height; ++y)
  144.         {
  145.                 const float minY = volumeMin.y + y * voxelSize.y;
  146.  
  147.                 for (size_t x = 0; x < width; ++x)
  148.                 {
  149.                         const float minX = volumeMin.x + x * voxelSize.x;
  150.                         const float minZ = volumeMin.z;
  151.  
  152.                         if (const CompactSpanGrid::Cell cell = grid.GetCell(x, y))
  153.                         {
  154.                                 size_t count = cell.count;
  155.  
  156.                                 for (size_t s = 0; s < count; ++s)
  157.                                 {
  158.                                         const CompactSpanGrid::Span& span = grid.GetSpan(cell.index + s);
  159.  
  160.                                         if (filter(grid, cell.index + s))
  161.                                         {
  162.                                                 AABB aabb(Vec3(minX, minY, minZ + span.bottom * voxelSize.z),
  163.                                                           Vec3(minX + voxelSize.x, minY + voxelSize.y, minZ + (span.bottom + span.height) * voxelSize.z));
  164.  
  165.                                                 Vec3 topCenter(aabb.GetCenter());
  166.                                                 topCenter.z = aabb.max.z;
  167.                                                 printer(span, SSpanCoord(x, y, s, cell.index + s), topCenter, renderAuxGeom);
  168.  
  169.                                                 renderAuxGeom->DrawAABB(aabb, true, color(grid, cell.index + s), eBBD_Faceted);
  170.                                         }
  171.                                 }
  172.                         }
  173.                 }
  174.         }
  175.  
  176.         renderAuxGeom->SetRenderFlags(oldFlags);
  177. }
  178.  
  179. template<typename TyFilter, typename TyColorPicker>
  180. void DrawSpanGrid(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter,
  181.                   const TyColorPicker& color)
  182. {
  183.         DrawSpanGrid(volumeMin, voxelSize, grid, filter, color, SEmptyInfoPrinter());
  184. }
  185.  
  186. template<typename TyFilter, typename TyColorPicker, typename TyInfoPrinter>
  187. void DrawSpanGridTop(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter,
  188.                      const TyColorPicker& color, const TyInfoPrinter& printer)
  189. {
  190.         const size_t width = grid.GetWidth();
  191.         const size_t height = grid.GetHeight();
  192.         const size_t gridSize = width * height;
  193.  
  194.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  195.  
  196.         SAuxGeomRenderFlags oldFlags = renderAuxGeom->GetRenderFlags();
  197.         SAuxGeomRenderFlags renderFlags(oldFlags);
  198.  
  199.         renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  200.         renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  201.  
  202.         for (size_t y = 0; y < height; ++y)
  203.         {
  204.                 const float minY = volumeMin.y + y * voxelSize.y;
  205.  
  206.                 for (size_t x = 0; x < width; ++x)
  207.                 {
  208.                         const float minX = volumeMin.x + x * voxelSize.x;
  209.                         const float minZ = volumeMin.z;
  210.  
  211.                         if (const CompactSpanGrid::Cell cell = grid.GetCell(x, y))
  212.                         {
  213.                                 size_t count = cell.count;
  214.  
  215.                                 for (size_t s = 0; s < count; ++s)
  216.                                 {
  217.                                         const CompactSpanGrid::Span& span = grid.GetSpan(cell.index + s);
  218.  
  219.                                         if (filter(grid, cell.index + s))
  220.                                         {
  221.                                                 ColorB vcolor = color(grid, cell.index + s);
  222.  
  223.                                                 Vec3 v0 = Vec3(minX, minY, minZ + (span.bottom + span.height) * voxelSize.z);
  224.                                                 Vec3 v1 = Vec3(v0.x, v0.y + voxelSize.y, v0.z);
  225.                                                 Vec3 v2 = Vec3(v0.x + voxelSize.x, v0.y + voxelSize.y, v0.z);
  226.                                                 Vec3 v3 = Vec3(v0.x + voxelSize.x, v0.y, v0.z);
  227.  
  228.                                                 renderAuxGeom->DrawTriangle(v0, vcolor, v2, vcolor, v1, vcolor);
  229.                                                 renderAuxGeom->DrawTriangle(v0, vcolor, v3, vcolor, v2, vcolor);
  230.  
  231.                                                 printer(span, SSpanCoord(x, y, s, cell.index + s), (v0 + v2) * 0.5f, renderAuxGeom);
  232.                                         }
  233.                                 }
  234.                         }
  235.                 }
  236.         }
  237.  
  238.         renderAuxGeom->SetRenderFlags(oldFlags);
  239. }
  240.  
  241. template<typename TyFilter, typename TyColorPicker>
  242. void DrawSpanGridTop(const Vec3 volumeMin, const Vec3 voxelSize, const CompactSpanGrid& grid, const TyFilter& filter,
  243.                      const TyColorPicker& color)
  244. {
  245.         DrawSpanGridTop(volumeMin, voxelSize, grid, filter, color, SEmptyInfoPrinter());
  246. }
  247.  
  248. ColorB ColorFromNumber(size_t n)
  249. {
  250.         return ColorB(64 + (n * 64) % 192, 64 + ((n * 32) + 64) % 192, 64 + (n * 24) % 192, 255);
  251. }
  252.  
  253. struct AllPassFilter
  254. {
  255.         bool operator()(const CompactSpanGrid& grid, size_t i) const
  256.         {
  257.                 return true;
  258.         }
  259. };
  260.  
  261. struct NotWalkableFilter
  262. {
  263.         bool operator()(const CompactSpanGrid& grid, size_t i) const
  264.         {
  265.                 const CompactSpanGrid::Span& span = grid.GetSpan(i);
  266.                 return (span.flags & CTileGenerator::NotWalkable) != 0;
  267.         }
  268. };
  269.  
  270. struct WalkableFilter
  271. {
  272.         bool operator()(const CompactSpanGrid& grid, size_t i) const
  273.         {
  274.                 const CompactSpanGrid::Span& span = grid.GetSpan(i);
  275.                 return (span.flags & CTileGenerator::NotWalkable) == 0;
  276.         }
  277. };
  278.  
  279. struct BoundaryFilter
  280. {
  281.         bool operator()(const CompactSpanGrid& grid, size_t i) const
  282.         {
  283.                 const CompactSpanGrid::Span& span = grid.GetSpan(i);
  284.                 return (span.flags & CTileGenerator::TileBoundary) != 0;
  285.         }
  286. };
  287.  
  288. struct RawColorPicker
  289. {
  290.         RawColorPicker(const ColorB& _normal, const ColorB& _backface)
  291.                 : normal(_normal)
  292.                 , backface(_backface)
  293.         {}
  294.  
  295.         ColorB operator()(const CompactSpanGrid& grid, size_t i) const
  296.         {
  297.                 const CompactSpanGrid::Span& span = grid.GetSpan(i);
  298.                 if (!span.backface)
  299.                         return normal;
  300.                 return backface;
  301.         }
  302. private:
  303.         ColorB normal;
  304.         ColorB backface;
  305. };
  306.  
  307. struct DistanceColorPicker
  308. {
  309.         DistanceColorPicker(const uint16* _distances)
  310.                 : distances(_distances)
  311.         {}
  312.  
  313.         ColorB operator()(const CompactSpanGrid& grid, size_t i) const
  314.         {
  315.                 uint8 distance = (uint8)min<uint16>(distances[i] * 4, 255);
  316.                 return ColorB(distance, distance, distance, 255);
  317.         }
  318. private:
  319.         const uint16* distances;
  320. };
  321.  
  322. struct LabelColor
  323. {
  324.         ColorB operator()(size_t r) const
  325.         {
  326.                 if (r < CTileGenerator::NoLabel)
  327.                         return ColorFromNumber(r);
  328.                 else if (r == CTileGenerator::NoLabel)
  329.                         return Col_DarkGray;
  330.                 else if ((r& CTileGenerator::BorderLabelV) == CTileGenerator::BorderLabelV)
  331.                         return Col_DarkSlateBlue;
  332.                 else if ((r& CTileGenerator::BorderLabelH) == CTileGenerator::BorderLabelH)
  333.                         return Col_DarkOliveGreen;
  334.                 else if (r & CTileGenerator::ExternalContour)
  335.                         return Col_DarkSlateBlue * 0.5f + Col_DarkOliveGreen * 0.5f;
  336.                 else if (r & CTileGenerator::InternalContour)
  337.                         return Col_DarkSlateBlue * 0.25f + Col_DarkOliveGreen * 0.75f;
  338.                 else
  339.                         return Col_DarkSlateBlue * 0.5f + Col_DarkOliveGreen * 0.5f;
  340.  
  341.                 return Col_VioletRed;
  342.         }
  343. };
  344.  
  345. struct LabelColorPicker
  346. {
  347.         LabelColorPicker(const uint16* _labels)
  348.                 : labels(_labels)
  349.         {}
  350.  
  351.         ColorB operator()(const CompactSpanGrid& grid, size_t i) const
  352.         {
  353.                 return LabelColor()(labels[i]);
  354.         }
  355. private:
  356.         const uint16* labels;
  357. };
  358.  
  359. struct SPaintColor
  360. {
  361.         ColorB operator()(size_t r) const
  362.         {
  363.                 switch (r)
  364.                 {
  365.                 case CTileGenerator::Paint::NoPaint:
  366.                         return Col_DarkGray;
  367.                 case CTileGenerator::Paint::BadPaint:
  368.                         return Col_DarkSlateBlue;
  369.                 }
  370.                 static_assert(CTileGenerator::Paint::OkPaintStart == 2, "There are unknown values before TileGenerator::Paint::OkPaintStart");
  371.                 return ColorFromNumber(r - CTileGenerator::Paint::OkPaintStart);
  372.         }
  373. };
  374.  
  375. struct SPaintColorPicker
  376. {
  377.         SPaintColorPicker(const uint16* _paints)
  378.                 : paints(_paints)
  379.         {
  380.         }
  381.  
  382.         ColorB operator()(const CompactSpanGrid& grid, size_t i) const
  383.         {
  384.                 return SPaintColor()(paints[i]);
  385.         }
  386. private:
  387.         const uint16* paints;
  388. };
  389.  
  390. struct SLegendRenderer
  391. {
  392.         void DrawColorLegendLine(const Vec2& pos, const Vec2& size, const float fontSize, const ColorB& color, const char* szLabel)
  393.         {
  394.                 const ColorF fontColor(color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f);
  395.  
  396.                 // TODO pavloi 2016.03.09: why 2d quad is not working? It's hard to tell a color from text.
  397.  
  398.                 const vtx_idx auxIndices[6] = { 2, 1, 0, 2, 3, 1 };
  399.                 const Vec3 quadVertices[4] = {
  400.                         Vec3(pos.x,          pos.y,          1.0f),
  401.                         Vec3(pos.x + size.x, pos.y,          1.0f),
  402.                         Vec3(pos.x,          pos.y + size.y, 1.0f),
  403.                         Vec3(pos.x + size.x, pos.y + size.y, 1.0f)
  404.                 };
  405.                 pRenderAuxGeom->DrawTriangles(quadVertices, 4, auxIndices, 6, color);
  406.                 pRenderAuxGeom->Draw2dLabel(quadVertices[1].x, quadVertices[1].y, fontSize, fontColor, false, szLabel);
  407.         }
  408.  
  409.         SLegendRenderer()
  410.                 : pRenderAuxGeom(gEnv->pRenderer->GetIRenderAuxGeom())
  411.                 , oldRenderFlags(pRenderAuxGeom ? pRenderAuxGeom->GetRenderFlags() : SAuxGeomRenderFlags())
  412.         {}
  413.  
  414.         ~SLegendRenderer()
  415.         {
  416.                 if (pRenderAuxGeom)
  417.                 {
  418.                         pRenderAuxGeom->SetRenderFlags(oldRenderFlags);
  419.                 }
  420.         }
  421.  
  422.         void SetDefaultRenderFlags()
  423.         {
  424.                 SAuxGeomRenderFlags flags = e_Def3DPublicRenderflags;
  425.                 flags.SetMode2D3DFlag(e_Mode2D);
  426.                 flags.SetAlphaBlendMode(e_AlphaBlended);
  427.                 flags.SetDrawInFrontMode(e_DrawInFrontOn);
  428.                 flags.SetDepthTestFlag(e_DepthTestOff);
  429.  
  430.                 pRenderAuxGeom->SetRenderFlags(flags);
  431.         }
  432.  
  433.         operator bool() const { return pRenderAuxGeom != nullptr; }
  434.  
  435.         IRenderAuxGeom*           pRenderAuxGeom;
  436.         const SAuxGeomRenderFlags oldRenderFlags;
  437. };
  438.  
  439. struct SLabelColorLegendRenderer
  440. {
  441.         static void DrawLegend()
  442.         {
  443.                 const float fontSize = 1.8f;
  444.                 const float dy = 15.0f;
  445.                 const float x = 10.0f;
  446.                 float y = 120.0f;
  447.  
  448.                 LabelColor colorer;
  449.                 SLegendRenderer legend;
  450.                 if (legend)
  451.                 {
  452.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::NoLabel), "NoLabel");
  453.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::BorderLabelV), "BorderLabelV");
  454.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::BorderLabelH), "BorderLabelH");
  455.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::ExternalContour), "ExternalContour");
  456.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::InternalContour), "InternalContour");
  457.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::NoLabel | CTileGenerator::InternalContour), "Something else");
  458.                 }
  459.         }
  460. };
  461.  
  462. struct SPaintColorLegendRenderer
  463. {
  464.         static void DrawLegend(const std::vector<uint16>& paints)
  465.         {
  466.                 const float fontSize = 1.8f;
  467.                 const float dy = 15.0f;
  468.                 const float x = 10.0f;
  469.                 float y = 120.0f;
  470.  
  471.                 uint16 maxPaintValue = CTileGenerator::Paint::NoPaint;
  472.                 if (!paints.empty())
  473.                 {
  474.                         auto iter = std::max_element(paints.begin(), paints.end());
  475.                         maxPaintValue = *iter;
  476.                 }
  477.  
  478.                 SPaintColor colorer;
  479.                 SLegendRenderer legend;
  480.                 if (legend)
  481.                 {
  482.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::Paint::NoPaint), "NoPaint");
  483.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::Paint::BadPaint), "BadPaint");
  484.                         legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(CTileGenerator::Paint::OkPaintStart), "OkPaintStart");
  485.                         for (uint16 paintVal = CTileGenerator::Paint::OkPaintStart, idx = 1; paintVal < maxPaintValue; ++paintVal, ++idx)
  486.                         {
  487.                                 legend.DrawColorLegendLine(Vec2(x, (y += dy)), Vec2(dy, dy), fontSize, colorer(paintVal), stack_string().Format("paint #%u", (uint32)idx).c_str());
  488.                         }
  489.                 }
  490.         }
  491. };
  492.  
  493. #if DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  494.  
  495. class CNonWalkableInfoPrinter
  496. {
  497. public:
  498.         CNonWalkableInfoPrinter(const CTileGenerator::NonWalkableSpanReasonMap& nonWalkabaleSpanInfos)
  499.                 : m_nonWalkabaleSpanInfos(nonWalkabaleSpanInfos)
  500.         {}
  501.  
  502.         void operator()(const CompactSpanGrid::Span& span, const SSpanCoord& spanCoord, const Vec3& topCenter, IRenderAuxGeom* const pRenderAuxGeom) const
  503.         {
  504.                 const auto& iterCoordInfoPair = m_nonWalkabaleSpanInfos.find(spanCoord);
  505.                 if (iterCoordInfoPair != m_nonWalkabaleSpanInfos.end())
  506.                 {
  507.                         if (!IsOnScreen(topCenter))
  508.                         {
  509.                                 return;
  510.                         }
  511.  
  512.                         const CTileGenerator::SNonWalkableReason& info = iterCoordInfoPair->second;
  513.  
  514.                         SDrawTextInfo ti;
  515.                         ti.scale = Vec2(0.08f);
  516.                         ti.flags = eDrawText_800x600 | eDrawText_IgnoreOverscan | eDrawText_Center | eDrawText_CenterV;
  517.  
  518.                         if (info.bIsNeighbourReason)
  519.                         {
  520.                                 RenderText(pRenderAuxGeom, topCenter, ti, "%" PRISIZE_T ", %" PRISIZE_T ", %" PRISIZE_T " %s\n%s",
  521.                                            spanCoord.cellX, spanCoord.cellY, spanCoord.spanIdx, info.szReason,
  522.                                            info.neighbourReason.szReason);
  523.                         }
  524.                         else
  525.                         {
  526.                                 RenderText(pRenderAuxGeom, topCenter, ti, "%" PRISIZE_T ", %" PRISIZE_T ", %" PRISIZE_T " %s",
  527.                                            spanCoord.cellX, spanCoord.cellY, spanCoord.spanIdx, info.szReason);
  528.                         }
  529.                 }
  530.         }
  531. private:
  532.         const CTileGenerator::NonWalkableSpanReasonMap& m_nonWalkabaleSpanInfos;
  533. };
  534.  
  535. #endif // DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  536.  
  537. class CDistanceInfoPrinter
  538. {
  539. public:
  540.         CDistanceInfoPrinter(const uint16* pDistances_)
  541.                 : pDistances(pDistances_)
  542.         {
  543.         }
  544.  
  545.         void operator()(const CompactSpanGrid::Span& span, const SSpanCoord& spanCoord, const Vec3& topCenter, IRenderAuxGeom* const pRenderAuxGeom) const
  546.         {
  547.                 if (IsOnScreen(topCenter))
  548.                 {
  549.                         SDrawTextInfo ti;
  550.                         ti.scale = Vec2(0.1f);
  551.                         ti.flags = eDrawText_800x600 | eDrawText_IgnoreOverscan | eDrawText_Center | eDrawText_CenterV;
  552.  
  553.                         RenderText(pRenderAuxGeom, topCenter, ti, "%u", uint32(pDistances[spanCoord.spanAbsIdx]));
  554.                 }
  555.         }
  556. private:
  557.         const uint16* pDistances;
  558. };
  559.  
  560. static void DrawRawTriangulation(const std::vector<Triangle>& rawGeometryTriangles)
  561. {
  562.         IRenderAuxGeom* pRenderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  563.         const size_t triCount = rawGeometryTriangles.size();
  564.         if (triCount > 0)
  565.         {
  566.                 const ColorB vcolor(Col_SlateBlue, 0.65f);
  567.                 const ColorB lcolor(Col_White);
  568.  
  569.                 const Vec3 offset(0.0f, 0.0f, 0.0f);
  570.                 const Vec3 lineOffset(0.0f, 0.0f, 0.0005f);
  571.  
  572.                 SAuxGeomRenderFlags oldFlags = pRenderAuxGeom->GetRenderFlags();
  573.                 SAuxGeomRenderFlags renderFlags(oldFlags);
  574.  
  575.                 renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  576.                 renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  577.                 pRenderAuxGeom->SetRenderFlags(renderFlags);
  578.  
  579.                 for (size_t i = 0; i < triCount; ++i)
  580.                 {
  581.                         const Triangle& triangle = rawGeometryTriangles[i];
  582.                         const Vec3 v0 = triangle.v0 + offset;
  583.                         const Vec3 v1 = triangle.v1 + offset;
  584.                         const Vec3 v2 = triangle.v2 + offset;
  585.  
  586.                         pRenderAuxGeom->DrawTriangle(v0, vcolor, v1, vcolor, v2, vcolor);
  587.                 }
  588.  
  589.                 renderFlags.SetAlphaBlendMode(e_AlphaNone);
  590.                 renderFlags.SetDepthWriteFlag(e_DepthWriteOn);
  591.                 pRenderAuxGeom->SetRenderFlags(renderFlags);
  592.  
  593.                 for (size_t i = 0; i < triCount; ++i)
  594.                 {
  595.                         const Triangle& triangle = rawGeometryTriangles[i];
  596.  
  597.                         const Vec3 v0 = triangle.v0 + offset + lineOffset;
  598.                         const Vec3 v1 = triangle.v1 + offset + lineOffset;
  599.                         const Vec3 v2 = triangle.v2 + offset + lineOffset;
  600.  
  601.                         pRenderAuxGeom->DrawLine(v0, lcolor, v1, lcolor);
  602.                         pRenderAuxGeom->DrawLine(v1, lcolor, v2, lcolor);
  603.                         pRenderAuxGeom->DrawLine(v2, lcolor, v0, lcolor);
  604.                 }
  605.                 pRenderAuxGeom->SetRenderFlags(oldFlags);
  606.         }
  607. }
  608.  
  609. class CContourRenderer
  610. {
  611. public:
  612.         struct SDummyContourVertexPrinter
  613.         {
  614.                 void operator()(IRenderAuxGeom& /*renderAuxGeom*/, const CTileGenerator::ContourVertex& /*vtx*/, const size_t /*vtxIdx*/, const Vec3& /*vtxPosWorld*/) const
  615.                 {}
  616.         };
  617.  
  618.         struct SContourVertexNumberPrinter
  619.         {
  620.                 void operator()(IRenderAuxGeom& renderAuxGeom, const CTileGenerator::ContourVertex& vtx, const size_t vtxIdx, const Vec3& vtxPosWorld) const
  621.                 {
  622.                         Vec2 screenPos;
  623.                         if (IsOnScreen(vtxPosWorld, *&screenPos))
  624.                         {
  625.                                 ColorF textColor(Col_White);
  626.  
  627.                                 IRenderAuxText::Draw2dLabel(screenPos.x, screenPos.y, 1.5f, (float*)&textColor, true, "%" PRISIZE_T, vtxIdx);
  628.                         }
  629.                 }
  630.         };
  631.  
  632. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  633.         struct SContourVertexDebugInfoPrinter
  634.         {
  635.                 SContourVertexDebugInfoPrinter(const CTileGenerator::ContourVertexDebugInfos& infos)
  636.                         : infos(infos)
  637.                 {}
  638.  
  639.                 void operator()(IRenderAuxGeom& renderAuxGeom, const CTileGenerator::ContourVertex& vtx, const size_t vtxIdx, const Vec3& vtxPosWorld) const
  640.                 {
  641.                         if (vtx.debugInfoIndex == (~0))
  642.                         {
  643.                                 return;
  644.                         }
  645.  
  646.                         const char* szText = nullptr;
  647.                         if (vtx.debugInfoIndex < infos.size())
  648.                         {
  649.                                 const CTileGenerator::SContourVertexDebugInfo& info = infos[vtx.debugInfoIndex];
  650.  
  651.                                 if (IsOnScreen(vtxPosWorld))
  652.                                 {
  653.                                         SDrawTextInfo ti;
  654.                                         ti.scale = Vec2(0.1f);
  655.                                         ti.flags = eDrawText_800x600 | eDrawText_IgnoreOverscan | eDrawText_Center | eDrawText_CenterV;
  656.  
  657.                                         const char dirNames[4] = { 'N', 'E', 'S', 'W' };
  658.                                         const char* const classNames[3] = { "UW", "NB", "WB" };
  659.  
  660.                                         RenderText(&renderAuxGeom, vtxPosWorld, ti,
  661.                                                    "(%d;%d;%d):%d:%c\n"
  662.                                                    "%s %s %s, %u %u %u %u\n"
  663.                                                    "%s",
  664.                                                    info.tracer.pos.x, info.tracer.pos.y, info.tracer.pos.z, info.tracerIndex, dirNames[info.tracer.dir],
  665.                                                    classNames[info.lclass], classNames[info.flclass], classNames[info.fclass], info.walkableBit, info.borderBitH, info.borderBitV, info.internalBorderV,
  666.                                                    info.unremovableReason.c_str());
  667.                                 }
  668.                         }
  669.  
  670.                 }
  671.  
  672.                 const CTileGenerator::ContourVertexDebugInfos& infos;
  673.         };
  674. #endif // DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  675. public:
  676.         CContourRenderer(const Vec3& origin, const CTileGenerator::Params& params)
  677.                 : m_origin(origin)
  678.                 , m_voxelSize(params.voxelSize)
  679.                 , m_contourBoundaryVertexRadius(ContourBoundaryVertexRadius(m_voxelSize.x))
  680.                 , m_pRenderAuxGeom(gEnv->pRenderer->GetIRenderAuxGeom())
  681.                 , m_oldRenderFlags(m_pRenderAuxGeom->GetRenderFlags())
  682.         {
  683.                 SAuxGeomRenderFlags flags = m_oldRenderFlags;
  684.                 // Note: uncomment and recode for contour without depth write
  685.                 //flags.SetAlphaBlendMode(e_AlphaBlended);
  686.                 //flags.SetDepthWriteFlag(e_DepthWriteOff);
  687.                 m_pRenderAuxGeom->SetRenderFlags(flags);
  688.         }
  689.  
  690.         ~CContourRenderer()
  691.         {
  692.                 m_pRenderAuxGeom->SetRenderFlags(m_oldRenderFlags);
  693.         }
  694.  
  695.         template<typename TVertexPrinter>
  696.         void DrawRegions(const CTileGenerator::Regions& regions, const ColorB unremovableColor, const TVertexPrinter& vertexPrinter)
  697.         {
  698.                 if (!regions.empty())
  699.                 {
  700.                         for (size_t i = 0; i < regions.size(); ++i)
  701.                         {
  702.                                 const CTileGenerator::Region& region = regions[i];
  703.  
  704.                                 if (region.contour.empty())
  705.                                         continue;
  706.  
  707.                                 DrawRegion(region, i, unremovableColor, vertexPrinter);
  708.                         }
  709.                 }
  710.         }
  711.  
  712.         template<typename TVertexPrinter>
  713.         void DrawRegion(const CTileGenerator::Region& region, const size_t regionIndex, const ColorB unremovableColor, const TVertexPrinter& vertexPrinter)
  714.         {
  715.                 const ColorB vcolor = LabelColor()(regionIndex);
  716.  
  717.                 DrawContour(region.contour, vcolor, unremovableColor, vertexPrinter);
  718.  
  719.                 for (size_t h = 0; h < region.holes.size(); ++h)
  720.                 {
  721.                         const CTileGenerator::Contour& hole = region.holes[h];
  722.  
  723.                         DrawContour(hole, vcolor, unremovableColor, vertexPrinter);
  724.                 }
  725.  
  726.                 size_t xx = 0;
  727.                 size_t yy = 0;
  728.                 size_t zz = 0;
  729.  
  730.                 for (size_t c = 0; c < region.contour.size(); ++c)
  731.                 {
  732.                         const CTileGenerator::ContourVertex& cv = region.contour[c];
  733.                         xx += cv.x;
  734.                         yy += cv.y;
  735.                         zz = std::max<size_t>(zz, cv.z);
  736.                 }
  737.  
  738.                 Vec3 idLocation(xx / (float)region.contour.size(), yy / (float)region.contour.size(), (float)zz);
  739.                 idLocation = m_origin + idLocation.CompMul(m_voxelSize);
  740.  
  741.                 Vec2 screenPos;
  742.                 if (IsOnScreen(idLocation, *&screenPos))
  743.                 {
  744.                         ColorF textColor(vcolor.pack_abgr8888());
  745.  
  746.                         IRenderAuxText::Draw2dLabel(screenPos.x, screenPos.y, 1.8f, (float*)&textColor, true, "%" PRISIZE_T, regionIndex);
  747.                         IRenderAuxText::Draw2dLabel(screenPos.x, screenPos.y + 1.6f * 10.0f, 1.1f, (float*)&textColor, true,
  748.                                                      "spans: %" PRISIZE_T " holes: %" PRISIZE_T, region.spanCount, region.holes.size());
  749.                 }
  750.         }
  751.  
  752.         template<typename TVertexPrinter>
  753.         void DrawContour(const CTileGenerator::Contour& contour, const ColorB vcolor, const ColorB unremovableColor, const TVertexPrinter& printer) const
  754.         {
  755.                 const CTileGenerator::ContourVertex& v = contour.front();
  756.  
  757.                 Vec3 v0 = ContourVertexWorldPos(v);
  758.  
  759.                 for (size_t s = 1; s <= contour.size(); ++s)
  760.                 {
  761.                         const size_t vtxIndex = s % contour.size();
  762.                         const CTileGenerator::ContourVertex& nv = contour[vtxIndex];
  763.                         const ColorB pcolor = (nv.flags & CTileGenerator::ContourVertex::Unremovable) ? unremovableColor : vcolor;
  764.  
  765.                         const Vec3 v1 = ContourVertexWorldPos(nv);
  766.  
  767.                         m_pRenderAuxGeom->DrawLine(v0, vcolor, v1, vcolor, 7.0f);
  768.  
  769.                         if (nv.flags & CTileGenerator::ContourVertex::TileBoundary)
  770.                         {
  771.                                 m_pRenderAuxGeom->DrawCone(v1, Vec3(0.0f, 0.0f, 1.0f), m_contourBoundaryVertexRadius, 0.085f, pcolor);
  772.  
  773.                                 if (nv.flags & CTileGenerator::ContourVertex::TileBoundaryV)
  774.                                         m_pRenderAuxGeom->DrawAABB(AABB(v1, m_contourBoundaryVertexRadius), IDENTITY, true, pcolor, eBBD_Faceted);
  775.                         }
  776.                         else if (nv.flags & CTileGenerator::ContourVertex::TileBoundaryV)
  777.                                 m_pRenderAuxGeom->DrawAABB(AABB(v1, m_contourBoundaryVertexRadius), IDENTITY, true, pcolor, eBBD_Faceted);
  778.                         else
  779.                                 m_pRenderAuxGeom->DrawSphere(v1, m_contourBoundaryVertexRadius, pcolor);
  780.  
  781.                         printer(*m_pRenderAuxGeom, nv, vtxIndex, v1);
  782.  
  783.                         v0 = v1;
  784.                 }
  785.         }
  786.  
  787.         Vec3 ContourVertexWorldPos(const CTileGenerator::ContourVertex& vtx) const
  788.         {
  789.                 return m_origin + Vec3(
  790.                   vtx.x * m_voxelSize.x,
  791.                   vtx.y * m_voxelSize.y,
  792.                   vtx.z * m_voxelSize.z);
  793.         }
  794.  
  795.         static float ContourBoundaryVertexRadius(float voxelSizeX)
  796.         {
  797.                 return std::min(voxelSizeX * 0.3f, 0.03f);
  798.         }
  799.  
  800. private:
  801.         const Vec3          m_origin;
  802.         const Vec3          m_voxelSize;
  803.         const float         m_contourBoundaryVertexRadius;
  804.         IRenderAuxGeom*     m_pRenderAuxGeom;
  805.         SAuxGeomRenderFlags m_oldRenderFlags;
  806. };
  807.  
  808. void CTileGenerator::Draw(const EDrawMode mode, const bool bDrawAdditionalInfo) const
  809. {
  810. #if DEBUG_MNM_ENABLED
  811.  
  812.         const size_t border = BorderSizeH(m_params);
  813.         const size_t borderV = BorderSizeV(m_params);
  814.         const Vec3 origin = Vec3(
  815.           m_params.origin.x - m_params.voxelSize.x * border,
  816.           m_params.origin.y - m_params.voxelSize.y * border,
  817.           m_params.origin.z - m_params.voxelSize.z * borderV);
  818.  
  819.         const float blinking = 0.25f + 0.75f * fabs_tpl(sin_tpl(gEnv->pTimer->GetCurrTime() * gf_PI));
  820.         const ColorB red = (Col_Red * blinking) + (Col_VioletRed * (1.0f - blinking));
  821.  
  822.         const AABB tileVolume(m_params.origin, m_params.origin + Vec3(m_params.sizeX, m_params.sizeY, m_params.sizeZ));
  823.         gAIEnv.GetDebugRenderer()->DrawAABB(tileVolume, false, Col_Red, eBBD_Faceted);
  824.         gAIEnv.GetDebugRenderer()->DrawAABB(m_debugVoxelizedVolume, false, Col_DarkOliveGreen, eBBD_Faceted);
  825.  
  826.         switch (mode)
  827.         {
  828.         case EDrawMode::DrawNone:
  829.         default:
  830.                 break;
  831.         case EDrawMode::DrawRawInputGeometry:
  832.                 {
  833.                         DrawRawTriangulation(m_debugRawGeometry);
  834.                 }
  835.                 break;
  836.  
  837.         case EDrawMode::DrawRawVoxels:
  838.                 if (m_spanGridRaw.GetSpanCount())
  839.                 {
  840.                         MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGridRaw
  841.                                           , AllPassFilter(), RawColorPicker(Col_LightGray, Col_DarkGray));
  842.                 }
  843.                 break;
  844.  
  845.         case EDrawMode::DrawFilteredVoxels:
  846.                 if (m_spanGrid.GetSpanCount())
  847.                 {
  848.                         MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGrid
  849.                                           , AllPassFilter(), RawColorPicker(Col_LightGray, Col_DarkGray));
  850.                 }
  851.                 break;
  852.  
  853.         case EDrawMode::DrawFlaggedVoxels:
  854.                 if (m_spanGridFlagged.GetSpanCount())
  855.                 {
  856.                         if (bDrawAdditionalInfo)
  857.                         {
  858.         #if DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  859.                                 MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGridFlagged, NotWalkableFilter(), ColorB(Col_VioletRed), CNonWalkableInfoPrinter(m_debugNonWalkableReasonMap));
  860.         #endif
  861.                         }
  862.                         else
  863.                         {
  864.                                 MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGridFlagged, NotWalkableFilter(), ColorB(Col_VioletRed));
  865.                         }
  866.                         MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGridFlagged, WalkableFilter(), ColorB(Col_SlateBlue));
  867.                         MNM::DrawSpanGrid(origin, m_params.voxelSize, m_spanGridFlagged, BoundaryFilter(), ColorB(Col_NavyBlue, 0.5f));
  868.                 }
  869.                 break;
  870.         case EDrawMode::DrawDistanceTransform:
  871.                 if (!m_distances.empty())
  872.                 {
  873.                         if (bDrawAdditionalInfo)
  874.                         {
  875.                                 DrawSpanGridTop(origin, m_params.voxelSize, m_spanGrid, AllPassFilter(), DistanceColorPicker(&m_distances.front()), CDistanceInfoPrinter(&m_distances.front()));
  876.                         }
  877.                         else
  878.                         {
  879.                                 DrawSpanGridTop(origin, m_params.voxelSize, m_spanGrid, AllPassFilter(), DistanceColorPicker(&m_distances.front()));
  880.                         }
  881.                 }
  882.                 break;
  883.  
  884.         case EDrawMode::DrawPainting:
  885.                 if (!m_paint.empty())
  886.                 {
  887.                         DrawSpanGridTop(origin, m_params.voxelSize, m_spanGrid, AllPassFilter(), SPaintColorPicker(&m_paint.front()));
  888.                         if (bDrawAdditionalInfo)
  889.                         {
  890.                                 SPaintColorLegendRenderer::DrawLegend(m_paint);
  891.                         }
  892.                 }
  893.                 break;
  894.  
  895.         case EDrawMode::DrawSegmentation:
  896.                 DrawSegmentation(origin, bDrawAdditionalInfo);
  897.                 break;
  898.  
  899.         case EDrawMode::DrawNumberedContourVertices:
  900.                 {
  901.                         CContourRenderer contourRenderer(origin, m_params);
  902.                         contourRenderer.DrawRegions(m_regions, red, CContourRenderer::SContourVertexNumberPrinter());
  903.                 }
  904.                 break;
  905.  
  906.         case EDrawMode::DrawContourVertices:
  907.                 {
  908.                         CContourRenderer contourRenderer(origin, m_params);
  909.         #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  910.                         if (bDrawAdditionalInfo)
  911.                         {
  912.                                 DrawSegmentation(origin + Vec3(0, 0, -0.01f), false);
  913.                                 contourRenderer.DrawRegions(m_regions, red, CContourRenderer::SContourVertexDebugInfoPrinter(m_debugContourVertexDebugInfos));
  914.                                 DrawTracers(origin + Vec3(0, 0, 0.003f));
  915.                                 // Note: uncomment and recode to show even vertices, which were discarded during contour creation
  916.                                 //contourRenderer.DrawContour(m_debugDiscardedVertices, Col_Blue, red, CContourRenderer::SContourVertexDebugInfoPrinter(m_debugContourVertexDebugInfos));
  917.                         }
  918.                         else
  919.         #endif // DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  920.                         {
  921.                                 contourRenderer.DrawRegions(m_regions, red, CContourRenderer::SDummyContourVertexPrinter());
  922.                         }
  923.                 }
  924.                 break;
  925.  
  926.         case EDrawMode::DrawTracers:
  927.                 {
  928.                         DrawTracers(origin);
  929.                 }
  930.                 break;
  931.  
  932.         case EDrawMode::DrawSimplifiedContours:
  933.                 {
  934.                         DrawSimplifiedContours(origin);
  935.  
  936.                 }
  937.                 break;
  938.         case EDrawMode::DrawTriangulation:
  939.                 {
  940.                         DrawNavTriangulation();
  941.                 }
  942.                 break;
  943.         case EDrawMode::DrawBVTree:
  944.                 {
  945.                         DrawNavTriangulation();
  946.  
  947.                         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  948.  
  949.                         for (size_t i = 0; i < m_bvtree.size(); ++i)
  950.                         {
  951.                                 const Tile::SBVNode& node = m_bvtree[i];
  952.  
  953.                                 AABB nodeAABB;
  954.  
  955.                                 nodeAABB.min = m_params.origin + node.aabb.min.GetVec3();
  956.                                 nodeAABB.max = m_params.origin + node.aabb.max.GetVec3();
  957.  
  958.                                 renderAuxGeom->DrawAABB(nodeAABB, IDENTITY, false, Col_White, eBBD_Faceted);
  959.                         }
  960.                 }
  961.                 break;
  962.         }
  963.  
  964. #endif // DEBUG_MNM_ENABLED
  965. }
  966.  
  967. void CTileGenerator::DrawSegmentation(const Vec3& origin, const bool bDrawAdditionalInfo) const
  968. {
  969.         if (!m_labels.empty())
  970.         {
  971.                 DrawSpanGridTop(origin, m_params.voxelSize, m_spanGrid, WalkableFilter(), LabelColorPicker(&m_labels.front()));
  972.                 if (bDrawAdditionalInfo)
  973.                 {
  974.                         SLabelColorLegendRenderer::DrawLegend();
  975.                 }
  976.         }
  977.  
  978.         for (size_t i = 0; i < m_regions.size(); ++i)
  979.         {
  980.                 const Region& region = m_regions[i];
  981.  
  982.                 if (region.contour.empty())
  983.                         continue;
  984.  
  985.                 size_t xx = 0;
  986.                 size_t yy = 0;
  987.                 size_t zz = 0;
  988.  
  989.                 for (size_t c = 0; c < region.contour.size(); ++c)
  990.                 {
  991.                         const ContourVertex& v = region.contour[c];
  992.                         xx += v.x;
  993.                         yy += v.y;
  994.                         zz = std::max<size_t>(zz, v.z);
  995.                 }
  996.  
  997.                 Vec3 idLocation(xx / (float)region.contour.size(), yy / (float)region.contour.size(), (float)zz);
  998.                 idLocation = origin + idLocation.CompMul(m_params.voxelSize);
  999.  
  1000.                 Vec2 screenPos;
  1001.                 if (IsOnScreen(idLocation, *&screenPos))
  1002.                 {
  1003.                         const ColorB vcolor = LabelColor()(i);
  1004.                         ColorF textColor(vcolor.pack_abgr8888());
  1005.  
  1006.                         IRenderAuxText::Draw2dLabel(screenPos.x, screenPos.y, 1.8f, (float*)&textColor, true, "%" PRISIZE_T, i);
  1007.                         IRenderAuxText::Draw2dLabel(screenPos.x, screenPos.y + 1.6f * 10.0f, 1.1f, (float*)&textColor, true,
  1008.                                                      "spans: %" PRISIZE_T " holes: %" PRISIZE_T, region.spanCount, region.holes.size());
  1009.                 }
  1010.         }
  1011. }
  1012.  
  1013. void CTileGenerator::DrawTracers(const Vec3& origin) const
  1014. {
  1015.         if (IRenderAuxGeom* pRender = gEnv->pRenderer->GetIRenderAuxGeom())
  1016.         {
  1017.                 const SAuxGeomRenderFlags old = pRender->GetRenderFlags();
  1018.                 SAuxGeomRenderFlags flags;
  1019.                 flags.SetAlphaBlendMode(e_AlphaBlended);
  1020.                 flags.SetDepthWriteFlag(e_DepthWriteOff);
  1021.  
  1022.                 pRender->SetRenderFlags(flags);
  1023.                 {
  1024.                         const Vec3 corners[4] =
  1025.                         {
  1026.                                 Vec3(-m_params.voxelSize.x, +m_params.voxelSize.y, 0.f) * 0.5f,
  1027.                                 Vec3(+m_params.voxelSize.x, +m_params.voxelSize.y, 0.f) * 0.5f,
  1028.                                 Vec3(+m_params.voxelSize.x, -m_params.voxelSize.y, 0.f) * 0.5f,
  1029.                                 Vec3(-m_params.voxelSize.x, -m_params.voxelSize.y, 0.f) * 0.5f
  1030.                         };
  1031.                         const ColorF cols[4] =
  1032.                         {
  1033.                                 Col_Red, Col_Yellow, Col_Green, Col_Blue
  1034.                         };
  1035.                         const int numPaths = m_tracerPaths.size();
  1036.                         for (int i = 0; i < numPaths; i++)
  1037.                         {
  1038.                                 const TracerPath& path = m_tracerPaths[i];
  1039.                                 const int numTracers = path.steps.size();
  1040.                                 for (int j = 0; j < numTracers; j++)
  1041.                                 {
  1042.                                         const Tracer& tracer = path.steps[j];
  1043.                                         const Vec3 mid(origin + (m_params.voxelSize.CompMul(tracer.pos)));
  1044.                                         const size_t corner1 = (tracer.dir) % 4;
  1045.                                         const size_t corner2 = (tracer.dir + 3) % 4;
  1046.                                         pRender->DrawTriangle(mid, Col_White, mid + corners[corner1], cols[tracer.dir], mid + corners[corner2], cols[tracer.dir]);
  1047.                                 }
  1048.                         }
  1049.                 }
  1050.                 pRender->SetRenderFlags(old);
  1051.         }
  1052. }
  1053.  
  1054. void CTileGenerator::DrawSimplifiedContours(const Vec3& origin) const
  1055. {
  1056.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  1057.  
  1058.         for (size_t i = 0; i < m_polygons.size(); ++i)
  1059.         {
  1060.                 const PolygonContour& contour = m_polygons[i].contour;
  1061.  
  1062.                 if (contour.empty())
  1063.                         continue;
  1064.  
  1065.                 const ColorB vcolor = LabelColor()(i);
  1066.  
  1067.                 const PolygonVertex& pv = contour[contour.size() - 1];
  1068.  
  1069.                 Vec3 v0(origin.x + pv.x * m_params.voxelSize.x,
  1070.                         origin.y + pv.y * m_params.voxelSize.y,
  1071.                         origin.z + pv.z * m_params.voxelSize.z);
  1072.  
  1073.                 for (size_t s = 0; s < contour.size(); ++s)
  1074.                 {
  1075.                         const PolygonVertex& nv = contour[s];
  1076.                         const Vec3 v1(origin.x + nv.x * m_params.voxelSize.x, origin.y + nv.y * m_params.voxelSize.y, origin.z + nv.z * m_params.voxelSize.z);
  1077.  
  1078.                         renderAuxGeom->DrawLine(v0, vcolor, v1, vcolor, 8.0f);
  1079.                         renderAuxGeom->DrawSphere(v1, 0.025f, vcolor);
  1080.                         IRenderAuxText::DrawLabelF(v1, 1.8f, "%d", (int)s);
  1081.  
  1082.                         v0 = v1;
  1083.                 }
  1084.  
  1085.                 {
  1086.                         for (size_t h = 0; h < m_polygons[i].holes.size(); ++h)
  1087.                         {
  1088.                                 const PolygonContour& hole = m_polygons[i].holes[h].verts;
  1089.                                 const PolygonVertex& hv = hole.front();
  1090.  
  1091.                                 float holeHeightRaise = 0.05f;
  1092.  
  1093.                                 v0(origin.x + hv.x * m_params.voxelSize.x,
  1094.                                    origin.y + hv.y * m_params.voxelSize.y,
  1095.                                    (origin.z + hv.z * m_params.voxelSize.z) + holeHeightRaise);
  1096.  
  1097.                                 for (size_t s = 1; s <= hole.size(); ++s)
  1098.                                 {
  1099.                                         const PolygonVertex& nv = hole[s % hole.size()];
  1100.                                         const ColorB pcolor = vcolor;
  1101.  
  1102.                                         Vec3 v1(origin.x + nv.x * m_params.voxelSize.x,
  1103.                                                 origin.y + nv.y * m_params.voxelSize.y,
  1104.                                                 (origin.z + nv.z * m_params.voxelSize.z) + holeHeightRaise);
  1105.  
  1106.                                         renderAuxGeom->DrawLine(v0, vcolor, v1, vcolor, 7.0f);
  1107.                                         renderAuxGeom->DrawCylinder(v1, Vec3(0.0f, 0.0f, 1.0f), 0.025f, 0.04f, pcolor);
  1108.  
  1109.                                         v0 = v1;
  1110.                                 }
  1111.                         }
  1112.                 }
  1113.  
  1114.         }
  1115. }
  1116.  
  1117. void CTileGenerator::DrawNavTriangulation() const
  1118. {
  1119.         IRenderAuxGeom* renderAuxGeom = gEnv->pRenderer->GetIRenderAuxGeom();
  1120.  
  1121.         const CGeneratedMesh::Triangles& triangles = m_mesh.GetTriangles();
  1122.         const CGeneratedMesh::Vertices& vertices = m_mesh.GetVertices();
  1123.  
  1124.         const size_t triCount = triangles.size();
  1125.  
  1126.         const ColorB vcolor(Col_SlateBlue, 0.65f);
  1127.         const ColorB lcolor(Col_White);
  1128.         const ColorB bcolor(Col_Black);
  1129.  
  1130.         const Vec3 offset(0.0f, 0.0f, 0.05f);
  1131.         const Vec3 loffset(0.0f, 0.0f, 0.0005f);
  1132.  
  1133.         SAuxGeomRenderFlags oldFlags = renderAuxGeom->GetRenderFlags();
  1134.         SAuxGeomRenderFlags renderFlags(oldFlags);
  1135.  
  1136.         renderFlags.SetAlphaBlendMode(e_AlphaBlended);
  1137.         renderFlags.SetDepthWriteFlag(e_DepthWriteOff);
  1138.  
  1139.         renderAuxGeom->SetRenderFlags(renderFlags);
  1140.  
  1141.         for (size_t i = 0; i < triCount; ++i)
  1142.         {
  1143.                 const Tile::STriangle& triangle = triangles[i];
  1144.                 const Vec3 v0 = vertices[triangle.vertex[0]].GetVec3() + m_params.origin + offset;
  1145.                 const Vec3 v1 = vertices[triangle.vertex[1]].GetVec3() + m_params.origin + offset;
  1146.                 const Vec3 v2 = vertices[triangle.vertex[2]].GetVec3() + m_params.origin + offset;
  1147.  
  1148.                 renderAuxGeom->DrawTriangle(v0, vcolor, v1, vcolor, v2, vcolor);
  1149.         }
  1150.  
  1151.         renderAuxGeom->SetRenderFlags(oldFlags);
  1152.  
  1153.         {
  1154.                 for (size_t i = 0; i < triCount; ++i)
  1155.                 {
  1156.                         const Tile::STriangle& triangle = triangles[i];
  1157.  
  1158.                         const Vec3 v0 = vertices[triangle.vertex[0]].GetVec3() + m_params.origin + offset;
  1159.                         const Vec3 v1 = vertices[triangle.vertex[1]].GetVec3() + m_params.origin + offset;
  1160.                         const Vec3 v2 = vertices[triangle.vertex[2]].GetVec3() + m_params.origin + offset;
  1161.  
  1162.                         renderAuxGeom->DrawLine(v0 + loffset, lcolor, v1 + loffset, lcolor);
  1163.                         renderAuxGeom->DrawLine(v1 + loffset, lcolor, v2 + loffset, lcolor);
  1164.                         renderAuxGeom->DrawLine(v2 + loffset, lcolor, v0 + loffset, lcolor);
  1165.                 }
  1166.         }
  1167. }
  1168.  
  1169. } // namespace MNM
  1170.  
downloadTileGeneratorDraw.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