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: add ability to offset Recast and Detour debug drawing

Browse Source 
New ability to adjust it in all directions, recast and detour offsets are separate. By default, the Recast mesh renders 20 units from the input geom and Detour 30 units to avoid z-fighting.
This commit is contained in:
Kawe Mazidjatari 2024-07-14 18:34:13 +02:00
parent ba33e46308
commit 0edf5c1717
22 changed files with 441 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/naveditor/ConvexVolumeTool.cpp
View File

@ -261,6 +261,7 @@ void ConvexVolumeTool::handleUpdate(const float /*dt*/)
void ConvexVolumeTool::handleRender()
{
duDebugDraw& dd = m_editor->getDebugDraw();
const float* drawOffset = m_editor->getDetourDrawOffset();
// Find height extent of the shape.
float minh = FLT_MAX, maxh = 0;
@ -269,7 +270,7 @@ void ConvexVolumeTool::handleRender()
minh -= m_boxDescent;
maxh = minh + m_boxHeight;
dd.begin(DU_DRAW_POINTS, 4.0f);
dd.begin(DU_DRAW_POINTS, 4.0f, drawOffset);
for (int i = 0; i < m_npts; ++i)
{
unsigned int col = duRGBA(255,255,255,255);
@ -279,7 +280,7 @@ void ConvexVolumeTool::handleRender()
}
dd.end();
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int i = 0, j = m_nhull-1; i < m_nhull; j = i++)
{
const float* vi = &m_pts[m_hull[j]*3];

52
src/naveditor/CrowdTool.cpp
View File

@ -196,12 +196,15 @@ void CrowdToolState::handleRender()
dtCrowd* crowd = m_editor->getCrowd();
if (!nav || !crowd)
return;
const float* drawOffset = m_editor->getDetourDrawOffset();
const unsigned int drawFlags = m_editor->getNavMeshDrawFlags();
if (m_toolParams.m_showNodes && crowd->getPathQueue())
{
const dtNavMeshQuery* navquery = crowd->getPathQueue()->getNavQuery();
if (navquery)
duDebugDrawNavMeshNodes(&dd, *navquery);
duDebugDrawNavMeshNodes(&dd, *navquery, drawOffset);
}
dd.depthMask(false);
@ -219,12 +222,12 @@ void CrowdToolState::handleRender()
const dtPolyRef* path = ag->corridor.getPath();
const int npath = ag->corridor.getPathCount();
for (int j = 0; j < npath; ++j)
duDebugDrawNavMeshPoly(&dd, *nav, path[j], duRGBA(255,255,255,24));
duDebugDrawNavMeshPoly(&dd, *nav, path[j], drawOffset, drawFlags, duRGBA(255,255,255,24));
}
}
if (m_targetRef)
duDebugDrawCross(&dd, m_targetPos[0],m_targetPos[1],m_targetPos[2]+0.1f, rad, duRGBA(255,255,255,192), 2.0f);
duDebugDrawCross(&dd, m_targetPos[0],m_targetPos[1],m_targetPos[2]+0.1f, rad, duRGBA(255,255,255,192), 2.0f, drawOffset);
// Occupancy grid.
if (m_toolParams.m_showGrid)
@ -239,7 +242,7 @@ void CrowdToolState::handleRender()
}
gridz += 1.0f;
dd.begin(DU_DRAW_QUADS);
dd.begin(DU_DRAW_QUADS,1.0f,drawOffset);
const dtProximityGrid* grid = crowd->getGrid();
const int* bounds = grid->getBounds();
const float cs = grid->getCellSize();
@ -269,7 +272,7 @@ void CrowdToolState::handleRender()
const AgentTrail* trail = &m_trails[i];
const float* pos = ag->npos;
dd.begin(DU_DRAW_LINES,3.0f);
dd.begin(DU_DRAW_LINES,3.0f,drawOffset);
float prev[3], preva = 1;
dtVcopy(prev, pos);
for (int j = 0; j < AGENT_MAX_TRAIL-1; ++j)
@ -302,7 +305,7 @@ void CrowdToolState::handleRender()
{
if (ag->ncorners)
{
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f,drawOffset);
for (int j = 0; j < ag->ncorners; ++j)
{
const float* va = j == 0 ? agentPos : &ag->cornerVerts[(j-1)*3];
@ -332,7 +335,7 @@ void CrowdToolState::handleRender()
const float* tgt = &ag->cornerVerts[0];
const float z = ag->npos[2]+off;
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
dd.vertex(ag->npos[0],ag->npos[1],z, duRGBA(255,0,0,192));
dd.vertex(pos[0],pos[1],z, duRGBA(255,0,0,192));
@ -347,11 +350,11 @@ void CrowdToolState::handleRender()
if (m_toolParams.m_showCollisionSegments)
{
const float* center = ag->boundary.getCenter();
duDebugDrawCross(&dd, center[0],center[1],center[2]+agentRadius, 0.2f, duRGBA(192,0,128,255), 2.0f);
duDebugDrawCross(&dd, center[0],center[1],center[2]+agentRadius, 0.2f, duRGBA(192,0,128,255), 2.0f, drawOffset);
duDebugDrawCircle(&dd, center[0],center[1],center[2]+agentRadius, ag->params.collisionQueryRange,
duRGBA(192,0,128,128), 2.0f);
duRGBA(192,0,128,128), 2.0f, drawOffset);
dd.begin(DU_DRAW_LINES, 3.0f);
dd.begin(DU_DRAW_LINES, 3.0f, drawOffset);
for (int j = 0; j < ag->boundary.getSegmentCount(); ++j)
{
const float* s = ag->boundary.getSegment(j);
@ -367,9 +370,9 @@ void CrowdToolState::handleRender()
if (m_toolParams.m_showNeis)
{
duDebugDrawCircle(&dd, agentPos[0],agentPos[1],agentPos[2]+agentRadius, ag->params.collisionQueryRange,
duRGBA(0,192,128,128), 2.0f);
duRGBA(0,192,128,128), 2.0f, drawOffset);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int j = 0; j < ag->nneis; ++j)
{
// Get 'n'th active agent.
@ -386,7 +389,7 @@ void CrowdToolState::handleRender()
if (m_toolParams.m_showOpt)
{
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
dd.vertex(m_agentDebug.optStart[0],m_agentDebug.optStart[1],m_agentDebug.optStart[2]+0.3f, duRGBA(0,128,0,192));
dd.vertex(m_agentDebug.optEnd[0],m_agentDebug.optEnd[1],m_agentDebug.optEnd[2]+0.3f, duRGBA(0,128,0,192));
dd.end();
@ -406,7 +409,7 @@ void CrowdToolState::handleRender()
if (m_agentDebug.idx == i)
col = duRGBA(255,0,0,128);
duDebugDrawCircle(&dd, pos[0], pos[1], pos[2], radius, col, 2.0f);
duDebugDrawCircle(&dd, pos[0], pos[1], pos[2], radius, col, 2.0f, drawOffset);
}
for (int i = 0; i < crowd->getAgentCount(); ++i)
@ -429,7 +432,7 @@ void CrowdToolState::handleRender()
col = duLerpCol(col, duRGBA(64,255,0,128), 128);
duDebugDrawCylinder(&dd, pos[0]-radius, pos[1]-radius, pos[2]+radius*0.1f,
pos[0]+radius, pos[1]+radius, pos[2]+height, col);
pos[0]+radius, pos[1]+radius, pos[2]+height, col, drawOffset);
}
if (m_toolParams.m_showVO)
@ -449,9 +452,9 @@ void CrowdToolState::handleRender()
const float dy = ag->npos[1];
const float dz = ag->npos[2]+ag->params.height;
duDebugDrawCircle(&dd, dx,dy,dz, ag->params.maxSpeed, duRGBA(255,255,255,64), 2.0f);
duDebugDrawCircle(&dd, dx,dy,dz, ag->params.maxSpeed, duRGBA(255,255,255,64), 2.0f, drawOffset);
dd.begin(DU_DRAW_QUADS);
dd.begin(DU_DRAW_QUADS, 1.0f, drawOffset);
for (int j = 0; j < vod->getSampleCount(); ++j)
{
const float* p = vod->getSampleVelocity(j);
@ -491,15 +494,15 @@ void CrowdToolState::handleRender()
else if (ag->targetState == DT_CROWDAGENT_TARGET_VELOCITY)
col = duLerpCol(col, duRGBA(64,255,0,192), 128);
duDebugDrawCircle(&dd, pos[0], pos[1], pos[2]+height, radius, col, 2.0f);
duDebugDrawCircle(&dd, pos[0], pos[1], pos[2]+height, radius, col, 2.0f, drawOffset);
duDebugDrawArrow(&dd, pos[0],pos[1],pos[2]+height,
pos[0]+dvel[0],pos[1]+dvel[1],pos[2]+height+dvel[2],
0.0f, 30.0f, duRGBA(0,192,255,192), (m_agentDebug.idx == i) ? 2.0f : 1.0f);
0.0f, 30.0f, duRGBA(0,192,255,192), (m_agentDebug.idx == i) ? 2.0f : 1.0f, drawOffset);
duDebugDrawArrow(&dd, pos[0],pos[1],pos[2]+height,
pos[0]+vel[0],pos[1]+vel[1],pos[2]+height+vel[2],
0.0f, 30.0f, duRGBA(0,0,0,160), 2.0f);
0.0f, 30.0f, duRGBA(0,0,0,160), 2.0f, drawOffset);
}
dd.depthMask(true);
@ -514,9 +517,10 @@ void CrowdToolState::handleRenderOverlay(double* proj, double* model, int* view)
{
GLdouble x, y, z;
const int windowHeight = view[3];
const float* drawOffset = m_editor->getDetourDrawOffset();
// Draw start and end point labels
if (m_targetRef && gluProject((GLdouble)m_targetPos[0], (GLdouble)m_targetPos[1], (GLdouble)m_targetPos[2],
if (m_targetRef && gluProject((GLdouble)m_targetPos[0]+drawOffset[0], (GLdouble)m_targetPos[1]+drawOffset[1], (GLdouble)m_targetPos[2]+drawOffset[2],
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter,
@ -541,7 +545,7 @@ void CrowdToolState::handleRenderOverlay(double* proj, double* model, int* view)
const dtNode* node = pool->getNodeAtIdx(j+1);
if (!node) continue;
if (gluProject((GLdouble)node->pos[0],(GLdouble)node->pos[1],(GLdouble)node->pos[2]+off,
if (gluProject((GLdouble)node->pos[0]+drawOffset[0],(GLdouble)node->pos[1]+drawOffset[1],(GLdouble)node->pos[2]+drawOffset[2]+off,
model, proj, view, &x, &y, &z))
{
const float heuristic = node->total;// - node->cost;
@ -565,7 +569,7 @@ void CrowdToolState::handleRenderOverlay(double* proj, double* model, int* view)
if (!ag->active) continue;
const float* pos = ag->npos;
const float h = ag->params.height;
if (gluProject((GLdouble)pos[0], (GLdouble)pos[1], (GLdouble)pos[2]+h,
if (gluProject((GLdouble)pos[0]+drawOffset[0], (GLdouble)pos[1]+drawOffset[1], (GLdouble)pos[2]+drawOffset[2]+h,
model, proj, view, &x, &y, &z))
{
const TraverseAnimType_e animType = ag->params.traverseAnimType;
@ -599,7 +603,7 @@ void CrowdToolState::handleRenderOverlay(double* proj, double* model, int* view)
const dtCrowdAgent* nei = crowd->getAgent(ag->neis[j].idx);
if (!nei->active) continue;
if (gluProject((GLdouble)nei->npos[0], (GLdouble)nei->npos[1], (GLdouble)nei->npos[2]+radius,
if (gluProject((GLdouble)nei->npos[0]+drawOffset[0], (GLdouble)nei->npos[1]+drawOffset[1], (GLdouble)nei->npos[2]+drawOffset[2]+radius,
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter,

25
src/naveditor/Editor.cpp
View File

@ -19,6 +19,7 @@
#include "Pch.h"
#include "Recast/Include/Recast.h"
#include "Shared/Include/SharedAssert.h"
#include "Detour/Include/DetourCommon.h"
#include "Detour/Include/DetourNavMesh.h"
#include "Detour/Include/DetourNavMeshQuery.h"
#include "Detour/Include/DetourNavMeshBuilder.h"
@ -32,6 +33,7 @@
#include "game/server/ai_navmesh.h"
#include "game/server/ai_hull.h"
#include "coordsize.h"
unsigned int EditorDebugDraw::areaToCol(unsigned int area)
{
@ -79,6 +81,9 @@ Editor::Editor() :
for (int i = 0; i < MAX_TOOLS; i++)
m_toolStates[i] = 0;
dtVset(m_recastDrawOffset, 0.0f,0.0f,20.0f);
dtVset(m_detourDrawOffset, 0.0f,0.0f,30.0f);
}
Editor::~Editor()
@ -118,11 +123,11 @@ void Editor::handleRender()
// Draw mesh
duDebugDrawTriMesh(&m_dd, m_geom->getMesh()->getVerts(), m_geom->getMesh()->getVertCount(),
m_geom->getMesh()->getTris(), m_geom->getMesh()->getNormals(), m_geom->getMesh()->getTriCount(), 0, 1.0f);
m_geom->getMesh()->getTris(), m_geom->getMesh()->getNormals(), m_geom->getMesh()->getTriCount(), 0, 1.0f, nullptr);
// Draw bounds
const float* bmin = m_geom->getMeshBoundsMin();
const float* bmax = m_geom->getMeshBoundsMax();
duDebugDrawBoxWire(&m_dd, bmin[0],bmin[1],bmin[2], bmax[0],bmax[1],bmax[2], duRGBA(255,255,255,128), 1.0f);
duDebugDrawBoxWire(&m_dd, bmin[0],bmin[1],bmin[2], bmax[0],bmax[1],bmax[2], duRGBA(255,255,255,128), 1.0f, nullptr);
}
void Editor::handleRenderOverlay(double* /*proj*/, double* /*model*/, int* /*view*/)
@ -369,9 +374,21 @@ void Editor::renderOverlayToolStates(double* proj, double* model, int* view)
}
}
void Editor::renderNavMeshDebugMenu()
void Editor::renderMeshOffsetOptions()
{
ImGui::Text("NavMesh Render Options");
ImGui::Text("Render Offsets");
ImGui::PushItemWidth(230);
ImGui::SliderFloat3("Recast##RenderOffset", m_recastDrawOffset, -500, 500);
ImGui::SliderFloat3("Detour##RenderOffset", m_detourDrawOffset, -500, 500);
ImGui::PopItemWidth();
}
void Editor::renderDetourDebugMenu()
{
ImGui::Text("Detour Render Options");
bool isEnabled = (getNavMeshDrawFlags() & DU_DRAWNAVMESH_OFFMESHCONS);

36
src/naveditor/EditorInterfaces.cpp
View File

@ -1,5 +1,6 @@
#include "Pch.h"
#include "Recast/Include/Recast.h"
#include "Detour/Include/DetourCommon.h"
#include "DebugUtils/Include/RecastDebugDraw.h"
#include "DebugUtils/Include/DetourDebugDraw.h"
#include "NavEditor/Include/EditorInterfaces.h"
@ -195,7 +196,7 @@ void DebugDrawGL::texture(bool state)
}
}
void DebugDrawGL::begin(duDebugDrawPrimitives prim, float size)
void DebugDrawGL::begin(const duDebugDrawPrimitives prim, const float size, const float* offset)
{
switch (prim)
{
@ -214,32 +215,55 @@ void DebugDrawGL::begin(duDebugDrawPrimitives prim, float size)
glBegin(GL_QUADS);
break;
};
if (offset)
dtVcopy(m_drawOffset,offset);
}
void DebugDrawGL::vertex(const float* pos, unsigned int color)
{
glColor4ubv((GLubyte*)&color);
glVertex3fv(pos);
float opos[3];
dtVadd(opos,pos,m_drawOffset);
glVertex3fv(opos);
}
void DebugDrawGL::vertex(const float x, const float y, const float z, unsigned int color)
{
glColor4ubv((GLubyte*)&color);
glVertex3f(x,y,z);
float opos[3];
dtVset(opos, x,y,z);
dtVadd(opos,opos,m_drawOffset);
glVertex3fv(opos);
}
void DebugDrawGL::vertex(const float* pos, unsigned int color, const float* uv)
{
glColor4ubv((GLubyte*)&color);
glTexCoord2fv(uv);
glVertex3fv(pos);
float opos[3];
dtVadd(opos,pos,m_drawOffset);
glVertex3fv(opos);
}
void DebugDrawGL::vertex(const float x, const float y, const float z, unsigned int color, const float u, const float v)
{
glColor4ubv((GLubyte*)&color);
glTexCoord2f(u,v);
glVertex3f(x,y,z);
float opos[3];
dtVset(opos, x,y,z);
dtVadd(opos,opos,m_drawOffset);
glVertex3fv(opos);
}
void DebugDrawGL::end()
@ -247,6 +271,8 @@ void DebugDrawGL::end()
glEnd();
glLineWidth(1.0f);
glPointSize(1.0f);
dtVset(m_drawOffset, 0.0f,0.0f,0.0f);
}
////////////////////////////////////////////////////////////////////////////////////////////////////

129
src/naveditor/Editor_Common.cpp
View File

@ -55,7 +55,7 @@ static void EditorCommon_DrawInputGeometry(duDebugDraw* const dd, const InputGeo
{
duDebugDrawTriMeshSlope(dd, geom->getMesh()->getVerts(), geom->getMesh()->getVertCount(),
geom->getMesh()->getTris(), geom->getMesh()->getNormals(), geom->getMesh()->getTriCount(),
maxSlope, textureScale);
maxSlope, textureScale, nullptr);
}
static void EditorCommon_DrawBoundingBox(duDebugDraw* const dd, const InputGeom* const geom)
@ -63,7 +63,7 @@ static void EditorCommon_DrawBoundingBox(duDebugDraw* const dd, const InputGeom*
// Draw bounds
const float* const bmin = geom->getNavMeshBoundsMin();
const float* const bmax = geom->getNavMeshBoundsMax();
duDebugDrawBoxWire(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], duRGBA(255, 255, 255, 128), 1.0f);
duDebugDrawBoxWire(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], duRGBA(255, 255, 255, 128), 1.0f, nullptr);
}
static void EditorCommon_DrawTilingGrid(duDebugDraw* const dd, const InputGeom* const geom, const int tileSize, const float cellSize)
@ -78,7 +78,7 @@ static void EditorCommon_DrawTilingGrid(duDebugDraw* const dd, const InputGeom*
const int th = (gh + tileSize - 1) / tileSize;
const float s = tileSize * cellSize;
duDebugDrawGridXY(dd, bmax[0], bmin[1], bmin[2], tw, th, s, duRGBA(0, 0, 0, 64), 1.0f);
duDebugDrawGridXY(dd, bmax[0], bmin[1], bmin[2], tw, th, s, duRGBA(0, 0, 0, 64), 1.0f, nullptr);
}
int EditorCommon_SetAndRenderTileProperties(const InputGeom* const geom, const int tileSize,
@ -162,9 +162,9 @@ void Editor_StaticTileMeshCommon::cleanup()
m_dmesh = 0;
}
void Editor_StaticTileMeshCommon::renderTileMeshRenderOptions()
void Editor_StaticTileMeshCommon::renderRecastDebugMenu()
{
ImGui::Text("TileMesh Render Options");
ImGui::Text("Recast Render Options");
bool isEnabled = m_tileMeshDrawFlags & TM_DRAWFLAGS_INPUT_MESH;
@ -271,14 +271,14 @@ void Editor_StaticTileMeshCommon::renderTileMeshRenderOptions()
ImGui::EndDisabled();
if (intermediateDataUnavailable)
{
ImGui::Separator();
//if (intermediateDataUnavailable) // todo(amos): tool tip
//{
// ImGui::Separator();
ImGui::Text("Tick 'Keep Intermediate Results'");
ImGui::Text("rebuild some tiles to see");
ImGui::Text("more debug mode options.");
}
// ImGui::Text("Tick 'Keep Intermediate Results'");
// ImGui::Text("rebuild some tiles to see");
// ImGui::Text("more debug mode options.");
//}
}
void Editor_StaticTileMeshCommon::renderTileMeshData()
@ -300,19 +300,26 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
// Tiling grid.
EditorCommon_DrawTilingGrid(&m_dd, m_geom, m_tileSize, m_cellSize);
const float* recastDrawOffset = getRecastDrawOffset();
const float* detourDrawOffset = getDetourDrawOffset();
const unsigned int recastDrawFlags = getTileMeshDrawFlags();
const unsigned int detourDrawFlags = getNavMeshDrawFlags();
if (m_drawActiveTile)
{
// Draw active tile
duDebugDrawBoxWire(&m_dd, m_lastBuiltTileBmin[0], m_lastBuiltTileBmin[1], m_lastBuiltTileBmin[2],
m_lastBuiltTileBmax[0], m_lastBuiltTileBmax[1], m_lastBuiltTileBmax[2], m_tileCol, 1.0f);
// NOTE: only perform offset in x-y
duDebugDrawBoxWire(&m_dd, m_lastBuiltTileBmin[0]+detourDrawOffset[0], m_lastBuiltTileBmin[1]+detourDrawOffset[1], m_lastBuiltTileBmin[2],
m_lastBuiltTileBmax[0]+detourDrawOffset[0], m_lastBuiltTileBmax[1]+detourDrawOffset[1], m_lastBuiltTileBmax[2], m_tileCol, 1.0f, nullptr);
}
if (m_navMesh && m_navQuery)
{
if (m_tileMeshDrawFlags & TM_DRAWFLAGS_NAVMESH)
{
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, m_navMeshDrawFlags);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, EDITOR_POLYFLAGS_DISABLED, duRGBA(0, 0, 0, 128));
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, detourDrawOffset, m_navMeshDrawFlags);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, EDITOR_POLYFLAGS_DISABLED, detourDrawOffset, detourDrawFlags, duRGBA(0, 0, 0, 128));
}
}
@ -320,74 +327,74 @@ void Editor_StaticTileMeshCommon::renderTileMeshData()
if (m_chf)
{
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT)
duDebugDrawCompactHeightfieldSolid(&m_dd, *m_chf);
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT)
duDebugDrawCompactHeightfieldSolid(&m_dd, *m_chf, recastDrawOffset);
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT_DISTANCE)
duDebugDrawCompactHeightfieldDistance(&m_dd, *m_chf);
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_COMPACT_REGIONS)
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf);
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT_DISTANCE)
duDebugDrawCompactHeightfieldDistance(&m_dd, *m_chf, recastDrawOffset);
if (recastDrawFlags & TM_DRAWFLAGS_COMPACT_REGIONS)
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf, recastDrawOffset);
}
if (m_solid)
{
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_VOXELS)
if (recastDrawFlags & TM_DRAWFLAGS_VOXELS)
{
glEnable(GL_FOG);
duDebugDrawHeightfieldSolid(&m_dd, *m_solid);
duDebugDrawHeightfieldSolid(&m_dd, *m_solid, recastDrawOffset);
glDisable(GL_FOG);
}
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_VOXELS_WALKABLE)
if (recastDrawFlags & TM_DRAWFLAGS_VOXELS_WALKABLE)
{
glEnable(GL_FOG);
duDebugDrawHeightfieldWalkable(&m_dd, *m_solid);
duDebugDrawHeightfieldWalkable(&m_dd, *m_solid, recastDrawOffset);
glDisable(GL_FOG);
}
}
if (m_cset)
{
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_RAW_CONTOURS)
if (recastDrawFlags & TM_DRAWFLAGS_RAW_CONTOURS)
{
glDepthMask(GL_FALSE);
duDebugDrawRawContours(&m_dd, *m_cset);
duDebugDrawRawContours(&m_dd, *m_cset, recastDrawOffset);
glDepthMask(GL_TRUE);
}
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_CONTOURS)
if (recastDrawFlags & TM_DRAWFLAGS_CONTOURS)
{
glDepthMask(GL_FALSE);
duDebugDrawContours(&m_dd, *m_cset);
duDebugDrawContours(&m_dd, *m_cset, recastDrawOffset);
glDepthMask(GL_TRUE);
}
}
if ((m_chf &&m_cset) &&
(getTileMeshDrawFlags() & TM_DRAWFLAGS_REGION_CONNECTIONS))
(recastDrawFlags & TM_DRAWFLAGS_REGION_CONNECTIONS))
{
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf);
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf, recastDrawOffset);
glDepthMask(GL_FALSE);
duDebugDrawRegionConnections(&m_dd, *m_cset);
duDebugDrawRegionConnections(&m_dd, *m_cset, recastDrawOffset);
glDepthMask(GL_TRUE);
}
if (m_pmesh && (getTileMeshDrawFlags() & TM_DRAWFLAGS_POLYMESH))
if (m_pmesh && (recastDrawFlags & TM_DRAWFLAGS_POLYMESH))
{
glDepthMask(GL_FALSE);
duDebugDrawPolyMesh(&m_dd, *m_pmesh);
duDebugDrawPolyMesh(&m_dd, *m_pmesh, recastDrawOffset);
glDepthMask(GL_TRUE);
}
if (m_dmesh && (getTileMeshDrawFlags() & TM_DRAWFLAGS_POLYMESH_DETAIL))
if (m_dmesh && (recastDrawFlags & TM_DRAWFLAGS_POLYMESH_DETAIL))
{
glDepthMask(GL_FALSE);
duDebugDrawPolyMeshDetail(&m_dd, *m_dmesh);
duDebugDrawPolyMeshDetail(&m_dd, *m_dmesh, recastDrawOffset);
glDepthMask(GL_TRUE);
}
// TODO: also add flags for this
m_geom->drawConvexVolumes(&m_dd);
m_geom->drawOffMeshConnections(&m_dd);
m_geom->drawConvexVolumes(&m_dd, recastDrawOffset);
m_geom->drawOffMeshConnections(&m_dd, recastDrawOffset);
if (m_tool)
m_tool->handleRender();
@ -441,7 +448,7 @@ void Editor_StaticTileMeshCommon::renderIntermediateTileMeshOptions()
ImGui::Separator();
}
void drawTiles(duDebugDraw* dd, dtTileCache* tc)
void drawTiles(duDebugDraw* dd, dtTileCache* tc, const float* offset)
{
unsigned int fcol[6];
float bmin[3], bmax[3];
@ -455,7 +462,7 @@ void drawTiles(duDebugDraw* dd, dtTileCache* tc)
const unsigned int col = duIntToCol(i, 64);
duCalcBoxColors(fcol, col, col);
duDebugDrawBox(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], fcol);
duDebugDrawBox(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], fcol, offset);
}
for (int i = 0; i < tc->getTileCount(); ++i)
@ -468,11 +475,11 @@ void drawTiles(duDebugDraw* dd, dtTileCache* tc)
const unsigned int col = duIntToCol(i, 255);
const float pad = tc->getParams()->cs * 0.1f;
duDebugDrawBoxWire(dd, bmin[0] - pad, bmin[1] - pad, bmin[2] - pad,
bmax[0] + pad, bmax[1] + pad, bmax[2] + pad, col, 2.0f);
bmax[0] + pad, bmax[1] + pad, bmax[2] + pad, col, 2.0f, offset);
}
}
void drawObstacles(duDebugDraw* dd, const dtTileCache* tc)
void drawObstacles(duDebugDraw* dd, const dtTileCache* tc, const float* offset)
{
// Draw obstacles
for (int i = 0; i < tc->getObstacleCount(); ++i)
@ -490,8 +497,8 @@ void drawObstacles(duDebugDraw* dd, const dtTileCache* tc)
else if (ob->state == DT_OBSTACLE_REMOVING)
col = duRGBA(220, 0, 0, 128);
duDebugDrawCylinder(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], col);
duDebugDrawCylinderWire(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], duDarkenCol(col), 2);
duDebugDrawCylinder(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], col, offset);
duDebugDrawCylinderWire(dd, bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2], duDarkenCol(col), 2.0f, offset);
}
}
@ -510,9 +517,9 @@ Editor_DynamicTileMeshCommon::Editor_DynamicTileMeshCommon()
{
}
void Editor_DynamicTileMeshCommon::renderTileMeshRenderOptions()
void Editor_DynamicTileMeshCommon::renderRecastRenderOptions()
{
ImGui::Text("TileMesh Render Options");
ImGui::Text("Recast Render Options");
bool isEnabled = m_tileMeshDrawFlags & TM_DRAWFLAGS_INPUT_MESH;
@ -551,10 +558,14 @@ void Editor_DynamicTileMeshCommon::renderTileMeshData()
return;
const float texScale = 1.0f / (m_cellSize * 10.0f);
const unsigned int drawFlags = getTileMeshDrawFlags();
const unsigned int recastDrawFlags = getTileMeshDrawFlags();
const unsigned int detourDrawFlags = getNavMeshDrawFlags();
const float* recastDrawOffset = getRecastDrawOffset();
const float* detourDrawOffset = getDetourDrawOffset();
// Draw input mesh
if (getTileMeshDrawFlags() & TM_DRAWFLAGS_INPUT_MESH)
if (recastDrawFlags & TM_DRAWFLAGS_INPUT_MESH)
EditorCommon_DrawInputGeometry(&m_dd, m_geom, m_agentMaxSlope, texScale);
// Draw bounds
@ -563,26 +574,24 @@ void Editor_DynamicTileMeshCommon::renderTileMeshData()
// Tiling grid.
EditorCommon_DrawTilingGrid(&m_dd, m_geom, m_tileSize, m_cellSize);
if (m_tileCache && drawFlags & TM_DRAWFLAGS_TILE_CACHE_BOUNDS)
drawTiles(&m_dd, m_tileCache);
if (m_tileCache && recastDrawFlags & TM_DRAWFLAGS_TILE_CACHE_BOUNDS)
drawTiles(&m_dd, m_tileCache, detourDrawOffset);
if (m_tileCache && drawFlags & TM_DRAWFLAGS_TILE_CACHE_OBSTACLES)
drawObstacles(&m_dd, m_tileCache);
const bool navMeshRenderingEnabled = (drawFlags & TM_DRAWFLAGS_NAVMESH) != 0;
if (m_tileCache && recastDrawFlags & TM_DRAWFLAGS_TILE_CACHE_OBSTACLES)
drawObstacles(&m_dd, m_tileCache, detourDrawOffset);
if (m_navMesh && m_navQuery)
{
if (drawFlags & TM_DRAWFLAGS_NAVMESH)
if (recastDrawFlags & TM_DRAWFLAGS_NAVMESH)
{
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, m_navMeshDrawFlags);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, EDITOR_POLYFLAGS_DISABLED, duRGBA(0, 0, 0, 128));
duDebugDrawNavMeshWithClosedList(&m_dd, *m_navMesh, *m_navQuery, detourDrawOffset, detourDrawFlags);
duDebugDrawNavMeshPolysWithFlags(&m_dd, *m_navMesh, EDITOR_POLYFLAGS_DISABLED, detourDrawOffset, detourDrawFlags, duRGBA(0, 0, 0, 128));
}
}
// TODO: also add flags for this
m_geom->drawConvexVolumes(&m_dd);
m_geom->drawOffMeshConnections(&m_dd);
m_geom->drawConvexVolumes(&m_dd, recastDrawOffset);
m_geom->drawOffMeshConnections(&m_dd, recastDrawOffset);
if (m_tool)
m_tool->handleRender();

