zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-02-10 09:33:03 +00:00
Code Activity

refactor: introduce subasset loading

Browse Source
This commit is contained in:
Jan Laupetin
2026-02-05 16:25:00 +00:00
parent 1be411b371
commit aa47ffa629
255 changed files with 1668 additions and 3132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/Common/Game/IAsset.h
View File

@@ -5,20 +5,39 @@
#include <stdexcept>
#include <type_traits>
struct IAssetBase
{
};
template<asset_type_t AssetTypeEnum, typename AssetType> class Asset : IAssetBase
template<asset_type_t AssetTypeEnum, class AssetType> class Asset
{
public:
static constexpr bool IS_ASSET = true;
static constexpr auto EnumEntry = AssetTypeEnum;
using Type = AssetType;
};
template<typename AssetType> struct AssetNameAccessor
template<asset_type_t AssetTypeEnum, class AssetType> class SubAsset
{
public:
static constexpr bool IS_ASSET = false;
static constexpr auto EnumEntry = AssetTypeEnum;
using Type = AssetType;
};
template<typename T>
concept HasAssetEnumEntry = std::is_integral_v<decltype(T::EnumEntry)>;
template<typename T>
concept HasAssetType = std::is_class_v<typename T::Type>;
template<typename T>
concept AssetOrSubAssetDefinition = HasAssetEnumEntry<T> && HasAssetType<T>;
template<typename T>
concept AssetDefinition = AssetOrSubAssetDefinition<T> && T::IS_ASSET;
template<typename T>
concept SubAssetDefinition = AssetOrSubAssetDefinition<T> && !T::IS_ASSET;
template<AssetOrSubAssetDefinition> struct AssetNameAccessor
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
// static constexpr bool IS_SINGLETON = false;
// using RETURN_TYPE = const char*&;
@@ -32,7 +51,6 @@ template<typename AssetType> struct AssetNameAccessor
template<> struct AssetNameAccessor<assetType> \
{ \
public: \
static_assert(std::is_base_of_v<IAssetBase, assetType>); \
static constexpr bool IS_SINGLETON = false; \
using RETURN_TYPE = const char*&; \
\
@@ -46,7 +64,6 @@ template<typename AssetType> struct AssetNameAccessor
template<> struct AssetNameAccessor<assetType> \
{ \
public: \
static_assert(std::is_base_of_v<IAssetBase, assetType>); \
static constexpr bool IS_SINGLETON = true; \
using RETURN_TYPE = const char* const&; \
\
@@ -57,8 +74,7 @@ template<typename AssetType> struct AssetNameAccessor
} \
}
template<typename AssetType> AssetNameAccessor<AssetType>::RETURN_TYPE AssetName(typename AssetType::Type& asset)
template<AssetDefinition Asset_t> AssetNameAccessor<Asset_t>::RETURN_TYPE AssetName(typename Asset_t::Type& asset)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return AssetNameAccessor<AssetType>::GetAssetName(asset);
return AssetNameAccessor<Asset_t>::GetAssetName(asset);
}

3
src/Common/Game/IGame.h
View File

@@ -69,5 +69,8 @@ public:
[[nodiscard]] virtual asset_type_t GetAssetTypeCount() const = 0;
[[nodiscard]] virtual std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const = 0;
[[nodiscard]] virtual asset_type_t GetSubAssetTypeCount() const = 0;
[[nodiscard]] virtual std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const = 0;
static IGame* GetGameById(GameId gameId);
};

19
src/Common/Game/IW3/GameIW3.cpp
View File

@@ -14,6 +14,12 @@ namespace
"menulist", "menu", "localize", "weapon", "snddriverglobals", "fx", "impactfx", "aitype", "mptype", "character",
"xmodelalias", "rawfile", "stringtable",
};
constexpr const char* SUB_ASSET_TYPE_NAMES[SUB_ASSET_TYPE_COUNT]{
"technique",
"vertexshader",
"pixelshader",
};
} // namespace
namespace IW3
@@ -53,4 +59,17 @@ namespace IW3
return std::nullopt;
}
asset_type_t Game::GetSubAssetTypeCount() const
{
return SUB_ASSET_TYPE_COUNT;
}
std::optional<const char*> Game::GetSubAssetTypeName(const asset_type_t subAssetType) const
{
if (subAssetType < std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
return SUB_ASSET_TYPE_NAMES[subAssetType];
return std::nullopt;
}
} // namespace IW3

2
src/Common/Game/IW3/GameIW3.h
View File

@@ -14,5 +14,7 @@ namespace IW3
[[nodiscard]] asset_type_t GetAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
[[nodiscard]] asset_type_t GetSubAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const override;
};
} // namespace IW3

47
src/Common/Game/IW3/IW3.h
View File

@@ -11,6 +11,53 @@
namespace IW3
{
enum XAssetType
{
ASSET_TYPE_XMODELPIECES,
ASSET_TYPE_PHYSPRESET,
ASSET_TYPE_XANIMPARTS,
ASSET_TYPE_XMODEL,
ASSET_TYPE_MATERIAL,
ASSET_TYPE_TECHNIQUE_SET,
ASSET_TYPE_IMAGE,
ASSET_TYPE_SOUND,
ASSET_TYPE_SOUND_CURVE,
ASSET_TYPE_LOADED_SOUND,
ASSET_TYPE_CLIPMAP,
ASSET_TYPE_CLIPMAP_PVS,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GAMEWORLD_SP,
ASSET_TYPE_GAMEWORLD_MP,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_MENULIST,
ASSET_TYPE_MENU,
ASSET_TYPE_LOCALIZE_ENTRY,
ASSET_TYPE_WEAPON,
ASSET_TYPE_SNDDRIVER_GLOBALS,
ASSET_TYPE_FX,
ASSET_TYPE_IMPACT_FX,
ASSET_TYPE_AITYPE,
ASSET_TYPE_MPTYPE,
ASSET_TYPE_CHARACTER,
ASSET_TYPE_XMODELALIAS,
ASSET_TYPE_RAWFILE,
ASSET_TYPE_STRINGTABLE,
ASSET_TYPE_COUNT
};
enum SubAssetType
{
SUB_ASSET_TYPE_TECHNIQUE,
SUB_ASSET_TYPE_VERTEX_SHADER,
SUB_ASSET_TYPE_PIXEL_SHADER,
SUB_ASSET_TYPE_COUNT
};
struct DB_AuthHash
{

43
src/Common/Game/IW3/IW3_Assets.h
View File

@@ -9,49 +9,6 @@
namespace IW3
{
#endif
enum XAssetType
{
ASSET_TYPE_XMODELPIECES = 0x0,
ASSET_TYPE_PHYSPRESET = 0x1,
ASSET_TYPE_XANIMPARTS = 0x2,
ASSET_TYPE_XMODEL = 0x3,
ASSET_TYPE_MATERIAL = 0x4,
ASSET_TYPE_TECHNIQUE_SET = 0x5,
ASSET_TYPE_IMAGE = 0x6,
ASSET_TYPE_SOUND = 0x7,
ASSET_TYPE_SOUND_CURVE = 0x8,
ASSET_TYPE_LOADED_SOUND = 0x9,
ASSET_TYPE_CLIPMAP = 0xA,
ASSET_TYPE_CLIPMAP_PVS = 0xB,
ASSET_TYPE_COMWORLD = 0xC,
ASSET_TYPE_GAMEWORLD_SP = 0xD,
ASSET_TYPE_GAMEWORLD_MP = 0xE,
ASSET_TYPE_MAP_ENTS = 0xF,
ASSET_TYPE_GFXWORLD = 0x10,
ASSET_TYPE_LIGHT_DEF = 0x11,
ASSET_TYPE_UI_MAP = 0x12,
ASSET_TYPE_FONT = 0x13,
ASSET_TYPE_MENULIST = 0x14,
ASSET_TYPE_MENU = 0x15,
ASSET_TYPE_LOCALIZE_ENTRY = 0x16,
ASSET_TYPE_WEAPON = 0x17,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x18,
ASSET_TYPE_FX = 0x19,
ASSET_TYPE_IMPACT_FX = 0x1A,
ASSET_TYPE_AITYPE = 0x1B,
ASSET_TYPE_MPTYPE = 0x1C,
ASSET_TYPE_CHARACTER = 0x1D,
ASSET_TYPE_XMODELALIAS = 0x1E,
ASSET_TYPE_RAWFILE = 0x1F,
ASSET_TYPE_STRINGTABLE = 0x20,
ASSET_TYPE_COUNT,
ASSET_TYPE_STRING = ASSET_TYPE_COUNT,
ASSET_TYPE_ASSETLIST,
ASSET_TYPE_FULLCOUNT
};
enum XFileBlock
{
XFILE_BLOCK_TEMP,

17
src/Common/Game/IW4/GameIW4.cpp
View File

@@ -19,6 +19,10 @@ namespace
"xmodelalias", "rawfile", "stringtable", "leaderboard", "structureddatadef",
"tracer", "vehicle", "addonmapents",
};
constexpr const char* SUB_ASSET_TYPE_NAMES[SUB_ASSET_TYPE_COUNT]{
"technique",
};
} // namespace
namespace IW4
@@ -58,4 +62,17 @@ namespace IW4
return std::nullopt;
}
asset_type_t Game::GetSubAssetTypeCount() const
{
return SUB_ASSET_TYPE_COUNT;
}
std::optional<const char*> Game::GetSubAssetTypeName(const asset_type_t subAssetType) const
{
if (subAssetType < std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
return SUB_ASSET_TYPE_NAMES[subAssetType];
return std::nullopt;
}
} // namespace IW4

2
src/Common/Game/IW4/GameIW4.h
View File

@@ -13,5 +13,7 @@ namespace IW4
[[nodiscard]] asset_type_t GetAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
[[nodiscard]] asset_type_t GetSubAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const override;
};
} // namespace IW4

56
src/Common/Game/IW4/IW4.h
View File

