#include <DataAssetManager.h>

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

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

Public 멤버 함수
	UDataAssetManager ()

virtual void	StartInitialLoading () override

template<typename GameDataClass >
const GameDataClass &	GetOrLoadTypedGameData (const TSoftObjectPtr< GameDataClass > &DataPath)

template<typename GameDataClass >
TArray< const GameDataClass * >	GetAllTypedGameData () const

정적 Public 멤버 함수
static UDataAssetManager &	GetInstance ()
	UDataAssetManager 싱글턴 인스턴스를 반환합니다.

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())
	지정한 폴더 경로에서 TData 타입의 에셋을 비동기로 일괄 로드합니다.

static void	LoadAsyncByPath (const FSoftObjectPath &AssetPath, FAsyncLoadCompletedDelegate CompletedDelegate=FAsyncLoadCompletedDelegate())
	소프트 오브젝트 경로로 에셋을 비동기 로드합니다.

static void	LoadAsyncByName (const FName &AssetName, FAsyncLoadCompletedDelegate CompletedDelegate=FAsyncLoadCompletedDelegate())
	Primary Asset 이름으로 에셋을 비동기 로드합니다.

static UObject *	SynchronousLoadAsset (const FSoftObjectPath &AssetPath)
	소프트 오브젝트 경로로 에셋을 동기 로드합니다.

Protected 멤버 함수
template<typename TData >
const TData &	GetOrLoadTypedGameData (const TSoftObjectPtr< TData > &DataPath)

template<typename TData >
TArray< const TData * >	GetAllTypedGameData () const

void	OnUpdateLoadPercentage (float Percentage)

virtual void	TryCreateLoadJobForDataAsset (TSoftObjectPtr< UPrimaryDataAsset > DataPath, FString JobName)

UPrimaryDataAsset *	LoadGameDataOfClass (TSubclassOf< UPrimaryDataAsset > DataClass, const TSoftObjectPtr< UPrimaryDataAsset > &DataClassPath, FPrimaryAssetType PrimaryAssetType)
	지정한 클래스 타입의 게임 데이터 에셋을 동기 로드하고 GameDataMap에 등록합니다.

Protected 속성
TSoftObjectPtr< IDataAssetBundle >	InitialBundlePath

TMap< TObjectPtr< UClass >, FGameDataAssetList >	GameDataMap

FDataAssetJobManager	JobManager

Private 속성
TMap< FName, FSoftObjectPath >	PrimaryAssetNameCache

생성자 & 소멸자 문서화

◆ UDataAssetManager()

UDataAssetManager::UDataAssetManager ( )

{
    InitialBundlePath = GetEnvironmentSoftPtrByKey<UPrimaryDataAsset>(TEXT("InitialBundle"));
}

멤버 함수 문서화

◆ GetAllAssetsByType()

template<typename TData >

TArray< TData * > UDataAssetManager::GetAllAssetsByType ( )

static

GameDataMap에서 TData 타입의 모든 에셋을 반환합니다.

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

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

◆ GetAllTypedGameData() [1/2]

template<typename TData >

TArray< const TData * > UDataAssetManager::GetAllTypedGameData ( ) const

protected

◆ GetAllTypedGameData() [2/2]

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

◆ GetAssetByType()

template<typename TData >

TData * UDataAssetManager::GetAssetByType ( )

static

GameDataMap에서 TData 타입의 첫 번째 에셋을 반환합니다. 없으면 nullptr.

{
    const FGameDataAssetList* List = GetInstance().GameDataMap.Find(TData::StaticClass());
 
    if (List == nullptr || List->Assets.IsEmpty())
    {
        return nullptr;
    }
 
    return Cast<TData>(List->Assets[0]);
}

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

◆ GetInstance()

UDataAssetManager & UDataAssetManager::GetInstance ( )

static

UDataAssetManager 싱글턴 인스턴스를 반환합니다.

GEngine->AssetManager를 UDataAssetManager로 캐스팅하여 반환합니다. DefaultEngine.ini에 AssetManagerClassName이 올바르게 설정되어 있어야 합니다.

반환값: UDataAssetManager 싱글턴 참조

