Add AssetLoader basis

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

@@ -0,0 +1,32 @@
+#include "AssetLoaderRawFile.h"
+
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+bool AssetLoaderRawFile::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool AssetLoaderRawFile::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager) 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 = static_cast<char*>(memory->Alloc(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;
+
+    rawFile->data.buffer = fileBuffer;
+    manager->AddAsset(ASSET_TYPE_RAWFILE, assetName, rawFile);
+
+    return true;
+}

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

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

src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp

@@ -3,106 +3,160 @@
 #include "Game/IW4/GameAssetPoolIW4.h"
 #include "ObjContainer/IPak/IPak.h"
 #include "ObjLoading.h"
+#include "AssetLoaders/AssetLoaderRawFile.h"
+#include "AssetLoading/AssetLoadingManager.h"
 #include "Image/Texture.h"
 #include "Image/IwiLoader.h"
 
-namespace IW4
+using namespace IW4;
+
+ObjLoader::ObjLoader()
 {
-    bool ObjLoader::SupportsZone(Zone* zone) const
+#define REGISTER_ASSET_LOADER(t) {auto l = std::make_unique<t>(); m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);}
+#define BASIC_LOADER(assetType, assetClass) BasicAssetLoader<assetType, assetClass>
+
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSPRESET, PhysPreset))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSCOLLMAP, PhysCollmap))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XANIMPARTS, XAnimParts))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XMODEL_SURFS, XModelSurfs))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XMODEL, XModel))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MATERIAL, Material))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PIXELSHADER, MaterialPixelShader))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VERTEXSHADER, MaterialVertexShader))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VERTEXDECL, MaterialVertexDeclaration))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMAGE, GfxImage))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND, snd_alias_list_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND_CURVE, SndCurve))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LOADED_SOUND, LoadedSound))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_CLIPMAP_SP, clipMap_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_CLIPMAP_MP, clipMap_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_COMWORLD, ComWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GAMEWORLD_SP, GameWorldSp))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GAMEWORLD_MP, GameWorldMp))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MAP_ENTS, MapEnts))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FXWORLD, FxWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GFXWORLD, GfxWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LIGHT_DEF, GfxLightDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FONT, Font_s))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENULIST, MenuList))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENU, menuDef_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON, WeaponCompleteDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FX, FxEffectDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMPACT_FX, FxImpactTable))
+    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_STRINGTABLE, StringTable))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LEADERBOARD, LeaderboardDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_STRUCTURED_DATA_DEF, StructuredDataDefSet))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TRACER, TracerDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VEHICLE, VehicleDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ADDON_MAP_ENTS, AddonMapEnts))
+
+#undef BASIC_LOADER
+#undef REGISTER_ASSET_LOADER
+}
+
+bool ObjLoader::SupportsZone(Zone* zone) const
+{
+    return zone->m_game == &g_GameIW4;
+}
+
+bool ObjLoader::IsMpZone(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(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::LoadImageFromLoadDef(GfxImage* image, Zone* zone)
+{
+    // TODO: Load Texture from LoadDef here
+}
+
+void ObjLoader::LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone)
+{
+    Texture* loadedTexture = nullptr;
+    IwiLoader loader(zone->GetMemory());
+
+    const auto imageFileName = "images/" + std::string(image->name) + ".iwi";
+
     {
-        return zone->m_game == &g_GameIW4;
-    }
-
-    bool ObjLoader::IsMpZone(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(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::LoadImageFromLoadDef(GfxImage* image, Zone* zone)
-    {
-        // TODO: Load Texture from LoadDef here
-    }
-
-    void ObjLoader::LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone)
-    {
-        Texture* loadedTexture = nullptr;
-        IwiLoader loader(zone->GetMemory());
-
-        const auto imageFileName = "images/" + std::string(image->name) + ".iwi";
-
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (filePathImage.IsOpen())
         {
-            const auto filePathImage = searchPath->Open(imageFileName);
-            if (filePathImage.IsOpen())
-            {
-                loadedTexture = loader.LoadIwi(*filePathImage.m_stream);
-            }
-        }
-
-        if (loadedTexture != nullptr)
-        {
-            image->texture.texture = loadedTexture;
-            image->cardMemory.platform[0] = 0;
-
-            const auto textureMipCount = loadedTexture->GetMipMapCount();
-            for (auto mipLevel = 0; mipLevel < textureMipCount; mipLevel++)
-                image->cardMemory.platform[0] += static_cast<int>(loadedTexture->GetSizeOfMipLevel(mipLevel) * loadedTexture->GetFaceCount());
-        }
-        else
-        {
-            printf("Could not find data for image \"%s\"\n", image->name);
+            loadedTexture = loader.LoadIwi(*filePathImage.m_stream);
         }
     }
 
-    void ObjLoader::LoadImageData(ISearchPath* searchPath, Zone* zone)
+    if (loadedTexture != nullptr)
     {
-        auto* assetPool = dynamic_cast<GameAssetPoolIW4*>(zone->m_pools.get());
+        image->texture.texture = loadedTexture;
+        image->cardMemory.platform[0] = 0;
 
-        if (assetPool && assetPool->m_image != nullptr)
-        {
-            for (auto* imageEntry : *assetPool->m_image)
-            {
-                auto* image = imageEntry->Asset();
-
-                if (image->cardMemory.platform[0] > 0)
-                {
-                    continue;
-                }
-
-                // Do not load linked assets
-                if (image->name && image->name[0] == ',')
-                {
-                    continue;
-                }
-
-                if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
-                {
-                    LoadImageFromLoadDef(image, zone);
-                }
-                else
-                {
-                    LoadImageFromIwi(image, searchPath, zone);
-                }
-            }
-        }
+        const auto textureMipCount = loadedTexture->GetMipMapCount();
+        for (auto mipLevel = 0; mipLevel < textureMipCount; mipLevel++)
+            image->cardMemory.platform[0] += static_cast<int>(loadedTexture->GetSizeOfMipLevel(mipLevel) * loadedTexture->GetFaceCount());
     }
-
-    void ObjLoader::LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const
+    else
     {
-        LoadImageData(searchPath, zone);
+        printf("Could not find data for image \"%s\"\n", image->name);
     }
 }
+
+void ObjLoader::LoadImageData(ISearchPath* searchPath, Zone* zone)
+{
+    auto* assetPool = dynamic_cast<GameAssetPoolIW4*>(zone->m_pools.get());
+
+    if (assetPool && assetPool->m_image != nullptr)
+    {
+        for (auto* imageEntry : *assetPool->m_image)
+        {
+            auto* image = imageEntry->Asset();
+
+            if (image->cardMemory.platform[0] > 0)
+            {
+                continue;
+            }
+
+            // Do not load linked assets
+            if (image->name && image->name[0] == ',')
+            {
+                continue;
+            }
+
+            if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            {
+                LoadImageFromLoadDef(image, zone);
+            }
+            else
+            {
+                LoadImageFromIwi(image, searchPath, zone);
+            }
+        }
+    }
+}
+
+void ObjLoader::LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const
+{
+    LoadImageData(searchPath, zone);
+}
+
+bool ObjLoader::LoadAssetForZone(AssetLoadingContext* context, asset_type_t assetType, const std::string& assetName) const
+{
+    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, *context);
+    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+}

src/ObjLoading/Game/IW4/ObjLoaderIW4.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#include <unordered_map>
+#include <memory>
+
 #include "IObjLoader.h"
+#include "AssetLoading/IAssetLoader.h"
 #include "SearchPath/ISearchPath.h"
 #include "Game/IW4/IW4.h"
 
@@ -8,6 +12,8 @@ namespace IW4
 {
     class ObjLoader final : public IObjLoader
     {
+        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
+
         static void LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone);
         static void LoadImageFromLoadDef(GfxImage* image, Zone* zone);
         static void LoadImageData(ISearchPath* searchPath, Zone* zone);
@@ -16,11 +22,15 @@ namespace IW4
         static bool IsZmZone(Zone* zone);
 
     public:
+        ObjLoader();
+
         bool SupportsZone(Zone* zone) const override;
 
         void LoadReferencedContainersForZone(ISearchPath* searchPath, Zone* zone) const override;
         void UnloadContainersOfZone(Zone* zone) const override;
 
         void LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const override;
+
+        bool LoadAssetForZone(AssetLoadingContext* context, asset_type_t assetType, const std::string& assetName) const override;
     };
 }

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

