UE小计：Unreal Engine 中 Actor 数据的 JSON 序列化

Unreal Engine 中 Actor 数据的 JSON 序列化

在游戏开发过程中，经常需要将游戏世界中的实体（Actors）信息导出到其他格式以便于分析、存储或交互。在Unreal Engine中，我们可以通过序列化这些实体的数据为JSON格式来实现这一目的。以下是在Unreal Engine项目中实现Actor数据序列化为JSON对象的技术细节概述。

FActorData 结构体

FActorData结构体用于存储Actor的相关信息，包括名称、ID、类型、标签、用户数据以及子Actor信息。此结构体还包含一个方法ToJsonObject，用于将FActorData实例转换为JSON对象。

struct FActorData
{
    FString Name;
    FString ID;
	//...

    TSharedPtr<FJsonObject> ToJsonObject() const;
    // 其他成员和方法的定义...
};

ToJsonObject方法将FActorData的每个字段转换为JSON格式，并处理子Actor数据的递归序列化。

CreateActorData 函数

CreateActorData函数用于提取给定Actor的数据，并将其封装在FActorData结构体中。该函数检查Actor的标签以确定其类型，并递归收集子Actor的数据。

FActorData CreateActorData(AActor* Actor);

在实现中，如果Actor的标签包含"Thing"，则将类型设置为"Thing"；否则，使用Actor的类名作为类型。此外，该函数还会收集Actor的标签和用户数据，这些数据由UUnrealUtils::GetUserData提供，假设该函数返回TMap<FString, FString>类型的数据。

ParseWorldActorsToJson 函数

ParseWorldActorsToJson函数遍历Unreal Engine世界中的所有Actors，使用CreateActorData函数为每个Actor创建FActorData实例，并将这些实例序列化为JSON数组。

TArray<TSharedPtr<FJsonValue>> ParseWorldActorsToJson(UWorld* World);

该函数假设传入的UWorld对象是有效的，并且所有Actors都已经加载到世界中。它返回一个JSON值数组，每个值都是一个表示Actor数据的JSON对象。

技术细节

在Unreal Engine中，将Actor数据序列化为JSON涉及到几个关键步骤，包括定义数据结构、提取Actor信息、转换为JSON格式以及处理复杂数据类型。以下是这些步骤的详细说明和相关代码示例。

1. 定义数据结构（FActorData）

FActorData结构体用于表示Actor的数据模型。它包含了Actor的名称、唯一标识符、类型、标签列表、用户自定义数据以及子Actor的列表。

struct FActorData
{
    FString Name;
    FString ID;
    FString Type;
    TArray<FString> Tags;
    TMap<FString, FString> UserData;
    TArray<FActorData> Children;
    
    // ... 其他成员和方法的定义 ...
};

2. 提取Actor信息（CreateActorData）

CreateActorData函数负责遍历Actor及其子Actor，提取相关信息，并填充到FActorData结构体实例中。这个过程包括检查Actor的标签来确定其类型，并收集用户自定义数据。

FActorData CreateActorData(AActor* Actor)
{
    FActorData Data;
    if (Actor != nullptr)
    {
        Data.Name = Actor->GetActorLabel();
        Data.ID = Actor->GetName();
        // ... 标签检查和类型确定的逻辑 ...
        Data.UserData = UUnrealUtils::GetUserData(Actor);
        // ... 收集子Actor数据的逻辑 ...
    }
    return Data;
}

3. 转换为JSON格式（ToJsonObject）

ToJsonObject方法负责将FActorData实例转换为JSON对象。它使用Unreal Engine的JSON API来创建和填充JSON对象。

TSharedPtr<FJsonObject> FActorData::ToJsonObject() const
{
    TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject);
    // ... 设置基本字段 ...
    // 序列化UserData为JSON对象
    TSharedPtr<FJsonObject> JsonUserData = MakeShareable(new FJsonObject);
    for (const auto& Elem : UserData)
    {
        JsonUserData->SetStringField(Elem.Key, Elem.Value);
    }
    JsonObject->SetObjectField(TEXT("UserData"), JsonUserData);
    // ... 序列化子Actor ...
    return JsonObject;
}

4. 处理复杂数据类型

在FActorData中，UserData字段是一个TMap<FString, FString>类型，它需要特殊处理来转换为JSON对象。同样，子Actor列表也需要递归地转换为JSON数组。

// 序列化UserData为JSON对象
TSharedPtr<FJsonObject> JsonUserData = MakeShareable(new FJsonObject);
for (const auto& Elem : UserData)
{
    JsonUserData->SetStringField(Elem.Key, Elem.Value);
}
JsonObject->SetObjectField(TEXT("UserData"), JsonUserData);

// 序列化子Actor为JSON数组
TArray<TSharedPtr<FJsonValue>> JsonChildren;
for (const FActorData& ChildData : Children)
{
    JsonChildren.Add(MakeShareable(new FJsonValueObject(ChildData.ToJsonObject())));
}
JsonObject->SetArrayField(TEXT("Children"), JsonChildren);

完整代码

