[UE] 언리얼 오브젝트 관리 I - 직렬화 (UE Object Management I

언리얼 엔진이 제공하는 직렬화 기능을 이해하고 언리얼 오브젝트의 데이터를 저장하고 불러들이기

언리얼 엔진이 제공하는 직렬화 기능을 이해
언리얼 오브젝트를 직렬화하고 이 데이터를 저장하고 불러들이는 방법을 이

인프런 이득우님의 '언리얼 프로그래밍 Part1 - 언리얼 C++의 이해' 강의를 참고하였습니다.
😎 [이득우의 언리얼 프로그래밍 Part1 - 언리얼 C++의 이해] 강의 들으러 가기!

언리얼 엔진의 직렬화

직렬화(Serialization)란?

오브젝트나 연결된 오브젝트의 묶음(오브젝트 그래프)을 바이트 스트림으로 변경하는 과정
- 복잡한 데이터를 일렬로 세우므로 직렬화라 부름.
거꾸로 복구시키는 과정도 포함해서 의미
- Serialization : 오브젝트 그래프에서 바이트 스트림으로 (Object → Byte Stream)
- Deserialization : 바이트 스트림에서 오브젝트 그래프로 (Byte Stream → Object)
직렬화가 가지는 장점
- 현재 프로그램의 상태를 저장하고 필요한 때 복원할 수 있다 (게임의 저장)
- 현재 프로그램에서 사용하고 있는 객체의 정보를 클립보드에 복사해서 다른 프로그램으로 전송할 수 있다.
- 네트워크를 통해 현재 프로그램의 상태를 다른 컴퓨터에 복원할 수 있다.
- 직렬화된 데이터는 압축, 암호화를 통해 데이터를 효율적이고 안전하게 보관할 수 있다.

직렬화 구현 시 고려해야 할 점

이러한 직렬화를 직접 구현할 경우, 다양한 상황을 고려해야 한다.

데이터 레이아웃 : 오브젝트가 가지고 있는 데이터를 어떻게 일렬로 변환할 것인가?
이식성 : 서로 다른 시스템에 전송해도 이식될 수 있는가? (운영체제 별 데이터를 저장하는 방법인 엔디안 기법이 다를 수 있다)
버전 관리 : 새로운 기능이 추가될 때 이를 어떻게 확장하고 처리할 것인가?
성능 : 네트웍 비용을 줄이기 위해서 어떤 데이터 형식을 사용할 것인가?
- ex. 회전의 경우에는 4개의 플롯(16바이트)을 사용. 해당 경우, 모두 보낼 필요가 없으므로 최대한 줄여서 보내는 방법이 있는데 이를 '양자화라 한다.
보안 : 데이터를 어떻게 안전하게 보호할 것인가?
에러 처리 : 전송 과정에서 문제가 발생할 경우 어떻게 인식하고 처리할 것인가?

이러한 상황을 모두 감안해 직렬화 모델을 만드는 것은 쉬운일이 아님

언리얼 엔진의 직렬화 시스템

언리얼 엔진은 이런 상황을 모두 고려한 직렬화 시스템을 자체적으로 제공하고 있음
직렬화 시스템을 위해 제공하는 클래스 FArchive와 연산자
- 아카이브 클래스 FArchive
- Shift operator <<
  - 데이터 자체를 바이트 스트림으로 바꿔 전송
다양한 아카이브 클래스 제공
- 메모리 아카이브 ( FMemoryReader, FMemoryWriter ) ⇒ 메모리에 전송하는 방법
- 파일 아카이브 ( FArchiveFileReaderGeneric, FArchiveFileWriterGeneric ) ⇒ 파일에다가 쓰고 읽는 방법
- 기타 언리얼 오브젝트와 관련된 아카이브 클래스 ( FArchiveUObject )
Json 직렬화 기능 : 별도의 라이브러리를 통해 제공하고 있음

예제 코드

Student.h

 #pragma once
#include "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "Student.generated.h"
 
UCLASS()
class UNREALSERIALIZATION_API UStudent : public UObject
{
	GENERATED_BODY()
	
public:
	UStudent();
 
	int32 GetOrder() const { return Order; }
	void SetOrder(int32 InOrder) { Order = InOrder; }
 
	const FString& GetName() const { return Name; }
	void SetName(const FString& InName) { Name = InName; }
 
	// 언리얼 오브젝트의 Serialize 함수 재정의
	virtual void Serialize(FArchive& Ar) override;
 
private:
	UPROPERTY()
	int32 Order;
 
	UPROPERTY()
	FString Name;
};

Student.cpp

 #include "Student.h"
 
UStudent::UStudent()
{
	Order = -1;
	Name = TEXT("홍길동");
}
 
void UStudent::Serialize(FArchive& Ar)
{
	Super::Serialize(Ar);
 
	Ar << Order; // Order 정보 넣기
	Ar << Name;  // Name 정보 넣기
}

GameInstance.h

 #pragma once
#include "CoreMinimal.h"
#include "Engine/GameInstance.h"
#include "Engine/StreamableManager.h"
#include "MyGameInstance.generated.h"
 
struct FStudentData // C++ 구조체
{
	FStudentData() {}
	FStudentData(int32 InOrder, const FString& InName) : Order(InOrder), Name(InName) {}
 
	friend FArchive& operator<<(FArchive& Ar, FStudentData& InStudentData)
	{
		Ar << InStudentData.Order;  // Order 넣기
		Ar << InStudentData.Name;	// Name 넣기
		return Ar;
	}
 
	int32 Order = -1;
	FString Name = TEXT("홍길동");
};
 
UCLASS()
class UNREALSERIALIZATION_API UMyGameInstance : public UGameInstance
{
	GENERATED_BODY()
	
public:
	UMyGameInstance();
	virtual void Init() override;
 
private:
	UPROPERTY()
	TObjectPtr<class UStudent> StudentSrc; // 저장할 대상인 소스 오브젝트
};

GameInstance.cpp

 #include "MyGameInstance.h"
#include "Student.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")); // 프로젝트의 Saved 폴더 경로
	UE_LOG(LogTemp, Log, TEXT("저장할 파일 폴더 : %s"), *SavedDir);
 
	{
		const FString RawDataFileName(TEXT("RawData.bin")); // 저장할 파일 이름
		FString RawDataAbosolutePath = FPaths::Combine(*SavedDir, *RawDataFileName); // 파일의 절대 경로값
		UE_LOG(LogTemp, Log, TEXT("저장할 파일 전체 경로 : %s"), *RawDataAbosolutePath);
		
       FPaths::MakeStandardFilename(RawDataAbosolutePath); // 깔끔하게 정돈된 경로값으로 수정
		UE_LOG(LogTemp, Log, TEXT("변경할 파일 전체 경로 : %s"), *RawDataAbosolutePath);
 
		FArchive* RawFileWriterAr = IFileManager::Get().CreateFileWriter(*RawDataAbosolutePath);
		if (nullptr != RawFileWriterAr) // 데이터가 있다면
		{
			*RawFileWriterAr << RawDataSrc; // 데이터 전송
			RawFileWriterAr->Close(); 		// 파일 닫기
			delete RawFileWriterAr;			// 파일 삭제
			RawFileWriterAr = nullptr;
		}
 
		FStudentData RawDataDest; // 구조체 선언
		FArchive* RawFileReaderAr = IFileManager::Get().CreateFileReader(*RawDataAbosolutePath); 
		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->SetOrder(59);			// 데이터 넣기
	StudentSrc->SetName(TEXT("이득우")); // 데이터 넣기
 
	//** 언리얼 오브젝트를 저장하고 불러들인다.
	{
		const FString ObjectDataFileName(TEXT("ObjectData.bin")); // 파일 이름
		FString ObjectDataAbsolutePath = FPaths::Combine(*SavedDir, *ObjectDataFileName); // 파일 절대 경로값(파일경로 + 파일 이름)
		FPaths::MakeStandardFilename(ObjectDataAbsolutePath); // 경로 보기좋게 바꿈
 
		TArray<uint8> BufferArray; 				   // 바이트 스트림을 위한 버퍼(Buffer)
		FMemoryWriter MemoryWriterAr(BufferArray); // 메모리 Writer에 버퍼 연동
		StudentSrc->Serialize(MemoryWriterAr); // Serialize 함수 실행시키고 메모리에 쓸 Archive를 지정
		
        // 쓰기
		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); // Archive에 버퍼 연동
		UStudent* StudentDest = NewObject<UStudent>();	   // 새로운 Student 객체 생성
		StudentDest->Serialize(MemoryReaderAr);			   // 새로운 객체에 BufferArrayFromFile에 있는 내용 덮어쓰기
		PrintStudentInfo(StudentDest, TEXT("ObjectData")); // 출력
	}
 
}

