[Unreal] 언리얼 오브젝트 관리2 - 패키지

1. 언리얼 오브젝트 패키지

• 단일 언리얼 오브젝트가 가진 정보는 저장할 수 있지만, 오브젝트들이 조합되어 있다면?
  • 저장된 언리얼 오브젝트 데이터를 효과적으로 찾고 관리하는 방법은?
  • 복잡한 계층 구조를 가진 언리얼 오브젝트를 효과적으로 저장과 불러들이는 방법을 통일해야 한다.
• 언리얼 엔진은 이를 위해 패키지(UPackage) 단위로 언리얼 오브젝트를 관리함
• 패키지의 중의적 개념
  • 언리얼 엔진은 다양한 곳에서 단어 패키지를 사용하고 있음
  • 언리얼 오브젝트를 감싼 포장 오브젝트를 의미함 👉 포스팅의 주제
  • 또한 개발된 최종 콘텐츠를 정리해 프로그램으로 만드는 작업을 의미함 예) 게임 패키징
  • DLC와 같이 향후 확장 콘텐츠에 사용되는 별도의 데이터 묶음을 의미하기도 함 예) pkg 파일
• 구분을 위해 언리얼 오브젝트 패키지로 부르는 것도 고려한다.

 

🟩 패키지와 에셋

• 언리얼 오브젝트 패키지는 다수의 언리얼 오브젝트를 포장하는데 사용하는 언리얼 오브젝트
  • 모든 언리얼 오브젝트는 패키지에 소속되어 있음 예) Transient Package
• 언리얼 오브젝트 패키지의 서브 오브젝트를 에셋(asset)이라고 하며 에디터에는 이들이 노출됨
• 구조상 패키지는 다수의 언리얼 오브젝트를 소유할 수 있으나, 일반적으로는 하나의 에셋만 가짐
• 에셋은 다수의 서브 오브젝트를 가질 수 있으며, 모두 언리얼 오브젝트 패키지에 포함됨
  • 하지만 에디터에는 노출되지 않음

---

2. 에셋 정보의 저장과 로딩 전략

• 게임 제작 단계에서 에셋 간의 연결 작업을 위해 직접 패키지를 불러 할당하는 작업은 부하가 큼
  • 에셋 로딩 대신 패키지와 오브젝트를 지정한 문자열을 대체해 사용. 이를 오브젝트 경로라 함
  • 프로젝트 내에 오브젝트 경로 값은 유일함을 보장함
  • 그렇기에 오브젝트 간의 연결은 오브젝트 경로 값으로 기록될 수 있음
  • 오브젝트 경로를 사용해 다양한 방법으로 에셋을 로딩할 수 있음
• 에셋의 로딩 전략
  • 프로젝트에서 에셋이 반드시 필요한 경우 : 생성자 코드에서 미리 로딩
  • 런타임에서 필요한 때 바로 로딩하는 경우 : 런타임 로직에서 정적 로딩
  • 런타임에서 비동기적으로 로딩하는 경우 : 런타임  로직에서 관리자를 사용해 비동기 로딩

 

🟩 오브젝트 경로

• 패키지 이름과 에셋 이름을 한 데 묶은 문자열
• 에셋 클래스 정보는 생략할 수 있음
• 패키지 내 데이터를 모두 로드하지 않고 오브젝트 경로를 사용해 필요한 에셋만 로드할 수 있음
• {에셋 클래스 정보}'{패키지 이름}.{에셋 이름}' or {패키지 이름}.{에셋 이름}

 

🟩 에셋 스트리밍 관리자(Steamable Manager)

• 에셋의 비동기 로딩을 지원하는 관리자 객체
• 콘텐츠 제작과 무관한 싱글턴 클래스에 FStreamableManager를 선언해두면 좋음
  • GameInstance는 좋은 선택지
• FStreamableManager를 활용해 에셋의 동기/비동기 로딩을 관리할 수 있음
• 다수의 오브젝트 경로를 입력해 다수의 에셋을 로딩하는 것도 가능함

 

🌟 MyGameInstance(h, cpp)

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Engine/GameInstance.h"
#include "Engine/StreamableManager.h"
#include "MyGameInstance.generated.h"

struct FStudentData {
	FStudentData() {}
	FStudentData(int32 InOrder, const FString& InName) : Order(InOrder), Name(InName) {}

	friend FArchive& operator<<(FArchive& Ar, FStudentData& InStudentData) {
		Ar << InStudentData.Order;
		Ar << InStudentData.Name;
		return Ar;
	}

	int32 Order = -1;
	FString Name = TEXT("홍길동");
};

/**
 * 
 */
UCLASS()
class UNREALSERIALIZATION_API UMyGameInstance : public UGameInstance
{
	GENERATED_BODY()
	
public:
	UMyGameInstance();
	virtual void Init() override;

