EnvQueryManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "EnvironmentQuery/Items/EnvQueryItemType.h"
#include "EnvironmentQuery/EnvQueryContext.h"
#include "EnvironmentQuery/EnvQueryTypes.h"
#include "AISubsystem.h"
#include "EnvironmentQuery/EnvQueryInstanceBlueprintWrapper.h"
#include "EnvQueryManager.generated.h"
 
class UEnvQuery;
class UEnvQueryManager;
class UEnvQueryOption;
class UEnvQueryTest;
 
//----------------------------------------------------------------------//
// FEnvQueryManagerConfig
//----------------------------------------------------------------------//
 
USTRUCT()
struct FEnvQueryManagerConfig
{
    GENERATED_BODY()
 
public:
 
    UPROPERTY(config)
    float MaxAllowedTestingTime = 0.003f;
 
    UPROPERTY(config)
    bool bTestQueriesUsingBreadth = false;
 
    UPROPERTY(config)
    int32 QueryCountWarningThreshold = 200;
 
    UPROPERTY(config)
    double QueryCountWarningInterval = 60.0f;
 
    UPROPERTY(config)
    double ExecutionTimeWarningSeconds = 0.025f;
 
    UPROPERTY(config)
    double HandlingResultTimeWarningSeconds = 0.025f;
 
    UPROPERTY(config)
    double GenerationTimeWarningSeconds = 0.01f;
 
public:
    FString ToString() const;
};
 
USTRUCT()
struct FEnvQueryRequest
{
    GENERATED_USTRUCT_BODY()
 
    FEnvQueryRequest() : QueryTemplate(NULL), Owner(NULL), World(NULL) {}
 
    // basic constructor: owner will be taken from finish delegate bindings
    FEnvQueryRequest(const UEnvQuery* Query) : QueryTemplate(Query), Owner(NULL), World(NULL) {}
 
    // use when owner is different from finish delegate binding
    FEnvQueryRequest(const UEnvQuery* Query, UObject* RequestOwner) : QueryTemplate(Query), Owner(RequestOwner), World(NULL) {}
 
    // set names param indicated by Param. If Param is configured to read values from a blackboard then BlackboardComponent
    // is expected to be non-null (the function will fail a check otherwise).
    AIMODULE_API FEnvQueryRequest& SetDynamicParam(const FAIDynamicParam& Param, const UBlackboardComponent* BlackboardComponent = nullptr);
 
    // set named params
    inline FEnvQueryRequest& SetFloatParam(FName ParamName, float Value) { NamedParams.Add(ParamName, Value); return *this; }
    inline FEnvQueryRequest& SetIntParam(FName ParamName, int32 Value) { NamedParams.Add(ParamName, *((float*)&Value)); return *this; }
    inline FEnvQueryRequest& SetBoolParam(FName ParamName, bool Value) { NamedParams.Add(ParamName, Value ? 1.0f : -1.0f); return *this; }
    inline FEnvQueryRequest& SetNamedParam(const FEnvNamedValue& ParamData) { NamedParams.Add(ParamData.ParamName, ParamData.Value); return *this; }
    AIMODULE_API FEnvQueryRequest& SetNamedParams(const TArray<FEnvNamedValue>& Params);
 
    // set world (for accessing query manager) when owner can't provide it
    inline FEnvQueryRequest& SetWorldOverride(UWorld* InWorld) { World = InWorld; return *this; }
 
    template< class UserClass > 
    inline int32 Execute(EEnvQueryRunMode::Type Mode, UserClass* InObj, typename FQueryFinishedSignature::TMethodPtr< UserClass > InMethod)
    {
        return Execute(Mode, FQueryFinishedSignature::CreateUObject(InObj, InMethod));
    }
    template< class UserClass > 
    inline int32 Execute(EEnvQueryRunMode::Type Mode, UserClass* InObj, typename FQueryFinishedSignature::TConstMethodPtr< UserClass > InMethod)
    {
        return Execute(Mode, FQueryFinishedSignature::CreateUObject(InObj, InMethod));
    }
    AIMODULE_API int32 Execute(EEnvQueryRunMode::Type RunMode, FQueryFinishedSignature const& FinishDelegate);
 
protected:
 
    UPROPERTY()
    TObjectPtr<const UEnvQuery> QueryTemplate;
 
    UPROPERTY()
    TObjectPtr<UObject> Owner;
 
    UPROPERTY()
    TObjectPtr<UWorld> World;
 
    TMap<FName, float> NamedParams;
 
    friend UEnvQueryManager;
};
 
USTRUCT()
struct FEnvQueryInstanceCache
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<UEnvQuery> Template = nullptr;
 
    UPROPERTY(Transient)
    FEnvQueryInstance Instance;
 
    FName AssetName;
};
 
