UDataBundleRegistry 클래스 참조

DataBundle의 로드/언로드를 관리하는 GameInstance 서브시스템. 더 자세히 ...

#include <DataBundleRegistry.h>

UDataBundleRegistry에 대한 상속 다이어그램 :

UDataBundleRegistry에 대한 협력 다이어그램:

클래스
struct	FBundleEntry
	번들 하나의 런타임 상태를 담는 구조체. 더 자세히 ...

Public 멤버 함수
virtual void	Initialize (FSubsystemCollectionBase &Collection) override
	서브시스템 초기화. 번들 스캔 및 PreLoad 정책 번들 로드를 수행합니다.
virtual void	Deinitialize () override
	서브시스템 종료. 모든 StreamableHandle을 해제하고 상태를 정리합니다.
void	RequestLoad (FGameplayTag BundleTag, TFunction< void(UDataBundleDefinition *)> OnReady=nullptr)
	번들을 비동기 로드합니다. 로드 완료 시 OnReady 콜백을 호출합니다.
void	RequestLoad (const FGameplayTagContainer &BundleTags, TFunction< void(TArray< UDataBundleDefinition * >)> OnAllReady)
	여러 번들을 비동기 로드합니다. 모든 번들 로드 완료 시 OnAllReady 콜백을 호출합니다.
void	Release (FGameplayTag BundleTag)
	번들을 언로드합니다 (bPersistent 번들 제외).
void	ForceRelease (FGameplayTag BundleTag)
	bPersistent 여부와 관계없이 번들을 강제 언로드합니다.
EDataBundleState	GetState (FGameplayTag BundleTag) const
	번들의 현재 로드 상태를 반환합니다.
bool	IsLoaded (FGameplayTag BundleTag) const
	번들이 로드 완료 상태인지 여부를 반환합니다.
TArray< FGameplayTag >	GetLoadedBundleTags () const
	현재 로드 완료 상태인 모든 번들의 태그 목록을 반환합니다.
void	ReleaseUnusedBundles (const FGameplayTagContainer &RequiredTags)
	로드된 번들 중 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)
	번들을 비동기 로드한 뒤 에셋 포인터를 콜백으로 전달합니다.

정적 Public 멤버 함수
static UDataBundleRegistry *	Get ()
	싱글톤 인스턴스를 반환합니다. 서브시스템이 초기화되지 않은 경우 nullptr을 반환합니다.
template<typename T >
static TArray< T * >	GetBundleAssetsOfType (const UDataBundleDefinition *BundleDef)
	번들 정의에 포함된 에셋 중 특정 타입에 해당하는 목록을 반환합니다.
template<typename T >
static T *	GetBundleAssetByTag (FGameplayTag BundleTag)
static TArray< UDataBundleDefinition * >	FindBundleAssetsByTag (FGameplayTag BundleTag)
	주어진 태그와 매칭되는 번들 정의 목록을 반환합니다.

Private 멤버 함수
void	ScanAndRegisterBundles ()
	AssetManager에서 DataBundle 타입 에셋을 스캔해 Definitions에 등록합니다.
void	PreLoadBundles ()
	LoadPolicy가 PreLoad인 번들을 게임 시작 시 자동 로드합니다.
void	OnAllDependenciesReady (FGameplayTag BundleTag)
	의존 번들이 모두 로드됐을 때 호출됩니다. 본 번들의 에셋 스트리밍을 시작합니다.
void	OnAssetsLoaded (FGameplayTag BundleTag)
	에셋 스트리밍 완료 시 호출됩니다. 상태를 Loaded로 전환하고 콜백을 실행합니다.
void	FlushPendingCallbacks (FGameplayTag BundleTag)
	누적된 PendingCallbacks를 모두 실행하고 큐를 비웁니다.
void	NotifyBundleLoadedToAssets (const TArray< UObject * > &Assets, FGameplayTag BundleTag)
void	NotifyBundleReleasedToAssets (const TArray< UObject * > &Assets, FGameplayTag BundleTag)

Private 속성
TMap< FGameplayTag, TObjectPtr< UDataBundleDefinition > >	Definitions
	번들 태그 → 정의 에셋 맵. UPROPERTY로 GC를 방지합니다.
TMap< FGameplayTag, FBundleEntry >	Entries
	번들 태그 → 런타임 상태 맵.

