From af37476e23485443cfb25dbb3145fa93e31078d9 Mon Sep 17 00:00:00 2001 From: Jan Date: Sun, 24 Mar 2024 13:29:35 +0100 Subject: [PATCH 1/5] chore: make material json loader use anonymous namespace --- src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp b/src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp index db3d8f61..12998197 100644 --- a/src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp +++ b/src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp @@ -4,13 +4,13 @@ #include "Game/T6/Json/JsonMaterial.h" #include -#include #include #include using namespace nlohmann; +using namespace T6; -namespace T6 +namespace { class JsonLoader { @@ -362,7 +362,10 @@ namespace T6 IAssetLoadingManager& m_manager; std::vector& m_dependencies; }; +} // namespace +namespace T6 +{ bool LoadMaterialAsJson( std::istream& stream, Material& material, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies) { From c881cd6fd3beb87e104e5a1fce7d92e20f2d0a86 Mon Sep 17 00:00:00 2001 From: Jan Date: Sun, 24 Mar 2024 14:48:54 +0100 Subject: [PATCH 2/5] =?UTF-8?q?=EF=BB=BFfeat:=20load=20t6=20weapon=20camo?= =?UTF-8?q?=20from=20json?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../T6/AssetLoaders/AssetLoaderWeaponCamo.cpp | 46 ++++ .../T6/AssetLoaders/AssetLoaderWeaponCamo.h | 17 ++ src/ObjLoading/Game/T6/ObjLoaderT6.cpp | 3 +- .../T6/WeaponCamo/JsonWeaponCamoLoader.cpp | 247 ++++++++++++++++++ .../Game/T6/WeaponCamo/JsonWeaponCamoLoader.h | 13 + 5 files changed, 325 insertions(+), 1 deletion(-) create mode 100644 src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp create mode 100644 src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.h create mode 100644 src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp create mode 100644 src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.h diff --git a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp new file mode 100644 index 00000000..160a8e2f --- /dev/null +++ b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp @@ -0,0 +1,46 @@ +#include "AssetLoaderWeaponCamo.h" + +#include "Game/T6/WeaponCamo/JsonWeaponCamoLoader.h" +#include "Game/T6/T6.h" +#include "Pool/GlobalAssetPool.h" + +#include +#include +#include + +using namespace T6; + +void* AssetLoaderWeaponCamo::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) +{ + auto* weaponCamo = memory->Create(); + memset(weaponCamo, 0, sizeof(WeaponCamo)); + weaponCamo->name = memory->Dup(assetName.c_str()); + + return weaponCamo; +} + +bool AssetLoaderWeaponCamo::CanLoadFromRaw() const +{ + return true; +} + +bool AssetLoaderWeaponCamo::LoadFromRaw( + const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const +{ + const auto fileName = std::format("camo/{}.json", assetName); + const auto file = searchPath->Open(fileName); + if (!file.IsOpen()) + return false; + + auto* weaponCamo = static_cast(memory->Alloc(sizeof(WeaponCamo))); + memset(weaponCamo, 0, sizeof(WeaponCamo)); + weaponCamo->name = memory->Dup(assetName.c_str()); + + std::vector dependencies; + if (LoadWeaponCamoAsJson(*file.m_stream, *weaponCamo, memory, manager, dependencies)) + manager->AddAsset(ASSET_TYPE_WEAPON_CAMO, assetName, weaponCamo, std::move(dependencies)); + else + std::cerr << "Failed to load weapon camo \"" << assetName << "\"\n"; + + return true; +} diff --git a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.h b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.h new file mode 100644 index 00000000..7c6fb2ac --- /dev/null +++ b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.h @@ -0,0 +1,17 @@ +#pragma once +#include "AssetLoading/BasicAssetLoader.h" +#include "AssetLoading/IAssetLoadingManager.h" +#include "Game/T6/T6.h" +#include "SearchPath/ISearchPath.h" + +namespace T6 +{ + class AssetLoaderWeaponCamo final : public BasicAssetLoader + { + public: + _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override; + _NODISCARD bool CanLoadFromRaw() const override; + bool + LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override; + }; +} // namespace T6 diff --git a/src/ObjLoading/Game/T6/ObjLoaderT6.cpp b/src/ObjLoading/Game/T6/ObjLoaderT6.cpp index 667e70ab..40b29f29 100644 --- a/src/ObjLoading/Game/T6/ObjLoaderT6.cpp +++ b/src/ObjLoading/Game/T6/ObjLoaderT6.cpp @@ -17,6 +17,7 @@ #include "AssetLoaders/AssetLoaderWeapon.h" #include "AssetLoaders/AssetLoaderWeaponAttachment.h" #include "AssetLoaders/AssetLoaderWeaponAttachmentUnique.h" +#include "AssetLoaders/AssetLoaderWeaponCamo.h" #include "AssetLoaders/AssetLoaderZBarrier.h" #include "AssetLoading/AssetLoadingManager.h" #include "Game/T6/CommonT6.h" @@ -72,7 +73,7 @@ namespace T6 REGISTER_ASSET_LOADER(AssetLoaderWeapon) REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachment) REGISTER_ASSET_LOADER(AssetLoaderWeaponAttachmentUnique) - REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON_CAMO, WeaponCamo)) + REGISTER_ASSET_LOADER(AssetLoaderWeaponCamo) REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SNDDRIVER_GLOBALS, SndDriverGlobals)) REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FX, FxEffectDef)) REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMPACT_FX, FxImpactTable)) diff --git a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp new file mode 100644 index 00000000..9c527f21 --- /dev/null +++ b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp @@ -0,0 +1,247 @@ +#include "JsonWeaponCamoLoader.h" + +#include "Game/T6/CommonT6.h" +#include "Game/T6/Json/JsonWeaponCamo.h" + +#include +#include +#include + +using namespace nlohmann; +using namespace T6; + +namespace +{ + class JsonLoader + { + public: + JsonLoader(std::istream& stream, MemoryManager& memory, IAssetLoadingManager& manager, std::vector& dependencies) + : m_stream(stream), + m_memory(memory), + m_manager(manager), + m_dependencies(dependencies) + + { + } + + bool Load(WeaponCamo& weaponCamo) const + { + const auto jRoot = json::parse(m_stream); + std::string type; + unsigned version; + + jRoot.at("_type").get_to(type); + jRoot.at("_version").get_to(version); + + if (type != "weaponCamo" || version != 1u) + { + std::cerr << "Tried to load weapon camo \"" << weaponCamo.name << "\" but did not find expected type weaponCamo of version 1\n"; + return false; + } + + const auto jWeaponCamo = jRoot.get(); + return CreateWeaponCamoFromJson(jWeaponCamo, weaponCamo); + } + + private: + static void PrintError(const WeaponCamo& weaponCamo, const std::string& message) + { + std::cerr << "Cannot load weapon camo \"" << weaponCamo.name << "\": " << message << "\n"; + } + + bool CreateWeaponCamoSetFromJson(const JsonWeaponCamoSet& jWeaponCamoSet, WeaponCamoSet& weaponCamoSet, const WeaponCamo& weaponCamo) const + { + if (jWeaponCamoSet.solidCamoImage) + { + auto* image = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_IMAGE, jWeaponCamoSet.solidCamoImage.value())); + if (!image) + { + PrintError(weaponCamo, "Could not find solidCamoImage"); + return false; + } + m_dependencies.push_back(image); + weaponCamoSet.solidCamoImage = image->Asset(); + } + + if (jWeaponCamoSet.patternCamoImage) + { + auto* image = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_IMAGE, jWeaponCamoSet.patternCamoImage.value())); + if (!image) + { + PrintError(weaponCamo, "Could not find patternCamoImage"); + return false; + } + m_dependencies.push_back(image); + weaponCamoSet.patternCamoImage = image->Asset(); + } + + weaponCamoSet.patternOffset.x = jWeaponCamoSet.patternOffset.x; + weaponCamoSet.patternOffset.y = jWeaponCamoSet.patternOffset.y; + weaponCamoSet.patternScale = jWeaponCamoSet.patternScale; + + return true; + } + + bool CreateWeaponCamoMaterialFromJson(const JsonWeaponCamoMaterial& jWeaponCamoMaterial, + WeaponCamoMaterial& weaponCamoMaterial, + const WeaponCamo& weaponCamo) const + { + weaponCamoMaterial.replaceFlags = static_cast(jWeaponCamoMaterial.replaceFlags); + + if (jWeaponCamoMaterial.baseMaterials.size() != jWeaponCamoMaterial.camoMaterials.size()) + { + PrintError(weaponCamo, "baseMaterials and camoMaterials arrays must have the same amount of entries"); + return false; + } + + weaponCamoMaterial.numBaseMaterials = static_cast(jWeaponCamoMaterial.baseMaterials.size()); + if (weaponCamoMaterial.numBaseMaterials > 0) + { + weaponCamoMaterial.baseMaterials = static_cast(m_memory.Alloc(sizeof(Material*) * weaponCamoMaterial.numBaseMaterials)); + weaponCamoMaterial.camoMaterials = static_cast(m_memory.Alloc(sizeof(Material*) * weaponCamoMaterial.numBaseMaterials)); + memset(weaponCamoMaterial.baseMaterials, 0, sizeof(Material*) * weaponCamoMaterial.numBaseMaterials); + memset(weaponCamoMaterial.camoMaterials, 0, sizeof(Material*) * weaponCamoMaterial.numBaseMaterials); + + for (auto i = 0u; i < weaponCamoMaterial.numBaseMaterials; i++) + { + auto* baseMaterial = + static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, jWeaponCamoMaterial.baseMaterials[i])); + auto* camoMaterial = + static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, jWeaponCamoMaterial.camoMaterials[i])); + + if (!baseMaterial) + { + PrintError(weaponCamo, "Could not find baseMaterial"); + return false; + } + + if (!camoMaterial) + { + PrintError(weaponCamo, "Could not find camoMaterial"); + return false; + } + + m_dependencies.push_back(baseMaterial); + m_dependencies.push_back(camoMaterial); + + weaponCamoMaterial.baseMaterials[i] = baseMaterial->Asset(); + weaponCamoMaterial.camoMaterials[i] = camoMaterial->Asset(); + } + } + else + { + weaponCamoMaterial.baseMaterials = nullptr; + weaponCamoMaterial.camoMaterials = nullptr; + } + + return true; + } + + bool CreateWeaponCamoMaterialSetFromJson(const JsonWeaponCamoMaterialSet& jWeaponCamoMaterialSet, + WeaponCamoMaterialSet& weaponCamoMaterialSet, + const WeaponCamo& weaponCamo) const + { + if (!jWeaponCamoMaterialSet.materials.empty()) + { + weaponCamoMaterialSet.numMaterials = jWeaponCamoMaterialSet.materials.size(); + weaponCamoMaterialSet.materials = + static_cast(m_memory.Alloc(sizeof(WeaponCamoMaterial) * weaponCamoMaterialSet.numMaterials)); + memset(weaponCamoMaterialSet.materials, 0, sizeof(WeaponCamoMaterial) * weaponCamoMaterialSet.numMaterials); + + for (auto i = 0u; i < weaponCamoMaterialSet.numMaterials; i++) + { + if (!CreateWeaponCamoMaterialFromJson(jWeaponCamoMaterialSet.materials[i], weaponCamoMaterialSet.materials[i], weaponCamo)) + return false; + } + } + else + { + weaponCamoMaterialSet.numMaterials = 0; + weaponCamoMaterialSet.materials = nullptr; + } + + return true; + } + + bool CreateWeaponCamoFromJson(const JsonWeaponCamo& jWeaponCamo, WeaponCamo& weaponCamo) const + { + if (jWeaponCamo.solidBaseImage) + { + auto* image = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_IMAGE, jWeaponCamo.solidBaseImage.value())); + if (!image) + { + PrintError(weaponCamo, "Could not find solidBaseImage"); + return false; + } + m_dependencies.push_back(image); + weaponCamo.solidBaseImage = image->Asset(); + } + + if (jWeaponCamo.patternBaseImage) + { + auto* image = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_IMAGE, jWeaponCamo.patternBaseImage.value())); + if (!image) + { + PrintError(weaponCamo, "Could not find patternBaseImage"); + return false; + } + m_dependencies.push_back(image); + weaponCamo.patternBaseImage = image->Asset(); + } + + if (!jWeaponCamo.camoSets.empty()) + { + weaponCamo.numCamoSets = jWeaponCamo.camoSets.size(); + weaponCamo.camoSets = static_cast(m_memory.Alloc(sizeof(WeaponCamoSet) * weaponCamo.numCamoSets)); + memset(weaponCamo.camoSets, 0, sizeof(WeaponCamoSet) * weaponCamo.numCamoSets); + + for (auto i = 0u; i < weaponCamo.numCamoSets; i++) + { + if (!CreateWeaponCamoSetFromJson(jWeaponCamo.camoSets[i], weaponCamo.camoSets[i], weaponCamo)) + return false; + } + } + else + { + weaponCamo.numCamoSets = 0; + weaponCamo.camoSets = nullptr; + } + + if (!jWeaponCamo.camoMaterials.empty()) + { + weaponCamo.numCamoMaterials = jWeaponCamo.camoMaterials.size(); + weaponCamo.camoMaterials = static_cast(m_memory.Alloc(sizeof(WeaponCamoMaterialSet) * weaponCamo.numCamoMaterials)); + memset(weaponCamo.camoMaterials, 0, sizeof(WeaponCamoMaterialSet) * weaponCamo.numCamoMaterials); + + for (auto i = 0u; i < weaponCamo.numCamoMaterials; i++) + { + if (!CreateWeaponCamoMaterialSetFromJson(jWeaponCamo.camoMaterials[i], weaponCamo.camoMaterials[i], weaponCamo)) + return false; + } + } + else + { + weaponCamo.numCamoMaterials = 0; + weaponCamo.camoMaterials = nullptr; + } + + return true; + } + + std::istream& m_stream; + MemoryManager& m_memory; + IAssetLoadingManager& m_manager; + std::vector& m_dependencies; + }; +} // namespace + +namespace T6 +{ + bool LoadWeaponCamoAsJson( + std::istream& stream, WeaponCamo& weaponCamo, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies) + { + const JsonLoader loader(stream, *memory, *manager, dependencies); + + return loader.Load(weaponCamo); + } +} // namespace T6 diff --git a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.h b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.h new file mode 100644 index 00000000..b0fc78bb --- /dev/null +++ b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.h @@ -0,0 +1,13 @@ +#pragma once + +#include "AssetLoading/IAssetLoadingManager.h" +#include "Game/T6/T6.h" +#include "Utils/MemoryManager.h" + +#include + +namespace T6 +{ + bool LoadWeaponCamoAsJson( + std::istream& stream, WeaponCamo& weaponCamo, MemoryManager* memory, IAssetLoadingManager* manager, std::vector& dependencies); +} // namespace T6 From 742b8d5bc64a916a8a100c7efaa514d6e04416c5 Mon Sep 17 00:00:00 2001 From: Jan Date: Sun, 24 Mar 2024 15:38:46 +0100 Subject: [PATCH 3/5] chore: restructure t6 weapon camo json --- src/Common/Game/T6/T6_Assets.h | 7 ++++++ src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h | 18 ++++++++++---- .../T6/WeaponCamo/JsonWeaponCamoLoader.cpp | 24 +++++++++---------- .../T6/WeaponCamo/JsonWeaponCamoWriter.cpp | 15 +++++------- 4 files changed, 38 insertions(+), 26 deletions(-) diff --git a/src/Common/Game/T6/T6_Assets.h b/src/Common/Game/T6/T6_Assets.h index 3cc64a64..11e55fc0 100644 --- a/src/Common/Game/T6/T6_Assets.h +++ b/src/Common/Game/T6/T6_Assets.h @@ -6666,6 +6666,13 @@ namespace T6 const char* flameCooldownSound; }; + enum WeaponCamoMaterialFlags + { + WCM_REPLACE_COLOR = 0x1, + WCM_REPLACE_NORMAL = 0x2, + WCM_REPLACE_SPECULAR = 0x4, + }; + struct WeaponCamoMaterial { uint16_t replaceFlags; diff --git a/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h b/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h index 6f473898..d8d89f53 100644 --- a/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h +++ b/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h @@ -23,16 +23,26 @@ namespace T6 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoSet, solidCamoImage, patternCamoImage, patternOffset, patternScale); + class JsonWeaponCamoMaterialOverride + { + public: + std::string baseMaterial; + std::string camoMaterial; + }; + + NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterialOverride, baseMaterial, camoMaterial); + class JsonWeaponCamoMaterial { public: - unsigned replaceFlags; - std::vector baseMaterials; - std::vector camoMaterials; + bool useColorMap; + bool useNormalMap; + bool useSpecularMap; + std::vector materialOverrides; std::array shaderConsts; }; - NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterial, replaceFlags, baseMaterials, camoMaterials, shaderConsts); + NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterial, useColorMap, useNormalMap, useSpecularMap, materialOverrides, shaderConsts); class JsonWeaponCamoMaterialSet { diff --git a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp index 9c527f21..f929540f 100644 --- a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp +++ b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp @@ -86,16 +86,15 @@ namespace WeaponCamoMaterial& weaponCamoMaterial, const WeaponCamo& weaponCamo) const { - weaponCamoMaterial.replaceFlags = static_cast(jWeaponCamoMaterial.replaceFlags); + if (jWeaponCamoMaterial.useColorMap) + weaponCamoMaterial.replaceFlags |= WCM_REPLACE_COLOR; + if (jWeaponCamoMaterial.useNormalMap) + weaponCamoMaterial.replaceFlags |= WCM_REPLACE_NORMAL; + if (jWeaponCamoMaterial.useSpecularMap) + weaponCamoMaterial.replaceFlags |= WCM_REPLACE_SPECULAR; - if (jWeaponCamoMaterial.baseMaterials.size() != jWeaponCamoMaterial.camoMaterials.size()) - { - PrintError(weaponCamo, "baseMaterials and camoMaterials arrays must have the same amount of entries"); - return false; - } - - weaponCamoMaterial.numBaseMaterials = static_cast(jWeaponCamoMaterial.baseMaterials.size()); - if (weaponCamoMaterial.numBaseMaterials > 0) + weaponCamoMaterial.numBaseMaterials = static_cast(jWeaponCamoMaterial.materialOverrides.size()); + if (!jWeaponCamoMaterial.materialOverrides.empty()) { weaponCamoMaterial.baseMaterials = static_cast(m_memory.Alloc(sizeof(Material*) * weaponCamoMaterial.numBaseMaterials)); weaponCamoMaterial.camoMaterials = static_cast(m_memory.Alloc(sizeof(Material*) * weaponCamoMaterial.numBaseMaterials)); @@ -104,10 +103,9 @@ namespace for (auto i = 0u; i < weaponCamoMaterial.numBaseMaterials; i++) { - auto* baseMaterial = - static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, jWeaponCamoMaterial.baseMaterials[i])); - auto* camoMaterial = - static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, jWeaponCamoMaterial.camoMaterials[i])); + const auto& materialOverride = jWeaponCamoMaterial.materialOverrides[i]; + auto* baseMaterial = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, materialOverride.baseMaterial)); + auto* camoMaterial = static_cast*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, materialOverride.camoMaterial)); if (!baseMaterial) { diff --git a/src/ObjWriting/Game/T6/WeaponCamo/JsonWeaponCamoWriter.cpp b/src/ObjWriting/Game/T6/WeaponCamo/JsonWeaponCamoWriter.cpp index fc43824d..ad40d536 100644 --- a/src/ObjWriting/Game/T6/WeaponCamo/JsonWeaponCamoWriter.cpp +++ b/src/ObjWriting/Game/T6/WeaponCamo/JsonWeaponCamoWriter.cpp @@ -55,20 +55,17 @@ namespace static void CreateJsonWeaponCamoMaterial(JsonWeaponCamoMaterial& jWeaponCamoMaterial, const WeaponCamoMaterial& weaponCamoMaterial) { - jWeaponCamoMaterial.replaceFlags = weaponCamoMaterial.replaceFlags; + jWeaponCamoMaterial.useColorMap = weaponCamoMaterial.replaceFlags & WCM_REPLACE_COLOR; + jWeaponCamoMaterial.useNormalMap = weaponCamoMaterial.replaceFlags & WCM_REPLACE_NORMAL; + jWeaponCamoMaterial.useSpecularMap = weaponCamoMaterial.replaceFlags & WCM_REPLACE_SPECULAR; - jWeaponCamoMaterial.baseMaterials.resize(weaponCamoMaterial.numBaseMaterials); + jWeaponCamoMaterial.materialOverrides.resize(weaponCamoMaterial.numBaseMaterials); for (auto i = 0u; i < weaponCamoMaterial.numBaseMaterials; i++) { if (weaponCamoMaterial.baseMaterials[i] && weaponCamoMaterial.baseMaterials[i]->info.name) - jWeaponCamoMaterial.baseMaterials[i] = AssetName(weaponCamoMaterial.baseMaterials[i]->info.name); - } - - jWeaponCamoMaterial.camoMaterials.resize(weaponCamoMaterial.numBaseMaterials); - for (auto i = 0u; i < weaponCamoMaterial.numBaseMaterials; i++) - { + jWeaponCamoMaterial.materialOverrides[i].baseMaterial = AssetName(weaponCamoMaterial.baseMaterials[i]->info.name); if (weaponCamoMaterial.camoMaterials[i] && weaponCamoMaterial.camoMaterials[i]->info.name) - jWeaponCamoMaterial.camoMaterials[i] = AssetName(weaponCamoMaterial.camoMaterials[i]->info.name); + jWeaponCamoMaterial.materialOverrides[i].camoMaterial = AssetName(weaponCamoMaterial.camoMaterials[i]->info.name); } for (auto i = 0u; i < std::extent_v; i++) From b1ff653dc86bcae86cd41ac378e690da9ac49826 Mon Sep 17 00:00:00 2001 From: Jan Date: Sun, 24 Mar 2024 16:35:10 +0100 Subject: [PATCH 4/5] style: fix formatting --- src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp index 160a8e2f..8175e3bc 100644 --- a/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp +++ b/src/ObjLoading/Game/T6/AssetLoaders/AssetLoaderWeaponCamo.cpp @@ -1,7 +1,7 @@ #include "AssetLoaderWeaponCamo.h" -#include "Game/T6/WeaponCamo/JsonWeaponCamoLoader.h" #include "Game/T6/T6.h" +#include "Game/T6/WeaponCamo/JsonWeaponCamoLoader.h" #include "Pool/GlobalAssetPool.h" #include From e62e4c873eeae6f6ae32050aa23a2e8b70b4045d Mon Sep 17 00:00:00 2001 From: Jan Date: Sun, 24 Mar 2024 16:57:47 +0100 Subject: [PATCH 5/5] fix: not loading t6 weapon camo shader consts from json --- src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h | 6 +++++- src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp | 3 +++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h b/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h index d8d89f53..eb9f72af 100644 --- a/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h +++ b/src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h @@ -32,6 +32,8 @@ namespace T6 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterialOverride, baseMaterial, camoMaterial); + constexpr auto SHADER_CONST_COUNT = 8; + class JsonWeaponCamoMaterial { public: @@ -39,9 +41,11 @@ namespace T6 bool useNormalMap; bool useSpecularMap; std::vector materialOverrides; - std::array shaderConsts; + std::array shaderConsts; }; + static_assert(SHADER_CONST_COUNT == std::extent_v); + NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterial, useColorMap, useNormalMap, useSpecularMap, materialOverrides, shaderConsts); class JsonWeaponCamoMaterialSet diff --git a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp index f929540f..a455fc54 100644 --- a/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp +++ b/src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp @@ -132,6 +132,9 @@ namespace weaponCamoMaterial.camoMaterials = nullptr; } + for (auto i = 0u; i < std::extent_v; i++) + weaponCamoMaterial.shaderConsts[i] = jWeaponCamoMaterial.shaderConsts[i]; + return true; }