실행화면

Json 직렬화

Json은 JavaScript Object Notation의 약자
웹 환경에서 서버와 클라이언트 사이에 데이터를 주고받을 때 사용하는 텍스트 기반 데이터 포맷
데이터를 표현하기 위한 텍스트 기반 경량의 데이터 교환 포맷이다.
Json 장점
- 텍스트임에도 데이터 크기가 가볍움.
- 읽기 편해서 데이터를 보고 이해할 수 있음.
- 사실 상 웹 통신의 표준으로 널리 사용됨.
Json 단점
- 지원하는 타입이 몇 가지 안됨. (문자, 숫자, 불리언, 널, 배열, 오브젝트만 사용 가능)
- 텍스트 형식으로만 사용할 수 있음. (네트워크 상에서 극도의 효율을 추구하고 싶을 때는 조금 불리할 수 있다.)

언리얼은 Json, JosnUtilities 라이브러리 활용

Json 데이터 예시

Json 데이터 유형

오브젝트: { }
- 오브젝트 내 데이터는 Key, Value 조합으로 구성됨.
- ex. { "key" : 10 }
배열: [ ]
- 배열 내 데이터는 Value로만 구성됨.
- ex. [ "value1", "value2", "value3" ]
이외 데이터
- 문자열 ( "string" ), 숫자 ( 10 또는 3.14 ), 불리언 ( true 또는 false ), 널 ( null )로 구성

