feat: convert from dds to iwi

src/ImageConverter/ImageConverter.cpp

@@ -1,11 +1,17 @@
 #include "ImageConverter.h"
 
+#include "Image/DdsLoader.h"
 #include "Image/DdsWriter.h"
 #include "Image/IwiLoader.h"
+#include "Image/IwiWriter13.h"
+#include "Image/IwiWriter27.h"
+#include "Image/IwiWriter6.h"
+#include "Image/IwiWriter8.h"
 #include "Image/Texture.h"
 #include "ImageConverterArgs.h"
 #include "Utils/StringUtils.h"
 
+#include <assert.h>
 #include <filesystem>
 #include <format>
 #include <fstream>
@@ -16,19 +22,7 @@ namespace fs = std::filesystem;
 namespace image_converter
 {
     constexpr auto EXTENSION_IWI = ".iwi";
-
-    class ImageLoader
-    {
-    public:
-        ImageLoader() = default;
-        virtual ~ImageLoader() = default;
-        ImageLoader(const ImageLoader& other) = default;
-        ImageLoader(ImageLoader&& other) noexcept = default;
-        ImageLoader& operator=(const ImageLoader& other) = default;
-        ImageLoader& operator=(ImageLoader&& other) noexcept = default;
-
-        // virtual Texture*
-    };
+    constexpr auto EXTENSION_DDS = ".dds";
 
     class ImageConverterImpl final : public ImageConverter
     {
@@ -63,14 +57,12 @@ namespace image_converter
             utils::MakeStringLowerCase(extension);
 
             if (extension == EXTENSION_IWI)
-            {
                 ConvertIwi(filePath);
-            }
+            else if (extension == EXTENSION_DDS)
+                ConvertDds(filePath);
             else
-            {
                 std::cerr << std::format("Unsupported extension {}\n", extension);
         }
-        }
 
         bool ConvertIwi(const fs::path& iwiPath)
         {
@@ -99,9 +91,108 @@ namespace image_converter
             return true;
         }
 
+        bool ConvertDds(const fs::path& ddsPath)
+        {
+            std::ifstream file(ddsPath, std::ios::in | std::ios::binary);
+            if (!file.is_open())
+            {
+                std::cerr << std::format("Failed to open input file {}\n", ddsPath.string());
+                return false;
+            }
+
+            const auto texture = dds::LoadDds(file);
+            if (!texture)
+                return false;
+
+            if (!EnsureIwiWriterIsPresent())
+                return false;
+
+            auto outPath = ddsPath;
+            outPath.replace_extension(".iwi");
+
+            std::ofstream outFile(outPath, std::ios::out | std::ios::binary);
+            if (!outFile.is_open())
+            {
+                std::cerr << std::format("Failed to open output file {}\n", outPath.string());
+                return false;
+            }
+
+            m_iwi_writer->DumpImage(outFile, texture.get());
+            return true;
+        }
+
+        bool EnsureIwiWriterIsPresent()
+        {
+            if (m_iwi_writer)
+                return true;
+
+            if (m_game_to_convert_to == Game::UNKNOWN && !ShowGameTui())
+                return false;
+
+            switch (m_game_to_convert_to)
+            {
+            case Game::IW3:
+                m_iwi_writer = std::make_unique<iwi6::IwiWriter>();
+                break;
+            case Game::IW4:
+            case Game::IW5:
+                m_iwi_writer = std::make_unique<iwi8::IwiWriter>();
+                break;
+            case Game::T5:
+                m_iwi_writer = std::make_unique<iwi13::IwiWriter>();
+                break;
+            case Game::T6:
+                m_iwi_writer = std::make_unique<iwi27::IwiWriter>();
+                break;
+            default:
+                assert(false);
+                return false;
+            }
+
+            return true;
+        }
+
+        bool ShowGameTui()
+        {
+            std::cout << "Select the game to convert to:\n";
+            std::cout << "  1 - Call Of Duty 4: Modern Warfare (IW3)\n";
+            std::cout << "  2 - Call Of Duty: Modern Warfare 2 (IW4)\n";
+            std::cout << "  3 - Call Of Duty: Modern Warfare 3 (IW5)\n";
+            std::cout << "  4 - Call Of Duty: Black Ops (T5)\n";
+            std::cout << "  5 - Call Of Duty: Black Ops 2 (T6)\n";
+
+            unsigned num;
+            std::cin >> num;
+
+            switch (num)
+            {
+            case 1:
+                m_game_to_convert_to = Game::IW3;
+                break;
+            case 2:
+                m_game_to_convert_to = Game::IW4;
+                break;
+            case 3:
+                m_game_to_convert_to = Game::IW5;
+                break;
+            case 4:
+                m_game_to_convert_to = Game::T5;
+                break;
+            case 5:
+                m_game_to_convert_to = Game::T6;
+                break;
+            default:
+                std::cerr << "Invalid input\n";
+                return false;
+            }
+
+            return true;
+        }
+
         ImageConverterArgs m_args;
         image_converter::Game m_game_to_convert_to;
         DdsWriter m_dds_writer;
+        std::unique_ptr<IImageWriter> m_iwi_writer;
     };
 } // namespace image_converter
 

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

