feat: dump techsets for t6

src/ObjWriting/Game/IW4/Material/MaterialDecompilingDumperIW4.cpp

@@ -2,8 +2,7 @@
 
 #include "Game/IW4/MaterialConstantsIW4.h"
 #include "Game/IW4/ObjConstantsIW4.h"
-#include "Game/IW4/TechsetConstantsIW4.h"
-#include "Utils/ClassUtils.h"
+#include "Game/IW4/Techset/TechsetConstantsIW4.h"
 #include "Utils/Logging/Log.h"
 
 #pragma warning(push, 0)

src/ObjWriting/Game/IW4/Techset/TechsetDumperIW4.cpp

@@ -1,9 +1,12 @@
 #include "TechsetDumperIW4.h"
 
 #include "Dumping/AbstractTextDumper.h"
-#include "Game/IW4/TechsetConstantsIW4.h"
+#include "Game/IW4/Techset/TechsetConstantsIW4.h"
 #include "Pool/GlobalAssetPool.h"
 #include "Shader/D3D9ShaderAnalyser.h"
+#include "Techset/CommonTechset.h"
+#include "Techset/CommonTechsetDumper.h"
+#include "Techset/TechniqueDumpingZoneState.h"
 #include "Techset/TechsetCommon.h"
 #include "Utils/Logging/Log.h"
 
@@ -16,23 +19,8 @@
 
 using namespace IW4;
 
-namespace IW4
+namespace
 {
-    class TechniqueDumpingZoneState final : public IZoneAssetDumperState
-    {
-        std::set<const MaterialTechnique*> m_dumped_techniques;
-
-    public:
-        bool ShouldDumpTechnique(const MaterialTechnique* technique)
-        {
-            if (m_dumped_techniques.find(technique) != m_dumped_techniques.end())
-                return false;
-
-            m_dumped_techniques.emplace(technique);
-            return true;
-        }
-    };
-
     class TechniqueFileWriter : public AbstractTextDumper
     {
         void DumpStateMap() const
@@ -472,67 +460,31 @@ namespace IW4
         }
     };
 
-    class TechsetFileWriter : public AbstractTextDumper
+    techset::CommonTechset ConvertToCommonTechset(const MaterialTechniqueSet& techset)
     {
-        bool m_last_write_was_value;
+        std::vector<std::string> techniqueNames(std::extent_v<decltype(techniqueTypeNames)>);
 
-    public:
-        explicit TechsetFileWriter(std::ostream& stream)
-            : AbstractTextDumper(stream),
-              m_last_write_was_value(false)
+        for (auto techniqueIndex = 0u; techniqueIndex < std::extent_v<decltype(techniqueTypeNames)>; techniqueIndex++)
         {
+            const auto* technique = techset.techniques[techniqueIndex];
+            if (technique && technique->name)
+                techniqueNames[techniqueIndex] = technique->name;
         }
 
-        void WriteTechniqueType(const size_t techniqueIndex)
-        {
-            assert(techniqueIndex < std::extent_v<decltype(techniqueTypeNames)>);
+        return techset::CommonTechset{
+            .m_name = techset.name,
+            .m_technique_names = std::move(techniqueNames),
+        };
+    }
 
-            if (m_last_write_was_value)
-            {
-                m_stream << "\n";
-                m_last_write_was_value = false;
-            }
-            m_stream << '"' << techniqueTypeNames[techniqueIndex] << "\":\n";
-        }
+    void DumpTechset(const AssetDumpingContext& context, const MaterialTechniqueSet& techset)
+    {
+        static techset::CommonTechniqueTypeNames commonNames(techniqueTypeNames, std::extent_v<decltype(techniqueTypeNames)>);
+        const auto commonTechset = ConvertToCommonTechset(techset);
 
-        void WriteTechniqueValue(const char* value)
-        {
-            m_last_write_was_value = true;
-
-            IncIndent();
-            Indent();
-            m_stream << value << ";\n";
-            DecIndent();
-        }
-
-        void DumpTechset(const MaterialTechniqueSet* techset)
-        {
-            std::vector<bool> dumpedTechniques(std::extent_v<decltype(MaterialTechniqueSet::techniques)>);
-
-            for (auto techniqueIndex = 0u; techniqueIndex < std::extent_v<decltype(MaterialTechniqueSet::techniques)>; techniqueIndex++)
-            {
-                const auto* technique = techset->techniques[techniqueIndex];
-                if (technique == nullptr || dumpedTechniques[techniqueIndex])
-                    continue;
-
-                dumpedTechniques[techniqueIndex] = true;
-                WriteTechniqueType(techniqueIndex);
-
-                for (auto nextTechniqueIndex = techniqueIndex + 1; nextTechniqueIndex < std::extent_v<decltype(MaterialTechniqueSet::techniques)>;
-                     nextTechniqueIndex++)
-                {
-                    if (techset->techniques[nextTechniqueIndex] != technique)
-                        continue;
-
-                    dumpedTechniques[nextTechniqueIndex] = true;
-                    WriteTechniqueType(nextTechniqueIndex);
-                }
-
-                WriteTechniqueValue(technique->name);
-            }
-        }
-    };
-} // namespace IW4
+        techset::DumpCommonTechset(commonNames, context, commonTechset);
+    }
+} // namespace
 
 namespace techset
 {
@@ -543,18 +495,11 @@ namespace techset
 
     void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetTechniqueSet::Type>& asset)
     {
-        const auto* techset = asset.Asset();
-
-        const auto techsetFile = context.OpenAssetFile(GetFileNameForTechsetName(techset->name));
-
-        if (techsetFile)
-        {
-            TechsetFileWriter writer(*techsetFile);
-            writer.DumpTechset(techset);
-        }
+        const auto* techniqueSet = asset.Asset();
+        DumpTechset(context, *techniqueSet);
 
         auto* techniqueState = context.GetZoneAssetDumperState<TechniqueDumpingZoneState>();
-        for (const auto* technique : techset->techniques)
+        for (const auto* technique : techniqueSet->techniques)
         {
             if (technique && techniqueState->ShouldDumpTechnique(technique))
             {

src/ObjWriting/Game/T6/Techset/TechsetDumperT6.cpp

@@ -1,6 +1,10 @@
 #include "TechsetDumperT6.h"
 
+#include "Game/T6/Techset/TechsetConstantsT6.h"
 #include "Shader/ShaderCommon.h"
+#include "Techset/CommonTechniqueDumper.h"
+#include "Techset/CommonTechsetDumper.h"
+#include "Techset/TechniqueDumpingZoneState.h"
 
 #include <sstream>
 #include <unordered_set>
@@ -73,21 +77,12 @@ namespace
 
         shaderFile->write(vertexShader.prog.loadDef.program, vertexShader.prog.loadDef.programSize);
     }
-} // namespace
 
-namespace techset
-{
-    DumperT6::DumperT6(const AssetPool<AssetTechniqueSet::Type>& pool)
-        : AbstractAssetDumper(pool)
+    void DumpShaders(AssetDumpingContext& context, const MaterialTechniqueSet& techset)
     {
-    }
-
-    void DumperT6::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetTechniqueSet::Type>& asset)
-    {
-        const auto* techniqueSet = asset.Asset();
         auto* shaderState = context.GetZoneAssetDumperState<ShaderZoneState>();
 
-        for (const auto* technique : techniqueSet->techniques)
+        for (const auto* technique : techset.techniques)
         {
             if (!technique || !shaderState->ShouldDumpTechnique(technique))
                 continue;
@@ -104,4 +99,76 @@ namespace techset
             }
         }
     }
