EXPORT_API bool nmcsBuildSet(nmgBuildContext* ctx
, rcCompactHeightfield* chf
, const float maxError
, const int maxEdgeLen
, rcContourSet* cset
, const int flags)
{
if (!ctx || !chf || !cset)
return false;
return rcBuildContours(ctx
, *chf
, maxError
, maxEdgeLen
, *cset
, flags);
}
bool Sample_Debug::handleBuild()
{
if (m_chf)
{
rcFreeContourSet(m_cset);
m_cset = 0;
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'.");
return false;
}
if (!rcBuildContours(m_ctx, *m_chf, /*m_cfg.maxSimplificationError*/1.3f, /*m_cfg.maxEdgeLen*/12, *m_cset))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not create contours.");
return false;
}
}
return true;
}
bool Sample_SoloMesh::handleBuild()
{
if (!m_geom || !m_geom->getMesh())
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Input mesh is not specified.");
return false;
}
cleanup();
const float* bmin = m_geom->getMeshBoundsMin();
const float* bmax = m_geom->getMeshBoundsMax();
const float* verts = m_geom->getMesh()->getVerts();
const int nverts = m_geom->getMesh()->getVertCount();
const int* tris = m_geom->getMesh()->getTris();
const int ntris = m_geom->getMesh()->getTriCount();
//
// Step 1. Initialize build config.
//
// 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 = (int)rcSqr(m_regionMinSize); // Note: area = size*size
m_cfg.mergeRegionArea = (int)rcSqr(m_regionMergeSize); // Note: area = size*size
m_cfg.maxVertsPerPoly = (int)m_vertsPerPoly;
m_cfg.detailSampleDist = m_detailSampleDist < 0.9f ? 0 : m_cellSize * m_detailSampleDist;
m_cfg.detailSampleMaxError = m_cellHeight * m_detailSampleMaxError;
// Set the area where the navigation will be build.
// Here the bounds of the input mesh are used, but the
// area could be specified by an user defined box, etc.
rcVcopy(m_cfg.bmin, bmin);
rcVcopy(m_cfg.bmax, bmax);
rcCalcGridSize(m_cfg.bmin, m_cfg.bmax, m_cfg.cs, &m_cfg.width, &m_cfg.height);
// 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);
//
// Step 2. Rasterize input polygon soup.
//
// 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 false;
}
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 false;
}
// Allocate array that can hold triangle area types.
// If you have multiple meshes you need to process, allocate
// and array which can hold the max number of triangles you need to process.
m_triareas = new unsigned char[ntris];
if (!m_triareas)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'm_triareas' (%d).", ntris);
return false;
}
// Find triangles which are walkable based on their slope and rasterize them.
// If your input data is multiple meshes, you can transform them here, calculate
// the are type for each of the meshes and rasterize them.
memset(m_triareas, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle, verts, nverts, tris, ntris, m_triareas);
rcRasterizeTriangles(m_ctx, verts, nverts, tris, m_triareas, ntris, *m_solid, m_cfg.walkableClimb);
if (!m_keepInterResults)
{
delete [] m_triareas;
m_triareas = 0;
}
//
// Step 3. Filter walkables surfaces.
//
// Once all geoemtry 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(m_ctx, m_cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid);
rcFilterWalkableLowHeightSpans(m_ctx, m_cfg.walkableHeight, *m_solid);
//
// Step 4. Partition walkable surface to simple regions.
//
// 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 false;
}
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 false;
}
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 false;
}
// (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 martitioning 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 nacmesh, use this if you have large open areas
// 2) Monotone partioning
// - 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 partitoining
// - 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 == SAMPLE_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 false;
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build watershed regions.");
return false;
}
}
else if (m_partitionType == SAMPLE_PARTITION_MONOTONE)
{
// Partition the walkable surface into simple regions without holes.
// Monotone partitioning does not need distancefield.
if (!rcBuildRegionsMonotone(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build monotone regions.");
return false;
}
}
else // SAMPLE_PARTITION_LAYERS
{
// Partition the walkable surface into simple regions without holes.
if (!rcBuildLayerRegions(m_ctx, *m_chf, 0, m_cfg.minRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build layer regions.");
return false;
}
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'.");
return false;
}
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 false;
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
m_pmesh = rcAllocPolyMesh();
if (!m_pmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'.");
return false;
}
if (!rcBuildPolyMesh(m_ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not triangulate contours.");
return false;
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
m_dmesh = rcAllocPolyMeshDetail();
if (!m_dmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmdtl'.");
return false;
}
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 detail mesh.");
return false;
}
if (!m_keepInterResults)
{
rcFreeCompactHeightfield(m_chf);
m_chf = 0;
rcFreeContourSet(m_cset);
m_cset = 0;
}
// At this point the navigation mesh data is ready, you can access it from m_pmesh.
// See duDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// (Optional) Step 8. Create Detour data from Recast poly mesh.
//
// The GUI may allow more max points per polygon than Detour can handle.
// Only build the detour navmesh if we do not exceed the limit.
if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON)
{
unsigned char* navData = 0;
int navDataSize = 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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == SAMPLE_POLYAREA_GROUND ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_GRASS ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_ROAD)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_WATER)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_SWIM;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_DOOR)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK | SAMPLE_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.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.offMeshConCount = m_geom->getOffMeshConnectionCount();
params.walkableHeight = m_agentHeight;
params.walkableRadius = m_agentRadius;
params.walkableClimb = m_agentMaxClimb;
rcVcopy(params.bmin, m_pmesh->bmin);
rcVcopy(params.bmax, m_pmesh->bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
params.buildBvTree = true;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
m_ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh.");
return false;
}
m_navMesh = dtAllocNavMesh();
if (!m_navMesh)
{
dtFree(navData);
m_ctx->log(RC_LOG_ERROR, "Could not create Detour navmesh");
return false;
}
dtStatus status;
status = m_navMesh->init(navData, navDataSize, DT_TILE_FREE_DATA);
if (dtStatusFailed(status))
{
dtFree(navData);
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh");
return false;
}
status = m_navQuery->init(m_navMesh, 2048);
if (dtStatusFailed(status))
{
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh query");
return false;
}
}
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_totalBuildTimeMs = m_ctx->getAccumulatedTime(RC_TIMER_TOTAL)/1000.0f;
if (m_tool)
m_tool->init(this);
initToolStates(this);
return true;
}
void NavMeshCreator::computeNavMesh()
{
// Reset build times gathering.
m_context->resetTimers();
// Start the build process.
m_context->startTimer(RC_TIMER_TOTAL);
m_context->log(RC_LOG_PROGRESS, "NavMesh computation start");
m_context->log(RC_LOG_PROGRESS, " - %.1fK vertices, %.1fK triangles", m_inputVerticesCount/1000.0f, m_inputTrianglesCount/1000.0f);
if (m_success)
{
//Compute the grid size
rcCalcGridSize(
m_min,
m_max,
m_voxelSize,
&m_intermediateHeightfieldWidth,
&m_intermediateHeightfieldHeight);
}
m_context->log(RC_LOG_PROGRESS, " - %d x %d = %d voxels", m_intermediateHeightfieldWidth, m_intermediateHeightfieldHeight, m_intermediateHeightfieldHeight * m_intermediateHeightfieldWidth);
//Mark the walkable m_inputTriangles
rcMarkWalkableTriangles(
m_context,
m_maximumSlope,
m_inputVertices,
m_inputVerticesCount,
m_inputTriangles,
m_inputTrianglesCount,
m_intermediateTriangleTags);
// Build the heightfield
m_success = m_success && (rcCreateHeightfield(
m_context,
*m_intermediateHeightfield,
m_intermediateHeightfieldWidth,
m_intermediateHeightfieldHeight,
m_min,
m_max,
m_voxelSize,
m_voxelHeight));
// rasterize m_inputTriangles.
rcRasterizeTriangles(
m_context,
m_inputVertices,
m_inputVerticesCount,
m_inputTriangles,
m_intermediateTriangleTags,
m_inputTrianglesCount,
*m_intermediateHeightfield,
static_cast<int>(floor(m_maximumStepHeight / m_voxelHeight)));
// Filter voxels
rcFilterLowHangingWalkableObstacles(
m_context,
static_cast<int>(floor(m_maximumStepHeight / m_voxelHeight)),
*m_intermediateHeightfield);
rcFilterLedgeSpans(
m_context,
static_cast<int>(ceil(m_minimumCeilingClearance / m_voxelHeight)),
static_cast<int>(floor(m_maximumStepHeight / m_voxelHeight)),
*m_intermediateHeightfield);
rcFilterWalkableLowHeightSpans(
m_context,
static_cast<int>(ceil(m_minimumCeilingClearance / m_voxelHeight)),
*m_intermediateHeightfield);
// Build the compact representation for the heightfield
m_success = m_success && (rcBuildCompactHeightfield(
m_context,
static_cast<int>(ceil(m_minimumCeilingClearance / m_voxelHeight)),
static_cast<int>(floor(m_maximumStepHeight / m_voxelHeight)),
*m_intermediateHeightfield,
*m_intermediateCompactHeightfield));
// Erode the navigatble area by minimum clearance to obstacles
m_success = m_success && (rcErodeWalkableArea(
m_context,
static_cast<int>(ceil(m_minimumObstacleClearance / m_voxelSize)),
*m_intermediateCompactHeightfield));
// Prepare for region partitioning, by calculating distance field along the walkable surface.
m_success = m_success && (rcBuildDistanceField(
m_context,
*m_intermediateCompactHeightfield));
// Partition the walkable surface into simple regions without holes.
m_success = m_success && (rcBuildRegions(
m_context,
*m_intermediateCompactHeightfield,
0,
rcSqr<int>(m_regionMinSize),
rcSqr<int>(m_regionMergeSize)));
// Build the contours of the walkable surface
m_success = m_success && (rcBuildContours(
m_context,
*m_intermediateCompactHeightfield,
m_edgeMaxError,
static_cast<int>(ceil(m_edgeMaxLength / m_voxelSize)),
*m_intermediateContourSet));
// Build the polygon mesh, i.e. the navigation mesh geometry
m_success = m_success && (rcBuildPolyMesh(
m_context,
*m_intermediateContourSet,
m_polyMaxNbVertices,
*m_intermediatePolyMesh));
//Build the detailed polygon mesh, i.e. the detail for the ground.
m_success = m_success && (rcBuildPolyMeshDetail(
m_context,
*m_intermediatePolyMesh,
*m_intermediateCompactHeightfield,
m_sampleDist,
m_sampleMaxError,
*m_intermediatePolyMeshDetail));
// Update poly flags from areas.
for (int i = 0; m_success && i < m_intermediatePolyMesh->npolys; ++i)
{
switch(m_intermediatePolyMesh->areas[i])
{
case RC_WALKABLE_AREA:
m_intermediatePolyMesh->areas[i] = area::Ground;
break;
case RC_NULL_AREA:
default:
m_intermediatePolyMesh->areas[i] = area::Obstacle;
break;
}
switch(m_intermediatePolyMesh->areas[i])
{
case area::Ground:
m_intermediatePolyMesh->flags[i] = navigationFlags::Walkable;
break;
case area::Obstacle:
default:
m_intermediatePolyMesh->flags[i] = navigationFlags::NonWalkable;
break;
}
}
if (m_polyMaxNbVertices > DT_VERTS_PER_POLYGON)
{
m_context->log(RC_LOG_ERROR, "NavMeshCreator: unable to create Detour NavMesh, the configured maximum number of vertex per polygon (%d) is over Detour's limit (%d).",m_polyMaxNbVertices,DT_VERTS_PER_POLYGON);
m_success = false;
}
if (m_success)
{
memset(m_intermediateNavMeshCreateParams, 0, sizeof(dtNavMeshCreateParams));
m_intermediateNavMeshCreateParams->verts = m_intermediatePolyMesh->verts;
m_intermediateNavMeshCreateParams->vertCount = m_intermediatePolyMesh->nverts;
m_intermediateNavMeshCreateParams->polys = m_intermediatePolyMesh->polys;
m_intermediateNavMeshCreateParams->polyAreas = m_intermediatePolyMesh->areas;
m_intermediateNavMeshCreateParams->polyFlags = m_intermediatePolyMesh->flags;
m_intermediateNavMeshCreateParams->polyCount = m_intermediatePolyMesh->npolys;
m_intermediateNavMeshCreateParams->nvp = m_intermediatePolyMesh->nvp;
m_intermediateNavMeshCreateParams->detailMeshes = m_intermediatePolyMeshDetail->meshes;
m_intermediateNavMeshCreateParams->detailVerts = m_intermediatePolyMeshDetail->verts;
m_intermediateNavMeshCreateParams->detailVertsCount = m_intermediatePolyMeshDetail->nverts;
m_intermediateNavMeshCreateParams->detailTris = m_intermediatePolyMeshDetail->tris;
m_intermediateNavMeshCreateParams->detailTriCount = m_intermediatePolyMeshDetail->ntris;
m_intermediateNavMeshCreateParams->offMeshConVerts = 0;
m_intermediateNavMeshCreateParams->offMeshConRad = 0;
m_intermediateNavMeshCreateParams->offMeshConDir = 0;
m_intermediateNavMeshCreateParams->offMeshConAreas = 0;
m_intermediateNavMeshCreateParams->offMeshConFlags = 0;
m_intermediateNavMeshCreateParams->offMeshConUserID = 0;
m_intermediateNavMeshCreateParams->offMeshConCount = 0;
m_intermediateNavMeshCreateParams->walkableHeight = m_minimumCeilingClearance;
m_intermediateNavMeshCreateParams->walkableRadius = m_minimumObstacleClearance;
m_intermediateNavMeshCreateParams->walkableClimb = m_maximumStepHeight;
rcVcopy(m_intermediateNavMeshCreateParams->bmin, m_intermediatePolyMesh->bmin);
rcVcopy(m_intermediateNavMeshCreateParams->bmax, m_intermediatePolyMesh->bmax);
m_intermediateNavMeshCreateParams->cs = m_voxelSize;
m_intermediateNavMeshCreateParams->ch = m_voxelHeight;
m_intermediateNavMeshCreateParams->buildBvTree = true;
}
if (m_success)
{
m_outputNavMeshBuffer = 0;
m_outputNavMeshBufferSize = 0;
if (!dtCreateNavMeshData(m_intermediateNavMeshCreateParams, &m_outputNavMeshBuffer, &m_outputNavMeshBufferSize))
{
m_context->log(RC_LOG_ERROR, "NavMeshCreator: unable to create the detour navmesh data.");
m_success = false;
}
}
m_context->stopTimer(RC_TIMER_TOTAL);
if (m_success)
{
duLogBuildTimes(*m_context, m_context->getAccumulatedTime(RC_TIMER_TOTAL));
}
}
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;
}
bool NavMesh::createPolyMesh(rcConfig &cfg, NavModelData &data, rcContext *ctx)
{
// Create a heightfield to voxelise our input geometry
hf = rcAllocHeightfield();
if(!hf || !rcCreateHeightfield(ctx, *hf, cfg.width, cfg.height, cfg.bmin, cfg.bmax, cfg.cs, cfg.ch))
{
Con::errorf("Could not generate rcHeightField for NavMesh %s", getIdString());
return false;
}
unsigned char *areas = new unsigned char[data.getTriCount()];
if (!areas)
{
Con::errorf("Out of memory (area flags) for NavMesh %s", getIdString());
return false;
}
memset(areas, 0, data.getTriCount()*sizeof(unsigned char));
// Subtract 1 from all indices!
for(U32 i = 0; i < data.getTriCount(); i++)
{
data.tris[i*3]--;
data.tris[i*3+1]--;
data.tris[i*3+2]--;
}
// Filter triangles by angle and rasterize
rcMarkWalkableTriangles(ctx, cfg.walkableSlopeAngle,
data.getVerts(), data.getVertCount(),
data.getTris(), data.getTriCount(), areas);
rcRasterizeTriangles(ctx, data.getVerts(), data.getVertCount(),
data.getTris(), areas, data.getTriCount(),
*hf, cfg.walkableClimb);
delete [] areas;
// Filter out areas with low ceilings and other stuff
rcFilterLowHangingWalkableObstacles(ctx, cfg.walkableClimb, *hf);
rcFilterLedgeSpans(ctx, cfg.walkableHeight, cfg.walkableClimb, *hf);
rcFilterWalkableLowHeightSpans(ctx, cfg.walkableHeight, *hf);
chf = rcAllocCompactHeightfield();
if(!chf || !rcBuildCompactHeightfield(ctx, cfg.walkableHeight, cfg.walkableClimb, *hf, *chf))
{
Con::errorf("Could not generate rcCompactHeightField for NavMesh %s", getIdString());
return false;
}
if(!rcErodeWalkableArea(ctx, cfg.walkableRadius, *chf))
{
Con::errorf("Could not erode walkable area for NavMesh %s", getIdString());
return false;
}
if(false)
{
if(!rcBuildRegionsMonotone(ctx, *chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea))
{
Con::errorf("Could not build regions for NavMesh %s", getIdString());
return false;
}
}
else
{
if(!rcBuildDistanceField(ctx, *chf))
return false;
if(!rcBuildRegions(ctx, *chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea))
return false;
}
cs = rcAllocContourSet();
if(!cs || !rcBuildContours(ctx, *chf, cfg.maxSimplificationError, cfg.maxEdgeLen, *cs))
{
Con::errorf("Could not construct rcContourSet for NavMesh %s", getIdString());
return false;
}
pm = rcAllocPolyMesh();
if(!pm || !rcBuildPolyMesh(ctx, *cs, cfg.maxVertsPerPoly, *pm))
{
Con::errorf("Could not construct rcPolyMesh for NavMesh %s", getIdString());
return false;
}
pmd = rcAllocPolyMeshDetail();
if(!pmd || !rcBuildPolyMeshDetail(ctx, *pm, *chf, cfg.detailSampleDist, cfg.detailSampleMaxError, *pmd))
{
Con::errorf("Could not construct rcPolyMeshDetail for NavMesh %s", getIdString());
return false;
}
return true;
}
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;
}
unsigned char* Sample_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 = (int)rcSqr(m_regionMinSize); // Note: area = size*size
m_cfg.mergeRegionArea = (int)rcSqr(m_regionMergeSize); // Note: area = size*size
m_cfg.maxVertsPerPoly = (int)m_vertsPerPoly;
m_cfg.tileSize = (int)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.
rcVcopy(m_cfg.bmin, bmin);
rcVcopy(m_cfg.bmax, bmax);
m_cfg.bmin[0] -= m_cfg.borderSize*m_cfg.cs;
m_cfg.bmin[2] -= m_cfg.borderSize*m_cfg.cs;
m_cfg.bmax[0] += m_cfg.borderSize*m_cfg.cs;
m_cfg.bmax[2] += 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
// and 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[2];
tbmax[0] = m_cfg.bmax[0];
tbmax[1] = m_cfg.bmax[2];
int cid[512];// TODO: Make grow when returning too many items.
const int ncid = rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 512);
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;
}
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 martitioning 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 nacmesh, use this if you have large open areas
// 2) Monotone partioning
// - 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 partitoining
// - 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 == SAMPLE_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 == SAMPLE_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 // SAMPLE_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;
}
if (!rcBuildPolyMeshDetail(m_ctx, *m_pmesh, *m_chf,
m_cfg.detailSampleDist, m_cfg.detailSampleMaxError,
*m_dmesh))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could build polymesh detail.");
return 0;
}
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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == SAMPLE_POLYAREA_GROUND ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_GRASS ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_ROAD)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_WATER)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_SWIM;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_DOOR)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK | SAMPLE_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.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.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;
rcVcopy(params.bmin, m_pmesh->bmin);
rcVcopy(params.bmax, m_pmesh->bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
params.buildBvTree = true;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
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;
}
bool NavMeshGenerator::handleBuild(const Array2D<int>& tab)
{
cleanup();
//
// Step 1. Initialize build config.
//
// Init build configuration from GUI
memset(&m_cfg, 0, sizeof(m_cfg));
const int voxels_per_tile = 3; //3
m_cfg.width = tab.size().x*3*voxels_per_tile;
m_cfg.height = tab.size().x*3*voxels_per_tile;
m_cfg.cs = pixels_per_tile/float(voxels_per_tile);
m_cfg.walkableRadius = voxels_per_tile == 1 ? 0 : 1;
m_cfg.maxEdgeLen = 0;//20; //
m_cfg.maxSimplificationError = 0.f; // 0 or 1, no need because we are working on tiles
m_cfg.minRegionArea = 64;//(int)rcSqr(m_regionMinSize); // Note: area = size*size
m_cfg.mergeRegionArea = 10000;//(int)rcSqr(m_regionMergeSize); // Note: area = size*size
m_cfg.maxVertsPerPoly = 4;//(int)m_vertsPerPoly;
m_cfg.ch = 0.2f; // < height info, not used
m_cfg.detailSampleDist = 20.f; // < height info, not used
m_cfg.detailSampleMaxError = 0.2f; // < height info, not used
m_cfg.walkableSlopeAngle = 0; // < height info, not used
m_cfg.walkableHeight = 0; // < height info, not used
m_cfg.walkableClimb = 0; // < height info, not used
// Set the area where the navigation will be build.
m_cfg.bmin[0] = 0;
m_cfg.bmin[1] = 0;
m_cfg.bmin[2] = 0;
m_cfg.bmax[0] = tab.size().x*3*pixels_per_tile;
m_cfg.bmax[1] = 3;
m_cfg.bmax[2] = tab.size().y*3*pixels_per_tile;
// 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);
//
// Step 2. Create Heightfield
//
// Allocate voxel heightfield
m_solid = rcAllocHeightfield();
if (!m_solid)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'solid'.");
return false;
}
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 false;
}
for(int i = 0; i < m_solid->width; ++i) {
for(int j = 0; j < m_solid->height; ++j) {
bool colide = tab(int(i*tab.size().x/m_solid->width) , int(j*tab.size().y/m_solid->height)) != 0 ;
rcAddSpan(NULL,
*m_solid, i, j, 0,
colide ? 10: 0, colide ? RC_NULL_AREA : RC_WALKABLE_AREA, 1);
}
}
//
// Step 3. Filter walkables surfaces.
//----> Not done for 2D
//
// Step 4. Partition walkable surface to simple regions.
//
// 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 false;
}
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 false;
}
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 false;
}
// (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 martitioning 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 nacmesh, use this if you have large open areas
// 2) Monotone partioning
// - 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 partitoining
// - 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 (true) //m_partitionType == SAMPLE_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 false;
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build watershed regions.");
return false;
}
}
else if (false)//m_partitionType == SAMPLE_PARTITION_MONOTONE)
{
// Partition the walkable surface into simple regions without holes.
// Monotone partitioning does not need distancefield.
if (!rcBuildRegionsMonotone(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build monotone regions.");
return false;
}
}
else // SAMPLE_PARTITION_LAYERS
{
// Partition the walkable surface into simple regions without holes.
if (!rcBuildLayerRegions(m_ctx, *m_chf, 0, m_cfg.minRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build layer regions.");
return false;
}
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'.");
return false;
}
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 false;
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
m_pmesh = rcAllocPolyMesh();
if (!m_pmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'.");
return false;
}
if (!rcBuildPolyMesh(m_ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not triangulate contours.");
return false;
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
m_dmesh = rcAllocPolyMeshDetail();
if (!m_dmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmdtl'.");
return false;
}
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 detail mesh.");
return false;
}
if (!m_keepInterResults)
{
rcFreeCompactHeightfield(m_chf);
m_chf = 0;
rcFreeContourSet(m_cset);
m_cset = 0;
}
// At this point the navigation mesh data is ready, you can access it from m_pmesh.
// See duDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// (Optional) Step 8. Create Detour data from Recast poly mesh.
//
// The GUI may allow more max points per polygon than Detour can handle.
// Only build the detour navmesh if we do not exceed the limit.
if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON)
{
unsigned char* navData = 0;
int navDataSize = 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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == RC_WALKABLE_AREA)
{
m_pmesh->flags[i] = 1;
}
else {
m_pmesh->flags[i] = 0;
}
}
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.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.offMeshConCount = 0;
/*
unused since offMeshConCount is null
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.walkableHeight = m_agentHeight;
params.walkableRadius = m_agentRadius;
params.walkableClimb = m_agentMaxClimb;
rcVcopy(params.bmin, m_pmesh->bmin);
rcVcopy(params.bmax, m_pmesh->bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
params.buildBvTree = true;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
m_ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh.");
return false;
}
m_navMesh = dtAllocNavMesh();
if (!m_navMesh)
{
dtFree(navData);
m_ctx->log(RC_LOG_ERROR, "Could not create Detour navmesh");
return false;
}
dtStatus status;
status = m_navMesh->init(navData, navDataSize, DT_TILE_FREE_DATA);
if (dtStatusFailed(status))
{
dtFree(navData);
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh");
return false;
}
status = m_navQuery->init(m_navMesh, 2048);
if (dtStatusFailed(status))
{
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh query");
return false;
}
}
m_ctx->stopTimer(RC_TIMER_TOTAL);
// Show performance stats.
m_ctx->log(RC_LOG_PROGRESS, ">> Polymesh: %d vertices %d polygons", m_pmesh->nverts, m_pmesh->npolys);
return true;
}
bool OgreRecast::NavMeshBuild(InputGeom* input)
{
// TODO: clean up unused variables
m_pLog->logMessage("NavMeshBuild Start");
//
// Step 1. Initialize build config.
//
// Reset build times gathering.
m_ctx->resetTimers();
// Start the build process.
m_ctx->startTimer(RC_TIMER_TOTAL);
//
// Step 2. Rasterize input polygon soup.
//
InputGeom *inputGeom = input;
rcVcopy(m_cfg.bmin, inputGeom->getMeshBoundsMin());
rcVcopy(m_cfg.bmax, inputGeom->getMeshBoundsMax());
rcCalcGridSize(m_cfg.bmin, m_cfg.bmax, m_cfg.cs, &m_cfg.width, &m_cfg.height);
int nverts = inputGeom->getVertCount();
int ntris = inputGeom->getTriCount();
Ogre::Vector3 min; FloatAToOgreVect3(inputGeom->getMeshBoundsMin(), min);
Ogre::Vector3 max; FloatAToOgreVect3(inputGeom->getMeshBoundsMax(), max);
//Ogre::LogManager::getSingletonPtr()->logMessage("Bounds: "+Ogre::StringConverter::toString(min) + " "+ Ogre::StringConverter::toString(max));
m_pLog->logMessage("Building navigation:");
m_pLog->logMessage(" - " + Ogre::StringConverter::toString(m_cfg.width) + " x " + Ogre::StringConverter::toString(m_cfg.height) + " cells");
m_pLog->logMessage(" - " + Ogre::StringConverter::toString(nverts/1000.0f) + " K verts, " + Ogre::StringConverter::toString(ntris/1000.0f) + " K tris");
// Allocate voxel heightfield where we rasterize our input data to.
m_solid = rcAllocHeightfield();
if (!m_solid)
{
m_pLog->logMessage("ERROR: buildNavigation: Out of memory 'solid'.");
return false;
}
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_pLog->logMessage("ERROR: buildNavigation: Could not create solid heightfield. Possibly it requires too much memory, try setting a higher cellSize and cellHeight value.");
return false;
}
// Allocate array that can hold triangle area types.
// 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[ntris];
if (!m_triareas)
{
m_pLog->logMessage("ERROR: buildNavigation: Out of memory 'm_triareas' ("+Ogre::StringConverter::toString(ntris)+").");
return false;
}
// Find triangles which are walkable based on their slope and rasterize them.
// If your input data is multiple meshes, you can transform them here, calculate
// the are type for each of the meshes and rasterize them.
memset(m_triareas, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle, inputGeom->getVerts(), inputGeom->getVertCount(), inputGeom->getTris(), inputGeom->getTriCount(), m_triareas);
rcRasterizeTriangles(m_ctx, inputGeom->getVerts(), inputGeom->getVertCount(), inputGeom->getTris(), m_triareas, inputGeom->getTriCount(), *m_solid, m_cfg.walkableClimb);
if (!m_keepInterResults)
{
delete [] m_triareas;
m_triareas = 0;
}
//
// Step 3. Filter walkables surfaces.
//
// Once all geoemtry 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(m_ctx, m_cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid);
rcFilterWalkableLowHeightSpans(m_ctx, m_cfg.walkableHeight, *m_solid);
//
// Step 4. Partition walkable surface to simple regions.
//
// 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_pLog->logMessage("ERROR: buildNavigation: Out of memory 'chf'.");
return false;
}
if (!rcBuildCompactHeightfield(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid, *m_chf))
{
m_pLog->logMessage("ERROR: buildNavigation: Could not build compact data.");
return false;
}
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_pLog->logMessage("ERROR: buildNavigation: Could not erode walkable areas.");
return false;
}
// TODO implement
// (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);
// Prepare for region partitioning, by calculating distance field along the walkable surface.
if (!rcBuildDistanceField(m_ctx, *m_chf))
{
m_pLog->logMessage("ERROR: buildNavigation: Could not build distance field.");
return false;
}
// 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_pLog->logMessage("ERROR: buildNavigation: Could not build regions.");
return false;
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
m_pLog->logMessage("ERROR: buildNavigation: Out of memory 'cset'.");
return false;
}
if (!rcBuildContours(m_ctx, *m_chf, m_cfg.maxSimplificationError, m_cfg.maxEdgeLen, *m_cset))
{
m_pLog->logMessage("ERROR: buildNavigation: Could not create contours.");
return false;
}
if (m_cset->nconts == 0)
{
// In case of errors see: http://groups.google.com/group/recastnavigation/browse_thread/thread/a6fbd509859a12c8
// You should probably tweak the parameters
m_pLog->logMessage("ERROR: No contours created (Recast)!");
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
m_pmesh = rcAllocPolyMesh();
if (!m_pmesh)
{
m_pLog->logMessage("ERROR: buildNavigation: Out of memory 'pmesh'.");
return false;
}
if (!rcBuildPolyMesh(m_ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh))
{
// Try modifying the parameters. I experienced this error when setting agentMaxClimb too high.
m_pLog->logMessage("ERROR: buildNavigation: Could not triangulate contours.");
return false;
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
m_dmesh = rcAllocPolyMeshDetail();
if (!m_dmesh)
{
m_pLog->logMessage("ERROR: buildNavigation: Out of memory 'pmdtl'.");
return false;
}
if (!rcBuildPolyMeshDetail(m_ctx, *m_pmesh, *m_chf, m_cfg.detailSampleDist, m_cfg.detailSampleMaxError, *m_dmesh))
{
m_pLog->logMessage("ERROR: buildNavigation: Could not build detail mesh.");
return false;
}
if (!m_keepInterResults)
{
rcFreeCompactHeightfield(m_chf);
m_chf = 0;
rcFreeContourSet(m_cset);
m_cset = 0;
}
// At this point the navigation mesh data is ready, you can access it from m_pmesh.
// See duDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// (Optional) Step 8. Create Detour data from Recast poly mesh.
//
// The GUI may allow more max points per polygon than Detour can handle.
// Only build the detour navmesh if we do not exceed the limit.
if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON)
{
m_pLog->logMessage("Detour 1000");
unsigned char* navData = 0;
int navDataSize = 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] = SAMPLE_POLYAREA_GROUND;
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
}
// Set navmesh params
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.detailMeshes = m_dmesh->meshes;
params.detailVerts = m_dmesh->verts;
params.detailVertsCount = m_dmesh->nverts;
params.detailTris = m_dmesh->tris;
params.detailTriCount = m_dmesh->ntris;
// no off mesh connections yet
m_offMeshConCount=0 ;
params.offMeshConVerts = m_offMeshConVerts ;
params.offMeshConRad = m_offMeshConRads ;
params.offMeshConDir = m_offMeshConDirs ;
params.offMeshConAreas = m_offMeshConAreas ;
params.offMeshConFlags = m_offMeshConFlags ;
params.offMeshConUserID = m_offMeshConId ;
params.offMeshConCount = m_offMeshConCount ;
params.walkableHeight = m_agentHeight;
params.walkableRadius = m_agentRadius;
params.walkableClimb = m_agentMaxClimb;
rcVcopy(params.bmin, m_pmesh->bmin);
rcVcopy(params.bmax, m_pmesh->bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
m_pLog->logMessage("Detour 2000");
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
m_pLog->logMessage("ERROR: Could not build Detour navmesh.");
return false;
}
m_pLog->logMessage("Detour 3000");
m_navMesh = dtAllocNavMesh();
if (!m_navMesh)
{
dtFree(navData);
m_pLog->logMessage("ERROR: Could not create Detour navmesh");
return false;
}
m_pLog->logMessage("Detour 4000");
dtStatus status;
status = m_navMesh->init(navData, navDataSize, DT_TILE_FREE_DATA);
if (dtStatusFailed(status))
{
dtFree(navData);
m_pLog->logMessage("ERROR: Could not init Detour navmesh");
return false;
}
m_pLog->logMessage("Detour 5000");
m_navQuery = dtAllocNavMeshQuery();
status = m_navQuery->init(m_navMesh, 2048);
m_pLog->logMessage("Detour 5500");
if (dtStatusFailed(status))
{
m_pLog->logMessage("ERROR: Could not init Detour navmesh query");
return false;
}
m_pLog->logMessage("Detour 6000");
}
m_ctx->stopTimer(RC_TIMER_TOTAL);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// cleanup stuff we don't need
// delete [] rc_verts ;
// delete [] rc_tris ;
// delete [] rc_trinorms ;
//CreateRecastPolyMesh(*m_pmesh) ; // Debug render it
m_pLog->logMessage("NavMeshBuild End");
return true;
}
PDT_NAV_MESH gkRecast::createNavMesh(PMESHDATA meshData, const Config& config)
{
if (!meshData.get())
return PDT_NAV_MESH(0);
rcConfig cfg;
cfg.cs = config.CELL_SIZE;
cfg.ch = config.CELL_HEIGHT;
GK_ASSERT(cfg.ch && "cfg.ch cannot be zero");
GK_ASSERT(cfg.ch && "cfg.ch cannot be zero");
cfg.walkableSlopeAngle = config.AGENT_MAX_SLOPE;
cfg.walkableHeight = (int)ceilf(config.AGENT_HEIGHT / cfg.ch);
cfg.walkableClimb = (int)ceilf(config.AGENT_MAX_CLIMB / cfg.ch);
cfg.walkableRadius = (int)ceilf(config.AGENT_RADIUS / cfg.cs);
cfg.maxEdgeLen = (int)(config.EDGE_MAX_LEN / cfg.cs);
cfg.maxSimplificationError = config.EDGE_MAX_ERROR;
cfg.minRegionSize = (int)rcSqr(config.REGION_MIN_SIZE);
cfg.mergeRegionSize = (int)rcSqr(config.REGION_MERGE_SIZE);
cfg.maxVertsPerPoly = gkMin(config.VERTS_PER_POLY, DT_VERTS_PER_POLYGON);
cfg.tileSize = config.TILE_SIZE;
cfg.borderSize = cfg.walkableRadius + 4; // Reserve enough padding.
cfg.detailSampleDist = config.DETAIL_SAMPLE_DIST < 0.9f ? 0 : cfg.cs * config.DETAIL_SAMPLE_DIST;
cfg.detailSampleMaxError = cfg.ch * config.DETAIL_SAMPLE_ERROR;
if (!meshData->getVertCount())
return PDT_NAV_MESH(0);
gkScalar bmin[3], bmax[3];
const gkScalar* verts = meshData->getVerts();
int nverts = meshData->getVertCount();
const int* tris = meshData->getTris();
const gkScalar* trinorms = meshData->getNormals();
int ntris = meshData->getTriCount();
rcCalcBounds(verts, nverts, bmin, bmax);
//
// Step 1. Initialize build config.
//
// Set the area where the navigation will be build.
// Here the bounds of the input mesh are used, but the
// area could be specified by an user defined box, etc.
rcVcopy(cfg.bmin, bmin);
rcVcopy(cfg.bmax, bmax);
rcCalcGridSize(cfg.bmin, cfg.bmax, cfg.cs, &cfg.width, &cfg.height);
rcBuildTimes m_buildTimes;
// Reset build times gathering.
memset(&m_buildTimes, 0, sizeof(m_buildTimes));
rcSetBuildTimes(&m_buildTimes);
// Start the build process.
rcTimeVal totStartTime = rcGetPerformanceTimer();
//gkPrintf("Building navigation:");
//gkPrintf(" - %d x %d cells", cfg.width, cfg.height);
//gkPrintf(" - %.1fK verts, %.1fK tris", nverts/1000.0f, ntris/1000.0f);
//
// Step 2. Rasterize input polygon soup.
//
// Allocate voxel heighfield where we rasterize our input data to.
rcHeightfield heightField;
if (!rcCreateHeightfield(heightField, cfg.width, cfg.height, cfg.bmin, cfg.bmax, cfg.cs, cfg.ch))
{
gkPrintf("buildNavigation: Could not create solid heightfield.");
return PDT_NAV_MESH(0);
}
{
// Allocate array that can hold triangle flags.
// If you have multiple meshes you need to process, allocate
// and array which can hold the max number of triangles you need to process.
utArray<unsigned char> triflags;
triflags.resize(ntris);
// Find triangles which are walkable based on their slope and rasterize them.
// If your input data is multiple meshes, you can transform them here, calculate
// the flags for each of the meshes and rasterize them.
memset(triflags.ptr(), 0, ntris * sizeof(unsigned char));
rcMarkWalkableTriangles(cfg.walkableSlopeAngle, verts, nverts, tris, ntris, triflags.ptr());
rcRasterizeTriangles(verts, nverts, tris, triflags.ptr(), ntris, heightField);
}
//
// Step 3. Filter walkables surfaces.
//
// Once all geoemtry 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.
rcFilterLedgeSpans(cfg.walkableHeight, cfg.walkableClimb, heightField);
rcFilterWalkableLowHeightSpans(cfg.walkableHeight, heightField);
//
// Step 4. Partition walkable surface to simple regions.
//
// 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.
rcCompactHeightfield chf;
if (!rcBuildCompactHeightfield(cfg.walkableHeight, cfg.walkableClimb, RC_WALKABLE, heightField, chf))
{
gkPrintf("buildNavigation: Could not build compact data.");
return PDT_NAV_MESH(0);
}
// Erode the walkable area by agent radius.
if (!rcErodeArea(RC_WALKABLE_AREA, cfg.walkableRadius, chf))
{
gkPrintf("buildNavigation: Could not erode.");
return PDT_NAV_MESH(0);
}
//
// Mark areas from objects
//
gkScene* scene = gkEngine::getSingleton().getActiveScene();
gkGameObjectSet& objects = scene->getInstancedObjects();
gkGameObjectSet::Iterator it = objects.iterator();
while (it.hasMoreElements())
{
gkGameObject* obj = it.getNext();
if (!obj->getNavData().isEmpty())
{
size_t tBaseIndex = obj->getNavData().triangleBaseIndex;
size_t vBaseIndex = tBaseIndex / 2;
const float* v = verts + vBaseIndex;
const int nVerts = obj->getNavData().nIndex / 3;
const gkGameObjectProperties& prop = obj->getProperties();
rcMarkConvexPolyArea(v, nVerts, obj->getNavData().hmin, obj->getNavData().hmax, prop.m_findPathFlag, chf);
}
}
// Prepare for region partitioning, by calculating distance field along the walkable surface.
if (!rcBuildDistanceField(chf))
{
gkPrintf("buildNavigation: Could not build distance field.");
return PDT_NAV_MESH(0);
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(chf, cfg.borderSize, cfg.minRegionSize, cfg.mergeRegionSize))
{
gkPrintf("buildNavigation: Could not build regions.");
return PDT_NAV_MESH(0);
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
rcContourSet cset;
if (!rcBuildContours(chf, cfg.maxSimplificationError, cfg.maxEdgeLen, cset))
{
gkPrintf("buildNavigation: Could not create contours.");
return PDT_NAV_MESH(0);
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
rcPolyMesh pmesh;
if (!rcBuildPolyMesh(cset, cfg.maxVertsPerPoly, pmesh))
{
gkPrintf("buildNavigation: Could not triangulate contours.");
return PDT_NAV_MESH(0);
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
rcPolyMeshDetail dmesh;
if (!rcBuildPolyMeshDetail(pmesh, chf, cfg.detailSampleDist, cfg.detailSampleMaxError, dmesh))
{
gkPrintf("buildNavigation: Could not build detail mesh.");
return PDT_NAV_MESH(0);
}
// At this point the navigation mesh data is ready, you can access it from pmesh.
// See rcDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// Step 8. Create Detour data from Recast poly mesh.
//
PDT_NAV_MESH navMesh;
// Update poly flags from areas.
for (int i = 0; i < pmesh.npolys; ++i)
pmesh.flags[i] = 0xFFFF & pmesh.areas[i];
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
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;
params.detailMeshes = dmesh.meshes;
params.detailVerts = dmesh.verts;
params.detailVertsCount = dmesh.nverts;
params.detailTris = dmesh.tris;
params.detailTriCount = 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.offMeshConCount = m_geom->getOffMeshConnectionCount();
*/
params.walkableHeight = cfg.walkableHeight * cfg.ch;
params.walkableRadius = cfg.walkableRadius * cfg.cs;;
params.walkableClimb = cfg.walkableClimb * cfg.ch;
rcVcopy(params.bmin, pmesh.bmin);
rcVcopy(params.bmax, pmesh.bmax);
params.cs = cfg.cs;
params.ch = cfg.ch;
unsigned char* navData = 0;
int navDataSize = 0;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
gkPrintf("Could not build Detour navmesh.");
return PDT_NAV_MESH(0);
}
navMesh = PDT_NAV_MESH(new gkDetourNavMesh(new dtNavMesh));
if (!navMesh->m_p->init(navData, navDataSize, DT_TILE_FREE_DATA, 2048))
{
delete [] navData;
gkPrintf("Could not init Detour navmesh");
return PDT_NAV_MESH(0);
}
rcTimeVal totEndTime = rcGetPerformanceTimer();
gkPrintf("Navigation mesh created: %.1fms", rcGetDeltaTimeUsec(totStartTime, totEndTime) / 1000.0f);
return navMesh;
}
unsigned char* buildTileMesh(const int tx, const int ty,
const float* bmin, const float* bmax, int& dataSize,
InputGeom* geom,
rcConfig cfg,
rcContext* ctx)
{
const float* verts = geom->getMesh()->getVerts();
const int nverts = geom->getMesh()->getVertCount();
const int ntris = geom->getMesh()->getTriCount();
const rcChunkyTriMesh* chunkyMesh = geom->getChunkyMesh();
rcVcopy(cfg.bmin, bmin);
rcVcopy(cfg.bmax, bmax);
cfg.bmin[0] -= cfg.borderSize*cfg.cs;
cfg.bmin[2] -= cfg.borderSize*cfg.cs;
cfg.bmax[0] += cfg.borderSize*cfg.cs;
cfg.bmax[2] += cfg.borderSize*cfg.cs;
// Reset build times gathering.
ctx->resetTimers();
// Start the build process.
ctx->startTimer(RC_TIMER_TOTAL);
ctx->log(RC_LOG_PROGRESS, "Building navigation:");
ctx->log(RC_LOG_PROGRESS, " - %d x %d cells", cfg.width, cfg.height);
ctx->log(RC_LOG_PROGRESS, " - %.1fK verts, %.1fK tris", nverts/1000.0f, ntris/1000.0f);
// all involved objects
rcHeightfield* m_solid = 0;
unsigned char* m_triareas = 0;
rcCompactHeightfield* m_chf = 0;
rcContourSet* m_cset = 0;
rcPolyMesh* m_pmesh = 0;
rcPolyMeshDetail* m_dmesh = 0;
// Allocate voxel heightfield where we rasterize our input data to.
m_solid = rcAllocHeightfield();
if (!m_solid)
{
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'solid'.");
return 0;
}
if (!rcCreateHeightfield(ctx, *m_solid, cfg.width, cfg.height, cfg.bmin, cfg.bmax, cfg.cs, cfg.ch))
{
CleanupAfterTileBuild();
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
// and array which can hold the max number of triangles you need to process.
m_triareas = new unsigned char[chunkyMesh->maxTrisPerChunk];
if (!m_triareas)
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'm_triareas' (%d).", chunkyMesh->maxTrisPerChunk);
return 0;
}
float tbmin[2], tbmax[2];
tbmin[0] = cfg.bmin[0];
tbmin[1] = cfg.bmin[2];
tbmax[0] = cfg.bmax[0];
tbmax[1] = cfg.bmax[2];
int cid[512];// TODO: Make grow when returning too many items.
const int ncid = rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 512);
if (!ncid) {
CleanupAfterTileBuild();
return 0;
}
int m_tileTriCount = 0;
for (int i = 0; i < ncid; ++i)
{
const rcChunkyTriMeshNode& node = chunkyMesh->nodes[cid[i]];
const int* tris = &chunkyMesh->tris[node.i*3];
const int ntris = node.n;
m_tileTriCount += ntris;
memset(m_triareas, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(ctx, cfg.walkableSlopeAngle,
verts, nverts, tris, ntris, m_triareas);
rcRasterizeTriangles(ctx, verts, nverts, tris, m_triareas, ntris, *m_solid, cfg.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.
// Domi edit: Do not filter any triangles
#ifndef DOMI_EDIT
rcFilterLowHangingWalkableObstacles(ctx, cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(ctx, cfg.walkableHeight, cfg.walkableClimb, *m_solid);
rcFilterWalkableLowHeightSpans(ctx, cfg.walkableHeight, *m_solid);
#endif
// 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)
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'chf'.");
return 0;
}
if (!rcBuildCompactHeightfield(ctx, cfg.walkableHeight, cfg.walkableClimb, *m_solid, *m_chf))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build compact data.");
return 0;
}
// Erode the walkable area by agent radius.
if (!rcErodeWalkableArea(ctx, cfg.walkableRadius, *m_chf))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not erode.");
return 0;
}
// (Optional) Mark areas.
const ConvexVolume* vols = geom->getConvexVolumes();
for (int i = 0; i < geom->getConvexVolumeCount(); ++i)
rcMarkConvexPolyArea(ctx, vols[i].verts, vols[i].nverts, vols[i].hmin, vols[i].hmax, (unsigned char)vols[i].area, *m_chf);
if (0) // m_monotonePartitioning
{
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegionsMonotone(ctx, *m_chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build regions.");
return 0;
}
}
else
{
// Prepare for region partitioning, by calculating distance field along the walkable surface.
if (!rcBuildDistanceField(ctx, *m_chf))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build distance field.");
return 0;
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(ctx, *m_chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build regions.");
return 0;
}
}
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'.");
return 0;
}
if (!rcBuildContours(ctx, *m_chf, cfg.maxSimplificationError, cfg.maxEdgeLen, *m_cset))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not create contours.");
return 0;
}
if (m_cset->nconts == 0)
{
CleanupAfterTileBuild();
return 0;
}
// Build polygon navmesh from the contours.
m_pmesh = rcAllocPolyMesh();
if (!m_pmesh)
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'.");
return 0;
}
if (!rcBuildPolyMesh(ctx, *m_cset, cfg.maxVertsPerPoly, *m_pmesh))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could not triangulate contours.");
return 0;
}
// Build detail mesh.
m_dmesh = rcAllocPolyMeshDetail();
if (!m_dmesh)
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'dmesh'.");
return 0;
}
if (!rcBuildPolyMeshDetail(ctx, *m_pmesh, *m_chf,
cfg.detailSampleDist, cfg.detailSampleMaxError,
*m_dmesh))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "buildNavigation: Could build polymesh detail.");
return 0;
}
unsigned char* navData = 0;
int navDataSize = 0;
if (cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON)
{
if (m_pmesh->nverts >= 0xffff)
{
CleanupAfterTileBuild();
// The vertex indices are ushorts, and cannot point to more than 0xffff vertices.
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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == SAMPLE_POLYAREA_GROUND ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_GRASS ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_ROAD)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_WATER)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_SWIM;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_DOOR)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK | SAMPLE_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.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 = geom->getOffMeshConnectionVerts();
params.offMeshConRad = geom->getOffMeshConnectionRads();
params.offMeshConDir = geom->getOffMeshConnectionDirs();
params.offMeshConAreas = geom->getOffMeshConnectionAreas();
params.offMeshConFlags = geom->getOffMeshConnectionFlags();
params.offMeshConUserID = geom->getOffMeshConnectionId();
params.offMeshConCount = geom->getOffMeshConnectionCount();
params.walkableHeight = (float)cfg.walkableHeight;
params.walkableRadius = (float)cfg.walkableRadius;
params.walkableClimb = (float)cfg.walkableClimb;
params.tileX = tx;
params.tileY = ty;
params.tileLayer = 0;
rcVcopy(params.bmin, m_pmesh->bmin);
rcVcopy(params.bmax, m_pmesh->bmax);
params.cs = cfg.cs;
params.ch = cfg.ch;
params.buildBvTree = true;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
CleanupAfterTileBuild();
ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh.");
return 0;
}
}
ctx->stopTimer(RC_TIMER_TOTAL);
// Show performance stats.
ctx->log(RC_LOG_PROGRESS, ">> Polymesh: %d vertices %d polygons", m_pmesh->nverts, m_pmesh->npolys);
dataSize = navDataSize;
CleanupAfterTileBuild();
return navData;
}
bool NavigationMesh::BuildTile(Vector<NavigationGeometryInfo>& geometryList, int x, int z)
{
PROFILE(BuildNavigationMeshTile);
// Remove previous tile (if any)
navMesh_->removeTile(navMesh_->getTileRefAt(x, z, 0), 0, 0);
float tileEdgeLength = (float)tileSize_ * cellSize_;
BoundingBox tileBoundingBox(Vector3(
boundingBox_.min_.x_ + tileEdgeLength * (float)x,
boundingBox_.min_.y_,
boundingBox_.min_.z_ + tileEdgeLength * (float)z
),
Vector3(
boundingBox_.min_.x_ + tileEdgeLength * (float)(x + 1),
boundingBox_.max_.y_,
boundingBox_.min_.z_ + tileEdgeLength * (float)(z + 1)
));
NavigationBuildData build;
rcConfig cfg;
memset(&cfg, 0, sizeof cfg);
cfg.cs = cellSize_;
cfg.ch = cellHeight_;
cfg.walkableSlopeAngle = agentMaxSlope_;
cfg.walkableHeight = (int)ceilf(agentHeight_ / cfg.ch);
cfg.walkableClimb = (int)floorf(agentMaxClimb_ / cfg.ch);
cfg.walkableRadius = (int)ceilf(agentRadius_ / cfg.cs);
cfg.maxEdgeLen = (int)(edgeMaxLength_ / cellSize_);
cfg.maxSimplificationError = edgeMaxError_;
cfg.minRegionArea = (int)sqrtf(regionMinSize_);
cfg.mergeRegionArea = (int)sqrtf(regionMergeSize_);
cfg.maxVertsPerPoly = 6;
cfg.tileSize = tileSize_;
cfg.borderSize = cfg.walkableRadius + 3; // Add padding
cfg.width = cfg.tileSize + cfg.borderSize * 2;
cfg.height = cfg.tileSize + cfg.borderSize * 2;
cfg.detailSampleDist = detailSampleDistance_ < 0.9f ? 0.0f : cellSize_ * detailSampleDistance_;
cfg.detailSampleMaxError = cellHeight_ * detailSampleMaxError_;
rcVcopy(cfg.bmin, &tileBoundingBox.min_.x_);
rcVcopy(cfg.bmax, &tileBoundingBox.max_.x_);
cfg.bmin[0] -= cfg.borderSize * cfg.cs;
cfg.bmin[2] -= cfg.borderSize * cfg.cs;
cfg.bmax[0] += cfg.borderSize * cfg.cs;
cfg.bmax[2] += cfg.borderSize * cfg.cs;
BoundingBox expandedBox(*reinterpret_cast<Vector3*>(cfg.bmin), *reinterpret_cast<Vector3*>(cfg.bmax));
GetTileGeometry(build, geometryList, expandedBox);
if (build.vertices_.Empty() || build.indices_.Empty())
return true; // Nothing to do
build.heightField_ = rcAllocHeightfield();
if (!build.heightField_)
{
LOGERROR("Could not allocate heightfield");
return false;
}
if (!rcCreateHeightfield(build.ctx_, *build.heightField_, cfg.width, cfg.height, cfg.bmin, cfg.bmax, cfg.cs,
cfg.ch))
{
LOGERROR("Could not create heightfield");
return false;
}
unsigned numTriangles = build.indices_.Size() / 3;
SharedArrayPtr<unsigned char> triAreas(new unsigned char[numTriangles]);
memset(triAreas.Get(), 0, numTriangles);
rcMarkWalkableTriangles(build.ctx_, cfg.walkableSlopeAngle, &build.vertices_[0].x_, build.vertices_.Size(),
&build.indices_[0], numTriangles, triAreas.Get());
rcRasterizeTriangles(build.ctx_, &build.vertices_[0].x_, build.vertices_.Size(), &build.indices_[0],
triAreas.Get(), numTriangles, *build.heightField_, cfg.walkableClimb);
rcFilterLowHangingWalkableObstacles(build.ctx_, cfg.walkableClimb, *build.heightField_);
rcFilterLedgeSpans(build.ctx_, cfg.walkableHeight, cfg.walkableClimb, *build.heightField_);
rcFilterWalkableLowHeightSpans(build.ctx_, cfg.walkableHeight, *build.heightField_);
build.compactHeightField_ = rcAllocCompactHeightfield();
if (!build.compactHeightField_)
{
LOGERROR("Could not allocate create compact heightfield");
return false;
}
if (!rcBuildCompactHeightfield(build.ctx_, cfg.walkableHeight, cfg.walkableClimb, *build.heightField_,
*build.compactHeightField_))
{
LOGERROR("Could not build compact heightfield");
return false;
}
if (!rcErodeWalkableArea(build.ctx_, cfg.walkableRadius, *build.compactHeightField_))
{
LOGERROR("Could not erode compact heightfield");
return false;
}
if (!rcBuildDistanceField(build.ctx_, *build.compactHeightField_))
{
LOGERROR("Could not build distance field");
return false;
}
if (!rcBuildRegions(build.ctx_, *build.compactHeightField_, cfg.borderSize, cfg.minRegionArea,
cfg.mergeRegionArea))
{
LOGERROR("Could not build regions");
return false;
}
build.contourSet_ = rcAllocContourSet();
if (!build.contourSet_)
{
LOGERROR("Could not allocate contour set");
return false;
}
if (!rcBuildContours(build.ctx_, *build.compactHeightField_, cfg.maxSimplificationError, cfg.maxEdgeLen,
*build.contourSet_))
{
LOGERROR("Could not create contours");
return false;
}
build.polyMesh_ = rcAllocPolyMesh();
if (!build.polyMesh_)
{
LOGERROR("Could not allocate poly mesh");
return false;
}
if (!rcBuildPolyMesh(build.ctx_, *build.contourSet_, cfg.maxVertsPerPoly, *build.polyMesh_))
{
LOGERROR("Could not triangulate contours");
return false;
}
build.polyMeshDetail_ = rcAllocPolyMeshDetail();
if (!build.polyMeshDetail_)
{
LOGERROR("Could not allocate detail mesh");
return false;
}
if (!rcBuildPolyMeshDetail(build.ctx_, *build.polyMesh_, *build.compactHeightField_, cfg.detailSampleDist,
cfg.detailSampleMaxError, *build.polyMeshDetail_))
{
LOGERROR("Could not build detail mesh");
return false;
}
// Set polygon flags
/// \todo Allow to define custom flags
for (int i = 0; i < build.polyMesh_->npolys; ++i)
{
if (build.polyMesh_->areas[i] == RC_WALKABLE_AREA)
build.polyMesh_->flags[i] = 0x1;
}
unsigned char* navData = 0;
int navDataSize = 0;
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof params);
params.verts = build.polyMesh_->verts;
params.vertCount = build.polyMesh_->nverts;
params.polys = build.polyMesh_->polys;
params.polyAreas = build.polyMesh_->areas;
params.polyFlags = build.polyMesh_->flags;
params.polyCount = build.polyMesh_->npolys;
params.nvp = build.polyMesh_->nvp;
params.detailMeshes = build.polyMeshDetail_->meshes;
params.detailVerts = build.polyMeshDetail_->verts;
params.detailVertsCount = build.polyMeshDetail_->nverts;
params.detailTris = build.polyMeshDetail_->tris;
params.detailTriCount = build.polyMeshDetail_->ntris;
params.walkableHeight = agentHeight_;
params.walkableRadius = agentRadius_;
params.walkableClimb = agentMaxClimb_;
params.tileX = x;
params.tileY = z;
rcVcopy(params.bmin, build.polyMesh_->bmin);
rcVcopy(params.bmax, build.polyMesh_->bmax);
params.cs = cfg.cs;
params.ch = cfg.ch;
params.buildBvTree = true;
// Add off-mesh connections if have them
if (build.offMeshRadii_.Size())
{
params.offMeshConCount = build.offMeshRadii_.Size();
params.offMeshConVerts = &build.offMeshVertices_[0].x_;
params.offMeshConRad = &build.offMeshRadii_[0];
params.offMeshConFlags = &build.offMeshFlags_[0];
params.offMeshConAreas = &build.offMeshAreas_[0];
params.offMeshConDir = &build.offMeshDir_[0];
}
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
LOGERROR("Could not build navigation mesh tile data");
return false;
}
if (dtStatusFailed(navMesh_->addTile(navData, navDataSize, DT_TILE_FREE_DATA, 0, 0)))
{
LOGERROR("Failed to add navigation mesh tile");
dtFree(navData);
return false;
}
return true;
}
int recast_buildContours(struct recast_compactHeightfield *chf,
const float maxError, const int maxEdgeLen, struct recast_contourSet *cset)
{
INIT_SCTX();
return rcBuildContours(sctx, *(rcCompactHeightfield *) chf, maxError, maxEdgeLen, *(rcContourSet *) cset);
}
/*!
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;
}
unsigned char* Sample_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 = (int)rcSqr(m_regionMinSize); // Note: area = size*size
m_cfg.mergeRegionArea = (int)rcSqr(m_regionMergeSize); // Note: area = size*size
m_cfg.maxVertsPerPoly = (int)m_vertsPerPoly;
m_cfg.tileSize = (int)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;
rcVcopy(m_cfg.bmin, bmin);
rcVcopy(m_cfg.bmax, bmax);
m_cfg.bmin[0] -= m_cfg.borderSize*m_cfg.cs;
m_cfg.bmin[2] -= m_cfg.borderSize*m_cfg.cs;
m_cfg.bmax[0] += m_cfg.borderSize*m_cfg.cs;
m_cfg.bmax[2] += 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
// and 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[2];
tbmax[0] = m_cfg.bmax[0];
tbmax[1] = m_cfg.bmax[2];
int cid[512];// TODO: Make grow when returning too many items.
const int ncid = rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 512);
if (!ncid)
return 0;
m_tileTriCount = 0;
for (int i = 0; i < ncid; ++i)
{
const rcChunkyTriMeshNode& node = chunkyMesh->nodes[cid[i]];
const int* tris = &chunkyMesh->tris[node.i*3];
const int ntris = node.n;
m_tileTriCount += ntris;
memset(m_triareas, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle,
verts, nverts, tris, ntris, m_triareas);
rcRasterizeTriangles(m_ctx, verts, nverts, tris, m_triareas, ntris, *m_solid, m_cfg.walkableClimb);
}
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.
rcFilterLowHangingWalkableObstacles(m_ctx, m_cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid);
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 false;
}
// (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);
// 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 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;
}
if (!rcBuildPolyMeshDetail(m_ctx, *m_pmesh, *m_chf,
m_cfg.detailSampleDist, m_cfg.detailSampleMaxError,
*m_dmesh))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could build polymesh detail.");
return 0;
}
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)
{
// Remove padding from the polymesh data. TODO: Remove this odditity.
for (int i = 0; i < m_pmesh->nverts; ++i)
{
unsigned short* v = &m_pmesh->verts[i*3];
v[0] -= (unsigned short)m_cfg.borderSize;
v[2] -= (unsigned short)m_cfg.borderSize;
}
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 false;
}
// 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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == SAMPLE_POLYAREA_GROUND ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_GRASS ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_ROAD)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_WATER)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_SWIM;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_DOOR)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK | SAMPLE_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.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.offMeshConCount = m_geom->getOffMeshConnectionCount();
params.walkableHeight = m_agentHeight;
params.walkableRadius = m_agentRadius;
params.walkableClimb = m_agentMaxClimb;
params.tileX = tx;
params.tileY = ty;
rcVcopy(params.bmin, bmin);
rcVcopy(params.bmax, bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
params.tileSize = m_cfg.tileSize;
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
m_ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh.");
return 0;
}
// Restore padding so that the debug visualization is correct.
for (int i = 0; i < m_pmesh->nverts; ++i)
{
unsigned short* v = &m_pmesh->verts[i*3];
v[0] += (unsigned short)m_cfg.borderSize;
v[2] += (unsigned short)m_cfg.borderSize;
}
}
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;
}
bool NavMesher::Build()
{
// ******* Only for OBJ Loading ****
cleanup();
const char * filepath = "../../media/models/";
if (!m_geom || !m_geom->loadMesh(filepath))
{
delete m_geom;
m_geom = 0;
m_ctx->log(RC_LOG_ERROR, "Geom load log %s:");
}
assert(m_geom);
if (!m_geom || !m_geom->getMesh())
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Input mesh is not specified.");
return false;
}
if(m_geom->getMesh()->getTriCount() <= 0 || m_geom->getMesh()->getVertCount()<=0)
Ogre::Exception(0,Ogre::String("Bad verts or Triangle count. Verts: "+
StringConverter::toString( m_geom->getMesh()->getVertCount()) + "/n"
+ "Triangles :" +StringConverter::toString(m_geom->getMesh()->getTriCount())),"NavMesher::Build");
//reset timer
Ogre::Timer tm;
tm.reset();
unsigned long stime = tm.getMicroseconds();
//clear existing
Clear();
// ******* Only for OBJ Loading ****
const float* bmin = m_geom->getMeshBoundsMin();
const float* bmax = m_geom->getMeshBoundsMax();
const float* verts = m_geom->getMesh()->getVerts();
const int nverts = m_geom->getMesh()->getVertCount();
const int *tris = m_geom->getMesh()->getTris();
const int ntris = m_geom->getMesh()->getTriCount();
if(sizeof(tris) <= 0 || ntris <= 0) {
return false;
}
//
// Step 1. Initialize build config.
//
// 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 = (int)rcSqr(m_regionMinSize); // Note: area = size*size
m_cfg.mergeRegionArea = (int)rcSqr(m_regionMergeSize); // Note: area = size*size
m_cfg.maxVertsPerPoly = (int)m_vertsPerPoly;
m_cfg.detailSampleDist = m_detailSampleDist < 0.9f ? 0 : m_cellSize * m_detailSampleDist;
m_cfg.detailSampleMaxError = m_cellHeight * m_detailSampleMaxError;
// Set the area where the navigation will be build.
// Here the bounds of the input mesh are used, but the
// area could be specified by an user defined box, etc.
rcVcopy(m_cfg.bmin, bmin);
rcVcopy(m_cfg.bmax, bmax);
rcCalcGridSize(m_cfg.bmin, m_cfg.bmax, m_cfg.cs, &m_cfg.width, &m_cfg.height);
// 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);
//
// Step 2. Rasterize input polygon soup.
//
// 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 false;
}
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 false;
}
// Allocate array that can hold triangle area types.
// If you have multiple meshes you need to process, allocate
// and array which can hold the max number of triangles you need to process.
m_triareas = new unsigned char[ntris];
if (!m_triareas)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'm_triareas' (%d).", ntris);
return false;
}
// Find triangles which are walkable based on their slope and rasterize them.
// If your input data is multiple meshes, you can transform them here, calculate
// the are type for each of the meshes and rasterize them.
memset(m_triareas, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(m_ctx, m_cfg.walkableSlopeAngle, verts, nverts, tris, ntris, m_triareas);
rcRasterizeTriangles(m_ctx, verts, nverts, tris, m_triareas, ntris, *m_solid, m_cfg.walkableClimb);
if (!m_keepInterResults)
{
delete [] m_triareas;
m_triareas = 0;
}
//
// Step 3. Filter walkables surfaces.
//
// Once all geoemtry 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(m_ctx, m_cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(m_ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid);
rcFilterWalkableLowHeightSpans(m_ctx, m_cfg.walkableHeight, *m_solid);
//
// Step 4. Partition walkable surface to simple regions.
//
// 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 false;
}
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 false;
}
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 false;
}
// (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);
if (m_monotonePartitioning)
{
// Partition the walkable surface into simple regions without holes.
// Monotone partitioning does not need distancefield.
if (!rcBuildRegionsMonotone(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build regions.");
return false;
}
}
else
{
// 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 false;
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(m_ctx, *m_chf, 0, m_cfg.minRegionArea, m_cfg.mergeRegionArea))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not build regions.");
return false;
}
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
m_cset = rcAllocContourSet();
if (!m_cset)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'.");
return false;
}
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 false;
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
m_pmesh = rcAllocPolyMesh();
if (!m_pmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'.");
return false;
}
if (!rcBuildPolyMesh(m_ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh))
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not triangulate contours.");
return false;
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
m_dmesh = rcAllocPolyMeshDetail();
if (!m_dmesh)
{
m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmdtl'.");
return false;
}
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 detail mesh.");
return false;
}
if (!m_keepInterResults)
{
rcFreeCompactHeightfield(m_chf);
m_chf = 0;
rcFreeContourSet(m_cset);
m_cset = 0;
}
// At this point the navigation mesh data is ready, you can access it from m_pmesh.
// See rcDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// (Optional) Step 8. Create Detour data from Recast poly mesh.
//
// The GUI may allow more max points per polygon than Detour can handle.
// Only build the detour navmesh if we do not exceed the limit.
unsigned char* navData = 0;
int navDataSize = 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] = SAMPLE_POLYAREA_GROUND;
if (m_pmesh->areas[i] == SAMPLE_POLYAREA_GROUND ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_GRASS ||
m_pmesh->areas[i] == SAMPLE_POLYAREA_ROAD)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_WATER)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_SWIM;
}
else if (m_pmesh->areas[i] == SAMPLE_POLYAREA_DOOR)
{
m_pmesh->flags[i] = SAMPLE_POLYFLAGS_WALK | SAMPLE_POLYFLAGS_DOOR;
}
}
memset(&m_params, 0, sizeof(m_params));
m_params.verts = m_pmesh->verts;
m_params.vertCount = m_pmesh->nverts;
m_params.polys = m_pmesh->polys;
m_params.polyAreas = m_pmesh->areas;
m_params.polyFlags = m_pmesh->flags;
m_params.polyCount = m_pmesh->npolys;
m_params.nvp = m_pmesh->nvp;
m_params.detailMeshes = m_dmesh->meshes;
m_params.detailVerts = m_dmesh->verts;
m_params.detailVertsCount = m_dmesh->nverts;
m_params.detailTris = m_dmesh->tris;
m_params.detailTriCount = m_dmesh->ntris;
m_params.walkableHeight = m_agentHeight;
m_params.walkableRadius = m_agentRadius;
m_params.walkableClimb = m_agentMaxClimb;
rcVcopy(m_params.bmin, m_pmesh->bmin);
rcVcopy(m_params.bmax, m_pmesh->bmax);
m_params.cs = m_cfg.cs;
m_params.ch = m_cfg.ch;
m_params.buildBvTree = true;
if (!dtCreateNavMeshData(&m_params, &navData, &navDataSize)) {
m_ctx->log(RC_LOG_ERROR, "Could not build Detour navmesh.");
return false;
}
m_navMesh = dtAllocNavMesh();
if (!m_navMesh) {
delete [] navData;
m_ctx->log(RC_LOG_ERROR, "Could not create Detour navmesh");
return false;
}
m_navQuery = dtAllocNavMeshQuery();
dtStatus status = m_navQuery->init(m_navMesh, 2048);
if (dtStatusFailed(status)) {
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh query");
return false;
}
if (!m_navMesh->init(navData, navDataSize, true)) {
delete [] navData;
m_ctx->log(RC_LOG_ERROR, "Could not init Detour navmesh");
return false;
}
//take time
stime = tm.getMicroseconds() - stime;
DrawDebug();
return true;
}
void MapBuilder::buildMoveMapTile(uint32 mapID, uint32 tileX, uint32 tileY,
MeshData &meshData, float bmin[3], float bmax[3],
dtNavMesh* navMesh)
{
// console output
std::string tileString = Trinity::StringFormat("[Map %04u] [%02i,%02i]: ", mapID, tileX, tileY);
printf("%s Building movemap tiles...\n", tileString.c_str());
IntermediateValues iv;
float* tVerts = meshData.solidVerts.getCArray();
int tVertCount = meshData.solidVerts.size() / 3;
int* tTris = meshData.solidTris.getCArray();
int tTriCount = meshData.solidTris.size() / 3;
float* lVerts = meshData.liquidVerts.getCArray();
int lVertCount = meshData.liquidVerts.size() / 3;
int* lTris = meshData.liquidTris.getCArray();
int lTriCount = meshData.liquidTris.size() / 3;
uint8* lTriFlags = meshData.liquidType.getCArray();
// these are WORLD UNIT based metrics
// this are basic unit dimentions
// value have to divide GRID_SIZE(533.3333f) ( aka: 0.5333, 0.2666, 0.3333, 0.1333, etc )
const static float BASE_UNIT_DIM = m_bigBaseUnit ? 0.5333333f : 0.2666666f;
// All are in UNIT metrics!
const static int VERTEX_PER_MAP = int(GRID_SIZE/BASE_UNIT_DIM + 0.5f);
const static int VERTEX_PER_TILE = m_bigBaseUnit ? 40 : 80; // must divide VERTEX_PER_MAP
const static int TILES_PER_MAP = VERTEX_PER_MAP/VERTEX_PER_TILE;
rcConfig config;
memset(&config, 0, sizeof(rcConfig));
rcVcopy(config.bmin, bmin);
rcVcopy(config.bmax, bmax);
config.maxVertsPerPoly = DT_VERTS_PER_POLYGON;
config.cs = BASE_UNIT_DIM;
config.ch = BASE_UNIT_DIM;
config.walkableSlopeAngle = m_maxWalkableAngle;
config.tileSize = VERTEX_PER_TILE;
config.walkableRadius = m_bigBaseUnit ? 1 : 2;
config.borderSize = config.walkableRadius + 3;
config.maxEdgeLen = VERTEX_PER_TILE + 1; // anything bigger than tileSize
config.walkableHeight = m_bigBaseUnit ? 3 : 6;
// a value >= 3|6 allows npcs to walk over some fences
// a value >= 4|8 allows npcs to walk over all fences
config.walkableClimb = m_bigBaseUnit ? 4 : 8;
config.minRegionArea = rcSqr(60);
config.mergeRegionArea = rcSqr(50);
config.maxSimplificationError = 1.8f; // eliminates most jagged edges (tiny polygons)
config.detailSampleDist = config.cs * 64;
config.detailSampleMaxError = config.ch * 2;
// this sets the dimensions of the heightfield - should maybe happen before border padding
rcCalcGridSize(config.bmin, config.bmax, config.cs, &config.width, &config.height);
// allocate subregions : tiles
Tile* tiles = new Tile[TILES_PER_MAP * TILES_PER_MAP];
// 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*[TILES_PER_MAP * TILES_PER_MAP];
rcPolyMeshDetail** dmmerge = new rcPolyMeshDetail*[TILES_PER_MAP * TILES_PER_MAP];
int nmerge = 0;
// build all tiles
for (int y = 0; y < TILES_PER_MAP; ++y)
{
for (int x = 0; x < TILES_PER_MAP; ++x)
{
Tile& tile = tiles[x + y * TILES_PER_MAP];
// 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;
// build heightfield
tile.solid = rcAllocHeightfield();
if (!tile.solid || !rcCreateHeightfield(m_rcContext, *tile.solid, tileCfg.width, tileCfg.height, tileCfg.bmin, tileCfg.bmax, tileCfg.cs, tileCfg.ch))
{
printf("%s Failed building heightfield! \n", tileString.c_str());
continue;
}
// mark all walkable tiles, both liquids and solids
unsigned char* triFlags = new unsigned char[tTriCount];
memset(triFlags, NAV_GROUND, tTriCount*sizeof(unsigned char));
rcClearUnwalkableTriangles(m_rcContext, tileCfg.walkableSlopeAngle, tVerts, tVertCount, tTris, tTriCount, triFlags);
rcRasterizeTriangles(m_rcContext, tVerts, tVertCount, tTris, triFlags, tTriCount, *tile.solid, config.walkableClimb);
delete[] triFlags;
rcFilterLowHangingWalkableObstacles(m_rcContext, config.walkableClimb, *tile.solid);
rcFilterLedgeSpans(m_rcContext, tileCfg.walkableHeight, tileCfg.walkableClimb, *tile.solid);
rcFilterWalkableLowHeightSpans(m_rcContext, tileCfg.walkableHeight, *tile.solid);
rcRasterizeTriangles(m_rcContext, lVerts, lVertCount, lTris, lTriFlags, lTriCount, *tile.solid, config.walkableClimb);
// compact heightfield spans
tile.chf = rcAllocCompactHeightfield();
if (!tile.chf || !rcBuildCompactHeightfield(m_rcContext, tileCfg.walkableHeight, tileCfg.walkableClimb, *tile.solid, *tile.chf))
{
printf("%s Failed compacting heightfield! \n", tileString.c_str());
continue;
}
// build polymesh intermediates
if (!rcErodeWalkableArea(m_rcContext, config.walkableRadius, *tile.chf))
{
printf("%s Failed eroding area! \n", tileString.c_str());
continue;
}
if (!rcBuildDistanceField(m_rcContext, *tile.chf))
{
printf("%s Failed building distance field! \n", tileString.c_str());
continue;
}
if (!rcBuildRegions(m_rcContext, *tile.chf, tileCfg.borderSize, tileCfg.minRegionArea, tileCfg.mergeRegionArea))
{
printf("%s Failed building regions! \n", tileString.c_str());
continue;
}
tile.cset = rcAllocContourSet();
if (!tile.cset || !rcBuildContours(m_rcContext, *tile.chf, tileCfg.maxSimplificationError, tileCfg.maxEdgeLen, *tile.cset))
{
printf("%s Failed building contours! \n", tileString.c_str());
continue;
}
// build polymesh
tile.pmesh = rcAllocPolyMesh();
if (!tile.pmesh || !rcBuildPolyMesh(m_rcContext, *tile.cset, tileCfg.maxVertsPerPoly, *tile.pmesh))
{
printf("%s Failed building polymesh! \n", tileString.c_str());
continue;
}
tile.dmesh = rcAllocPolyMeshDetail();
if (!tile.dmesh || !rcBuildPolyMeshDetail(m_rcContext, *tile.pmesh, *tile.chf, tileCfg.detailSampleDist, tileCfg.detailSampleMaxError, *tile.dmesh))
{
printf("%s Failed building polymesh detail! \n", tileString.c_str());
continue;
}
// free those up
// we may want to keep them in the future for debug
// but right now, we don't have the code to merge them
rcFreeHeightField(tile.solid);
tile.solid = NULL;
rcFreeCompactHeightfield(tile.chf);
tile.chf = NULL;
rcFreeContourSet(tile.cset);
tile.cset = NULL;
pmmerge[nmerge] = tile.pmesh;
dmmerge[nmerge] = tile.dmesh;
nmerge++;
}
}
iv.polyMesh = rcAllocPolyMesh();
if (!iv.polyMesh)
{
printf("%s alloc iv.polyMesh FAILED!\n", tileString.c_str());
delete[] pmmerge;
delete[] dmmerge;
delete[] tiles;
return;
}
rcMergePolyMeshes(m_rcContext, pmmerge, nmerge, *iv.polyMesh);
iv.polyMeshDetail = rcAllocPolyMeshDetail();
if (!iv.polyMeshDetail)
{
printf("%s alloc m_dmesh FAILED!\n", tileString.c_str());
delete[] pmmerge;
delete[] dmmerge;
delete[] tiles;
return;
}
rcMergePolyMeshDetails(m_rcContext, dmmerge, nmerge, *iv.polyMeshDetail);
// free things up
delete[] pmmerge;
delete[] dmmerge;
delete[] tiles;
// set polygons as walkable
// TODO: special flags for DYNAMIC polygons, ie surfaces that can be turned on and off
for (int i = 0; i < iv.polyMesh->npolys; ++i)
if (iv.polyMesh->areas[i] & RC_WALKABLE_AREA)
iv.polyMesh->flags[i] = iv.polyMesh->areas[i];
// setup mesh parameters
dtNavMeshCreateParams params;
memset(¶ms, 0, sizeof(params));
params.verts = iv.polyMesh->verts;
params.vertCount = iv.polyMesh->nverts;
params.polys = iv.polyMesh->polys;
params.polyAreas = iv.polyMesh->areas;
params.polyFlags = iv.polyMesh->flags;
params.polyCount = iv.polyMesh->npolys;
params.nvp = iv.polyMesh->nvp;
params.detailMeshes = iv.polyMeshDetail->meshes;
params.detailVerts = iv.polyMeshDetail->verts;
params.detailVertsCount = iv.polyMeshDetail->nverts;
params.detailTris = iv.polyMeshDetail->tris;
params.detailTriCount = iv.polyMeshDetail->ntris;
params.offMeshConVerts = meshData.offMeshConnections.getCArray();
params.offMeshConCount = meshData.offMeshConnections.size()/6;
params.offMeshConRad = meshData.offMeshConnectionRads.getCArray();
params.offMeshConDir = meshData.offMeshConnectionDirs.getCArray();
params.offMeshConAreas = meshData.offMeshConnectionsAreas.getCArray();
params.offMeshConFlags = meshData.offMeshConnectionsFlags.getCArray();
params.walkableHeight = BASE_UNIT_DIM*config.walkableHeight; // agent height
params.walkableRadius = BASE_UNIT_DIM*config.walkableRadius; // agent radius
params.walkableClimb = BASE_UNIT_DIM*config.walkableClimb; // keep less that walkableHeight (aka agent height)!
params.tileX = (((bmin[0] + bmax[0]) / 2) - navMesh->getParams()->orig[0]) / GRID_SIZE;
params.tileY = (((bmin[2] + bmax[2]) / 2) - navMesh->getParams()->orig[2]) / GRID_SIZE;
rcVcopy(params.bmin, bmin);
rcVcopy(params.bmax, bmax);
params.cs = config.cs;
params.ch = config.ch;
params.tileLayer = 0;
params.buildBvTree = true;
// will hold final navmesh
unsigned char* navData = NULL;
int navDataSize = 0;
do
{
// these values are checked within dtCreateNavMeshData - handle them here
// so we have a clear error message
if (params.nvp > DT_VERTS_PER_POLYGON)
{
printf("%s Invalid verts-per-polygon value! \n", tileString.c_str());
break;
}
if (params.vertCount >= 0xffff)
{
printf("%s Too many vertices! \n", tileString.c_str());
break;
}
if (!params.vertCount || !params.verts)
{
// occurs mostly when adjacent tiles have models
// loaded but those models don't span into this tile
// message is an annoyance
//printf("%sNo vertices to build tile! \n", tileString.c_str());
break;
}
if (!params.polyCount || !params.polys ||
TILES_PER_MAP*TILES_PER_MAP == 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("%s No polygons to build on tile! \n", tileString.c_str());
break;
}
if (!params.detailMeshes || !params.detailVerts || !params.detailTris)
{
printf("%s No detail mesh to build tile! \n", tileString.c_str());
break;
}
printf("%s Building navmesh tile...\n", tileString.c_str());
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
printf("%s Failed building navmesh tile! \n", tileString.c_str());
break;
}
dtTileRef tileRef = 0;
printf("%s Adding tile to navmesh...\n", tileString.c_str());
// DT_TILE_FREE_DATA tells detour to unallocate memory when the tile
// is removed via removeTile()
dtStatus dtResult = navMesh->addTile(navData, navDataSize, DT_TILE_FREE_DATA, 0, &tileRef);
if (!tileRef || dtResult != DT_SUCCESS)
{
printf("%s Failed adding tile to navmesh! \n", tileString.c_str());
break;
}
// file output
char fileName[255];
sprintf(fileName, "mmaps/%04u%02i%02i.mmtile", mapID, tileY, tileX);
FILE* file = fopen(fileName, "wb");
if (!file)
{
char message[1024];
sprintf(message, "[Map %04u] Failed to open %s for writing!\n", mapID, fileName);
perror(message);
navMesh->removeTile(tileRef, NULL, NULL);
break;
}
printf("%s Writing to file...\n", tileString.c_str());
// write header
MmapTileHeader header;
header.usesLiquids = m_terrainBuilder->usesLiquids();
header.size = uint32(navDataSize);
fwrite(&header, sizeof(MmapTileHeader), 1, file);
// write data
fwrite(navData, sizeof(unsigned char), navDataSize, file);
fclose(file);
// now that tile is written to disk, we can unload it
navMesh->removeTile(tileRef, NULL, NULL);
}
while (0);
if (m_debugOutput)
{
// restore padding so that the debug visualization is correct
for (int i = 0; i < iv.polyMesh->nverts; ++i)
{
unsigned short* v = &iv.polyMesh->verts[i*3];
v[0] += (unsigned short)config.borderSize;
v[2] += (unsigned short)config.borderSize;
}
iv.generateObjFile(mapID, tileX, tileY, meshData);
iv.writeIV(mapID, tileX, tileY);
}
}
bool RecastInterface::buildNavMesh(InputGeometry* inputGeom)
{
//Step 1 : Initialize build configuration
//Start the timers.
#ifdef _DEBUG
std::cout << "NavMesh build started." << std::endl;
unsigned long start = Ogre::Root::getSingleton().getTimer()->getMilliseconds();
unsigned long end = 0;
#endif
//Step 2 : Rasterize input polygon soup
//InputGeometry* input = inputGeom; WTF? Is this necessary?
rcVcopy(_config.bmin, inputGeom->getMeshBoundsMin());
rcVcopy(_config.bmax, inputGeom->getMeshBoundsMax());
rcCalcGridSize(_config.bmin,_config.bmax,_config.cs,&_config.width,&_config.height);
int numVerts = inputGeom->getVertexCount();
int numTris = inputGeom->getTriangleCount();
#ifdef _DEBUG
Ogre::Vector3 min,max;
Utility::floatPtr_toVector3(inputGeom->getMeshBoundsMin(),min);
Utility::floatPtr_toVector3(inputGeom->getMeshBoundsMax(),max);
std::cout << "Bounds: min=" << min << " max=" << max << std::endl;
std::cout << "Building navmesh" << std::endl;
std::cout << " - " << _config.width << " x " << _config.height << std::endl;
std::cout << " - " << numVerts / 1000.0f << "K vertices, ";
std::cout << numTris / 1000.0f << "K triangles" << std::endl;
//_printConfig();
#endif
_solid = rcAllocHeightfield();
if(!_solid)
{
std::cout << "Error! Out of memory needed for '_solid'." << std::endl;
return false;
}
if(!rcCreateHeightfield(_context,*_solid,
_config.width,_config.height,
_config.bmin,_config.bmax,
_config.cs,_config.ch))
{
std::cout << "Error! Couldn't create heightfield, try higher cellSize and cellHeight values." << std::endl;
return false;
}
//holds triangle area types
_triangleAreas = new unsigned char[numTris];
if(!_triangleAreas)
{
std::cout << "Error! Out of memory '_triangleAreas'([" << numTris << "])" << std::endl;
return false;
}
//find triangles that are walkable in slope and rasterize them
memset(_triangleAreas,0,numTris * sizeof(unsigned char));
rcMarkWalkableTriangles(_context,_config.walkableSlopeAngle,
inputGeom->getVertices(),inputGeom->getVertexCount(),
inputGeom->getTriangles(),inputGeom->getTriangleCount(),
_triangleAreas);
rcRasterizeTriangles(_context,inputGeom->getVertices(),inputGeom->getVertexCount(),
inputGeom->getTriangles(),_triangleAreas,
inputGeom->getTriangleCount(),*_solid,_config.walkableClimb);
//I know I put this option in the params, but...
if(!_recastParams.getKeepIntermediateResults())
{
delete[] _triangleAreas;
_triangleAreas = nullptr;
}
//Step 3 : Filter walkables surfaces
//Initial pass of filtering to remove unwanted overhangs caused
//by the conservative rasterization.
//Also filters spans where the character can't stand.
rcFilterLowHangingWalkableObstacles(_context,_config.walkableClimb,*_solid);
rcFilterLedgeSpans(_context,_config.walkableHeight,_config.walkableClimb,*_solid);
rcFilterWalkableLowHeightSpans(_context,_config.walkableHeight,*_solid);
//Step 4 : Partition walkable surface to simple regions
//Compact the heightfield so that it is faster to handle from now on.
_compactHeightfield = rcAllocCompactHeightfield();
if(!_compactHeightfield)
{
std::cout << "Error! Out of memory '_compactHeightfield'" << std::endl;
return false;
}
if(!rcBuildCompactHeightfield(_context,
_config.walkableHeight,_config.walkableClimb,
*_solid,*_compactHeightfield))
{
std::cout << "Error! BuildNav - Could not build compact data." << std::endl;
return false;
}
if(!_recastParams.getKeepIntermediateResults())
{
rcFreeHeightField(_solid);
_solid = nullptr;
}
//Erode walkable area by agent radius
if(!rcErodeWalkableArea(_context,_config.walkableRadius,*_compactHeightfield))
{
std::cout << "Error! BuildNav - Could not erode walkable areas." << std::endl;
return false;
}
//Prepare for region partitioning, generate distance field
if(!rcBuildDistanceField(_context,*_compactHeightfield))
{
std::cout << "Error! BuildNav - Could not build distance field." << std::endl;
return false;
}
//Partition the walkable surface into simple regions w/o holes
if(!rcBuildRegions(_context,*_compactHeightfield,
_config.borderSize,
_config.minRegionArea,_config.mergeRegionArea))
{
std::cout << "Error! BuildNav - Could not build regions." << std::endl;
return false;
}
//Step 5 : Trace and simplify region contours.
//create contours
_contourSet = rcAllocContourSet();
if(!_contourSet)
{
std::cout << "Error! BuildNav - Out of memory '_contourSet'" << std::endl;
return false;
}
if(!rcBuildContours(_context,*_compactHeightfield,_config.maxSimplificationError,_config.maxEdgeLen,*_contourSet))
{
std::cout << "Error! BuildNav - Could not create contours." << std::endl;
return false;
}
if(_contourSet->nconts == 0)
{
//Check this thread for details on solving these:
//http://groups.google.com/group/recastnavigation/browse_thread/thread/a6fbd509859a12c8
std::cout << "Error! BuildNav - RecastNav created no contours!" << std::endl;
std::cout << _compactHeightfield->spanCount << std::endl;
}
//Step 6 : Build polygons mesh from contours
//Build polygon navmesh from the contours
_polyMesh = rcAllocPolyMesh();
if(!_polyMesh)
{
std::cout << "Error! Out of memory '_polyMesh'." << std::endl;
return false;
}
if(!rcBuildPolyMesh(_context,*_contourSet,_config.maxVertsPerPoly,*_polyMesh))
{
std::cout << "Error! BuildNav - Could not triangulate contours." << std::endl;
}
//Step 7 : Create detail mesh which allows access to approximate height on each polygon.
_detailMesh = rcAllocPolyMeshDetail();
if(!_detailMesh)
{
std::cout << "Error! Out of memory '_detailMesh'." << std::endl;
return false;
}
if(!rcBuildPolyMeshDetail(_context,
*_polyMesh,*_compactHeightfield,
_config.detailSampleDist,_config.detailSampleMaxError,
*_detailMesh))
{
std::cout << "Error! BuildNav - Could not build detail mesh." << std::endl;
return false;
}
if(!_recastParams.getKeepIntermediateResults())
{
rcFreeCompactHeightfield(_compactHeightfield);
_compactHeightfield = nullptr;
rcFreeContourSet(_contourSet);
_contourSet = nullptr;
}
//Recast navmesh is finished!
#ifdef _DEBUG
end = Ogre::Root::getSingletonPtr()->getTimer()->getMilliseconds();
std::cout << "Navmesh build finished." << std::endl;
std::cout << " - Time elapsed:" << end - start << "ms" << std::endl;
#endif
return true;
}
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;
}
/*
* Tries to load vmap and tilemap for a gridtile and creates a navmesh for it.
*
*/
bool
ModelContainerView::generateMoveMapForTile (int pMapId, int x, int y)
{
bool result = iVMapManager.loadMap (gVMapDataDir.c_str (), pMapId, x, y) == VMAP_LOAD_RESULT_OK;
if (result == VMAP_LOAD_RESULT_OK)
{
//VMap loaded. Add data from vmap to global Triangle-Array
parseVMap (pMapId, x, y);
}
// Add data from Height-Map to global Triangle-Array
generateHeightMap(pMapId,x,y);
// We will now add all triangles inside the given zone to the vectormap.
// We could also do additional checks here.
double x_max = (32-x)*SIZE_OF_GRIDS + 50;
double y_max = (32-y)*SIZE_OF_GRIDS + 50;
double x_min = x_max - SIZE_OF_GRIDS - 100;
double y_min = y_max - SIZE_OF_GRIDS - 100;
Vector3 low = Vector3(x_min,y_min,-inf());
Vector3 high = Vector3(x_max,y_max,inf());
AABox checkBox = AABox(low,high);
AABox check;
Triangle t;
//each triangle has mangos format.
for (int i = 0; i < globalTriangleArray.size(); i++) {
t = globalTriangleArray[i];
t.getBounds(check);
if (checkBox.contains(check)) {
// Write it down in detour format.
iGlobArray.append(t.vertex(0).y,t.vertex(0).z,t.vertex(0).x);
iGlobArray.append(t.vertex(1).y,t.vertex(1).z,t.vertex(1).x);
iGlobArray.append(t.vertex(2).y,t.vertex(2).z,t.vertex(2).x);
}
}
if (iGlobArray.size() == 0) {
printf("No models - check your mmap.datadir in your config");
return true;
}
if(gMakeObjFile)
debugGenerateObjFile(); // create obj file for Recast Demo viewer
//return true;
float bmin[3], bmax[3];
/*
* The format looks like this
* Verticle = float[3]
* Triangle = Verticle[3]
* So there are
* array.size() floats
* that means there are
* nverts = array.size()/3 Verticles
* that means there are
* ntris = nverts/3
*/
//array/3 verticles
const int nverts = iGlobArray.size()/3; // because 1 vert is 3 float.
// -> vert = float[3]
const float* verts = iGlobArray.getCArray();
rcCalcBounds(verts,nverts,bmin,bmax);
// nverts/3 triangles
// -> Triangle = vert[3] = float[9]
int* tris = new int[nverts];// because 1 triangle is 3 verts
for (int i = 0; i< nverts; i++)
tris[i] = i;
/* tris[i] = 1,2,3;4,5,6;7,8,9;
*
*/
const int ntris = (nverts/3);
rcConfig m_cfg;
//
// Step 1. Initialize build config.
//
// Init build configuration from GUI
memset(&m_cfg, 0, sizeof(m_cfg));
// Change config settings here!
m_cfg.cs = 0.3f;
m_cfg.ch = 0.2f;
m_cfg.walkableSlopeAngle = 50.0f;
m_cfg.walkableHeight = 10;
m_cfg.walkableClimb = 4;
m_cfg.walkableRadius = 2;
m_cfg.maxEdgeLen = (int)(12 / 0.3f);
m_cfg.maxSimplificationError = 1.3f;
m_cfg.minRegionSize = (int)rcSqr(50);
m_cfg.mergeRegionSize = (int)rcSqr(20);
m_cfg.maxVertsPerPoly = (int)6;
m_cfg.detailSampleDist = 1.8f;
m_cfg.detailSampleMaxError = 0.2f * 1;
bool m_keepInterResults = false;
printf("CellSize : %.2f\n",m_cfg.cs);
printf("CellHeight : %.2f\n",m_cfg.ch);
printf("WalkableSlope : %.2f\n",m_cfg.walkableSlopeAngle);
printf("WalkableHeight : %i\n",m_cfg.walkableHeight);
printf("walkableClimb : %i\n",m_cfg.walkableClimb);
printf("walkableRadius : %i\n",m_cfg.walkableRadius);
printf("maxEdgeLen : %i\n",m_cfg.maxEdgeLen);
printf("maxSimplific.Er.: %.2f\n",m_cfg.maxSimplificationError);
printf("minRegionSize : %i\n",m_cfg.minRegionSize);
printf("mergedRegSize : %i\n",m_cfg.mergeRegionSize);
printf("maxVertsPerPoly : %i\n",m_cfg.maxVertsPerPoly);
printf("detailSampledist: %.2f\n",m_cfg.detailSampleDist);
printf("det.Samp.max.err: %.2f\n",m_cfg.detailSampleMaxError);
// Set the area where the navigation will be build.
// Here the bounds of the input mesh are used, but the
// area could be specified by an user defined box, etc.
vcopy(m_cfg.bmin, bmin);
vcopy(m_cfg.bmax, bmax);
rcCalcGridSize(m_cfg.bmin, m_cfg.bmax, m_cfg.cs, &m_cfg.width, &m_cfg.height);
//
// Step 2. Rasterize input polygon soup.
//
// Allocate voxel heighfield where we rasterize our input data to.
rcHeightfield* m_solid = new rcHeightfield;
if (!m_solid)
{
printf("buildNavigation: Out of memory 'solid'.\n");
return false;
}
if (!rcCreateHeightfield(*m_solid, m_cfg.width, m_cfg.height, m_cfg.bmin, m_cfg.bmax, m_cfg.cs, m_cfg.ch))
{
printf("buildNavigation: Could not create solid heightfield.\n");
return false;
}
// Allocate array that can hold triangle flags.
// If you have multiple meshes you need to process, allocate
// and array which can hold the max number of triangles you need to process.
unsigned char* m_triflags = new unsigned char[ntris];
if (!m_triflags)
{
printf("buildNavigation: Out of memory 'triangleFlags' (%d).\n", ntris);
return false;
}
// Find triangles which are walkable based on their slope and rasterize them.
// If your input data is multiple meshes, you can transform them here, calculate
// the flags for each of the meshes and rasterize them.
memset(m_triflags, 0, ntris*sizeof(unsigned char));
rcMarkWalkableTriangles(m_cfg.walkableSlopeAngle, verts, nverts, tris, ntris, m_triflags);
rcRasterizeTriangles(verts, nverts, tris, m_triflags, ntris, *m_solid, m_cfg.walkableClimb);
// should delete [] verts? - probably not, this is just pointer to data in a G3D Array
// should delete [] tris?
if (!m_keepInterResults)
{
delete [] m_triflags;
m_triflags = 0;
}
//
// Step 3. Filter walkables surfaces.
//
// Once all geoemtry 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(m_cfg.walkableClimb, *m_solid);
rcFilterLedgeSpans(m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid);
rcFilterWalkableLowHeightSpans(m_cfg.walkableHeight, *m_solid);
//
// Step 4. Partition walkable surface to simple regions.
//
// 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.
rcCompactHeightfield* m_chf = new rcCompactHeightfield;
if (!m_chf)
{
printf("buildNavigation: Out of memory 'chf'.\n");
return false;
}
if (!rcBuildCompactHeightfield(m_cfg.walkableHeight, m_cfg.walkableClimb, RC_WALKABLE, *m_solid, *m_chf))
{
printf( "buildNavigation: Could not build compact data.\n");
return false;
}
if (!m_keepInterResults)
{
delete m_solid;
m_solid = 0;
}
// Erode the walkable area by agent radius.
if (!rcErodeArea(RC_WALKABLE_AREA, m_cfg.walkableRadius, *m_chf))
{
printf("buildNavigation: Could not erode.\n");
return false;
}
// (Optional) Mark areas.
//const ConvexVolume* vols = m_geom->getConvexVolumes();
//for (int i = 0; i < m_geom->getConvexVolumeCount(); ++i)
// rcMarkConvexPolyArea(vols[i].verts, vols[i].nverts, vols[i].hmin, vols[i].hmax, (unsigned char)vols[i].area, *m_chf);
// Prepare for region partitioning, by calculating distance field along the walkable surface.
if (!rcBuildDistanceField(*m_chf))
{
printf("buildNavigation: Could not build distance field.\n");
return false;
}
// Partition the walkable surface into simple regions without holes.
if (!rcBuildRegions(*m_chf, m_cfg.borderSize, m_cfg.minRegionSize, m_cfg.mergeRegionSize))
{
printf("buildNavigation: Could not build regions.\n");
}
//
// Step 5. Trace and simplify region contours.
//
// Create contours.
rcContourSet* m_cset = new rcContourSet;
if (!m_cset)
{
printf("buildNavigation: Out of memory 'cset'.\n");
return false;
}
if (!rcBuildContours(*m_chf, m_cfg.maxSimplificationError, m_cfg.maxEdgeLen, *m_cset))
{
printf("buildNavigation: Could not create contours.\n");
return false;
}
//
// Step 6. Build polygons mesh from contours.
//
// Build polygon navmesh from the contours.
rcPolyMesh* m_pmesh = new rcPolyMesh;
if (!m_pmesh)
{
printf("buildNavigation: Out of memory 'pmesh'.\n");
return false;
}
if (!rcBuildPolyMesh(*m_cset, m_cfg.maxVertsPerPoly, *m_pmesh))
{
printf( "buildNavigation: Could not triangulate contours.\n");
return false;
}
//
// Step 7. Create detail mesh which allows to access approximate height on each polygon.
//
rcPolyMeshDetail* m_dmesh = new rcPolyMeshDetail;
if (!m_dmesh)
{
printf("buildNavigation: Out of memory 'pmdtl'.\n");
return false;
}
if (!rcBuildPolyMeshDetail(*m_pmesh, *m_chf, m_cfg.detailSampleDist, m_cfg.detailSampleMaxError, *m_dmesh))
{
printf("buildNavigation: Could not build detail mesh.\n");
}
if (!m_keepInterResults)
{
delete m_chf;
m_chf = 0;
delete m_cset;
m_cset = 0;
}
// At this point the navigation mesh data is ready, you can access it from m_pmesh.
// See duDebugDrawPolyMesh or dtCreateNavMeshData as examples how to access the data.
//
// (Optional) Step 8. Create Detour data from Recast poly mesh.
//
// The GUI may allow more max points per polygon than Detour can handle.
// Only build the detour navmesh if we do not exceed the limit.
if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON)
{
unsigned char* navData = 0;
int navDataSize = 0;
// Update poly flags from areas.
for (int i = 0; i < m_pmesh->npolys; ++i)
{
// for now all generated navmesh is walkable by everyone.
// else there will be no pathfinding at all!
m_pmesh->flags[i] = RC_WALKABLE_AREA;
}
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.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 = 0;
params.offMeshConRad = 0;
params.offMeshConDir = 0;
params.offMeshConAreas = 0;
params.offMeshConFlags = 0;
params.offMeshConCount = 0;
params.walkableHeight = 2.0f;
params.walkableRadius = 0.6f;
params.walkableClimb = 0.9f;
vcopy(params.bmin, m_pmesh->bmin);
vcopy(params.bmax, m_pmesh->bmax);
params.cs = m_cfg.cs;
params.ch = m_cfg.ch;
printf("vertcount : %05u\n",params.vertCount);
printf("polycount : %05u\n",params.polyCount);
printf("detailVertsCount: %05u\n",params.detailVertsCount);
printf("detailTriCount : %05u\n",params.detailTriCount);
printf("walkableClimb : %.2f\n",params.walkableClimb);
printf("walkableRadius : %.2f\n",params.walkableRadius);
printf("walkableHeight : %.2f\n",params.walkableHeight);
if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize))
{
printf("Could not build Detour navmesh.\n");
return false;
}
// navData now contains the MoveMap
printf("Generated Navigation Mesh! Size: %i bytes/ %i kB / %i MB\n",navDataSize,navDataSize/1024,navDataSize/(1024*1024));
char tmp[14];
sprintf(tmp, "%03u%02u%02u.mmap",iMap,ix,iy);
std::string savefilepath = gMMapDataDir + "/" + tmp;
ofstream inf( savefilepath.c_str(),ofstream::binary );
if( inf )
{
inf.write( (char*)( &navData[0] ), navDataSize ) ;
}
printf("MoveMap saved under %s\n", savefilepath.c_str());
delete [] navData;
}
// debugLoadNavMesh();
return (result);
}