14
src/naveditor/Editor_Debug.cpp
View File

@ -184,15 +184,15 @@ void Editor_Debug::handleRender()
{
if (m_chf)
{
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf);
// duDebugDrawCompactHeightfieldSolid(&dd, *m_chf);
duDebugDrawCompactHeightfieldRegions(&m_dd, *m_chf, m_recastDrawOffset);
// duDebugDrawCompactHeightfieldSolid(&dd, *m_chf, m_recastRenderOffset);
}
if (m_navMesh)
duDebugDrawNavMesh(&m_dd, *m_navMesh, DU_DRAWNAVMESH_OFFMESHCONS);
duDebugDrawNavMesh(&m_dd, *m_navMesh, m_detourDrawOffset, DU_DRAWNAVMESH_OFFMESHCONS);
if (m_ref && m_navMesh)
duDebugDrawNavMeshPoly(&m_dd, *m_navMesh, m_ref, duRGBA(255,0,0,128));
duDebugDrawNavMeshPoly(&m_dd, *m_navMesh, m_ref, m_detourDrawOffset, m_navMeshDrawFlags, duRGBA(255,0,0,128));
/* float bmin[3], bmax[3];
rcVsub(bmin, m_center, m_halfExtents);
@ -202,13 +202,13 @@ void Editor_Debug::handleRender()
if (m_cset)
{
duDebugDrawRawContours(&m_dd, *m_cset, 0.25f);
duDebugDrawContours(&m_dd, *m_cset);
duDebugDrawRawContours(&m_dd, *m_cset, m_recastDrawOffset, 0.25f);
duDebugDrawContours(&m_dd, *m_cset, m_recastDrawOffset);
}
if (m_pmesh)
{
duDebugDrawPolyMesh(&m_dd, *m_pmesh);
duDebugDrawPolyMesh(&m_dd, *m_pmesh, m_recastDrawOffset);
}
/*

6
src/naveditor/Editor_SoloMesh.cpp
View File

@ -118,9 +118,11 @@ void Editor_SoloMesh::handleTools()
void Editor_SoloMesh::handleDebugMode()
{
Editor::renderNavMeshDebugMenu();
Editor::renderMeshOffsetOptions();
ImGui::Separator();
Editor_StaticTileMeshCommon::renderTileMeshRenderOptions();
Editor_StaticTileMeshCommon::renderRecastDebugMenu();
ImGui::Separator();
Editor::renderDetourDebugMenu();
}
void Editor_SoloMesh::handleRender()

24
src/naveditor/Editor_TileMesh.cpp
View File

@ -147,6 +147,13 @@ public:
{
GLdouble x, y, z;
const int h = view[3];
const float* drawOffset = m_editor->getDetourDrawOffset();
// NOTE: don't add the render offset here as we want to keep the overlay at the hit position, this
// way we can have the navmesh on the side and hit a specific location on the input geometry, and
// see which tile we build as this will be drawn on the hit position, while we can enumerate all
// the tiles using the debug options in the NavMeshTileTool which will always be aligned with the
// navmesh.
if (m_hitPosSet && gluProject((GLdouble)m_hitPos[0], (GLdouble)m_hitPos[1], (GLdouble)m_hitPos[2],
model, proj, view, &x, &y, &z))
{
@ -181,7 +188,7 @@ public:
rdAssert(0);
}
if (gluProject((GLdouble)poly->center[0], (GLdouble)poly->center[1], (GLdouble)poly->center[2] + 30,
if (gluProject((GLdouble)poly->center[0]+drawOffset[0], (GLdouble)poly->center[1]+drawOffset[1], (GLdouble)poly->center[2]+drawOffset[2]+30,
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter,
@ -301,9 +308,11 @@ void Editor_TileMesh::handleTools()
void Editor_TileMesh::handleDebugMode()
{
Editor::renderNavMeshDebugMenu();
Editor::renderMeshOffsetOptions();
ImGui::Separator();
Editor_StaticTileMeshCommon::renderTileMeshRenderOptions();
Editor_StaticTileMeshCommon::renderRecastDebugMenu();
ImGui::Separator();
Editor::renderDetourDebugMenu();
}
void Editor_TileMesh::handleRender()
@ -315,9 +324,16 @@ void Editor_TileMesh::handleRenderOverlay(double* proj, double* model, int* view
{
GLdouble x, y, z;
const int h = view[3];
const float* drawOffset = getDetourDrawOffset();
float projectPos[3];
dtVset(projectPos,
((m_lastBuiltTileBmin[0]+m_lastBuiltTileBmax[0])/2)+drawOffset[0],
((m_lastBuiltTileBmin[1]+m_lastBuiltTileBmax[1])/2)+drawOffset[1],
((m_lastBuiltTileBmin[2]+m_lastBuiltTileBmax[2])/2)+drawOffset[2]);
// Draw start and end point labels
if (m_tileBuildTime > 0.0f && gluProject((GLdouble)(m_lastBuiltTileBmin[0]+m_lastBuiltTileBmax[0])/2, (GLdouble)(m_lastBuiltTileBmin[1]+m_lastBuiltTileBmax[1])/2, (GLdouble)(m_lastBuiltTileBmin[2]+m_lastBuiltTileBmax[2])/2,
if (m_tileBuildTime > 0.0f && gluProject((GLdouble)projectPos[0], (GLdouble)projectPos[1], (GLdouble)projectPos[2],
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter, ImVec2((float)x, h-(float)(y-25)),

12
src/naveditor/InputGeom.cpp
View File

@ -560,13 +560,13 @@ void InputGeom::deleteOffMeshConnection(int i)
m_offMeshConFlags[i] = m_offMeshConFlags[m_offMeshConCount];
}
void InputGeom::drawOffMeshConnections(duDebugDraw* dd, bool hilight)
void InputGeom::drawOffMeshConnections(duDebugDraw* dd, const float* offset, bool hilight)
{
unsigned int conColor = duRGBA(192,0,128,192);
unsigned int baseColor = duRGBA(0,0,0,64);
dd->depthMask(false);
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < m_offMeshConCount; ++i)
{
float* v = &m_offMeshConVerts[i*3*2];
@ -617,11 +617,11 @@ void InputGeom::deleteConvexVolume(int i)
m_volumes[i] = m_volumes[m_volumeCount];
}
void InputGeom::drawConvexVolumes(struct duDebugDraw* dd, bool /*hilight*/)
void InputGeom::drawConvexVolumes(struct duDebugDraw* dd, const float* offset, bool /*hilight*/)
{
dd->depthMask(false);
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < m_volumeCount; ++i)
{
@ -654,7 +654,7 @@ void InputGeom::drawConvexVolumes(struct duDebugDraw* dd, bool /*hilight*/)
dd->end();
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < m_volumeCount; ++i)
{
const ConvexVolume* vol = &m_volumes[i];
@ -679,7 +679,7 @@ void InputGeom::drawConvexVolumes(struct duDebugDraw* dd, bool /*hilight*/)
}
dd->end();
dd->begin(DU_DRAW_POINTS, 3.0f);
dd->begin(DU_DRAW_POINTS, 3.0f, offset);
for (int i = 0; i < m_volumeCount; ++i)
{
const ConvexVolume* vol = &m_volumes[i];

5
src/naveditor/NavMeshPruneTool.cpp
View File

@ -285,6 +285,9 @@ void NavMeshPruneTool::handleRender()
}
const dtNavMesh* nav = m_editor->getNavMesh();
const float* drawOffset = m_editor->getDetourDrawOffset();
const unsigned int drawFlags = m_editor->getNavMeshDrawFlags();
if (m_flags && nav)
{
for (int i = 0; i < nav->getMaxTiles(); ++i)
@ -297,7 +300,7 @@ void NavMeshPruneTool::handleRender()
const dtPolyRef ref = base | (unsigned int)j;
if (m_flags->getFlags(ref))
{
duDebugDrawNavMeshPoly(&dd, *nav, ref, duRGBA(255,255,255,128));
duDebugDrawNavMeshPoly(&dd, *nav, ref, drawOffset, drawFlags, duRGBA(255,255,255,128));
}
}
}

