IW5 support initial commit

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

@@ -0,0 +1,51 @@
+#include "AssetLoaderLocalizeEntry.h"
+
+#include <sstream>
+
+#include "Localize/LocalizeCommon.h"
+#include "Parsing/LocalizeFile/LocalizeFileReader.h"
+
+using namespace IW5;
+
+XAssetInfoGeneric* AssetLoaderLocalizeEntry::LoadFromGlobalAssetPools(const std::string& assetName) const
+{
+    return nullptr;
+}
+
+void* AssetLoaderLocalizeEntry::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    return nullptr;
+}
+
+bool AssetLoaderLocalizeEntry::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool AssetLoaderLocalizeEntry::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    std::string fileName;
+    {
+        std::ostringstream str;
+        str << LocalizeCommon::GetNameOfLanguage(zone->m_language) << "/localizedstrings/" << assetName << ".str";
+        fileName = str.str();
+    }
+
+    const auto file = searchPath->Open(fileName);
+    if (!file.IsOpen())
+        return false;
+
+    LocalizeFileReader reader(*file.m_stream, assetName, zone->m_language);
+    const auto localizeEntries = reader.ReadLocalizeFile();
+
+    for (const auto& entry : localizeEntries)
+    {
+        auto* localizeEntry = memory->Create<LocalizeEntry>();
+        localizeEntry->name = memory->Dup(entry.m_key.c_str());
+        localizeEntry->value = memory->Dup(entry.m_value.c_str());
+
+        manager->AddAsset(ASSET_TYPE_LOCALIZE_ENTRY, entry.m_key, localizeEntry);
+    }
+
+    return true;
+}

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderLocalizeEntry.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "Game/IW5/IW5.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW5
+{
+    class AssetLoaderLocalizeEntry final : public BasicAssetLoader<ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry>
+    {
+    public:
+        _NODISCARD XAssetInfoGeneric* LoadFromGlobalAssetPools(const std::string& assetName) const override;
+        _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;
+    };
+}

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

@@ -0,0 +1,43 @@
+#include "AssetLoaderRawFile.h"
+
+#include <cstring>
+
+#include "Game/IW5/IW5.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW5;
+
+void* AssetLoaderRawFile::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* rawFile = memory->Create<RawFile>();
+    memset(rawFile, 0, sizeof(RawFile));
+    rawFile->name = memory->Dup(assetName.c_str());
+    return rawFile;
+}
+
+bool AssetLoaderRawFile::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool AssetLoaderRawFile::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;
+
+    auto* rawFile = memory->Create<RawFile>();
+    rawFile->name = memory->Dup(assetName.c_str());
+    rawFile->len = static_cast<int>(file.m_length);
+
+    auto* fileBuffer = static_cast<char*>(memory->Alloc(static_cast<size_t>(file.m_length + 1)));
+    file.m_stream->read(fileBuffer, file.m_length);
+    if (file.m_stream->gcount() != file.m_length)
+        return false;
+    fileBuffer[rawFile->len] = '\0';
+
+    rawFile->data.buffer = fileBuffer;
+    manager->AddAsset(ASSET_TYPE_RAWFILE, assetName, rawFile);
+
+    return true;
+}

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderRawFile.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "Game/IW5/IW5.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW5
+{
+    class AssetLoaderRawFile final : public BasicAssetLoader<ASSET_TYPE_RAWFILE, RawFile>
+    {
+    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;
+    };
+}

src/ObjLoading/Game/IW5/InfoString/InfoStringToStructConverter.cpp

@@ -0,0 +1,4 @@
+#include "InfoStringToStructConverter.h"
+
+using namespace IW5;
+

src/ObjLoading/Game/IW5/InfoString/InfoStringToStructConverter.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "InfoString/InfoStringToStructConverterBase.h"
+#include "Game/IW5/IW5.h"
+
+namespace IW5
+{
+    class InfoStringToStructConverter : public InfoStringToStructConverterBase
+    {
+    protected:
+        IAssetLoadingManager* m_loading_manager;
+        const cspField_t* m_fields;
+        size_t m_field_count;
+
+        static bool GetHashValue(const std::string& value, unsigned int& hash);
+
+        virtual bool ConvertExtensionField(const cspField_t& field, const std::string& value) = 0;
+        bool ConvertBaseField(const cspField_t& field, const std::string& value);
+
+    public:
+        InfoStringToStructConverter(const InfoString& infoString, void* structure, ZoneScriptStrings& zoneScriptStrings, MemoryManager* memory, IAssetLoadingManager* manager, const cspField_t* fields,
+            size_t fieldCount);
+        bool Convert() override;
+    };
+}

src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp

@@ -0,0 +1,193 @@
+#include "ObjLoaderIW5.h"
+
+#include "Game/IW5/GameIW5.h"
+#include "Game/IW5/GameAssetPoolIW5.h"
+#include "ObjContainer/IPak/IPak.h"
+#include "ObjLoading.h"
+#include "AssetLoaders/AssetLoaderLocalizeEntry.h"
+#include "AssetLoaders/AssetLoaderRawFile.h"
+#include "AssetLoading/AssetLoadingManager.h"
+#include "Image/Dx9TextureLoader.h"
+#include "Image/Texture.h"
+#include "Image/IwiLoader.h"
+#include "Image/IwiTypes.h"
+
+using namespace IW5;
+
+ObjLoader::ObjLoader()
+{
+#define REGISTER_ASSET_LOADER(t) {auto l = std::make_unique<t>(); m_asset_loaders_by_type[l->GetHandlingAssetType()] = std::move(l);}
+#define BASIC_LOADER(assetType, assetClass) BasicAssetLoader<assetType, assetClass>
+
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSPRESET, PhysPreset))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PHYSCOLLMAP, PhysCollmap))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XANIMPARTS, XAnimParts))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XMODEL_SURFS, XModelSurfs))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_XMODEL, XModel))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MATERIAL, Material))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PIXELSHADER, MaterialPixelShader))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VERTEXSHADER, MaterialVertexShader))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VERTEXDECL, MaterialVertexDeclaration))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMAGE, GfxImage))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND, snd_alias_list_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SOUND_CURVE, SndCurve))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LOADED_SOUND, LoadedSound))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_CLIPMAP, clipMap_t))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_COMWORLD, ComWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GLASSWORLD, GlassWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_PATHDATA, PathData))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VEHICLE_TRACK, VehicleTrack))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MAP_ENTS, MapEnts))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FXWORLD, FxWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GFXWORLD, GfxWorld))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LIGHT_DEF, GfxLightDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FONT, Font_s))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENULIST, MenuList))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENU, menuDef_t))
+    REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ATTACHMENT, WeaponAttachment))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON, WeaponCompleteDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FX, FxEffectDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_IMPACT_FX, FxImpactTable))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SURFACE_FX, SurfaceFxTable))
+    REGISTER_ASSET_LOADER(AssetLoaderRawFile)
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_SCRIPTFILE, ScriptFile))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_STRINGTABLE, StringTable))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LEADERBOARD, LeaderboardDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_STRUCTURED_DATA_DEF, StructuredDataDefSet))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_TRACER, TracerDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_VEHICLE, VehicleDef))
+    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ADDON_MAP_ENTS, AddonMapEnts))
+
+#undef BASIC_LOADER
+#undef REGISTER_ASSET_LOADER
+}
+
+bool ObjLoader::SupportsZone(Zone* zone) const
+{
+    return zone->m_game == &g_GameIW5;
+}
+
+bool ObjLoader::IsMpZone(Zone* zone)
+{
+    return zone->m_name.compare(0, 3, "mp_") == 0
+        || zone->m_name.compare(zone->m_name.length() - 3, 3, "_mp") == 0;
+}
+
+bool ObjLoader::IsZmZone(Zone* zone)
+{
+    return zone->m_name.compare(0, 3, "zm_") == 0
+        || zone->m_name.compare(zone->m_name.length() - 3, 3, "_zm") == 0;
+}
+
+void ObjLoader::LoadReferencedContainersForZone(ISearchPath* searchPath, Zone* zone) const
+{
+}
+
+void ObjLoader::UnloadContainersOfZone(Zone* zone) const
+{
+}
+
+void ObjLoader::LoadImageFromLoadDef(GfxImage* image, Zone* zone)
+{
+    const auto* loadDef = image->texture.loadDef;
+    Dx9TextureLoader textureLoader(zone->GetMemory());
+
+    textureLoader.Width(image->width).Height(image->height).Depth(image->depth);
+
+    if ((loadDef->flags & iwi8::IMG_FLAG_MAPTYPE_MASK) == iwi8::IMG_FLAG_MAPTYPE_3D)
+        textureLoader.Type(TextureType::T_3D);
+    else if ((loadDef->flags & iwi8::IMG_FLAG_MAPTYPE_MASK) == iwi8::IMG_FLAG_MAPTYPE_CUBE)
+        textureLoader.Type(TextureType::T_CUBE);
+    else
+        textureLoader.Type(TextureType::T_2D);
+
+    textureLoader.Format(static_cast<D3DFORMAT>(loadDef->format));
+    textureLoader.HasMipMaps(!(loadDef->flags & iwi8::IMG_FLAG_NOMIPMAPS));
+    Texture* loadedTexture = textureLoader.LoadTexture(image->texture.loadDef->data);
+
+    if (loadedTexture != nullptr)
+    {
+        image->texture.texture = loadedTexture;
+        image->cardMemory.platform[0] = 0;
+
+        const auto textureMipCount = loadedTexture->GetMipMapCount();
+        for (auto mipLevel = 0; mipLevel < textureMipCount; mipLevel++)
+            image->cardMemory.platform[0] += static_cast<int>(loadedTexture->GetSizeOfMipLevel(mipLevel) * loadedTexture->GetFaceCount());
+    }
+}
+
+void ObjLoader::LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone)
+{
+    Texture* loadedTexture = nullptr;
+    IwiLoader loader(zone->GetMemory());
+
+    const auto imageFileName = "images/" + std::string(image->name) + ".iwi";
+
+    {
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (filePathImage.IsOpen())
+        {
+            loadedTexture = loader.LoadIwi(*filePathImage.m_stream);
+        }
+    }
+
+    if (loadedTexture != nullptr)
+    {
+        image->texture.texture = loadedTexture;
+        image->cardMemory.platform[0] = 0;
+
+        const auto textureMipCount = loadedTexture->GetMipMapCount();
+        for (auto mipLevel = 0; mipLevel < textureMipCount; mipLevel++)
+            image->cardMemory.platform[0] += static_cast<int>(loadedTexture->GetSizeOfMipLevel(mipLevel) * loadedTexture->GetFaceCount());
+    }
+    else
+    {
+        printf("Could not find data for image \"%s\"\n", image->name);
+    }
+}
+
+void ObjLoader::LoadImageData(ISearchPath* searchPath, Zone* zone)
+{
+    auto* assetPool = dynamic_cast<GameAssetPoolIW5*>(zone->m_pools.get());
+
+    if (assetPool && assetPool->m_image != nullptr)
+    {
+        for (auto* imageEntry : *assetPool->m_image)
+        {
+            auto* image = imageEntry->Asset();
+
+            if (image->cardMemory.platform[0] > 0)
+            {
+                continue;
+            }
+
+            // Do not load linked assets
+            if (image->name && image->name[0] == ',')
+            {
+                continue;
+            }
+
+            if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            {
+                LoadImageFromLoadDef(image, zone);
+            }
+            else
+            {
+                LoadImageFromIwi(image, searchPath, zone);
+            }
+        }
+    }
+}
+
+void ObjLoader::LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const
+{
+    LoadImageData(searchPath, zone);
+}
+
+bool ObjLoader::LoadAssetForZone(AssetLoadingContext* context, asset_type_t assetType, const std::string& assetName) const
+{
+    AssetLoadingManager assetLoadingManager(m_asset_loaders_by_type, *context);
+    return assetLoadingManager.LoadAssetFromLoader(assetType, assetName);
+}

