void ATheHUD::DrawHUD()
{
// Canvas is only initialized here.
Super::DrawHUD();
InitWidgets();
RenderPortrait();
// Render the minimap, only if the floor is present
FBox box = Game->flycam->floor->GetBox();
FVector lookPt = box.GetCenter();
RenderScreen( rendererMinimap, lookPt, box.GetExtent().GetMax(), FVector( 0, 0, -1 ) );
ui->SetSize( FVector2D( Canvas->SizeX, Canvas->SizeY ) );
ui->Update( Game->gm->T ); // Ticked here, in case reflow is needed
ui->render();
// Overlay the lines for the minimap's view.
vector< FVector2D > pts = ui->gameChrome->rightPanel->minimap->pts;
for( int i = 0; i < pts.size()-1; i++ )
{
Canvas->K2_DrawLine( pts[i], pts[i+1], 2.f, FLinearColor::Green );
}
if( pts.size() > 1 )
{
Canvas->K2_DrawLine( pts[ pts.size()-1 ], pts[ 0 ], 2.f, FLinearColor::Green );
}
}
void ASpacePartioner::Initialize(const float& inExtent, const bool& inDrawDebugInfo)
{
bInitialized = true;
bDrawDebugInfo = inDrawDebugInfo;
// The Extent is very similar to the radius of a circle
FVector min = FVector(-inExtent, -inExtent, -inExtent);
FVector max = FVector(inExtent, inExtent, inExtent);
FBox NewBounds = FBox(min, max);
OctreeData = new FSimpleOctree(NewBounds.GetCenter(), NewBounds.GetExtent().GetMax()); // const FVector & InOrigin, float InExtent
}
void AStrategyHUD::DrawHealthBar(AActor* ForActor, float HealthPercentage, int32 BarHeight, int32 OffsetY) const
{
FBox BB = ForActor->GetComponentsBoundingBox();
FVector Center = BB.GetCenter();
FVector Extent = BB.GetExtent();
FVector2D Center2D = FVector2D(Canvas->Project(FVector(Center.X,Center.Y,Center.Z + Extent.Z)));
float ActorExtent = 40;
if (Cast<APawn>(ForActor) != NULL)
{
AStrategyChar* StrategyChar = Cast<AStrategyChar>(ForActor);
if( ( StrategyChar != NULL ) && ( StrategyChar->GetCapsuleComponent() != NULL ) )
{
ActorExtent = StrategyChar->GetCapsuleComponent()->GetScaledCapsuleRadius();
}
}
else if (Cast<AStrategyBuilding>(ForActor) != NULL)
{
Center2D = FVector2D(Canvas->Project(ForActor->GetActorLocation()));
ActorExtent = 60;
}
FVector Pos1 = Canvas->Project(FVector(Center.X,Center.Y - ActorExtent*2, Center.Z + Extent.Z));
FVector Pos2 = Canvas->Project(FVector(Center.X,Center.Y + ActorExtent*2, Center.Z + Extent.Z));
float HealthBarLength = (Pos2-Pos1).Size2D();
AStrategyPlayerController* MyPC = GetPlayerController();
IStrategyTeamInterface* ActorTeam = Cast<IStrategyTeamInterface>(ForActor);
UTexture2D* HealthBarTexture = EnemyTeamHPTexture;
if (ActorTeam != NULL && MyPC != NULL && ActorTeam->GetTeamNum() == MyPC->GetTeamNum())
{
HealthBarTexture = PlayerTeamHPTexture;
}
float X = Center2D.X - HealthBarLength/2;
float Y = Center2D.Y + OffsetY;
FCanvasTileItem TileItem( FVector2D( X, Y ), HealthBarTexture->Resource, FVector2D( HealthBarLength * HealthPercentage, BarHeight ), FLinearColor::White );
TileItem.BlendMode = SE_BLEND_Translucent;
TileItem.UV1 = FVector2D(HealthPercentage, 1.0f);
Canvas->DrawItem( TileItem );
//Fill the rest of health with gray gradient texture
X = Center2D.X-HealthBarLength/2 + HealthBarLength * HealthPercentage;
Y = Center2D.Y + OffsetY;
TileItem.Position = FVector2D( X, Y );
TileItem.Texture = BarFillTexture->Resource;
TileItem.UV1 = FVector2D(1.0f, 1.0f);
TileItem.Size = FVector2D( HealthBarLength * (1.0f - HealthPercentage), BarHeight );
TileItem.SetColor(FLinearColor(0.5f, 0.5f, 0.5f, 0.5f));
Canvas->DrawItem( TileItem );
}
void UHUDBlueprintLibrary::Projected2DBoundsWithOriginAndExtent(UObject* WorldContextObject, FVector Origin, FVector Extents,FVector2D &OutCenter, FVector2D &OutSize)
{
const FVector BoundsPointMapping[8] =
{
FVector(1.f, 1.f, 1.f),
FVector(1.f, 1.f, -1.f),
FVector(1.f, -1.f, 1.f),
FVector(1.f, -1.f, -1.f),
FVector(-1.f, 1.f, 1.f),
FVector(-1.f, 1.f, -1.f),
FVector(-1.f, -1.f, 1.f),
FVector(-1.f, -1.f, -1.f)
};
UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject);
APlayerController *PlayerController = UGameplayStatics::GetPlayerController(World, 0);
if (!PlayerController || !PlayerController->IsValidLowLevelFast()) return;
FBox ActorBox = FBox::BuildAABB(Origin, Extents);
FVector ActorCenter = ActorBox.GetCenter();
FVector2D ProjectedCenter;
float MinX, MinY, MaxX, MaxY;
PlayerController->ProjectWorldLocationToScreen(ActorCenter, ProjectedCenter);
MinX = MaxX = ProjectedCenter.X;
MinY = MaxY = ProjectedCenter.Y;
//FBox2D ActorBox2D(0);
for (uint8 BoundsPointItr = 0; BoundsPointItr < 8; BoundsPointItr++)
{
// Project vert into screen space.
FVector Corner = ActorCenter + (BoundsPointMapping[BoundsPointItr] * Extents);
FVector2D ProjectedCorner;
PlayerController->ProjectWorldLocationToScreen(Corner, ProjectedCorner);
if (MinX > ProjectedCorner.X) MinX = ProjectedCorner.X;
if (MaxX < ProjectedCorner.X) MaxX = ProjectedCorner.X;
if (MinY > ProjectedCorner.Y) MinY = ProjectedCorner.Y;
if (MaxY < ProjectedCorner.Y) MaxY = ProjectedCorner.Y;
//ActorBox2D += ProjectedWorldLocation;
}
OutCenter.X = MinX + ((MaxX - MinX) / 2.f);
OutCenter.Y = MinY + ((MaxY - MinY) / 2.f);
OutSize.X = fabsf(MaxX - MinX);
OutSize.Y = fabsf(MaxY - MinY);
}
void FVertexSnappingImpl::GetActorsInsideBox( const FBox& Box, UWorld* World, TArray<FSnapActor>& OutActorsInBox, const TSet< TWeakObjectPtr<AActor> >& ActorsToIgnore, const FSceneView* View )
{
for( FActorIterator It(World); It; ++It )
{
AActor* Actor = *It;
// Ignore the builder brush, hidden actors and forcefully ignored actors (actors being moved)
if( Actor != World->GetDefaultBrush() && It->IsHiddenEd() == false && !ActorsToIgnore.Contains( Actor ) )
{
const bool bNonColliding = true;
FBox ActorBoundingBox = Actor->GetComponentsBoundingBox(true);
// Actors must be within the bounding box and within the view frustum
if( Box.Intersect( ActorBoundingBox ) && View->ViewFrustum.IntersectBox( ActorBoundingBox.GetCenter(), ActorBoundingBox.GetExtent() ) )
{
OutActorsInBox.Add( FSnapActor( Actor, Box ) );
}
}
}
}
void ALevelBounds::UpdateLevelBounds()
{
FBox LevelBounds = CalculateLevelBounds(GetLevel());
if (LevelBounds.IsValid)
{
FVector LevelCenter = LevelBounds.GetCenter();
FVector LevelSize = LevelBounds.GetSize();
SetActorTransform(FTransform(FQuat::Identity, LevelCenter, LevelSize));
bUsingDefaultBounds = false;
}
else
{
SetActorTransform(FTransform(FQuat::Identity, FVector::ZeroVector, DefaultLevelSize));
bUsingDefaultBounds = true;
}
BroadcastLevelBoundsUpdated();
}
/**
* Calculates a tight box-sphere bounds for the aggregate geometry; this is more expensive than CalcAABB
* (tight meaning the sphere may be smaller than would be required to encompass the AABB, but all individual components lie within both the box and the sphere)
*
* @param Output The output box-sphere bounds calculated for this set of aggregate geometry
* @param LocalToWorld Transform
*/
void FKAggregateGeom::CalcBoxSphereBounds(FBoxSphereBounds& Output, const FTransform& LocalToWorld) const
{
// Calculate the AABB
const FBox AABB = CalcAABB(LocalToWorld);
if ((SphereElems.Num() == 0) && (SphylElems.Num() == 0) && (BoxElems.Num() == 0))
{
// For bounds that only consist of convex shapes (such as anything generated from a BSP model),
// we can get nice tight bounds by considering just the points of the convex shape
const FVector Origin = AABB.GetCenter();
float RadiusSquared = 0.0f;
for (int32 i = 0; i < ConvexElems.Num(); i++)
{
const FKConvexElem& Elem = ConvexElems[i];
for (int32 j = 0; j < Elem.VertexData.Num(); ++j)
{
const FVector Point = LocalToWorld.TransformPosition(Elem.VertexData[j]);
RadiusSquared = FMath::Max(RadiusSquared, (Point - Origin).SizeSquared());
}
}
// Push the resulting AABB and sphere into the output
AABB.GetCenterAndExtents(Output.Origin, Output.BoxExtent);
Output.SphereRadius = FMath::Sqrt(RadiusSquared);
}
else if ((SphereElems.Num() == 1) && (SphylElems.Num() == 0) && (BoxElems.Num() == 0) && (ConvexElems.Num() == 0))
{
// For bounds that only consist of a single sphere,
// we can be certain the box extents are the same as its radius
AABB.GetCenterAndExtents(Output.Origin, Output.BoxExtent);
Output.SphereRadius = Output.BoxExtent.X;
}
else
{
// Just use the loose sphere bounds that totally fit the AABB
Output = FBoxSphereBounds(AABB);
}
}
void UStretchGizmoHandleGroup::UpdateGizmoHandleGroup( const FTransform& LocalToWorld, const FBox& LocalBounds, const FVector ViewLocation, bool bAllHandlesVisible, class UActorComponent* DraggingHandle, const TArray< UActorComponent* >& HoveringOverHandles,
float AnimationAlpha, float GizmoScale, const float GizmoHoverScale, const float GizmoHoverAnimationDuration, bool& bOutIsHoveringOrDraggingThisHandleGroup )
{
// Call parent implementation (updates hover animation)
Super::UpdateGizmoHandleGroup(LocalToWorld, LocalBounds, ViewLocation, bAllHandlesVisible, DraggingHandle, HoveringOverHandles,
AnimationAlpha, GizmoScale, GizmoHoverScale, GizmoHoverAnimationDuration, bOutIsHoveringOrDraggingThisHandleGroup );
for (int32 HandleIndex = 0; HandleIndex < Handles.Num(); ++HandleIndex)
{
FGizmoHandle& Handle = Handles[ HandleIndex ];
UStaticMeshComponent* StretchingHandle = Handle.HandleMesh;
if (StretchingHandle != nullptr) // Can be null if no handle for this specific placement
{
const FTransformGizmoHandlePlacement HandlePlacement = MakeHandlePlacementForIndex( HandleIndex );
float GizmoHandleScale = GizmoScale;
const float OffsetFromSide = GizmoHandleScale *
(0.0f + // @todo vreditor tweak: Hard coded handle offset from side of primitive
(1.0f - AnimationAlpha) * 10.0f); // @todo vreditor tweak: Animation offset
// Make the handle bigger while hovered (but don't affect the offset -- we want it to scale about it's origin)
GizmoHandleScale *= FMath::Lerp( 1.0f, GizmoHoverScale, Handle.HoverAlpha );
FVector HandleRelativeLocation = FVector::ZeroVector;
for (int32 AxisIndex = 0; AxisIndex < 3; ++AxisIndex)
{
if (HandlePlacement.Axes[AxisIndex] == ETransformGizmoHandleDirection::Negative) // Negative direction
{
HandleRelativeLocation[AxisIndex] = LocalBounds.Min[AxisIndex] - OffsetFromSide;
}
else if (HandlePlacement.Axes[AxisIndex] == ETransformGizmoHandleDirection::Positive) // Positive direction
{
HandleRelativeLocation[AxisIndex] = LocalBounds.Max[AxisIndex] + OffsetFromSide;
}
else // ETransformGizmoHandleDirection::Center
{
HandleRelativeLocation[AxisIndex] = LocalBounds.GetCenter()[AxisIndex];
}
}
StretchingHandle->SetRelativeLocation( HandleRelativeLocation );
int32 CenterHandleCount, FacingAxisIndex, CenterAxisIndex;
HandlePlacement.GetCenterHandleCountAndFacingAxisIndex( /* Out */ CenterHandleCount, /* Out */ FacingAxisIndex, /* Out */ CenterAxisIndex );
FRotator Rotator = FRotator::ZeroRotator;
{
// Back bottom left
if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Negative)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = 0.0f;
}
// Back bottom right
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Negative)
{
Rotator.Yaw = -90.0f;
Rotator.Pitch = 0.0f;
}
// Back top left
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Positive)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = -90.0f;
}
// Back top right
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Positive)
{
Rotator.Yaw = -90.0f;
Rotator.Pitch = -90.0f;
}
// Front bottom left
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Negative)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = 90.0f;
}
// Front bottom right
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Negative)
{
Rotator.Yaw = 90.0f;
Rotator.Pitch = 90.0f;
}
// Front top left
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Positive)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = -180.0f;
}
// Front top right
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[1] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[2] == ETransformGizmoHandleDirection::Positive)
{
Rotator.Yaw = 180.0f;
Rotator.Pitch = -90.0f;
}
// Back left/right edge
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[1] != ETransformGizmoHandleDirection::Center)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = 90.0f;
}
// Back bottom/top edge
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Negative && HandlePlacement.Axes[2] != ETransformGizmoHandleDirection::Center)
{
Rotator.Yaw = 90.0f;
Rotator.Pitch = 0.0f;
}
// Front left/right edge
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[1] != ETransformGizmoHandleDirection::Center)
{
Rotator.Yaw = 0.0f;
Rotator.Pitch = 90.0f;
}
// Front bottom/top edge
else if (HandlePlacement.Axes[0] == ETransformGizmoHandleDirection::Positive && HandlePlacement.Axes[2] != ETransformGizmoHandleDirection::Center)
{
Rotator.Yaw = 90.0f;
Rotator.Pitch = 0.0f;
}
else
{
// Facing out from center of a face
if (CenterHandleCount == 2)
{
const FQuat GizmoSpaceOrientation = GetAxisVector( FacingAxisIndex, HandlePlacement.Axes[FacingAxisIndex] ).ToOrientationQuat();
Rotator = GizmoSpaceOrientation.Rotator();
}
else
{
// One of the left/right bottom or top edges
}
}
}
StretchingHandle->SetRelativeRotation( Rotator );
StretchingHandle->SetRelativeScale3D( FVector( GizmoHandleScale ) );
// Update material
UpdateHandleColor( FacingAxisIndex, Handle, DraggingHandle, HoveringOverHandles );
}
}
}
FVector ABxtAsteroidSpawner::GetRandomSpawnLocation() const
{
const FBox spawnerBounds = GetComponentsBoundingBox(true);
const float y = FMath::FRandRange(spawnerBounds.Min.Y, spawnerBounds.Max.Y);
return FVector(spawnerBounds.GetCenter().X - 500.0f, y, 0.0f);
}
static void UpdatePlanarReflectionContents_RenderThread(
FRHICommandListImmediate& RHICmdList,
FSceneRenderer* MainSceneRenderer,
FSceneRenderer* SceneRenderer,
const FPlanarReflectionSceneProxy* SceneProxy,
FRenderTarget* RenderTarget,
FTexture* RenderTargetTexture,
const FPlane& MirrorPlane,
const FName OwnerName,
const FResolveParams& ResolveParams,
bool bUseSceneColorTexture)
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_RenderPlanarReflection);
FBox PlanarReflectionBounds = SceneProxy->WorldBounds;
bool bIsInAnyFrustum = false;
for (int32 ViewIndex = 0; ViewIndex < SceneRenderer->Views.Num(); ++ViewIndex)
{
FViewInfo& View = SceneRenderer->Views[ViewIndex];
if (View.ViewFrustum.IntersectBox(PlanarReflectionBounds.GetCenter(), PlanarReflectionBounds.GetExtent()))
{
bIsInAnyFrustum = true;
break;
}
}
if (bIsInAnyFrustum)
{
bool bIsVisibleInAnyView = true;
for (int32 ViewIndex = 0; ViewIndex < SceneRenderer->Views.Num(); ++ViewIndex)
{
FViewInfo& View = SceneRenderer->Views[ViewIndex];
FSceneViewState* ViewState = View.ViewState;
if (ViewState)
{
FIndividualOcclusionHistory& OcclusionHistory = ViewState->PlanarReflectionOcclusionHistories.FindOrAdd(SceneProxy->PlanarReflectionId);
// +1 to buffered frames because the query is submitted late into the main frame, but read at the beginning of a reflection capture frame
const int32 NumBufferedFrames = FOcclusionQueryHelpers::GetNumBufferedFrames() + 1;
// +1 to frame counter because we are operating before the main view's InitViews, which is where OcclusionFrameCounter is incremented
uint32 OcclusionFrameCounter = ViewState->OcclusionFrameCounter + 1;
FRenderQueryRHIRef& PastQuery = OcclusionHistory.GetPastQuery(OcclusionFrameCounter, NumBufferedFrames);
if (IsValidRef(PastQuery))
{
uint64 NumSamples = 0;
QUICK_SCOPE_CYCLE_COUNTER(STAT_PlanarReflectionOcclusionQueryResults);
if (RHIGetRenderQueryResult(PastQuery.GetReference(), NumSamples, true))
{
bIsVisibleInAnyView = NumSamples > 0;
if (bIsVisibleInAnyView)
{
break;
}
}
}
}
}
if (bIsVisibleInAnyView)
{
FMemMark MemStackMark(FMemStack::Get());
// update any resources that needed a deferred update
FDeferredUpdateResource::UpdateResources(RHICmdList);
{
#if WANTS_DRAW_MESH_EVENTS
FString EventName;
OwnerName.ToString(EventName);
SCOPED_DRAW_EVENTF(RHICmdList, SceneCapture, TEXT("PlanarReflection %s"), *EventName);
#else
SCOPED_DRAW_EVENT(RHICmdList, UpdatePlanarReflectionContent_RenderThread);
#endif
const FRenderTarget* Target = SceneRenderer->ViewFamily.RenderTarget;
SetRenderTarget(RHICmdList, Target->GetRenderTargetTexture(), NULL, true);
// Note: relying on GBuffer SceneColor alpha being cleared to 1 in the main scene rendering
check(GetSceneColorClearAlpha() == 1.0f);
RHICmdList.Clear(true, FLinearColor(0, 0, 0, 1), false, (float)ERHIZBuffer::FarPlane, false, 0, FIntRect());
// Reflection view late update
if (SceneRenderer->Views.Num() > 1)
{
const FMirrorMatrix MirrorMatrix(MirrorPlane);
for (int32 ViewIndex = 0; ViewIndex < SceneRenderer->Views.Num(); ++ViewIndex)
{
FViewInfo& ReflectionViewToUpdate = SceneRenderer->Views[ViewIndex];
const FViewInfo& UpdatedParentView = MainSceneRenderer->Views[ViewIndex];
ReflectionViewToUpdate.UpdatePlanarReflectionViewMatrix(UpdatedParentView, MirrorMatrix);
}
}
// Render the scene normally
{
SCOPED_DRAW_EVENT(RHICmdList, RenderScene);
SceneRenderer->Render(RHICmdList);
}
for (int32 ViewIndex = 0; ViewIndex < SceneRenderer->Views.Num(); ++ViewIndex)
{
FViewInfo& View = SceneRenderer->Views[ViewIndex];
if (MainSceneRenderer->Scene->GetShadingPath() == EShadingPath::Deferred)
{
PrefilterPlanarReflection<true>(RHICmdList, View, SceneProxy, Target);
}
else
{
PrefilterPlanarReflection<false>(RHICmdList, View, SceneProxy, Target);
}
}
RHICmdList.CopyToResolveTarget(RenderTarget->GetRenderTargetTexture(), RenderTargetTexture->TextureRHI, false, ResolveParams);
}
FSceneRenderer::WaitForTasksClearSnapshotsAndDeleteSceneRenderer(RHICmdList, SceneRenderer);
}
}
}
void FLogVisualizer::UpdateCameraPosition(FName RowName, int32 ItemIndes)
{
const FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
auto &Entries = DBRow.GetItems();
if (DBRow.GetCurrentItemIndex() == INDEX_NONE || Entries.IsValidIndex(DBRow.GetCurrentItemIndex()) == false)
{
return;
}
UWorld* World = GetWorld();
FVector CurrentLocation = Entries[DBRow.GetCurrentItemIndex()].Entry.Location;
FVector Extent(150);
bool bFoundActor = false;
FName OwnerName = Entries[DBRow.GetCurrentItemIndex()].OwnerName;
for (FActorIterator It(World); It; ++It)
{
AActor* Actor = *It;
if (Actor->GetFName() == OwnerName)
{
FVector Orgin;
Actor->GetActorBounds(false, Orgin, Extent);
bFoundActor = true;
break;
}
}
const float DefaultCameraDistance = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->DefaultCameraDistance;
Extent = Extent.SizeSquared() < FMath::Square(DefaultCameraDistance) ? FVector(DefaultCameraDistance) : Extent;
#if WITH_EDITOR
UEditorEngine *EEngine = Cast<UEditorEngine>(GEngine);
if (GIsEditor && EEngine != NULL)
{
for (auto ViewportClient : EEngine->AllViewportClients)
{
ViewportClient->FocusViewportOnBox(FBox::BuildAABB(CurrentLocation, Extent));
}
}
else if (AVisualLoggerCameraController::IsEnabled(World) && AVisualLoggerCameraController::Instance.IsValid() && AVisualLoggerCameraController::Instance->GetSpectatorPawn())
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(AVisualLoggerCameraController::Instance->Player);
if (LocalPlayer && LocalPlayer->ViewportClient && LocalPlayer->ViewportClient->Viewport)
{
FViewport* Viewport = LocalPlayer->ViewportClient->Viewport;
FBox BoundingBox = FBox::BuildAABB(CurrentLocation, Extent);
const FVector Position = BoundingBox.GetCenter();
float Radius = BoundingBox.GetExtent().Size();
FViewportCameraTransform ViewTransform;
ViewTransform.TransitionToLocation(Position, nullptr, true);
float NewOrthoZoom;
const float AspectRatio = 1.777777f;
CA_SUPPRESS(6326);
uint32 MinAxisSize = (AspectRatio > 1.0f) ? Viewport->GetSizeXY().Y : Viewport->GetSizeXY().X;
float Zoom = Radius / (MinAxisSize / 2.0f);
NewOrthoZoom = Zoom * (Viewport->GetSizeXY().X*15.0f);
NewOrthoZoom = FMath::Clamp<float>(NewOrthoZoom, 250, MAX_FLT);
ViewTransform.SetOrthoZoom(NewOrthoZoom);
AVisualLoggerCameraController::Instance->GetSpectatorPawn()->TeleportTo(ViewTransform.GetLocation(), ViewTransform.GetRotation(), false, true);
}
}
#endif
}
void UGameplayDebuggingComponent::ServerCollectNavmeshData_Implementation(FVector_NetQuantize10 TargetLocation)
{
#if WITH_RECAST
UNavigationSystem* NavSys = UNavigationSystem::GetCurrent(GetWorld());
ARecastNavMesh* NavData = GetNavData();
if (NavData == NULL)
{
NavmeshRepData.Empty();
return;
}
const double Timer1 = FPlatformTime::Seconds();
TArray<int32> Indices;
int32 TileX = 0;
int32 TileY = 0;
const int32 DeltaX[] = { 0, 1, 1, 0, -1, -1, -1, 0, 1 };
const int32 DeltaY[] = { 0, 0, 1, 1, 1, 0, -1, -1, -1 };
NavData->BeginBatchQuery();
// add 3x3 neighborhood of target
int32 TargetTileX = 0;
int32 TargetTileY = 0;
NavData->GetNavMeshTileXY(TargetLocation, TargetTileX, TargetTileY);
for (int32 i = 0; i < ARRAY_COUNT(DeltaX); i++)
{
const int32 NeiX = TargetTileX + DeltaX[i];
const int32 NeiY = TargetTileY + DeltaY[i];
if (FMath::Abs(NeiX - TileX) > 1 || FMath::Abs(NeiY - TileY) > 1)
{
NavData->GetNavMeshTilesAt(NeiX, NeiY, Indices);
}
}
const FNavDataConfig& NavConfig = NavData->GetConfig();
FColor NavMeshColors[RECAST_MAX_AREAS];
NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : NavMeshRenderColor_RecastMesh;
for (uint8 i = 0; i < RECAST_DEFAULT_AREA; ++i)
{
NavMeshColors[i] = NavData->GetAreaIDColor(i);
}
TArray<uint8> UncompressedBuffer;
FMemoryWriter ArWriter(UncompressedBuffer);
int32 NumIndices = Indices.Num();
ArWriter << NumIndices;
for (int32 i = 0; i < NumIndices; i++)
{
FRecastDebugGeometry NavMeshGeometry;
NavMeshGeometry.bGatherPolyEdges = false;
NavMeshGeometry.bGatherNavMeshEdges = false;
NavData->GetDebugGeometry(NavMeshGeometry, Indices[i]);
NavMeshDebug::FTileData TileData;
const FBox TileBoundingBox = NavData->GetNavMeshTileBounds(Indices[i]);
TileData.Location = TileBoundingBox.GetCenter();
for (int32 VertIndex = 0; VertIndex < NavMeshGeometry.MeshVerts.Num(); ++VertIndex)
{
const NavMeshDebug::FShortVector SV = NavMeshGeometry.MeshVerts[VertIndex] - TileData.Location;
TileData.Verts.Add(SV);
}
for (int32 iArea = 0; iArea < RECAST_MAX_AREAS; iArea++)
{
const int32 NumTris = NavMeshGeometry.AreaIndices[iArea].Num();
if (NumTris)
{
NavMeshDebug::FAreaPolys AreaPolys;
for (int32 AreaIndicesIndex = 0; AreaIndicesIndex < NavMeshGeometry.AreaIndices[iArea].Num(); ++AreaIndicesIndex)
{
AreaPolys.Indices.Add(NavMeshGeometry.AreaIndices[iArea][AreaIndicesIndex]);
}
AreaPolys.Color = NavMeshColors[iArea];
TileData.Areas.Add(AreaPolys);
}
}
TileData.Links.Reserve(NavMeshGeometry.OffMeshLinks.Num());
for (int32 iLink = 0; iLink < NavMeshGeometry.OffMeshLinks.Num(); iLink++)
{
const FRecastDebugGeometry::FOffMeshLink& SrcLink = NavMeshGeometry.OffMeshLinks[iLink];
NavMeshDebug::FOffMeshLink Link;
Link.Left = SrcLink.Left - TileData.Location;
Link.Right = SrcLink.Right - TileData.Location;
Link.Color = ((SrcLink.Direction && SrcLink.ValidEnds) || (SrcLink.ValidEnds & FRecastDebugGeometry::OMLE_Left)) ? DarkenColor(NavMeshColors[SrcLink.AreaID]) : NavMeshRenderColor_OffMeshConnectionInvalid;
Link.PackedFlags.Radius = (int8)SrcLink.Radius;
Link.PackedFlags.Direction = SrcLink.Direction;
Link.PackedFlags.ValidEnds = SrcLink.ValidEnds;
TileData.Links.Add(Link);
}
ArWriter << TileData;
}
NavData->FinishBatchQuery();
const double Timer2 = FPlatformTime::Seconds();
const int32 HeaderSize = sizeof(int32);
NavmeshRepData.Init(0, HeaderSize + FMath::TruncToInt(1.1f * UncompressedBuffer.Num()));
const int32 UncompressedSize = UncompressedBuffer.Num();
int32 CompressedSize = NavmeshRepData.Num() - HeaderSize;
uint8* DestBuffer = NavmeshRepData.GetData();
FMemory::Memcpy(DestBuffer, &UncompressedSize, HeaderSize);
DestBuffer += HeaderSize;
FCompression::CompressMemory((ECompressionFlags)(COMPRESS_ZLIB | COMPRESS_BiasMemory),
(void*)DestBuffer, CompressedSize, (void*)UncompressedBuffer.GetData(), UncompressedSize);
NavmeshRepData.SetNum(CompressedSize + HeaderSize, false);
const double Timer3 = FPlatformTime::Seconds();
UE_LOG(LogGDT, Log, TEXT("Preparing navmesh data: %.1fkB took %.3fms (collect: %.3fms + compress %d%%: %.3fms)"),
NavmeshRepData.Num() / 1024.0f, 1000.0f * (Timer3 - Timer1),
1000.0f * (Timer2 - Timer1),
FMath::TruncToInt(100.0f * NavmeshRepData.Num() / UncompressedBuffer.Num()), 1000.0f * (Timer3 - Timer2));
#endif
if (World && World->GetNetMode() != NM_DedicatedServer)
{
OnRep_UpdateNavmesh();
}
}
AHierarchicalLODVolume* FHierarchicalLODUtilities::CreateVolumeForLODActor(ALODActor* InLODActor, UWorld* InWorld)
{
FBox BoundingBox = InLODActor->GetComponentsBoundingBox(true);
AHierarchicalLODVolume* Volume = InWorld->SpawnActor<AHierarchicalLODVolume>(AHierarchicalLODVolume::StaticClass(), FTransform(BoundingBox.GetCenter()));
// this code builds a brush for the new actor
Volume->PreEditChange(NULL);
Volume->PolyFlags = 0;
Volume->Brush = NewObject<UModel>(Volume, NAME_None, RF_Transactional);
Volume->Brush->Initialize(nullptr, true);
Volume->Brush->Polys = NewObject<UPolys>(Volume->Brush, NAME_None, RF_Transactional);
Volume->GetBrushComponent()->Brush = Volume->Brush;
Volume->BrushBuilder = NewObject<UCubeBuilder>(Volume, NAME_None, RF_Transactional);
UCubeBuilder* CubeBuilder = static_cast<UCubeBuilder*>(Volume->BrushBuilder);
CubeBuilder->X = BoundingBox.GetSize().X * 1.5f;
CubeBuilder->Y = BoundingBox.GetSize().Y * 1.5f;
CubeBuilder->Z = BoundingBox.GetSize().Z * 1.5f;
Volume->BrushBuilder->Build(InWorld, Volume);
FBSPOps::csgPrepMovingBrush(Volume);
// Set the texture on all polys to NULL. This stops invisible textures
// dependencies from being formed on volumes.
if (Volume->Brush)
{
for (int32 poly = 0; poly < Volume->Brush->Polys->Element.Num(); ++poly)
{
FPoly* Poly = &(Volume->Brush->Polys->Element[poly]);
Poly->Material = NULL;
}
}
Volume->PostEditChange();
return Volume;
}
/**
* Returns an array of visibility data for the given view position, or NULL if none exists.
* The data bits are indexed by VisibilityId of each primitive in the scene.
* This method decompresses data if necessary and caches it based on the bucket and chunk index in the view state.
*/
const uint8* FSceneViewState::GetPrecomputedVisibilityData(FViewInfo& View, const FScene* Scene)
{
const uint8* PrecomputedVisibilityData = NULL;
if (Scene->PrecomputedVisibilityHandler && GAllowPrecomputedVisibility && View.Family->EngineShowFlags.PrecomputedVisibility)
{
const FPrecomputedVisibilityHandler& Handler = *Scene->PrecomputedVisibilityHandler;
FViewElementPDI VisibilityCellsPDI(&View, NULL);
// Draw visibility cell bounds for debugging if enabled
if ((GShowPrecomputedVisibilityCells || View.Family->EngineShowFlags.PrecomputedVisibilityCells) && !GShowRelevantPrecomputedVisibilityCells)
{
for (int32 BucketIndex = 0; BucketIndex < Handler.PrecomputedVisibilityCellBuckets.Num(); BucketIndex++)
{
for (int32 CellIndex = 0; CellIndex < Handler.PrecomputedVisibilityCellBuckets[BucketIndex].Cells.Num(); CellIndex++)
{
const FPrecomputedVisibilityCell& CurrentCell = Handler.PrecomputedVisibilityCellBuckets[BucketIndex].Cells[CellIndex];
// Construct the cell's bounds
const FBox CellBounds(CurrentCell.Min, CurrentCell.Min + FVector(Handler.PrecomputedVisibilityCellSizeXY, Handler.PrecomputedVisibilityCellSizeXY, Handler.PrecomputedVisibilityCellSizeZ));
if (View.ViewFrustum.IntersectBox(CellBounds.GetCenter(), CellBounds.GetExtent()))
{
DrawWireBox(&VisibilityCellsPDI, CellBounds, FColor(50, 50, 255), SDPG_World);
}
}
}
}
// Calculate the bucket that ViewOrigin falls into
// Cells are hashed into buckets to reduce search time
const float FloatOffsetX = (View.ViewMatrices.ViewOrigin.X - Handler.PrecomputedVisibilityCellBucketOriginXY.X) / Handler.PrecomputedVisibilityCellSizeXY;
// FMath::TruncToInt rounds toward 0, we want to always round down
const int32 BucketIndexX = FMath::Abs((FMath::TruncToInt(FloatOffsetX) - (FloatOffsetX < 0.0f ? 1 : 0)) / Handler.PrecomputedVisibilityCellBucketSizeXY % Handler.PrecomputedVisibilityNumCellBuckets);
const float FloatOffsetY = (View.ViewMatrices.ViewOrigin.Y -Handler.PrecomputedVisibilityCellBucketOriginXY.Y) / Handler.PrecomputedVisibilityCellSizeXY;
const int32 BucketIndexY = FMath::Abs((FMath::TruncToInt(FloatOffsetY) - (FloatOffsetY < 0.0f ? 1 : 0)) / Handler.PrecomputedVisibilityCellBucketSizeXY % Handler.PrecomputedVisibilityNumCellBuckets);
const int32 PrecomputedVisibilityBucketIndex = BucketIndexY * Handler.PrecomputedVisibilityCellBucketSizeXY + BucketIndexX;
check(PrecomputedVisibilityBucketIndex < Handler.PrecomputedVisibilityCellBuckets.Num());
const FPrecomputedVisibilityBucket& CurrentBucket = Handler.PrecomputedVisibilityCellBuckets[PrecomputedVisibilityBucketIndex];
for (int32 CellIndex = 0; CellIndex < CurrentBucket.Cells.Num(); CellIndex++)
{
const FPrecomputedVisibilityCell& CurrentCell = CurrentBucket.Cells[CellIndex];
// Construct the cell's bounds
const FBox CellBounds(CurrentCell.Min, CurrentCell.Min + FVector(Handler.PrecomputedVisibilityCellSizeXY, Handler.PrecomputedVisibilityCellSizeXY, Handler.PrecomputedVisibilityCellSizeZ));
// Check if ViewOrigin is inside the current cell
if (CellBounds.IsInside(View.ViewMatrices.ViewOrigin))
{
// Reuse a cached decompressed chunk if possible
if (CachedVisibilityChunk
&& CachedVisibilityHandlerId == Scene->PrecomputedVisibilityHandler->GetId()
&& CachedVisibilityBucketIndex == PrecomputedVisibilityBucketIndex
&& CachedVisibilityChunkIndex == CurrentCell.ChunkIndex)
{
checkSlow(CachedVisibilityChunk->Num() >= CurrentCell.DataOffset + CurrentBucket.CellDataSize);
PrecomputedVisibilityData = &(*CachedVisibilityChunk)[CurrentCell.DataOffset];
}
else
{
const FCompressedVisibilityChunk& CompressedChunk = Handler.PrecomputedVisibilityCellBuckets[PrecomputedVisibilityBucketIndex].CellDataChunks[CurrentCell.ChunkIndex];
CachedVisibilityBucketIndex = PrecomputedVisibilityBucketIndex;
CachedVisibilityChunkIndex = CurrentCell.ChunkIndex;
CachedVisibilityHandlerId = Scene->PrecomputedVisibilityHandler->GetId();
if (CompressedChunk.bCompressed)
{
// Decompress the needed visibility data chunk
DecompressedVisibilityChunk.Reset();
DecompressedVisibilityChunk.AddUninitialized(CompressedChunk.UncompressedSize);
verify(FCompression::UncompressMemory(
COMPRESS_ZLIB,
DecompressedVisibilityChunk.GetData(),
CompressedChunk.UncompressedSize,
CompressedChunk.Data.GetData(),
CompressedChunk.Data.Num()));
CachedVisibilityChunk = &DecompressedVisibilityChunk;
}
else
{
CachedVisibilityChunk = &CompressedChunk.Data;
}
checkSlow(CachedVisibilityChunk->Num() >= CurrentCell.DataOffset + CurrentBucket.CellDataSize);
// Return a pointer to the cell containing ViewOrigin's decompressed visibility data
PrecomputedVisibilityData = &(*CachedVisibilityChunk)[CurrentCell.DataOffset];
}
if (GShowRelevantPrecomputedVisibilityCells)
{
// Draw the currently used visibility cell with green wireframe for debugging
DrawWireBox(&VisibilityCellsPDI, CellBounds, FColor(50, 255, 50), SDPG_Foreground);
}
else
{
break;
}
}
else if (GShowRelevantPrecomputedVisibilityCells)
{
// Draw all cells in the current visibility bucket as blue wireframe
DrawWireBox(&VisibilityCellsPDI, CellBounds, FColor(50, 50, 255), SDPG_World);
}
}
}
return PrecomputedVisibilityData;
}
void ASpacePartioner::Initialize(const FBox& inNewBounds, const bool& inDrawDebugInfo)
{
bInitialized = true;
bDrawDebugInfo = inDrawDebugInfo;
OctreeData = new FSimpleOctree(inNewBounds.GetCenter(), inNewBounds.GetExtent().GetMax()); // const FVector & InOrigin, float InExtent
}
void AGameplayDebuggerReplicator::DrawDebugData(class UCanvas* Canvas, class APlayerController* PC, bool bHideMenu)
{
#if ENABLED_GAMEPLAY_DEBUGGER
if (!LocalPlayerOwner && IsActorTickEnabled())
{
return;
}
const bool bAllowToDraw = Canvas && Canvas->SceneView && (Canvas->SceneView->ViewActor == LocalPlayerOwner->AcknowledgedPawn || Canvas->SceneView->ViewActor == LocalPlayerOwner->GetPawnOrSpectator());
if (!bAllowToDraw)
{
// check for spectator debug camera during debug camera
if (DebugCameraController.IsValid() == false || Canvas->SceneView->ViewActor->GetInstigatorController() != DebugCameraController.Get())
{
return;
}
}
const float DebugInfoStartX = UGameplayDebuggerModuleSettings::StaticClass()->GetDefaultObject<UGameplayDebuggerModuleSettings>()->DebugInfoStart.X;
const float DebugInfoStartY = UGameplayDebuggerModuleSettings::StaticClass()->GetDefaultObject<UGameplayDebuggerModuleSettings>()->DebugInfoStart.Y;
const FVector SelectedActorLoc = LastSelectedActorToDebug ? LastSelectedActorToDebug->GetActorLocation() + FVector(0, 0, LastSelectedActorToDebug->GetSimpleCollisionHalfHeight()) : DebugTools::InvalidLocation;
UGameplayDebuggerHelper::FPrintContext DefaultContext(GEngine->GetSmallFont(), Canvas, DebugInfoStartX, DebugInfoStartY);
DefaultContext.FontRenderInfo.bEnableShadow = true;
const bool bDrawFullData = SelectedActorLoc != DebugTools::InvalidLocation;
const FVector ScreenLoc = SelectedActorLoc != DebugTools::InvalidLocation ? UGameplayDebuggerHelper::ProjectLocation(DefaultContext, SelectedActorLoc) : FVector::ZeroVector;
UGameplayDebuggerHelper::FPrintContext OverHeadContext(GEngine->GetSmallFont(), Canvas, ScreenLoc.X, ScreenLoc.Y);
UGameplayDebuggerHelper::SetOverHeadContext(OverHeadContext);
UGameplayDebuggerHelper::SetDefaultContext(DefaultContext);
if (DefaultContext.Canvas != nullptr)
{
float XL, YL;
const FString ToolName = FString::Printf(TEXT("Gameplay Debugger [Timestamp: %05.03f]"), GetWorld()->TimeSeconds);
UGameplayDebuggerHelper::CalulateStringSize(DefaultContext, nullptr, ToolName, XL, YL);
UGameplayDebuggerHelper::PrintString(DefaultContext, FColorList::White, ToolName, DefaultContext.Canvas->ClipX / 2.0f - XL / 2.0f, 0);
}
if (!bHideMenu)
{
DrawMenu(DefaultContext, OverHeadContext);
}
TMap<FString, TArray<UGameplayDebuggerBaseObject*> > CategoryToClasses;
for (UGameplayDebuggerBaseObject* Obj : ReplicatedObjects)
{
if (Obj)
{
FString Category = Obj->GetCategoryName();
CategoryToClasses.FindOrAdd(Category).Add(Obj);
}
}
CategoryToClasses.KeySort(TLess<FString>());
for (auto It(CategoryToClasses.CreateIterator()); It; ++It)
{
const FGameplayDebuggerCategorySettings* Element = Categories.FindByPredicate([&](const FGameplayDebuggerCategorySettings& C){ return It.Key() == C.CategoryName; });
if (Element == nullptr || Element->bPIE == false)
{
continue;
}
UGameplayDebuggerHelper::PrintString(UGameplayDebuggerHelper::GetDefaultContext(), FString::Printf(TEXT("\n{R=0,G=255,B=0,A=255}%s\n"), *It.Key()));
TArray<UGameplayDebuggerBaseObject*>& CurrentObjects = It.Value();
for (UGameplayDebuggerBaseObject* Obj : CurrentObjects)
{
Obj->DrawCollectedData(LocalPlayerOwner, LastSelectedActorToDebug);
}
}
const IConsoleVariable* cvarHighlightSelectedActor = IConsoleManager::Get().FindConsoleVariable(TEXT("ai.gd.HighlightSelectedActor"));
const bool bHighlightSelectedActor = !cvarHighlightSelectedActor || cvarHighlightSelectedActor->GetInt();
if (LastSelectedActorToDebug && bHighlightSelectedActor)
{
FBox ComponentsBoundingBox = LastSelectedActorToDebug->GetComponentsBoundingBox(false);
DrawDebugBox(GetWorld(), ComponentsBoundingBox.GetCenter(), ComponentsBoundingBox.GetExtent(), FColor::Red, false);
DrawDebugSolidBox(GetWorld(), ComponentsBoundingBox.GetCenter(), ComponentsBoundingBox.GetExtent(), FColor::Red.WithAlpha(25));
}
#endif
}
void UNavMeshRenderingComponent::GatherData(struct FNavMeshSceneProxyData* CurrentData) const
{
#if WITH_RECAST
const ARecastNavMesh* NavMesh = Cast<ARecastNavMesh>(GetOwner());
CurrentData->Reset();
CurrentData->bEnableDrawing = NavMesh->bEnableDrawing;
CurrentData->bNeedsNewData = false;
if (CurrentData && NavMesh && NavMesh->bEnableDrawing)
{
FHitProxyId HitProxyId = FHitProxyId();
CurrentData->bDrawPathCollidingGeometry = NavMesh->bDrawPathCollidingGeometry;
CurrentData->NavMeshDrawOffset.Z = NavMesh->DrawOffset;
CurrentData->NavMeshGeometry.bGatherPolyEdges = NavMesh->bDrawPolyEdges;
CurrentData->NavMeshGeometry.bGatherNavMeshEdges = NavMesh->bDrawNavMeshEdges;
const FNavDataConfig& NavConfig = NavMesh->GetConfig();
CurrentData->NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : NavMeshRenderColor_RecastMesh;
for (uint8 i = 0; i < RECAST_DEFAULT_AREA; ++i)
{
CurrentData->NavMeshColors[i] = NavMesh->GetAreaIDColor(i);
}
// just a little trick to make sure navmeshes with different sized are not drawn with same offset
CurrentData->NavMeshDrawOffset.Z += NavMesh->GetConfig().AgentRadius / 10.f;
NavMesh->BeginBatchQuery();
if (NavMesh->bDrawOctree)
{
const UNavigationSystem* NavSys = UNavigationSystem::GetCurrent(GetWorld());
const FNavigationOctree* NavOctree = NavSys ? NavSys->GetNavOctree() : NULL;
if (NavOctree)
{
for (FNavigationOctree::TConstIterator<> NodeIt(*NavOctree); NodeIt.HasPendingNodes(); NodeIt.Advance())
{
const FNavigationOctree::FNode& CurrentNode = NodeIt.GetCurrentNode();
const FOctreeNodeContext& CorrentContext = NodeIt.GetCurrentContext();
CurrentData->OctreeBounds.Add(CorrentContext.Bounds);
FOREACH_OCTREE_CHILD_NODE(ChildRef)
{
if (CurrentNode.HasChild(ChildRef))
{
NodeIt.PushChild(ChildRef);
}
}
}
}
}
NavMesh->GetDebugGeometry(CurrentData->NavMeshGeometry);
const TArray<FVector>& MeshVerts = CurrentData->NavMeshGeometry.MeshVerts;
// @fixme, this is going to double up on lots of interior lines
if (NavMesh->bDrawTriangleEdges)
{
for (int32 AreaIdx = 0; AreaIdx < RECAST_MAX_AREAS; ++AreaIdx)
{
const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.AreaIndices[AreaIdx];
for (int32 Idx=0; Idx<MeshIndices.Num(); Idx += 3)
{
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(MeshVerts[MeshIndices[Idx + 0]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx + 1]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges, DefaultEdges_LineThickness));
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(MeshVerts[MeshIndices[Idx + 1]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx + 2]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges, DefaultEdges_LineThickness));
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(MeshVerts[MeshIndices[Idx + 2]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx + 0]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges, DefaultEdges_LineThickness));
}
}
}
// make lines for tile edges
if (NavMesh->bDrawPolyEdges)
{
const TArray<FVector>& TileEdgeVerts = CurrentData->NavMeshGeometry.PolyEdges;
for (int32 Idx=0; Idx < TileEdgeVerts.Num(); Idx += 2)
{
CurrentData->TileEdgeLines.Add( FDebugRenderSceneProxy::FDebugLine(TileEdgeVerts[Idx] + CurrentData->NavMeshDrawOffset, TileEdgeVerts[Idx+1] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TileEdges));
}
}
// make lines for navmesh edges
if (NavMesh->bDrawNavMeshEdges)
{
const FColor EdgesColor = DarkenColor(CurrentData->NavMeshColors[RECAST_DEFAULT_AREA]);
const TArray<FVector>& NavMeshEdgeVerts = CurrentData->NavMeshGeometry.NavMeshEdges;
for (int32 Idx=0; Idx < NavMeshEdgeVerts.Num(); Idx += 2)
{
CurrentData->NavMeshEdgeLines.Add( FDebugRenderSceneProxy::FDebugLine(NavMeshEdgeVerts[Idx] + CurrentData->NavMeshDrawOffset, NavMeshEdgeVerts[Idx+1] + CurrentData->NavMeshDrawOffset, EdgesColor));
}
}
// offset all navigation-link positions
if (!NavMesh->bDrawClusters)
{
for (int32 OffMeshLineIndex = 0; OffMeshLineIndex < CurrentData->NavMeshGeometry.OffMeshLinks.Num(); ++OffMeshLineIndex)
{
FRecastDebugGeometry::FOffMeshLink& Link = CurrentData->NavMeshGeometry.OffMeshLinks[OffMeshLineIndex];
const bool bLinkValid = (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left) && (Link.ValidEnds & FRecastDebugGeometry::OMLE_Right);
if (NavMesh->bDrawFailedNavLinks || (NavMesh->bDrawNavLinks && bLinkValid))
{
const FVector V0 = Link.Left + CurrentData->NavMeshDrawOffset;
const FVector V1 = Link.Right + CurrentData->NavMeshDrawOffset;
const FColor LinkColor = ((Link.Direction && Link.ValidEnds) || (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left)) ? DarkenColor(CurrentData->NavMeshColors[Link.AreaID]) : NavMeshRenderColor_OffMeshConnectionInvalid;
CacheArc(CurrentData->NavLinkLines, V0, V1, 0.4f, 4, LinkColor, LinkLines_LineThickness);
const FVector VOffset(0, 0, FVector::Dist(V0, V1) * 1.333f);
CacheArrowHead(CurrentData->NavLinkLines, V1, V0+VOffset, 30.f, LinkColor, LinkLines_LineThickness);
if (Link.Direction)
{
CacheArrowHead(CurrentData->NavLinkLines, V0, V1+VOffset, 30.f, LinkColor, LinkLines_LineThickness);
}
// if the connection as a whole is valid check if there are any of ends is invalid
if (LinkColor != NavMeshRenderColor_OffMeshConnectionInvalid)
{
if (Link.Direction && (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left) == 0)
{
// left end invalid - mark it
DrawWireCylinder(CurrentData->NavLinkLines, V0, FVector(1,0,0), FVector(0,1,0), FVector(0,0,1), NavMeshRenderColor_OffMeshConnectionInvalid, Link.Radius, NavMesh->AgentMaxStepHeight, 16, 0, DefaultEdges_LineThickness);
}
if ((Link.ValidEnds & FRecastDebugGeometry::OMLE_Right) == 0)
{
DrawWireCylinder(CurrentData->NavLinkLines, V1, FVector(1,0,0), FVector(0,1,0), FVector(0,0,1), NavMeshRenderColor_OffMeshConnectionInvalid, Link.Radius, NavMesh->AgentMaxStepHeight, 16, 0, DefaultEdges_LineThickness);
}
}
}
}
}
if (NavMesh->bDrawTileLabels || NavMesh->bDrawPolygonLabels || NavMesh->bDrawDefaultPolygonCost || NavMesh->bDrawTileBounds)
{
// calculate appropriate points for displaying debug labels
const int32 TilesCount = NavMesh->GetNavMeshTilesCount();
CurrentData->DebugLabels.Reserve(TilesCount);
for (int32 TileIndex = 0; TileIndex < TilesCount; ++TileIndex)
{
int32 X, Y, Layer;
if (NavMesh->GetNavMeshTileXY(TileIndex, X, Y, Layer))
{
const FBox TileBoundingBox = NavMesh->GetNavMeshTileBounds(TileIndex);
FVector TileLabelLocation = TileBoundingBox.GetCenter();
TileLabelLocation.Z = TileBoundingBox.Max.Z;
FNavLocation NavLocation(TileLabelLocation);
if (!NavMesh->ProjectPoint(TileLabelLocation, NavLocation, FVector(NavMesh->TileSizeUU/100, NavMesh->TileSizeUU/100, TileBoundingBox.Max.Z-TileBoundingBox.Min.Z)))
{
NavMesh->ProjectPoint(TileLabelLocation, NavLocation, FVector(NavMesh->TileSizeUU/2, NavMesh->TileSizeUU/2, TileBoundingBox.Max.Z-TileBoundingBox.Min.Z));
}
if (NavMesh->bDrawTileLabels)
{
CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText(
/*Location*/NavLocation.Location + CurrentData->NavMeshDrawOffset
, /*Text*/FString::Printf(TEXT("(%d,%d:%d)"), X, Y, Layer)
));
}
if (NavMesh->bDrawPolygonLabels || NavMesh->bDrawDefaultPolygonCost)
{
TArray<FNavPoly> Polys;
NavMesh->GetPolysInTile(TileIndex, Polys);
if (NavMesh->bDrawDefaultPolygonCost)
{
float DefaultCosts[RECAST_MAX_AREAS];
float FixedCosts[RECAST_MAX_AREAS];
NavMesh->GetDefaultQueryFilter()->GetAllAreaCosts(DefaultCosts, FixedCosts, RECAST_MAX_AREAS);
for(int k = 0; k < Polys.Num(); ++k)
{
uint32 AreaID = NavMesh->GetPolyAreaID(Polys[k].Ref);
CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText(
/*Location*/Polys[k].Center + CurrentData->NavMeshDrawOffset
, /*Text*/FString::Printf(TEXT("\\%.3f; %.3f\\"), DefaultCosts[AreaID], FixedCosts[AreaID])
));
}
}
else
{
for(int k = 0; k < Polys.Num(); ++k)
{
uint32 NavPolyIndex = 0;
uint32 NavTileIndex = 0;
NavMesh->GetPolyTileIndex(Polys[k].Ref, NavPolyIndex, NavTileIndex);
CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText(
/*Location*/Polys[k].Center + CurrentData->NavMeshDrawOffset
, /*Text*/FString::Printf(TEXT("[%X:%X]"), NavTileIndex, NavPolyIndex)
));
}
}
}
if (NavMesh->bDrawTileBounds)
{
FBox TileBox = NavMesh->GetNavMeshTileBounds(TileIndex);
float DrawZ = (TileBox.Min.Z + TileBox.Max.Z) * 0.5f; // @hack average
FVector LL(TileBox.Min.X, TileBox.Min.Y, DrawZ);
FVector UR(TileBox.Max.X, TileBox.Max.Y, DrawZ);
FVector UL(LL.X, UR.Y, DrawZ);
FVector LR(UR.X, LL.Y, DrawZ);
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(LL, UL, NavMeshRenderColor_TileBounds, DefaultEdges_LineThickness));
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(UL, UR, NavMeshRenderColor_TileBounds, DefaultEdges_LineThickness));
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(UR, LR, NavMeshRenderColor_TileBounds, DefaultEdges_LineThickness));
CurrentData->ThickLineItems.Add(FNavMeshSceneProxyData::FDebugThickLine(LR, LL, NavMeshRenderColor_TileBounds, DefaultEdges_LineThickness));
}
}
}
}
CurrentData->bSkipDistanceCheck = GIsEditor && (GEngine->GetDebugLocalPlayer() == NULL);
CurrentData->bDrawClusters = NavMesh->bDrawClusters;
NavMesh->FinishBatchQuery();
// Draw Mesh
if (NavMesh->bDrawClusters)
{
for (int32 Idx = 0; Idx < CurrentData->NavMeshGeometry.Clusters.Num(); ++Idx)
{
const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.Clusters[Idx].MeshIndices;
if (MeshIndices.Num() == 0)
{
continue;
}
FNavMeshSceneProxyData::FDebugMeshData DebugMeshData;
DebugMeshData.ClusterColor = GetClusterColor(Idx);
for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx)
{
AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset, DebugMeshData.ClusterColor);
}
for (int32 TriIdx=0; TriIdx < MeshIndices.Num(); TriIdx+=3)
{
AddTriangleHelper(DebugMeshData, MeshIndices[TriIdx], MeshIndices[TriIdx+1], MeshIndices[TriIdx+2]);
}
CurrentData->MeshBuilders.Add(DebugMeshData);
}
}
else if (NavMesh->bDrawNavMesh)
{
for (int32 AreaType = 0; AreaType < RECAST_MAX_AREAS; ++AreaType)
{
const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.AreaIndices[AreaType];
if (MeshIndices.Num() == 0)
{
continue;
}
FNavMeshSceneProxyData::FDebugMeshData DebugMeshData;
for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx)
{
AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset, CurrentData->NavMeshColors[AreaType]);
}
for (int32 TriIdx=0; TriIdx < MeshIndices.Num(); TriIdx+=3)
{
AddTriangleHelper(DebugMeshData, MeshIndices[TriIdx], MeshIndices[TriIdx+1], MeshIndices[TriIdx+2]);
}
DebugMeshData.ClusterColor = CurrentData->NavMeshColors[AreaType];
CurrentData->MeshBuilders.Add(DebugMeshData);
}
}
if (NavMesh->bDrawPathCollidingGeometry)
{
// draw all geometry gathered in navoctree
const FNavigationOctree* NavOctree = NavMesh->GetWorld()->GetNavigationSystem()->GetNavOctree();
TArray<FVector> PathCollidingGeomVerts;
TArray <int32> PathCollidingGeomIndices;
for (FNavigationOctree::TConstIterator<> It(*NavOctree); It.HasPendingNodes(); It.Advance())
{
const FNavigationOctree::FNode& Node = It.GetCurrentNode();
for (FNavigationOctree::ElementConstIt ElementIt(Node.GetElementIt()); ElementIt; ElementIt++)
{
const FNavigationOctreeElement& Element = *ElementIt;
if (Element.ShouldUseGeometry(&NavMesh->NavDataConfig) && Element.Data.CollisionData.Num())
{
const FRecastGeometryCache CachedGeometry(Element.Data.CollisionData.GetData());
AppendGeometry(PathCollidingGeomVerts, PathCollidingGeomIndices, CachedGeometry.Verts, CachedGeometry.Header.NumVerts, CachedGeometry.Indices, CachedGeometry.Header.NumFaces);
}
}
FOREACH_OCTREE_CHILD_NODE(ChildRef)
{
if (Node.HasChild(ChildRef))
{
It.PushChild(ChildRef);
}
}
}
CurrentData->PathCollidingGeomIndices = PathCollidingGeomIndices;
for (const auto& Vertex : PathCollidingGeomVerts)
{
CurrentData->PathCollidingGeomVerts.Add(FDynamicMeshVertex(Vertex));
}
}
if (CurrentData->NavMeshGeometry.BuiltMeshIndices.Num() > 0)
{
FNavMeshSceneProxyData::FDebugMeshData DebugMeshData;
for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx)
{
AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_RecastTileBeingRebuilt);
}
DebugMeshData.Indices.Append(CurrentData->NavMeshGeometry.BuiltMeshIndices);
DebugMeshData.ClusterColor = NavMeshRenderColor_RecastTileBeingRebuilt;
CurrentData->MeshBuilders.Add(DebugMeshData);
// updates should be requested by FRecastNavMeshGenerator::TickAsyncBuild after tiles were refreshed
}
if (NavMesh->bDrawClusters)
{
for (int i = 0; i < CurrentData->NavMeshGeometry.ClusterLinks.Num(); i++)
{
const FRecastDebugGeometry::FClusterLink& CLink = CurrentData->NavMeshGeometry.ClusterLinks[i];
const FVector V0 = CLink.FromCluster + CurrentData->NavMeshDrawOffset;
const FVector V1 = CLink.ToCluster + CurrentData->NavMeshDrawOffset + FVector(0,0,20.0f);
CacheArc(CurrentData->ClusterLinkLines, V0, V1, 0.4f, 4, FColor::Black, ClusterLinkLines_LineThickness);
const FVector VOffset(0, 0, FVector::Dist(V0, V1) * 1.333f);
CacheArrowHead(CurrentData->ClusterLinkLines, V1, V0+VOffset, 30.f, FColor::Black, ClusterLinkLines_LineThickness);
}
}
// cache segment links
if (NavMesh->bDrawNavLinks)
{
for (int32 iArea = 0; iArea < RECAST_MAX_AREAS; iArea++)
{
const TArray<int32>& Indices = CurrentData->NavMeshGeometry.OffMeshSegmentAreas[iArea];
FNavMeshSceneProxyData::FDebugMeshData DebugMeshData;
int32 VertBase = 0;
for (int32 i = 0; i < Indices.Num(); i++)
{
FRecastDebugGeometry::FOffMeshSegment& SegInfo = CurrentData->NavMeshGeometry.OffMeshSegments[Indices[i]];
const FVector A0 = SegInfo.LeftStart + CurrentData->NavMeshDrawOffset;
const FVector A1 = SegInfo.LeftEnd + CurrentData->NavMeshDrawOffset;
const FVector B0 = SegInfo.RightStart + CurrentData->NavMeshDrawOffset;
const FVector B1 = SegInfo.RightEnd + CurrentData->NavMeshDrawOffset;
const FVector Edge0 = B0 - A0;
const FVector Edge1 = B1 - A1;
const float Len0 = Edge0.Size();
const float Len1 = Edge1.Size();
const FColor SegColor = DarkenColor(CurrentData->NavMeshColors[SegInfo.AreaID]);
const FColor ColA = (SegInfo.ValidEnds & FRecastDebugGeometry::OMLE_Left) ? FColor::White : FColor::Black;
const FColor ColB = (SegInfo.ValidEnds & FRecastDebugGeometry::OMLE_Right) ? FColor::White : FColor::Black;
const int32 NumArcPoints = 8;
const float ArcPtsScale = 1.0f / NumArcPoints;
FVector Prev0 = EvalArc(A0, Edge0, Len0*0.25f, 0);
FVector Prev1 = EvalArc(A1, Edge1, Len1*0.25f, 0);
AddVertexHelper(DebugMeshData, Prev0, ColA);
AddVertexHelper(DebugMeshData, Prev1, ColA);
for (int32 j = 1; j <= NumArcPoints; j++)
{
const float u = j * ArcPtsScale;
FVector Pt0 = EvalArc(A0, Edge0, Len0*0.25f, u);
FVector Pt1 = EvalArc(A1, Edge1, Len1*0.25f, u);
AddVertexHelper(DebugMeshData, Pt0, (j == NumArcPoints) ? ColB : FColor::White);
AddVertexHelper(DebugMeshData, Pt1, (j == NumArcPoints) ? ColB : FColor::White);
AddTriangleHelper(DebugMeshData, VertBase+0, VertBase+2, VertBase+1);
AddTriangleHelper(DebugMeshData, VertBase+2, VertBase+3, VertBase+1);
AddTriangleHelper(DebugMeshData, VertBase+0, VertBase+1, VertBase+2);
AddTriangleHelper(DebugMeshData, VertBase+2, VertBase+1, VertBase+3);
VertBase += 2;
Prev0 = Pt0;
Prev1 = Pt1;
}
VertBase += 2;
DebugMeshData.ClusterColor = SegColor;
}
if (DebugMeshData.Indices.Num())
{
CurrentData->MeshBuilders.Add(DebugMeshData);
}
}
}
CurrentData->NavMeshGeometry.PolyEdges.Empty();
CurrentData->NavMeshGeometry.NavMeshEdges.Empty();
}
void AHUD::GetActorsInSelectionRectangle(TSubclassOf<class AActor> ClassFilter, const FVector2D& FirstPoint, const FVector2D& SecondPoint, TArray<AActor*>& OutActors, bool bIncludeNonCollidingComponents, bool bActorMustBeFullyEnclosed)
{
// Because this is a HUD function it is likely to get called each tick,
// so make sure any previous contents of the out actor array have been cleared!
OutActors.Reset();
//Create Selection Rectangle from Points
FBox2D SelectionRectangle(0);
//This method ensures that an appropriate rectangle is generated,
// no matter what the coordinates of first and second point actually are.
SelectionRectangle += FirstPoint;
SelectionRectangle += SecondPoint;
//The Actor Bounds Point Mapping
const FVector BoundsPointMapping[8] =
{
FVector(1, 1, 1),
FVector(1, 1, -1),
FVector(1, -1, 1),
FVector(1, -1, -1),
FVector(-1, 1, 1),
FVector(-1, 1, -1),
FVector(-1, -1, 1),
FVector(-1, -1, -1)
};
//~~~
//For Each Actor of the Class Filter Type
for (TActorIterator<AActor> Itr(GetWorld(), ClassFilter); Itr; ++Itr)
{
AActor* EachActor = *Itr;
//Get Actor Bounds //casting to base class, checked by template in the .h
const FBox EachActorBounds = Cast<AActor>(EachActor)->GetComponentsBoundingBox(bIncludeNonCollidingComponents); /* All Components? */
//Center
const FVector BoxCenter = EachActorBounds.GetCenter();
//Extents
const FVector BoxExtents = EachActorBounds.GetExtent();
// Build 2D bounding box of actor in screen space
FBox2D ActorBox2D(0);
for (uint8 BoundsPointItr = 0; BoundsPointItr < 8; BoundsPointItr++)
{
// Project vert into screen space.
const FVector ProjectedWorldLocation = Project(BoxCenter + (BoundsPointMapping[BoundsPointItr] * BoxExtents));
// Add to 2D bounding box
ActorBox2D += FVector2D(ProjectedWorldLocation.X, ProjectedWorldLocation.Y);
}
//Selection Box must fully enclose the Projected Actor Bounds
if (bActorMustBeFullyEnclosed)
{
if(SelectionRectangle.IsInside(ActorBox2D))
{
OutActors.Add(Cast<AActor>(EachActor));
}
}
//Partial Intersection with Projected Actor Bounds
else
{
if (SelectionRectangle.Intersect(ActorBox2D))
{
OutActors.Add(Cast<AActor>(EachActor));
}
}
}
}