@@ -0,0 +1,32 @@
+#include "AssetLoaderRawFile.h"
+
+#include "Game/T6/T6.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace T6;
+
+bool AssetLoaderRawFile::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool AssetLoaderRawFile::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager) 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 = static_cast<char*>(memory->Alloc(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;
+
+    rawFile->buffer = static_cast<char16*>(fileBuffer);
+    manager->AddAsset(ASSET_TYPE_RAWFILE, assetName, rawFile);
+
+    return true;
+}

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

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

src/ObjLoading/Game/T6/ObjLoaderT6.cpp

@@ -4,6 +4,8 @@
 #include "Game/T6/GameAssetPoolT6.h"
 #include "ObjContainer/IPak/IPak.h"
 #include "ObjLoading.h"
+#include "AssetLoaders/AssetLoaderRawFile.h"
+#include "AssetLoading/AssetLoadingManager.h"
 #include "Image/Texture.h"
 #include "Image/IwiLoader.h"
 #include "Game/T6/CommonT6.h"
@@ -13,6 +15,64 @@ namespace T6
     const int ObjLoader::IPAK_READ_HASH = CommonT6::Com_HashKey("ipak_read", 64);
     const int ObjLoader::GLOBAL_HASH = CommonT6::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);}
+#define BASIC_LOADER(assetType, assetClass) BasicAssetLoader<assetType, assetClass>
+
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSPRESET, PhysPreset))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSCONSTRAINTS, PhysConstraints))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_DESTRUCTIBLEDEF, DestructibleDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XANIMPARTS, XAnimParts))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XMODEL, XModel))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MATERIAL, Material))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMAGE, GfxImage))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND, SndBank))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND_PATCH, SndPatch))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_CLIPMAP, clipMap_t))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_CLIPMAP_PVS, clipMap_t))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_COMWORLD, ComWorld))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GAMEWORLD_SP, GameWorldSp))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GAMEWORLD_MP, GameWorldMp))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MAP_ENTS, MapEnts))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GFXWORLD, GfxWorld))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LIGHT_DEF, GfxLightDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FONT, Font_s))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FONTICON, FontIcon))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENULIST, MenuList))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENU, menuDef_t))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON, WeaponVariantDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ATTACHMENT, WeaponAttachment))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ATTACHMENT_UNIQUE, WeaponAttachmentUnique))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON_CAMO, WeaponCamo))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SNDDRIVER_GLOBALS, SndDriverGlobals))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FX, FxEffectDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMPACT_FX, FxImpactTable))
+        REGISTER_ASSET_LOADER(AssetLoaderRawFile)
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_STRINGTABLE, StringTable))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LEADERBOARD, LeaderboardDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XGLOBALS, XGlobals))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_DDL, ddlDef_t))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GLASSES, Glasses))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_EMBLEMSET, EmblemSet))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SCRIPTPARSETREE, ScriptParseTree))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VEHICLEDEF, VehicleDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MEMORYBLOCK, MemoryBlock))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ADDON_MAP_ENTS, AddonMapEnts))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TRACER, TracerDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SKINNEDVERTS, SkinnedVertsDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_QDB, Qdb))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SLUG, Slug))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FOOTSTEP_TABLE, FootstepTableDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FOOTSTEPFX_TABLE, FootstepFXTableDef))
+        REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ZBARRIER, ZBarrierDef))
+
+#undef BASIC_LOADER
+#undef REGISTER_ASSET_LOADER
+    }
+
     bool ObjLoader::SupportsZone(Zone* zone) const
     {
         return zone->m_game == &g_GameT6;
@@ -227,4 +287,10 @@ namespace T6
     {
         LoadImageData(searchPath, zone);
     }
+
+    bool ObjLoader::LoadAssetForZone(AssetLoadingContext* context, const asset_type_t assetType, const std::string& assetName) const
+    {
+        AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, *context);
+        return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+    }
 }

src/ObjLoading/Game/T6/ObjLoaderT6.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#include <unordered_map>
+#include <memory>
+
 #include "IObjLoader.h"
+#include "AssetLoading/IAssetLoader.h"
 #include "SearchPath/ISearchPath.h"
 #include "Game/T6/T6.h"
 
@@ -11,6 +15,8 @@ namespace T6
         static const int IPAK_READ_HASH;
         static const int GLOBAL_HASH;
 
+        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
+
         static void LoadIPakForZone(ISearchPath* searchPath, const std::string& ipakName, Zone* zone);
 
         static void LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone);
@@ -22,11 +28,15 @@ namespace T6
         static void LoadCommonIPaks(ISearchPath* searchPath, Zone* zone);
 
     public:
+        ObjLoader();
+
         bool SupportsZone(Zone* zone) const override;
 
         void LoadReferencedContainersForZone(ISearchPath* searchPath, Zone* zone) const override;
         void UnloadContainersOfZone(Zone* zone) const override;
 
         void LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const override;
+
+        bool LoadAssetForZone(AssetLoadingContext* context, asset_type_t assetType, const std::string& assetName) const override;
     };
 }