zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-10-19 04:55:19 +00:00
Code Activity

feat: report on unlinking progress

Browse Source
This commit is contained in:
Jan Laupetin
2025-10-14 23:20:56 +01:00
parent 9fa41ca0d3
commit c6e9cbedda
159 changed files with 686 additions and 802 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ModMan/Context/FastFileContext.cpp
View File

@@ -12,10 +12,10 @@ namespace
{ {
constexpr double MIN_PROGRESS_TO_REPORT = 0.005; constexpr double MIN_PROGRESS_TO_REPORT = 0.005;
class EventProgressReporter : public ProgressCallback class LoadingEventProgressReporter : public ProgressCallback
{ {
public: public:
explicit EventProgressReporter(std::string zoneName) explicit LoadingEventProgressReporter(std::string zoneName)
: m_zone_name(std::move(zoneName)), : m_zone_name(std::move(zoneName)),
m_last_progress(0) m_last_progress(0)
{ {
@@ -46,7 +46,7 @@ void FastFileContext::Destroy()
result::Expected<Zone*, std::string> FastFileContext::LoadFastFile(const std::string& path) result::Expected<Zone*, std::string> FastFileContext::LoadFastFile(const std::string& path)
{ {
auto zone = ZoneLoading::LoadZone(path, std::make_unique<EventProgressReporter>(fs::path(path).filename().replace_extension().string())); auto zone = ZoneLoading::LoadZone(path, std::make_unique<LoadingEventProgressReporter>(fs::path(path).filename().replace_extension().string()));
if (!zone) if (!zone)
return result::Unexpected(std::move(zone.error())); return result::Unexpected(std::move(zone.error()));

45
src/ModMan/Web/Binds/UnlinkingBinds.cpp
View File

@@ -14,22 +14,41 @@ namespace fs = std::filesystem;
namespace namespace
{ {
class ZoneLoadedDto class ZoneUnlinkProgressDto
{ {
public: public:
std::string zoneName; std::string zoneName;
std::string filePath; double percentage;
}; };
NLOHMANN_DEFINE_TYPE_EXTENSION(ZoneLoadedDto, zoneName, filePath); NLOHMANN_DEFINE_TYPE_EXTENSION(ZoneUnlinkProgressDto, zoneName, percentage);
class ZoneUnloadedDto constexpr double MIN_PROGRESS_TO_REPORT = 0.005;
class UnlinkingEventProgressReporter : public ProgressCallback
{ {
public: public:
std::string zoneName; explicit UnlinkingEventProgressReporter(std::string zoneName)
}; : m_zone_name(std::move(zoneName)),
m_last_progress(0)
{
}
NLOHMANN_DEFINE_TYPE_EXTENSION(ZoneUnloadedDto, zoneName); void OnProgress(const size_t current, const size_t total) override
{
const double percentage = static_cast<double>(current) / static_cast<double>(total);
if (percentage - m_last_progress >= MIN_PROGRESS_TO_REPORT)
{
m_last_progress = percentage;
ui::NotifyZoneUnlinkProgress(m_zone_name, percentage);
}
}
private:
std::string m_zone_name;
double m_last_progress;
};
result::Expected<NoResult, std::string> UnlinkZoneInDbThread(const std::string& zoneName) result::Expected<NoResult, std::string> UnlinkZoneInDbThread(const std::string& zoneName)
{ {
@@ -52,7 +71,8 @@ namespace
OutputPathFilesystem outputFolderOutputPath(outputFolderPath); OutputPathFilesystem outputFolderOutputPath(outputFolderPath);
SearchPaths searchPaths; SearchPaths searchPaths;
AssetDumpingContext dumpingContext(zone, outputFolderPathStr, outputFolderOutputPath, searchPaths); AssetDumpingContext dumpingContext(
zone, outputFolderPathStr, outputFolderOutputPath, searchPaths, std::make_unique<UnlinkingEventProgressReporter>(zoneName));
objWriter->DumpZone(dumpingContext); objWriter->DumpZone(dumpingContext);
return NoResult(); return NoResult();
@@ -81,6 +101,15 @@ namespace
namespace ui namespace ui
{ {
void NotifyZoneUnlinkProgress(std::string zoneName, const double percentage)
{
const ZoneUnlinkProgressDto dto{
.zoneName = std::move(zoneName),
.percentage = percentage,
};
Notify(*ModManContext::Get().m_main_webview, "zoneUnlinkProgress", dto);
}
void RegisterUnlinkingBinds(webview::webview& wv) void RegisterUnlinkingBinds(webview::webview& wv)
{ {
BindAsync<std::string>(wv, BindAsync<std::string>(wv,

2
src/ModMan/Web/Binds/UnlinkingBinds.h
View File

@@ -4,5 +4,7 @@
namespace ui namespace ui
{ {
void NotifyZoneUnlinkProgress(std::string zoneName, double percentage);
void RegisterUnlinkingBinds(webview::webview& wv); void RegisterUnlinkingBinds(webview::webview& wv);
} // namespace ui } // namespace ui

6
src/ModManUi/src/App.vue
View File

@@ -76,9 +76,13 @@ function onUnloadClicked(zoneName: string) {
} }
webviewAddEventListener("zoneLoadProgress", (dto) => { webviewAddEventListener("zoneLoadProgress", (dto) => {
console.log(dto);
lastPercentage.value = dto.percentage; lastPercentage.value = dto.percentage;
}); });
webviewAddEventListener("zoneUnlinkProgress", (dto) => {
lastPercentage.value = dto.percentage;
console.log("unlink", dto);
});
</script> </script>
<template> <template>

9
src/ModManUi/src/native/UnlinkingBinds.ts
View File

@@ -1,3 +1,12 @@
export interface ZoneUnlinkProgressDto {
zoneName: string;
percentage: number;
}
export interface UnlinkingBinds { export interface UnlinkingBinds {
unlinkZone(zoneName: string): Promise<void>; unlinkZone(zoneName: string): Promise<void>;
} }
export interface UnlinkingEventMap {
zoneUnlinkProgress: ZoneUnlinkProgressDto;
}

4
src/ModManUi/src/native/index.ts
View File

@@ -1,10 +1,10 @@
import type { DialogBinds } from "./DialogBinds"; import type { DialogBinds } from "./DialogBinds";
import type { UnlinkingBinds } from "./UnlinkingBinds"; import type { UnlinkingBinds, UnlinkingEventMap } from "./UnlinkingBinds";
import type { ZoneBinds, ZoneEventMap } from "./ZoneBinds"; import type { ZoneBinds, ZoneEventMap } from "./ZoneBinds";
export type NativeMethods = DialogBinds & UnlinkingBinds & ZoneBinds; export type NativeMethods = DialogBinds & UnlinkingBinds & ZoneBinds;
type NativeEventMap = ZoneEventMap; type NativeEventMap = UnlinkingEventMap & ZoneEventMap;
type WebViewExtensions = { type WebViewExtensions = {
webviewBinds: NativeMethods; webviewBinds: NativeMethods;

39
src/ObjWriting/Dumping/AbstractAssetDumper.h
View File

@@ -4,25 +4,32 @@
template<class T> class AbstractAssetDumper : public IAssetDumper<T> template<class T> class AbstractAssetDumper : public IAssetDumper<T>
{ {
public:
[[nodiscard]] size_t GetProgressTotalCount(const AssetPool<T>& pool) const override
{
return pool.m_asset_lookup.size();
}
void DumpPool(AssetDumpingContext& context, const AssetPool<T>& pool) override
{
for (const auto* assetInfo : pool)
{
if (assetInfo->m_name[0] == ',' || !ShouldDump(*assetInfo))
{
context.IncrementProgress();
continue;
}
DumpAsset(context, *assetInfo);
context.IncrementProgress();
}
}
protected: protected:
virtual bool ShouldDump(XAssetInfo<T>* asset) virtual bool ShouldDump(const XAssetInfo<T>& asset)
{ {
return true; return true;
} }
virtual void DumpAsset(AssetDumpingContext& context, XAssetInfo<T>* asset) = 0; virtual void DumpAsset(AssetDumpingContext& context, const XAssetInfo<T>& asset) = 0;
public:
void DumpPool(AssetDumpingContext& context, AssetPool<T>* pool) override
{
for (auto assetInfo : *pool)
{
if (assetInfo->m_name[0] == ',' || !ShouldDump(assetInfo))
{
continue;
}
DumpAsset(context, assetInfo);
}
}
}; };

33
src/ObjWriting/Dumping/AssetDumpingContext.cpp
View File

@@ -1,18 +1,43 @@
#include "AssetDumpingContext.h" #include "AssetDumpingContext.h"
#include <filesystem> #include <filesystem>
#include <format>
#include <fstream>
AssetDumpingContext::AssetDumpingContext(const Zone& zone, const std::string& basePath, IOutputPath& outputPath, ISearchPath& objSearchPath) AssetDumpingContext::AssetDumpingContext(const Zone& zone,
const std::string& basePath,
IOutputPath& outputPath,
ISearchPath& objSearchPath,
std::optional<std::unique_ptr<ProgressCallback>> progressCallback)
: m_zone(zone), : m_zone(zone),
m_base_path(basePath), m_base_path(basePath),
m_output_path(outputPath), m_output_path(outputPath),
m_obj_search_path(objSearchPath) m_obj_search_path(objSearchPath),
m_current_progress(0uz),
m_total_progress(0uz)
{ {
if (progressCallback)
m_progress_callback = *std::move(progressCallback);
} }
std::unique_ptr<std::ostream> AssetDumpingContext::OpenAssetFile(const std::string& fileName) const std::unique_ptr<std::ostream> AssetDumpingContext::OpenAssetFile(const std::string& fileName) const
{ {
return m_output_path.Open(fileName); return m_output_path.Open(fileName);
} }
void AssetDumpingContext::IncrementProgress()
{
if (m_progress_callback)
{
m_current_progress++;
m_progress_callback->OnProgress(m_current_progress, m_total_progress);
}
}
void AssetDumpingContext::SetTotalProgress(const size_t value)
{
m_total_progress = value;
}
bool AssetDumpingContext::ShouldTrackProgress() const
{
return static_cast<bool>(m_progress_callback);
}

14
src/ObjWriting/Dumping/AssetDumpingContext.h
View File

@@ -4,6 +4,7 @@
#include "Obj/Gdt/GdtStream.h" #include "Obj/Gdt/GdtStream.h"
#include "SearchPath/IOutputPath.h" #include "SearchPath/IOutputPath.h"
#include "SearchPath/ISearchPath.h" #include "SearchPath/ISearchPath.h"
#include "Utils/ProgressCallback.h"
#include "Zone/Zone.h" #include "Zone/Zone.h"
#include <memory> #include <memory>
@@ -14,10 +15,18 @@
class AssetDumpingContext class AssetDumpingContext
{ {
public: public:
AssetDumpingContext(const Zone& zone, const std::string& basePath, IOutputPath& outputPath, ISearchPath& objSearchPath); AssetDumpingContext(const Zone& zone,
const std::string& basePath,
IOutputPath& outputPath,
ISearchPath& objSearchPath,
std::optional<std::unique_ptr<ProgressCallback>> progressCallback);
[[nodiscard]] std::unique_ptr<std::ostream> OpenAssetFile(const std::string& fileName) const; [[nodiscard]] std::unique_ptr<std::ostream> OpenAssetFile(const std::string& fileName) const;
void IncrementProgress();
void SetTotalProgress(size_t value);
[[nodiscard]] bool ShouldTrackProgress() const;
template<typename T> T* GetZoneAssetDumperState() template<typename T> T* GetZoneAssetDumperState()
{ {
static_assert(std::is_base_of_v<IZoneAssetDumperState, T>, "T must inherit IZoneAssetDumperState"); static_assert(std::is_base_of_v<IZoneAssetDumperState, T>, "T must inherit IZoneAssetDumperState");
@@ -42,4 +51,7 @@ public:
private: private:
std::unordered_map<std::type_index, std::unique_ptr<IZoneAssetDumperState>> m_zone_asset_dumper_states; std::unordered_map<std::type_index, std::unique_ptr<IZoneAssetDumperState>> m_zone_asset_dumper_states;
std::unique_ptr<ProgressCallback> m_progress_callback;
size_t m_current_progress;
size_t m_total_progress;
}; };

3
src/ObjWriting/Dumping/IAssetDumper.h
View File

@@ -13,5 +13,6 @@ public:
IAssetDumper& operator=(const IAssetDumper& other) = default; IAssetDumper& operator=(const IAssetDumper& other) = default;
IAssetDumper& operator=(IAssetDumper&& other) noexcept = default; IAssetDumper& operator=(IAssetDumper&& other) noexcept = default;
virtual void DumpPool(AssetDumpingContext& context, AssetPool<T>* pool) = 0; [[nodiscard]] virtual size_t GetProgressTotalCount(const AssetPool<T>& pool) const = 0;
virtual void DumpPool(AssetDumpingContext& context, const AssetPool<T>& pool) = 0;
}; };

11
src/ObjWriting/Game/IW3/Image/ImageDumperIW3.cpp
View File

@@ -79,19 +79,14 @@ namespace image
} }
} }
bool DumperIW3::ShouldDump(XAssetInfo<GfxImage>* asset) void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<GfxImage>& asset)
{ {
return true; const auto* image = asset.Asset();
}
void DumperIW3::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
{
const auto* image = asset->Asset();
const auto texture = LoadImageData(context.m_obj_search_path, *image); const auto texture = LoadImageData(context.m_obj_search_path, *image);
if (!texture) if (!texture)
return; return;
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name, m_writer->GetFileExtension())); const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset.m_name, m_writer->GetFileExtension()));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW3/Image/ImageDumperIW3.h
View File

@@ -14,8 +14,7 @@ namespace image
DumperIW3(); DumperIW3();
protected: protected:
bool ShouldDump(XAssetInfo<IW3::GfxImage>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::GfxImage>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW3::GfxImage>* asset) override;
private: private:
std::unique_ptr<IImageWriter> m_writer; std::unique_ptr<IImageWriter> m_writer;

13
src/ObjWriting/Game/IW3/Localize/LocalizeDumperIW3.cpp
View File

@@ -11,9 +11,14 @@ using namespace IW3;
namespace localize namespace localize
{ {
void DumperIW3::DumpPool(AssetDumpingContext& context, AssetPool<LocalizeEntry>* pool) size_t DumperIW3::GetProgressTotalCount(const AssetPool<IW3::LocalizeEntry>& pool) const
{ {
if (pool->m_asset_lookup.empty()) return pool.m_asset_lookup.empty() ? 0uz : 1uz;
}
void DumperIW3::DumpPool(AssetDumpingContext& context, const AssetPool<LocalizeEntry>& pool)
{
if (pool.m_asset_lookup.empty())
return; return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language); const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -30,7 +35,7 @@ namespace localize
stringFileDumper.SetNotes(""); stringFileDumper.SetNotes("");
for (auto* localizeEntry : *pool) for (const auto* localizeEntry : pool)
{ {
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value); stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
} }
@@ -41,5 +46,7 @@ namespace localize
{ {
con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name); con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name);
} }
context.IncrementProgress();
} }
} // namespace localize } // namespace localize

3
src/ObjWriting/Game/IW3/Localize/LocalizeDumperIW3.h
View File

@@ -8,6 +8,7 @@ namespace localize
class DumperIW3 final : public IAssetDumper<IW3::LocalizeEntry> class DumperIW3 final : public IAssetDumper<IW3::LocalizeEntry>
{ {
public: public:
void DumpPool(AssetDumpingContext& context, AssetPool<IW3::LocalizeEntry>* pool) override; [[nodiscard]] size_t GetProgressTotalCount(const AssetPool<IW3::LocalizeEntry>& pool) const override;
void DumpPool(AssetDumpingContext& context, const AssetPool<IW3::LocalizeEntry>& pool) override;
}; };
} // namespace localize } // namespace localize

11
src/ObjWriting/Game/IW3/Maps/MapEntsDumperIW3.cpp
View File

@@ -4,15 +4,10 @@ using namespace IW3;
namespace map_ents namespace map_ents
{ {
bool DumperIW3::ShouldDump(XAssetInfo<MapEnts>* asset) void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MapEnts>& asset)
{ {
return true; const auto* mapEnts = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name + ".ents");
void DumperIW3::DumpAsset(AssetDumpingContext& context, XAssetInfo<MapEnts>* asset)
{
const auto* mapEnts = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name + ".ents");
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW3/Maps/MapEntsDumperIW3.h
View File

@@ -8,7 +8,6 @@ namespace map_ents
class DumperIW3 final : public AbstractAssetDumper<IW3::MapEnts> class DumperIW3 final : public AbstractAssetDumper<IW3::MapEnts>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW3::MapEnts>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::MapEnts>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW3::MapEnts>* asset) override;
}; };
} // namespace map_ents } // namespace map_ents

15
src/ObjWriting/Game/IW3/ObjWriterIW3.cpp
View File

@@ -19,11 +19,20 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \ if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \
{ \ { \
dumperType dumper; \ dumperType dumper; \
dumper.DumpPool(context, assetPools->poolName.get()); \ totalProgress += dumper.GetProgressTotalCount(*assetPools->poolName); \
dumpingFunctions.emplace_back( \
[](AssetDumpingContext& funcContext, const GameAssetPoolIW3* funcPools) \
{ \
dumperType dumper; \
dumper.DumpPool(funcContext, *funcPools->poolName); \
}); \
} }
const auto* assetPools = dynamic_cast<GameAssetPoolIW3*>(context.m_zone.m_pools.get()); const auto* assetPools = dynamic_cast<GameAssetPoolIW3*>(context.m_zone.m_pools.get());
size_t totalProgress = 0uz;
std::vector<std::function<void(AssetDumpingContext & context, const GameAssetPoolIW3*)>> dumpingFunctions;
// DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET) // DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET)
// DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS) // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS)
DUMP_ASSET_POOL(xmodel::DumperIW3, m_xmodel, ASSET_TYPE_XMODEL) DUMP_ASSET_POOL(xmodel::DumperIW3, m_xmodel, ASSET_TYPE_XMODEL)
@@ -51,6 +60,10 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
DUMP_ASSET_POOL(raw_file::DumperIW3, m_raw_file, ASSET_TYPE_RAWFILE) DUMP_ASSET_POOL(raw_file::DumperIW3, m_raw_file, ASSET_TYPE_RAWFILE)
DUMP_ASSET_POOL(string_table::DumperIW3, m_string_table, ASSET_TYPE_STRINGTABLE) DUMP_ASSET_POOL(string_table::DumperIW3, m_string_table, ASSET_TYPE_STRINGTABLE)
context.SetTotalProgress(totalProgress);
for (const auto& func : dumpingFunctions)
func(context, assetPools);
return true; return true;
#undef DUMP_ASSET_POOL #undef DUMP_ASSET_POOL

11
src/ObjWriting/Game/IW3/RawFile/RawFileDumperIW3.cpp
View File

@@ -4,15 +4,10 @@ using namespace IW3;
namespace raw_file namespace raw_file
{ {
bool DumperIW3::ShouldDump(XAssetInfo<RawFile>* asset) void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset)
{ {
return true; const auto* rawFile = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW3::DumpAsset(AssetDumpingContext& context, XAssetInfo<RawFile>* asset)
{
const auto* rawFile = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW3/RawFile/RawFileDumperIW3.h
View File

@@ -8,7 +8,6 @@ namespace raw_file
class DumperIW3 final : public AbstractAssetDumper<IW3::RawFile> class DumperIW3 final : public AbstractAssetDumper<IW3::RawFile>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW3::RawFile>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::RawFile>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW3::RawFile>* asset) override;
}; };
} // namespace raw_file } // namespace raw_file

11
src/ObjWriting/Game/IW3/Sound/LoadedSoundDumperIW3.cpp
View File

@@ -25,15 +25,10 @@ namespace
namespace sound namespace sound
{ {
bool LoadedSoundDumperIW3::ShouldDump(XAssetInfo<LoadedSound>* asset) void LoadedSoundDumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LoadedSound>& asset)
{ {
return true; const auto* loadedSound = asset.Asset();
} const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset.m_name));
void LoadedSoundDumperIW3::DumpAsset(AssetDumpingContext& context, XAssetInfo<LoadedSound>* asset)
{
const auto* loadedSound = asset->Asset();
const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset->m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW3/Sound/LoadedSoundDumperIW3.h
View File

@@ -8,7 +8,6 @@ namespace sound
class LoadedSoundDumperIW3 final : public AbstractAssetDumper<IW3::LoadedSound> class LoadedSoundDumperIW3 final : public AbstractAssetDumper<IW3::LoadedSound>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW3::LoadedSound>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::LoadedSound>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW3::LoadedSound>* asset) override;
}; };
} // namespace sound } // namespace sound

11
src/ObjWriting/Game/IW3/StringTable/StringTableDumperIW3.cpp
View File

@@ -6,15 +6,10 @@ using namespace IW3;
namespace string_table namespace string_table
{ {
bool DumperIW3::ShouldDump(XAssetInfo<StringTable>* asset) void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& asset)
{ {
return true; const auto* stringTable = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW3::DumpAsset(AssetDumpingContext& context, XAssetInfo<StringTable>* asset)
{
const auto* stringTable = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW3/StringTable/StringTableDumperIW3.h
View File

@@ -8,7 +8,6 @@ namespace string_table
class DumperIW3 final : public AbstractAssetDumper<IW3::StringTable> class DumperIW3 final : public AbstractAssetDumper<IW3::StringTable>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW3::StringTable>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::StringTable>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW3::StringTable>* asset) override;
}; };
} // namespace string_table } // namespace string_table

11
src/ObjWriting/Game/IW4/Image/ImageDumperIW4.cpp
View File

@@ -76,19 +76,14 @@ namespace image
} }
} }
bool DumperIW4::ShouldDump(XAssetInfo<GfxImage>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<GfxImage>& asset)
{ {
return true; const auto* image = asset.Asset();
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
{
const auto* image = asset->Asset();
const auto texture = LoadImageData(context.m_obj_search_path, *image); const auto texture = LoadImageData(context.m_obj_search_path, *image);
if (!texture) if (!texture)
return; return;
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name, m_writer->GetFileExtension())); const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset.m_name, m_writer->GetFileExtension()));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Image/ImageDumperIW4.h
View File

