UDataAssetManager 클래스 참조

#include <DataAssetManager.h>

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

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

Public 멤버 함수
	UDataAssetManager ()
template<typename AssetType >
AssetType *	GetAsset (const TSoftObjectPtr< AssetType > &AssetPointer, bool bKeepInMemory)
template<typename AssetType >
TSubclassOf< AssetType >	GetSubclass (const TSoftClassPtr< AssetType > &AssetPointer, bool bKeepInMemory)
template<typename GameDataClass >
const GameDataClass &	GetOrLoadTypedGameData (const TSoftObjectPtr< GameDataClass > &DataPath)
template<typename GameDataClass >
TArray< const GameDataClass * >	GetAllTypedGameData () const

정적 Public 멤버 함수
static UDataAssetManager &	GetInstance ()
	UDataAssetManager 싱글턴 인스턴스를 반환합니다.
static void	DumpLoadedAssets ()
	현재 GC 방지 풀에 등록된 모든 에셋 정보를 로그로 출력합니다.
static void	RegisterBundleAssets (const TArray< UObject * > &InAssets)
	번들 로드 완료 후 에셋들을 GC 방지 풀에 등록합니다.
static void	UnregisterBundleAssets (const TArray< UObject * > &InAssets)
	번들 언로드 시 GC 방지 풀에서 에셋들을 제거합니다.
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())
	Primary Asset 이름으로 에셋을 비동기 로드합니다.

Protected 멤버 함수
template<typename TData >
const TData &	GetOrLoadTypedGameData (const TSoftObjectPtr< TData > &DataPath)
template<typename TData >
TArray< const TData * >	GetAllTypedGameData () const
void	InitializeOnManager ()
void	OnUpdateLoadPercentage (float Percentage)
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)
	지정한 클래스 타입의 게임 데이터 에셋을 동기 로드하고 GameDataMap에 등록합니다.

정적 Protected 멤버 함수
static UObject *	SynchronousLoadAsset (const FSoftObjectPath &AssetPath)
	소프트 오브젝트 경로로 에셋을 동기 로드합니다.
static bool	ShouldLogAssetLoads ()
	에셋 로드 로깅 여부를 반환합니다.

Protected 속성
TMap< TObjectPtr< UClass >, FGameDataAssetList >	GameDataMap
TArray< TSoftObjectPtr< UPrimaryDataAsset > >	InitialGameDataPaths
FDataAssetJobManager	JobManager

Private 속성
TSet< TObjectPtr< UObject > >	LoadedAssets

생성자 & 소멸자 문서화

UDataAssetManager()

UDataAssetManager::UDataAssetManager

(

)

{ }

멤버 함수 문서화

DumpLoadedAssets()

void UDataAssetManager::DumpLoadedAssets ( )

static

현재 GC 방지 풀에 등록된 모든 에셋 정보를 로그로 출력합니다.

{
    LOG_INFO(LogCKAsset, "========== 로드된 에셋 덤프 시작 ==========");
 
    for (const UObject* LoadedAsset : GetInstance().LoadedAssets)
    {
        LOG_INFO(LogCKAsset, "  %s", *GetNameSafe(LoadedAsset));
    }
 
    int DumpedAssetCount = GetInstance().LoadedAssets.Num();
 
    if (DumpedAssetCount > 0)
    {
        LOG_INFO(LogCKAsset, "Pool에 %d개의 에셋 존재", DumpedAssetCount);
    }
    else
    {
        LOG_INFO(LogCKAsset, "Pool에 불러올 에셋이 없습니다.");
    }
 
    LOG_INFO(LogCKAsset, "========== 로드된 에셋 덤프 완료 ==========");
}

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

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

GetAsset() [1/2]

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

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

GetAsset() [2/2]

template<typename TData >

static TData * UDataAssetManager::GetAsset ( const TSoftObjectPtr< TData > &  AssetPointer, bool  bKeepInMemory = true  )

static

GetInstance()

UDataAssetManager & UDataAssetManager::GetInstance ( )

static

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

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

반환값

UDataAssetManager 싱글턴 참조

{
    check(GEngine);
 
    UDataAssetManager* Singleton = Cast<UDataAssetManager>(GEngine->AssetManager);
 
    if (Singleton)
    {
        return *Singleton;
    }
    else
    {
        LOG_ERROR(LogCKAsset, "DefaultEngine.ini에서 AssetManagerClassName이 유효하지 않습니다.");
        return *NewObject<UDataAssetManager>();
    }
}

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

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

