void LogPathPartHelper(AActor* LogOwner, FNavMeshPath* NavMeshPath, int32 StartIdx, int32 EndIdx)
{
#if ENABLE_VISUAL_LOG && WITH_RECAST
ARecastNavMesh* NavMesh = Cast<ARecastNavMesh>(NavMeshPath->GetNavigationDataUsed());
if (NavMesh == NULL ||
!NavMeshPath->PathCorridor.IsValidIndex(StartIdx) ||
!NavMeshPath->PathCorridor.IsValidIndex(EndIdx))
{
return;
}
NavMesh->BeginBatchQuery();
FVector SegmentStart = NavMeshPath->GetPathPoints()[0].Location;
FVector SegmentEnd(FVector::ZeroVector);
if (StartIdx > 0)
{
NavMesh->GetPolyCenter(NavMeshPath->PathCorridor[StartIdx], SegmentStart);
}
for (int32 Idx = StartIdx + 1; Idx < EndIdx; Idx++)
{
NavMesh->GetPolyCenter(NavMeshPath->PathCorridor[Idx], SegmentEnd);
UE_VLOG_SEGMENT_THICK(LogOwner, LogCrowdFollowing, Log, SegmentStart, SegmentEnd, FColor::Yellow, 2, TEXT_EMPTY);
SegmentStart = SegmentEnd;
}
if (EndIdx == (NavMeshPath->PathCorridor.Num() - 1))
{
SegmentEnd = NavMeshPath->GetPathPoints()[1].Location;
}
else
{
NavMesh->GetPolyCenter(NavMeshPath->PathCorridor[EndIdx], SegmentEnd);
}
UE_VLOG_SEGMENT_THICK(LogOwner, LogCrowdFollowing, Log, SegmentStart, SegmentEnd, FColor::Yellow, 2, TEXT_EMPTY);
NavMesh->FinishBatchQuery();
#endif // ENABLE_VISUAL_LOG && WITH_RECAST
}
void UCrowdManager::DebugTick() const
{
#if WITH_RECAST
if (DetourCrowd == NULL || DetourAgentDebug == NULL)
{
return;
}
for (auto It = ActiveAgents.CreateConstIterator(); It; ++It)
{
const FCrowdAgentData& AgentData = It.Value();
if (AgentData.IsValid())
{
UpdateSelectedDebug(It.Key(), AgentData.AgentIndex);
}
}
// on screen debugging
const dtCrowdAgent* SelectedAgent = DetourAgentDebug->idx >= 0 ? DetourCrowd->getAgent(DetourAgentDebug->idx) : NULL;
if (SelectedAgent && CrowdDebugDrawing::bDebugSelectedActors)
{
if (CrowdDebugDrawing::bDrawDebugCorners)
{
DrawDebugCorners(SelectedAgent);
}
if (CrowdDebugDrawing::bDrawDebugCollisionSegments)
{
DrawDebugCollisionSegments(SelectedAgent);
}
if (CrowdDebugDrawing::bDrawDebugPath)
{
DrawDebugPath(SelectedAgent);
}
if (CrowdDebugDrawing::bDrawDebugVelocityObstacles)
{
DrawDebugVelocityObstacles(SelectedAgent);
}
if (CrowdDebugDrawing::bDrawDebugPathOptimization)
{
DrawDebugPathOptimization(SelectedAgent);
}
if (CrowdDebugDrawing::bDrawDebugNeighbors)
{
DrawDebugNeighbors(SelectedAgent);
}
}
if (CrowdDebugDrawing::bDrawDebugBoundaries)
{
DrawDebugSharedBoundary();
}
// vislog debugging
if (CrowdDebugDrawing::bDebugVisLog)
{
for (auto It = ActiveAgents.CreateConstIterator(); It; ++It)
{
const ICrowdAgentInterface* IAgent = It.Key();
const UObject* AgentOb = IAgent ? Cast<const UObject>(IAgent) : NULL;
const AActor* LogOwner = AgentOb ? Cast<const AActor>(AgentOb->GetOuter()) : NULL;
const FCrowdAgentData& AgentData = It.Value();
const dtCrowdAgent* CrowdAgent = AgentData.IsValid() ? DetourCrowd->getAgent(AgentData.AgentIndex) : NULL;
if (CrowdAgent && LogOwner)
{
FString LogData = DetourAgentDebug->agentLog.FindRef(AgentData.AgentIndex);
if (LogData.Len() > 0)
{
UE_VLOG(LogOwner, LogCrowdFollowing, Log, *LogData);
}
{
FVector P0 = Recast2UnrealPoint(CrowdAgent->npos);
for (int32 Idx = 0; Idx < CrowdAgent->ncorners; Idx++)
{
FVector P1 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[Idx * 3]);
UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0 + CrowdDebugDrawing::Offset, P1 + CrowdDebugDrawing::Offset, CrowdDebugDrawing::Corner, TEXT(""));
UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P1 + CrowdDebugDrawing::Offset, FVector(2, 2, 2)), CrowdDebugDrawing::Corner, TEXT("%d"), CrowdAgent->cornerFlags[Idx]);
P0 = P1;
}
}
ARecastNavMesh* RecastNavData = Cast<ARecastNavMesh>(MyNavData);
if (RecastNavData)
{
for (int32 Idx = 0; Idx < CrowdAgent->corridor.getPathCount(); Idx++)
{
dtPolyRef PolyRef = CrowdAgent->corridor.getPath()[Idx];
TArray<FVector> PolyPoints;
RecastNavData->GetPolyVerts(PolyRef, PolyPoints);
UE_VLOG_CONVEXPOLY(LogOwner, LogCrowdFollowing, Verbose, PolyPoints, FColor::Cyan, TEXT(""));
}
}
if (CrowdAgent->ncorners && (CrowdAgent->cornerFlags[CrowdAgent->ncorners - 1] & DT_STRAIGHTPATH_OFFMESH_CONNECTION))
{
FVector P0 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[(CrowdAgent->ncorners - 1) * 3]);
UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0, P0 + CrowdDebugDrawing::Offset * 2.0f, CrowdDebugDrawing::CornerLink, TEXT(""));
}
if (CrowdAgent->corridor.hasNextFixedCorner())
{
FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner());
UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT(""));
}
if (CrowdAgent->corridor.hasNextFixedCorner2())
{
FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner2());
UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT(""));
}
for (int32 Idx = 0; Idx < CrowdAgent->boundary.getSegmentCount(); Idx++)
{
const float* s = CrowdAgent->boundary.getSegment(Idx);
const int32 SegFlags = CrowdAgent->boundary.getSegmentFlags(Idx);
const FColor Color = (SegFlags & DT_CROWD_BOUNDARY_IGNORE) ? CrowdDebugDrawing::CollisionSegIgnored :
(dtTriArea2D(CrowdAgent->npos, s, s + 3) < 0.0f) ? CrowdDebugDrawing::CollisionSeg1 :
CrowdDebugDrawing::CollisionSeg0;
FVector Pt0 = Recast2UnrealPoint(s);
FVector Pt1 = Recast2UnrealPoint(s + 3);
UE_VLOG_SEGMENT_THICK(LogOwner, LogCrowdFollowing, Log, Pt0 + CrowdDebugDrawing::Offset, Pt1 + CrowdDebugDrawing::Offset, Color, 3.0f, TEXT(""));
}
}
}
}
DetourAgentDebug->agentLog.Reset();
#endif // WITH_RECAST
}