@@ -14,8 +14,7 @@ namespace image
DumperIW4(); DumperIW4();
protected: protected:
bool ShouldDump(XAssetInfo<IW4::GfxImage>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::GfxImage>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::GfxImage>* asset) override;
private: private:
std::unique_ptr<IImageWriter> m_writer; std::unique_ptr<IImageWriter> m_writer;

11
src/ObjWriting/Game/IW4/Leaderboard/LeaderboardJsonDumperIW4.cpp
View File

@@ -77,19 +77,14 @@ namespace
namespace leaderboard namespace leaderboard
{ {
bool JsonDumperIW4::ShouldDump(XAssetInfo<LeaderboardDef>* asset) void JsonDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LeaderboardDef>& asset)
{ {
return true; const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAsset(asset.m_name));
}
void JsonDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<LeaderboardDef>* asset)
{
const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAsset(asset->m_name));
if (!assetFile) if (!assetFile)
return; return;
Dumper dumper(*assetFile); Dumper dumper(*assetFile);
dumper.Dump(*asset->Asset()); dumper.Dump(*asset.Asset());
} }
} // namespace leaderboard } // namespace leaderboard

3
src/ObjWriting/Game/IW4/Leaderboard/LeaderboardJsonDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace leaderboard
class JsonDumperIW4 final : public AbstractAssetDumper<IW4::LeaderboardDef> class JsonDumperIW4 final : public AbstractAssetDumper<IW4::LeaderboardDef>
{ {
protected: protected:
[[nodiscard]] bool ShouldDump(XAssetInfo<IW4::LeaderboardDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::LeaderboardDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::LeaderboardDef>* asset) override;
}; };
} // namespace leaderboard } // namespace leaderboard

