UE4 动态创建寻路网格（二）

已于 2023-09-28 10:55:35 修改
阅读量749 收藏
点赞数
分类专栏： C++ UE4 文章标签： ue4 c++
于 2023-09-20 12:47:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DuGuYiZhao/article/details/133073042
版权
UE4 同时被 2 个专栏收录
18 篇文章 4 订阅
订阅专栏
C++
11 篇文章 0 订阅
订阅专栏

目录

1. 依赖模块

2. 自定义 ANavMeshBoundsVolume

3. 动态绘制

4. 模块化

5.导航测试

1. 依赖模块

*.build.cs

        PublicDependencyModuleNames
                "NavigationSystem",
                "Landscape",

2. 自定义 ANavMeshBoundsVolume

#pragma once

#include "CoreMinimal.h"
//#include "GameFramework/Volume.h"
#include "NavMesh/NavMeshBoundsVolume.h"
#include "CustomNavMeshBoundsVolume.generated.h"

UCLASS(BlueprintType, Blueprintable)
class NAVTEST_API ACustomNavMeshBoundsVolume : public ANavMeshBoundsVolume, public INavRelevantInterface 
{
    GENERATED_BODY()

public:
    // Sets default values for this actor's properties
    ACustomNavMeshBoundsVolume();

    
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "RuntimeNavMesh")
    float Width;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "RuntimeNavMesh")
    float Height;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "RuntimeNavMesh")
    float Depth;

    // Function to update the Brush Shape
    UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh")
    void UpdateBrushShape();


    //~ Begin AActor Interface
    virtual void PostRegisterAllComponents() override;
    virtual void PostUnregisterAllComponents() override;
    //~ End AActor Interface
#if WITH_EDITOR
    //~ Begin UObject Interface
    virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual void PostEditUndo() override;
    //~ End UObject Interface
#endif // WITH_EDITOR


    virtual void CalcAndCacheBounds() const;
    //~ Begin INavRelevantInterface Interface
    virtual FBox GetNavigationBounds() const override;
    virtual bool IsNavigationRelevant() const override;
    virtual void UpdateNavigationBounds() override;
    virtual UObject* GetNavigationParent() const override;
    //~ End INavRelevantInterface Interface

    //~ Begin Actor Interface
    virtual FBox GetComponentsBoundingBox(bool bNonColliding = false, bool bIncludeFromChildActors = false) const override;
    //~ End Actor Interface

private:
    void updateNavMesh();
protected:

	/** bounds for navigation octree */
	mutable  FBox Bounds;
    FBox BoundsPre;
    
	mutable uint32 bBoundsInitialized : 1;

};

.cpp

#include "CustomNavMeshBoundsVolume.h"
#include "PhysicsEngine/BoxElem.h"
#include "NavigationSystem.h"
#include "Components/BrushComponent.h"


ACustomNavMeshBoundsVolume::ACustomNavMeshBoundsVolume()
{
    Width = 1000.0f;
    Height = 1000.0f;
    Depth = 1000.0f;

    GetBrushComponent()->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    GetBrushComponent()->Mobility = EComponentMobility::Movable;

    BrushColor = FColor(200, 200, 200, 255);
    SupportedAgents.MarkInitialized();

    bColored = true;

    //bNavigationRelevant = true;
    PrimaryActorTick.bCanEverTick = true;
    BoundsPre.Init();
#if WITH_EDITOR
    updateNavMesh();
#endif
}

// Called when the game starts or when spawned
void ACustomNavMeshBoundsVolume::BeginPlay()
{
    Super::BeginPlay();

}

void ACustomNavMeshBoundsVolume::updateNavMesh()
{
    CalcAndCacheBounds();
    if (!(Bounds == BoundsPre))
    {
        BoundsPre = Bounds;
        UpdateBrushShape();
    }
}

// Called every frame
void ACustomNavMeshBoundsVolume::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    updateNavMesh();
}

// Function to update the Brush Shape
void ACustomNavMeshBoundsVolume::UpdateBrushShape()
{
    UpdateNavigationBounds();

    class UBrushComponent* CurrBrushComp = GetBrushComponent();
    if (CurrBrushComp)
    {
        // Clear the old Brush Component
        //GetBrushComponent()->ClearBrushComponent();
        //GetBrushComponent()->MarkRenderStateDirty();

        
        if (CurrBrushComp->BrushBodySetup)
        {
            CurrBrushComp->BrushBodySetup->AggGeom.BoxElems.Add(FKBoxElem(Depth, Width, Height));
        }
        else
        {
            if (GEngine)
            {
                //GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("CurrBrushComp->BrushBodySetup invalid!")));
                UE_LOG(LogTemp, Log, TEXT("CurrBrushComp->BrushBodySetup invalid!"));
            }
        }
            
        // Update navigation data
        FNavigationSystem::UpdateComponentData(*CurrBrushComp);

        UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
        if (NavSys)
        {
            NavSys->OnNavigationBoundsUpdated(this);
            NavSys->UpdateActorInNavOctree(*this);
        }
    }
    else
    {
        if (GEngine)
        {
            //GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("CurrBrushComp invalid!")));
            UE_LOG(LogTemp, Log, TEXT("CurrBrushComp invalid!"));
        }
    }
}

void ACustomNavMeshBoundsVolume::PostRegisterAllComponents()
{
    Super::PostRegisterAllComponents();

    UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
    if (NavSys && GetLocalRole() == ROLE_Authority)
    {
        NavSys->OnNavigationBoundsAdded(this);
    }
}

void ACustomNavMeshBoundsVolume::PostUnregisterAllComponents()
{
    Super::PostUnregisterAllComponents();

    UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
    if (NavSys && GetLocalRole() == ROLE_Authority)
    {
        NavSys->OnNavigationBoundsRemoved(this);
    }
}

#if WITH_EDITOR

void ACustomNavMeshBoundsVolume::PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent)
{
    Super::PostEditChangeProperty(PropertyChangedEvent);

    UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
    if (GIsEditor && NavSys)
    {
        const FName PropName = (PropertyChangedEvent.Property != nullptr) ? PropertyChangedEvent.Property->GetFName() : FName();
        const FName MemberName = (PropertyChangedEvent.MemberProperty != nullptr) ? PropertyChangedEvent.MemberProperty->GetFName() : FName();

        if (PropName == FName("Width")
            || PropName == FName("Height")
            || PropName == FName("Depth")
            || PropName == FName("ComponentToWorld")
            || PropName == GET_MEMBER_NAME_CHECKED(ABrush, BrushBuilder)
            || MemberName == GET_MEMBER_NAME_CHECKED(ANavMeshBoundsVolume, SupportedAgents)
            || MemberName == USceneComponent::GetRelativeLocationPropertyName()
            || MemberName == USceneComponent::GetRelativeRotationPropertyName()
            || MemberName == USceneComponent::GetRelativeScale3DPropertyName())
        {       
            CalcAndCacheBounds();
            BoundsPre = Bounds;
            NavSys->OnNavigationBoundsUpdated(this);
        }
    }
}