src/ObjLoading/Game/IW5/ObjLoaderIW5.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <unordered_map>
+#include <memory>
+
+#include "IObjLoader.h"
+#include "AssetLoading/IAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+#include "Game/IW5/IW5.h"
+
+namespace IW5
+{
+    class ObjLoader final : public IObjLoader
+    {
+        std::unordered_map<asset_type_t, std::unique_ptr<IAssetLoader>> m_asset_loaders_by_type;
+
+        static void LoadImageFromIwi(GfxImage* image, ISearchPath* searchPath, Zone* zone);
+        static void LoadImageFromLoadDef(GfxImage* image, Zone* zone);
+        static void LoadImageData(ISearchPath* searchPath, Zone* zone);
+
+        static bool IsMpZone(Zone* zone);
+        static bool IsZmZone(Zone* zone);
+
+    public:
+        ObjLoader();
+
+        bool SupportsZone(Zone* zone) const override;
+
+        void LoadReferencedContainersForZone(ISearchPath* searchPath, Zone* zone) const override;
+        void UnloadContainersOfZone(Zone* zone) const override;
+
+        void LoadObjDataForZone(ISearchPath* searchPath, Zone* zone) const override;
+
+        bool LoadAssetForZone(AssetLoadingContext* context, asset_type_t assetType, const std::string& assetName) const override;
+    };
+}

src/ObjLoading/ObjLoading.cpp

@@ -5,6 +5,7 @@
 #include "IObjLoader.h"
 #include "Game/IW3/ObjLoaderIW3.h"
 #include "Game/IW4/ObjLoaderIW4.h"
+#include "Game/IW5/ObjLoaderIW5.h"
 #include "Game/T5/ObjLoaderT5.h"
 #include "Game/T6/ObjLoaderT6.h"
 #include "ObjContainer/IWD/IWD.h"
@@ -17,6 +18,7 @@ const IObjLoader* const OBJ_LOADERS[]
 {
     new IW3::ObjLoader(),
     new IW4::ObjLoader(),
+    new IW5::ObjLoader(),
     new T5::ObjLoader(),
     new T6::ObjLoader()
 };