chore: consider specified obj containers when post processing

src/Linker/ZoneCreation/ZoneCreator.cpp

@@ -64,8 +64,9 @@ namespace zone_creator
         const auto* objLoader = IObjLoader::GetObjLoaderForGame(gameId);
 
         AssetCreatorCollection creatorCollection(*zone);
+        ZoneDefinitionContext zoneDefinitionContext(*context.m_definition);
         objCompiler->ConfigureCreatorCollection(
-            creatorCollection, *zone, *context.m_definition, *context.m_asset_search_path, lookup, context.m_out_dir, context.m_cache_dir);
+            creatorCollection, *zone, zoneDefinitionContext, *context.m_asset_search_path, lookup, context.m_out_dir, context.m_cache_dir);
         objLoader->ConfigureCreatorCollection(creatorCollection, *zone, *context.m_asset_search_path, lookup);
 
         AssetCreationContext creationContext(zone.get(), &creatorCollection, &ignoredAssetLookup);
@@ -76,6 +77,8 @@ namespace zone_creator
 
             if (!createdAsset)
                 return nullptr;
+
+            ++zoneDefinitionContext.m_asset_index_in_definition;
         }
 
         creatorCollection.FinalizeZone(creationContext);

src/ObjCompiling/Game/IW3/ObjCompilerIW3.cpp

@@ -17,21 +17,23 @@ namespace
         // No compilers yet
     }
 
-    void ConfigurePostProcessors(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, const fs::path& outDir)
+    void ConfigurePostProcessors(
+        AssetCreatorCollection& collection, Zone& zone, const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const fs::path& outDir)
     {
         auto& memory = *zone.GetMemory();
 
-        collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(searchPath, outDir));
+        if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
     }
 } // namespace
 
 void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              Zone& zone,
-                                             const ZoneDefinition& zoneDefinition,
+                                             const ZoneDefinitionContext& zoneDefinition,
                                              ISearchPath& searchPath,
                                              IGdtQueryable& gdt,
                                              const fs::path& outDir,
                                              const fs::path& cacheDir) const
 {
-    ConfigurePostProcessors(collection, zone, searchPath, outDir);
+    ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, outDir);
 }

src/ObjCompiling/Game/IW3/ObjCompilerIW3.h

@@ -9,7 +9,7 @@ namespace IW3
     public:
         void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                         Zone& zone,
-                                        const ZoneDefinition& zoneDefinition,
+                                        const ZoneDefinitionContext& zoneDefinition,
                                         ISearchPath& searchPath,
                                         IGdtQueryable& gdt,
                                         const std::filesystem::path& outDir,

src/ObjCompiling/Game/IW4/ObjCompilerIW4.cpp

@@ -17,21 +17,23 @@ namespace
         // No compilers yet
     }
 
-    void ConfigurePostProcessors(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, const fs::path& outDir)
+    void ConfigurePostProcessors(
+        AssetCreatorCollection& collection, Zone& zone, const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const fs::path& outDir)
     {
         auto& memory = *zone.GetMemory();
 
-        collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(searchPath, outDir));
+        if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
     }
 } // namespace
 
 void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              Zone& zone,
-                                             const ZoneDefinition& zoneDefinition,
+                                             const ZoneDefinitionContext& zoneDefinition,
                                              ISearchPath& searchPath,
                                              IGdtQueryable& gdt,
                                              const fs::path& outDir,
                                              const fs::path& cacheDir) const
 {
-    ConfigurePostProcessors(collection, zone, searchPath, outDir);
+    ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, outDir);
 }

src/ObjCompiling/Game/IW4/ObjCompilerIW4.h

@@ -9,7 +9,7 @@ namespace IW4
     public:
         void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                         Zone& zone,
-                                        const ZoneDefinition& zoneDefinition,
+                                        const ZoneDefinitionContext& zoneDefinition,
                                         ISearchPath& searchPath,
                                         IGdtQueryable& gdt,
                                         const std::filesystem::path& outDir,

src/ObjCompiling/Game/IW5/ObjCompilerIW5.cpp

@@ -17,21 +17,23 @@ namespace
         // No compilers yet
     }
 