@@ -40,12 +40,10 @@ bool AssetLoaderGfxImage::LoadFromRaw(
     if (!file.IsOpen())
         return false;
 
-    const DdsLoader ddsLoader(zone->GetMemory());
-    auto* texture = ddsLoader.LoadDds(*file.m_stream);
-
-    if (texture == nullptr)
+    const auto texture = dds::LoadDds(*file.m_stream);
+    if (!texture)
     {
-        std::cout << std::format("Failed to load dds file for image asset \"{}\"\n", assetName);
+        std::cerr << std::format("Failed to load dds file for image asset \"{}\"\n", assetName);
         return false;
     }
 

src/ObjLoading/Image/DdsLoader.cpp

@@ -4,13 +4,16 @@
 #include "Utils/ClassUtils.h"
 #include "Utils/FileUtils.h"
 
+#include <format>
 #include <iostream>
+#include <memory>
 
+namespace dds
+{
     class DdsLoaderInternal
     {
         static constexpr auto DDS_MAGIC = FileUtils::MakeMagic32('D', 'D', 'S', ' ');
 
-    MemoryManager* m_memory_manager;
         std::istream& m_stream;
 
         TextureType m_texture_type;
@@ -26,13 +29,13 @@ class DdsLoaderInternal
             m_stream.read(reinterpret_cast<char*>(&magic), sizeof(magic));
             if (m_stream.gcount() != sizeof(magic))
             {
-            std::cout << "Failed to read dds data\n";
+                std::cerr << "Failed to read dds data\n";
                 return false;
             }
 
             if (magic != DDS_MAGIC)
             {
-            std::cout << "Invalid magic for dds\n";
+                std::cerr << "Invalid magic for dds\n";
                 return false;
             }
 
@@ -45,7 +48,7 @@ class DdsLoaderInternal
             m_stream.read(reinterpret_cast<char*>(&headerDx10), sizeof(headerDx10));
             if (m_stream.gcount() != sizeof(headerDx10))
             {
-            std::cout << "Failed to read dds data\n";
+                std::cerr << "Failed to read dds data\n";
                 return false;
             }
 
@@ -66,7 +69,7 @@ class DdsLoaderInternal
             }
             else
             {
-            std::cout << "Unsupported dds resourceDimension " << headerDx10.resourceDimension << "\n";
+                std::cerr << std::format("Unsupported dds resourceDimension {}\n", static_cast<unsigned>(headerDx10.resourceDimension));
                 return false;
             }
 
@@ -79,7 +82,7 @@ class DdsLoaderInternal
                 }
             }
 
-        std::cout << "Unsupported dds dxgi format " << headerDx10.dxgiFormat << "\n";
+            std::cerr << std::format("Unsupported dds dxgi format {}\n", static_cast<unsigned>(headerDx10.dxgiFormat));
             return false;
         }
 
@@ -103,7 +106,7 @@ class DdsLoaderInternal
                 return ReadDxt10Header();
 
             default:
-            std::cout << "Unknown dds FourCC " << pf.dwFourCC << "\n";
+                std::cerr << std::format("Unknown dds FourCC {}\n", pf.dwFourCC);
                 return false;
             }
         }