{
    checkf(GEngine, TEXT("GEngine 이 유효하지 않습니다. "));
    UDataAssetManager* Singleton = Cast<UDataAssetManager>(GEngine->AssetManager);
    checkf(Singleton, TEXT("%s가 에셋 매니저로 설정되어 있지 않습니다."), NAMEOF(UDataAssetManager));
    return *Singleton;
}

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

◆ GetOrLoadTypedGameData() [1/2]

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

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

◆ GetOrLoadTypedGameData() [2/2]

template<typename TData >

const TData & UDataAssetManager::GetOrLoadTypedGameData ( const TSoftObjectPtr< TData > & DataPath )

protected

◆ LoadAllPrimaryAssetsAsyncInPath()

template<typename TData >

void UDataAssetManager::LoadAllPrimaryAssetsAsyncInPath	(	const FString &	FolderPath,
		FAsyncBatchLoadCompletedDelegate	CompletedDelegate = `FAsyncBatchLoadCompletedDelegate()`
	)

static

지정한 폴더 경로에서 TData 타입의 에셋을 비동기로 일괄 로드합니다.

TData::StaticClass()->GetFName()을 PrimaryAssetType으로 사용하여 등록된 ID를 수집하고, FolderPath로 시작하는 PackagePath를 가진 에셋만 필터링합니다. 로드할 에셋이 없으면 빈 배열로 즉시 콜백합니다.

매개변수

FolderPath	필터링할 패키지 경로 (예: "/Game/CK_UE/Core/Data/LevelData")
CompletedDelegate	로드 완료 시 호출될 델리게이트 (로드된 UObject 배열 전달)

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

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

◆ LoadAsyncByName()

void UDataAssetManager::LoadAsyncByName	(	const FName &	AssetName,
		FAsyncLoadCompletedDelegate	CompletedDelegate = `FAsyncLoadCompletedDelegate()`
	)

static

Primary Asset 이름으로 에셋을 비동기 로드합니다.

Asset Manager에 등록된 모든 Primary Asset 중 이름이 일치하는 항목을 탐색한 뒤 LoadAsyncByPath에 위임합니다. 동일한 이름이 여러 타입에 등록된 경우 첫 번째 매칭만 로드됩니다.

매개변수

AssetName	로드할 에셋의 PrimaryAssetName
CompletedDelegate	로드 완료 시 호출될 델리게이트 (에셋 이름, 로드된 UObject 전달)

{
    const FSoftObjectPath* Found = GetInstance().PrimaryAssetNameCache.Find(AssetName);
 
    if (Found == nullptr)
    {
        LOG_WARNING(LogCKAsset, "LoadAsyncByName: '%s' 이름의 Primary Asset을 찾을 수 없습니다.", *AssetName.ToString());
    }
    else
    {
        LoadAsyncByPath(*Found, CompletedDelegate);
    }
}

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

◆ LoadAsyncByPath()

void UDataAssetManager::LoadAsyncByPath	(	const FSoftObjectPath &	AssetPath,
		FAsyncLoadCompletedDelegate	CompletedDelegate = `FAsyncLoadCompletedDelegate()`
	)

static

소프트 오브젝트 경로로 에셋을 비동기 로드합니다.

FStreamableManager::RequestAsyncLoad를 사용하여 메인 스레드를 블로킹하지 않습니다. 로드 완료 시 CompletedDelegate가 게임 스레드에서 호출됩니다.

매개변수

AssetPath	로드할 에셋의 소프트 오브젝트 경로
CompletedDelegate	로드 완료 시 호출될 델리게이트 (에셋 이름, 로드된 UObject 전달)

{
    if (AssetPath.IsValid() == false)
    {
        LOG_WARNING(LogCKAsset, "LoadAsyncByPath 가 유효하지 않은 에셋 경로입니다.");
        return;
    }
 
    FStreamableManager& Manager = GetInstance().GetStreamableManager();
 
    auto LoadCompletedLambda = FStreamableDelegate::CreateLambda([AssetPath, CompletedDelegate]()
    {
        if (CompletedDelegate.IsBound() == false)
        {
            return;
        }
 
        CompletedDelegate.Execute(AssetPath.GetAssetFName(), AssetPath.ResolveObject());
    });
 
    Manager.RequestAsyncLoad(AssetPath, LoadCompletedLambda);
}

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

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

◆ LoadGameDataOfClass()