언리얼 스마트 포인터 라이브러리 개요

일반 C++오브젝트의 포인터 문제를 해결해주는 언리얼 엔진의 라이브러리이다.

일반 C++ 스마트 포인터와 비교
- TUniquePtr : std::unique_ptr
- TSharedPtr : std::shared_ptr, nullptr 가능
- TSharedRef : 공유 참조, Not NULL 보장,
- TWeakPtr : std::weak_ptr. 독립 사용 불가
TUniquePtr: 지정한 곳에서만 메모리를 관리하는 포인터
- 특정 오브젝트에게 명확하게 해지 권한을 주고 싶은 경우
- delete 구문 없이 함수 실행 후 자동으로 소멸시키고 싶을 때
TSharedPtr: 더 이상 사용되지 않으면 자동으로 메모리를 해지하는 포인터
- 여러 로직에서 할당된 오브젝트가 공유해서 사용되는 경우
- 다른 함수로부터 할당된 오브젝트를 Out으로 받는 경우
- Null 일 수 있음
TShardRef: 공유 포인터와 동일하지만, 유효한 객체를 항상 보장받는 레퍼런스
- 여러 로직에서 할당된 오브젝트가 공유해서 사용되는 경우
- Not Null을 보장받으며 오브젝트를 편리하게 사용하고 싶은 경우

예제 코드

Student.h

 #pragma once
#include "CoreMinimal.h"
#include "UObject/NoExportTypes.h"
#include "Student.generated.h"
 
UCLASS()
class UNREALSERIALIZATION_API UStudent : public UObject
{
	GENERATED_BODY()
	
public:
	UStudent();
 
	int32 GetOrder() const { return Order; }
	void SetOrder(int32 InOrder) { Order = InOrder; }
 
	const FString& GetName() const { return Name; }
	void SetName(const FString& InName) { Name = InName; }
 
	// 언리얼 오브젝트의 Serialize 함수 재정의
	virtual void Serialize(FArchive& Ar) override;
 
private:
	UPROPERTY()
	int32 Order;
 
	UPROPERTY()
	FString Name;
};

Student.cpp

 #include "Student.h"
 
UStudent::UStudent()
{
	Order = -1;
	Name = TEXT("홍길동");
}
 
void UStudent::Serialize(FArchive& Ar)
{
	Super::Serialize(Ar);
 
	Ar << Order; // Order 정보 넣기
	Ar << Name;  // Name 정보 넣기
}

GameInstance.h

 #pragma once
#include "CoreMinimal.h"
#include "Engine/GameInstance.h"
#include "Engine/StreamableManager.h"
#include "MyGameInstance.generated.h"
 
struct FStudentData // C++ 구조체
{
	FStudentData() {}
	FStudentData(int32 InOrder, const FString& InName) : Order(InOrder), Name(InName) {}
 
	friend FArchive& operator<<(FArchive& Ar, FStudentData& InStudentData)
	{
		Ar << InStudentData.Order;  // Order 넣기
		Ar << InStudentData.Name;	// 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;
};

GameInstance.cpp

 #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")); // 프로젝트의 Saved 폴더 경로
	UE_LOG(LogTemp, Log, TEXT("저장할 파일 폴더 : %s"), *SavedDir);
 
