DataAssetManager.h

이 파일의 문서화 페이지로 가기

#pragma once
 
#include "CoreMinimal.h"
#include "Engine/AssetManager.h"
#include "LoadJob/DataAssetJobManager.h"
#include "DataAssetManager.generated.h"
 
struct FDataAssetLoadJob;
 
 
DECLARE_DELEGATE_TwoParams(FAsyncLoadCompletedDelegate, const FName&/*AssetName or Label*/, UObject*/*LoadedAsset*/);
 
 
USTRUCT()
struct FGameDataAssetList
{
    GENERATED_BODY()
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UPrimaryDataAsset>> Assets;
};
 
UCLASS(Blueprintable)
class CK_UE_API UDataAssetManager : public UAssetManager
{
    GENERATED_BODY()
 
public:
    UDataAssetManager();
 
public:
    static UDataAssetManager& GetInstance();
    
    static void DumpLoadedAssets();
 
    static void RegisterBundleAssets(const TArray<UObject*>& InAssets);
 
    static void UnregisterBundleAssets(const TArray<UObject*>& InAssets);
 
    
public:
    template <typename TData>
    static TData* GetAsset(const TSoftObjectPtr<TData>& AssetPointer, bool bKeepInMemory = true);
 
    template <typename TData>
    static TSubclassOf<TData> GetSubclass(const TSoftClassPtr<TData>& AssetPointer, bool bKeepInMemory = true);
 
    static void LoadAsyncByPath(const FSoftObjectPath& AssetPath, FAsyncLoadCompletedDelegate CompletedDelegate = FAsyncLoadCompletedDelegate());
    static void LoadAsyncByName(const FName& AssetName, FAsyncLoadCompletedDelegate CompletedDelegate = FAsyncLoadCompletedDelegate());
 
    
protected:
    static UObject* SynchronousLoadAsset(const FSoftObjectPath& AssetPath);
    static bool ShouldLogAssetLoads();
    
    template <typename TData>
    const TData& GetOrLoadTypedGameData(const TSoftObjectPtr<TData>& DataPath);
 
    template <typename TData>
    TArray<const TData*> GetAllTypedGameData() const;
 
    
protected:
    UFUNCTION(BlueprintNativeEvent, Category = "DataAssetManager")
    void InitializeOnManager();
    
    UFUNCTION(BlueprintNativeEvent, Category = "DataAssetManager")
    void OnUpdateLoadPercentage(float Percentage);
 
    UFUNCTION(BlueprintNativeEvent, Category = "DataAssetManager")
    void OnAllDataLoadCompleted();
 
    virtual void TryCreateLoadJobForDataAsset(TSoftObjectPtr<UPrimaryDataAsset> DataPath, FString JobName);
    virtual void StartInitialLoading() override;
    
    UPrimaryDataAsset* LoadGameDataOfClass(TSubclassOf<UPrimaryDataAsset> DataClass, const TSoftObjectPtr<UPrimaryDataAsset>& DataClassPath, FPrimaryAssetType PrimaryAssetType);
    
    
#if WITH_EDITOR
    virtual void PreBeginPIE(bool bStartSimulate) override;
#endif
 
protected:
    UPROPERTY(Transient)
    TMap<TObjectPtr<UClass>, FGameDataAssetList> GameDataMap;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "GameData")
    TArray<TSoftObjectPtr<UPrimaryDataAsset>> InitialGameDataPaths;
 
    UPROPERTY()
    FDataAssetJobManager JobManager;
 
private:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "DataAssetManager", meta = (AllowPrivateAccess = "true"))
    TSet<TObjectPtr<UObject>> LoadedAssets;
};
 
 
#pragma region Static Template Functions
 
template <typename AssetType>
AssetType* UDataAssetManager::GetAsset(const TSoftObjectPtr<AssetType>& AssetPointer, bool bKeepInMemory)
{
    AssetType* LoadedAsset = nullptr;
    const FSoftObjectPath& AssetPath = AssetPointer.ToSoftObjectPath();
 
    if (AssetPath.IsNull())
    {
        return LoadedAsset;
    }
 
    LoadedAsset = AssetPointer.Get();
 
    if (LoadedAsset == nullptr)
    {
        LoadedAsset = Cast<AssetType>(SynchronousLoadAsset(AssetPath));
        ensureAlwaysMsgf(LoadedAsset, TEXT("Failed to load asset [%s]"), *AssetPointer.ToString());
    }
 
    if (LoadedAsset && bKeepInMemory)
    {
        GetInstance().LoadedAssets.Add(Cast<UObject>(LoadedAsset));
    }
 
    return LoadedAsset;
}
 
 
template <typename AssetType>
TSubclassOf<AssetType> UDataAssetManager::GetSubclass(const TSoftClassPtr<AssetType>& AssetPointer, bool bKeepInMemory)
{
    TSubclassOf<AssetType> LoadedSubclass;
    const FSoftObjectPath& AssetPath = AssetPointer.ToSoftObjectPath();
 
    if (AssetPath.IsNull())
    {
        return LoadedSubclass;
    }
 
    LoadedSubclass = AssetPointer.Get();
 
    if (LoadedSubclass == nullptr)
    {
        LoadedSubclass = Cast<UClass>(SynchronousLoadAsset(AssetPath));
        ensureAlwaysMsgf(LoadedSubclass, TEXT("Failed to load asset class [%s]"), *AssetPointer.ToString());
    }
 
    if (LoadedSubclass && bKeepInMemory)
    {
        GetInstance().LoadedAssets.Add(Cast<UObject>(LoadedSubclass));
    }
 
    return LoadedSubclass;
}
 
 
template <typename GameDataClass>
const GameDataClass& UDataAssetManager::GetOrLoadTypedGameData(const TSoftObjectPtr<GameDataClass>& DataPath)
{
    if (auto* pResult = GameDataMap.Find(GameDataClass::StaticClass()))
    {
        if (pResult->Assets.IsEmpty() == false)
        {
            return *CastChecked<GameDataClass>(pResult->Assets[0]);
        }
    }
 
    return *CastChecked<const GameDataClass>(LoadGameDataOfClass(GameDataClass::StaticClass(), DataPath, GameDataClass::StaticClass()->GetFName()));
}
 
 
template <typename GameDataClass>
TArray<const GameDataClass*> UDataAssetManager::GetAllTypedGameData() const
{
    TArray<const GameDataClass*> Result;
 
    const auto* pResult = GameDataMap.Find(GameDataClass::StaticClass());
 
    if (pResult == nullptr)
    {
        return Result;
    }
 
    for (const TObjectPtr<UPrimaryDataAsset>& Asset : pResult->Assets)
    {
        if (const GameDataClass* Typed = Cast<GameDataClass>(Asset))
        {
            Result.Add(Typed);
        }
    }
 
    return Result;
}
 
#pragma endregion