+
+    techset::CommonTechnique ConvertToCommonTechnique(const MaterialTechnique& technique)
+    {
+        std::vector<std::string> techniqueNames(std::extent_v<decltype(techniqueTypeNames)>);
+
+        for (auto techniqueIndex = 0u; techniqueIndex < std::extent_v<decltype(techniqueTypeNames)>; techniqueIndex++)
+        {
+            const auto* technique = techset.techniques[techniqueIndex];
+            if (technique && technique->name)
+                techniqueNames[techniqueIndex] = technique->name;
+        }
+
+        return techset::CommonTechset{
+            .m_name = techset.name,
+            .m_technique_names = std::move(techniqueNames),
+        };
+    }
+
+    void DumpTechniques(AssetDumpingContext& context, const MaterialTechniqueSet& techset)
+    {
+        auto* techniqueState = context.GetZoneAssetDumperState<techset::TechniqueDumpingZoneState>();
+        for (const auto* technique : techset.techniques)
+        {
+            if (technique && techniqueState->ShouldDumpTechnique(technique))
+            {
+                const auto commonTechnique = ConvertToCommonTechnique(*technique);
+
+                techset::DumpCommonTechnique(context, commonTechnique);
+            }
+        }
+    }
+
+    techset::CommonTechset ConvertToCommonTechset(const MaterialTechniqueSet& techset)
+    {
+        std::vector<std::string> techniqueNames(std::extent_v<decltype(techniqueTypeNames)>);
+
+        for (auto techniqueIndex = 0u; techniqueIndex < std::extent_v<decltype(techniqueTypeNames)>; techniqueIndex++)
+        {
+            const auto* technique = techset.techniques[techniqueIndex];
+            if (technique && technique->name)
+                techniqueNames[techniqueIndex] = technique->name;
+        }
+
+        return techset::CommonTechset{
+            .m_name = techset.name,
+            .m_technique_names = std::move(techniqueNames),
+        };
+    }
+
+    void DumpTechset(const AssetDumpingContext& context, const MaterialTechniqueSet& techset)
+    {
+        static techset::CommonTechniqueTypeNames commonNames(techniqueTypeNames, std::extent_v<decltype(techniqueTypeNames)>);
+        const auto commonTechset = ConvertToCommonTechset(techset);
+
+        techset::DumpCommonTechset(commonNames, context, commonTechset);
+    }
+} // namespace
+
+namespace techset
+{
+    DumperT6::DumperT6(const AssetPool<AssetTechniqueSet::Type>& pool)
+        : AbstractAssetDumper(pool)
+    {
+    }
+
+    void DumperT6::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetTechniqueSet::Type>& asset)
+    {
+        const auto* techniqueSet = asset.Asset();
+        DumpTechset(context, *techniqueSet);
+        DumpTechniques(context, *techniqueSet);
+        DumpShaders(context, *techniqueSet);
+    }
 } // namespace techset