13
src/ObjWriting/Game/IW4/LightDef/LightDefDumperIW4.cpp
View File

@@ -2,21 +2,14 @@
#include "LightDef/LightDefCommon.h" #include "LightDef/LightDefCommon.h"
#include <sstream>
using namespace IW4; using namespace IW4;
namespace light_def namespace light_def
{ {
bool DumperIW4::ShouldDump(XAssetInfo<GfxLightDef>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<GfxLightDef>& asset)
{ {
return true; const auto* lightDef = asset.Asset();
} const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset.m_name));
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxLightDef>* asset)
{
const auto* lightDef = asset->Asset();
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name));
if (!assetFile || lightDef->attenuation.image == nullptr || lightDef->attenuation.image->name == nullptr) if (!assetFile || lightDef->attenuation.image == nullptr || lightDef->attenuation.image->name == nullptr)
return; return;

3
src/ObjWriting/Game/IW4/LightDef/LightDefDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace light_def
class DumperIW4 final : public AbstractAssetDumper<IW4::GfxLightDef> class DumperIW4 final : public AbstractAssetDumper<IW4::GfxLightDef>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::GfxLightDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::GfxLightDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::GfxLightDef>* asset) override;
}; };
} // namespace light_def } // namespace light_def

14
src/ObjWriting/Game/IW4/Localize/LocalizeDumperIW4.cpp
View File

@@ -5,15 +5,19 @@
#include "Utils/Logging/Log.h" #include "Utils/Logging/Log.h"
#include <format> #include <format>
#include <sstream>
using namespace IW4; using namespace IW4;
namespace localize namespace localize
{ {
void DumperIW4::DumpPool(AssetDumpingContext& context, AssetPool<LocalizeEntry>* pool) size_t DumperIW4::GetProgressTotalCount(const AssetPool<LocalizeEntry>& pool) const
{ {
if (pool->m_asset_lookup.empty()) return pool.m_asset_lookup.empty() ? 0uz : 1uz;
}
void DumperIW4::DumpPool(AssetDumpingContext& context, const AssetPool<LocalizeEntry>& pool)
{
if (pool.m_asset_lookup.empty())
return; return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language); const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -30,7 +34,7 @@ namespace localize
stringFileDumper.SetNotes(""); stringFileDumper.SetNotes("");
for (auto* localizeEntry : *pool) for (const auto* localizeEntry : pool)
{ {
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value); stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
} }
@@ -41,5 +45,7 @@ namespace localize
{ {
con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name); con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name);
} }
context.IncrementProgress();
} }
} // namespace localize } // namespace localize

3
src/ObjWriting/Game/IW4/Localize/LocalizeDumperIW4.h
View File

@@ -8,6 +8,7 @@ namespace localize
class DumperIW4 final : public IAssetDumper<IW4::LocalizeEntry> class DumperIW4 final : public IAssetDumper<IW4::LocalizeEntry>
{ {
public: public:
void DumpPool(AssetDumpingContext& context, AssetPool<IW4::LocalizeEntry>* pool) override; [[nodiscard]] size_t GetProgressTotalCount(const AssetPool<IW4::LocalizeEntry>& pool) const override;
void DumpPool(AssetDumpingContext& context, const AssetPool<IW4::LocalizeEntry>& pool) override;
}; };
} // namespace localize } // namespace localize

11
src/ObjWriting/Game/IW4/Maps/AddonMapEntsDumperIW4.cpp
View File

@@ -7,15 +7,10 @@ using namespace IW4;
namespace addon_map_ents namespace addon_map_ents
{ {
bool DumperIW4::ShouldDump(XAssetInfo<AddonMapEnts>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AddonMapEnts>& asset)
{ {
return true; const auto* addonMapEnts = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<AddonMapEnts>* asset)
{
const auto* addonMapEnts = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Maps/AddonMapEntsDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace addon_map_ents
class DumperIW4 final : public AbstractAssetDumper<IW4::AddonMapEnts> class DumperIW4 final : public AbstractAssetDumper<IW4::AddonMapEnts>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::AddonMapEnts>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AddonMapEnts>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::AddonMapEnts>* asset) override;
}; };
} // namespace addon_map_ents } // namespace addon_map_ents

9
src/ObjWriting/Game/IW4/Material/MaterialDecompilingDumperIW4.cpp
View File

@@ -1110,17 +1110,12 @@ namespace
namespace material namespace material
{ {
bool DecompilingGdtDumperIW4::ShouldDump(XAssetInfo<Material>* asset) void DecompilingGdtDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<Material>& asset)
{
return true;
}
void DecompilingGdtDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<Material>* asset)
{ {
if (!context.m_gdt) if (!context.m_gdt)
return; return;
MaterialGdtDumper dumper(*asset->Asset()); MaterialGdtDumper dumper(*asset.Asset());
context.m_gdt->WriteEntry(dumper.CreateGdtEntry()); context.m_gdt->WriteEntry(dumper.CreateGdtEntry());
} }
} // namespace material } // namespace material

3
src/ObjWriting/Game/IW4/Material/MaterialDecompilingDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace material
class DecompilingGdtDumperIW4 final : public AbstractAssetDumper<IW4::Material> class DecompilingGdtDumperIW4 final : public AbstractAssetDumper<IW4::Material>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::Material>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::Material>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::Material>* asset) override;
}; };
} // namespace material } // namespace material

17
src/ObjWriting/Game/IW4/Menu/MenuDumperIW4.cpp
View File

@@ -13,12 +13,12 @@ using namespace IW4;
namespace namespace
{ {
std::string GetPathForMenu(menu::MenuDumpingZoneState* zoneState, XAssetInfo<menuDef_t>* asset) std::string GetPathForMenu(menu::MenuDumpingZoneState* zoneState, const XAssetInfo<menuDef_t>& asset)
{ {
const auto menuDumpingState = zoneState->m_menu_dumping_state_map.find(asset->Asset()); const auto menuDumpingState = zoneState->m_menu_dumping_state_map.find(asset.Asset());
if (menuDumpingState == zoneState->m_menu_dumping_state_map.end()) if (menuDumpingState == zoneState->m_menu_dumping_state_map.end())
return "ui_mp/" + std::string(asset->Asset()->window.name) + ".menu"; return "ui_mp/" + std::string(asset.Asset()->window.name) + ".menu";
return menuDumpingState->second.m_path; return menuDumpingState->second.m_path;
} }
@@ -26,20 +26,15 @@ namespace
namespace menu namespace menu
{ {
bool MenuDumperIW4::ShouldDump(XAssetInfo<menuDef_t>* asset) void MenuDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<menuDef_t>& asset)
{ {
return true; const auto* menu = asset.Asset();
}
void MenuDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<menuDef_t>* asset)
{
const auto* menu = asset->Asset();
auto* zoneState = context.GetZoneAssetDumperState<MenuDumpingZoneState>(); auto* zoneState = context.GetZoneAssetDumperState<MenuDumpingZoneState>();
if (!ObjWriting::ShouldHandleAssetType(ASSET_TYPE_MENULIST)) if (!ObjWriting::ShouldHandleAssetType(ASSET_TYPE_MENULIST))
{ {
// Make sure menu paths based on menu lists are created // Make sure menu paths based on menu lists are created
const auto* gameAssetPool = dynamic_cast<GameAssetPoolIW4*>(asset->m_zone->m_pools.get()); const auto* gameAssetPool = dynamic_cast<GameAssetPoolIW4*>(asset.m_zone->m_pools.get());
for (auto* menuListAsset : *gameAssetPool->m_menu_list) for (auto* menuListAsset : *gameAssetPool->m_menu_list)
CreateDumpingStateForMenuListIW4(zoneState, menuListAsset->Asset()); CreateDumpingStateForMenuListIW4(zoneState, menuListAsset->Asset());
} }

3
src/ObjWriting/Game/IW4/Menu/MenuDumperIW4.h
View File

@@ -9,7 +9,6 @@ namespace menu
class MenuDumperIW4 final : public AbstractAssetDumper<IW4::menuDef_t> class MenuDumperIW4 final : public AbstractAssetDumper<IW4::menuDef_t>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::menuDef_t>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::menuDef_t>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::menuDef_t>* asset) override;
}; };
} // namespace menu } // namespace menu

15
src/ObjWriting/Game/IW4/Menu/MenuListDumperIW4.cpp
View File

