Merge pull request #257 from Laupetin/feature/t6-default-assets

chore: add asset loaders for all asset types of t6

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderAddonMapEnts.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderAddonMapEnts::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetAddonMapEnts::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,23 @@
+#include "AssetLoaderClipMap.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderClipMapBase::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<clipMap_t>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}
+
+asset_type_t AssetLoaderClipMap::GetHandlingAssetType() const
+{
+    return ASSET_TYPE_CLIPMAP;
+}
+
+asset_type_t AssetLoaderClipMapPvs::GetHandlingAssetType() const
+{
+    return ASSET_TYPE_CLIPMAP_PVS;
+}

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "AssetLoading/BasicAssetLoader.h"
+#include "Game/T6/T6.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace T6
+{
+    class AssetLoaderClipMapBase : public BasicAssetLoaderWithoutType<clipMap_t>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+
+    class AssetLoaderClipMap final : public AssetLoaderClipMapBase
+    {
+    public:
+        [[nodiscard]] asset_type_t GetHandlingAssetType() const override;
+    };
+
+    class AssetLoaderClipMapPvs final : public AssetLoaderClipMapBase
+    {
+    public:
+        [[nodiscard]] asset_type_t GetHandlingAssetType() const override;
+    };
+} // namespace T6

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderComWorld.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderComWorld::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetComWorld::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderDDL.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderDDL::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetDDL::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderDestructibleDef.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderDestructibleDef::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetDestructibleDef::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderEmblemSet.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderEmblemSet::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    // Asset does not have a name
+    // So this cannot be an asset reference
+    return nullptr;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderFont.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderFont::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetFont::Type>();
+    asset->fontName = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -13,10 +13,9 @@ using namespace T6;
 
 void* AssetLoaderFontIcon::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* fontIcon = memory->Create<FontIcon>();
-    memset(fontIcon, 0, sizeof(FontIcon));
-    fontIcon->name = memory->Dup(assetName.c_str());
-    return fontIcon;
+    auto* asset = memory->Alloc<AssetFontIcon::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderFontIcon::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderFootstepFxTable.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderFootstepFxTable::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetFootstepFxTable::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderFootstepTable.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderFootstepTable::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetFootstepTable::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderFx.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderFx::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetFx::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderGameWorldMp.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderGameWorldMp::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetGameWorldMp::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderGameWorldSp.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderGameWorldSp::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetGameWorldSp::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -14,10 +14,9 @@ using namespace T6;
 
 void* AssetLoaderGfxImage::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* image = memory->Create<GfxImage>();
-    memset(image, 0, sizeof(GfxImage));
-    image->name = memory->Dup(assetName.c_str());
-    return image;
+    auto* asset = memory->Alloc<AssetImage::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderGfxImage::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderGfxLightDef.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderGfxLightDef::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetLightDef::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderGfxWorld.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderGfxWorld::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetGfxWorld::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderGlasses.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderGlasses::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetGlasses::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderImpactFx.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderImpactFx::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetImpactFx::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -13,10 +13,9 @@ using namespace T6;
 
 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;
+    auto* asset = memory->Alloc<AssetLeaderboard::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderLeaderboard::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderMapEnts.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderMapEnts::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetMapEnts::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -12,11 +12,9 @@ using namespace T6;
 
 void* AssetLoaderMaterial::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* material = memory->Create<Material>();
