NavigationData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#endif
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "Async/TaskGraphInterfaces.h"
#include "GameFramework/Actor.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "NavFilters/NavigationQueryFilter.h"
#endif
#include "AI/Navigation/NavigationTypes.h"
#include "NavigationSystemTypes.h"
#include "EngineDefines.h"
#include "AI/Navigation/NavigationDataInterface.h"
 
#include "NavigationData.generated.h"
 
class ANavigationData;
class Error;
class FNavDataGenerator;
class INavAgentInterface;
class INavLinkCustomInterface;
class UNavArea;
class UPrimitiveComponent;
class UNavigationQueryFilter;
struct FNavigationDirtyArea;
 
USTRUCT()
struct FSupportedAreaData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FString AreaClassName;
 
    UPROPERTY()
    int32 AreaID;
 
    UPROPERTY(transient)
    TObjectPtr<const UClass> AreaClass;
 
    NAVIGATIONSYSTEM_API FSupportedAreaData(TSubclassOf<UNavArea> NavAreaClass = {}, int32 InAreaID = INDEX_NONE);
};
 
struct FNavPathRecalculationRequest
{
    FNavPathWeakPtr Path;
    ENavPathUpdateType::Type Reason;
 
    FNavPathRecalculationRequest(const FNavPathSharedPtr& InPath, ENavPathUpdateType::Type InReason)
        : Path(InPath.ToSharedRef()), Reason(InReason)
    {}
 
    bool operator==(const FNavPathRecalculationRequest& Other) const { return Path == Other.Path;  }
};
 
struct FPathFindingResult
{
    FNavPathSharedPtr Path;
    ENavigationQueryResult::Type Result;
 
    FPathFindingResult(ENavigationQueryResult::Type InResult = ENavigationQueryResult::Invalid) : Result(InResult)
    { }
 
    inline bool IsSuccessful() const
    {
        return Result == ENavigationQueryResult::Success;
    }
    inline bool IsPartial() const;
};
 
struct FNavigationRaycastAdditionalResults
{
    bool bIsRayEndInCorridor = false;
};
 
struct FNavigationPath : public TSharedFromThis<FNavigationPath, ESPMode::ThreadSafe>
{
    //DECLARE_DELEGATE_OneParam(FPathObserverDelegate, FNavigationPath*);
    DECLARE_MULTICAST_DELEGATE_TwoParams(FPathObserverDelegate, FNavigationPath*, ENavPathEvent::Type);
 
    NAVIGATIONSYSTEM_API FNavigationPath();
    NAVIGATIONSYSTEM_API FNavigationPath(const TArray<FVector>& Points, AActor* Base = NULL);
    NAVIGATIONSYSTEM_API virtual ~FNavigationPath();
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FNavigationPath(const FNavigationPath&) = default;
    FNavigationPath& operator=(const FNavigationPath& Other) = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    inline bool IsValid() const
    {
        return bIsReady && PathPoints.Num() > 1 && bUpToDate;
    }
    inline bool IsUpToDate() const
    {
        return bUpToDate;
    }
    inline bool IsReady() const
    {
        return bIsReady;
    }
    inline bool IsPartial() const
    {
        return bIsPartial;
    }
    inline bool DidSearchReachedLimit() const
    {
        return bReachedSearchLimit;
    }
 
    // True when the path request failed because the start location couldn't be projected on the NavData.
    // False doesn't guarantee that the location is navigable, it's also possible a previous error skipped the projection altogether
    bool IsErrorStartLocationNonNavigable() const
    {
        return bErrorStartLocationNonNavigable;
    }
 
    // True when the path request failed because the end location couldn't be projected on the NavData.
    // False doesn't guarantee that the location is navigable, it's also possible a previous error skipped the projection altogether
    bool IsErrorEndLocationNonNavigable() const
    {
        return bErrorEndLocationNonNavigable;
    }
    inline bool IsWaitingForRepath() const
    {
        return bWaitingForRepath;
    }
    inline void SetManualRepathWaiting(const bool bInWaitingForRepath)
    {
        bWaitingForRepath = bInWaitingForRepath;
    }
    inline bool ShouldUpdateStartPointOnRepath() const
    {
        return bUpdateStartPointOnRepath;
    }
    inline bool ShouldUpdateEndPointOnRepath() const
    {
        return bUpdateEndPointOnRepath;
    }
    inline FVector GetDestinationLocation() const
    {
        return IsValid() ? PathPoints.Last().Location : INVALID_NAVEXTENT;
    }
    inline FPathObserverDelegate& GetObserver()
    {
        return ObserverDelegate;
    }
    inline FDelegateHandle AddObserver(FPathObserverDelegate::FDelegate NewObserver)
    {
        return ObserverDelegate.Add(NewObserver);
    }
    inline void RemoveObserver(FDelegateHandle HandleOfObserverToRemove)
    {
        ObserverDelegate.Remove(HandleOfObserverToRemove);
    }
 
    inline void MarkReady()
    {
        bIsReady = true;
    }
 