정적 Private 속성
static UDataBundleRegistry *	Instance = nullptr
	싱글톤 인스턴스.

상세한 설명

DataBundle의 로드/언로드를 관리하는 GameInstance 서브시스템.

특징:

• 이미 로드된 번들에 RequestLoad 시 콜백만 즉시 실행 (중복 로드 없음)
• 로딩 중 중복 요청: 콜백만 큐에 추가, 로드 완료 시 일괄 실행
• 로드할 번들은 ULevelStreamingData::UsingBundlesTag로 지정

DefaultGame.ini에 DataBundle PrimaryAssetType 등록 필요 (DataBundleDefinition.h 참조)

멤버 함수 문서화

Deinitialize()

void UDataBundleRegistry::Deinitialize ( )

overridevirtual

서브시스템 종료. 모든 StreamableHandle을 해제하고 상태를 정리합니다.

{
    // 살아있는 모든 StreamableHandle을 명시적으로 해제하여 에셋 언로드를 유도
    for (auto& [Tag, Entry] : Entries)
    {
        if (Entry.Handle.IsValid())
        {
            Entry.Handle->ReleaseHandle();
        }
    }
 
    Entries.Empty();
    Definitions.Empty();
    Instance = nullptr;
 
    Super::Deinitialize();
}

FindBundleAssetsByTag()

TArray< UDataBundleDefinition * > UDataBundleRegistry::FindBundleAssetsByTag ( FGameplayTag  BundleTag )

static

주어진 태그와 매칭되는 번들 정의 목록을 반환합니다.

FGameplayTag::MatchesTag 기준으로 비교하므로 부모 태그를 전달하면 하위 태그를 가진 번들들이 모두 포함됩니다. (예: "Bundle.Level" 전달 시 "Bundle.Level.Forest" 번들도 반환)

매개변수

BundleTag

필터링 기준이 될 GameplayTag.

반환값

매칭되는 UDataBundleDefinition 배열.