void ACustomNavMeshBoundsVolume::PostEditUndo()
{
    Super::PostEditUndo();
    UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
    if (GIsEditor && NavSys)
    {
        NavSys->OnNavigationBoundsUpdated(this);
    }
}

#endif // WITH_EDITOR



void ACustomNavMeshBoundsVolume::CalcAndCacheBounds() const
{
    FVector vecScale(1.0, 1.0, 1.0);
    vecScale = GetActorScale();
    Bounds = FBox::BuildAABB(GetActorLocation(), FVector(Depth, Width, Height) / 2 * vecScale);
    
    
    //旋转========旋转轴有问题，待优化
    FQuat Quat = GetActorQuat();    
    FTransform RotTran;
    RotTran.SetRotation(Quat);
    Bounds = Bounds.TransformBy(RotTran);
}

//~ Begin INavRelevantInterface Interface
FBox ACustomNavMeshBoundsVolume::GetNavigationBounds() const
{
    //if (!bBoundsInitialized || !(Bounds == BoundsPre))
    {
        CalcAndCacheBounds();
        bBoundsInitialized = true;
    }

    return Bounds;
}
bool ACustomNavMeshBoundsVolume::IsNavigationRelevant() const
{
    return true;// bNavigationRelevant;
}
void ACustomNavMeshBoundsVolume::UpdateNavigationBounds()
{
    CalcAndCacheBounds();
    bBoundsInitialized = true;
}
UObject* ACustomNavMeshBoundsVolume::GetNavigationParent() const
{
    return GetOwner();
}
//~ End INavRelevantInterface Interface


FBox ACustomNavMeshBoundsVolume::GetComponentsBoundingBox(bool bNonColliding/* = false*/, bool bIncludeFromChildActors/* = false*/) const
{
    FBox Box(ForceInit);
    Box = Super::GetComponentsBoundingBox(bNonColliding, bIncludeFromChildActors);
    Box += GetNavigationBounds();
    return Box;
}

3. 动态绘制

 .h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "NavMeshDrawMgrActor.generated.h"

class ULineBatchComponent;

UCLASS()
class NAVTEST_API ANavMeshDrawMgrActor : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	ANavMeshDrawMgrActor();

public:

	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category=DebugDraw)
		bool bShowBox=false;
	/** Box Line Batchers.  */
	UPROPERTY(Transient)
		class ULineBatchComponent* BoxLineBatcher;
	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = DebugDraw)
		bool bShowNavMesh = false;
	/** NavMesh Line Batchers.  */
	UPROPERTY(Transient)
		class ULineBatchComponent* NavMeshLineBatcher;
	/** NavMesh Edges Line Batchers.  */
	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = DebugDraw)
		bool bShowNavMeshEdges = false;
	UPROPERTY(Transient)
		class ULineBatchComponent* NavMeshEdgesLineBatcher;
private:
	/** LineBatcher组件初始化 */
	void initLineBatcher();
	/** LineBatcher组件清理 */
	void clearLineBatcher();
	/** 绘制清理 */
	void FlushBoxDebugLines();
	void FlushNavMeshDebugLines();
	void FlushNavMeshEdgesDebugLines();
	/** 绘制Box */
	void DrawDebugBox(const UWorld* InWorld, FVector const& Center, FVector const& Extent, FColor const& Color, bool bPersistentLines = false, float LifeTime = -1.f, uint8 DepthPriority = 0, float Thickness = 0.f);
	/** 绘制Mesh */
	void DrawDebugMesh(const UWorld* InWorld, TArray<FVector> const& Verts, TArray<int32> const& Indices, FColor const& Color, bool bPersistent = false, float LifeTime = -1.f, uint8 DepthPriority = 0);
	/** 绘制Line */
	void DrawDebugLine(const UWorld* InWorld, FVector const& LineStart, FVector const& LineEnd, FColor const& Color, bool bPersistentLines = false, float LifeTime = -1.f, uint8 DepthPriority = 0, float Thickness = 0.f);
	/** 更新导航盒子 */
	void UpdateNavBoxDraw();
	/** 更新导航网格 */
	void UpdateNavMeshDraw();
	/** 更新导航网格边界 */
	void UpdateNavMeshEdgesDraw();
	/** 绘制导航网格Tiles */
	void DrawNavMeshTiles();
	/** 绘制导航网格Edges */
	void DrawNavMeshEdges();
public:

	/** Draw Navigation Mesh in Runtime (Box) */
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|Draw")
	bool RtNavMeshDrawBox(bool bInShowBox = true);
	/** Draw Navigation Mesh in Runtime (Mesh) */
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|Draw")
	bool RtNavMeshDrawMesh(bool bInShowNavMesh = true);
	/** Draw Navigation Mesh in Runtime (Edges) */
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|Draw")
	bool RtNavMeshDrawEdges(bool bInShowNavMeshEdges = true);

	/** Draw Navigation Mesh in Runtime */
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|Draw")
		bool RtNavMeshDraw(bool bInShowBox = true, bool bInShowNavMesh = true);
	/** Draw Navigation Mesh in Runtime */
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|Draw")
		bool RuntimeNavMeshDraw(bool bInShowBox = true, bool bInShowNavMesh = true, bool bInShowNavMeshEdges = true);

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

};

.cpp

// Fill out your copyright notice in the Description page of Project Settings.


#include "NavMeshDrawMgrActor.h"
#include "NavMesh/NavMeshRenderingComponent.h"
#include "Kismet/GameplayStatics.h"
#include "NavMesh/RecastNavMesh.h"
#include "NavMesh/NavMeshBoundsVolume.h"
#include "EngineUtils.h"
#include "Components/LineBatchComponent.h"
#include "NavigationSystem.h"
#include <QERBoxCollision.h>
//#include "DetourNavMesh.h"

// Sets default values
ANavMeshDrawMgrActor::ANavMeshDrawMgrActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

}

