// // Copyright (c) 2009-2010 Mikko Mononen memon@inside.org // // This software is provided 'as-is', without any express or implied // warranty. In no event will the authors be held liable for any damages // arising from the use of this software. // Permission is granted to anyone to use this software for any purpose, // including commercial applications, and to alter it and redistribute it // freely, subject to the following restrictions: // 1. The origin of this software must not be misrepresented; you must not // claim that you wrote the original software. If you use this software // in a product, an acknowledgment in the product documentation would be // appreciated but is not required. // 2. Altered source versions must be plainly marked as such, and must not be // misrepresented as being the original software. // 3. This notice may not be removed or altered from any source distribution. // #include "Shared/Include/SharedAssert.h" #include "Shared/Include/SharedCommon.h" #include "Recast/Include/Recast.h" #include "Detour/Include/DetourNavMesh.h" #include "Detour/Include/DetourNavMeshBuilder.h" #include "DebugUtils/Include/RecastDebugDraw.h" #include "DebugUtils/Include/DetourDebugDraw.h" #include "NavEditor/Include/NavMeshTesterTool.h" #include "NavEditor/Include/NavMeshPruneTool.h" #include "NavEditor/Include/OffMeshConnectionTool.h" #include "NavEditor/Include/ConvexVolumeTool.h" #include "NavEditor/Include/CrowdTool.h" #include "NavEditor/Include/InputGeom.h" #include "NavEditor/Include/Editor.h" #include "NavEditor/Include/Editor_TileMesh.h" #include "game/server/ai_navmesh.h" #include "game/server/ai_hull.h" #ifdef DT_POLYREF64 const static int MAX_POLYREF_CHARS = 22; #define STR_TO_ID strtoull #else const static int MAX_POLYREF_CHARS = 11; #define STR_TO_ID strtoul #endif // DT_POLYREF64 class NavMeshTileTool : public EditorTool { Editor_TileMesh* m_editor; dtNavMesh* m_navMesh; float m_hitPos[3]; dtPolyRef m_markedPolyRef; enum TextOverlayDrawMode { TO_DRAW_DISABLED = -1, TO_DRAW_POLY_GROUPS, TO_DRAW_POLY_SURF_AREAS }; TextOverlayDrawMode m_textOverlayDrawMode; char m_polyRefTextInput[MAX_POLYREF_CHARS]; bool m_hitPosSet; public: NavMeshTileTool() : m_editor(0), m_navMesh(0), m_markedPolyRef(0), m_textOverlayDrawMode(TO_DRAW_DISABLED), m_hitPosSet(false) { rdVset(m_hitPos, 0.0f,0.0f,0.0f); memset(m_polyRefTextInput, '\0', sizeof(m_polyRefTextInput)); } virtual ~NavMeshTileTool() { } virtual int type() { return TOOL_TILE_EDIT; } virtual void init(Editor* editor) { m_editor = (Editor_TileMesh*)editor; m_navMesh = editor->getNavMesh(); } virtual void reset() {} virtual void handleMenu() { ImGui::Text("Create Tiles"); if (ImGui::Button("Create All")) { if (m_editor) m_editor->buildAllTiles(); } if (ImGui::Button("Remove All")) { if (m_editor) m_editor->removeAllTiles(); } ImGui::Separator(); ImGui::Text("Debug Options"); if (ImGui::RadioButton("Show Poly Groups", m_textOverlayDrawMode == TO_DRAW_POLY_GROUPS)) toggleTextOverlayDrawMode(TO_DRAW_POLY_GROUPS); if (ImGui::RadioButton("Show Poly Surface Areas", m_textOverlayDrawMode == TO_DRAW_POLY_SURF_AREAS)) toggleTextOverlayDrawMode(TO_DRAW_POLY_SURF_AREAS); if (m_navMesh) { ImGui::PushItemWidth(83); if (m_navMesh && ImGui::InputText("Mark Poly By Ref", m_polyRefTextInput, sizeof(m_polyRefTextInput), ImGuiInputTextFlags_EnterReturnsTrue)) { char* pEnd = nullptr; m_markedPolyRef = (dtPolyRef)STR_TO_ID(m_polyRefTextInput, &pEnd, 10); } ImGui::PopItemWidth(); } if (m_markedPolyRef) { if (ImGui::Button("Clear Marker")) { m_markedPolyRef = 0; } } } virtual void handleClick(const float* /*s*/, const float* p, bool shift) { m_hitPosSet = true; rdVcopy(m_hitPos,p); if (m_editor) { if (shift) m_editor->removeTile(m_hitPos); else m_editor->buildTile(m_hitPos); m_editor->buildStaticPathingData(); } } virtual void handleToggle() {} virtual void handleStep() {} virtual void handleUpdate(const float /*dt*/) {} virtual void handleRender() { if (m_hitPosSet) { const float s = m_editor->getAgentRadius(); glColor4ub(0,0,0,128); glLineWidth(2.0f); glBegin(GL_LINES); glVertex3f(m_hitPos[0]-s,m_hitPos[1],m_hitPos[2]+0.1f); glVertex3f(m_hitPos[0]+s,m_hitPos[1],m_hitPos[2]+0.1f); glVertex3f(m_hitPos[0],m_hitPos[1]-s,m_hitPos[2]+0.1f); glVertex3f(m_hitPos[0],m_hitPos[1]+s,m_hitPos[2]+0.1f); glVertex3f(m_hitPos[0],m_hitPos[1],m_hitPos[2]-s+0.1f); glVertex3f(m_hitPos[0],m_hitPos[1],m_hitPos[2]+s+0.1f); glEnd(); glLineWidth(1.0f); } if (m_markedPolyRef && m_editor && m_navMesh) { duDebugDrawNavMeshPoly(&m_editor->getDebugDraw(), *m_navMesh, m_markedPolyRef, m_editor->getDetourDrawOffset(), m_editor->getNavMeshDrawFlags(), duRGBA(255, 0, 170, 190), false); } } virtual void handleRenderOverlay(double* proj, double* model, int* view) { GLdouble x, y, z; const int h = view[3]; const float* drawOffset = m_editor->getDetourDrawOffset(); // NOTE: don't add the render offset here as we want to keep the overlay at the hit position, this // way we can have the navmesh on the side and hit a specific location on the input geometry, and // see which tile we build as this will be drawn on the hit position, while we can enumerate all // the tiles using the debug options in the NavMeshTileTool which will always be aligned with the // navmesh. if (m_hitPosSet && gluProject((GLdouble)m_hitPos[0], (GLdouble)m_hitPos[1], (GLdouble)m_hitPos[2], model, proj, view, &x, &y, &z)) { int tx=0, ty=0; m_editor->getTilePos(m_hitPos, tx, ty); ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter, ImVec2((float)x, h-((float)y-25)), ImVec4(0,0,0,0.8f), "(%d,%d)", tx,ty); } if (m_navMesh && m_textOverlayDrawMode != TO_DRAW_DISABLED) { for (int i = 0; i < m_navMesh->getMaxTiles(); i++) { const dtMeshTile* tile = m_navMesh->getTile(i); if (!tile->header) continue; for (int j = 0; j < tile->header->polyCount; j++) { const dtPoly* poly = &tile->polys[j]; unsigned short value = 0; switch (m_textOverlayDrawMode) { case TO_DRAW_POLY_GROUPS: value = poly->groupId; break; case TO_DRAW_POLY_SURF_AREAS: value = poly->surfaceArea; break; default: // Unhandled text overlay mode. rdAssert(0); } if (gluProject((GLdouble)poly->center[0]+drawOffset[0], (GLdouble)poly->center[1]+drawOffset[1], (GLdouble)poly->center[2]+drawOffset[2]+30, model, proj, view, &x, &y, &z)) { ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter, ImVec2((float)x, h - (float)y), ImVec4(0, 0, 0, 0.8f), "%hu (%d,%d)", value, i, j); } } //for (int j = 0; j < tile->header->maxCellCount; j++) //{ // const dtCell* cell = &tile->cells[j]; // if (gluProject((GLdouble)cell->pos[0]+drawOffset[0], (GLdouble)cell->pos[1]+drawOffset[1], (GLdouble)cell->pos[2]+drawOffset[2]+30, // model, proj, view, &x, &y, &z)) // { // ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter, // ImVec2((float)x, h - (float)y), ImVec4(0, 0.4, 0, 0.8f), "(%d,%d)", j, cell->flags); // } //} } } // Tool help ImGui_RenderText(ImGuiTextAlign_e::kAlignLeft, ImVec2(280, 40), ImVec4(1.0f,1.0f,1.0f,0.75f), "LMB: Rebuild hit tile. Shift+LMB: Clear hit tile."); } void toggleTextOverlayDrawMode(const TextOverlayDrawMode drawMode) { m_textOverlayDrawMode == drawMode ? m_textOverlayDrawMode = TO_DRAW_DISABLED : m_textOverlayDrawMode = drawMode; } }; #undef STR_TO_ID Editor_TileMesh::Editor_TileMesh() : m_buildAll(true), m_maxTiles(0), m_maxPolysPerTile(0), m_tileBuildTime(0), m_tileMemUsage(0), m_tileTriCount(0) { resetCommonSettings(); selectNavMeshType(NAVMESH_SMALL); memset(m_lastBuiltTileBmin, 0, sizeof(m_lastBuiltTileBmin)); memset(m_lastBuiltTileBmax, 0, sizeof(m_lastBuiltTileBmax)); setTool(new NavMeshTileTool); m_drawActiveTile = true; } Editor_TileMesh::~Editor_TileMesh() { cleanup(); dtFreeNavMesh(m_navMesh); m_navMesh = 0; } void Editor_TileMesh::handleSettings() { Editor::handleCommonSettings(); ImGui::Text("Tiling"); ImGui::SliderInt("Tile Size", &m_tileSize, 8, 2048); ImGui::Checkbox("Build All Tiles", &m_buildAll); ImGui::Checkbox("Keep Intermediate Results", &m_keepInterResults); EditorCommon_SetAndRenderTileProperties(m_geom, m_tileSize, m_cellSize, m_maxTiles, m_maxPolysPerTile); ImGui::Separator(); Editor_StaticTileMeshCommon::renderIntermediateTileMeshOptions(); } void Editor_TileMesh::handleTools() { int type = !m_tool ? TOOL_NONE : m_tool->type(); bool isEnabled = type == TOOL_NAVMESH_TESTER; if (ImGui::Checkbox("Test NavMesh", &isEnabled)) { setTool(new NavMeshTesterTool); } isEnabled = type == TOOL_NAVMESH_PRUNE; if (ImGui::Checkbox("Prune NavMesh", &isEnabled)) { setTool(new NavMeshPruneTool); } isEnabled = type == TOOL_TILE_EDIT; if (ImGui::Checkbox("Create Tiles", &isEnabled)) { setTool(new NavMeshTileTool); } isEnabled = type == TOOL_OFFMESH_CONNECTION; if (ImGui::Checkbox("Create Off-Mesh Links", &isEnabled)) { setTool(new OffMeshConnectionTool); } isEnabled = type == TOOL_CONVEX_VOLUME; if (ImGui::Checkbox("Create Convex Volumes", &isEnabled)) { setTool(new ConvexVolumeTool); } isEnabled = type == TOOL_CROWD; if (ImGui::Checkbox("Create Crowds", &isEnabled)) { setTool(new CrowdTool); } ImGui::Separator(); ImGui::Indent(); if (m_tool) m_tool->handleMenu(); ImGui::Unindent(); } void Editor_TileMesh::handleDebugMode() { Editor::renderMeshOffsetOptions(); ImGui::Separator(); Editor_StaticTileMeshCommon::renderRecastDebugMenu(); ImGui::Separator(); Editor::renderDetourDebugMenu(); } void Editor_TileMesh::handleRender() { Editor_StaticTileMeshCommon::renderTileMeshData(); } void Editor_TileMesh::handleRenderOverlay(double* proj, double* model, int* view) { GLdouble x, y, z; const int h = view[3]; const float* drawOffset = getDetourDrawOffset(); float projectPos[3]; rdVset(projectPos, ((m_lastBuiltTileBmin[0]+m_lastBuiltTileBmax[0])/2)+drawOffset[0], ((m_lastBuiltTileBmin[1]+m_lastBuiltTileBmax[1])/2)+drawOffset[1], ((m_lastBuiltTileBmin[2]+m_lastBuiltTileBmax[2])/2)+drawOffset[2]); // Draw start and end point labels if (m_tileBuildTime > 0.0f && gluProject((GLdouble)projectPos[0], (GLdouble)projectPos[1], (GLdouble)projectPos[2], model, proj, view, &x, &y, &z)) { ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter, ImVec2((float)x, h-(float)(y-25)), ImVec4(0,0,0,0.8f), "%.3fms / %dTris / %.1fkB", m_tileBuildTime, m_tileTriCount, m_tileMemUsage); } if (m_tool) m_tool->handleRenderOverlay(proj, model, view); renderOverlayToolStates(proj, model, view); } void Editor_TileMesh::handleMeshChanged(InputGeom* geom) { Editor::handleMeshChanged(geom); const BuildSettings* buildSettings = geom->getBuildSettings(); if (buildSettings && buildSettings->tileSize > 0) m_tileSize = buildSettings->tileSize; cleanup(); dtFreeNavMesh(m_navMesh); m_navMesh = 0; if (m_tool) { m_tool->reset(); m_tool->init(this); } resetToolStates(); initToolStates(this); } bool Editor_TileMesh::handleBuild() { if (!m_geom || !m_geom->getMesh()) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: No vertices and triangles."); return false; } dtFreeNavMesh(m_navMesh); m_navMesh = dtAllocNavMesh(); if (!m_navMesh) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not allocate navmesh."); return false; } m_loadedNavMeshType = m_selectedNavMeshType; dtNavMeshParams params; rdVcopy(params.orig, m_geom->getNavMeshBoundsMin()); params.orig[0] = m_geom->getNavMeshBoundsMax()[0]; params.tileWidth = m_tileSize*m_cellSize; params.tileHeight = m_tileSize*m_cellSize; params.maxTiles = m_maxTiles; params.maxPolys = m_maxPolysPerTile; params.polyGroupCount = 0; params.traversalTableSize = 0; params.traversalTableCount = NavMesh_GetTraversalTableCountForNavMeshType(m_selectedNavMeshType); #if DT_NAVMESH_SET_VERSION >= 8 params.magicDataCount = 0; #endif dtStatus status; status = m_navMesh->init(¶ms); if (dtStatusFailed(status)) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not init Detour navmesh."); return false; } status = m_navQuery->init(m_navMesh, 2048); if (dtStatusFailed(status)) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not init Detour navmesh query"); return false; } if (m_buildAll) buildAllTiles(); if (m_tool) m_tool->init(this); initToolStates(this); return true; } void Editor_TileMesh::collectSettings(BuildSettings& settings) { Editor::collectSettings(settings); settings.tileSize = m_tileSize; } void Editor_TileMesh::buildTile(const float* pos) { if (!m_geom) return; if (!m_navMesh) return; int tx, ty; getTilePos(pos, tx, ty); getTileExtents(tx, ty, m_lastBuiltTileBmin, m_lastBuiltTileBmax); m_tileCol = duRGBA(255,255,255,64); m_ctx->resetLog(); int dataSize = 0; unsigned char* data = buildTileMesh(tx, ty, m_lastBuiltTileBmin, m_lastBuiltTileBmax, dataSize); // Remove any previous data (navmesh owns and deletes the data). m_navMesh->removeTile(m_navMesh->getTileRefAt(tx,ty,0),0,0); // Add tile, or leave the location empty. if (data) { // Let the navmesh own the data. dtTileRef tileRef = 0; dtStatus status = m_navMesh->addTile(data,dataSize,DT_TILE_FREE_DATA,0,&tileRef); if (dtStatusFailed(status)) rdFree(data); else m_navMesh->connectTile(tileRef); } m_ctx->dumpLog("Build Tile (%d,%d):", tx,ty); } void Editor_TileMesh::getTileExtents(int tx, int ty, float* tmin, float* tmax) { const float ts = m_tileSize * m_cellSize; const float* bmin = m_geom->getNavMeshBoundsMin(); const float* bmax = m_geom->getNavMeshBoundsMax(); tmin[0] = bmax[0] - (tx+1)*ts; tmin[1] = bmin[1] + (ty)*ts; tmin[2] = bmin[2]; tmax[0] = bmax[0] - (tx)*ts; tmax[1] = bmin[1] + (ty+1)*ts; tmax[2] = bmax[2]; } void Editor_TileMesh::getTilePos(const float* pos, int& tx, int& ty) { if (!m_geom) return; const float* bmin = m_geom->getNavMeshBoundsMin(); const float* bmax = m_geom->getNavMeshBoundsMax(); const float ts = m_tileSize*m_cellSize; tx = (int)((bmax[0]- pos[0]) / ts); ty = (int)((pos[1] - bmin[1]) / ts); } void Editor_TileMesh::removeTile(const float* pos) { if (!m_geom) return; if (!m_navMesh) return; int tx, ty; getTilePos(pos, tx, ty); getTileExtents(tx, ty, m_lastBuiltTileBmin, m_lastBuiltTileBmax); m_tileCol = duRGBA(255,0,0,180); m_navMesh->removeTile(m_navMesh->getTileRefAt(tx,ty,0),0,0); } void Editor_TileMesh::buildAllTiles() { if (!m_geom) return; if (!m_navMesh) return; const float* bmin = m_geom->getNavMeshBoundsMin(); const float* bmax = m_geom->getNavMeshBoundsMax(); int gw = 0, gh = 0; rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh); const int ts = m_tileSize; const int tw = (gw + ts-1) / ts; const int th = (gh + ts-1) / ts; // Start the build process. m_ctx->startTimer(RC_TIMER_TEMP); for (int y = 0; y < th; ++y) { for (int x = 0; x < tw; ++x) { getTileExtents(x, y, m_lastBuiltTileBmin, m_lastBuiltTileBmax); int dataSize = 0; unsigned char* data = buildTileMesh(x, y, m_lastBuiltTileBmin, m_lastBuiltTileBmax, dataSize); if (data) { // Remove any previous data (navmesh owns and deletes the data). m_navMesh->removeTile(m_navMesh->getTileRefAt(x,y,0),0,0); // Let the navmesh own the data. dtTileRef tileRef = 0; dtStatus status = m_navMesh->addTile(data,dataSize,DT_TILE_FREE_DATA,0,&tileRef); if (dtStatusFailed(status)) rdFree(data); else m_navMesh->connectTile(tileRef); } } } buildStaticPathingData(); // Start the build process. m_ctx->stopTimer(RC_TIMER_TEMP); m_totalBuildTimeMs = m_ctx->getAccumulatedTime(RC_TIMER_TEMP)/1000.0f; m_tileCol = duRGBA(0,0,0,64); } void Editor_TileMesh::removeAllTiles() { if (!m_geom || !m_navMesh) return; const float* bmin = m_geom->getNavMeshBoundsMin(); const float* bmax = m_geom->getNavMeshBoundsMax(); int gw = 0, gh = 0; rcCalcGridSize(bmin, bmax, m_cellSize, &gw, &gh); const int ts = m_tileSize; const int tw = (gw + ts-1) / ts; const int th = (gh + ts-1) / ts; for (int y = 0; y < th; ++y) for (int x = 0; x < tw; ++x) m_navMesh->removeTile(m_navMesh->getTileRefAt(x,y,0),0,0); } void Editor_TileMesh::buildAllHulls() { for (const hulldef& h : hulls) { m_agentRadius = h.radius; m_agentMaxClimb = h.climbHeight; m_agentHeight = h.height; m_navmeshName = h.name; m_tileSize = h.tileSize; m_ctx->resetLog(); handleSettings(); handleBuild(); m_ctx->dumpLog("Build log %s:", h.name); Editor::saveAll(m_modelName.c_str(), m_navMesh); } } unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const float* bmin, const float* bmax, int& dataSize) { if (!m_geom || !m_geom->getMesh() || !m_geom->getChunkyMesh()) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Input mesh is not specified."); return 0; } m_tileMemUsage = 0; m_tileBuildTime = 0; cleanup(); const float* verts = m_geom->getMesh()->getVerts(); const int nverts = m_geom->getMesh()->getVertCount(); const int ntris = m_geom->getMesh()->getTriCount(); const rcChunkyTriMesh* chunkyMesh = m_geom->getChunkyMesh(); // Init build configuration from GUI memset(&m_cfg, 0, sizeof(m_cfg)); m_cfg.cs = m_cellSize; m_cfg.ch = m_cellHeight; m_cfg.walkableSlopeAngle = m_agentMaxSlope; m_cfg.walkableHeight = (int)ceilf(m_agentHeight / m_cfg.ch); m_cfg.walkableClimb = (int)floorf(m_agentMaxClimb / m_cfg.ch); m_cfg.walkableRadius = (int)ceilf(m_agentRadius / m_cfg.cs); m_cfg.maxEdgeLen = (int)(m_edgeMaxLen / m_cellSize); m_cfg.maxSimplificationError = m_edgeMaxError; m_cfg.minRegionArea = rdSqr(m_regionMinSize); // Note: area = size*size m_cfg.mergeRegionArea = rdSqr(m_regionMergeSize); // Note: area = size*size m_cfg.maxVertsPerPoly = (int)m_vertsPerPoly; m_cfg.tileSize = m_tileSize; m_cfg.borderSize = m_cfg.walkableRadius + 3; // Reserve enough padding. m_cfg.width = m_cfg.tileSize + m_cfg.borderSize*2; m_cfg.height = m_cfg.tileSize + m_cfg.borderSize*2; m_cfg.detailSampleDist = m_detailSampleDist < 0.9f ? 0 : m_cellSize * m_detailSampleDist; m_cfg.detailSampleMaxError = m_cellHeight * m_detailSampleMaxError; // Expand the heighfield bounding box by border size to find the extents of geometry we need to build this tile. // // This is done in order to make sure that the navmesh tiles connect correctly at the borders, // and the obstacles close to the border work correctly with the dilation process. // No polygons (or contours) will be created on the border area. // // IMPORTANT! // // :''''''''': // : +-----+ : // : | | : // : | |<--- tile to build // : | | : // : +-----+ :<-- geometry needed // :.........: // // You should use this bounding box to query your input geometry. // // For example if you build a navmesh for terrain, and want the navmesh tiles to match the terrain tile size // you will need to pass in data from neighbour terrain tiles too! In a simple case, just pass in all the 8 neighbours, // or use the bounding box below to only pass in a sliver of each of the 8 neighbours. rdVcopy(m_cfg.bmin, bmin); rdVcopy(m_cfg.bmax, bmax); m_cfg.bmin[0] -= m_cfg.borderSize*m_cfg.cs; m_cfg.bmin[1] -= m_cfg.borderSize*m_cfg.cs; m_cfg.bmax[0] += m_cfg.borderSize*m_cfg.cs; m_cfg.bmax[1] += m_cfg.borderSize*m_cfg.cs; // Reset build times gathering. m_ctx->resetTimers(); // Start the build process. m_ctx->startTimer(RC_TIMER_TOTAL); m_ctx->log(RC_LOG_PROGRESS, "Building navigation:"); m_ctx->log(RC_LOG_PROGRESS, " - %d x %d cells", m_cfg.width, m_cfg.height); m_ctx->log(RC_LOG_PROGRESS, " - %.1fK verts, %.1fK tris", nverts/1000.0f, ntris/1000.0f); // Allocate voxel heightfield where we rasterize our input data to. m_solid = rcAllocHeightfield(); if (!m_solid) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'solid'."); return 0; } if (!rcCreateHeightfield(m_ctx, *m_solid, m_cfg.width, m_cfg.height, m_cfg.bmin, m_cfg.bmax, m_cfg.cs, m_cfg.ch)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not create solid heightfield."); return 0; } // Allocate array that can hold triangle flags. // If you have multiple meshes you need to process, allocate // an array which can hold the max number of triangles you need to process. m_triareas = new unsigned char[chunkyMesh->maxTrisPerChunk]; if (!m_triareas) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'm_triareas' (%d).", chunkyMesh->maxTrisPerChunk); return 0; } float tbmin[2], tbmax[2]; tbmin[0] = m_cfg.bmin[0]; tbmin[1] = m_cfg.bmin[1]; tbmax[0] = m_cfg.bmax[0]; tbmax[1] = m_cfg.bmax[1]; #if 0 //NOTE(warmist): original algo int cid[2048];// TODO: Make grow when returning too many items. const int ncid = rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 2048); if (!ncid) return 0; m_tileTriCount = 0; for (int i = 0; i < ncid; ++i) { const rcChunkyTriMeshNode& node = chunkyMesh->nodes[cid[i]]; const int* ctris = &chunkyMesh->tris[node.i*3]; const int nctris = node.n; m_tileTriCount += nctris; memset(m_triareas, 0, nctris*sizeof(unsigned char)); rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle, verts, nverts, ctris, nctris, m_triareas); if (!rcRasterizeTriangles(m_ctx, verts, nverts, ctris, m_triareas, nctris, *m_solid, m_cfg.walkableClimb)) return 0; } #else //NOTE(warmist): algo with limited return but can be reinvoked to continue the query int cid[1024];//NOTE: we don't grow it but we reuse it (e.g. like a yieldable function or iterator or sth) int currentNode = 0; bool done = false; m_tileTriCount = 0; do{ int currentCount = 0; done=rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 1024,currentCount,currentNode); for (int i = 0; i < currentCount; ++i) { const rcChunkyTriMeshNode& node = chunkyMesh->nodes[cid[i]]; const int* ctris = &chunkyMesh->tris[node.i*3]; const int nctris = node.n; m_tileTriCount += nctris; memset(m_triareas, 0, nctris * sizeof(unsigned char)); rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle, verts, nverts, ctris, nctris, m_triareas); if (!rcRasterizeTriangles(m_ctx, verts, nverts, ctris, m_triareas, nctris, *m_solid, m_cfg.walkableClimb)) return 0; } } while (!done); if (m_tileTriCount == 0) return 0; #endif if (!m_keepInterResults) { delete [] m_triareas; m_triareas = 0; } // Once all geometry is rasterized, we do initial pass of filtering to // remove unwanted overhangs caused by the conservative rasterization // as well as filter spans where the character cannot possibly stand. if (m_filterLowHangingObstacles) rcFilterLowHangingWalkableObstacles(m_ctx, m_cfg.walkableClimb, *m_solid); if (m_filterLedgeSpans) rcFilterLedgeSpans(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid); if (m_filterWalkableLowHeightSpans) rcFilterWalkableLowHeightSpans(m_ctx, m_cfg.walkableHeight, *m_solid); // Compact the heightfield so that it is faster to handle from now on. // This will result more cache coherent data as well as the neighbours // between walkable cells will be calculated. m_chf = rcAllocCompactHeightfield(); if (!m_chf) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'chf'."); return 0; } if (!rcBuildCompactHeightfield(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid, *m_chf)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build compact data."); return 0; } if (!m_keepInterResults) { rcFreeHeightField(m_solid); m_solid = 0; } // Erode the walkable area by agent radius. if (!rcErodeWalkableArea(m_ctx, m_cfg.walkableRadius, *m_chf)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not erode."); return 0; } // (Optional) Mark areas. const ConvexVolume* vols = m_geom->getConvexVolumes(); for (int i = 0; i < m_geom->getConvexVolumeCount(); ++i) rcMarkConvexPolyArea(m_ctx, vols[i].verts, vols[i].nverts, vols[i].hmin, vols[i].hmax, (unsigned char)vols[i].area, *m_chf); // Partition the heightfield so that we can use simple algorithm later to triangulate the walkable areas. // There are 3 partitioning methods, each with some pros and cons: // 1) Watershed partitioning // - the classic Recast partitioning // - creates the nicest tessellation // - usually slowest // - partitions the heightfield into nice regions without holes or overlaps // - the are some corner cases where this method creates produces holes and overlaps // - holes may appear when a small obstacles is close to large open area (triangulation can handle this) // - overlaps may occur if you have narrow spiral corridors (i.e stairs), this make triangulation to fail // * generally the best choice if you precompute the navmesh, use this if you have large open areas // 2) Monotone partitioning // - fastest // - partitions the heightfield into regions without holes and overlaps (guaranteed) // - creates long thin polygons, which sometimes causes paths with detours // * use this if you want fast navmesh generation // 3) Layer partitioning // - quite fast // - partitions the heighfield into non-overlapping regions // - relies on the triangulation code to cope with holes (thus slower than monotone partitioning) // - produces better triangles than monotone partitioning // - does not have the corner cases of watershed partitioning // - can be slow and create a bit ugly tessellation (still better than monotone) // if you have large open areas with small obstacles (not a problem if you use tiles) // * good choice to use for tiled navmesh with medium and small sized tiles if (m_partitionType == EDITOR_PARTITION_WATERSHED) { // Prepare for region partitioning, by calculating distance field along the walkable surface. if (!rcBuildDistanceField(m_ctx, *m_chf)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build distance field."); return 0; } // Partition the walkable surface into simple regions without holes. if (!rcBuildRegions(m_ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea, m_cfg.mergeRegionArea)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build watershed regions."); return 0; } } else if (m_partitionType == EDITOR_PARTITION_MONOTONE) { // Partition the walkable surface into simple regions without holes. // Monotone partitioning does not need distancefield. if (!rcBuildRegionsMonotone(m_ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea, m_cfg.mergeRegionArea)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build monotone regions."); return 0; } } else // EDITOR_PARTITION_LAYERS { // Partition the walkable surface into simple regions without holes. if (!rcBuildLayerRegions(m_ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build layer regions."); return 0; } } // Create contours. m_cset = rcAllocContourSet(); if (!m_cset) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'."); return 0; } if (!rcBuildContours(m_ctx, *m_chf, m_cfg.maxSimplificationError, m_cfg.maxEdgeLen, *m_cset)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not create contours."); return 0; } if (m_cset->nconts == 0) { return 0; } // Build polygon navmesh from the contours. m_pmesh = rcAllocPolyMesh(); if (!m_pmesh) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'."); return 0; } if (!rcBuildPolyMesh(m_ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not triangulate contours."); return 0; } // Build detail mesh. m_dmesh = rcAllocPolyMeshDetail(); if (!m_dmesh) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'dmesh'."); return 0; } //rcFlipPolyMesh(*m_pmesh); if (!rcBuildPolyMeshDetail(m_ctx, *m_pmesh, *m_chf, m_cfg.detailSampleDist, m_cfg.detailSampleMaxError, *m_dmesh)) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build polymesh detail."); return 0; } //rcFlipPolyMeshDetail(*m_dmesh,m_pmesh->nverts); if (!m_keepInterResults) { rcFreeCompactHeightfield(m_chf); m_chf = 0; rcFreeContourSet(m_cset); m_cset = 0; } unsigned char* navData = 0; int navDataSize = 0; if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON) { if (m_pmesh->nverts >= 0xffff) { // The vertex indices are ushorts, and cannot point to more than 0xffff vertices. m_ctx->log(RC_LOG_ERROR, "Too many vertices per tile %d (max: %d).", m_pmesh->nverts, 0xffff); return 0; } // Update poly flags from areas. for (int i = 0; i < m_pmesh->npolys; ++i) { if (m_pmesh->areas[i] == RC_WALKABLE_AREA) m_pmesh->areas[i] = EDITOR_POLYAREA_GROUND; if (m_pmesh->areas[i] == EDITOR_POLYAREA_GROUND //|| //m_pmesh->areas[i] == EDITOR_POLYAREA_GRASS || //m_pmesh->areas[i] == EDITOR_POLYAREA_ROAD ) { m_pmesh->flags[i] = EDITOR_POLYFLAGS_WALK; } //else if (m_pmesh->areas[i] == EDITOR_POLYAREA_WATER) //{ // m_pmesh->flags[i] = EDITOR_POLYFLAGS_SWIM; //} else if (m_pmesh->areas[i] == EDITOR_POLYAREA_DOOR) { m_pmesh->flags[i] = EDITOR_POLYFLAGS_WALK | EDITOR_POLYFLAGS_DOOR; } } dtNavMeshCreateParams params; memset(¶ms, 0, sizeof(params)); params.verts = m_pmesh->verts; params.vertCount = m_pmesh->nverts; params.polys = m_pmesh->polys; params.polyAreas = m_pmesh->areas; params.polyFlags = m_pmesh->flags; params.polyCount = m_pmesh->npolys; params.nvp = m_pmesh->nvp; params.cellResolution = m_polyCellRes; params.detailMeshes = m_dmesh->meshes; params.detailVerts = m_dmesh->verts; params.detailVertsCount = m_dmesh->nverts; params.detailTris = m_dmesh->tris; params.detailTriCount = m_dmesh->ntris; params.offMeshConVerts = m_geom->getOffMeshConnectionVerts(); params.offMeshConRad = m_geom->getOffMeshConnectionRads(); params.offMeshConDir = m_geom->getOffMeshConnectionDirs(); params.offMeshConAreas = m_geom->getOffMeshConnectionAreas(); params.offMeshConFlags = m_geom->getOffMeshConnectionFlags(); params.offMeshConUserID = m_geom->getOffMeshConnectionId(); params.offMeshConRefPos = m_geom->getOffMeshConnectionRefPos(); params.offMeshConRefYaw = m_geom->getOffMeshConnectionRefYaws(); params.offMeshConCount = m_geom->getOffMeshConnectionCount(); params.walkableHeight = m_agentHeight; params.walkableRadius = m_agentRadius; params.walkableClimb = m_agentMaxClimb; params.tileX = tx; params.tileY = ty; params.tileLayer = 0; rdVcopy(params.bmin, m_pmesh->bmin); rdVcopy(params.bmax, m_pmesh->bmax); params.cs = m_cfg.cs; params.ch = m_cfg.ch; params.buildBvTree = true; const bool navMeshBuildSuccess = dtCreateNavMeshData(¶ms, &navData, &navDataSize); // Restore poly areas. for (int i = 0; i < m_pmesh->npolys; ++i) { // The game's poly area (ground) shares the same value as // RC_NULL_AREA, if we try to render the recast polymesh cache // without restoring this, the renderer will draw it as NULL area // even though it's walkable. The other values will get color ID'd // by the renderer so we don't need to check on those. if (m_pmesh->areas[i] == EDITOR_POLYAREA_GROUND) m_pmesh->areas[i] = RC_WALKABLE_AREA; } if (!navMeshBuildSuccess) { m_ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh."); return 0; } } m_tileMemUsage = navDataSize/1024.0f; m_ctx->stopTimer(RC_TIMER_TOTAL); // Show performance stats. duLogBuildTimes(*m_ctx, m_ctx->getAccumulatedTime(RC_TIMER_TOTAL)); m_ctx->log(RC_LOG_PROGRESS, ">> Polymesh: %d vertices %d polygons", m_pmesh->nverts, m_pmesh->npolys); m_tileBuildTime = m_ctx->getAccumulatedTime(RC_TIMER_TOTAL)/1000.0f; dataSize = navDataSize; return navData; }