    inline void SetNavigationDataUsed(const ANavigationData* const NewData);
 
    inline ANavigationData* GetNavigationDataUsed() const
    {
        return NavigationDataUsed.Get();
    }
    inline void SetQuerier(const UObject* InQuerier)
    {
        PathFindingQueryData.Owner = InQuerier;
    }
    inline const UObject* GetQuerier() const
    {
        return PathFindingQueryData.Owner.Get();
    }
    inline void SetQueryData(const FPathFindingQueryData& QueryData)
    {
        PathFindingQueryData = QueryData;
    }
    inline FPathFindingQueryData GetQueryData() const
    {
        // return copy of query data
        return PathFindingQueryData;
    }
 
    //FORCEINLINE void SetObserver(const FPathObserverDelegate& Observer) { ObserverDelegate = Observer; }
    inline void SetIsPartial(const bool bPartial)
    {
        bIsPartial = bPartial;
    }
    inline void SetSearchReachedLimit(const bool bLimited)
    {
        bReachedSearchLimit = bLimited;
    }
    void SetErrorStartLocationNonNavigable(const bool bErrorNonNavigable)
    {
        bErrorStartLocationNonNavigable = bErrorNonNavigable;
    }
    void SetErrorEndLocationNonNavigable(const bool bErrorNonNavigable)
    {
        bErrorEndLocationNonNavigable = bErrorNonNavigable;
    }
    inline void SetFilter(FSharedConstNavQueryFilter InFilter)
    {
        PathFindingQueryData.QueryFilter = InFilter;
        Filter = InFilter;
    }
    inline FSharedConstNavQueryFilter GetFilter() const
    {
        return PathFindingQueryData.QueryFilter;
    }
    inline AActor* GetBaseActor() const
    {
        return Base.Get();
    }
 
    FVector GetStartLocation() const
    {
        return PathPoints.Num() > 0 ? PathPoints[0].Location : FNavigationSystem::InvalidLocation;
    }
    FVector GetEndLocation() const
    {
        return PathPoints.Num() > 0 ? PathPoints.Last().Location : FNavigationSystem::InvalidLocation;
    }
 
    inline void DoneUpdating(ENavPathUpdateType::Type UpdateType)
    {
        static const ENavPathEvent::Type PathUpdateTypeToPathEvent[] = {
            ENavPathEvent::UpdatedDueToGoalMoved // GoalMoved,
            , ENavPathEvent::UpdatedDueToNavigationChanged // NavigationChanged,
            , ENavPathEvent::MetaPathUpdate // MetaPathUpdate,
            , ENavPathEvent::Custom // Custom,
        };
 
        bUpToDate = true;
        bWaitingForRepath = false;
 
        if (bUseOnPathUpdatedNotify)
        {
            // notify path before observers
            OnPathUpdated(UpdateType);
        }
        
        ObserverDelegate.Broadcast(this, PathUpdateTypeToPathEvent[uint8(UpdateType)]);
    }
 
    inline double GetTimeStamp() const { return LastUpdateTimeStamp; }
    inline void SetTimeStamp(double TimeStamp) { LastUpdateTimeStamp = TimeStamp; }
 
    NAVIGATIONSYSTEM_API void Invalidate();
    NAVIGATIONSYSTEM_API void RePathFailed();
 
    NAVIGATIONSYSTEM_API virtual void ResetForRepath();
 
    NAVIGATIONSYSTEM_API void RemoveOverlappingPoints(const FVector& Tolerance);
 
    NAVIGATIONSYSTEM_API virtual void DebugDraw(const ANavigationData* NavData, const FColor PathColor, class UCanvas* Canvas, const bool bPersistent, const float LifeTime, const uint32 NextPathPointIndex = 0) const;
    
#if ENABLE_VISUAL_LOG
    NAVIGATIONSYSTEM_API virtual void DescribeSelfToVisLog(struct FVisualLogEntry* Snapshot) const;
    NAVIGATIONSYSTEM_API virtual FString GetDescription() const;
#endif // ENABLE_VISUAL_LOG
 
    UE_DEPRECATED(5.3, "Use version that takes FNavLinkId instead. This function only returns false.")
    virtual bool ContainsCustomLink(uint32 UniqueLinkId) const final {  return false; }
 
    NAVIGATIONSYSTEM_API virtual bool ContainsCustomLink(FNavLinkId UniqueLinkId) const;
 
    NAVIGATIONSYSTEM_API virtual bool ContainsAnyCustomLink() const;
 
    NAVIGATIONSYSTEM_API virtual bool ContainsNode(NavNodeRef NodeRef) const;
 
    virtual FVector::FReal GetCostFromIndex(int32 PathPointIndex) const
    {
        return 0.;
    }
 
    virtual FVector::FReal GetCostFromNode(NavNodeRef PathNode) const
    {
        return 0.;
    }
 
    inline FVector::FReal GetCost() const
    {
        return GetCostFromIndex(0);
    }
 