void ANavMeshDrawMgrActor::initLineBatcher()
{
	if (!BoxLineBatcher)
	{
		BoxLineBatcher = NewObject<ULineBatchComponent>();
		BoxLineBatcher->bCalculateAccurateBounds = false;
	}
	if (BoxLineBatcher && !BoxLineBatcher->IsRegistered())
	{
		BoxLineBatcher->RegisterComponentWithWorld(GetWorld());
	}

	if (!NavMeshLineBatcher)
	{
		NavMeshLineBatcher = NewObject<ULineBatchComponent>();
		NavMeshLineBatcher->bCalculateAccurateBounds = false;
	}
	if (NavMeshLineBatcher && !NavMeshLineBatcher->IsRegistered())
	{
		NavMeshLineBatcher->RegisterComponentWithWorld(GetWorld());
	}

	if (!NavMeshEdgesLineBatcher)
	{
		NavMeshEdgesLineBatcher = NewObject<ULineBatchComponent>();
		NavMeshEdgesLineBatcher->bCalculateAccurateBounds = false;
	}
	if (NavMeshEdgesLineBatcher && !NavMeshEdgesLineBatcher->IsRegistered())
	{
		NavMeshEdgesLineBatcher->RegisterComponentWithWorld(GetWorld());
	}
}

void ANavMeshDrawMgrActor::clearLineBatcher()
{
	if (BoxLineBatcher && BoxLineBatcher->IsRegistered())
	{
		BoxLineBatcher->UnregisterComponent();
	}

	if (NavMeshLineBatcher && NavMeshLineBatcher->IsRegistered())
	{
		NavMeshLineBatcher->UnregisterComponent();
	}

	if (NavMeshEdgesLineBatcher && NavMeshEdgesLineBatcher->IsRegistered())
	{
		NavMeshEdgesLineBatcher->UnregisterComponent();
	}
}

void ANavMeshDrawMgrActor::FlushBoxDebugLines()
{
	if (BoxLineBatcher)
	{
		BoxLineBatcher->Flush();
	}
}

void ANavMeshDrawMgrActor::FlushNavMeshDebugLines()
{
	if (NavMeshLineBatcher)
	{
		NavMeshLineBatcher->Flush();
	}
}

void ANavMeshDrawMgrActor::FlushNavMeshEdgesDebugLines()
{
	if (NavMeshEdgesLineBatcher)
	{
		NavMeshEdgesLineBatcher->Flush();
	}
}

