AssetManagerTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AssetRegistry/AssetIdentifier.h"
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
#include "Templates/Tuple.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectPtr.h"
#include "UObject/PrimaryAssetId.h"
#include "UObject/SoftObjectPtr.h"
 
#include "AssetManagerTypes.generated.h"
 
class FCbWriter;
 
UENUM()
enum class EPrimaryAssetCookRule : uint8
{
    Unknown,
 
    NeverCook,
 
    ProductionNeverCook,
    DevelopmentCook=ProductionNeverCook,
 
    DevelopmentAlwaysProductionNeverCook,
    DevelopmentAlwaysCook = DevelopmentAlwaysProductionNeverCook,
 
    DevelopmentAlwaysProductionUnknownCook,
 
    AlwaysCook,
};
 
enum class EPrimaryAssetProductionLevel
{
    Development = 0,
    Production,
    Count
};
 
USTRUCT()
struct FPrimaryAssetRules
{
    GENERATED_BODY()
    
    
    UPROPERTY(EditAnywhere, Category = Rules)
    int32 Priority;
 
    UPROPERTY(EditAnywhere, Category = Rules, meta = (DisplayName = "Chunk ID"))
    int32 ChunkId;
 
    UPROPERTY(EditAnywhere, Category = Rules)
    bool bApplyRecursively;
 
    UPROPERTY(EditAnywhere, Category = Rules)
    EPrimaryAssetCookRule CookRule;
 
    FPrimaryAssetRules() 
        : Priority(-1), ChunkId(-1), bApplyRecursively(true), CookRule(EPrimaryAssetCookRule::Unknown)
    {
    }
 
    bool operator==(const FPrimaryAssetRules& Other) const
    {
        return Priority == Other.Priority
            && bApplyRecursively == Other.bApplyRecursively
            && ChunkId == Other.ChunkId
            && CookRule == Other.CookRule;
    }
 
    ENGINE_API bool IsDefault() const;
 
    ENGINE_API void OverrideRules(const FPrimaryAssetRules& OverrideRules);
 
    ENGINE_API void PropagateCookRules(const FPrimaryAssetRules& ParentRules);
};
 
struct FPrimaryAssetRulesExplicitOverride
{
    FPrimaryAssetRules Rules;
    uint8 bOverridePriority:1;
    uint8 bOverrideApplyRecursively:1;
    uint8 bOverrideChunkId:1;
    uint8 bOverrideCookRule:1;
 
    FPrimaryAssetRulesExplicitOverride()
        : bOverridePriority(false), bOverrideApplyRecursively(false), bOverrideChunkId(false), bOverrideCookRule(false)
    {
    }
 
    bool HasAnyOverride() const { return bOverridePriority || bOverrideApplyRecursively || bOverrideChunkId || bOverrideCookRule; }
 
    ENGINE_API void OverrideRulesExplicitly(FPrimaryAssetRules& RulesToOverride) const;
};
 
USTRUCT()
struct FPrimaryAssetTypeInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = AssetType)
    FName PrimaryAssetType;
 
private:
    // Use accessors below to modify config data
 
    UPROPERTY(EditAnywhere, Category = AssetType, meta = (AllowAbstract))
    TSoftClassPtr<UObject> AssetBaseClass;
 
public:
    UPROPERTY(Transient)
    TObjectPtr<UClass> AssetBaseClassLoaded;
 
    UPROPERTY(EditAnywhere, Category = AssetType)
    bool bHasBlueprintClasses;
 
    UPROPERTY(EditAnywhere, Category = AssetType)
    bool bIsEditorOnly;
 
private:
    // Use accessors below to modify config data
 
    UPROPERTY(EditAnywhere, Category = AssetType, meta = (RelativeToGameContentDir, LongPackageName))
    TArray<FDirectoryPath> Directories;
 
    UPROPERTY(EditAnywhere, Category = AssetType)
    TArray<FSoftObjectPath> SpecificAssets;
 