    NAVIGATIONSYSTEM_API virtual FVector::FReal GetLengthFromPosition(FVector SegmentStart, uint32 NextPathPointIndex) const;
 
    inline FVector::FReal GetLength() const
    {
        return PathPoints.Num() ? GetLengthFromPosition(PathPoints[0].Location, 1) : 0.0f;
    }
 
    static bool GetPathPoint(const FNavigationPath* Path, uint32 PathVertIdx, FNavPathPoint& PathPoint)
    {
        if (Path && Path->GetPathPoints().IsValidIndex((int32)PathVertIdx))
        {
            PathPoint = Path->PathPoints[PathVertIdx];
            return true;
        }
 
        return false;
    }
 
    inline const TArray<FNavPathPoint>& GetPathPoints() const
    {
        return PathPoints;
    }
    inline TArray<FNavPathPoint>& GetPathPoints()
    {
        return PathPoints;
    }
 
    NAVIGATIONSYSTEM_API FBasedPosition GetPathPointLocation(uint32 Index) const;
 
    NAVIGATIONSYSTEM_API virtual bool DoesIntersectBox(const FBox& Box, uint32 StartingIndex = 0, int32* IntersectingSegmentIndex = NULL, FVector* AgentExtent = NULL) const;
    NAVIGATIONSYSTEM_API virtual bool DoesIntersectBox(const FBox& Box, const FVector& AgentLocation, uint32 StartingIndex = 0, int32* IntersectingSegmentIndex = NULL, FVector* AgentExtent = NULL) const;
    NAVIGATIONSYSTEM_API virtual FVector GetSegmentDirection(uint32 SegmentEndIndex) const;
 
private:
    NAVIGATIONSYSTEM_API bool DoesPathIntersectBoxImplementation(const FBox& Box, const FVector& StartLocation, uint32 StartingIndex, int32* IntersectingSegmentIndex, FVector* AgentExtent) const;
 
    NAVIGATIONSYSTEM_API void InternalResetNavigationPath();
 
public:
 
    template<typename PathClass>
    inline const PathClass* CastPath() const
    {
        return PathType.IsA(PathClass::Type) ? static_cast<const PathClass*>(this) : NULL;
    }
 
    template<typename PathClass>
    inline PathClass* CastPath()
    {
        return PathType.IsA(PathClass::Type) ? static_cast<PathClass*>(this) : NULL;
    }
 
    NAVIGATIONSYSTEM_API void SetGoalActorObservation(const AActor& ActorToObserve, float TetherDistance);
    void SetGoalActorTetherDistance(const float NewTetherDistace) { GoalActorLocationTetherDistanceSq = FMath::Square(NewTetherDistace); }
    NAVIGATIONSYSTEM_API void DisableGoalActorObservation();
    NAVIGATIONSYSTEM_API void SetSourceActor(const AActor& InSourceActor);
 
    const AActor* GetSourceActor() const { return SourceActor.Get(); }
    const INavAgentInterface* GetSourceActorAsNavAgent() const { return SourceActorAsNavAgent; }
 
    FVector GetLastRepathGoalLocation() const { return GoalActorLastLocation; }
    NAVIGATIONSYSTEM_API void UpdateLastRepathGoalLocation();
    
    double GetLastUpdateTime() const { return LastUpdateTimeStamp; }
    float GetGoalActorTetherDistance() const { return FMath::Sqrt(GoalActorLocationTetherDistanceSq); }
 
    void EnableRecalculationOnInvalidation(bool bShouldAutoUpdate)
    {
        bDoAutoUpdateOnInvalidation = bShouldAutoUpdate;
    }
    bool WillRecalculateOnInvalidation() const
    {
        return bDoAutoUpdateOnInvalidation;
    }
 
    void SetIgnoreInvalidation(bool bShouldIgnore) { bIgnoreInvalidation = bShouldIgnore; }
    bool GetIgnoreInvalidation() const { return bIgnoreInvalidation; }
 
    NAVIGATIONSYSTEM_API EPathObservationResult::Type TickPathObservation();
 
    NAVIGATIONSYSTEM_API FVector GetGoalLocation() const;
 
    NAVIGATIONSYSTEM_API FVector GetPathFindingStartLocation() const;
 
    const AActor* GetGoalActor() const
    {
        return bObservingGoalActor ? GoalActor.Get() : nullptr;
    }
    const INavAgentInterface* GetGoalActorAsNavAgent() const
    {
        return GoalActor.IsValid() ? GoalActorAsNavAgent : NULL;
    }
 
    // @todo this is navigation-type specific and should not be implemented here.
    TArray<NavNodeRef> ShortcutNodeRefs;
 
protected:
    
    virtual void OnPathUpdated(ENavPathUpdateType::Type UpdateType) {};
    
    TArray<FNavPathPoint> PathPoints;
 
    TWeakObjectPtr<AActor> Base;
 
private:
    TWeakObjectPtr<const AActor> GoalActor;
 