-    void ConfigurePostProcessors(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, const fs::path& outDir)
+    void ConfigurePostProcessors(
+        AssetCreatorCollection& collection, Zone& zone, const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const fs::path& outDir)
     {
         auto& memory = *zone.GetMemory();
 
-        collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(searchPath, outDir));
+        if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
     }
 } // namespace
 
 void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              Zone& zone,
-                                             const ZoneDefinition& zoneDefinition,
+                                             const ZoneDefinitionContext& zoneDefinition,
                                              ISearchPath& searchPath,
                                              IGdtQueryable& gdt,
                                              const fs::path& outDir,
                                              const fs::path& cacheDir) const
 {
-    ConfigurePostProcessors(collection, zone, searchPath, outDir);
+    ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, outDir);
 }

src/ObjCompiling/Game/IW5/ObjCompilerIW5.h

@@ -9,7 +9,7 @@ namespace IW5
     public:
         void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                         Zone& zone,
-                                        const ZoneDefinition& zoneDefinition,
+                                        const ZoneDefinitionContext& zoneDefinition,
                                         ISearchPath& searchPath,
                                         IGdtQueryable& gdt,
                                         const std::filesystem::path& outDir,

src/ObjCompiling/Game/T5/ObjCompilerT5.cpp

@@ -17,21 +17,23 @@ namespace
         // No compilers yet
     }
 
-    void ConfigurePostProcessors(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, const fs::path& outDir)
+    void ConfigurePostProcessors(
+        AssetCreatorCollection& collection, Zone& zone, const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const fs::path& outDir)
     {
         auto& memory = *zone.GetMemory();
 
-        collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(searchPath, outDir));
+        if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
     }
 } // namespace
 
 void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              Zone& zone,
-                                             const ZoneDefinition& zoneDefinition,
+                                             const ZoneDefinitionContext& zoneDefinition,
                                              ISearchPath& searchPath,
                                              IGdtQueryable& gdt,
                                              const fs::path& outDir,
                                              const fs::path& cacheDir) const
 {
-    ConfigurePostProcessors(collection, zone, searchPath, outDir);
+    ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, outDir);
 }

src/ObjCompiling/Game/T5/ObjCompilerT5.h

@@ -9,7 +9,7 @@ namespace T5
     public:
         void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                         Zone& zone,
-                                        const ZoneDefinition& zoneDefinition,
+                                        const ZoneDefinitionContext& zoneDefinition,
                                         ISearchPath& searchPath,
                                         IGdtQueryable& gdt,
                                         const std::filesystem::path& outDir,

src/ObjCompiling/Game/T6/ObjCompilerT6.cpp

@@ -1,6 +1,7 @@
 #include "ObjCompilerT6.h"
 
 #include "Game/T6/T6.h"
+#include "Image/ImageIPakPostProcessor.h"
 #include "Image/ImageIwdPostProcessor.h"
 
 #include <memory>
@@ -17,21 +18,26 @@ namespace
         // No compilers yet
     }
 
-    void ConfigurePostProcessors(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, const fs::path& outDir)
+    void ConfigurePostProcessors(
+        AssetCreatorCollection& collection, Zone& zone, const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const fs::path& outDir)
     {
         auto& memory = *zone.GetMemory();
 
-        collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(searchPath, outDir));
+        if (ImageIPakPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIPakPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
+
+        if (ImageIwdPostProcessor<AssetImage>::AppliesToZoneDefinition(zoneDefinition))
+            collection.AddAssetPostProcessor(std::make_unique<ImageIwdPostProcessor<AssetImage>>(zoneDefinition, searchPath, outDir));
     }
 } // namespace
 
 void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              Zone& zone,
-                                             const ZoneDefinition& zoneDefinition,
+                                             const ZoneDefinitionContext& zoneDefinition,
                                              ISearchPath& searchPath,
                                              IGdtQueryable& gdt,
                                              const fs::path& outDir,
                                              const fs::path& cacheDir) const
 {
-    ConfigurePostProcessors(collection, zone, searchPath, outDir);
+    ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, outDir);
 }

src/ObjCompiling/Game/T6/ObjCompilerT6.h

@@ -9,7 +9,7 @@ namespace T6
     public:
         void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                         Zone& zone,
