start refactoring, legacy load still working

Author: briaguya-ai

src/resource/archive/Archive.cpp

@@ -106,59 +106,90 @@ void Archive::AddFile(const std::string& filePath) {
     (*mHashes)[CRC64(filePath.c_str())] = filePath;
 }
 
-std::shared_ptr<File> Archive::LoadFile(const std::string& filePath) {
-    auto fileToLoad = LoadFileRaw(filePath);
+std::shared_ptr<ResourceInitData> Archive::ReadResourceInitData(const std::string& filePath, std::shared_ptr<File> metaFileToLoad) {
+
+}
 
+std::shared_ptr<ResourceInitData> Archive::ReadResourceInitDataLegacy(const std::string& filePath, std::shared_ptr<File> fileToLoad) {
     // Determine if file is binary or XML...
     if (fileToLoad->Buffer->at(0) == '<') {
         // File is XML
         // Read the xml document
         auto stream = std::make_shared<MemoryStream>(fileToLoad->Buffer);
         auto binaryReader = std::make_shared<BinaryReader>(stream);
-        fileToLoad->Reader = std::make_shared<tinyxml2::XMLDocument>();
-        auto xmlReader = std::get<std::shared_ptr<tinyxml2::XMLDocument>>(fileToLoad->Reader);
+
+        auto xmlReader = std::make_shared<tinyxml2::XMLDocument>();
 
         xmlReader->Parse(binaryReader->ReadCString().data());
         if (xmlReader->Error()) {
             SPDLOG_ERROR("Failed to parse XML file {}. Error: {}", filePath, xmlReader->ErrorStr());
             return nullptr;
         }
-        fileToLoad->InitData = ReadResourceInitDataXml(filePath, xmlReader);
+        return ReadResourceInitDataXml(filePath, xmlReader);
     } else {
-        // File is Binary
-        auto fileToLoadMeta = LoadFileMeta(filePath);
-
-        // Split out the header for reading.
-        if (fileToLoadMeta != nullptr) {
-            fileToLoad->Buffer =
-                std::make_shared<std::vector<char>>(fileToLoad->Buffer->begin(), fileToLoad->Buffer->end());
-        } else {
-            auto headerBuffer = std::make_shared<std::vector<char>>(fileToLoad->Buffer->begin(),
-                                                                    fileToLoad->Buffer->begin() + OTR_HEADER_SIZE);
-
-            if (headerBuffer->size() < OTR_HEADER_SIZE) {
-                SPDLOG_ERROR("Failed to parse ResourceInitData, buffer size too small. File: {}. Got {} bytes and "
-                             "needed {} bytes.",
-                             filePath, headerBuffer->size(), OTR_HEADER_SIZE);
-                return nullptr;
-            }
-
-            fileToLoad->Buffer = std::make_shared<std::vector<char>>(fileToLoad->Buffer->begin() + OTR_HEADER_SIZE,
-                                                                     fileToLoad->Buffer->end());
-
-            // Create a reader for the header buffer
-            auto headerStream = std::make_shared<MemoryStream>(headerBuffer);
-            auto headerReader = std::make_shared<BinaryReader>(headerStream);
-            fileToLoadMeta = ReadResourceInitDataBinary(filePath, headerReader);
+        auto headerBuffer = std::make_shared<std::vector<char>>(fileToLoad->Buffer->begin(),
+                                                                fileToLoad->Buffer->begin() + OTR_HEADER_SIZE);
+
+        if (headerBuffer->size() < OTR_HEADER_SIZE) {
+            SPDLOG_ERROR("Failed to parse ResourceInitData, buffer size too small. File: {}. Got {} bytes and "
+                            "needed {} bytes.",
+                            filePath, headerBuffer->size(), OTR_HEADER_SIZE);
+            return nullptr;
         }
 
-        // Create a reader for the data buffer
-        auto stream = std::make_shared<MemoryStream>(fileToLoad->Buffer);
-        fileToLoad->Reader = std::make_shared<BinaryReader>(stream);
+        // Factories expect the buffer to not include the header,
+        // so we need to remove it from the buffer on the file
+        fileToLoad->Buffer = std::make_shared<std::vector<char>>(fileToLoad->Buffer->begin() + OTR_HEADER_SIZE,
+                                                                    fileToLoad->Buffer->end());
+
+        // Create a reader for the header buffer
+        auto headerStream = std::make_shared<MemoryStream>(headerBuffer);
+        auto headerReader = std::make_shared<BinaryReader>(headerStream);
+        return ReadResourceInitDataBinary(filePath, headerReader);
+    }
+}
+
+std::shared_ptr<BinaryReader> Archive::CreateBinaryReader(std::shared_ptr<File> fileToLoad) {
+    auto stream = std::make_shared<MemoryStream>(fileToLoad->Buffer);
+    auto reader = std::make_shared<BinaryReader>(stream);
+    reader->SetEndianness(fileToLoad->InitData->ByteOrder);
+    return reader;
+}
+
+std::shared_ptr<tinyxml2::XMLDocument> Archive::CreateXMLReader(std::shared_ptr<File> fileToLoad) {
+    auto stream = std::make_shared<MemoryStream>(fileToLoad->Buffer);
+    auto binaryReader = std::make_shared<BinaryReader>(stream);
+
+    auto xmlReader = std::make_shared<tinyxml2::XMLDocument>();
+
+    xmlReader->Parse(binaryReader->ReadCString().data());
+    if (xmlReader->Error()) {
+        SPDLOG_ERROR("Failed to parse XML file {}. Error: {}", fileToLoad->InitData->Path, xmlReader->ErrorStr());
+        return nullptr;
+    }
+
+    return xmlReader;
+}
+
+std::shared_ptr<File> Archive::LoadFile(const std::string& filePath) {
+    auto fileToLoad = LoadFileRaw(filePath);
+
+    auto metaFilePath = filePath + ".meta";
+    auto metaFileToLoad = LoadFileRaw(metaFilePath);
+
+    if (metaFileToLoad != nullptr) {
+        fileToLoad->InitData = ReadResourceInitData(filePath, metaFileToLoad);
+    } else {
+        fileToLoad->InitData = ReadResourceInitDataLegacy(filePath, fileToLoad);
+    }
 
-        fileToLoad->InitData = fileToLoadMeta;
-        auto binaryReader = std::get<std::shared_ptr<BinaryReader>>(fileToLoad->Reader);
-        binaryReader->SetEndianness(fileToLoad->InitData->ByteOrder);
+    switch (fileToLoad->InitData->Format) {
+        case RESOURCE_FORMAT_BINARY:
+            fileToLoad->Reader = CreateBinaryReader(fileToLoad);
+            break;
+        case RESOURCE_FORMAT_XML:
+            fileToLoad->Reader = CreateXMLReader(fileToLoad);
+            break;
     }
 
     return fileToLoad;

src/resource/archive/Archive.h

@@ -53,6 +53,10 @@ class Archive {
 
   private:
     static std::shared_ptr<ResourceInitData> CreateDefaultResourceInitData();
+    std::shared_ptr<ResourceInitData> ReadResourceInitData(const std::string& filePath, std::shared_ptr<File> metaFileToLoad);
+    std::shared_ptr<ResourceInitData> ReadResourceInitDataLegacy(const std::string& filePath, std::shared_ptr<File> fileToLoad);
+    std::shared_ptr<BinaryReader> CreateBinaryReader(std::shared_ptr<File> fileToLoad);
+    std::shared_ptr<tinyxml2::XMLDocument> CreateXMLReader(std::shared_ptr<File> fileToLoad);
 
     bool mIsLoaded;
     bool mHasGameVersion;