GetSubclass() [1/2]

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

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

GetSubclass() [2/2]

template<typename TData >

static TSubclassOf< TData > UDataAssetManager::GetSubclass ( const TSoftClassPtr< TData > &  AssetPointer, bool  bKeepInMemory = true  )

static

InitializeOnManager()

void UDataAssetManager::InitializeOnManager ( )

protected

LoadAsyncByName()

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

static

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

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

매개변수

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

{
    UDataAssetManager& Instance = GetInstance();
 
    TArray<FPrimaryAssetId> AllAssetIds;
    Instance.GetPrimaryAssetIdList(FPrimaryAssetType(), AllAssetIds);
 
    const FPrimaryAssetId* FoundId = AllAssetIds.FindByPredicate([&AssetName](const FPrimaryAssetId& Id)
    {
        return Id.PrimaryAssetName == AssetName;
    });
 
    if (FoundId == nullptr)
    {
        LOG_WARNING(LogCKAsset, "LoadAsyncByName: '%s' 이름의 Primary Asset을 찾을 수 없습니다.", *AssetName.ToString());
        return;
    }
 
    FAssetData AssetData;
    Instance.GetPrimaryAssetData(*FoundId, AssetData);
 
    const FSoftObjectPath AssetPath = AssetData.ToSoftObjectPath();
    LoadAsyncByPath(AssetPath, CompletedDelegate);
}

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

LoadAsyncByPath()

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

static

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

JobManager에 로드 작업을 등록하고 실행합니다. 내부적으로 WaitUntilComplete를 사용하므로 실제로는 블로킹 방식으로 동작합니다.

매개변수

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

{
    UDataAssetManager& Instance = GetInstance();
 
    auto LoadJobLambda = [&Instance, AssetPath](const FDataAssetLoadJob& Job, TSharedPtr<FStreamableHandle>& OutHandle)
    {
        FStreamableManager& Manager = Instance.GetStreamableManager();
        OutHandle = Manager.RequestAsyncLoad(AssetPath);
    };
 
    Instance.JobManager.CreateAndAddNewJob("LoadByPath", 1.0f, LoadJobLambda);
 
    DataAssetLoadJobProgress Progress;
    Progress.BindUObject(&Instance, &UDataAssetManager::OnUpdateLoadPercentage);
    ensureAlwaysMsgf(Progress.IsBound(), TEXT("OnUpdateLoadPercentage 함수 등록에 실패했습니다. "));
 
    auto OnCompleted = [AssetPath, CompletedDelegate](float ElapsedTime)
    {
        if (CompletedDelegate.IsBound() == false)
        {
            return;
        }
 
        UObject* LoadedAsset = AssetPath.ResolveObject();
        const FName AssetName = AssetPath.GetAssetFName();
        CompletedDelegate.Execute(AssetName, LoadedAsset);
        LOG_SCREEN("모든 시작 작업이 %.2f초 만에 완료되었습니다", ElapsedTime);
    };
 
    Instance.JobManager.RunAllJobs(Progress, OnCompleted);
}

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

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

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);
 
    if (GIsEditor)
    {
        Asset = DataClassPath.LoadSynchronous();
        LoadPrimaryAssetsWithType(PrimaryAssetType);
        GameDataMap.FindOrAdd(DataClass).Assets.Add(Asset);
        return Asset;
    }
 
    TSharedPtr<FStreamableHandle> Handle = LoadPrimaryAssetsWithType(PrimaryAssetType);
 
    if (Handle.IsValid())
    {
        Handle->WaitUntilComplete(0.0f, false);
        Asset = Cast<UPrimaryDataAsset>(Handle->GetLoadedAsset());
    }
 
    if (Asset)
    {
        GameDataMap.FindOrAdd(DataClass).Assets.Add(Asset);
        return Asset;
    }
    else
    {
        return nullptr;
    }
}

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

OnAllDataLoadCompleted()

void UDataAssetManager::OnAllDataLoadCompleted ( )

protected

OnUpdateLoadPercentage()

void UDataAssetManager::OnUpdateLoadPercentage ( float  Percentage )

protected

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

RegisterBundleAssets()

void UDataAssetManager::RegisterBundleAssets ( const TArray< UObject * > &  InAssets )

static

