chore: implement obj loading skeleton with localize asset

src/Linker/ZoneCreation/ZoneCreator.cpp

@@ -58,7 +58,7 @@ namespace zone_creator
 
         AssetCreatorCollection creatorCollection(*zone);
         objCompiler->ConfigureCreatorCollection(creatorCollection, *zone, *context.m_definition);
-        objLoader->ConfigureCreatorCollection(creatorCollection);
+        objLoader->ConfigureCreatorCollection(creatorCollection, *zone, *context.m_asset_search_path);
 
         AssetCreationContext creationContext(zone.get(), &creatorCollection, &ignoredAssetLookup);
 

src/ObjLoading/Asset/AssetCreationContext.cpp

@@ -79,7 +79,7 @@ XAssetInfoGeneric* AssetCreationContext::AddAssetGeneric(GenericAssetRegistratio
     return addedAsset;
 }
 
-XAssetInfoGeneric* AssetCreationContext::LoadDefaultAssetDependency(const asset_type_t assetType, const std::string& assetName) const
+XAssetInfoGeneric* AssetCreationContext::LoadDefaultAssetDependency(const asset_type_t assetType, const std::string& assetName)
 {
     const auto result = m_creators->CreateDefaultAsset(assetType, assetName, *this);
     if (result.HasTakenAction() && !result.HasFailed())

src/ObjLoading/Asset/AssetCreationContext.h

@@ -39,6 +39,13 @@ public:
         return static_cast<XAssetInfo<typename AssetType::Type>*>(AddAssetGeneric(std::move(registration)));
     }
 
+    template<typename AssetType> XAssetInfo<typename AssetType::Type>* AddAsset(std::string assetName, typename AssetType::Type* asset)
+    {
+        static_assert(std::is_base_of_v<IAssetBase, AssetType>);
+
+        return static_cast<XAssetInfo<typename AssetType::Type>*>(AddAssetGeneric(AssetRegistration<AssetType>(std::move(assetName), asset)));
+    }
+
     XAssetInfoGeneric* AddAssetGeneric(GenericAssetRegistration registration) const;
 
     template<typename AssetType> XAssetInfo<typename AssetType::Type>* LoadDependency(const std::string& assetName)
@@ -76,7 +83,7 @@ public:
     }
 
 private:
-    [[nodiscard]] XAssetInfoGeneric* LoadDefaultAssetDependency(asset_type_t assetType, const std::string& assetName) const;
+    [[nodiscard]] XAssetInfoGeneric* LoadDefaultAssetDependency(asset_type_t assetType, const std::string& assetName);
 
     Zone* m_zone;
     const AssetCreatorCollection* m_creators;

src/ObjLoading/Asset/AssetCreatorCollection.cpp

@@ -44,15 +44,13 @@ AssetCreationResult AssetCreatorCollection::CreateAsset(const asset_type_t asset
     return AssetCreationResult::NoAction();
 }
 