@@ -11,6 +11,62 @@
namespace IW4
{
enum XAssetType
{
ASSET_TYPE_PHYSPRESET,
ASSET_TYPE_PHYSCOLLMAP,
ASSET_TYPE_XANIMPARTS,
ASSET_TYPE_XMODEL_SURFS,
ASSET_TYPE_XMODEL,
ASSET_TYPE_MATERIAL,
ASSET_TYPE_PIXELSHADER,
ASSET_TYPE_VERTEXSHADER,
ASSET_TYPE_VERTEXDECL,
ASSET_TYPE_TECHNIQUE_SET,
ASSET_TYPE_IMAGE,
ASSET_TYPE_SOUND,
ASSET_TYPE_SOUND_CURVE,
ASSET_TYPE_LOADED_SOUND,
ASSET_TYPE_CLIPMAP_SP,
ASSET_TYPE_CLIPMAP_MP,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GAMEWORLD_SP,
ASSET_TYPE_GAMEWORLD_MP,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_FXWORLD,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_MENULIST,
ASSET_TYPE_MENU,
ASSET_TYPE_LOCALIZE_ENTRY,
ASSET_TYPE_WEAPON,
ASSET_TYPE_SNDDRIVER_GLOBALS,
ASSET_TYPE_FX,
ASSET_TYPE_IMPACT_FX,
ASSET_TYPE_AITYPE,
ASSET_TYPE_MPTYPE,
ASSET_TYPE_CHARACTER,
ASSET_TYPE_XMODELALIAS,
ASSET_TYPE_RAWFILE,
ASSET_TYPE_STRINGTABLE,
ASSET_TYPE_LEADERBOARD,
ASSET_TYPE_STRUCTURED_DATA_DEF,
ASSET_TYPE_TRACER,
ASSET_TYPE_VEHICLE,
ASSET_TYPE_ADDON_MAP_ENTS,
ASSET_TYPE_COUNT
};
enum SubAssetType
{
SUB_ASSET_TYPE_TECHNIQUE,
SUB_ASSET_TYPE_COUNT
};
struct DB_AuthHash
{
char bytes[32];

53
src/Common/Game/IW4/IW4_Assets.h
View File

@@ -9,59 +9,6 @@
namespace IW4
{
#endif
enum XAssetType
{
ASSET_TYPE_PHYSPRESET = 0x0,
ASSET_TYPE_PHYSCOLLMAP = 0x1,
ASSET_TYPE_XANIMPARTS = 0x2,
ASSET_TYPE_XMODEL_SURFS = 0x3,
ASSET_TYPE_XMODEL = 0x4,
ASSET_TYPE_MATERIAL = 0x5,
ASSET_TYPE_PIXELSHADER = 0x6,
ASSET_TYPE_VERTEXSHADER = 0x7,
ASSET_TYPE_VERTEXDECL = 0x8,
ASSET_TYPE_TECHNIQUE_SET = 0x9,
ASSET_TYPE_IMAGE = 0xA,
ASSET_TYPE_SOUND = 0xB,
ASSET_TYPE_SOUND_CURVE = 0xC,
ASSET_TYPE_LOADED_SOUND = 0xD,
ASSET_TYPE_CLIPMAP_SP = 0xE,
ASSET_TYPE_CLIPMAP_MP = 0xF,
ASSET_TYPE_COMWORLD = 0x10,
ASSET_TYPE_GAMEWORLD_SP = 0x11,
ASSET_TYPE_GAMEWORLD_MP = 0x12,
ASSET_TYPE_MAP_ENTS = 0x13,
ASSET_TYPE_FXWORLD = 0x14,
ASSET_TYPE_GFXWORLD = 0x15,
ASSET_TYPE_LIGHT_DEF = 0x16,
ASSET_TYPE_UI_MAP = 0x17,
ASSET_TYPE_FONT = 0x18,
ASSET_TYPE_MENULIST = 0x19,
ASSET_TYPE_MENU = 0x1A,
ASSET_TYPE_LOCALIZE_ENTRY = 0x1B,
ASSET_TYPE_WEAPON = 0x1C,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x1D,
ASSET_TYPE_FX = 0x1E,
ASSET_TYPE_IMPACT_FX = 0x1F,
ASSET_TYPE_AITYPE = 0x20,
ASSET_TYPE_MPTYPE = 0x21,
ASSET_TYPE_CHARACTER = 0x22,
ASSET_TYPE_XMODELALIAS = 0x23,
ASSET_TYPE_RAWFILE = 0x24,
ASSET_TYPE_STRINGTABLE = 0x25,
ASSET_TYPE_LEADERBOARD = 0x26,
ASSET_TYPE_STRUCTURED_DATA_DEF = 0x27,
ASSET_TYPE_TRACER = 0x28,
ASSET_TYPE_VEHICLE = 0x29,
ASSET_TYPE_ADDON_MAP_ENTS = 0x2A,
ASSET_TYPE_COUNT,
ASSET_TYPE_STRING = ASSET_TYPE_COUNT,
ASSET_TYPE_ASSETLIST = 0x2C,
ASSET_TYPE_FULLCOUNT
};
enum XFileBlock
{
XFILE_BLOCK_TEMP,

17
src/Common/Game/IW5/GameIW5.cpp
View File

@@ -56,6 +56,10 @@ namespace
"vehicle",
"addonmapents",
};
constexpr const char* SUB_ASSET_TYPE_NAMES[SUB_ASSET_TYPE_COUNT]{
"technique",
};
} // namespace
namespace IW5
@@ -95,4 +99,17 @@ namespace IW5
return std::nullopt;
}
asset_type_t Game::GetSubAssetTypeCount() const
{
return SUB_ASSET_TYPE_COUNT;
}
std::optional<const char*> Game::GetSubAssetTypeName(const asset_type_t subAssetType) const
{
if (subAssetType < std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
return SUB_ASSET_TYPE_NAMES[subAssetType];
return std::nullopt;
}
} // namespace IW5

2
src/Common/Game/IW5/GameIW5.h
View File

@@ -13,5 +13,7 @@ namespace IW5
[[nodiscard]] asset_type_t GetAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
[[nodiscard]] asset_type_t GetSubAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const override;
};
} // namespace IW5

59
src/Common/Game/IW5/IW5.h
View File

@@ -11,6 +11,65 @@
namespace IW5
{
enum XAssetType
{
ASSET_TYPE_PHYSPRESET,
ASSET_TYPE_PHYSCOLLMAP,
ASSET_TYPE_XANIMPARTS,
ASSET_TYPE_XMODEL_SURFS,
ASSET_TYPE_XMODEL,
ASSET_TYPE_MATERIAL,
ASSET_TYPE_PIXELSHADER,
ASSET_TYPE_VERTEXSHADER,
ASSET_TYPE_VERTEXDECL,
ASSET_TYPE_TECHNIQUE_SET,
ASSET_TYPE_IMAGE,
ASSET_TYPE_SOUND,
ASSET_TYPE_SOUND_CURVE,
ASSET_TYPE_LOADED_SOUND,
ASSET_TYPE_CLIPMAP,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GLASSWORLD,
ASSET_TYPE_PATHDATA,
ASSET_TYPE_VEHICLE_TRACK,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_FXWORLD,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_MENULIST,
ASSET_TYPE_MENU,
ASSET_TYPE_LOCALIZE_ENTRY,
ASSET_TYPE_ATTACHMENT,
ASSET_TYPE_WEAPON,
ASSET_TYPE_SNDDRIVER_GLOBALS,
ASSET_TYPE_FX,
ASSET_TYPE_IMPACT_FX,
ASSET_TYPE_SURFACE_FX,
ASSET_TYPE_AITYPE,
ASSET_TYPE_MPTYPE,
ASSET_TYPE_CHARACTER,
ASSET_TYPE_XMODELALIAS,
ASSET_TYPE_RAWFILE,
ASSET_TYPE_SCRIPTFILE,
ASSET_TYPE_STRINGTABLE,
ASSET_TYPE_LEADERBOARD,
ASSET_TYPE_STRUCTURED_DATA_DEF,
ASSET_TYPE_TRACER,
ASSET_TYPE_VEHICLE,
ASSET_TYPE_ADDON_MAP_ENTS,
ASSET_TYPE_COUNT
};
enum SubAssetType
{
SUB_ASSET_TYPE_TECHNIQUE,
SUB_ASSET_TYPE_COUNT
};
struct DB_AuthHash
{
char bytes[32];

56
src/Common/Game/IW5/IW5_Assets.h
View File

@@ -17,62 +17,6 @@ namespace IW5
{
#endif
#endif
enum XAssetType
{
ASSET_TYPE_PHYSPRESET = 0x0,
ASSET_TYPE_PHYSCOLLMAP = 0x1,
ASSET_TYPE_XANIMPARTS = 0x2,
ASSET_TYPE_XMODEL_SURFS = 0x3,
ASSET_TYPE_XMODEL = 0x4,
ASSET_TYPE_MATERIAL = 0x5,
ASSET_TYPE_PIXELSHADER = 0x6,
ASSET_TYPE_VERTEXSHADER = 0x7,
ASSET_TYPE_VERTEXDECL = 0x8,
ASSET_TYPE_TECHNIQUE_SET = 0x9,
ASSET_TYPE_IMAGE = 0xA,
ASSET_TYPE_SOUND = 0xB,
ASSET_TYPE_SOUND_CURVE = 0xC,
ASSET_TYPE_LOADED_SOUND = 0xD,
ASSET_TYPE_CLIPMAP = 0xE,
ASSET_TYPE_COMWORLD = 0xF,
ASSET_TYPE_GLASSWORLD = 0x10,
ASSET_TYPE_PATHDATA = 0x11,
ASSET_TYPE_VEHICLE_TRACK = 0x12,
ASSET_TYPE_MAP_ENTS = 0x13,
ASSET_TYPE_FXWORLD = 0x14,
ASSET_TYPE_GFXWORLD = 0x15,
ASSET_TYPE_LIGHT_DEF = 0x16,
ASSET_TYPE_UI_MAP = 0x17,
ASSET_TYPE_FONT = 0x18,
ASSET_TYPE_MENULIST = 0x19,
ASSET_TYPE_MENU = 0x1A,
ASSET_TYPE_LOCALIZE_ENTRY = 0x1B,
ASSET_TYPE_ATTACHMENT = 0x1C,
ASSET_TYPE_WEAPON = 0x1D,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x1E,
ASSET_TYPE_FX = 0x1F,
ASSET_TYPE_IMPACT_FX = 0x20,
ASSET_TYPE_SURFACE_FX = 0x21,
ASSET_TYPE_AITYPE = 0x22,
ASSET_TYPE_MPTYPE = 0x23,
ASSET_TYPE_CHARACTER = 0x24,
ASSET_TYPE_XMODELALIAS = 0x25,
ASSET_TYPE_RAWFILE = 0x26,
ASSET_TYPE_SCRIPTFILE = 0x27,
ASSET_TYPE_STRINGTABLE = 0x28,
ASSET_TYPE_LEADERBOARD = 0x29,
ASSET_TYPE_STRUCTURED_DATA_DEF = 0x2A,
ASSET_TYPE_TRACER = 0x2B,
ASSET_TYPE_VEHICLE = 0x2C,
ASSET_TYPE_ADDON_MAP_ENTS = 0x2D,
ASSET_TYPE_COUNT,
ASSET_TYPE_STRING = ASSET_TYPE_COUNT,
ASSET_TYPE_ASSETLIST = 0x2F,
ASSET_TYPE_FULLCOUNT
};
enum XFileBlock
{
XFILE_BLOCK_TEMP,

19
src/Common/Game/T5/GameT5.cpp
View File

@@ -17,6 +17,12 @@ namespace
"xmodelalias", "rawfile", "stringtable", "packindex", "xglobals", "ddl", "glasses",
"emblemset",
};
constexpr const char* SUB_ASSET_TYPE_NAMES[SUB_ASSET_TYPE_COUNT]{
"technique",
"vertexshader",
"pixelshader",
};
} // namespace
namespace T5
@@ -71,4 +77,17 @@ namespace T5
return std::nullopt;
}
asset_type_t Game::GetSubAssetTypeCount() const
{
return SUB_ASSET_TYPE_COUNT;
}
std::optional<const char*> Game::GetSubAssetTypeName(const asset_type_t subAssetType) const
{
if (subAssetType < std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
return SUB_ASSET_TYPE_NAMES[subAssetType];
return std::nullopt;
}
} // namespace T5

2
src/Common/Game/T5/GameT5.h
View File

@@ -13,5 +13,7 @@ namespace T5
[[nodiscard]] asset_type_t GetAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
[[nodiscard]] asset_type_t GetSubAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const override;
};
} // namespace T5

58
src/Common/Game/T5/T5.h
View File

@@ -11,6 +11,64 @@
namespace T5
{
enum XAssetType
{
ASSET_TYPE_XMODELPIECES,
ASSET_TYPE_PHYSPRESET,
ASSET_TYPE_PHYSCONSTRAINTS,
ASSET_TYPE_DESTRUCTIBLEDEF,
ASSET_TYPE_XANIMPARTS,
ASSET_TYPE_XMODEL,
ASSET_TYPE_MATERIAL,
ASSET_TYPE_TECHNIQUE_SET,
ASSET_TYPE_IMAGE,
ASSET_TYPE_SOUND,
ASSET_TYPE_SOUND_PATCH,
ASSET_TYPE_CLIPMAP,
ASSET_TYPE_CLIPMAP_PVS,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GAMEWORLD_SP,
ASSET_TYPE_GAMEWORLD_MP,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_MENULIST,
ASSET_TYPE_MENU,
ASSET_TYPE_LOCALIZE_ENTRY,
ASSET_TYPE_WEAPON,
ASSET_TYPE_WEAPONDEF,
ASSET_TYPE_WEAPON_VARIANT,
ASSET_TYPE_SNDDRIVER_GLOBALS,
ASSET_TYPE_FX,
ASSET_TYPE_IMPACT_FX,
ASSET_TYPE_AITYPE,
ASSET_TYPE_MPTYPE,
ASSET_TYPE_MPBODY,
ASSET_TYPE_MPHEAD,
ASSET_TYPE_CHARACTER,
ASSET_TYPE_XMODELALIAS,
ASSET_TYPE_RAWFILE,
ASSET_TYPE_STRINGTABLE,
ASSET_TYPE_PACK_INDEX,
ASSET_TYPE_XGLOBALS,
ASSET_TYPE_DDL,
ASSET_TYPE_GLASSES,
ASSET_TYPE_EMBLEMSET,
ASSET_TYPE_COUNT
};
enum SubAssetType
{
SUB_ASSET_TYPE_TECHNIQUE = ASSET_TYPE_COUNT,
SUB_ASSET_TYPE_VERTEX_SHADER,
SUB_ASSET_TYPE_PIXEL_SHADER,
SUB_ASSET_TYPE_COUNT
};
struct ScriptStringList
{
int count;

52
src/Common/Game/T5/T5_Assets.h
View File

@@ -43,58 +43,6 @@ namespace T5
struct Glasses;
struct EmblemSet;
enum XAssetType
{
ASSET_TYPE_XMODELPIECES = 0x0,
ASSET_TYPE_PHYSPRESET = 0x1,
ASSET_TYPE_PHYSCONSTRAINTS = 0x2,
ASSET_TYPE_DESTRUCTIBLEDEF = 0x3,
ASSET_TYPE_XANIMPARTS = 0x4,
ASSET_TYPE_XMODEL = 0x5,
ASSET_TYPE_MATERIAL = 0x6,
ASSET_TYPE_TECHNIQUE_SET = 0x7,
ASSET_TYPE_IMAGE = 0x8,
ASSET_TYPE_SOUND = 0x9,
ASSET_TYPE_SOUND_PATCH = 0xA,
ASSET_TYPE_CLIPMAP = 0xB,
ASSET_TYPE_CLIPMAP_PVS = 0xC,
ASSET_TYPE_COMWORLD = 0xD,
ASSET_TYPE_GAMEWORLD_SP = 0xE,
ASSET_TYPE_GAMEWORLD_MP = 0xF,
ASSET_TYPE_MAP_ENTS = 0x10,
ASSET_TYPE_GFXWORLD = 0x11,
ASSET_TYPE_LIGHT_DEF = 0x12,
ASSET_TYPE_UI_MAP = 0x13,
ASSET_TYPE_FONT = 0x14,
ASSET_TYPE_MENULIST = 0x15,
ASSET_TYPE_MENU = 0x16,
ASSET_TYPE_LOCALIZE_ENTRY = 0x17,
ASSET_TYPE_WEAPON = 0x18,
ASSET_TYPE_WEAPONDEF = 0x19,
ASSET_TYPE_WEAPON_VARIANT = 0x1A,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x1B,
ASSET_TYPE_FX = 0x1C,
ASSET_TYPE_IMPACT_FX = 0x1D,
ASSET_TYPE_AITYPE = 0x1E,
ASSET_TYPE_MPTYPE = 0x1F,
ASSET_TYPE_MPBODY = 0x20,
ASSET_TYPE_MPHEAD = 0x21,
ASSET_TYPE_CHARACTER = 0x22,
ASSET_TYPE_XMODELALIAS = 0x23,
ASSET_TYPE_RAWFILE = 0x24,
ASSET_TYPE_STRINGTABLE = 0x25,
ASSET_TYPE_PACK_INDEX = 0x26,
ASSET_TYPE_XGLOBALS = 0x27,
ASSET_TYPE_DDL = 0x28,
ASSET_TYPE_GLASSES = 0x29,
ASSET_TYPE_EMBLEMSET = 0x2A,
ASSET_TYPE_COUNT = 0x2B,
ASSET_TYPE_STRING = 0x2B,
ASSET_TYPE_ASSETLIST = 0x2C,
ASSET_TYPE_FULL_COUNT
};
enum XFileBlock
{
XFILE_BLOCK_TEMP,

19
src/Common/Game/T6/GameT6.cpp
View File

@@ -70,6 +70,12 @@ namespace
"footstepfxtable",
"zbarrier",
};
constexpr const char* SUB_ASSET_TYPE_NAMES[SUB_ASSET_TYPE_COUNT]{
"technique",
"vertexshader",
"pixelshader",
};
} // namespace
namespace T6
@@ -127,4 +133,17 @@ namespace T6
return std::nullopt;
}
asset_type_t Game::GetSubAssetTypeCount() const
{
return SUB_ASSET_TYPE_COUNT;
}
std::optional<const char*> Game::GetSubAssetTypeName(const asset_type_t subAssetType) const
{
if (subAssetType < std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
return SUB_ASSET_TYPE_NAMES[subAssetType];
return std::nullopt;
}
} // namespace T6