    const INavAgentInterface* GoalActorAsNavAgent;
 
    TWeakObjectPtr<const AActor> SourceActor;
 
    const INavAgentInterface* SourceActorAsNavAgent;
 
protected:
    // DEPRECATED: filter used to build this path
    FSharedConstNavQueryFilter Filter;
 
    static NAVIGATIONSYSTEM_API const FNavPathType Type;
 
    FNavPathType PathType;
 
    FPathObserverDelegate ObserverDelegate;
 
    uint32 bUpToDate : 1;
 
    uint32 bIsReady : 1;
 
    uint32 bIsPartial : 1;
 
    uint32 bReachedSearchLimit : 1;
 
    uint32 bErrorStartLocationNonNavigable : 1 = false;
 
    uint32 bErrorEndLocationNonNavigable : 1 = false;
 
    uint32 bDoAutoUpdateOnInvalidation : 1;
 
    uint32 bIgnoreInvalidation : 1;
 
    uint32 bUpdateStartPointOnRepath : 1;
 
    uint32 bUpdateEndPointOnRepath : 1;
 
    uint32 bWaitingForRepath : 1;
 
    uint32 bUseOnPathUpdatedNotify : 1;
 
    uint32 bObservingGoalActor : 1;
 
    TWeakObjectPtr<ANavigationData> NavigationDataUsed;
 
    FPathFindingQueryData PathFindingQueryData;
 
    double LastUpdateTimeStamp;
 
private:
    /* if GoalActor is set this is the distance we'll try to keep GoalActor from end of path. If GoalActor
    * moves more then this from the end of the path we'll recalculate the path */
    float GoalActorLocationTetherDistanceSq;
 
    FVector GoalActorLastLocation;
};
 
UENUM()
enum class ERuntimeGenerationType : uint8
{
    // No runtime generation, fully static navigation data
    Static,             
    // Supports only navigation modifiers updates
    DynamicModifiersOnly,   
    // Fully dynamic, supports geometry changes along with navigation modifiers
    Dynamic,
    // Only for legacy loading don't use it!
    LegacyGeneration UMETA(Hidden)
};
 
UCLASS(config=Engine, defaultconfig, NotBlueprintable, abstract, MinimalAPI)
class ANavigationData : public AActor, public INavigationDataInterface
{
    GENERATED_UCLASS_BODY()
    
    UPROPERTY(transient, duplicatetransient)
    TObjectPtr<UPrimitiveComponent> RenderingComp;
 
protected:
    UPROPERTY()
    FNavDataConfig NavDataConfig;
 
    UPROPERTY(Transient, EditAnywhere, Category=Display)
    uint32 bEnableDrawing:1;
 
    //----------------------------------------------------------------------//
    // game-time config
    //----------------------------------------------------------------------//
    
    UPROPERTY(config, EditAnywhere, Category = Runtime)
    uint32 bForceRebuildOnLoad : 1;
 
    UPROPERTY(config, EditAnywhere, Category = Runtime)
    uint32 bAutoDestroyWhenNoNavigation : 1;
 
    UPROPERTY(config, EditAnywhere, Category = Runtime, AdvancedDisplay)
    uint32 bCanBeMainNavData : 1;
 
    UPROPERTY(config, VisibleAnywhere, Category = Runtime, AdvancedDisplay)
    uint32 bCanSpawnOnRebuild : 1;
 
    UPROPERTY(config)
    uint32 bRebuildAtRuntime_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, Category = Runtime, config)
    ERuntimeGenerationType RuntimeGeneration;
 
    UPROPERTY(EditAnywhere, Category = Runtime, config)
    float ObservedPathsTickInterval;
 
public:
    //----------------------------------------------------------------------//
    // Life cycle                                                                
    //----------------------------------------------------------------------//
 
    //~ Begin UObject/AActor Interface
    NAVIGATIONSYSTEM_API virtual void PostInitProperties() override;
    NAVIGATIONSYSTEM_API virtual void PostInitializeComponents() override;
    NAVIGATIONSYSTEM_API virtual void PostLoad() override;
#if WITH_EDITOR
    NAVIGATIONSYSTEM_API virtual void RerunConstructionScripts() override;
    NAVIGATIONSYSTEM_API virtual void PostEditUndo() override;
    bool IsBuildingOnLoad() const { return bIsBuildingOnLoad; }
    void SetIsBuildingOnLoad(bool bValue) { bIsBuildingOnLoad = bValue; }
#endif // WITH_EDITOR
    NAVIGATIONSYSTEM_API virtual void Destroyed() override;
    NAVIGATIONSYSTEM_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    //~ End UObject Interface
        
    NAVIGATIONSYSTEM_API virtual void CleanUp();
    NAVIGATIONSYSTEM_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
 
protected:
    NAVIGATIONSYSTEM_API void RequestRegistration();
 
private:
    NAVIGATIONSYSTEM_API void UnregisterAndCleanUp();
 
