chore: refactor IW4 asset loaders

src/ObjLoading/Game/IW4/Techset/LoaderTechsetIW4.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW4/IW4.h"
+#include "SearchPath/ISearchPath.h"
+#include "StateMap/StateMapDefinition.h"
+#include "Techset/TechsetDefinition.h"
+#include "Utils/MemoryManager.h"
+
+#include <memory>
+#include <string>
+
+namespace IW4
+{
+    [[nodiscard]] std::string GetTechsetFileName(const std::string& techsetAssetName);
+    [[nodiscard]] std::string GetTechniqueFileName(const std::string& techniqueName);
+    [[nodiscard]] std::string GetStateMapFileName(const std::string& stateMapName);
+
+    class ITechsetCreator : public AssetCreator<AssetTechniqueSet>
+    {
+    public:
+        ITechsetCreator() = default;
+        virtual ~ITechsetCreator() = default;
+
+        virtual techset::TechsetDefinition* LoadTechsetDefinition(const std::string& assetName, AssetCreationContext& context, bool& failure) = 0;
+        virtual const state_map::StateMapDefinition* LoadStateMapDefinition(const std::string& stateMapName, AssetCreationContext& context) = 0;
+    };
+
+    std::unique_ptr<ITechsetCreator> CreateTechsetLoader(MemoryManager& memory, ISearchPath& searchPath);
+} // namespace IW4

src/ObjLoading/Game/IW4/Techset/LoaderVertexDeclIW4.cpp

@@ -0,0 +1,101 @@
+#include "LoaderVertexDeclIW4.h"
+
+#include "Game/IW4/IW4.h"
+#include "Game/IW4/TechsetConstantsIW4.h"
+
+#include <cstring>
+#include <format>
+#include <iostream>
+
+using namespace IW4;
+
+namespace
+{
+    class LoaderVertexDecl final : public AssetCreator<AssetVertexDecl>
+    {
+    public:
+        LoaderVertexDecl(MemoryManager& memory)
+            : m_memory(memory)
+        {
+        }
+
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
+        {
+            auto* decl = m_memory.Alloc<MaterialVertexDeclaration>();
+            decl->name = m_memory.Dup(assetName.c_str());
+
+            size_t currentOffset = 0u;
+
+            std::string sourceAbbreviation;
+            while (NextAbbreviation(assetName, sourceAbbreviation, currentOffset))
+            {
+                if (decl->streamCount >= std::extent_v<decltype(MaterialVertexStreamRouting::data)>)
+                {
+                    std::cerr << std::format("Failed to add vertex decl stream. Too many abbreviations: {}\n", assetName);
+                    return AssetCreationResult::Failure();
+                }
+
+                std::string destinationAbbreviation;
+                if (!NextAbbreviation(assetName, destinationAbbreviation, currentOffset))
+                {
+                    std::cerr << std::format("Failed to detect vertex decl destination abbreviation: {}\n", assetName);
+                    return AssetCreationResult::Failure();
+                }
+
+                const auto foundSourceAbbreviation = std::ranges::find(materialStreamSourceAbbreviation, sourceAbbreviation);
+                if (foundSourceAbbreviation == std::end(materialStreamSourceAbbreviation))
+                {
+                    std::cerr << std::format("Unknown vertex decl source abbreviation: {}\n", sourceAbbreviation);
+                    return AssetCreationResult::Failure();
+                }
+
+                const auto foundDestinationAbbreviation = std::ranges::find(materialStreamDestinationAbbreviation, destinationAbbreviation);
+                if (foundDestinationAbbreviation == std::end(materialStreamDestinationAbbreviation))
+                {
+                    std::cerr << std::format("Unknown vertex decl destination abbreviation: {}\n", destinationAbbreviation);
+                    return AssetCreationResult::Failure();
+                }
+
+                const auto sourceIndex = static_cast<MaterialStreamStreamSource_e>(foundSourceAbbreviation - std::begin(materialStreamSourceAbbreviation));
+                const auto destinationIndex =
+                    static_cast<MaterialStreamDestination_e>(foundDestinationAbbreviation - std::begin(materialStreamDestinationAbbreviation));
+
+                decl->routing.data[decl->streamCount].source = sourceIndex;
+                decl->routing.data[decl->streamCount].dest = destinationIndex;
+                decl->hasOptionalSource = decl->hasOptionalSource || sourceIndex >= STREAM_SRC_OPTIONAL_BEGIN;
+                decl->streamCount++;
+            }
+
+            return AssetCreationResult::Success(context.AddAsset<AssetVertexDecl>(assetName, decl));
+        }
+
+        static bool NextAbbreviation(const std::string& assetName, std::string& abbreviation, size_t& offset)
+        {
+            if (offset >= assetName.size())
+                return false;
+
+            if (offset + 1 < assetName.size() && isdigit(assetName[offset + 1]))
+            {
+                abbreviation = std::string(assetName, offset, 2);
+                offset += 2;
+            }
+            else
+            {
+                abbreviation = std::string(assetName, offset, 1);
+                offset += 1;
+            }
+
+            return true;
+        }
+
+        MemoryManager& m_memory;
+    };
+} // namespace
+
+namespace IW4
+{
+    std::unique_ptr<AssetCreator<AssetVertexDecl>> CreateVertexDeclLoader(MemoryManager& memory)
+    {
+        return std::make_unique<LoaderVertexDecl>(memory);
+    }
+} // namespace IW4

src/ObjLoading/Game/IW4/Techset/LoaderVertexDeclIW4.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW4/IW4.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <memory>
+
+namespace IW4
+{
+    std::unique_ptr<AssetCreator<AssetVertexDecl>> CreateVertexDeclLoader(MemoryManager& memory);
+} // namespace IW4