-AssetCreationResult
+AssetCreationResult AssetCreatorCollection::CreateDefaultAsset(const asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const
-    AssetCreatorCollection::CreateDefaultAsset(const asset_type_t assetType, const std::string& assetName, const AssetCreationContext& context) const
 {
     assert(assetType >= 0 && static_cast<unsigned>(assetType) < m_default_asset_creators_by_type.size());
 
     if (assetType >= 0 && static_cast<unsigned>(assetType) < m_default_asset_creators_by_type.size() && m_default_asset_creators_by_type[assetType])
     {
-        auto defaultAsset = m_default_asset_creators_by_type[assetType]->CreateDefaultAsset(assetName);
+        return m_default_asset_creators_by_type[assetType]->CreateDefaultAsset(assetName, context);
-        return AssetCreationResult::Success(context.AddAssetGeneric(std::move(defaultAsset)));
     }
 
     return AssetCreationResult::NoAction();

src/ObjLoading/Asset/AssetCreatorCollection.h

@@ -22,7 +22,7 @@ public:
     void AddDefaultAssetCreator(std::unique_ptr<IDefaultAssetCreator> defaultAssetCreator);
 
     AssetCreationResult CreateAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
-    AssetCreationResult CreateDefaultAsset(asset_type_t assetType, const std::string& assetName, const AssetCreationContext& context) const;
+    AssetCreationResult CreateDefaultAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
     void FinalizeZone(AssetCreationContext& context) const;
 
 private:

src/ObjLoading/Asset/GlobalAssetPoolsLoader.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "Asset/IAssetCreator.h"
+#include "Pool/GlobalAssetPool.h"
+
+template<typename AssetType> class GlobalAssetPoolsLoader : public AssetCreator<AssetType>
+{
+public:
+    static_assert(std::is_base_of_v<IAssetBase, AssetType>);
+
+    GlobalAssetPoolsLoader(Zone& zone)
+        : m_zone(zone)
+    {
+    }
+
+    AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
+    {
+        auto* existingAsset = GlobalAssetPool<typename AssetType::Type>::GetAssetByName(assetName);
+
+        if (!existingAsset)
+            return AssetCreationResult::Failure();
+
+        AssetRegistration<AssetType> registration(assetName, existingAsset->Asset());
+
+        for (const auto* dependency : existingAsset->m_dependencies)
+        {
+            auto* newDependency = context.LoadDependencyGeneric(dependency->m_type, dependency->m_name);
+            if (newDependency)
+                registration.AddDependency(newDependency);
+            else
+                return AssetCreationResult::Failure();
+        }
+
+        for (const auto& indirectAssetReference : existingAsset->m_indirect_asset_references)
+            registration.AddIndirectAssetReference(context.LoadIndirectAssetReferenceGeneric(indirectAssetReference.m_type, indirectAssetReference.m_name));
+
+        // Make sure any used script string is available in the created zone
+        // The replacement of the scr_string_t values will be done upon writing
+        for (const auto scrString : existingAsset->m_used_script_strings)
+            m_zone.m_script_strings.AddOrGetScriptString(existingAsset->m_zone->m_script_strings.CValue(scrString));
+
+        return AssetCreationResult::Success(context.AddAsset(std::move(registration)));
+    }
+
+private:
+    Zone& m_zone;
+};

src/ObjLoading/Asset/IAssetCreator.cpp

@@ -15,6 +15,11 @@ AssetCreationResult AssetCreationResult::NoAction()
     return AssetCreationResult(false, nullptr);
 }
 
+bool AssetCreationResult::HasBeenSuccessful() const
+{
+    return m_taken_action && m_asset_info != nullptr;
+}
+
 bool AssetCreationResult::HasTakenAction() const
 {
     return m_taken_action;

src/ObjLoading/Asset/IAssetCreator.h

@@ -17,6 +17,7 @@ public:
     static AssetCreationResult Failure();
     static AssetCreationResult NoAction();
 
+    [[nodiscard]] bool HasBeenSuccessful() const;
     [[nodiscard]] bool HasTakenAction() const;
     [[nodiscard]] bool HasFailed() const;
     [[nodiscard]] XAssetInfoGeneric* GetAssetInfo() const;

src/ObjLoading/Asset/IDefaultAssetCreator.h

@@ -1,16 +1,15 @@
 #pragma once
 
 #include "AssetCreationContext.h"
-#include "AssetRegistration.h"
 #include "Game/IAsset.h"
-#include "Utils/MemoryManager.h"
+#include "IAssetCreator.h"
 #include "Zone/ZoneTypes.h"
 
 #include <string>
 #include <type_traits>
 
-class GenericAssetRegistration;
+class AssetCreationResult;
-template<typename AssetType> class AssetRegistration;
+class AssetCreationContext;
 
 class IDefaultAssetCreator
 {
@@ -23,7 +22,7 @@ public:
     IDefaultAssetCreator& operator=(IDefaultAssetCreator&& other) noexcept = default;
 
     [[nodiscard]] virtual asset_type_t GetHandlingAssetType() const = 0;
-    virtual GenericAssetRegistration CreateDefaultAsset(const std::string& assetName) const = 0;
+    virtual AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const = 0;
 };
 
 template<typename AssetType> class DefaultAssetCreator : public IDefaultAssetCreator
@@ -35,12 +34,4 @@ public:
     {
         return AssetType::EnumEntry;
     }
-
-    GenericAssetRegistration CreateDefaultAsset(const std::string& assetName) const override
-    {
-        return CreateDefaultAssetInternal(assetName);
-    }
-
-protected:
-    virtual AssetRegistration<typename AssetType::Type> CreateDefaultAssetInternal(const std::string& assetName) const = 0;
 };

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderGfxImage.h

@@ -1,17 +0,0 @@
-#pragma once
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/IW3/IW3.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace IW3
-{
-    class AssetLoaderGfxImage final : public BasicAssetLoader<AssetImage>
-    {
-    public:
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace IW3

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,36 +0,0 @@
-#include "AssetLoaderLocalizeEntry.h"
-
-#include "Localize/LocalizeCommonAssetLoader.h"
-
-using namespace IW3;
-
-XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
-{
-    return nullptr;
-}
-
-void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    return nullptr;
-}
-
-bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderLocalizeEntry::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const LocalizeCommonAssetLoader commonLoader(
-        [memory, manager](const CommonLocalizeEntry& entry)
-        {
-            auto* localizeEntry = memory->Create<LocalizeEntry>();
-            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-            localizeEntry->value = memory->Dup(entry.m_value.c_str());
-
-            manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
-        });
-
-    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
-}

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/IW3/IW3.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace IW3
-{
-    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
-    {
-    public:
-        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace IW3

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderRawFile.cpp

@@ -1,44 +0,0 @@
-#include "AssetLoaderRawFile.h"
-
-#include "Game/IW3/IW3.h"
-#include "Pool/GlobalAssetPool.h"
-
-#include <cstring>
-
-using namespace IW3;
-
-void* AssetLoaderRawFile::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    auto* rawFile = memory->Create<RawFile>();
-    memset(rawFile, 0, sizeof(RawFile));
-    rawFile->name = memory->Dup(assetName.c_str());
-    return rawFile;
-}
-
-bool AssetLoaderRawFile::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderRawFile::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const auto file = searchPath->Open(assetName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* rawFile = memory->Create<RawFile>();
-    rawFile->name = memory->Dup(assetName.c_str());
-    rawFile->len = static_cast<int>(file.m_length);
-
-    auto* fileBuffer = memory->Alloc<char>(static_cast<size_t>(file.m_length + 1));
-    file.m_stream->read(fileBuffer, file.m_length);
-    if (file.m_stream->gcount() != file.m_length)
-        return false;
-    fileBuffer[rawFile->len] = '\0';
-
-    rawFile->buffer = fileBuffer;
-    manager->AddAsset<AssetRawFile>(assetName, rawFile);
-
-    return true;
-}

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderRawFile.h

@@ -1,17 +0,0 @@
-#pragma once
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/IW3/IW3.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace IW3
-{
-    class AssetLoaderRawFile final : public BasicAssetLoader<AssetRawFile>
-    {
-    public:
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace IW3

src/ObjLoading/Game/IW3/Image/AssetLoaderImageIW3.cpp

@@ -1,4 +1,4 @@
-#include "AssetLoaderGfxImage.h"
+#include "AssetLoaderImageIW3.h"
 
 #include "Game/IW3/IW3.h"
 #include "Image/DdsLoader.h"
@@ -12,43 +12,35 @@
 
 using namespace IW3;
 
-void* AssetLoaderGfxImage::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+AssetLoaderImage::AssetLoaderImage(MemoryManager& memory, ISearchPath& searchPath)
+    : m_memory(memory),
+      m_search_path(searchPath)
 {
-    auto* image = memory->Create<GfxImage>();
-    memset(image, 0, sizeof(GfxImage));
-    image->name = memory->Dup(assetName.c_str());
-    return image;
 }
 
-bool AssetLoaderGfxImage::CanLoadFromRaw() const
+AssetCreationResult AssetLoaderImage::CreateAsset(const std::string& assetName, AssetCreationContext& context)
-{
-    return true;
-}
-
-bool AssetLoaderGfxImage::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
     // Do not load any GfxImages from raw for now that are not loaded
     // TODO: Load iwis and add streaming info to asset
     if (assetName.empty() || assetName[0] != '*')
-        return false;
+        return AssetCreationResult::NoAction();
 
     std::string safeAssetName = assetName;
     std::ranges::replace(safeAssetName, '*', '_');
 
-    const auto file = searchPath->Open(std::format("images/{}.dds", safeAssetName));
+    const auto file = m_search_path.Open(std::format("images/{}.dds", safeAssetName));
     if (!file.IsOpen())
-        return false;
+        return AssetCreationResult::NoAction();
 
     const auto texture = dds::LoadDds(*file.m_stream);
     if (!texture)
     {
         std::cerr << std::format("Failed to load dds file for image asset \"{}\"\n", assetName);
-        return false;
+        return AssetCreationResult::Failure();
     }
 
-    auto* image = memory->Create<GfxImage>();
+    auto* image = m_memory.Alloc<GfxImage>();
-    image->name = memory->Dup(assetName.c_str());
+    image->name = m_memory.Dup(assetName.c_str());
     image->picmip.platform[0] = 0;
     image->picmip.platform[1] = 0;
     image->noPicmip = !texture->HasMipMaps();
@@ -88,7 +80,7 @@ bool AssetLoaderGfxImage::LoadFromRaw(
     for (auto mipLevel = 0; mipLevel < mipCount; mipLevel++)
         dataSize += texture->GetSizeOfMipLevel(mipLevel) * faceCount;
 
-    auto* loadDef = static_cast<GfxImageLoadDef*>(zone->GetMemory()->AllocRaw(offsetof(GfxImageLoadDef, data) + dataSize));
+    auto* loadDef = static_cast<GfxImageLoadDef*>(m_memory.AllocRaw(offsetof(GfxImageLoadDef, data) + dataSize));
     image->texture.loadDef = loadDef;
     loadDef->levelCount = static_cast<char>(mipCount);
     loadDef->flags = 0;
@@ -116,7 +108,5 @@ bool AssetLoaderGfxImage::LoadFromRaw(
         }
     }
 
-    manager->AddAsset<AssetImage>(assetName, image);
+    return AssetCreationResult::Success(context.AddAsset<AssetImage>(assetName, image));
-
-    return true;
 }

src/ObjLoading/Game/IW3/Image/AssetLoaderImageIW3.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW3
+{
+    class AssetLoaderImage final : public AssetCreator<AssetImage>
+    {
+    public:
+        AssetLoaderImage(MemoryManager& memory, ISearchPath& searchPath);
+
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+        ISearchPath& m_search_path;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/Image/DefaultCreatorImageIW3.cpp

@@ -0,0 +1,16 @@
+#include "DefaultCreatorImageIW3.h"
+
+using namespace IW3;
+
+DefaultCreatorImage::DefaultCreatorImage(MemoryManager& memory)
+    : m_memory(memory)
+{
+}
+
+AssetCreationResult DefaultCreatorImage::CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const
+{
+    auto* asset = m_memory.Alloc<GfxImage>();
+    asset->name = m_memory.Dup(assetName.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetImage>(assetName, asset));
+}

src/ObjLoading/Game/IW3/Image/DefaultCreatorImageIW3.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Asset/IDefaultAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW3
+{
+    class DefaultCreatorImage : public DefaultAssetCreator<AssetImage>
+    {
+    public:
+        explicit DefaultCreatorImage(MemoryManager& memory);
+        AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/Localize/AssetLoaderLocalizeIW3.cpp

@@ -0,0 +1,23 @@
+#include "AssetLoaderLocalizeIW3.h"
+
+using namespace IW3;
+
+AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
+    : CommonLocalizeLoader(searchPath, zone),
+      m_memory(memory)
+{
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    return CreateLocalizeAsset(assetName, context);
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
+{
+    auto* asset = m_memory.Alloc<LocalizeEntry>();
+    asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
+    asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
+}

src/ObjLoading/Game/IW3/Localize/AssetLoaderLocalizeIW3.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "Localize/CommonLocalizeLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW3
+{
+    class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
+    {
+    public:
+        AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    protected:
+        AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp

@@ -1,77 +1,123 @@
 #include "ObjLoaderIW3.h"
 
-#include "AssetLoaders/AssetLoaderGfxImage.h"
+#include "Asset/GlobalAssetPoolsLoader.h"
-#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
-#include "AssetLoaders/AssetLoaderRawFile.h"
-#include "AssetLoading/AssetLoadingManager.h"
 #include "Game/IW3/GameIW3.h"
+#include "Game/IW3/IW3.h"
+#include "Image/AssetLoaderImageIW3.h"
+#include "Image/DefaultCreatorImageIW3.h"
+#include "Localize/AssetLoaderLocalizeIW3.h"
 #include "ObjLoading.h"
 
+#include <memory>
+
 using namespace IW3;
 
-ObjLoader::ObjLoader()
-{
-#define REGISTER_ASSET_LOADER(t)                                                                                                                               \
-    {                                                                                                                                                          \
-        auto l = std::make_unique<t>();                                                                                                                        \
-        m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);                                                                                     \
-    }
-
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysPreset>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXAnim>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXModel>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMaterial>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetTechniqueSet>)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSound>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundCurve>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLoadedSound>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMap>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMapPvs>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetComWorld>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldSp>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldMp>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMapEnts>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGfxWorld>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLightDef>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFont>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenuList>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenu>)
-    REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetWeapon>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundDriverGlobals>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFx>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImpactFx>)
-    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetStringTable>)
-
-#undef REGISTER_ASSET_LOADER
-}
-
-bool ObjLoader::IsMpZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
-}
-
-bool ObjLoader::IsZmZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
-}
-
 void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
 
 void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
 
-void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
+namespace
-
-bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
 {
-    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
-    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+    {
-}
+        auto& memory = *zone.GetMemory();
 
-void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
+        collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
+    }
+
+    void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
+    {
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
+    }
+
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
+    {
+        auto& memory = *zone.GetMemory();
+
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
+        collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory, searchPath));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
+        collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
+    }
+} // namespace
+
+void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
 {
-    for (const auto& [type, loader] : m_asset_loaders_by_type)
+    ConfigureDefaultCreators(collection, zone, searchPath);
-        loader->FinalizeAssetsForZone(context);
+    ConfigureGlobalAssetPoolsLoaders(collection, zone);
 }