public:
    NAVIGATIONSYSTEM_API virtual void CleanUpAndMarkPendingKill();
 
    inline bool IsRegistered() const { return bRegistered; }
    NAVIGATIONSYSTEM_API virtual void OnRegistered();
    NAVIGATIONSYSTEM_API void OnUnregistered();
    
    inline uint16 GetNavDataUniqueID() const { return NavDataUniqueID; }
 
    NAVIGATIONSYSTEM_API virtual void TickActor(float DeltaTime, enum ELevelTick TickType, FActorTickFunction& ThisTickFunction) override;
 
    virtual bool NeedsRebuild() const { return false; }
    NAVIGATIONSYSTEM_API virtual bool SupportsRuntimeGeneration() const;
    NAVIGATIONSYSTEM_API virtual bool SupportsStreaming() const;
    NAVIGATIONSYSTEM_API virtual void OnNavigationBoundsChanged();
 
    virtual void FillNavigationDataChunkActor(const FBox& QueryBounds, class ANavigationDataChunkActor& DataChunkActor, FBox& OutTilesBounds) const {};
    virtual void OnStreamingNavDataAdded(class ANavigationDataChunkActor& InActor) {};
    virtual void OnStreamingNavDataRemoved(class ANavigationDataChunkActor& InActor) {};
    
    virtual void OnStreamingLevelAdded(ULevel* InLevel, UWorld* InWorld) {};
    virtual void OnStreamingLevelRemoved(ULevel* InLevel, UWorld* InWorld) {};
 
#if WITH_EDITOR 
    virtual double GetWorldPartitionNavigationDataBuilderOverlap() const { return 0; }
#endif
 
    //----------------------------------------------------------------------//
    // Generation & data access                                                      
    //----------------------------------------------------------------------//
public:
    inline const FNavDataConfig& GetConfig() const { return NavDataConfig; }
    inline ERuntimeGenerationType GetRuntimeGenerationMode() const { return RuntimeGeneration; }
    NAVIGATIONSYSTEM_API virtual void SetConfig(const FNavDataConfig& Src);
 
    void SetSupportsDefaultAgent(bool bIsDefault) { bSupportsDefaultAgent = bIsDefault; SetNavRenderingEnabled(bIsDefault); }
    bool IsSupportingDefaultAgent() const { return bSupportsDefaultAgent; }
    const FNavAgentProperties& GetNavAgentProperties() const
    {
        return NavAgentProperties;
    }
 
    NAVIGATIONSYSTEM_API virtual bool DoesSupportAgent(const FNavAgentProperties& AgentProps) const;
 
    virtual void RestrictBuildingToActiveTiles(bool InRestrictBuildingToActiveTiles) {}
 
    bool CanBeMainNavData() const { return bCanBeMainNavData; }
    bool CanSpawnOnRebuild() const { return bCanSpawnOnRebuild; }
    bool NeedsRebuildOnLoad() const { return bForceRebuildOnLoad; }
 
protected:
    virtual void FillConfig(FNavDataConfig& Dest) { Dest = NavDataConfig; }
 
public:
    NAVIGATIONSYSTEM_API virtual void ConditionalConstructGenerator();
 
    virtual void LoadBeforeGeneratorRebuild() {}
 
    virtual void PostLoadPreRebuild() {}
    
    NAVIGATIONSYSTEM_API virtual void RebuildAll();
 
    NAVIGATIONSYSTEM_API virtual void EnsureBuildCompletion();
 
    NAVIGATIONSYSTEM_API virtual void CancelBuild();
 
    NAVIGATIONSYSTEM_API virtual void TickAsyncBuild(float DeltaSeconds);
    
    FNavDataGenerator* GetGenerator() { return NavDataGenerator.Get(); }
    const FNavDataGenerator* GetGenerator() const { return NavDataGenerator.Get(); }
 
    NAVIGATIONSYSTEM_API virtual void RebuildDirtyAreas(const TArray<FNavigationDirtyArea>& DirtyAreas);
 
    NAVIGATIONSYSTEM_API virtual void SetRebuildingSuspended(const bool bNewSuspend);
 
    virtual bool IsRebuildingSuspended() const { return bRebuildingSuspended; }
 
    virtual int32 GetNumSuspendedDirtyAreas() const { return SuspendedDirtyAreas.Num(); }
    
protected:
    NAVIGATIONSYSTEM_API void RegisterAsNavAreaClassObserver();
 
public:
    template<typename PathType>
    FNavPathSharedPtr CreatePathInstance(const FPathFindingQueryData& QueryData) const
    {
        FNavPathSharedPtr SharedPath = MakeShareable(new PathType());
        SharedPath->SetNavigationDataUsed(this);
        SharedPath->SetQueryData(QueryData);
        SharedPath->SetTimeStamp( GetWorldTimeStamp() );
 
        const_cast<ANavigationData*>(this)->RegisterActivePath(SharedPath);
        return SharedPath;
    }
    
    void RegisterObservedPath(FNavPathSharedPtr SharedPath)
    {
        check(IsInGameThread());
        if (ObservedPaths.Num() == 0)
        {
            NextObservedPathsTickInSeconds = ObservedPathsTickInterval;
        }
        ObservedPaths.Add(SharedPath);
    }
 
    void RequestRePath(FNavPathSharedPtr Path, ENavPathUpdateType::Type Reason)
    {
        check(IsInGameThread());
        RepathRequests.AddUnique(FNavPathRecalculationRequest(Path, Reason)); 
    }
 