@@ -147,15 +147,10 @@ namespace menu
} }
} }
bool MenuListDumperIW4::ShouldDump(XAssetInfo<MenuList>* asset) void MenuListDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MenuList>& asset)
{ {
return true; const auto* menuList = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void MenuListDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<MenuList>* asset)
{
const auto* menuList = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;
@@ -174,11 +169,11 @@ namespace menu
menuWriter->End(); menuWriter->End();
} }
void MenuListDumperIW4::DumpPool(AssetDumpingContext& context, AssetPool<MenuList>* pool) void MenuListDumperIW4::DumpPool(AssetDumpingContext& context, const AssetPool<MenuList>& pool)
{ {
auto* zoneState = context.GetZoneAssetDumperState<MenuDumpingZoneState>(); auto* zoneState = context.GetZoneAssetDumperState<MenuDumpingZoneState>();
for (auto* asset : *pool) for (const auto* asset : pool)
CreateDumpingStateForMenuListIW4(zoneState, asset->Asset()); CreateDumpingStateForMenuListIW4(zoneState, asset->Asset());
AbstractAssetDumper<MenuList>::DumpPool(context, pool); AbstractAssetDumper<MenuList>::DumpPool(context, pool);

9
src/ObjWriting/Game/IW4/Menu/MenuListDumperIW4.h
View File

@@ -11,11 +11,10 @@ namespace menu
class MenuListDumperIW4 final : public AbstractAssetDumper<IW4::MenuList> class MenuListDumperIW4 final : public AbstractAssetDumper<IW4::MenuList>
{ {
protected:
bool ShouldDump(XAssetInfo<IW4::MenuList>* asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MenuList>* asset) override;
public: public:
void DumpPool(AssetDumpingContext& context, AssetPool<IW4::MenuList>* pool) override; void DumpPool(AssetDumpingContext& context, const AssetPool<IW4::MenuList>& pool) override;
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::MenuList>& asset) override;
}; };
} // namespace menu } // namespace menu

15
src/ObjWriting/Game/IW4/ObjWriterIW4.cpp
View File

@@ -34,11 +34,20 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \ if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \
{ \ { \
dumperType dumper; \ dumperType dumper; \
dumper.DumpPool(context, assetPools->poolName.get()); \ totalProgress += dumper.GetProgressTotalCount(*assetPools->poolName); \
dumpingFunctions.emplace_back( \
[](AssetDumpingContext& funcContext, const GameAssetPoolIW4* funcPools) \
{ \
dumperType dumper; \
dumper.DumpPool(funcContext, *funcPools->poolName); \
}); \
} }
const auto* assetPools = dynamic_cast<GameAssetPoolIW4*>(context.m_zone.m_pools.get()); const auto* assetPools = dynamic_cast<GameAssetPoolIW4*>(context.m_zone.m_pools.get());
size_t totalProgress = 0uz;
std::vector<std::function<void(AssetDumpingContext & context, const GameAssetPoolIW4*)>> dumpingFunctions;
DUMP_ASSET_POOL(phys_preset::InfoStringDumperIW4, m_phys_preset, ASSET_TYPE_PHYSPRESET) DUMP_ASSET_POOL(phys_preset::InfoStringDumperIW4, m_phys_preset, ASSET_TYPE_PHYSPRESET)
DUMP_ASSET_POOL(phys_collmap::DumperIW4, m_phys_collmap, ASSET_TYPE_PHYSCOLLMAP) DUMP_ASSET_POOL(phys_collmap::DumperIW4, m_phys_collmap, ASSET_TYPE_PHYSCOLLMAP)
// DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS) // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS)
@@ -78,6 +87,10 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
DUMP_ASSET_POOL(vehicle::DumperIW4, m_vehicle, ASSET_TYPE_VEHICLE) DUMP_ASSET_POOL(vehicle::DumperIW4, m_vehicle, ASSET_TYPE_VEHICLE)
DUMP_ASSET_POOL(addon_map_ents::DumperIW4, m_addon_map_ents, ASSET_TYPE_ADDON_MAP_ENTS) DUMP_ASSET_POOL(addon_map_ents::DumperIW4, m_addon_map_ents, ASSET_TYPE_ADDON_MAP_ENTS)
context.SetTotalProgress(totalProgress);
for (const auto& func : dumpingFunctions)
func(context, assetPools);
return true; return true;
#undef DUMP_ASSET_POOL #undef DUMP_ASSET_POOL

11
src/ObjWriting/Game/IW4/PhysCollmap/PhysCollmapDumperIW4.cpp
View File

@@ -10,15 +10,10 @@ using namespace IW4;
namespace phys_collmap namespace phys_collmap
{ {
bool DumperIW4::ShouldDump(XAssetInfo<PhysCollmap>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<PhysCollmap>& asset)
{ {
return true; const auto* physCollmap = asset.Asset();
} const auto assetFile = context.OpenAssetFile(phys_collmap::GetFileNameForAssetName(asset.m_name));
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<PhysCollmap>* asset)
{
const auto* physCollmap = asset->Asset();
const auto assetFile = context.OpenAssetFile(phys_collmap::GetFileNameForAssetName(asset->m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/PhysCollmap/PhysCollmapDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace phys_collmap
class DumperIW4 final : public AbstractAssetDumper<IW4::PhysCollmap> class DumperIW4 final : public AbstractAssetDumper<IW4::PhysCollmap>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::PhysCollmap>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::PhysCollmap>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::PhysCollmap>* asset) override;
}; };
} // namespace phys_collmap } // namespace phys_collmap

21
src/ObjWriting/Game/IW4/PhysPreset/PhysPresetInfoStringDumperIW4.cpp
View File

@@ -57,21 +57,21 @@ namespace
physPresetInfo->perSurfaceSndAlias = physPreset->perSurfaceSndAlias ? 1 : 0; physPresetInfo->perSurfaceSndAlias = physPreset->perSurfaceSndAlias ? 1 : 0;
} }
InfoString CreateInfoString(XAssetInfo<PhysPreset>* asset) InfoString CreateInfoString(const XAssetInfo<PhysPreset>& asset)
{ {
auto* physPresetInfo = new PhysPresetInfo; auto* physPresetInfo = new PhysPresetInfo;
CopyToPhysPresetInfo(asset->Asset(), physPresetInfo); CopyToPhysPresetInfo(asset.Asset(), physPresetInfo);
InfoStringFromPhysPresetConverter converter(physPresetInfo, InfoStringFromPhysPresetConverter converter(physPresetInfo,
phys_preset_fields, phys_preset_fields,
std::extent_v<decltype(phys_preset_fields)>, std::extent_v<decltype(phys_preset_fields)>,
[asset](const scr_string_t scrStr) -> std::string [asset](const scr_string_t scrStr) -> std::string
{ {
assert(scrStr < asset->m_zone->m_script_strings.Count()); assert(scrStr < asset.m_zone->m_script_strings.Count());
if (scrStr >= asset->m_zone->m_script_strings.Count()) if (scrStr >= asset.m_zone->m_script_strings.Count())
return ""; return "";
return asset->m_zone->m_script_strings[scrStr]; return asset.m_zone->m_script_strings[scrStr];
}); });
return converter.Convert(); return converter.Convert();
@@ -80,24 +80,19 @@ namespace
namespace phys_preset namespace phys_preset
{ {
bool InfoStringDumperIW4::ShouldDump(XAssetInfo<IW4::PhysPreset>* asset) void InfoStringDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<PhysPreset>& asset)
{
return true;
}
void InfoStringDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::PhysPreset>* asset)
{ {
// Only dump raw when no gdt available // Only dump raw when no gdt available
if (context.m_gdt) if (context.m_gdt)
{ {
const auto infoString = CreateInfoString(asset); const auto infoString = CreateInfoString(asset);
GdtEntry gdtEntry(asset->m_name, ObjConstants::GDF_FILENAME_PHYS_PRESET); GdtEntry gdtEntry(asset.m_name, ObjConstants::GDF_FILENAME_PHYS_PRESET);
infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_PHYS_PRESET, gdtEntry); infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_PHYS_PRESET, gdtEntry);
context.m_gdt->WriteEntry(gdtEntry); context.m_gdt->WriteEntry(gdtEntry);
} }
else else
{ {
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset->m_name)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset.m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/PhysPreset/PhysPresetInfoStringDumperIW4.h
View File

@@ -9,7 +9,6 @@ namespace phys_preset
class InfoStringDumperIW4 final : public AbstractAssetDumper<IW4::PhysPreset> class InfoStringDumperIW4 final : public AbstractAssetDumper<IW4::PhysPreset>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::PhysPreset>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::PhysPreset>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::PhysPreset>* asset) override;
}; };
} // namespace phys_preset } // namespace phys_preset

11
src/ObjWriting/Game/IW4/RawFile/RawFileDumperIW4.cpp
View File

@@ -10,15 +10,10 @@ using namespace IW4;
namespace raw_file namespace raw_file
{ {
bool DumperIW4::ShouldDump(XAssetInfo<RawFile>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset)
{ {
return true; const auto* rawFile = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<RawFile>* asset)
{
const auto* rawFile = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/RawFile/RawFileDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace raw_file
class DumperIW4 final : public AbstractAssetDumper<IW4::RawFile> class DumperIW4 final : public AbstractAssetDumper<IW4::RawFile>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::RawFile>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::RawFile>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::RawFile>* asset) override;
}; };
} // namespace raw_file } // namespace raw_file

11
src/ObjWriting/Game/IW4/Shader/PixelShaderDumperIW4.cpp
View File

@@ -6,15 +6,10 @@ using namespace IW4;
namespace shader namespace shader
{ {
bool PixelShaderDumperIW4::ShouldDump(XAssetInfo<IW4::MaterialPixelShader>* asset) void PixelShaderDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MaterialPixelShader>& asset)
{ {
return true; const auto* pixelShader = asset.Asset();
} const auto shaderFile = context.OpenAssetFile(shader::GetFileNameForPixelShaderAssetName(asset.m_name));
void PixelShaderDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MaterialPixelShader>* asset)
{
const auto* pixelShader = asset->Asset();
const auto shaderFile = context.OpenAssetFile(shader::GetFileNameForPixelShaderAssetName(asset->m_name));
if (!shaderFile) if (!shaderFile)
return; return;

3
src/ObjWriting/Game/IW4/Shader/PixelShaderDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace shader
class PixelShaderDumperIW4 final : public AbstractAssetDumper<IW4::MaterialPixelShader> class PixelShaderDumperIW4 final : public AbstractAssetDumper<IW4::MaterialPixelShader>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::MaterialPixelShader>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::MaterialPixelShader>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MaterialPixelShader>* asset) override;
}; };
} // namespace shader } // namespace shader

11
src/ObjWriting/Game/IW4/Shader/VertexShaderDumperIW4.cpp
View File