	void SaveStudentPackage() const;
	void LoadStudentPackage() const;
	void LoadStudentObject() const;

private:
	static const FString PackageName;
	static const FString AssetName;

	UPROPERTY()
	TObjectPtr<class UStudent> StudentSrc;

	FStreamableManager StreamableManager;
	TSharedPtr<FStreamableHandle> Handle;
};

// Fill out your copyright notice in the Description page of Project Settings.


#include "MyGameInstance.h"
#include "Student.h"
#include "JsonObjectConverter.h"
#include "UObject/SavePackage.h"

const FString UMyGameInstance::PackageName = TEXT("/Game/Student");
const FString UMyGameInstance::AssetName = TEXT("TopStudent");

void PrintStudentInfo(const UStudent* InStudent, const FString& InTag) {
   UE_LOG(LogTemp, Log, TEXT("[%s] 이름 %s 순번 %d"), *InTag, *InStudent->GetName(), InStudent->GetOrder());
}

UMyGameInstance::UMyGameInstance()
{
   const FString TopSoftObjectPath = FString::Printf(TEXT("%s.%s"), *PackageName, *AssetName);
   static ConstructorHelpers::FObjectFinder<UStudent> UASSET_TopStudent(*TopSoftObjectPath);

   if (UASSET_TopStudent.Succeeded()) {
      PrintStudentInfo(UASSET_TopStudent.Object, TEXT("Constructor"));
   }
}

void UMyGameInstance::Init()
{
   Super::Init();
   FStudentData RawDataSrc(16, TEXT("이득우"));

   const FString SavedDir = FPaths::Combine(FPlatformMisc::ProjectDir(), TEXT("Saved"));
   UE_LOG(LogTemp, Log, TEXT("저장할 파일 폴더 : %s"), *SavedDir);

   {
      const FString RawDataFileName(TEXT("RawData.bin"));
      FString RawDataAbsolutePath = FPaths::Combine(*SavedDir, *RawDataFileName);
      UE_LOG(LogTemp, Log, TEXT("저장할 파일 전체 경로 : %s"), *RawDataAbsolutePath);
      FPaths::MakeStandardFilename(RawDataAbsolutePath);
      UE_LOG(LogTemp, Log, TEXT("변경할 파일 전체 경로 : %s"), *RawDataAbsolutePath);

      FArchive* RawFileWriterAr = IFileManager::Get().CreateFileWriter(*RawDataAbsolutePath);
      if (nullptr != RawFileWriterAr) {
         *RawFileWriterAr << RawDataSrc;
         RawFileWriterAr->Close();
         delete RawFileWriterAr;
         RawFileWriterAr = nullptr;
      }

      FStudentData RawDataDest;
      FArchive* RawFileReaderAr = IFileManager::Get().CreateFileReader(*RawDataAbsolutePath);
      if (nullptr != RawFileReaderAr) {
         *RawFileReaderAr << RawDataDest;
         RawFileReaderAr->Close();
         delete RawFileReaderAr;
         RawFileReaderAr = nullptr;

         UE_LOG(LogTemp, Log, TEXT("[RawData] 이름 %s, 순번 %d"), *RawDataDest.Name, RawDataDest.Order);
      }
   }

   StudentSrc = NewObject<UStudent>();
   StudentSrc->SetName(TEXT("이득우"));
   StudentSrc->SetOrder(59);

   {
      const FString ObjectDataFileName(TEXT("ObjectData.bin"));
      FString ObjectDataAbsolutePath = FPaths::Combine(*SavedDir, *ObjectDataFileName);
      FPaths::MakeStandardFilename(ObjectDataAbsolutePath);

      TArray<uint8> BufferArray;
      FMemoryWriter MemoryWriterAr(BufferArray);
      StudentSrc->Serialize(MemoryWriterAr);

      if (TUniquePtr<FArchive> FileWriterAr = TUniquePtr<FArchive>(IFileManager::Get().CreateFileWriter(*ObjectDataAbsolutePath))) {
         *FileWriterAr << BufferArray;
         FileWriterAr->Close();
      }

      TArray<uint8> BufferArrayFromFile;
      if (TUniquePtr<FArchive> FileReaderAr = TUniquePtr<FArchive>(IFileManager::Get().CreateFileReader(*ObjectDataAbsolutePath))) {
         *FileReaderAr << BufferArrayFromFile;
         FileReaderAr->Close();
      }

      FMemoryReader MemoryReaderAr(BufferArrayFromFile);
      UStudent* StudentDest = NewObject<UStudent>();
      StudentDest->Serialize(MemoryReaderAr);
      PrintStudentInfo(StudentDest, TEXT("ObjectData"));
   }
    
   // json 직렬화
   {
      const FString JsonDataFileName(TEXT("StudentJsonData.txt"));
      FString JsonDataAbsolutePath = FPaths::Combine(*SavedDir, *JsonDataFileName);
      FPaths::MakeStandardFilename(JsonDataAbsolutePath);

      TSharedRef<FJsonObject> JsonObjectSrc = MakeShared<FJsonObject>();
      FJsonObjectConverter::UStructToJsonObject(StudentSrc->GetClass(), StudentSrc, JsonObjectSrc);

      FString JsonOutString;
      TSharedRef<TJsonWriter<TCHAR>> JsonWriterAr = TJsonWriterFactory<TCHAR>::Create(&JsonOutString);
      if (FJsonSerializer::Serialize(JsonObjectSrc, JsonWriterAr)) {
         FFileHelper::SaveStringToFile(JsonOutString, *JsonDataAbsolutePath);
      }

      FString JsonInString;
      FFileHelper::LoadFileToString(JsonInString, *JsonDataAbsolutePath);

      TSharedRef<TJsonReader<TCHAR>> JsonReaderAr = TJsonReaderFactory<TCHAR>::Create(JsonInString);\

      TSharedPtr<FJsonObject> JsonObjectDest;
      if (FJsonSerializer::Deserialize(JsonReaderAr, JsonObjectDest)) {
         UStudent* JsonStudentDest = NewObject<UStudent>();
         if(FJsonObjectConverter::JsonObjectToUStruct(JsonObjectDest.ToSharedRef(), JsonStudentDest->GetClass(), JsonStudentDest)) {
            PrintStudentInfo(JsonStudentDest, TEXT("JsonData"));
         }
      }
   }

   // 패키지를 사용한 에셋 저장
   SaveStudentPackage();
   //LoadStudentPackage();
   //LoadStudentObject();

   const FString TopSoftObjectPath = FString::Printf(TEXT("%s.%s"), *PackageName, *AssetName);
   Handle = StreamableManager.RequestAsyncLoad(TopSoftObjectPath,
         [&]() {
            if (Handle.IsValid() && Handle->HasLoadCompleted()) {
               UStudent* TopStudent = Cast<UStudent>(Handle->GetLoadedAsset());
               if (TopStudent) {
                  PrintStudentInfo(TopStudent, TEXT("AsyncLoad"));

                  Handle->ReleaseHandle();
                  Handle.Reset();
               }
            }
         }
      );
}

