Add loading of gdt entries to info based assets

src/ObjCommon/InfoString/InfoString.cpp

@@ -93,7 +93,7 @@ void InfoString::ToGdtProperties(const std::string& prefix, GdtEntry& gdtEntry)
         gdtEntry.m_properties[key] = value->second;
     }
 
-    gdtEntry.m_properties["configstringFileType"] = prefix;
+    gdtEntry.m_properties[GDT_PREFIX_FIELD] = prefix;
 }
 
 class InfoStringInputStream
@@ -195,3 +195,21 @@ bool InfoString::FromStream(const std::string& prefix, std::istream& stream)
 
     return true;
 }
+
+bool InfoString::FromGdtProperties(const std::string& prefix, const GdtEntry& gdtEntry)
+{
+    const auto foundPrefixEntry = gdtEntry.m_properties.find(GDT_PREFIX_FIELD);
+    if (foundPrefixEntry == gdtEntry.m_properties.end() || foundPrefixEntry->second != prefix)
+        return false;
+
+    for(const auto& [key, value] : gdtEntry.m_properties)
+    {
+        if(key == GDT_PREFIX_FIELD)
+            continue;
+
+        m_keys_by_insertion.push_back(key);
+        m_values.emplace(std::make_pair(key, value));
+    }
+
+    return true;
+}

src/ObjCommon/InfoString/InfoString.h

@@ -9,6 +9,8 @@
 
 class InfoString
 {
+    static constexpr const char* GDT_PREFIX_FIELD = "configstringFileType";
+
     static const std::string EMPTY_VALUE;
     std::unordered_map<std::string, std::string> m_values;
     std::vector<std::string> m_keys_by_insertion;
@@ -26,4 +28,5 @@ public:
 
     bool FromStream(std::istream& stream);
     bool FromStream(const std::string& prefix, std::istream& stream);
+    bool FromGdtProperties(const std::string& prefix, const GdtEntry& gdtEntry);
 };

src/ObjLoading/AssetLoading/AssetLoadingManager.cpp