void ANavMeshDrawMgrActor::DrawDebugBox(const UWorld* InWorld, FVector const& Center, FVector const& Box, FColor const& Color, bool bPersistentLines /*= false*/, float LifeTime /*= -1.f*/, uint8 DepthPriority /*= 0*/, float Thickness /*= 0.f*/)
{
	// no debug line drawing on dedicated server
	if (GEngine->GetNetMode(InWorld) != NM_DedicatedServer)
	{
		// this means foreground lines can't be persistent 
		if (ULineBatchComponent* const LineBatcher = BoxLineBatcher)
		{
			float LineLifeTime = bPersistentLines ? -1.0f : ((LifeTime > 0.f) ? LifeTime : LineBatcher->DefaultLifeTime);

			LineBatcher->DrawLine(Center + FVector(Box.X, Box.Y, Box.Z), Center + FVector(Box.X, -Box.Y, Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(Box.X, -Box.Y, Box.Z), Center + FVector(-Box.X, -Box.Y, Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, -Box.Y, Box.Z), Center + FVector(-Box.X, Box.Y, Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, Box.Y, Box.Z), Center + FVector(Box.X, Box.Y, Box.Z), Color, DepthPriority, Thickness, LineLifeTime);

			LineBatcher->DrawLine(Center + FVector(Box.X, Box.Y, -Box.Z), Center + FVector(Box.X, -Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(Box.X, -Box.Y, -Box.Z), Center + FVector(-Box.X, -Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, -Box.Y, -Box.Z), Center + FVector(-Box.X, Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, Box.Y, -Box.Z), Center + FVector(Box.X, Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);

			LineBatcher->DrawLine(Center + FVector(Box.X, Box.Y, Box.Z), Center + FVector(Box.X, Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(Box.X, -Box.Y, Box.Z), Center + FVector(Box.X, -Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, -Box.Y, Box.Z), Center + FVector(-Box.X, -Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
			LineBatcher->DrawLine(Center + FVector(-Box.X, Box.Y, Box.Z), Center + FVector(-Box.X, Box.Y, -Box.Z), Color, DepthPriority, Thickness, LineLifeTime);
		}
	}
	else
	{
		//UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT(&DrawDebugBox, Center, Box, Color, bPersistentLines, LifeTime, DepthPriority, Thickness);
	}
}

void ANavMeshDrawMgrActor::DrawDebugMesh(const UWorld* InWorld, TArray<FVector> const& Verts, TArray<int32> const& Indices, FColor const& Color, bool bPersistent /*= false*/, float LifeTime /*= -1.f*/, uint8 DepthPriority /*= 0*/)
{
	// no debug line drawing on dedicated server
	if (GEngine->GetNetMode(InWorld) != NM_DedicatedServer)
	{
		if (ULineBatchComponent* const LineBatcher = NavMeshLineBatcher)
		{
			float const ActualLifetime = bPersistent ? -1.0f : ((LifeTime > 0.f) ? LifeTime : LineBatcher->DefaultLifeTime);
			LineBatcher->DrawMesh(Verts, Indices, Color, DepthPriority, ActualLifetime);
		}
	}
	else
	{
		//UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT(DrawDebugMesh, Verts, Indices, Color, bPersistent, LifeTime, DepthPriority);
	}
}

void ANavMeshDrawMgrActor::DrawDebugLine(const UWorld* InWorld, FVector const& LineStart, FVector const& LineEnd, FColor const& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority, float Thickness)
{
	if (GEngine->GetNetMode(InWorld) != NM_DedicatedServer)
	{
		// this means foreground lines can't be persistent 
		if (ULineBatchComponent* const LineBatcher = NavMeshEdgesLineBatcher)
		{
			float const LineLifeTime = bPersistentLines ? -1.0f : ((LifeTime > 0.f) ? LifeTime : LineBatcher->DefaultLifeTime);
			LineBatcher->DrawLine(LineStart, LineEnd, Color, DepthPriority, Thickness, LineLifeTime);
		}
	}
	else
	{
		//UE_DRAW_SERVER_DEBUG_ON_EACH_CLIENT(DrawDebugLine, LineStart, LineEnd, AdjustColorForServer(Color), bPersistentLines, LifeTime, DepthPriority, Thickness);
	}
}

void ANavMeshDrawMgrActor::UpdateNavBoxDraw()
{
	this->FlushBoxDebugLines();

	UWorld* CurrWorld = GetWorld();
	if (CurrWorld)
	{
		if (bShowBox)
		{
			const EActorIteratorFlags Flags = EActorIteratorFlags::SkipPendingKill;
			for (TActorIterator<ANavMeshBoundsVolume> ItNavMeshBV(CurrWorld, ANavMeshBoundsVolume::StaticClass(), Flags); ItNavMeshBV; ++ItNavMeshBV)
			{
				ANavMeshBoundsVolume* pTempNMBV = *ItNavMeshBV;
				if (pTempNMBV)
				{
					const FVector Center = pTempNMBV->GetComponentsBoundingBox().GetCenter();
					const FVector Extent = pTempNMBV->GetComponentsBoundingBox().GetSize() / 2.f;

					this->DrawDebugBox(CurrWorld, Center, Extent, FColor(0, 255, 0), true, -1.f, 0, 10.f);
				}
			}
		}
	}
}

/** 更新导航网格 */
void ANavMeshDrawMgrActor::UpdateNavMeshDraw()
{
	this->FlushNavMeshDebugLines();
	if (bShowNavMesh)
	{
		DrawNavMeshTiles();
	}
}

/** 更新导航网格边界 */
void ANavMeshDrawMgrActor::UpdateNavMeshEdgesDraw()
{
	this->FlushNavMeshEdgesDebugLines();
	if (bShowNavMeshEdges)
	{
		DrawNavMeshEdges();
	}
}

/** Draw Navigation Mesh in Runtime (Box) */
bool ANavMeshDrawMgrActor::RtNavMeshDrawBox(bool bInShowBox/* = true*/)
{
	bShowBox = bInShowBox;
	if (!bInShowBox)
	{
		this->FlushBoxDebugLines();
	}
	return true;
}
/** Draw Navigation Mesh in Runtime (Mesh) */
bool ANavMeshDrawMgrActor::RtNavMeshDrawMesh(bool bInShowNavMesh/* = true*/)
{
	bShowNavMesh = bInShowNavMesh;
	if (!bInShowNavMesh)
	{
		this->FlushNavMeshDebugLines();
	}
	return true;
}
/** Draw Navigation Mesh in Runtime (Edges) */
bool ANavMeshDrawMgrActor::RtNavMeshDrawEdges(bool bInShowNavMeshEdges/* = true*/)
{
	bShowNavMeshEdges = bInShowNavMeshEdges;
	if (!bInShowNavMeshEdges)
	{
		this->FlushNavMeshEdgesDebugLines();
	}
	return true;
}

bool ANavMeshDrawMgrActor::RtNavMeshDraw(bool bInShowBox /*= true*/, bool bInShowNavMesh /*= true*/)
{
	UWorld* CurrWorld = GetWorld();
	if (CurrWorld)
	{
#if 0 //WITH_EDITOR
		ARecastNavMesh* DefRecastNavMesh = Cast<ARecastNavMesh>(UGameplayStatics::GetActorOfClass(CurrWorld, ARecastNavMesh::StaticClass()));
		if (DefRecastNavMesh)
		{
			DefRecastNavMesh->bDrawFilledPolys = bInDraw;
			DefRecastNavMesh->bDrawNavMeshEdges = bInDraw;
			//DefRecastNavMesh->UpdateDrawing();
			UNavMeshRenderingComponent* NavMeshRenderComp = Cast<UNavMeshRenderingComponent>(DefRecastNavMesh->RenderingComp);
			if (NavMeshRenderComp != nullptr && NavMeshRenderComp->GetVisibleFlag() && (NavMeshRenderComp->IsForcingUpdate() || UNavMeshRenderingComponent::IsNavigationShowFlagSet(CurrWorld)))
			{
				DefRecastNavMesh->RenderingComp->MarkRenderStateDirty();
			}
			//return true;
		}
#endif

		RtNavMeshDrawBox(bInShowBox);
		RtNavMeshDrawMesh(bInShowNavMesh);

		return true;
	}

	return false;
}

bool ANavMeshDrawMgrActor::RuntimeNavMeshDraw(bool bInShowBox /*= true*/, bool bInShowNavMesh /*= true*/, bool bInShowNavMeshEdges /*= true*/)
{
	RtNavMeshDrawBox(bInShowBox);
	RtNavMeshDrawMesh(bInShowNavMesh);
	RtNavMeshDrawEdges(bInShowNavMeshEdges);

	return true;
}

// Called when the game starts or when spawned
void ANavMeshDrawMgrActor::BeginPlay()
{
	Super::BeginPlay();

	initLineBatcher();
}

// Called every frame
void ANavMeshDrawMgrActor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	if (bShowBox)
	{
		UpdateNavBoxDraw();
	}

	if (bShowNavMesh)
	{
		UpdateNavMeshDraw();
	}
	if (bShowNavMeshEdges)
	{
		UpdateNavMeshEdgesDraw();
	}
}

void ANavMeshDrawMgrActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	FlushBoxDebugLines();
	FlushNavMeshDebugLines();
	FlushNavMeshEdgesDebugLines();
	clearLineBatcher();
}

#if WITH_RECAST
int32 ANavMeshDrawMgrActor::GetDetailFlags(const ARecastNavMesh* NavMesh)
{
	return (NavMesh == nullptr) ? 0 : 0 |
		(NavMesh->bDrawTriangleEdges ? (1 << static_cast<int32>(ENavMeshDetailFlags::TriangleEdges)) : 0) |
		(NavMesh->bDrawPolyEdges ? (1 << static_cast<int32>(ENavMeshDetailFlags::PolyEdges)) : 0) |
		(NavMesh->bDrawFilledPolys ? (1 << static_cast<int32>(ENavMeshDetailFlags::FilledPolys)) : 0) |
		(NavMesh->bDrawNavMeshEdges ? (1 << static_cast<int32>(ENavMeshDetailFlags::BoundaryEdges)) : 0) |
		(NavMesh->bDrawTileBounds ? (1 << static_cast<int32>(ENavMeshDetailFlags::TileBounds)) : 0) |
		(NavMesh->bDrawPathCollidingGeometry ? (1 << static_cast<int32>(ENavMeshDetailFlags::PathCollidingGeometry)) : 0) |
		(NavMesh->bDrawTileLabels ? (1 << static_cast<int32>(ENavMeshDetailFlags::TileLabels)) : 0) |
		(NavMesh->bDrawPolygonLabels ? (1 << static_cast<int32>(ENavMeshDetailFlags::PolygonLabels)) : 0) |
		(NavMesh->bDrawDefaultPolygonCost ? (1 << static_cast<int32>(ENavMeshDetailFlags::PolygonCost)) : 0) |
		(NavMesh->bDrawPolygonFlags ? (1 << static_cast<int32>(ENavMeshDetailFlags::PolygonFlags)) : 0) |
		(NavMesh->bDrawLabelsOnPathNodes ? (1 << static_cast<int32>(ENavMeshDetailFlags::PathLabels)) : 0) |
		(NavMesh->bDrawNavLinks ? (1 << static_cast<int32>(ENavMeshDetailFlags::NavLinks)) : 0) |
		(NavMesh->bDrawFailedNavLinks ? (1 << static_cast<int32>(ENavMeshDetailFlags::FailedNavLinks)) : 0) |
		(NavMesh->bDrawClusters ? (1 << static_cast<int32>(ENavMeshDetailFlags::Clusters)) : 0) |
		(NavMesh->bDrawOctree ? (1 << static_cast<int32>(ENavMeshDetailFlags::NavOctree)) : 0) |
		(NavMesh->bDrawOctreeDetails ? (1 << static_cast<int32>(ENavMeshDetailFlags::NavOctreeDetails)) : 0) |
		(NavMesh->bDrawMarkedForbiddenPolys ? (1 << static_cast<int32>(ENavMeshDetailFlags::MarkForbiddenPolys)) : 0);
}
#endif // WITH_RECAST

void ANavMeshDrawMgrActor::DrawNavMeshTiles()
{
	UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());

	if (NavSys)
	{
#if WITH_RECAST
		for (auto NavigationData : NavSys->NavDataSet)
		{
			ARecastNavMesh* RecastNavMesh = Cast<ARecastNavMesh>(NavigationData);
			if (RecastNavMesh)
			{
				const FNavDataConfig& NavConfig = RecastNavMesh->GetConfig();
				TArray<FColor> NavMeshColors;
				NavMeshColors.AddDefaulted(RECAST_MAX_AREAS);

				for (uint8 Idx = 0; Idx < RECAST_MAX_AREAS; Idx++)
				{
					NavMeshColors[Idx] = RecastNavMesh->GetAreaIDColor(Idx);
				}
				NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : FColor(140, 255, 0, 164);
				FVector NavMeshDrawOffset = FVector::ZeroVector;
				NavMeshDrawOffset.Z = RecastNavMesh->DrawOffset;

				//方式2：代理方式
				FNavMeshSceneProxyData OutProxyData;
				//const int32 DetailFlags = OutProxyData.GetDetailFlags(RecastNavMesh);// UE4.27
				const int32 DetailFlags = GetDetailFlags(RecastNavMesh);
				TArray<int32> EmptyTileSet;
				OutProxyData.GatherData(RecastNavMesh, DetailFlags, EmptyTileSet);
				for (FNavMeshSceneProxyData::FDebugMeshData& ItDMeshData : OutProxyData.MeshBuilders)
				{
					TArray<FVector> ArrayVecTempVerties;
					int nVertNum = ItDMeshData.Vertices.Num();
					ArrayVecTempVerties.AddDefaulted(nVertNum);
					for (int nItVert = 0; nItVert < nVertNum; ++nItVert)
					{
						//ArrayVecTempVerties[nItVert] = ItDMeshData.Vertices[nItVert].Position;// UE4.27
						ArrayVecTempVerties[nItVert].X = ItDMeshData.Vertices[nItVert].Position.X;
						ArrayVecTempVerties[nItVert].Y = ItDMeshData.Vertices[nItVert].Position.Y;
						ArrayVecTempVerties[nItVert].Z = ItDMeshData.Vertices[nItVert].Position.Z;
					}
					TArray<int32> ArrayTempIndex;
					int nIdxNum = ItDMeshData.Indices.Num();
					ArrayTempIndex.AddDefaulted(nIdxNum);
					for (int nItIdx = 0; nItIdx < nIdxNum; ++nItIdx)
					{
						ArrayTempIndex[nItIdx] = ItDMeshData.Indices[nItIdx];
					}
					this->DrawDebugMesh(GetWorld(), ArrayVecTempVerties, ArrayTempIndex, ItDMeshData.ClusterColor, true, -1.f, 2);

				}

#if 0
				//方式1：GetDebugGeometry(FRecastDebugGeometry & OutGeometry, int32 TileIndex = INDEX_NONE)
				FRecastDebugGeometry OutGeometry;
				OutGeometry.bGatherNavMeshEdges = false;
				OutGeometry.bGatherPolyEdges = true;// false;
				OutGeometry.bMarkForbiddenPolys = false;
				RecastNavMesh->GetDebugGeometry(OutGeometry);
				//this->DrawDebugMesh(GetWorld(), OutGeometry.MeshVerts, OutGeometry.BuiltMeshIndices, FColor(0, 200, 0), true, -1.f, 0);
				//Offset
				TArray<FVector> VecMeshVertsWithOffset;
				int nVertNum = OutGeometry.MeshVerts.Num();
				VecMeshVertsWithOffset.AddDefaulted(nVertNum);
				for (int32 VertIdx = 0; VertIdx < nVertNum; ++VertIdx)
				{
					VecMeshVertsWithOffset[VertIdx] = OutGeometry.MeshVerts[VertIdx] + NavMeshDrawOffset;
				}
				for (int32 AreaType = 0; AreaType < RECAST_MAX_AREAS; ++AreaType)
				{
					if (NavMeshColors[AreaType].B>0  || NavMeshColors[AreaType].R> NavMeshColors[AreaType].G)
					{
						if (GEngine)
						{							
							GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("Blue Area %d: Color-%s"), AreaType, *NavMeshColors[AreaType].ToString()));
							UE_LOG(LogTemp, Log, TEXT("CurrBrushComp invalid!"));
						}
					}
					else
					{
						this->DrawDebugMesh(GetWorld(), VecMeshVertsWithOffset, OutGeometry.AreaIndices[AreaType], NavMeshColors[AreaType], true, -1.f, 0);
						break;
					}
				}
			}
		}
#endif
	}
}

void ANavMeshDrawMgrActor::DrawNavMeshEdges()
{
	UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());

	if (NavSys)
	{
#if WITH_RECAST
		for (auto NavigationData : NavSys->NavDataSet)
		{
			ARecastNavMesh* RecastNavMesh = Cast<ARecastNavMesh>(NavigationData);
			if (RecastNavMesh)
			{
				const FNavDataConfig& NavConfig = RecastNavMesh->GetConfig();
				TArray<FColor> NavMeshColors;
				NavMeshColors.AddDefaulted(RECAST_MAX_AREAS);

				for (uint8 Idx = 0; Idx < RECAST_MAX_AREAS; Idx++)
				{
					NavMeshColors[Idx] = RecastNavMesh->GetAreaIDColor(Idx);
				}
				NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : FColor(140, 255, 0, 164);
				FVector NavMeshDrawOffset = FVector::ZeroVector;
				NavMeshDrawOffset.Z = RecastNavMesh->DrawOffset;

				//GetDebugGeometry(FRecastDebugGeometry & OutGeometry, int32 TileIndex = INDEX_NONE)
				FRecastDebugGeometry OutGeometry;
				OutGeometry.bGatherNavMeshEdges = true;
				OutGeometry.bGatherPolyEdges = false;
				OutGeometry.bMarkForbiddenPolys = false;
				RecastNavMesh->GetDebugGeometry(OutGeometry);

				//NavMeshEdges
				const uint32 Col = NavMeshColors[RECAST_DEFAULT_AREA].DWColor();
				const FColor EdgesColor = FColor(((Col >> 1) & 0x007f7f7f) | (Col & 0xff000000));
				const TArray<FVector>& NavMeshEdgeVerts = OutGeometry.NavMeshEdges;
				for (int32 Idx = 0; Idx < NavMeshEdgeVerts.Num(); Idx += 2)
				{
					this->DrawDebugLine(GetWorld(), NavMeshEdgeVerts[Idx] + NavMeshDrawOffset, NavMeshEdgeVerts[Idx + 1] + NavMeshDrawOffset, /*EdgesColor*/ FColor(0, 0, 255, 255), true, -1.f, 4);
				}
			}
		}
#endif
	}
}