@@ -6,15 +6,10 @@ using namespace IW4;
namespace shader namespace shader
{ {
bool VertexShaderDumperIW4::ShouldDump(XAssetInfo<IW4::MaterialVertexShader>* asset) void VertexShaderDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MaterialVertexShader>& asset)
{ {
return true; const auto* vertexShader = asset.Asset();
} const auto shaderFile = context.OpenAssetFile(shader::GetFileNameForVertexShaderAssetName(asset.m_name));
void VertexShaderDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MaterialVertexShader>* asset)
{
const auto* vertexShader = asset->Asset();
const auto shaderFile = context.OpenAssetFile(shader::GetFileNameForVertexShaderAssetName(asset->m_name));
if (!shaderFile) if (!shaderFile)
return; return;

3
src/ObjWriting/Game/IW4/Shader/VertexShaderDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace shader
class VertexShaderDumperIW4 final : public AbstractAssetDumper<IW4::MaterialVertexShader> class VertexShaderDumperIW4 final : public AbstractAssetDumper<IW4::MaterialVertexShader>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::MaterialVertexShader>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::MaterialVertexShader>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MaterialVertexShader>* asset) override;
}; };
} // namespace shader } // namespace shader

11
src/ObjWriting/Game/IW4/Sound/LoadedSoundDumperIW4.cpp
View File

@@ -25,15 +25,10 @@ namespace
namespace sound namespace sound
{ {
bool LoadedSoundDumperIW4::ShouldDump(XAssetInfo<LoadedSound>* asset) void LoadedSoundDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LoadedSound>& asset)
{ {
return true; const auto* loadedSound = asset.Asset();
} const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset.m_name));
void LoadedSoundDumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<LoadedSound>* asset)
{
const auto* loadedSound = asset->Asset();
const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset->m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Sound/LoadedSoundDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace sound
class LoadedSoundDumperIW4 final : public AbstractAssetDumper<IW4::LoadedSound> class LoadedSoundDumperIW4 final : public AbstractAssetDumper<IW4::LoadedSound>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::LoadedSound>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::LoadedSound>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::LoadedSound>* asset) override;
}; };
} // namespace sound } // namespace sound

11
src/ObjWriting/Game/IW4/Sound/SndCurveDumperIW4.cpp
View File

@@ -3,20 +3,13 @@
#include "Sound/SndCurveDumper.h" #include "Sound/SndCurveDumper.h"
#include "Sound/SoundCurveCommon.h" #include "Sound/SoundCurveCommon.h"
#include <sstream>
using namespace IW4; using namespace IW4;
namespace sound_curve namespace sound_curve
{ {
bool DumperIW4::ShouldDump(XAssetInfo<SndCurve>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<SndCurve>& asset)
{ {
return true; const auto* sndCurve = asset.Asset();
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<SndCurve>* asset)
{
const auto* sndCurve = asset->Asset();
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(sndCurve->filename)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(sndCurve->filename));

3
src/ObjWriting/Game/IW4/Sound/SndCurveDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace sound_curve
class DumperIW4 final : public AbstractAssetDumper<IW4::SndCurve> class DumperIW4 final : public AbstractAssetDumper<IW4::SndCurve>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::SndCurve>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::SndCurve>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::SndCurve>* asset) override;
}; };
} // namespace sound_curve } // namespace sound_curve

11
src/ObjWriting/Game/IW4/StringTable/StringTableDumperIW4.cpp
View File

@@ -6,15 +6,10 @@ using namespace IW4;
namespace string_table namespace string_table
{ {
bool DumperIW4::ShouldDump(XAssetInfo<StringTable>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& asset)
{ {
return true; const auto* stringTable = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<StringTable>* asset)
{
const auto* stringTable = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/StringTable/StringTableDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace string_table
class DumperIW4 final : public AbstractAssetDumper<IW4::StringTable> class DumperIW4 final : public AbstractAssetDumper<IW4::StringTable>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::StringTable>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::StringTable>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::StringTable>* asset) override;
}; };
} // namespace string_table } // namespace string_table

11
src/ObjWriting/Game/IW4/StructuredDataDef/StructuredDataDefDumperIW4.cpp
View File

@@ -185,15 +185,10 @@ namespace
namespace structured_data_def namespace structured_data_def
{ {
bool DumperIW4::ShouldDump(XAssetInfo<StructuredDataDefSet>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StructuredDataDefSet>& asset)
{ {
return true; const auto* set = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<StructuredDataDefSet>* asset)
{
const auto* set = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile || set->defs == nullptr) if (!assetFile || set->defs == nullptr)
return; return;

3
src/ObjWriting/Game/IW4/StructuredDataDef/StructuredDataDefDumperIW4.h
View File

@@ -11,7 +11,6 @@ namespace structured_data_def
class DumperIW4 final : public AbstractAssetDumper<IW4::StructuredDataDefSet> class DumperIW4 final : public AbstractAssetDumper<IW4::StructuredDataDefSet>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::StructuredDataDefSet>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::StructuredDataDefSet>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::StructuredDataDefSet>* asset) override;
}; };
} // namespace structured_data_def } // namespace structured_data_def

9
src/ObjWriting/Game/IW4/Techset/TechsetDumperIW4.cpp
View File

@@ -536,14 +536,9 @@ namespace IW4
namespace techset namespace techset
{ {
bool DumperIW4::ShouldDump(XAssetInfo<MaterialTechniqueSet>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MaterialTechniqueSet>& asset)
{ {
return true; const auto* techset = asset.Asset();
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<MaterialTechniqueSet>* asset)
{
const auto* techset = asset->Asset();
const auto techsetFile = context.OpenAssetFile(GetFileNameForTechsetName(techset->name)); const auto techsetFile = context.OpenAssetFile(GetFileNameForTechsetName(techset->name));

3
src/ObjWriting/Game/IW4/Techset/TechsetDumperIW4.h
View File

@@ -8,7 +8,6 @@ namespace techset
class DumperIW4 final : public AbstractAssetDumper<IW4::MaterialTechniqueSet> class DumperIW4 final : public AbstractAssetDumper<IW4::MaterialTechniqueSet>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::MaterialTechniqueSet>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::MaterialTechniqueSet>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::MaterialTechniqueSet>* asset) override;
}; };
} // namespace techset } // namespace techset

21
src/ObjWriting/Game/IW4/Tracer/TracerDumperIW4.cpp
View File

@@ -32,18 +32,18 @@ namespace
} }
}; };
InfoString CreateInfoString(XAssetInfo<TracerDef>* asset) InfoString CreateInfoString(const XAssetInfo<TracerDef>& asset)
{ {
InfoStringFromTracerConverter converter(asset->Asset(), InfoStringFromTracerConverter converter(asset.Asset(),
tracer_fields, tracer_fields,
std::extent_v<decltype(tracer_fields)>, std::extent_v<decltype(tracer_fields)>,
[asset](const scr_string_t scrStr) -> std::string [asset](const scr_string_t scrStr) -> std::string
{ {
assert(scrStr < asset->m_zone->m_script_strings.Count()); assert(scrStr < asset.m_zone->m_script_strings.Count());
if (scrStr >= asset->m_zone->m_script_strings.Count()) if (scrStr >= asset.m_zone->m_script_strings.Count())
return ""; return "";
return asset->m_zone->m_script_strings[scrStr]; return asset.m_zone->m_script_strings[scrStr];
}); });
return converter.Convert(); return converter.Convert();
@@ -52,24 +52,19 @@ namespace
namespace tracer namespace tracer
{ {
bool DumperIW4::ShouldDump(XAssetInfo<TracerDef>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<TracerDef>& asset)
{
return true;
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<TracerDef>* asset)
{ {
// Only dump raw when no gdt available // Only dump raw when no gdt available
if (context.m_gdt) if (context.m_gdt)
{ {
const auto infoString = CreateInfoString(asset); const auto infoString = CreateInfoString(asset);
GdtEntry gdtEntry(asset->m_name, ObjConstants::GDF_FILENAME_TRACER); GdtEntry gdtEntry(asset.m_name, ObjConstants::GDF_FILENAME_TRACER);
infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_TRACER, gdtEntry); infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_TRACER, gdtEntry);
context.m_gdt->WriteEntry(gdtEntry); context.m_gdt->WriteEntry(gdtEntry);
} }
else else
{ {
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset->m_name)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset.m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Tracer/TracerDumperIW4.h
View File

@@ -9,7 +9,6 @@ namespace tracer
class DumperIW4 final : public AbstractAssetDumper<IW4::TracerDef> class DumperIW4 final : public AbstractAssetDumper<IW4::TracerDef>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::TracerDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::TracerDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::TracerDef>* asset) override;
}; };
} // namespace tracer } // namespace tracer

21
src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.cpp
View File

@@ -73,18 +73,18 @@ namespace
} }
}; };
InfoString CreateInfoString(XAssetInfo<VehicleDef>* asset) InfoString CreateInfoString(const XAssetInfo<VehicleDef>& asset)
{ {
InfoStringFromVehicleConverter converter(asset->Asset(), InfoStringFromVehicleConverter converter(asset.Asset(),
vehicle_fields, vehicle_fields,
std::extent_v<decltype(vehicle_fields)>, std::extent_v<decltype(vehicle_fields)>,
[asset](const scr_string_t scrStr) -> std::string [asset](const scr_string_t scrStr) -> std::string
{ {
assert(scrStr < asset->m_zone->m_script_strings.Count()); assert(scrStr < asset.m_zone->m_script_strings.Count());
if (scrStr >= asset->m_zone->m_script_strings.Count()) if (scrStr >= asset.m_zone->m_script_strings.Count())
return ""; return "";
return asset->m_zone->m_script_strings[scrStr]; return asset.m_zone->m_script_strings[scrStr];
}); });
return converter.Convert(); return converter.Convert();
@@ -93,24 +93,19 @@ namespace
namespace vehicle namespace vehicle
{ {
bool DumperIW4::ShouldDump(XAssetInfo<VehicleDef>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<VehicleDef>& asset)
{
return true;
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<VehicleDef>* asset)
{ {
// Only dump raw when no gdt available // Only dump raw when no gdt available
if (context.m_gdt) if (context.m_gdt)
{ {
const auto infoString = CreateInfoString(asset); const auto infoString = CreateInfoString(asset);
GdtEntry gdtEntry(asset->m_name, ObjConstants::GDF_FILENAME_VEHICLE); GdtEntry gdtEntry(asset.m_name, ObjConstants::GDF_FILENAME_VEHICLE);
infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_VEHICLE, gdtEntry); infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_VEHICLE, gdtEntry);
context.m_gdt->WriteEntry(gdtEntry); context.m_gdt->WriteEntry(gdtEntry);
} }
else else
{ {
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset->m_name)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset.m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Vehicle/VehicleDumperIW4.h
View File

@@ -9,7 +9,6 @@ namespace vehicle
class DumperIW4 final : public AbstractAssetDumper<IW4::VehicleDef> class DumperIW4 final : public AbstractAssetDumper<IW4::VehicleDef>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::VehicleDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::VehicleDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::VehicleDef>* asset) override;
}; };
} // namespace vehicle } // namespace vehicle

25
src/ObjWriting/Game/IW4/Weapon/WeaponDumperIW4.cpp
View File

@@ -353,31 +353,31 @@ namespace
} }
} }
InfoString CreateInfoString(XAssetInfo<WeaponCompleteDef>* asset) InfoString CreateInfoString(const XAssetInfo<WeaponCompleteDef>& asset)
{ {
const auto fullDef = std::make_unique<WeaponFullDef>(); const auto fullDef = std::make_unique<WeaponFullDef>();
memset(fullDef.get(), 0, sizeof(WeaponFullDef)); memset(fullDef.get(), 0, sizeof(WeaponFullDef));
CopyToFullDef(asset->Asset(), fullDef.get()); CopyToFullDef(asset.Asset(), fullDef.get());
InfoStringFromWeaponConverter converter(fullDef.get(), InfoStringFromWeaponConverter converter(fullDef.get(),
weapon_fields, weapon_fields,
std::extent_v<decltype(weapon_fields)>, std::extent_v<decltype(weapon_fields)>,
[asset](const scr_string_t scrStr) -> std::string [asset](const scr_string_t scrStr) -> std::string
{ {
assert(scrStr < asset->m_zone->m_script_strings.Count()); assert(scrStr < asset.m_zone->m_script_strings.Count());
if (scrStr >= asset->m_zone->m_script_strings.Count()) if (scrStr >= asset.m_zone->m_script_strings.Count())
return ""; return "";
return asset->m_zone->m_script_strings[scrStr]; return asset.m_zone->m_script_strings[scrStr];
}); });
return converter.Convert(); return converter.Convert();
} }
void DumpAccuracyGraphs(AssetDumpingContext& context, XAssetInfo<WeaponCompleteDef>* asset) void DumpAccuracyGraphs(AssetDumpingContext& context, const XAssetInfo<WeaponCompleteDef>& asset)
{ {
auto* accuracyGraphWriter = context.GetZoneAssetDumperState<AccuracyGraphWriter>(); auto* accuracyGraphWriter = context.GetZoneAssetDumperState<AccuracyGraphWriter>();
const auto weapon = asset->Asset(); const auto weapon = asset.Asset();
const auto* weapDef = weapon->weapDef; const auto* weapDef = weapon->weapDef;
if (!weapDef) if (!weapDef)
@@ -405,24 +405,19 @@ namespace
namespace weapon namespace weapon
{ {
bool DumperIW4::ShouldDump(XAssetInfo<WeaponCompleteDef>* asset) void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<WeaponCompleteDef>& asset)
{
return true;
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, XAssetInfo<WeaponCompleteDef>* asset)
{ {
// Only dump raw when no gdt available // Only dump raw when no gdt available
if (context.m_gdt) if (context.m_gdt)
{ {
const auto infoString = CreateInfoString(asset); const auto infoString = CreateInfoString(asset);
GdtEntry gdtEntry(asset->m_name, ObjConstants::GDF_FILENAME_WEAPON); GdtEntry gdtEntry(asset.m_name, ObjConstants::GDF_FILENAME_WEAPON);
infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON, gdtEntry); infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON, gdtEntry);
context.m_gdt->WriteEntry(gdtEntry); context.m_gdt->WriteEntry(gdtEntry);
} }
else else
{ {
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset->m_name)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset.m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW4/Weapon/WeaponDumperIW4.h
View File

@@ -9,7 +9,6 @@ namespace weapon
class DumperIW4 final : public AbstractAssetDumper<IW4::WeaponCompleteDef> class DumperIW4 final : public AbstractAssetDumper<IW4::WeaponCompleteDef>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW4::WeaponCompleteDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::WeaponCompleteDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW4::WeaponCompleteDef>* asset) override;
}; };
} // namespace weapon } // namespace weapon