79
src/naveditor/NavMeshTesterTool.cpp
View File

@ -1092,6 +1092,8 @@ void NavMeshTesterTool::handleRender()
const float agentRadius = m_editor->getAgentRadius();
const float agentHeight = m_editor->getAgentHeight();
const float agentClimb = m_editor->getAgentClimb();
const unsigned int drawFlags = m_editor->getNavMeshDrawFlags();
dd.depthMask(false);
if (m_sposSet)
@ -1105,10 +1107,12 @@ void NavMeshTesterTool::handleRender()
return;
}
const float* drawOffset = m_editor->getDetourDrawOffset();
if (m_toolMode == TOOLMODE_PATHFIND_FOLLOW)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, endCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, drawOffset, drawFlags, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, drawOffset, drawFlags, endCol);
if (m_npolys)
{
@ -1116,7 +1120,7 @@ void NavMeshTesterTool::handleRender()
{
if (m_polys[i] == m_startRef || m_polys[i] == m_endRef)
continue;
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
}
}
@ -1124,7 +1128,7 @@ void NavMeshTesterTool::handleRender()
{
dd.depthMask(false);
const unsigned int spathCol = duRGBA(0,0,0,220);
dd.begin(DU_DRAW_LINES, 3.0f);
dd.begin(DU_DRAW_LINES, 3.0f, drawOffset);
for (int i = 0; i < m_nsmoothPath; ++i)
dd.vertex(m_smoothPath[i*3], m_smoothPath[i*3+1], m_smoothPath[i*3+2]+0.1f, spathCol);
dd.end();
@ -1133,10 +1137,10 @@ void NavMeshTesterTool::handleRender()
if (m_pathIterNum)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_pathIterPolys[0], duRGBA(255,255,255,128));
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_pathIterPolys[0], drawOffset, drawFlags, duRGBA(255,255,255,128));
dd.depthMask(false);
dd.begin(DU_DRAW_LINES, 1.0f);
dd.begin(DU_DRAW_LINES, 1.0f, drawOffset);
const unsigned int prevCol = duRGBA(255,192,0,220);
const unsigned int curCol = duRGBA(255,255,255,220);
@ -1167,8 +1171,8 @@ void NavMeshTesterTool::handleRender()
else if (m_toolMode == TOOLMODE_PATHFIND_STRAIGHT ||
m_toolMode == TOOLMODE_PATHFIND_SLICED)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, endCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, drawOffset, drawFlags, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, drawOffset, drawFlags, endCol);
if (m_npolys)
{
@ -1176,7 +1180,7 @@ void NavMeshTesterTool::handleRender()
{
if (m_polys[i] == m_startRef || m_polys[i] == m_endRef)
continue;
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
}
}
@ -1185,7 +1189,7 @@ void NavMeshTesterTool::handleRender()
dd.depthMask(false);
const unsigned int spathCol = duRGBA(64,16,0,220);
const unsigned int offMeshCol = duRGBA(128,96,0,220);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int i = 0; i < m_nstraightPath-1; ++i)
{
unsigned int col;
@ -1198,7 +1202,7 @@ void NavMeshTesterTool::handleRender()
dd.vertex(m_straightPath[(i+1)*3], m_straightPath[(i+1)*3+1], m_straightPath[(i+1)*3+2] + 0.4f, col);
}
dd.end();
dd.begin(DU_DRAW_POINTS, 6.0f);
dd.begin(DU_DRAW_POINTS, 6.0f, drawOffset);
for (int i = 0; i < m_nstraightPath; ++i)
{
unsigned int col;
@ -1218,23 +1222,23 @@ void NavMeshTesterTool::handleRender()
}
else if (m_toolMode == TOOLMODE_RAYCAST)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, drawOffset, drawFlags, startCol);
if (m_nstraightPath)
{
for (int i = 1; i < m_npolys; ++i)
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
dd.depthMask(false);
const unsigned int spathCol = m_hitResult ? duRGBA(64,16,0,220) : duRGBA(240,240,240,220);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int i = 0; i < m_nstraightPath-1; ++i)
{
dd.vertex(m_straightPath[i*3], m_straightPath[i*3+1], m_straightPath[i*3+2] + 0.4f, spathCol);
dd.vertex(m_straightPath[(i+1)*3], m_straightPath[(i+1)*3+1], m_straightPath[(i+1)*3+2] + 0.4f, spathCol);
}
dd.end();
dd.begin(DU_DRAW_POINTS, 4.0f);
dd.begin(DU_DRAW_POINTS, 4.0f, drawOffset);
for (int i = 0; i < m_nstraightPath; ++i)
dd.vertex(m_straightPath[i*3], m_straightPath[i*3+1], m_straightPath[i*3+2] + 0.4f, spathCol);
dd.end();
@ -1242,7 +1246,7 @@ void NavMeshTesterTool::handleRender()
if (m_hitResult)
{
const unsigned int hitCol = duRGBA(0,0,0,128);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
dd.vertex(m_hitPos[0],m_hitPos[1],m_hitPos[2]+0.4f,hitCol);
dd.vertex(m_hitPos[0]+m_hitNormal[0]*agentRadius,
m_hitPos[1]+m_hitNormal[1]*agentRadius,
@ -1254,10 +1258,10 @@ void NavMeshTesterTool::handleRender()
}
else if (m_toolMode == TOOLMODE_DISTANCE_TO_WALL)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, drawOffset, drawFlags, startCol);
dd.depthMask(false);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_distanceToWall, duRGBA(64,16,0,220), 2.0f);
dd.begin(DU_DRAW_LINES, 3.0f);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_distanceToWall, duRGBA(64,16,0,220), 2.0f, drawOffset);
dd.begin(DU_DRAW_LINES, 3.0f, drawOffset);
dd.vertex(m_hitPos[0], m_hitPos[1] , m_hitPos[2] + 0.02f, duRGBA(0,0,0,192));
dd.vertex(m_hitPos[0], m_hitPos[1] , m_hitPos[2] + agentHeight, duRGBA(0,0,0,192));
dd.end();
@ -1267,7 +1271,7 @@ void NavMeshTesterTool::handleRender()
{
for (int i = 0; i < m_npolys; ++i)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
dd.depthMask(false);
if (m_parent[i])
{
@ -1275,7 +1279,7 @@ void NavMeshTesterTool::handleRender()
dd.depthMask(false);
getPolyCenter(m_navMesh, m_parent[i], p0);
getPolyCenter(m_navMesh, m_polys[i], p1);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f, drawOffset);
dd.depthMask(true);
}
dd.depthMask(true);
@ -1287,7 +1291,7 @@ void NavMeshTesterTool::handleRender()
const float dx = m_epos[0] - m_spos[0];
const float dy = m_epos[1] - m_spos[1];
const float dist = sqrtf(dx*dx + dy*dy);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, dist, duRGBA(64,16,0,220), 2.0f);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, dist, duRGBA(64,16,0,220), 2.0f, drawOffset);
dd.depthMask(true);
}
}
@ -1295,7 +1299,7 @@ void NavMeshTesterTool::handleRender()
{
for (int i = 0; i < m_npolys; ++i)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
dd.depthMask(false);
if (m_parent[i])
{
@ -1303,7 +1307,7 @@ void NavMeshTesterTool::handleRender()
dd.depthMask(false);
getPolyCenter(m_navMesh, m_parent[i], p0);
getPolyCenter(m_navMesh, m_polys[i], p1);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f, drawOffset);
dd.depthMask(true);
}
dd.depthMask(true);
@ -1313,7 +1317,7 @@ void NavMeshTesterTool::handleRender()
{
dd.depthMask(false);
const unsigned int col = duRGBA(64,16,0,220);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int i = 0, j = 3; i < 4; j=i++)
{
const float* p0 = &m_queryPoly[j*3];
@ -1329,7 +1333,7 @@ void NavMeshTesterTool::handleRender()
{
for (int i = 0; i < m_npolys; ++i)
{
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], pathCol);
duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_polys[i], drawOffset, drawFlags, pathCol);
dd.depthMask(false);
if (m_parent[i])
{
@ -1337,7 +1341,7 @@ void NavMeshTesterTool::handleRender()
dd.depthMask(false);
getPolyCenter(m_navMesh, m_parent[i], p0);
getPolyCenter(m_navMesh, m_polys[i], p1);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f);
duDebugDrawArc(&dd, p0[0],p0[1],p0[2], p1[0],p1[1],p1[2], 0.25f, 0.0f, 30.0f, duRGBA(0,0,0,128), 2.0f, drawOffset);
dd.depthMask(true);
}
@ -1347,7 +1351,7 @@ void NavMeshTesterTool::handleRender()
memset(refs, 0, sizeof(dtPolyRef)*MAX_SEGS);
int nsegs = 0;
m_navQuery->getPolyWallSegments(m_polys[i], &m_filter, segs, refs, &nsegs, MAX_SEGS);
dd.begin(DU_DRAW_LINES, 2.0f);
dd.begin(DU_DRAW_LINES, 2.0f, drawOffset);
for (int j = 0; j < nsegs; ++j)
{
const float* s = &segs[j*6];
@ -1395,14 +1399,14 @@ void NavMeshTesterTool::handleRender()
if (m_sposSet)
{
dd.depthMask(false);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_neighbourhoodRadius, duRGBA(64,16,0,220), 2.0f);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_neighbourhoodRadius, duRGBA(64,16,0,220), 2.0f, drawOffset);
dd.depthMask(true);
}
}
if (m_nrandPoints > 0)
{
dd.begin(DU_DRAW_POINTS, 6.0f);
dd.begin(DU_DRAW_POINTS, 6.0f, drawOffset);
for (int i = 0; i < m_nrandPoints; i++)
{
const float* p = &m_randPoints[i*3];
@ -1412,7 +1416,7 @@ void NavMeshTesterTool::handleRender()
if (m_randPointsInCircle && m_sposSet)
{
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_randomRadius, duRGBA(64,16,0,220), 2.0f);
duDebugDrawCircle(&dd, m_spos[0], m_spos[1], m_spos[2] + agentHeight / 2, m_randomRadius, duRGBA(64,16,0,220), 2.0f, drawOffset);
}
}
}
@ -1421,15 +1425,16 @@ void NavMeshTesterTool::handleRenderOverlay(double* proj, double* model, int* vi
{
GLdouble x, y, z;
const int h = view[3];
const float* drawOffset = m_editor->getDetourDrawOffset();
// Draw start and end point labels
if (m_sposSet && gluProject((GLdouble)m_spos[0], (GLdouble)m_spos[1], (GLdouble)m_spos[2],
if (m_sposSet && gluProject((GLdouble)m_spos[0]+drawOffset[0], (GLdouble)m_spos[1]+drawOffset[1], (GLdouble)m_spos[2]+drawOffset[2],
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter,
ImVec2((float)x, h-((float)y-25)), ImVec4(0,0,0,0.8f), "Start");
}
if (m_eposSet && gluProject((GLdouble)m_epos[0], (GLdouble)m_epos[1], (GLdouble)m_epos[2],
if (m_eposSet && gluProject((GLdouble)m_epos[0]+drawOffset[0], (GLdouble)m_epos[1]+drawOffset[1], (GLdouble)m_epos[2]+drawOffset[2],
model, proj, view, &x, &y, &z))
{
ImGui_RenderText(ImGuiTextAlign_e::kAlignCenter,
@ -1446,14 +1451,16 @@ void NavMeshTesterTool::drawAgent(const float* pos, float r, float h, float c, c
duDebugDraw& dd = m_editor->getDebugDraw();
dd.depthMask(false);
const float* drawOffset = m_editor->getDetourDrawOffset();
// Agent dimensions.
duDebugDrawCylinderWire(&dd, pos[0]-r, pos[1]-r, pos[2]+0.02f, pos[0]+r, pos[1]+r, pos[2]+h, col, 2.0f);
duDebugDrawCylinderWire(&dd, pos[0]-r, pos[1]-r, pos[2]+0.02f, pos[0]+r, pos[1]+r, pos[2]+h, col, 2.0f, drawOffset);
duDebugDrawCircle(&dd, pos[0],pos[1],pos[2] + c,r,duRGBA(0,0,0,64),1.0f);
duDebugDrawCircle(&dd, pos[0],pos[1],pos[2] + c,r,duRGBA(0,0,0,64),1.0f, drawOffset);
unsigned int colb = duRGBA(0,0,0,196);
dd.begin(DU_DRAW_LINES);
dd.begin(DU_DRAW_LINES, 1.0f, drawOffset);
dd.vertex(pos[0],pos[1],pos[2]-c,colb);
dd.vertex(pos[0],pos[1],pos[2]+c,colb);
dd.vertex(pos[0]-r/2,pos[1],pos[2]+0.02f,colb);

4
src/naveditor/OffMeshConnectionTool.cpp
View File

@ -138,11 +138,11 @@ void OffMeshConnectionTool::handleRender()
const float s = m_editor->getAgentRadius();
if (m_hitPosSet)
duDebugDrawCross(&dd, m_hitPos[0],m_hitPos[1],m_hitPos[2]+0.1f, s, duRGBA(0,0,0,128), 2.0f);
duDebugDrawCross(&dd, m_hitPos[0],m_hitPos[1],m_hitPos[2]+0.1f, s, duRGBA(0,0,0,128), 2.0f, nullptr);
InputGeom* geom = m_editor->getInputGeom();
if (geom)
geom->drawOffMeshConnections(&dd, true);
geom->drawOffMeshConnections(&dd, m_editor->getRecastDrawOffset(), true);
}
void OffMeshConnectionTool::handleRenderOverlay(double* proj, double* model, int* view)

7
src/naveditor/include/Editor.h
View File

@ -146,6 +146,8 @@ protected:
BuildContext* m_ctx;
EditorDebugDraw m_dd;
float m_recastDrawOffset[3];
float m_detourDrawOffset[3];
dtNavMesh* loadAll(std::string path);
void saveAll(std::string path, const dtNavMesh* mesh);
@ -163,6 +165,8 @@ public:
void setToolState(int type, EditorToolState* s) { m_toolStates[type] = s; }
EditorDebugDraw& getDebugDraw() { return m_dd; }
const float* getRecastDrawOffset() const { return m_recastDrawOffset; }
const float* getDetourDrawOffset() const { return m_detourDrawOffset; }
virtual void handleSettings();
virtual void handleTools();
@ -199,7 +203,8 @@ public:
void renderToolStates();
void renderOverlayToolStates(double* proj, double* model, int* view);
void renderNavMeshDebugMenu();
void renderMeshOffsetOptions();
void renderDetourDebugMenu();
void renderIntermediateTileMeshOptions();
void selectNavMeshType(const NavMeshType_e navMeshType);

5
src/naveditor/include/EditorInterfaces.h
View File

@ -67,12 +67,15 @@ class DebugDrawGL : public duDebugDraw
public:
virtual void depthMask(bool state);
virtual void texture(bool state);
virtual void begin(duDebugDrawPrimitives prim, float size = 1.0f);
virtual void begin(const duDebugDrawPrimitives prim, const float size = 1.0f, const float* offset = 0);
virtual void vertex(const float* pos, unsigned int color);
virtual void vertex(const float x, const float y, const float z, unsigned int color);
virtual void vertex(const float* pos, unsigned int color, const float* uv);
virtual void vertex(const float x, const float y, const float z, unsigned int color, const float u, const float v);
virtual void end();
private:
float m_drawOffset[3];
};
/// stdio file implementation.

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

@ -45,7 +45,7 @@ public:
Editor_StaticTileMeshCommon();
void cleanup();
void renderTileMeshRenderOptions();
void renderRecastDebugMenu();
void renderTileMeshData();
void renderIntermediateTileMeshOptions();
@ -82,7 +82,7 @@ class Editor_DynamicTileMeshCommon : public Editor
public:
Editor_DynamicTileMeshCommon();
void renderTileMeshRenderOptions();
void renderRecastRenderOptions();
void renderTileMeshData();
inline unsigned int getTileMeshDrawFlags() const { return m_tileMeshDrawFlags; }

4
src/naveditor/include/InputGeom.h
View File

@ -133,7 +133,7 @@ public:
void addOffMeshConnection(const float* spos, const float* epos, const float rad,
unsigned char bidir, unsigned char area, unsigned short flags);
void deleteOffMeshConnection(int i);
void drawOffMeshConnections(struct duDebugDraw* dd, bool hilight = false);
void drawOffMeshConnections(struct duDebugDraw* dd, const float* offset, bool hilight = false);
///@}
/// @name Box Volumes.
@ -143,7 +143,7 @@ public:
void addConvexVolume(const float* verts, const int nverts,
const float minh, const float maxh, unsigned char area);
void deleteConvexVolume(int i);
void drawConvexVolumes(struct duDebugDraw* dd, bool hilight = false);
void drawConvexVolumes(struct duDebugDraw* dd, const float* offset, bool hilight = false);
///@}
private:

33
src/thirdparty/recast/DebugUtils/Include/DebugDraw.h vendored
View File

@ -42,7 +42,7 @@ struct duDebugDraw
/// Begin drawing primitives.
/// @param prim [in] primitive type to draw, one of rcDebugDrawPrimitives.
/// @param size [in] size of a primitive, applies to point size and line width only.
virtual void begin(duDebugDrawPrimitives prim, float size = 1.0f) = 0;
virtual void begin(const duDebugDrawPrimitives prim, const float size = 1.0f, const float* offset = 0) = 0;
/// Submit a vertex
/// @param pos [in] position of the verts.
@ -129,37 +129,41 @@ inline unsigned int duTransCol(unsigned int c, unsigned int a)
void duCalcBoxColors(unsigned int* colors, unsigned int colTop, unsigned int colSide);
void duDebugDrawCylinderWire(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col, const float lineWidth);
float maxx, float maxy, float maxz, unsigned int col,
const float lineWidth, const float* offset);
void duDebugDrawBoxWire(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col, const float lineWidth);
float maxx, float maxy, float maxz, unsigned int col,
const float lineWidth, const float* offset);
void duDebugDrawArc(struct duDebugDraw* dd, const float x0, const float y0, const float z0,
const float x1, const float y1, const float z1, const float h,
const float as0, const float as1, unsigned int col, const float lineWidth);
const float as0, const float as1, unsigned int col,
const float lineWidth, const float* offset);
void duDebugDrawArrow(struct duDebugDraw* dd, const float x0, const float y0, const float z0,
const float x1, const float y1, const float z1,
const float as0, const float as1, unsigned int col, const float lineWidth);
const float as0, const float as1, unsigned int col,
const float lineWidth, const float* offset);
void duDebugDrawCircle(struct duDebugDraw* dd, const float x, const float y, const float z,
const float r, unsigned int col, const float lineWidth);
const float r, unsigned int col, const float lineWidth, const float* offset);
void duDebugDrawCross(struct duDebugDraw* dd, const float x, const float y, const float z,
const float size, unsigned int col, const float lineWidth);
const float size, unsigned int col, const float lineWidth, const float* offset);
void duDebugDrawBox(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, const unsigned int* fcol);
float maxx, float maxy, float maxz, const unsigned int* fcol, const float* offset);
void duDebugDrawCylinder(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col);
float maxx, float maxy, float maxz, unsigned int col, const float* offset);
void duDebugDrawGridXZ(struct duDebugDraw* dd, const float ox, const float oy, const float oz,
const int w, const int h, const float size,
const unsigned int col, const float lineWidth);
const unsigned int col, const float lineWidth, const float* offset);
void duDebugDrawGridXY(struct duDebugDraw* dd, const float ox, const float oy, const float oz,
const int w, const int h, const float size,
const unsigned int col, const float lineWidth);
const unsigned int col, const float lineWidth, const float* offset);
// Versions without begin/end, can be used to draw multiple primitives.
void duAppendCylinderWire(struct duDebugDraw* dd, float minx, float miny, float minz,
@ -196,12 +200,15 @@ class duDisplayList : public duDebugDraw
{
float* m_pos;
unsigned int* m_color;
int m_size;
int m_cap;
bool m_depthMask;
duDebugDrawPrimitives m_prim;
float m_primSize;
float m_drawOffset[3];
bool m_depthMask;
void resize(int cap);
@ -209,7 +216,7 @@ public:
duDisplayList(int cap = 512);
~duDisplayList();
virtual void depthMask(bool state);
virtual void begin(duDebugDrawPrimitives prim, float size = 1.0f);
virtual void begin(const duDebugDrawPrimitives prim, const float size = 1.0f, const float* offset = 0);
virtual void vertex(const float x, const float y, const float z, unsigned int color);
virtual void vertex(const float* pos, unsigned int color);
virtual void end();

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

@ -40,19 +40,21 @@ enum DrawNavMeshFlags
DU_DRAWNAVMESH_ALPHA = 1 << 12, // Use transparency.
};
void duDebugDrawNavMesh(struct duDebugDraw* dd, const dtNavMesh& mesh, unsigned int flags);
void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery& query, unsigned int flags);
void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query);
void duDebugDrawNavMeshBVTree(struct duDebugDraw* dd, const dtNavMesh& mesh);
void duDebugDrawNavMeshPortals(struct duDebugDraw* dd, const dtNavMesh& mesh);
void duDebugDrawNavMeshPolysWithFlags(struct duDebugDraw* dd, const dtNavMesh& mesh, const unsigned short polyFlags, const unsigned int col);
void duDebugDrawNavMeshPoly(struct duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef ref, const unsigned int col);
void duDebugDrawNavMesh(struct duDebugDraw* dd, const dtNavMesh& mesh, const float* offset, unsigned int flags);
void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery& query, const float* offset, unsigned int flags);
void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query, const float* offset);
void duDebugDrawNavMeshBVTree(struct duDebugDraw* dd, const dtNavMesh& mesh, const float* offset);
void duDebugDrawNavMeshPortals(struct duDebugDraw* dd, const dtNavMesh& mesh, const float* offset);
void duDebugDrawNavMeshPolysWithFlags(struct duDebugDraw* dd, const dtNavMesh& mesh, const unsigned short polyFlags, const float* offset,
const unsigned int drawFlags, const unsigned int col);
void duDebugDrawNavMeshPoly(struct duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef ref, const float* offset,
const unsigned int drawFlags, const unsigned int col);
void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch);
void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch);
void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch, const float* offset);
void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch, const float* offset);
void duDebugDrawTileCacheContours(duDebugDraw* dd, const struct dtTileCacheContourSet& lcset,
const float* orig, const float cs, const float ch);
const float* orig, const float cs, const float ch, const float* offset);
void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyMesh& lmesh,
const float* orig, const float cs, const float ch);
const float* orig, const float cs, const float ch, const float* offset);
#endif // DETOURDEBUGDRAW_H

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

