BVB Source Codes

CRYENGINE Show TileGenerator.h Source code

Return Download CRYENGINE: download TileGenerator.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __MNM_TILE_GENERATOR_H
  4. #define __MNM_TILE_GENERATOR_H
  5.  
  6. #pragma once
  7.  
  8. #include "MNM.h"
  9. #include "MNMProfiler.h"
  10. #include "CompactSpanGrid.h"
  11. #include "Tile.h"
  12. #include "BoundingVolume.h"
  13. #include "HashComputer.h"
  14.  
  15. #include <CryAISystem/NavigationSystem/MNMTileGenerator.h>
  16.  
  17. #include <CryMath/SimpleHashLookUp.h>
  18.  
  19. #include <CryCore/Containers/CryListenerSet.h>
  20.  
  21. #if DEBUG_MNM_ENABLED
  22.         #define DEBUG_MNM_GATHER_NONWALKABLE_REASONS       (1)
  23.         #define DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO (1)
  24. #endif // DEBUG_MNM_ENABLED
  25.  
  26. struct IExternalNavigationMeshProvider;
  27.  
  28. namespace MNM
  29. {
  30.  
  31. struct STileGeneratorExtensionsContainer
  32. {
  33.         typedef VectorMap<TileGeneratorExtensionID, MNM::TileGenerator::IExtension*> TileGeneratorExtensionPtrsMap;
  34.  
  35.         TileGeneratorExtensionPtrsMap extensions;
  36.         TileGeneratorExtensionID      idCounter;
  37.         mutable CryReadModifyLock     extensionsLock;
  38. };
  39.  
  40. struct SSpanCoord
  41. {
  42.         struct Hash
  43.         {
  44.                 size_t operator()(const SSpanCoord& coord) const { return std::hash<size_t>()(coord.spanAbsIdx); }
  45.         };
  46.  
  47.         SSpanCoord(size_t x, size_t y, size_t s, size_t spanAbsIdx_)
  48.                 : cellX(x)
  49.                 , cellY(y)
  50.                 , spanIdx(s)
  51.                 , spanAbsIdx(spanAbsIdx_)
  52.         {}
  53.  
  54.         bool operator==(const SSpanCoord& other) const
  55.         {
  56.                 return (spanAbsIdx == other.spanAbsIdx) && (cellX == other.cellX) && (cellY == other.cellY) && (spanIdx == other.spanIdx);
  57.         }
  58.  
  59.         size_t cellX;
  60.         size_t cellY;
  61.         size_t spanIdx;
  62.         size_t spanAbsIdx;
  63. };
  64.  
  65. class CTileGenerator
  66. {
  67. public:
  68.         enum
  69.         {
  70.                 MaxTileSizeX = 18,
  71.                 MaxTileSizeY = 18,
  72.                 MaxTileSizeZ = 18,
  73.         };
  74.  
  75.         struct Params
  76.         {
  77.                 Params()
  78.                         : origin(ZERO)
  79.                         , sizeX(8)
  80.                         , sizeY(8)
  81.                         , sizeZ(8)
  82.                         , voxelSize(0.1f)
  83.                         , climbableInclineGradient(0.0f)
  84.                         , climbableStepRatio(0.0f)
  85.                         , flags(0)
  86.                         , blurAmount(0)
  87.                         , minWalkableArea(16)
  88.                         , boundary(nullptr)
  89.                         , exclusions(nullptr)
  90.                         , exclusionCount(0)
  91.                         , hashValue(0)
  92.                         , pTileGeneratorExtensions(nullptr)
  93.                 {}
  94.  
  95.                 enum Flags
  96.                 {
  97.                         NoBorder    = 1 << 0,
  98.                         NoErosion   = 1 << 1,
  99.                         NoHashTest  = 1 << 2,
  100.                         BuildBVTree = 1 << 3,
  101.                         DebugInfo   = 1 << 7,
  102.                 };
  103.  
  104.                 Vec3   origin;
  105.                 Vec3   voxelSize;
  106.                 float  climbableInclineGradient;
  107.                 float  climbableStepRatio;
  108.  
  109.                 uint16 flags;
  110.                 uint16 minWalkableArea;
  111.                 uint16 exclusionCount;
  112.  
  113.                 uint8  blurAmount;
  114.                 uint8  sizeX;
  115.                 uint8  sizeY;
  116.                 uint8  sizeZ;
  117.  
  118.                 struct AgentSettings
  119.                 {
  120.                         AgentSettings()
  121.                                 : radius(4)
  122.                                 , height(18)
  123.                                 , climbableHeight(4)
  124.                                 , maxWaterDepth(8)
  125.                                 , callback()
  126.                         {}
  127.  
  128.                         uint32                       radius          : 8;
  129.                         uint32                       height          : 8;
  130.                         uint32                       climbableHeight : 8;
  131.                         uint32                       maxWaterDepth   : 8;
  132.  
  133.                         NavigationMeshEntityCallback callback;
  134.                 }                                        agent;
  135.  
  136.                 const BoundingVolume*                    boundary;
  137.                 const BoundingVolume*                    exclusions;
  138.                 uint32                                   hashValue;
  139.  
  140.                 const STileGeneratorExtensionsContainer* pTileGeneratorExtensions;
  141.                 NavigationAgentTypeID                    navAgentTypeId;
  142.         };
  143.  
  144.         enum ProfilerTimers
  145.         {
  146.                 Voxelization = 0,
  147.                 Filter,
  148.                 DistanceTransform,
  149.                 Blur,
  150.                 ContourExtraction,
  151.                 Simplification,
  152.                 Triangulation,
  153.                 BVTreeConstruction,
  154.         };
  155.  
  156.         enum ProfilerMemoryUsers
  157.         {
  158.                 DynamicSpanGridMemory = 0,
  159.                 CompactSpanGridMemory,
  160.                 SegmentationMemory,
  161.                 RegionMemory,
  162.                 PolygonMemory,
  163.                 TriangulationMemory,
  164.                 VertexMemory,
  165.                 TriangleMemory,
  166.                 BVTreeConstructionMemory,
  167.                 BVTreeMemory,
  168.         };
  169.  
  170.         enum ProfilerStats
  171.         {
  172.                 VoxelizationTriCount = 0,
  173.                 RegionCount,
  174.                 PolygonCount,
  175.                 TriangleCount,
  176.                 VertexCount,
  177.                 BVTreeNodeCount,
  178.         };
  179.  
  180.         enum class EDrawMode
  181.         {
  182.                 DrawNone = 0,
  183.                 DrawRawInputGeometry,
  184.                 DrawRawVoxels,
  185.                 DrawFlaggedVoxels,
  186.                 DrawFilteredVoxels,
  187.                 DrawDistanceTransform,
  188.                 DrawPainting,
  189.                 DrawSegmentation,
  190.                 DrawTracers,
  191.                 DrawContourVertices,
  192.                 DrawNumberedContourVertices,
  193.                 DrawSimplifiedContours,
  194.                 DrawTriangulation,
  195.                 DrawBVTree,
  196.                 LastDrawMode,
  197.         };
  198.  
  199.         bool Generate(const Params& params, STile& tile, uint32* hashValue);
  200.         void Draw(const EDrawMode mode, const bool bDrawAdditionalInfo) const;
  201.  
  202.         typedef MNMProfiler<ProfilerMemoryUsers, ProfilerTimers, ProfilerStats> ProfilerType;
  203.         const ProfilerType& GetProfiler() const;
  204.  
  205.         enum SpanFlags
  206.         {
  207.                 NotWalkable  = BIT(0),
  208.                 TileBoundary = BIT(1),
  209.         };
  210.  
  211.         enum Labels
  212.         {
  213.                 FirstInvalidLabel = BIT(12) - 1,
  214.                 NoLabel           = FirstInvalidLabel,
  215.                 ExternalContour   = BIT(12),
  216.                 InternalContour   = BIT(13),
  217.                 BorderLabelH      = BIT(14),
  218.                 BorderLabelV      = BIT(15),
  219.         };
  220.  
  221.         enum Paint
  222.         {
  223.                 NoPaint = 0,
  224.                 BadPaint,
  225.                 OkPaintStart,
  226.         };
  227.  
  228. protected:
  229.  
  230.         typedef std::vector<uint16> SpanExtraInfo;
  231.  
  232.         struct ContourVertex
  233.         {
  234.                 ContourVertex()
  235. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  236.                         : debugInfoIndex(~0)
  237. #endif
  238.                 {}
  239.  
  240.                 ContourVertex(uint16 _x, uint16 _y, uint16 _z)
  241.                         : x(_x)
  242.                         , y(_y)
  243.                         , z(_z)
  244.                         , flags(0)
  245. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  246.                         , debugInfoIndex(~0)
  247. #endif
  248.                 {}
  249.  
  250.                 enum Flags
  251.                 {
  252.                         TileBoundary  = BIT(0),
  253.                         TileBoundaryV = BIT(1),
  254.                         Unremovable   = BIT(2),
  255.                         TileSideA     = BIT(4),
  256.                         TileSideB     = BIT(5),
  257.                         TileSideC     = BIT(6),
  258.                         TileSideD     = BIT(7),
  259.                         TileSides     = (TileSideA | TileSideB | TileSideC | TileSideD),
  260.                 };
  261.  
  262.                 bool operator<(const ContourVertex& other) const
  263.                 {
  264.                         if (x == other.x)
  265.                                 return y < other.y;
  266.                         else
  267.                                 return x < other.x;
  268.                 }
  269.  
  270.                 bool operator==(const ContourVertex& other) const
  271.                 {
  272.                         return (x == other.x) && (y == other.y) && (z == other.z);
  273.                 }
  274.  
  275.                 uint16 x;
  276.                 uint16 y;
  277.                 uint16 z;
  278.                 uint16 flags;
  279. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  280.                 size_t debugInfoIndex;
  281. #endif
  282.         };
  283.  
  284.         typedef std::vector<ContourVertex> Contour;
  285.         typedef std::vector<Contour>       Contours;
  286.  
  287.         struct PolygonVertex
  288.         {
  289.                 enum Flags
  290.                 {
  291.                         Reflex = BIT(0),
  292.                         Ear    = BIT(1),
  293.                 };
  294.  
  295.                 PolygonVertex(uint16 _x, uint16 _y, uint16 _z)
  296.                         : x(_x)
  297.                         , y(_y)
  298.                         , z(_z)
  299.                         , flags(0)
  300.                 {}
  301.  
  302.                 uint16 x;
  303.                 uint16 y;
  304.                 uint16 z;
  305.                 uint16 flags;
  306.  
  307.                 bool operator<(const ContourVertex& other) const
  308.                 {
  309.                         if (x == other.x)
  310.                                 return y < other.y;
  311.                         else
  312.                                 return x < other.x;
  313.                 }
  314.  
  315.                 bool operator==(const ContourVertex& other) const
  316.                 {
  317.                         return (x == other.x) && (y == other.y) && (z == other.z);
  318.                 }
  319.         };
  320.  
  321.         typedef std::vector<PolygonVertex> PolygonContour;
  322.  
  323.         struct Hole
  324.         {
  325.                 PolygonContour verts;
  326.                 Vec2i          center;
  327.                 int            rad;
  328.         };
  329.  
  330.         typedef std::vector<Hole>          PolygonHoles;
  331.         typedef std::vector<PolygonVertex> VoxelContour;
  332.  
  333.         struct Polygon
  334.         {
  335.                 PolygonContour contour;
  336.                 PolygonHoles   holes;
  337.         };
  338.  
  339.         struct Region
  340.         {
  341.                 Region()
  342.                         : spanCount(0)
  343.                         , flags(0)
  344.                 {}
  345.  
  346.                 enum Flags
  347.                 {
  348.                         TileBoundary  = BIT(0),
  349.                         TileBoundaryV = BIT(1),
  350.                 };
  351.  
  352.                 Contour  contour;
  353.                 Contours holes;
  354.  
  355.                 size_t   spanCount;
  356.                 size_t   flags;
  357.  
  358.                 void     swap(Region& other)
  359.                 {
  360.                         std::swap(spanCount, other.spanCount);
  361.  
  362.                         contour.swap(other.contour);
  363.                         holes.swap(other.holes);
  364.                 }
  365.         };
  366.  
  367.         class CGeneratedMesh : public TileGenerator::IMesh
  368.         {
  369.         public:
  370.                 typedef uint64                                               TileVertexKey;
  371.                 typedef simple_hash_lookup<TileVertexKey, Tile::VertexIndex> TileVertexIndexLookUp;
  372.                 typedef std::vector<Tile::STriangle>                         Triangles;
  373.                 typedef std::vector<Tile::Vertex>                            Vertices;
  374.  
  375.         public:
  376.                 void Clear();
  377.                 void SetTileAabb(const AABB& tileAabbWorld) { m_tileAabb = tileAabbWorld; }
  378.  
  379.                 bool IsEmpty() const                        { return m_triangles.empty(); }
  380.                 void CopyIntoTile(STile& tile) const;
  381.  
  382.                 // Functions for Triangulate()
  383.                 void             Reserve(size_t trianglesCount, size_t verticesCount);
  384.                 size_t           InsertVertex(const Tile::Vertex& vertex);
  385.                 Tile::STriangle& InsertTriangle();
  386.  
  387.                 // TileGenerator::IMesh
  388.                 virtual bool AddTrianglesWorld(const Triangle* pTriangles, const size_t count, const Tile::STriangle::EFlags flags) override;
  389.                 // ~TileGenerator::IMesh
  390.  
  391.                 void                 AddStatsToProfiler(ProfilerType& profiler) const;
  392.  
  393.                 const Triangles&     GetTriangles() const { return m_triangles; }
  394.                 const Vertices&      GetVertices() const  { return m_vertices; }
  395.  
  396.                 void                 ResetHashSeed(uint32 hashSeed);
  397.                 uint32               CompleteAndGetHashValue();
  398.  
  399.                 static TileVertexKey GetKeyFromTileVertex(const Tile::Vertex& vtx);
  400.  
  401.         private:
  402.                 enum { k_maxTriangleCount = 1024 };
  403.  
  404.                 Triangles             m_triangles;
  405.                 Vertices              m_vertices;
  406.                 TileVertexIndexLookUp m_vertexIndexLookUp;
  407.                 AABB                  m_tileAabb;
  408.                 HashComputer          m_hashComputer;
  409.         };
  410.  
  411.         // Call this when reusing an existing TileGenerator for a second job.
  412.         // Clears all the data but leaves the allocated memory.
  413.         void                 Clear();
  414.  
  415.         static size_t        BorderSizeH(const Params& params);
  416.         static size_t        BorderSizeV(const Params& params);
  417.  
  418.         inline static size_t Top(const Params& params)
  419.         {
  420.                 // TODO pavloi 2016.03.10: is 0.1f added to deal with some numerical issues?
  421.                 return (size_t)(params.sizeZ / params.voxelSize.z + 0.10f);
  422.         }
  423.  
  424.         inline bool IsBorderCell(size_t x, size_t y) const
  425.         {
  426.                 const size_t border = BorderSizeH(m_params);
  427.                 const size_t width = m_spanGrid.GetWidth();
  428.                 const size_t height = m_spanGrid.GetHeight();
  429.  
  430.                 return (x < border) || (x >= width - border) || (y < border) || (y >= height - border);
  431.         }
  432.  
  433.         inline bool IsBoundaryCell_Static(size_t x, size_t y, const size_t border, const size_t width, const size_t height) const
  434.         {
  435.                 return (((x == border) || (x == width - border - 1)) && (y >= border) && (y <= height - border - 1))
  436.                        || (((y == border) || (y == height - border - 1)) && (x >= border) && (x <= width - border - 1));
  437.         }
  438.  
  439.         inline bool IsBoundaryCell(size_t x, size_t y) const
  440.         {
  441.                 const size_t border = BorderSizeH(m_params);
  442.                 const size_t width = m_spanGrid.GetWidth();
  443.                 const size_t height = m_spanGrid.GetHeight();
  444.  
  445.                 return (((x == border) || (x == width - border - 1)) && (y >= border) && (y <= height - border - 1))
  446.                        || (((y == border) || (y == height - border - 1)) && (x >= border) && (x <= width - border - 1));
  447.         }
  448.  
  449.         inline bool IsBoundaryVertex(size_t x, size_t y) const
  450.         {
  451.                 const size_t border = BorderSizeH(m_params);
  452.                 const size_t width = m_spanGrid.GetWidth();
  453.                 const size_t height = m_spanGrid.GetHeight();
  454.  
  455.                 return (((x == border) || (x == width - border)) && (y >= border) && (y <= height - border))
  456.                        || (((y == border) || (y == height - border)) && (x >= border) && (x <= width - border));
  457.         }
  458.  
  459.         inline bool IsCornerVertex(size_t x, size_t y) const
  460.         {
  461.                 const size_t border = BorderSizeH(m_params);
  462.                 const size_t width = m_spanGrid.GetWidth();
  463.                 const size_t height = m_spanGrid.GetHeight();
  464.  
  465.                 return (((x == border) || (x == width - border)) && ((y == border) || (y == height - border)));
  466.         }
  467.  
  468.         inline bool IsBoundaryVertexV(size_t z) const
  469.         {
  470.                 const size_t borderV = BorderSizeV(m_params);
  471.  
  472.                 return (z == borderV) || (z == Top(m_params) + borderV);
  473.         }
  474.  
  475.         size_t VoxelizeVolume(const AABB& volume, uint32 hashValueSeed = 0, uint32* hashValue = 0);
  476.  
  477.         // Filter walkable and helpers
  478.         struct SFilterWalkableParams;
  479.         struct SSpanClearance;
  480.         struct SNonWalkableNeighbourReason;
  481.  
  482.         bool        GenerateFromVoxelizedVolume(const AABB& aabb, const bool fullyContained);
  483.  
  484.         void        FilterWalkable(const AABB& aabb, bool fullyContained = true);
  485.         static bool FilterWalkable_CheckSpanBackface(const CompactSpanGrid::Span& span);
  486.         static bool FilterWalkable_CheckSpanWaterDepth(const CompactSpanGrid::Span& span, const Params& params);
  487.         static bool FilterWalkable_CheckNeighbours(const SSpanCoord& spanCoord, const SSpanClearance& spanClearance, const SFilterWalkableParams& filterParams, SNonWalkableNeighbourReason* pOutReason);
  488.         void        FilterWalkable_CheckBoundaries(const AABB& aabb, const size_t gridWidth, const size_t gridHeight);
  489.  
  490.         void        ComputeDistanceTransform();
  491.         void        BlurDistanceTransform();
  492.  
  493.         void        PaintBorder(uint16* data, size_t borderH, size_t borderV);
  494.  
  495.         struct NeighbourInfoRequirements
  496.         {
  497.                 NeighbourInfoRequirements()
  498.                         : paint(NoPaint)
  499.                         , notPaint(NoPaint)
  500.                 {}
  501.                 uint16 paint, notPaint;
  502.         };
  503.  
  504.         struct NeighbourInfo
  505.         {
  506.                 NeighbourInfo(const Vec3i& pos)
  507.                         : pos(pos.x, pos.y)
  508.                         , top(pos.z)
  509.                         , index(~0ul)
  510.                         , label(CTileGenerator::NoLabel)
  511.                         , paint(NoPaint)
  512.                         , isValid(false)
  513.                 {}
  514.                 NeighbourInfo(const Vec2i& xy, const size_t z)
  515.                         : pos(xy)
  516.                         , top(z)
  517.                         , index(~0ul)
  518.                         , label(CTileGenerator::NoLabel)
  519.                         , paint(NoPaint)
  520.                         , isValid(false)
  521.                 {}
  522.                 const Vec2i pos;
  523.                 size_t      top;
  524.                 size_t      index;
  525.                 uint16      label;
  526.                 uint16      paint;
  527.                 bool        isValid;
  528.                 ILINE bool  Check(const NeighbourInfoRequirements& req) const
  529.                 {
  530.                         return isValid &&
  531.                                (req.paint == NoPaint || req.paint == paint) &&
  532.                                (req.notPaint == NoPaint || req.notPaint != paint);
  533.                 }
  534.         };
  535.  
  536.         uint16 GetPaintVal(size_t x, size_t y, size_t z, size_t index, size_t borderH, size_t borderV, size_t erosion);
  537.         void   AssessNeighbour(NeighbourInfo& info, size_t erosion, size_t climbableVoxelCount);
  538.  
  539.         enum TracerDir
  540.         {
  541.                 N,    //  0,+1
  542.                 E,    // +1, 0
  543.                 S,    //  0,-1
  544.                 W,    // -1, 0
  545.                 TOTAL_DIR
  546.         };
  547.  
  548.         struct Tracer
  549.         {
  550.                 Vec3i  pos;
  551.                 int    dir;
  552.                 size_t indexIn;
  553.                 size_t indexOut;
  554.                 bool   bPinchPoint;
  555.  
  556.                 ILINE bool  operator==(const Tracer& rhs) const { return pos == rhs.pos && dir == rhs.dir; }
  557.                 ILINE bool  operator!=(const Tracer& rhs) const { return pos != rhs.pos || dir != rhs.dir; }
  558.                 ILINE void  SetPos(const NeighbourInfo& info)   { pos = info.pos; pos.z = info.top; }
  559.                 ILINE void  TurnRight()                         { dir = ((dir + 1) & 3); }
  560.                 ILINE void  TurnLeft()                          { dir = ((dir + 3) & 3); }
  561.                 ILINE Vec2i GetDir() const                      { return Vec2i((dir & 1) * sgn(2 - dir), ((dir + 1) & 1) * sgn(1 - dir)); }
  562.                 ILINE Vec3i GetFront() const                    { return pos + GetDir(); }
  563.                 ILINE Vec3i GetLeft() const                     { return pos + (GetDir().rot90ccw()); }
  564.                 ILINE Vec3i GetFrontLeft() const                { const Vec2i dv(GetDir()); return pos + dv + (dv.rot90ccw()); }
  565.         };
  566.  
  567.         struct TracerPath
  568.         {
  569.                 TracerPath() : turns(0) {}
  570.                 typedef std::vector<Tracer> Tracers;
  571.                 Tracers steps;
  572.                 int     turns;
  573.         };
  574.  
  575.         void   TraceContour(CTileGenerator::TracerPath& path, const Tracer& start, size_t erosion, size_t climbableVoxelCount, const NeighbourInfoRequirements& contourReq);
  576.         int    LabelTracerPath(const CTileGenerator::TracerPath& path, size_t climbableVoxelCount, Region& region, Contour& contour, const uint16 internalLabel, const uint16 internalLabelFlags, const uint16 externalLabel);
  577.  
  578.         void   TidyUpContourEnd(Contour& contour);
  579.         size_t ExtractContours();
  580.         void   CalcPaintValues();
  581.  
  582.         void   FilterBadRegions(size_t minSpanCount);
  583.  
  584.         bool   SimplifyContour(const Contour& contour, const real_t& tolerance2DSq, const real_t& tolerance3DSq,
  585.                                PolygonContour& poly);
  586.         void   SimplifyContours();
  587.  
  588.         typedef simple_hash_lookup<uint32, uint16> VertexIndexLookUp;
  589.         void       MergeHole(PolygonContour& contour, const size_t contourVertex, const PolygonContour& hole, const size_t holeVertex, const int distSqr) const;
  590.         size_t     Triangulate(PolygonContour& contour, const size_t agentHeight, const size_t borderH, const size_t borderV,
  591.                                VertexIndexLookUp& lookUp);
  592.         size_t     Triangulate();
  593.         void       BuildBVTree();
  594.  
  595.         ILINE void CacheTracerPath(const TracerPath& path)
  596.         {
  597. #ifndef _RELEASE
  598.                 if (m_params.flags & Params::DebugInfo)
  599.                 {
  600.                         // TODO pavloi 2016.03.15: m_tracerPaths is not accounted in memory profiler
  601.                         m_tracerPaths.push_back(path);
  602.                 }
  603. #endif      //_RELEASE
  604.         }
  605.  
  606.         struct SurroundingSpanInfo
  607.         {
  608.                 SurroundingSpanInfo(uint16 _label, size_t _index, size_t _flags = 0)
  609.                         : flags(_flags)
  610.                         , label(_label)
  611.                         , index(_index)
  612.                 {}
  613.                 size_t flags;
  614.                 size_t index;
  615.                 uint16 label;
  616.         };
  617.  
  618.         enum NeighbourClassification
  619.         {
  620.                 UW = 0,   // not walkable
  621.                 NB = 1,   // walkable, not border
  622.                 WB = 2,   // walkable, border
  623.         };
  624.  
  625.         struct SContourVertexDebugInfo;
  626.  
  627.         inline NeighbourClassification ClassifyNeighbour(const SurroundingSpanInfo& neighbour,
  628.                                                          size_t erosion, size_t borderFlag) const
  629.         {
  630.                 if (((neighbour.flags & NotWalkable) != 0) || (m_distances[neighbour.index] < erosion))
  631.                         return UW;
  632.                 return (neighbour.label & borderFlag) ? WB : NB;
  633.         }
  634.  
  635.         bool GatherSurroundingInfo(const Vec2i& vertex, const Vec2i& direction, const uint16 top,
  636.                                    const uint16 climbableVoxelCount, size_t& height, SurroundingSpanInfo& left, SurroundingSpanInfo& front,
  637.                                    SurroundingSpanInfo& frontLeft) const;
  638.         void        DetermineContourVertex(const Vec2i& vertex, const Vec2i& direction, uint16 top,
  639.                                            uint16 climbableVoxelCount, ContourVertex& contourVertex, const bool bInternalContour, SContourVertexDebugInfo* pDebugInfo) const;
  640.         inline bool ContourVertexRemovable(const ContourVertex& contourVertex) const
  641.         {
  642.                 return ((contourVertex.flags & ContourVertex::TileBoundary) == 0)
  643.                        && ((contourVertex.flags & ContourVertex::Unremovable) == 0);
  644.         }
  645.  
  646.         void   AddContourVertex(const ContourVertex& vertex, Region& region, Contour& contour) const;
  647.  
  648.         size_t InsertUniqueVertex(VertexIndexLookUp& lookUp, size_t x, size_t y, size_t z);
  649.  
  650.         void   DrawNavTriangulation() const;
  651.         void   DrawTracers(const Vec3& origin) const;
  652.         void   DrawSimplifiedContours(const Vec3& origin) const;
  653.         void   DrawSegmentation(const Vec3& origin, const bool bDrawAdditionalInfo) const;
  654.  
  655.         Params         m_params;
  656.         ProfilerType   m_profiler;
  657.  
  658.         CGeneratedMesh m_mesh;
  659.  
  660.         typedef std::vector<Tile::SBVNode> BVTree;
  661.         BVTree          m_bvtree;
  662.  
  663.         CompactSpanGrid m_spanGrid;
  664.  
  665.         SpanExtraInfo   m_distances;
  666.         SpanExtraInfo   m_labels;
  667.         SpanExtraInfo   m_paint;
  668.  
  669.         typedef std::vector<Region> Regions;
  670.         Regions m_regions;
  671.  
  672.         typedef std::vector<Polygon> Polygons;
  673.         Polygons m_polygons;
  674.  
  675.         typedef std::vector<TracerPath> TracerPaths;
  676.         TracerPaths     m_tracerPaths;
  677.  
  678.         CompactSpanGrid m_spanGridRaw;
  679.         CompactSpanGrid m_spanGridFlagged;
  680.  
  681. #if DEBUG_MNM_ENABLED
  682.         std::vector<Triangle> m_debugRawGeometry;
  683.         AABB                  m_debugVoxelizedVolume;
  684. #endif // DEBUG_MNM_ENABLED
  685.  
  686. #if DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  687.  
  688.         struct SNonWalkableNeighbourReason
  689.         {
  690.                 SNonWalkableNeighbourReason()
  691.                         : szReason(nullptr)
  692.                 {}
  693.  
  694.                 const char* szReason;
  695.         };
  696.  
  697.         struct SNonWalkableReason
  698.         {
  699.                 SNonWalkableReason(const char* szReason_ = nullptr)
  700.                         : szReason(szReason_)
  701.                         , bIsNeighbourReason(false)
  702.                         , neighbourReason()
  703.                 {}
  704.  
  705.                 SNonWalkableReason(const char* szReason_, const SNonWalkableNeighbourReason& neighbourReason_)
  706.                         : szReason(szReason_)
  707.                         , bIsNeighbourReason(true)
  708.                         , neighbourReason(neighbourReason_)
  709.                 {}
  710.  
  711.                 const char*                 szReason;
  712.                 bool                        bIsNeighbourReason;
  713.                 SNonWalkableNeighbourReason neighbourReason;
  714.         };
  715.  
  716.         typedef std::unordered_map<SSpanCoord, SNonWalkableReason, SSpanCoord::Hash> NonWalkableSpanReasonMap;
  717.  
  718.         friend class CNonWalkableInfoPrinter;
  719.  
  720.         NonWalkableSpanReasonMap m_debugNonWalkableReasonMap;
  721.  
  722. #endif // DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  723.  
  724.         inline void DebugAddNonWalkableReason(const SSpanCoord& spanCoord, const char* szReason)
  725.         {
  726. #if DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  727.                 IF_UNLIKELY (m_params.flags & Params::DebugInfo)
  728.                 {
  729.                         m_debugNonWalkableReasonMap[spanCoord] = SNonWalkableReason(szReason);
  730.                 }
  731. #endif // DEBUG_MNM_GATHER_NONWALKABLE_REASONS
  732.         }
  733.  
  734.         friend class CContourRenderer;
  735. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  736.         struct SContourVertexDebugInfo
  737.         {
  738.                 SContourVertexDebugInfo()
  739.                         : unremovableReason()
  740.                         , tracer()
  741.                         , tracerIndex(-1)
  742.                         , lclass(UW)
  743.                         , flclass(UW)
  744.                         , fclass(UW)
  745.                         , walkableBit(0)
  746.                         , borderBitH(0)
  747.                         , borderBitV(0)
  748.                         , internalBorderV(false)
  749.                 {}
  750.  
  751.                 CryFixedStringT<64>     unremovableReason;
  752.                 Tracer                  tracer;
  753.                 int                     tracerIndex;
  754.                 NeighbourClassification lclass;
  755.                 NeighbourClassification flclass;
  756.                 NeighbourClassification fclass;
  757.                 uint8                   walkableBit;
  758.                 uint8                   borderBitH;
  759.                 uint8                   borderBitV;
  760.                 bool                    internalBorderV;
  761.         };
  762.  
  763.         typedef std::vector<SContourVertexDebugInfo> ContourVertexDebugInfos;
  764.         ContourVertexDebugInfos m_debugContourVertexDebugInfos;
  765.         mutable Contour         m_debugDiscardedVertices;
  766. #endif // DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  767.  
  768.         void DebugAddContourVertexUnremovableReason(SContourVertexDebugInfo* pDebugInfo, const char* szUnremovableReason) const
  769.         {
  770. #if DEBUG_MNM_GATHER_EXTRA_CONTOUR_VERTEX_INFO
  771.                 IF_UNLIKELY (pDebugInfo)
  772.                 {
  773.                         if (!pDebugInfo->unremovableReason.empty())
  774.                         {
  775.                                 pDebugInfo->unremovableReason += '\n';
  776.                         }
  777.                         pDebugInfo->unremovableReason += szUnremovableReason;
  778.                 }
  779. #endif
  780.         }
  781. };
  782. }
  783.  
  784. #endif  // #ifndef __MNM_TILE_GENERATOR_H
  785.  
downloadTileGenerator.h 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