Integrating recast & detour to project

[TheExeQ]

Hello! Im trying to integrate rc and dt to my project however im a bit stuck trying to figure out how to use it. I have the library itself included in my project but im not sure how to actually use it.
I've read the README where it says "If you are new to Recast & Detour, check out Sample_SoloMesh.cpp to get started with building navmeshes and NavMeshTesterTool.cpp to see how Detour can be used to find paths."

I have checked out both of them but there is just so much so i don't know what is necessery for it to work. Like i tried copying the Sample_SoloMesh to my project but then it wanted InputGeom and Sample which needed SampleInterfaces etc.. idk how much of this is needed to just get the core to work.

Like i already have a modelloader from which i can get verts, indices, normals etc.. Can i use this info to use recast or do i actually need InputGeom and everything else?

EDIT: I figured it out after a while of experimenting :P

[grahamboree]

Hi! I'm in the process of writing up a more detailed intro guide to Recast, but the gist of it is:

Like i already have a modelloader from which i can get verts, indices, normals etc.. Can i use this info to use recast or do i actually need InputGeom and everything else?

Yes, you can use your modelloader! You likely don't need 95% of what's in RecastDemo.

The demo code tries to be a super full featured demo that uses every feature Recast has to offer, and keep intermediate results so you can examine them in the UI, and track build timing information. There's a lot of code in there you probably don't need.

The relevant code is probably just these lines in Sample_SoloMesh::handleBuild:

recastnavigation/RecastDemo/Source/Sample_SoloMesh.cpp

Lines 388 to 641 in d0b2ed8

	//
	// 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);
	if (!rcRasterizeTriangles(m_ctx, verts, nverts, tris, m_triareas, ntris, *m_solid, m_cfg.walkableClimb))
	{
	m_ctx->log(RC_LOG_ERROR, "buildNavigation: Could not rasterize triangles.");
	return false;
	}
	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.
	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);
	//
	// 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;
	}

For just building a navmesh you essentially need to call the following functions:

rcCalcGridSize // Figure out how big the raster voxel grid will be

// Create a voxel heightfield
rcAllocHeightfield
rcCreateHeightfield
rcMarkWalkableTriangles
rcRasterizeTriangles

// Clean up the rasterized data and filter out non-walkable areas.
rcFilterLowHangingWalkableObstacles
rcFilterLedgeSpans
rcFilterWalkableLowHeightSpans

// Create a compact heightfield
rcAllocCompactHeightfield
rcBuildCompactHeightfield

// Further refine the voxel representation
rcErodeWalkableArea
rcBuildDistanceField
rcBuildRegions

// Create a set of polygon contours
rcAllocContourSet
rcBuildContours

// Triangulate polygons from the contours
rcAllocPolyMesh
rcBuildPolyMesh

// Build a navmesh from the triangulated polygons
rcAllocPolyMeshDetail
rcBuildPolyMeshDetail

// Cleanup
rcFreeHeightField
rcFreeCompactHeightfield
rcFreeContourSet

There's a lot happening here, but that's by design. It's extremely common to want to tie into the navmesh building process at certain points to add things like spatial annotations, cover points, etc. so Recast airs on the side of being overly verbose, with the goal of being easily customizable. Long term I'd like to add a higher-level API that's a bit simpler to use, but for now this is about as concise as it gets.

[alishahb]

It would be great to have documentation, so we could improve on our settings with better understanding the config!

[SigmaKlim]

Hi, I am new to rc&dt. I am trying to integrate it into my project. I have transported code from handleBuild in RecastDemo. Everything there seems alright. Now I am trying to debug draw navmesh. I am inspecting handleRender in RecastDemo and I can't understand much there. Any tips or words of advice maybe? I woder why the devs of recastnavigation did not proide a simpler interface for their API....

[grahamboree]

Hi! The demo classes draw the navmesh through calls to functions that are defined in DebugUtils. The drawing code isn't terribly complex but the demo classes have a lot of options that let you draw the intermediate step data, as well as some setup for drawing the input mesh, etc. If you want to just draw a navmesh, you can call duDebugDrawNavMeshPolysWithFlags. There are other features like offmesh connections that require similar debug draw calls.
While a simple API is certainly our goal, we're also making a pretty industrial-strength tool here and customization is most important to us. I agree there should be a layer on top of the API currently provided that's more beginner-friendly, but we also want to provide all the options to those people integrating this into complex engines and games. It's a tricky balance but a high-level API is on our roadmap. You're welcome to help out with that if you're passionate about it :)