Export additional editor data to vpps so it persists through import/export

Currently only exports object name + description

Author: Moneyl

Dependencies/RfgToolsPlusPlus

@@ -577,27 +577,17 @@ void TerritoryDocument::DrawMenuBar(GuiState* state)
             }
 
             bool exportPressed = false;
-            bool exportPatchPressed = false;
             bool exportBinaryPatchPressed = false;
 
             exportPressed = ImGui::Button("Export");
-            if (!isSPMap)
-            {
-                exportPatchPressed = ImGui::Button("Export patch");
-                ImGui::SameLine();
-                gui::HelpMarker("This option is going away in future versions. You should use 'Export binary patch (SyncFaction)' instead.", ImGui::GetIO().FontDefault);
-                exportBinaryPatchPressed = ImGui::Button("Export binary patch (SyncFaction)");
-            }
 
             MapExportType exportType;
             if (exportPressed)
                 exportType = MapExportType::Vpp;
-            else if (exportPatchPressed)
-                exportType = MapExportType::RfgPatch;
             else if (exportBinaryPatchPressed)
                 exportType = MapExportType::BinaryPatch;
 
-            if (exportPressed || exportPatchPressed || exportBinaryPatchPressed)
+            if (exportPressed || exportBinaryPatchPressed)
             {
                 exportTask_ = Task::Create("Export map");
                 if (std::filesystem::exists(CVar_MapExportPath.Get<string>()))
@@ -1667,6 +1657,11 @@ void TerritoryDocument::Inspector(GuiState* state)
     u32 handle = selectedObject_.Property("Handle").Get<u32>();
     u32 num = selectedObject_.Property("Num").Get<u32>();
     ImGui::Text(fmt::format("{}, {}", handle, num).c_str());
+    
+    //Description
+    string description = selectedObject_.Get<string>("Description");
+    ImGui::InputText("Description", &description);
+    selectedObject_.Set<string>("Description", description);
     ImGui::Separator();
 
     if (ImGui::CollapsingHeader("Bounding box"))
@@ -2325,11 +2320,6 @@ void TerritoryDocument::ExportTask(GuiState* state, MapExportType exportType)
         {
             exportResult = ExportMapSP(state, CVar_MapExportPath.Get<string>());
         }
-        else if (exportType == MapExportType::RfgPatch)
-        {
-            Log->error("Failed to export {}. RfgPatch export isn't supported for SP maps.", mapName);
-            exportResult = false;
-        }
         else if (exportType == MapExportType::BinaryPatch)
         {
             Log->error("Failed to export {}. Binary patch export isn't supported for SP maps.", mapName);
@@ -2342,10 +2332,6 @@ void TerritoryDocument::ExportTask(GuiState* state, MapExportType exportType)
         {
             exportResult = ExportMap(state, CVar_MapExportPath.Get<string>());
         }
-        else if (exportType == MapExportType::RfgPatch)
-        {
-            exportResult = ExportPatch();
-        }
         else if (exportType == MapExportType::BinaryPatch)
         {
             exportResult = ExportBinaryPatch(state);
@@ -2380,7 +2366,7 @@ bool TerritoryDocument::ExportMap(GuiState* state, const string& exportPath)
     string mapName = Path::GetFileNameNoExtension(Territory.Object.Get<string>("Name"));
 
     //Steps: Export zones, extract vpp_pc, extract containers, copy zones to containers, repack containers, update asm_pc, repack vpp_pc, cleanup
-    const f32 numSteps = 8.0f;
+    const f32 numSteps = 9.0f;
     const f32 percentagePerStep = 1.0f / numSteps;
 
     exportPercentage_ = 0.0f;
@@ -2462,6 +2448,12 @@ bool TerritoryDocument::ExportMap(GuiState* state, const string& exportPath)
     //Update asm_pc file
     UpdateAsmPc(tempFolderPath + "\\vpp\\" + mapName + ".asm_pc");
 
+    exportPercentage_ += percentagePerStep;
+    exportStatus_ = "Exporting editor data...";
+
+    //Write additional editor data that isn't preserved in zone files
+    Exporters::ExportEditorMapData(Territory.Object, tempFolderPath + "vpp\\");
+
     exportPercentage_ += percentagePerStep;
     exportStatus_ = "Repacking " + terrPackfileName + "...";
 
@@ -2480,58 +2472,6 @@ bool TerritoryDocument::ExportMap(GuiState* state, const string& exportPath)
     return true;
 }
 
-constexpr u32 RFG_PATCHFILE_SIGNATURE = 1330528590; //Equals ASCII string "NANO"
-constexpr u32 RFG_PATCHFILE_VERSION = 1;
-bool TerritoryDocument::ExportPatch()
-{
-    exportPercentage_ = 0.0f;
-
-    //Export zone files
-    string terrPackfileName = Territory.Object.Get<string>("Name"); //Name of the map vpp_pc
-    string mapName = Path::GetFileNameNoExtension(terrPackfileName); //Name of the map
-    string exportFolderPath = CVar_MapExportPath.Get<string>(); //Folder to write final patch file to
-    if (!Exporters::ExportTerritory(Territory.Object, exportFolderPath))
-    {
-        LOG_ERROR("Map patch export failed! Map export failed for '{}'", mapName);
-        return false;
-    }
-
-    string zoneFilePath = fmt::format("{}\\{}.rfgzone_pc", exportFolderPath, mapName);
-    string pZoneFilePath = fmt::format("{}\\p_{}.rfgzone_pc", exportFolderPath, mapName);
-    std::vector<u8> zoneBytes = File::ReadAllBytes(zoneFilePath);
-    std::vector<u8> pZoneBytes = File::ReadAllBytes(pZoneFilePath);
-    if (zoneBytes.size() == 0 || pZoneBytes.size() == 0)
-    {
-        LOG_ERROR("Map patch export failed! More or both exported zone files are empty. Sizes: {}, {}", zoneBytes.size(), pZoneBytes.size());
-        return false;
-    }
-
-    //Merge zone files into single patch file. Meant to be used with the separate RfgMapPatcher tool. Makes the final exports much smaller.
-    //Write patch file header
-    BinaryWriter patch(fmt::format("{}\\{}.RfgPatch", exportFolderPath, mapName));
-    patch.Write<u32>(RFG_PATCHFILE_SIGNATURE);
-    patch.Write<u32>(RFG_PATCHFILE_VERSION);
-    patch.WriteNullTerminatedString(terrPackfileName);
-    patch.Align(4);
-    
-    //Write zone file sizes
-    patch.Write<size_t>(zoneBytes.size());
-    patch.Write<size_t>(pZoneBytes.size());
-
-    //Write zone file data
-    patch.WriteSpan<u8>(zoneBytes);
-    patch.Align(4);
-    patch.WriteSpan<u8>(pZoneBytes);
-    patch.Align(4);
-
-    //Remove zone files. We only care about the final patch file with this option
-    std::filesystem::remove(zoneFilePath);
-    std::filesystem::remove(pZoneFilePath);
-
-    exportPercentage_ = 1.0f;
-    return true;
-}
-
 bool TerritoryDocument::ExportBinaryPatch(GuiState* state)
 {
     //Make sure folder exists for writing temporary files

Nanoforge/gui/documents/TerritoryDocument.cpp

@@ -14,7 +14,6 @@ class GuiState;
 enum MapExportType
 {
     Vpp,
-    RfgPatch,
     BinaryPatch
 };
 
@@ -79,7 +78,6 @@ class TerritoryDocument : public IDocument
 
     void ExportTask(GuiState* state, MapExportType exportType);
     bool ExportMap(GuiState* state, const string& exportPath);
-    bool ExportPatch();
     bool ExportBinaryPatch(GuiState* state);
     bool ExportMapSP(GuiState* state, const string& exportPath);
 

Nanoforge/gui/documents/TerritoryDocument.h

@@ -133,6 +133,18 @@ void Territory::LoadThread(Handle<Task> task, Handle<Scene> scene, GuiState* sta
         }
     }
 
+    //Add description to objects missing them
+    for (ObjectHandle zone : Object.GetObjectList("Zones"))
+    {
+        for (ObjectHandle obj : zone.GetObjectList("Objects"))
+        {
+            if (!obj.Has("Description"))
+            {
+                obj.Set<string>("Description", "");
+            }
+        }
+    }
+
     //Get zone name with most characters for UI purposes
     u32 longest = 0;
     for (ObjectHandle zone : Object.GetObjectList("Zones"))

Nanoforge/rfg/Territory.cpp

@@ -7,4 +7,6 @@ namespace Exporters
 {
 	bool ExportTerritory(ObjectHandle territory, std::string_view outputPath, bool skipUneditedZones = false);
 	bool ExportZone(ObjectHandle zone, std::string_view outputPath, bool persistent = false);
+	//Xml containing additional map data used by the editor which is stripped from the RFG zone files
+	bool ExportEditorMapData(ObjectHandle territory, const string& outputFolder);
 }

Nanoforge/rfg/export/Exporters.h

@@ -1,4 +1,5 @@
 #include "Exporters.h"
+#include <tinyxml2/tinyxml2.h>
 
 bool Exporters::ExportTerritory(ObjectHandle territory, std::string_view outputPath, bool skipUneditedZones)
 {
@@ -51,3 +52,31 @@ bool Exporters::ExportTerritory(ObjectHandle territory, std::string_view outputP
 
 	return true;
 }
+
+bool Exporters::ExportEditorMapData(ObjectHandle territory, const string& outputFolder)
+{
+	tinyxml2::XMLDocument doc;
+	auto* editorData = doc.NewElement("EditorData");
+	doc.InsertFirstChild(editorData);
+	auto* zones = editorData->InsertNewChildElement("Zones");
+
+	//Store additional map data that typically isn't stored in RFG zone files (e.g. names, descriptions). This way it's preserved through map import/export
+	for (ObjectHandle zone : territory.GetObjectList("Zones"))
+	{
+		auto* zoneXml = zones->InsertNewChildElement("Zone");
+		zoneXml->InsertNewChildElement("Name")->SetText(zone.Get<string>("Name").c_str());
+		auto* objectsXml = zoneXml->InsertNewChildElement("Objects");
+		for (ObjectHandle object : zone.GetObjectList("Objects"))
+		{
+			auto* objectXml = objectsXml->InsertNewChildElement("Object");
+			objectXml->InsertNewChildElement("Name")->SetText(object.Get<string>("Name").c_str());
+			objectXml->InsertNewChildElement("Handle")->SetText(object.Get<u32>("Handle"));
+			objectXml->InsertNewChildElement("Num")->SetText(object.Get<u32>("Num"));
+			if (object.Has("Description"))
+				objectXml->InsertNewChildElement("Description")->SetText(object.Get<string>("Description").c_str());
+		}
+	}
+
+	doc.SaveFile((outputFolder + "EditorData.xml").c_str());
+	return true;
+}

Nanoforge/rfg/export/MapExporter.cpp

@@ -1,5 +1,6 @@
 #pragma once
 #include "application/Registry.h"
+#include <tinyxml2/tinyxml2.h>
 #include <span>
 
 class ZoneFile;
@@ -22,6 +23,8 @@ namespace Importers
 	ObjectHandle ImportPegFromPath(std::string_view pegPath, TextureIndex* textureIndex, bool useExistingTextures = true);
 	//Imports rfg chunk file (destructible mesh). Has extension .cchk_pc
 	ObjectHandle ImportChunk(std::string_view chunkFilename, PackfileVFS* packfileVFS, TextureIndex* textureIndex, bool* stopSignal = nullptr, ObjectHandle textureCache = NullObjectHandle);
+	//Xml containing additional map data used by the editor which is stripped from the RFG zone files
+	bool ImportEditorMapData(ObjectHandle territory, tinyxml2::XMLDocument* doc);
 }
 
 //Helpers for dealing with registry objects

Nanoforge/rfg/import/Importers.h

@@ -8,6 +8,7 @@
 #include "util/TaskScheduler.h"
 #include "Log.h"
 #include <RfgTools++/formats/packfiles/Packfile3.h>
+#include <tinyxml2/tinyxml2.h>
 
 //Used to stop the import process early by the calling code setting stopSignal to true. Does nothing if stopSignal is nullptr
 #define EarlyStopCheck() if(stopSignal && *stopSignal) \
@@ -106,6 +107,17 @@ ObjectHandle Importers::ImportTerritory(std::string_view territoryFilename, Pack
         }
     }
 
+    //Load additional map data if present
+    if (packfile->Contains("EditorData.xml"))
+    {
+        auto editorDataBytes = packfile->ExtractSingleFile("EditorData.xml", true);
+        std::vector<u8>& bytes = editorDataBytes.value();
+
+        tinyxml2::XMLDocument doc;
+        doc.Parse((char*)bytes.data(), bytes.size());
+        ImportEditorMapData(territory, &doc);
+    }
+
     return territory;
 }
 
