R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Recast: move and rename render flags

Browse Source 
Improve code readability.
This commit is contained in:
Kawe Mazidjatari 2024-10-25 00:39:35 +02:00
parent d1c5228d23
commit 349f7bd3b9
8 changed files with 154 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
src/naveditor/Editor.cpp
View File

@ -140,8 +140,8 @@ Editor::Editor() :
m_navQuery(0),
m_crowd(0),
m_navMeshDrawFlags(
DU_DRAWNAVMESH_OFFMESHCONS|DU_DRAWNAVMESH_WITH_CLOSED_LIST|
DU_DRAWNAVMESH_POLY_FACES|DU_DRAWNAVMESH_POLY_BOUNDS_OUTER|DU_DRAWNAVMESH_ALPHA),
DU_DRAW_DETOURMESH_OFFMESHCONS|DU_DRAW_DETOURMESH_WITH_CLOSED_LIST|
DU_DRAW_DETOURMESH_POLY_FACES|DU_DRAW_DETOURMESH_POLY_BOUNDS_OUTER|DU_DRAW_DETOURMESH_ALPHA),
m_filterLowHangingObstacles(true),
m_filterLedgeSpans(true),
m_filterWalkableLowHeightSpans(true),
@ -921,102 +921,102 @@ void Editor::renderDetourDebugMenu()
{
ImGui::Text("Detour Render Options");
bool isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_OFFMESHCONS);
bool isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_OFFMESHCONS);
if (ImGui::Checkbox("Off-Mesh Connections", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_OFFMESHCONS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_OFFMESHCONS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_QUERY_NODES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_QUERY_NODES);
if (ImGui::Checkbox("Query Nodes", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_QUERY_NODES);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_QUERY_NODES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_BVTREE);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_BVTREE);
if (ImGui::Checkbox("BVTree", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_BVTREE);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_BVTREE);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_PORTALS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_PORTALS);
if (ImGui::Checkbox("Portals", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_PORTALS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_PORTALS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_WITH_CLOSED_LIST);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_WITH_CLOSED_LIST);
if (ImGui::Checkbox("Closed List", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_WITH_CLOSED_LIST);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_WITH_CLOSED_LIST);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_TILE_COLORS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_TILE_COLORS);
if (ImGui::Checkbox("Tile ID Colors", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_TILE_COLORS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TILE_COLORS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_TILE_BOUNDS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_TILE_BOUNDS);
if (ImGui::Checkbox("Tile Bounds", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_TILE_BOUNDS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TILE_BOUNDS);
#if DT_NAVMESH_SET_VERSION >= 8
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_TILE_CELLS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_TILE_CELLS);
if (ImGui::Checkbox("Tile Cells", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_TILE_CELLS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TILE_CELLS);
#endif
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_FACES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_FACES);
if (ImGui::Checkbox("Poly Faces", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_FACES);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_FACES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_EDGES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_EDGES);
if (ImGui::Checkbox("Poly Edges", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_EDGES);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_EDGES);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_VERTS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_VERTS);
if (ImGui::Checkbox("Poly Verts", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_VERTS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_VERTS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_BOUNDS_INNER);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_BOUNDS_INNER);
if (ImGui::Checkbox("Inner Poly Boundaries", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_BOUNDS_INNER);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_BOUNDS_INNER);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_BOUNDS_OUTER);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_BOUNDS_OUTER);
if (ImGui::Checkbox("Outer Poly Boundaries", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_BOUNDS_OUTER);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_BOUNDS_OUTER);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_CENTERS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_CENTERS);
if (ImGui::Checkbox("Poly Centers", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_CENTERS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_CENTERS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_POLY_GROUPS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_POLY_GROUPS);
if (ImGui::Checkbox("Poly Group Colors", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_POLY_GROUPS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_POLY_GROUPS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_LEDGE_SPANS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_LEDGE_SPANS);
if (ImGui::Checkbox("Ledge Spans", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_LEDGE_SPANS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_LEDGE_SPANS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_DEPTH_MASK);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_DEPTH_MASK);
if (ImGui::Checkbox("Depth Mask", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_DEPTH_MASK);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_DEPTH_MASK);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_ALPHA);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_ALPHA);
if (ImGui::Checkbox("Transparency", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_ALPHA);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_ALPHA);
isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_TRAVERSE_LINKS);
isEnabled = (getNavMeshDrawFlags() & DU_DRAW_DETOURMESH_TRAVERSE_LINKS);
if (ImGui::Checkbox("Traverse Links", &isEnabled))
toggleNavMeshDrawFlag(DU_DRAWNAVMESH_TRAVERSE_LINKS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TRAVERSE_LINKS);
if (isEnabled && m_navMesh) // Supplemental options only available with a valid navmesh!
{

100
src/naveditor/Editor_Common.cpp
View File

@ -120,7 +120,7 @@ Editor_StaticTileMeshCommon::Editor_StaticTileMeshCommon()
, m_cset(nullptr)
, m_pmesh(nullptr)
, m_dmesh(nullptr)
, m_tileMeshDrawFlags(TM_DRAWFLAGS_INPUT_MESH|TM_DRAWFLAGS_NAVMESH)
, m_tileMeshDrawFlags(DU_DRAW_RECASTMESH_INPUT_MESH|DU_DRAW_RECASTMESH_NAVMESH)
, m_tileCol(duRGBA(0, 0, 0, 64))
, m_totalBuildTimeMs(0.0f)
, m_drawActiveTile(false)
@ -157,13 +157,13 @@ void Editor_StaticTileMeshCommon::renderRecastDebugMenu()
{
ImGui::Text("Recast Render Options");
bool isEnabled = m_tileMeshDrawFlags & TM_DRAWFLAGS_INPUT_MESH;
bool isEnabled = m_tileMeshDrawFlags & DU_DRAW_RECASTMESH_INPUT_MESH;
// This should always be available, since if we load a large mesh we want to
// be able to toggle this off to save on performance. The renderer has to be
// moved to its own thread to solve this issue.
if (ImGui::Checkbox("Input Mesh", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_INPUT_MESH);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_INPUT_MESH);
// Check which modes are valid.
//const bool hasNavMesh =m_navMesh != 0;
@ -172,91 +172,91 @@ void Editor_StaticTileMeshCommon::renderRecastDebugMenu()
const bool hasSolid = m_solid != 0;
const bool hasDMesh = m_dmesh != 0;
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_NAVMESH;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_NAVMESH;
//ImGui::BeginDisabled(!hasNavMesh);
if (ImGui::Checkbox("NavMesh", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_NAVMESH);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_NAVMESH);
//ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_VOXELS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_VOXELS;
ImGui::BeginDisabled(!hasSolid);
if (ImGui::Checkbox("Voxels", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_VOXELS);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_VOXELS);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_VOXELS_WALKABLE;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_VOXELS_WALKABLE;
ImGui::BeginDisabled(!hasSolid);
if (ImGui::Checkbox("Walkable Voxels", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_VOXELS_WALKABLE);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_VOXELS_WALKABLE);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_COMPACT;
ImGui::BeginDisabled(!hasChf);
if (ImGui::Checkbox("Compact", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_COMPACT);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_COMPACT);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT_DISTANCE;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_COMPACT_DISTANCE;
ImGui::BeginDisabled(!hasChf);
if (ImGui::Checkbox("Compact Distance", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_COMPACT_DISTANCE);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_COMPACT_DISTANCE);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT_REGIONS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_COMPACT_REGIONS;
ImGui::BeginDisabled(!hasChf);
if (ImGui::Checkbox("Compact Regions", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_COMPACT_REGIONS);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_COMPACT_REGIONS);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_REGION_CONNECTIONS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_REGION_CONNECTIONS;
ImGui::BeginDisabled(!hasCset);
if (ImGui::Checkbox("Region Connections", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_REGION_CONNECTIONS);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_REGION_CONNECTIONS);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_RAW_CONTOURS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_RAW_CONTOURS;
ImGui::BeginDisabled(!hasCset);
if (ImGui::Checkbox("Raw Contours", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_RAW_CONTOURS);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_RAW_CONTOURS);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_CONTOURS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_CONTOURS;
ImGui::BeginDisabled(!hasCset);
if (ImGui::Checkbox("Contours", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_CONTOURS);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_CONTOURS);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_POLYMESH;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_POLYMESH;
ImGui::BeginDisabled(!hasDMesh);
if (ImGui::Checkbox("Poly Mesh", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_POLYMESH);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_POLYMESH);
ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_POLYMESH_DETAIL;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_POLYMESH_DETAIL;
ImGui::BeginDisabled(!hasDMesh);
if (ImGui::Checkbox("Poly Mesh Detail", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_POLYMESH_DETAIL);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_POLYMESH_DETAIL);
ImGui::EndDisabled();
@ -278,7 +278,7 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
const float texScale = 1.0f / (m_cellSize * 10.0f);
// Draw input mesh
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_INPUT_MESH)
if (getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_INPUT_MESH)
EditorCommon_DrawInputGeometry(&m_dd, m_geom, m_agentMaxSlope, texScale);
glDepthMask(GL_FALSE);
@ -305,7 +305,7 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
if (m_navMesh && m_navQuery)
{
if (m_tileMeshDrawFlags & TM_DRAWFLAGS_NAVMESH)
if (m_tileMeshDrawFlags & DU_DRAW_RECASTMESH_NAVMESH)
{
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, detourDrawOffset, m_navMeshDrawFlags, m_traverseLinkDrawParams);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, DT_POLYFLAGS_DISABLED, detourDrawOffset, detourDrawFlags, duRGBA(0, 0, 0, 128));
@ -316,24 +316,24 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
if (m_chf)
{
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT)
if (recastDrawFlags & DU_DRAW_RECASTMESH_COMPACT)
duDebugDrawCompactHeightfieldSolid(&m_dd, *m_chf, recastDrawOffset);
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT_DISTANCE)
if (recastDrawFlags & DU_DRAW_RECASTMESH_COMPACT_DISTANCE)
duDebugDrawCompactHeightfieldDistance(&m_dd, *m_chf, recastDrawOffset);
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT_REGIONS)
if (recastDrawFlags & DU_DRAW_RECASTMESH_COMPACT_REGIONS)
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf, recastDrawOffset);
}
if (m_solid)
{
if (recastDrawFlags & TM_DRAWFLAGS_VOXELS)
if (recastDrawFlags & DU_DRAW_RECASTMESH_VOXELS)
{
glEnable(GL_FOG);
duDebugDrawHeightfieldSolid(&m_dd, *m_solid, recastDrawOffset);
glDisable(GL_FOG);
}
if (recastDrawFlags & TM_DRAWFLAGS_VOXELS_WALKABLE)
if (recastDrawFlags & DU_DRAW_RECASTMESH_VOXELS_WALKABLE)
{
glEnable(GL_FOG);
duDebugDrawHeightfieldWalkable(&m_dd, *m_solid, recastDrawOffset);
@ -343,13 +343,13 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
if (m_cset)
{
if (recastDrawFlags & TM_DRAWFLAGS_RAW_CONTOURS)
if (recastDrawFlags & DU_DRAW_RECASTMESH_RAW_CONTOURS)
{
glDepthMask(GL_FALSE);
duDebugDrawRawContours(&m_dd, *m_cset, recastDrawOffset);
glDepthMask(GL_TRUE);
}
if (recastDrawFlags & TM_DRAWFLAGS_CONTOURS)
if (recastDrawFlags & DU_DRAW_RECASTMESH_CONTOURS)
{
glDepthMask(GL_FALSE);
duDebugDrawContours(&m_dd, *m_cset, recastDrawOffset);
@ -358,7 +358,7 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
}
if ((m_chf &&m_cset) &&
(recastDrawFlags & TM_DRAWFLAGS_REGION_CONNECTIONS))
(recastDrawFlags & DU_DRAW_RECASTMESH_REGION_CONNECTIONS))
{
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf, recastDrawOffset);
@ -367,14 +367,14 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
glDepthMask(GL_TRUE);
}
if (m_pmesh && (recastDrawFlags & TM_DRAWFLAGS_POLYMESH))
if (m_pmesh && (recastDrawFlags & DU_DRAW_RECASTMESH_POLYMESH))
{
glDepthMask(GL_FALSE);
duDebugDrawPolyMesh(&m_dd, *m_pmesh, recastDrawOffset);
glDepthMask(GL_TRUE);
}
if (m_dmesh && (recastDrawFlags & TM_DRAWFLAGS_POLYMESH_DETAIL))
if (m_dmesh && (recastDrawFlags & DU_DRAW_RECASTMESH_POLYMESH_DETAIL))
{
glDepthMask(GL_FALSE);
duDebugDrawPolyMeshDetail(&m_dd, *m_dmesh, recastDrawOffset);
@ -509,7 +509,7 @@ Editor_DynamicTileMeshCommon::Editor_DynamicTileMeshCommon()
, m_cacheRawSize(0)
, m_cacheLayerCount(0)
, m_cacheBuildMemUsage(0)
, m_tileMeshDrawFlags(TM_DRAWFLAGS_INPUT_MESH|TM_DRAWFLAGS_NAVMESH)
, m_tileMeshDrawFlags(DU_DRAW_RECASTMESH_INPUT_MESH|DU_DRAW_RECASTMESH_NAVMESH)
, m_keepInterResults(false)
{
}
@ -518,33 +518,33 @@ void Editor_DynamicTileMeshCommon::renderRecastRenderOptions()
{
ImGui::Text("Recast Render Options");
bool isEnabled = m_tileMeshDrawFlags & TM_DRAWFLAGS_INPUT_MESH;
bool isEnabled = m_tileMeshDrawFlags & DU_DRAW_RECASTMESH_INPUT_MESH;
// This should always be available, since if we load a large mesh we want to
// be able to toggle this off to save on performance. The renderer has to be
// moved to its own thread to solve this issue.
if (ImGui::Checkbox("Input Mesh", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_INPUT_MESH);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_INPUT_MESH);
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_NAVMESH;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_RECASTMESH_NAVMESH;
//ImGui::BeginDisabled(!hasNavMesh);
if (ImGui::Checkbox("NavMesh", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_NAVMESH);
toggleTileMeshDrawFlag(DU_DRAW_RECASTMESH_NAVMESH);
//ImGui::EndDisabled();
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_TILE_CACHE_BOUNDS;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_DETOURMESH_TILE_CACHE_BOUNDS;
ImGui::BeginDisabled(!m_tileCache);
if (ImGui::Checkbox("Cache Bounds", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_TILE_CACHE_BOUNDS);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TILE_CACHE_BOUNDS);
isEnabled = getTileMeshDrawFlags() & TM_DRAWFLAGS_TILE_CACHE_OBSTACLES;
isEnabled = getTileMeshDrawFlags() & DU_DRAW_DETOURMESH_TILE_CACHE_OBSTACLES;
if (ImGui::Checkbox("Temp Obstacles", &isEnabled))
toggleTileMeshDrawFlag(TM_DRAWFLAGS_TILE_CACHE_OBSTACLES);
toggleNavMeshDrawFlag(DU_DRAW_DETOURMESH_TILE_CACHE_OBSTACLES);
ImGui::EndDisabled();
}
@ -562,7 +562,7 @@ void Editor_DynamicTileMeshCommon::renderTileMeshData()
const float* detourDrawOffset = getDetourDrawOffset();
// Draw input mesh
if (recastDrawFlags & TM_DRAWFLAGS_INPUT_MESH)
if (recastDrawFlags & DU_DRAW_RECASTMESH_INPUT_MESH)
EditorCommon_DrawInputGeometry(&m_dd, m_geom, m_agentMaxSlope, texScale);
// Draw bounds
@ -571,15 +571,15 @@ void Editor_DynamicTileMeshCommon::renderTileMeshData()
// Tiling grid.
EditorCommon_DrawTilingGrid(&m_dd, m_geom, m_tileSize, m_cellSize);
if (m_tileCache && recastDrawFlags & TM_DRAWFLAGS_TILE_CACHE_BOUNDS)
if (m_tileCache && detourDrawFlags & DU_DRAW_DETOURMESH_TILE_CACHE_BOUNDS)
drawTiles(&m_dd, m_tileCache, detourDrawOffset);
if (m_tileCache && recastDrawFlags & TM_DRAWFLAGS_TILE_CACHE_OBSTACLES)
if (m_tileCache && detourDrawFlags & DU_DRAW_DETOURMESH_TILE_CACHE_OBSTACLES)
drawObstacles(&m_dd, m_tileCache, detourDrawOffset);
if (m_navMesh && m_navQuery)
{
if (recastDrawFlags & TM_DRAWFLAGS_NAVMESH)
if (recastDrawFlags & DU_DRAW_RECASTMESH_NAVMESH)
{
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, detourDrawOffset, detourDrawFlags, m_traverseLinkDrawParams);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, DT_POLYFLAGS_DISABLED, detourDrawOffset, detourDrawFlags, duRGBA(0, 0, 0, 128));

2
src/naveditor/Editor_Debug.cpp
View File

@ -188,7 +188,7 @@ void Editor_Debug::handleRender()
}
if (m_navMesh)
duDebugDrawNavMesh(&m_dd, *m_navMesh, m_detourDrawOffset, DU_DRAWNAVMESH_OFFMESHCONS, m_traverseLinkDrawParams);
duDebugDrawNavMesh(&m_dd, *m_navMesh, m_detourDrawOffset, DU_DRAW_DETOURMESH_OFFMESHCONS, m_traverseLinkDrawParams);
if (m_ref && m_navMesh)
duDebugDrawNavMeshPoly(&m_dd, *m_navMesh, m_ref, m_detourDrawOffset, m_navMeshDrawFlags, duRGBA(255,0,0,128));

6
src/naveditor/OffMeshConnectionTool.cpp
View File

@ -48,10 +48,10 @@ OffMeshConnectionTool::~OffMeshConnectionTool()
{
if (m_editor)
{
if (m_oldFlags & DU_DRAWNAVMESH_OFFMESHCONS)
if (m_oldFlags & DU_DRAW_DETOURMESH_OFFMESHCONS)
{
const unsigned int curFlags = m_editor->getNavMeshDrawFlags();
m_editor->setNavMeshDrawFlags(curFlags | DU_DRAWNAVMESH_OFFMESHCONS);
m_editor->setNavMeshDrawFlags(curFlags | DU_DRAW_DETOURMESH_OFFMESHCONS);
}
}
}
@ -62,7 +62,7 @@ void OffMeshConnectionTool::init(Editor* editor)
{
m_editor = editor;
m_oldFlags = m_editor->getNavMeshDrawFlags();
m_editor->setNavMeshDrawFlags(m_oldFlags & ~DU_DRAWNAVMESH_OFFMESHCONS);
m_editor->setNavMeshDrawFlags(m_oldFlags & ~DU_DRAW_DETOURMESH_OFFMESHCONS);
const float agentRadius = m_editor->getAgentRadius();
m_radius = agentRadius;

18
src/naveditor/include/Editor_Common.h
View File

@ -21,24 +21,6 @@
#include "Recast/Include/Recast.h"
#include "NavEditor/Include/ChunkyTriMesh.h"
enum DrawTileMeshFlags
{
TM_DRAWFLAGS_INPUT_MESH = (1<<0),
TM_DRAWFLAGS_NAVMESH = (1<<1),
TM_DRAWFLAGS_VOXELS = (1<<2),
TM_DRAWFLAGS_VOXELS_WALKABLE = (1<<3),
TM_DRAWFLAGS_COMPACT = (1<<4),
TM_DRAWFLAGS_COMPACT_DISTANCE = (1<<5),
TM_DRAWFLAGS_COMPACT_REGIONS = (1<<6),
TM_DRAWFLAGS_REGION_CONNECTIONS = (1<<7),
TM_DRAWFLAGS_RAW_CONTOURS = (1<<8),
TM_DRAWFLAGS_CONTOURS = (1<<9),
TM_DRAWFLAGS_POLYMESH = (1<<10),
TM_DRAWFLAGS_POLYMESH_DETAIL = (1<<11),
TM_DRAWFLAGS_TILE_CACHE_BOUNDS = (1<<12),
TM_DRAWFLAGS_TILE_CACHE_OBSTACLES = (1<<13),
};
class Editor_StaticTileMeshCommon : public Editor
{
public:

42
src/thirdparty/recast/DebugUtils/Include/DetourDebugDraw.h vendored
View File

@ -23,27 +23,29 @@
#include "Detour/Include/DetourNavMeshQuery.h"
#include "DetourTileCache/Include/DetourTileCacheBuilder.h"
enum DrawNavMeshFlags
enum DrawDetourMeshFlags
{
DU_DRAWNAVMESH_OFFMESHCONS = 1 << 0, // Render off-mesh connections.
DU_DRAWNAVMESH_QUERY_NODES = 1 << 1, // Render navmesh query nodes.
DU_DRAWNAVMESH_BVTREE = 1 << 2, // Render BVTree.
DU_DRAWNAVMESH_PORTALS = 1 << 3, // Render portals.
DU_DRAWNAVMESH_WITH_CLOSED_LIST = 1 << 4, // Render navmesh with closed list.
DU_DRAWNAVMESH_TILE_COLORS = 1 << 5, // Render tiles colored by their ID's.
DU_DRAWNAVMESH_TILE_BOUNDS = 1 << 6, // Render tile boundaries.
DU_DRAWNAVMESH_TILE_CELLS = 1 << 7, // Render tile cells.
DU_DRAWNAVMESH_POLY_FACES = 1 << 8, // Render poly faces.
DU_DRAWNAVMESH_POLY_EDGES = 1 << 9, // Render poly edges.
DU_DRAWNAVMESH_POLY_VERTS = 1 << 10, // Render poly verts.
DU_DRAWNAVMESH_POLY_BOUNDS_INNER = 1 << 11, // Render inner poly boundaries.
DU_DRAWNAVMESH_POLY_BOUNDS_OUTER = 1 << 12, // Render outer poly boundaries.
DU_DRAWNAVMESH_POLY_CENTERS = 1 << 13, // Render poly centers.
DU_DRAWNAVMESH_POLY_GROUPS = 1 << 14, // Render poly group by color.
DU_DRAWNAVMESH_LEDGE_SPANS = 1 << 15, // Render ledge spans.
DU_DRAWNAVMESH_DEPTH_MASK = 1 << 16, // Use depth mask.
DU_DRAWNAVMESH_ALPHA = 1 << 17, // Use transparency.
DU_DRAWNAVMESH_TRAVERSE_LINKS = 1 << 18, // Render traverse links.
DU_DRAW_DETOURMESH_OFFMESHCONS = 1<<0, // Render off-mesh connections.
DU_DRAW_DETOURMESH_QUERY_NODES = 1<<1, // Render navmesh query nodes.
DU_DRAW_DETOURMESH_BVTREE = 1<<2, // Render BVTree.
DU_DRAW_DETOURMESH_PORTALS = 1<<3, // Render portals.
DU_DRAW_DETOURMESH_WITH_CLOSED_LIST = 1<<4, // Render navmesh with closed list.
DU_DRAW_DETOURMESH_TILE_COLORS = 1<<5, // Render tiles colored by their ID's.
DU_DRAW_DETOURMESH_TILE_BOUNDS = 1<<6, // Render tile boundaries.
DU_DRAW_DETOURMESH_TILE_CELLS = 1<<7, // Render tile cells.
DU_DRAW_DETOURMESH_POLY_FACES = 1<<8, // Render poly faces.
DU_DRAW_DETOURMESH_POLY_EDGES = 1<<9, // Render poly edges.
DU_DRAW_DETOURMESH_POLY_VERTS = 1<<10, // Render poly verts.
DU_DRAW_DETOURMESH_POLY_BOUNDS_INNER = 1<<11, // Render inner poly boundaries.
DU_DRAW_DETOURMESH_POLY_BOUNDS_OUTER = 1<<12, // Render outer poly boundaries.
DU_DRAW_DETOURMESH_POLY_CENTERS = 1<<13, // Render poly centers.
DU_DRAW_DETOURMESH_POLY_GROUPS = 1<<14, // Render poly group by color.
DU_DRAW_DETOURMESH_LEDGE_SPANS = 1<<15, // Render ledge spans.
DU_DRAW_DETOURMESH_DEPTH_MASK = 1<<16, // Use depth mask.
DU_DRAW_DETOURMESH_ALPHA = 1<<17, // Use transparency.
DU_DRAW_DETOURMESH_TRAVERSE_LINKS = 1<<18, // Render traverse links.
DU_DRAW_DETOURMESH_TILE_CACHE_BOUNDS = 1<<19,
DU_DRAW_DETOURMESH_TILE_CACHE_OBSTACLES = 1<<20,
};
struct duDrawTraverseLinkParams

16
src/thirdparty/recast/DebugUtils/Include/RecastDebugDraw.h vendored
View File

@ -19,6 +19,22 @@
#ifndef RECAST_DEBUGDRAW_H
#define RECAST_DEBUGDRAW_H
enum DrawRecastMeshFlags
{
DU_DRAW_RECASTMESH_INPUT_MESH = 1<<0,
DU_DRAW_RECASTMESH_NAVMESH = 1<<1,
DU_DRAW_RECASTMESH_VOXELS = 1<<2,
DU_DRAW_RECASTMESH_VOXELS_WALKABLE = 1<<3,
DU_DRAW_RECASTMESH_COMPACT = 1<<4,
DU_DRAW_RECASTMESH_COMPACT_DISTANCE = 1<<5,
DU_DRAW_RECASTMESH_COMPACT_REGIONS = 1<<6,
DU_DRAW_RECASTMESH_REGION_CONNECTIONS = 1<<7,
DU_DRAW_RECASTMESH_RAW_CONTOURS = 1<<8,
DU_DRAW_RECASTMESH_CONTOURS = 1<<9,
DU_DRAW_RECASTMESH_POLYMESH = 1<<10,
DU_DRAW_RECASTMESH_POLYMESH_DETAIL = 1<<11,
};
void duDebugDrawTriMesh(struct duDebugDraw* dd, const float* verts, int nverts, const int* tris, const float* normals, int ntris,
const unsigned char* flags, const float texScale, const float* offset);
void duDebugDrawTriMeshSlope(struct duDebugDraw* dd, const float* verts, int nverts, const int* tris, const float* normals, int ntris,

44
src/thirdparty/recast/DebugUtils/Source/DetourDebugDraw.cpp vendored
View File

@ -56,7 +56,7 @@ static void drawPolyMeshFaces(duDebugDraw* dd, const dtNavMesh& mesh, const dtNa
const dtPolyRef base = mesh.getPolyRefBase(tile);
// If the "Alpha" flag isn't set, force the colour to be opaque instead of semi-transparent.
const int tileAlpha = flags & DU_DRAWNAVMESH_ALPHA ? 170 : 255;
const int tileAlpha = flags & DU_DRAW_DETOURMESH_ALPHA ? 170 : 255;
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < header->polyCount; ++i)
@ -72,9 +72,9 @@ static void drawPolyMeshFaces(duDebugDraw* dd, const dtNavMesh& mesh, const dtNa
col = duRGBA(255,196,0,64);
else
{
if (flags & DU_DRAWNAVMESH_TILE_COLORS)
if (flags & DU_DRAW_DETOURMESH_TILE_COLORS)
col = duIntToCol(mesh.decodePolyIdTile(base), tileAlpha);
else if (flags & DU_DRAWNAVMESH_POLY_GROUPS)
else if (flags & DU_DRAW_DETOURMESH_POLY_GROUPS)
col = duIntToCol(p->groupId, tileAlpha);
else
col = getPolySurfaceColor(dd, p, tileAlpha);
@ -183,7 +183,7 @@ static void drawPolyBoundaries(duDebugDraw* dd, const dtMeshTile* tile,
const float* v0 = &tile->verts[p->verts[j]*3];
const float* v1 = &tile->verts[p->verts[(j+1) % nj]*3];
if (!inner && flags & DU_DRAWNAVMESH_LEDGE_SPANS)
if (!inner && flags & DU_DRAW_DETOURMESH_LEDGE_SPANS)
{
float normal[3];
rdCalcEdgeNormalPt2D(v0, v1, normal);
@ -497,41 +497,41 @@ static void drawOffMeshLinks(duDebugDraw* dd, const dtNavMesh& mesh, const dtNav
void duDebugDrawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery* query,
const dtMeshTile* tile, const float* offset, unsigned int flags, const duDrawTraverseLinkParams& traverseLinkParams)
{
const bool depthTest = flags & DU_DRAWNAVMESH_DEPTH_MASK;
const bool depthTest = flags & DU_DRAW_DETOURMESH_DEPTH_MASK;
dd->depthMask(depthTest);
if (flags & DU_DRAWNAVMESH_POLY_FACES)
if (flags & DU_DRAW_DETOURMESH_POLY_FACES)
drawPolyMeshFaces(dd, mesh, query, tile, offset, flags);
if (flags & DU_DRAWNAVMESH_POLY_EDGES)
if (flags & DU_DRAW_DETOURMESH_POLY_EDGES)
drawPolyMeshEdges(dd, tile, offset);
if (flags & DU_DRAWNAVMESH_POLY_VERTS)
if (flags & DU_DRAW_DETOURMESH_POLY_VERTS)
drawPolyVerts(dd, tile, offset);
// Draw inner poly boundaries
if (flags & DU_DRAWNAVMESH_POLY_BOUNDS_INNER)
if (flags & DU_DRAW_DETOURMESH_POLY_BOUNDS_INNER)
drawPolyBoundaries(dd, tile, 1.5f, offset, flags, true);
// Draw outer poly boundaries
if (flags & DU_DRAWNAVMESH_POLY_BOUNDS_OUTER)
if (flags & DU_DRAW_DETOURMESH_POLY_BOUNDS_OUTER)
drawPolyBoundaries(dd, tile, 3.5f, offset, flags, false);
// Draw poly centers
if (flags & DU_DRAWNAVMESH_POLY_CENTERS)
if (flags & DU_DRAW_DETOURMESH_POLY_CENTERS)
drawPolyCenters(dd, tile, duRGBA(255, 255, 255, 100), 1.0f, offset);
if (query && (flags & DU_DRAWNAVMESH_TRAVERSE_LINKS))
if (query && (flags & DU_DRAW_DETOURMESH_TRAVERSE_LINKS))
drawTraverseLinks(dd, mesh, query, tile, offset, traverseLinkParams);
if (flags & DU_DRAWNAVMESH_TILE_CELLS)
if (flags & DU_DRAW_DETOURMESH_TILE_CELLS)
drawTileCells(dd, tile, offset);
if (flags & DU_DRAWNAVMESH_TILE_BOUNDS)
if (flags & DU_DRAW_DETOURMESH_TILE_BOUNDS)
drawTileBounds(dd, tile, offset);
if (flags & DU_DRAWNAVMESH_OFFMESHCONS)
if (flags & DU_DRAW_DETOURMESH_OFFMESHCONS)
drawOffMeshLinks(dd, mesh, query, tile, offset);
if (!depthTest)
@ -554,7 +554,7 @@ void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& m
{
if (!dd) return;
const dtNavMeshQuery* q = (flags & DU_DRAWNAVMESH_WITH_CLOSED_LIST) ? &query : 0;
const dtNavMeshQuery* q = (flags & DU_DRAW_DETOURMESH_WITH_CLOSED_LIST) ? &query : 0;
for (int i = 0; i < mesh.getMaxTiles(); ++i)
{
@ -563,11 +563,11 @@ void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& m
duDebugDrawMeshTile(dd, mesh, q, tile, offset, flags, traverseLinkParams);
}
if (flags & DU_DRAWNAVMESH_BVTREE)
if (flags & DU_DRAW_DETOURMESH_BVTREE)
duDebugDrawNavMeshBVTree(dd, mesh, offset);
if (flags & DU_DRAWNAVMESH_PORTALS)
if (flags & DU_DRAW_DETOURMESH_PORTALS)
duDebugDrawNavMeshPortals(dd, mesh, offset);
if (flags & DU_DRAWNAVMESH_QUERY_NODES)
if (flags & DU_DRAW_DETOURMESH_QUERY_NODES)
duDebugDrawNavMeshNodes(dd, query, offset);
}
@ -756,7 +756,7 @@ void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef re
if (dtStatusFailed(mesh.getTileAndPolyByRef(ref, &tile, &poly)))
return;
const bool depthTest = drawFlags & DU_DRAWNAVMESH_DEPTH_MASK;
const bool depthTest = drawFlags & DU_DRAW_DETOURMESH_DEPTH_MASK;
dd->depthMask(depthTest);
const unsigned int c = soften ? duTransCol(col, 64) : col;
@ -764,7 +764,7 @@ void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef re
if (poly->getType() == DT_POLYTYPE_OFFMESH_CONNECTION)
{
if (drawFlags & DU_DRAWNAVMESH_OFFMESHCONS)
if (drawFlags & DU_DRAW_DETOURMESH_OFFMESHCONS)
{
dtOffMeshConnection* con = &tile->offMeshCons[ip - tile->header->offMeshBase];
@ -803,7 +803,7 @@ void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef re
}
dd->end();
if (drawFlags & DU_DRAWNAVMESH_POLY_EDGES)
if (drawFlags & DU_DRAW_DETOURMESH_POLY_EDGES)
{
const unsigned int edgeCol = duRGBA(0,0,0,48);