-    memset(material, 0, sizeof(Material));
-    material->info.name = memory->Dup(assetName.c_str());
-
-    return material;
+    auto* asset = memory->Alloc<AssetMaterial::Type>();
+    asset->info.name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderMaterial::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderMemoryBlock.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderMemoryBlock::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetMemoryBlock::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderMenu.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderMenu::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetMenu::Type>();
+    asset->window.name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderMenuList.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderMenuList::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetMenuList::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -102,10 +102,9 @@ bool AssetLoaderPhysConstraints::LoadFromInfoString(
 
 void* AssetLoaderPhysConstraints::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* physConstraints = memory->Create<PhysConstraints>();
-    memset(physConstraints, 0, sizeof(PhysConstraints));
-    physConstraints->name = memory->Dup(assetName.c_str());
-    return physConstraints;
+    auto* asset = memory->Alloc<AssetPhysConstraints::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderPhysConstraints::CanLoadFromGdt() const

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

@@ -85,10 +85,9 @@ bool AssetLoaderPhysPreset::LoadFromInfoString(
 
 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;
+    auto* asset = memory->Alloc<AssetPhysPreset::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderPhysPreset::CanLoadFromGdt() const

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

@@ -9,10 +9,9 @@ using namespace T6;
 
 void* AssetLoaderQdb::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* qdb = memory->Create<Qdb>();
-    memset(qdb, 0, sizeof(Qdb));
-    qdb->name = memory->Dup(assetName.c_str());
-    return qdb;
+    auto* asset = memory->Alloc<AssetQdb::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderQdb::CanLoadFromRaw() const

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

@@ -15,10 +15,9 @@ namespace fs = std::filesystem;
 
 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;
+    auto* asset = memory->Alloc<AssetRawFile::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderRawFile::CanLoadFromRaw() const

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

@@ -9,10 +9,9 @@ using namespace T6;
 
 void* AssetLoaderScriptParseTree::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* scriptParseTree = memory->Create<ScriptParseTree>();
-    memset(scriptParseTree, 0, sizeof(ScriptParseTree));
-    scriptParseTree->name = memory->Dup(assetName.c_str());
-    return scriptParseTree;
+    auto* asset = memory->Alloc<AssetScript::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderScriptParseTree::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderSkinnedVerts.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderSkinnedVerts::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetSkinnedVerts::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -9,10 +9,9 @@ using namespace T6;
 
 void* AssetLoaderSlug::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* slug = memory->Create<Slug>();
-    memset(slug, 0, sizeof(Slug));
-    slug->name = memory->Dup(assetName.c_str());
-    return slug;
+    auto* asset = memory->Alloc<AssetSlug::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderSlug::CanLoadFromRaw() const

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

@@ -62,10 +62,9 @@ namespace
 
 void* AssetLoaderSoundBank::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* soundBank = memory->Create<SndBank>();
-    memset(soundBank, 0, sizeof(SndBank));
-    soundBank->name = memory->Dup(assetName.c_str());
-    return soundBank;
+    auto* asset = memory->Alloc<AssetSoundBank::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderSoundBank::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderSoundDriverGlobals.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderSoundDriverGlobals::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetSoundDriverGlobals::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderSoundPatch.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderSoundPatch::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetSoundPatch::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -12,10 +12,9 @@ using namespace T6;
 
 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;
+    auto* asset = memory->Alloc<AssetStringTable::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderStringTable::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderTechniqueSet.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderTechniqueSet::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetTechniqueSet::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -68,10 +68,9 @@ bool AssetLoaderTracer::LoadFromInfoString(
 
 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;
+    auto* asset = memory->Alloc<AssetTracer::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderTracer::CanLoadFromGdt() const

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

@@ -131,10 +131,9 @@ bool AssetLoaderVehicle::LoadFromInfoString(
 
 void* AssetLoaderVehicle::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* vehicleDef = memory->Create<VehicleDef>();
-    memset(vehicleDef, 0, sizeof(VehicleDef));
-    vehicleDef->name = memory->Dup(assetName.c_str());
-    return vehicleDef;
+    auto* asset = memory->Alloc<AssetVehicle::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderVehicle::CanLoadFromGdt() const

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

@@ -630,8 +630,7 @@ bool AssetLoaderWeapon::LoadFromInfoString(
 
 void* AssetLoaderWeapon::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* weaponFullDef = memory->Create<WeaponFullDef>();
-    memset(weaponFullDef, 0, sizeof(WeaponFullDef));
+    auto* weaponFullDef = memory->Alloc<WeaponFullDef>();
     LinkWeaponFullDefSubStructs(weaponFullDef);
     CalculateWeaponFields(weaponFullDef);
     weaponFullDef->weapVariantDef.szInternalName = memory->Dup(assetName.c_str());

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

@@ -120,8 +120,7 @@ bool AssetLoaderWeaponAttachment::LoadFromInfoString(
 
 void* AssetLoaderWeaponAttachment::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* attachment = memory->Create<WeaponAttachment>();
-    memset(attachment, 0, sizeof(WeaponAttachment));
+    auto* attachment = memory->Alloc<WeaponAttachment>();
     CalculateAttachmentFields(attachment);
     attachment->szInternalName = memory->Dup(assetName.c_str());
     return attachment;

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

@@ -239,8 +239,7 @@ bool AssetLoaderWeaponAttachmentUnique::LoadFromInfoString(
 
 void* AssetLoaderWeaponAttachmentUnique::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* attachmentUniqueFull = memory->Create<WeaponAttachmentUniqueFull>();
-    memset(attachmentUniqueFull, 0, sizeof(WeaponAttachmentUniqueFull));
+    auto* attachmentUniqueFull = memory->Alloc<WeaponAttachmentUniqueFull>();
     LinkAttachmentUniqueFullSubStructs(attachmentUniqueFull);
     CalculateAttachmentUniqueFields(assetName, attachmentUniqueFull);
     attachmentUniqueFull->attachment.szInternalName = memory->Dup(assetName.c_str());

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

@@ -12,11 +12,9 @@ using namespace T6;
 
 void* AssetLoaderWeaponCamo::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* weaponCamo = memory->Create<WeaponCamo>();
-    memset(weaponCamo, 0, sizeof(WeaponCamo));
-    weaponCamo->name = memory->Dup(assetName.c_str());
-
-    return weaponCamo;
+    auto* asset = memory->Alloc<AssetWeaponCamo::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderWeaponCamo::CanLoadFromRaw() const

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderXAnim.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderXAnim::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetXAnim::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -0,0 +1,13 @@
+#include "AssetLoaderXGlobals.h"
+
+#include "Game/T6/T6.h"
+#include "ObjLoading.h"
+
+using namespace T6;
+
+void* AssetLoaderXGlobals::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* asset = memory->Alloc<AssetXGlobals::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
+}

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

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

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

@@ -12,11 +12,9 @@ using namespace T6;
 
 void* AssetLoaderXModel::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* xmodel = memory->Create<XModel>();
-    memset(xmodel, 0, sizeof(XModel));
-    xmodel->name = memory->Dup(assetName.c_str());
-
-    return xmodel;
+    auto* asset = memory->Alloc<AssetXModel::Type>();
+    asset->name = memory->Dup(assetName.c_str());
+    return asset;
 }
 
 bool AssetLoaderXModel::CanLoadFromRaw() const

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

@@ -81,8 +81,7 @@ bool AssetLoaderZBarrier::LoadFromInfoString(
 
 void* AssetLoaderZBarrier::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
-    auto* zbarrier = memory->Create<ZBarrierDef>();
-    memset(zbarrier, 0, sizeof(ZBarrierDef));
+    auto* zbarrier = memory->Alloc<ZBarrierDef>();
     CalculateZBarrierFields(zbarrier);
     zbarrier->name = memory->Dup(assetName.c_str());
     return zbarrier;

src/ObjLoading/Game/T6/ObjLoaderT6.cpp

@@ -1,24 +1,50 @@
 #include "ObjLoaderT6.h"
 
+#include "AssetLoaders/AssetLoaderAddonMapEnts.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"
@@ -49,51 +75,51 @@ namespace T6
 
         REGISTER_ASSET_LOADER(AssetLoaderPhysPreset)
         REGISTER_ASSET_LOADER(AssetLoaderPhysConstraints)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDestructibleDef>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetXAnim>)
+        REGISTER_ASSET_LOADER(AssetLoaderDestructibleDef)
+        REGISTER_ASSET_LOADER(AssetLoaderXAnim)
         REGISTER_ASSET_LOADER(AssetLoaderXModel)
         REGISTER_ASSET_LOADER(AssetLoaderMaterial)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetTechniqueSet>)
+        REGISTER_ASSET_LOADER(AssetLoaderTechniqueSet)
         REGISTER_ASSET_LOADER(AssetLoaderGfxImage)
         REGISTER_ASSET_LOADER(AssetLoaderSoundBank)
-        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(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(BasicAssetLoader<AssetMenuList>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetMenu>)
+        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(BasicAssetLoader<AssetSoundDriverGlobals>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFx>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetImpactFx>)
+        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(BasicAssetLoader<AssetXGlobals>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetDDL>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetGlasses>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetEmblemSet>)
+        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(BasicAssetLoader<AssetMemoryBlock>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetAddonMapEnts>)
+        REGISTER_ASSET_LOADER(AssetLoaderMemoryBlock)
+        REGISTER_ASSET_LOADER(AssetLoaderAddonMapEnts)
         REGISTER_ASSET_LOADER(AssetLoaderTracer)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetSkinnedVerts>)
+        REGISTER_ASSET_LOADER(AssetLoaderSkinnedVerts)
         REGISTER_ASSET_LOADER(AssetLoaderQdb)
         REGISTER_ASSET_LOADER(AssetLoaderSlug)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFootstepTable>)
-        REGISTER_ASSET_LOADER(BasicAssetLoader<AssetFootstepFxTable>)
+        REGISTER_ASSET_LOADER(AssetLoaderFootstepTable)
+        REGISTER_ASSET_LOADER(AssetLoaderFootstepFxTable)
         REGISTER_ASSET_LOADER(AssetLoaderZBarrier)
 
 #undef REGISTER_ASSET_LOADER