@ -19,24 +19,26 @@
#ifndef RECAST_DEBUGDRAW_H
#define RECAST_DEBUGDRAW_H
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);
void duDebugDrawTriMeshSlope(struct duDebugDraw* dd, const float* verts, int nverts, const int* tris, const float* normals, int ntris, const float walkableSlopeAngle, const float texScale);
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,
const float walkableSlopeAngle, const float texScale, const float* offset);
void duDebugDrawHeightfieldSolid(struct duDebugDraw* dd, const struct rcHeightfield& hf);
void duDebugDrawHeightfieldWalkable(struct duDebugDraw* dd, const struct rcHeightfield& hf);
void duDebugDrawHeightfieldSolid(struct duDebugDraw* dd, const struct rcHeightfield& hf, const float* offset);
void duDebugDrawHeightfieldWalkable(struct duDebugDraw* dd, const struct rcHeightfield& hf, const float* offset);
void duDebugDrawCompactHeightfieldSolid(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf);
void duDebugDrawCompactHeightfieldRegions(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf);
void duDebugDrawCompactHeightfieldDistance(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf);
void duDebugDrawCompactHeightfieldSolid(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf, const float* offset);
void duDebugDrawCompactHeightfieldRegions(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf, const float* offset);
void duDebugDrawCompactHeightfieldDistance(struct duDebugDraw* dd, const struct rcCompactHeightfield& chf, const float* offset);
void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLayer& layer, const int idx);
void duDebugDrawHeightfieldLayers(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset);
void duDebugDrawHeightfieldLayersRegions(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset);
void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLayer& layer, const int idx, const float* offset);
void duDebugDrawHeightfieldLayers(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset, const float* offset);
void duDebugDrawHeightfieldLayersRegions(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset, const float* offset);
void duDebugDrawRegionConnections(struct duDebugDraw* dd, const struct rcContourSet& cset, const float alpha = 1.0f);
void duDebugDrawRawContours(struct duDebugDraw* dd, const struct rcContourSet& cset, const float alpha = 1.0f);
void duDebugDrawContours(struct duDebugDraw* dd, const struct rcContourSet& cset, const float alpha = 1.0f);
void duDebugDrawPolyMesh(struct duDebugDraw* dd, const struct rcPolyMesh& mesh);
void duDebugDrawPolyMeshDetail(struct duDebugDraw* dd, const struct rcPolyMeshDetail& dmesh);
void duDebugDrawRegionConnections(struct duDebugDraw* dd, const struct rcContourSet& cset, const float* offset, const float alpha = 1.0f);
void duDebugDrawRawContours(struct duDebugDraw* dd, const struct rcContourSet& cset, const float* offset, const float alpha = 1.0f);
void duDebugDrawContours(struct duDebugDraw* dd, const struct rcContourSet& cset, const float* offset, const float alpha = 1.0f);
void duDebugDrawPolyMesh(struct duDebugDraw* dd, const struct rcPolyMesh& mesh, const float* offset);
void duDebugDrawPolyMeshDetail(struct duDebugDraw* dd, const struct rcPolyMeshDetail& dmesh, const float* offset);
#endif // RECAST_DEBUGDRAW_H