src/ObjLoading/Game/IW3/ObjLoaderIW3.h

@@ -1,30 +1,16 @@
 #pragma once
 
-#include "AssetLoading/IAssetLoader.h"
 #include "IObjLoader.h"
 #include "SearchPath/ISearchPath.h"
 
-#include <memory>
-#include <unordered_map>
-
 namespace IW3
 {
     class ObjLoader final : public IObjLoader
     {
-        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
-
-        static bool IsMpZone(const Zone& zone);
-        static bool IsZmZone(const Zone& zone);
-
     public:
-        ObjLoader();
-
         void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
         void UnloadContainersOfZone(Zone& zone) const override;
 
-        void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
+        void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
-
-        bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
-        void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
     };
 } // namespace IW3

src/ObjLoading/Game/IW3/RawFile/AssetLoaderRawFileIW3.cpp

@@ -0,0 +1,35 @@
+#include "AssetLoaderRawFileIW3.h"
+
+#include "Game/IW3/IW3.h"
+#include "Pool/GlobalAssetPool.h"
+
+#include <cstring>
+
+using namespace IW3;
+
+AssetLoaderRawFile::AssetLoaderRawFile(MemoryManager& memory, ISearchPath& searchPath)
+    : m_memory(memory),
+      m_search_path(searchPath)
+{
+}
+
+AssetCreationResult AssetLoaderRawFile::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    const auto file = m_search_path.Open(assetName);
+    if (!file.IsOpen())
+        return AssetCreationResult::NoAction();
+
+    auto* rawFile = m_memory.Alloc<RawFile>();
+    rawFile->name = m_memory.Dup(assetName.c_str());
+    rawFile->len = static_cast<int>(file.m_length);
+
+    auto* fileBuffer = m_memory.Alloc<char>(static_cast<size_t>(file.m_length + 1));
+    file.m_stream->read(fileBuffer, file.m_length);
+    if (file.m_stream->gcount() != file.m_length)
+        return AssetCreationResult::Failure();
+    fileBuffer[rawFile->len] = '\0';
+
+    rawFile->buffer = fileBuffer;
+
+    return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, rawFile));
+}

