ok so this is just a bunch of stuff

Author: briaguya-ai

src/CMakeLists.txt

@@ -325,7 +325,6 @@ set(Source_Files__Resource
     ${CMAKE_CURRENT_SOURCE_DIR}/resource/ResourceLoader.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/resource/ResourceLoader.h
     ${CMAKE_CURRENT_SOURCE_DIR}/resource/ResourceFactory.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/resource/ResourceFactory.cpp
 )
 source_group("resource" FILES ${Source_Files__Resource})
 

src/resource/File.h

@@ -11,14 +11,17 @@
 namespace LUS {
 class Archive;
 
+#define RESOURCE_FORMAT_BINARY 0
+#define RESOURCE_FORMAT_XML 1
+
 struct ResourceInitData {
     std::string Path;
     Endianness ByteOrder;
     uint32_t Type;
     int32_t ResourceVersion;
     uint64_t Id;
     bool IsCustom;
-    bool IsXml;
+    uint32_t Format;
 };
 
 struct File {

src/resource/ResourceLoader.cpp

@@ -24,29 +24,56 @@ ResourceLoader::~ResourceLoader() {
 
 void ResourceLoader::RegisterGlobalResourceFactories() {
     // include strings so we register types for mResourceTypes
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::Texture), std::make_shared<TextureFactory>());
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::Vertex), std::make_shared<VertexFactory>());
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::DisplayList), std::make_shared<DisplayListFactory>());
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::Matrix), std::make_shared<MatrixFactory>());
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::Array), std::make_shared<ArrayFactory>());
-    RegisterResourceFactory(static_cast<uint32_t>(ResourceType::Blob), std::make_shared<BlobFactory>());
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryTextureV0>(), RESOURCE_FORMAT_BINARY, "Texture", static_cast<uint32_t>(ResourceType::Texture), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryTextureV1>(), RESOURCE_FORMAT_BINARY, "Texture", static_cast<uint32_t>(ResourceType::Texture), 1);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryVertexV0>(), RESOURCE_FORMAT_BINARY, "Vertex", static_cast<uint32_t>(ResourceType::Vertex), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryXMLVertexV0>(), RESOURCE_FORMAT_XML, "Vertex", static_cast<uint32_t>(ResourceType::Vertex), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryDisplayListV0>(), RESOURCE_FORMAT_BINARY, "DisplayList", static_cast<uint32_t>(ResourceType::DisplayList), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryXMLDisplayListV0>(), RESOURCE_FORMAT_XML, "DisplayList", static_cast<uint32_t>(ResourceType::DisplayList), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryMatrixV0>(), RESOURCE_FORMAT_BINARY, "Matrix", static_cast<uint32_t>(ResourceType::Matrix), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryArrayV0>(), RESOURCE_FORMAT_BINARY, "Array", static_cast<uint32_t>(ResourceType::Array), 0);
+    RegisterResourceFactory(std::make_shared<ResourceFactoryBinaryBlobV0>(), RESOURCE_FORMAT_BINARY, "Blob", static_cast<uint32_t>(ResourceType::Blob), 0);
 }
 
 bool ResourceLoader::RegisterResourceFactory(std::shared_ptr<ResourceFactory> factory, uint32_t format, std::string typeName, uint32_t type, uint32_t version) {
     if (mResourceTypes.contains(typeName)) {
-        return false;
+        if(mResourceTypes[typeName] != type) {
+            SPDLOG_ERROR("Failed to register resource factory: conflicting types for name {}", typeName);
+            return false;
+        }
+    } else {
+        mResourceTypes[typeName] = type;
     }
-    mResourceTypes[typeName] = type;
 
     ResourceFactoryKey key = {resourceFormat: format,  resourceType: type, resourceVersion: version};
     if (mFactories.contains(key)) {
+        SPDLOG_ERROR("Failed to register resource factory: factory with key {}{}{} already exists", format, type, version);
         return false;
     }
     mFactories[key] = factory;
 
     return true;
 }
 
+std::shared_ptr<ResourceFactory> ResourceLoader::GetFactory(uint32_t format, uint32_t type, uint32_t version) {
+    ResourceFactoryKey key = {resourceFormat: format,  resourceType: type, resourceVersion: version};
+    if (!mFactories.contains(key)) {
+        SPDLOG_ERROR("Could not find resource factory with key {}{}{}", format, type, version);
+        return nullptr;
+    }
+
+    return mFactories[key];
+}
+
+std::shared_ptr<ResourceFactory> ResourceLoader::GetFactory(uint32_t format, std::string typeName, uint32_t version) {
+    if (!mResourceTypes.contains(typeName)) {
+        SPDLOG_ERROR("Could not find resource type for name {}", typeName);
+        return nullptr;
+    }
+
+    return GetFactory(format, mResourceTypes[typeName], version);
+}
+
 std::shared_ptr<IResource> ResourceLoader::LoadResource(std::shared_ptr<File> fileToLoad) {
     std::shared_ptr<IResource> result = nullptr;
 
@@ -64,7 +91,9 @@ std::shared_ptr<IResource> ResourceLoader::LoadResource(std::shared_ptr<File> fi
     // make a method that takes in a string instead of an int for the type too
     // make those protected
 
-    auto factory = mFactories[fileToLoad->InitData->Type];
+
+
+    auto factory = GetFactory(fileToLoad->InitData->IsXml) mFactories[fileToLoad->InitData->Type];
     if (factory == nullptr) {
         SPDLOG_ERROR("Failed to load resource: Factory does not exist ({} - {})", fileToLoad->InitData->Type,
                      fileToLoad->InitData->Path);

src/resource/ResourceLoader.h

@@ -23,11 +23,14 @@ class ResourceLoader {
     std::shared_ptr<IResource> LoadResource(std::shared_ptr<File> fileToLoad);
     bool RegisterResourceFactory(std::shared_ptr<ResourceFactory> factory, uint32_t format, std::string typeName, uint32_t type, uint32_t version);
 
+    uint32_t GetResourceType(const std::string& type);
+
   protected:
     void RegisterGlobalResourceFactories();
+    std::shared_ptr<ResourceFactory> GetFactory(uint32_t format, uint32_t type, uint32_t version);
+    std::shared_ptr<ResourceFactory> GetFactory(uint32_t format, std::string typeName, uint32_t version);
 
   private:
-    uint32_t GetResourceType(const std::string& type);
     std::unordered_map<std::string, uint32_t> mResourceTypes;
     std::unordered_map<ResourceFactoryKey, std::shared_ptr<ResourceFactory>> mFactories;
 };

src/resource/archive/Archive.cpp

@@ -233,7 +233,7 @@ std::shared_ptr<ResourceInitData> Archive::ReadResourceInitDataXml(const std::st
     resourceInitData->IsXml = true;
 
     auto root = document->FirstChildElement();
-    resourceInitData->Type = mFactoriesTypes[root->Name()];
+    resourceInitData->Type = Context::GetInstance()->GetResourceManager()->GetResourceLoader()->GetResourceType(root->Name());
     resourceInitData->ResourceVersion = root->IntAttribute("Version");
 
     return resourceInitData;