{
    TArray<UDataBundleDefinition*> Result;
 
    if (Instance == nullptr)
    {
        return Result;
    }
 
    for (const auto& [Tag, Def] : Instance->Definitions)
    {
        if (Tag.MatchesTag(BundleTag))
        {
            Result.Add(Def);
        }
    }
 
    return Result;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FlushPendingCallbacks()

void UDataBundleRegistry::FlushPendingCallbacks ( FGameplayTag  BundleTag )

private

누적된 PendingCallbacks를 모두 실행하고 큐를 비웁니다.

매개변수

BundleTag

콜백을 실행할 번들의 GameplayTag.

{
    FBundleEntry* Entry = Entries.Find(BundleTag);
 
    if (Entry == nullptr)
    {
        return;
    }
 
    UDataBundleDefinition* Def = Definitions.FindRef(BundleTag);
 
    // MoveTemp으로 콜백 목록을 이관한 뒤 실행 — 콜백 내부에서 새 콜백이 추가돼도 안전
    TArray<TFunction<void(UDataBundleDefinition*)>> Callbacks = MoveTemp(Entry->PendingCallbacks);
 
    for (auto& CallbackFunc : Callbacks)
    {
        if (CallbackFunc)
        {
            CallbackFunc(Def);
        }
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ForceRelease()

void UDataBundleRegistry::ForceRelease

(

FGameplayTag

BundleTag

)

bPersistent 여부와 관계없이 번들을 강제 언로드합니다.

매개변수

BundleTag

해제할 번들의 GameplayTag.

{
    FBundleEntry* Entry = Entries.Find(BundleTag);
 
    if (Entry == nullptr || Entry->State != EDataBundleState::Loaded)
    {
        return;
    }
 
    if (Entry->Handle.IsValid())
    {
        TArray<UObject*> LoadedObjects;
        Entry->Handle->GetLoadedAssets(LoadedObjects);
        NotifyBundleReleasedToAssets(LoadedObjects, BundleTag);
 
        Entry->Handle->ReleaseHandle();
        Entry->Handle.Reset();
    }
 
    Entry->State = EDataBundleState::Unloaded;
 
    LOG_SCREEN("번들 강제 언로드: %s", *BundleTag.ToString());
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

Get()

UDataBundleRegistry * UDataBundleRegistry::Get ( )

static

싱글톤 인스턴스를 반환합니다. 서브시스템이 초기화되지 않은 경우 nullptr을 반환합니다.

{
    return Instance;
}

GetBundleAsset()

template<typename T >

T * UDataBundleRegistry::GetBundleAsset	(	FGameplayTag	BundleTag,
		const TSoftObjectPtr< T > &	AssetPtr
	)		const

로드된 번들에서 특정 에셋을 동기적으로 반환합니다.

번들이 로드되지 않은 경우 nullptr을 반환합니다. 비동기 접근이 필요하면 RequestBundleAsset을 사용하세요.

템플릿 파라메터

T	가져올 에셋의 타입.

매개변수

BundleTag	조회할 번들 태그.
AssetPtr	반환할 에셋의 소프트 포인터.

반환값

번들이 로드 상태면 T*, 아니면 nullptr.

{
    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;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

GetBundleAssetByTag()

template<typename T >

T * UDataBundleRegistry::GetBundleAssetByTag ( FGameplayTag  BundleTag )

static

{
    for (UDataBundleDefinition* BundleDef : FindBundleAssetsByTag(BundleTag))
    {
        TArray<T*> Found = UDataBundleRegistry::GetBundleAssetsOfType<T>(BundleDef);
 
        if (Found.IsEmpty())
        {
            continue;
        }
 
        return Found[0];
    }
 
    return nullptr;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

GetBundleAssetsOfType()

template<typename T >

TArray< T * > UDataBundleRegistry::GetBundleAssetsOfType ( const UDataBundleDefinition *  BundleDef )

static

번들 정의에 포함된 에셋 중 특정 타입에 해당하는 목록을 반환합니다.

번들이 로드된 상태에서 전달받은 정의 에셋의 Assets를 순회하며 T* 로 캐스팅 가능한 것만 반환합니다. 에셋이 메모리에 없으면 해당 항목은 건너뜁니다.

템플릿 파라메터

T	필터링할 에셋 타입.

매개변수

BundleDef

조회할 번들 정의 에셋.

반환값

T* 타입으로 캐스팅 가능한 에셋 배열.

{
    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;
}

GetLoadedBundleTags()

TArray< FGameplayTag > UDataBundleRegistry::GetLoadedBundleTags

(

)

const

현재 로드 완료 상태인 모든 번들의 태그 목록을 반환합니다.

반환값

Loaded 상태인 번들 태그 배열.

{
    TArray<FGameplayTag> Result;
 
    for (const auto& [Tag, Entry] : Entries)
    {
        if (Entry.State == EDataBundleState::Loaded)
        {
            Result.Add(Tag);
        }
    }
 
    return Result;
}

GetState()

EDataBundleState UDataBundleRegistry::GetState

(

FGameplayTag

BundleTag

)

const

번들의 현재 로드 상태를 반환합니다.

매개변수

BundleTag

조회할 번들의 GameplayTag.

반환값

해당 번들의 EDataBundleState. 등록되지 않은 경우 Unloaded 반환.

{
    if (const FBundleEntry* Entry = Entries.Find(BundleTag))
    {
        return Entry->State;
    }
    else
    {
        return EDataBundleState::Unloaded;
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

Initialize()

void UDataBundleRegistry::Initialize ( FSubsystemCollectionBase &  Collection )

overridevirtual

서브시스템 초기화. 번들 스캔 및 PreLoad 정책 번들 로드를 수행합니다.

{
    Super::Initialize(Collection);
    Instance = this;
    ScanAndRegisterBundles();
    PreLoadBundles();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

IsLoaded()

bool UDataBundleRegistry::IsLoaded

(

FGameplayTag

BundleTag

)

const

번들이 로드 완료 상태인지 여부를 반환합니다.

매개변수

BundleTag

조회할 번들의 GameplayTag.

반환값

로드 완료 상태이면 true.

{
    if (GetState(BundleTag) == EDataBundleState::Loaded)
    {
        return true;
    }
    else
    {
        return false;
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

NotifyBundleLoadedToAssets()

void UDataBundleRegistry::NotifyBundleLoadedToAssets ( const TArray< UObject * > &  Assets, FGameplayTag  BundleTag  )

private

{
    for (UObject* Asset : Assets)
    {
        if (Asset && Asset->Implements<UDataAssetBundle>())
        {
            IDataAssetBundle::Execute_OnBundleLoaded(Asset, BundleTag);
        }
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

NotifyBundleReleasedToAssets()

void UDataBundleRegistry::NotifyBundleReleasedToAssets ( const TArray< UObject * > &  Assets, FGameplayTag  BundleTag  )

private

{
    for (UObject* Asset : Assets)
    {
        if (Asset && Asset->Implements<UDataAssetBundle>())
        {
            IDataAssetBundle::Execute_OnBundleReleased(Asset, BundleTag);
        }
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

OnAllDependenciesReady()

void UDataBundleRegistry::OnAllDependenciesReady ( FGameplayTag  BundleTag )

private

의존 번들이 모두 로드됐을 때 호출됩니다. 본 번들의 에셋 스트리밍을 시작합니다.

매개변수

BundleTag

에셋 스트리밍을 시작할 번들의 GameplayTag.

{
    UDataBundleDefinition* Def = Definitions.FindRef(BundleTag);
 
    if (Def == nullptr)
    {
        return;
    }
 
    TArray<FSoftObjectPath> AssetPaths = Def->GetAssetPaths();
 
    // 에셋 목록이 비어 있으면 스트리밍 없이 즉시 로드 완료 처리
    if (AssetPaths.IsEmpty())
    {
        OnAssetsLoaded(BundleTag);
        return;
    }
 
    FStreamableManager& Manager = UAssetManager::Get().GetStreamableManager();
 
    auto AssetsLoadedLambda = FStreamableDelegate::CreateWeakLambda(this, [this, BundleTag]()
    {
        OnAssetsLoaded(BundleTag);
    });
 
    TSharedPtr<FStreamableHandle> Handle = Manager.RequestAsyncLoad(AssetPaths, AssetsLoadedLambda);
 
    // Handle을 Entry에 보관해 에셋 수명을 유지하고 이후 명시적 해제에 사용
    if (FBundleEntry* Entry = Entries.Find(BundleTag))
    {
        Entry->Handle = Handle;
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

OnAssetsLoaded()

void UDataBundleRegistry::OnAssetsLoaded ( FGameplayTag  BundleTag )

private

에셋 스트리밍 완료 시 호출됩니다. 상태를 Loaded로 전환하고 콜백을 실행합니다.

로드 완료 전 이미 Release된 경우 bPersistent 여부에 따라 즉시 언로드합니다.

매개변수

BundleTag

로드가 완료된 번들의 GameplayTag.

{
    FBundleEntry* Entry = Entries.Find(BundleTag);
 
    if (Entry == nullptr)
    {
        return;
    }
 
    Entry->State = EDataBundleState::Loaded;
 
    LOG_SCREEN("번들 로드 완료: %s", *BundleTag.ToString());
 
    if (Entry->Handle.IsValid())
    {
        TArray<UObject*> LoadedObjects;
        Entry->Handle->GetLoadedAssets(LoadedObjects);
        NotifyBundleLoadedToAssets(LoadedObjects, BundleTag);
    }
 
    FlushPendingCallbacks(BundleTag);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

PreLoadBundles()

void UDataBundleRegistry::PreLoadBundles ( )

private

LoadPolicy가 PreLoad인 번들을 게임 시작 시 자동 로드합니다.

{
    int32 PreLoadCount = 0;
 
    for (const auto& [Tag, Def] : Definitions)
    {
        if (Def == nullptr)
        {
            continue;
        }
 
        // PreLoad 정책이 아닌 번들은 명시적 RequestLoad 호출 시에만 로드
        if (Def->LoadPolicy != EBundleLoadPolicy::PreLoad)
        {
            continue;
        }
 
        RequestLoad(Tag);
        PreLoadCount++;
 
        LOG_INFO(LogCKAsset, "번들 PreLoad 요청: %s", *Tag.ToString());
    }
 
    LOG_INFO(LogCKAsset, "PreLoad 정책 번들 %d개 로드 요청 완료", PreLoadCount);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

Release()

void UDataBundleRegistry::Release

(

FGameplayTag

BundleTag

)

번들을 언로드합니다 (bPersistent 번들 제외).

매개변수

BundleTag

해제할 번들의 GameplayTag.

{
    FBundleEntry* Entry = Entries.Find(BundleTag);
 
    if (Entry == nullptr || Entry->State != EDataBundleState::Loaded)
    {
        return;
    }
 
    UDataBundleDefinition* Def = Definitions.FindRef(BundleTag);
 
    if (Def && Def->bPersistent)
    {
        return;
    }
 
    if (Entry->Handle.IsValid())
    {
        TArray<UObject*> LoadedObjects;
        Entry->Handle->GetLoadedAssets(LoadedObjects);
        NotifyBundleReleasedToAssets(LoadedObjects, BundleTag);
 
        Entry->Handle->ReleaseHandle();
        Entry->Handle.Reset();
    }
 
    Entry->State = EDataBundleState::Unloaded;
 
    LOG_SCREEN("번들 언로드: %s", *BundleTag.ToString());
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

ReleaseUnusedBundles()

void UDataBundleRegistry::ReleaseUnusedBundles

(

const FGameplayTagContainer &

RequiredTags

)

로드된 번들 중 RequiredTags에 없는 번들을 해제합니다.

bPersistent 번들은 건너뜁니다.

매개변수

RequiredTags

유지할 번들 태그 목록.

{
    // Release 호출이 Entries를 수정하므로 태그를 먼저 수집
    TArray<FGameplayTag> TagsToRelease;
 
    for (const auto& [Tag, Entry] : Entries)
    {
        if (Entry.State != EDataBundleState::Loaded)
        {
            continue;
        }
 
        if (RequiredTags.HasTagExact(Tag))
        {
            continue;
        }
 
        UDataBundleDefinition* Def = Definitions.FindRef(Tag);
 
        if (Def && Def->bPersistent)
        {
            continue;
        }
 
        TagsToRelease.Add(Tag);
    }
 
    LOG_INFO(LogCKAsset, "[ReleaseUnused] 해제 대상: %d개", TagsToRelease.Num());
 
    for (const FGameplayTag& Tag : TagsToRelease)
    {
        Release(Tag);
    }
}

RequestBundleAsset()

template<typename T >

void UDataBundleRegistry::RequestBundleAsset	(	FGameplayTag	BundleTag,
		const TSoftObjectPtr< T > &	AssetPtr,
		TFunction< void(T *)>	OnReady
	)

번들을 비동기 로드한 뒤 에셋 포인터를 콜백으로 전달합니다.

번들이 이미 로드된 경우 콜백이 즉시 실행됩니다.

템플릿 파라메터

T	가져올 에셋의 타입.

매개변수

BundleTag	로드할 번들 태그.
AssetPtr	요청할 에셋의 소프트 포인터.
OnReady	로드 완료 시 호출될 콜백 (T* 인자).

{
    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);
        }
    });
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

RequestLoad() [1/2]

void UDataBundleRegistry::RequestLoad	(	const FGameplayTagContainer &	BundleTags,
		TFunction< void(TArray< UDataBundleDefinition * >)>	OnAllReady
	)

여러 번들을 비동기 로드합니다. 모든 번들 로드 완료 시 OnAllReady 콜백을 호출합니다.

빈 배열이 전달되면 OnAllReady가 즉시 호출됩니다.

매개변수

BundleTags	로드할 번들 태그 목록.
OnAllReady	모든 번들 로드 완료 시 실행할 콜백 (로드된 번들 정의 배열).

{
    bool bEarlyExit = false;
 
    if (BundleTags.IsEmpty() && OnAllReady)
    {
        OnAllReady({});
        bEarlyExit = true;
    }
 
    if (bEarlyExit)
    {
        return;
    }
 
    auto SharedCallback = MakeShared<TFunction<void(TArray<UDataBundleDefinition*>)>>(MoveTemp(OnAllReady));
    TSharedRef<int32> PendingCount = MakeShared<int32>(BundleTags.Num());
    TSharedRef<TArray<UDataBundleDefinition*>> AllDefs = MakeShared<TArray<UDataBundleDefinition*>>();
 
    auto OnReady = [PendingCount, SharedCallback, AllDefs](UDataBundleDefinition* Def)
    {
        AllDefs->Add(Def);
 
        if (--(*PendingCount) > 0)
        {
            return;
        }
 
        if (*SharedCallback)
        {
            (*SharedCallback)(*AllDefs);
        }
    };
 
    for (const FGameplayTag& Tag : BundleTags)
    {
        RequestLoad(Tag, OnReady);
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

RequestLoad() [2/2]

void UDataBundleRegistry::RequestLoad	(	FGameplayTag	BundleTag,
		TFunction< void(UDataBundleDefinition *)>	OnReady = nullptr
	)

번들을 비동기 로드합니다. 로드 완료 시 OnReady 콜백을 호출합니다.

매개변수

BundleTag	로드할 번들의 GameplayTag.
OnReady	번들 로드 완료 시 실행할 콜백.

{
    if (Definitions.Contains(BundleTag) == false)
    {
        LOG_ERROR(LogCKAsset, "등록되지 않은 번들: %s", *BundleTag.ToString());
        
        if (OnReady)
        {
            OnReady(nullptr);
        }
        
        return;
    }
    
    FBundleEntry& Entry = Entries.FindOrAdd(BundleTag);
 
    switch (Entry.State)
    {
        // 로딩되지 않음: 완료 시 실행되도록 큐에 추가하고 로딩 시작.
        case EDataBundleState::Unloaded:
        {
            Entry.State = EDataBundleState::Loading;
            if (OnReady)
            {
                Entry.PendingCallbacks.Add(MoveTemp(OnReady));
            }
            OnAllDependenciesReady(BundleTag);
            break;
        }
 
        // 로딩 진행 중: 완료 시 실행되도록 큐에 추가
        case EDataBundleState::Loading:
        {
            if (OnReady)
            {
                Entry.PendingCallbacks.Add(MoveTemp(OnReady));
            }
            break;
        }
 
        // 이미 로드됨: 콜백 즉시 실행
        case EDataBundleState::Loaded:
        {
            if (OnReady)
            {
                OnReady(Definitions.FindRef(BundleTag));
            }
            break;
        }
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ScanAndRegisterBundles()

void UDataBundleRegistry::ScanAndRegisterBundles ( )

private

AssetManager에서 DataBundle 타입 에셋을 스캔해 Definitions에 등록합니다.

{
    UAssetManager& AssetManager = UAssetManager::Get();
    TArray<FPrimaryAssetId> BundleIds;
 
    // "DataBundle" PrimaryAssetType으로 등록된 에셋 ID를 모두 수집
    AssetManager.GetPrimaryAssetIdList(FPrimaryAssetType(TEXT("DataBundle")), BundleIds);
 
    for (const FPrimaryAssetId& AssetId : BundleIds)
    {
        // 이미 메모리에 있으면 캐스트, 없으면 동기 로드로 정의 에셋을 확보
        UDataBundleDefinition* Def = Cast<UDataBundleDefinition>(AssetManager.GetPrimaryAssetObject(AssetId));
 
        if (Def == nullptr)
        {
            FSoftObjectPath AssetPath = AssetManager.GetPrimaryAssetPath(AssetId);
            Def = Cast<UDataBundleDefinition>(AssetPath.TryLoad());
        }
 
        if (Def == nullptr)
        {
            LOG_WARNING(LogCKAsset, "DataBundleDefinition 로드 실패: %s", *AssetId.ToString());
            continue;
        }
 
        if (Def->BundleTag.IsValid() == false)
        {
            LOG_WARNING(LogCKAsset, "BundleTag가 유효하지 않습니다: %s", *AssetId.ToString());
            continue;
        }
 
        if (Definitions.Contains(Def->BundleTag))
        {
            LOG_WARNING(LogCKAsset, "중복 BundleTag 감지: %s — 기존 항목을 덮어씁니다.", *Def->BundleTag.ToString());
        }
 
        Definitions.Add(Def->BundleTag, Def);
        Entries.FindOrAdd(Def->BundleTag); // Entry를 미리 생성해 기본 상태로 초기화
 
        LOG_INFO(LogCKAsset, "번들 등록: %s (%d개 에셋)", *Def->BundleTag.ToString(), Def->Assets.Num());
    }
 
    LOG_INFO(LogCKAsset, "총 %d개의 DataBundle 등록 완료", Definitions.Num());
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

Definitions

TMap<FGameplayTag, TObjectPtr<UDataBundleDefinition> > UDataBundleRegistry::Definitions

private

번들 태그 → 정의 에셋 맵. UPROPERTY로 GC를 방지합니다.

Entries

TMap<FGameplayTag, FBundleEntry> UDataBundleRegistry::Entries

private

번들 태그 → 런타임 상태 맵.

Instance

UDataBundleRegistry * UDataBundleRegistry::Instance = nullptr

staticprivate

싱글톤 인스턴스.

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/Data/Bundle/DataBundleRegistry.h
• Source/CK_UE/Data/Bundle/DataBundleRegistry.cpp