4. 模块化

.h

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"

class FNavTestModule : public IModuleInterface
{
public:

	/** IModuleInterface implementation */
	virtual void StartupModule() override;
	virtual void ShutdownModule() override;
};

.cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "NavTest.h"
#include "Modules/ModuleManager.h"

#define LOCTEXT_NAMESPACE "FNavTestModule"

void FNavTestModule::StartupModule()
{
	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
}

void FNavTestModule::ShutdownModule()
{
	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
	// we call this function before unloading the module.
}

#undef LOCTEXT_NAMESPACE
	
IMPLEMENT_MODULE(FNavTestModule, NavTest)

5.导航测试

 .h

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "NavBlueprintFunctionLibrary.generated.h"

class UNavigationPath;
/**
 * 
 */
UCLASS()
class NAVTEST_API UNavBlueprintFunctionLibrary : public UBlueprintFunctionLibrary
{
	GENERATED_BODY()
	
public:

	/** 获取指定名称的World; */
	/*@Param	InStrWorldName		World Name
	 *@Return	UWorld*				World Pointer(if World Name is Empty return the first vaild world.)	
	*/
	static UWorld* GetWorldByName(FString InStrWorldName=TEXT(""));

	// Function to find the Nearest Point of Navigation
	//@param InStartPoint		Start Point
	//@param InEndPoint			End Point(Preferably a navigable point)
	//@param fNavigationOffset	Navigation offset
	UFUNCTION(BlueprintCallable, Category = "RuntimeNavMesh|BPL")
		static FVector FindNearestNavPoint(const FVector& InStartPoint, const FVector& InEndPoint, float fNavigationOffset=100.0, FString InStrWorldName=TEXT(""));