UPrimaryDataAsset * UDataAssetManager::LoadGameDataOfClass	(	TSubclassOf< UPrimaryDataAsset >	DataClass,
		const TSoftObjectPtr< UPrimaryDataAsset > &	DataClassPath,
		FPrimaryAssetType	PrimaryAssetType
	)

protected

지정한 클래스 타입의 게임 데이터 에셋을 동기 로드하고 GameDataMap에 등록합니다.

에디터 환경에서는 LoadSynchronous()를 사용하고, 런타임에서는 LoadPrimaryAssetsWithType()으로 스트리밍 후 WaitUntilComplete()로 대기합니다.

매개변수

DataClass	로드할 게임 데이터의 UClass
DataClassPath	로드할 에셋의 소프트 오브젝트 포인터
PrimaryAssetType	Asset Manager에 등록된 Primary Asset 타입

반환값: 로드된 UPrimaryDataAsset 포인터. 실패 시 nullptr

{
    UPrimaryDataAsset* Asset = nullptr;
    DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading GameData Object"), STAT_GameData, STATGROUP_LoadTime);
 
    if (DataClassPath.IsNull())
    {
        return Asset;
    }
 
#if WITH_EDITOR
    FText Message = FText::Format(NSLOCTEXT("PlaybackEditor", "BeginLoadingGameDataTask", "Loading GameData {0}"), FText::FromName(DataClass->GetFName()));
    FScopedSlowTask SlowTask(0, Message);
    SlowTask.MakeDialog(false, true);
#endif
 
    LOG_INFO(LogCKAsset, "게임 데이터 로드 중: %s ...", *DataClassPath.ToString());
    SCOPE_LOG_TIME_IN_SECONDS(TEXT(" ... GameData loaded!"), nullptr);
 
    TSharedPtr<FStreamableHandle> Handle = LoadPrimaryAssetsWithType(PrimaryAssetType);
 
    if (Handle.IsValid())
    {
        Handle->WaitUntilComplete(0.0f, false);
        Asset = Cast<UPrimaryDataAsset>(Handle->GetLoadedAsset());
    }
 
    // Handle이 null인 경우(에디터에서 이미 로드된 에셋 등) Get() 으로 폴백
    if (Asset == nullptr)
    {
        Asset = DataClassPath.Get();
    }
 
    if (Asset)
    {
        GameDataMap.FindOrAdd(DataClass).Assets.Add(Asset);
    }
 
    return Asset;
}

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

◆ OnUpdateLoadPercentage()

void UDataAssetManager::OnUpdateLoadPercentage ( float Percentage )

protected

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

◆ StartInitialLoading()

void UDataAssetManager::StartInitialLoading ( )

overridevirtual

{
    Super::StartInitialLoading();
 
    LOG_INFO(LogCKAsset, "기본 Primary 데이터 로드를 시작합니다. ");
 
    TArray<FPrimaryAssetId> AllIds;
    GetPrimaryAssetIdList(FPrimaryAssetType(), AllIds);
    PrimaryAssetNameCache.Reserve(AllIds.Num());
 
 
    Algo::ForEach(AllIds, [this](const FPrimaryAssetId& Id)
    {
        LOG_INFO(LogCKAsset, "%s 에셋을 등록합니다. ", *Id.PrimaryAssetName.ToString());
 
        //AllIds는 유효한 ID만 담고 있으므로 GetPrimaryAssetPath이 실패할 일이 없음.
        PrimaryAssetNameCache.Add(Id.PrimaryAssetName, GetPrimaryAssetPath(Id));
    });
 
 
    if (InitialBundlePath.IsNull())
    {
        return;
    }
 
    LOG_INFO(LogCKAsset, "데이터 로드를 시작합니다. ");
    
    
    TryCreateLoadJobForDataAsset(InitialBundlePath, TEXT("LoadGameData"));
 
    DataAssetLoadJobProgress Progress;
    Progress.BindUObject(this, &UDataAssetManager::OnUpdateLoadPercentage);
 
    if (Progress.IsBound() == false)
    {
        LOG_ERROR(LogCKAsset, "OnUpdateLoadPercentage 함수 등록에 실패했습니다.");
        return;
    }
 
    JobManager.RunAllJobs(Progress, [this](const float ElapsedTime)
    {
        LOG_INFO(LogCKAsset, "모든 시작 작업이 %.2f초 만에 완료되었습니다", ElapsedTime);
    });
}

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