src/ObjLoading/Game/IW3/RawFile/AssetLoaderRawFileIW3.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW3
+{
+    class AssetLoaderRawFile final : public AssetCreator<AssetRawFile>
+    {
+    public:
+        AssetLoaderRawFile(MemoryManager& memory, ISearchPath& searchPath);
+
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+        ISearchPath& m_search_path;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/RawFile/DefaultCreatorRawFileIW3.cpp

@@ -0,0 +1,16 @@
+#include "DefaultCreatorRawFileIW3.h"
+
+using namespace IW3;
+
+DefaultCreatorRawFile::DefaultCreatorRawFile(MemoryManager& memory)
+    : m_memory(memory)
+{
+}
+
+AssetCreationResult DefaultCreatorRawFile::CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const
+{
+    auto* asset = m_memory.Alloc<RawFile>();
+    asset->name = m_memory.Dup(assetName.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, asset));
+}

src/ObjLoading/Game/IW3/RawFile/DefaultCreatorRawFileIW3.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Asset/IDefaultAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW3
+{
+    class DefaultCreatorRawFile : public DefaultAssetCreator<AssetRawFile>
+    {
+    public:
+        explicit DefaultCreatorRawFile(MemoryManager& memory);
+        AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,36 +0,0 @@
-#include "AssetLoaderLocalizeEntry.h"
-
-#include "Localize/LocalizeCommonAssetLoader.h"
-
-using namespace IW4;
-
-XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
-{
-    return nullptr;
-}
-
-void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    return nullptr;
-}
-
-bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderLocalizeEntry::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const LocalizeCommonAssetLoader commonLoader(
-        [memory, manager](const CommonLocalizeEntry& entry)
-        {
-            auto* localizeEntry = memory->Create<LocalizeEntry>();
-            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-            localizeEntry->value = memory->Dup(entry.m_value.c_str());
-
-            manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
-        });
-
-    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
-}

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/IW4/IW4.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace IW4
-{
-    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
-    {
-    public:
-        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace IW4

src/ObjLoading/Game/IW4/Localize/AssetLoaderLocalizeIW4.cpp

@@ -0,0 +1,23 @@
+#include "AssetLoaderLocalizeIW4.h"
+
+using namespace IW4;
+
+AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
+    : CommonLocalizeLoader(searchPath, zone),
+      m_memory(memory)
+{
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    return CreateLocalizeAsset(assetName, context);
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
+{
+    auto* asset = m_memory.Alloc<LocalizeEntry>();
+    asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
+    asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
+}

src/ObjLoading/Game/IW4/Localize/AssetLoaderLocalizeIW4.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Asset/AssetCreationContext.h"
+#include "Asset/IAssetCreator.h"
+#include "Game/IW4/IW4.h"
+#include "Localize/CommonLocalizeLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+#include "Zone/Zone.h"
+
+namespace IW4
+{
+    class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
+    {
+    public:
+        AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    protected:
+        AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace IW4

src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp

@@ -1,121 +1,150 @@
 #include "ObjLoaderIW4.h"
 
-#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
+#include "Asset/GlobalAssetPoolsLoader.h"
-#include "AssetLoaders/AssetLoaderClipMap.h"
-#include "AssetLoaders/AssetLoaderComWorld.h"
-#include "AssetLoaders/AssetLoaderFont.h"
-#include "AssetLoaders/AssetLoaderFx.h"
-#include "AssetLoaders/AssetLoaderFxImpactTable.h"
-#include "AssetLoaders/AssetLoaderFxWorld.h"
-#include "AssetLoaders/AssetLoaderGameWorldMp.h"
-#include "AssetLoaders/AssetLoaderGameWorldSp.h"
-#include "AssetLoaders/AssetLoaderGfxImage.h"
-#include "AssetLoaders/AssetLoaderGfxLightDef.h"
-#include "AssetLoaders/AssetLoaderGfxWorld.h"
-#include "AssetLoaders/AssetLoaderLeaderboard.h"
-#include "AssetLoaders/AssetLoaderLoadedSound.h"
-#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
-#include "AssetLoaders/AssetLoaderMapEnts.h"
-#include "AssetLoaders/AssetLoaderMaterial.h"
-#include "AssetLoaders/AssetLoaderMenuDef.h"
-#include "AssetLoaders/AssetLoaderMenuList.h"
-#include "AssetLoaders/AssetLoaderPhysCollmap.h"
-#include "AssetLoaders/AssetLoaderPhysPreset.h"
-#include "AssetLoaders/AssetLoaderPixelShader.h"
-#include "AssetLoaders/AssetLoaderRawFile.h"
-#include "AssetLoaders/AssetLoaderSndCurve.h"
-#include "AssetLoaders/AssetLoaderSoundAliasList.h"
-#include "AssetLoaders/AssetLoaderStringTable.h"
-#include "AssetLoaders/AssetLoaderStructuredDataDefSet.h"
-#include "AssetLoaders/AssetLoaderTechniqueSet.h"
-#include "AssetLoaders/AssetLoaderTracer.h"
-#include "AssetLoaders/AssetLoaderVehicle.h"
-#include "AssetLoaders/AssetLoaderVertexDecl.h"
-#include "AssetLoaders/AssetLoaderVertexShader.h"
-#include "AssetLoaders/AssetLoaderWeapon.h"
-#include "AssetLoaders/AssetLoaderXAnim.h"
-#include "AssetLoaders/AssetLoaderXModel.h"
-#include "AssetLoaders/AssetLoaderXModelSurfs.h"
-#include "AssetLoading/AssetLoadingManager.h"
 #include "Game/IW4/GameIW4.h"
-#include "Image/IwiLoader.h"
+#include "Game/IW4/IW4.h"
-#include "ObjContainer/IPak/IPak.h"
+#include "Localize/AssetLoaderLocalizeIW4.h"
+#include "ObjLoading.h"
+
+#include <memory>
 
 using namespace IW4;
 
-ObjLoader::ObjLoader()
-{
-#define REGISTER_ASSET_LOADER(t)                                                                                                                               \
-    {                                                                                                                                                          \
-        auto l = std::make_unique<t>();                                                                                                                        \
-        m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);                                                                                     \
-    }
-
-    REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
-    REGISTER_ASSET_LOADER(AssetLoaderPhysCollmap)
-    REGISTER_ASSET_LOADER(AssetLoaderXAnim)
-    REGISTER_ASSET_LOADER(AssetLoaderXModelSurfs)
-    REGISTER_ASSET_LOADER(AssetLoaderXModel)
-    REGISTER_ASSET_LOADER(AssetLoaderMaterial)
-    REGISTER_ASSET_LOADER(AssetLoaderPixelShader)
-    REGISTER_ASSET_LOADER(AssetLoaderVertexShader)
-    REGISTER_ASSET_LOADER(AssetLoaderVertexDecl)
-    REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
-    REGISTER_ASSET_LOADER(AssetLoaderSoundAliasList)
-    REGISTER_ASSET_LOADER(AssetLoaderSndCurve)
-    REGISTER_ASSET_LOADER(AssetLoaderLoadedSound)
-    REGISTER_ASSET_LOADER(AssetLoaderClipMapSp)
-    REGISTER_ASSET_LOADER(AssetLoaderClipMapMp)
-    REGISTER_ASSET_LOADER(AssetLoaderComWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGameWorldSp)
-    REGISTER_ASSET_LOADER(AssetLoaderGameWorldMp)
-    REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
-    REGISTER_ASSET_LOADER(AssetLoaderFxWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
-    REGISTER_ASSET_LOADER(AssetLoaderFont)
-    REGISTER_ASSET_LOADER(AssetLoaderMenuList)
-    REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
-    REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-    REGISTER_ASSET_LOADER(AssetLoaderWeapon)
-    REGISTER_ASSET_LOADER(AssetLoaderFx)
-    REGISTER_ASSET_LOADER(AssetLoaderFxImpactTable)
-    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
-    REGISTER_ASSET_LOADER(AssetLoaderStringTable)
-    REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
-    REGISTER_ASSET_LOADER(AssetLoaderStructuredDataDefSet)
-    REGISTER_ASSET_LOADER(AssetLoaderTracer)
-    REGISTER_ASSET_LOADER(AssetLoaderVehicle)
-    REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
-
-#undef REGISTER_ASSET_LOADER
-}
-
-bool ObjLoader::IsMpZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
-}
-
-bool ObjLoader::IsZmZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
-}
-
 void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
 
 void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
 
-void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
+namespace
-
-bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const
 {
-    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
-    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+    {
-}
+        auto& memory = *zone.GetMemory();
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysCollMap>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModelSurfs>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPixelShader>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexShader>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexDecl>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapSp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapMp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLeaderboard>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStructuredDataDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTracer>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicle>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAddonMapEnts>(memory));
+    }
 
-void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
+    void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
+    {
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysCollMap>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModelSurfs>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPixelShader>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexShader>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexDecl>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapSp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapMp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStructuredDataDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
+    }
+
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
+    {
+        auto& memory = *zone.GetMemory();
+
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysCollMap>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPixelShader>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexShader>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexDecl>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapSp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapMp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
+        collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStructuredDataDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
+    }
+} // namespace
+
+void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
 {
-    for (const auto& [type, loader] : m_asset_loaders_by_type)
+    ConfigureDefaultCreators(collection, zone, searchPath);
-        loader->FinalizeAssetsForZone(context);
+    ConfigureGlobalAssetPoolsLoaders(collection, zone);
 }

src/ObjLoading/Game/IW4/ObjLoaderIW4.h

@@ -3,29 +3,16 @@
 #include "AssetLoading/IAssetLoader.h"
 #include "IObjLoader.h"
 #include "SearchPath/ISearchPath.h"
-
+#include "Zone/Zone.h"
-#include <memory>
-#include <unordered_map>
 
 namespace IW4
 {
     class ObjLoader final : public IObjLoader
     {
     public:
-        ObjLoader();
-
         void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
         void UnloadContainersOfZone(Zone& zone) const override;
 
-        void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
+        void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
-
-        bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
-        void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
-
-    private:
-        static bool IsMpZone(const Zone& zone);
-        static bool IsZmZone(const Zone& zone);
-
-        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
     };
 } // namespace IW4

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,36 +0,0 @@
-#include "AssetLoaderLocalizeEntry.h"
-
-#include "Localize/LocalizeCommonAssetLoader.h"
-
-using namespace IW5;
-
-XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
-{
-    return nullptr;
-}
-
-void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    return nullptr;
-}
-
-bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderLocalizeEntry::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const LocalizeCommonAssetLoader commonLoader(
-        [memory, manager](const CommonLocalizeEntry& entry)
-        {
-            auto* localizeEntry = memory->Create<LocalizeEntry>();
-            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-            localizeEntry->value = memory->Dup(entry.m_value.c_str());
-
-            manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
-        });
-
-    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
-}

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/IW5/IW5.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace IW5
-{
-    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
-    {
-    public:
-        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace IW5

src/ObjLoading/Game/IW5/Localize/AssetLoaderLocalizeIW5.cpp

@@ -0,0 +1,23 @@
+#include "AssetLoaderLocalizeIW5.h"
+
+using namespace IW5;
+
+AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
+    : CommonLocalizeLoader(searchPath, zone),
+      m_memory(memory)
+{
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    return CreateLocalizeAsset(assetName, context);
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
+{
+    auto* asset = m_memory.Alloc<LocalizeEntry>();
+    asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
+    asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
+}

src/ObjLoading/Game/IW5/Localize/AssetLoaderLocalizeIW5.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Asset/AssetCreationContext.h"
+#include "Asset/IAssetCreator.h"
+#include "Game/IW5/IW5.h"
+#include "Localize/CommonLocalizeLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+#include "Zone/Zone.h"
+
+namespace IW5
+{
+    class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
+    {
+    public:
+        AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    protected:
+        AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace IW5

src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp

@@ -1,128 +1,158 @@
 #include "ObjLoaderIW5.h"
 
-#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
+#include "Asset/GlobalAssetPoolsLoader.h"
-#include "AssetLoaders/AssetLoaderClipMap.h"
-#include "AssetLoaders/AssetLoaderComWorld.h"
-#include "AssetLoaders/AssetLoaderFont.h"
-#include "AssetLoaders/AssetLoaderFx.h"
-#include "AssetLoaders/AssetLoaderFxImpactTable.h"
-#include "AssetLoaders/AssetLoaderFxWorld.h"
-#include "AssetLoaders/AssetLoaderGfxImage.h"
-#include "AssetLoaders/AssetLoaderGfxLightDef.h"
-#include "AssetLoaders/AssetLoaderGfxWorld.h"
-#include "AssetLoaders/AssetLoaderGlassWorld.h"
-#include "AssetLoaders/AssetLoaderLeaderboard.h"
-#include "AssetLoaders/AssetLoaderLoadedSound.h"
-#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
-#include "AssetLoaders/AssetLoaderMapEnts.h"
-#include "AssetLoaders/AssetLoaderMaterial.h"
-#include "AssetLoaders/AssetLoaderMenuDef.h"
-#include "AssetLoaders/AssetLoaderMenuList.h"
-#include "AssetLoaders/AssetLoaderPathData.h"
-#include "AssetLoaders/AssetLoaderPhysCollmap.h"
-#include "AssetLoaders/AssetLoaderPhysPreset.h"
-#include "AssetLoaders/AssetLoaderPixelShader.h"
-#include "AssetLoaders/AssetLoaderRawFile.h"
-#include "AssetLoaders/AssetLoaderScriptFile.h"
-#include "AssetLoaders/AssetLoaderSoundAliasList.h"
-#include "AssetLoaders/AssetLoaderSoundCurve.h"
-#include "AssetLoaders/AssetLoaderStringTable.h"
-#include "AssetLoaders/AssetLoaderStructuredDataDef.h"
-#include "AssetLoaders/AssetLoaderSurfaceFxTable.h"
-#include "AssetLoaders/AssetLoaderTechniqueSet.h"
-#include "AssetLoaders/AssetLoaderTracerDef.h"
-#include "AssetLoaders/AssetLoaderVehicleDef.h"
-#include "AssetLoaders/AssetLoaderVehicleTrack.h"
-#include "AssetLoaders/AssetLoaderVertexDecl.h"
-#include "AssetLoaders/AssetLoaderVertexShader.h"
-#include "AssetLoaders/AssetLoaderWeapon.h"
-#include "AssetLoaders/AssetLoaderWeaponAttachment.h"
-#include "AssetLoaders/AssetLoaderXAnim.h"
-#include "AssetLoaders/AssetLoaderXModel.h"
-#include "AssetLoaders/AssetLoaderXModelSurfs.h"
-#include "AssetLoading/AssetLoadingManager.h"
 #include "Game/IW5/GameIW5.h"
-#include "Image/IwiLoader.h"
+#include "Game/IW5/IW5.h"
-#include "ObjContainer/IPak/IPak.h"
+#include "Localize/AssetLoaderLocalizeIW5.h"
+#include "ObjLoading.h"
+
+#include <memory>
 
 using namespace IW5;
 
-ObjLoader::ObjLoader()
-{
-#define REGISTER_ASSET_LOADER(t)                                                                                                                               \
-    {                                                                                                                                                          \
-        auto l = std::make_unique<t>();                                                                                                                        \
-        m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);                                                                                     \
-    }
-
-    REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
-    REGISTER_ASSET_LOADER(AssetLoaderPhysCollmap)
-    REGISTER_ASSET_LOADER(AssetLoaderXAnim)
-    REGISTER_ASSET_LOADER(AssetLoaderXModelSurfs)
-    REGISTER_ASSET_LOADER(AssetLoaderXModel)
-    REGISTER_ASSET_LOADER(AssetLoaderMaterial)
-    REGISTER_ASSET_LOADER(AssetLoaderPixelShader)
-    REGISTER_ASSET_LOADER(AssetLoaderVertexShader)
-    REGISTER_ASSET_LOADER(AssetLoaderVertexDecl)
-    REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
-    REGISTER_ASSET_LOADER(AssetLoaderSoundAliasList)
-    REGISTER_ASSET_LOADER(AssetLoaderSoundCurve)
-    REGISTER_ASSET_LOADER(AssetLoaderLoadedSound)
-    REGISTER_ASSET_LOADER(AssetLoaderClipMap)
-    REGISTER_ASSET_LOADER(AssetLoaderComWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGlassWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderPathData)
-    REGISTER_ASSET_LOADER(AssetLoaderVehicleTrack)
-    REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
-    REGISTER_ASSET_LOADER(AssetLoaderFxWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
-    REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
-    REGISTER_ASSET_LOADER(AssetLoaderFont)
-    REGISTER_ASSET_LOADER(AssetLoaderMenuList)
-    REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
-    REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-    REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachment)
-    REGISTER_ASSET_LOADER(AssetLoaderWeapon)
-    REGISTER_ASSET_LOADER(AssetLoaderFx)
-    REGISTER_ASSET_LOADER(AssetLoaderFxImpactTable)
-    REGISTER_ASSET_LOADER(AssetLoaderSurfaceFxTable)
-    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
-    REGISTER_ASSET_LOADER(AssetLoaderScriptFile)
-    REGISTER_ASSET_LOADER(AssetLoaderStringTable)
-    REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
-    REGISTER_ASSET_LOADER(AssetLoaderStructuredDataDef)
-    REGISTER_ASSET_LOADER(AssetLoaderTracerDef)
-    REGISTER_ASSET_LOADER(AssetLoaderVehicleDef)
-    REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
-
-#undef REGISTER_ASSET_LOADER
-}
-
-bool ObjLoader::IsMpZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
-}
-
-bool ObjLoader::IsZmZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
-}
-
 void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
 
 void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
 
-void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
+namespace
-
-bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
 {
-    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
-    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+    {
-}
+        auto& memory = *zone.GetMemory();
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysCollMap>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModelSurfs>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPixelShader>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexShader>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVertexDecl>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundCurve>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLoadedSound>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlassWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPathData>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicleTrack>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAttachment>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSurfaceFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorScript>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLeaderboard>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStructuredDataDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTracer>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorVehicle>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorAddonMapEnts>(memory));
+    }
 
-void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
+    void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
+    {
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysCollMap>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModelSurfs>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPixelShader>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexShader>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVertexDecl>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLoadedSound>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlassWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPathData>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicleTrack>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachment>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSurfaceFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetScript>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStructuredDataDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
+    }
+
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
+    {
+        auto& memory = *zone.GetMemory();
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysCollMap>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPixelShader>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexShader>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexDecl>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundCurve>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLoadedSound>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGlassWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPathData>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVehicleTrack>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
+        collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory, searchPath, zone));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderAttachment>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSurfaceFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderScript>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStructuredDataDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
+    }
+} // namespace
+
+void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
 {
-    for (const auto& [type, loader] : m_asset_loaders_by_type)
+    ConfigureDefaultCreators(collection, zone, searchPath);
-        loader->FinalizeAssetsForZone(context);
+    ConfigureGlobalAssetPoolsLoaders(collection, zone);
 }