	// Get the landscape Height of the special Location
	//@param InVecLoc				Location 
	//@param InStrWorldName			World Name
	//@return float					Height Value
	UFUNCTION(BlueprintCallable)
		static float GetLandscapeHeight(const FVector& InVecLoc, FString InStrWorldName = TEXT(""));
	// Get the landscape Max/Min Height of the special World(or First World)
	//@param OutfMinHeight			(Out) Minimum Height
	//@param OutfMaxHeight			(Out) Maximum Height
	//@return bool					True-Success;false-Fail.
	UFUNCTION(BlueprintCallable)
		static bool GetLandscapeMinMaxHeight(float& OutfMinHeight, float& OutfMaxHeight, FString InStrWorldName = TEXT(""), float fExtendScale=1.f);
private:

	static UWorld* GetFirstWorld();
	/** 查找导航路径 */
	static UNavigationPath* findNavigationPath(const FVector& InStartPoint, const FVector& InEndPoint, FString InStrWorldName=TEXT(""));
	
};

.cpp

// Fill out your copyright notice in the Description page of Project Settings.


#include "NavBlueprintFunctionLibrary.h"
#include "Engine/Engine.h"
#include "NavigationPath.h"
#include "NavigationSystem.h"
#include "NavigationData.h"
#include "NavFilters/NavigationQueryFilter.h"
#include "Landscape.h"
#include "EngineUtils.h"
#include "LandscapeInfo.h"
#include "LandscapeHeightfieldCollisionComponent.h"
#include "GeneratedCodeHelpers.h"



UWorld* UNavBlueprintFunctionLibrary::GetFirstWorld()
{
	//Get first valid world
	for (const FWorldContext& Context : GEngine->GetWorldContexts())
	{
#if WITH_EDITOR
		if (GIsEditor)
		{
			if (Context.WorldType == EWorldType::Editor)
			{
				return Context.World();
			}
		}
		else
		{
			if (Context.World() != nullptr)
			{
				return Context.World();
			}
		}
#else
		if (Context.World() != nullptr)
		{
			return Context.World();
		}
#endif
	}

	return nullptr;
}

UWorld* UNavBlueprintFunctionLibrary::GetWorldByName(FString InStrWorldName/*=TEXT("")*/)
{
	if (InStrWorldName.IsEmpty())
	{
		return GetFirstWorld();
	}

	for (const FWorldContext& Context : GEngine->GetWorldContexts())
	{
#if WITH_EDITOR
		if (GIsEditor)
		{
			if (Context.WorldType == EWorldType::Editor)
			{
				if (Context.World()->GetName() == InStrWorldName)
				{
					return Context.World();
				}
			}
		}
		else
		{
			if (Context.World() != nullptr)
			{
				if (Context.World()->GetName() == InStrWorldName)
				{
					return Context.World();
				}
			}
		}
#else
		if (Context.World() != nullptr)
		{
			if (Context.World()->GetName() == InStrWorldName)
			{
				return Context.World();
			}
		}
#endif
	}

	return nullptr;
}

FVector UNavBlueprintFunctionLibrary::FindNearestNavPoint(const FVector& InStartPoint, const FVector& InEndPoint, float fNavigationOffset/*=100.0*/, FString InStrWorldName/*=TEXT("")*/)
{
	UE_LOG(LogTemp, Warning, TEXT("Start:%s; End:%s; Length=%f"), *InStartPoint.ToString(), *InEndPoint.ToString(), (InStartPoint - InEndPoint).Size());

	if ((InStartPoint - InEndPoint).Size() <= fNavigationOffset)
	{
		return InEndPoint;
	}

	UWorld* pTheWorld = GetWorldByName(InStrWorldName);
	if (!pTheWorld)
	{
		return InEndPoint;
	}
	UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(pTheWorld);
	if (NavSys)
	{
		FNavLocation OutNavLocation;
		ANavigationData* UseNavData = NavSys->GetDefaultNavDataInstance(FNavigationSystem::DontCreate);
		if (UseNavData)
		{
			bool bResult = false;
			FVector QueryExtent = FVector::ZeroVector;
			bResult = NavSys->ProjectPointToNavigation(InEndPoint, OutNavLocation, QueryExtent, nullptr);
			//终点导航不可达
			if (!bResult)
			{
				return InEndPoint;
			}
		}
	}

	UNavigationPath* pNavPath = findNavigationPath(InStartPoint, InEndPoint);
	if (pNavPath)
	{
		if (pNavPath->GetPathLength() <= 0.1)
		{
			FVector HalfStartPoint = (InEndPoint + InStartPoint) / 2;
			FVector VecNavigationableP = FindNearestNavPoint(HalfStartPoint, InEndPoint, fNavigationOffset);
			if ((VecNavigationableP - HalfStartPoint).Size() <= fNavigationOffset)
			{
				return VecNavigationableP;
			}
			else
			{
				return FindNearestNavPoint(HalfStartPoint, VecNavigationableP, fNavigationOffset);
			}
		}

		return InStartPoint;
	}

	return InEndPoint;
}

