zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-04-20 00:02:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add loading of gdt entries to info based assets

Browse Source
This commit is contained in:
Jan 2021-03-28 12:07:36 +02:00
parent d9abf12b16
commit 579c0747d0
19 changed files with 410 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/ObjCommon/InfoString/InfoString.cpp
View File

@ -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;
}

3
src/ObjCommon/InfoString/InfoString.h
View File

@ -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);
};

2
src/ObjLoading/AssetLoading/AssetLoadingManager.cpp
View File

@ -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;

62
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderPhysConstraints.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderPhysConstraints.h
View File

@ -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;
};

60
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderPhysPreset.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderPhysPreset.h
View File

@ -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;
};

56
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderTracer.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderTracer.h
View File

@ -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;
};

56
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderVehicle.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderVehicle.h
View File

@ -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;
};

66
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeapon.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeapon.h
View File

@ -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;
};

58
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponAttachment.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponAttachment.h
View File

@ -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;
};

75
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponAttachmentUnique.cpp
View File

@ -184,11 +184,32 @@ bool AssetLoaderWeaponAttachmentUnique::CalculateAttachmentUniqueFields(const st
}
}
// animationOverrides
// siblingLink
// childLink
// soundOverrides
// effectOverrides
return true;
}
bool AssetLoaderWeaponAttachmentUnique::LoadFromInfoString(const InfoString& infoString, const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone)
{
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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponAttachmentUnique.h
View File

@ -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;
};

58
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderZBarrier.cpp
View File

@ -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>();
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;
return LoadFromInfoString(infoString, assetName, memory, manager, zone);
}

5
src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderZBarrier.h
View File

@ -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;
};