@@ -154,8 +157,8 @@ class DdsLoaderInternal
                 }
             }
 
-        std::cout << "Failed to find dds pixel format: R=" << std::hex << pf.dwRBitMask << " G=" << std::hex << pf.dwGBitMask << " B=" << std::hex
-                  << pf.dwBBitMask << " A=" << std::hex << pf.dwABitMask << "\n";
+            std::cerr << std::format(
+                "Failed to find dds pixel format: R={:#x} G={:#x} B={:#x} A={:#x}\n", pf.dwRBitMask, pf.dwGBitMask, pf.dwBBitMask, pf.dwABitMask);
 
             return false;
         }
@@ -174,7 +177,7 @@ class DdsLoaderInternal
             m_stream.read(reinterpret_cast<char*>(&header), sizeof(header));
             if (m_stream.gcount() != sizeof(header))
             {
-            std::cout << "Failed to read dds data\n";
+                std::cerr << "Failed to read dds data\n";
                 return false;
             }
 
@@ -193,22 +196,22 @@ class DdsLoaderInternal
             return ReadPixelFormat(header.ddspf);
         }
 
-    _NODISCARD Texture* ReadTextureData() const
+        _NODISCARD std::unique_ptr<Texture> ReadTextureData() const
         {
-        Texture* result;
+            std::unique_ptr<Texture> result;
 
             switch (m_texture_type)
             {
             case TextureType::T_2D:
-            result = new Texture2D(m_format, m_width, m_height, m_has_mip_maps);
+                result = std::make_unique<Texture2D>(m_format, m_width, m_height, m_has_mip_maps);
                 break;
 
             case TextureType::T_3D:
-            result = new Texture3D(m_format, m_width, m_height, m_depth, m_has_mip_maps);
+                result = std::make_unique<Texture3D>(m_format, m_width, m_height, m_depth, m_has_mip_maps);
                 break;
 
             case TextureType::T_CUBE:
-            result = new TextureCube(m_format, m_width, m_height, m_has_mip_maps);
+                result = std::make_unique<TextureCube>(m_format, m_width, m_height, m_has_mip_maps);
                 break;
 
             default:
@@ -230,8 +233,7 @@ class DdsLoaderInternal
 
                     if (m_stream.gcount() != mipSize)
                     {
-                    std::cout << "Failed to read texture data from dds\n";
-                    delete result;
+                        std::cerr << "Failed to read texture data from dds\n";
                         return nullptr;
                     }
                 }
@@ -241,9 +243,8 @@ class DdsLoaderInternal
         }
 
     public:
-    DdsLoaderInternal(MemoryManager* memoryManager, std::istream& stream)
-        : m_memory_manager(memoryManager),
-          m_stream(stream),
+        explicit DdsLoaderInternal(std::istream& stream)
+            : m_stream(stream),
               m_texture_type(TextureType::T_2D),
               m_has_mip_maps(false),
               m_width(0u),
@@ -253,24 +254,18 @@ public:
         {
         }
 
-    Texture* LoadDds()
+        std::unique_ptr<Texture> LoadDds()
         {
             if (!ReadMagic() || !ReadHeader())
-        {
                 return nullptr;
-        }
 
             return ReadTextureData();
         }
     };
 
-DdsLoader::DdsLoader(MemoryManager* memoryManager)
-    : m_memory_manager(memoryManager)
+    std::unique_ptr<Texture> LoadDds(std::istream& stream)
     {
-}
-
-Texture* DdsLoader::LoadDds(std::istream& stream) const
-{
-    DdsLoaderInternal internal(m_memory_manager, stream);
+        DdsLoaderInternal internal(stream);
         return internal.LoadDds();
     }
+} // namespace dds

src/ObjLoading/Image/DdsLoader.h

@@ -1,16 +1,10 @@
 #pragma once
 
 #include "Image/Texture.h"
-#include "Utils/MemoryManager.h"
 
 #include <istream>
 
-class DdsLoader
+namespace dds
 {
-    MemoryManager* m_memory_manager;
-
-public:
-    explicit DdsLoader(MemoryManager* memoryManager);
-
-    Texture* LoadDds(std::istream& stream) const;
-};
+    std::unique_ptr<Texture> LoadDds(std::istream& stream);
+}