ZoneLoading: Add dumping for Rawfile based assets

src/ZoneLoading/Dumping/AbstractAssetDumper.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "IAssetDumper.h"
+#include "Utils/FileAPI.h"
+#include "Utils/PathUtils.h"
+
+#include <cstdio>
+
+template<class T>
+class AbstractAssetDumper : public IAssetDumper<T>
+{
+protected:
+    virtual std::string GetFileNameForAsset(T* asset) = 0;
+    virtual void DumpAsset(T* asset, FileAPI::File* out) = 0;
+
+public:
+    void DumpPool(AssetPool<T>* pool, const std::string& basePath) override
+    {
+        for(auto assetInfo : *pool)
+        {
+            std::string assetFilePath = utils::Path::Combine(basePath, GetFileNameForAsset(assetInfo->m_asset));
+
+            FileAPI::DirectoryCreate(utils::Path::GetDirectory(assetFilePath));
+
+            auto file = FileAPI::Open(assetFilePath, FileAPI::Mode::MODE_WRITE);
+
+            if(file.IsOpen())
+            {
+                DumpAsset(assetInfo->m_asset, &file);
+
+                file.Close();
+            }
+            else
+            {
+                printf("Failed to open file '%s' to dump asset '%s'\n", assetFilePath.c_str(), assetInfo->m_name.c_str());
+            }
+        }
+    }
+};

src/ZoneLoading/Dumping/IAssetDumper.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Pool/AssetPool.h"
+
+template<class T>
+class IAssetDumper
+{
+public:
+    virtual ~IAssetDumper() = default;
+
+    virtual void DumpPool(AssetPool<T>* pool, const std::string& basePath) = 0;
+};

