DataBundleRegistry.h

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

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "GameplayTagContainer.h"
#include "Engine/StreamableManager.h"
#include "DataBundleDefinition.h"
#include "CK_UE.h"
#include "DataBundleRegistry.generated.h"
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnBundleStateChanged, FGameplayTag /*BundleTag*/);
 
 
UENUM(BlueprintType)
enum class EDataBundleState : uint8
{
    Unloaded UMETA(DisplayName = "언로드됨"),
    Loading UMETA(DisplayName = "로딩 중"),
    Loaded UMETA(DisplayName = "로드됨"),
};
 
 
UCLASS()
class CK_UE_API UDataBundleRegistry : public UGameInstanceSubsystem
{
    GENERATED_BODY()
 
public:
    virtual void Initialize(FSubsystemCollectionBase& Collection) override;
 
    virtual void Deinitialize() override;
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    static UDataBundleRegistry* Get();
 
public:
    void RequestLoad(FGameplayTag BundleTag, TFunction<void(UDataBundleDefinition*)> OnReady = nullptr);
 
    void RequestLoad(const FGameplayTagContainer& BundleTags, TFunction<void(TArray<UDataBundleDefinition*>)> OnAllReady);
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    void Release(FGameplayTag BundleTag);
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    void ForceRelease(FGameplayTag BundleTag);
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    EDataBundleState GetState(FGameplayTag BundleTag) const;
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    bool IsLoaded(FGameplayTag BundleTag) const;
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    TArray<FGameplayTag> GetLoadedBundleTags() const;
 
    void ReleaseUnusedBundles(const FGameplayTagContainer& RequiredTags);
 
    template <typename T>
    T* GetBundleAsset(FGameplayTag BundleTag, const TSoftObjectPtr<T>& AssetPtr) const;
 
    template <typename T>
    void RequestBundleAsset(FGameplayTag BundleTag, const TSoftObjectPtr<T>& AssetPtr, TFunction<void(T*)> OnReady);
 
    template <typename T>
    static TArray<T*> GetBundleAssetsOfType(const UDataBundleDefinition* BundleDef);
    
    template <typename T>
    static T* GetBundleAssetByTag(FGameplayTag BundleTag);
 
    UFUNCTION(BlueprintCallable, Category = "Bundle")
    static TArray<UDataBundleDefinition*> FindBundleAssetsByTag(FGameplayTag BundleTag);
 
private:
    void ScanAndRegisterBundles();
 
    void PreLoadBundles();
 
    void OnAllDependenciesReady(FGameplayTag BundleTag);
 
    void OnAssetsLoaded(FGameplayTag BundleTag);
 
    void FlushPendingCallbacks(FGameplayTag BundleTag);
 
    void NotifyBundleLoadedToAssets(const TArray<UObject*>& Assets, FGameplayTag BundleTag);
    void NotifyBundleReleasedToAssets(const TArray<UObject*>& Assets, FGameplayTag BundleTag);
 
private:
    struct FBundleEntry
    {
        TSharedPtr<FStreamableHandle> Handle;
 
        EDataBundleState State = EDataBundleState::Unloaded;
 
        TArray<TFunction<void(UDataBundleDefinition*)>> PendingCallbacks;
    };
 
    UPROPERTY(Transient)
    TMap<FGameplayTag, TObjectPtr<UDataBundleDefinition>> Definitions;
 
    TMap<FGameplayTag, FBundleEntry> Entries;
 
    static UDataBundleRegistry* Instance;
};
 
 
#pragma region Template Implementations
 
template <typename T>
T* UDataBundleRegistry::GetBundleAsset(FGameplayTag BundleTag, const TSoftObjectPtr<T>& AssetPtr) const
{
    if (IsLoaded(BundleTag) == false)
    {
        LOG_WARNING(LogCKAsset, "번들 '%s'이 로드되지 않은 상태에서 GetBundleAsset 호출됨.", *BundleTag.ToString());
        return nullptr;
    }
 
    T* Asset = AssetPtr.Get();
 
    if (Asset == nullptr)
    {
        LOG_WARNING(LogCKAsset, "번들 '%s'의 에셋 '%s'이 메모리에 없습니다.", *BundleTag.ToString(), *AssetPtr.ToString());
    }
 
    return Asset;
}
 
 
template <typename T>
TArray<T*> UDataBundleRegistry::GetBundleAssetsOfType(const UDataBundleDefinition* BundleDef)
{
    TArray<T*> Result;
 
    if (BundleDef == nullptr)
    {
        return Result;
    }
 
    for (const TSoftObjectPtr<IDataAssetBundle>& SoftAsset : BundleDef->Assets)
    {
        UObject* Obj = SoftAsset.ToSoftObjectPath().ResolveObject();
 
        if (T* TypedAsset = Cast<T>(Obj))
        {
            Result.Add(TypedAsset);
        }
    }
 
    return Result;
}
 
 
template <typename T>
T* UDataBundleRegistry::GetBundleAssetByTag(FGameplayTag BundleTag)
{
    for (UDataBundleDefinition* BundleDef : FindBundleAssetsByTag(BundleTag))
    {
        TArray<T*> Found = UDataBundleRegistry::GetBundleAssetsOfType<T>(BundleDef);
 
        if (Found.IsEmpty())
        {
            continue;
        }
 
        return Found[0];
    }
 
    return nullptr;
}
 
 
template <typename T>
void UDataBundleRegistry::RequestBundleAsset(FGameplayTag BundleTag, const TSoftObjectPtr<T>& AssetPtr, TFunction<void(T*)> OnReady)
{
    TSoftObjectPtr<T> AssetCapture = AssetPtr;
 
    RequestLoad(BundleTag, [this, BundleTag, AssetCapture, OnReady = MoveTemp(OnReady)]()
    {
        T* Asset = AssetCapture.Get();
 
        if (Asset == nullptr)
        {
            LOG_WARNING(LogCKAsset, "RequestBundleAsset: 번들 '%s' 로드 완료 후에도 에셋을 찾을 수 없습니다: %s", *BundleTag.ToString(), *AssetCapture.ToString());
        }
 
        if (OnReady)
        {
            OnReady(Asset);
        }
    });
}
 
#pragma endregion