DataAssetManager.h

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

#pragma once
 
#include "CoreMinimal.h"
#include "CK_UE.h"
#include "Engine/AssetManager.h"
#include "LoadJob/DataAssetJobManager.h"
#include "DataAssetManager.generated.h"
 
class IDataAssetBundle;
struct FDataAssetLoadJob;
 
 
DECLARE_DELEGATE_TwoParams(FAsyncLoadCompletedDelegate, const FName&/*AssetName or Label*/, UObject*/*LoadedAsset*/);
DECLARE_DELEGATE_OneParam(FAsyncBatchLoadCompletedDelegate, const TArray<UObject*>& /*LoadedAssets*/);
 
 
USTRUCT()
struct FGameDataAssetList
{
    GENERATED_BODY()
 
public:
    UPROPERTY(Transient)
    TArray<TObjectPtr<UPrimaryDataAsset>> Assets;
};
 
UCLASS(Blueprintable)
class CK_UE_API UDataAssetManager : public UAssetManager
{
    GENERATED_BODY()
    
public:
    UDataAssetManager();;
    
public:
    static UDataAssetManager& GetInstance();
 
    template <typename TData>
    static TData* GetAssetByType();
 
    template <typename TData>
    static TArray<TData*> GetAllAssetsByType();
 
    template <typename TData>
    static void LoadAllPrimaryAssetsAsyncInPath(const FString& FolderPath, FAsyncBatchLoadCompletedDelegate CompletedDelegate = FAsyncBatchLoadCompletedDelegate());
 
    static void LoadAsyncByPath(const FSoftObjectPath& AssetPath, FAsyncLoadCompletedDelegate CompletedDelegate = FAsyncLoadCompletedDelegate());
    static void LoadAsyncByName(const FName& AssetName, FAsyncLoadCompletedDelegate CompletedDelegate = FAsyncLoadCompletedDelegate());
 
    static UObject* SynchronousLoadAsset(const FSoftObjectPath& AssetPath);
 
    
public:
    virtual void StartInitialLoading() override;
    
    
protected:
    template <typename TData>
    const TData& GetOrLoadTypedGameData(const TSoftObjectPtr<TData>& DataPath);
 
    template <typename TData>
    TArray<const TData*> GetAllTypedGameData() const;
 
    
protected:
    UFUNCTION(BlueprintNativeEvent, Category = "DataAssetManager")
    void OnUpdateLoadPercentage(float Percentage);
 
    virtual void TryCreateLoadJobForDataAsset(TSoftObjectPtr<UPrimaryDataAsset> DataPath, FString JobName);
    UPrimaryDataAsset* LoadGameDataOfClass(TSubclassOf<UPrimaryDataAsset> DataClass, const TSoftObjectPtr<UPrimaryDataAsset>& DataClassPath, FPrimaryAssetType PrimaryAssetType);
 
    
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = GameData)
    TSoftObjectPtr<IDataAssetBundle> InitialBundlePath;
    
    UPROPERTY(Transient)
    TMap<TObjectPtr<UClass>, FGameDataAssetList> GameDataMap;
 
    UPROPERTY()
    FDataAssetJobManager JobManager;
 
private:
    TMap<FName, FSoftObjectPath> PrimaryAssetNameCache; 
};
 
 
#pragma region Static Template Functions
 
template <typename TData>
TData* UDataAssetManager::GetAssetByType()
{
    const FGameDataAssetList* List = GetInstance().GameDataMap.Find(TData::StaticClass());
 
    if (List == nullptr || List->Assets.IsEmpty())
    {
        return nullptr;
    }
 
    return Cast<TData>(List->Assets[0]);
}
 
 
template <typename TData>
TArray<TData*> UDataAssetManager::GetAllAssetsByType()
{
    TArray<TData*> Result;
 
    const FGameDataAssetList* List = GetInstance().GameDataMap.Find(TData::StaticClass());
 
    if (List == nullptr)
    {
        return Result;
    }
 
    for (const TObjectPtr<UPrimaryDataAsset>& Asset : List->Assets)
    {
        if (TData* Typed = Cast<TData>(Asset))
        {
            Result.Add(Typed);
        }
    }
 
    return Result;
}
 
 
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;
}
 
template <typename TData>
void UDataAssetManager::LoadAllPrimaryAssetsAsyncInPath(const FString& FolderPath, FAsyncBatchLoadCompletedDelegate CompletedDelegate)
{
    static_assert(TIsDerivedFrom<TData, UPrimaryDataAsset>::Value, "TData must derive from UPrimaryDataAsset");
 
    if (CompletedDelegate.IsBound() == false)
    {
        LOG_WARNING(LogCKAsset, "완료 델리게이트가 바인딩되지 않아, 로드된 에셋을 받을 수 없습니다.");
        return;
    }
 
    UDataAssetManager& Instance = GetInstance();
 
    const FPrimaryAssetType AssetType = GetDefault<TData>()->GetPrimaryAssetId().PrimaryAssetType;
 
    TArray<FPrimaryAssetId> Ids;
    Instance.GetPrimaryAssetIdList(AssetType, Ids);
 
    TArray<FSoftObjectPath> PathsToLoad;
 
    for (const FPrimaryAssetId& Id : Ids)
    {
        FAssetData AssetData;
 
        if (Instance.GetPrimaryAssetData(Id, AssetData) == false)
        {
            continue;
        }
 
        if (AssetData.PackagePath.ToString().StartsWith(FolderPath) == false)
        {
            continue;
        }
 
        PathsToLoad.Add(AssetData.ToSoftObjectPath());
    }
 
    if (PathsToLoad.IsEmpty())
    {
        LOG_WARNING(LogCKAsset, "LoadAsyncByTypeAndPath: 경로 '%s'에서 로드할 에셋이 없습니다.", *FolderPath);
 
        if (CompletedDelegate.IsBound())
        {
            CompletedDelegate.Execute({});
        }
        
        return;
    }
 
    auto LoadCompletedLambda = FStreamableDelegate::CreateLambda([PathsToLoad, CompletedDelegate]
    {
        TArray<UObject*> LoadedAssets;
        LoadedAssets.Reserve(PathsToLoad.Num());
 
        for (const FSoftObjectPath& Path : PathsToLoad)
        {
            UObject* ResolveObject = Path.ResolveObject();
            ensureMsgf(ResolveObject, TEXT("'%s'에서 로드한 에셋이 Nullptr 입니다."), *Path.ToString());
            LoadedAssets.Add(ResolveObject);
        }
 
        CompletedDelegate.Execute(LoadedAssets);
    });
 
    FStreamableManager& Manager = Instance.GetStreamableManager();
    Manager.RequestAsyncLoad(PathsToLoad, LoadCompletedLambda);
}
 
#pragma endregion