UNavigationPath* UNavBlueprintFunctionLibrary::findNavigationPath(const FVector& InStartPoint, const FVector& InEndPoint, FString InStrWorldName)
{
	UNavigationPath* ResultPath = NULL;

	UWorld* pTheWorld = GetWorldByName(InStrWorldName);
	if (pTheWorld)
	{
		UNavigationSystemV1* NavSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(pTheWorld);
		if (NavSys)
		{
			ResultPath = NewObject<UNavigationPath>(NavSys);
			const ANavigationData* NavigationData = NULL;
			// just use default
			NavigationData = NavSys->GetDefaultNavDataInstance();
			check(NavigationData);
			TSubclassOf<UNavigationQueryFilter> FilterClass;
			const FPathFindingQuery Query(nullptr, *NavigationData, InStartPoint, InEndPoint, UNavigationQueryFilter::GetQueryFilter(*NavigationData, nullptr, FilterClass));
			const FPathFindingResult Result = NavSys->FindPathSync(Query, EPathFindingMode::Regular);
			if (Result.IsSuccessful() && ResultPath)
			{
				ResultPath->SetPath(Result.Path);
			}
		}
	}
	return ResultPath;
}


float UNavBlueprintFunctionLibrary::GetLandscapeHeight(const FVector& InVecLoc, FString InStrWorldName)
{
	UWorld* pTheWorld = GetWorldByName(InStrWorldName);
	if (pTheWorld)
	{
		// 获取Landscape的Actor
		ALandscape* Landscape = nullptr;
		const EActorIteratorFlags Flags = EActorIteratorFlags::SkipPendingKill;
		for (TActorIterator<ALandscape> ItLs(pTheWorld, ALandscape::StaticClass(), Flags); ItLs; ++ItLs)
		{
			Landscape = *ItLs;

			if (Landscape)
			{
				TOptional<float> fOpHeight = Landscape->GetHeightAtLocation(InVecLoc);
				if (fOpHeight.IsSet())
				{
					return fOpHeight.GetValue();
				}
			}
		}
	}

	return 0.0f;
}

bool UNavBlueprintFunctionLibrary::GetLandscapeMinMaxHeight(float& OutfMinHeight, float& OutfMaxHeight, FString InStrWorldName, float fExtendScale)
{
	UWorld* pTheWorld = GetWorldByName(InStrWorldName);
	if (pTheWorld)
	{
		float MinHeight = TNumericLimits<float>::Max();
		float MaxHeight = TNumericLimits<float>::Min();
		// 获取Landscape的Actor
		ALandscape* Landscape = nullptr;
		const EActorIteratorFlags Flags = EActorIteratorFlags::SkipPendingKill;
		for (TActorIterator<ALandscape> ItLs(pTheWorld, ALandscape::StaticClass(), Flags); ItLs; ++ItLs)
		{
			Landscape = *ItLs;

			if (Landscape)
			{				
				#if WITH_CHAOS
				int32 nSizeX = 0;
				int32 nSizeY = 0;
				TArray<float> ArrayValues;
				Landscape->GetHeightValues(nSizeX, nSizeY, ArrayValues);
				for (float ItHeight : ArrayValues)
				{
					if (ItHeight < MinHeight)
					{
						MinHeight = ItHeight;
					}
					if (ItHeight > MaxHeight)
					{
						MaxHeight = ItHeight;
					}
				}
				#else
				
				FVector VecBase = Landscape->GetActorLocation();
				FVector VecScale3D = Landscape->GetActorScale3D();
				FVector Origin; FVector BoxExtent;
				Landscape->GetActorBounds(false, Origin, BoxExtent);
				FVector VecResolution = (BoxExtent - Origin) * 2;
				float fInterval = (float)Landscape->ComponentSizeQuads;
				for (int nItSampleX = 0; nItSampleX < Landscape->ComponentSizeQuads; ++nItSampleX)
				{
					for (int nItSampleY = 0; nItSampleY < Landscape->ComponentSizeQuads; ++nItSampleY)
					{
						FVector VecAdder = VecResolution * FVector(nItSampleX / fInterval, nItSampleY/ fInterval, 0.f) * fExtendScale;
						TOptional<float> Height = Landscape->GetHeightAtLocation(VecBase + VecAdder);
						if (Height.IsSet())
						{
							if (Height.GetValue() < MinHeight)
							{
								MinHeight = Height.GetValue();
							}
							if (Height.GetValue() > MaxHeight)
							{
								MaxHeight = Height.GetValue();
							}
						}
					}
				}
				#endif				
			}
		}

		OutfMinHeight = MinHeight;
		OutfMaxHeight = MaxHeight;

		return true;
	}

	return false;
}