src/ObjLoading/Game/IW5/ObjLoaderIW5.h

@@ -4,28 +4,14 @@
 #include "IObjLoader.h"
 #include "SearchPath/ISearchPath.h"
 
-#include <memory>
-#include <unordered_map>
-
 namespace IW5
 {
     class ObjLoader final : public IObjLoader
     {
     public:
-        ObjLoader();
-
         void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
         void UnloadContainersOfZone(Zone& zone) const override;
 
-        void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
+        void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
-
-        bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
-        void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
-
-    private:
-        static bool IsMpZone(const Zone& zone);
-        static bool IsZmZone(const Zone& zone);
-
-        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
     };
 } // namespace IW5

src/ObjLoading/Game/T5/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,36 +0,0 @@
-#include "AssetLoaderLocalizeEntry.h"
-
-#include "Localize/LocalizeCommonAssetLoader.h"
-
-using namespace T5;
-
-XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
-{
-    return nullptr;
-}
-
-void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    return nullptr;
-}
-
-bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderLocalizeEntry::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const LocalizeCommonAssetLoader commonLoader(
-        [memory, manager](const CommonLocalizeEntry& entry)
-        {
-            auto* localizeEntry = memory->Create<LocalizeEntry>();
-            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-            localizeEntry->value = memory->Dup(entry.m_value.c_str());
-
-            manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
-        });
-
-    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
-}

src/ObjLoading/Game/T5/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/T5/T5.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace T5
-{
-    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
-    {
-    public:
-        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace T5

src/ObjLoading/Game/T5/Localize/AssetLoaderLocalizeT5.cpp

@@ -0,0 +1,23 @@
+#include "AssetLoaderLocalizeT5.h"
+
+using namespace T5;
+
+AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
+    : CommonLocalizeLoader(searchPath, zone),
+      m_memory(memory)
+{
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    return CreateLocalizeAsset(assetName, context);
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
+{
+    auto* asset = m_memory.Alloc<LocalizeEntry>();
+    asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
+    asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
+}

src/ObjLoading/Game/T5/Localize/AssetLoaderLocalizeT5.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Asset/AssetCreationContext.h"
+#include "Asset/IAssetCreator.h"
+#include "Game/T5/T5.h"
+#include "Localize/CommonLocalizeLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+#include "Zone/Zone.h"
+
+namespace T5
+{
+    class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
+    {
+    public:
+        AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    protected:
+        AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace T5

src/ObjLoading/Game/T5/ObjLoaderT5.cpp

@@ -1,85 +1,137 @@
 #include "ObjLoaderT5.h"
 
-#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
+#include "Asset/GlobalAssetPoolsLoader.h"
-#include "AssetLoaders/AssetLoaderRawFile.h"
-#include "AssetLoaders/AssetLoaderStringTable.h"
-#include "AssetLoaders/AssetLoaderXModel.h"
-#include "AssetLoading/AssetLoadingManager.h"
 #include "Game/T5/GameT5.h"
-#include "Image/IwiLoader.h"
+#include "Game/T5/T5.h"
-#include "ObjContainer/IPak/IPak.h"
+#include "Localize/AssetLoaderLocalizeT5.h"
+#include "ObjLoading.h"
+
+#include <memory>
 
 using namespace T5;
 
-ObjLoader::ObjLoader()
-{
-#define REGISTER_ASSET_LOADER(t)                                                                                                                               \
-    {                                                                                                                                                          \
-        auto l = std::make_unique<t>();                                                                                                                        \
-        m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);                                                                                     \
-    }
-
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysPreset>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPhysConstraints>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDestructibleDef>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXAnim>)
-    REGISTER_ASSET_LOADER(AssetLoaderXModel)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMaterial>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetTechniqueSet>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImage>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundBank>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundPatch>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMap>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetClipMapPvs>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetComWorld>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldSp>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGameWorldMp>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMapEnts>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGfxWorld>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetLightDef>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFont>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenuList>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenu>)
-    REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetWeapon>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSoundDriverGlobals>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFx>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImpactFx>)
-    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
-    REGISTER_ASSET_LOADER(AssetLoaderStringTable)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetPackIndex>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXGlobals>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDDL>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGlasses>)
-    REGISTER_ASSET_LOADER(BasicAssetLoader<AssetEmblemSet>)
-
-#undef REGISTER_ASSET_LOADER
-}
-
-bool ObjLoader::IsMpZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "mp_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_mp") == 0;
-}
-
-bool ObjLoader::IsZmZone(const Zone& zone)
-{
-    return zone.m_name.compare(0, 3, "zm_") == 0 || zone.m_name.compare(zone.m_name.length() - 3, 3, "_zm") == 0;
-}
-
 void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {}
 
 void ObjLoader::UnloadContainersOfZone(Zone& zone) const {}
 
-void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
+namespace
-
-bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const
 {
-    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
-    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+    {
-}
+        auto& memory = *zone.GetMemory();
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysConstraints>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDestructibleDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundBank>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundPatch>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPackIndex>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXGlobals>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDDL>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlasses>(memory));
+        // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorEmblemSet>(memory));
+    }
 
-void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
+    void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
+    {
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysConstraints>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDestructibleDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundBank>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundPatch>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPackIndex>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXGlobals>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDDL>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlasses>>(zone));
+        collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetEmblemSet>>(zone));
+    }
+
+    void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
+    {
+        auto& memory = *zone.GetMemory();
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysConstraints>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderDestructibleDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundBank>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundPatch>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderPackIndex>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderXGlobals>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderDDL>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderGlasses>(memory));
+        // collection.AddAssetCreator(std::make_unique<AssetLoaderEmblemSet>(memory));
+    }
+} // namespace
+
+void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
 {
-    for (const auto& [type, loader] : m_asset_loaders_by_type)
+    ConfigureDefaultCreators(collection, zone, searchPath);
-        loader->FinalizeAssetsForZone(context);
+    ConfigureGlobalAssetPoolsLoaders(collection, zone);
 }

src/ObjLoading/Game/T5/ObjLoaderT5.h

@@ -4,28 +4,14 @@
 #include "IObjLoader.h"
 #include "SearchPath/ISearchPath.h"
 