public:
    UPROPERTY(EditAnywhere, Category = Rules, meta = (ShowOnlyInnerProperties))
    FPrimaryAssetRules Rules;
 
    UPROPERTY(Transient)
    TArray<FString> AssetScanPaths;
 
    UPROPERTY(Transient)
    bool bIsDynamicAsset;
 
    UPROPERTY(Transient)
    int32 NumberOfAssets;
 
    FPrimaryAssetTypeInfo() : AssetBaseClass(UObject::StaticClass()), AssetBaseClassLoaded(UObject::StaticClass()), bHasBlueprintClasses(false), bIsEditorOnly(false),  bIsDynamicAsset(false), NumberOfAssets(0) {}
 
    FPrimaryAssetTypeInfo(FName InPrimaryAssetType, UClass* InAssetBaseClass, bool bInHasBlueprintClasses, bool bInIsEditorOnly)
        : PrimaryAssetType(InPrimaryAssetType), AssetBaseClass(InAssetBaseClass), AssetBaseClassLoaded(InAssetBaseClass), bHasBlueprintClasses(bInHasBlueprintClasses), bIsEditorOnly(bInIsEditorOnly), bIsDynamicAsset(false), NumberOfAssets(0)
    {
    }
 
    FPrimaryAssetTypeInfo(FName InPrimaryAssetType, UClass* InAssetBaseClass, bool bInHasBlueprintClasses, bool bInIsEditorOnly, TArray<FDirectoryPath>&& InDirectories, TArray<FSoftObjectPath>&& InSpecificAssets)
        : PrimaryAssetType(InPrimaryAssetType)
        , AssetBaseClass(InAssetBaseClass)
        , AssetBaseClassLoaded(InAssetBaseClass)
        , bHasBlueprintClasses(bInHasBlueprintClasses)
        , bIsEditorOnly(bInIsEditorOnly)
        , Directories(MoveTemp(InDirectories))
        , SpecificAssets(MoveTemp(InSpecificAssets))
        , bIsDynamicAsset(false)
        , NumberOfAssets(0)
    {
    }
 
    const TSoftClassPtr<UObject>& GetAssetBaseClass() const
    {
        return AssetBaseClass;
    }
 
    void SetAssetBaseClass(const TSoftClassPtr<UObject>& InAssetBaseClass)
    {
        if (ensure(CanModifyConfigData()))
        {
            AssetBaseClass = InAssetBaseClass;
        }
    }
 
    const TArray<FDirectoryPath>& GetDirectories() const 
    {
        return Directories;
    }
 
    TArray<FDirectoryPath>& GetDirectories()
    {
        ensure(CanModifyConfigData());
        return Directories; 
    }
 
    const TArray<FSoftObjectPath>& GetSpecificAssets() const 
    {
        return SpecificAssets;
    }
    
    TArray<FSoftObjectPath>& GetSpecificAssets() 
    {
        ensure(CanModifyConfigData());
        return SpecificAssets;
    }
 
    ENGINE_API bool HasValidConfigData() const;
 
    ENGINE_API bool HasValidRuntimeData() const;
 
    ENGINE_API bool CanModifyConfigData() const;
 
    ENGINE_API void FillRuntimeData(bool& bIsValid, bool& bBaseClassWasLoaded);
};
 
struct FAssetManagerChunkInfo
{
    TSet<FAssetIdentifier> ExplicitAssets;
 
    TSet<FAssetIdentifier> AllAssets;
};
 
enum class EAssetManagerFilter : int32
{
    // Default filter, process everything
    Default         = 0,
 
    // Only process assets that are unloaded (have no active or pending bundle assignments)
    UnloadedOnly    = 0x00000001
};
 
ENUM_CLASS_FLAGS(EAssetManagerFilter);
 
DECLARE_DELEGATE_RetVal_TwoParams(bool, FAssetManagerShouldIncludeDelegate, const struct FAssetData&, const struct FAssetManagerSearchRules&);
 
USTRUCT(BlueprintType)
struct FAssetManagerSearchRules
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    TArray<FString> AssetScanPaths;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    TArray<FString> IncludePatterns;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    TArray<FString> ExcludePatterns;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    TObjectPtr<UClass> AssetBaseClass = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    bool bHasBlueprintClasses = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    bool bForceSynchronousScan = false;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    bool bSkipVirtualPathExpansion = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Default)
    bool bSkipManagerIncludeCheck = false;
 
    FAssetManagerShouldIncludeDelegate ShouldIncludeDelegate;
 
    ENGINE_API bool AreRulesSet() const;
};
 
struct FPrimaryAssetCookRuleUnion
{
    ENGINE_API void UnionWith(EPrimaryAssetCookRule CookRule, bool bDirectReference, const FPrimaryAssetId& Id, int32 Priority);
 
    ENGINE_API EPrimaryAssetCookRule GetRule(TOptional<TTuple<FPrimaryAssetId, FPrimaryAssetId>>* OutConflictIds);
 
private:
    struct FAssignmentInfo
    {
        FPrimaryAssetId Id;
        int32 Priority = -1;
        bool bSet = false;
    };
 
    FAssignmentInfo InclusionByLevel[(int32)EPrimaryAssetProductionLevel::Count];
    FAssignmentInfo ExclusionByLevel[(int32)EPrimaryAssetProductionLevel::Count];
 
    friend void SerializeForLog(FCbWriter& Writer, const FPrimaryAssetRules& Value);
};