DuGuYiZhao
关注
专栏目录
UE4 访问网格的顶点数据
07-30
在UE4（Unreal Engine 4）中，访问网格的顶点数据是图形编程和游戏开发中的重要操作，尤其在自定义着色器或者进行几何处理时。这涉及到引擎内部的渲染管线和数据结构，因此深入理解这个过程对优化游戏性能和实现复杂...
UE4 动态创建寻路网格
DuGuYiZhao的博客
09-01 2246
UE Runtime动态创建导航网格并绘制分析
[UE4笔记] 导航网格的一些认识.
weixin_44052668的博客
07-11 1万+
关于Nav Mesh、RecastNavmesh、Nav Modife Mesh相关设置 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功...
[UE4]引擎自带的自动寻路组件：NavMeshBoundsVolume
玄冬Wong
12-22 9457
如果要使用 UE4自带的自动寻路功能，除了需要调用寻路相关的API以外，还要设置寻路组件：NavMeshBoundsVolume，否则调用寻路API时无效。 更详细的说明见官方文档：https://docs.unrealengine.com/latest/INT/Resources/ContentExamples/NavMesh/index.html   1，首先向场景中拖入NavMes...
UE4-（蓝图）第三十一课设置自动寻路并使用寻路AI
Stone的博客
08-22 9700
一、设置寻路范围 1.将 体积/Nav Mesh Bounds Volume 拖拽到场景中 2.选中拖入的NavMeshBoundsVolume，调整大小，将想要自动寻路的范围全部包裹。（尽量比场景轮廓大一点） 3.选中NavMeshBoundsVolume，按P查看寻路情况，再次按P消失。 二、编辑寻路AI 1.创建机器人蓝图类，基于Character类创建，命名为Ro...
ue4中寻路设置navmesh
热门推荐
.
12-12 2万+
修改Level 中寻路区域 修改Level 中寻路区域,增加跳跃线 有些区域不能连接起来，比如楼上到楼下，可以增加寻路连接点     输入navlink，拖动到场景中，拖动两个连接点   实时重建寻路范围   新建寻路边缘radius height   在视图中显示   游戏运行中显示和隐藏寻路范围 现实寻路范围，输入命令，按 `
（蓝图）虚幻4制作超级马里奥（八）两种方法实现AI移动
Tfeng
07-14 1751
目录 NavMeshBoundsVolume AIMoveTo控制AI 1.创建Character类型蓝图 2.记录AI的初始位置，提升为变量 3.AutoWalk自定义事件 4.停止移动 完成 行为树控制AI 1.新建Character类型蓝图命名为AI_Character 2.黑板命名为MyBlackboard 3.新建行为树命名为MyBT 4.新建AIContro...
UE5.3.2自动寻路简单案例
05-23
### UE5.3.2自动寻路简单案例 #### 一、引言 随着游戏开发技术的不断进步，虚幻引擎（Unreal Engine，简称UE）已成为业界领先的游戏引擎之一，尤其是在虚拟现实（VR）、增强现实（AR）等领域内表现突出。本案例由...
ue4动态加载资源路径信息
11-22
在UE4（Unreal Engine 4）中，动态加载资源是一项关键功能，它允许游戏或应用在运行时根据需要加载和卸载资产，从而优化内存使用和性能。UE4使用了一种模块化的设计，使得资源管理变得更加灵活。下面将详细探讨如何...
UE4动画烘焙器-ue4.27
05-23
二、UE4动画系统 UE4的动画系统基于AnimGraph，这是一个可视化的动画工作流程，允许开发者创建、编辑和组合各种动画状态和过渡。AnimGraph支持多种动画技术，如混合树、状态机、蒙皮权重计算等，为角色提供丰富多样...
UE4蓝图节点详细介绍
03-27
在虚幻引擎4（UE4）中，蓝图是一种可视化编程系统，它允许开发者，特别是初级开发者，无需编写C++代码就能构建游戏逻辑和交互。蓝图系统由一系列节点组成，这些节点构成了逻辑流程图，用于控制游戏对象的行为。本篇...
UE4 C++入门之路6-PostEditChangeProperty以及和PostInitProperties的区别
TurboQ珞珈
11-06 6038
UE4 C++入门之路6-PostEditChangepROPITY
UE4 NavMesh学习笔记
Haipai1998的博客
02-28 2896
学习资料： https://zhuanlan.zhihu.com/p/74537236 https://blog.csdn.net/u013272009/article/details/80086833 RecastNavigation有哪些内容 主要包含两大类：RecastNavigation = Recast（生成凸多边形，即网格）+ Detour（基于凸多边形集合的A*寻路算法） ...
UE4学习-AI导航网格的创建及修改
u013824564的博客
07-10 5606
文章目录
【测试人生】UE4大世界游戏寻路效果自动化测试
HiKariのTechLab
11-20 1868
在一些大世界的游戏当中，我们通常能够体验到游戏的自动寻路功能，在测试寻路功能时，不仅需要检查寻路是否成功到达，而且也需要关注寻路路径呈现的效果，从而确定玩家是否走在策划预想的路径上。但是，由于寻路起点重点选择随机性较高，遍历数量大，在验收寻路效果时，手工测试效率会非常低下。因此，笔者结合自己实际工作经验，分享一种在UE4大世界游戏中，寻路效果自动化测试的方案。
UE4 中 AI相互阻挡的解决方案 Navmesh+RVO
hj_jie的博客
01-06 3512
现象 在UE4 中当AI角色较多，AI之间自动寻路时，通道相对狭窄，AI之间会存在相互阻挡的情况： 解决方法: AI角色蓝图 => Character Movement => 勾选 Use RVO Advance
UE 项目导航数据生成配置
你好，旅行者
02-24 1266
如果有必要把不影响导航的组件及Actor中Collision的CanEverAffectNavigation取消勾选，可以影响Nav Tree Memory占用。该值在开启修改导航模式的情况下开启,把模型数据导出放到异步线程里去做，目前不知道对构建导航Task造不造成影响。为了优化内存占用，该值微调可以降低整个内存占用，但是过大会造成孤立的导航数据区域丢弃，所以不宜过大。相对应的是该值越低最终生成的导航数据与物体碰撞误差越小，越大误差越大。该值可以影响AI的导航攀爬，数值调整的越大，内存占用会约低。
【UE5.1】NPC人工智能——03 NPC跨障碍移动
ChaoChao66666的博客
07-19 715
​ 在上一篇中（【UE5.1】NPC人工智能——02 NPC移动到指定位置）我们已经实现了NPC向指定位置或Actor移动的功能，但是如果NPC移动路线上有障碍则无法绕过障碍移动，为了解决这个问题，本篇文章介绍使用导航数据让NPC跨障碍移动。 ​
UE4 VR 项目（二）
最新发布
龙哥盟
07-25 1495
原文：zh.annas-archive.org/md5/3F4ADC3F92B633551D2F5B3D47CE968D 译者：飞龙 协议：CC BY-NC-SA 4.0 第四章：在虚拟世界中移动 在本章中，我们将使用前一章中构建的角色，使其在世界中移动。我们将从常用的传送移动方案开始，涵盖一系列设置任务。我们将了解环境中的导航网格，如何在项目中设置输入事件并在蓝图中使用它们，以及如何构建一个玩家角色蓝图并使其在世界中移动。最后，我们还将探讨一种沉浸式的无缝定位方案，您可以使用它让玩家在世界中移动而无需
ue4怎么创建骨骼网格体
11-30
根据提供的引用内容，以下是在UE4中创建骨骼网格体的步骤： 1. 在内容浏览器中搜索'SkeletalMesh'，找到需要的骨骼网格体。 2. 在Matinee中创建一个新的序列，将骨骼网格体拖放到编辑器视口中。 3. 确保骨骼网格体被选中并高亮显示，然后右键单击“轨迹视图”选项卡下方的空闲区域。 4. 在弹出的菜单中选择“新建骨骼网格组”。 5. 在弹出的对话框中输入骨骼网格组的名称，然后单击“确定”按钮。 6. 现在，您已经成功创建了一个新的骨骼网格组，并将骨骼网格体连接到该组中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值