-#include <memory>
-#include <unordered_map>
-
 namespace T5
 {
     class ObjLoader final : public IObjLoader
     {
     public:
-        ObjLoader();
-
         void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
         void UnloadContainersOfZone(Zone& zone) const override;
 
-        void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
+        void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
-
-        bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
-        void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
-
-    private:
-        static bool IsMpZone(const Zone& zone);
-        static bool IsZmZone(const Zone& zone);
-
-        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
     };
 } // namespace T5

src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderLocalizeEntry.cpp

@@ -1,36 +0,0 @@
-#include "AssetLoaderLocalizeEntry.h"
-
-#include "Localize/LocalizeCommonAssetLoader.h"
-
-using namespace T6;
-
-XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
-{
-    return nullptr;
-}
-
-void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
-{
-    return nullptr;
-}
-
-bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
-{
-    return true;
-}
-
-bool AssetLoaderLocalizeEntry::LoadFromRaw(
-    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
-{
-    const LocalizeCommonAssetLoader commonLoader(
-        [memory, manager](const CommonLocalizeEntry& entry)
-        {
-            auto* localizeEntry = memory->Create<LocalizeEntry>();
-            localizeEntry->name = memory->Dup(entry.m_key.c_str());
-            localizeEntry->value = memory->Dup(entry.m_value.c_str());
-
-            manager->AddAsset<AssetLocalize>(entry.m_key, localizeEntry);
-        });
-
-    return commonLoader.LoadLocalizeAsset(assetName, searchPath, manager, zone);
-}

src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "AssetLoading/BasicAssetLoader.h"
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Game/T6/T6.h"
-#include "SearchPath/ISearchPath.h"
-
-namespace T6
-{
-    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<AssetLocalize>
-    {
-    public:
-        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
-        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
-        _NODISCARD bool CanLoadFromRaw() const override;
-        bool
-            LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
-    };
-} // namespace T6

src/ObjLoading/Game/T6/Localize/AssetLoaderLocalizeT6.cpp

@@ -0,0 +1,23 @@
+#include "AssetLoaderLocalizeT6.h"
+
+using namespace T6;
+
+AssetLoaderLocalize::AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
+    : CommonLocalizeLoader(searchPath, zone),
+      m_memory(memory)
+{
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    return CreateLocalizeAsset(assetName, context);
+}
+
+AssetCreationResult AssetLoaderLocalize::CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context)
+{
+    auto* asset = m_memory.Alloc<LocalizeEntry>();
+    asset->name = m_memory.Dup(localizeEntry.m_key.c_str());
+    asset->value = m_memory.Dup(localizeEntry.m_value.c_str());
+
+    return AssetCreationResult::Success(context.AddAsset<AssetLocalize>(localizeEntry.m_key, asset));
+}

src/ObjLoading/Game/T6/Localize/AssetLoaderLocalizeT6.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Asset/AssetCreationContext.h"
+#include "Asset/IAssetCreator.h"
+#include "Game/T6/T6.h"
+#include "Localize/CommonLocalizeLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+#include "Zone/Zone.h"
+
+namespace T6
+{
+    class AssetLoaderLocalize final : public AssetCreator<AssetLocalize>, public CommonLocalizeLoader
+    {
+    public:
+        AssetLoaderLocalize(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override;
+
+    protected:
+        AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override;
+
+    private:
+        MemoryManager& m_memory;
+    };
+} // namespace T6

src/ObjLoading/Game/T6/ObjLoaderT6.cpp

@@ -1,130 +1,27 @@
 #include "ObjLoaderT6.h"
 
-#include "AssetLoaders/AssetLoaderAddonMapEnts.h"
+#include "Asset/GlobalAssetPoolsLoader.h"
-#include "AssetLoaders/AssetLoaderClipMap.h"
-#include "AssetLoaders/AssetLoaderComWorld.h"
-#include "AssetLoaders/AssetLoaderDDL.h"
-#include "AssetLoaders/AssetLoaderDestructibleDef.h"
-#include "AssetLoaders/AssetLoaderEmblemSet.h"
-#include "AssetLoaders/AssetLoaderFont.h"
-#include "AssetLoaders/AssetLoaderFontIcon.h"
-#include "AssetLoaders/AssetLoaderFootstepFxTable.h"
-#include "AssetLoaders/AssetLoaderFootstepTable.h"
-#include "AssetLoaders/AssetLoaderFx.h"
-#include "AssetLoaders/AssetLoaderGameWorldMp.h"
-#include "AssetLoaders/AssetLoaderGameWorldSp.h"
-#include "AssetLoaders/AssetLoaderGfxImage.h"
-#include "AssetLoaders/AssetLoaderGfxLightDef.h"
-#include "AssetLoaders/AssetLoaderGfxWorld.h"
-#include "AssetLoaders/AssetLoaderGlasses.h"
-#include "AssetLoaders/AssetLoaderImpactFx.h"
-#include "AssetLoaders/AssetLoaderLeaderboard.h"
-#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
-#include "AssetLoaders/AssetLoaderMapEnts.h"
-#include "AssetLoaders/AssetLoaderMaterial.h"
-#include "AssetLoaders/AssetLoaderMemoryBlock.h"
-#include "AssetLoaders/AssetLoaderMenu.h"
-#include "AssetLoaders/AssetLoaderMenuList.h"
-#include "AssetLoaders/AssetLoaderPhysConstraints.h"
-#include "AssetLoaders/AssetLoaderPhysPreset.h"
-#include "AssetLoaders/AssetLoaderQdb.h"
-#include "AssetLoaders/AssetLoaderRawFile.h"
-#include "AssetLoaders/AssetLoaderScriptParseTree.h"
-#include "AssetLoaders/AssetLoaderSkinnedVerts.h"
-#include "AssetLoaders/AssetLoaderSlug.h"
-#include "AssetLoaders/AssetLoaderSoundBank.h"
-#include "AssetLoaders/AssetLoaderSoundDriverGlobals.h"
-#include "AssetLoaders/AssetLoaderSoundPatch.h"
-#include "AssetLoaders/AssetLoaderStringTable.h"
-#include "AssetLoaders/AssetLoaderTechniqueSet.h"
-#include "AssetLoaders/AssetLoaderTracer.h"
-#include "AssetLoaders/AssetLoaderVehicle.h"
-#include "AssetLoaders/AssetLoaderWeapon.h"
-#include "AssetLoaders/AssetLoaderWeaponAttachment.h"
-#include "AssetLoaders/AssetLoaderWeaponAttachmentUnique.h"
-#include "AssetLoaders/AssetLoaderWeaponCamo.h"
-#include "AssetLoaders/AssetLoaderXAnim.h"
-#include "AssetLoaders/AssetLoaderXGlobals.h"
-#include "AssetLoaders/AssetLoaderXModel.h"
-#include "AssetLoaders/AssetLoaderZBarrier.h"
 #include "AssetLoading/AssetLoadingManager.h"
 #include "Game/T6/CommonT6.h"
 #include "Game/T6/GameAssetPoolT6.h"
 #include "Game/T6/GameT6.h"
+#include "Game/T6/T6.h"
 #include "Image/Dx12TextureLoader.h"
 #include "Image/IwiLoader.h"
 #include "Image/IwiTypes.h"
 #include "Image/Texture.h"
+#include "Localize/AssetLoaderLocalizeT6.h"
 #include "ObjContainer/IPak/IPak.h"
 #include "ObjLoading.h"
 
 #include <format>
+#include <memory>
 
 namespace T6
 {
     constexpr auto IPAK_READ_HASH = Common::Com_HashKey("ipak_read", 64);
     constexpr auto GLOBAL_HASH = Common::Com_HashKey("GLOBAL", 64);
 
-    ObjLoader::ObjLoader()
-    {
-#define REGISTER_ASSET_LOADER(t)                                                                                                                               \
-    {                                                                                                                                                          \
-        auto l = std::make_unique<t>();                                                                                                                        \
-        m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);                                                                                     \
-    }
-
-        REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
-        REGISTER_ASSET_LOADER(AssetLoaderPhysConstraints)
-        REGISTER_ASSET_LOADER(AssetLoaderDestructibleDef)
-        REGISTER_ASSET_LOADER(AssetLoaderXAnim)
-        REGISTER_ASSET_LOADER(AssetLoaderXModel)
-        REGISTER_ASSET_LOADER(AssetLoaderMaterial)
-        REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
-        REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
-        REGISTER_ASSET_LOADER(AssetLoaderSoundBank)
-        REGISTER_ASSET_LOADER(AssetLoaderSoundPatch)
-        REGISTER_ASSET_LOADER(AssetLoaderClipMap)
-        REGISTER_ASSET_LOADER(AssetLoaderClipMapPvs)
-        REGISTER_ASSET_LOADER(AssetLoaderComWorld)
-        REGISTER_ASSET_LOADER(AssetLoaderGameWorldSp)
-        REGISTER_ASSET_LOADER(AssetLoaderGameWorldMp)
-        REGISTER_ASSET_LOADER(AssetLoaderMapEnts)
-        REGISTER_ASSET_LOADER(AssetLoaderGfxWorld)
-        REGISTER_ASSET_LOADER(AssetLoaderGfxLightDef)
-        REGISTER_ASSET_LOADER(AssetLoaderFont)
-        REGISTER_ASSET_LOADER(AssetLoaderFontIcon)
-        REGISTER_ASSET_LOADER(AssetLoaderMenuList)
-        REGISTER_ASSET_LOADER(AssetLoaderMenu)
-        REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-        REGISTER_ASSET_LOADER(AssetLoaderWeapon)
-        REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachment)
-        REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachmentUnique)
-        REGISTER_ASSET_LOADER(AssetLoaderWeaponCamo)
-        REGISTER_ASSET_LOADER(AssetLoaderSoundDriverGlobals)
-        REGISTER_ASSET_LOADER(AssetLoaderFx)
-        REGISTER_ASSET_LOADER(AssetLoaderImpactFx)
-        REGISTER_ASSET_LOADER(AssetLoaderRawFile)
-        REGISTER_ASSET_LOADER(AssetLoaderStringTable)
-        REGISTER_ASSET_LOADER(AssetLoaderLeaderboard)
-        REGISTER_ASSET_LOADER(AssetLoaderXGlobals)
-        REGISTER_ASSET_LOADER(AssetLoaderDDL)
-        REGISTER_ASSET_LOADER(AssetLoaderGlasses)
-        REGISTER_ASSET_LOADER(AssetLoaderEmblemSet)
-        REGISTER_ASSET_LOADER(AssetLoaderScriptParseTree)
-        REGISTER_ASSET_LOADER(AssetLoaderVehicle)
-        REGISTER_ASSET_LOADER(AssetLoaderMemoryBlock)
-        REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
-        REGISTER_ASSET_LOADER(AssetLoaderTracer)
-        REGISTER_ASSET_LOADER(AssetLoaderSkinnedVerts)
-        REGISTER_ASSET_LOADER(AssetLoaderQdb)
-        REGISTER_ASSET_LOADER(AssetLoaderSlug)
-        REGISTER_ASSET_LOADER(AssetLoaderFootstepTable)
-        REGISTER_ASSET_LOADER(AssetLoaderFootstepFxTable)
-        REGISTER_ASSET_LOADER(AssetLoaderZBarrier)
-
-#undef REGISTER_ASSET_LOADER
-    }
-
     bool ObjLoader::VerifySoundBankChecksum(const SoundBank& soundBank, const SndRuntimeAssetBank& sndRuntimeAssetBank)
     {
         SoundAssetBankChecksum checksum{};
@@ -356,17 +253,155 @@ namespace T6
         IPak::Repository.RemoveContainerReferences(&zone);
     }
 