11
src/ObjWriting/Game/IW5/Image/ImageDumperIW5.cpp
View File

@@ -77,19 +77,14 @@ namespace image
} }
} }
bool DumperIW5::ShouldDump(XAssetInfo<GfxImage>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<GfxImage>& asset)
{ {
return true; const auto* image = asset.Asset();
}
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
{
const auto* image = asset->Asset();
const auto texture = LoadImageData(context.m_obj_search_path, *image); const auto texture = LoadImageData(context.m_obj_search_path, *image);
if (!texture) if (!texture)
return; return;
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name, m_writer->GetFileExtension())); const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset.m_name, m_writer->GetFileExtension()));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/Image/ImageDumperIW5.h
View File

@@ -14,8 +14,7 @@ namespace image
DumperIW5(); DumperIW5();
protected: protected:
bool ShouldDump(XAssetInfo<IW5::GfxImage>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::GfxImage>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::GfxImage>* asset) override;
private: private:
std::unique_ptr<IImageWriter> m_writer; std::unique_ptr<IImageWriter> m_writer;

11
src/ObjWriting/Game/IW5/Leaderboard/LeaderboardJsonDumperIW5.cpp
View File

@@ -94,19 +94,14 @@ namespace
namespace leaderboard namespace leaderboard
{ {
bool JsonDumperIW5::ShouldDump(XAssetInfo<LeaderboardDef>* asset) void JsonDumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LeaderboardDef>& asset)
{ {
return true; const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAsset(asset.m_name));
}
void JsonDumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<LeaderboardDef>* asset)
{
const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAsset(asset->m_name));
if (!assetFile) if (!assetFile)
return; return;
Dumper dumper(*assetFile); Dumper dumper(*assetFile);
dumper.Dump(*asset->Asset()); dumper.Dump(*asset.Asset());
} }
} // namespace leaderboard } // namespace leaderboard

3
src/ObjWriting/Game/IW5/Leaderboard/LeaderboardJsonDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace leaderboard
class JsonDumperIW5 final : public AbstractAssetDumper<IW5::LeaderboardDef> class JsonDumperIW5 final : public AbstractAssetDumper<IW5::LeaderboardDef>
{ {
protected: protected:
[[nodiscard]] bool ShouldDump(XAssetInfo<IW5::LeaderboardDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::LeaderboardDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::LeaderboardDef>* asset) override;
}; };
} // namespace leaderboard } // namespace leaderboard

13
src/ObjWriting/Game/IW5/Localize/LocalizeDumperIW5.cpp
View File

@@ -11,9 +11,14 @@ using namespace IW5;
namespace localize namespace localize
{ {
void DumperIW5::DumpPool(AssetDumpingContext& context, AssetPool<IW5::LocalizeEntry>* pool) size_t DumperIW5::GetProgressTotalCount(const AssetPool<IW5::LocalizeEntry>& pool) const
{ {
if (pool->m_asset_lookup.empty()) return pool.m_asset_lookup.empty() ? 0uz : 1uz;
}
void DumperIW5::DumpPool(AssetDumpingContext& context, const AssetPool<LocalizeEntry>& pool)
{
if (pool.m_asset_lookup.empty())
return; return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language); const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -30,7 +35,7 @@ namespace localize
stringFileDumper.SetNotes(""); stringFileDumper.SetNotes("");
for (auto* localizeEntry : *pool) for (const auto* localizeEntry : pool)
{ {
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value); stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
} }
@@ -41,5 +46,7 @@ namespace localize
{ {
con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name); con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name);
} }
context.IncrementProgress();
} }
} // namespace localize } // namespace localize

3
src/ObjWriting/Game/IW5/Localize/LocalizeDumperIW5.h
View File

@@ -8,6 +8,7 @@ namespace localize
class DumperIW5 final : public IAssetDumper<IW5::LocalizeEntry> class DumperIW5 final : public IAssetDumper<IW5::LocalizeEntry>
{ {
public: public:
void DumpPool(AssetDumpingContext& context, AssetPool<IW5::LocalizeEntry>* pool) override; [[nodiscard]] size_t GetProgressTotalCount(const AssetPool<IW5::LocalizeEntry>& pool) const override;
void DumpPool(AssetDumpingContext& context, const AssetPool<IW5::LocalizeEntry>& pool) override;
}; };
} // namespace localize } // namespace localize

11
src/ObjWriting/Game/IW5/Maps/AddonMapEntsDumperIW5.cpp
View File

@@ -7,15 +7,10 @@ using namespace IW5;
namespace addon_map_ents namespace addon_map_ents
{ {
bool DumperIW5::ShouldDump(XAssetInfo<AddonMapEnts>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AddonMapEnts>& asset)
{ {
return true; const auto* addonMapEnts = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<AddonMapEnts>* asset)
{
const auto* addonMapEnts = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/Maps/AddonMapEntsDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace addon_map_ents
class DumperIW5 final : public AbstractAssetDumper<IW5::AddonMapEnts> class DumperIW5 final : public AbstractAssetDumper<IW5::AddonMapEnts>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::AddonMapEnts>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::AddonMapEnts>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::AddonMapEnts>* asset) override;
}; };
} // namespace addon_map_ents } // namespace addon_map_ents

21
src/ObjWriting/Game/IW5/Menu/MenuDumperIW5.cpp
View File

@@ -15,10 +15,10 @@ using namespace IW5;
namespace namespace
{ {
const MenuList* GetParentMenuList(XAssetInfo<menuDef_t>* asset) const MenuList* GetParentMenuList(const XAssetInfo<menuDef_t>& asset)
{ {
const auto* menu = asset->Asset(); const auto* menu = asset.Asset();
const auto* gameAssetPool = dynamic_cast<GameAssetPoolIW5*>(asset->m_zone->m_pools.get()); const auto* gameAssetPool = dynamic_cast<GameAssetPoolIW5*>(asset.m_zone->m_pools.get());
for (const auto* menuList : *gameAssetPool->m_menu_list) for (const auto* menuList : *gameAssetPool->m_menu_list)
{ {
const auto* menuListAsset = menuList->Asset(); const auto* menuListAsset = menuList->Asset();
@@ -33,32 +33,27 @@ namespace
return nullptr; return nullptr;
} }
std::string GetPathForMenu(XAssetInfo<menuDef_t>* asset) std::string GetPathForMenu(const XAssetInfo<menuDef_t>& asset)
{ {
const auto* list = GetParentMenuList(asset); const auto* list = GetParentMenuList(asset);
if (!list) if (!list)
return std::format("ui_mp/{}.menu", asset->Asset()->window.name); return std::format("ui_mp/{}.menu", asset.Asset()->window.name);
const fs::path p(list->name); const fs::path p(list->name);
std::string parentPath; std::string parentPath;
if (p.has_parent_path()) if (p.has_parent_path())
parentPath = p.parent_path().string() + "/"; parentPath = p.parent_path().string() + "/";
return std::format("{}{}.menu", parentPath, asset->Asset()->window.name); return std::format("{}{}.menu", parentPath, asset.Asset()->window.name);
} }
} // namespace } // namespace
namespace menu namespace menu
{ {
bool MenuDumperIW5::ShouldDump(XAssetInfo<menuDef_t>* asset) void MenuDumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<menuDef_t>& asset)
{ {
return true; const auto* menu = asset.Asset();
}
void MenuDumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<menuDef_t>* asset)
{
const auto* menu = asset->Asset();
const auto menuFilePath = GetPathForMenu(asset); const auto menuFilePath = GetPathForMenu(asset);
if (ObjWriting::ShouldHandleAssetType(ASSET_TYPE_MENULIST)) if (ObjWriting::ShouldHandleAssetType(ASSET_TYPE_MENULIST))

3
src/ObjWriting/Game/IW5/Menu/MenuDumperIW5.h
View File

@@ -9,7 +9,6 @@ namespace menu
class MenuDumperIW5 final : public AbstractAssetDumper<IW5::menuDef_t> class MenuDumperIW5 final : public AbstractAssetDumper<IW5::menuDef_t>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::menuDef_t>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::menuDef_t>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::menuDef_t>* asset) override;
}; };
} // namespace menu } // namespace menu

11
src/ObjWriting/Game/IW5/Menu/MenuListDumperIW5.cpp
View File

@@ -106,15 +106,10 @@ namespace
namespace menu namespace menu
{ {
bool MenuListDumperIW5::ShouldDump(XAssetInfo<MenuList>* asset) void MenuListDumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MenuList>& asset)
{ {
return true; const auto* menuList = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void MenuListDumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<MenuList>* asset)
{
const auto* menuList = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/Menu/MenuListDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace menu
class MenuListDumperIW5 final : public AbstractAssetDumper<IW5::MenuList> class MenuListDumperIW5 final : public AbstractAssetDumper<IW5::MenuList>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::MenuList>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::MenuList>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::MenuList>* asset) override;
}; };
} // namespace menu } // namespace menu