@@ -59,7 +59,7 @@ XAssetInfoGeneric* AssetLoadingManager::LoadIgnoredDependency(const asset_type_t
 
 XAssetInfoGeneric* AssetLoadingManager::LoadAssetDependency(const asset_type_t assetType, const std::string& assetName, IAssetLoader* loader)
 {
-    if (loader->CanLoadFromGdt() && loader->LoadFromGdt(assetName, &m_context, m_context.m_zone->GetMemory(), this, m_context.m_zone))
+    if (loader->CanLoadFromGdt() && !m_context.m_gdt_files.empty() && loader->LoadFromGdt(assetName, &m_context, m_context.m_zone->GetMemory(), this, m_context.m_zone))
     {
         auto* lastDependency = m_last_dependency_loaded;
         m_last_dependency_loaded = nullptr;

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

@@ -71,6 +71,28 @@ void AssetLoaderPhysConstraints::CalculatePhysConstraintsFields(PhysConstraints*
     }
 }
 
+bool AssetLoaderPhysConstraints::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* physConstraints = memory->Create<PhysConstraints>();
+    memset(physConstraints, 0, sizeof(PhysConstraints));
+
+    InfoStringToPhysConstraintsConverter converter(infoString, physConstraints, zone->m_script_strings, memory, manager, phys_constraints_fields, std::extent<decltype(phys_constraints_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse phys constraints: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    CalculatePhysConstraintsFields(physConstraints, zone);
+    physConstraints->name = memory->Dup(assetName.c_str());
+
+    auto scrStrings = converter.GetUsedScriptStrings();
+    scrStrings.push_back(zone->m_script_strings.AddOrGetScriptString(""));
+    manager->AddAsset(ASSET_TYPE_PHYSCONSTRAINTS, assetName, physConstraints, converter.GetDependencies(), scrStrings);
+
+    return true;
+}
+
 void* AssetLoaderPhysConstraints::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* physConstraints = memory->Create<PhysConstraints>();
@@ -79,6 +101,27 @@ void* AssetLoaderPhysConstraints::CreateEmptyAsset(const std::string& assetName,
     return physConstraints;
 }
 
+bool AssetLoaderPhysConstraints::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderPhysConstraints::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_PHYS_CONSTRAINTS, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_PHYS_CONSTRAINTS, *gdtEntry))
+    {
+        std::cout << "Failed to read phys constraints gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderPhysConstraints::CanLoadFromRaw() const
 {
     return true;
@@ -98,22 +141,5 @@ bool AssetLoaderPhysConstraints::LoadFromRaw(const std::string& assetName, ISear
         return true;
     }
 
-    auto* physConstraints = memory->Create<PhysConstraints>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(physConstraints, 0, sizeof(PhysConstraints));
-
-    InfoStringToPhysConstraintsConverter converter(infoString, physConstraints, zone->m_script_strings, memory, manager, phys_constraints_fields, std::extent<decltype(phys_constraints_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse phys constraints raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    CalculatePhysConstraintsFields(physConstraints, zone);
-    physConstraints->name = memory->Dup(assetName.c_str());
-
-    auto scrStrings = converter.GetUsedScriptStrings();
-    scrStrings.push_back(zone->m_script_strings.AddOrGetScriptString(""));
-    manager->AddAsset(ASSET_TYPE_PHYSCONSTRAINTS, assetName, physConstraints, converter.GetDependencies(), scrStrings);
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -10,8 +11,12 @@ namespace T6
     {
         static void CalculatePhysConstraintsFields(PhysConstraints* physConstraints, Zone* zone);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -55,6 +55,27 @@ void AssetLoaderPhysPreset::CopyFromPhysPresetInfo(const PhysPresetInfo* physPre
     physPreset->buoyancyBoxMax = physPresetInfo->buoyancyBoxMax;
 }
 
+bool AssetLoaderPhysPreset::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    const auto presetInfo = std::make_unique<PhysPresetInfo>();
+    memset(presetInfo.get(), 0, sizeof(PhysPresetInfo));
+    InfoStringToPhysPresetConverter converter(infoString, presetInfo.get(), zone->m_script_strings, memory, manager, phys_preset_fields, std::extent<decltype(phys_preset_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse phys preset: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    auto* physPreset = memory->Create<PhysPreset>();
+
+    CopyFromPhysPresetInfo(presetInfo.get(), physPreset);
+    physPreset->name = memory->Dup(assetName.c_str());
+
+    manager->AddAsset(ASSET_TYPE_PHYSPRESET, assetName, physPreset, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderPhysPreset::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* physPreset = memory->Create<PhysPreset>();
@@ -63,6 +84,27 @@ void* AssetLoaderPhysPreset::CreateEmptyAsset(const std::string& assetName, Memo
     return physPreset;
 }
 
+bool AssetLoaderPhysPreset::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderPhysPreset::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_PHYS_PRESET, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_PHYS_PRESET, *gdtEntry))
+    {
+        std::cout << "Failed to read phys preset gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderPhysPreset::CanLoadFromRaw() const
 {
     return true;
@@ -82,21 +124,5 @@ bool AssetLoaderPhysPreset::LoadFromRaw(const std::string& assetName, ISearchPat
         return true;
     }
 
-    auto presetInfo = std::make_unique<PhysPresetInfo>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(presetInfo.get(), 0, sizeof(PhysPresetInfo));
-    InfoStringToPhysPresetConverter converter(infoString, presetInfo.get(), zone->m_script_strings, memory, manager, phys_preset_fields, std::extent<decltype(phys_preset_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse phys preset raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    auto* physPreset = memory->Create<PhysPreset>();
-
-    CopyFromPhysPresetInfo(presetInfo.get(), physPreset);
-    physPreset->name = memory->Dup(assetName.c_str());
-
-    manager->AddAsset(ASSET_TYPE_PHYSPRESET, assetName, physPreset, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -10,8 +11,12 @@ namespace T6
     {
         static void CopyFromPhysPresetInfo(const PhysPresetInfo* physPresetInfo, PhysPreset* physPreset);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -41,6 +41,25 @@ namespace T6
     };
 }
 
+bool AssetLoaderTracer::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* tracer = memory->Create<TracerDef>();
+    memset(tracer, 0, sizeof(TracerDef));
+
+    InfoStringToTracerConverter converter(infoString, tracer, zone->m_script_strings, memory, manager, tracer_fields, std::extent<decltype(tracer_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse tracer: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    tracer->name = memory->Dup(assetName.c_str());
+
+    manager->AddAsset(ASSET_TYPE_TRACER, assetName, tracer, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderTracer::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* tracer = memory->Create<TracerDef>();
@@ -49,6 +68,27 @@ void* AssetLoaderTracer::CreateEmptyAsset(const std::string& assetName, MemoryMa
     return tracer;
 }
 
+bool AssetLoaderTracer::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderTracer::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_TRACER, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_TRACER, *gdtEntry))
+    {
+        std::cout << "Failed to read tracer gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderTracer::CanLoadFromRaw() const
 {
     return true;
@@ -68,19 +108,5 @@ bool AssetLoaderTracer::LoadFromRaw(const std::string& assetName, ISearchPath* s
         return true;
     }
 
-    auto* tracer = memory->Create<TracerDef>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(tracer, 0, sizeof(TracerDef));
-
-    InfoStringToTracerConverter converter(infoString, tracer, zone->m_script_strings, memory, manager, tracer_fields, std::extent<decltype(tracer_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse tracer raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-    
-    tracer->name = memory->Dup(assetName.c_str());
-
-    manager->AddAsset(ASSET_TYPE_TRACER, assetName, tracer, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,14 +2,19 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
 {
     class AssetLoaderTracer final : public BasicAssetLoader<ASSET_TYPE_TRACER, TracerDef>
     {
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -97,6 +97,25 @@ namespace T6
     };
 }
 
+bool AssetLoaderVehicle::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* vehicleDef = memory->Create<VehicleDef>();
+    memset(vehicleDef, 0, sizeof(VehicleDef));
+
+    InfoStringToVehicleConverter converter(infoString, vehicleDef, zone->m_script_strings, memory, manager, vehicle_fields, std::extent<decltype(vehicle_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse vehicle: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    vehicleDef->name = memory->Dup(assetName.c_str());
+
+    manager->AddAsset(ASSET_TYPE_VEHICLEDEF, assetName, vehicleDef, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderVehicle::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* vehicleDef = memory->Create<VehicleDef>();
@@ -105,6 +124,27 @@ void* AssetLoaderVehicle::CreateEmptyAsset(const std::string& assetName, MemoryM
     return vehicleDef;
 }
 
+bool AssetLoaderVehicle::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderVehicle::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_VEHICLE, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_VEHICLE, *gdtEntry))
+    {
+        std::cout << "Failed to read vehicle gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderVehicle::CanLoadFromRaw() const
 {
     return true;
@@ -124,19 +164,5 @@ bool AssetLoaderVehicle::LoadFromRaw(const std::string& assetName, ISearchPath*
         return true;
     }
 
-    auto* vehicleDef = memory->Create<VehicleDef>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(vehicleDef, 0, sizeof(VehicleDef));
-
-    InfoStringToVehicleConverter converter(infoString, vehicleDef, zone->m_script_strings, memory, manager, vehicle_fields, std::extent<decltype(vehicle_fields)>::value);
-    if(!converter.Convert())
-    {
-        std::cout << "Failed to parse vehicle raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    vehicleDef->name = memory->Dup(assetName.c_str());
-
-    manager->AddAsset(ASSET_TYPE_VEHICLEDEF, assetName, vehicleDef, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,14 +2,19 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
 {
     class AssetLoaderVehicle final : public BasicAssetLoader<ASSET_TYPE_VEHICLEDEF, VehicleDef>
     {
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -506,6 +506,30 @@ void AssetLoaderWeapon::CalculateAttachmentFields(WeaponFullDef* weapon)
     }
 }
 
+bool AssetLoaderWeapon::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* weaponFullDef = memory->Create<WeaponFullDef>();
+    memset(weaponFullDef, 0, sizeof(WeaponFullDef));
+    LinkWeaponFullDefSubStructs(weaponFullDef);
+
+    InfoStringToWeaponConverter converter(infoString, weaponFullDef, zone->m_script_strings, memory, manager, weapon_fields, std::extent<decltype(weapon_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse weapon: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    weaponFullDef->weapVariantDef.szInternalName = memory->Dup(assetName.c_str());
+
+    // TODO: Load accuracy graph and flametable
+    CalculateWeaponFields(weaponFullDef);
+    CalculateAttachmentFields(weaponFullDef);
+
+    manager->AddAsset(ASSET_TYPE_WEAPON, assetName, &weaponFullDef->weapVariantDef, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderWeapon::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* weaponFullDef = memory->Create<WeaponFullDef>();
@@ -516,6 +540,27 @@ void* AssetLoaderWeapon::CreateEmptyAsset(const std::string& assetName, MemoryMa
     return weaponFullDef;
 }
 
+bool AssetLoaderWeapon::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderWeapon::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_WEAPON, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if(!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON, *gdtEntry))
+    {
+        std::cout << "Failed to read weapon gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderWeapon::CanLoadFromRaw() const
 {
     return true;
@@ -535,24 +580,5 @@ bool AssetLoaderWeapon::LoadFromRaw(const std::string& assetName, ISearchPath* s
         return true;
     }
 
-    auto* weaponFullDef = memory->Create<WeaponFullDef>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(weaponFullDef, 0, sizeof(WeaponFullDef));
-    LinkWeaponFullDefSubStructs(weaponFullDef);
-
-    InfoStringToWeaponConverter converter(infoString, weaponFullDef, zone->m_script_strings, memory, manager, weapon_fields, std::extent<decltype(weapon_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse weapon raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    weaponFullDef->weapVariantDef.szInternalName = memory->Dup(assetName.c_str());
-
-    // TODO: Load accuracy graph and flametable
-    CalculateWeaponFields(weaponFullDef);
-    CalculateAttachmentFields(weaponFullDef);
-
-    manager->AddAsset(ASSET_TYPE_WEAPON, assetName, &weaponFullDef->weapVariantDef, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -19,8 +20,12 @@ namespace T6
         static void CalculateAttachmentFields(WeaponFullDef* weapon, unsigned attachmentIndex, WeaponAttachmentUnique* attachmentUnique);
         static void CalculateAttachmentFields(WeaponFullDef* weapon);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -91,6 +91,26 @@ void AssetLoaderWeaponAttachment::CalculateAttachmentFields(WeaponAttachment* at
     }
 }
 
+bool AssetLoaderWeaponAttachment::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* attachment = memory->Create<WeaponAttachment>();
+    memset(attachment, 0, sizeof(WeaponAttachment));
+
+    InfoStringToWeaponAttachmentConverter converter(infoString, attachment, zone->m_script_strings, memory, manager, attachment_fields, std::extent<decltype(attachment_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse attachment: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    CalculateAttachmentFields(attachment);
+    attachment->szInternalName = memory->Dup(assetName.c_str());
+
+    manager->AddAsset(ASSET_TYPE_ATTACHMENT, assetName, attachment, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderWeaponAttachment::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* attachment = memory->Create<WeaponAttachment>();
@@ -100,6 +120,27 @@ void* AssetLoaderWeaponAttachment::CreateEmptyAsset(const std::string& assetName
     return attachment;
 }
 
+bool AssetLoaderWeaponAttachment::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderWeaponAttachment::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_WEAPON_ATTACHMENT, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON_ATTACHMENT, *gdtEntry))
+    {
+        std::cout << "Failed to read attachment gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderWeaponAttachment::CanLoadFromRaw() const
 {
     return true;
@@ -119,20 +160,5 @@ bool AssetLoaderWeaponAttachment::LoadFromRaw(const std::string& assetName, ISea
         return true;
     }
 
-    auto* attachment = memory->Create<WeaponAttachment>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(attachment, 0, sizeof(WeaponAttachment));
-
-    InfoStringToWeaponAttachmentConverter converter(infoString, attachment, zone->m_script_strings, memory, manager, attachment_fields, std::extent<decltype(attachment_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse attachment raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    CalculateAttachmentFields(attachment);
-    attachment->szInternalName = memory->Dup(assetName.c_str());
-
-    manager->AddAsset(ASSET_TYPE_ATTACHMENT, assetName, attachment, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -10,8 +11,12 @@ namespace T6
     {
         static void CalculateAttachmentFields(WeaponAttachment* attachment);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -184,11 +184,32 @@ bool AssetLoaderWeaponAttachmentUnique::CalculateAttachmentUniqueFields(const st
         }
     }
 
-    // animationOverrides
+    return true;
-    // siblingLink
+}
-    // childLink
+
-    // soundOverrides
+bool AssetLoaderWeaponAttachmentUnique::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
-    // effectOverrides
+{
+
+    auto* attachmentUniqueFull = memory->Create<WeaponAttachmentUniqueFull>();
+    memset(attachmentUniqueFull, 0, sizeof(WeaponAttachmentUniqueFull));
+    LinkAttachmentUniqueFullSubStructs(attachmentUniqueFull);
+
+    InfoStringToWeaponAttachmentUniqueConverter converter(infoString, attachmentUniqueFull, zone->m_script_strings, memory, manager, attachment_unique_fields, std::extent<decltype(attachment_unique_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse attachment unique: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    if (!CalculateAttachmentUniqueFields(assetName, attachmentUniqueFull))
+        return true;
+
+    attachmentUniqueFull->attachment.szInternalName = memory->Dup(assetName.c_str());
+
+    auto* assetInfo = GlobalAssetPool<WeaponAttachmentUnique>::GetAssetByName(assetName);
+    auto* asset = assetInfo ? assetInfo->Asset() : nullptr;
+
+    manager->AddAsset(ASSET_TYPE_ATTACHMENT_UNIQUE, assetName, &attachmentUniqueFull->attachment, converter.GetDependencies(), converter.GetUsedScriptStrings());
 
     return true;
 }
@@ -203,6 +224,27 @@ void* AssetLoaderWeaponAttachmentUnique::CreateEmptyAsset(const std::string& ass
     return attachmentUniqueFull;
 }
 
+bool AssetLoaderWeaponAttachmentUnique::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderWeaponAttachmentUnique::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_WEAPON_ATTACHMENT_UNIQUE, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON_ATTACHMENT_UNIQUE, *gdtEntry))
+    {
+        std::cout << "Failed to read attachment unique gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderWeaponAttachmentUnique::CanLoadFromRaw() const
 {
     return true;
@@ -222,26 +264,5 @@ bool AssetLoaderWeaponAttachmentUnique::LoadFromRaw(const std::string& assetName
         return true;
     }
 
-    auto* attachmentUniqueFull = memory->Create<WeaponAttachmentUniqueFull>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(attachmentUniqueFull, 0, sizeof(WeaponAttachmentUniqueFull));
-    LinkAttachmentUniqueFullSubStructs(attachmentUniqueFull);
-
-    InfoStringToWeaponAttachmentUniqueConverter converter(infoString, attachmentUniqueFull, zone->m_script_strings, memory, manager, attachment_unique_fields, std::extent<decltype(attachment_unique_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse attachment unique raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    if (!CalculateAttachmentUniqueFields(assetName, attachmentUniqueFull))
-        return true;
-
-    attachmentUniqueFull->attachment.szInternalName = memory->Dup(assetName.c_str());
-
-    auto* assetInfo = GlobalAssetPool<WeaponAttachmentUnique>::GetAssetByName(assetName);
-    auto* asset = assetInfo ? assetInfo->Asset() : nullptr;
-
-    manager->AddAsset(ASSET_TYPE_ATTACHMENT_UNIQUE, assetName, &attachmentUniqueFull->attachment, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -11,10 +12,14 @@ namespace T6
         static void LinkAttachmentUniqueFullSubStructs(WeaponAttachmentUniqueFull* attachmentUnique);
         static bool CalculateAttachmentUniqueFields(const std::string& assetName, WeaponAttachmentUniqueFull* attachmentUnique);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         static bool ExtractAttachmentsFromAssetName(const std::string& assetName, std::vector<eAttachment>& attachmentList);
 
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };

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

@@ -52,6 +52,26 @@ void AssetLoaderZBarrier::CalculateZBarrierFields(ZBarrierDef* zbarrier)
     }
 }
 
+bool AssetLoaderZBarrier::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
+{
+    auto* zbarrier = memory->Create<ZBarrierDef>();
+    memset(zbarrier, 0, sizeof(ZBarrierDef));
+
+    InfoStringToZBarrierConverter converter(infoString, zbarrier, zone->m_script_strings, memory, manager, zbarrier_fields, std::extent<decltype(zbarrier_fields)>::value);
+    if (!converter.Convert())
+    {
+        std::cout << "Failed to parse zbarrier: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    CalculateZBarrierFields(zbarrier);
+    zbarrier->name = memory->Dup(assetName.c_str());
+
+    manager->AddAsset(ASSET_TYPE_ZBARRIER, assetName, zbarrier, converter.GetDependencies(), converter.GetUsedScriptStrings());
+
+    return true;
+}
+
 void* AssetLoaderZBarrier::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
 {
     auto* zbarrier = memory->Create<ZBarrierDef>();
@@ -61,6 +81,27 @@ void* AssetLoaderZBarrier::CreateEmptyAsset(const std::string& assetName, Memory
     return zbarrier;
 }
 
+bool AssetLoaderZBarrier::CanLoadFromGdt() const
+{
+    return true;
+}
+
+bool AssetLoaderZBarrier::LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    auto* gdtEntry = gdtQueryable->GetGdtEntryByGdfAndName(ObjConstants::GDF_FILENAME_ZBARRIER, assetName);
+    if (gdtEntry == nullptr)
+        return false;
+
+    InfoString infoString;
+    if (!infoString.FromGdtProperties(ObjConstants::INFO_STRING_PREFIX_ZBARRIER, *gdtEntry))
+    {
+        std::cout << "Failed to read zbarrier gdt entry: \"" << assetName << "\"" << std::endl;
+        return true;
+    }
+
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
+}
+
 bool AssetLoaderZBarrier::CanLoadFromRaw() const
 {
     return true;
@@ -80,20 +121,5 @@ bool AssetLoaderZBarrier::LoadFromRaw(const std::string& assetName, ISearchPath*
         return true;
     }
 
-    auto* zbarrier = memory->Create<ZBarrierDef>();
+    return LoadFromInfoString(infoString, assetName, memory, manager, zone);
-    memset(zbarrier, 0, sizeof(ZBarrierDef));
-
-    InfoStringToZBarrierConverter converter(infoString, zbarrier, zone->m_script_strings, memory, manager, zbarrier_fields, std::extent<decltype(zbarrier_fields)>::value);
-    if (!converter.Convert())
-    {
-        std::cout << "Failed to parse zbarrier raw file: \"" << fileName << "\"" << std::endl;
-        return true;
-    }
-
-    CalculateZBarrierFields(zbarrier);
-    zbarrier->name = memory->Dup(assetName.c_str());
-
-    manager->AddAsset(ASSET_TYPE_ZBARRIER, assetName, zbarrier, converter.GetDependencies(), converter.GetUsedScriptStrings());
-
-    return true;
 }

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

@@ -2,6 +2,7 @@
 #include "Game/T6/T6.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoString.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace T6
@@ -10,8 +11,12 @@ namespace T6
     {
         static void CalculateZBarrierFields(ZBarrierDef* zbarrier);
 
+        static bool LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromGdt() const override;
+        bool LoadFromGdt(const std::string& assetName, IGdtQueryable* gdtQueryable, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
         _NODISCARD bool CanLoadFromRaw() const override;
         bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
     };