CrowdManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CrowdManagerBase.h"
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "AI/Navigation/NavigationTypes.h"
#include "Tickable.h"
#include "DrawDebugHelpers.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "NavFilters/NavigationQueryFilter.h"
#endif
#include "CrowdManager.generated.h"
 
class ANavigationData;
class dtCrowd;
class dtObstacleAvoidanceDebugData;
class ICrowdAgentInterface;
class UCrowdFollowingComponent;
class UCrowdManager;
struct dtCrowdAgent;
struct dtCrowdAgentDebugInfo;
struct dtCrowdAgentParams;
struct FNavMeshPath;
 
#if WITH_RECAST
struct dtQuerySpecialLinkFilter;
struct dtCrowdAgentParams;
class dtCrowd;
struct dtCrowdAgent;
struct dtCrowdAgentDebugInfo;
class dtObstacleAvoidanceDebugData;
#endif
 
struct FNavigationQueryFilter;
typedef TSharedPtr<const FNavigationQueryFilter, ESPMode::ThreadSafe> FSharedConstNavQueryFilter;
 
USTRUCT()
struct FCrowdAvoidanceConfig
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=Crowd)
    float VelocityBias;
 
    UPROPERTY(EditAnywhere, Category=Crowd)
    float DesiredVelocityWeight;
    
    UPROPERTY(EditAnywhere, Category=Crowd)
    float CurrentVelocityWeight;
    
    UPROPERTY(EditAnywhere, Category=Crowd)
    float SideBiasWeight;
    
    UPROPERTY(EditAnywhere, Category=Crowd)
    float ImpactTimeWeight;
 
    UPROPERTY(EditAnywhere, Category=Crowd)
    float ImpactTimeRange;
 
    // index in SamplingPatterns array or 0xff for adaptive sampling
    UPROPERTY(EditAnywhere, Category=Crowd)
    uint8 CustomPatternIdx;
 
    // adaptive sampling: number of divisions per ring
    UPROPERTY(EditAnywhere, Category=Crowd)
    uint8 AdaptiveDivisions;
 
    // adaptive sampling: number of rings
    UPROPERTY(EditAnywhere, Category=Crowd)
    uint8 AdaptiveRings;
    
    // adaptive sampling: number of iterations at best velocity
    UPROPERTY(EditAnywhere, Category=Crowd)
    uint8 AdaptiveDepth;
 
    FCrowdAvoidanceConfig() :
        VelocityBias(0.4f), DesiredVelocityWeight(2.0f), CurrentVelocityWeight(0.75f),
        SideBiasWeight(0.75f), ImpactTimeWeight(2.5f), ImpactTimeRange(2.5f),
        CustomPatternIdx(0xff), AdaptiveDivisions(7), AdaptiveRings(2), AdaptiveDepth(5)
    {}
};
 
USTRUCT()
struct FCrowdAvoidanceSamplingPattern
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=Crowd)
    TArray<float> Angles;
 
    UPROPERTY(EditAnywhere, Category = Crowd)
    TArray<float> Radii;
 
    AIMODULE_API void AddSample(float AngleInDegrees, float NormalizedRadius);
    AIMODULE_API void AddSampleWithMirror(float AngleInDegrees, float NormalizedRadius);
};
 
struct FCrowdAgentData
{
#if WITH_RECAST
    TSharedPtr<dtQuerySpecialLinkFilter> LinkFilter;
#endif
 
    NavNodeRef PrevPoly;
 
    int32 AgentIndex;
 
    float PathOptRemainingTime;
 
    uint32 bIsSimulated : 1;
 
    uint32 bWantsPathOptimization : 1;
 
    FCrowdAgentData() : PrevPoly(0), AgentIndex(-1), PathOptRemainingTime(0), bIsSimulated(false), bWantsPathOptimization(false) {}
 
    bool IsValid() const { return AgentIndex >= 0; }
    AIMODULE_API void ClearFilter();
};
 