16
src/ObjWriting/Game/IW5/ObjWriterIW5.cpp
View File

@@ -25,10 +25,20 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \ if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \
{ \ { \
dumperType dumper; \ dumperType dumper; \
dumper.DumpPool(context, assetPools->poolName.get()); \ totalProgress += dumper.GetProgressTotalCount(*assetPools->poolName); \
dumpingFunctions.emplace_back( \
[](AssetDumpingContext& funcContext, const GameAssetPoolIW5* funcPools) \
{ \
dumperType dumper; \
dumper.DumpPool(funcContext, *funcPools->poolName); \
}); \
} }
const auto* assetPools = dynamic_cast<GameAssetPoolIW5*>(context.m_zone.m_pools.get()); const auto* assetPools = dynamic_cast<GameAssetPoolIW5*>(context.m_zone.m_pools.get());
size_t totalProgress = 0uz;
std::vector<std::function<void(AssetDumpingContext & context, const GameAssetPoolIW5*)>> dumpingFunctions;
// DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET) // DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET)
// DUMP_ASSET_POOL(AssetDumperPhysCollmap, m_phys_collmap, ASSET_TYPE_PHYSCOLLMAP) // DUMP_ASSET_POOL(AssetDumperPhysCollmap, m_phys_collmap, ASSET_TYPE_PHYSCOLLMAP)
// DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS) // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS)
@@ -70,6 +80,10 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
// DUMP_ASSET_POOL(AssetDumperVehicleDef, m_vehicle, ASSET_TYPE_VEHICLE) // DUMP_ASSET_POOL(AssetDumperVehicleDef, m_vehicle, ASSET_TYPE_VEHICLE)
DUMP_ASSET_POOL(addon_map_ents::DumperIW5, m_addon_map_ents, ASSET_TYPE_ADDON_MAP_ENTS) DUMP_ASSET_POOL(addon_map_ents::DumperIW5, m_addon_map_ents, ASSET_TYPE_ADDON_MAP_ENTS)
context.SetTotalProgress(totalProgress);
for (const auto& func : dumpingFunctions)
func(context, assetPools);
return true; return true;
#undef DUMP_ASSET_POOL #undef DUMP_ASSET_POOL

11
src/ObjWriting/Game/IW5/RawFile/RawFileDumperIW5.cpp
View File

@@ -10,15 +10,10 @@ using namespace IW5;
namespace raw_file namespace raw_file
{ {
bool DumperIW5::ShouldDump(XAssetInfo<RawFile>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset)
{ {
return true; const auto* rawFile = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<RawFile>* asset)
{
const auto* rawFile = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/RawFile/RawFileDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace raw_file
class DumperIW5 final : public AbstractAssetDumper<IW5::RawFile> class DumperIW5 final : public AbstractAssetDumper<IW5::RawFile>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::RawFile>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::RawFile>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::RawFile>* asset) override;
}; };
} // namespace raw_file } // namespace raw_file

19
src/ObjWriting/Game/IW5/Script/ScriptDumperIW5.cpp
View File

@@ -4,16 +4,11 @@ using namespace IW5;
namespace script namespace script
{ {
bool DumperIW5::ShouldDump(XAssetInfo<IW5::ScriptFile>* asset)
{
return true;
}
// See https://github.com/xensik/gsc-tool#file-format for an in-depth explanation about the .gscbin format // See https://github.com/xensik/gsc-tool#file-format for an in-depth explanation about the .gscbin format
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::ScriptFile>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<ScriptFile>& asset)
{ {
auto* scriptFile = asset->Asset(); auto* scriptFile = asset.Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name + ".gscbin"); const auto assetFile = context.OpenAssetFile(asset.m_name + ".gscbin");
if (!assetFile) if (!assetFile)
return; return;
@@ -21,10 +16,10 @@ namespace script
auto& stream = *assetFile; auto& stream = *assetFile;
// Dump the name and the numeric fields // Dump the name and the numeric fields
stream.write(asset->m_name.c_str(), asset->m_name.size() + 1); stream.write(asset.m_name.c_str(), asset.m_name.size() + 1);
stream.write(reinterpret_cast<char*>(&scriptFile->compressedLen), sizeof(scriptFile->compressedLen)); stream.write(reinterpret_cast<const char*>(&scriptFile->compressedLen), sizeof(scriptFile->compressedLen));
stream.write(reinterpret_cast<char*>(&scriptFile->len), sizeof(scriptFile->len)); stream.write(reinterpret_cast<const char*>(&scriptFile->len), sizeof(scriptFile->len));
stream.write(reinterpret_cast<char*>(&scriptFile->bytecodeLen), sizeof(scriptFile->bytecodeLen)); stream.write(reinterpret_cast<const char*>(&scriptFile->bytecodeLen), sizeof(scriptFile->bytecodeLen));
// Dump the buffers // Dump the buffers
stream.write(scriptFile->buffer, scriptFile->compressedLen); stream.write(scriptFile->buffer, scriptFile->compressedLen);

3
src/ObjWriting/Game/IW5/Script/ScriptDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace script
class DumperIW5 final : public AbstractAssetDumper<IW5::ScriptFile> class DumperIW5 final : public AbstractAssetDumper<IW5::ScriptFile>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::ScriptFile>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::ScriptFile>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::ScriptFile>* asset) override;
}; };
} // namespace script } // namespace script

11
src/ObjWriting/Game/IW5/Sound/LoadedSoundDumperIW5.cpp
View File

@@ -25,15 +25,10 @@ namespace
namespace sound namespace sound
{ {
bool LoadedSoundDumperIW5::ShouldDump(XAssetInfo<LoadedSound>* asset) void LoadedSoundDumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LoadedSound>& asset)
{ {
return true; const auto* loadedSound = asset.Asset();
} const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset.m_name));
void LoadedSoundDumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<LoadedSound>* asset)
{
const auto* loadedSound = asset->Asset();
const auto assetFile = context.OpenAssetFile(std::format("sound/{}", asset->m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/Sound/LoadedSoundDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace sound
class LoadedSoundDumperIW5 final : public AbstractAssetDumper<IW5::LoadedSound> class LoadedSoundDumperIW5 final : public AbstractAssetDumper<IW5::LoadedSound>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::LoadedSound>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::LoadedSound>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::LoadedSound>* asset) override;
}; };
} // namespace sound } // namespace sound

11
src/ObjWriting/Game/IW5/StringTable/StringTableDumperIW5.cpp
View File

@@ -6,15 +6,10 @@ using namespace IW5;
namespace string_table namespace string_table
{ {
bool DumperIW5::ShouldDump(XAssetInfo<StringTable>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& asset)
{ {
return true; const auto* stringTable = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<StringTable>* asset)
{
const auto* stringTable = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/StringTable/StringTableDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace string_table
class DumperIW5 final : public AbstractAssetDumper<IW5::StringTable> class DumperIW5 final : public AbstractAssetDumper<IW5::StringTable>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::StringTable>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::StringTable>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::StringTable>* asset) override;
}; };
} // namespace string_table } // namespace string_table

11
src/ObjWriting/Game/IW5/Weapon/AttachmentJsonDumperIW5.cpp
View File

@@ -395,19 +395,14 @@ namespace
namespace attachment namespace attachment
{ {
bool JsonDumperIW5::ShouldDump(XAssetInfo<WeaponAttachment>* asset) void JsonDumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<WeaponAttachment>& asset)
{ {
return true; const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAssetName(asset.m_name));
}
void JsonDumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<WeaponAttachment>* asset)
{
const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAssetName(asset->m_name));
if (!assetFile) if (!assetFile)
return; return;
const JsonDumperImpl dumper(context, *assetFile); const JsonDumperImpl dumper(context, *assetFile);
dumper.Dump(asset->Asset()); dumper.Dump(asset.Asset());
} }
} // namespace attachment } // namespace attachment

3
src/ObjWriting/Game/IW5/Weapon/AttachmentJsonDumperIW5.h
View File

@@ -8,7 +8,6 @@ namespace attachment
class JsonDumperIW5 final : public AbstractAssetDumper<IW5::WeaponAttachment> class JsonDumperIW5 final : public AbstractAssetDumper<IW5::WeaponAttachment>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::WeaponAttachment>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::WeaponAttachment>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::WeaponAttachment>* asset) override;
}; };
} // namespace attachment } // namespace attachment

25
src/ObjWriting/Game/IW5/Weapon/WeaponDumperIW5.cpp
View File