◆ SynchronousLoadAsset()

UObject * UDataAssetManager::SynchronousLoadAsset ( const FSoftObjectPath & AssetPath )

static

소프트 오브젝트 경로로 에셋을 동기 로드합니다.

Asset Manager가 초기화된 경우 StreamableManager를 통해 로드하고, 그렇지 않은 경우 TryLoad()로 폴백합니다.

매개변수

AssetPath 로드할 에셋의 소프트 오브젝트 경로

반환값: 로드된 UObject 포인터. 경로가 유효하지 않으면 nullptr

{
    if (AssetPath.IsValid() == false)
    {
        return nullptr;
    }
 
    if (IsInitialized())
    {
        return GetStreamableManager().LoadSynchronous(AssetPath, false);
    }
    else
    {
        return AssetPath.TryLoad();
    }
}

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

◆ TryCreateLoadJobForDataAsset()

void UDataAssetManager::TryCreateLoadJobForDataAsset	(	TSoftObjectPtr< UPrimaryDataAsset >	DataPath,
		FString	JobName
	)

protectedvirtual

{
    if (DataPath.IsNull() || JobName.IsEmpty())
    {
        LOG_ERROR(LogCKAsset, "유효하지 않은 데이터 경로 또는 이미 로드된 데이터입니다: %s", *DataPath.ToString());
        return;
    }
 
    auto LoadJobLambda = [this, DataPath](const auto _, const auto __)
    {
        UObject* Loaded = SynchronousLoadAsset(DataPath.ToSoftObjectPath());
        UPrimaryDataAsset* Asset = Cast<UPrimaryDataAsset>(Loaded);
 
        if (Asset == nullptr)
        {
            LOG_ERROR(LogCKAsset, "초기화 데이터 에셋 로드 실패: %s", *DataPath.ToString());
            return;
        }
 
        if (Asset->Implements<UDataAssetBundle>() == false)
        {
            LOG_WARNING(LogCKAsset, "IDataAssetBundle을 구현하지 않은 에셋은 로드할 수 없습니다: %s", *DataPath.ToString());
            return;
        }
 
        GameDataMap.FindOrAdd(Asset->GetClass()).Assets.Add(Asset);
    };
 
    JobManager.CreateAndAddNewJob(JobName, 25.0f, LoadJobLambda);
}

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

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

멤버 데이터 문서화

◆ GameDataMap

TMap<TObjectPtr<UClass>, FGameDataAssetList> UDataAssetManager::GameDataMap

protected

◆ InitialBundlePath

TSoftObjectPtr<IDataAssetBundle> UDataAssetManager::InitialBundlePath

protected

◆ JobManager

FDataAssetJobManager UDataAssetManager::JobManager

protected

◆ PrimaryAssetNameCache

TMap<FName, FSoftObjectPath> UDataAssetManager::PrimaryAssetNameCache

private

StartInitialLoading에서 구축되는 이름 → 경로 캐시. LoadAsyncByName O(1) 조회에 사용됩니다.

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

Source/CK_UE/Data/Asset/DataAssetManager.h
Source/CK_UE/Data/Asset/DataAssetManager.cpp

Public 멤버 함수

정적 Public 멤버 함수

Protected 멤버 함수

Protected 속성

Private 속성

생성자 & 소멸자 문서화

◆ UDataAssetManager()

멤버 함수 문서화

◆ GetAllAssetsByType()

◆ GetAllTypedGameData() [1/2]

◆ GetAllTypedGameData() [2/2]

◆ GetAssetByType()

◆ GetInstance()

◆ GetOrLoadTypedGameData() [1/2]

◆ GetOrLoadTypedGameData() [2/2]

◆ LoadAllPrimaryAssetsAsyncInPath()

◆ LoadAsyncByName()

◆ LoadAsyncByPath()

◆ LoadGameDataOfClass()

◆ OnUpdateLoadPercentage()

◆ StartInitialLoading()

◆ SynchronousLoadAsset()

◆ TryCreateLoadJobForDataAsset()

멤버 데이터 문서화

◆ GameDataMap

◆ InitialBundlePath

◆ JobManager

◆ PrimaryAssetNameCache