2
src/Common/Game/T6/GameT6.h
View File

@@ -13,5 +13,7 @@ namespace T6
[[nodiscard]] asset_type_t GetAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
[[nodiscard]] asset_type_t GetSubAssetTypeCount() const override;
[[nodiscard]] std::optional<const char*> GetSubAssetTypeName(asset_type_t subAssetType) const override;
};
} // namespace T6

82
src/Common/Game/T6/T6.h
View File

@@ -9,8 +9,86 @@
// clang-format on
#include <cstdint>
#include <utility>
namespace T6
{
enum XAssetType
{
ASSET_TYPE_XMODELPIECES,
ASSET_TYPE_PHYSPRESET,
ASSET_TYPE_PHYSCONSTRAINTS,
ASSET_TYPE_DESTRUCTIBLEDEF,
ASSET_TYPE_XANIMPARTS,
ASSET_TYPE_XMODEL,
ASSET_TYPE_MATERIAL,
ASSET_TYPE_TECHNIQUE_SET,
ASSET_TYPE_IMAGE,
ASSET_TYPE_SOUND,
ASSET_TYPE_SOUND_PATCH,
ASSET_TYPE_CLIPMAP,
ASSET_TYPE_CLIPMAP_PVS,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GAMEWORLD_SP,
ASSET_TYPE_GAMEWORLD_MP,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_FONTICON,
ASSET_TYPE_MENULIST,
ASSET_TYPE_MENU,
ASSET_TYPE_LOCALIZE_ENTRY,
ASSET_TYPE_WEAPON,
ASSET_TYPE_WEAPONDEF,
ASSET_TYPE_WEAPON_VARIANT,
ASSET_TYPE_WEAPON_FULL,
ASSET_TYPE_ATTACHMENT,
ASSET_TYPE_ATTACHMENT_UNIQUE,
ASSET_TYPE_WEAPON_CAMO,
ASSET_TYPE_SNDDRIVER_GLOBALS,
ASSET_TYPE_FX,
ASSET_TYPE_IMPACT_FX,
ASSET_TYPE_AITYPE,
ASSET_TYPE_MPTYPE,
ASSET_TYPE_MPBODY,
ASSET_TYPE_MPHEAD,
ASSET_TYPE_CHARACTER,
ASSET_TYPE_XMODELALIAS,
ASSET_TYPE_RAWFILE,
ASSET_TYPE_STRINGTABLE,
ASSET_TYPE_LEADERBOARD,
ASSET_TYPE_XGLOBALS,
ASSET_TYPE_DDL,
ASSET_TYPE_GLASSES,
ASSET_TYPE_EMBLEMSET,
ASSET_TYPE_SCRIPTPARSETREE,
ASSET_TYPE_KEYVALUEPAIRS,
ASSET_TYPE_VEHICLEDEF,
ASSET_TYPE_MEMORYBLOCK,
ASSET_TYPE_ADDON_MAP_ENTS,
ASSET_TYPE_TRACER,
ASSET_TYPE_SKINNEDVERTS,
ASSET_TYPE_QDB,
ASSET_TYPE_SLUG,
ASSET_TYPE_FOOTSTEP_TABLE,
ASSET_TYPE_FOOTSTEPFX_TABLE,
ASSET_TYPE_ZBARRIER,
ASSET_TYPE_COUNT
};
enum SubAssetType
{
SUB_ASSET_TYPE_TECHNIQUE,
SUB_ASSET_TYPE_VERTEX_SHADER,
SUB_ASSET_TYPE_PIXEL_SHADER,
SUB_ASSET_TYPE_COUNT
};
struct ScriptStringList
{
int count;
@@ -208,6 +286,10 @@ namespace T6
using AssetFootstepTable = Asset<ASSET_TYPE_FOOTSTEP_TABLE, FootstepTableDef>;
using AssetFootstepFxTable = Asset<ASSET_TYPE_FOOTSTEPFX_TABLE, FootstepFXTableDef>;
using AssetZBarrier = Asset<ASSET_TYPE_ZBARRIER, ZBarrierDef>;
using SubAssetTechnique = SubAsset<SUB_ASSET_TYPE_TECHNIQUE, MaterialTechnique>;
using SubAssetVertexShader = SubAsset<SUB_ASSET_TYPE_VERTEX_SHADER, MaterialTechnique>;
using SubAssetPixelShader = SubAsset<SUB_ASSET_TYPE_PIXEL_SHADER, MaterialTechnique>;
} // namespace T6
DEFINE_ASSET_NAME_ACCESSOR(T6::AssetPhysPreset, name);

70
src/Common/Game/T6/T6_Assets.h
View File

@@ -236,76 +236,6 @@ namespace T6
struct FootstepTableDef;
struct FootstepFXTableDef;
enum XAssetType
{
ASSET_TYPE_XMODELPIECES = 0x0,
ASSET_TYPE_PHYSPRESET = 0x1,
ASSET_TYPE_PHYSCONSTRAINTS = 0x2,
ASSET_TYPE_DESTRUCTIBLEDEF = 0x3,
ASSET_TYPE_XANIMPARTS = 0x4,
ASSET_TYPE_XMODEL = 0x5,
ASSET_TYPE_MATERIAL = 0x6,
ASSET_TYPE_TECHNIQUE_SET = 0x7,
ASSET_TYPE_IMAGE = 0x8,
ASSET_TYPE_SOUND = 0x9,
ASSET_TYPE_SOUND_PATCH = 0xA,
ASSET_TYPE_CLIPMAP = 0xB,
ASSET_TYPE_CLIPMAP_PVS = 0xC,
ASSET_TYPE_COMWORLD = 0xD,
ASSET_TYPE_GAMEWORLD_SP = 0xE,
ASSET_TYPE_GAMEWORLD_MP = 0xF,
ASSET_TYPE_MAP_ENTS = 0x10,
ASSET_TYPE_GFXWORLD = 0x11,
ASSET_TYPE_LIGHT_DEF = 0x12,
ASSET_TYPE_UI_MAP = 0x13,
ASSET_TYPE_FONT = 0x14,
ASSET_TYPE_FONTICON = 0x15,
ASSET_TYPE_MENULIST = 0x16,
ASSET_TYPE_MENU = 0x17,
ASSET_TYPE_LOCALIZE_ENTRY = 0x18,
ASSET_TYPE_WEAPON = 0x19,
ASSET_TYPE_WEAPONDEF = 0x1A,
ASSET_TYPE_WEAPON_VARIANT = 0x1B,
ASSET_TYPE_WEAPON_FULL = 0x1C,
ASSET_TYPE_ATTACHMENT = 0x1D,
ASSET_TYPE_ATTACHMENT_UNIQUE = 0x1E,
ASSET_TYPE_WEAPON_CAMO = 0x1F,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x20,
ASSET_TYPE_FX = 0x21,
ASSET_TYPE_IMPACT_FX = 0x22,
ASSET_TYPE_AITYPE = 0x23,
ASSET_TYPE_MPTYPE = 0x24,
ASSET_TYPE_MPBODY = 0x25,
ASSET_TYPE_MPHEAD = 0x26,
ASSET_TYPE_CHARACTER = 0x27,
ASSET_TYPE_XMODELALIAS = 0x28,
ASSET_TYPE_RAWFILE = 0x29,
ASSET_TYPE_STRINGTABLE = 0x2A,
ASSET_TYPE_LEADERBOARD = 0x2B,
ASSET_TYPE_XGLOBALS = 0x2C,
ASSET_TYPE_DDL = 0x2D,
ASSET_TYPE_GLASSES = 0x2E,
ASSET_TYPE_EMBLEMSET = 0x2F,
ASSET_TYPE_SCRIPTPARSETREE = 0x30,
ASSET_TYPE_KEYVALUEPAIRS = 0x31,
ASSET_TYPE_VEHICLEDEF = 0x32,
ASSET_TYPE_MEMORYBLOCK = 0x33,
ASSET_TYPE_ADDON_MAP_ENTS = 0x34,
ASSET_TYPE_TRACER = 0x35,
ASSET_TYPE_SKINNEDVERTS = 0x36,
ASSET_TYPE_QDB = 0x37,
ASSET_TYPE_SLUG = 0x38,
ASSET_TYPE_FOOTSTEP_TABLE = 0x39,
ASSET_TYPE_FOOTSTEPFX_TABLE = 0x3A,
ASSET_TYPE_ZBARRIER = 0x3B,
ASSET_TYPE_COUNT = 0x3C,
ASSET_TYPE_STRING = 0x3C,
ASSET_TYPE_ASSETLIST = 0x3D,
ASSET_TYPE_REPORT = 0x3E,
ASSET_TYPE_DEPEND = 0x3F,
ASSET_TYPE_FULL_COUNT = 0x40,
};
enum XFileBlock
{
XFILE_BLOCK_TEMP,

4
src/ModMan/Web/Binds/AssetBinds.cpp
View File

@@ -110,12 +110,12 @@ namespace
std::vector<AssetDto> references;
// Reserve some entries already. Numbers are arbitrary.
const auto assetCount = zone.m_pools->GetTotalAssetCount();
const auto assetCount = zone.m_pools.GetTotalAssetCount();
assets.reserve(assetCount / 2);
references.reserve(assetCount / 8);
const auto& assetTypeMapper = *ICommonAssetTypeMapper::GetCommonAssetMapperByGame(zone.m_game_id);
for (const auto& asset : *zone.m_pools)
for (const auto& asset : zone.m_pools)
{
if (asset->IsReference())
{

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

@@ -1,7 +1,7 @@
#include "UnlinkingBinds.h"
#include "Context/ModManContext.h"
#include "IObjWriter.h"
#include "ObjWriter.h"
#include "SearchPath/OutputPathFilesystem.h"
#include "SearchPath/SearchPaths.h"
#include "Utils/PathUtils.h"
@@ -64,7 +64,7 @@ namespace
const auto& loadedZone = *existingZone->get();
const auto* objWriter = IObjWriter::GetObjWriterForGame(loadedZone.m_zone->m_game_id);
auto* objWriter = IObjWriter::GetObjWriterForGame(loadedZone.m_zone->m_game_id);
const auto outputFolderPath = fs::path(utils::GetExecutablePath()).parent_path() / "zone_dump" / zoneName;
const auto outputFolderPathStr = outputFolderPath.string();

2
src/ObjCompiling/Game/IW4/Material/CompilerMaterialIW4.cpp
View File

@@ -8,7 +8,6 @@
#include "Game/IW4/Techset/TechsetConstantsIW4.h"
#include "Gdt/AbstractGdtEntryReader.h"
#include "Gdt/IGdtQueryable.h"
#include "ObjLoading.h"
#include "Pool/GlobalAssetPool.h"
#include "StateMap/StateMapFromTechniqueExtractor.h"
#include "StateMap/StateMapHandler.h"
@@ -18,6 +17,7 @@
#include "Techset/TechsetDefinitionCache.h"
#include "Utils/Logging/Log.h"
#include <cassert>
#include <cmath>
#include <cstring>
#include <format>

6
src/ObjCompiling/Image/ImageIPakPostProcessor.h
View File

@@ -34,11 +34,9 @@ namespace image
unsigned m_current_ipak_end_index;
};
template<typename AssetType> class IPakPostProcessor final : public AbstractIPakPostProcessor
template<AssetDefinition Asset_t> class IPakPostProcessor final : public AbstractIPakPostProcessor
{
public:
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
IPakPostProcessor(const ZoneDefinitionContext& zoneDefinition,
ISearchPath& searchPath,
ZoneAssetCreationStateContainer& zoneStates,
@@ -49,7 +47,7 @@ namespace image
[[nodiscard]] asset_type_t GetHandlingAssetType() const override
{
return AssetType::EnumEntry;
return Asset_t::EnumEntry;
}
};
} // namespace image

6
src/ObjCompiling/Image/ImageIwdPostProcessor.h
View File

@@ -34,11 +34,9 @@ namespace image
unsigned m_current_iwd_end_index;
};
template<typename AssetType> class IwdPostProcessor final : public AbstractIwdPostProcessor
template<AssetDefinition Asset_t> class IwdPostProcessor final : public AbstractIwdPostProcessor
{
public:
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
IwdPostProcessor(const ZoneDefinitionContext& zoneDefinition, ISearchPath& searchPath, ZoneAssetCreationStateContainer& zoneStates, IOutputPath& outDir)
: AbstractIwdPostProcessor(zoneDefinition, searchPath, zoneStates, outDir)
{
@@ -46,7 +44,7 @@ namespace image
[[nodiscard]] asset_type_t GetHandlingAssetType() const override
{
return AssetType::EnumEntry;
return Asset_t::EnumEntry;
}
};
} // namespace image

51
src/ObjLoading/Asset/AssetCreationContext.cpp
View File

@@ -16,7 +16,7 @@ IgnoredAssetLookup::IgnoredAssetLookup(const AssetList& assetList)
}
}
bool IgnoredAssetLookup::IsAssetIgnored(asset_type_t assetType, const std::string& name) const
bool IgnoredAssetLookup::IsAssetIgnored(const asset_type_t assetType, const std::string& name) const
{
const auto entries = m_ignored_asset_lookup.equal_range(name);
@@ -66,7 +66,8 @@ std::unique_ptr<XAssetInfoGeneric> GenericAssetRegistration::CreateXAssetInfo()
AssetCreationContext::AssetCreationContext(Zone& zone, const AssetCreatorCollection* creators, const IgnoredAssetLookup* ignoredAssetLookup)
: ZoneAssetCreationStateContainer(zone),
m_zone(zone),
m_forced_asset_pools(ZoneAssetPools::CreateForGame(zone.m_game_id, &zone, zone.m_priority)),
m_forced_asset_pools(std::make_unique<ZoneAssetPools>(zone, zone.m_priority)),
m_sub_asset_pools(IGame::GetGameById(zone.m_game_id)->GetSubAssetTypeCount()),
m_creators(creators),
m_ignored_asset_lookup(ignoredAssetLookup),
m_forced_load_depth(0u)
@@ -85,10 +86,27 @@ XAssetInfoGeneric* AssetCreationContext::AddAssetGeneric(GenericAssetRegistratio
if (m_forced_load_depth > 0)
addedAsset = m_forced_asset_pools->AddAsset(std::move(xAssetInfo));
else
addedAsset = m_zone.m_pools->AddAsset(std::move(xAssetInfo));
addedAsset = m_zone.m_pools.AddAsset(std::move(xAssetInfo));
if (addedAsset == nullptr)
con::error(R"(Failed to add asset of type "{}" to pool: "{}")", *IGame::GetGameById(m_zone.m_game_id)->GetAssetTypeName(assetType), pAssetName);
return addedAsset;
}
XAssetInfoGeneric* AssetCreationContext::AddSubAssetGeneric(GenericAssetRegistration registration) const
{
auto xAssetInfo = registration.CreateXAssetInfo();
xAssetInfo->m_zone = &m_zone;
const auto subAssetType = xAssetInfo->m_type;
const auto* pAssetName = xAssetInfo->m_name.c_str();
auto* addedAsset = m_sub_asset_pools[subAssetType]->AddAsset(std::move(xAssetInfo));
if (addedAsset == nullptr)
con::error(R"(Failed to add sub asset of type "{}" to pool: "{}")", *IGame::GetGameById(m_zone.m_game_id)->GetAssetTypeName(subAssetType), pAssetName);
return addedAsset;
}
@@ -103,9 +121,9 @@ XAssetInfoGeneric* AssetCreationContext::LoadDefaultAssetDependency(const asset_
return nullptr;
}
XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_t assetType, const std::string& assetName, bool required)
XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_t assetType, const std::string& assetName, const bool required)
{
auto* alreadyLoadedAsset = m_zone.m_pools->GetAssetOrAssetReference(assetType, assetName);
auto* alreadyLoadedAsset = m_zone.m_pools.GetAssetOrAssetReference(assetType, assetName);
if (alreadyLoadedAsset)
return alreadyLoadedAsset;
@@ -138,9 +156,28 @@ XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_
return nullptr;
}
XAssetInfoGeneric* AssetCreationContext::LoadSubAssetGeneric(const asset_type_t subAssetType, const std::string& assetName)
{
assert(subAssetType < m_sub_asset_pools.size());
auto* alreadyLoadedSubAsset = m_sub_asset_pools[subAssetType]->GetAsset(assetName);
if (alreadyLoadedSubAsset)
return alreadyLoadedSubAsset;
const auto result = m_creators->CreateSubAsset(subAssetType, assetName, *this);
if (result.HasTakenAction())
{
if (!result.HasFailed())
return result.GetAssetInfo();
con::error(R"(Could not load sub asset "{}" of type "{}")", assetName, *IGame::GetGameById(m_zone.m_game_id)->GetSubAssetTypeName(subAssetType));
}
return nullptr;
}
IndirectAssetReference AssetCreationContext::LoadIndirectAssetReferenceGeneric(const asset_type_t assetType, const std::string& assetName)
{
const auto* alreadyLoadedAsset = m_zone.m_pools->GetAssetOrAssetReference(assetType, assetName);
const auto* alreadyLoadedAsset = m_zone.m_pools.GetAssetOrAssetReference(assetType, assetName);
if (alreadyLoadedAsset)
return IndirectAssetReference(assetType, assetName);
@@ -158,7 +195,7 @@ IndirectAssetReference AssetCreationContext::LoadIndirectAssetReferenceGeneric(c
XAssetInfoGeneric* AssetCreationContext::ForceLoadDependencyGeneric(const asset_type_t assetType, const std::string& assetName)
{
auto* alreadyLoadedAsset = m_zone.m_pools->GetAssetOrAssetReference(assetType, assetName);
auto* alreadyLoadedAsset = m_zone.m_pools.GetAssetOrAssetReference(assetType, assetName);
if (alreadyLoadedAsset && !alreadyLoadedAsset->IsReference())
return alreadyLoadedAsset;
alreadyLoadedAsset = m_forced_asset_pools->GetAssetOrAssetReference(assetType, assetName);

48
src/ObjLoading/Asset/AssetCreationContext.h
View File

@@ -30,36 +30,47 @@ class AssetCreationContext : public ZoneAssetCreationStateContainer
public:
AssetCreationContext(Zone& zone, const AssetCreatorCollection* creators, const IgnoredAssetLookup* ignoredAssetLookup);
template<typename AssetType> XAssetInfo<typename AssetType::Type>* AddAsset(AssetRegistration<AssetType> registration)
template<AssetDefinition Asset_t> XAssetInfo<typename Asset_t::Type>* AddAsset(AssetRegistration<Asset_t> registration)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return static_cast<XAssetInfo<typename AssetType::Type>*>(AddAssetGeneric(std::move(registration)));
return static_cast<XAssetInfo<typename Asset_t::Type>*>(AddAssetGeneric(std::move(registration)));
}
template<typename AssetType> XAssetInfo<typename AssetType::Type>* AddAsset(std::string assetName, typename AssetType::Type* asset)
template<AssetDefinition Asset_t> XAssetInfo<typename Asset_t::Type>* AddAsset(std::string assetName, Asset_t::Type* asset)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return static_cast<XAssetInfo<typename AssetType::Type>*>(AddAssetGeneric(AssetRegistration<AssetType>(std::move(assetName), asset)));
return static_cast<XAssetInfo<typename Asset_t::Type>*>(AddAssetGeneric(AssetRegistration<Asset_t>(std::move(assetName), asset)));
}
XAssetInfoGeneric* AddAssetGeneric(GenericAssetRegistration registration) const;
template<typename AssetType> XAssetInfo<typename AssetType::Type>* LoadDependency(const std::string& assetName)
template<SubAssetDefinition SubAsset_t> XAssetInfo<typename SubAsset_t::Type>* AddSubAsset(AssetRegistration<SubAsset_t> registration)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return static_cast<XAssetInfo<typename SubAsset_t::Type>*>(AddSubAssetGeneric(std::move(registration)));
}
return static_cast<XAssetInfo<typename AssetType::Type>*>(LoadDependencyGeneric(AssetType::EnumEntry, assetName));
template<SubAssetDefinition SubAsset_t> XAssetInfo<typename SubAsset_t::Type>* AddSubAsset(std::string assetName, SubAsset_t::Type* asset)
{
return static_cast<XAssetInfo<typename SubAsset_t::Type>*>(AddSubAssetGeneric(AssetRegistration<SubAsset_t>(std::move(assetName), asset)));
}
XAssetInfoGeneric* AddSubAssetGeneric(GenericAssetRegistration registration) const;
template<AssetDefinition Asset_t> XAssetInfo<typename Asset_t::Type>* LoadDependency(const std::string& assetName)
{
return static_cast<XAssetInfo<typename Asset_t::Type>*>(LoadDependencyGeneric(Asset_t::EnumEntry, assetName));
}
XAssetInfoGeneric* LoadDependencyGeneric(asset_type_t assetType, const std::string& assetName, bool required = true);
template<typename AssetType> IndirectAssetReference LoadIndirectAssetReference(const std::string& assetName)
template<SubAssetDefinition SubAsset_t> XAssetInfo<typename SubAsset_t::Type>* LoadSubAsset(const std::string& assetName)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return static_cast<XAssetInfo<typename SubAsset_t::Type>*>(LoadSubAssetGeneric(SubAsset_t::EnumEntry, assetName));
}
return LoadIndirectAssetReferenceGeneric(AssetType::EnumEntry, assetName);
XAssetInfoGeneric* LoadSubAssetGeneric(asset_type_t subAssetType, const std::string& assetName);
template<AssetDefinition Asset_t> IndirectAssetReference LoadIndirectAssetReference(const std::string& assetName)
{
return LoadIndirectAssetReferenceGeneric(Asset_t::EnumEntry, assetName);
}
IndirectAssetReference LoadIndirectAssetReferenceGeneric(asset_type_t assetType, const std::string& assetName);
@@ -67,15 +78,13 @@ public:
/**
* \brief Loads an asset dependency like \c LoadDependency but guarantees that the returned asset is not a reference.
* If normally a reference would be created, the actual asset is loaded but a reference is added to the zone.
* \tparam AssetType The type of the asset
* \tparam Asset_t The type of the asset
* \param assetName The name of the asset
* \return XAssetInfo of the asset that is guaranteed to not be a reference or \c nullptr
*/
template<typename AssetType> XAssetInfo<typename AssetType::Type>* ForceLoadDependency(const std::string& assetName)
template<AssetDefinition Asset_t> XAssetInfo<typename Asset_t::Type>* ForceLoadDependency(const std::string& assetName)
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
return static_cast<XAssetInfo<typename AssetType::Type>*>(ForceLoadDependencyGeneric(AssetType::EnumEntry, assetName));
return static_cast<XAssetInfo<typename Asset_t::Type>*>(ForceLoadDependencyGeneric(Asset_t::EnumEntry, assetName));
}
XAssetInfoGeneric* ForceLoadDependencyGeneric(asset_type_t assetType, const std::string& assetName);
@@ -85,6 +94,7 @@ private:
Zone& m_zone;
std::unique_ptr<ZoneAssetPools> m_forced_asset_pools;
std::vector<std::unique_ptr<AssetPool>> m_sub_asset_pools;
const AssetCreatorCollection* m_creators;
const IgnoredAssetLookup* m_ignored_asset_lookup;