protected:
    NAVIGATIONSYSTEM_API void PurgeUnusedPaths();
 
    NAVIGATIONSYSTEM_API void RegisterActivePath(FNavPathSharedPtr SharedPath);
 
public:
    virtual FBox GetBounds() const PURE_VIRTUAL(ANavigationData::GetBounds,return FBox(););
    
    NAVIGATIONSYSTEM_API TArray<FBox> GetNavigableBounds() const;
    
    NAVIGATIONSYSTEM_API TArray<FBox> GetNavigableBoundsInLevel(ULevel* InLevel) const;
    
    //----------------------------------------------------------------------//
    // Debug                                                                
    //----------------------------------------------------------------------//
    NAVIGATIONSYSTEM_API void DrawDebugPath(FNavigationPath* Path, const FColor PathColor = FColor::White, class UCanvas* Canvas = nullptr, const bool bPersistent = true, const float LifeTime = -1.f, const uint32 NextPathPointIndex = 0) const;
 
    inline bool IsDrawingEnabled() const { return bEnableDrawing; }
 
    NAVIGATIONSYSTEM_API virtual uint32 LogMemUsed() const;
 
    //----------------------------------------------------------------------//
    // Batch processing (important with async rebuilding)
    //----------------------------------------------------------------------//
 
    virtual void BeginBatchQuery() const {}
 
    virtual void FinishBatchQuery() const {};
 
    //----------------------------------------------------------------------//
    // Querying                                                                
    //----------------------------------------------------------------------//
    inline FSharedConstNavQueryFilter GetDefaultQueryFilter() const { return DefaultQueryFilter; }
    inline const class INavigationQueryFilterInterface* GetDefaultQueryFilterImpl() const { return DefaultQueryFilter->GetImplementation(); }   
    inline FVector GetDefaultQueryExtent() const { return NavDataConfig.DefaultQueryExtent; }
 
    inline FPathFindingResult FindPath(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query) const
    {
        check(FindPathImplementation);
        // this awkward implementation avoids virtual call overhead - it's possible this function will be called a lot
        return (*FindPathImplementation)(AgentProperties, Query);
    }
 
    inline FPathFindingResult FindHierarchicalPath(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query) const
    {
        check(FindHierarchicalPathImplementation);
        // this awkward implementation avoids virtual call overhead - it's possible this function will be called a lot
        return (*FindHierarchicalPathImplementation)(AgentProperties, Query);
    }
 
    inline bool TestPath(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query, int32* NumVisitedNodes) const
    {
        check(TestPathImplementation);
        // this awkward implementation avoids virtual call overhead - it's possible this function will be called a lot
        return (*TestPathImplementation)(AgentProperties, Query, NumVisitedNodes);
    }
 
    inline bool TestHierarchicalPath(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query, int32* NumVisitedNodes) const
    {
        check(TestHierarchicalPathImplementation);
        // this awkward implementation avoids virtual call overhead - it's possible this function will be called a lot
        return (*TestHierarchicalPathImplementation)(AgentProperties, Query, NumVisitedNodes);
    }
 
    inline bool Raycast(const FVector& RayStart, const FVector& RayEnd, FVector& HitLocation, FSharedConstNavQueryFilter QueryFilter, const UObject* Querier = NULL) const
    {
        return Raycast(RayStart, RayEnd, HitLocation, nullptr/*AdditionalResults*/, QueryFilter, Querier);
    }
 
    inline bool Raycast(const FVector& RayStart, const FVector& RayEnd, FVector& HitLocation, FNavigationRaycastAdditionalResults* AdditionalResults, FSharedConstNavQueryFilter QueryFilter, const UObject* Querier = NULL) const
    {
        check(RaycastImplementationWithAdditionalResults);
        // this awkward implementation avoids virtual call overhead - it's possible this function will be called a lot
        return (*RaycastImplementationWithAdditionalResults)(this, RayStart, RayEnd, HitLocation, AdditionalResults, QueryFilter, Querier);
    }
 
    virtual void BatchRaycast(TArray<FNavigationRaycastWork>& Workload, FSharedConstNavQueryFilter QueryFilter, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::BatchRaycast, );
 
    virtual bool FindMoveAlongSurface(const FNavLocation& StartLocation, const FVector& TargetPosition, FNavLocation& OutLocation, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::FindMoveAlongSurface, return false;);
 
    virtual bool FindOverlappingEdges(const FNavLocation& StartLocation, TConstArrayView<FVector> ConvexPolygon, TArray<FVector>& OutEdges, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::FindOverlappingEdges, return false;);
    
    virtual bool GetPathSegmentBoundaryEdges(const FNavigationPath& Path, const FNavPathPoint& StartPoint, const FNavPathPoint& EndPoint, const TConstArrayView<FVector> SearchArea, TArray<FVector>& OutEdges, const float MaxAreaEnterCost, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::GetPathSegmentBoundaryEdges, return false;);
 
    virtual FNavLocation GetRandomPoint(FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::GetRandomPoint, return FNavLocation(););
 
    virtual bool GetRandomReachablePointInRadius(const FVector& Origin, float Radius, FNavLocation& OutResult, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::GetRandomReachablePointInRadius, return false;);
 
    virtual bool GetRandomPointInNavigableRadius(const FVector& Origin, float Radius, FNavLocation& OutResult, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::GetRandomPointInNavigableRadius, return false;);
    
    virtual bool ProjectPoint(const FVector& Point, FNavLocation& OutLocation, const FVector& Extent, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::ProjectPoint, return false;);
 
    virtual void BatchProjectPoints(TArray<FNavigationProjectionWork>& Workload, const FVector& Extent, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::BatchProjectPoints, );
 
    virtual void BatchProjectPoints(TArray<FNavigationProjectionWork>& Workload, FSharedConstNavQueryFilter Filter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::BatchProjectPoints, );
 
    virtual ENavigationQueryResult::Type CalcPathCost(const FVector& PathStart, const FVector& PathEnd, FVector::FReal& OutPathCost, FSharedConstNavQueryFilter QueryFilter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::CalcPathCost, return ENavigationQueryResult::Invalid;);
 
    virtual ENavigationQueryResult::Type CalcPathLength(const FVector& PathStart, const FVector& PathEnd, FVector::FReal& OutPathLength, FSharedConstNavQueryFilter QueryFilter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::CalcPathLength, return ENavigationQueryResult::Invalid;);
 
    virtual ENavigationQueryResult::Type CalcPathLengthAndCost(const FVector& PathStart, const FVector& PathEnd, FVector::FReal& OutPathLength, FVector::FReal& OutPathCost, FSharedConstNavQueryFilter QueryFilter = NULL, const UObject* Querier = NULL) const PURE_VIRTUAL(ANavigationData::CalcPathLengthAndCost, return ENavigationQueryResult::Invalid;);
 
    virtual bool DoesNodeContainLocation(NavNodeRef NodeRef, const FVector& WorldSpaceLocation) const PURE_VIRTUAL(ANavigationData::DoesNodeContainLocation, return false;);
 
    NAVIGATIONSYSTEM_API double GetWorldTimeStamp() const;
 
    //----------------------------------------------------------------------//
    // Areas
    //----------------------------------------------------------------------//
 
    NAVIGATIONSYSTEM_API virtual void OnNavAreaAdded(const UClass* NavAreaClass, int32 AgentIndex);
    
    NAVIGATIONSYSTEM_API virtual void OnNavAreaRemoved(const UClass* NavAreaClass);
 
    NAVIGATIONSYSTEM_API virtual void OnNavAreaChanged();
 
    NAVIGATIONSYSTEM_API void OnNavAreaEvent(const UClass* NavAreaClass, ENavAreaEvent::Type Event);
 
    NAVIGATIONSYSTEM_API void ProcessNavAreas(const TSet<const UClass*>& AreaClasses, int32 AgentIndex);
 
    NAVIGATIONSYSTEM_API const UClass* GetAreaClass(int32 AreaID) const;
    
    NAVIGATIONSYSTEM_API bool IsAreaAssigned(int32 AreaID) const;
 
    NAVIGATIONSYSTEM_API int32 GetAreaID(const UClass* AreaClass) const;
 
    virtual int32 GetMaxSupportedAreas() const { return MAX_int32; }
 
    void GetSupportedAreas(TArray<FSupportedAreaData>& Areas) const { Areas = SupportedAreas; }
 
    //----------------------------------------------------------------------//
    // Custom navigation links
    //----------------------------------------------------------------------//
 
    NAVIGATIONSYSTEM_API virtual void UpdateCustomLink(const INavLinkCustomInterface* CustomLink);
 
    //----------------------------------------------------------------------//
    // Filters
    //----------------------------------------------------------------------//
 
    NAVIGATIONSYSTEM_API FSharedConstNavQueryFilter GetQueryFilter(TSubclassOf<UNavigationQueryFilter> FilterClass) const;
 
    NAVIGATIONSYSTEM_API void StoreQueryFilter(TSubclassOf<UNavigationQueryFilter> FilterClass, FSharedConstNavQueryFilter NavFilter);
 
    NAVIGATIONSYSTEM_API void RemoveQueryFilter(TSubclassOf<UNavigationQueryFilter> FilterClass);
 
    //----------------------------------------------------------------------//
    // all the rest                                                                
    //----------------------------------------------------------------------//
    virtual UPrimitiveComponent* ConstructRenderingComponent() { return NULL; }
 
    NAVIGATIONSYSTEM_API void SetNavRenderingEnabled(bool bEnable);
 
