/**
* 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 RecastInterface::recastClean()
{
if(_triangleAreas)
{
delete[] _triangleAreas;
_triangleAreas = nullptr;
}
rcFreeHeightField(_solid);
_solid = nullptr;
rcFreeCompactHeightfield(_compactHeightfield);
_compactHeightfield = nullptr;
rcFreeContourSet(_contourSet);
_contourSet = nullptr;
rcFreePolyMesh(_polyMesh);
_polyMesh = nullptr;
rcFreePolyMeshDetail(_detailMesh);
_detailMesh = nullptr;
if(_context)
{
delete _context;
_context = nullptr;
}
}
IntermediateValues::~IntermediateValues()
{
rcFreeCompactHeightfield(compactHeightfield);
rcFreeHeightField(heightfield);
rcFreeContourSet(contours);
rcFreePolyMesh(polyMesh);
rcFreePolyMeshDetail(polyMeshDetail);
}
SimpleNavBuildData::~SimpleNavBuildData()
{
rcFreeContourSet(contourSet_);
contourSet_ = nullptr;
rcFreePolyMesh(polyMesh_);
polyMesh_ = nullptr;
rcFreePolyMeshDetail(polyMeshDetail_);
polyMeshDetail_ = nullptr;
}
void RecastTileBuilder::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;
}
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 Sample_TileMesh::cleanup()
{
delete [] m_triareaMasks;
m_triareaMasks = 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;
}
void NavMeshCreator::freeIntermediateResults()
{
rcFreeContourSet(m_intermediateContourSet);
m_intermediateContourSet = 0;
rcFreePolyMesh(m_intermediatePolyMesh);
m_intermediatePolyMesh = 0;
rcFreeHeightField(m_intermediateHeightfield);
m_intermediateHeightfield = 0;
rcFreeCompactHeightfield(m_intermediateCompactHeightfield);
m_intermediateCompactHeightfield = 0;
rcFreePolyMeshDetail(m_intermediatePolyMeshDetail);
m_intermediatePolyMeshDetail = 0;
}
void Sample_SoloMeshSimple::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;
}
void NavMesh::freeIntermediates(bool freeAll)
{
mNavMeshLock.lock();
rcFreeHeightField(hf); hf = NULL;
rcFreeCompactHeightfield(chf); chf = NULL;
if(!mSaveIntermediates || freeAll)
{
rcFreeContourSet(cs); cs = NULL;
rcFreePolyMesh(pm); pm = NULL;
rcFreePolyMeshDetail(pmd); pmd = NULL;
delete mInPolys;
mInPolys = NULL;
}
mNavMeshLock.unlock();
}
uint8* TileBuilder::BuildInstance( dtNavMeshParams& navMeshParams )
{
float* bmin = NULL, *bmax = NULL;
_Geometry->CalculateBoundingBox(bmin, bmax);
rcVcopy(InstanceConfig.bmax, bmax);
rcVcopy(InstanceConfig.bmin, bmin);
uint32 numVerts = _Geometry->Vertices.size();
uint32 numTris = _Geometry->Triangles.size();
float* vertices;
int* triangles;
uint8* areas;
_Geometry->GetRawData(vertices, triangles, areas);
// this sets the dimensions of the heightfield
rcCalcGridSize(InstanceConfig.bmin, InstanceConfig.bmax, InstanceConfig.cs, &InstanceConfig.width, &InstanceConfig.height);
rcHeightfield* hf = rcAllocHeightfield();
rcCreateHeightfield(Context, *hf, InstanceConfig.width, InstanceConfig.height, InstanceConfig.bmin, InstanceConfig.bmax, InstanceConfig.cs, InstanceConfig.ch);
rcClearUnwalkableTriangles(Context, InstanceConfig.walkableSlopeAngle, vertices, numVerts, triangles, numTris, areas);
rcRasterizeTriangles(Context, vertices, numVerts, triangles, areas, numTris, *hf, InstanceConfig.walkableClimb);
rcFilterLowHangingWalkableObstacles(Context, InstanceConfig.walkableClimb, *hf);
rcFilterLedgeSpans(Context, InstanceConfig.walkableHeight, InstanceConfig.walkableClimb, *hf);
rcFilterWalkableLowHeightSpans(Context, InstanceConfig.walkableHeight, *hf);
rcCompactHeightfield* chf = rcAllocCompactHeightfield();
rcBuildCompactHeightfield(Context, InstanceConfig.walkableHeight, InstanceConfig.walkableClimb, *hf, *chf);
rcErodeWalkableArea(Context, InstanceConfig.walkableRadius, *chf);
rcBuildDistanceField(Context, *chf);
rcBuildRegions(Context, *chf, InstanceConfig.borderSize, InstanceConfig.minRegionArea, InstanceConfig.minRegionArea);
rcContourSet* contours = rcAllocContourSet();
rcBuildContours(Context, *chf, InstanceConfig.maxSimplificationError, InstanceConfig.maxEdgeLen, *contours);
rcPolyMesh* pmesh = rcAllocPolyMesh();
rcBuildPolyMesh(Context, *contours, InstanceConfig.maxVertsPerPoly, *pmesh);
rcPolyMeshDetail* dmesh = rcAllocPolyMeshDetail();
rcBuildPolyMeshDetail(Context, *pmesh, *chf, InstanceConfig.detailSampleDist, InstanceConfig.detailSampleMaxError, *dmesh);
// Set flags according to area types (e.g. Swim for Water)
for (int i = 0; i < pmesh->npolys; i++)
{
if (pmesh->areas[i] == Constants::POLY_AREA_ROAD || pmesh->areas[i] == Constants::POLY_AREA_TERRAIN)
pmesh->flags[i] = Constants::POLY_FLAG_WALK;
else if (pmesh->areas[i] == Constants::POLY_AREA_WATER)
pmesh->flags[i] = Constants::POLY_FLAG_SWIM;
}
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
// PolyMesh data
params.verts = pmesh->verts;
params.vertCount = pmesh->nverts;
params.polys = pmesh->polys;
params.polyAreas = pmesh->areas;
params.polyFlags = pmesh->flags;
params.polyCount = pmesh->npolys;
params.nvp = pmesh->nvp;
// PolyMeshDetail data
params.detailMeshes = dmesh->meshes;
params.detailVerts = dmesh->verts;
params.detailVertsCount = dmesh->nverts;
params.detailTris = dmesh->tris;
params.detailTriCount = dmesh->ntris;
rcVcopy(params.bmin, pmesh->bmin);
rcVcopy(params.bmax, pmesh->bmax);
// General settings
params.ch = InstanceConfig.ch;
params.cs = InstanceConfig.cs;
params.walkableClimb = InstanceConfig.walkableClimb * InstanceConfig.ch;
params.walkableHeight = InstanceConfig.walkableHeight * InstanceConfig.ch;
params.walkableRadius = InstanceConfig.walkableRadius * InstanceConfig.cs;
params.tileX = X;
params.tileY = Y;
params.tileLayer = 0;
params.buildBvTree = true;
rcVcopy(params.bmax, bmax);
rcVcopy(params.bmin, bmin);
// Offmesh-connection settings
params.offMeshConCount = 0; // none for now
rcFreeHeightField(hf);
rcFreeCompactHeightfield(chf);
rcFreeContourSet(contours);
delete vertices;
delete triangles;
delete areas;
delete bmin;
delete bmax;
if (!params.polyCount || !params.polys || Constants::TilesPerMap * Constants::TilesPerMap == params.polyCount)
{
// we have flat tiles with no actual geometry - don't build those, its useless
// keep in mind that we do output those into debug info
// drop tiles with only exact count - some tiles may have geometry while having less tiles
printf("No polygons to build on tile, skipping.\n");
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
return NULL;
}
int navDataSize;
uint8* navData;
printf("Creating the navmesh with %i vertices, %i polys, %i triangles!\n", params.vertCount, params.polyCount, params.detailTriCount);
bool result = dtCreateNavMeshData(¶ms, &navData, &navDataSize);
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
if (result)
{
printf("NavMesh created, size %i!\n", navDataSize);
DataSize = navDataSize;
return navData;
}
return NULL;
}
uint8* TileBuilder::BuildTiled(dtNavMeshParams& navMeshParams)
{
_Geometry = new Geometry();
_Geometry->Transform = true;
ADT* adt = new ADT(Utils::GetAdtPath(World, X, Y), X, Y);
adt->Read();
_Geometry->AddAdt(adt);
delete adt;
if (_Geometry->Vertices.empty() && _Geometry->Triangles.empty())
return NULL;
float* bmin = NULL, *bmax = NULL;
CalculateTileBounds(bmin, bmax, navMeshParams);
_Geometry->CalculateMinMaxHeight(bmin[1], bmax[1]);
// again, we load everything - wasteful but who cares
for (int ty = Y - 1; ty <= Y + 1; ty++)
{
for (int tx = X - 1; tx <= X + 1; tx++)
{
// don't load main tile again
if (tx == X && ty == Y)
continue;
ADT* _adt = new ADT(Utils::GetAdtPath(World, tx, ty), tx, ty);
// If this condition is met, it means that this WDT does not contain the ADT
if (!_adt->Data->Stream)
{
delete _adt;
continue;
}
_adt->Read();
_Geometry->AddAdt(_adt);
delete _adt;
}
}
OutputDebugVertices();
uint32 numVerts = _Geometry->Vertices.size();
uint32 numTris = _Geometry->Triangles.size();
float* vertices;
int* triangles;
uint8* areas;
_Geometry->GetRawData(vertices, triangles, areas);
_Geometry->Vertices.clear();
_Geometry->Triangles.clear();
// add border
bmin[0] -= Config.borderSize * Config.cs;
bmin[2] -= Config.borderSize * Config.cs;
bmax[0] += Config.borderSize * Config.cs;
bmax[2] += Config.borderSize * Config.cs;
rcHeightfield* hf = rcAllocHeightfield();
int width = Config.tileSize + (Config.borderSize * 2);
rcCreateHeightfield(Context, *hf, width, width, bmin, bmax, Config.cs, Config.ch);
rcClearUnwalkableTriangles(Context, Config.walkableSlopeAngle, vertices, numVerts, triangles, numTris, areas);
rcRasterizeTriangles(Context, vertices, numVerts, triangles, areas, numTris, *hf, Config.walkableClimb);
rcFilterLowHangingWalkableObstacles(Context, Config.walkableClimb, *hf);
rcFilterLedgeSpans(Context, Config.walkableHeight, Config.walkableClimb, *hf);
rcFilterWalkableLowHeightSpans(Context, Config.walkableHeight, *hf);
rcCompactHeightfield* chf = rcAllocCompactHeightfield();
rcBuildCompactHeightfield(Context, Config.walkableHeight, Config.walkableClimb, *hf, *chf);
rcErodeWalkableArea(Context, Config.walkableRadius, *chf);
rcBuildDistanceField(Context, *chf);
rcBuildRegions(Context, *chf, Config.borderSize, Config.minRegionArea, Config.mergeRegionArea);
rcContourSet* contours = rcAllocContourSet();
rcBuildContours(Context, *chf, Config.maxSimplificationError, Config.maxEdgeLen, *contours);
rcPolyMesh* pmesh = rcAllocPolyMesh();
rcBuildPolyMesh(Context, *contours, Config.maxVertsPerPoly, *pmesh);
rcPolyMeshDetail* dmesh = rcAllocPolyMeshDetail();
rcBuildPolyMeshDetail(Context, *pmesh, *chf, Config.detailSampleDist, Config.detailSampleMaxError, *dmesh);
// Set flags according to area types (e.g. Swim for Water)
for (int i = 0; i < pmesh->npolys; i++)
{
if (pmesh->areas[i] == Constants::POLY_AREA_ROAD || pmesh->areas[i] == Constants::POLY_AREA_TERRAIN)
pmesh->flags[i] = Constants::POLY_FLAG_WALK;
else if (pmesh->areas[i] == Constants::POLY_AREA_WATER)
pmesh->flags[i] = Constants::POLY_FLAG_SWIM;
}
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
// PolyMesh data
params.verts = pmesh->verts;
params.vertCount = pmesh->nverts;
params.polys = pmesh->polys;
params.polyAreas = pmesh->areas;
params.polyFlags = pmesh->flags;
params.polyCount = pmesh->npolys;
params.nvp = pmesh->nvp;
// PolyMeshDetail data
params.detailMeshes = dmesh->meshes;
params.detailVerts = dmesh->verts;
params.detailVertsCount = dmesh->nverts;
params.detailTris = dmesh->tris;
params.detailTriCount = dmesh->ntris;
// General settings
params.ch = Config.ch;
params.cs = Config.cs;
params.walkableClimb = Config.walkableClimb * Config.ch;
params.walkableHeight = Config.walkableHeight * Config.ch;
params.walkableRadius = Config.walkableRadius * Config.cs;
params.tileX = X;
params.tileY = Y;
params.tileLayer = 0;
params.buildBvTree = true;
// Recalculate the bounds with the added geometry
float* bmin2 = NULL, *bmax2 = NULL;
CalculateTileBounds(bmin2, bmax2, navMeshParams);
bmin2[1] = bmin[1];
bmax2[1] = bmax[1];
rcVcopy(params.bmax, bmax2);
rcVcopy(params.bmin, bmin2);
// Offmesh-connection settings
params.offMeshConCount = 0; // none for now
rcFreeHeightField(hf);
rcFreeCompactHeightfield(chf);
rcFreeContourSet(contours);
delete vertices;
delete triangles;
delete areas;
delete bmin;
delete bmax;
if (!params.polyCount || !params.polys || Constants::TilesPerMap * Constants::TilesPerMap == params.polyCount)
{
// we have flat tiles with no actual geometry - don't build those, its useless
// keep in mind that we do output those into debug info
// drop tiles with only exact count - some tiles may have geometry while having less tiles
printf("[%02i, %02i] No polygons to build on tile, skipping.\n", X, Y);
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
return NULL;
}
int navDataSize;
uint8* navData;
printf("[%02i, %02i] Creating the navmesh with %i vertices, %i polys, %i triangles!\n", X, Y, params.vertCount, params.polyCount, params.detailTriCount);
bool result = dtCreateNavMeshData(¶ms, &navData, &navDataSize);
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
if (result)
{
printf("[%02i, %02i] NavMesh created, size %i!\n", X, Y, navDataSize);
DataSize = navDataSize;
return navData;
}
return NULL;
}
void recast_destroyPolyMeshDetail(struct recast_polyMeshDetail *polyMeshDetail)
{
rcFreePolyMeshDetail((rcPolyMeshDetail *) polyMeshDetail);
}
uint8* TileBuilder::Build(bool dbg, dtNavMeshParams& navMeshParams)
{
_Geometry = new Geometry();
_Geometry->Transform = true;
ADT* adt = new ADT(Utils::GetAdtPath(World, X, Y));
adt->Read();
_Geometry->AddAdt(adt);
delete adt;
if (_Geometry->Vertices.empty() && _Geometry->Triangles.empty())
return NULL;
// again, we load everything - wasteful but who cares
for (int ty = Y - 2; ty <= Y + 2; ty++)
{
for (int tx = X - 2; tx <= X + 2; tx++)
{
// don't load main tile again
if (tx == X && ty == Y)
continue;
ADT* _adt = new ADT(Utils::GetAdtPath(World, tx, ty));
// If this condition is met, it means that this wdt does not contain the ADT
if (!_adt->Data->Stream)
{
delete _adt;
continue;
}
_adt->Read();
_Geometry->AddAdt(_adt);
delete _adt;
}
}
if (dbg)
{
char buff[100];
sprintf(buff, "mmaps/%s_%02u%02u.obj", World.c_str(), Y, X);
FILE* debug = fopen(buff, "wb");
for (uint32 i = 0; i < _Geometry->Vertices.size(); ++i)
fprintf(debug, "v %f %f %f\n", _Geometry->Vertices[i].x, _Geometry->Vertices[i].y, _Geometry->Vertices[i].z);
for (uint32 i = 0; i < _Geometry->Triangles.size(); ++i)
fprintf(debug, "f %i %i %i\n", _Geometry->Triangles[i].V0 + 1, _Geometry->Triangles[i].V1 + 1, _Geometry->Triangles[i].V2 + 1);
fclose(debug);
}
uint32 numVerts = _Geometry->Vertices.size();
uint32 numTris = _Geometry->Triangles.size();
float* vertices;
int* triangles;
uint8* areas;
_Geometry->GetRawData(vertices, triangles, areas);
_Geometry->Vertices.clear();
_Geometry->Triangles.clear();
rcVcopy(Config.bmin, cBuilder->bmin);
rcVcopy(Config.bmax, cBuilder->bmax);
// this sets the dimensions of the heightfield - should maybe happen before border padding
rcCalcGridSize(Config.bmin, Config.bmax, Config.cs, &Config.width, &Config.height);
// Initialize per tile config.
rcConfig tileCfg = Config;
tileCfg.width = Config.tileSize + Config.borderSize * 2;
tileCfg.height = Config.tileSize + Config.borderSize * 2;
// merge per tile poly and detail meshes
rcPolyMesh** pmmerge = new rcPolyMesh*[Constants::TilesPerMap * Constants::TilesPerMap];
rcPolyMeshDetail** dmmerge = new rcPolyMeshDetail*[Constants::TilesPerMap * Constants::TilesPerMap];
int nmerge = 0;
for (int y = 0; y < Constants::TilesPerMap; ++y)
{
for (int x = 0; x < Constants::TilesPerMap; ++x)
{
// Calculate the per tile bounding box.
tileCfg.bmin[0] = Config.bmin[0] + float(x * Config.tileSize - Config.borderSize) * Config.cs;
tileCfg.bmin[2] = Config.bmin[2] + float(y * Config.tileSize - Config.borderSize) * Config.cs;
tileCfg.bmax[0] = Config.bmin[0] + float((x + 1) * Config.tileSize + Config.borderSize) * Config.cs;
tileCfg.bmax[2] = Config.bmin[2] + float((y + 1) * Config.tileSize + Config.borderSize) * Config.cs;
rcHeightfield* hf = rcAllocHeightfield();
rcCreateHeightfield(Context, *hf, tileCfg.width, tileCfg.height, tileCfg.bmin, tileCfg.bmax, tileCfg.cs, tileCfg.ch);
rcClearUnwalkableTriangles(Context, tileCfg.walkableSlopeAngle, vertices, numVerts, triangles, numTris, areas);
rcRasterizeTriangles(Context, vertices, numVerts, triangles, areas, numTris, *hf, Config.walkableClimb);
// 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.
rcFilterLowHangingWalkableObstacles(Context, Config.walkableClimb, *hf);
rcFilterLedgeSpans(Context, tileCfg.walkableHeight, tileCfg.walkableClimb, *hf);
rcFilterWalkableLowHeightSpans(Context, tileCfg.walkableHeight, *hf);
// Compact the heightfield so that it is faster to handle from now on.
// This will result in more cache coherent data as well as the neighbours
// between walkable cells will be calculated.
rcCompactHeightfield* chf = rcAllocCompactHeightfield();
rcBuildCompactHeightfield(Context, tileCfg.walkableHeight, tileCfg.walkableClimb, *hf, *chf);
rcFreeHeightField(hf);
// Erode the walkable area by agent radius.
rcErodeWalkableArea(Context, Config.walkableRadius, *chf);
// Prepare for region partitioning, by calculating distance field along the walkable surface.
rcBuildDistanceField(Context, *chf);
// Partition the walkable surface into simple regions without holes.
rcBuildRegions(Context, *chf, tileCfg.borderSize, tileCfg.minRegionArea, tileCfg.mergeRegionArea);
// Create contours.
rcContourSet* cset = rcAllocContourSet();
rcBuildContours(Context, *chf, tileCfg.maxSimplificationError, tileCfg.maxEdgeLen, *cset);
// Build polygon navmesh from the contours.
rcPolyMesh* pmesh = rcAllocPolyMesh();
rcBuildPolyMesh(Context, *cset, tileCfg.maxVertsPerPoly, *pmesh);
// Build detail mesh.
rcPolyMeshDetail* dmesh = rcAllocPolyMeshDetail();
rcBuildPolyMeshDetail(Context, *pmesh, *chf, tileCfg.detailSampleDist, tileCfg.detailSampleMaxError, *dmesh);
// Free memory
rcFreeCompactHeightfield(chf);
rcFreeContourSet(cset);
pmmerge[nmerge] = pmesh;
dmmerge[nmerge] = dmesh;
++nmerge;
}
}
rcPolyMesh* pmesh = rcAllocPolyMesh();
rcMergePolyMeshes(Context, pmmerge, nmerge, *pmesh);
rcPolyMeshDetail* dmesh = rcAllocPolyMeshDetail();
rcMergePolyMeshDetails(Context, dmmerge, nmerge, *dmesh);
delete[] pmmerge;
delete[] dmmerge;
printf("[%02i,%02i] Meshes merged!\n", X, Y);
// Remove padding from the polymesh data. (Remove this odditity)
for (int i = 0; i < pmesh->nverts; ++i)
{
unsigned short* v = &pmesh->verts[i * 3];
v[0] -= (unsigned short)Config.borderSize;
v[2] -= (unsigned short)Config.borderSize;
}
// Set flags according to area types (e.g. Swim for Water)
for (int i = 0; i < pmesh->npolys; i++)
{
if (pmesh->areas[i] == Constants::POLY_AREA_ROAD || pmesh->areas[i] == Constants::POLY_AREA_TERRAIN)
pmesh->flags[i] = Constants::POLY_FLAG_WALK;
else if (pmesh->areas[i] == Constants::POLY_AREA_WATER)
pmesh->flags[i] = Constants::POLY_FLAG_SWIM;
}
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
// PolyMesh data
params.verts = pmesh->verts;
params.vertCount = pmesh->nverts;
params.polys = pmesh->polys;
params.polyAreas = pmesh->areas;
params.polyFlags = pmesh->flags;
params.polyCount = pmesh->npolys;
params.nvp = pmesh->nvp;
// PolyMeshDetail data
params.detailMeshes = dmesh->meshes;
params.detailVerts = dmesh->verts;
params.detailVertsCount = dmesh->nverts;
params.detailTris = dmesh->tris;
params.detailTriCount = dmesh->ntris;
rcVcopy(params.bmin, pmesh->bmin);
rcVcopy(params.bmax, pmesh->bmax);
// General settings
params.ch = Config.ch;
params.cs = Config.cs;
params.walkableClimb = Constants::BaseUnitDim * Config.walkableClimb;
params.walkableHeight = Constants::BaseUnitDim * Config.walkableHeight;
params.walkableRadius = Constants::BaseUnitDim * Config.walkableRadius;
params.tileX = (((cBuilder->bmin[0] + cBuilder->bmax[0]) / 2) - navMeshParams.orig[0]) / Constants::TileSize;
params.tileY = (((cBuilder->bmin[2] + cBuilder->bmax[2]) / 2) - navMeshParams.orig[2]) / Constants::TileSize;
rcVcopy(params.bmin, cBuilder->bmin);
rcVcopy(params.bmax, cBuilder->bmax);
// Offmesh-connection settings
params.offMeshConCount = 0; // none for now
params.tileSize = Constants::VertexPerMap;
if (!params.polyCount || !params.polys || Constants::TilesPerMap * Constants::TilesPerMap == params.polyCount)
{
// we have flat tiles with no actual geometry - don't build those, its useless
// keep in mind that we do output those into debug info
// drop tiles with only exact count - some tiles may have geometry while having less tiles
printf("[%02i,%02i] No polygons to build on tile, skipping.\n", X, Y);
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
delete areas;
delete triangles;
delete vertices;
return NULL;
}
int navDataSize;
uint8* navData;
printf("[%02i,%02i] Creating the navmesh with %i vertices, %i polys, %i triangles!\n", X, Y, pmesh->nverts, pmesh->npolys, dmesh->ntris);
bool result = dtCreateNavMeshData(¶ms, &navData, &navDataSize);
// Free some memory
rcFreePolyMesh(pmesh);
rcFreePolyMeshDetail(dmesh);
delete areas;
delete triangles;
delete vertices;
if (result)
{
printf("[%02i,%02i] NavMesh created, size %i!\n", X, Y, navDataSize);
DataSize = navDataSize;
return navData;
}
return NULL;
}
/*!
Build a NAVIGATION mesh from an OBJ mesh index. Usually this OBJMESH is either a collision map
or a mesh that have been built especially for navigation.
\param[in,out] navigation A valid NAVIGATION structure pointer.
\param[in] obj A valid OBJ structure pointer.
\param[in] mesh_index The mesh index of the OBJMESH to use to create the NAVIGATION mesh.
\return Return 1 if the NAVIGATION mesh have been generated successfully, else this function will return 0.
*/
unsigned char NAVIGATION_build( NAVIGATION *navigation, OBJ *obj, unsigned int mesh_index )
{
unsigned int i = 0,
j = 0,
k = 0,
triangle_count = 0;
int *indices = NULL;
OBJMESH *objmesh = &obj->objmesh[ mesh_index ];
vec3 *vertex_array = ( vec3 * ) malloc( objmesh->n_objvertexdata * sizeof( vec3 ) ),
*vertex_start = vertex_array;
rcHeightfield *rcheightfield;
rcCompactHeightfield *rccompactheightfield;
rcContourSet *rccontourset;
rcPolyMesh *rcpolymesh;
rcPolyMeshDetail *rcpolymeshdetail;
while( i != objmesh->n_objvertexdata )
{
memcpy( vertex_array,
&obj->indexed_vertex[ objmesh->objvertexdata[ i ].vertex_index ],
sizeof( vec3 ) );
vec3_to_recast( vertex_array );
++vertex_array;
++i;
}
i = 0;
while( i != objmesh->n_objtrianglelist )
{
triangle_count += objmesh->objtrianglelist[ i ].n_indice_array;
indices = ( int * ) realloc( indices, triangle_count * sizeof( int ) );
j = 0;
while( j != objmesh->objtrianglelist[ i ].n_indice_array )
{
indices[ k ] = objmesh->objtrianglelist[ i ].indice_array[ j ];
++k;
++j;
}
++i;
}
triangle_count /= 3;
rcConfig rcconfig;
memset( &rcconfig, 0, sizeof( rcConfig ) );
rcconfig.cs = navigation->navigationconfiguration.cell_size;
rcconfig.ch = navigation->navigationconfiguration.cell_height;
rcconfig.walkableHeight = ( int )ceilf ( navigation->navigationconfiguration.agent_height / rcconfig.ch );
rcconfig.walkableRadius = ( int )ceilf ( navigation->navigationconfiguration.agent_radius / rcconfig.cs );
rcconfig.walkableClimb = ( int )floorf( navigation->navigationconfiguration.agent_max_climb / rcconfig.ch );
rcconfig.walkableSlopeAngle = navigation->navigationconfiguration.agent_max_slope;
rcconfig.minRegionSize = ( int )rcSqr( navigation->navigationconfiguration.region_min_size );
rcconfig.mergeRegionSize = ( int )rcSqr( navigation->navigationconfiguration.region_merge_size );
rcconfig.maxEdgeLen = ( int )( navigation->navigationconfiguration.edge_max_len / rcconfig.cs );
rcconfig.maxSimplificationError = navigation->navigationconfiguration.edge_max_error;
rcconfig.maxVertsPerPoly = ( int )navigation->navigationconfiguration.vert_per_poly;
rcconfig.detailSampleDist = rcconfig.cs * navigation->navigationconfiguration.detail_sample_dst;
rcconfig.detailSampleMaxError = rcconfig.ch * navigation->navigationconfiguration.detail_sample_max_error;
rcCalcBounds( ( float * )vertex_start,
objmesh->n_objvertexdata,
rcconfig.bmin,
rcconfig.bmax );
rcCalcGridSize( rcconfig.bmin,
rcconfig.bmax,
rcconfig.cs,
&rcconfig.width,
&rcconfig.height );
rcheightfield = rcAllocHeightfield();
rcCreateHeightfield( *rcheightfield,
rcconfig.width,
rcconfig.height,
rcconfig.bmin,
rcconfig.bmax,
rcconfig.cs,
rcconfig.ch );
navigation->triangle_flags = new unsigned char[ triangle_count ];
memset( navigation->triangle_flags, 0, triangle_count * sizeof( unsigned char ) );
rcMarkWalkableTriangles( rcconfig.walkableSlopeAngle,
( float * )vertex_start,
objmesh->n_objvertexdata,
indices,
triangle_count,
navigation->triangle_flags );
rcRasterizeTriangles( ( float * )vertex_start,
objmesh->n_objvertexdata,
indices,
navigation->triangle_flags,
triangle_count,
*rcheightfield,
rcconfig.walkableClimb );
delete []navigation->triangle_flags;
navigation->triangle_flags = NULL;
free( vertex_start );
free( indices );
rcFilterLowHangingWalkableObstacles( rcconfig.walkableClimb,
*rcheightfield );
rcFilterLedgeSpans( rcconfig.walkableHeight,
rcconfig.walkableClimb,
*rcheightfield );
rcFilterWalkableLowHeightSpans( rcconfig.walkableHeight,
*rcheightfield );
rccompactheightfield = rcAllocCompactHeightfield();
rcBuildCompactHeightfield( rcconfig.walkableHeight,
rcconfig.walkableClimb,
RC_WALKABLE,
*rcheightfield,
*rccompactheightfield );
rcFreeHeightField( rcheightfield );
rcheightfield = NULL;
rcErodeArea( RC_WALKABLE_AREA,
rcconfig.walkableRadius,
*rccompactheightfield );
rcBuildDistanceField( *rccompactheightfield );
rcBuildRegions( *rccompactheightfield,
rcconfig.borderSize,
rcconfig.minRegionSize,
rcconfig.mergeRegionSize );
rccontourset = rcAllocContourSet();
rcBuildContours( *rccompactheightfield,
rcconfig.maxSimplificationError,
rcconfig.maxEdgeLen,
*rccontourset );
rcpolymesh = rcAllocPolyMesh();
rcBuildPolyMesh( *rccontourset,
rcconfig.maxVertsPerPoly,
*rcpolymesh );
rcpolymeshdetail = rcAllocPolyMeshDetail();
rcBuildPolyMeshDetail( *rcpolymesh,
*rccompactheightfield,
rcconfig.detailSampleDist,
rcconfig.detailSampleMaxError,
*rcpolymeshdetail );
rcFreeCompactHeightfield( rccompactheightfield );
rccompactheightfield = NULL;
rcFreeContourSet( rccontourset );
rccontourset = NULL;
if( rcconfig.maxVertsPerPoly <= DT_VERTS_PER_POLYGON )
{
dtNavMeshCreateParams dtnavmeshcreateparams;
unsigned char *nav_data = NULL;
int nav_data_size = 0;
i = 0;
while( i != rcpolymesh->npolys )
{
if( rcpolymesh->areas[ i ] == RC_WALKABLE_AREA )
{
rcpolymesh->areas[ i ] = 0;
rcpolymesh->flags[ i ] = 0x01;
}
++i;
}
memset( &dtnavmeshcreateparams, 0, sizeof( dtNavMeshCreateParams ) );
dtnavmeshcreateparams.verts = rcpolymesh->verts;
dtnavmeshcreateparams.vertCount = rcpolymesh->nverts;
dtnavmeshcreateparams.polys = rcpolymesh->polys;
dtnavmeshcreateparams.polyAreas = rcpolymesh->areas;
dtnavmeshcreateparams.polyFlags = rcpolymesh->flags;
dtnavmeshcreateparams.polyCount = rcpolymesh->npolys;
dtnavmeshcreateparams.nvp = rcpolymesh->nvp;
dtnavmeshcreateparams.detailMeshes = rcpolymeshdetail->meshes;
dtnavmeshcreateparams.detailVerts = rcpolymeshdetail->verts;
dtnavmeshcreateparams.detailVertsCount = rcpolymeshdetail->nverts;
dtnavmeshcreateparams.detailTris = rcpolymeshdetail->tris;
dtnavmeshcreateparams.detailTriCount = rcpolymeshdetail->ntris;
dtnavmeshcreateparams.walkableHeight = navigation->navigationconfiguration.agent_height;
dtnavmeshcreateparams.walkableRadius = navigation->navigationconfiguration.agent_radius;
dtnavmeshcreateparams.walkableClimb = navigation->navigationconfiguration.agent_max_climb;
rcVcopy( dtnavmeshcreateparams.bmin, rcpolymesh->bmin );
rcVcopy( dtnavmeshcreateparams.bmax, rcpolymesh->bmax );
dtnavmeshcreateparams.cs = rcconfig.cs;
dtnavmeshcreateparams.ch = rcconfig.ch;
dtCreateNavMeshData( &dtnavmeshcreateparams,
&nav_data,
&nav_data_size );
if( !nav_data ) return 0;
navigation->dtnavmesh = dtAllocNavMesh();
navigation->dtnavmesh->init( nav_data,
nav_data_size,
DT_TILE_FREE_DATA,
NAVIGATION_MAX_NODE );
rcFreePolyMesh( rcpolymesh );
rcpolymesh = NULL;
rcFreePolyMeshDetail( rcpolymeshdetail );
rcpolymeshdetail = NULL;
return 1;
}
return 0;
}