void BotShutdownNav( void ) { for ( int i = 0; i < numNavData; i++ ) { NavData_t *nav = &BotNavData[ i ]; if ( nav->cache ) { dtFreeTileCache( nav->cache ); nav->cache = 0; } if ( nav->mesh ) { dtFreeNavMesh( nav->mesh ); nav->mesh = 0; } if ( nav->query ) { dtFreeNavMeshQuery( nav->query ); nav->query = 0; } nav->process.con.reset(); memset( nav->name, 0, sizeof( nav->name ) ); } #ifndef DEDICATED NavEditShutdown(); #endif numNavData = 0; }
/** * Cleanup recast stuff, not debug manualobjects. **/ void OgreRecast::RecastCleanup() { if(m_triareas) delete [] m_triareas; m_triareas = 0; rcFreeHeightField(m_solid); m_solid = 0; rcFreeCompactHeightfield(m_chf); m_chf = 0; rcFreeContourSet(m_cset); m_cset = 0; rcFreePolyMesh(m_pmesh); m_pmesh = 0; rcFreePolyMeshDetail(m_dmesh); m_dmesh = 0; dtFreeNavMesh(m_navMesh); m_navMesh = 0; dtFreeNavMeshQuery(m_navQuery); m_navQuery = 0 ; if(m_ctx){ delete m_ctx; m_ctx = 0; } }
void Sample_SoloMesh::handleSettings() { Sample::handleCommonSettings(); if (imguiCheck("Keep Itermediate Results", m_keepInterResults)) m_keepInterResults = !m_keepInterResults; imguiSeparator(); imguiIndent(); imguiIndent(); if (imguiButton("Save")) { Sample::saveAll("solo_navmesh.bin", m_navMesh); } if (imguiButton("Load")) { dtFreeNavMesh(m_navMesh); m_navMesh = Sample::loadAll("solo_navmesh.bin"); m_navQuery->init(m_navMesh, 2048); } imguiUnindent(); imguiUnindent(); char msg[64]; snprintf(msg, 64, "Build Time: %.1fms", m_totalBuildTimeMs); imguiLabel(msg); imguiSeparator(); }
EXPORT_API void dtnmFreeNavMesh(dtNavMesh** pNavMesh, bool freeTiles) { if (!pNavMesh && !(*pNavMesh)) return; dtNavMesh* mesh = *pNavMesh; const dtNavMesh* cmesh = *pNavMesh; // Cleaner code when calling getTile(). if (freeTiles) { unsigned char* tData = 0; for (int i = 0; i < mesh->getMaxTiles(); ++i) { const dtMeshTile* tile = cmesh->getTile(i); if (!tile || !tile->header || !tile->dataSize) continue; dtTileRef tref = mesh->getTileRef(tile); dtStatus status = mesh->removeTile(tref, &tData, 0); if (dtStatusSucceed(status) && tData) { dtFree(tData); tData = 0; } } } dtFreeNavMesh(mesh); }
EXPORT_API dtStatus dtnmBuildSingleTileMesh(dtNavMeshCreateParams* params , dtNavMesh** ppNavMesh) { if (!params) return DT_FAILURE + DT_INVALID_PARAM; unsigned char* navData = 0; int navDataSize = 0; if (!dtCreateNavMeshData(params, &navData, &navDataSize)) return DT_FAILURE + DT_INVALID_PARAM; dtNavMesh* pNavMesh = dtAllocNavMesh(); if (!pNavMesh) { dtFree(navData); return DT_FAILURE + DT_OUT_OF_MEMORY; } dtStatus status = pNavMesh->init(navData, navDataSize, DT_TILE_FREE_DATA); if (dtStatusFailed(status)) { dtFreeNavMesh(pNavMesh); dtFree(navData); return status; } *ppNavMesh = pNavMesh; return DT_SUCCESS; }
bool NavMesh::buildProcess() { mBuilding = true; // Create mesh bool success = generateMesh(); mNavMeshLock.lock(); // Copy new navmesh into old. dtNavMesh *old = nm; nm = tnm; // I am trusting that this is atomic. dtFreeNavMesh(old); tnm = NULL; mNavMeshLock.unlock(); // Free structs used during build freeIntermediates(false); // Alert event manager that we have been built. if(mEventManager) mEventManager->postEvent("NavMeshBuild", ""); mBuilding = false; return success; }
Sample::~Sample() { dtFreeNavMeshQuery(m_navQuery); dtFreeNavMesh(m_navMesh); dtFreeCrowd(m_crowd); delete m_tool; }
void DetourInterface::detourCleanup() { dtFreeNavMesh(_navMesh); _navMesh = 0; dtFreeNavMeshQuery(_navQuery); _navQuery = 0; }
NavMeshGenerator::~NavMeshGenerator() { cleanup(); dtFreeNavMeshQuery(m_navQuery); dtFreeNavMesh(m_navMesh); dtFreeCrowd(m_crowd); }
void SoloMesh::handleMeshChanged(InputGeom* geom) { // m_geom = geom; Sample::handleMeshChanged(geom); dtFreeNavMesh(m_navMesh); m_navMesh = 0; }
Sample::~Sample() { dtFreeNavMeshQuery(m_navQuery); dtFreeNavMesh(m_navMesh); dtFreeCrowd(m_crowd); delete m_tool; for (int i = 0; i < MAX_TOOLS; i++) delete m_toolStates[i]; }
void NavMesh::SetMesh(InputGeom* geom) { m_geom = geom; dtFreeTileCache(m_tileCache); m_tileCache = 0; dtFreeNavMesh(m_navMesh); m_navMesh = 0; }
bool OgreDetourTileCache::initTileCache() { // BUILD TileCache dtFreeTileCache(m_tileCache); dtStatus status; m_tileCache = dtAllocTileCache(); if (!m_tileCache) { m_recast->m_pLog->logMessage("ERROR: buildTiledNavigation: Could not allocate tile cache."); return false; } status = m_tileCache->init(&m_tcparams, m_talloc, m_tcomp, m_tmproc); if (dtStatusFailed(status)) { m_recast->m_pLog->logMessage("ERROR: buildTiledNavigation: Could not init tile cache."); return false; } dtFreeNavMesh(m_recast->m_navMesh); m_recast->m_navMesh = dtAllocNavMesh(); if (!m_recast->m_navMesh) { m_recast->m_pLog->logMessage("ERROR: buildTiledNavigation: Could not allocate navmesh."); return false; } // Init multi-tile navmesh parameters dtNavMeshParams params; memset(¶ms, 0, sizeof(params)); rcVcopy(params.orig, m_tcparams.orig); // Set world-space origin of tile grid params.tileWidth = m_tileSize*m_tcparams.cs; params.tileHeight = m_tileSize*m_tcparams.cs; params.maxTiles = m_maxTiles; params.maxPolys = m_maxPolysPerTile; status = m_recast->m_navMesh->init(¶ms); if (dtStatusFailed(status)) { m_recast->m_pLog->logMessage("ERROR: buildTiledNavigation: Could not init navmesh."); return false; } // Init recast navmeshquery with created navmesh (in OgreRecast component) m_recast->m_navQuery = dtAllocNavMeshQuery(); status = m_recast->m_navQuery->init(m_recast->m_navMesh, 2048); if (dtStatusFailed(status)) { m_recast->m_pLog->logMessage("ERROR: buildTiledNavigation: Could not init Detour navmesh query"); return false; } return true; }
NavMeshLoader::~NavMeshLoader() { if (m_navMesh) { dtFreeNavMesh(m_navMesh); } if (m_navQuery) { dtFreeNavMeshQuery(m_navQuery); } }
//------------------------------------------------------------------------------------- NavMeshHandle::~NavMeshHandle() { std::map<int, NavmeshLayer>::iterator iter = navmeshLayer.begin(); for(; iter != navmeshLayer.end(); ++iter) { dtFreeNavMesh(iter->second.pNavmesh); dtFreeNavMeshQuery(iter->second.pNavmeshQuery); } DEBUG_MSG(fmt::format("NavMeshHandle::~NavMeshHandle(): ({}) is destroyed!\n", resPath)); }
//------------------------------------------------------------------------------------- NavMeshHandle::~NavMeshHandle() { std::vector<dtNavMesh*>::iterator iter = navmesh_layers.begin(); for(; iter != navmesh_layers.end(); iter++) dtFreeNavMesh((*iter)); std::vector<dtNavMeshQuery*>::iterator iter1 = navmeshQuery_layers.begin(); for(; iter1 != navmeshQuery_layers.end(); iter1++) dtFreeNavMeshQuery((*iter1)); DEBUG_MSG(fmt::format("NavMeshHandle::~NavMeshHandle(): ({}) is destroyed!\n", name)); }
void MapBuilder::buildMap(uint32 mapID) { #ifndef __APPLE__ //printf("[Thread %u] Building map %03u:\n", uint32(ACE_Thread::self()), mapID); #endif std::set<uint32>* tiles = getTileList(mapID); // make sure we process maps which don't have tiles if (!tiles->size()) { // convert coord bounds to grid bounds uint32 minX, minY, maxX, maxY; getGridBounds(mapID, minX, minY, maxX, maxY); // add all tiles within bounds to tile list. for (uint32 i = minX; i <= maxX; ++i) for (uint32 j = minY; j <= maxY; ++j) tiles->insert(StaticMapTree::packTileID(i, j)); } if (!tiles->empty()) { // build navMesh dtNavMesh* navMesh = NULL; buildNavMesh(mapID, navMesh); if (!navMesh) { printf("[Map %04i] Failed creating navmesh!\n", mapID); return; } // now start building mmtiles for each tile printf("[Map %04i] We have %u tiles. \n", mapID, (unsigned int)tiles->size()); for (std::set<uint32>::iterator it = tiles->begin(); it != tiles->end(); ++it) { uint32 tileX, tileY; // unpack tile coords StaticMapTree::unpackTileID((*it), tileX, tileY); if (shouldSkipTile(mapID, tileX, tileY)) continue; buildTile(mapID, tileX, tileY, navMesh); } dtFreeNavMesh(navMesh); } printf("[Map %04u] Complete!\n", mapID); }
void NavigationMesh::ReleaseNavigationMesh() { dtFreeNavMesh(navMesh_); navMesh_ = 0; dtFreeNavMeshQuery(navMeshQuery_); navMeshQuery_ = 0; numTilesX_ = 0; numTilesZ_ = 0; boundingBox_.min_ = boundingBox_.max_ = Vector3::ZERO; boundingBox_.defined_ = false; }
void Sample_SoloMesh::handleMeshChanged(class InputGeom* geom) { Sample::handleMeshChanged(geom); dtFreeNavMesh(m_navMesh); m_navMesh = 0; if (m_tool) { m_tool->reset(); m_tool->init(this); } }
void MapBuilder::buildSingleTile(uint32 mapID, uint32 tileX, uint32 tileY) { dtNavMesh* navMesh = NULL; buildNavMesh(mapID, navMesh); if (!navMesh) { printf("Failed creating navmesh! \n"); return; } buildTile(mapID, tileX, tileY, navMesh); dtFreeNavMesh(navMesh); }
void MapBuilder::buildMap(int mapID) { printf("Building map %03u:\n", mapID); set<int>* tiles = getTileList(mapID); // make sure we process maps which don't have tiles if (!tiles->size()) { // convert coord bounds to grid bounds int minX, minY, maxX, maxY; getGridBounds(mapID, minX, minY, maxX, maxY); // add all tiles within bounds to tile list. for (int i = minX; i <= maxX; ++i) for (int j = minY; j <= maxY; ++j) { tiles->insert(StaticMapTree::packTileID(i, j)); } } if (!tiles->size()) { return; } // build navMesh dtNavMesh* navMesh = NULL; buildNavMesh(mapID, navMesh); if (!navMesh) { printf("Failed creating navmesh! \n"); return; } // now start building mmtiles for each tile printf("We have %u tiles. \n", (unsigned int)tiles->size()); for (set<int>::iterator it = tiles->begin(); it != tiles->end(); ++it) { int tileX, tileY; // unpack tile coords StaticMapTree::unpackTileID((*it), tileX, tileY); if (shouldSkipTile(mapID, tileX, tileY)) { continue; } buildTile(mapID, tileX, tileY, navMesh); } dtFreeNavMesh(navMesh); printf("Complete! \n\n"); }
bool Sample_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; } dtNavMeshParams params; rcVcopy(params.orig, m_geom->getNavMeshBoundsMin()); params.tileWidth = m_tileSize*m_cellSize; params.tileHeight = m_tileSize*m_cellSize; params.maxTiles = m_maxTiles; params.maxPolys = m_maxPolysPerTile; dtStatus status; status = m_navMesh->init(¶ms); if (dtStatusFailed(status)) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not init 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 NavMeshGenerator::cleanup() { rcFreeHeightField(m_solid); m_solid = 0; rcFreeCompactHeightfield(m_chf); m_chf = 0; rcFreeContourSet(m_cset); m_cset = 0; rcFreePolyMesh(m_pmesh); m_pmesh = 0; rcFreePolyMeshDetail(m_dmesh); m_dmesh = 0; dtFreeNavMesh(m_navMesh); m_navMesh = 0; }
void MapBuilder::buildSingleTile(int mapID, int tileX, int tileY) { dtNavMesh* navMesh = NULL; dtNavMeshParams* meshParams = NULL; buildNavMesh(mapID, navMesh, meshParams); if (!navMesh) { printf("Failed creating navmesh! \n"); return; } buildTile(mapID, tileX, tileY, navMesh); dtFreeNavMesh(navMesh); if (meshParams) { delete meshParams; } }
//------------------------------------------------------------------------------------- NavMeshEx::~NavMeshEx() { KBEngine::thread::ThreadGuard tg(&mutex_); KBEUnordered_map<std::string, NavMeshHandle*>::iterator iter = navmeshs_.begin(); for(; iter != navmeshs_.end(); iter++) { NavMeshHandle* pNavMeshHandle = (NavMeshHandle*)iter->second; dtFreeNavMeshQuery(pNavMeshHandle->navmeshQuery); dtFreeNavMesh(pNavMeshHandle->navmesh); delete pNavMeshHandle; DEBUG_MSG(boost::format("NavMeshEx::~NavMeshEx(): (%1%) is destroyed!\n") % iter->first); } navmeshs_.clear(); }
void Sample_TileMesh::handleMeshChanged(class InputGeom* geom) { Sample::handleMeshChanged(geom); cleanup(); dtFreeNavMesh(m_navMesh); m_navMesh = 0; if (m_tool) { m_tool->reset(); m_tool->init(this); } resetToolStates(); initToolStates(this); }
/*! Free a previously initialized NAVIGATION structure pointer. \param[in,out] navigation The NAVIGATION structure pointer to free from local memory. \return Return a NULL NAVIGATION structure pointer. */ NAVIGATION *NAVIGATION_free( NAVIGATION *navigation ) { if( navigation->dtnavmesh ) dtFreeNavMesh( navigation->dtnavmesh ); if( navigation->program ) { SHADER_free( navigation->program->vertex_shader ); SHADER_free( navigation->program->fragment_shader ); PROGRAM_free( navigation->program ); } free( navigation ); return NULL; }
void Sample_SoloMesh::cleanup() { delete [] m_triareas; m_triareas = 0; rcFreeHeightField(m_solid); m_solid = 0; rcFreeCompactHeightfield(m_chf); m_chf = 0; rcFreeContourSet(m_cset); m_cset = 0; rcFreePolyMesh(m_pmesh); m_pmesh = 0; rcFreePolyMeshDetail(m_dmesh); m_dmesh = 0; dtFreeNavMesh(m_navMesh); m_navMesh = 0; }
//------------------------------------------------------------------------------------- bool NavMeshEx::removeNavmesh(std::string name) { KBEngine::thread::ThreadGuard tg(&mutex_); KBEUnordered_map<std::string, NavMeshHandle*>::iterator iter = navmeshs_.find(name); if(navmeshs_.find(name) != navmeshs_.end()) { NavMeshHandle* pNavMeshHandle = (NavMeshHandle*)iter->second; dtFreeNavMeshQuery(pNavMeshHandle->navmeshQuery); dtFreeNavMesh(pNavMeshHandle->navmesh); navmeshs_.erase(iter); delete pNavMeshHandle; DEBUG_MSG(boost::format("NavMeshEx::removeNavmesh: (%1%) is destroyed!\n") % name); return true; } return false; }
void Sample_TempObstacles::handleMeshChanged(class InputGeom* geom) { Sample::handleMeshChanged(geom); dtFreeTileCache(m_tileCache); m_tileCache = 0; dtFreeNavMesh(m_navMesh); m_navMesh = 0; if (m_tool) { m_tool->reset(); m_tool->init(this); m_tmproc->init(m_geom); } resetToolStates(); initToolStates(this); }