#if USE_EQS_DEBUGGER
struct FEQSDebugger
{
    struct FEnvQueryInfo
    {
        TSharedPtr<FEnvQueryInstance> Instance;
        double Timestamp;
    };
 
    struct FStatsInfo
    {
        // most expensive run
        FEnvQueryDebugProfileData MostExpensive;
        double MostExpensiveDuration;
 
        // average run (sum of all runs, divide by TotalAvgCount to get values)
        FEnvQueryDebugProfileData TotalAvgData;
        double TotalAvgDuration;
        int32 TotalAvgCount;
 
        // EQS tick load
        TArray<uint8> TickPct;
        double LastTickTime;
        uint64 LastTickFrame;
        uint16 FirstTickEntry;
        uint16 LastTickEntry;
 
        FStatsInfo() :
            MostExpensiveDuration(0.0f),
            TotalAvgDuration(0.0f), TotalAvgCount(0),
            LastTickTime(0.0f), LastTickFrame(0),
            FirstTickEntry(MAX_uint16), LastTickEntry(0)
        {}
    };
 
    AIMODULE_API void StoreStats(const FEnvQueryInstance& QueryInstance);
    AIMODULE_API void StoreTickTime(const FEnvQueryInstance& QueryInstance, double TickTime, double MaxTickTime);
    AIMODULE_API void StoreQuery(const TSharedPtr<FEnvQueryInstance>& QueryInstance);
    
    static AIMODULE_API void SaveStats(const FString& FileName);
    static AIMODULE_API void LoadStats(const FString& FileName);
 
    AIMODULE_API const TArray<FEnvQueryInfo>& GetAllQueriesForOwner(const UObject* Owner);
 
    // map query name with profiler data
    TMap<FName, FStatsInfo> StoredStats;
 
protected:
    // maps owner to performed queries
    TMap<FObjectKey, TArray<FEnvQueryInfo>> StoredQueries;
};
 
FArchive& operator<<(FArchive& Ar, FEQSDebugger::FStatsInfo& Data);
 
inline bool operator== (const FEQSDebugger::FEnvQueryInfo & Left, const FEQSDebugger::FEnvQueryInfo & Right)
{
    return Left.Instance == Right.Instance;
}
#endif // USE_EQS_DEBUGGER
 
UCLASS(config = Game, defaultconfig, Transient, MinimalAPI)
class UEnvQueryManager : public UAISubsystem, public FSelfRegisteringExec
{
    GENERATED_UCLASS_BODY()
 
    // makes sure we don't have any UEnvQueryManager instances serialized in. 
    // Any loaded instance will get marked as PendingKill
    AIMODULE_API virtual void PostLoad() override;
    AIMODULE_API virtual void PostInitProperties() override;
 
    // FTickableGameObject begin
    AIMODULE_API virtual void Tick(float DeltaTime) override;
    AIMODULE_API virtual TStatId GetStatId() const override;
    virtual bool IsTickableInEditor() const override { return true; }
    // FTickableGameObject end
 
    AIMODULE_API int32 RunQuery(const FEnvQueryRequest& Request, EEnvQueryRunMode::Type RunMode, FQueryFinishedSignature const& FinishDelegate);
    AIMODULE_API int32 RunQuery(const TSharedPtr<FEnvQueryInstance>& QueryInstance, FQueryFinishedSignature const& FinishDelegate);
 
    void SilentlyRemoveAllQueriesByQuerier(const UObject& Querier)
    {
        RemoveAllQueriesByQuerier(Querier, /*bExecuteFinishDelegate=*/false);
    }
 
    AIMODULE_API void RemoveAllQueriesByQuerier(const UObject& Querier, bool bExecuteFinishDelegate);
 
    AIMODULE_API TSharedPtr<FEnvQueryResult> RunInstantQuery(const FEnvQueryRequest& Request, EEnvQueryRunMode::Type RunMode);
    AIMODULE_API void RunInstantQuery(const TSharedPtr<FEnvQueryInstance>& QueryInstance);
 
    AIMODULE_API TSharedPtr<FEnvQueryInstance> PrepareQueryInstance(const FEnvQueryRequest& Request, EEnvQueryRunMode::Type RunMode);
 
    AIMODULE_API UEnvQuery* FindQueryTemplate(const FString& QueryName) const;
 
    AIMODULE_API UEnvQueryContext* PrepareLocalContext(TSubclassOf<UEnvQueryContext> ContextClass);
 
    AIMODULE_API float FindNamedParam(int32 QueryId, FName ParamName) const;
 
    AIMODULE_API bool AbortQuery(int32 RequestID);
 
    AIMODULE_API void PrintActiveQueryInfo() const;
 
    AIMODULE_API virtual void OnWorldCleanup();
 
    AIMODULE_API virtual void FinishDestroy() override;
 