-                                        const ZoneDefinition& zoneDefinition,
+                                        const ZoneDefinitionContext& zoneDefinition,
                                         ISearchPath& searchPath,
                                         IGdtQueryable& gdt,
                                         const std::filesystem::path& outDir,

src/ObjCompiling/IObjCompiler.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Asset/AssetCreatorCollection.h"
+#include "Asset/ZoneDefinitionContext.h"
 #include "Gdt/IGdtQueryable.h"
 #include "SearchPath/ISearchPath.h"
 #include "Zone/Definition/ZoneDefinition.h"
@@ -22,7 +23,7 @@ public:
 
     virtual void ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                             Zone& zone,
-                                            const ZoneDefinition& zoneDefinition,
+                                            const ZoneDefinitionContext& zoneDefinition,
                                             ISearchPath& searchPath,
                                             IGdtQueryable& gdt,
                                             const std::filesystem::path& outDir,

src/ObjCompiling/Image/IPak/IPakCreator.cpp

@@ -3,15 +3,39 @@
 #include <format>
 #include <iostream>
 
-void IPakCreator::AddImage(std::string imageName)
+IPakToCreate::IPakToCreate(std::string name)
+    : m_name(std::move(name))
+{
+}
+
+void IPakToCreate::AddImage(std::string imageName)
 {
     m_image_names.emplace_back(std::move(imageName));
 }
 
-void IPakCreator::Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath)
+void IPakToCreate::Build(ISearchPath& searchPath, const std::filesystem::path& outPath)
 {
-    std::cout << std::format("Creating ipak with {} entries:\n", m_image_names.size());
+    std::cout << std::format("Creating ipak {} with {} entries:\n", m_name, m_image_names.size());
 
     for (const auto& imageName : m_image_names)
         std::cout << std::format("  {}\n", imageName);
 }
+
+IPakToCreate* IPakCreator::GetOrAddIPak(const std::string& ipakName)
+{
+    const auto existingIPak = m_ipak_lookup.find(ipakName);
+    if (existingIPak != m_ipak_lookup.end())
+        return existingIPak->second;
+
+    auto newIPak = std::make_unique<IPakToCreate>(ipakName);
+    auto* result = newIPak.get();
+    m_ipaks.emplace_back(std::move(newIPak));
+
+    return result;
+}
+
+void IPakCreator::Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath)
+{
+    for (const auto& ipakToCreate : m_ipaks)
+        ipakToCreate->Build(searchPath, outPath);
+}

src/ObjCompiling/Image/IPak/IPakCreator.h

@@ -4,13 +4,30 @@
 #include "SearchPath/ISearchPath.h"
 
 #include <filesystem>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+class IPakToCreate
+{
+public:
+    explicit IPakToCreate(std::string name);
+
+    void AddImage(std::string imageName);
+    void Build(ISearchPath& searchPath, const std::filesystem::path& outPath);
+
+private:
+    std::string m_name;
+    std::vector<std::string> m_image_names;
+};
 
 class IPakCreator : public IZoneAssetLoaderState
 {
 public:
-    void AddImage(std::string imageName);
+    IPakToCreate* GetOrAddIPak(const std::string& ipakName);
     void Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath);
 
 private:
-    std::vector<std::string> m_image_names;
+    std::unordered_map<std::string, IPakToCreate*> m_ipak_lookup;
+    std::vector<std::unique_ptr<IPakToCreate>> m_ipaks;
 };

src/ObjCompiling/Image/ImageIPakPostProcessor.cpp

@@ -4,19 +4,68 @@
 
 #include <format>
 
-AbstractImageIPakPostProcessor::AbstractImageIPakPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir)
+AbstractImageIPakPostProcessor::AbstractImageIPakPostProcessor(const ZoneDefinitionContext& zoneDefinition,
-    : m_search_path(searchPath),
+                                                               ISearchPath& searchPath,
-      m_out_dir(outDir)
+                                                               const std::filesystem::path& outDir)
+    : m_zone_definition(zoneDefinition),
+      m_search_path(searchPath),
+      m_out_dir(outDir),
+      m_initialized(false),
+      m_obj_container_index(0u),
+      m_current_ipak(nullptr),
+      m_current_ipak_start_index(0u),
+      m_current_ipak_end_index(0u)
 {
 }
 