번들 로드 완료 후 에셋들을 GC 방지 풀에 등록합니다.

DataBundleRegistry::OnAssetsLoaded에서 호출됩니다.

매개변수

InAssets

FStreamableHandle에서 수집한 UObject 포인터 목록

{
    UDataAssetManager& Instance = GetInstance();
 
    for (UObject* Asset : InAssets)
    {
        if (Asset == nullptr)
        {
            continue;
        }
 
        Instance.LoadedAssets.Add(Asset);
    }
 
    LOG_INFO(LogCKAsset, "번들 에셋 %d개를 GC 방지 풀에 등록했습니다.", InAssets.Num());
}

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

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

ShouldLogAssetLoads()

bool UDataAssetManager::ShouldLogAssetLoads ( )

staticprotected

에셋 로드 로깅 여부를 반환합니다.

커맨드라인에 -LogAssetLoads 인자가 있을 때 true를 반환합니다.

반환값

로깅 활성화 여부

{
    return FParse::Param(FCommandLine::Get(), TEXT("LogAssetLoads"));
}

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

StartInitialLoading()

void UDataAssetManager::StartInitialLoading ( )

overrideprotectedvirtual

엔진 시작 시 초기 에셋 로딩을 수행합니다.

UAssetManager::StartInitialLoading을 호출한 뒤, GameDataPath에 지정된 Primary Data Asset을 JobManager를 통해 로드합니다.

{
    Super::StartInitialLoading();
 
    if (InitialGameDataPaths.IsEmpty())
    {
        LOG_WARNING(LogCKAsset, "불러올 데이터가 없습니다. ");
        return;
    }
 
 
    LOG_INFO(LogCKAsset, "데이터 로드를 시작합니다. ");
 
 
    for (int32 Index = 0; Index < InitialGameDataPaths.Num(); ++Index)
    {
        const FString JobName = FString::Printf(TEXT("LoadGameData %d"), Index);
        TryCreateLoadJobForDataAsset(InitialGameDataPaths[Index], JobName);
    }
 
    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 )

staticprotected

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

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

매개변수

AssetPath

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

반환값

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

{
    if (AssetPath.IsValid())
    {
        TUniquePtr<FScopeLogTime> LogTimePtr;
 
        if (ShouldLogAssetLoads())
        {
            LogTimePtr = MakeUnique<FScopeLogTime>(*FString::Printf(TEXT("Synchronously loaded asset [%s]"), *AssetPath.ToString()), nullptr, FScopeLogTime::ScopeLog_Seconds);
        }
 
        if (IsInitialized())
        {
            return GetStreamableManager().LoadSynchronous(AssetPath, false);
        }
 
        return AssetPath.TryLoad();
    }
 
    return nullptr;
}

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

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

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());
 
        if (UPrimaryDataAsset* Asset = Cast<UPrimaryDataAsset>(Loaded))
        {
            GameDataMap.FindOrAdd(Asset->GetClass()).Assets.Add(Asset);
        }
        else
        {
            LOG_ERROR(LogCKAsset, "초기화 데이터 에셋 로드 실패: %s", *DataPath.ToString());
        }
    };
 
    JobManager.CreateAndAddNewJob(JobName, 25.0f, LoadJobLambda);
}

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

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

UnregisterBundleAssets()

void UDataAssetManager::UnregisterBundleAssets ( const TArray< UObject * > &  InAssets )

static

번들 언로드 시 GC 방지 풀에서 에셋들을 제거합니다.

DataBundleRegistry::Release에서 호출됩니다.

매개변수

InAssets

제거할 UObject 포인터 목록

{
    UDataAssetManager& Instance = GetInstance();
 
    for (UObject* Asset : InAssets)
    {
        if (Asset == nullptr)
        {
            continue;
        }
 
        Instance.LoadedAssets.Remove(Asset);
    }
 
    LOG_INFO(LogCKAsset, "번들 에셋 %d개를 GC 방지 풀에서 제거했습니다.", InAssets.Num());
}

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

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

멤버 데이터 문서화

GameDataMap

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

protected

InitialGameDataPaths

TArray<TSoftObjectPtr<UPrimaryDataAsset> > UDataAssetManager::InitialGameDataPaths

protected

JobManager

FDataAssetJobManager UDataAssetManager::JobManager

protected

LoadedAssets

TSet<TObjectPtr<UObject> > UDataAssetManager::LoadedAssets

private

---

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

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