    AIMODULE_API void RegisterExternalQuery(const TSharedPtr<FEnvQueryInstance>& QueryInstance);
 
    AIMODULE_API void UnregisterExternalQuery(const TSharedPtr<FEnvQueryInstance>& QueryInstance);
 
    static AIMODULE_API TArray<TSubclassOf<UEnvQueryItemType> > RegisteredItemTypes;
 
    static AIMODULE_API UEnvQueryManager* GetCurrent(UWorld* World);
    static AIMODULE_API UEnvQueryManager* GetCurrent(const UObject* WorldContextObject);
    
    UFUNCTION(BlueprintCallable, Category = "AI|EQS", meta = (WorldContext = "WorldContextObject", AdvancedDisplay = "WrapperClass"))
    static AIMODULE_API UEnvQueryInstanceBlueprintWrapper* RunEQSQuery(UObject* WorldContextObject, UEnvQuery* QueryTemplate, UObject* Querier, TEnumAsByte<EEnvQueryRunMode::Type> RunMode, TSubclassOf<UEnvQueryInstanceBlueprintWrapper> WrapperClass);
 
    AIMODULE_API void RegisterActiveWrapper(UEnvQueryInstanceBlueprintWrapper& Wrapper);
    AIMODULE_API void UnregisterActiveWrapper(UEnvQueryInstanceBlueprintWrapper& Wrapper);
 
    static AIMODULE_API void SetAllowTimeSlicing(bool bAllowTimeSlicing);
 
    AIMODULE_API void Configure(const FEnvQueryManagerConfig& NewConfig);
 
protected:
    //~ Begin FExec Interface
    AIMODULE_API virtual bool Exec_Dev(UWorld* Inworld,const TCHAR* Cmd,FOutputDevice& Ar) override;
    //~ End FExec Interface
 
    friend UEnvQueryInstanceBlueprintWrapper;
    AIMODULE_API TSharedPtr<FEnvQueryInstance> FindQueryInstance(const int32 QueryID);
 
#if USE_EQS_DEBUGGER
public:
    static AIMODULE_API void NotifyAssetUpdate(UEnvQuery* Query);
    static AIMODULE_API TMap<FName, FEQSDebugger::FStatsInfo> DebuggerStats;
 
    FEQSDebugger& GetDebugger() { return EQSDebugger; }
 
protected:
    FEQSDebugger EQSDebugger;
#endif // USE_EQS_DEBUGGER
 
protected:
 
    TArray<TSharedPtr<FEnvQueryInstance> > RunningQueries;
 
    int32 NumRunningQueriesAbortedSinceLastUpdate;
 
    TMap<int32, TWeakPtr<FEnvQueryInstance>> ExternalQueries;
 
    UPROPERTY(transient)
    TArray<FEnvQueryInstanceCache> InstanceCache;
 
    UPROPERTY(transient)
    TArray<TObjectPtr<UEnvQueryContext>> LocalContexts;
 
    UPROPERTY()
    TArray<TObjectPtr<UEnvQueryInstanceBlueprintWrapper>> GCShieldedWrappers;
 
    TMap<FName, UEnvQueryContext*> LocalContextMap;
 
    int32 NextQueryID;
 
    AIMODULE_API TSharedPtr<FEnvQueryInstance> CreateQueryInstance(const UEnvQuery* Template, EEnvQueryRunMode::Type RunMode);
 
    UPROPERTY(config)
    float MaxAllowedTestingTime;
 
    UPROPERTY(config)
    bool bTestQueriesUsingBreadth;
 
    UPROPERTY(config)
    int32 QueryCountWarningThreshold;
 
    UPROPERTY(config)
    double QueryCountWarningInterval;
 
    UPROPERTY(config)
    double ExecutionTimeWarningSeconds = 0.025f;
 
    UPROPERTY(config)
    double HandlingResultTimeWarningSeconds = 0.025f;
 
    UPROPERTY(config)
    double GenerationTimeWarningSeconds = 0.01f;
private:
 
    AIMODULE_API void CreateOptionInstance(UEnvQueryOption* OptionTemplate, int32 SourceOptionIndex, const TArray<UEnvQueryTest*>& SortedTests, FEnvQueryInstance& Instance);
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    static AIMODULE_API bool bAllowEQSTimeSlicing;
#endif
#if !(UE_BUILD_SHIPPING)
    mutable double LastQueryCountWarningThresholdTime;
 
    AIMODULE_API void CheckQueryCount() const;
    AIMODULE_API void LogQueryInfo(bool bDisplayThresholdWarning) const;
#endif
 
#if WITH_EDITOR
    FDelegateHandle OnBlueprintCompiledHandle;
 
    // used to reset LocalContextMap in case we had BP contexts stored
    AIMODULE_API void OnBlueprintCompiled();
#endif // WITH_EDITOR
};