void drawDetail(duDebugDraw* dd, dtTileCache* tc, const int tx, const int ty, int type)
{
struct TileCacheBuildContext
{
inline TileCacheBuildContext(struct dtTileCacheAlloc* a) : layer(0), lcset(0), lmesh(0), alloc(a) {}
inline ~TileCacheBuildContext() {
purge();
}
void purge()
{
dtFreeTileCacheLayer(alloc, layer);
layer = 0;
dtFreeTileCacheContourSet(alloc, lcset);
lcset = 0;
dtFreeTileCachePolyMesh(alloc, lmesh);
lmesh = 0;
}
struct dtTileCacheLayer* layer;
struct dtTileCacheContourSet* lcset;
struct dtTileCachePolyMesh* lmesh;
struct dtTileCacheAlloc* alloc;
};
dtCompressedTileRef tiles[MAX_LAYERS];
const int ntiles = tc->getTilesAt(tx,ty,tiles,MAX_LAYERS);
dtTileCacheAlloc* talloc = tc->getAlloc();
dtTileCacheCompressor* tcomp = tc->getCompressor();
const dtTileCacheParams* params = tc->getParams();
for (int i = 0; i < ntiles; ++i)
{
const dtCompressedTile* tile = tc->getTileByRef(tiles[i]);
talloc->reset();
TileCacheBuildContext bc(talloc);
const int walkableClimbVx = (int)(params->walkableClimb / params->ch);
dtStatus status;
// Decompress tile layer data.
status = dtDecompressTileCacheLayer(talloc, tcomp, tile->data, tile->dataSize, &bc.layer);
if (dtStatusFailed(status))
return;
if (type == DRAWDETAIL_AREAS)
{
duDebugDrawTileCacheLayerAreas(dd, *bc.layer, params->cs, params->ch);
continue;
}
// Build navmesh
status = dtBuildTileCacheRegions(talloc, *bc.layer, walkableClimbVx);
if (dtStatusFailed(status))
return;
if (type == DRAWDETAIL_REGIONS)
{
duDebugDrawTileCacheLayerRegions(dd, *bc.layer, params->cs, params->ch);
continue;
}
bc.lcset = dtAllocTileCacheContourSet(talloc);
if (!bc.lcset)
return;
status = dtBuildTileCacheContours(talloc, *bc.layer, walkableClimbVx,
params->maxSimplificationError, *bc.lcset);
if (dtStatusFailed(status))
return;
if (type == DRAWDETAIL_CONTOURS)
{
duDebugDrawTileCacheContours(dd, *bc.lcset, tile->header->bmin, params->cs, params->ch);
continue;
}
bc.lmesh = dtAllocTileCachePolyMesh(talloc);
if (!bc.lmesh)
return;
status = dtBuildTileCachePolyMesh(talloc, *bc.lcset, *bc.lmesh);
if (dtStatusFailed(status))
return;
if (type == DRAWDETAIL_MESH)
{
duDebugDrawTileCachePolyMesh(dd, *bc.lmesh, tile->header->bmin, params->cs, params->ch);
continue;
}
}
}
void OgreDetourTileCache::drawDetail(const int tx, const int ty)
{
if (!DEBUG_DRAW)
return; // Don't debug draw for huge performance gain!
struct TileCacheBuildContext
{
inline TileCacheBuildContext(struct dtTileCacheAlloc* a) : layer(0), lcset(0), lmesh(0), alloc(a) {}
inline ~TileCacheBuildContext() { purge(); }
void purge()
{
dtFreeTileCacheLayer(alloc, layer);
layer = 0;
dtFreeTileCacheContourSet(alloc, lcset);
lcset = 0;
dtFreeTileCachePolyMesh(alloc, lmesh);
lmesh = 0;
}
struct dtTileCacheLayer* layer;
struct dtTileCacheContourSet* lcset;
struct dtTileCachePolyMesh* lmesh;
struct dtTileCacheAlloc* alloc;
};
dtCompressedTileRef tiles[MAX_LAYERS];
const int ntiles = m_tileCache->getTilesAt(tx,ty,tiles,MAX_LAYERS);
dtTileCacheAlloc* talloc = m_tileCache->getAlloc();
dtTileCacheCompressor* tcomp = m_tileCache->getCompressor();
const dtTileCacheParams* params = m_tileCache->getParams();
for (int i = 0; i < ntiles; ++i)
{
const dtCompressedTile* tile = m_tileCache->getTileByRef(tiles[i]);
talloc->reset();
TileCacheBuildContext bc(talloc);
const int walkableClimbVx = (int)(params->walkableClimb / params->ch);
dtStatus status;
// Decompress tile layer data.
status = dtDecompressTileCacheLayer(talloc, tcomp, tile->data, tile->dataSize, &bc.layer);
if (dtStatusFailed(status))
return;
// Build navmesh
status = dtBuildTileCacheRegions(talloc, *bc.layer, walkableClimbVx);
if (dtStatusFailed(status))
return;
//TODO this part is replicated from navmesh tile building in DetourTileCache. Maybe that can be reused. Also is it really necessary to do an extra navmesh rebuild from compressed tile just to draw it? Can't I just draw it somewhere where the navmesh is rebuilt?
bc.lcset = dtAllocTileCacheContourSet(talloc);
if (!bc.lcset)
return;
status = dtBuildTileCacheContours(talloc, *bc.layer, walkableClimbVx,
params->maxSimplificationError, *bc.lcset);
if (dtStatusFailed(status))
return;
bc.lmesh = dtAllocTileCachePolyMesh(talloc);
if (!bc.lmesh)
return;
status = dtBuildTileCachePolyMesh(talloc, *bc.lcset, *bc.lmesh);
if (dtStatusFailed(status))
return;
// Draw navmesh
Ogre::String tileName = Ogre::StringConverter::toString(tiles[i]);
// Ogre::LogManager::getSingletonPtr()->logMessage("Drawing tile: "+tileName);
// TODO this is a dirty quickfix that should be gone as soon as there is a rebuildTile(tileref) method
if(m_recast->m_pSceneMgr->hasManualObject("RecastMOWalk_"+tileName))
return;
drawPolyMesh(tileName, *bc.lmesh, tile->header->bmin, params->cs, params->ch, *bc.layer);
}
}
dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* navmesh)
{
dtAssert(m_talloc);
dtAssert(m_tcomp);
unsigned int idx = decodeTileIdTile(ref);
if (idx > (unsigned int)m_params.maxTiles)
return DT_FAILURE | DT_INVALID_PARAM;
const dtCompressedTile* tile = &m_tiles[idx];
unsigned int salt = decodeTileIdSalt(ref);
if (tile->salt != salt)
return DT_FAILURE | DT_INVALID_PARAM;
m_talloc->reset();
BuildContext bc(m_talloc);
const int walkableClimbVx = (int)(m_params.walkableClimb / m_params.ch);
dtStatus status;
// Decompress tile layer data.
status = dtDecompressTileCacheLayer(m_talloc, m_tcomp, tile->data, tile->dataSize, &bc.layer);
if (dtStatusFailed(status))
return status;
#if 0
if (tile->header->tx != 1 || tile->header->ty != 0 || tile->header->tlayer < 1)
return status;
#endif
// Rasterize obstacles.
for (int i = 0; i < m_params.maxObstacles; ++i)
{
const dtTileCacheObstacle* ob = &m_obstacles[i];
if (ob->state == DT_OBSTACLE_EMPTY || ob->state == DT_OBSTACLE_REMOVING)
continue;
if (contains(ob->touched, ob->ntouched, ref))
{
dtMarkCylinderArea(*bc.layer, tile->header->bmin, m_params.cs, m_params.ch,
ob->pos, ob->radius, ob->height, 0);
}
}
if (m_tmproc)
{
m_tmproc->markAreas(bc.layer, tile->header->bmin, m_params.cs, m_params.ch);
}
// Build navmesh
if (m_params.regionPartitioning == DT_REGION_MONOTONE)
{
status = dtBuildTileCacheRegionsMonotone(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer);
}
else if (m_params.regionPartitioning == DT_REGION_WATERSHED)
{
bc.dfield = dtAllocTileCacheDistanceField(m_talloc);
if (!bc.dfield)
return status;
status = dtBuildTileCacheDistanceField(m_talloc, *bc.layer, *bc.dfield);
if (dtStatusFailed(status))
return status;
status = dtBuildTileCacheRegions(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer, *bc.dfield);
}
else
{
status = dtBuildTileCacheRegionsChunky(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer, m_params.regionChunkSize);
}
if (dtStatusFailed(status))
return status;
bc.lcset = dtAllocTileCacheContourSet(m_talloc);
bc.lclusters = dtAllocTileCacheClusterSet(m_talloc);
if (!bc.lcset || !bc.lclusters)
return status;
status = dtBuildTileCacheContours(m_talloc, *bc.layer, walkableClimbVx,
m_params.maxSimplificationError, m_params.cs, m_params.ch,
*bc.lcset, *bc.lclusters);
if (dtStatusFailed(status))
return status;
bc.lmesh = dtAllocTileCachePolyMesh(m_talloc);
if (!bc.lmesh)
return status;
status = dtBuildTileCachePolyMesh(m_talloc, 0, *bc.lcset, *bc.lmesh);
if (dtStatusFailed(status))
return status;
// Early out if the mesh tile is empty.
if (!bc.lmesh->npolys)
return DT_SUCCESS;
status = dtBuildTileCacheClusters(m_talloc, *bc.lclusters, *bc.lmesh);
if (dtStatusFailed(status))
return status;
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
params.verts = bc.lmesh->verts;
params.vertCount = bc.lmesh->nverts;
params.polys = bc.lmesh->polys;
params.polyAreas = bc.lmesh->areas;
params.polyFlags = bc.lmesh->flags;
params.polyCount = bc.lmesh->npolys;
params.nvp = DT_VERTS_PER_POLYGON;
params.walkableHeight = m_params.walkableHeight;
params.walkableRadius = m_params.walkableRadius;
params.walkableClimb = m_params.walkableClimb;
params.tileX = tile->header->tx;
params.tileY = tile->header->ty;
params.tileLayer = tile->header->tlayer;
params.cs = m_params.cs;
params.ch = m_params.ch;
params.buildBvTree = false;
dtVcopy(params.bmin, tile->header->bmin);
dtVcopy(params.bmax, tile->header->bmax);
params.polyClusters = bc.lclusters->polyMap;
params.clusterCount = (unsigned short)bc.lclusters->nclusters;
if (m_tmproc)
{
m_tmproc->process(¶ms, bc.lmesh->areas, bc.lmesh->flags);
}
unsigned char* navData = 0;
int navDataSize = 0;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
return DT_FAILURE;
// Remove existing tile.
navmesh->removeTile(navmesh->getTileRefAt(tile->header->tx,tile->header->ty,tile->header->tlayer),0,0);
// Add new tile, or leave the location empty.
if (navData)
{
// Let the navmesh own the data.
status = navmesh->addTile(navData,navDataSize,DT_TILE_FREE_DATA,0,0);
if (dtStatusFailed(status))
{
dtFree(navData);
return status;
}
}
return DT_SUCCESS;
}