src/ObjWriting/Techset/CommonTechniqueDumper.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "Dumping/AssetDumpingContext.h"
+#include "Techset/CommonTechset.h"
+
+namespace techset
+{
+    void DumpCommonTechnique(const AssetDumpingContext& context, const CommonTechset& techset);
+} // namespace techset

src/ObjWriting/Techset/CommonTechsetDumper.cpp

@@ -0,0 +1,92 @@
+#include "CommonTechsetDumper.h"
+
+#include "Dumping/AbstractTextDumper.h"
+#include "Game/IW3/Material/MaterialConstantZoneStateIW3.h"
+#include "Techset/TechsetCommon.h"
+
+#include <cassert>
+
+using namespace techset;
+
+namespace
+{
+    class TechsetFileWriter : public AbstractTextDumper
+    {
+    public:
+        TechsetFileWriter(const CommonTechniqueTypeNames& techniqueTypeNames, std::ostream& stream)
+            : AbstractTextDumper(stream),
+              m_last_write_was_value(false),
+              m_technique_type_names(techniqueTypeNames)
+        {
+        }
+
+        void DumpTechset(const CommonTechset& techset)
+        {
+            const auto techniqueCount = m_technique_type_names.GetTechniqueTypeCount();
+            assert(techset.m_technique_names.size() == techniqueCount);
+
+            std::vector<bool> dumpedTechniques(techniqueCount);
+
+            for (auto techniqueIndex = 0u; techniqueIndex < techniqueCount; techniqueIndex++)
+            {
+                const auto& technique = techset.m_technique_names[techniqueIndex];
+                if (technique.empty() || dumpedTechniques[techniqueIndex])
+                    continue;
+
+                dumpedTechniques[techniqueIndex] = true;
+                WriteTechniqueType(techniqueIndex);
+
+                for (auto nextTechniqueIndex = techniqueIndex + 1; nextTechniqueIndex < std::extent_v<decltype(IW3::MaterialTechniqueSet::techniques)>;
+                     nextTechniqueIndex++)
+                {
+                    if (techset.m_technique_names[nextTechniqueIndex] != technique)
+                        continue;
+
+                    dumpedTechniques[nextTechniqueIndex] = true;
+                    WriteTechniqueType(nextTechniqueIndex);
+                }
+
+                WriteTechniqueValue(technique);
+            }
+        }
+
+    private:
+        void WriteTechniqueType(const size_t techniqueIndex)
+        {
+            if (m_last_write_was_value)
+            {
+                m_stream << "\n";
+                m_last_write_was_value = false;
+            }
+
+            m_stream << '"' << m_technique_type_names.GetTechniqueTypeName(techniqueIndex) << "\":\n";
+        }
+
+        void WriteTechniqueValue(const std::string& value)
+        {
+            m_last_write_was_value = true;
+
+            IncIndent();
+            Indent();
+            m_stream << value << ";\n";
+            DecIndent();
+        }
+
+        bool m_last_write_was_value;
+        const CommonTechniqueTypeNames& m_technique_type_names;
+    };
+} // namespace
+
+namespace techset
+{
+    void DumpCommonTechset(const CommonTechniqueTypeNames& techniqueTypeNames, const AssetDumpingContext& context, const CommonTechset& techset)
+    {
+        const auto techsetFile = context.OpenAssetFile(GetFileNameForTechsetName(techset.m_name));
+
+        if (techsetFile)
+        {
+            TechsetFileWriter writer(techniqueTypeNames, *techsetFile);
+            writer.DumpTechset(techset);
+        }
+    }
+} // namespace techset

src/ObjWriting/Techset/CommonTechsetDumper.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "Dumping/AssetDumpingContext.h"
+#include "Techset/CommonTechset.h"
+
+namespace techset
+{
+    void DumpCommonTechset(const CommonTechniqueTypeNames& techniqueTypeNames, const AssetDumpingContext& context, const CommonTechset& techset);
+} // namespace techset

src/ObjWriting/Techset/TechniqueDumpingZoneState.cpp

@@ -0,0 +1,13 @@
+#include "TechniqueDumpingZoneState.h"
+
+namespace techset
+{
+    bool TechniqueDumpingZoneState::ShouldDumpTechnique(const void* technique)
+    {
+        if (m_dumped_techniques.find(technique) != m_dumped_techniques.end())
+            return false;
+
+        m_dumped_techniques.emplace(technique);
+        return true;
+    }
+} // namespace techset

src/ObjWriting/Techset/TechniqueDumpingZoneState.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Dumping/IZoneAssetDumperState.h"
+
+#include <unordered_set>
+
+namespace techset
+{
+    class TechniqueDumpingZoneState final : public IZoneAssetDumperState
+    {
+    public:
+        bool ShouldDumpTechnique(const void* technique);
+
+    private:
+        std::unordered_set<const void*> m_dumped_techniques;
+    };
+} // namespace techset