void UMyGameInstance::SaveStudentPackage() const
{
   UPackage* StudentPackage = ::LoadPackage(nullptr, *PackageName, LOAD_None);
   if (StudentPackage) {
      StudentPackage->FullyLoad();
   }

   StudentPackage = CreatePackage(*PackageName);
   EObjectFlags ObjectFlag = RF_Public | RF_Standalone;

   UStudent* TopStudent = NewObject<UStudent>(StudentPackage, UStudent::StaticClass(), *AssetName, ObjectFlag);
   TopStudent->SetName(TEXT("이득우"));
   TopStudent->SetOrder(36);

   const int32 NumOfSubs = 10;
   for (int32 ix = 1; ix <= NumOfSubs; ++ix) {
      FString SubObjectName = FString::Printf(TEXT("Student%d"), ix);
      UStudent* SubStudent = NewObject<UStudent>(TopStudent, UStudent::StaticClass(), *SubObjectName, ObjectFlag);
      SubStudent->SetOrder(ix);
   }

   const FString PackageFileName = FPackageName::LongPackageNameToFilename(PackageName, FPackageName::GetAssetPackageExtension());
   FSavePackageArgs SaveArgs;
   SaveArgs.TopLevelFlags = ObjectFlag;

   if (UPackage::SavePackage(StudentPackage, nullptr, *PackageFileName, SaveArgs)) {
      UE_LOG(LogTemp, Log, TEXT("패키지가 성공적으로 저장되었습니다."));
   }
}

void UMyGameInstance::LoadStudentPackage() const
{
   UPackage* StudentPackage = ::LoadPackage(nullptr, *PackageName, LOAD_None);
   if (nullptr == StudentPackage) {
      UE_LOG(LogTemp, Warning, TEXT("패키지를 찾을 수 없습니다."));;
      return;
   }

   StudentPackage->FullyLoad();
   UStudent* TopStudent = FindObject<UStudent>(StudentPackage, *AssetName);
   PrintStudentInfo(TopStudent, TEXT("FindObject Asset"));

}

void UMyGameInstance::LoadStudentObject() const
{
   const FString TopSoftObjectPath = FString::Printf(TEXT("%s.%s"), *PackageName, *AssetName);
   UStudent* TopStudent = LoadObject<UStudent>(nullptr, *TopSoftObjectPath);
   PrintStudentInfo(TopStudent, TEXT("LoadObject Asset"));
}