Merge pull request #91 from Laupetin/iw3-stringtable

feat: add StringTable loading for IW3

src/ObjCommon/Csv/CsvStream.cpp

@@ -14,6 +14,27 @@ bool CsvInputStream::NextRow(std::vector<std::string>& out) const
     if (!out.empty())
         out.clear();
 
+    return EmitNextRow(
+        [&out](std::string value)
+        {
+            out.emplace_back(std::move(value));
+        });
+}
+
+bool CsvInputStream::NextRow(std::vector<const char*>& out, MemoryManager& memory) const
+{
+    if (!out.empty())
+        out.clear();
+
+    return EmitNextRow(
+        [&out, &memory](const std::string& value)
+        {
+            out.emplace_back(memory.Dup(value.c_str()));
+        });
+}
+
+bool CsvInputStream::EmitNextRow(const std::function<void(std::string)>& cb) const
+{
     auto c = m_stream.get();
     const auto isEof = c == EOF;
     std::ostringstream col;
@@ -21,7 +42,7 @@ bool CsvInputStream::NextRow(std::vector<std::string>& out) const
     {
         if (c == CSV_SEPARATOR)
         {
-            out.emplace_back(col.str());
+            cb(col.str());
             col.clear();
             col.str(std::string());
         }
@@ -46,7 +67,7 @@ bool CsvInputStream::NextRow(std::vector<std::string>& out) const
 
     if (!isEof)
     {
-        out.emplace_back(col.str());
+        cb(col.str());
     }
 
     return !isEof;

src/ObjCommon/Csv/CsvStream.h

@@ -1,28 +1,36 @@
 #pragma once
+#include "Utils/MemoryManager.h"
+
+#include <functional>
 #include <iostream>
 #include <string>
 #include <vector>
 
 class CsvInputStream
 {
-    std::istream& m_stream;
-
 public:
     explicit CsvInputStream(std::istream& stream);
 
     bool NextRow(std::vector<std::string>& out) const;
+    bool NextRow(std::vector<const char*>& out, MemoryManager& memory) const;
+
+private:
+    bool EmitNextRow(const std::function<void(std::string)>& cb) const;
+
+    std::istream& m_stream;
 };
 
 class CsvOutputStream
 {
-    std::ostream& m_stream;
-    unsigned m_column_count;
-    unsigned m_current_column;
-    bool m_first_row;
-
 public:
     explicit CsvOutputStream(std::ostream& stream);
 
     void WriteColumn(const std::string& value);
     void NextRow();
+
+private:
+    std::ostream& m_stream;
+    unsigned m_column_count;
+    unsigned m_current_column;
+    bool m_first_row;
 };

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderStringTable.cpp

@@ -0,0 +1,39 @@
+#include "AssetLoaderStringTable.h"
+
+#include "Csv/CsvStream.h"
+#include "Game/IW3/CommonIW3.h"
+#include "ObjLoading.h"
+#include "Pool/GlobalAssetPool.h"
+#include "StringTable/StringTableLoader.h"
+
+#include <cstring>
+
+using namespace IW3;
+
+void* AssetLoaderStringTable::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* stringTable = memory->Create<StringTable>();
+    memset(stringTable, 0, sizeof(StringTable));
+    stringTable->name = memory->Dup(assetName.c_str());
+    return stringTable;
+}
+
+bool AssetLoaderStringTable::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool AssetLoaderStringTable::LoadFromRaw(
+    const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    const auto file = searchPath->Open(assetName);
+    if (!file.IsOpen())
+        return false;
+
+    string_table::StringTableLoaderV1<StringTable> loader;
+    auto* stringTable = loader.LoadFromStream(assetName, *memory, *file.m_stream);
+
+    manager->AddAsset(ASSET_TYPE_STRINGTABLE, assetName, stringTable);
+
+    return true;
+}

src/ObjLoading/Game/IW3/AssetLoaders/AssetLoaderStringTable.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "AssetLoading/BasicAssetLoader.h"
+#include "Game/IW3/IW3.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW3
+{
+    class AssetLoaderStringTable final : public BasicAssetLoader<ASSET_TYPE_STRINGTABLE, StringTable>
+    {
+    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 IW3

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderStringTable.cpp

@@ -5,6 +5,7 @@
 #include "Game/IW4/IW4.h"
 #include "ObjLoading.h"
 #include "Pool/GlobalAssetPool.h"
+#include "StringTable/StringTableLoader.h"
 
 #include <cstring>
 
@@ -30,49 +31,8 @@ bool AssetLoaderStringTable::LoadFromRaw(
     if (!file.IsOpen())
         return false;
 
-    auto* stringTable = memory->Create<StringTable>();
+    string_table::StringTableLoaderV2<StringTable, Common::StringTable_HashString> loader;
-    stringTable->name = memory->Dup(assetName.c_str());
+    auto* stringTable = loader.LoadFromStream(assetName, *memory, *file.m_stream);
-
-    std::vector<std::vector<std::string>> csvLines;
-    std::vector<std::string> currentLine;
-    auto maxCols = 0u;
-    const CsvInputStream csv(*file.m_stream);
-
-    while (csv.NextRow(currentLine))
-    {
-        if (currentLine.size() > maxCols)
-            maxCols = currentLine.size();
-        csvLines.emplace_back(std::move(currentLine));
-        currentLine = std::vector<std::string>();
-    }
-
-    stringTable->columnCount = static_cast<int>(maxCols);
-    stringTable->rowCount = static_cast<int>(csvLines.size());
-    const auto cellCount = static_cast<unsigned>(stringTable->rowCount) * static_cast<unsigned>(stringTable->columnCount);
-
-    if (cellCount)
-    {
-        stringTable->values = static_cast<StringTableCell*>(memory->Alloc(sizeof(StringTableCell) * cellCount));
-
-        for (auto row = 0u; row < csvLines.size(); row++)
-        {
-            const auto& rowValues = csvLines[row];
-            for (auto col = 0u; col < maxCols; col++)
-            {
-                auto& cell = stringTable->values[row * maxCols + col];
-                if (col >= rowValues.size() || rowValues[col].empty())
-                    cell.string = "";
-                else
-                    cell.string = memory->Dup(rowValues[col].c_str());
-
-                cell.hash = Common::StringTable_HashString(cell.string);
-            }
-        }
-    }
-    else
-    {
-        stringTable->values = nullptr;
-    }
 
     manager->AddAsset(ASSET_TYPE_STRINGTABLE, assetName, stringTable);
 

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderStringTable.cpp

@@ -5,6 +5,7 @@
 #include "Game/IW5/IW5.h"
 #include "ObjLoading.h"
 #include "Pool/GlobalAssetPool.h"
+#include "StringTable/StringTableLoader.h"
 
 #include <cstring>
 
@@ -30,49 +31,8 @@ bool AssetLoaderStringTable::LoadFromRaw(
     if (!file.IsOpen())
         return false;
 
-    auto* stringTable = memory->Create<StringTable>();
+    string_table::StringTableLoaderV2<StringTable, Common::StringTable_HashString> loader;
-    stringTable->name = memory->Dup(assetName.c_str());
+    auto* stringTable = loader.LoadFromStream(assetName, *memory, *file.m_stream);
-
-    std::vector<std::vector<std::string>> csvLines;
-    std::vector<std::string> currentLine;
-    auto maxCols = 0u;
-    const CsvInputStream csv(*file.m_stream);
-
-    while (csv.NextRow(currentLine))
-    {
-        if (currentLine.size() > maxCols)
-            maxCols = currentLine.size();
-        csvLines.emplace_back(std::move(currentLine));
-        currentLine = std::vector<std::string>();
-    }
-
-    stringTable->columnCount = static_cast<int>(maxCols);
-    stringTable->rowCount = static_cast<int>(csvLines.size());
-    const auto cellCount = static_cast<unsigned>(stringTable->rowCount) * static_cast<unsigned>(stringTable->columnCount);
-
-    if (cellCount)
-    {
-        stringTable->values = static_cast<StringTableCell*>(memory->Alloc(sizeof(StringTableCell) * cellCount));
-
-        for (auto row = 0u; row < csvLines.size(); row++)
-        {
-            const auto& rowValues = csvLines[row];
-            for (auto col = 0u; col < maxCols; col++)
-            {
-                auto& cell = stringTable->values[row * maxCols + col];
-                if (col >= rowValues.size() || rowValues[col].empty())
-                    cell.string = "";
-                else
-                    cell.string = memory->Dup(rowValues[col].c_str());
-
-                cell.hash = Common::StringTable_HashString(cell.string);
-            }
-        }
-    }
-    else
-    {
-        stringTable->values = nullptr;
-    }
 
     manager->AddAsset(ASSET_TYPE_STRINGTABLE, assetName, stringTable);
 

src/ObjLoading/Game/T5/AssetLoaders/AssetLoaderStringTable.cpp

@@ -4,6 +4,7 @@
 #include "Game/T5/CommonT5.h"
 #include "Game/T5/T5.h"
 #include "Pool/GlobalAssetPool.h"
+#include "StringTable/StringTableLoader.h"
 
 #include <cstring>
 
@@ -29,65 +30,8 @@ bool AssetLoaderStringTable::LoadFromRaw(
     if (!file.IsOpen())
         return false;
 
-    auto* stringTable = memory->Create<StringTable>();
+    string_table::StringTableLoaderV3<StringTable, Common::Com_HashString> loader;
-    stringTable->name = memory->Dup(assetName.c_str());
+    auto* stringTable = loader.LoadFromStream(assetName, *memory, *file.m_stream);
-
-    std::vector<std::vector<std::string>> csvLines;
-    std::vector<std::string> currentLine;
-    auto maxCols = 0u;
-    const CsvInputStream csv(*file.m_stream);
-
-    while (csv.NextRow(currentLine))
-    {
-        if (currentLine.size() > maxCols)
-            maxCols = currentLine.size();
-        csvLines.emplace_back(std::move(currentLine));
-        currentLine = std::vector<std::string>();
-    }
-
-    stringTable->columnCount = static_cast<int>(maxCols);
-    stringTable->rowCount = static_cast<int>(csvLines.size());
-    const auto cellCount = static_cast<unsigned>(stringTable->rowCount) * static_cast<unsigned>(stringTable->columnCount);
-
-    if (cellCount)
-    {
-        stringTable->values = static_cast<StringTableCell*>(memory->Alloc(sizeof(StringTableCell) * cellCount));
-        stringTable->cellIndex = static_cast<int16_t*>(memory->Alloc(sizeof(int16_t) * cellCount));
-
-        for (auto c = 0u; c < cellCount; c++)
-            stringTable->cellIndex[c] = static_cast<int16_t>(c);
-
-        for (auto row = 0u; row < csvLines.size(); row++)
-        {
-            const auto& rowValues = csvLines[row];
-            for (auto col = 0u; col < maxCols; col++)
-            {
-                auto& cell = stringTable->values[row * maxCols + col];
-                if (col >= rowValues.size() || rowValues[col].empty())
-                    cell.string = "";
-                else
-                    cell.string = memory->Dup(rowValues[col].c_str());
-
-                cell.hash = Common::Com_HashString(cell.string);
-            }
-        }
-
-        std::sort(&stringTable->cellIndex[0],
-                  &stringTable->cellIndex[cellCount - 1],
-                  [stringTable, maxCols](const int16_t a, const int16_t b)
-                  {
-                      auto compareResult = stringTable->values[a].hash - stringTable->values[b].hash;
-                      if (compareResult == 0)
-                          compareResult = a % maxCols - b % maxCols;
-                      return compareResult < 0;
-                  });
-    }
-
-    else
-    {
-        stringTable->values = nullptr;
-        stringTable->cellIndex = nullptr;
-    }
 
     manager->AddAsset(ASSET_TYPE_STRINGTABLE, assetName, stringTable);
 

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

@@ -4,6 +4,7 @@
 #include "Game/T6/CommonT6.h"
 #include "Game/T6/T6.h"
 #include "Pool/GlobalAssetPool.h"
+#include "StringTable/StringTableLoader.h"
 
 #include <cstring>
 
@@ -29,65 +30,8 @@ bool AssetLoaderStringTable::LoadFromRaw(
     if (!file.IsOpen())
         return false;
 
-    auto* stringTable = memory->Create<StringTable>();
+    string_table::StringTableLoaderV3<StringTable, Common::Com_HashString> loader;
-    stringTable->name = memory->Dup(assetName.c_str());
+    auto* stringTable = loader.LoadFromStream(assetName, *memory, *file.m_stream);
-
-    std::vector<std::vector<std::string>> csvLines;
-    std::vector<std::string> currentLine;
-    auto maxCols = 0u;
-    const CsvInputStream csv(*file.m_stream);
-
-    while (csv.NextRow(currentLine))
-    {
-        if (currentLine.size() > maxCols)
-            maxCols = currentLine.size();
-        csvLines.emplace_back(std::move(currentLine));
-        currentLine = std::vector<std::string>();
-    }
-
-    stringTable->columnCount = static_cast<int>(maxCols);
-    stringTable->rowCount = static_cast<int>(csvLines.size());
-    const auto cellCount = static_cast<unsigned>(stringTable->rowCount) * static_cast<unsigned>(stringTable->columnCount);
-
-    if (cellCount)
-    {
-        stringTable->values = static_cast<StringTableCell*>(memory->Alloc(sizeof(StringTableCell) * cellCount));
-        stringTable->cellIndex = static_cast<int16_t*>(memory->Alloc(sizeof(int16_t) * cellCount));
-
-        for (auto c = 0u; c < cellCount; c++)
-            stringTable->cellIndex[c] = static_cast<int16_t>(c);
-
-        for (auto row = 0u; row < csvLines.size(); row++)
-        {
-            const auto& rowValues = csvLines[row];
-            for (auto col = 0u; col < maxCols; col++)
-            {
-                auto& cell = stringTable->values[row * maxCols + col];
-                if (col >= rowValues.size() || rowValues[col].empty())
-                    cell.string = "";
-                else
-                    cell.string = memory->Dup(rowValues[col].c_str());
-
-                cell.hash = Common::Com_HashString(cell.string);
-            }
-        }
-
-        std::sort(&stringTable->cellIndex[0],
-                  &stringTable->cellIndex[cellCount - 1],
-                  [stringTable, maxCols](const int16_t a, const int16_t b)
-                  {
-                      auto compareResult = stringTable->values[a].hash - stringTable->values[b].hash;
-                      if (compareResult == 0)
-                          compareResult = a % maxCols - b % maxCols;
-                      return compareResult < 0;
-                  });
-    }
-
-    else
-    {
-        stringTable->values = nullptr;
-        stringTable->cellIndex = nullptr;
-    }
 
     manager->AddAsset(ASSET_TYPE_STRINGTABLE, assetName, stringTable);
 

src/ObjLoading/StringTable/StringTableLoader.h

@@ -0,0 +1,147 @@
+#pragma once
+
+#include "Csv/CsvStream.h"
+
+#include <algorithm>
+#include <istream>
+#include <type_traits>
+#include <vector>
+
+namespace string_table
+{
+    template<typename StringTableType, typename CellType> class AbstractStringTableLoader
+    {
+    protected:
+        AbstractStringTableLoader() = default;
+        virtual ~AbstractStringTableLoader() = default;
+        AbstractStringTableLoader(const AbstractStringTableLoader& other) = default;
+        AbstractStringTableLoader(AbstractStringTableLoader&& other) noexcept = default;
+        AbstractStringTableLoader& operator=(const AbstractStringTableLoader& other) = default;
+        AbstractStringTableLoader& operator=(AbstractStringTableLoader&& other) noexcept = default;
+
+        virtual void SetCellContent(CellType& cell, const char* content) = 0;
+
+        virtual void PostProcessStringTable(StringTableType* stringTable, const unsigned cellCount, MemoryManager& memory) {}
+
+    public:
+        StringTableType* LoadFromStream(const std::string& assetName, MemoryManager& memory, std::istream& stream)
+        {
+            auto* stringTable = memory.Create<StringTableType>();
+            stringTable->name = memory.Dup(assetName.c_str());
+
+            std::vector<std::vector<std::string>> csvLines;
+            std::vector<std::string> currentLine;
+            auto maxCols = 0u;
+            const CsvInputStream csv(stream);
+
+            while (csv.NextRow(currentLine))
+            {
+                if (currentLine.size() > maxCols)
+                    maxCols = currentLine.size();
+                csvLines.emplace_back(std::move(currentLine));
+                currentLine = std::vector<std::string>();
+            }
+
+            stringTable->columnCount = static_cast<int>(maxCols);
+            stringTable->rowCount = static_cast<int>(csvLines.size());
+            const auto cellCount = static_cast<unsigned>(stringTable->rowCount) * static_cast<unsigned>(stringTable->columnCount);
+
+            if (cellCount)
+            {
+                stringTable->values = static_cast<CellType*>(memory.Alloc(sizeof(CellType) * cellCount));
+
+                for (auto row = 0u; row < csvLines.size(); row++)
+                {
+                    const auto& rowValues = csvLines[row];
+                    for (auto col = 0u; col < maxCols; col++)
+                    {
+                        auto& cell = stringTable->values[row * maxCols + col];
+                        if (col >= rowValues.size() || rowValues[col].empty())
+                            SetCellContent(cell, "");
+                        else
+                            SetCellContent(cell, memory.Dup(rowValues[col].c_str()));
+                    }
+                }
+            }
+            else
+            {
+                stringTable->values = nullptr;
+            }
+
+            PostProcessStringTable(stringTable, cellCount, memory);
+
+            return stringTable;
+        }
+    };
+
+    // =================================
+    // V1: IW3
+    // - Cells are const char*
+    // =================================
+    template<typename StringTableType> class StringTableLoaderV1 final : public AbstractStringTableLoader<StringTableType, const char*>
+    {
+    protected:
+        void SetCellContent(const char*& cell, const char* content) override
+        {
+            cell = content;
+        }
+    };
+
+    // =================================
+    // V2: IW4, IW5
+    // - Cells are a struct and have a hash
+    // =================================
+    template<typename StringTableType, int (*HashFunc)(const char*)>
+    class StringTableLoaderV2 final : public AbstractStringTableLoader<StringTableType, std::remove_pointer_t<decltype(StringTableType::values)>>
+    {
+        using CellType_t = decltype(*StringTableType::values);
+
+    protected:
+        void SetCellContent(CellType_t& cell, const char* content) override
+        {
+            cell.string = content;
+            cell.hash = HashFunc(content);
+        }
+    };
+
+    // =================================
+    // V3: T5, T6
+    // - Cells are a struct and have a hash
+    // - StringTable has an index array for binary search
+    // =================================
+    template<typename StringTableType, int (*HashFunc)(const char*)>
+    class StringTableLoaderV3 final : public AbstractStringTableLoader<StringTableType, std::remove_pointer_t<decltype(StringTableType::values)>>
+    {
+        using CellType_t = decltype(*StringTableType::values);
+
+    protected:
+        void SetCellContent(CellType_t& cell, const char* content) override
+        {
+            cell.string = content;
+            cell.hash = HashFunc(content);
+        }
+
+        void PostProcessStringTable(StringTableType* stringTable, const unsigned cellCount, MemoryManager& memory) override
+        {
+            if (!cellCount)
+            {
+                stringTable->cellIndex = nullptr;
+                return;
+            }
+
+            stringTable->cellIndex = static_cast<int16_t*>(memory.Alloc(sizeof(int16_t) * cellCount));
+            for (auto i = 0u; i < cellCount; i++)
+                stringTable->cellIndex[i] = i;
+
+            std::sort(&stringTable->cellIndex[0],
+                      &stringTable->cellIndex[cellCount - 1],
+                      [stringTable](const int16_t a, const int16_t b)
+                      {
+                          auto compareResult = stringTable->values[a].hash - stringTable->values[b].hash;
+                          if (compareResult == 0)
+                              compareResult = (a % stringTable->columnCount) - (b % stringTable->columnCount);
+                          return compareResult < 0;
+                      });
+        }
+    };
+} // namespace string_table

test/ObjLoadingTests/Game/IW3/AssetLoaders/AssetLoaderStringTableTest.cpp

@@ -0,0 +1,46 @@
+#include "Game/IW3/AssetLoaders/AssetLoaderStringTable.h"
+
+#include "Game/IW3/GameIW3.h"
+#include "Mock/MockAssetLoadingManager.h"
+#include "Mock/MockSearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+using namespace IW3;
+using namespace std::literals;
+
+namespace
+{
+    TEST_CASE("AssetLoaderStringTable(IW3): Can parse string table", "[iw3][stringtable][assetloader]")
+    {
+        MockSearchPath searchPath;
+        searchPath.AddFileData("mp/cooltable.csv",
+                               "test,data,lol\n"
+                               "lorem,ipsum");
+
+        Zone zone("MockZone", 0, &g_GameIW3);
+        MockAssetLoadingManager assetLoadingManager(&zone, &searchPath);
+
+        AssetLoaderStringTable assetLoader;
+        MemoryManager memory;
+
+        assetLoader.LoadFromRaw("mp/cooltable.csv", &searchPath, &memory, &assetLoadingManager, &zone);
+
+        auto* assetInfo = reinterpret_cast<XAssetInfo<StringTable>*>(assetLoadingManager.MockGetAddedAsset("mp/cooltable.csv"));
+        REQUIRE(assetInfo != nullptr);
+
+        const auto* stringTable = assetInfo->Asset();
+        REQUIRE(stringTable->name == "mp/cooltable.csv"s);
+        REQUIRE(stringTable->columnCount == 3);
+        REQUIRE(stringTable->rowCount == 2);
+
+        REQUIRE(stringTable->values[0] == "test"s);
+        REQUIRE(stringTable->values[1] == "data"s);
+        REQUIRE(stringTable->values[2] == "lol"s);
+        REQUIRE(stringTable->values[3] == "lorem"s);
+        REQUIRE(stringTable->values[4] == "ipsum"s);
+        REQUIRE(stringTable->values[5] == ""s);
+    }
+} // namespace

test/ObjLoadingTests/Game/IW4/AssetLoaders/AssetLoaderStringTableTest.cpp

@@ -0,0 +1,53 @@
+#include "Game/IW4/AssetLoaders/AssetLoaderStringTable.h"
+
+#include "Game/IW4/CommonIW4.h"
+#include "Game/IW4/GameIW4.h"
+#include "Mock/MockAssetLoadingManager.h"
+#include "Mock/MockSearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+using namespace IW4;
+using namespace std::literals;
+
+namespace
+{
+    TEST_CASE("AssetLoaderStringTable(IW4): Can parse string table", "[iw4][stringtable][assetloader]")
+    {
+        MockSearchPath searchPath;
+        searchPath.AddFileData("mp/cooltable.csv",
+                               "test,data,lol\n"
+                               "lorem,ipsum");
+
+        Zone zone("MockZone", 0, &g_GameIW4);
+        MockAssetLoadingManager assetLoadingManager(&zone, &searchPath);
+
+        AssetLoaderStringTable assetLoader;
+        MemoryManager memory;
+
+        assetLoader.LoadFromRaw("mp/cooltable.csv", &searchPath, &memory, &assetLoadingManager, &zone);
+
+        auto* assetInfo = reinterpret_cast<XAssetInfo<StringTable>*>(assetLoadingManager.MockGetAddedAsset("mp/cooltable.csv"));
+        REQUIRE(assetInfo != nullptr);
+
+        const auto* stringTable = assetInfo->Asset();
+        REQUIRE(stringTable->name == "mp/cooltable.csv"s);
+        REQUIRE(stringTable->columnCount == 3);
+        REQUIRE(stringTable->rowCount == 2);
+
+        CHECK(stringTable->values[0].string == "test"s);
+        CHECK(stringTable->values[0].hash == 0x364492);
+        CHECK(stringTable->values[1].string == "data"s);
+        CHECK(stringTable->values[1].hash == 0x2eefaa);
+        CHECK(stringTable->values[2].string == "lol"s);
+        CHECK(stringTable->values[2].hash == 0x1a349);
+        CHECK(stringTable->values[3].string == "lorem"s);
+        CHECK(stringTable->values[3].hash == 0x6261837);
+        CHECK(stringTable->values[4].string == "ipsum"s);
+        CHECK(stringTable->values[4].hash == 0x5fc4bc4);
+        CHECK(stringTable->values[5].string == ""s);
+        CHECK(stringTable->values[5].hash == 0x0);
+    }
+} // namespace

test/ObjLoadingTests/Game/IW5/AssetLoaders/AssetLoaderStringTableTest.cpp

@@ -0,0 +1,52 @@
+#include "Game/IW5/AssetLoaders/AssetLoaderStringTable.h"
+
+#include "Game/IW5/GameIW5.h"
+#include "Mock/MockAssetLoadingManager.h"
+#include "Mock/MockSearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+using namespace IW5;
+using namespace std::literals;
+
+namespace
+{
+    TEST_CASE("AssetLoaderStringTable(IW5): Can parse string table", "[iw5][stringtable][assetloader]")
+    {
+        MockSearchPath searchPath;
+        searchPath.AddFileData("mp/cooltable.csv",
+                               "test,data,lol\n"
+                               "lorem,ipsum");
+
+        Zone zone("MockZone", 0, &g_GameIW5);
+        MockAssetLoadingManager assetLoadingManager(&zone, &searchPath);
+
+        AssetLoaderStringTable assetLoader;
+        MemoryManager memory;
+
+        assetLoader.LoadFromRaw("mp/cooltable.csv", &searchPath, &memory, &assetLoadingManager, &zone);
+
+        auto* assetInfo = reinterpret_cast<XAssetInfo<StringTable>*>(assetLoadingManager.MockGetAddedAsset("mp/cooltable.csv"));
+        REQUIRE(assetInfo != nullptr);
+
+        const auto* stringTable = assetInfo->Asset();
+        REQUIRE(stringTable->name == "mp/cooltable.csv"s);
+        REQUIRE(stringTable->columnCount == 3);
+        REQUIRE(stringTable->rowCount == 2);
+
+        CHECK(stringTable->values[0].string == "test"s);
+        CHECK(stringTable->values[0].hash == 0x364492);
+        CHECK(stringTable->values[1].string == "data"s);
+        CHECK(stringTable->values[1].hash == 0x2eefaa);
+        CHECK(stringTable->values[2].string == "lol"s);
+        CHECK(stringTable->values[2].hash == 0x1a349);
+        CHECK(stringTable->values[3].string == "lorem"s);
+        CHECK(stringTable->values[3].hash == 0x6261837);
+        CHECK(stringTable->values[4].string == "ipsum"s);
+        CHECK(stringTable->values[4].hash == 0x5fc4bc4);
+        CHECK(stringTable->values[5].string == ""s);
+        CHECK(stringTable->values[5].hash == 0x0);
+    }
+} // namespace

test/ObjLoadingTests/Game/T5/AssetLoaders/AssetLoaderStringTableTest.cpp

@@ -0,0 +1,59 @@
+#include "Game/T5/AssetLoaders/AssetLoaderStringTable.h"
+
+#include "Game/T5/GameT5.h"
+#include "Mock/MockAssetLoadingManager.h"
+#include "Mock/MockSearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+using namespace T5;
+using namespace std::literals;
+
+namespace
+{
+    TEST_CASE("AssetLoaderStringTable(T5): Can parse string table", "[t5][stringtable][assetloader]")
+    {
+        MockSearchPath searchPath;
+        searchPath.AddFileData("mp/cooltable.csv",
+                               "test,data,lol\n"
+                               "lorem,ipsum");
+
+        Zone zone("MockZone", 0, &g_GameT5);
+        MockAssetLoadingManager assetLoadingManager(&zone, &searchPath);
+
+        AssetLoaderStringTable assetLoader;
+        MemoryManager memory;
+
+        assetLoader.LoadFromRaw("mp/cooltable.csv", &searchPath, &memory, &assetLoadingManager, &zone);
+
+        auto* assetInfo = reinterpret_cast<XAssetInfo<StringTable>*>(assetLoadingManager.MockGetAddedAsset("mp/cooltable.csv"));
+        REQUIRE(assetInfo != nullptr);
+
+        const auto* stringTable = assetInfo->Asset();
+        REQUIRE(stringTable->name == "mp/cooltable.csv"s);
+        REQUIRE(stringTable->columnCount == 3);
+        REQUIRE(stringTable->rowCount == 2);
+
+        CHECK(stringTable->values[0].string == "test"s);
+        CHECK(stringTable->values[0].hash == 0x7c9e6865);
+        CHECK(stringTable->values[1].string == "data"s);
+        CHECK(stringTable->values[1].hash == 0x7c95915f);
+        CHECK(stringTable->values[2].string == "lol"s);
+        CHECK(stringTable->values[2].hash == 0xb888d0c);
+        CHECK(stringTable->values[3].string == "lorem"s);
+        CHECK(stringTable->values[3].hash == 0xfe02704);
+        CHECK(stringTable->values[4].string == "ipsum"s);
+        CHECK(stringTable->values[4].hash == 0xfaa7033);
+        CHECK(stringTable->values[5].string == ""s);
+        CHECK(stringTable->values[5].hash == 0x1505);
+
+        REQUIRE(stringTable->cellIndex != nullptr);
+        CHECK(stringTable->cellIndex[0] == 2);
+        CHECK(stringTable->cellIndex[1] == 4);
+        CHECK(stringTable->cellIndex[2] == 3);
+        CHECK(stringTable->cellIndex[3] == 1);
+        CHECK(stringTable->cellIndex[4] == 0);
+    }
+} // namespace

test/ObjLoadingTests/Game/T6/AssetLoaders/AssetLoaderStringTableTest.cpp

@@ -0,0 +1,59 @@
+#include "Game/T6/AssetLoaders/AssetLoaderStringTable.h"
+
+#include "Game/T6/GameT6.h"
+#include "Mock/MockAssetLoadingManager.h"
+#include "Mock/MockSearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+using namespace T6;
+using namespace std::literals;
+
+namespace
+{
+    TEST_CASE("AssetLoaderStringTable(T6): Can parse string table", "[t6][stringtable][assetloader]")
+    {
+        MockSearchPath searchPath;
+        searchPath.AddFileData("mp/cooltable.csv",
+                               "test,data,lol\n"
+                               "lorem,ipsum");
+
+        Zone zone("MockZone", 0, &g_GameT6);
+        MockAssetLoadingManager assetLoadingManager(&zone, &searchPath);
+
+        AssetLoaderStringTable assetLoader;
+        MemoryManager memory;
+
+        assetLoader.LoadFromRaw("mp/cooltable.csv", &searchPath, &memory, &assetLoadingManager, &zone);
+
+        auto* assetInfo = reinterpret_cast<XAssetInfo<StringTable>*>(assetLoadingManager.MockGetAddedAsset("mp/cooltable.csv"));
+        REQUIRE(assetInfo != nullptr);
+
+        const auto* stringTable = assetInfo->Asset();
+        REQUIRE(stringTable->name == "mp/cooltable.csv"s);
+        REQUIRE(stringTable->columnCount == 3);
+        REQUIRE(stringTable->rowCount == 2);
+
+        CHECK(stringTable->values[0].string == "test"s);
+        CHECK(stringTable->values[0].hash == 0x7c9e6865);
+        CHECK(stringTable->values[1].string == "data"s);
+        CHECK(stringTable->values[1].hash == 0x7c95915f);
+        CHECK(stringTable->values[2].string == "lol"s);
+        CHECK(stringTable->values[2].hash == 0xb888d0c);
+        CHECK(stringTable->values[3].string == "lorem"s);
+        CHECK(stringTable->values[3].hash == 0xfe02704);
+        CHECK(stringTable->values[4].string == "ipsum"s);
+        CHECK(stringTable->values[4].hash == 0xfaa7033);
+        CHECK(stringTable->values[5].string == ""s);
+        CHECK(stringTable->values[5].hash == 0x1505);
+
+        REQUIRE(stringTable->cellIndex != nullptr);
+        CHECK(stringTable->cellIndex[0] == 2);
+        CHECK(stringTable->cellIndex[1] == 4);
+        CHECK(stringTable->cellIndex[2] == 3);
+        CHECK(stringTable->cellIndex[3] == 1);
+        CHECK(stringTable->cellIndex[4] == 0);
+    }
+} // namespace