+bool AbstractImageIPakPostProcessor::AppliesToZoneDefinition(const ZoneDefinitionContext& zoneDefinition)
+{
+    for (const auto& objContainer : zoneDefinition.m_zone_definition.m_obj_containers)
+    {
+        if (objContainer.m_type == ZoneDefinitionObjContainerType::IPAK)
+            return true;
+    }
+
+    return false;
+}
+
+void AbstractImageIPakPostProcessor::FindNextObjContainer(AssetCreationContext& context)
+{
+    const auto objContainerCount = m_zone_definition.m_zone_definition.m_obj_containers.size();
+    while (m_obj_container_index < objContainerCount)
+    {
+        const auto& objContainer = m_zone_definition.m_zone_definition.m_obj_containers[m_obj_container_index++];
+
+        if (objContainer.m_type != ZoneDefinitionObjContainerType::IPAK)
+            continue;
+
+        auto* ipakCreator = context.GetZoneAssetLoaderState<IPakCreator>();
+        m_current_ipak = ipakCreator->GetOrAddIPak(objContainer.m_name);
+        m_current_ipak_start_index = objContainer.m_asset_start;
+        m_current_ipak_end_index = objContainer.m_asset_end;
+        return;
+    }
+
+    m_current_ipak = nullptr;
+}
+
 void AbstractImageIPakPostProcessor::PostProcessAsset(XAssetInfoGeneric& assetInfo, AssetCreationContext& context)
 {
     if (assetInfo.m_name.empty() || assetInfo.m_name[0] == ',')
         return;
 
-    auto* ipakCreator = context.GetZoneAssetLoaderState<IPakCreator>();
+    // Initialize on first image occurance
-    ipakCreator->AddImage(assetInfo.m_name);
+    if (!m_initialized)
+    {
+        FindNextObjContainer(context);
+        m_initialized = true;
+    }
+
+    while (m_current_ipak && m_zone_definition.m_asset_index_in_definition >= m_current_ipak_end_index)
+        FindNextObjContainer(context);
+
+    if (m_current_ipak && m_zone_definition.m_asset_index_in_definition <= m_current_ipak_start_index)
+        m_current_ipak->AddImage(assetInfo.m_name);
 }
 
 void AbstractImageIPakPostProcessor::FinalizeZone(AssetCreationContext& context)

src/ObjCompiling/Image/ImageIPakPostProcessor.h

@@ -1,20 +1,33 @@
 #pragma once
 
 #include "Asset/IAssetPostProcessor.h"
+#include "Asset/ZoneDefinitionContext.h"
+#include "Image/IPak/IPakCreator.h"
 
 #include <filesystem>
 
 class AbstractImageIPakPostProcessor : public IAssetPostProcessor
 {
 public:
-    AbstractImageIPakPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir);
+    AbstractImageIPakPostProcessor(const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const std::filesystem::path& outDir);
+
+    static bool AppliesToZoneDefinition(const ZoneDefinitionContext& zoneDefinition);
 
     void PostProcessAsset(XAssetInfoGeneric& assetInfo, AssetCreationContext& context) override;
     void FinalizeZone(AssetCreationContext& context) override;
 
 private:
+    void FindNextObjContainer(AssetCreationContext& context);
+
+    const ZoneDefinitionContext& m_zone_definition;
     ISearchPath& m_search_path;
     const std::filesystem::path& m_out_dir;
+
+    bool m_initialized;
+    unsigned m_obj_container_index;
+    IPakToCreate* m_current_ipak;
+    unsigned m_current_ipak_start_index;
+    unsigned m_current_ipak_end_index;
 };
 
 template<typename AssetType> class ImageIPakPostProcessor final : public AbstractImageIPakPostProcessor
@@ -22,8 +35,8 @@ template<typename AssetType> class ImageIPakPostProcessor final : public Abstrac
 public:
     static_assert(std::is_base_of_v<IAssetBase, AssetType>);
 
-    ImageIPakPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir)
+    ImageIPakPostProcessor(const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const std::filesystem::path& outDir)
-        : AbstractImageIPakPostProcessor(searchPath, outDir)
+        : AbstractImageIPakPostProcessor(zoneDefinition, searchPath, outDir)
     {
     }
 

