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);
}