FString UUnrealUtils::ParseWorldActorsToJson()
{
	UWorld* World = GetWorldInGameMode();
	if (!World)
	{
		return TEXT("{}");
	}

	TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject);
	TArray<TSharedPtr<FJsonValue>> JsonActorsArray;

	TArray<TSharedPtr<FJsonValue>> JsonActors;

	// 遍历所有的Actor
	for (TActorIterator<AActor> It(World); It; ++It)
	{
		AActor* Actor = *It;
		// 检查Actor是否为顶层Actor（没有父Actor）
		if (!Actor->GetAttachParentActor())
		{
			FActorData ActorData = CreateActorData(Actor);
			JsonActorsArray.Add(MakeShareable(new FJsonValueObject(ActorData.ToJsonObject())));

			
			// 只从顶层Actor开始递归
			AddActorAndChildren(Actor, JsonActors);
		}
	}
	
	JsonObject->SetArrayField(TEXT("actors"), JsonActorsArray);
	FString OutputString;
	TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
	FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer);
	return OutputString;

	// // 序列化 JsonActors 数组到 JSON 字符串
	// FString OutputString;
	// TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
	// if (FJsonSerializer::Serialize(JsonActors, Writer))
	// {
	// 	Writer->Close();
	// 	return OutputString;
	// }
	//
	// return TEXT("{}");
}

TMap<FString,FString> GetUserData(AActor* Actor) {
	TMap<FString,FString> ThingData;
	USceneComponent* SceneComponent = Actor->GetRootComponent();
	UThingUEUserData* AssetUserData = nullptr;
	if (SceneComponent)
	{
		const TArray<UAssetUserData*>* ass = SceneComponent->GetAssetUserDataArray();
		AssetUserData = SceneComponent->GetAssetUserData<UThingUEUserData>();
	}
	if (AssetUserData)
	{
		FString guid = AssetUserData->GUID;
		TMap<FString, FString> userdata = AssetUserData->UserData;
		return userdata;
	}

	return ThingData;
}

FActorData CreateActorData(AActor* Actor)
{
	FActorData Data;
	if (Actor != nullptr)
	{
		Data.Name = Actor->GetActorLabel();
		Data.ID = Actor->GetName();
		// 检查Actor的标签中是否包含"Thing"
		bool bHasThingTag = Actor->Tags.ContainsByPredicate([](const FName& Tag) {
			return Tag.ToString().Equals("Thing", ESearchCase::IgnoreCase);
		});
		// 根据是否包含"Thing"标签来设置Data.Type
		Data.Type = bHasThingTag ? "Thing" : Actor->GetClass()->GetName();
        
		for (const auto& Tag : Actor->Tags)
		{
			Data.Tags.Add(Tag.ToString());
		}
		
		Data.UserData = GetUserData(Actor);

		// 递归收集子Actor的数据
		TArray<AActor*> Children;
		Actor->GetAttachedActors(Children);
		for (AActor* Child : Children)
		{
			Data.Children.Add(CreateActorData(Child));
		}
		
		// // 收集子Actor的名字
		// TArray<AActor*> ChildrenActors;
		// Actor->GetAttachedActors(ChildrenActors);
		// for (AActor* ChildActor : ChildrenActors)
		// {
		// 	Data.Children.Add(ChildActor->GetActorLabel());
		// }
	}
	return Data;
}

// 辅助函数，递归地添加Actor及其子Actor到JsonActors数组
void AddActorAndChildren(AActor* Actor, TArray<TSharedPtr<FJsonValue>>& JsonActors)
{
	if (Actor == nullptr)
	{
		return;
	}
	UUnrealUtils::CurrentSelectedActors.Add(Actor);
	// // 创建父Actor数据并添加到数组
	// FActorData ActorData = CreateActorData(Actor);
	// TSharedPtr<FJsonValueObject> JsonValue = MakeShareable(new FJsonValueObject(ActorData.ToJsonObject()));
	// JsonActors.Add(JsonValue);
	//
	// // 递归添加子Actor
	TArray<AActor*> ChildrenActors;
	Actor->GetAttachedActors(ChildrenActors);
	for (AActor* ChildActor : ChildrenActors)
	{
		AddActorAndChildren(ChildActor, JsonActors);
	}
}

FString YouClass::ParseWorldActorsToJson()
{
	UWorld* World = GetWorldInGameMode();
	if (!World)
	{
		return TEXT("{}");
	}

	TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject);
	TArray<TSharedPtr<FJsonValue>> JsonActorsArray;

	TArray<TSharedPtr<FJsonValue>> JsonActors;

	// 遍历所有的Actor
	for (TActorIterator<AActor> It(World); It; ++It)
	{
		AActor* Actor = *It;
		// 检查Actor是否为顶层Actor（没有父Actor）
		if (!Actor->GetAttachParentActor())
		{
			FActorData ActorData = CreateActorData(Actor);
			JsonActorsArray.Add(MakeShareable(new FJsonValueObject(ActorData.ToJsonObject())));

			
			// 只从顶层Actor开始递归
			AddActorAndChildren(Actor, JsonActors);
		}
	}
	
	JsonObject->SetArrayField(TEXT("actors"), JsonActorsArray);
	FString OutputString;
	TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
	FJsonSerializer::Serialize(JsonObject.ToSharedRef(), Writer);
	return OutputString;

	// // 序列化 JsonActors 数组到 JSON 字符串
	// FString OutputString;
	// TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
	// if (FJsonSerializer::Serialize(JsonActors, Writer))
	// {
	// 	Writer->Close();
	// 	return OutputString;
	// }
	//
	// return TEXT("{}");
}

结论

通过以上步骤，我们可以将Unreal Engine中的Actor数据序列化为JSON格式。这个过程不仅包括基本类型的转换，还涉及到复杂数据类型的处理，如映射和数组。最终，我们能够生成一个完整的JSON对象，它准确地反映了Actor的状态和属性，可以用于数据存储、分析或与外部系统的交互