feat: compile t6 techsets

src/ObjCompiling/Techset/LiteralConstsZoneState.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#include "Asset/IZoneAssetCreationState.h"
+
+#include <array>
+#include <concepts>
+#include <unordered_map>
+
+namespace techset
+{
+    template<std::floating_point T> class LiteralConst
+    {
+    public:
+        using game_ptr_t = const T (*)[4];
+
+        LiteralConst() = default;
+
+        LiteralConst(T v0, T v1, T v2, T v3)
+            : m_value({v0, v1, v2, v3})
+        {
+        }
+
+        explicit LiteralConst(std::array<T, 4> value)
+            : m_value(value)
+        {
+        }
+
+        friend bool operator<(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            if (lhs.m_value[0] < rhs.m_value[0])
+                return true;
+            if (lhs.m_value[0] > rhs.m_value[0])
+                return false;
+            if (lhs.m_value[1] < rhs.m_value[1])
+                return true;
+            if (lhs.m_value[1] > rhs.m_value[1])
+                return false;
+            if (lhs.m_value[2] < rhs.m_value[2])
+                return true;
+            if (lhs.m_value[2] > rhs.m_value[2])
+                return false;
+            if (lhs.m_value[3] < rhs.m_value[3])
+                return true;
+            if (lhs.m_value[3] > rhs.m_value[3])
+                return false;
+            return false;
+        }
+
+        friend bool operator==(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            return lhs.m_value == rhs.m_value;
+        }
+
+        friend bool operator!=(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        friend bool operator<=(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            return !(rhs < lhs);
+        }
+
+        friend bool operator>(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            return rhs < lhs;
+        }
+
+        friend bool operator>=(const LiteralConst& lhs, const LiteralConst& rhs)
+        {
+            return !(lhs < rhs);
+        }
+
+        game_ptr_t GamePtr() const
+        {
+            return reinterpret_cast<game_ptr_t>(m_value.data());
+        }
+
+        std::array<T, 4> m_value;
+    };
+
+    template<std::floating_point T> struct LiteralConstHash
+    {
+        std::size_t operator()(const LiteralConst<T>& v) const noexcept
+        {
+            std::size_t seed = 0x1DDB76B3;
+            seed ^= (seed << 6) + (seed >> 2) + 0x0354144B + std::hash<T>()(v.m_value[0]);
+            seed ^= (seed << 6) + (seed >> 2) + 0x66847B5C + std::hash<T>()(v.m_value[1]);
+            seed ^= (seed << 6) + (seed >> 2) + 0x77399D60 + std::hash<T>()(v.m_value[2]);
+            seed ^= (seed << 6) + (seed >> 2) + 0x477AF9AB + std::hash<T>()(v.m_value[3]);
+            return seed;
+        }
+    };
+
+    template<std::floating_point T> class LiteralConstsZoneState : public IZoneAssetCreationState
+    {
+    public:
+        using literal_t = LiteralConst<T>;
+
+        LiteralConstsZoneState()
+            : m_memory(nullptr)
+        {
+        }
+
+        void Inject(ZoneAssetCreationInjection& inject) override
+        {
+            m_memory = &inject.m_zone.Memory();
+        }
+
+        literal_t* GetAllocatedLiteral(const literal_t& literal)
+        {
+            const auto& existingEntry = m_allocated_literals.find(literal);
+
+            if (existingEntry != m_allocated_literals.end())
+                return existingEntry->second;
+
+            auto* newLiteral = m_memory->Alloc<literal_t>();
+            newLiteral->m_value[0] = literal.m_value[0];
+            newLiteral->m_value[1] = literal.m_value[1];
+            newLiteral->m_value[2] = literal.m_value[2];
+            newLiteral->m_value[3] = literal.m_value[3];
+            m_allocated_literals.emplace(literal, newLiteral);
+
+            return newLiteral;
+        }
+
+    private:
+        std::unordered_map<literal_t, literal_t*, LiteralConstHash<T>> m_allocated_literals;
+        MemoryManager* m_memory;
+    };
+} // namespace techset