src/ObjCompiling/Image/ImageIwdPostProcessor.cpp

@@ -3,20 +3,70 @@
 #include "Iwd/IwdCreator.h"
 
 #include <format>
+#include <iostream>
 
-AbstractImageIwdPostProcessor::AbstractImageIwdPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir)
+AbstractImageIwdPostProcessor::AbstractImageIwdPostProcessor(const ZoneDefinitionContext& zoneDefinition,
-    : m_search_path(searchPath),
+                                                             ISearchPath& searchPath,
-      m_out_dir(outDir)
+                                                             const std::filesystem::path& outDir)
+    : m_zone_definition(zoneDefinition),
+      m_search_path(searchPath),
+      m_out_dir(outDir),
+      m_initialized(false),
+      m_obj_container_index(0u),
+      m_current_iwd(nullptr),
+      m_current_iwd_start_index(0u),
+      m_current_iwd_end_index(0u)
 {
 }
 
+bool AbstractImageIwdPostProcessor::AppliesToZoneDefinition(const ZoneDefinitionContext& zoneDefinition)
+{
+    for (const auto& objContainer : zoneDefinition.m_zone_definition.m_obj_containers)
+    {
+        if (objContainer.m_type == ZoneDefinitionObjContainerType::IWD)
+            return true;
+    }
+
+    return false;
+}
+
+void AbstractImageIwdPostProcessor::FindNextObjContainer(AssetCreationContext& context)
+{
+    const auto objContainerCount = m_zone_definition.m_zone_definition.m_obj_containers.size();
+    while (m_obj_container_index < objContainerCount)
+    {
+        const auto& objContainer = m_zone_definition.m_zone_definition.m_obj_containers[m_obj_container_index++];
+
+        if (objContainer.m_type != ZoneDefinitionObjContainerType::IWD)
+            continue;
+
+        auto* iwdCreator = context.GetZoneAssetLoaderState<IwdCreator>();
+        m_current_iwd = iwdCreator->GetOrAddIwd(objContainer.m_name);
+        m_current_iwd_start_index = objContainer.m_asset_start;
+        m_current_iwd_end_index = objContainer.m_asset_end;
+        return;
+    }
+
+    m_current_iwd = nullptr;
+}
+
 void AbstractImageIwdPostProcessor::PostProcessAsset(XAssetInfoGeneric& assetInfo, AssetCreationContext& context)
 {
     if (assetInfo.m_name.empty() || assetInfo.m_name[0] == ',')
         return;
 
-    auto* iwdCreator = context.GetZoneAssetLoaderState<IwdCreator>();
+    // Initialize on first image occurance
-    iwdCreator->AddFile(std::format("images/{}.iwi", assetInfo.m_name));
+    if (!m_initialized)
+    {
+        FindNextObjContainer(context);
+        m_initialized = true;
+    }
+
+    while (m_current_iwd && m_zone_definition.m_asset_index_in_definition >= m_current_iwd_end_index)
+        FindNextObjContainer(context);
+
+    if (m_current_iwd && m_zone_definition.m_asset_index_in_definition <= m_current_iwd_start_index)
+        m_current_iwd->AddFile(std::format("images/{}.iwi", assetInfo.m_name));
 }
 
 void AbstractImageIwdPostProcessor::FinalizeZone(AssetCreationContext& context)

src/ObjCompiling/Image/ImageIwdPostProcessor.h

@@ -1,20 +1,33 @@
 #pragma once
 
 #include "Asset/IAssetPostProcessor.h"
+#include "Asset/ZoneDefinitionContext.h"
+#include "Iwd/IwdCreator.h"
 
 #include <filesystem>
 
 class AbstractImageIwdPostProcessor : public IAssetPostProcessor
 {
 public:
-    AbstractImageIwdPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir);
+    AbstractImageIwdPostProcessor(const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const std::filesystem::path& outDir);
+
+    static bool AppliesToZoneDefinition(const ZoneDefinitionContext& zoneDefinition);
 
     void PostProcessAsset(XAssetInfoGeneric& assetInfo, AssetCreationContext& context) override;
     void FinalizeZone(AssetCreationContext& context) override;
 
 private:
+    void FindNextObjContainer(AssetCreationContext& context);
+
+    const ZoneDefinitionContext& m_zone_definition;
     ISearchPath& m_search_path;
     const std::filesystem::path& m_out_dir;
+
+    bool m_initialized;
+    unsigned m_obj_container_index;
+    IwdToCreate* m_current_iwd;
+    unsigned m_current_iwd_start_index;
+    unsigned m_current_iwd_end_index;
 };
 
 template<typename AssetType> class ImageIwdPostProcessor final : public AbstractImageIwdPostProcessor
@@ -22,8 +35,8 @@ template<typename AssetType> class ImageIwdPostProcessor final : public Abstract
 public:
     static_assert(std::is_base_of_v<IAssetBase, AssetType>);
 
-    ImageIwdPostProcessor(ISearchPath& searchPath, const std::filesystem::path& outDir)
+    ImageIwdPostProcessor(const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, const std::filesystem::path& outDir)
-        : AbstractImageIwdPostProcessor(searchPath, outDir)
+        : AbstractImageIwdPostProcessor(zoneDefinition, searchPath, outDir)
     {
     }
 

src/ObjCompiling/Iwd/IwdCreator.cpp

@@ -1,17 +1,43 @@
 #include "IwdCreator.h"
 
+#include "Utils/FileToZlibWrapper.h"
+
 #include <format>
 #include <iostream>
 
-void IwdCreator::AddFile(std::string filePath)
+IwdToCreate::IwdToCreate(std::string name)
+    : m_name(std::move(name))
+{
+}
+
+void IwdToCreate::AddFile(std::string filePath)
 {
     m_file_paths.emplace_back(std::move(filePath));
 }
 
-void IwdCreator::Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath)
+void IwdToCreate::Build(ISearchPath& searchPath, const std::filesystem::path& outPath)
 {
-    std::cout << std::format("Creating iwd with {} entries:\n", m_file_paths.size());
+    std::cout << std::format("Creating iwd {} with {} entries:\n", m_name, m_file_paths.size());
 
     for (const auto& filePath : m_file_paths)
         std::cout << std::format("  {}\n", filePath);
 }
+
+IwdToCreate* IwdCreator::GetOrAddIwd(const std::string& iwdName)
+{
+    const auto existingIwd = m_iwd_lookup.find(iwdName);
+    if (existingIwd != m_iwd_lookup.end())
+        return existingIwd->second;
+
+    auto newIwd = std::make_unique<IwdToCreate>(iwdName);
+    auto* result = newIwd.get();
+    m_iwds.emplace_back(std::move(newIwd));
+
+    return result;
+}
+
+void IwdCreator::Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath)
+{
+    for (const auto& iwdToCreate : m_iwds)
+        iwdToCreate->Build(searchPath, outPath);
+}

src/ObjCompiling/Iwd/IwdCreator.h

@@ -4,13 +4,30 @@
 #include "SearchPath/ISearchPath.h"
 
 #include <filesystem>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+class IwdToCreate
+{
+public:
+    explicit IwdToCreate(std::string name);
+
+    void AddFile(std::string filePath);
+    void Build(ISearchPath& searchPath, const std::filesystem::path& outPath);
+
+private:
+    std::string m_name;
+    std::vector<std::string> m_file_paths;
+};
 
 class IwdCreator : public IZoneAssetLoaderState
 {
 public:
-    void AddFile(std::string filePath);
+    IwdToCreate* GetOrAddIwd(const std::string& iwdName);
     void Finalize(ISearchPath& searchPath, const std::filesystem::path& outPath);
 
 private:
-    std::vector<std::string> m_file_paths;
+    std::unordered_map<std::string, IwdToCreate*> m_iwd_lookup;
+    std::vector<std::unique_ptr<IwdToCreate>> m_iwds;
 };

src/ObjLoading/Asset/ZoneDefinitionContext.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Zone/Definition/ZoneDefinition.h"
+
+class ZoneDefinitionContext
+{
+public:
+    ZoneDefinitionContext(const ZoneDefinition& zoneDefinition)
+        : m_zone_definition(zoneDefinition),
+          m_asset_index_in_definition(0u)
+    {
+    }
+
+    const ZoneDefinition& m_zone_definition;
+    unsigned m_asset_index_in_definition;
+};