@@ -210,4 +222,80 @@ void LoadChunks(ObjectHandle zone, ObjectHandle territory, PackfileVFS* packfile
             obj.Set<ObjectHandle>("ChunkMesh", chunkMesh);
         }
     }
+}
+
+bool Importers::ImportEditorMapData(ObjectHandle territory, tinyxml2::XMLDocument* doc)
+{
+    auto* editorData = doc->FirstChildElement("EditorData");
+    if (!editorData)
+    {
+        LOG_ERROR("<EditorData> not found in map editor data file.");
+        return false;
+    }
+
+    auto* zonesXml = editorData->FirstChildElement("Zones");
+    if (!zonesXml)
+    {
+        LOG_ERROR("<EditorData/Zones> not found in map editor data file.");
+        return false;
+    }
+
+    //Load zone data
+    for (auto* zoneXml = zonesXml->FirstChildElement("Zone"); zoneXml; zoneXml = zoneXml->NextSiblingElement())
+    {
+        const char* zoneName = zoneXml->FirstChildElement("Name")->GetText();
+        if (!zoneName)
+        {
+            LOG_ERROR("<EditorData/Zones/Zone> missing <Name> in map editor data file.");
+            continue;
+        }
+
+        //Find zone
+        auto search = std::ranges::find_if(territory.GetObjectList("Zones"), [&](ObjectHandle zone) -> bool { return zone.Get<string>("Name") == zoneName; });
+        if (search == territory.GetObjectList("Zones").end())
+        {
+            LOG_ERROR("Failed to find zone with name '{}'", zoneName);
+            continue;
+        }
+        ObjectHandle zone = *search;
+
+        //Load object data
+        auto* objectsXml = zoneXml->FirstChildElement("Objects");
+        for (auto* objectXml = objectsXml->FirstChildElement("Object"); objectXml; objectXml = objectXml->NextSiblingElement("Object"))
+        {
+            auto* handleXml = objectXml->FirstChildElement("Handle");
+            auto* numXml = objectXml->FirstChildElement("Num");
+            if (!handleXml || !handleXml->GetText())
+            {
+                LOG_ERROR("<Object/Handle> missing in map editor data file.");
+                continue;
+            }
+            if (!numXml || !numXml->GetText())
+            {
+                LOG_ERROR("<Object/Num> missing in map editor data file.");
+                continue;
+            }
+
+            //Find object in registry
+            u32 handle = handleXml->UnsignedText();
+            u32 num = numXml->UnsignedText();
+            auto objectSearch = std::ranges::find_if(zone.GetObjectList("Objects"), [&](ObjectHandle obj) -> bool { return obj.Get<u32>("Handle") == handle && obj.Get<u32>("Num") == num; });
+            if (objectSearch == zone.GetObjectList("Objects").end())
+            {
+                LOG_ERROR("Failed to find zone object [{}, {}]", handle, num);
+                continue;
+            }
+            ObjectHandle obj = *objectSearch;
+
+            //Set name + description if present
+            auto* nameXml = objectXml->FirstChildElement("Name");
+            auto* descriptionXml = objectXml->FirstChildElement("Description");
+            if (nameXml && nameXml->GetText())
+                obj.Set<string>("Name", nameXml->GetText());
+            if (descriptionXml && descriptionXml->GetText())
+                obj.Set<string>("Description", descriptionXml->GetText());
+        }
+    }
+
+    return true;
 }

Nanoforge/rfg/import/MapImporter.cpp

@@ -92,6 +92,7 @@ ObjectHandle Importers::ImportZoneFile(ZoneFile& zoneFile, ZoneFile& persistentZ
         string classname = current->Classname();
         ObjectHandle zoneObject = registry.CreateObject(classname);
         zone.AppendObjectList("Objects", zoneObject);
+        zoneObject.Set<string>("Description", "");
         //TODO: Strip properties not needed by the editor
         zoneObject.Property("ClassnameHash").Set<u32>(current->ClassnameHash);
         zoneObject.Property("Handle").Set<u32>(current->Handle);