@@ -681,31 +681,31 @@ namespace
} }
} }
InfoString CreateInfoString(XAssetInfo<WeaponCompleteDef>* asset) InfoString CreateInfoString(const XAssetInfo<WeaponCompleteDef>& asset)
{ {
const auto fullDef = std::make_unique<WeaponFullDef>(); const auto fullDef = std::make_unique<WeaponFullDef>();
memset(fullDef.get(), 0, sizeof(WeaponFullDef)); memset(fullDef.get(), 0, sizeof(WeaponFullDef));
CopyToFullDef(asset->Asset(), fullDef.get()); CopyToFullDef(asset.Asset(), fullDef.get());
InfoStringFromWeaponConverter converter(fullDef.get(), InfoStringFromWeaponConverter converter(fullDef.get(),
weapon_fields, weapon_fields,
std::extent_v<decltype(weapon_fields)>, std::extent_v<decltype(weapon_fields)>,
[asset](const scr_string_t scrStr) -> std::string [asset](const scr_string_t scrStr) -> std::string
{ {
assert(scrStr < asset->m_zone->m_script_strings.Count()); assert(scrStr < asset.m_zone->m_script_strings.Count());
if (scrStr >= asset->m_zone->m_script_strings.Count()) if (scrStr >= asset.m_zone->m_script_strings.Count())
return ""; return "";
return asset->m_zone->m_script_strings[scrStr]; return asset.m_zone->m_script_strings[scrStr];
}); });
return converter.Convert(); return converter.Convert();
} }
void DumpAccuracyGraphs(AssetDumpingContext& context, XAssetInfo<WeaponCompleteDef>* asset) void DumpAccuracyGraphs(AssetDumpingContext& context, const XAssetInfo<WeaponCompleteDef>& asset)
{ {
auto* accuracyGraphWriter = context.GetZoneAssetDumperState<AccuracyGraphWriter>(); auto* accuracyGraphWriter = context.GetZoneAssetDumperState<AccuracyGraphWriter>();
const auto weapon = asset->Asset(); const auto weapon = asset.Asset();
const auto* weapDef = weapon->weapDef; const auto* weapDef = weapon->weapDef;
if (!weapDef) if (!weapDef)
@@ -733,12 +733,7 @@ namespace
namespace weapon namespace weapon
{ {
bool DumperIW5::ShouldDump(XAssetInfo<WeaponCompleteDef>* asset) void DumperIW5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<WeaponCompleteDef>& asset)
{
return true;
}
void DumperIW5::DumpAsset(AssetDumpingContext& context, XAssetInfo<WeaponCompleteDef>* asset)
{ {
// TODO: only dump infostring fields when non-default // TODO: only dump infostring fields when non-default
@@ -746,13 +741,13 @@ namespace weapon
if (context.m_gdt) if (context.m_gdt)
{ {
const auto infoString = CreateInfoString(asset); const auto infoString = CreateInfoString(asset);
GdtEntry gdtEntry(asset->m_name, ObjConstants::GDF_FILENAME_WEAPON); GdtEntry gdtEntry(asset.m_name, ObjConstants::GDF_FILENAME_WEAPON);
infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON, gdtEntry); infoString.ToGdtProperties(ObjConstants::INFO_STRING_PREFIX_WEAPON, gdtEntry);
context.m_gdt->WriteEntry(gdtEntry); context.m_gdt->WriteEntry(gdtEntry);
} }
else else
{ {
const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset->m_name)); const auto assetFile = context.OpenAssetFile(GetFileNameForAssetName(asset.m_name));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/IW5/Weapon/WeaponDumperIW5.h
View File

@@ -9,7 +9,6 @@ namespace weapon
class DumperIW5 final : public AbstractAssetDumper<IW5::WeaponCompleteDef> class DumperIW5 final : public AbstractAssetDumper<IW5::WeaponCompleteDef>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<IW5::WeaponCompleteDef>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::WeaponCompleteDef>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<IW5::WeaponCompleteDef>* asset) override;
}; };
} // namespace weapon } // namespace weapon

11
src/ObjWriting/Game/T5/Image/ImageDumperT5.cpp
View File

@@ -76,19 +76,14 @@ namespace image
} }
} }
bool DumperT5::ShouldDump(XAssetInfo<GfxImage>* asset) void DumperT5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<GfxImage>& asset)
{ {
return true; const auto* image = asset.Asset();
}
void DumperT5::DumpAsset(AssetDumpingContext& context, XAssetInfo<GfxImage>* asset)
{
const auto* image = asset->Asset();
const auto texture = LoadImageData(context.m_obj_search_path, *image); const auto texture = LoadImageData(context.m_obj_search_path, *image);
if (!texture) if (!texture)
return; return;
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name, m_writer->GetFileExtension())); const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset.m_name, m_writer->GetFileExtension()));
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/T5/Image/ImageDumperT5.h
View File

@@ -14,8 +14,7 @@ namespace image
DumperT5(); DumperT5();
protected: protected:
bool ShouldDump(XAssetInfo<T5::GfxImage>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<T5::GfxImage>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<T5::GfxImage>* asset) override;
private: private:
std::unique_ptr<IImageWriter> m_writer; std::unique_ptr<IImageWriter> m_writer;

13
src/ObjWriting/Game/T5/Localize/LocalizeDumperT5.cpp
View File

@@ -11,9 +11,14 @@ using namespace T5;
namespace localize namespace localize
{ {
void DumperT5::DumpPool(AssetDumpingContext& context, AssetPool<LocalizeEntry>* pool) size_t DumperT5::GetProgressTotalCount(const AssetPool<T5::LocalizeEntry>& pool) const
{ {
if (pool->m_asset_lookup.empty()) return pool.m_asset_lookup.empty() ? 0uz : 1uz;
}
void DumperT5::DumpPool(AssetDumpingContext& context, const AssetPool<LocalizeEntry>& pool)
{
if (pool.m_asset_lookup.empty())
return; return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language); const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -30,7 +35,7 @@ namespace localize
stringFileDumper.SetNotes(""); stringFileDumper.SetNotes("");
for (auto* localizeEntry : *pool) for (const auto* localizeEntry : pool)
{ {
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value); stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
} }
@@ -41,5 +46,7 @@ namespace localize
{ {
con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name); con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name);
} }
context.IncrementProgress();
} }
} // namespace localize } // namespace localize

3
src/ObjWriting/Game/T5/Localize/LocalizeDumperT5.h
View File

@@ -8,6 +8,7 @@ namespace localize
class DumperT5 final : public IAssetDumper<T5::LocalizeEntry> class DumperT5 final : public IAssetDumper<T5::LocalizeEntry>
{ {
public: public:
void DumpPool(AssetDumpingContext& context, AssetPool<T5::LocalizeEntry>* pool) override; [[nodiscard]] size_t GetProgressTotalCount(const AssetPool<T5::LocalizeEntry>& pool) const override;
void DumpPool(AssetDumpingContext& context, const AssetPool<T5::LocalizeEntry>& pool) override;
}; };
} // namespace localize } // namespace localize

15
src/ObjWriting/Game/T5/ObjWriterT5.cpp
View File

@@ -17,11 +17,20 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \ if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(assetType)) \
{ \ { \
dumperType dumper; \ dumperType dumper; \
dumper.DumpPool(context, assetPools->poolName.get()); \ totalProgress += dumper.GetProgressTotalCount(*assetPools->poolName); \
dumpingFunctions.emplace_back( \
[](AssetDumpingContext& funcContext, const GameAssetPoolT5* funcPools) \
{ \
dumperType dumper; \
dumper.DumpPool(funcContext, *funcPools->poolName); \
}); \
} }
const auto* assetPools = dynamic_cast<GameAssetPoolT5*>(context.m_zone.m_pools.get()); const auto* assetPools = dynamic_cast<GameAssetPoolT5*>(context.m_zone.m_pools.get());
size_t totalProgress = 0uz;
std::vector<std::function<void(AssetDumpingContext & context, const GameAssetPoolT5*)>> dumpingFunctions;
// DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET) // DUMP_ASSET_POOL(AssetDumperPhysPreset, m_phys_preset, ASSET_TYPE_PHYSPRESET)
// DUMP_ASSET_POOL(AssetDumperPhysConstraints, m_phys_constraints, ASSET_TYPE_PHYSCONSTRAINTS) // DUMP_ASSET_POOL(AssetDumperPhysConstraints, m_phys_constraints, ASSET_TYPE_PHYSCONSTRAINTS)
// DUMP_ASSET_POOL(AssetDumperDestructibleDef, m_destructible_def, ASSET_TYPE_DESTRUCTIBLEDEF) // DUMP_ASSET_POOL(AssetDumperDestructibleDef, m_destructible_def, ASSET_TYPE_DESTRUCTIBLEDEF)
@@ -55,6 +64,10 @@ bool ObjWriter::DumpZone(AssetDumpingContext& context) const
// DUMP_ASSET_POOL(AssetDumperGlasses, m_glasses, ASSET_TYPE_GLASSES) // DUMP_ASSET_POOL(AssetDumperGlasses, m_glasses, ASSET_TYPE_GLASSES)
// DUMP_ASSET_POOL(AssetDumperEmblemSet, m_emblem_set, ASSET_TYPE_EMBLEMSET) // DUMP_ASSET_POOL(AssetDumperEmblemSet, m_emblem_set, ASSET_TYPE_EMBLEMSET)
context.SetTotalProgress(totalProgress);
for (const auto& func : dumpingFunctions)
func(context, assetPools);
return true; return true;
#undef DUMP_ASSET_POOL #undef DUMP_ASSET_POOL

15
src/ObjWriting/Game/T5/RawFile/RawFileDumperT5.cpp
View File

@@ -15,9 +15,9 @@ namespace
{ {
constexpr static size_t GSC_MAX_SIZE = 0xC000000; constexpr static size_t GSC_MAX_SIZE = 0xC000000;
void DumpGsc(AssetDumpingContext& context, XAssetInfo<RawFile>* asset, std::ostream& stream) void DumpGsc(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset, std::ostream& stream)
{ {
const auto* rawFile = asset->Asset(); const auto* rawFile = asset.Asset();
if (rawFile->len <= 8) if (rawFile->len <= 8)
{ {
@@ -96,15 +96,10 @@ namespace
namespace raw_file namespace raw_file
{ {
bool DumperT5::ShouldDump(XAssetInfo<RawFile>* asset) void DumperT5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset)
{ {
return true; const auto* rawFile = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperT5::DumpAsset(AssetDumpingContext& context, XAssetInfo<RawFile>* asset)
{
const auto* rawFile = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/T5/RawFile/RawFileDumperT5.h
View File

@@ -8,7 +8,6 @@ namespace raw_file
class DumperT5 final : public AbstractAssetDumper<T5::RawFile> class DumperT5 final : public AbstractAssetDumper<T5::RawFile>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<T5::RawFile>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<T5::RawFile>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<T5::RawFile>* asset) override;
}; };
} // namespace raw_file } // namespace raw_file

11
src/ObjWriting/Game/T5/StringTable/StringTableDumperT5.cpp
View File

@@ -6,15 +6,10 @@ using namespace T5;
namespace string_table namespace string_table
{ {
bool DumperT5::ShouldDump(XAssetInfo<StringTable>* asset) void DumperT5::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& asset)
{ {
return true; const auto* stringTable = asset.Asset();
} const auto assetFile = context.OpenAssetFile(asset.m_name);
void DumperT5::DumpAsset(AssetDumpingContext& context, XAssetInfo<StringTable>* asset)
{
const auto* stringTable = asset->Asset();
const auto assetFile = context.OpenAssetFile(asset->m_name);
if (!assetFile) if (!assetFile)
return; return;

3
src/ObjWriting/Game/T5/StringTable/StringTableDumperT5.h
View File

@@ -8,7 +8,6 @@ namespace string_table
class DumperT5 final : public AbstractAssetDumper<T5::StringTable> class DumperT5 final : public AbstractAssetDumper<T5::StringTable>
{ {
protected: protected:
bool ShouldDump(XAssetInfo<T5::StringTable>* asset) override; void DumpAsset(AssetDumpingContext& context, const XAssetInfo<T5::StringTable>& asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<T5::StringTable>* asset) override;
}; };
} // namespace string_table } // namespace string_table

Some files were not shown because too many files have changed in this diff Show More