#if WITH_EDITOR
    virtual bool CanChangeIsSpatiallyLoadedFlag() const override { return false; }
#endif
 
protected:
    NAVIGATIONSYSTEM_API void InstantiateAndRegisterRenderingComponent();
 
    NAVIGATIONSYSTEM_API virtual int32 GetNewAreaID(const UClass* AreaClass) const;
    
protected:
    UPROPERTY()
    uint32 DataVersion;
 
    typedef FPathFindingResult (*FFindPathPtr)(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query);
    FFindPathPtr FindPathImplementation;
    FFindPathPtr FindHierarchicalPathImplementation; 
    
    typedef bool (*FTestPathPtr)(const FNavAgentProperties& AgentProperties, const FPathFindingQuery& Query, int32* NumVisitedNodes);
    FTestPathPtr TestPathImplementation;
    FTestPathPtr TestHierarchicalPathImplementation; 
 
    typedef bool(*FNavRaycastPtr)(const ANavigationData* NavDataInstance, const FVector& RayStart, const FVector& RayEnd, FVector& HitLocation, FSharedConstNavQueryFilter QueryFilter, const UObject* Querier);
    UE_DEPRECATED(5.6, "Please use RaycastImplementationWithAdditionalResults instead") 
    FNavRaycastPtr RaycastImplementation;
 
    typedef bool(*FNavRaycastWithAdditionalResultsPtr)(const ANavigationData* NavDataInstance, const FVector& RayStart, const FVector& RayEnd, FVector& HitLocation, FNavigationRaycastAdditionalResults* AdditionalResults, FSharedConstNavQueryFilter QueryFilter, const UObject* Querier);
    FNavRaycastWithAdditionalResultsPtr RaycastImplementationWithAdditionalResults;
 