-    void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection) const {}
+    namespace
-
-    bool ObjLoader::LoadAssetForZone(AssetLoadingContext& context, const asset_type_t assetType, const std::string& assetName) const
     {
-        AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, context);
+        void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
-        return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+        {
+            auto& memory = *zone.GetMemory();
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysPreset>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPhysConstraints>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDestructibleDef>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXAnim>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXModel>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMaterial>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorTechniqueSet>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImage>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundBank>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundPatch>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMap>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorClipMapPvs>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorComWorld>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldSp>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGameWorldMp>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMapEnts>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGfxWorld>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLightDef>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFont>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenuList>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorMenu>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorLocalize>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorWeapon>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorSoundDriverGlobals>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorFx>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorImpactFx>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorRawFile>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorStringTable>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorPackIndex>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorXGlobals>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorDDL>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorGlasses>(memory));
+            // collection.AddDefaultAssetCreator(std::make_unique<DefaultCreatorEmblemSet>(memory));
         }
 
-    void ObjLoader::FinalizeAssetsForZone(AssetLoadingContext& context) const
+        void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
         {
-        for (const auto& [type, loader] : m_asset_loaders_by_type)
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
-            loader->FinalizeAssetsForZone(context);
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysConstraints>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDestructibleDef>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundBank>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundPatch>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMap>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapPvs>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFontIcon>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachment>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAttachmentUnique>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeaponCamo>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundDriverGlobals>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLeaderboard>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXGlobals>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDDL>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGlasses>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetEmblemSet>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetScript>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetVehicle>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMemoryBlock>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetAddonMapEnts>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTracer>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSkinnedVerts>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetQdb>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSlug>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFootstepTable>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFootstepFxTable>>(zone));
+            collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetZBarrier>>(zone));
+        }
+
+        void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
+        {
+            auto& memory = *zone.GetMemory();
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysPreset>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderPhysConstraints>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderDestructibleDef>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderMaterial>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderImage>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundBank>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundPatch>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMap>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderClipMapPvs>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderComWorld>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldSp>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderGameWorldMp>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderMapEnts>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderLightDef>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderFont>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderFontIcon>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderLocalize>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderWeapon>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderAttachment>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderAttachmentUnique>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderWeaponCamo>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderSoundDriverGlobals>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderFx>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderImpactFx>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderRawFile>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderStringTable>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderLeaderboard>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderXGlobals>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderDDL>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderGlasses>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderEmblemSet>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderScript>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderVehicle>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderMemoryBlock>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderAddonMapEnts>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderTracer>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderSkinnedVerts>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderQdb>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderSlug>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderFootstepTable>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderFootstepFxTable>(memory));
+            // collection.AddAssetCreator(std::make_unique<AssetLoaderZBarrier>(memory));
+        }
+    } // namespace
+
+    void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const
+    {
+        ConfigureDefaultCreators(collection, zone, searchPath);
+        ConfigureGlobalAssetPoolsLoaders(collection, zone);
     }
 } // namespace T6

src/ObjLoading/Game/T6/ObjLoaderT6.h

@@ -10,22 +10,16 @@
 #include <set>
 #include <stack>
 #include <string>
-#include <unordered_map>
 
 namespace T6
 {
     class ObjLoader final : public IObjLoader
     {
     public:
-        ObjLoader();
-
         void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override;
         void UnloadContainersOfZone(Zone& zone) const override;
 
-        void ConfigureCreatorCollection(AssetCreatorCollection& collection) const override;
+        void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const override;
-
-        bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const override;
-        void FinalizeAssetsForZone(AssetLoadingContext& context) const override;
 
     private:
         static bool VerifySoundBankChecksum(const SoundBank& soundBank, const SndRuntimeAssetBank& sndRuntimeAssetBank);
@@ -43,7 +37,5 @@ namespace T6
 
         static bool IsMpZone(const Zone& zone);
         static bool IsZmZone(const Zone& zone);
-
-        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
     };
 } // namespace T6

src/ObjLoading/IObjLoader.h

@@ -28,10 +28,7 @@ public:
      */
     virtual void UnloadContainersOfZone(Zone& zone) const = 0;
 
-    virtual void ConfigureCreatorCollection(AssetCreatorCollection& collection) const = 0;
+    virtual void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) const = 0;
-
-    virtual bool LoadAssetForZone(AssetLoadingContext& context, asset_type_t assetType, const std::string& assetName) const = 0;
-    virtual void FinalizeAssetsForZone(AssetLoadingContext& context) const = 0;
 
     static const IObjLoader* GetObjLoaderForGame(GameId game);
 };

src/ObjLoading/Localize/CommonLocalizeLoader.cpp

@@ -0,0 +1,52 @@
+#include "CommonLocalizeLoader.h"
+
+#include "Localize/LocalizeCommon.h"
+#include "Localize/Parsing/LocalizeFileReader.h"
+
+#include <format>
+
+CommonLocalizeLoader::CommonLocalizeLoader(ISearchPath& searchPath, Zone& zone)
+    : m_search_path(searchPath),
+      m_zone(zone)
+{
+}
+
+std::string CommonLocalizeLoader::GetFileName(const std::string& assetName) const
+{
+    return std::format("{}/localizedstrings/{}.str", LocalizeCommon::GetNameOfLanguage(m_zone.m_language), assetName);
+}
+
+AssetCreationResult CommonLocalizeLoader::CreateLocalizeAsset(const std::string& assetName, AssetCreationContext& context)
+{
+    std::string fileName = GetFileName(assetName);
+
+    const auto file = m_search_path.Open(fileName);
+    if (!file.IsOpen())
+        return AssetCreationResult::NoAction();
+
+    LocalizeFileReader reader(*file.m_stream, assetName, m_zone.m_language, *this);
+
+    std::vector<CommonLocalizeEntry> localizeEntries;
+    if (!reader.ReadLocalizeFile(localizeEntries))
+        return AssetCreationResult::Failure();
+
+    auto lastResult = AssetCreationResult::Failure();
+    for (const auto& entry : localizeEntries)
+    {
+        lastResult = CreateAssetFromCommonAsset(entry, context);
+        if (!lastResult.HasBeenSuccessful())
+            return lastResult;
+    }
+
+    return lastResult;
+}
+
+bool CommonLocalizeLoader::CheckLocalizeEntryForDuplicates(const std::string& key)
+{
+    const auto existingEntry = m_keys.find(key);
+    if (existingEntry != m_keys.end())
+        return false;
+
+    m_keys.emplace(key);
+    return true;
+}

