Add IW4 asset loader classes for all asset types that did not have one yet

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderAddonMapEnts.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderAddonMapEnts::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* addonMapEnts = memory->Create<AddonMapEnts>();
+    memset(addonMapEnts, 0, sizeof(AddonMapEnts));
+    addonMapEnts->name = memory->Dup(assetName.c_str());
+    return addonMapEnts;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderAddonMapEnts final : public BasicAssetLoader<ASSET_TYPE_ADDON_MAP_ENTS, AddonMapEnts>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,27 @@
+#include "AssetLoaderClipMap.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderClipMap::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* clipMap = memory->Create<clipMap_t>();
+    memset(clipMap, 0, sizeof(clipMap_t));
+    clipMap->name = memory->Dup(assetName.c_str());
+    return clipMap;
+}
+
+asset_type_t AssetLoaderClipMapSp::GetHandlingAssetType() const
+{
+    return ASSET_TYPE_CLIPMAP_SP;
+}
+
+asset_type_t AssetLoaderClipMapMp::GetHandlingAssetType() const
+{
+    return ASSET_TYPE_CLIPMAP_MP;
+}

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderClipMap : public BasicAssetLoader<ASSET_TYPE_CLIPMAP_MP, clipMap_t>
+    {
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+
+    class AssetLoaderClipMapSp final : public AssetLoaderClipMap
+    {
+    public:
+        _NODISCARD asset_type_t GetHandlingAssetType() const override;
+    };
+
+    class AssetLoaderClipMapMp final : public AssetLoaderClipMap
+    {
+    public:
+        _NODISCARD asset_type_t GetHandlingAssetType() const override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderComWorld.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderComWorld::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* comWorld = memory->Create<ComWorld>();
+    memset(comWorld, 0, sizeof(ComWorld));
+    comWorld->name = memory->Dup(assetName.c_str());
+    return comWorld;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderComWorld final : public BasicAssetLoader<ASSET_TYPE_COMWORLD, ComWorld>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderFont.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderFont::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* font = memory->Create<Font_s>();
+    memset(font, 0, sizeof(Font_s));
+    font->fontName = memory->Dup(assetName.c_str());
+    return font;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderFont final : public BasicAssetLoader<ASSET_TYPE_FONT, Font_s>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderFx.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderFx::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* fx = memory->Create<FxEffectDef>();
+    memset(fx, 0, sizeof(FxEffectDef));
+    fx->name = memory->Dup(assetName.c_str());
+    return fx;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderFx final : public BasicAssetLoader<ASSET_TYPE_FX, FxEffectDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderFxImpactTable.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderFxImpactTable::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* fxImpactTable = memory->Create<FxImpactTable>();
+    memset(fxImpactTable, 0, sizeof(FxImpactTable));
+    fxImpactTable->name = memory->Dup(assetName.c_str());
+    return fxImpactTable;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderFxImpactTable final : public BasicAssetLoader<ASSET_TYPE_IMPACT_FX, FxImpactTable>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderFxWorld.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderFxWorld::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* fxWorld = memory->Create<FxWorld>();
+    memset(fxWorld, 0, sizeof(FxWorld));
+    fxWorld->name = memory->Dup(assetName.c_str());
+    return fxWorld;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderFxWorld final : public BasicAssetLoader<ASSET_TYPE_FXWORLD, FxWorld>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderGameWorldMp.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderGameWorldMp::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* gameWorld = memory->Create<GameWorldMp>();
+    memset(gameWorld, 0, sizeof(GameWorldMp));
+    gameWorld->name = memory->Dup(assetName.c_str());
+    return gameWorld;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderGameWorldMp final : public BasicAssetLoader<ASSET_TYPE_GAMEWORLD_MP, GameWorldMp>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderGameWorldSp.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderGameWorldSp::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* gameWorld = memory->Create<GameWorldSp>();
+    memset(gameWorld, 0, sizeof(GameWorldSp));
+    gameWorld->name = memory->Dup(assetName.c_str());
+    return gameWorld;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderGameWorldSp final : public BasicAssetLoader<ASSET_TYPE_GAMEWORLD_SP, GameWorldSp>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderGfxLightDef.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderGfxLightDef::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* lightDef = memory->Create<GfxLightDef>();
+    memset(lightDef, 0, sizeof(GfxLightDef));
+    lightDef->name = memory->Dup(assetName.c_str());
+    return lightDef;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderGfxLightDef final : public BasicAssetLoader<ASSET_TYPE_LIGHT_DEF, GfxLightDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderGfxWorld.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderGfxWorld::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* gfxWorld = memory->Create<GfxWorld>();
+    memset(gfxWorld, 0, sizeof(GfxWorld));
+    gfxWorld->name = memory->Dup(assetName.c_str());
+    return gfxWorld;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderGfxWorld final : public BasicAssetLoader<ASSET_TYPE_GFXWORLD, GfxWorld>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderLeaderboard.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderLeaderboard::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* leaderboard = memory->Create<LeaderboardDef>();
+    memset(leaderboard, 0, sizeof(LeaderboardDef));
+    leaderboard->name = memory->Dup(assetName.c_str());
+    return leaderboard;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderLeaderboard final : public BasicAssetLoader<ASSET_TYPE_LEADERBOARD, LeaderboardDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderLoadedSound.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderLoadedSound::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* loadedSound = memory->Create<LoadedSound>();
+    memset(loadedSound, 0, sizeof(LoadedSound));
+    loadedSound->name = memory->Dup(assetName.c_str());
+    return loadedSound;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderLoadedSound final : public BasicAssetLoader<ASSET_TYPE_LOADED_SOUND, LoadedSound>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderMapEnts.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderMapEnts::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* mapEnts = memory->Create<MapEnts>();
+    memset(mapEnts, 0, sizeof(MapEnts));
+    mapEnts->name = memory->Dup(assetName.c_str());
+    return mapEnts;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderMapEnts final : public BasicAssetLoader<ASSET_TYPE_MAP_ENTS, MapEnts>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderPhysCollmap.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderPhysCollmap::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* collmap = memory->Create<PhysCollmap>();
+    memset(collmap, 0, sizeof(PhysCollmap));
+    collmap->name = memory->Dup(assetName.c_str());
+    return collmap;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderPhysCollmap final : public BasicAssetLoader<ASSET_TYPE_PHYSCOLLMAP, PhysCollmap>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderPhysPreset.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderPhysPreset::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* physPreset = memory->Create<PhysPreset>();
+    memset(physPreset, 0, sizeof(PhysPreset));
+    physPreset->name = memory->Dup(assetName.c_str());
+    return physPreset;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderPhysPreset final : public BasicAssetLoader<ASSET_TYPE_PHYSPRESET, PhysPreset>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderPixelShader.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderPixelShader::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* pixelShader = memory->Create<MaterialPixelShader>();
+    memset(pixelShader, 0, sizeof(MaterialPixelShader));
+    pixelShader->name = memory->Dup(assetName.c_str());
+    return pixelShader;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderPixelShader final : public BasicAssetLoader<ASSET_TYPE_PIXELSHADER, MaterialPixelShader>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderSndCurve.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderSndCurve::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* sndCurve = memory->Create<SndCurve>();
+    memset(sndCurve, 0, sizeof(SndCurve));
+    sndCurve->filename = memory->Dup(assetName.c_str());
+    return sndCurve;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderSndCurve final : public BasicAssetLoader<ASSET_TYPE_SOUND_CURVE, SndCurve>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderSoundAliasList.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderSoundAliasList::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* sndAliasList = memory->Create<snd_alias_list_t>();
+    memset(sndAliasList, 0, sizeof(snd_alias_list_t));
+    sndAliasList->aliasName = memory->Dup(assetName.c_str());
+    return sndAliasList;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderSoundAliasList final : public BasicAssetLoader<ASSET_TYPE_SOUND, snd_alias_list_t>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderStringTable.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderStringTable::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* stringTable = memory->Create<StringTable>();
+    memset(stringTable, 0, sizeof(StringTable));
+    stringTable->name = memory->Dup(assetName.c_str());
+    return stringTable;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderStringTable final : public BasicAssetLoader<ASSET_TYPE_STRINGTABLE, StringTable>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderStructuredDataDefSet.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderStructuredDataDefSet::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* structuredDataDefSet = memory->Create<StructuredDataDefSet>();
+    memset(structuredDataDefSet, 0, sizeof(StructuredDataDefSet));
+    structuredDataDefSet->name = memory->Dup(assetName.c_str());
+    return structuredDataDefSet;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderStructuredDataDefSet final : public BasicAssetLoader<ASSET_TYPE_STRUCTURED_DATA_DEF, StructuredDataDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderTechniqueSet.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderTechniqueSet::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* techset = memory->Create<MaterialTechniqueSet>();
+    memset(techset, 0, sizeof(MaterialTechniqueSet));
+    techset->name = memory->Dup(assetName.c_str());
+    return techset;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderTechniqueSet final : public BasicAssetLoader<ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderTracer.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderTracer::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* tracer = memory->Create<TracerDef>();
+    memset(tracer, 0, sizeof(TracerDef));
+    tracer->name = memory->Dup(assetName.c_str());
+    return tracer;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderTracer final : public BasicAssetLoader<ASSET_TYPE_TRACER, TracerDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderVehicle.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderVehicle::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* vehicle = memory->Create<VehicleDef>();
+    memset(vehicle, 0, sizeof(VehicleDef));
+    vehicle->name = memory->Dup(assetName.c_str());
+    return vehicle;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderVehicle final : public BasicAssetLoader<ASSET_TYPE_VEHICLE, VehicleDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderVertexDecl.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderVertexDecl::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* vertexDecl = memory->Create<MaterialVertexDeclaration>();
+    memset(vertexDecl, 0, sizeof(MaterialVertexDeclaration));
+    vertexDecl->name = memory->Dup(assetName.c_str());
+    return vertexDecl;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderVertexDecl final : public BasicAssetLoader<ASSET_TYPE_VERTEXDECL, MaterialVertexDeclaration>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderVertexShader.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderVertexShader::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* vertexShader = memory->Create<MaterialVertexShader>();
+    memset(vertexShader, 0, sizeof(MaterialVertexShader));
+    vertexShader->name = memory->Dup(assetName.c_str());
+    return vertexShader;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderVertexShader final : public BasicAssetLoader<ASSET_TYPE_VERTEXSHADER, MaterialVertexShader>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderWeapon.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderWeapon::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* weapon = memory->Create<WeaponCompleteDef>();
+    memset(weapon, 0, sizeof(WeaponCompleteDef));
+    weapon->szInternalName = memory->Dup(assetName.c_str());
+    return weapon;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderWeapon final : public BasicAssetLoader<ASSET_TYPE_WEAPON, WeaponCompleteDef>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderXAnim.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderXAnim::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* anim = memory->Create<XAnimParts>();
+    memset(anim, 0, sizeof(XAnimParts));
+    anim->name = memory->Dup(assetName.c_str());
+    return anim;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderXAnim final : public BasicAssetLoader<ASSET_TYPE_XANIMPARTS, XAnimParts>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderXModel.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderXModel::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* model = memory->Create<XModel>();
+    memset(model, 0, sizeof(XModel));
+    model->name = memory->Dup(assetName.c_str());
+    return model;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderXModel final : public BasicAssetLoader<ASSET_TYPE_XMODEL, XModel>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,17 @@
+#include "AssetLoaderXModelSurfs.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW4/IW4.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW4;
+
+void* AssetLoaderXModelSurfs::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* modelSurfs = memory->Create<XModelSurfs>();
+    memset(modelSurfs, 0, sizeof(XModelSurfs));
+    modelSurfs->name = memory->Dup(assetName.c_str());
+    return modelSurfs;
+}

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW4/IW4.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW4
+{
+    class AssetLoaderXModelSurfs final : public BasicAssetLoader<ASSET_TYPE_XMODEL_SURFS, XModel>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp

@@ -4,11 +4,42 @@
 #include "Game/IW4/GameAssetPoolIW4.h"
 #include "ObjContainer/IPak/IPak.h"
 #include "ObjLoading.h"
+#include "AssetLoaders/AssetLoaderAddonMapEnts.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 "Image/Dx9TextureLoader.h"
 #include "Image/Texture.h"
@@ -20,47 +51,45 @@ 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);}
-#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(AssetLoaderPhysPreset)
+    REGISTER_ASSET_LOADER(AssetLoaderPhysCollmap)
+    REGISTER_ASSET_LOADER(AssetLoaderXAnim)
+    REGISTER_ASSET_LOADER(AssetLoaderXModelSurfs)
+    REGISTER_ASSET_LOADER(AssetLoaderXModel)
     REGISTER_ASSET_LOADER(AssetLoaderMaterial)
-    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(AssetLoaderPixelShader)
+    REGISTER_ASSET_LOADER(AssetLoaderVertexShader)
+    REGISTER_ASSET_LOADER(AssetLoaderVertexDecl)
+    REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
     REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
-    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(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(BASIC_LOADER(ASSET_TYPE_MENU, menuDef_t))
+    REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
     REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
-    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(AssetLoaderWeapon)
+    REGISTER_ASSET_LOADER(AssetLoaderFx)
+    REGISTER_ASSET_LOADER(AssetLoaderFxImpactTable)
     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))
+    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 BASIC_LOADER
 #undef REGISTER_ASSET_LOADER
 }