62
src/thirdparty/recast/DebugUtils/Source/DebugDraw.cpp vendored
View File

@ -19,6 +19,7 @@
#define _USE_MATH_DEFINES
#include <string.h>
#include "DebugUtils/Include/DebugDraw.h"
#include "Detour/Include/DetourCommon.h"
#include "Detour/Include/DetourMath.h"
#include "Detour/Include/DetourNavMesh.h"
@ -77,94 +78,98 @@ void duCalcBoxColors(unsigned int* colors, unsigned int colTop, unsigned int col
}
void duDebugDrawCylinderWire(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col, const float lineWidth)
float maxx, float maxy, float maxz, unsigned int col,
const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendCylinderWire(dd, minx,miny,minz, maxx,maxy,maxz, col);
dd->end();
}
void duDebugDrawBoxWire(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col, const float lineWidth)
float maxx, float maxy, float maxz, unsigned int col,
const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendBoxWire(dd, minx,miny,minz, maxx,maxy,maxz, col);
dd->end();
}
void duDebugDrawArc(struct duDebugDraw* dd, const float x0, const float y0, const float z0,
const float x1, const float y1, const float z1, const float h,
const float as0, const float as1, unsigned int col, const float lineWidth)
const float as0, const float as1, unsigned int col,
const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendArc(dd, x0,y0,z0, x1,y1,z1, h, as0, as1, col);
dd->end();
}
void duDebugDrawArrow(struct duDebugDraw* dd, const float x0, const float y0, const float z0,
const float x1, const float y1, const float z1,
const float as0, const float as1, unsigned int col, const float lineWidth)
const float as0, const float as1, unsigned int col,
const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendArrow(dd, x0,y0,z0, x1,y1,z1, as0, as1, col);
dd->end();
}
void duDebugDrawCircle(struct duDebugDraw* dd, const float x, const float y, const float z,
const float r, unsigned int col, const float lineWidth)
const float r, unsigned int col, const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendCircle(dd, x,y,z, r, col);
dd->end();
}
void duDebugDrawCross(struct duDebugDraw* dd, const float x, const float y, const float z,
const float size, unsigned int col, const float lineWidth)
const float size, unsigned int col, const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
duAppendCross(dd, x,y,z, size, col);
dd->end();
}
void duDebugDrawBox(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, const unsigned int* fcol)
float maxx, float maxy, float maxz, const unsigned int* fcol, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
duAppendBox(dd, minx,miny,minz, maxx,maxy,maxz, fcol);
dd->end();
}
void duDebugDrawCylinder(struct duDebugDraw* dd, float minx, float miny, float minz,
float maxx, float maxy, float maxz, unsigned int col)
float maxx, float maxy, float maxz, unsigned int col, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
duAppendCylinder(dd, minx,miny,minz, maxx,maxy,maxz, col);
dd->end();
}
void duDebugDrawGridXZ(struct duDebugDraw* dd, const float ox, const float oy, const float oz,
const int w, const int h, const float size,
const unsigned int col, const float lineWidth)
const unsigned int col, const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
for (int i = 0; i <= h; ++i)
{
dd->vertex(ox,oy,oz+i*size, col);
@ -180,11 +185,11 @@ void duDebugDrawGridXZ(struct duDebugDraw* dd, const float ox, const float oy, c
void duDebugDrawGridXY(struct duDebugDraw* dd, const float ox, const float oy, const float oz,
const int w, const int h, const float size,
const unsigned int col, const float lineWidth)
const unsigned int col, const float lineWidth, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_LINES, lineWidth);
dd->begin(DU_DRAW_LINES, lineWidth, offset);
for (int i = 0; i <= h; ++i)
{
dd->vertex(ox,oy+i*size,oz, col);
@ -541,17 +546,18 @@ void duAppendCross(struct duDebugDraw* dd, const float x, const float y, const f
}
duDisplayList::duDisplayList(int cap) :
m_prim(DU_DRAW_LINES),
m_primSize(1.0f),
m_pos(0),
m_color(0),
m_size(0),
m_cap(0),
m_depthMask(true),
m_prim(DU_DRAW_LINES),
m_primSize(1.0f)
m_depthMask(true)
{
if (cap < 8)
cap = 8;
resize(cap);
dtVset(m_drawOffset, 0.0f,0.0f,0.0f);
}
duDisplayList::~duDisplayList()
@ -587,11 +593,13 @@ void duDisplayList::depthMask(bool state)
m_depthMask = state;
}
void duDisplayList::begin(duDebugDrawPrimitives prim, float size)
void duDisplayList::begin(const duDebugDrawPrimitives prim, const float size, const float* offset)
{
clear();
m_prim = prim;
m_primSize = size;
if (offset)
dtVcopy(m_drawOffset, offset);
}
void duDisplayList::vertex(const float x, const float y, const float z, unsigned int color)
@ -599,9 +607,8 @@ void duDisplayList::vertex(const float x, const float y, const float z, unsigned
if (m_size+1 >= m_cap)
resize(m_cap*2);
float* p = &m_pos[m_size*3];
p[0] = x;
p[1] = y;
p[2] = z;
dtVset(p,x,y,z);
dtVadd(p,p,m_drawOffset);
m_color[m_size] = color;
m_size++;
}
@ -613,6 +620,7 @@ void duDisplayList::vertex(const float* pos, unsigned int color)
void duDisplayList::end()
{
dtVset(m_drawOffset, 0.0f,0.0f,0.0f);
}
void duDisplayList::draw(struct duDebugDraw* dd)

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

@ -46,11 +46,11 @@ static void drawOffMeshConnectionRefPosition(duDebugDraw* dd, const dtOffMeshCon
}
static void drawPolyBoundaries(duDebugDraw* dd, const dtMeshTile* tile,
const float linew, bool inner)
const float linew, const float* offset, bool inner)
{
static const float thr = 0.01f*0.01f;
dd->begin(DU_DRAW_LINES, linew);
dd->begin(DU_DRAW_LINES, linew, offset);
for (int i = 0; i < tile->header->polyCount; ++i)
{
@ -124,17 +124,17 @@ static void drawPolyBoundaries(duDebugDraw* dd, const dtMeshTile* tile,
dd->end();
}
static void drawPolyCenters(duDebugDraw* dd, const dtMeshTile* tile, const unsigned int col, const float linew)
static void drawPolyCenters(duDebugDraw* dd, const dtMeshTile* tile, const unsigned int col, const float linew, const float* offset)
{
for (int i = 0; i < tile->header->polyCount; ++i)
{
const dtPoly* p = &tile->polys[i];
duDebugDrawCross(dd, p->center[0], p->center[1], p->center[2], 3.0f, col, linew);
duDebugDrawCross(dd, p->center[0], p->center[1], p->center[2], 3.0f, col, linew, offset);
}
}
static void drawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery* query,
const dtMeshTile* tile, unsigned int flags)
const dtMeshTile* tile, const float* offset, unsigned int flags)
{
// 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;
@ -144,7 +144,7 @@ static void drawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMesh
dd->depthMask(depthTest);
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < tile->header->polyCount; ++i)
{
const dtPoly* p = &tile->polys[i];
@ -182,19 +182,19 @@ static void drawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMesh
// Draw inner poly boundaries
if (flags & DU_DRAWNAVMESH_INNERBOUND)
drawPolyBoundaries(dd, tile, 2.5f, true);
drawPolyBoundaries(dd, tile, 2.5f, offset, true);
// Draw outer poly boundaries
if (flags & DU_DRAWNAVMESH_OUTERBOUND)
drawPolyBoundaries(dd, tile, 4.5f, false);
drawPolyBoundaries(dd, tile, 4.5f, offset, false);
// Draw poly centers
if (flags & DU_DRAWNAVMESH_POLYCENTERS)
drawPolyCenters(dd, tile, duRGBA(255, 255, 255, 100), 1.0f);
drawPolyCenters(dd, tile, duRGBA(255, 255, 255, 100), 1.0f, offset);
if (flags & DU_DRAWNAVMESH_OFFMESHCONS)
{
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < tile->header->polyCount; ++i)
{
const dtPoly* p = &tile->polys[i];
@ -253,7 +253,7 @@ static void drawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMesh
if (flags & DU_DRAWNAVMESH_VERTS)
{
const unsigned int vcol = duRGBA(0,0,0,196);
dd->begin(DU_DRAW_POINTS, 5.0f);
dd->begin(DU_DRAW_POINTS, 5.0f, offset);
for (int i = 0; i < tile->header->vertCount; ++i)
{
const float* v = &tile->verts[i*3];
@ -265,7 +265,7 @@ static void drawMeshTile(duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMesh
dd->depthMask(true);
}
void duDebugDrawNavMesh(duDebugDraw* dd, const dtNavMesh& mesh, unsigned int flags)
void duDebugDrawNavMesh(duDebugDraw* dd, const dtNavMesh& mesh, const float* offset, unsigned int flags)
{
if (!dd) return;
@ -273,11 +273,11 @@ void duDebugDrawNavMesh(duDebugDraw* dd, const dtNavMesh& mesh, unsigned int fla
{
const dtMeshTile* tile = mesh.getTile(i);
if (!tile->header) continue;
drawMeshTile(dd, mesh, 0, tile, flags);
drawMeshTile(dd, mesh, 0, tile, offset, flags);
}
}
void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery& query, unsigned int flags)
void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& mesh, const dtNavMeshQuery& query, const float* offset, unsigned int flags)
{
if (!dd) return;
@ -287,18 +287,18 @@ void duDebugDrawNavMeshWithClosedList(struct duDebugDraw* dd, const dtNavMesh& m
{
const dtMeshTile* tile = mesh.getTile(i);
if (!tile->header) continue;
drawMeshTile(dd, mesh, q, tile, flags);
drawMeshTile(dd, mesh, q, tile, offset, flags);
}
if (flags & DU_DRAWNAVMESH_BVTREE)
duDebugDrawNavMeshBVTree(dd, mesh);
duDebugDrawNavMeshBVTree(dd, mesh, offset);
if (flags & DU_DRAWNAVMESH_PORTALS)
duDebugDrawNavMeshPortals(dd, mesh);
duDebugDrawNavMeshPortals(dd, mesh, offset);
if (flags & DU_DRAWNAVMESH_NODES)
duDebugDrawNavMeshNodes(dd, query);
duDebugDrawNavMeshNodes(dd, query, offset);
}
void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query)
void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query, const float* offset)
{
if (!dd) return;
@ -306,7 +306,7 @@ void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query
if (pool)
{
const float off = 0.5f;
dd->begin(DU_DRAW_POINTS, 4.0f);
dd->begin(DU_DRAW_POINTS, 4.0f, offset);
for (int i = 0; i < pool->getHashSize(); ++i)
{
for (dtNodeIndex j = pool->getFirst(i); j != DT_NULL_IDX; j = pool->getNext(j))
@ -318,7 +318,7 @@ void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query
}
dd->end();
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < pool->getHashSize(); ++i)
{
for (dtNodeIndex j = pool->getFirst(i); j != DT_NULL_IDX; j = pool->getNext(j))
@ -337,11 +337,11 @@ void duDebugDrawNavMeshNodes(struct duDebugDraw* dd, const dtNavMeshQuery& query
}
static void drawMeshTileBVTree(duDebugDraw* dd, const dtMeshTile* tile)
static void drawMeshTileBVTree(duDebugDraw* dd, const dtMeshTile* tile, const float* offset)
{
// Draw BV nodes.
const float cs = 1.0f / tile->header->bvQuantFactor;
dd->begin(DU_DRAW_LINES, 1.0f);
dd->begin(DU_DRAW_LINES, 1.0f, offset);
for (int i = 0; i < tile->header->bvNodeCount; ++i)
{
const dtBVNode* n = &tile->bvTree[i];
@ -358,7 +358,7 @@ static void drawMeshTileBVTree(duDebugDraw* dd, const dtMeshTile* tile)
dd->end();
}
void duDebugDrawNavMeshBVTree(duDebugDraw* dd, const dtNavMesh& mesh)
void duDebugDrawNavMeshBVTree(duDebugDraw* dd, const dtNavMesh& mesh, const float* offset)
{
if (!dd) return;
@ -366,17 +366,17 @@ void duDebugDrawNavMeshBVTree(duDebugDraw* dd, const dtNavMesh& mesh)
{
const dtMeshTile* tile = mesh.getTile(i);
if (!tile->header) continue;
drawMeshTileBVTree(dd, tile);
drawMeshTileBVTree(dd, tile, offset);
}
}
static void drawMeshTilePortal(duDebugDraw* dd, const dtMeshTile* tile)
static void drawMeshTilePortal(duDebugDraw* dd, const dtMeshTile* tile, const float* offset)
{
// Draw portals
const float padx = 0.04f;
const float padz = tile->header->walkableClimb;
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int side = 0; side < 8; ++side)
{
@ -441,7 +441,7 @@ static void drawMeshTilePortal(duDebugDraw* dd, const dtMeshTile* tile)
dd->end();
}
void duDebugDrawNavMeshPortals(duDebugDraw* dd, const dtNavMesh& mesh)
void duDebugDrawNavMeshPortals(duDebugDraw* dd, const dtNavMesh& mesh, const float* offset)
{
if (!dd) return;
@ -449,12 +449,12 @@ void duDebugDrawNavMeshPortals(duDebugDraw* dd, const dtNavMesh& mesh)
{
const dtMeshTile* tile = mesh.getTile(i);
if (!tile->header) continue;
drawMeshTilePortal(dd, tile);
drawMeshTilePortal(dd, tile, offset);
}
}
void duDebugDrawNavMeshPolysWithFlags(struct duDebugDraw* dd, const dtNavMesh& mesh,
const unsigned short polyFlags, const unsigned int col)
void duDebugDrawNavMeshPolysWithFlags(struct duDebugDraw* dd, const dtNavMesh& mesh, const unsigned short polyFlags,
const float* offset, const unsigned int drawFlags, const unsigned int col)
{
if (!dd) return;
@ -468,12 +468,12 @@ void duDebugDrawNavMeshPolysWithFlags(struct duDebugDraw* dd, const dtNavMesh& m
{
const dtPoly* p = &tile->polys[j];
if ((p->flags & polyFlags) == 0) continue;
duDebugDrawNavMeshPoly(dd, mesh, base|(dtPolyRef)j, col);
duDebugDrawNavMeshPoly(dd, mesh, base|(dtPolyRef)j, offset, col, drawFlags);
}
}
}
void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef ref, const unsigned int col)
void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef ref, const float* offset, const unsigned int drawFlags, const unsigned int col)
{
if (!dd) return;
@ -489,24 +489,27 @@ void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef re
if (poly->getType() == DT_POLYTYPE_OFFMESH_CONNECTION)
{
dtOffMeshConnection* con = &tile->offMeshCons[ip - tile->header->offMeshBase];
if (drawFlags & DU_DRAWNAVMESH_OFFMESHCONS)
{
dtOffMeshConnection* con = &tile->offMeshCons[ip - tile->header->offMeshBase];
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
// Connection arc.
duAppendArc(dd, con->pos[0],con->pos[1],con->pos[2], con->pos[3],con->pos[4],con->pos[5], 0.25f,
(con->flags & DT_OFFMESH_CON_BIDIR) ? 30.0f : 0.0f, 30.0f, c);
// Connection arc.
duAppendArc(dd, con->pos[0],con->pos[1],con->pos[2], con->pos[3],con->pos[4],con->pos[5], 0.25f,
(con->flags & DT_OFFMESH_CON_BIDIR) ? 30.0f : 0.0f, 30.0f, c);
// Reference positions.
drawOffMeshConnectionRefPosition(dd, con);
// Reference positions.
drawOffMeshConnectionRefPosition(dd, con);
dd->end();
dd->end();
}
}
else
{
const dtPolyDetail* pd = &tile->detailMeshes[ip];
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < pd->triCount; ++i)
{
const unsigned char* t = &tile->detailTris[(pd->triBase+i)*4];
@ -525,7 +528,7 @@ void duDebugDrawNavMeshPoly(duDebugDraw* dd, const dtNavMesh& mesh, dtPolyRef re
}
static void debugDrawTileCachePortals(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch)
static void debugDrawTileCachePortals(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch, const float* offset)
{
const int w = (int)layer.header->width;
const int h = (int)layer.header->height;
@ -537,7 +540,7 @@ static void debugDrawTileCachePortals(struct duDebugDraw* dd, const dtTileCacheL
const int segs[4*4] = {0,0,0,1, 0,1,1,1, 1,1,1,0, 1,0,0,0};
// Layer portals
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
@ -566,7 +569,7 @@ static void debugDrawTileCachePortals(struct duDebugDraw* dd, const dtTileCacheL
dd->end();
}
void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch)
void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch, const float* offset)
{
const int w = (int)layer.header->width;
const int h = (int)layer.header->height;
@ -584,10 +587,10 @@ void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLay
lbmax[0] = bmin[0] + (layer.header->maxx+1)*cs;
lbmax[1] = bmax[1] + (layer.header->maxy+1)*cs;
lbmax[2] = bmin[2];
duDebugDrawBoxWire(dd, lbmin[0],lbmin[1],lbmin[2], lbmax[0],lbmax[1],lbmax[2], duTransCol(color,128), 2.0f);
duDebugDrawBoxWire(dd, lbmin[0],lbmin[1],lbmin[2], lbmax[0],lbmax[1],lbmax[2], duTransCol(color,128), 2.0f, offset);
// Layer height
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
@ -617,10 +620,10 @@ void duDebugDrawTileCacheLayerAreas(struct duDebugDraw* dd, const dtTileCacheLay
}
dd->end();
debugDrawTileCachePortals(dd, layer, cs, ch);
debugDrawTileCachePortals(dd, layer, cs, ch, offset);
}
void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch)
void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheLayer& layer, const float cs, const float ch, const float* offset)
{
const int w = (int)layer.header->width;
const int h = (int)layer.header->height;
@ -638,10 +641,10 @@ void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheL
lbmax[0] = bmin[0] + (layer.header->maxx+1)*cs;
lbmax[1] = bmax[1] + (layer.header->maxy+1)*cs;
lbmax[2] = bmin[2];
duDebugDrawBoxWire(dd, lbmin[0],lbmin[1],lbmin[2], lbmax[0],lbmax[1],lbmax[2], duTransCol(color,128), 2.0f);
duDebugDrawBoxWire(dd, lbmin[0],lbmin[1],lbmin[2], lbmax[0],lbmax[1],lbmax[2], duTransCol(color,128), 2.0f, offset);
// Layer height
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
@ -665,7 +668,7 @@ void duDebugDrawTileCacheLayerRegions(struct duDebugDraw* dd, const dtTileCacheL
}
dd->end();
debugDrawTileCachePortals(dd, layer, cs, ch);
debugDrawTileCachePortals(dd, layer, cs, ch, offset);
}
@ -686,7 +689,7 @@ struct dtTileCacheContourSet
};*/
void duDebugDrawTileCacheContours(duDebugDraw* dd, const struct dtTileCacheContourSet& lcset,
const float* orig, const float cs, const float ch)
const float* orig, const float cs, const float ch, const float* offset)
{
if (!dd) return;
@ -694,7 +697,7 @@ void duDebugDrawTileCacheContours(duDebugDraw* dd, const struct dtTileCacheConto
const int offs[2*4] = {-1,0, 0,1, 1,0, 0,-1};
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < lcset.nconts; ++i)
{
@ -738,7 +741,7 @@ void duDebugDrawTileCacheContours(duDebugDraw* dd, const struct dtTileCacheConto
}
dd->end();
dd->begin(DU_DRAW_POINTS, 4.0f);
dd->begin(DU_DRAW_POINTS, 4.0f, offset);
for (int i = 0; i < lcset.nconts; ++i)
{
@ -766,7 +769,7 @@ void duDebugDrawTileCacheContours(duDebugDraw* dd, const struct dtTileCacheConto
}
void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyMesh& lmesh,
const float* orig, const float cs, const float ch)
const float* orig, const float cs, const float ch, const float* offset)
{
if (!dd) return;
@ -774,7 +777,7 @@ void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyM
const int offs[2*4] = {-1,0, 0,1, 1,0, 0,-1};
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < lmesh.npolys; ++i)
{
@ -810,7 +813,7 @@ void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyM
// Draw neighbours edges
const unsigned int coln = duRGBA(0,48,64,32);
dd->begin(DU_DRAW_LINES, 1.5f);
dd->begin(DU_DRAW_LINES, 1.5f, offset);
for (int i = 0; i < lmesh.npolys; ++i)
{
const unsigned short* p = &lmesh.polys[i*nvp*2];
@ -835,7 +838,7 @@ void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyM
// Draw boundary edges
const unsigned int colb = duRGBA(0,48,64,220);
dd->begin(DU_DRAW_LINES, 4.5f);
dd->begin(DU_DRAW_LINES, 4.5f, offset);
for (int i = 0; i < lmesh.npolys; ++i)
{
const unsigned short* p = &lmesh.polys[i*nvp*2];
@ -887,7 +890,7 @@ void duDebugDrawTileCachePolyMesh(duDebugDraw* dd, const struct dtTileCachePolyM
}
dd->end();
dd->begin(DU_DRAW_POINTS, 5.0f);
dd->begin(DU_DRAW_POINTS, 5.0f, offset);
const unsigned int colv = duRGBA(0,0,0,220);
for (int i = 0; i < lmesh.nverts; ++i)
{

82
src/thirdparty/recast/DebugUtils/Source/RecastDebugDraw.cpp vendored
View File

@ -24,7 +24,7 @@
void duDebugDrawTriMesh(duDebugDraw* dd, const float* verts, int /*nverts*/,
const int* tris, const float* normals, int ntris,
const unsigned char* flags, const float texScale)
const unsigned char* flags, const float texScale, const float* offset)
{
if (!dd) return;
if (!verts) return;
@ -39,7 +39,7 @@ void duDebugDrawTriMesh(duDebugDraw* dd, const float* verts, int /*nverts*/,
dd->texture(true);
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < ntris*3; i += 3)
{
const float* norm = &normals[i];
@ -79,7 +79,7 @@ void duDebugDrawTriMesh(duDebugDraw* dd, const float* verts, int /*nverts*/,
void duDebugDrawTriMeshSlope(duDebugDraw* dd, const float* verts, int /*nverts*/,
const int* tris, const float* normals, int ntris,
const float walkableSlopeAngle, const float texScale)
const float walkableSlopeAngle, const float texScale, const float* offset)
{
if (!dd) return;
if (!verts) return;
@ -96,7 +96,7 @@ void duDebugDrawTriMeshSlope(duDebugDraw* dd, const float* verts, int /*nverts*/
const unsigned int unwalkable = duRGBA(192,128,0,255);
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < ntris*3; i += 3)
{
const float* norm = &normals[i];
@ -135,7 +135,7 @@ void duDebugDrawTriMeshSlope(duDebugDraw* dd, const float* verts, int /*nverts*/
dd->texture(false);
}
void duDebugDrawHeightfieldSolid(duDebugDraw* dd, const rcHeightfield& hf)
void duDebugDrawHeightfieldSolid(duDebugDraw* dd, const rcHeightfield& hf, const float* offset)
{
if (!dd) return;
@ -149,7 +149,7 @@ void duDebugDrawHeightfieldSolid(duDebugDraw* dd, const rcHeightfield& hf)
unsigned int fcol[6];
duCalcBoxColors(fcol, duRGBA(255,255,255,255), duRGBA(255,255,255,255));
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < h; ++y)
{
@ -168,7 +168,7 @@ void duDebugDrawHeightfieldSolid(duDebugDraw* dd, const rcHeightfield& hf)
dd->end();
}
void duDebugDrawHeightfieldWalkable(duDebugDraw* dd, const rcHeightfield& hf)
void duDebugDrawHeightfieldWalkable(duDebugDraw* dd, const rcHeightfield& hf, const float* offset)
{
if (!dd) return;
@ -182,7 +182,7 @@ void duDebugDrawHeightfieldWalkable(duDebugDraw* dd, const rcHeightfield& hf)
unsigned int fcol[6];
duCalcBoxColors(fcol, duRGBA(255,255,255,255), duRGBA(217,217,217,255));
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < h; ++y)
{
@ -209,14 +209,14 @@ void duDebugDrawHeightfieldWalkable(duDebugDraw* dd, const rcHeightfield& hf)
dd->end();
}
void duDebugDrawCompactHeightfieldSolid(duDebugDraw* dd, const rcCompactHeightfield& chf)
void duDebugDrawCompactHeightfieldSolid(duDebugDraw* dd, const rcCompactHeightfield& chf, const float* offset)
{
if (!dd) return;
const float cs = chf.cs;
const float ch = chf.ch;
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < chf.height; ++y)
{
@ -250,14 +250,14 @@ void duDebugDrawCompactHeightfieldSolid(duDebugDraw* dd, const rcCompactHeightfi
dd->end();
}
void duDebugDrawCompactHeightfieldRegions(duDebugDraw* dd, const rcCompactHeightfield& chf)
void duDebugDrawCompactHeightfieldRegions(duDebugDraw* dd, const rcCompactHeightfield& chf, const float* offset)
{
if (!dd) return;
const float cs = chf.cs;
const float ch = chf.ch;
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < chf.height; ++y)
{
@ -289,7 +289,7 @@ void duDebugDrawCompactHeightfieldRegions(duDebugDraw* dd, const rcCompactHeight
}
void duDebugDrawCompactHeightfieldDistance(duDebugDraw* dd, const rcCompactHeightfield& chf)
void duDebugDrawCompactHeightfieldDistance(duDebugDraw* dd, const rcCompactHeightfield& chf, const float* offset)
{
if (!dd) return;
if (!chf.dist) return;
@ -301,7 +301,7 @@ void duDebugDrawCompactHeightfieldDistance(duDebugDraw* dd, const rcCompactHeigh
if (maxd < 1.0f) maxd = 1;
const float dscale = 255.0f / maxd;
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < chf.height; ++y)
{
@ -327,7 +327,7 @@ void duDebugDrawCompactHeightfieldDistance(duDebugDraw* dd, const rcCompactHeigh
dd->end();
}
static void drawLayerPortals(duDebugDraw* dd, const rcHeightfieldLayer* layer)
static void drawLayerPortals(duDebugDraw* dd, const rcHeightfieldLayer* layer, const float* offset)
{
const float cs = layer->cs;
const float ch = layer->ch;
@ -339,7 +339,7 @@ static void drawLayerPortals(duDebugDraw* dd, const rcHeightfieldLayer* layer)
const int segs[4*4] = {0,0,0,1, 0,1,1,1, 1,1,1,0, 1,0,0,0};
// Layer portals
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
@ -368,7 +368,7 @@ static void drawLayerPortals(duDebugDraw* dd, const rcHeightfieldLayer* layer)
dd->end();
}
void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLayer& layer, const int idx)
void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLayer& layer, const int idx, const float* offset)
{
const float cs = layer.cs;
const float ch = layer.ch;
@ -385,10 +385,10 @@ void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLaye
bmax[0] = layer.bmin[0] + (layer.maxx+1)*cs;
bmax[1] = layer.bmax[1] + (layer.maxy+1)*cs;
bmax[2] = layer.bmin[2];
duDebugDrawBoxWire(dd, bmin[0],bmin[1],bmin[2], bmax[0],bmax[1],bmax[2], duTransCol(color,128), 2.0f);
duDebugDrawBoxWire(dd, bmin[0],bmin[1],bmin[2], bmax[0],bmax[1],bmax[2], duTransCol(color,128), 2.0f, 0);
// Layer height
dd->begin(DU_DRAW_QUADS);
dd->begin(DU_DRAW_QUADS, 1.0f, offset);
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
@ -419,14 +419,14 @@ void duDebugDrawHeightfieldLayer(duDebugDraw* dd, const struct rcHeightfieldLaye
dd->end();
// Portals
drawLayerPortals(dd, &layer);
drawLayerPortals(dd, &layer, offset);
}
void duDebugDrawHeightfieldLayers(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset)
void duDebugDrawHeightfieldLayers(duDebugDraw* dd, const struct rcHeightfieldLayerSet& lset, const float* offset)
{
if (!dd) return;
for (int i = 0; i < lset.nlayers; ++i)
duDebugDrawHeightfieldLayer(dd, lset.layers[i], i);
duDebugDrawHeightfieldLayer(dd, lset.layers[i], i, offset);
}
static void getContourCenter(const rcContour* cont, const float* orig, float cs, float ch, float* center)
@ -462,7 +462,7 @@ static const rcContour* findContourFromSet(const rcContourSet& cset, unsigned sh
return 0;
}
void duDebugDrawRegionConnections(duDebugDraw* dd, const rcContourSet& cset, const float alpha)
void duDebugDrawRegionConnections(duDebugDraw* dd, const rcContourSet& cset, const float* offset, const float alpha)
{
if (!dd) return;
@ -475,7 +475,7 @@ void duDebugDrawRegionConnections(duDebugDraw* dd, const rcContourSet& cset, con
unsigned int color = duRGBA(0,0,0,196);
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -498,7 +498,7 @@ void duDebugDrawRegionConnections(duDebugDraw* dd, const rcContourSet& cset, con
unsigned char a = (unsigned char)(alpha * 255.0f);
dd->begin(DU_DRAW_POINTS, 7.0f);
dd->begin(DU_DRAW_POINTS, 7.0f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -510,7 +510,7 @@ void duDebugDrawRegionConnections(duDebugDraw* dd, const rcContourSet& cset, con
dd->end();
}
void duDebugDrawRawContours(duDebugDraw* dd, const rcContourSet& cset, const float alpha)
void duDebugDrawRawContours(duDebugDraw* dd, const rcContourSet& cset, const float* offset, const float alpha)
{
if (!dd) return;
@ -520,7 +520,7 @@ void duDebugDrawRawContours(duDebugDraw* dd, const rcContourSet& cset, const flo
const unsigned char a = (unsigned char)(alpha*255.0f);
dd->begin(DU_DRAW_LINES, 2.0f);
dd->begin(DU_DRAW_LINES, 2.0f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -546,7 +546,7 @@ void duDebugDrawRawContours(duDebugDraw* dd, const rcContourSet& cset, const flo
}
dd->end();
dd->begin(DU_DRAW_POINTS, 2.0f);
dd->begin(DU_DRAW_POINTS, 2.0f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -573,7 +573,7 @@ void duDebugDrawRawContours(duDebugDraw* dd, const rcContourSet& cset, const flo
dd->end();
}
void duDebugDrawContours(duDebugDraw* dd, const rcContourSet& cset, const float alpha)
void duDebugDrawContours(duDebugDraw* dd, const rcContourSet& cset, const float* offset, const float alpha)
{
if (!dd) return;
@ -583,7 +583,7 @@ void duDebugDrawContours(duDebugDraw* dd, const rcContourSet& cset, const float
const unsigned char a = (unsigned char)(alpha*255.0f);
dd->begin(DU_DRAW_LINES, 4.5f);
dd->begin(DU_DRAW_LINES, 4.5f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -610,7 +610,7 @@ void duDebugDrawContours(duDebugDraw* dd, const rcContourSet& cset, const float
}
dd->end();
dd->begin(DU_DRAW_POINTS, 5.0f);
dd->begin(DU_DRAW_POINTS, 5.0f, offset);
for (int i = 0; i < cset.nconts; ++i)
{
@ -636,7 +636,7 @@ void duDebugDrawContours(duDebugDraw* dd, const rcContourSet& cset, const float
dd->end();
}
void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh, const float* offset)
{
if (!dd) return;
@ -645,7 +645,7 @@ void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
const float ch = mesh.ch;
const float* orig = mesh.bmin;
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < mesh.npolys; ++i)
{
@ -681,7 +681,7 @@ void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
// Draw neighbours edges
const unsigned int coln = duRGBA(0,48,64,32);
dd->begin(DU_DRAW_LINES, 1.5f);
dd->begin(DU_DRAW_LINES, 1.5f, offset);
for (int i = 0; i < mesh.npolys; ++i)
{
const unsigned short* p = &mesh.polys[i*nvp*2];
@ -706,7 +706,7 @@ void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
// Draw boundary edges
const unsigned int colb = duRGBA(0,48,64,220);
dd->begin(DU_DRAW_LINES, 4.5f);
dd->begin(DU_DRAW_LINES, 4.5f, offset);
for (int i = 0; i < mesh.npolys; ++i)
{
const unsigned short* p = &mesh.polys[i*nvp*2];
@ -732,7 +732,7 @@ void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
}
dd->end();
dd->begin(DU_DRAW_POINTS, 5.0f);
dd->begin(DU_DRAW_POINTS, 5.0f, offset);
const unsigned int colv = duRGBA(0,0,0,220);
for (int i = 0; i < mesh.nverts; ++i)
{
@ -745,11 +745,11 @@ void duDebugDrawPolyMesh(duDebugDraw* dd, const struct rcPolyMesh& mesh)
dd->end();
}
void duDebugDrawPolyMeshDetail(duDebugDraw* dd, const struct rcPolyMeshDetail& dmesh)
void duDebugDrawPolyMeshDetail(duDebugDraw* dd, const struct rcPolyMeshDetail& dmesh, const float* offset)
{
if (!dd) return;
dd->begin(DU_DRAW_TRIS);
dd->begin(DU_DRAW_TRIS, 1.0f, offset);
for (int i = 0; i < dmesh.nmeshes; ++i)
{
@ -772,7 +772,7 @@ void duDebugDrawPolyMeshDetail(duDebugDraw* dd, const struct rcPolyMeshDetail& d
dd->end();
// Internal edges.
dd->begin(DU_DRAW_LINES, 0.8f);
dd->begin(DU_DRAW_LINES, 0.8f, offset);
const unsigned int coli = duRGBA(0,0,0,64);
for (int i = 0; i < dmesh.nmeshes; ++i)
{
@ -804,7 +804,7 @@ void duDebugDrawPolyMeshDetail(duDebugDraw* dd, const struct rcPolyMeshDetail& d
dd->end();
// External edges.
dd->begin(DU_DRAW_LINES, 4.5f);
dd->begin(DU_DRAW_LINES, 4.5f, offset);
const unsigned int cole = duRGBA(0,0,0,64);
for (int i = 0; i < dmesh.nmeshes; ++i)
{
@ -832,7 +832,7 @@ void duDebugDrawPolyMeshDetail(duDebugDraw* dd, const struct rcPolyMeshDetail& d
}
dd->end();
dd->begin(DU_DRAW_POINTS, 5.0f);
dd->begin(DU_DRAW_POINTS, 5.0f, offset);
const unsigned int colv = duRGBA(0,0,0,64);
for (int i = 0; i < dmesh.nmeshes; ++i)
{