src/ObjLoading/Localize/CommonLocalizeLoader.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "Localize/CommonLocalizeEntry.h"
+#include "Localize/Parsing/ILocalizeFileDuplicationChecker.h"
+#include "SearchPath/ISearchPath.h"
+#include "Zone/Zone.h"
+
+#include <string>
+#include <unordered_set>
+
+class CommonLocalizeLoader : ILocalizeFileDuplicationChecker
+{
+public:
+    CommonLocalizeLoader(ISearchPath& searchPath, Zone& zone);
+
+    AssetCreationResult CreateLocalizeAsset(const std::string& assetName, AssetCreationContext& context);
+
+protected:
+    virtual AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) = 0;
+
+private:
+    std::string GetFileName(const std::string& assetName) const;
+
+    bool CheckLocalizeEntryForDuplicates(const std::string& key) override;
+
+    ISearchPath& m_search_path;
+    Zone& m_zone;
+
+    std::unordered_set<std::string> m_keys;
+};

src/ObjLoading/Localize/LocalizeCommonAssetLoader.cpp

@@ -1,42 +0,0 @@
-#include "LocalizeCommonAssetLoader.h"
-
-#include "Localize/LocalizeCommon.h"
-#include "Localize/LocalizeReadingZoneState.h"
-#include "Localize/Parsing/LocalizeFileReader.h"
-
-#include <sstream>
-
-LocalizeCommonAssetLoader::LocalizeCommonAssetLoader(std::function<void(const CommonLocalizeEntry&)> entryCallback)
-    : m_entry_callback(std::move(entryCallback))
-{
-}
-
-std::string LocalizeCommonAssetLoader::GetFileName(const std::string& assetName, Zone* zone) const
-{
-    std::ostringstream ss;
-    ss << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
-    return ss.str();
-}
-
-bool LocalizeCommonAssetLoader::LoadLocalizeAsset(const std::string& assetName, ISearchPath* searchPath, IAssetLoadingManager* manager, Zone* zone) const
-{
-    std::string fileName = GetFileName(assetName, zone);
-
-    const auto file = searchPath->Open(fileName);
-    if (!file.IsOpen())
-        return false;
-
-    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<LocalizeReadingZoneState>();
-    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language, zoneState);
-
-    std::vector<CommonLocalizeEntry> localizeEntries;
-    if (!reader.ReadLocalizeFile(localizeEntries))
-        return false;
-
-    for (const auto& entry : localizeEntries)
-    {
-        m_entry_callback(entry);
-    }
-
-    return true;
-}

src/ObjLoading/Localize/LocalizeCommonAssetLoader.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "AssetLoading/IAssetLoadingManager.h"
-#include "Localize/CommonLocalizeEntry.h"
-#include "SearchPath/ISearchPath.h"
-#include "Zone/Zone.h"
-
-#include <functional>
-#include <string>
-
-class LocalizeCommonAssetLoader
-{
-public:
-    explicit LocalizeCommonAssetLoader(std::function<void(const CommonLocalizeEntry&)> entryCallback);
-
-    bool LoadLocalizeAsset(const std::string& assetName, ISearchPath* searchPath, IAssetLoadingManager* manager, Zone* zone) const;
-
-private:
-    std::string GetFileName(const std::string& assetName, Zone* zone) const;
-
-    std::function<void(const CommonLocalizeEntry&)> m_entry_callback;
-};

src/ObjLoading/Localize/LocalizeReadingZoneState.cpp

@@ -1,11 +0,0 @@
-#include "LocalizeReadingZoneState.h"
-
-bool LocalizeReadingZoneState::DoLocalizeEntryDuplicateCheck(const std::string& key)
-{
-    const auto existingEntry = m_keys.find(key);
-    if (existingEntry != m_keys.end())
-        return false;
-
-    m_keys.emplace(key);
-    return true;
-}

src/ObjLoading/Localize/Parsing/ILocalizeFileDuplicationChecker.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include "AssetLoading/IZoneAssetLoaderState.h"
-
 #include <string>
-#include <unordered_set>
 
-class LocalizeReadingZoneState final : public IZoneAssetLoaderState
+class ILocalizeFileDuplicationChecker
 {
 public:
+    virtual ~ILocalizeFileDuplicationChecker() = default;
+
     /**
      * Checks whether a localize key was already added.
      * Inserts key if it was not added yet.
@@ -15,8 +14,5 @@ public:
      * \param key The key to check
      * \returns \c true if key was not duplicated yet, \c false otherwise
      */
-    bool DoLocalizeEntryDuplicateCheck(const std::string& key);
+    virtual bool CheckLocalizeEntryForDuplicates(const std::string& key) = 0;
-
-private:
-    std::unordered_set<std::string> m_keys;
 };

src/ObjLoading/Localize/Parsing/LocalizeFileParser.cpp

@@ -8,8 +8,8 @@
 #include "Sequence/SequenceLocalizeFileReference.h"
 #include "Sequence/SequenceLocalizeFileVersion.h"
 
-LocalizeFileParser::LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, LocalizeReadingZoneState* zoneState)
+LocalizeFileParser::LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
-    : AbstractParser(lexer, std::make_unique<LocalizeFileParserState>(language, zoneState))
+    : AbstractParser(lexer, std::make_unique<LocalizeFileParserState>(language, duplicationChecker))
 {
 }
 

src/ObjLoading/Localize/Parsing/LocalizeFileParser.h

@@ -12,6 +12,6 @@ protected:
     const std::vector<sequence_t*>& GetTestsForState() override;
 
 public:
-    LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, LocalizeReadingZoneState* zoneState);
+    LocalizeFileParser(SimpleLexer* lexer, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
     std::vector<CommonLocalizeEntry> GetParsedValues();
 };

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.cpp

@@ -3,10 +3,10 @@
 #include "Localize/LocalizeCommon.h"
 #include "Utils/StringUtils.h"
 
-LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, LocalizeReadingZoneState* zoneState)
+LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
     : m_end(false),
       m_language(language),
-      m_zone_state(zoneState)
+      m_duplication_checker(duplicationChecker)
 {
     m_language_name_caps = LocalizeCommon::GetNameOfLanguage(m_language);
     utils::MakeStringUpperCase(m_language_name_caps);

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "ILocalizeFileDuplicationChecker.h"
 #include "Localize/CommonLocalizeEntry.h"
-#include "Localize/LocalizeReadingZoneState.h"
 
 #include <unordered_set>
 #include <vector>
@@ -10,16 +10,16 @@
 class LocalizeFileParserState
 {
 public:
+    LocalizeFileParserState(GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
+
     bool m_end;
 
     std::vector<CommonLocalizeEntry> m_entries;
 
     GameLanguage m_language;
-    LocalizeReadingZoneState* m_zone_state;
+    ILocalizeFileDuplicationChecker& m_duplication_checker;
     std::string m_language_name_caps;
 
     std::string m_current_reference;
     std::unordered_set<std::string> m_current_reference_languages;
-
-    LocalizeFileParserState(GameLanguage language, LocalizeReadingZoneState* zoneState);
 };

src/ObjLoading/Localize/Parsing/LocalizeFileReader.cpp

@@ -4,11 +4,11 @@
 #include "Parsing/Impl/CommentRemovingStreamProxy.h"
 #include "Parsing/Impl/ParserSingleInputStream.h"
 
-LocalizeFileReader::LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, LocalizeReadingZoneState* zoneState)
+LocalizeFileReader::LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker)
     : m_file_name(std::move(fileName)),
       m_stream(nullptr),
       m_language(language),
-      m_zone_state(zoneState)
+      m_duplication_checker(duplicationChecker)
 {
     OpenBaseStream(stream);
     SetupStreamProxies();
@@ -38,7 +38,7 @@ bool LocalizeFileReader::ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entr
     lexerConfig.m_read_floating_point_numbers = false;
     const auto lexer = std::make_unique<SimpleLexer>(m_stream, std::move(lexerConfig));
 
-    const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language, m_zone_state);
+    const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language, m_duplication_checker);
 
     if (parser->Parse())
     {

src/ObjLoading/Localize/Parsing/LocalizeFileReader.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Game/GameLanguage.h"
+#include "ILocalizeFileDuplicationChecker.h"
 #include "Localize/CommonLocalizeEntry.h"
-#include "Localize/LocalizeReadingZoneState.h"
 #include "Parsing/IParserLineStream.h"
 
 #include <map>
@@ -16,13 +16,13 @@ class LocalizeFileReader
     IParserLineStream* m_stream;
     std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
     GameLanguage m_language;
-    LocalizeReadingZoneState* m_zone_state;
+    ILocalizeFileDuplicationChecker& m_duplication_checker;
 
     bool OpenBaseStream(std::istream& stream);
     void SetupStreamProxies();
 
 public:
-    LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, LocalizeReadingZoneState* zoneState);
+    LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language, ILocalizeFileDuplicationChecker& duplicationChecker);
 
     bool ReadLocalizeFile(std::vector<CommonLocalizeEntry>& entries);
 };

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileLanguageValue.cpp

@@ -33,7 +33,7 @@ void SequenceLocalizeFileLanguageValue::ProcessMatch(LocalizeFileParserState* st
     if (langName == state->m_language_name_caps)
     {
         const auto& currentReference = state->m_current_reference;
-        if (!state->m_zone_state->DoLocalizeEntryDuplicateCheck(currentReference))
+        if (!state->m_duplication_checker.CheckLocalizeEntryForDuplicates(currentReference))
         {
             std::cout << "Localize: a value for reference \"" << currentReference << "\" was already defined\n";
         }