protected:
    TSharedPtr<FNavDataGenerator, ESPMode::ThreadSafe> NavDataGenerator;
 
    TArray<FNavigationDirtyArea> SuspendedDirtyAreas;
 
    TArray<FNavPathWeakPtr> ActivePaths;
 
    mutable FTransactionallySafeCriticalSection ActivePathsLock;
 
    TArray<FNavPathWeakPtr> ObservedPaths;
 
    TArray<FNavPathRecalculationRequest> RepathRequests;
 
    float NextObservedPathsTickInSeconds;
 
    FSharedNavQueryFilter DefaultQueryFilter;
 
    TMap<UClass*,FSharedConstNavQueryFilter > QueryFilters;
 
    UPROPERTY()
    TArray<FSupportedAreaData> SupportedAreas;
 
    TMap<const UClass*, int32> AreaClassToIdMap;
 
    uint32 bRegistered : 1;
 
    uint32 bSupportsDefaultAgent : 1;
 
    uint32 bRebuildingSuspended : 1;
 
    uint32 bReachedSuspendedAreasMaxCount : 1 = false;
 
#if WITH_EDITORONLY_DATA
    uint32 bIsBuildingOnLoad : 1;
#endif
 
private:
    uint16 NavDataUniqueID;
 
    static NAVIGATIONSYSTEM_API uint16 GetNextUniqueID();
 
protected:
    FNavAgentProperties NavAgentProperties;
 
    void SetNavAgentProperties(const FNavAgentProperties& InNavAgentProperties)
    {
        NavAgentProperties = InNavAgentProperties;
    }
};
 
struct FAsyncPathFindingQuery : public FPathFindingQuery
{
    const uint32 QueryID;
    const FNavPathQueryDelegate OnDoneDelegate;
    const TEnumAsByte<EPathFindingMode::Type> Mode;
    FPathFindingResult Result;
 
    FAsyncPathFindingQuery()
        : QueryID(INVALID_NAVQUERYID)
        , Mode(EPathFindingMode::Regular)
    { }
 
    FAsyncPathFindingQuery(const UObject* InOwner, const ANavigationData& InNavData, const FVector& Start, const FVector& End, const FNavPathQueryDelegate& Delegate, FSharedConstNavQueryFilter SourceQueryFilter, const FVector::FReal CostLimit = TNumericLimits<FVector::FReal>::Max());
    FAsyncPathFindingQuery(const FPathFindingQuery& Query, const FNavPathQueryDelegate& Delegate, const EPathFindingMode::Type QueryMode);
 
protected:
    inline static uint32 GetUniqueID()
    {
        return ++LastPathFindingUniqueID;
    }
 
    static uint32 LastPathFindingUniqueID;
};
 
inline bool FPathFindingResult::IsPartial() const
{
    return (Result != ENavigationQueryResult::Error) && Path.IsValid() && Path->IsPartial();
}
 
inline void FNavigationPath::SetNavigationDataUsed(const ANavigationData* const NavData)
{
    NavigationDataUsed = MakeWeakObjectPtr(const_cast<ANavigationData*>(NavData));
}