	{
		const FString RawDataFileName(TEXT("RawData.bin")); // 저장할 파일 이름
		FString RawDataAbosolutePath = FPaths::Combine(*SavedDir, *RawDataFileName); // 파일의 절대 경로값
		UE_LOG(LogTemp, Log, TEXT("저장할 파일 전체 경로 : %s"), *RawDataAbosolutePath);
		
       FPaths::MakeStandardFilename(RawDataAbosolutePath); // 깔끔하게 정돈된 경로값으로 수정
		UE_LOG(LogTemp, Log, TEXT("변경할 파일 전체 경로 : %s"), *RawDataAbosolutePath);
 
		FArchive* RawFileWriterAr = IFileManager::Get().CreateFileWriter(*RawDataAbosolutePath);
		if (nullptr != RawFileWriterAr) // 데이터가 있다면
		{
			*RawFileWriterAr << RawDataSrc; // 데이터 전송
			RawFileWriterAr->Close(); 		// 파일 닫기
			delete RawFileWriterAr;			// 파일 삭제
			RawFileWriterAr = nullptr;
		}
 
		FStudentData RawDataDest; // 구조체 선언
		FArchive* RawFileReaderAr = IFileManager::Get().CreateFileReader(*RawDataAbosolutePath); 
		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->SetOrder(59);			// 데이터 넣기
	StudentSrc->SetName(TEXT("이득우")); // 데이터 넣기
 
	//** 언리얼 오브젝트를 저장하고 불러들인다.
	{
		const FString ObjectDataFileName(TEXT("ObjectData.bin")); // 파일 이름
		FString ObjectDataAbsolutePath = FPaths::Combine(*SavedDir, *ObjectDataFileName); // 파일 절대 경로값(파일경로 + 파일 이름)
		FPaths::MakeStandardFilename(ObjectDataAbsolutePath); // 경로 보기좋게 바꿈
 
		TArray<uint8> BufferArray; 				   // 바이트 스트림을 위한 버퍼(Buffer)
		FMemoryWriter MemoryWriterAr(BufferArray); // 메모리 Writer에 버퍼 연동
		StudentSrc->Serialize(MemoryWriterAr); // Serialize 함수 실행시키고 메모리에 쓸 Archive를 지정
		
        // 쓰기
		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); // Archive에 버퍼 연동
		UStudent* StudentDest = NewObject<UStudent>();	   // 새로운 Student 객체 생성
		StudentDest->Serialize(MemoryReaderAr);			   // 새로운 객체에 BufferArrayFromFile에 있는 내용 덮어쓰기
		PrintStudentInfo(StudentDest, TEXT("ObjectData")); // 출력
	}
 
	{
		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->SetName(FString::Printf(TEXT("학생%d"), ix));
		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"));
}

실행화면

'⭐ Unreal Engine > UE 개념정리 - 언리얼의 이해' 카테고리의 다른 글

[UE] 언리얼 빌드 시스템 (4)	2024.09.02
[UE] 언리얼 오브젝트 관리 II - 패키지 (Package) (0)	2024.07.09
[UE] 언리얼 엔진의 메모리 관리 (Memory Management in UE) (0)	2024.07.02
[UE] 언리얼 구조체와 TMap (1)	2024.07.01
[UE] 언리얼 C++의 TArray, TSet, TMap 자료구조 라이브러리와 활용방법 (0)	2024.04.20

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

[UE] 언리얼 오브젝트 관리 I - 직렬화 (UE Object Management I - Serialization)

언리얼 엔진의 직렬화

직렬화(Serialization)란?

직렬화 구현 시 고려해야 할 점

언리얼 엔진의 직렬화 시스템

예제 코드

실행화면

Json 직렬화

Json 직렬화

Json 데이터 예시

언리얼 스마트 포인터 라이브러리 개요

예제 코드

실행화면

'⭐ Unreal Engine > UE 개념정리 - 언리얼의 이해' 카테고리의 다른 글

댓글

이 글 공유하기

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역

언리얼 엔진의 직렬화

직렬화(Serialization)란?

직렬화 구현 시 고려해야 할 점

언리얼 엔진의 직렬화 시스템

예제 코드

실행화면

Json 직렬화

Json 직렬화

Json 데이터 예시

언리얼 스마트 포인터 라이브러리 개요

예제 코드

실행화면

'⭐ Unreal Engine > UE 개념정리 - 언리얼의 이해' 카테고리의 다른 글

댓글

이 글 공유하기

다른 글

[UE] 언리얼 빌드 시스템

[UE] 언리얼 오브젝트 관리 II - 패키지 (Package)

[UE] 언리얼 엔진의 메모리 관리 (Memory Management in UE)

[UE] 언리얼 구조체와 TMap

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역