feat: dump techsets for t6

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