37
src/ObjLoading/Asset/AssetCreatorCollection.cpp
View File

@@ -6,6 +6,7 @@ AssetCreatorCollection::AssetCreatorCollection(const Zone& zone)
{
const auto* game = IGame::GetGameById(zone.m_game_id);
m_asset_creators_by_type.resize(game->GetAssetTypeCount());
m_sub_asset_creators_by_type.resize(game->GetSubAssetTypeCount());
m_asset_post_processors_by_type.resize(game->GetAssetTypeCount());
m_default_asset_creators_by_type.resize(game->GetAssetTypeCount());
}
@@ -20,6 +21,16 @@ void AssetCreatorCollection::AddAssetCreator(std::unique_ptr<IAssetCreator> crea
m_asset_creators.emplace_back(std::move(creator));
}
void AssetCreatorCollection::AddSubAssetCreator(std::unique_ptr<ISubAssetCreator> creator)
{
const auto maybeHandlingSubAssetType = creator->GetHandlingSubAssetType();
assert(!maybeHandlingSubAssetType || static_cast<unsigned>(*maybeHandlingSubAssetType) < m_sub_asset_creators_by_type.size());
if (maybeHandlingSubAssetType && static_cast<unsigned>(*maybeHandlingSubAssetType) < m_sub_asset_creators_by_type.size())
m_sub_asset_creators_by_type[static_cast<unsigned>(*maybeHandlingSubAssetType)].emplace_back(creator.get());
m_sub_asset_creators.emplace_back(std::move(creator));
}
void AssetCreatorCollection::AddAssetPostProcessor(std::unique_ptr<IAssetPostProcessor> postProcessor)
{
const auto handlingAssetType = postProcessor->GetHandlingAssetType();
@@ -42,9 +53,9 @@ void AssetCreatorCollection::AddDefaultAssetCreator(std::unique_ptr<IDefaultAsse
AssetCreationResult AssetCreatorCollection::CreateAsset(const asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const
{
assert(assetType >= 0 && static_cast<unsigned>(assetType) < m_asset_creators_by_type.size());
assert(assetType < m_asset_creators_by_type.size());
if (assetType >= 0 && static_cast<unsigned>(assetType) < m_asset_creators_by_type.size())
if (assetType < m_asset_creators_by_type.size())
{
for (const auto& creator : m_asset_creators_by_type[assetType])
{
@@ -68,11 +79,29 @@ AssetCreationResult AssetCreatorCollection::CreateAsset(const asset_type_t asset
return AssetCreationResult::NoAction();
}
AssetCreationResult
AssetCreatorCollection::CreateSubAsset(const asset_type_t subAssetType, const std::string& subAssetName, AssetCreationContext& context) const
{
assert(subAssetType < m_sub_asset_creators_by_type.size());
if (subAssetType < m_sub_asset_creators_by_type.size())
{
for (const auto& creator : m_sub_asset_creators_by_type[subAssetType])
{
const auto result = creator->CreateSubAsset(subAssetName, context);
if (result.HasTakenAction())
return result;
}
}
return AssetCreationResult::NoAction();
}
AssetCreationResult AssetCreatorCollection::CreateDefaultAsset(const asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const
{
assert(assetType >= 0 && static_cast<unsigned>(assetType) < m_default_asset_creators_by_type.size());
assert(assetType < m_default_asset_creators_by_type.size());
if (assetType >= 0 && static_cast<unsigned>(assetType) < m_default_asset_creators_by_type.size() && m_default_asset_creators_by_type[assetType])
if (assetType < m_default_asset_creators_by_type.size() && m_default_asset_creators_by_type[assetType])
{
return m_default_asset_creators_by_type[assetType]->CreateDefaultAsset(assetName, context);
}

8
src/ObjLoading/Asset/AssetCreatorCollection.h
View File

@@ -12,6 +12,7 @@
class AssetCreationContext;
class IAssetCreator;
class ISubAssetCreator;
class IAssetPostProcessor;
class AssetCreationResult;
class IDefaultAssetCreator;
@@ -22,17 +23,24 @@ public:
explicit AssetCreatorCollection(const Zone& zone);
void AddAssetCreator(std::unique_ptr<IAssetCreator> creator);
void AddSubAssetCreator(std::unique_ptr<ISubAssetCreator> creator);
void AddAssetPostProcessor(std::unique_ptr<IAssetPostProcessor> postProcessor);
void AddDefaultAssetCreator(std::unique_ptr<IDefaultAssetCreator> defaultAssetCreator);
AssetCreationResult CreateAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
AssetCreationResult CreateSubAsset(asset_type_t subAssetType, const std::string& subAssetName, AssetCreationContext& context) const;
AssetCreationResult CreateDefaultAsset(asset_type_t assetType, const std::string& assetName, AssetCreationContext& context) const;
void FinalizeZone(AssetCreationContext& context) const;
private:
std::vector<std::vector<IAssetCreator*>> m_asset_creators_by_type;
std::vector<std::unique_ptr<IAssetCreator>> m_asset_creators;
std::vector<std::vector<ISubAssetCreator*>> m_sub_asset_creators_by_type;
std::vector<std::unique_ptr<ISubAssetCreator>> m_sub_asset_creators;
std::vector<std::vector<IAssetPostProcessor*>> m_asset_post_processors_by_type;
std::vector<std::unique_ptr<IAssetPostProcessor>> m_asset_post_processors;
std::vector<std::unique_ptr<IDefaultAssetCreator>> m_default_asset_creators_by_type;
};

14
src/ObjLoading/Asset/AssetRegistration.h
View File

@@ -34,18 +34,16 @@ protected:
std::unordered_set<IndirectAssetReference> m_indirect_asset_references;
};
template<typename AssetType> class AssetRegistration : public GenericAssetRegistration
template<AssetOrSubAssetDefinition Asset_t> class AssetRegistration : public GenericAssetRegistration
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
public:
AssetRegistration(std::string assetName)
: GenericAssetRegistration(AssetType::EnumEntry, std::move(assetName), nullptr)
explicit AssetRegistration(std::string assetName)
: GenericAssetRegistration(Asset_t::EnumEntry, std::move(assetName), nullptr)
{
}
AssetRegistration(std::string assetName, typename AssetType::Type* asset)
: GenericAssetRegistration(AssetType::EnumEntry, std::move(assetName), asset)
AssetRegistration(std::string assetName, typename Asset_t::Type* asset)
: GenericAssetRegistration(Asset_t::EnumEntry, std::move(assetName), asset)
{
}
@@ -54,7 +52,7 @@ public:
AssetRegistration& operator=(const AssetRegistration& other) = delete;
AssetRegistration& operator=(AssetRegistration&& other) noexcept = default;
void SetAsset(typename AssetType::Type* asset)
void SetAsset(typename Asset_t::Type* asset)
{
m_asset = asset;
}

10
src/ObjLoading/Asset/GlobalAssetPoolsLoader.h
View File

@@ -25,11 +25,9 @@ private:
bool m_failure;
};
template<typename AssetType> class GlobalAssetPoolsLoader : public AssetCreator<AssetType>
template<AssetDefinition Asset_t> class GlobalAssetPoolsLoader : public AssetCreator<Asset_t>
{
public:
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
explicit GlobalAssetPoolsLoader(Zone& zone)
: m_zone(zone)
{
@@ -37,15 +35,15 @@ public:
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
{
auto* existingAsset = GlobalAssetPool<typename AssetType::Type>::GetAssetByName(assetName);
auto* existingAsset = GameGlobalAssetPools::GetGlobalPoolsForGame(m_zone.m_game_id)->GetAsset<Asset_t>(assetName);
if (!existingAsset)
return AssetCreationResult::NoAction();
AssetRegistration<AssetType> registration(assetName, existingAsset->Asset());
AssetRegistration<Asset_t> registration(assetName, existingAsset->Asset());
GlobalAssetPoolsRegistrationPreparation registrationPreparation(registration, m_zone, *existingAsset->m_zone, context);
AssetMarker<AssetType> marker(registrationPreparation);
AssetMarker<Asset_t> marker(registrationPreparation);
marker.Mark(existingAsset->Asset());
auto* newAsset = context.AddAsset(std::move(registration));

31
src/ObjLoading/Asset/IAssetCreator.h
View File

@@ -29,13 +29,36 @@ public:
virtual void FinalizeZone(AssetCreationContext& context) {}
};
template<typename AssetType> class AssetCreator : public IAssetCreator
class ISubAssetCreator
{
public:
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
ISubAssetCreator() = default;
virtual ~ISubAssetCreator() = default;
ISubAssetCreator(const ISubAssetCreator& other) = default;
ISubAssetCreator(ISubAssetCreator&& other) noexcept = default;
ISubAssetCreator& operator=(const ISubAssetCreator& other) = default;
ISubAssetCreator& operator=(ISubAssetCreator&& other) noexcept = default;
[[nodiscard]] virtual std::optional<asset_type_t> GetHandlingSubAssetType() const = 0;
virtual AssetCreationResult CreateSubAsset(const std::string& subAssetName, AssetCreationContext& context) = 0;
virtual void FinalizeZone(AssetCreationContext& context) {}
};
template<AssetDefinition Asset_t> class AssetCreator : public IAssetCreator
{
public:
[[nodiscard]] std::optional<asset_type_t> GetHandlingAssetType() const override
{
return AssetType::EnumEntry;
};
return Asset_t::EnumEntry;
}
};
template<SubAssetDefinition SubAsset_t> class SubAssetCreator : public ISubAssetCreator
{
public:
[[nodiscard]] std::optional<asset_type_t> GetHandlingSubAssetType() const override
{
return SubAsset_t::EnumEntry;
}
};

14
src/ObjLoading/Asset/IDefaultAssetCreator.h
View File

@@ -24,27 +24,25 @@ public:
virtual AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const = 0;
};
template<typename AssetType> class DefaultAssetCreator : public IDefaultAssetCreator
template<AssetDefinition Asset_t> class DefaultAssetCreator : public IDefaultAssetCreator
{
public:
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
DefaultAssetCreator(MemoryManager& memory)
explicit DefaultAssetCreator(MemoryManager& memory)
: m_memory(memory)
{
}
[[nodiscard]] asset_type_t GetHandlingAssetType() const override
{
return AssetType::EnumEntry;
return Asset_t::EnumEntry;
}
AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override
{
auto* asset = m_memory.Alloc<typename AssetType::Type>();
AssetName<AssetType>(*asset) = m_memory.Dup(assetName.c_str());
auto* asset = m_memory.Alloc<typename Asset_t::Type>();
AssetName<Asset_t>(*asset) = m_memory.Dup(assetName.c_str());
return AssetCreationResult::Success(context.AddAsset<AssetType>(assetName, asset));
return AssetCreationResult::Success(context.AddAsset<Asset_t>(assetName, asset));
}
private:

30
src/ObjLoading/Game/T6/ObjLoaderT6.cpp
View File

@@ -5,7 +5,6 @@
#include "FontIcon/JsonLoaderFontIconT6.h"
#include "Game/T6/AssetMarkerT6.h"
#include "Game/T6/CommonT6.h"
#include "Game/T6/GameAssetPoolT6.h"
#include "Game/T6/GameT6.h"
#include "Game/T6/Image/ImageLoaderEmbeddedT6.h"
#include "Game/T6/Image/ImageLoaderExternalT6.h"
@@ -236,36 +235,29 @@ namespace T6
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const
{
const auto* assetPoolT6 = dynamic_cast<GameAssetPoolT6*>(zone.m_pools.get());
const auto zoneNameHash = Common::Com_HashKey(zone.m_name.c_str(), 64);
LoadCommonIPaks(searchPath, zone);
if (assetPoolT6->m_key_value_pairs != nullptr)
for (auto* keyValuePairsEntry : zone.m_pools.PoolAssets<AssetKeyValuePairs>())
{
for (auto* keyValuePairsEntry : *assetPoolT6->m_key_value_pairs)
const auto* keyValuePairs = keyValuePairsEntry->Asset();
for (auto variableIndex = 0u; variableIndex < keyValuePairs->numVariables; variableIndex++)
{
const auto* keyValuePairs = keyValuePairsEntry->Asset();
for (auto variableIndex = 0u; variableIndex < keyValuePairs->numVariables; variableIndex++)
{
auto* variable = &keyValuePairs->keyValuePairs[variableIndex];
auto* variable = &keyValuePairs->keyValuePairs[variableIndex];
if (variable->namespaceHash == zoneNameHash && variable->keyHash == IPAK_READ_HASH)
{
LoadIPakForZone(searchPath, variable->value, zone);
}
if (variable->namespaceHash == zoneNameHash && variable->keyHash == IPAK_READ_HASH)
{
LoadIPakForZone(searchPath, variable->value, zone);
}
}
}
if (assetPoolT6->m_sound_bank != nullptr)
{
std::set<std::string> loadedSoundBanksForZone;
std::set<std::string> loadedSoundBanksForZone;
for (auto* sndBankAssetInfo : *assetPoolT6->m_sound_bank)
{
LoadSoundBanksFromAsset(searchPath, *sndBankAssetInfo->Asset(), zone, loadedSoundBanksForZone);
}
for (auto* sndBankAssetInfo : zone.m_pools.PoolAssets<AssetSoundBank>())
{
LoadSoundBanksFromAsset(searchPath, *sndBankAssetInfo->Asset(), zone, loadedSoundBanksForZone);
}
}

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

@@ -4,23 +4,26 @@
#include "IAssetDumper.h"
#include "Pool/AssetPool.h"
template<class AssetType> class AbstractAssetDumper : public IAssetDumper
template<AssetDefinition Asset_t> class AbstractAssetDumper : public IAssetDumper
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
public:
using AssetType_t = AssetType;
using AssetType_t = Asset_t;
[[nodiscard]] size_t GetProgressTotalCount() const override
[[nodiscard]] std::optional<asset_type_t> GetHandlingAssetType() const override
{
return m_pool.m_asset_lookup.size();
return Asset_t::EnumEntry;
}
[[nodiscard]] size_t GetProgressTotalCount(AssetDumpingContext& context) const override
{
return context.m_zone.m_pools.PoolAssets<Asset_t>().size();
}
void Dump(AssetDumpingContext& context) override
{
for (const auto* assetInfo : m_pool)
for (const auto* assetInfo : context.m_zone.m_pools.PoolAssets<Asset_t>())
{
if (assetInfo->m_name[0] == ',' || !ShouldDump(*assetInfo))
if (assetInfo->IsReference() || !ShouldDump(*assetInfo))
{
context.IncrementProgress();
continue;
@@ -32,38 +35,26 @@ public:
}
protected:
explicit AbstractAssetDumper(const AssetPool<typename AssetType::Type>& pool)
: m_pool(pool)
{
}
virtual bool ShouldDump(const XAssetInfo<typename AssetType::Type>& asset)
virtual bool ShouldDump(const XAssetInfo<typename Asset_t::Type>& asset)
{
return true;
}
virtual void DumpAsset(AssetDumpingContext& context, const XAssetInfo<typename AssetType::Type>& asset) = 0;
const AssetPool<typename AssetType::Type>& m_pool;
virtual void DumpAsset(AssetDumpingContext& context, const XAssetInfo<typename Asset_t::Type>& asset) = 0;
};
template<class AssetType> class AbstractSingleProgressAssetDumper : public IAssetDumper
template<AssetDefinition Asset_t> class AbstractSingleProgressAssetDumper : public IAssetDumper
{
static_assert(std::is_base_of_v<IAssetBase, AssetType>);
public:
using AssetType_t = AssetType;
using AssetType_t = Asset_t;
[[nodiscard]] size_t GetProgressTotalCount() const override
[[nodiscard]] std::optional<asset_type_t> GetHandlingAssetType() const override
{
return m_pool.m_asset_lookup.empty() ? 0uz : 1uz;
return Asset_t::EnumEntry;
}
protected:
explicit AbstractSingleProgressAssetDumper(const AssetPool<typename AssetType::Type>& pool)
: m_pool(pool)
[[nodiscard]] size_t GetProgressTotalCount(AssetDumpingContext& context) const override
{
return context.m_zone.m_pools.PoolAssets<Asset_t>().empty() ? 0uz : 1uz;
}
const AssetPool<typename AssetType::Type>& m_pool;
};

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

@@ -1,6 +1,9 @@
#pragma once
#include "AssetDumpingContext.h"
#include "Zone/ZoneTypes.h"
#include <optional>
class IAssetDumper
{
@@ -12,6 +15,11 @@ public:
IAssetDumper& operator=(const IAssetDumper& other) = default;
IAssetDumper& operator=(IAssetDumper&& other) noexcept = default;
[[nodiscard]] virtual size_t GetProgressTotalCount() const = 0;
[[nodiscard]] virtual std::optional<asset_type_t> GetHandlingAssetType() const
{
return std::nullopt;
}
[[nodiscard]] virtual size_t GetProgressTotalCount(AssetDumpingContext& context) const = 0;
virtual void Dump(AssetDumpingContext& context) = 0;
};

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

@@ -64,8 +64,8 @@ namespace
namespace image
{
DumperIW3::DumperIW3(const AssetPool<AssetImage::Type>& pool)
: AbstractAssetDumper(pool)
DumperIW3::DumperIW3()
: AbstractAssetDumper()
{
switch (ObjWriting::Configuration.ImageOutputFormat)
{

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

@@ -11,7 +11,7 @@ namespace image
class DumperIW3 final : public AbstractAssetDumper<IW3::AssetImage>
{
public:
explicit DumperIW3(const AssetPool<IW3::AssetImage::Type>& pool);
DumperIW3();
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::AssetImage::Type>& asset) override;

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

@@ -5,25 +5,15 @@
#include "Utils/Logging/Log.h"
#include <format>
#include <iostream>
using namespace IW3;
namespace localize
{
DumperIW3::DumperIW3(const AssetPool<IW3::AssetLocalize::Type>& pool)
: AbstractSingleProgressAssetDumper(pool)
{
}
size_t DumperIW3::GetProgressTotalCount() const
{
return m_pool.m_asset_lookup.empty() ? 0uz : 1uz;
}
void DumperIW3::Dump(AssetDumpingContext& context)
{
if (m_pool.m_asset_lookup.empty())
auto localizeAssets = context.m_zone.m_pools.PoolAssets<AssetLocalize>();
if (localizeAssets.empty())
return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -40,7 +30,7 @@ namespace localize
stringFileDumper.SetNotes("");
for (const auto* localizeEntry : m_pool)
for (const auto* localizeEntry : localizeAssets)
{
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
}

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

@@ -2,16 +2,12 @@
#include "Dumping/AbstractAssetDumper.h"
#include "Game/IW3/IW3.h"
#include "Pool/AssetPool.h"
namespace localize
{
class DumperIW3 final : public AbstractSingleProgressAssetDumper<IW3::AssetLocalize>
{
public:
explicit DumperIW3(const AssetPool<IW3::AssetLocalize::Type>& pool);
[[nodiscard]] size_t GetProgressTotalCount() const override;
void Dump(AssetDumpingContext& context) override;
};
} // namespace localize

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

@@ -4,11 +4,6 @@ using namespace IW3;
namespace map_ents
{
DumperIW3::DumperIW3(const AssetPool<IW3::AssetMapEnts::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<MapEnts>& asset)
{
const auto* mapEnts = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace map_ents
{
class DumperIW3 final : public AbstractAssetDumper<IW3::AssetMapEnts>
{
public:
explicit DumperIW3(const AssetPool<IW3::AssetMapEnts::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::MapEnts>& asset) override;
};

7
src/ObjWriting/Game/IW3/Material/MaterialConstantZoneStateIW3.cpp
View File

@@ -1,7 +1,6 @@
#include "MaterialConstantZoneStateIW3.h"
#include "Game/IW3/CommonIW3.h"
#include "Game/IW3/GameAssetPoolIW3.h"
#include "Game/IW3/GameIW3.h"
#include "ObjWriting.h"
#include "Zone/ZoneRegistry.h"
@@ -205,11 +204,7 @@ namespace IW3
{
for (const auto* zone : ZoneRegistry::GetRegistryForGame(GameId::IW3)->Zones())
{
const auto* assetPools = dynamic_cast<const GameAssetPoolIW3*>(zone->m_pools.get());
if (!assetPools)
return;
for (const auto* techniqueSetInfo : *assetPools->m_technique_set)
for (const auto* techniqueSetInfo : zone->m_pools.PoolAssets<AssetTechniqueSet>())
{
const auto* techniqueSet = techniqueSetInfo->Asset();

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

@@ -1,69 +1,42 @@
#include "ObjWriterIW3.h"
#include "Game/IW3/GameAssetPoolIW3.h"
#include "Game/IW3/Material/MaterialJsonDumperIW3.h"
#include "Game/IW3/XModel/XModelDumperIW3.h"
#include "Image/ImageDumperIW3.h"
#include "Localize/LocalizeDumperIW3.h"
#include "Maps/MapEntsDumperIW3.h"
#include "ObjWriting.h"
#include "RawFile/RawFileDumperIW3.h"
#include "Sound/LoadedSoundDumperIW3.h"
#include "StringTable/StringTableDumperIW3.h"
using namespace IW3;
bool ObjWriter::DumpZone(AssetDumpingContext& context) const
void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context)
{
#define REGISTER_DUMPER(dumperType, poolName) \
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(dumperType::AssetType_t::EnumEntry)) \
{ \
dumpers.emplace_back(std::make_unique<dumperType>(*assetPools->poolName)); \
}
const auto* assetPools = dynamic_cast<GameAssetPoolIW3*>(context.m_zone.m_pools.get());
std::vector<std::unique_ptr<IAssetDumper>> dumpers;
// REGISTER_DUMPER(AssetDumperPhysPreset, m_phys_preset)
// REGISTER_DUMPER(AssetDumperXAnimParts, m_xanim_parts)
REGISTER_DUMPER(xmodel::DumperIW3, m_xmodel)
REGISTER_DUMPER(material::JsonDumperIW3, m_material)
// REGISTER_DUMPER(AssetDumperMaterialTechniqueSet, m_technique_set)
REGISTER_DUMPER(image::DumperIW3, m_image)
// REGISTER_DUMPER(AssetDumpersnd_alias_list_t, m_sound)
// REGISTER_DUMPER(AssetDumperSndCurve, m_sound_curve)
REGISTER_DUMPER(sound::LoadedSoundDumperIW3, m_loaded_sound)
// REGISTER_DUMPER(AssetDumperClipMap, m_clip_map)
// REGISTER_DUMPER(AssetDumperComWorld, m_com_world)
// REGISTER_DUMPER(AssetDumperGameWorldSp, m_game_world_sp)
// REGISTER_DUMPER(AssetDumperGameWorldMp, m_game_world_mp)
REGISTER_DUMPER(map_ents::DumperIW3, m_map_ents)
// REGISTER_DUMPER(AssetDumperGfxWorld, m_gfx_world)
// REGISTER_DUMPER(AssetDumperGfxLightDef, m_gfx_light_def)
// REGISTER_DUMPER(AssetDumperFont_s, m_font)
// REGISTER_DUMPER(AssetDumperMenuList, m_menu_list)
// REGISTER_DUMPER(AssetDumpermenuDef_t, m_menu_def)
REGISTER_DUMPER(localize::DumperIW3, m_localize)
// REGISTER_DUMPER(AssetDumperWeapon, m_weapon)
// REGISTER_DUMPER(AssetDumperSndDriverGlobals, m_snd_driver_globals)
// REGISTER_DUMPER(AssetDumperFxEffectDef, m_fx)
// REGISTER_DUMPER(AssetDumperFxImpactTable, m_fx_impact_table)
REGISTER_DUMPER(raw_file::DumperIW3, m_raw_file)
REGISTER_DUMPER(string_table::DumperIW3, m_string_table)
if (context.ShouldTrackProgress())
{
size_t totalProgress = 0uz;
for (const auto& dumper : dumpers)
totalProgress += dumper->GetProgressTotalCount();
context.SetTotalProgress(totalProgress);
}
for (const auto& dumper : dumpers)
dumper->Dump(context);
return true;
#undef REGISTER_DUMPER
// REGISTER_DUMPER(AssetDumperPhysPreset)
// REGISTER_DUMPER(AssetDumperXAnimParts)
RegisterAssetDumper(std::make_unique<xmodel::DumperIW3>());
RegisterAssetDumper(std::make_unique<material::JsonDumperIW3>());
// REGISTER_DUMPER(AssetDumperMaterialTechniqueSet)
RegisterAssetDumper(std::make_unique<image::DumperIW3>());
// REGISTER_DUMPER(AssetDumpersnd_alias_list_t)
// REGISTER_DUMPER(AssetDumperSndCurve)
RegisterAssetDumper(std::make_unique<sound::LoadedSoundDumperIW3>());
// REGISTER_DUMPER(AssetDumperClipMap)
// REGISTER_DUMPER(AssetDumperComWorld)
// REGISTER_DUMPER(AssetDumperGameWorldSp)
// REGISTER_DUMPER(AssetDumperGameWorldMp)
RegisterAssetDumper(std::make_unique<map_ents::DumperIW3>());
// REGISTER_DUMPER(AssetDumperGfxWorld)
// REGISTER_DUMPER(AssetDumperGfxLightDef)
// REGISTER_DUMPER(AssetDumperFont_s)
// REGISTER_DUMPER(AssetDumperMenuList)
// REGISTER_DUMPER(AssetDumpermenuDef_t)
RegisterAssetDumper(std::make_unique<localize::DumperIW3>());
// REGISTER_DUMPER(AssetDumperWeapon)
// REGISTER_DUMPER(AssetDumperSndDriverGlobals)
// REGISTER_DUMPER(AssetDumperFxEffectDef)
// REGISTER_DUMPER(AssetDumperFxImpactTable)
RegisterAssetDumper(std::make_unique<raw_file::DumperIW3>());
RegisterAssetDumper(std::make_unique<string_table::DumperIW3>());
}

6
src/ObjWriting/Game/IW3/ObjWriterIW3.h
View File

@@ -1,12 +1,12 @@
#pragma once
#include "IObjWriter.h"
#include "ObjWriter.h"
namespace IW3
{
class ObjWriter final : public IObjWriter
{
public:
bool DumpZone(AssetDumpingContext& context) const override;
protected:
void RegisterAssetDumpers(AssetDumpingContext& context) override;
};
} // namespace IW3

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

@@ -4,11 +4,6 @@ using namespace IW3;
namespace raw_file
{
DumperIW3::DumperIW3(const AssetPool<AssetRawFile::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& asset)
{
const auto* rawFile = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace raw_file
{
class DumperIW3 final : public AbstractAssetDumper<IW3::AssetRawFile>
{
public:
explicit DumperIW3(const AssetPool<IW3::AssetRawFile::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::RawFile>& asset) override;
};

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

@@ -25,11 +25,6 @@ namespace
namespace sound
{
LoadedSoundDumperIW3::LoadedSoundDumperIW3(const AssetPool<AssetLoadedSound::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void LoadedSoundDumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<LoadedSound>& asset)
{
const auto* loadedSound = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace sound
{
class LoadedSoundDumperIW3 final : public AbstractAssetDumper<IW3::AssetLoadedSound>
{
public:
explicit LoadedSoundDumperIW3(const AssetPool<IW3::AssetLoadedSound::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::AssetLoadedSound::Type>& asset) override;
};

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

@@ -6,11 +6,6 @@ using namespace IW3;
namespace string_table
{
DumperIW3::DumperIW3(const AssetPool<AssetStringTable::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW3::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& asset)
{
const auto* stringTable = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace string_table
{
class DumperIW3 final : public AbstractAssetDumper<IW3::AssetStringTable>
{
public:
explicit DumperIW3(const AssetPool<IW3::AssetStringTable::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW3::StringTable>& asset) override;
};

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

@@ -61,8 +61,7 @@ namespace
namespace image
{
DumperIW4::DumperIW4(const AssetPool<AssetImage::Type>& pool)
: AbstractAssetDumper(pool)
DumperIW4::DumperIW4()
{
switch (ObjWriting::Configuration.ImageOutputFormat)
{

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

@@ -11,7 +11,7 @@ namespace image
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetImage>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetImage::Type>& pool);
DumperIW4();
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetImage::Type>& asset) override;

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

@@ -77,11 +77,6 @@ namespace
namespace leaderboard
{
JsonDumperIW4::JsonDumperIW4(const AssetPool<AssetLeaderboard::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void JsonDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetLeaderboard::Type>& asset)
{
const auto assetFile = context.OpenAssetFile(GetJsonFileNameForAsset(asset.m_name));

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

@@ -7,9 +7,6 @@ namespace leaderboard
{
class JsonDumperIW4 final : public AbstractAssetDumper<IW4::AssetLeaderboard>
{
public:
explicit JsonDumperIW4(const AssetPool<IW4::AssetLeaderboard::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetLeaderboard::Type>& asset) override;
};

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

@@ -6,11 +6,6 @@ using namespace IW4;
namespace light_def
{
DumperIW4::DumperIW4(const AssetPool<AssetLightDef::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetLightDef::Type>& asset)
{
const auto* lightDef = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace light_def
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetLightDef>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetLightDef::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetLightDef::Type>& asset) override;
};

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

@@ -10,14 +10,10 @@ using namespace IW4;
namespace localize
{
DumperIW4::DumperIW4(const AssetPool<AssetLocalize::Type>& pool)
: AbstractSingleProgressAssetDumper(pool)
{
}
void DumperIW4::Dump(AssetDumpingContext& context)
{
if (m_pool.m_asset_lookup.empty())
auto localizeAssets = context.m_zone.m_pools.PoolAssets<AssetLocalize>();
if (localizeAssets.empty())
return;
const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language);
@@ -34,7 +30,7 @@ namespace localize
stringFileDumper.SetNotes("");
for (const auto* localizeEntry : m_pool)
for (const auto* localizeEntry : localizeAssets)
{
stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value);
}

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

@@ -8,8 +8,6 @@ namespace localize
class DumperIW4 final : public AbstractSingleProgressAssetDumper<IW4::AssetLocalize>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetLocalize::Type>& pool);
void Dump(AssetDumpingContext& context) override;
};
} // namespace localize

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

@@ -7,11 +7,6 @@ using namespace IW4;
namespace addon_map_ents
{
DumperIW4::DumperIW4(const AssetPool<AssetAddonMapEnts::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetAddonMapEnts::Type>& asset)
{
const auto* addonMapEnts = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace addon_map_ents
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetAddonMapEnts>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetAddonMapEnts::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetAddonMapEnts::Type>& asset) override;
};

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

@@ -1,7 +1,6 @@
#include "MaterialConstantZoneStateIW4.h"
#include "Game/IW4/CommonIW4.h"
#include "Game/IW4/GameAssetPoolIW4.h"
#include "Game/IW4/GameIW4.h"
#include "ObjWriting.h"
#include "Zone/ZoneRegistry.h"
@@ -205,18 +204,14 @@ namespace IW4
{
for (const auto* zone : ZoneRegistry::GetRegistryForGame(GameId::IW4)->Zones())
{
const auto* assetPools = dynamic_cast<const GameAssetPoolIW4*>(zone->m_pools.get());
if (!assetPools)
return;
for (const auto* vertexShaderAsset : *assetPools->m_material_vertex_shader)
for (const auto* vertexShaderAsset : zone->m_pools.PoolAssets<AssetVertexShader>())
{
const auto* vertexShader = vertexShaderAsset->Asset();
if (ShouldDumpFromStruct(vertexShader))
ExtractNamesFromShader(vertexShader->prog.loadDef.program, static_cast<size_t>(vertexShader->prog.loadDef.programSize) * sizeof(uint32_t));
}
for (const auto* pixelShaderAsset : *assetPools->m_material_pixel_shader)
for (const auto* pixelShaderAsset : zone->m_pools.PoolAssets<AssetPixelShader>())
{
const auto* pixelShader = pixelShaderAsset->Asset();
if (ShouldDumpFromStruct(pixelShader))

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

@@ -1109,11 +1109,6 @@ namespace
namespace material
{
DecompilingGdtDumperIW4::DecompilingGdtDumperIW4(const AssetPool<AssetMaterial::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DecompilingGdtDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetMaterial::Type>& asset)
{
if (!context.m_gdt)

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

@@ -7,9 +7,6 @@ namespace material
{
class DecompilingGdtDumperIW4 final : public AbstractAssetDumper<IW4::AssetMaterial>
{
public:
explicit DecompilingGdtDumperIW4(const AssetPool<IW4::AssetMaterial::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetMaterial::Type>& asset) override;
};

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

@@ -1,6 +1,5 @@
#include "MenuDumperIW4.h"
#include "Game/IW4/GameAssetPoolIW4.h"
#include "MenuListDumperIW4.h"
#include "MenuWriterIW4.h"
#include "ObjWriting.h"
@@ -25,11 +24,6 @@ namespace
namespace menu
{
MenuDumperIW4::MenuDumperIW4(const AssetPool<AssetMenu::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void MenuDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetMenu::Type>& asset)
{
const auto* menu = asset.Asset();
@@ -38,8 +32,8 @@ namespace menu
if (!ObjWriting::ShouldHandleAssetType(ASSET_TYPE_MENULIST))
{
// Make sure menu paths based on menu lists are created
const auto* gameAssetPool = dynamic_cast<GameAssetPoolIW4*>(asset.m_zone->m_pools.get());
for (auto* menuListAsset : *gameAssetPool->m_menu_list)
auto menuListAssets = context.m_zone.m_pools.PoolAssets<AssetMenuList>();
for (auto* menuListAsset : menuListAssets)
CreateDumpingStateForMenuListIW4(zoneState, menuListAsset->Asset());
}

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

@@ -7,9 +7,6 @@ namespace menu
{
class MenuDumperIW4 final : public AbstractAssetDumper<IW4::AssetMenu>
{
public:
explicit MenuDumperIW4(const AssetPool<IW4::AssetMenu::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetMenu::Type>& asset) override;
};

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

@@ -147,11 +147,6 @@ namespace menu
}
}
MenuListDumperIW4::MenuListDumperIW4(const AssetPool<AssetMenuList::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void MenuListDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetMenuList::Type>& asset)
{
const auto* menuList = asset.Asset();
@@ -178,7 +173,8 @@ namespace menu
{
auto* zoneState = context.GetZoneAssetDumperState<MenuDumpingZoneState>();
for (const auto* asset : m_pool)
auto menuListAssets = context.m_zone.m_pools.PoolAssets<AssetMenuList>();
for (const auto* asset : menuListAssets)
CreateDumpingStateForMenuListIW4(zoneState, asset->Asset());
AbstractAssetDumper::Dump(context);

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

@@ -11,8 +11,6 @@ namespace menu
class MenuListDumperIW4 final : public AbstractAssetDumper<IW4::AssetMenuList>
{
public:
explicit MenuListDumperIW4(const AssetPool<IW4::AssetMenuList::Type>& pool);
void Dump(AssetDumpingContext& context) override;
protected:

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

@@ -1,6 +1,5 @@
#include "ObjWriterIW4.h"
#include "Game/IW4/GameAssetPoolIW4.h"
#include "Game/IW4/Material/MaterialJsonDumperIW4.h"
#include "Game/IW4/XModel/XModelDumperIW4.h"
#include "Image/ImageDumperIW4.h"
@@ -11,7 +10,6 @@
#include "Material/MaterialDecompilingDumperIW4.h"
#include "Menu/MenuDumperIW4.h"
#include "Menu/MenuListDumperIW4.h"
#include "ObjWriting.h"
#include "PhysCollmap/PhysCollmapDumperIW4.h"
#include "PhysPreset/PhysPresetInfoStringDumperIW4.h"
#include "RawFile/RawFileDumperIW4.h"
@@ -28,69 +26,44 @@
using namespace IW4;
bool ObjWriter::DumpZone(AssetDumpingContext& context) const
void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context)
{
#define REGISTER_DUMPER(dumperType, poolName) \
if (assetPools->poolName && ObjWriting::ShouldHandleAssetType(dumperType::AssetType_t::EnumEntry)) \
{ \
dumpers.emplace_back(std::make_unique<dumperType>(*assetPools->poolName)); \
}
const auto* assetPools = dynamic_cast<GameAssetPoolIW4*>(context.m_zone.m_pools.get());
std::vector<std::unique_ptr<IAssetDumper>> dumpers;
REGISTER_DUMPER(phys_preset::InfoStringDumperIW4, m_phys_preset)
REGISTER_DUMPER(phys_collmap::DumperIW4, m_phys_collmap)
// REGISTER_DUMPER(AssetDumperXAnimParts, m_xanim_parts)
REGISTER_DUMPER(xmodel::DumperIW4, m_xmodel)
REGISTER_DUMPER(material::JsonDumperIW4, m_material)
RegisterAssetDumper(std::make_unique<phys_preset::InfoStringDumperIW4>());
RegisterAssetDumper(std::make_unique<phys_collmap::DumperIW4>());
// REGISTER_DUMPER(AssetDumperXAnimParts)
RegisterAssetDumper(std::make_unique<xmodel::DumperIW4>());
RegisterAssetDumper(std::make_unique<material::JsonDumperIW4>());
#ifdef EXPERIMENTAL_MATERIAL_COMPILATION
DUMP_ASSET_POOL(material::DecompilingGdtDumperIW4, m_material)
RegisterAssetDumper(std::make_unique<material::DecompilingGdtDumperIW4>());
#endif
REGISTER_DUMPER(shader::PixelShaderDumperIW4, m_material_pixel_shader)
REGISTER_DUMPER(shader::VertexShaderDumperIW4, m_material_vertex_shader)
REGISTER_DUMPER(techset::DumperIW4, m_technique_set)
REGISTER_DUMPER(image::DumperIW4, m_image)
// REGISTER_DUMPER(AssetDumpersnd_alias_list_t, m_sound)
REGISTER_DUMPER(sound_curve::DumperIW4, m_sound_curve)
REGISTER_DUMPER(sound::LoadedSoundDumperIW4, m_loaded_sound)
// REGISTER_DUMPER(AssetDumperClipMap, m_clip_map)
// REGISTER_DUMPER(AssetDumperComWorld, m_com_world)
// REGISTER_DUMPER(AssetDumperGameWorldSp, m_game_world_sp)
// REGISTER_DUMPER(AssetDumperGameWorldMp, m_game_world_mp)
// REGISTER_DUMPER(AssetDumperMapEnts, m_map_ents)
// REGISTER_DUMPER(AssetDumperFxWorld, m_fx_world)
// REGISTER_DUMPER(AssetDumperGfxWorld, m_gfx_world)
REGISTER_DUMPER(light_def::DumperIW4, m_gfx_light_def)
// REGISTER_DUMPER(AssetDumperFont_s, m_font)
REGISTER_DUMPER(menu::MenuListDumperIW4, m_menu_list)
REGISTER_DUMPER(menu::MenuDumperIW4, m_menu_def)
REGISTER_DUMPER(localize::DumperIW4, m_localize)
REGISTER_DUMPER(weapon::DumperIW4, m_weapon)
// REGISTER_DUMPER(AssetDumperSndDriverGlobals, m_snd_driver_globals)
// REGISTER_DUMPER(AssetDumperFxEffectDef, m_fx)
// REGISTER_DUMPER(AssetDumperFxImpactTable, m_fx_impact_table)
REGISTER_DUMPER(raw_file::DumperIW4, m_raw_file)
REGISTER_DUMPER(string_table::DumperIW4, m_string_table)
REGISTER_DUMPER(leaderboard::JsonDumperIW4, m_leaderboard)
REGISTER_DUMPER(structured_data_def::DumperIW4, m_structed_data_def_set)
REGISTER_DUMPER(tracer::DumperIW4, m_tracer)
REGISTER_DUMPER(vehicle::DumperIW4, m_vehicle)
REGISTER_DUMPER(addon_map_ents::DumperIW4, m_addon_map_ents)
if (context.ShouldTrackProgress())
{
size_t totalProgress = 0uz;
for (const auto& dumper : dumpers)
totalProgress += dumper->GetProgressTotalCount();
context.SetTotalProgress(totalProgress);
}
for (const auto& dumper : dumpers)
dumper->Dump(context);
return true;
#undef REGISTER_DUMPER
RegisterAssetDumper(std::make_unique<shader::PixelShaderDumperIW4>());
RegisterAssetDumper(std::make_unique<shader::VertexShaderDumperIW4>());
RegisterAssetDumper(std::make_unique<techset::DumperIW4>());
RegisterAssetDumper(std::make_unique<image::DumperIW4>());
// REGISTER_DUMPER(AssetDumpersnd_alias_list_t)
RegisterAssetDumper(std::make_unique<sound_curve::DumperIW4>());
RegisterAssetDumper(std::make_unique<sound::LoadedSoundDumperIW4>());
// REGISTER_DUMPER(AssetDumperClipMap)
// REGISTER_DUMPER(AssetDumperComWorld)
// REGISTER_DUMPER(AssetDumperGameWorldSp)
// REGISTER_DUMPER(AssetDumperGameWorldMp)
// REGISTER_DUMPER(AssetDumperMapEnts)
// REGISTER_DUMPER(AssetDumperFxWorld)
// REGISTER_DUMPER(AssetDumperGfxWorld)
RegisterAssetDumper(std::make_unique<light_def::DumperIW4>());
// REGISTER_DUMPER(AssetDumperFont_s)
RegisterAssetDumper(std::make_unique<menu::MenuListDumperIW4>());
RegisterAssetDumper(std::make_unique<menu::MenuDumperIW4>());
RegisterAssetDumper(std::make_unique<localize::DumperIW4>());
RegisterAssetDumper(std::make_unique<weapon::DumperIW4>());
// REGISTER_DUMPER(AssetDumperSndDriverGlobals)
// REGISTER_DUMPER(AssetDumperFxEffectDef)
// REGISTER_DUMPER(AssetDumperFxImpactTable)
RegisterAssetDumper(std::make_unique<raw_file::DumperIW4>());
RegisterAssetDumper(std::make_unique<string_table::DumperIW4>());
RegisterAssetDumper(std::make_unique<leaderboard::JsonDumperIW4>());
RegisterAssetDumper(std::make_unique<structured_data_def::DumperIW4>());
RegisterAssetDumper(std::make_unique<tracer::DumperIW4>());
RegisterAssetDumper(std::make_unique<vehicle::DumperIW4>());
RegisterAssetDumper(std::make_unique<addon_map_ents::DumperIW4>());
}

7
src/ObjWriting/Game/IW4/ObjWriterIW4.h
View File

@@ -1,11 +1,12 @@
#pragma once
#include "IObjWriter.h"
#include "ObjWriter.h"
namespace IW4
{
class ObjWriter final : public IObjWriter
{
public:
bool DumpZone(AssetDumpingContext& context) const override;
protected:
void RegisterAssetDumpers(AssetDumpingContext& context) override;
};
} // namespace IW4

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

@@ -10,11 +10,6 @@ using namespace IW4;
namespace phys_collmap
{
DumperIW4::DumperIW4(const AssetPool<AssetPhysCollMap::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetPhysCollMap::Type>& asset)
{
const auto* physCollmap = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace phys_collmap
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetPhysCollMap>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetPhysCollMap::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetPhysCollMap::Type>& asset) override;
};

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

@@ -80,11 +80,6 @@ namespace
namespace phys_preset
{
InfoStringDumperIW4::InfoStringDumperIW4(const AssetPool<AssetPhysPreset::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void InfoStringDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetPhysPreset::Type>& asset)
{
// Only dump raw when no gdt available

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

@@ -7,9 +7,6 @@ namespace phys_preset
{
class InfoStringDumperIW4 final : public AbstractAssetDumper<IW4::AssetPhysPreset>
{
public:
explicit InfoStringDumperIW4(const AssetPool<IW4::AssetPhysPreset::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetPhysPreset::Type>& asset) override;
};

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

@@ -10,11 +10,6 @@ using namespace IW4;
namespace raw_file
{
DumperIW4::DumperIW4(const AssetPool<AssetRawFile::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetRawFile::Type>& asset)
{
const auto* rawFile = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace raw_file
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetRawFile>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetRawFile::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetRawFile::Type>& asset) override;
};

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

@@ -6,11 +6,6 @@ using namespace IW4;
namespace shader
{
PixelShaderDumperIW4::PixelShaderDumperIW4(const AssetPool<AssetPixelShader::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void PixelShaderDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetPixelShader::Type>& asset)
{
const auto* pixelShader = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace shader
{
class PixelShaderDumperIW4 final : public AbstractAssetDumper<IW4::AssetPixelShader>
{
public:
explicit PixelShaderDumperIW4(const AssetPool<IW4::AssetPixelShader::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetPixelShader::Type>& asset) override;
};

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

@@ -6,11 +6,6 @@ using namespace IW4;
namespace shader
{
VertexShaderDumperIW4::VertexShaderDumperIW4(const AssetPool<AssetVertexShader::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void VertexShaderDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetVertexShader::Type>& asset)
{
const auto* vertexShader = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace shader
{
class VertexShaderDumperIW4 final : public AbstractAssetDumper<IW4::AssetVertexShader>
{
public:
explicit VertexShaderDumperIW4(const AssetPool<IW4::AssetVertexShader::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetVertexShader::Type>& asset) override;
};

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

@@ -25,11 +25,6 @@ namespace
namespace sound
{
LoadedSoundDumperIW4::LoadedSoundDumperIW4(const AssetPool<AssetLoadedSound::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void LoadedSoundDumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetLoadedSound::Type>& asset)
{
const auto* loadedSound = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace sound
{
class LoadedSoundDumperIW4 final : public AbstractAssetDumper<IW4::AssetLoadedSound>
{
public:
explicit LoadedSoundDumperIW4(const AssetPool<IW4::AssetLoadedSound::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetLoadedSound::Type>& asset) override;
};

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

@@ -7,11 +7,6 @@ using namespace IW4;
namespace sound_curve
{
DumperIW4::DumperIW4(const AssetPool<AssetSoundCurve::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetSoundCurve::Type>& asset)
{
const auto* sndCurve = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace sound_curve
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetSoundCurve>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetSoundCurve::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetSoundCurve::Type>& asset) override;
};

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

@@ -6,11 +6,6 @@ using namespace IW4;
namespace string_table
{
DumperIW4::DumperIW4(const AssetPool<AssetStringTable::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetStringTable::Type>& asset)
{
const auto* stringTable = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace string_table
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetStringTable>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetStringTable::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetStringTable::Type>& asset) override;
};

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

@@ -187,11 +187,6 @@ namespace
namespace structured_data_def
{
DumperIW4::DumperIW4(const AssetPool<AssetStructuredDataDef::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetStructuredDataDef::Type>& asset)
{
const auto* set = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace structured_data_def
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetStructuredDataDef>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetStructuredDataDef::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetStructuredDataDef::Type>& asset) override;
};

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

@@ -250,7 +250,8 @@ namespace
if (vertexShader->name[0] == ',')
{
const auto loadedVertexShaderFromOtherZone = GlobalAssetPool<MaterialVertexShader>::GetAssetByName(&vertexShader->name[1]);
const auto loadedVertexShaderFromOtherZone =
GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::IW4)->GetAsset<AssetVertexShader>(&vertexShader->name[1]);
if (loadedVertexShaderFromOtherZone == nullptr)
{
@@ -305,7 +306,8 @@ namespace
if (pixelShader->name[0] == ',')
{
const auto loadedPixelShaderFromOtherZone = GlobalAssetPool<MaterialPixelShader>::GetAssetByName(&pixelShader->name[1]);
const auto loadedPixelShaderFromOtherZone =
GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::IW4)->GetAsset<AssetPixelShader>(&pixelShader->name[1]);
if (loadedPixelShaderFromOtherZone == nullptr)
{
@@ -377,7 +379,8 @@ namespace
if (vertexDecl->name && vertexDecl->name[0] == ',')
{
const auto loadedVertexDeclFromOtherZone = GlobalAssetPool<MaterialVertexDeclaration>::GetAssetByName(&vertexDecl->name[1]);
const auto loadedVertexDeclFromOtherZone =
GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::IW4)->GetAsset<AssetVertexDecl>(&vertexDecl->name[1]);
if (loadedVertexDeclFromOtherZone == nullptr)
{
@@ -488,11 +491,6 @@ namespace
namespace techset
{
DumperIW4::DumperIW4(const AssetPool<AssetTechniqueSet::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetTechniqueSet::Type>& asset)
{
const auto* techniqueSet = asset.Asset();

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

@@ -7,9 +7,6 @@ namespace techset
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetTechniqueSet>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetTechniqueSet::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetTechniqueSet::Type>& asset) override;
};

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

@@ -52,11 +52,6 @@ namespace
namespace tracer
{
DumperIW4::DumperIW4(const AssetPool<AssetTracer::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetTracer::Type>& asset)
{
// Only dump raw when no gdt available

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

@@ -7,9 +7,6 @@ namespace tracer
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetTracer>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetTracer::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetTracer::Type>& asset) override;
};

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

@@ -93,11 +93,6 @@ namespace
namespace vehicle
{
DumperIW4::DumperIW4(const AssetPool<AssetVehicle::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetVehicle::Type>& asset)
{
// Only dump raw when no gdt available

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

@@ -7,9 +7,6 @@ namespace vehicle
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetVehicle>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetVehicle::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetVehicle::Type>& asset) override;
};

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

@@ -405,11 +405,6 @@ namespace
namespace weapon
{
DumperIW4::DumperIW4(const AssetPool<AssetWeapon::Type>& pool)
: AbstractAssetDumper(pool)
{
}
void DumperIW4::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetWeapon::Type>& asset)
{
// Only dump raw when no gdt available

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

@@ -7,9 +7,6 @@ namespace weapon
{
class DumperIW4 final : public AbstractAssetDumper<IW4::AssetWeapon>
{
public:
explicit DumperIW4(const AssetPool<IW4::AssetWeapon::Type>& pool);
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW4::AssetWeapon::Type>& asset) override;
};

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

@@ -62,8 +62,7 @@ namespace
namespace image
{
DumperIW5::DumperIW5(const AssetPool<AssetImage::Type>& pool)
: AbstractAssetDumper(pool)
DumperIW5::DumperIW5()
{
switch (ObjWriting::Configuration.ImageOutputFormat)
{

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

@@ -11,7 +11,7 @@ namespace image
class DumperIW5 final : public AbstractAssetDumper<IW5::AssetImage>
{
public:
explicit DumperIW5(const AssetPool<IW5::AssetImage::Type>& pool);
DumperIW5();
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<IW5::AssetImage::Type>& asset) override;

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