struct FCrowdTickHelper : FTickableGameObject
{
    TWeakObjectPtr<UCrowdManager> Owner;
 
    FCrowdTickHelper() : Owner(NULL) {}
    virtual void Tick(float DeltaTime);
    virtual bool IsTickable() const { return Owner.IsValid(); }
    virtual bool IsTickableInEditor() const { return true; }
    virtual bool IsTickableWhenPaused() const { return true; }
    virtual TStatId GetStatId() const;
};
 
UCLASS(config = Engine, defaultconfig, MinimalAPI)
class UCrowdManager : public UCrowdManagerBase
{
    GENERATED_BODY()
 
public:
    AIMODULE_API UCrowdManager(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
    AIMODULE_API virtual void Tick(float DeltaTime) override;
    AIMODULE_API virtual void BeginDestroy() override;
 
    AIMODULE_API void RegisterAgent(ICrowdAgentInterface* Agent);
 
    AIMODULE_API void UnregisterAgent(const ICrowdAgentInterface* Agent);
 
    AIMODULE_API void UpdateAgentParams(const ICrowdAgentInterface* Agent) const;
 
    AIMODULE_API void UpdateAgentState(const ICrowdAgentInterface* Agent) const;
 
    AIMODULE_API void OnAgentFinishedCustomLink(const ICrowdAgentInterface* Agent) const;
 
    AIMODULE_API bool SetAgentMoveTarget(const UCrowdFollowingComponent* AgentComponent, const FVector& MoveTarget, FSharedConstNavQueryFilter Filter) const;
 
    AIMODULE_API bool SetAgentMoveDirection(const UCrowdFollowingComponent* AgentComponent, const FVector& MoveDirection) const;
 
    AIMODULE_API bool SetAgentMovePath(const UCrowdFollowingComponent* AgentComponent, const FNavMeshPath* Path, int32 PathSectionStart, int32 PathSectionEnd, const FVector& PathSectionEndLocation) const;
 
    AIMODULE_API void ClearAgentMoveTarget(const UCrowdFollowingComponent* AgentComponent) const;
 
    AIMODULE_API void PauseAgent(const UCrowdFollowingComponent* AgentComponent) const;
 
    AIMODULE_API void ResumeAgent(const UCrowdFollowingComponent* AgentComponent, bool bForceReplanPath = true) const;
 
    AIMODULE_API bool IsAgentValid(const UCrowdFollowingComponent* AgentComponent) const;
    AIMODULE_API bool IsAgentValid(const ICrowdAgentInterface* Agent) const;
 
    AIMODULE_API int32 GetNumNearbyAgents(const ICrowdAgentInterface* Agent) const;
 
    AIMODULE_API int32 GetNearbyAgentLocations(const ICrowdAgentInterface* Agent, TArray<FVector>& OutLocations) const;
 
    AIMODULE_API bool GetAvoidanceConfig(int32 Idx, FCrowdAvoidanceConfig& Data) const;
 
    AIMODULE_API bool SetAvoidanceConfig(int32 Idx, const FCrowdAvoidanceConfig& Data);
 
    AIMODULE_API void SetOffmeshConnectionPruning(bool bRemoveFromCorridor);
 
    AIMODULE_API void SetSingleAreaVisibilityOptimization(bool bEnable);
 
    AIMODULE_API void AdjustAgentPathStart(const UCrowdFollowingComponent* AgentComponent, const FNavMeshPath* Path, int32& PathStartIdx) const;
 
#if WITH_EDITOR
    AIMODULE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
 
    AIMODULE_API void DebugTick() const;
#endif
 
    AIMODULE_API void OnNavMeshUpdate();
 
    AIMODULE_API virtual bool IsSuitableNavData(const ANavigationData& NavData) const;
 
    AIMODULE_API virtual void OnNavDataRegistered(ANavigationData& NavData) override;
 
    AIMODULE_API virtual void OnNavDataUnregistered(ANavigationData& NavData) override;
 
    virtual void CleanUp(float DeltaTime) override {};
 
    const ANavigationData* GetNavData() const { return MyNavData; }
 
    AIMODULE_API UWorld* GetWorld() const override;
 
    static AIMODULE_API UCrowdManager* GetCurrent(UObject* WorldContextObject);
    static AIMODULE_API UCrowdManager* GetCurrent(UWorld* World);
 
protected:
 
    UPROPERTY(transient)
    TObjectPtr<ANavigationData> MyNavData;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    TArray<FCrowdAvoidanceConfig> AvoidanceConfig;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    TArray<FCrowdAvoidanceSamplingPattern> SamplingPatterns;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    int32 MaxAgents;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    float MaxAgentRadius;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    int32 MaxAvoidedAgents;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    int32 MaxAvoidedWalls;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    float NavmeshCheckInterval;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    float PathOptimizationInterval;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    float SeparationDirClamp;
 
    UPROPERTY(config, EditAnywhere, Category = Config)
    float PathOffsetRadiusMultiplier;
 
    uint32 bPruneStartedOffmeshConnections : 1;
    uint32 bSingleAreaVisibilityOptimization : 1;
    uint32 bEarlyReachTestOptimization : 1;
    uint32 bAllowPathReplan : 1;
    
    UPROPERTY(config, EditAnywhere, Category = Config)
    uint32 bResolveCollisions : 1;
 
    TMap<ICrowdAgentInterface*, FCrowdAgentData> ActiveAgents;
 
    TArray<uint8> AgentFlags;
 
#if WITH_RECAST
    dtCrowd* DetourCrowd;
 
    dtCrowdAgentDebugInfo* DetourAgentDebug;
    dtObstacleAvoidanceDebugData* DetourAvoidanceDebug;
#endif
 
#if WITH_EDITOR
    FCrowdTickHelper* TickHelper;
#endif // WITH_EDITOR
 
    AIMODULE_API virtual void UpdateNavData();
 
    AIMODULE_API virtual void UpdateAvoidanceConfig();
 
    AIMODULE_API virtual void PostProximityUpdate();
 
    AIMODULE_API virtual void PostMovePointUpdate();
 
    AIMODULE_API void SetNavData(ANavigationData* NavData, const bool bFindNewNavDataIfNull = true);
 
#if WITH_RECAST
    AIMODULE_API void AddAgent(const ICrowdAgentInterface* Agent, FCrowdAgentData& AgentData) const;
    AIMODULE_API void RemoveAgent(const ICrowdAgentInterface* Agent, FCrowdAgentData* AgentData) const;
    AIMODULE_API void GetAgentParams(const ICrowdAgentInterface* Agent, dtCrowdAgentParams& AgentParams) const;
 
    AIMODULE_API void PrepareAgentStep(const ICrowdAgentInterface* Agent, FCrowdAgentData& AgentData, float DeltaTime) const;
 
    AIMODULE_API virtual void ApplyVelocity(UCrowdFollowingComponent* AgentComponent, int32 AgentIndex) const;
 
    AIMODULE_API void UpdateAgentPaths();
 
    AIMODULE_API void UpdateSelectedDebug(const ICrowdAgentInterface* Agent, int32 AgentIndex) const;
 
    AIMODULE_API void CreateCrowdManager();
    AIMODULE_API void DestroyCrowdManager();
 
#if ENABLE_DRAW_DEBUG
    AIMODULE_API UWorld* GetDebugDrawingWorld() const;
    AIMODULE_API void DrawDebugCorners(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugCollisionSegments(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugPath(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugVelocityObstacles(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugPathOptimization(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugNeighbors(const dtCrowdAgent* CrowdAgent) const;
    AIMODULE_API void DrawDebugSharedBoundary() const;
#endif // ENABLE_DRAW_DEBUG
 
#endif
};