Merge pull request #143 from Laupetin/feature/t6-weapon-camo-loading

feat: loading t6 weapon camo

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;

src/ObjCommon/Game/T6/Json/JsonWeaponCamo.h

@@ -23,16 +23,30 @@ 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);
+
+    constexpr auto SHADER_CONST_COUNT = 8;
+
     class JsonWeaponCamoMaterial
     {
     public:
-        unsigned replaceFlags;
+        bool useColorMap;
-        std::vector<std::string> baseMaterials;
+        bool useNormalMap;
-        std::vector<std::string> camoMaterials;
+        bool useSpecularMap;
-        std::array<float, 8> shaderConsts;
+        std::vector<JsonWeaponCamoMaterialOverride> materialOverrides;
+        std::array<float, SHADER_CONST_COUNT> shaderConsts;
     };
 
-    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterial, replaceFlags, baseMaterials, camoMaterials, shaderConsts);
+    static_assert(SHADER_CONST_COUNT == std::extent_v<decltype(WeaponCamoMaterial::shaderConsts)>);
+
+    NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(JsonWeaponCamoMaterial, useColorMap, useNormalMap, useSpecularMap, materialOverrides, shaderConsts);
 
     class JsonWeaponCamoMaterialSet
     {

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

@@ -0,0 +1,46 @@
+#include "AssetLoaderWeaponCamo.h"
+
+#include "Game/T6/T6.h"
+#include "Game/T6/WeaponCamo/JsonWeaponCamoLoader.h"
+#include "Pool/GlobalAssetPool.h"
+
+#include <cstring>
+#include <format>
+#include <iostream>
+
+using namespace T6;
+
+void* AssetLoaderWeaponCamo::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* weaponCamo = memory->Create<WeaponCamo>();
+    memset(weaponCamo, 0, sizeof(WeaponCamo));
+    weaponCamo->name = memory->Dup(assetName.c_str());
+
+    return weaponCamo;
+}
+
+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<WeaponCamo*>(memory->Alloc(sizeof(WeaponCamo)));
+    memset(weaponCamo, 0, sizeof(WeaponCamo));
+    weaponCamo->name = memory->Dup(assetName.c_str());
+
+    std::vector<XAssetInfoGeneric*> 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;
+}

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<ASSET_TYPE_WEAPON_CAMO, WeaponCamo>
+    {
+    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

src/ObjLoading/Game/T6/Material/JsonMaterialLoader.cpp

@@ -4,13 +4,13 @@
 #include "Game/T6/Json/JsonMaterial.h"
 
 #include <format>
-#include <iomanip>
 #include <iostream>
 #include <nlohmann/json.hpp>
 
 using namespace nlohmann;
+using namespace T6;
 
-namespace T6
+namespace
 {
     class JsonLoader
     {
@@ -362,7 +362,10 @@ namespace T6
         IAssetLoadingManager& m_manager;
         std::vector<XAssetInfoGeneric*>& m_dependencies;
     };
+} // namespace
 
+namespace T6
+{
     bool LoadMaterialAsJson(
         std::istream& stream, Material& material, MemoryManager* memory, IAssetLoadingManager* manager, std::vector<XAssetInfoGeneric*>& dependencies)
     {

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))

src/ObjLoading/Game/T6/WeaponCamo/JsonWeaponCamoLoader.cpp

@@ -0,0 +1,248 @@
+#include "JsonWeaponCamoLoader.h"
+
+#include "Game/T6/CommonT6.h"
+#include "Game/T6/Json/JsonWeaponCamo.h"
+
+#include <format>
+#include <iostream>
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
+using namespace T6;
+
+namespace
+{
+    class JsonLoader
+    {
+    public:
+        JsonLoader(std::istream& stream, MemoryManager& memory, IAssetLoadingManager& manager, std::vector<XAssetInfoGeneric*>& 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<JsonWeaponCamo>();
+            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<XAssetInfo<GfxImage>*>(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<XAssetInfo<GfxImage>*>(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
+        {
+            if (jWeaponCamoMaterial.useColorMap)
+                weaponCamoMaterial.replaceFlags |= WCM_REPLACE_COLOR;
+            if (jWeaponCamoMaterial.useNormalMap)
+                weaponCamoMaterial.replaceFlags |= WCM_REPLACE_NORMAL;
+            if (jWeaponCamoMaterial.useSpecularMap)
+                weaponCamoMaterial.replaceFlags |= WCM_REPLACE_SPECULAR;
+
+            weaponCamoMaterial.numBaseMaterials = static_cast<uint16_t>(jWeaponCamoMaterial.materialOverrides.size());
+            if (!jWeaponCamoMaterial.materialOverrides.empty())
+            {
+                weaponCamoMaterial.baseMaterials = static_cast<Material**>(m_memory.Alloc(sizeof(Material*) * weaponCamoMaterial.numBaseMaterials));
+                weaponCamoMaterial.camoMaterials = static_cast<Material**>(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++)
+                {
+                    const auto& materialOverride = jWeaponCamoMaterial.materialOverrides[i];
+                    auto* baseMaterial = static_cast<XAssetInfo<Material>*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, materialOverride.baseMaterial));
+                    auto* camoMaterial = static_cast<XAssetInfo<Material>*>(m_manager.LoadDependency(ASSET_TYPE_MATERIAL, materialOverride.camoMaterial));
+
+                    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;
+            }
+
+            for (auto i = 0u; i < std::extent_v<decltype(WeaponCamoMaterial::shaderConsts)>; i++)
+                weaponCamoMaterial.shaderConsts[i] = jWeaponCamoMaterial.shaderConsts[i];
+
+            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<WeaponCamoMaterial*>(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<XAssetInfo<GfxImage>*>(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<XAssetInfo<GfxImage>*>(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<WeaponCamoSet*>(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<WeaponCamoMaterialSet*>(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<XAssetInfoGeneric*>& m_dependencies;
+    };
+} // namespace
+
+namespace T6
+{
+    bool LoadWeaponCamoAsJson(
+        std::istream& stream, WeaponCamo& weaponCamo, MemoryManager* memory, IAssetLoadingManager* manager, std::vector<XAssetInfoGeneric*>& dependencies)
+    {
+        const JsonLoader loader(stream, *memory, *manager, dependencies);
+
+        return loader.Load(weaponCamo);
+    }
+} // namespace T6

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 <istream>
+
+namespace T6
+{
+    bool LoadWeaponCamoAsJson(
+        std::istream& stream, WeaponCamo& weaponCamo, MemoryManager* memory, IAssetLoadingManager* manager, std::vector<XAssetInfoGeneric*>& dependencies);
+} // namespace T6

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.materialOverrides[i].baseMaterial = AssetName(weaponCamoMaterial.baseMaterials[i]->info.name);
-            }
-
-            jWeaponCamoMaterial.camoMaterials.resize(weaponCamoMaterial.numBaseMaterials);
-            for (auto i = 0u; i < weaponCamoMaterial.numBaseMaterials; i++)
-            {
                 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<decltype(WeaponCamoMaterial::shaderConsts)>; i++)