refactor: image and obj data loading

src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperGfxImage.cpp

@@ -1,13 +1,63 @@
 #include "AssetDumperGfxImage.h"
 
 #include "Image/DdsWriter.h"
+#include "Image/Dx9TextureLoader.h"
+#include "Image/IwiLoader.h"
+#include "Image/IwiTypes.h"
 #include "Image/IwiWriter6.h"
+#include "Image/Texture.h"
 #include "ObjWriting.h"
+#include "SearchPath/ISearchPath.h"
 
+#include <algorithm>
 #include <cassert>
+#include <format>
 
 using namespace IW3;
 
+namespace
+{
+    std::unique_ptr<Texture> LoadImageFromLoadDef(const GfxImage* image)
+    {
+        Dx9TextureLoader textureLoader;
+
+        const auto& loadDef = *image->texture.loadDef;
+        textureLoader.Width(loadDef.dimensions[0]).Height(loadDef.dimensions[1]).Depth(loadDef.dimensions[2]);
+
+        if (loadDef.flags & iwi6::IMG_FLAG_VOLMAP)
+            textureLoader.Type(TextureType::T_3D);
+        else if (loadDef.flags & iwi6::IMG_FLAG_CUBEMAP)
+            textureLoader.Type(TextureType::T_CUBE);
+        else
+            textureLoader.Type(TextureType::T_2D);
+
+        textureLoader.Format(static_cast<oat::D3DFORMAT>(loadDef.format));
+        textureLoader.HasMipMaps(!(loadDef.flags & iwi6::IMG_FLAG_NOMIPMAPS));
+        return textureLoader.LoadTexture(loadDef.data);
+    }
+
+    std::unique_ptr<Texture> LoadImageFromIwi(const GfxImage* image, ISearchPath* searchPath)
+    {
+        const auto imageFileName = std::format("images/{}.iwi", image->name);
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (!filePathImage.IsOpen())
+        {
+            std::cerr << std::format("Could not find data for image \"{}\"\n", image->name);
+            return nullptr;
+        }
+
+        return iwi::LoadIwi(*filePathImage.m_stream);
+    }
+
+    std::unique_ptr<Texture> LoadImageData(ISearchPath* searchPath, const GfxImage* image)
+    {
+        if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            return LoadImageFromLoadDef(image);
+
+        return LoadImageFromIwi(image, searchPath);
+    }
+} // namespace
+
 AssetDumperGfxImage::AssetDumperGfxImage()
 {
     switch (ObjWriting::Configuration.ImageOutputFormat)
@@ -27,37 +77,29 @@ AssetDumperGfxImage::AssetDumperGfxImage()
 
 bool AssetDumperGfxImage::ShouldDump(XAssetInfo<GfxImage>* asset)
 {
-    const auto* image = asset->Asset();
-    return image->cardMemory.platform[0] > 0;
+    return true;
 }
 
-std::string AssetDumperGfxImage::GetAssetFileName(XAssetInfo<GfxImage>* asset) const
+std::string AssetDumperGfxImage::GetAssetFileName(const XAssetInfo<GfxImage>& asset) const
 {
-    std::string cleanAssetName = asset->m_name;
-    for (auto& c : cleanAssetName)
-    {
-        switch (c)
-        {
-        case '*':
-            c = '_';
-            break;
+    auto cleanAssetName = asset.m_name;
+    std::ranges::replace(cleanAssetName, '*', '_');
 
-        default:
-            break;
-        }
-    }
-
-    return "images/" + cleanAssetName + m_writer->GetFileExtension();
+    return std::format("images/{}{}", cleanAssetName, m_writer->GetFileExtension());
 }
 
 void AssetDumperGfxImage::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
 {
     const auto* image = asset->Asset();
-    const auto assetFile = context.OpenAssetFile(GetAssetFileName(asset));
+    const auto texture = LoadImageData(context.m_obj_search_path, image);
+    if (!texture)
+        return;
+
+    const auto assetFile = context.OpenAssetFile(GetAssetFileName(*asset));
 
     if (!assetFile)
         return;
 
     auto& stream = *assetFile;
-    m_writer->DumpImage(stream, image->texture.texture);
+    m_writer->DumpImage(stream, texture.get());
 }

src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperGfxImage.h

@@ -12,7 +12,7 @@ namespace IW3
     {
         std::unique_ptr<IImageWriter> m_writer;
 
-        std::string GetAssetFileName(XAssetInfo<GfxImage>* asset) const;
+        [[nodiscard]] std::string GetAssetFileName(const XAssetInfo<GfxImage>& asset) const;
 
     protected:
         bool ShouldDump(XAssetInfo<GfxImage>* asset) override;

src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperGfxImage.cpp

@@ -1,13 +1,60 @@
 #include "AssetDumperGfxImage.h"
 
 #include "Image/DdsWriter.h"
+#include "Image/Dx9TextureLoader.h"
+#include "Image/IwiLoader.h"
 #include "Image/IwiWriter8.h"
 #include "ObjWriting.h"
 
+#include <algorithm>
 #include <cassert>
+#include <format>
 
 using namespace IW4;
 
+namespace
+{
+    std::unique_ptr<Texture> LoadImageFromLoadDef(const GfxImage* image)
+    {
+        Dx9TextureLoader textureLoader;
+
+        const auto& loadDef = *image->texture.loadDef;
+        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<oat::D3DFORMAT>(loadDef.format));
+        textureLoader.HasMipMaps(!(loadDef.flags & iwi8::IMG_FLAG_NOMIPMAPS));
+        return textureLoader.LoadTexture(loadDef.data);
+    }
+
+    std::unique_ptr<Texture> LoadImageFromIwi(const GfxImage* image, ISearchPath* searchPath)
+    {
+        const auto imageFileName = std::format("images/{}.iwi", image->name);
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (!filePathImage.IsOpen())
+        {
+            std::cerr << std::format("Could not find data for image \"{}\"\n", image->name);
+            return nullptr;
+        }
+
+        return iwi::LoadIwi(*filePathImage.m_stream);
+    }
+
+    std::unique_ptr<Texture> LoadImageData(ISearchPath* searchPath, const GfxImage* image)
+    {
+        if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            return LoadImageFromLoadDef(image);
+
+        return LoadImageFromIwi(image, searchPath);
+    }
+} // namespace
+
 AssetDumperGfxImage::AssetDumperGfxImage()
 {
     switch (ObjWriting::Configuration.ImageOutputFormat)
@@ -27,37 +74,29 @@ AssetDumperGfxImage::AssetDumperGfxImage()
 
 bool AssetDumperGfxImage::ShouldDump(XAssetInfo<GfxImage>* asset)
 {
-    const auto* image = asset->Asset();
-    return image->cardMemory.platform[0] > 0;
+    return true;
 }
 
-std::string AssetDumperGfxImage::GetAssetFileName(XAssetInfo<GfxImage>* asset) const
+std::string AssetDumperGfxImage::GetAssetFileName(const XAssetInfo<GfxImage>& asset) const
 {
-    std::string cleanAssetName = asset->m_name;
-    for (auto& c : cleanAssetName)
-    {
-        switch (c)
-        {
-        case '*':
-            c = '_';
-            break;
+    auto cleanAssetName = asset.m_name;
+    std::ranges::replace(cleanAssetName, '*', '_');
 
-        default:
-            break;
-        }
-    }
-
-    return "images/" + cleanAssetName + m_writer->GetFileExtension();
+    return std::format("images/{}{}", cleanAssetName, m_writer->GetFileExtension());
 }
 
 void AssetDumperGfxImage::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
 {
     const auto* image = asset->Asset();
-    const auto assetFile = context.OpenAssetFile(GetAssetFileName(asset));
+    const auto texture = LoadImageData(context.m_obj_search_path, image);
+    if (!texture)
+        return;
+
+    const auto assetFile = context.OpenAssetFile(GetAssetFileName(*asset));
 
     if (!assetFile)
         return;
 
     auto& stream = *assetFile;
-    m_writer->DumpImage(stream, image->texture.texture);
+    m_writer->DumpImage(stream, texture.get());
 }

src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperGfxImage.h

@@ -12,7 +12,7 @@ namespace IW4
     {
         std::unique_ptr<IImageWriter> m_writer;
 
-        std::string GetAssetFileName(XAssetInfo<GfxImage>* asset) const;
+        [[nodiscard]] std::string GetAssetFileName(const XAssetInfo<GfxImage>& asset) const;
 
     protected:
         bool ShouldDump(XAssetInfo<GfxImage>* asset) override;

src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperGfxImage.cpp

@@ -1,13 +1,61 @@
 #include "AssetDumperGfxImage.h"
 
 #include "Image/DdsWriter.h"
+#include "Image/Dx9TextureLoader.h"
+#include "Image/IwiLoader.h"
 #include "Image/IwiWriter8.h"
 #include "ObjWriting.h"
 
+#include <algorithm>
 #include <cassert>
+#include <format>
 
 using namespace IW5;
 
+namespace
+{
+    std::unique_ptr<Texture> LoadImageFromLoadDef(const GfxImage* image)
+    {
+        Dx9TextureLoader textureLoader;
+
+        const auto& loadDef = *image->texture.loadDef;
+
+        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<oat::D3DFORMAT>(loadDef.format));
+        textureLoader.HasMipMaps(!(loadDef.flags & iwi8::IMG_FLAG_NOMIPMAPS));
+        return textureLoader.LoadTexture(loadDef.data);
+    }
+
+    std::unique_ptr<Texture> LoadImageFromIwi(const GfxImage* image, ISearchPath* searchPath)
+    {
+        const auto imageFileName = std::format("images/{}.iwi", image->name);
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (!filePathImage.IsOpen())
+        {
+            std::cerr << std::format("Could not find data for image \"{}\"\n", image->name);
+            return nullptr;
+        }
+
+        return iwi::LoadIwi(*filePathImage.m_stream);
+    }
+
+    std::unique_ptr<Texture> LoadImageData(ISearchPath* searchPath, const GfxImage* image)
+    {
+        if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            return LoadImageFromLoadDef(image);
+
+        return LoadImageFromIwi(image, searchPath);
+    }
+} // namespace
+
 AssetDumperGfxImage::AssetDumperGfxImage()
 {
     switch (ObjWriting::Configuration.ImageOutputFormat)
@@ -27,37 +75,29 @@ AssetDumperGfxImage::AssetDumperGfxImage()
 
 bool AssetDumperGfxImage::ShouldDump(XAssetInfo<GfxImage>* asset)
 {
-    const auto* image = asset->Asset();
-    return image->cardMemory.platform[0] > 0;
+    return true;
 }
 
-std::string AssetDumperGfxImage::GetAssetFileName(XAssetInfo<GfxImage>* asset) const
+std::string AssetDumperGfxImage::GetAssetFileName(const XAssetInfo<GfxImage>& asset) const
 {
-    std::string cleanAssetName = asset->m_name;
-    for (auto& c : cleanAssetName)
-    {
-        switch (c)
-        {
-        case '*':
-            c = '_';
-            break;
+    auto cleanAssetName = asset.m_name;
+    std::ranges::replace(cleanAssetName, '*', '_');
 
-        default:
-            break;
-        }
-    }
-
-    return "images/" + cleanAssetName + m_writer->GetFileExtension();
+    return std::format("images/{}{}", cleanAssetName, m_writer->GetFileExtension());
 }
 
 void AssetDumperGfxImage::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
 {
     const auto* image = asset->Asset();
-    const auto assetFile = context.OpenAssetFile(GetAssetFileName(asset));
+    const auto texture = LoadImageData(context.m_obj_search_path, image);
+    if (!texture)
+        return;
+
+    const auto assetFile = context.OpenAssetFile(GetAssetFileName(*asset));
 
     if (!assetFile)
         return;
 
     auto& stream = *assetFile;
-    m_writer->DumpImage(stream, image->texture.texture);
+    m_writer->DumpImage(stream, texture.get());
 }

src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperGfxImage.h

@@ -12,7 +12,7 @@ namespace IW5
     {
         std::unique_ptr<IImageWriter> m_writer;
 
-        std::string GetAssetFileName(XAssetInfo<GfxImage>* asset) const;
+        [[nodiscard]] std::string GetAssetFileName(const XAssetInfo<GfxImage>& asset) const;
 
     protected:
         bool ShouldDump(XAssetInfo<GfxImage>* asset) override;

src/ObjWriting/Game/T5/AssetDumpers/AssetDumperGfxImage.cpp

@@ -1,13 +1,60 @@
 #include "AssetDumperGfxImage.h"
 
 #include "Image/DdsWriter.h"
-#include "Image/IwiWriter27.h"
+#include "Image/Dx9TextureLoader.h"
+#include "Image/IwiLoader.h"
+#include "Image/IwiWriter13.h"
 #include "ObjWriting.h"
 
+#include <algorithm>
 #include <cassert>
+#include <format>
 
 using namespace T5;
 
+namespace
+{
+    std::unique_ptr<Texture> LoadImageFromLoadDef(const GfxImage* image)
+    {
+        Dx9TextureLoader textureLoader;
+
+        const auto& loadDef = *image->texture.loadDef;
+        textureLoader.Width(image->width).Height(image->height).Depth(image->depth);
+
+        if (loadDef.flags & iwi13::IMG_FLAG_VOLMAP)
+            textureLoader.Type(TextureType::T_3D);
+        else if (loadDef.flags & iwi13::IMG_FLAG_CUBEMAP)
+            textureLoader.Type(TextureType::T_CUBE);
+        else
+            textureLoader.Type(TextureType::T_2D);
+
+        textureLoader.Format(static_cast<oat::D3DFORMAT>(loadDef.format));
+        textureLoader.HasMipMaps(!(loadDef.flags & iwi13::IMG_FLAG_NOMIPMAPS));
+        return textureLoader.LoadTexture(loadDef.data);
+    }
+
+    std::unique_ptr<Texture> LoadImageFromIwi(const GfxImage* image, ISearchPath* searchPath)
+    {
+        const auto imageFileName = std::format("images/{}.iwi", image->name);
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (!filePathImage.IsOpen())
+        {
+            std::cerr << std::format("Could not find data for image \"{}\"\n", image->name);
+            return nullptr;
+        }
+
+        return iwi::LoadIwi(*filePathImage.m_stream);
+    }
+
+    std::unique_ptr<Texture> LoadImageData(ISearchPath* searchPath, const GfxImage* image)
+    {
+        if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            return LoadImageFromLoadDef(image);
+
+        return LoadImageFromIwi(image, searchPath);
+    }
+} // namespace
+
 AssetDumperGfxImage::AssetDumperGfxImage()
 {
     switch (ObjWriting::Configuration.ImageOutputFormat)
@@ -16,7 +63,7 @@ AssetDumperGfxImage::AssetDumperGfxImage()
         m_writer = std::make_unique<DdsWriter>();
         break;
     case ObjWriting::Configuration_t::ImageOutputFormat_e::IWI:
-        m_writer = std::make_unique<iwi27::IwiWriter>();
+        m_writer = std::make_unique<iwi13::IwiWriter>();
         break;
     default:
         assert(false);
@@ -27,37 +74,29 @@ AssetDumperGfxImage::AssetDumperGfxImage()
 
 bool AssetDumperGfxImage::ShouldDump(XAssetInfo<GfxImage>* asset)
 {
-    const auto* image = asset->Asset();
-    return image->loadedSize > 0;
+    return true;
 }
 
-std::string AssetDumperGfxImage::GetAssetFileName(XAssetInfo<GfxImage>* asset) const
+std::string AssetDumperGfxImage::GetAssetFileName(const XAssetInfo<GfxImage>& asset) const
 {
-    std::string cleanAssetName = asset->m_name;
-    for (auto& c : cleanAssetName)
-    {
-        switch (c)
-        {
-        case '*':
-            c = '_';
-            break;
+    auto cleanAssetName = asset.m_name;
+    std::ranges::replace(cleanAssetName, '*', '_');
 
-        default:
-            break;
-        }
-    }
-
-    return "images/" + cleanAssetName + m_writer->GetFileExtension();
+    return std::format("images/{}{}", cleanAssetName, m_writer->GetFileExtension());
 }
 
 void AssetDumperGfxImage::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
 {
     const auto* image = asset->Asset();
-    const auto assetFile = context.OpenAssetFile(GetAssetFileName(asset));
+    const auto texture = LoadImageData(context.m_obj_search_path, image);
+    if (!texture)
+        return;
+
+    const auto assetFile = context.OpenAssetFile(GetAssetFileName(*asset));
 
     if (!assetFile)
         return;
 
     auto& stream = *assetFile;
-    m_writer->DumpImage(stream, image->texture.texture);
+    m_writer->DumpImage(stream, texture.get());
 }

src/ObjWriting/Game/T5/AssetDumpers/AssetDumperGfxImage.h

@@ -12,7 +12,7 @@ namespace T5
     {
         std::unique_ptr<IImageWriter> m_writer;
 
-        std::string GetAssetFileName(XAssetInfo<GfxImage>* asset) const;
+        [[nodiscard]] std::string GetAssetFileName(const XAssetInfo<GfxImage>& asset) const;
 
     protected:
         bool ShouldDump(XAssetInfo<GfxImage>* asset) override;

src/ObjWriting/Game/T6/AssetDumpers/AssetDumperGfxImage.cpp

@@ -1,13 +1,78 @@
 #include "AssetDumperGfxImage.h"
 
 #include "Image/DdsWriter.h"
+#include "Image/Dx12TextureLoader.h"
+#include "Image/IwiLoader.h"
 #include "Image/IwiWriter27.h"
+#include "ObjContainer/IPak/IPak.h"
 #include "ObjWriting.h"
 
+#include <algorithm>
 #include <cassert>
+#include <format>
 
 using namespace T6;
 
+namespace
+{
+    std::unique_ptr<Texture> LoadImageFromLoadDef(const GfxImage* image)
+    {
+        Dx12TextureLoader textureLoader;
+
+        const auto& loadDef = *image->texture.loadDef;
+        textureLoader.Width(image->width).Height(image->height).Depth(image->depth);
+
+        if (loadDef.flags & iwi27::IMG_FLAG_VOLMAP)
+            textureLoader.Type(TextureType::T_3D);
+        else if (loadDef.flags & iwi27::IMG_FLAG_CUBEMAP)
+            textureLoader.Type(TextureType::T_CUBE);
+        else
+            textureLoader.Type(TextureType::T_2D);
+
+        textureLoader.Format(static_cast<oat::DXGI_FORMAT>(loadDef.format));
+        textureLoader.HasMipMaps(!(loadDef.flags & iwi27::IMG_FLAG_NOMIPMAPS));
+        return textureLoader.LoadTexture(loadDef.data);
+    }
+
+    std::unique_ptr<Texture> LoadImageFromIwi(const GfxImage* image, ISearchPath* searchPath)
+    {
+        if (image->streamedPartCount > 0)
+        {
+            for (auto* ipak : IPak::Repository)
+            {
+                auto ipakStream = ipak->GetEntryStream(image->hash, image->streamedParts[0].hash);
+
+                if (ipakStream)
+                {
+                    auto loadedTexture = iwi::LoadIwi(*ipakStream);
+                    ipakStream->close();
+
+                    if (loadedTexture != nullptr)
+                        return loadedTexture;
+                }
+            }
+        }
+
+        const auto imageFileName = std::format("images/{}.iwi", image->name);
+        const auto filePathImage = searchPath->Open(imageFileName);
+        if (!filePathImage.IsOpen())
+        {
+            std::cerr << std::format("Could not find data for image \"{}\"\n", image->name);
+            return nullptr;
+        }
+
+        return iwi::LoadIwi(*filePathImage.m_stream);
+    }
+
+    std::unique_ptr<Texture> LoadImageData(ISearchPath* searchPath, const GfxImage* image)
+    {
+        if (image->texture.loadDef && image->texture.loadDef->resourceSize > 0)
+            return LoadImageFromLoadDef(image);
+
+        return LoadImageFromIwi(image, searchPath);
+    }
+} // namespace
+
 AssetDumperGfxImage::AssetDumperGfxImage()
 {
     switch (ObjWriting::Configuration.ImageOutputFormat)
@@ -27,37 +92,29 @@ AssetDumperGfxImage::AssetDumperGfxImage()
 
 bool AssetDumperGfxImage::ShouldDump(XAssetInfo<GfxImage>* asset)
 {
-    const auto* image = asset->Asset();
-    return image->loadedSize > 0;
+    return true;
 }
 
-std::string AssetDumperGfxImage::GetAssetFileName(XAssetInfo<GfxImage>* asset) const
+std::string AssetDumperGfxImage::GetAssetFileName(const XAssetInfo<GfxImage>& asset) const
 {
-    std::string cleanAssetName = asset->m_name;
-    for (auto& c : cleanAssetName)
-    {
-        switch (c)
-        {
-        case '*':
-            c = '_';
-            break;
+    auto cleanAssetName = asset.m_name;
+    std::ranges::replace(cleanAssetName, '*', '_');
 
-        default:
-            break;
-        }
-    }
-
-    return "images/" + cleanAssetName + m_writer->GetFileExtension();
+    return std::format("images/{}{}", cleanAssetName, m_writer->GetFileExtension());
 }
 
 void AssetDumperGfxImage::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
 {
     const auto* image = asset->Asset();
-    const auto assetFile = context.OpenAssetFile(GetAssetFileName(asset));
+    const auto texture = LoadImageData(context.m_obj_search_path, image);
+    if (!texture)
+        return;
+
+    const auto assetFile = context.OpenAssetFile(GetAssetFileName(*asset));
 
     if (!assetFile)
         return;
 
     auto& stream = *assetFile;
-    m_writer->DumpImage(stream, image->texture.texture);
+    m_writer->DumpImage(stream, texture.get());
 }

src/ObjWriting/Game/T6/AssetDumpers/AssetDumperGfxImage.h

@@ -12,7 +12,7 @@ namespace T6
     {
         std::unique_ptr<IImageWriter> m_writer;
 
-        std::string GetAssetFileName(XAssetInfo<GfxImage>* asset) const;
+        std::string GetAssetFileName(const XAssetInfo<GfxImage>& asset) const;
 
     protected:
         bool ShouldDump(XAssetInfo<GfxImage>* asset) override;