Load T5 fastfiles

src/ZoneLoading/Game/T5/ContentLoaderT5.cpp

@@ -0,0 +1,188 @@
+#include "ContentLoaderT5.h"
+#include "Game/T5/T5.h"
+#include "Loading/Exception/UnsupportedAssetTypeException.h"
+
+#include <cassert>
+
+#include "Game/T5/XAssets/clipmap_t/clipmap_t_load_db.h"
+#include "Game/T5/XAssets/comworld/comworld_load_db.h"
+#include "Game/T5/XAssets/ddlroot_t/ddlroot_t_load_db.h"
+#include "Game/T5/XAssets/destructibledef/destructibledef_load_db.h"
+#include "Game/T5/XAssets/emblemset/emblemset_load_db.h"
+#include "Game/T5/XAssets/font_s/font_s_load_db.h"
+#include "Game/T5/XAssets/fxeffectdef/fxeffectdef_load_db.h"
+#include "Game/T5/XAssets/fximpacttable/fximpacttable_load_db.h"
+#include "Game/T5/XAssets/gameworldmp/gameworldmp_load_db.h"
+#include "Game/T5/XAssets/gameworldsp/gameworldsp_load_db.h"
+#include "Game/T5/XAssets/gfximage/gfximage_load_db.h"
+#include "Game/T5/XAssets/gfxlightdef/gfxlightdef_load_db.h"
+#include "Game/T5/XAssets/gfxworld/gfxworld_load_db.h"
+#include "Game/T5/XAssets/glasses/glasses_load_db.h"
+#include "Game/T5/XAssets/localizeentry/localizeentry_load_db.h"
+#include "Game/T5/XAssets/mapents/mapents_load_db.h"
+#include "Game/T5/XAssets/material/material_load_db.h"
+#include "Game/T5/XAssets/materialtechniqueset/materialtechniqueset_load_db.h"
+#include "Game/T5/XAssets/menudef_t/menudef_t_load_db.h"
+#include "Game/T5/XAssets/menulist/menulist_load_db.h"
+#include "Game/T5/XAssets/packindex/packindex_load_db.h"
+#include "Game/T5/XAssets/physconstraints/physconstraints_load_db.h"
+#include "Game/T5/XAssets/physpreset/physpreset_load_db.h"
+#include "Game/T5/XAssets/rawfile/rawfile_load_db.h"
+#include "Game/T5/XAssets/sndbank/sndbank_load_db.h"
+#include "Game/T5/XAssets/snddriverglobals/snddriverglobals_load_db.h"
+#include "Game/T5/XAssets/sndpatch/sndpatch_load_db.h"
+#include "Game/T5/XAssets/stringtable/stringtable_load_db.h"
+#include "Game/T5/XAssets/weaponvariantdef/weaponvariantdef_load_db.h"
+#include "Game/T5/XAssets/xanimparts/xanimparts_load_db.h"
+#include "Game/T5/XAssets/xglobals/xglobals_load_db.h"
+#include "Game/T5/XAssets/xmodel/xmodel_load_db.h"
+
+using namespace T5;
+
+ContentLoader::ContentLoader()
+{
+    varXAsset = nullptr;
+    varScriptStringList = nullptr;
+}
+
+void ContentLoader::LoadScriptStringList(const bool atStreamStart)
+{
+    assert(m_zone->m_script_strings.Empty());
+
+    m_stream->PushBlock(XFILE_BLOCK_VIRTUAL);
+
+    if (atStreamStart)
+        m_stream->Load<ScriptStringList>(varScriptStringList);
+
+    if (varScriptStringList->strings != nullptr)
+    {
+        assert(varScriptStringList->strings == PTR_FOLLOWING);
+
+        varScriptStringList->strings = m_stream->Alloc<const char*>(alignof(const char*));
+        varXString = varScriptStringList->strings;
+        LoadXStringArray(true, varScriptStringList->count);
+
+        for (int i = 0; i < varScriptStringList->count; i++)
+        {
+            if (varScriptStringList->strings[i])
+            {
+                m_zone->m_script_strings.AddScriptString(varScriptStringList->strings[i]);
+            }
+            else
+            {
+                m_zone->m_script_strings.AddScriptString("");
+            }
+        }
+    }
+
+    m_stream->PopBlock();
+
+    assert(m_zone->m_script_strings.Count() <= SCR_STRING_MAX + 1);
+}
+
+void ContentLoader::LoadXAsset(const bool atStreamStart)
+{
+#define LOAD_ASSET(type_index, typeName, headerEntry) \
+    case type_index: \
+        { \
+            Loader_##typeName loader(m_zone, m_stream); \
+            loader.Load(&varXAsset->header.headerEntry); \
+            break; \
+        }
+#define SKIP_ASSET(type_index, typeName, headerEntry) \
+    case type_index: \
+        break;
+
+    assert(varXAsset != nullptr);
+
+    if (atStreamStart)
+        m_stream->Load<XAsset>(varXAsset);
+
+    switch (varXAsset->type)
+    {
+    LOAD_ASSET(ASSET_TYPE_PHYSPRESET, PhysPreset, physPreset)
+    LOAD_ASSET(ASSET_TYPE_PHYSCONSTRAINTS, PhysConstraints, physConstraints)
+    LOAD_ASSET(ASSET_TYPE_DESTRUCTIBLEDEF, DestructibleDef, destructibleDef)
+    LOAD_ASSET(ASSET_TYPE_XANIMPARTS, XAnimParts, parts)
+    LOAD_ASSET(ASSET_TYPE_XMODEL, XModel, model)
+    LOAD_ASSET(ASSET_TYPE_MATERIAL, Material, material)
+    LOAD_ASSET(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet, techniqueSet)
+    LOAD_ASSET(ASSET_TYPE_IMAGE, GfxImage, image)
+    LOAD_ASSET(ASSET_TYPE_SOUND, SndBank, sound)
+    LOAD_ASSET(ASSET_TYPE_SOUND_PATCH, SndPatch, soundPatch)
+    LOAD_ASSET(ASSET_TYPE_CLIPMAP, clipMap_t, clipMap)
+    LOAD_ASSET(ASSET_TYPE_CLIPMAP_PVS, clipMap_t, clipMap)
+    LOAD_ASSET(ASSET_TYPE_COMWORLD, ComWorld, comWorld)
+    LOAD_ASSET(ASSET_TYPE_GAMEWORLD_SP, GameWorldSp, gameWorldSp)
+    LOAD_ASSET(ASSET_TYPE_GAMEWORLD_MP, GameWorldMp, gameWorldMp)
+    LOAD_ASSET(ASSET_TYPE_MAP_ENTS, MapEnts, mapEnts)
+    LOAD_ASSET(ASSET_TYPE_GFXWORLD, GfxWorld, gfxWorld)
+    LOAD_ASSET(ASSET_TYPE_LIGHT_DEF, GfxLightDef, lightDef)
+    LOAD_ASSET(ASSET_TYPE_FONT, Font_s, font)
+    LOAD_ASSET(ASSET_TYPE_MENULIST, MenuList, menuList)
+    LOAD_ASSET(ASSET_TYPE_MENU, menuDef_t, menu)
+    LOAD_ASSET(ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry, localize)
+    LOAD_ASSET(ASSET_TYPE_WEAPON, WeaponVariantDef, weapon)
+    LOAD_ASSET(ASSET_TYPE_SNDDRIVER_GLOBALS, SndDriverGlobals, sndDriverGlobals)
+    LOAD_ASSET(ASSET_TYPE_FX, FxEffectDef, fx)
+    LOAD_ASSET(ASSET_TYPE_IMPACT_FX, FxImpactTable, impactFx)
+    LOAD_ASSET(ASSET_TYPE_RAWFILE, RawFile, rawfile)
+    LOAD_ASSET(ASSET_TYPE_STRINGTABLE, StringTable, stringTable)
+    LOAD_ASSET(ASSET_TYPE_PACK_INDEX, PackIndex, packIndex)
+    LOAD_ASSET(ASSET_TYPE_XGLOBALS, XGlobals, xGlobals)
+    LOAD_ASSET(ASSET_TYPE_DDL, ddlRoot_t, ddlRoot)
+    LOAD_ASSET(ASSET_TYPE_GLASSES, Glasses, glasses)
+    LOAD_ASSET(ASSET_TYPE_EMBLEMSET, EmblemSet, emblemSet)
+
+    default:
+        {
+            throw UnsupportedAssetTypeException(varXAsset->type);
+        }
+    }
+
+#undef LOAD_ASSET
+}
+
+void ContentLoader::LoadXAssetArray(const bool atStreamStart, const size_t count)
+{
+    assert(varXAsset != nullptr);
+
+    if (atStreamStart)
+        m_stream->Load<XAsset>(varXAsset, count);
+
+    for (asset_type_t assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+    {
+        m_zone->m_pools->InitPoolDynamic(assetType);
+    }
+
+    for (size_t index = 0; index < count; index++)
+    {
+        LoadXAsset(false);
+        varXAsset++;
+    }
+}
+
+void ContentLoader::Load(Zone* zone, IZoneInputStream* stream)
+{
+    m_zone = zone;
+    m_stream = stream;
+
+    m_stream->PushBlock(XFILE_BLOCK_VIRTUAL);
+
+    XAssetList assetList{};
+    m_stream->LoadDataRaw(&assetList, sizeof assetList);
+
+    varScriptStringList = &assetList.stringList;
+    LoadScriptStringList(false);
+
+    if (assetList.assets != nullptr)
+    {
+        assert(assetList.assets == PTR_FOLLOWING);
+
+        assetList.assets = m_stream->Alloc<XAsset>(alignof(XAsset));
+        varXAsset = assetList.assets;
+        LoadXAssetArray(true, assetList.assetCount);
+    }
+
+    m_stream->PopBlock();
+}

src/ZoneLoading/Game/T5/ContentLoaderT5.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "Loading/ContentLoaderBase.h"
+#include "Loading/IContentLoadingEntryPoint.h"
+#include "Game/T5/T5.h"
+
+namespace T5
+{
+    class ContentLoader final : public ContentLoaderBase, public IContentLoadingEntryPoint
+    {
+        XAsset* varXAsset;
+        ScriptStringList* varScriptStringList;
+
+        void LoadScriptStringList(bool atStreamStart);
+
+        void LoadXAsset(bool atStreamStart);
+        void LoadXAssetArray(bool atStreamStart, size_t count);
+
+    public:
+        ContentLoader();
+
+        void Load(Zone* zone, IZoneInputStream* stream) override;
+    };
+}

src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp

@@ -0,0 +1,104 @@
+#include "ZoneLoaderFactoryT5.h"
+
+#include <cassert>
+#include <cstring>
+#include <type_traits>
+
+#include "Game/T5/T5.h"
+
+#include "Utils/ClassUtils.h"
+#include "ContentLoaderT5.h"
+#include "Game/T5/GameAssetPoolT5.h"
+#include "Game/T5/GameT5.h"
+#include "Game/GameLanguage.h"
+#include "Game/T5/ZoneConstantsT5.h"
+#include "Loading/Processor/ProcessorInflate.h"
+#include "Loading/Steps/StepSkipBytes.h"
+#include "Loading/Steps/StepAddProcessor.h"
+#include "Loading/Steps/StepAllocXBlocks.h"
+#include "Loading/Steps/StepLoadZoneContent.h"
+
+using namespace T5;
+
+class ZoneLoaderFactory::Impl
+{
+    static GameLanguage GetZoneLanguage(std::string& zoneName)
+    {
+        return GameLanguage::LANGUAGE_NONE;
+    }
+
+    static bool CanLoad(ZoneHeader& header, bool* isSecure, bool* isOfficial)
+    {
+        assert(isSecure != nullptr);
+        assert(isOfficial != nullptr);
+
+        if (header.m_version != ZoneConstants::ZONE_VERSION)
+        {
+            return false;
+        }
+
+        if (!memcmp(header.m_magic, ZoneConstants::MAGIC_UNSIGNED, std::char_traits<char>::length(ZoneConstants::MAGIC_UNSIGNED)))
+        {
+            *isSecure = false;
+            *isOfficial = true;
+            return true;
+        }
+
+        return false;
+    }
+
+    static void SetupBlock(ZoneLoader* zoneLoader)
+    {
+#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
+
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader->AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
+
+#undef XBLOCK_DEF
+    }
+
+public:
+    static ZoneLoader* CreateLoaderForHeader(ZoneHeader& header, std::string& fileName)
+    {
+        bool isSecure;
+        bool isOfficial;
+
+        // Check if this file is a supported IW4 zone.
+        if (!CanLoad(header, &isSecure, &isOfficial))
+            return nullptr;
+
+        // Create new zone
+        auto zone = std::make_unique<Zone>(fileName, 0, &g_GameT5);
+        auto* zonePtr = zone.get();
+        zone->m_pools = std::make_unique<GameAssetPoolT5>(zonePtr, 0);
+        zone->m_language = GetZoneLanguage(fileName);
+
+        // File is supported. Now setup all required steps for loading this file.
+        auto* zoneLoader = new ZoneLoader(std::move(zone));
+
+        SetupBlock(zoneLoader);
+
+        zoneLoader->AddLoadingStep(std::make_unique<StepAddProcessor>(std::make_unique<ProcessorInflate>(ZoneConstants::AUTHED_CHUNK_SIZE)));
+
+        // Start of the XFile struct
+        zoneLoader->AddLoadingStep(std::make_unique<StepSkipBytes>(8));
+        // Skip size and externalSize fields since they are not interesting for us
+        zoneLoader->AddLoadingStep(std::make_unique<StepAllocXBlocks>());
+
+        // Start of the zone content
+        zoneLoader->AddLoadingStep(std::make_unique<StepLoadZoneContent>(std::make_unique<ContentLoader>(), zonePtr, ZoneConstants::OFFSET_BLOCK_BIT_COUNT, ZoneConstants::INSERT_BLOCK));
+
+        // Return the fully setup zoneloader
+        return zoneLoader;
+    }
+};
+
+ZoneLoader* ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader& header, std::string& fileName)
+{
+    return Impl::CreateLoaderForHeader(header, fileName);
+}

src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Loading/IZoneLoaderFactory.h"
+#include <string>
+
+namespace T5
+{
+    class ZoneLoaderFactory final : public IZoneLoaderFactory
+    {
+        class Impl;
+
+    public:
+        ZoneLoader* CreateLoaderForHeader(ZoneHeader& header, std::string& fileName) override;
+    };
+}

src/ZoneLoading/ZoneLoading.cpp

@@ -6,6 +6,7 @@
 
 #include "Game/IW3/ZoneLoaderFactoryIW3.h"
 #include "Game/IW4/ZoneLoaderFactoryIW4.h"
+#include "Game/T5/ZoneLoaderFactoryT5.h"
 #include "Game/T6/ZoneLoaderFactoryT6.h"
 #include "Utils/ObjFileStream.h"
 
@@ -15,6 +16,7 @@ IZoneLoaderFactory* ZoneLoaderFactories[]
 {
     new IW3::ZoneLoaderFactory(),
     new IW4::ZoneLoaderFactory(),
+    new T5::ZoneLoaderFactory(),
     new T6::ZoneLoaderFactory()
 };