src/ZoneLoading/Dumping/IZoneDumper.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Zone/Zone.h"
+
+class IZoneDumper
+{
+public:
+    virtual ~IZoneDumper() = default;
+
+    virtual bool CanDumpZone(Zone* zone) = 0;
+    virtual bool DumpZone(Zone* zone, const std::string& basePath) = 0;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperKeyValuePairs.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperKeyValuePairs.h"
+
+using namespace T6;
+
+std::string AssetDumperKeyValuePairs::GetFileNameForAsset(KeyValuePairs* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperKeyValuePairs::DumpAsset(KeyValuePairs* asset, FileAPI::File* out)
+{
+    // TODO
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperKeyValuePairs.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperKeyValuePairs final : public AbstractAssetDumper<T6::KeyValuePairs>
+{
+protected:
+    std::string GetFileNameForAsset(T6::KeyValuePairs* asset) override;
+    void DumpAsset(T6::KeyValuePairs* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperLocalizeEntry.cpp

@@ -0,0 +1,8 @@
+#include "AssetDumperLocalizeEntry.h"
+
+using namespace T6;
+
+void AssetDumperLocalizeEntry::DumpPool(AssetPool<T6::LocalizeEntry>* pool, const std::string& basePath)
+{
+    // TODO: Add a dumping method that dumps all localized strings to a .str file and not in separate files.
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperLocalizeEntry.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperLocalizeEntry final : public IAssetDumper<T6::LocalizeEntry>
+{
+public:
+    void DumpPool(AssetPool<T6::LocalizeEntry>* pool, const std::string& basePath) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperQdb.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperQdb.h"
+
+using namespace T6;
+
+std::string AssetDumperQdb::GetFileNameForAsset(Qdb* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperQdb::DumpAsset(Qdb* asset, FileAPI::File* out)
+{
+    out->Write(asset->buffer, 1, asset->len);
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperQdb.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperQdb final : public AbstractAssetDumper<T6::Qdb>
+{
+protected:
+    std::string GetFileNameForAsset(T6::Qdb* asset) override;
+    void DumpAsset(T6::Qdb* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperRawFile.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperRawFile.h"
+
+using namespace T6;
+
+std::string AssetDumperRawFile::GetFileNameForAsset(RawFile* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperRawFile::DumpAsset(RawFile* asset, FileAPI::File* out)
+{
+    out->Write(asset->buffer, 1, asset->len);
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperRawFile.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperRawFile final : public AbstractAssetDumper<T6::RawFile>
+{
+protected:
+    std::string GetFileNameForAsset(T6::RawFile* asset) override;
+    void DumpAsset(T6::RawFile* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperScriptParseTree.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperScriptParseTree.h"
+
+using namespace T6;
+
+std::string AssetDumperScriptParseTree::GetFileNameForAsset(ScriptParseTree* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperScriptParseTree::DumpAsset(ScriptParseTree* asset, FileAPI::File* out)
+{
+    out->Write(asset->buffer, 1, asset->len);
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperScriptParseTree.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperScriptParseTree final : public AbstractAssetDumper<T6::ScriptParseTree>
+{
+protected:
+    std::string GetFileNameForAsset(T6::ScriptParseTree* asset) override;
+    void DumpAsset(T6::ScriptParseTree* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperSlug.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperSlug.h"
+
+using namespace T6;
+
+std::string AssetDumperSlug::GetFileNameForAsset(Slug* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperSlug::DumpAsset(Slug* asset, FileAPI::File* out)
+{
+    out->Write(asset->buffer, 1, asset->len);
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperSlug.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperSlug final : public AbstractAssetDumper<T6::Slug>
+{
+protected:
+    std::string GetFileNameForAsset(T6::Slug* asset) override;
+    void DumpAsset(T6::Slug* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperStringTable.cpp

@@ -0,0 +1,13 @@
+#include "AssetDumperStringTable.h"
+
+using namespace T6;
+
+std::string AssetDumperStringTable::GetFileNameForAsset(StringTable* asset)
+{
+    return std::string(asset->name);
+}
+
+void AssetDumperStringTable::DumpAsset(StringTable* asset, FileAPI::File* out)
+{
+    // TODO
+}

src/ZoneLoading/Game/T6/AssetDumpers/AssetDumperStringTable.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Dumping/AbstractAssetDumper.h"
+#include "Game/T6/T6.h"
+
+class AssetDumperStringTable final : public AbstractAssetDumper<T6::StringTable>
+{
+protected:
+    std::string GetFileNameForAsset(T6::StringTable* asset) override;
+    void DumpAsset(T6::StringTable* asset, FileAPI::File* out) override;
+};

src/ZoneLoading/Game/T6/ZoneDumperT6.cpp

@@ -0,0 +1,78 @@
+#include "ZoneDumperT6.h"
+#include "Game/T6/GameT6.h"
+#include "Game/T6/GameAssetPoolT6.h"
+
+#include "AssetDumpers/AssetDumperRawFile.h"
+#include "AssetDumpers/AssetDumperSlug.h"
+#include "AssetDumpers/AssetDumperQdb.h"
+#include "AssetDumpers/AssetDumperScriptParseTree.h"
+
+bool ZoneDumperT6::CanDumpZone(Zone* zone)
+{
+    return zone->m_game == &game_t6;
+}
+
+bool ZoneDumperT6::DumpZone(Zone* zone, const std::string& basePath)
+{
+#define DUMP_ASSET_POOL(dumperType, poolName) \
+    if(assetPools->poolName) \
+    { \
+        dumperType dumper; \
+        dumper.DumpPool(assetPools->poolName, basePath); \
+    }
+
+    const auto assetPools = dynamic_cast<GameAssetPoolT6*>(zone->GetPools());
+
+    // DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset);
+    // DUMP_ASSET_POOL(AssetDumperPhysConstraints, m_phys_constraints);
+    // DUMP_ASSET_POOL(AssetDumperDestructibleDef, m_destructible_def);
+    // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts);
+    // DUMP_ASSET_POOL(AssetDumperXModel, m_xmodel);
+    // DUMP_ASSET_POOL(AssetDumperMaterial, m_material);
+    // DUMP_ASSET_POOL(AssetDumperTechniqueSet, m_technique_set);
+    // DUMP_ASSET_POOL(AssetDumperGfxImage, m_image);
+    // DUMP_ASSET_POOL(AssetDumperSndBank, m_sound_bank);
+    // DUMP_ASSET_POOL(AssetDumperSndPatch, m_sound_patch);
+    // DUMP_ASSET_POOL(AssetDumperClipMap, m_clip_map);
+    // DUMP_ASSET_POOL(AssetDumperComWorld, m_com_world);
+    // DUMP_ASSET_POOL(AssetDumperGameWorldSp, m_game_world_sp);
+    // DUMP_ASSET_POOL(AssetDumperGameWorldMp, m_game_world_mp);
+    // DUMP_ASSET_POOL(AssetDumperMapEnts, m_map_ents);
+    // DUMP_ASSET_POOL(AssetDumperGfxWorld, m_gfx_world);
+    // DUMP_ASSET_POOL(AssetDumperGfxLightDef, m_gfx_light_def);
+    // DUMP_ASSET_POOL(AssetDumperFont, m_font);
+    // DUMP_ASSET_POOL(AssetDumperFontIcon, m_font_icon);
+    // DUMP_ASSET_POOL(AssetDumperMenuList, m_menu_list);
+    // DUMP_ASSET_POOL(AssetDumperMenuDef, m_menu_def);
+    // DUMP_ASSET_POOL(AssetDumperLocalizeEntry, m_localize);
+    // DUMP_ASSET_POOL(AssetDumperWeaponVariantDef, m_weapon);
+    // DUMP_ASSET_POOL(AssetDumperWeaponAttachment, m_attachment);
+    // DUMP_ASSET_POOL(AssetDumperWeaponAttachmentUnique, m_attachment_unique);
+    // DUMP_ASSET_POOL(AssetDumperWeaponCamo, m_camo);
+    // DUMP_ASSET_POOL(AssetDumperSndDriverGlobals, m_snd_driver_globals);
+    // DUMP_ASSET_POOL(AssetDumperFxEffectDef, m_fx);
+    // DUMP_ASSET_POOL(AssetDumperFxImpactTable, m_fx_impact_table);
+    DUMP_ASSET_POOL(AssetDumperRawFile, m_raw_file);
+    // DUMP_ASSET_POOL(AssetDumperStringTable, m_string_table);
+    // DUMP_ASSET_POOL(AssetDumperLeaderboardDef, m_leaderboard);
+    // DUMP_ASSET_POOL(AssetDumperXGlobals, m_xglobals);
+    // DUMP_ASSET_POOL(AssetDumperDDLRoot, m_ddl);
+    // DUMP_ASSET_POOL(AssetDumperGlasses, m_glasses);
+    // DUMP_ASSET_POOL(AssetDumperEmblemSet, m_emblem_set);
+    DUMP_ASSET_POOL(AssetDumperScriptParseTree, m_script);
+    // DUMP_ASSET_POOL(AssetDumperKeyValuePairs, m_key_value_pairs);
+    // DUMP_ASSET_POOL(AssetDumperVehicleDef, m_vehicle);
+    // DUMP_ASSET_POOL(AssetDumperMemoryBlock, m_memory_block);
+    // DUMP_ASSET_POOL(AssetDumperAddonMapEnts, m_addon_map_ents);
+    // DUMP_ASSET_POOL(AssetDumperTracerDef, m_tracer);
+    // DUMP_ASSET_POOL(AssetDumperSkinnedVertsDef, m_skinned_verts);
+    DUMP_ASSET_POOL(AssetDumperQdb, m_qdb);
+    DUMP_ASSET_POOL(AssetDumperSlug, m_slug);
+    // DUMP_ASSET_POOL(AssetDumperFootstepTableDef, m_footstep_table);
+    // DUMP_ASSET_POOL(AssetDumperFootstepFXTableDef, m_footstep_fx_table);
+    // DUMP_ASSET_POOL(AssetDumperZBarrierDef, m_zbarrier);
+
+    return true;
+
+#undef DUMP_ASSET_POOL
+}

src/ZoneLoading/Game/T6/ZoneDumperT6.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Dumping/IZoneDumper.h"
+
+class ZoneDumperT6 final : public IZoneDumper
+{
+public:
+    bool CanDumpZone(Zone* zone) override;
+    bool DumpZone(Zone* zone, const std::string& basePath) override;
+};

src/ZoneLoading/ZoneLoading.cpp

@@ -1,12 +1,20 @@
 #include "ZoneLoading.h"
-#include "Game/T6/ZoneLoaderFactoryT6.h"
 #include "Utils/PathUtils.h"
+#include "Dumping/IZoneDumper.h"
+
+#include "Game/T6/ZoneLoaderFactoryT6.h"
+#include "Game/T6/ZoneDumperT6.h"
 
 IZoneLoaderFactory* zoneLoaderFactories[]
 {
     new ZoneLoaderFactoryT6()
 };
 
+IZoneDumper* zoneDumper[]
+{
+    new ZoneDumperT6()
+};
+
 Zone* ZoneLoading::LoadZone(const std::string& path)
 {
     std::string zoneName = utils::Path::GetFilenameWithoutExtension(path);
@@ -44,10 +52,24 @@ Zone* ZoneLoading::LoadZone(const std::string& path)
 
 bool ZoneLoading::DumpZone(Zone* zone, const std::string& basePath)
 {
-    return true;
+    for(auto dumper : zoneDumper)
+    {
+        if(dumper->CanDumpZone(zone))
+        {
+            if(dumper->DumpZone(zone, basePath))
+            {
+                return true;
+            }
+
+            printf("Dumper for zone '%s' failed!\n", zone->m_name.c_str());
+            return false;
+        }
+    }
+
+    return false;
 }
 
 bool ZoneLoading::WriteZoneDefinition(Zone* zone, FileAPI::File* file, bool minimalistic)
 {
-    return true;
+    return file->Printf("// %s", "Insert zone definition here") > 0;
 }