From 44d6710991675427b9bac5e8694ebd15bbc0bf16 Mon Sep 17 00:00:00 2001 From: mo Date: Sun, 7 Jun 2026 13:06:33 +0100 Subject: [PATCH] feat: initial T4 support (#807) * feat: initial T4 support * chore: adjust t4 symbols a bit for accuracy * chore: add PackIndex asset to T4 * chore: remove unused AssetXModelPieces * chore: add default and global asset pools loader for T4 * chore: use separate defines for T4 in ImageDumper * chore: remove unnecessary namespaces in gfximage_actions * chore: small things * chore: fix T4 PhysPreset type * chore: use proper XQuat2 type for T4 xanims * chore: fix errors on T4 types * chore: use iw3 like struct for XModelStreamInfo * docs: add basic docs for T4 * chore: add basic ObjCompiler setup for T4 * chore: adjust loaded sound definition * chore: make sure t4 material has the correct alignment * chore: make sure t4 uses similar names for assets as other games * fix: asset references should not be reusable * chore: add content writer for t4 * feat: add t4 localize loader * chore: reorder game ids to be alphabetically ordered --------- Co-authored-by: Jan Laupetin --- README.md | 1 + docs/SupportedAssetTypes.md | 33 + src/Common/Game/CommonAsset.cpp | 5 +- src/Common/Game/IGame.cpp | 5 +- src/Common/Game/IGame.h | 2 + src/Common/Game/IW3/IW3.h | 2 - src/Common/Game/T4/CommonAssetT4.cpp | 104 + src/Common/Game/T4/CommonAssetT4.h | 15 + src/Common/Game/T4/CommonT4.cpp | 35 + src/Common/Game/T4/CommonT4.h | 32 + src/Common/Game/T4/GameT4.cpp | 93 + src/Common/Game/T4/GameT4.h | 16 + src/Common/Game/T4/T4.h | 150 + src/Common/Game/T4/T4_Assets.h | 4109 +++++++++++++++++ src/ModMan/Web/Binds/ZoneBinds.cpp | 1 + src/ModManUi/src/native/ZoneBinds.ts | 1 + src/ObjCompiling/Game/T4/ObjCompilerT4.cpp | 39 + src/ObjCompiling/Game/T4/ObjCompilerT4.h | 19 + src/ObjCompiling/IObjCompiler.cpp | 4 +- .../T4/Localize/AssetLoaderLocalizeT4.cpp | 45 + .../Game/T4/Localize/AssetLoaderLocalizeT4.h | 14 + src/ObjLoading/Game/T4/ObjLoaderT4.cpp | 97 + src/ObjLoading/Game/T4/ObjLoaderT4.h | 16 + src/ObjLoading/IObjLoader.cpp | 4 +- .../Game/T4/Localize/LocalizeDumperT4.cpp | 44 + .../Game/T4/Localize/LocalizeDumperT4.h | 13 + src/ObjWriting/Game/T4/ObjWriterT4.cpp | 16 + src/ObjWriting/Game/T4/ObjWriterT4.h | 12 + .../Game/T4/RawFile/RawFileDumperT4.cpp | 18 + .../Game/T4/RawFile/RawFileDumperT4.h | 13 + .../T4/StringTable/StringTableDumperT4.cpp | 29 + .../Game/T4/StringTable/StringTableDumperT4.h | 13 + src/ObjWriting/Image/ImageDumper.cpp.template | 8 +- src/ObjWriting/Image/ImageDumper.h.template | 2 +- src/ObjWriting/ObjWriter.cpp | 4 +- src/ZoneCode.lua | 31 + src/ZoneCode/Game/T4/T4.gen | 1 + src/ZoneCode/Game/T4/T4_Commands.txt | 71 + src/ZoneCode/Game/T4/T4_ZoneCode.h | 12 + src/ZoneCode/Game/T4/XAssets/ComWorld.txt | 18 + .../Game/T4/XAssets/DestructibleDef.txt | 27 + src/ZoneCode/Game/T4/XAssets/Font_s.txt | 8 + src/ZoneCode/Game/T4/XAssets/FxEffectDef.txt | 44 + .../Game/T4/XAssets/FxImpactTable.txt | 7 + src/ZoneCode/Game/T4/XAssets/GameWorldMp.txt | 6 + src/ZoneCode/Game/T4/XAssets/GameWorldSp.txt | 39 + src/ZoneCode/Game/T4/XAssets/GfxImage.txt | 20 + src/ZoneCode/Game/T4/XAssets/GfxLightDef.txt | 6 + src/ZoneCode/Game/T4/XAssets/GfxWorld.txt | 138 + src/ZoneCode/Game/T4/XAssets/LoadedSound.txt | 10 + .../Game/T4/XAssets/LocalizeEntry.txt | 7 + src/ZoneCode/Game/T4/XAssets/MapEnts.txt | 7 + src/ZoneCode/Game/T4/XAssets/Material.txt | 23 + .../Game/T4/XAssets/MaterialTechniqueSet.txt | 55 + src/ZoneCode/Game/T4/XAssets/MenuList.txt | 7 + src/ZoneCode/Game/T4/XAssets/PackIndex.txt | 7 + .../Game/T4/XAssets/PhysConstraints.txt | 13 + src/ZoneCode/Game/T4/XAssets/PhysPreset.txt | 7 + src/ZoneCode/Game/T4/XAssets/RawFile.txt | 7 + .../Game/T4/XAssets/SndDriverGlobals.txt | 6 + src/ZoneCode/Game/T4/XAssets/StringTable.txt | 8 + src/ZoneCode/Game/T4/XAssets/WeaponDef.txt | 64 + src/ZoneCode/Game/T4/XAssets/XAnimParts.txt | 68 + src/ZoneCode/Game/T4/XAssets/XModel.txt | 88 + src/ZoneCode/Game/T4/XAssets/clipMap_t.txt | 85 + src/ZoneCode/Game/T4/XAssets/menuDef_t.txt | 80 + .../Game/T4/XAssets/snd_alias_list_t.txt | 44 + .../T4/Zone/Definition/ZoneDefWriterT4.cpp | 33 + .../Game/T4/Zone/Definition/ZoneDefWriterT4.h | 13 + src/ZoneCommon/Game/T4/ZoneConstantsT4.h | 24 + src/ZoneCommon/Pool/GlobalAssetPool.cpp | 4 +- .../Zone/Definition/ZoneDefWriter.cpp | 5 +- .../IW3/XAssets/gfximage/gfximage_actions.cpp | 2 +- .../IW4/XAssets/gfximage/gfximage_actions.cpp | 2 +- .../IW5/XAssets/gfximage/gfximage_actions.cpp | 2 +- src/ZoneLoading/Game/T4/ContentLoaderT4.cpp | 174 + src/ZoneLoading/Game/T4/ContentLoaderT4.h | 25 + .../T4/XAssets/gfximage/gfximage_actions.cpp | 24 + .../T4/XAssets/gfximage/gfximage_actions.h | 16 + .../Game/T4/ZoneLoaderFactoryT4.cpp | 89 + src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.h | 17 + .../T6/XAssets/gfximage/gfximage_actions.cpp | 2 +- .../Loading/IZoneLoaderFactory.cpp | 4 +- src/ZoneWriting/Game/T4/ContentWriterT4.cpp | 220 + src/ZoneWriting/Game/T4/ContentWriterT4.h | 32 + .../Game/T4/ZoneWriterFactoryT4.cpp | 71 + src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.h | 14 + .../Writing/IZoneWriterFactory.cpp | 4 +- 88 files changed, 6787 insertions(+), 18 deletions(-) create mode 100644 src/Common/Game/T4/CommonAssetT4.cpp create mode 100644 src/Common/Game/T4/CommonAssetT4.h create mode 100644 src/Common/Game/T4/CommonT4.cpp create mode 100644 src/Common/Game/T4/CommonT4.h create mode 100644 src/Common/Game/T4/GameT4.cpp create mode 100644 src/Common/Game/T4/GameT4.h create mode 100644 src/Common/Game/T4/T4.h create mode 100644 src/Common/Game/T4/T4_Assets.h create mode 100644 src/ObjCompiling/Game/T4/ObjCompilerT4.cpp create mode 100644 src/ObjCompiling/Game/T4/ObjCompilerT4.h create mode 100644 src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.cpp create mode 100644 src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.h create mode 100644 src/ObjLoading/Game/T4/ObjLoaderT4.cpp create mode 100644 src/ObjLoading/Game/T4/ObjLoaderT4.h create mode 100644 src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.cpp create mode 100644 src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.h create mode 100644 src/ObjWriting/Game/T4/ObjWriterT4.cpp create mode 100644 src/ObjWriting/Game/T4/ObjWriterT4.h create mode 100644 src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.cpp create mode 100644 src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.h create mode 100644 src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.cpp create mode 100644 src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.h create mode 100644 src/ZoneCode/Game/T4/T4.gen create mode 100644 src/ZoneCode/Game/T4/T4_Commands.txt create mode 100644 src/ZoneCode/Game/T4/T4_ZoneCode.h create mode 100644 src/ZoneCode/Game/T4/XAssets/ComWorld.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/DestructibleDef.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/Font_s.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/FxEffectDef.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/FxImpactTable.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/GameWorldMp.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/GameWorldSp.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/GfxImage.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/GfxLightDef.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/GfxWorld.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/LoadedSound.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/LocalizeEntry.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/MapEnts.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/Material.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/MaterialTechniqueSet.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/MenuList.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/PackIndex.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/PhysConstraints.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/PhysPreset.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/RawFile.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/SndDriverGlobals.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/StringTable.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/WeaponDef.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/XAnimParts.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/XModel.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/clipMap_t.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/menuDef_t.txt create mode 100644 src/ZoneCode/Game/T4/XAssets/snd_alias_list_t.txt create mode 100644 src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.cpp create mode 100644 src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.h create mode 100644 src/ZoneCommon/Game/T4/ZoneConstantsT4.h create mode 100644 src/ZoneLoading/Game/T4/ContentLoaderT4.cpp create mode 100644 src/ZoneLoading/Game/T4/ContentLoaderT4.h create mode 100644 src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.cpp create mode 100644 src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.h create mode 100644 src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp create mode 100644 src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.h create mode 100644 src/ZoneWriting/Game/T4/ContentWriterT4.cpp create mode 100644 src/ZoneWriting/Game/T4/ContentWriterT4.h create mode 100644 src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.cpp create mode 100644 src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.h diff --git a/README.md b/README.md index 78f93a26..ca651250 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ It currently offers support for the PC versions of: - [IW3 (COD4: Modern Warfare - 2007)](https://en.wikipedia.org/wiki/Call_of_Duty_4:_Modern_Warfare) - [IW4 (Modern Warfare 2 - 2009)](https://en.wikipedia.org/wiki/Call_of_Duty:_Modern_Warfare_2) - [IW5 (Modern Warfare 3 - 2011)](https://en.wikipedia.org/wiki/Call_of_Duty:_Modern_Warfare_3) +- [T4 (World at War - 2008)](https://en.wikipedia.org/wiki/Call_of_Duty:_World_at_War) - [T5 (Black Ops - 2010)](https://en.wikipedia.org/wiki/Call_of_Duty:_Black_Ops) - [T6 (Black Ops II - 2012)](https://en.wikipedia.org/wiki/Call_of_Duty:_Black_Ops_II) diff --git a/docs/SupportedAssetTypes.md b/docs/SupportedAssetTypes.md index 54d3c121..ce0e3220 100644 --- a/docs/SupportedAssetTypes.md +++ b/docs/SupportedAssetTypes.md @@ -122,6 +122,39 @@ The following section specify which assets are supported to be dumped to disk (u | VehicleDef | ❌ | ❌ | | | AddonMapEnts | ⁉️ | ❌ | MapEnts String can be exported. Binary data currently not. | +## T4 (Call of Duty: World at War) + +| Asset Type | Dumping Support | Loading Support | Notes | +| -------------------- | --------------- | --------------- | ---------------------------------------------------- | +| PhysPreset | ❌ | ❌ | | +| PhysConstraints | ❌ | ❌ | | +| DestructibleDef | ❌ | ❌ | | +| XAnimParts | ❌ | ❌ | | +| XModel | ❌ | ❌ | | +| Material | ❌ | ❌ | | +| MaterialTechniqueSet | ❌ | ❌ | | +| GfxImage | ✅ | ❌ | A few special image encodings are not yet supported. | +| snd_alias_list_t | ❌ | ❌ | | +| SndDriverGlobals | ❌ | ❌ | | +| LoadedSound | ❌ | ❌ | | +| clipMap_t | ❌ | ❌ | | +| ComWorld | ❌ | ❌ | | +| GameWorldSp | ❌ | ❌ | | +| GameWorldMp | ❌ | ❌ | | +| MapEnts | ❌ | ❌ | | +| GfxWorld | ❌ | ❌ | | +| GfxLightDef | ❌ | ❌ | | +| Font_s | ❌ | ❌ | | +| MenuList | ❌ | ❌ | | +| menuDef_t | ❌ | ❌ | | +| LocalizeEntry | ✅ | ❌ | | +| WeaponDef | ❌ | ❌ | | +| FxEffectDef | ❌ | ❌ | | +| FxImpactTable | ❌ | ❌ | | +| RawFile | ✅ | ❌ | | +| StringTable | ✅ | ❌ | | +| PackIndex | ❌ | ❌ | | + ## T5 (Call of Duty: Black Ops) | Asset Type | Dumping Support | Loading Support | Notes | diff --git a/src/Common/Game/CommonAsset.cpp b/src/Common/Game/CommonAsset.cpp index 30bdfd7d..4351ba91 100644 --- a/src/Common/Game/CommonAsset.cpp +++ b/src/Common/Game/CommonAsset.cpp @@ -3,6 +3,7 @@ #include "IW3/CommonAssetIW3.h" #include "IW4/CommonAssetIW4.h" #include "IW5/CommonAssetIW5.h" +#include "T4/CommonAssetT4.h" #include "T5/CommonAssetT5.h" #include "T6/CommonAssetT6.h" @@ -10,13 +11,15 @@ ICommonAssetTypeMapper* ICommonAssetTypeMapper::GetCommonAssetMapperByGame(GameId gameId) { - static ICommonAssetTypeMapper* assetTypeMappers[static_cast(GameId::COUNT)]{ + static ICommonAssetTypeMapper* assetTypeMappers[]{ new IW3::CommonAssetTypeMapper(), new IW4::CommonAssetTypeMapper(), new IW5::CommonAssetTypeMapper(), + new T4::CommonAssetTypeMapper(), new T5::CommonAssetTypeMapper(), new T6::CommonAssetTypeMapper(), }; + static_assert(std::extent_v == static_cast(GameId::COUNT)); assert(static_cast(gameId) < static_cast(GameId::COUNT)); auto* result = assetTypeMappers[static_cast(gameId)]; diff --git a/src/Common/Game/IGame.cpp b/src/Common/Game/IGame.cpp index 46ff44f2..368a2e12 100644 --- a/src/Common/Game/IGame.cpp +++ b/src/Common/Game/IGame.cpp @@ -3,6 +3,7 @@ #include "IW3/GameIW3.h" #include "IW4/GameIW4.h" #include "IW5/GameIW5.h" +#include "T4/GameT4.h" #include "T5/GameT5.h" #include "T6/GameT6.h" #include "Utils/StringUtils.h" @@ -11,13 +12,15 @@ IGame* IGame::GetGameById(GameId gameId) { - static IGame* games[static_cast(GameId::COUNT)]{ + static IGame* games[]{ new IW3::Game(), new IW4::Game(), new IW5::Game(), + new T4::Game(), new T5::Game(), new T6::Game(), }; + static_assert(std::extent_v == static_cast(GameId::COUNT)); assert(static_cast(gameId) < static_cast(GameId::COUNT)); auto* result = games[static_cast(gameId)]; diff --git a/src/Common/Game/IGame.h b/src/Common/Game/IGame.h index 4d2b08ba..8cfccf2b 100644 --- a/src/Common/Game/IGame.h +++ b/src/Common/Game/IGame.h @@ -15,6 +15,7 @@ enum class GameId : std::uint8_t IW3, IW4, IW5, + T4, T5, T6, @@ -48,6 +49,7 @@ static constexpr const char* GameId_Names[]{ "IW3", "IW4", "IW5", + "T4", "T5", "T6", }; diff --git a/src/Common/Game/IW3/IW3.h b/src/Common/Game/IW3/IW3.h index 138b60f0..9dc8eff3 100644 --- a/src/Common/Game/IW3/IW3.h +++ b/src/Common/Game/IW3/IW3.h @@ -159,7 +159,6 @@ namespace IW3 WFT_NUM_FIELD_TYPES }; - using AssetXModelPieces = Asset; using AssetPhysPreset = Asset; using AssetXAnim = Asset; using AssetXModel = Asset; @@ -194,7 +193,6 @@ namespace IW3 using SubAssetPixelShader = SubAsset; } // namespace IW3 -DEFINE_ASSET_NAME_ACCESSOR(IW3::AssetXModelPieces, name); DEFINE_ASSET_NAME_ACCESSOR(IW3::AssetPhysPreset, name); DEFINE_ASSET_NAME_ACCESSOR(IW3::AssetXAnim, name); DEFINE_ASSET_NAME_ACCESSOR(IW3::AssetXModel, name); diff --git a/src/Common/Game/T4/CommonAssetT4.cpp b/src/Common/Game/T4/CommonAssetT4.cpp new file mode 100644 index 00000000..0c833c0d --- /dev/null +++ b/src/Common/Game/T4/CommonAssetT4.cpp @@ -0,0 +1,104 @@ +#include "CommonAssetT4.h" + +#include "T4.h" + +#include + +namespace T4 +{ + CommonAssetTypeMapper::CommonAssetTypeMapper() = default; + + CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const + { + static CommonAssetType lookupTable[static_cast(ASSET_TYPE_COUNT)]{ + CommonAssetType::XMODEL_PIECES, // ASSET_TYPE_XMODELPIECES + CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET + CommonAssetType::PHYS_CONSTRAINTS, // ASSET_TYPE_PHYSCONSTRAINTS + CommonAssetType::DESTRUCTIBLE_DEF, // ASSET_TYPE_DESTRUCTIBLEDEF + CommonAssetType::XANIM, // ASSET_TYPE_XANIMPARTS + CommonAssetType::XMODEL, // ASSET_TYPE_XMODEL + CommonAssetType::MATERIAL, // ASSET_TYPE_MATERIAL + CommonAssetType::TECHNIQUE_SET, // ASSET_TYPE_TECHNIQUE_SET + CommonAssetType::IMAGE, // ASSET_TYPE_IMAGE + CommonAssetType::SOUND, // ASSET_TYPE_SOUND + CommonAssetType::LOADED_SOUND, // ASSET_TYPE_LOADED_SOUND + CommonAssetType::CLIP_MAP, // ASSET_TYPE_CLIPMAP + CommonAssetType::CLIP_MAP, // ASSET_TYPE_CLIPMAP_PVS + CommonAssetType::COM_WORLD, // ASSET_TYPE_COMWORLD + CommonAssetType::GAME_WORLD_SP, // ASSET_TYPE_GAMEWORLD_SP + CommonAssetType::GAME_WORLD_MP, // ASSET_TYPE_GAMEWORLD_MP + CommonAssetType::MAP_ENTS, // ASSET_TYPE_MAP_ENTS + CommonAssetType::GFX_WORLD, // ASSET_TYPE_GFXWORLD + CommonAssetType::LIGHT_DEF, // ASSET_TYPE_LIGHT_DEF + CommonAssetType::UI_MAP, // ASSET_TYPE_UI_MAP + CommonAssetType::FONT, // ASSET_TYPE_FONT + CommonAssetType::MENU_LIST, // ASSET_TYPE_MENULIST + CommonAssetType::MENU, // ASSET_TYPE_MENU + CommonAssetType::LOCALIZE_ENTRY, // ASSET_TYPE_LOCALIZE_ENTRY + CommonAssetType::WEAPON, // ASSET_TYPE_WEAPON + CommonAssetType::SOUND_DRIVER_GLOBALS, // ASSET_TYPE_SNDDRIVER_GLOBALS + CommonAssetType::FX, // ASSET_TYPE_FX + CommonAssetType::IMPACT_FX, // ASSET_TYPE_IMPACT_FX + CommonAssetType::AI_TYPE, // ASSET_TYPE_AITYPE + CommonAssetType::MP_TYPE, // ASSET_TYPE_MPTYPE + CommonAssetType::CHARACTER, // ASSET_TYPE_CHARACTER + CommonAssetType::XMODEL_ALIAS, // ASSET_TYPE_XMODELALIAS + CommonAssetType::RAW_FILE, // ASSET_TYPE_RAWFILE + CommonAssetType::STRING_TABLE, // ASSET_TYPE_STRINGTABLE + CommonAssetType::PACK_INDEX, // ASSET_TYPE_PACK_INDEX + }; + + assert(gameAssetType < ASSET_TYPE_COUNT); + return lookupTable[gameAssetType]; + } + + std::optional CommonAssetTypeMapper::CommonToGameAssetType(const CommonAssetType commonAssetType) const + { +#define MAP_COMMON(common, game) \ + case common: \ + return game; + + switch (commonAssetType) + { + MAP_COMMON(CommonAssetType::XMODEL_PIECES, ASSET_TYPE_XMODELPIECES) + MAP_COMMON(CommonAssetType::PHYS_PRESET, ASSET_TYPE_PHYSPRESET) + MAP_COMMON(CommonAssetType::PHYS_CONSTRAINTS, ASSET_TYPE_PHYSCONSTRAINTS) + MAP_COMMON(CommonAssetType::DESTRUCTIBLE_DEF, ASSET_TYPE_DESTRUCTIBLEDEF) + MAP_COMMON(CommonAssetType::XANIM, ASSET_TYPE_XANIMPARTS) + MAP_COMMON(CommonAssetType::XMODEL, ASSET_TYPE_XMODEL) + MAP_COMMON(CommonAssetType::MATERIAL, ASSET_TYPE_MATERIAL) + MAP_COMMON(CommonAssetType::TECHNIQUE_SET, ASSET_TYPE_TECHNIQUE_SET) + MAP_COMMON(CommonAssetType::IMAGE, ASSET_TYPE_IMAGE) + MAP_COMMON(CommonAssetType::SOUND, ASSET_TYPE_SOUND) + MAP_COMMON(CommonAssetType::LOADED_SOUND, ASSET_TYPE_LOADED_SOUND) + MAP_COMMON(CommonAssetType::CLIP_MAP, ASSET_TYPE_CLIPMAP_PVS) + MAP_COMMON(CommonAssetType::COM_WORLD, ASSET_TYPE_COMWORLD) + MAP_COMMON(CommonAssetType::GAME_WORLD_SP, ASSET_TYPE_GAMEWORLD_SP) + MAP_COMMON(CommonAssetType::GAME_WORLD_MP, ASSET_TYPE_GAMEWORLD_MP) + MAP_COMMON(CommonAssetType::MAP_ENTS, ASSET_TYPE_MAP_ENTS) + MAP_COMMON(CommonAssetType::GFX_WORLD, ASSET_TYPE_GFXWORLD) + MAP_COMMON(CommonAssetType::LIGHT_DEF, ASSET_TYPE_LIGHT_DEF) + MAP_COMMON(CommonAssetType::UI_MAP, ASSET_TYPE_UI_MAP) + MAP_COMMON(CommonAssetType::FONT, ASSET_TYPE_FONT) + MAP_COMMON(CommonAssetType::MENU_LIST, ASSET_TYPE_MENULIST) + MAP_COMMON(CommonAssetType::MENU, ASSET_TYPE_MENU) + MAP_COMMON(CommonAssetType::LOCALIZE_ENTRY, ASSET_TYPE_LOCALIZE_ENTRY) + MAP_COMMON(CommonAssetType::WEAPON, ASSET_TYPE_WEAPON) + MAP_COMMON(CommonAssetType::SOUND_DRIVER_GLOBALS, ASSET_TYPE_SNDDRIVER_GLOBALS) + MAP_COMMON(CommonAssetType::FX, ASSET_TYPE_FX) + MAP_COMMON(CommonAssetType::IMPACT_FX, ASSET_TYPE_IMPACT_FX) + MAP_COMMON(CommonAssetType::AI_TYPE, ASSET_TYPE_AITYPE) + MAP_COMMON(CommonAssetType::MP_TYPE, ASSET_TYPE_MPTYPE) + MAP_COMMON(CommonAssetType::CHARACTER, ASSET_TYPE_CHARACTER) + MAP_COMMON(CommonAssetType::XMODEL_ALIAS, ASSET_TYPE_XMODELALIAS) + MAP_COMMON(CommonAssetType::RAW_FILE, ASSET_TYPE_RAWFILE) + MAP_COMMON(CommonAssetType::STRING_TABLE, ASSET_TYPE_STRINGTABLE) + MAP_COMMON(CommonAssetType::PACK_INDEX, ASSET_TYPE_PACK_INDEX) + + default: + return std::nullopt; + } + +#undef MAP_COMMON + } +} // namespace T4 diff --git a/src/Common/Game/T4/CommonAssetT4.h b/src/Common/Game/T4/CommonAssetT4.h new file mode 100644 index 00000000..dc77abb0 --- /dev/null +++ b/src/Common/Game/T4/CommonAssetT4.h @@ -0,0 +1,15 @@ +#pragma once + +#include "Game/CommonAsset.h" + +namespace T4 +{ + class CommonAssetTypeMapper final : public ICommonAssetTypeMapper + { + public: + CommonAssetTypeMapper(); + + [[nodiscard]] CommonAssetType GameToCommonAssetType(asset_type_t gameAssetType) const override; + [[nodiscard]] std::optional CommonToGameAssetType(CommonAssetType commonAssetType) const override; + }; +} // namespace T4 diff --git a/src/Common/Game/T4/CommonT4.cpp b/src/Common/Game/T4/CommonT4.cpp new file mode 100644 index 00000000..c97e767c --- /dev/null +++ b/src/Common/Game/T4/CommonT4.cpp @@ -0,0 +1,35 @@ +#include "CommonT4.h" + +#include "Utils/Pack.h" + +using namespace T4; + +PackedTexCoords Common::Vec2PackTexCoords(const float (&in)[2]) +{ + return PackedTexCoords{pack32::Vec2PackTexCoordsVU(in)}; +} + +PackedUnitVec Common::Vec3PackUnitVec(const float (&in)[3]) +{ + return PackedUnitVec{pack32::Vec3PackUnitVecScaleBased(in)}; +} + +GfxColor Common::Vec4PackGfxColor(const float (&in)[4]) +{ + return GfxColor{pack32::Vec4PackGfxColor(in)}; +} + +void Common::Vec2UnpackTexCoords(const PackedTexCoords& in, float (&out)[2]) +{ + pack32::Vec2UnpackTexCoordsVU(in.packed, out); +} + +void Common::Vec3UnpackUnitVec(const PackedUnitVec& in, float (&out)[3]) +{ + pack32::Vec3UnpackUnitVecScaleBased(in.packed, out); +} + +void Common::Vec4UnpackGfxColor(const GfxColor& in, float (&out)[4]) +{ + pack32::Vec4UnpackGfxColor(in.packed, out); +} diff --git a/src/Common/Game/T4/CommonT4.h b/src/Common/Game/T4/CommonT4.h new file mode 100644 index 00000000..52ac43cd --- /dev/null +++ b/src/Common/Game/T4/CommonT4.h @@ -0,0 +1,32 @@ +#pragma once + +#include "T4.h" +#include "Utils/Djb2.h" + +#include + +namespace T4 +{ + class Common + { + public: + static constexpr uint32_t R_HashString(const char* str, const uint32_t hash) + { + return djb2_xor_nocase(str, hash); + } + + static constexpr uint32_t R_HashString(const char* string) + { + // Using djb2 with a 0 starting value makes a worse hash func apparently + // but who am I to judge + return R_HashString(string, 0u); + } + + static PackedTexCoords Vec2PackTexCoords(const float (&in)[2]); + static PackedUnitVec Vec3PackUnitVec(const float (&in)[3]); + static GfxColor Vec4PackGfxColor(const float (&in)[4]); + static void Vec2UnpackTexCoords(const PackedTexCoords& in, float (&out)[2]); + static void Vec3UnpackUnitVec(const PackedUnitVec& in, float (&out)[3]); + static void Vec4UnpackGfxColor(const GfxColor& in, float (&out)[4]); + }; +} // namespace T4 diff --git a/src/Common/Game/T4/GameT4.cpp b/src/Common/Game/T4/GameT4.cpp new file mode 100644 index 00000000..ed9252b6 --- /dev/null +++ b/src/Common/Game/T4/GameT4.cpp @@ -0,0 +1,93 @@ +#include "GameT4.h" + +#include "T4.h" + +#include + +using namespace T4; + +namespace +{ + constexpr const char* ASSET_TYPE_NAMES[]{ + "xmodelpieces", + "physpreset", + "physconstraints", + "destructibledef", + "xanim", + "xmodel", + "material", + "techniqueset", + "image", + "sound", + "loadedsound", + "clipmap_unused", + "clipmap", + "comworld", + "gameworldsp", + "gameworldmp", + "mapents", + "gfxworld", + "lightdef", + "uimap", + "font", + "menulist", + "menu", + "localize", + "weapon", + "snddriverglobals", + "fx", + "impactfx", + "aitype", + "mptype", + "character", + "xmodelalias", + "rawfile", + "stringtable", + "packindex", + }; + static_assert(std::extent_v == ASSET_TYPE_COUNT); + + constexpr const char* SUB_ASSET_TYPE_NAMES[]{ + "technique", + "vertexdecl", + "vertexshader", + "pixelshader", + }; + static_assert(std::extent_v == SUB_ASSET_TYPE_COUNT); +} // namespace + +namespace T4 +{ + Game::Game() + : AbstractGame(ASSET_TYPE_NAMES, std::extent_v, SUB_ASSET_TYPE_NAMES, std::extent_v) + { + AddAssetTypeNameAlias("techset"); + AddAssetTypeNameAlias("loaded_sound"); + AddAssetTypeNameAlias("col_map_sp"); + AddAssetTypeNameAlias("col_map_mp"); + AddAssetTypeNameAlias("com_map"); + AddAssetTypeNameAlias("game_map_sp"); + AddAssetTypeNameAlias("game_map_mp"); + AddAssetTypeNameAlias("map_ents"); + AddAssetTypeNameAlias("gfx_map"); + AddAssetTypeNameAlias("gfxlightdef"); + AddAssetTypeNameAlias("menufile"); + } + + GameId Game::GetId() const + { + return GameId::T4; + } + + const std::string& Game::GetFullName() const + { + static std::string fullName = "Call Of Duty: World at War"; + return fullName; + } + + const std::string& Game::GetShortName() const + { + static std::string shortName = "T4"; + return shortName; + } +} // namespace T4 diff --git a/src/Common/Game/T4/GameT4.h b/src/Common/Game/T4/GameT4.h new file mode 100644 index 00000000..fb7fc691 --- /dev/null +++ b/src/Common/Game/T4/GameT4.h @@ -0,0 +1,16 @@ +#pragma once + +#include "Game/IGame.h" + +namespace T4 +{ + class Game final : public AbstractGame + { + public: + Game(); + + [[nodiscard]] GameId GetId() const override; + [[nodiscard]] const std::string& GetFullName() const override; + [[nodiscard]] const std::string& GetShortName() const override; + }; +} // namespace T4 diff --git a/src/Common/Game/T4/T4.h b/src/Common/Game/T4/T4.h new file mode 100644 index 00000000..09ec32d0 --- /dev/null +++ b/src/Common/Game/T4/T4.h @@ -0,0 +1,150 @@ +#pragma once + +// clang-format off: Order of includes matters here + +#include "Game/IAsset.h" + +#include "T4_Assets.h" + +// clang-format on + +namespace T4 +{ + 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_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_PACK_INDEX, + + ASSET_TYPE_COUNT, + + ASSET_TYPE_STRING = ASSET_TYPE_COUNT, + ASSET_TYPE_ASSETLIST + }; + + enum SubAssetType + { + SUB_ASSET_TYPE_TECHNIQUE, + SUB_ASSET_TYPE_VERTEX_DECL, + SUB_ASSET_TYPE_VERTEX_SHADER, + SUB_ASSET_TYPE_PIXEL_SHADER, + + SUB_ASSET_TYPE_COUNT + }; + + struct ScriptStringList + { + int count; + const char** strings; + }; + + struct XAsset + { + XAssetType type; + XAssetHeader header; + }; + + struct XAssetList + { + ScriptStringList stringList; + int assetCount; + XAsset* assets; + }; + + using AssetPhysPreset = Asset; + using AssetPhysConstraints = Asset; + using AssetDestructibleDef = Asset; + using AssetXAnim = Asset; + using AssetXModel = Asset; + using AssetMaterial = Asset; + using AssetTechniqueSet = Asset; + using AssetImage = Asset; + using AssetSound = Asset; + using AssetLoadedSound = Asset; + using AssetClipMap = Asset; + using AssetClipMapPvs = Asset; + using AssetComWorld = Asset; + using AssetGameWorldSp = Asset; + using AssetGameWorldMp = Asset; + using AssetMapEnts = Asset; + using AssetGfxWorld = Asset; + using AssetLightDef = Asset; + using AssetFont = Asset; + using AssetMenuList = Asset; + using AssetMenu = Asset; + using AssetLocalize = Asset; + using AssetWeapon = Asset; + using AssetSoundDriverGlobals = Asset; + using AssetFx = Asset; + using AssetImpactFx = Asset; + using AssetRawFile = Asset; + using AssetStringTable = Asset; + using AssetPackIndex = Asset; + + using SubAssetTechnique = SubAsset; + using SubAssetVertexDecl = SubAsset; + using SubAssetVertexShader = SubAsset; + using SubAssetPixelShader = SubAsset; +} // namespace T4 + +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetPhysPreset, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetPhysConstraints, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetDestructibleDef, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetXAnim, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetXModel, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetMaterial, info.name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetTechniqueSet, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetImage, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetSound, aliasName); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetLoadedSound, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetClipMap, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetClipMapPvs, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetComWorld, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetGameWorldSp, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetGameWorldMp, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetMapEnts, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetGfxWorld, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetLightDef, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetFont, fontName); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetMenuList, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetMenu, window.name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetLocalize, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetWeapon, szInternalName); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetSoundDriverGlobals, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetFx, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetImpactFx, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetRawFile, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetStringTable, name); +DEFINE_ASSET_NAME_ACCESSOR(T4::AssetPackIndex, name); diff --git a/src/Common/Game/T4/T4_Assets.h b/src/Common/Game/T4/T4_Assets.h new file mode 100644 index 00000000..4072e978 --- /dev/null +++ b/src/Common/Game/T4/T4_Assets.h @@ -0,0 +1,4109 @@ +#pragma once + +#ifndef __T4_ASSETS_H +#define __T4_ASSETS_H + +#include "../../Utils/TypeAlignment.h" + +#ifndef __zonecodegenerator +namespace T4 +{ +#endif + enum XFileBlock + { + XFILE_BLOCK_TEMP, + XFILE_BLOCK_RUNTIME, + XFILE_BLOCK_LARGE_RUNTIME, + XFILE_BLOCK_PHYSICAL_RUNTIME, + XFILE_BLOCK_VIRTUAL, + XFILE_BLOCK_LARGE, + XFILE_BLOCK_PHYSICAL, + + MAX_XFILE_COUNT + }; + + struct XModelPieces; + struct PhysPreset; + struct PhysConstraints; + struct DestructibleDef; + struct XAnimParts; + struct XModel; + struct Material; + struct MaterialPixelShader; + struct MaterialVertexShader; + struct MaterialTechniqueSet; + struct GfxImage; + struct snd_alias_list_t; + struct LoadedSound; + struct clipMap_t; + struct ComWorld; + struct GameWorldSp; + struct GameWorldMp; + struct MapEnts; + struct GfxWorld; + struct GfxLightDef; + struct Font_s; + struct MenuList; + struct menuDef_t; + struct LocalizeEntry; + struct WeaponDef; + struct SndDriverGlobals; + struct FxEffectDef; + struct FxImpactTable; + struct RawFile; + struct StringTable; + struct PackIndex; + + typedef unsigned short ScriptString; + typedef tdef_align32(16) char raw_byte16; + + union XAssetHeader + { + // XModelPieces *xmodelPieces; // NOT AN ASSET + PhysPreset* physPreset; + PhysConstraints* physConstraints; + DestructibleDef* destructibleDef; + XAnimParts* parts; + XModel* model; + Material* material; + MaterialPixelShader* pixelShader; + MaterialVertexShader* vertexShader; + MaterialTechniqueSet* techniqueSet; + GfxImage* image; + snd_alias_list_t* sound; + LoadedSound* loadSnd; + clipMap_t* clipMap; + ComWorld* comWorld; + GameWorldSp* gameWorldSp; + GameWorldMp* gameWorldMp; + MapEnts* mapEnts; + GfxWorld* gfxWorld; + GfxLightDef* lightDef; + Font_s* font; + MenuList* menuList; + menuDef_t* menu; + LocalizeEntry* localize; + WeaponDef* weapon; + SndDriverGlobals* sndDriverGlobals; + FxEffectDef* fx; + FxImpactTable* impactFx; + RawFile* rawfile; + StringTable* stringTable; + PackIndex* packIndex; + void* data; + }; + + typedef char cbrushedge_t; + typedef tdef_align32(128) unsigned int raw_uint128; + + union vec2_t + { + float v[2]; + + struct + { + float x; + float y; + }; + }; + + union vec3_t + { + struct + { + float x; + float y; + float z; + }; + + float v[3]; + }; + + union vec4_t + { + float v[4]; + + struct + { + float x; + float y; + float z; + float w; + }; + + struct + { + float r; + float g; + float b; + float a; + }; + }; + + enum ConstraintType : int + { + CONSTRAINT_NONE = 0x0, + CONSTRAINT_POINT = 0x1, + CONSTRAINT_DISTANCE = 0x2, + CONSTRAINT_HINGE = 0x3, + CONSTRAINT_JOINT = 0x4, + CONSTRAINT_ACTUATOR = 0x5, + CONSTRAINT_FAKE_SHAKE = 0x6, + CONSTRAINT_LAUNCH = 0x7, + CONSTRAINT_ROPE = 0x8, + NUM_CONSTRAINT_TYPES = 0x9, + }; + + enum AttachPointType : int + { + ATTACH_POINT_WORLD = 0x0, + ATTACH_POINT_DYNENT = 0x1, + ATTACH_POINT_ENT = 0x2, + ATTACH_POINT_BONE = 0x3, + }; + + struct XModelPiece + { + XModel* model; + float offset[3]; + }; + + struct XModelPieces + { + const char* name; + int numpieces; + XModelPiece* pieces; + }; + + struct PhysPreset + { + const char* name; + int type; + float mass; + float bounce; + float friction; + float bulletForceScale; + float explosiveForceScale; + const char* sndAliasPrefix; + float piecesSpreadFraction; + float piecesUpwardVelocity; + int canFloat; + float gravityScale; + }; + + struct PhysPresetInfo + { + float mass; + float bounce; + float friction; + int isFrictionInfinity; + float bulletForceScale; + float explosiveForceScale; + const char* sndAliasPrefix; + float piecesSpreadFraction; + float piecesUpwardVelocity; + int canFloat; + float gravityScale; + }; + + union XAnimIndices + { + unsigned char* _1; + uint16_t* _2; + void* data; + }; + + struct XAnimNotifyInfo + { + ScriptString name; + float time; + }; + + typedef unsigned char ByteVec[3]; + typedef tdef_align32(4) unsigned short UShortVec[3]; + + union XAnimDynamicIndicesTrans + { + unsigned char _1[1]; + uint16_t _2[1]; + }; + + union XAnimDynamicFrames + { + ByteVec* _1; + UShortVec* _2; + }; + + struct XAnimPartTransFrames + { + float mins[3]; + float size[3]; + XAnimDynamicFrames frames; + XAnimDynamicIndicesTrans indices; + }; + + union XAnimPartTransData + { + XAnimPartTransFrames frames; + vec3_t frame0; + }; + + struct XAnimPartTrans + { + uint16_t size; + unsigned char smallTrans; + XAnimPartTransData u; + }; + + struct type_align(4) XQuat + { + int16_t value[4]; + }; + + struct type_align(4) XQuat2 + { + int16_t value[2]; + }; + + union XAnimDynamicIndicesQuat + { + unsigned char _1[1]; + uint16_t _2[1]; + }; + + struct XAnimDeltaPartQuatDataFrames + { + XQuat2* frames; + XAnimDynamicIndicesQuat indices; + }; + + union XAnimDeltaPartQuatData + { + XAnimDeltaPartQuatDataFrames frames; + XQuat2 frame0; + }; + + struct XAnimDeltaPartQuat + { + uint16_t size; + XAnimDeltaPartQuatData u; + }; + + struct XAnimDeltaPart + { + XAnimPartTrans* trans; + XAnimDeltaPartQuat* quat; + }; + + enum XAnimPartType + { + PART_TYPE_NO_QUAT = 0x0, + PART_TYPE_HALF_QUAT = 0x1, + PART_TYPE_FULL_QUAT = 0x2, + PART_TYPE_HALF_QUAT_NO_SIZE = 0x3, + PART_TYPE_FULL_QUAT_NO_SIZE = 0x4, + PART_TYPE_SMALL_TRANS = 0x5, + PART_TYPE_TRANS = 0x6, + PART_TYPE_TRANS_NO_SIZE = 0x7, + PART_TYPE_NO_TRANS = 0x8, + PART_TYPE_ALL = 0x9, + + PART_TYPE_COUNT + }; + + struct XAnimParts + { + const char* name; + uint16_t dataByteCount; + uint16_t dataShortCount; + uint16_t dataIntCount; + uint16_t randomDataByteCount; + uint16_t randomDataIntCount; + uint16_t numframes; + bool bLoop; + bool bDelta; + unsigned char boneCount[PART_TYPE_COUNT]; + unsigned char notifyCount; + unsigned char assetType; + bool isDefault; + unsigned int randomDataShortCount; + unsigned int indexCount; + float framerate; + float frequency; + ScriptString* names; + unsigned char* dataByte; + int16_t* dataShort; + int* dataInt; + int16_t* randomDataShort; + unsigned char* randomDataByte; + int* randomDataInt; + XAnimIndices indices; + XAnimNotifyInfo* notify; + XAnimDeltaPart* deltaPart; + }; + + struct DObjSkelMat + { + float axis[3][4]; + float origin[4]; + }; + + struct DObjAnimMat + { + vec4_t quat; + vec3_t trans; + float transWeight; + }; + + struct XSurfaceCollisionAabb + { + uint16_t mins[3]; + uint16_t maxs[3]; + }; + + struct type_align(16) XSurfaceCollisionNode + { + XSurfaceCollisionAabb aabb; + uint16_t childBeginIndex; + uint16_t childCount; + }; + + struct XSurfaceCollisionLeaf + { + uint16_t triangleBeginIndex; + }; + + struct XSurfaceCollisionTree + { + float trans[3]; + float scale[3]; + unsigned int nodeCount; + XSurfaceCollisionNode* nodes; + unsigned int leafCount; + XSurfaceCollisionLeaf* leafs; + }; + + struct XRigidVertList + { + uint16_t boneOffset; + uint16_t vertCount; + uint16_t triOffset; + uint16_t triCount; + XSurfaceCollisionTree* collisionTree; + }; + + union GfxColor + { + unsigned int packed; + unsigned char array[4]; + }; + + union PackedTexCoords + { + unsigned int packed; + }; + + union PackedUnitVec + { + unsigned int packed; + unsigned char array[4]; + }; + + struct type_align(16) GfxPackedVertex + { + vec3_t xyz; + float binormalSign; + GfxColor color; + PackedTexCoords texCoord; + PackedUnitVec normal; + PackedUnitVec tangent; + }; + + struct XSurfaceVertexInfo + { + int16_t vertCount[4]; + uint16_t* vertsBlend; + }; + + struct XSurfaceTri + { + uint16_t i[3]; + }; + + typedef tdef_align32(16) XSurfaceTri XSurfaceTri16; + + struct XSurface + { + char tileMode; + bool deformed; + uint16_t vertCount; + uint16_t triCount; + char zoneHandle; + uint16_t baseTriIndex; + uint16_t baseVertIndex; + XSurfaceTri16* triIndices; + XSurfaceVertexInfo vertInfo; + GfxPackedVertex* verts0; + void /*IDirect3DVertexBuffer9*/* vb0; + unsigned int vertListCount; + XRigidVertList* vertList; + int partBits[4]; + void /*IDirect3DIndexBuffer9*/* indexBuffer; + }; + + struct XModelLodInfo + { + float dist; + uint16_t numsurfs; + uint16_t surfIndex; + int partBits[4]; + char lod; + char smcIndexPlusOne; + char smcAllocBits; + char unused; + }; + + struct XModelCollTri_s + { + float plane[4]; + float svec[4]; + float tvec[4]; + }; + + struct XModelCollSurf_s + { + XModelCollTri_s* collTris; + int numCollTris; + float mins[3]; + float maxs[3]; + int boneIdx; + int contents; + int surfFlags; + }; + + struct XBoneInfo + { + vec3_t bounds[2]; + vec3_t offset; + float radiusSquared; + }; + + struct cplane_s + { + float normal[3]; + float dist; + char type; + char signbits; + char pad[2]; + }; + + struct cbrushside_t + { + cplane_s* plane; + unsigned int materialNum; + int16_t firstAdjacentSideOffset; + char edgeCount; + }; + + struct type_align32(16) BrushWrapper + { + float mins[3]; + int contents; + float maxs[3]; + unsigned int numsides; + cbrushside_t* sides; + int16_t axialMaterialNum[2][3]; + cbrushedge_t* baseAdjacentSide; + int16_t firstAdjacentSideOffsets[2][3]; + char edgeCount[2][3]; + unsigned int numverts; + vec3_t* verts; + int totalEdgeCount; + cplane_s* planes; + }; + + struct PhysGeomInfo + { + BrushWrapper* brush; + int type; + float orientation[3][3]; + float offset[3]; + float halfLengths[3]; + }; + + struct PhysMass + { + float centerOfMass[3]; + }; + + struct PhysGeomList + { + unsigned int count; + PhysGeomInfo* geoms; + PhysMass mass; + }; + + struct PhysConstraint + { + ScriptString targetname; + ConstraintType type; + AttachPointType attach_point_type1; + int target_index1; + ScriptString target_ent1; + const char* target_bone1; + AttachPointType attach_point_type2; + int target_index2; + ScriptString target_ent2; + const char* target_bone2; + float offset[3]; + float pos[3]; + float pos2[3]; + float dir[3]; + int flags; + int timeout; + int min_health; + int max_health; + float distance; + float damp; + float power; + float scale[3]; + float spin_scale; + float minAngle; + float maxAngle; + Material* material; + int constraintHandle; + int rope_index; + }; + + struct PhysConstraints + { + const char* name; + unsigned int count; + PhysConstraint data[16]; + }; + + enum XModelLodRampType : unsigned char + { + XMODEL_LOD_RAMP_RIGID = 0x0, + XMODEL_LOD_RAMP_SKINNED = 0x1, + + XMODEL_LOD_RAMP_COUNT + }; + + struct XModelHighMipBounds + { + float mins[3]; + float maxs[3]; + }; + + struct XModelStreamInfo + { + char pad; + }; + + struct XModelQuat + { + int16_t v[4]; + }; + + struct XModel + { + const char* name; + unsigned char numBones; + unsigned char numRootBones; + unsigned char numsurfs; + XModelLodRampType lodRampType; + ScriptString* boneNames; + unsigned char* parentList; + XModelQuat* quats; + float* trans; + unsigned char* partClassification; + DObjAnimMat* baseMat; + XSurface* surfs; + Material** materialHandles; + XModelLodInfo lodInfo[4]; + XModelCollSurf_s* collSurfs; + int numCollSurfs; + int contents; + XBoneInfo* boneInfo; + float radius; + vec3_t mins; + vec3_t maxs; + uint16_t numLods; + int16_t collLod; + XModelStreamInfo streamInfo; + int memUsage; + unsigned char flags; + bool bad; + PhysPreset* physPreset; + PhysGeomList* physGeoms; + PhysGeomList* collmap; + PhysConstraints* physConstraints; + }; + + enum GfxBlend + { + GFXS_BLEND_DISABLED = 0x0, + GFXS_BLEND_ZERO = 0x1, + GFXS_BLEND_ONE = 0x2, + GFXS_BLEND_SRCCOLOR = 0x3, + GFXS_BLEND_INVSRCCOLOR = 0x4, + GFXS_BLEND_SRCALPHA = 0x5, + GFXS_BLEND_INVSRCALPHA = 0x6, + GFXS_BLEND_DESTALPHA = 0x7, + GFXS_BLEND_INVDESTALPHA = 0x8, + GFXS_BLEND_DESTCOLOR = 0x9, + GFXS_BLEND_INVDESTCOLOR = 0xA, + + GFXS_BLEND_COUNT + }; + + enum GfxBlendOp + { + GFXS_BLENDOP_DISABLED = 0x0, + GFXS_BLENDOP_ADD = 0x1, + GFXS_BLENDOP_SUBTRACT = 0x2, + GFXS_BLENDOP_REVSUBTRACT = 0x3, + GFXS_BLENDOP_MIN = 0x4, + GFXS_BLENDOP_MAX = 0x5, + + GFXS_BLENDOP_COUNT + }; + + enum GfxAlphaTest_e + { + GFXS_ALPHA_TEST_GT_0 = 1, + GFXS_ALPHA_TEST_LT_128 = 2, + GFXS_ALPHA_TEST_GE_128 = 3, + + GFXS_ALPHA_TEST_COUNT + }; + + enum GfxCullFace_e + { + GFXS_CULL_NONE = 1, + GFXS_CULL_BACK = 2, + GFXS_CULL_FRONT = 3, + }; + + enum GfxDepthTest_e + { + GFXS_DEPTHTEST_ALWAYS = 0, + GFXS_DEPTHTEST_LESS = 1, + GFXS_DEPTHTEST_EQUAL = 2, + GFXS_DEPTHTEST_LESSEQUAL = 3 + }; + + enum GfxPolygonOffset_e + { + GFXS_POLYGON_OFFSET_0 = 0, + GFXS_POLYGON_OFFSET_1 = 1, + GFXS_POLYGON_OFFSET_2 = 2, + GFXS_POLYGON_OFFSET_SHADOWMAP = 3 + }; + + enum GfxStencilOp + { + GFXS_STENCILOP_KEEP = 0x0, + GFXS_STENCILOP_ZERO = 0x1, + GFXS_STENCILOP_REPLACE = 0x2, + GFXS_STENCILOP_INCRSAT = 0x3, + GFXS_STENCILOP_DECRSAT = 0x4, + GFXS_STENCILOP_INVERT = 0x5, + GFXS_STENCILOP_INCR = 0x6, + GFXS_STENCILOP_DECR = 0x7 + }; + + enum GfxStencilFunc + { + GFXS_STENCILFUNC_NEVER = 0x0, + GFXS_STENCILFUNC_LESS = 0x1, + GFXS_STENCILFUNC_EQUAL = 0x2, + GFXS_STENCILFUNC_LESSEQUAL = 0x3, + GFXS_STENCILFUNC_GREATER = 0x4, + GFXS_STENCILFUNC_NOTEQUAL = 0x5, + GFXS_STENCILFUNC_GREATEREQUAL = 0x6, + GFXS_STENCILFUNC_ALWAYS = 0x7 + }; + + enum GfxStateBitsEnum : unsigned int + { + GFXS0_SRCBLEND_RGB_SHIFT = 0x0, + GFXS0_SRCBLEND_RGB_MASK = 0xF, + + GFXS0_DSTBLEND_RGB_SHIFT = 0x4, + GFXS0_DSTBLEND_RGB_MASK = 0xF0, + + GFXS0_BLENDOP_RGB_SHIFT = 0x8, + GFXS0_BLENDOP_RGB_MASK = 0x700, + GFXS0_BLEND_RGB_MASK = 0x7FF, + + GFXS0_ATEST_DISABLE = 0x800, + GFXS0_ATEST_GT_0 = 0x1000, + GFXS0_ATEST_LT_128 = 0x2000, + GFXS0_ATEST_GE_128 = 0x3000, + GFXS0_ATEST_MASK = 0x3000, + + GFXS0_CULL_NONE = 0x4000, + GFXS0_CULL_BACK = 0x8000, + GFXS0_CULL_FRONT = 0xC000, + GFXS0_CULL_SHIFT = 0xE, + GFXS0_CULL_MASK = 0xC000, + + GFXS0_SRCBLEND_ALPHA_SHIFT = 0x10, + GFXS0_SRCBLEND_ALPHA_MASK = 0xF0000, + + GFXS0_DSTBLEND_ALPHA_SHIFT = 0x14, + GFXS0_DSTBLEND_ALPHA_MASK = 0xF00000, + + GFXS0_BLENDOP_ALPHA_SHIFT = 0x18, + GFXS0_BLENDOP_ALPHA_MASK = 0x7000000, + GFXS0_BLEND_ALPHA_MASK = 0x7FF0000, + + GFXS0_COLORWRITE_RGB = 0x8000000, + GFXS0_COLORWRITE_ALPHA = 0x10000000, + GFXS0_COLORWRITE_MASK = 0x18000000, + + GFXS0_POLYMODE_LINE = 0x80000000, + + GFXS1_DEPTHWRITE = 0x1, + + GFXS1_DEPTHTEST_DISABLE = 0x2, + GFXS1_DEPTHTEST_ALWAYS = 0x0, + GFXS1_DEPTHTEST_LESS = 0x4, + GFXS1_DEPTHTEST_EQUAL = 0x8, + GFXS1_DEPTHTEST_LESSEQUAL = 0xC, + GFXS1_DEPTHTEST_SHIFT = 0x2, + GFXS1_DEPTHTEST_MASK = 0xC, + + GFXS1_POLYGON_OFFSET_0 = 0x0, + GFXS1_POLYGON_OFFSET_1 = 0x10, + GFXS1_POLYGON_OFFSET_2 = 0x20, + GFXS1_POLYGON_OFFSET_SHADOWMAP = 0x30, + GFXS1_POLYGON_OFFSET_SHIFT = 0x4, + GFXS1_POLYGON_OFFSET_MASK = 0x30, + + GFXS1_STENCIL_FRONT_ENABLE = 0x40, + GFXS1_STENCIL_BACK_ENABLE = 0x80, + GFXS1_STENCIL_MASK = 0xC0, + + GFXS1_STENCIL_FRONT_PASS_SHIFT = 0x8, + GFXS1_STENCIL_FRONT_FAIL_SHIFT = 0xB, + GFXS1_STENCIL_FRONT_ZFAIL_SHIFT = 0xE, + GFXS1_STENCIL_FRONT_FUNC_SHIFT = 0x11, + GFXS1_STENCIL_FRONT_MASK = 0xFFF00, + + GFXS1_STENCIL_BACK_PASS_SHIFT = 0x14, + GFXS1_STENCIL_BACK_FAIL_SHIFT = 0x17, + GFXS1_STENCIL_BACK_ZFAIL_SHIFT = 0x1A, + GFXS1_STENCIL_BACK_FUNC_SHIFT = 0x1D, + GFXS1_STENCIL_BACK_MASK = 0xFFF00000, + + GFXS1_STENCILFUNC_FRONTBACK_MASK = 0xE00E0000, + GFXS1_STENCILOP_FRONTBACK_MASK = 0x1FF1FF00, + }; + + struct GfxStateBitsLoadBitsStructured + { + // Byte 0 + unsigned int srcBlendRgb : 4; // 0-3 + unsigned int dstBlendRgb : 4; // 4-7 + unsigned int blendOpRgb : 3; // 8-10 + unsigned int alphaTestDisabled : 1; // 11 + unsigned int alphaTest : 2; // 12-13 + unsigned int cullFace : 2; // 14-15 + unsigned int srcBlendAlpha : 4; // 16-19 + unsigned int dstBlendAlpha : 4; // 20-23 + unsigned int blendOpAlpha : 3; // 24-26 + unsigned int colorWriteRgb : 1; // 27 + unsigned int colorWriteAlpha : 1; // 28 + unsigned int unused1 : 2; // 29-30 + unsigned int polymodeLine : 1; // 31 + + // Byte 1 + unsigned int depthWrite : 1; // 0 + unsigned int depthTestDisabled : 1; // 1 + unsigned int depthTest : 2; // 2-3 + unsigned int polygonOffset : 2; // 4-5 + unsigned int stencilFrontEnabled : 1; // 6 + unsigned int stencilBackEnabled : 1; // 7 + unsigned int stencilFrontPass : 3; // 8-10 + unsigned int stencilFrontFail : 3; // 11-13 + unsigned int stencilFrontZFail : 3; // 14-16 + unsigned int stencilFrontFunc : 3; // 17-19 + unsigned int stencilBackPass : 3; // 20-22 + unsigned int stencilBackFail : 3; // 23-25 + unsigned int stencilBackZFail : 3; // 26-28 + unsigned int stencilBackFunc : 3; // 29-31 + }; + + union GfxStateBitsLoadBits + { + unsigned int raw[2]; + GfxStateBitsLoadBitsStructured structured; + }; + +#ifndef __zonecodegenerator + static_assert(sizeof(GfxStateBitsLoadBits) == 8); + static_assert(sizeof(GfxStateBitsLoadBitsStructured) == 8); +#endif + + struct GfxStateBits + { + GfxStateBitsLoadBits loadBits; + }; + + struct type_align(16) MaterialConstantDef + { + unsigned int nameHash; + char name[12]; + vec4_t literal; + }; + + struct complex_s + { + float real; + float imag; + }; + + struct WaterWritable + { + float floatTime; + }; + + struct water_t + { + WaterWritable writable; + complex_s* H0; + float* wTerm; + int M; + int N; + float Lx; + float Lz; + float gravity; + float windvel; + float winddir[2]; + float amplitude; + float codeConstant[4]; + GfxImage* image; + }; + + union MaterialTextureDefInfo + { + GfxImage* image; + water_t* water; + }; + + enum TextureFilter + { + TEXTURE_FILTER_DISABLED = 0x0, + TEXTURE_FILTER_NEAREST = 0x1, + TEXTURE_FILTER_LINEAR = 0x2, + TEXTURE_FILTER_ANISO2X = 0x3, + TEXTURE_FILTER_ANISO4X = 0x4, + + TEXTURE_FILTER_COUNT + }; + + enum SamplerStateBitsMipMap_e + { + SAMPLER_MIPMAP_ENUM_DISABLED, + SAMPLER_MIPMAP_ENUM_NEAREST, + SAMPLER_MIPMAP_ENUM_LINEAR, + + SAMPLER_MIPMAP_ENUM_COUNT + }; + + enum SamplerStateBits_e + { + SAMPLER_FILTER_SHIFT = 0x0, + SAMPLER_FILTER_NEAREST = 0x1, + SAMPLER_FILTER_LINEAR = 0x2, + SAMPLER_FILTER_ANISO2X = 0x3, + SAMPLER_FILTER_ANISO4X = 0x4, + SAMPLER_FILTER_MASK = 0x7, + + SAMPLER_MIPMAP_SHIFT = 0x3, + SAMPLER_MIPMAP_DISABLED = 0x0, + SAMPLER_MIPMAP_NEAREST = 0x8, + SAMPLER_MIPMAP_LINEAR = 0x10, + SAMPLER_MIPMAP_COUNT = 0x3, + SAMPLER_MIPMAP_MASK = 0x18, + + SAMPLER_CLAMP_U_SHIFT = 0x5, + SAMPLER_CLAMP_V_SHIFT = 0x6, + SAMPLER_CLAMP_W_SHIFT = 0x7, + SAMPLER_CLAMP_U = 0x20, + SAMPLER_CLAMP_V = 0x40, + SAMPLER_CLAMP_W = 0x80, + SAMPLER_CLAMP_MASK = 0xE0, + }; + + struct MaterialTextureDefSamplerState + { + unsigned char filter : 3; + unsigned char mipMap : 2; + unsigned char clampU : 1; + unsigned char clampV : 1; + unsigned char clampW : 1; + }; + +#ifndef __zonecodegenerator + static_assert(sizeof(MaterialTextureDefSamplerState) == 1u); +#endif + + struct MaterialTextureDef + { + unsigned int nameHash; + char nameStart; + char nameEnd; + MaterialTextureDefSamplerState samplerState; // SamplerStateBits_e + unsigned char semantic; // TextureSemantic + char isMatureContent; + MaterialTextureDefInfo u; + }; + + struct gcc_align32(8) GfxDrawSurfFields + { + uint64_t objectId : 16; + uint64_t reflectionProbeIndex : 8; + uint64_t customIndex : 5; + uint64_t materialSortedIndex : 11; + uint64_t prepass : 2; + uint64_t primaryLightIndex : 8; + uint64_t surfType : 4; + uint64_t primarySortKey : 6; + uint64_t unused : 4; + }; + + union GfxDrawSurf + { + gcc_align32(8) GfxDrawSurfFields fields; + gcc_align32(8) uint64_t packed; + }; + + enum materialSurfType_t + { + SURF_TYPE_DEFAULT, + SURF_TYPE_BARK, + SURF_TYPE_BRICK, + SURF_TYPE_CARPET, + SURF_TYPE_CLOTH, + SURF_TYPE_CONCRETE, + SURF_TYPE_DIRT, + SURF_TYPE_FLESH, + SURF_TYPE_FOLIAGE, + SURF_TYPE_GLASS, + SURF_TYPE_GRASS, + SURF_TYPE_GRAVEL, + SURF_TYPE_ICE, + SURF_TYPE_METAL, + SURF_TYPE_MUD, + SURF_TYPE_PAPER, + SURF_TYPE_PLASTER, + SURF_TYPE_ROCK, + SURF_TYPE_SAND, + SURF_TYPE_SNOW, + SURF_TYPE_WATER, + SURF_TYPE_WOOD, + SURF_TYPE_ASPHALT, + SURF_TYPE_CERAMIC, + SURF_TYPE_PLASTIC, + SURF_TYPE_RUBBER, + SURF_TYPE_CUSHION, + SURF_TYPE_FRUIT, + SURF_TYPE_PAINTED_METAL, + + SURF_TYPE_NUM + }; + + // Unknown if this is the right amount of flags + enum MaterialGameFlags + { + MTL_GAMEFLAG_1 = 0x1, + MTL_GAMEFLAG_2 = 0x2, + MTL_GAMEFLAG_4 = 0x4, + MTL_GAMEFLAG_8 = 0x8, + MTL_GAMEFLAG_10 = 0x10, + MTL_GAMEFLAG_20 = 0x20, + MTL_GAMEFLAG_CASTS_SHADOW = 0x40, + MTL_GAMEFLAG_80 = 0x80, + MTL_GAMEFLAG_100 = 0x100, + MTL_GAMEFLAG_200 = 0x200, + MTL_GAMEFLAG_400 = 0x400, + MTL_GAMEFLAG_800 = 0x800, + MTL_GAMEFLAG_1000 = 0x1000, + }; + + struct MaterialInfo + { + const char* name; + unsigned char gameFlags; + unsigned char sortKey; + unsigned char textureAtlasRowCount; + unsigned char textureAtlasColumnCount; + GfxDrawSurf drawSurf; + unsigned int surfaceTypeBits; + uint16_t hashIndex; + }; + + enum GfxCameraRegionType + { + CAMERA_REGION_LIT = 0x0, + CAMERA_REGION_DECAL = 0x1, + CAMERA_REGION_EMISSIVE = 0x2, + + CAMERA_REGION_COUNT, + CAMERA_REGION_NONE = CAMERA_REGION_COUNT, + }; + + enum MaterialStateFlags + { + STATE_FLAG_CULL_BACK = 0x1, + STATE_FLAG_CULL_FRONT = 0x2, + STATE_FLAG_DECAL = 0x4, + STATE_FLAG_WRITES_DEPTH = 0x8, + STATE_FLAG_USES_DEPTH_BUFFER = 0x10, + STATE_FLAG_USES_STENCIL_BUFFER = 0x20, + STATE_FLAG_CULL_BACK_SHADOW = 0x40, + STATE_FLAG_CULL_FRONT_SHADOW = 0x80, + }; + + struct Material + { + MaterialInfo info; + char stateBitsEntry[67]; + unsigned char textureCount; + unsigned char constantCount; + unsigned char stateBitsCount; + unsigned char stateFlags; + unsigned char cameraRegion; + MaterialTechniqueSet* techniqueSet; + MaterialTextureDef* textureTable; + MaterialConstantDef* constantTable; + GfxStateBits* stateBitsTable; + }; + + struct MaterialArgumentCodeConst + { + uint16_t index; + unsigned char firstRow; + unsigned char rowCount; + }; + + union MaterialArgumentDef + { + const float (*literalConst)[4]; + MaterialArgumentCodeConst codeConst; + unsigned int codeSampler; + unsigned int nameHash; + }; + + enum MaterialShaderArgumentType + { + MTL_ARG_MATERIAL_VERTEX_CONST = 0x0, + MTL_ARG_LITERAL_VERTEX_CONST = 0x1, + MTL_ARG_MATERIAL_PIXEL_SAMPLER = 0x2, + + MTL_ARG_CODE_PRIM_BEGIN = 0x3, + + MTL_ARG_CODE_VERTEX_CONST = 0x3, + MTL_ARG_CODE_PIXEL_SAMPLER = 0x4, + MTL_ARG_CODE_PIXEL_CONST = 0x5, + + MTL_ARG_CODE_PRIM_END = 0x6, + + MTL_ARG_MATERIAL_PIXEL_CONST = 0x6, + MTL_ARG_LITERAL_PIXEL_CONST = 0x7, + + MTL_ARG_COUNT + }; + + enum MaterialType + { + MTL_TYPE_DEFAULT = 0x0, + MTL_TYPE_MODEL = 0x1, // m_ + MTL_TYPE_MODEL_VERTCOL = 0x2, // mc_ + MTL_TYPE_WORLD = 0x3, // w_ + MTL_TYPE_WORLD_VERTCOL = 0x4, // wc_ + + MTL_TYPE_COUNT, + }; + + struct MaterialTypeInfo + { + const char* materialPrefix; + const char* techniqueSetPrefix; + }; + + enum ShaderCodeConstants + { + CONST_SRC_CODE_MAYBE_DIRTY_PS_BEGIN = 0x0, + + CONST_SRC_CODE_LIGHT_POSITION = 0x0, + CONST_SRC_CODE_LIGHT_DIFFUSE = 0x1, + CONST_SRC_CODE_LIGHT_SPECULAR = 0x2, + CONST_SRC_CODE_LIGHT_SPOTDIR = 0x3, + CONST_SRC_CODE_LIGHT_SPOTFACTORS = 0x4, + CONST_SRC_CODE_NEARPLANE_ORG = 0x5, + CONST_SRC_CODE_NEARPLANE_DX = 0x6, + CONST_SRC_CODE_NEARPLANE_DY = 0x7, + CONST_SRC_CODE_SHADOW_PARMS = 0x8, + CONST_SRC_CODE_SHADOWMAP_POLYGON_OFFSET = 0x9, + CONST_SRC_CODE_RENDER_TARGET_SIZE = 0xA, + CONST_SRC_CODE_LIGHT_FALLOFF_PLACEMENT = 0xB, + CONST_SRC_CODE_DOF_EQUATION_VIEWMODEL_AND_FAR_BLUR = 0xC, + CONST_SRC_CODE_DOF_EQUATION_SCENE = 0xD, + CONST_SRC_CODE_DOF_LERP_SCALE = 0xE, + CONST_SRC_CODE_DOF_LERP_BIAS = 0xF, + CONST_SRC_CODE_DOF_ROW_DELTA = 0x10, + CONST_SRC_CODE_PARTICLE_CLOUD_COLOR = 0x11, + CONST_SRC_CODE_GAMETIME = 0x12, + + CONST_SRC_CODE_MAYBE_DIRTY_PS_END = 0x13, + CONST_SRC_CODE_ALWAYS_DIRTY_PS_BEGIN = 0x13, + + CONST_SRC_CODE_PIXEL_COST_FRACS = 0x13, + CONST_SRC_CODE_PIXEL_COST_DECODE = 0x14, + CONST_SRC_CODE_FILTER_TAP_0 = 0x15, + CONST_SRC_CODE_FILTER_TAP_1 = 0x16, + CONST_SRC_CODE_FILTER_TAP_2 = 0x17, + CONST_SRC_CODE_FILTER_TAP_3 = 0x18, + CONST_SRC_CODE_FILTER_TAP_4 = 0x19, + CONST_SRC_CODE_FILTER_TAP_5 = 0x1A, + CONST_SRC_CODE_FILTER_TAP_6 = 0x1B, + CONST_SRC_CODE_FILTER_TAP_7 = 0x1C, + CONST_SRC_CODE_COLOR_MATRIX_R = 0x1D, + CONST_SRC_CODE_COLOR_MATRIX_G = 0x1E, + CONST_SRC_CODE_COLOR_MATRIX_B = 0x1F, + + CONST_SRC_CODE_ALWAYS_DIRTY_PS_END = 0x20, + CONST_SRC_CODE_NEVER_DIRTY_PS_BEGIN = 0x20, + + CONST_SRC_CODE_SHADOWMAP_SWITCH_PARTITION = 0x20, + CONST_SRC_CODE_SHADOWMAP_SCALE = 0x21, + CONST_SRC_CODE_ZNEAR = 0x22, + CONST_SRC_CODE_SUN_POSITION = 0x23, + CONST_SRC_CODE_SUN_DIFFUSE = 0x24, + CONST_SRC_CODE_SUN_SPECULAR = 0x25, + CONST_SRC_CODE_LIGHTING_LOOKUP_SCALE = 0x26, + CONST_SRC_CODE_DEBUG_BUMPMAP = 0x27, + CONST_SRC_CODE_MATERIAL_COLOR = 0x28, + CONST_SRC_CODE_FOG = 0x29, + CONST_SRC_CODE_FOG_COLOR = 0x2A, + CONST_SRC_CODE_GLOW_SETUP = 0x2B, + CONST_SRC_CODE_GLOW_APPLY = 0x2C, + CONST_SRC_CODE_COLOR_BIAS = 0x2D, + CONST_SRC_CODE_COLOR_TINT_BASE = 0x2E, + CONST_SRC_CODE_COLOR_TINT_DELTA = 0x2F, + CONST_SRC_CODE_OUTDOOR_FEATHER_PARMS = 0x30, + CONST_SRC_CODE_ENVMAP_PARMS = 0x31, + CONST_SRC_CODE_SPOT_SHADOWMAP_PIXEL_ADJUST = 0x32, + CONST_SRC_CODE_CLIP_SPACE_LOOKUP_SCALE = 0x33, + CONST_SRC_CODE_CLIP_SPACE_LOOKUP_OFFSET = 0x34, + CONST_SRC_CODE_PARTICLE_CLOUD_MATRIX = 0x35, + CONST_SRC_CODE_DEPTH_FROM_CLIP = 0x36, + CONST_SRC_CODE_CODE_MESH_ARG_0 = 0x37, + CONST_SRC_CODE_CODE_MESH_ARG_1 = 0x38, + + CONST_SRC_CODE_CODE_MESH_ARG_LAST = 0x38, + + CONST_SRC_CODE_BASE_LIGHTING_COORDS = 0x39, + + CONST_SRC_CODE_NEVER_DIRTY_PS_END = 0x3A, + CONST_SRC_CODE_COUNT_FLOAT4 = 0x3A, + CONST_SRC_FIRST_CODE_MATRIX = 0x3A, + + CONST_SRC_CODE_WORLD_MATRIX = 0x3A, + CONST_SRC_CODE_INVERSE_WORLD_MATRIX = 0x3B, + CONST_SRC_CODE_TRANSPOSE_WORLD_MATRIX = 0x3C, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_MATRIX = 0x3D, + CONST_SRC_CODE_VIEW_MATRIX = 0x3E, + CONST_SRC_CODE_INVERSE_VIEW_MATRIX = 0x3F, + CONST_SRC_CODE_TRANSPOSE_VIEW_MATRIX = 0x40, + CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_MATRIX = 0x41, + CONST_SRC_CODE_PROJECTION_MATRIX = 0x42, + CONST_SRC_CODE_INVERSE_PROJECTION_MATRIX = 0x43, + CONST_SRC_CODE_TRANSPOSE_PROJECTION_MATRIX = 0x44, + CONST_SRC_CODE_INVERSE_TRANSPOSE_PROJECTION_MATRIX = 0x45, + CONST_SRC_CODE_WORLD_VIEW_MATRIX = 0x46, + CONST_SRC_CODE_INVERSE_WORLD_VIEW_MATRIX = 0x47, + CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_MATRIX = 0x48, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX = 0x49, + CONST_SRC_CODE_VIEW_PROJECTION_MATRIX = 0x4A, + CONST_SRC_CODE_INVERSE_VIEW_PROJECTION_MATRIX = 0x4B, + CONST_SRC_CODE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0x4C, + CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0x4D, + CONST_SRC_CODE_WORLD_VIEW_PROJECTION_MATRIX = 0x4E, + CONST_SRC_CODE_INVERSE_WORLD_VIEW_PROJECTION_MATRIX = 0x4F, + CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX = 0x50, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX = 0x51, + CONST_SRC_CODE_SHADOW_LOOKUP_MATRIX = 0x52, + CONST_SRC_CODE_INVERSE_SHADOW_LOOKUP_MATRIX = 0x53, + CONST_SRC_CODE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0x54, + CONST_SRC_CODE_INVERSE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0x55, + CONST_SRC_CODE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x56, + CONST_SRC_CODE_INVERSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x57, + CONST_SRC_CODE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x58, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x59, + + CONST_SRC_TOTAL_COUNT, + CONST_SRC_NONE + }; + + enum MaterialTextureSource + { + TEXTURE_SRC_CODE_BLACK = 0x0, + TEXTURE_SRC_CODE_WHITE = 0x1, + TEXTURE_SRC_CODE_IDENTITY_NORMAL_MAP = 0x2, + TEXTURE_SRC_CODE_MODEL_LIGHTING = 0x3, + TEXTURE_SRC_CODE_LIGHTMAP_PRIMARY = 0x4, + TEXTURE_SRC_CODE_LIGHTMAP_SECONDARY = 0x5, + TEXTURE_SRC_CODE_SHADOWCOOKIE = 0x6, + TEXTURE_SRC_CODE_SHADOWMAP_SUN = 0x7, + TEXTURE_SRC_CODE_SHADOWMAP_SPOT = 0x8, + TEXTURE_SRC_CODE_FEEDBACK = 0x9, + TEXTURE_SRC_CODE_RESOLVED_POST_SUN = 0xA, + TEXTURE_SRC_CODE_RESOLVED_SCENE = 0xB, + TEXTURE_SRC_CODE_POST_EFFECT_0 = 0xC, + TEXTURE_SRC_CODE_POST_EFFECT_1 = 0xD, + TEXTURE_SRC_CODE_SKY = 0xE, + TEXTURE_SRC_CODE_LIGHT_ATTENUATION = 0xF, + TEXTURE_SRC_CODE_DYNAMIC_SHADOWS = 0x10, + TEXTURE_SRC_CODE_OUTDOOR = 0x11, + TEXTURE_SRC_CODE_FLOATZ = 0x12, + TEXTURE_SRC_CODE_PROCESSED_FLOATZ = 0x13, + TEXTURE_SRC_CODE_RAW_FLOATZ = 0x14, + TEXTURE_SRC_CODE_CASE_TEXTURE = 0x15, + TEXTURE_SRC_CODE_CINEMATIC_Y = 0x16, + TEXTURE_SRC_CODE_CINEMATIC_CR = 0x17, + TEXTURE_SRC_CODE_CINEMATIC_CB = 0x18, + TEXTURE_SRC_CODE_CINEMATIC_A = 0x19, + TEXTURE_SRC_CODE_REFLECTION_PROBE = 0x1A, + + TEXTURE_SRC_CODE_COUNT + }; + + enum CustomSamplers + { + CUSTOM_SAMPLER_REFLECTION_PROBE = 0x0, + CUSTOM_SAMPLER_LIGHTMAP_PRIMARY = 0x1, + CUSTOM_SAMPLER_LIGHTMAP_SECONDARY = 0x2, + + CUSTOM_SAMPLER_COUNT + }; + + enum MaterialUpdateFrequency + { + MTL_UPDATE_PER_PRIM = 0x0, + MTL_UPDATE_PER_OBJECT = 0x1, + MTL_UPDATE_RARELY = 0x2, + MTL_UPDATE_CUSTOM = 0x3, + }; + + struct MaterialShaderArgument + { + uint16_t type; + uint16_t dest; + MaterialArgumentDef u; + }; + + enum MaterialStreamStreamSource_e + { + STREAM_SRC_POSITION = 0x0, + STREAM_SRC_COLOR = 0x1, + STREAM_SRC_TEXCOORD_0 = 0x2, + STREAM_SRC_NORMAL = 0x3, + + STREAM_SRC_PRE_OPTIONAL_BEGIN = 0x4, + + STREAM_SRC_TANGENT = 0x4, + + STREAM_SRC_OPTIONAL_BEGIN = 0x5, + + STREAM_SRC_TEXCOORD_1 = 0x5, + STREAM_SRC_TEXCOORD_2 = 0x6, + STREAM_SRC_NORMAL_TRANSFORM_0 = 0x7, + STREAM_SRC_NORMAL_TRANSFORM_1 = 0x8, + + STREAM_SRC_COUNT + }; + + enum MaterialStreamDestination_e + { + STREAM_DST_POSITION = 0x0, + STREAM_DST_NORMAL = 0x1, + STREAM_DST_COLOR_0 = 0x2, + STREAM_DST_COLOR_1 = 0x3, + STREAM_DST_TEXCOORD_0 = 0x4, + STREAM_DST_TEXCOORD_1 = 0x5, + STREAM_DST_TEXCOORD_2 = 0x6, + STREAM_DST_TEXCOORD_3 = 0x7, + STREAM_DST_TEXCOORD_4 = 0x8, + STREAM_DST_TEXCOORD_5 = 0x9, + STREAM_DST_TEXCOORD_6 = 0xA, + STREAM_DST_TEXCOORD_7 = 0xB, + STREAM_DST_COUNT + }; + + struct MaterialStreamRouting + { + unsigned char source; + unsigned char dest; + }; + + struct MaterialVertexStreamRouting + { + MaterialStreamRouting data[16]; + void /*IDirect3DVertexDeclaration9*/* decl[17]; + }; + + struct MaterialVertexDeclaration + { + unsigned char streamCount; + bool hasOptionalSource; + bool isLoaded; + MaterialVertexStreamRouting routing; + }; + + struct GfxVertexShaderLoadDef + { + unsigned int* program; + uint16_t programSize; + uint16_t loadForRenderer; + }; + + struct MaterialVertexShaderProgram + { + void /*IDirect3DVertexShader9*/* vs; + GfxVertexShaderLoadDef loadDef; + }; + + struct MaterialVertexShader + { + const char* name; + MaterialVertexShaderProgram prog; + }; + + struct GfxPixelShaderLoadDef + { + unsigned int* program; + uint16_t programSize; + uint16_t loadForRenderer; + }; + + struct MaterialPixelShaderProgram + { + void /*IDirect3DPixelShader9*/* ps; + GfxPixelShaderLoadDef loadDef; + }; + + struct MaterialPixelShader + { + const char* name; + MaterialPixelShaderProgram prog; + }; + + struct MaterialPass + { + MaterialVertexDeclaration* vertexDecl; + MaterialVertexShader* vertexShader; + MaterialPixelShader* pixelShader; + unsigned char perPrimArgCount; + unsigned char perObjArgCount; + unsigned char stableArgCount; + unsigned char customSamplerFlags; + MaterialShaderArgument* args; + }; + + enum TechniqueFlags + { + MTL_TECHFLAG_NEEDS_RESOLVED_POST_SUN = 0x1, + MTL_TECHFLAG_NEEDS_RESOLVED_SCENE = 0x2, + MTL_TECHFLAG_ZPREPASS = 0x4, + + MTL_TECHFLAG_DECL_HAS_OPTIONAL_SOURCE = 0x8, + + MTL_TECHFLAG_USES_LIGHT_SPOT_FACTORS = 0x10, + MTL_TECHFLAG_USES_FLOATZ = 0x20, + }; + + struct MaterialTechnique + { + const char* name; + uint16_t flags; + uint16_t passCount; + MaterialPass passArray[1]; + }; + + enum MaterialTechniqueType + { + TECHNIQUE_DEPTH_PREPASS = 0x0, + TECHNIQUE_BUILD_FLOAT_Z = 0x1, + TECHNIQUE_BUILD_SHADOWMAP_DEPTH = 0x2, + TECHNIQUE_BUILD_SHADOWMAP_COLOR = 0x3, + TECHNIQUE_UNLIT = 0x4, + TECHNIQUE_EMISSIVE = 0x5, + TECHNIQUE_EMISSIVE_SHADOW = 0x6, + TECHNIQUE_EMISSIVE_REFLECTED = 0x7, + + TECHNIQUE_LIT_BEGIN = 0x8, + + TECHNIQUE_LIT = 0x8, + TECHNIQUE_LIT_FADE = 0x9, + TECHNIQUE_LIT_SUN = 0xA, + TECHNIQUE_LIT_SUN_FADE = 0xB, + TECHNIQUE_LIT_SUN_SHADOW = 0xC, + TECHNIQUE_LIT_SUN_SHADOW_FADE = 0xD, + TECHNIQUE_LIT_SPOT = 0xE, + TECHNIQUE_LIT_SPOT_FADE = 0xF, + TECHNIQUE_LIT_SPOT_SHADOW = 0x10, + TECHNIQUE_LIT_SPOT_SHADOW_FADE = 0x11, + TECHNIQUE_LIT_OMNI = 0x12, + TECHNIQUE_LIT_OMNI_FADE = 0x13, + TECHNIQUE_LIT_OMNI_SHADOW = 0x14, + TECHNIQUE_LIT_OMNI_SHADOW_FADE = 0x15, + TECHNIQUE_LIT_CHARRED = 0x16, + TECHNIQUE_LIT_FADE_CHARRED = 0x17, + TECHNIQUE_LIT_SUN_CHARRED = 0x18, + TECHNIQUE_LIT_SUN_FADE_CHARRED = 0x19, + TECHNIQUE_LIT_SUN_SHADOW_CHARRED = 0x1A, + TECHNIQUE_LIT_SUN_SHADOW_FADE_CHARRED = 0x1B, + TECHNIQUE_LIT_SPOT_CHARRED = 0x1C, + TECHNIQUE_LIT_SPOT_FADE_CHARRED = 0x1D, + TECHNIQUE_LIT_SPOT_SHADOW_CHARRED = 0x1E, + TECHNIQUE_LIT_SPOT_SHADOW_FADE_CHARRED = 0x1F, + TECHNIQUE_LIT_OMNI_CHARRED = 0x20, + TECHNIQUE_LIT_OMNI_FADE_CHARRED = 0x21, + TECHNIQUE_LIT_OMNI_SHADOW_CHARRED = 0x22, + TECHNIQUE_LIT_OMNI_SHADOW_FADE_CHARRED = 0x23, + + TECHNIQUE_LIT_END = 0x24, + + TECHNIQUE_LIGHT_SPOT = 0x24, + TECHNIQUE_LIGHT_OMNI = 0x25, + TECHNIQUE_LIGHT_SPOT_SHADOW = 0x26, + TECHNIQUE_LIGHT_SPOT_CHARRED = 0x27, + TECHNIQUE_LIGHT_OMNI_CHARRED = 0x28, + TECHNIQUE_LIGHT_SPOT_SHADOW_CHARRED = 0x29, + TECHNIQUE_FAKELIGHT_NORMAL = 0x2A, + TECHNIQUE_FAKELIGHT_VIEW = 0x2B, + TECHNIQUE_SUNLIGHT_PREVIEW = 0x2C, + TECHNIQUE_CASE_TEXTURE = 0x2D, + TECHNIQUE_WIREFRAME_SOLID = 0x2E, + TECHNIQUE_WIREFRAME_SHADED = 0x2F, + TECHNIQUE_SHADOWCOOKIE_CASTER = 0x30, + TECHNIQUE_SHADOWCOOKIE_RECEIVER = 0x31, + TECHNIQUE_DEBUG_BUMPMAP = 0x32, + TECHNIQUE_COUNT = 0x33, + TECHNIQUE_TOTAL_COUNT = 0x34, + TECHNIQUE_NONE = 0x35, + }; + + enum MaterialWorldVertexFormat : unsigned char + { + MTL_WORLDVERT_TEX_1_NRM_1 = 0x0, + MTL_WORLDVERT_TEX_2_NRM_1 = 0x1, + MTL_WORLDVERT_TEX_2_NRM_2 = 0x2, + MTL_WORLDVERT_TEX_3_NRM_1 = 0x3, + MTL_WORLDVERT_TEX_3_NRM_2 = 0x4, + MTL_WORLDVERT_TEX_3_NRM_3 = 0x5, + MTL_WORLDVERT_TEX_4_NRM_1 = 0x6, + MTL_WORLDVERT_TEX_4_NRM_2 = 0x7, + MTL_WORLDVERT_TEX_4_NRM_3 = 0x8, + MTL_WORLDVERT_TEX_5_NRM_1 = 0x9, + MTL_WORLDVERT_TEX_5_NRM_2 = 0xA, + MTL_WORLDVERT_TEX_5_NRM_3 = 0xB, + }; + + struct MaterialTechniqueSet + { + const char* name; + MaterialWorldVertexFormat worldVertFormat; + bool hasBeenUploaded; + char unused[1]; + MaterialTechniqueSet* remappedTechniqueSet; + MaterialTechnique* techniques[59]; + }; + + struct CardMemory + { + int platform[2]; + }; + + struct Picmip + { + char platform[2]; + }; + + struct GfxImageLoadDef + { + char levelCount; + char flags; + uint16_t dimensions[3]; + int format; + unsigned int resourceSize; + char data[1]; + }; + + union GfxTexture + { + // void/*IDirect3DBaseTexture9*/* basemap; + // void/*IDirect3DTexture9*/* map; + // void/*IDirect3DVolumeTexture9*/* volmap; + // void/*IDirect3DCubeTexture9*/* cubemap; + GfxImageLoadDef* loadDef; + }; + + enum MapType + { + MAPTYPE_NONE = 0x0, + MAPTYPE_INVALID1 = 0x1, + MAPTYPE_INVALID2 = 0x2, + MAPTYPE_2D = 0x3, + MAPTYPE_3D = 0x4, + MAPTYPE_CUBE = 0x5, + + MAPTYPE_COUNT + }; + + enum TextureSemantic + { + TS_2D = 0x0, + TS_FUNCTION = 0x1, + TS_COLOR_MAP = 0x2, + TS_UNUSED_1 = 0x3, + TS_UNUSED_2 = 0x4, + TS_NORMAL_MAP = 0x5, + TS_UNUSED_3 = 0x6, + TS_UNUSED_4 = 0x7, + TS_SPECULAR_MAP = 0x8, + TS_UNUSED_5 = 0x9, + TS_UNUSED_6 = 0xA, + TS_WATER_MAP = 0xB, + }; + + enum ImageCategory + { + IMG_CATEGORY_UNKNOWN = 0x0, + IMG_CATEGORY_AUTO_GENERATED = 0x1, + IMG_CATEGORY_LIGHTMAP = 0x2, + IMG_CATEGORY_LOAD_FROM_FILE = 0x3, + IMG_CATEGORY_RAW = 0x4, + IMG_CATEGORY_FIRST_UNMANAGED = 0x5, + IMG_CATEGORY_WATER = 0x5, + IMG_CATEGORY_RENDERTARGET = 0x6, + IMG_CATEGORY_TEMP = 0x7, + }; + + struct GfxImage + { + MapType mapType; + GfxTexture texture; + Picmip picmip; + bool noPicmip; + char semantic; + char track; + CardMemory cardMemory; + uint16_t width; + uint16_t height; + uint16_t depth; + char category; + bool delayLoadPixels; + const char* name; + }; + + struct MSSSpeakerLevels + { + int speaker; + int numLevels; + float levels[2]; + }; + + struct MSSChannelMap + { + int speakerCount; + MSSSpeakerLevels speakers[6]; + }; + + struct SpeakerMap + { + bool isDefault; + const char* name; + MSSChannelMap channelMaps[2][2]; + }; + + enum snd_limit_type_t + { + SND_LIMIT_NONE = 0x0, + SND_LIMIT_OLDEST = 0x1, + SND_LIMIT_REJECT = 0x2, + SND_LIMIT_PRIORITY = 0x3, + SND_LIMIT_SOFTEST = 0x4, + SND_LIMIT_COUNT = 0x5, + }; + + enum snd_randomize_type_t + { + SND_RANDOMIZE_INSTANCE = 0x0, + SND_RANDOMIZE_ENTITY_VOLUME = 0x1, + SND_RANDOMIZE_ENTITY_PITCH = 0x2, + SND_RANDOMIZE_ENTITY_VARIANT = 0x4, + }; + + enum snd_category_t + { + SND_CATEGORY_SFX = 0x0, + SND_CATEGORY_MUSIC = 0x1, + SND_CATEGORY_VOICE = 0x2, + }; + + struct snd_asset + { + char* data; + int data_size; + }; + + struct LoadedSound + { + const char* name; + snd_asset sound; + }; + + struct StreamFileName + { + unsigned int hash; + const char* dir; + const char* name; + }; + + struct PrimedSound + { + const char* name; + unsigned char* buffer; + unsigned int size; + }; + + struct StreamedSound + { + StreamFileName filename; + PrimedSound* primeSnd; + }; + + union SoundFileRef + { + LoadedSound* loadSnd; + StreamedSound streamSnd; + }; + + enum snd_alias_type_t + { + SAT_UNKNOWN = 0x0, + SAT_LOADED = 0x1, + SAT_STREAMED = 0x2, + SAT_PRIMED = 0x3, + SAT_COUNT = 0x4, + }; + + struct SoundFile + { + unsigned char type; + unsigned char exists; + SoundFileRef u; + }; + + struct snd_alias_t + { + const char* aliasName; + int aliasNameHash; + const char* subtitle; + const char* secondaryAliasName; + const char* chainAliasName; + SoundFile* soundFile; + unsigned int sequence; + float volMin; + float volMax; + float pitchMin; + float pitchMax; + float distMin; + float distMax; + float distReverbMax; + float slavePercentage; + float probability; + float lfePercentage; + float centerPercentage; + float envelopMin; + float envelopMax; + float envelopPercentage; + float minPriority; + float maxPriority; + float minPriorityThreshold; + float maxPriorityThreshold; + float reverbSend; + int gap2; + int gap3; + float occlusionLevel; + float occlusionWetDry; + unsigned int moveTime; + unsigned int startDelay; + unsigned int speakerMap; + int flags; + unsigned int volumeFalloffCurve; + unsigned int reverbFalloffCurve; + unsigned int volumeMinFalloffCurve; + unsigned int reverbMinFalloffCurve; + snd_limit_type_t limitType; + int gap5; + unsigned int entityLimitCount; + int gap6; + snd_randomize_type_t randomizeType; + int gap7; + int gap8; + int gap9; + }; + + struct snd_alias_list_t + { + const char* aliasName; + snd_alias_t* head; + int count; + }; + + struct cStaticModelWritable + { + uint16_t nextModelInWorldSector; + }; + + struct cStaticModel_s + { + cStaticModelWritable writable; + XModel* xmodel; + float origin[3]; + float invScaledAxis[3][3]; + float absmin[3]; + float absmax[3]; + }; + + struct dmaterial_t + { + char material[64]; + int surfaceFlags; + int contentFlags; + }; + + struct cNode_t + { + cplane_s* plane; + int16_t children[2]; + }; + + struct cLeaf_t + { + uint16_t firstCollAabbIndex; + uint16_t collAabbCount; + int brushContents; + int terrainContents; + float mins[3]; + float maxs[3]; + int leafBrushNode; + int16_t cluster; + }; + + struct cLeafBrushNodeChildren_t + { + float dist; + float range; + uint16_t childOffset[2]; + }; + + struct cLeafBrushNodeLeaf_t + { + uint16_t* brushes; + }; + + union cLeafBrushNodeData_t + { + cLeafBrushNodeLeaf_t leaf; + cLeafBrushNodeChildren_t children; + }; + + struct cLeafBrushNode_s + { + char axis; + int16_t leafBrushCount; + int contents; + cLeafBrushNodeData_t data; + }; + + struct CollisionBorder + { + float distEq[3]; + float zBase; + float zSlope; + float start; + float length; + }; + + struct CollisionPartition + { + unsigned char triCount; + unsigned char borderCount; + int firstTri; + int nuinds; + int fuind; + CollisionBorder* borders; + }; + + union CollisionAabbTreeIndex + { + int firstChildIndex; + int partitionIndex; + }; + + struct CollisionAabbTree + { + float origin[3]; + uint16_t materialIndex; + uint16_t childCount; + float halfSize[3]; + CollisionAabbTreeIndex u; + }; + + struct cmodel_t + { + float mins[3]; + float maxs[3]; + float radius; + cLeaf_t leaf; + }; + + struct type_align32(16) cbrush_t + { + float mins[3]; + int contents; + float maxs[3]; + unsigned int numsides; + cbrushside_t* sides; + int16_t axialMaterialNum[2][3]; + cbrushedge_t* baseAdjacentSide; + int16_t firstAdjacentSideOffsets[2][3]; + char edgeCount[2][3]; + unsigned int numverts; + vec3_t* verts; + }; + + struct GfxPlacement + { + float quat[4]; + float origin[3]; + }; + + enum DynEntityType + { + DYNENT_TYPE_INVALID = 0x0, + DYNENT_TYPE_CLUTTER = 0x1, + DYNENT_TYPE_DESTRUCT = 0x2, + DYNENT_TYPE_COUNT = 0x3, + }; + + struct DynEntityDef + { + DynEntityType type; + GfxPlacement pose; + XModel* xModel; + uint16_t brushModel; + uint16_t physicsBrushModel; + FxEffectDef* destroyFx; + XModelPieces* destroyPieces; + PhysPreset* physPreset; + unsigned char physConstraints[4]; + int health; + PhysMass mass; + int flags; + int contents; + ScriptString targetname; + }; + + struct DynEntityPose + { + GfxPlacement pose; + float radius; + }; + + struct DynEntityClient + { + int physObjId; + uint16_t flags; + uint16_t lightingHandle; + int health; + uint16_t burnTime; + uint16_t fadeTime; + }; + + struct DynEntityServer + { + uint16_t flags; + int health; + }; + + struct DynEntityColl + { + uint16_t sector; + uint16_t nextEntInSector; + float linkMins[3]; + float linkMaxs[3]; + int contents; + }; + + typedef unsigned short LeafBrush; + + typedef tdef_align32(16) cbrush_t cbrush_array_t; + + struct clipMap_t + { + const char* name; + int isInUse; + int planeCount; + cplane_s* planes; + unsigned int numStaticModels; + cStaticModel_s* staticModelList; + unsigned int numMaterials; + dmaterial_t* materials; + unsigned int numBrushSides; + cbrushside_t* brushsides; + unsigned int numBrushEdges; + cbrushedge_t* brushEdges; + unsigned int numNodes; + cNode_t* nodes; + unsigned int numLeafs; + cLeaf_t* leafs; + unsigned int leafbrushNodesCount; + cLeafBrushNode_s* leafbrushNodes; + unsigned int numLeafBrushes; + LeafBrush* leafbrushes; + unsigned int numLeafSurfaces; + unsigned int* leafsurfaces; + unsigned int vertCount; + vec3_t* verts; + unsigned int numBrushVerts; + vec3_t* brushVerts; + unsigned int nuinds; + uint16_t* uinds; + int triCount; + uint16_t* triIndices; + char* triEdgeIsWalkable; + int borderCount; + CollisionBorder* borders; + int partitionCount; + CollisionPartition* partitions; + int aabbTreeCount; + CollisionAabbTree* aabbTrees; + unsigned int numSubModels; + cmodel_t* cmodels; + uint16_t numBrushes; + cbrush_t* brushes; + int numClusters; + int clusterBytes; + char* visibility; + int vised; + MapEnts* mapEnts; + cbrush_t* box_brush; + cmodel_t box_model; + uint16_t originalDynEntCount; + uint16_t dynEntCount[4]; + DynEntityDef* dynEntDefList[2]; + DynEntityPose* dynEntPoseList[2]; + DynEntityClient* dynEntClientList[2]; + DynEntityServer* dynEntServerList[2]; + DynEntityColl* dynEntCollList[4]; + int num_constraints; + PhysConstraint* constraints; + unsigned int checksum; + }; + + struct ComPrimaryLight + { + unsigned char type; + unsigned char canUseShadowMap; + unsigned char exponent; + char priority; + int16_t cullDist; + float color[3]; + float dir[3]; + float origin[3]; + float radius; + float cosHalfFovOuter; + float cosHalfFovInner; + float cosHalfFovExpanded; + float rotationLimit; + float translationLimit; + const char* defName; + }; + + struct ComWaterHeader + { + int minx; + int miny; + int maxx; + int maxy; + }; + + struct ComWaterCell + { + int16_t waterheight; + char flooroffset; + unsigned char shoredist; + unsigned char color[4]; + }; + + struct ComBurnableHeader + { + int minx; + int miny; + int maxx; + int maxy; + }; + + struct ComBurnableSample + { + unsigned char state; + }; + + struct ComBurnableCell + { + int x; + int y; + ComBurnableSample* data; + }; + + struct ComWorld + { + const char* name; + int isInUse; + unsigned int primaryLightCount; + ComPrimaryLight* primaryLights; + ComWaterHeader waterHeader; + unsigned int numWaterCells; + ComWaterCell* waterCells; + ComBurnableHeader burnableHeader; + unsigned int numBurnableCells; + ComBurnableCell* burnableCells; + }; + + struct pathnode_tree_nodes_t + { + int nodeCount; + uint16_t* nodes; + }; + + struct pathnode_t; + struct pathnode_tree_t; + + union pathnode_tree_info_t + { + pathnode_tree_t* child[2]; + pathnode_tree_nodes_t s; + }; + + struct pathnode_tree_t + { + int axis; + float dist; + pathnode_tree_info_t u; + }; + + struct type_align(16) pathbasenode_t + { + float vOrigin[3]; + unsigned int type; + }; + + struct pathnode_transient_t + { + int iSearchFrame; + pathnode_t* pNextOpen; + pathnode_t* pPrevOpen; + pathnode_t* pParent; + float fCost; + float fHeuristic; + float costFactor; + }; + + struct pathnode_dynamic_t + { + void* pOwner; + int iFreeTime; + int iValidTime[3]; + int inPlayerLOSTime; + int16_t wLinkCount; + int16_t wOverlapCount; + int16_t turretEntNumber; + int16_t userCount; + }; + + struct pathlink_s + { + float fDist; + uint16_t nodeNum; + char disconnectCount; + char negotiationLink; + char ubBadPlaceCount[4]; + }; + + enum nodeType + { + NODE_BADNODE = 0x0, + NODE_PATHNODE = 0x1, + NODE_COVER_STAND = 0x2, + NODE_COVER_CROUCH = 0x3, + NODE_COVER_CROUCH_WINDOW = 0x4, + NODE_COVER_PRONE = 0x5, + NODE_COVER_RIGHT = 0x6, + NODE_COVER_LEFT = 0x7, + NODE_COVER_WIDE_RIGHT = 0x8, + NODE_COVER_WIDE_LEFT = 0x9, + NODE_CONCEALMENT_STAND = 0xA, + NODE_CONCEALMENT_CROUCH = 0xB, + NODE_CONCEALMENT_PRONE = 0xC, + NODE_REACQUIRE = 0xD, + NODE_BALCONY = 0xE, + NODE_SCRIPTED = 0xF, + NODE_NEGOTIATION_BEGIN = 0x10, + NODE_NEGOTIATION_END = 0x11, + NODE_TURRET = 0x12, + NODE_GUARD = 0x13, + NODE_NUMTYPES = 0x14, + NODE_DONTLINK = 0x14, + }; + + struct pathnode_constant_t + { + nodeType type; + uint16_t spawnflags; + uint16_t targetname; + uint16_t script_linkName; + uint16_t script_noteworthy; + uint16_t target; + uint16_t animscript; + int animscriptfunc; + float vOrigin[3]; + float fAngle; + float forward[2]; + float fRadius; + float minUseDistSq; + int16_t wOverlapNode[2]; + int16_t wChainId; + int16_t wChainDepth; + int16_t wChainParent; + uint16_t totalLinkCount; + pathlink_s* Links; + }; + + struct pathnode_t + { + pathnode_constant_t constant; + pathnode_dynamic_t dynamic; + pathnode_transient_t transient; + }; + + struct PathData + { + unsigned int nodeCount; + pathnode_t* nodes; + pathbasenode_t* basenodes; + unsigned int chainNodeCount; + uint16_t* chainNodeForNode; + uint16_t* nodeForChainNode; + int visBytes; + char* pathVis; + int nodeTreeCount; + pathnode_tree_t* nodeTree; + }; + + struct GameWorldSp + { + const char* name; + PathData path; + }; + + struct GameWorldMp + { + const char* name; + PathData path; + }; + + struct MapEnts + { + const char* name; + const char* entityString; + int numEntityChars; + }; + + struct GfxWorldVertex + { + float xyz[3]; + float binormalSign; + GfxColor color; + float texCoord[2]; + float lmapCoord[2]; + PackedUnitVec normal; + PackedUnitVec tangent; + }; + + struct GfxWorldVertexData + { + GfxWorldVertex* vertices; + void /*IDirect3DVertexBuffer9*/* worldVb; + }; + + struct GfxWorldVertexLayerData + { + char* data; + void /*IDirect3DVertexBuffer9*/* layerVb; + }; + + struct SunLightParseParams + { + char name[64]; + float ambientScale; + float ambientColor[3]; + float diffuseFraction; + float sunLight; + float sunColor[3]; + float diffuseColor[3]; + bool diffuseColorHasBeenSet; + float angles[3]; + float treeScatterIntensity; + float treeScatterAmount; + }; + + struct GfxLightImage + { + GfxImage* image; + char samplerState; + }; + + struct GfxLightDef + { + const char* name; + GfxLightImage attenuation; + int lmapLookupStart; + }; + + struct GfxLight + { + unsigned char type; + unsigned char canUseShadowMap; + int16_t cullDist; + float color[3]; + float dir[3]; + float origin[3]; + float radius; + float cosHalfFovOuter; + float cosHalfFovInner; + int exponent; + unsigned int spotShadowIndex; + GfxLightDef* def; + }; + + struct GfxReflectionProbe + { + float origin[3]; + GfxImage* reflectionImage; + }; + + struct GfxLightCorona + { + float origin[3]; + float radius; + float color[3]; + float intensity; + }; + + struct GfxWorldDpvsPlanes + { + int cellCount; + cplane_s* planes; + uint16_t* nodes; + unsigned int* sceneEntCellBits; + }; + + struct DpvsPlane + { + float coeffs[4]; + char side[3]; + char pad; + }; + + struct GfxCell; + struct GfxPortal; + + struct GfxPortalWritable + { + bool isQueued; + bool isAncestor; + char recursionDepth; + char hullPointCount; + float (*hullPoints)[2]; + GfxPortal* queuedParent; + }; + + struct GfxPortal + { + GfxPortalWritable writable; + DpvsPlane plane; + GfxCell* cell; + vec3_t* vertices; + char vertexCount; + float hullAxis[2][3]; + }; + + struct GfxAabbTree + { + float mins[3]; + float maxs[3]; + uint16_t childCount; + uint16_t surfaceCount; + uint16_t startSurfIndex; + uint16_t smodelIndexCount; + uint16_t* smodelIndexes; + int childrenOffset; + }; + + struct GfxCell + { + float mins[3]; + float maxs[3]; + int aabbTreeCount; + GfxAabbTree* aabbTree; + int portalCount; + GfxPortal* portals; + int cullGroupCount; + int* cullGroups; + char reflectionProbeCount; + char* reflectionProbes; + }; + + struct GfxLightmapArray + { + GfxImage* primary; + GfxImage* secondary; + }; + + struct type_align(4) GfxLightGridEntry + { + uint16_t colorsIndex; + char primaryLightIndex; + char needsTrace; + }; + + struct type_align(4) GfxLightGridColors + { + char rgb[56][3]; + }; + + struct GfxLightGrid + { + bool hasLightRegions; + unsigned int sunPrimaryLightIndex; + uint16_t mins[3]; + uint16_t maxs[3]; + unsigned int rowAxis; + unsigned int colAxis; + uint16_t* rowDataStart; + unsigned int rawRowDataSize; + char* rawRowData; + unsigned int entryCount; + GfxLightGridEntry* entries; + unsigned int colorCount; + GfxLightGridColors* colors; + }; + + struct GfxBrushModelWritable + { + float mins[3]; + float maxs[3]; + }; + + struct GfxBrushModel + { + GfxBrushModelWritable writable; + float bounds[2][3]; + unsigned int surfaceCount; + unsigned int startSurfIndex; + }; + + struct MaterialMemory + { + Material* material; + int memory; + }; + + struct sunflare_t + { + bool hasValidData; + Material* spriteMaterial; + Material* flareMaterial; + float spriteSize; + float flareMinSize; + float flareMinDot; + float flareMaxSize; + float flareMaxDot; + float flareMaxAlpha; + int flareFadeInTime; + int flareFadeOutTime; + float blindMinDot; + float blindMaxDot; + float blindMaxDarken; + int blindFadeInTime; + int blindFadeOutTime; + float glareMinDot; + float glareMaxDot; + float glareMaxLighten; + int glareFadeInTime; + int glareFadeOutTime; + float sunFxPosition[3]; + }; + + struct XModelDrawInfo + { + uint16_t lod; + uint16_t surfId; + }; + + struct GfxSceneDynModel + { + XModelDrawInfo info; + uint16_t dynEntId; + }; + + struct BModelDrawInfo + { + uint16_t surfId; + }; + + struct type_align(4) GfxSceneDynBrush + { + BModelDrawInfo info; + uint16_t dynEntId; + }; + + struct GfxShadowGeometry + { + uint16_t surfaceCount; + uint16_t smodelCount; + uint16_t* sortedSurfIndex; + uint16_t* smodelIndex; + }; + + struct GfxLightRegionAxis + { + float dir[3]; + float midPoint; + float halfSize; + }; + + struct GfxLightRegionHull + { + float kdopMidPoint[9]; + float kdopHalfSize[9]; + unsigned int axisCount; + GfxLightRegionAxis* axis; + }; + + struct GfxLightRegion + { + unsigned int hullCount; + GfxLightRegionHull* hulls; + }; + + struct GfxPackedPlacement + { + float origin[3]; + float axis[3][3]; + float scale; + }; + + struct ModelLodFade + { + unsigned int value; + }; + + struct GfxStaticModelDrawInst + { + float cullDist; + GfxPackedPlacement placement; + XModel* model; + ModelLodFade lodFade; + int cachedLightSettingIndex; + char field_44; + char field_45; + unsigned char reflectionProbeIndex; + unsigned char primaryLightIndex; + int flags; + unsigned int smodelCacheIndex[4]; + }; + + struct GfxStaticModelInst + { + float mins[3]; + float maxs[3]; + GfxColor groundLighting; + }; + + struct srfTriangles_t + { + int vertexLayerData; + int firstVertex; + uint16_t vertexCount; + uint16_t triCount; + int baseIndex; + }; + + struct GfxSurface + { + srfTriangles_t tris; + int pad; + Material* material; + char lightmapIndex; + char reflectionProbeIndex; + char primaryLightIndex; + char flags; + float bounds[2][3]; + }; + + struct GfxCullGroup + { + float mins[3]; + float maxs[3]; + int surfaceCount; + int startSurfIndex; + }; + + struct GfxWorldDpvsStatic + { + unsigned int smodelCount; + unsigned int staticSurfaceCount; + unsigned int litSurfsBegin; + unsigned int litSurfsEnd; + unsigned int decalSurfsBegin; + unsigned int decalSurfsEnd; + unsigned int emissiveSurfsBegin; + unsigned int emissiveSurfsEnd; + unsigned int smodelVisDataCount; + unsigned int surfaceVisDataCount; + char* smodelVisData[3]; + char* surfaceVisData[3]; + raw_uint128* lodData; + uint16_t* sortedSurfIndex; + GfxStaticModelInst* smodelInsts; + GfxSurface* surfaces; + GfxCullGroup* cullGroups; + GfxStaticModelDrawInst* smodelDrawInsts; + GfxDrawSurf* surfaceMaterials; + raw_uint128* surfaceCastsSunShadow; + volatile int usageCount; + }; + + struct GfxWorldDpvsDynamic + { + unsigned int dynEntClientWordCount[2]; + unsigned int dynEntClientCount[2]; + unsigned int* dynEntCellBits[2]; + raw_byte16* dynEntVisData[2][3]; + }; + + struct GfxWorldLodChain + { + float origin[3]; + float lastDist; + unsigned int firstLodInfo; + uint16_t lodInfoCount; + }; + + struct GfxWorldLodInfo + { + float dist; + unsigned int firstSurf; + uint16_t surfCount; + }; + + struct GfxWaterBuffer + { + unsigned int bufferSize; + vec4_t* buffer; + }; + + typedef tdef_align32(4) GfxSceneDynModel GfxSceneDynModel4; + + struct GfxWorld + { + const char* name; + const char* baseName; + int planeCount; + int nodeCount; + int indexCount; + uint16_t* indices; + int surfaceCount; + int streamInfo; + int skySurfCount; + int* skyStartSurfs; + GfxImage* skyImage; + char skySamplerState; + const char* skyBoxModel; + unsigned int vertexCount; + GfxWorldVertexData vd; + unsigned int vertexLayerDataSize; + GfxWorldVertexLayerData vld; + unsigned int vertexStream2DataSize; + SunLightParseParams sunParse; + GfxLight* sunLight; + float sunColorFromBsp[3]; + unsigned int sunPrimaryLightIndex; + unsigned int primaryLightCount; + int cullGroupCount; + unsigned int reflectionProbeCount; + GfxReflectionProbe* reflectionProbes; + GfxTexture* reflectionProbeTextures; + unsigned int coronaCount; + GfxLightCorona* coronas; + GfxWorldDpvsPlanes dpvsPlanes; + int cellBitsCount; + GfxCell* cells; + int lightmapCount; + GfxLightmapArray* lightmaps; + GfxLightGrid lightGrid; + GfxTexture* lightmapPrimaryTextures; + GfxTexture* lightmapSecondaryTextures; + int modelCount; + GfxBrushModel* models; + float mins[3]; + float maxs[3]; + unsigned int checksum; + int materialMemoryCount; + MaterialMemory* materialMemory; + sunflare_t sun; + float outdoorLookupMatrix[4][4]; + GfxImage* outdoorImage; + unsigned int* cellCasterBits; + GfxSceneDynModel4* sceneDynModel; + GfxSceneDynBrush* sceneDynBrush; + unsigned int* primaryLightEntityShadowVis; + unsigned int* primaryLightDynEntShadowVis[2]; + char* nonSunPrimaryLightForModelDynEnt; + GfxShadowGeometry* shadowGeom; + GfxLightRegion* lightRegion; + GfxWorldDpvsStatic dpvs; + GfxWorldDpvsDynamic dpvsDyn; + unsigned int worldLodChainCount; + GfxWorldLodChain* worldLodChains; + unsigned int worldLodInfoCount; + GfxWorldLodInfo* worldLodInfos; + unsigned int worldLodSurfaceCount; + unsigned int* worldLodSurfaces; + float waterDirection; + GfxWaterBuffer waterBuffers[2]; + Material* waterMaterial; + }; + + struct Glyph + { + uint16_t letter; + char x0; + char y0; + char dx; + char pixelWidth; + char pixelHeight; + float s0; + float t0; + float s1; + float t1; + }; + + struct Font_s + { + const char* fontName; + int pixelHeight; + int glyphCount; + Material* material; + Material* glowMaterial; + Glyph* glyphs; + }; + + struct MenuList + { + const char* name; + int menuCount; + menuDef_t** menus; + }; + + struct rectDef_s + { + float x; + float y; + float w; + float h; + int horzAlign; + int vertAlign; + }; + + struct windowDef_t + { + const char* name; + rectDef_s rect; + rectDef_s rectClient; + const char* group; + int style; + int border; + int ownerDraw; + int ownerDrawFlags; + float borderSize; + int staticFlags; + int dynamicFlags[1]; + int nextTime; + float foreColor[4]; + float backColor[4]; + float borderColor[4]; + float outlineColor[4]; + Material* background; + }; + + struct ItemKeyHandler + { + int key; + const char* action; + ItemKeyHandler* next; + }; + + union operandInternalDataUnion + { + int intVal; + float floatVal; + const char* string; + }; + + enum expDataType + { + VAL_INT = 0x0, + VAL_FLOAT = 0x1, + VAL_STRING = 0x2, + }; + + enum expOperationEnum + { + OP_NEGATE = 0x7, + NUM_EXPRESSION_OPERATORS = 0x18, + MAX_OPERATOR_VALUE = 0x4000, + }; + + struct Operand + { + expDataType dataType; + operandInternalDataUnion internals; + }; + + union entryInternalData + { + Operand operand; + expOperationEnum op; + }; + + enum expressionEntryType : int + { + EET_OPERATOR = 0x0, + EET_OPERAND = 0x1, + }; + + struct expressionEntry + { + int type; + entryInternalData data; + }; + + struct statement_s + { + int numEntries; + expressionEntry** entries; + }; + + struct columnInfo_s + { + int pos; + int width; + int maxChars; + int alignment; + }; + + struct listBoxDef_s + { + int mousePos; + int startPos[1]; + int endPos[1]; + int drawPadding; + float elementWidth; + float elementHeight; + int elementStyle; + int numColumns; + columnInfo_s columnInfo[16]; + const char* doubleClick; + int notselectable; + int noScrollBars; + int usePaging; + float selectBorder[4]; + float disableColor[4]; + float focusColor[4]; + Material* selectIcon; + Material* backgroundItemListbox; + Material* highlightTexture; + }; + + struct editFieldDef_s + { + float minVal; + float maxVal; + float defVal; + float range; + int maxChars; + int maxCharsGotoNext; + int maxPaintChars; + int paintOffset; + }; + + struct multiDef_s + { + const char* dvarList[32]; + const char* dvarStr[32]; + float dvarValue[32]; + int count; + int strDef; + }; + + union itemDefData_t + { + listBoxDef_s* listBox; + editFieldDef_s* editField; + multiDef_s* multi; + const char* enumDvarName; + void* data; + }; + + enum ItemDefType + { + ITEM_TYPE_TEXT = 0x0, + ITEM_TYPE_BUTTON = 0x1, + ITEM_TYPE_RADIOBUTTON = 0x2, + ITEM_TYPE_CHECKBOX = 0x3, + ITEM_TYPE_EDITFIELD = 0x4, + ITEM_TYPE_COMBO = 0x5, + ITEM_TYPE_LISTBOX = 0x6, + ITEM_TYPE_MODEL = 0x7, + ITEM_TYPE_OWNERDRAW = 0x8, + ITEM_TYPE_NUMERICFIELD = 0x9, + ITEM_TYPE_SLIDER = 0xA, + ITEM_TYPE_YESNO = 0xB, + ITEM_TYPE_MULTI = 0xC, + ITEM_TYPE_DVARENUM = 0xD, + ITEM_TYPE_BIND = 0xE, + ITEM_TYPE_MENUMODEL = 0xF, + ITEM_TYPE_VALIDFILEFIELD = 0x10, + ITEM_TYPE_DECIMALFIELD = 0x11, + ITEM_TYPE_UPREDITFIELD = 0x12, + ITEM_TYPE_GAME_MESSAGE_WINDOW = 0x13 + }; + + struct itemDef_s + { + windowDef_t window; + rectDef_s textRect[1]; + int type; + int dataType; + int alignment; + int fontEnum; + int textAlignMode; + float textalignx; + float textaligny; + float textscale; + int textStyle; + int gameMsgWindowIndex; + int gameMsgWindowMode; + const char* text; + int itemFlags; + menuDef_t* parent; + const char* mouseEnterText; + const char* mouseExitText; + const char* mouseEnter; + const char* mouseExit; + const char* action; + const char* onAccept; + const char* onFocus; + const char* leaveFocus; + const char* dvar; + const char* dvarTest; + const char* onListboxSelectionChange; + ItemKeyHandler* onKey; + const char* enableDvar; + int dvarFlags; + snd_alias_list_t* focusSound; + float special; + int cursorPos[1]; + itemDefData_t typeData; + int imageTrack; + statement_s visibleExp; + statement_s textExp; + statement_s materialExp; + statement_s rectXExp; + statement_s rectYExp; + statement_s rectWExp; + statement_s rectHExp; + statement_s forecolorAExp; + }; + + struct menuDef_t + { + windowDef_t window; + const char* font; + int fullScreen; + int itemCount; + int fontIndex; + int cursorItem[1]; + int fadeCycle; + float fadeClamp; + float fadeAmount; + float fadeInAmount; + float blurRadius; + const char* onOpen; + const char* onFocus; + const char* onClose; + const char* onESC; + ItemKeyHandler* onKey; + statement_s visibleExp; + const char* allowedBinding; + const char* soundName; + int imageTrack; + float focusColor[4]; + float disableColor[4]; + statement_s rectXExp; + statement_s rectYExp; + itemDef_s** items; + }; + + struct LocalizeEntry + { + const char* value; + const char* name; + }; + + enum weapType_t + { + WEAPTYPE_BULLET = 0x0, + WEAPTYPE_GRENADE = 0x1, + WEAPTYPE_PROJECTILE = 0x2, + WEAPTYPE_BINOCULARS = 0x3, + WEAPTYPE_NUM = 0x4, + }; + + enum weapClass_t + { + WEAPCLASS_RIFLE = 0x0, + WEAPCLASS_MG = 0x1, + WEAPCLASS_SMG = 0x2, + WEAPCLASS_SPREAD = 0x3, + WEAPCLASS_PISTOL = 0x4, + WEAPCLASS_GRENADE = 0x5, + WEAPCLASS_ROCKETLAUNCHER = 0x6, + WEAPCLASS_TURRET = 0x7, + WEAPCLASS_NON_PLAYER = 0x8, + WEAPCLASS_ITEM = 0x9, + WEAPCLASS_NUM = 0xA, + }; + + enum PenetrateType + { + PENETRATE_TYPE_NONE = 0x0, + PENETRATE_TYPE_SMALL = 0x1, + PENETRATE_TYPE_MEDIUM = 0x2, + PENETRATE_TYPE_LARGE = 0x3, + PENETRATE_TYPE_COUNT = 0x4, + }; + + enum ImpactType + { + IMPACT_TYPE_NONE = 0x0, + IMPACT_TYPE_BULLET_SMALL = 0x1, + IMPACT_TYPE_BULLET_LARGE = 0x2, + IMPACT_TYPE_BULLET_AP = 0x3, + IMPACT_TYPE_SHOTGUN = 0x4, + IMPACT_TYPE_GRENADE_BOUNCE = 0x5, + IMPACT_TYPE_GRENADE_EXPLODE = 0x6, + IMPACT_TYPE_ROCKET_EXPLODE = 0x7, + IMPACT_TYPE_PROJECTILE_DUD = 0x8, + IMPACT_TYPE_COUNT = 0x9, + }; + + enum weapInventoryType_t + { + WEAPINVENTORY_PRIMARY = 0x0, + WEAPINVENTORY_OFFHAND = 0x1, + WEAPINVENTORY_ITEM = 0x2, + WEAPINVENTORY_ALTMODE = 0x3, + WEAPINVENTORYCOUNT = 0x4, + }; + + enum weapFireType_t + { + WEAPON_FIRETYPE_FULLAUTO = 0x0, + WEAPON_FIRETYPE_SINGLESHOT = 0x1, + WEAPON_FIRETYPE_BURSTFIRE2 = 0x2, + WEAPON_FIRETYPE_BURSTFIRE3 = 0x3, + WEAPON_FIRETYPE_BURSTFIRE4 = 0x4, + WEAPON_FIRETYPECOUNT = 0x5, + }; + + enum OffhandClass + { + OFFHAND_CLASS_NONE = 0x0, + OFFHAND_CLASS_FRAG_GRENADE = 0x1, + OFFHAND_CLASS_SMOKE_GRENADE = 0x2, + OFFHAND_CLASS_FLASH_GRENADE = 0x3, + OFFHAND_CLASS_COUNT = 0x4, + }; + + enum weapStance_t + { + WEAPSTANCE_STAND = 0x0, + WEAPSTANCE_DUCK = 0x1, + WEAPSTANCE_PRONE = 0x2, + WEAPSTANCE_NUM = 0x3, + }; + + enum activeReticleType_t + { + VEH_ACTIVE_RETICLE_NONE = 0x0, + VEH_ACTIVE_RETICLE_PIP_ON_A_STICK = 0x1, + VEH_ACTIVE_RETICLE_BOUNCING_DIAMOND = 0x2, + VEH_ACTIVE_RETICLE_COUNT = 0x3, + }; + + enum weaponIconRatioType_t + { + WEAPON_ICON_RATIO_1TO1 = 0x0, + WEAPON_ICON_RATIO_2TO1 = 0x1, + WEAPON_ICON_RATIO_4TO1 = 0x2, + WEAPON_ICON_RATIO_COUNT = 0x3, + }; + + enum weapClipType_t + { + WEAPON_CLIPTYPE_BOTTOM = 0x0, + WEAPON_CLIPTYPE_TOP = 0x1, + WEAPON_CLIPTYPE_LEFT = 0x2, + WEAPON_CLIPTYPE_DP28 = 0x3, + WEAPON_CLIPTYPE_PTRS = 0x4, + WEAPON_CLIPTYPE_LMG = 0x5, + WEAPON_CLIPTYPECOUNT = 0x6, + }; + + enum ammoCounterClipType_t + { + AMMO_COUNTER_CLIP_NONE = 0x0, + AMMO_COUNTER_CLIP_MAGAZINE = 0x1, + AMMO_COUNTER_CLIP_SHORTMAGAZINE = 0x2, + AMMO_COUNTER_CLIP_SHOTGUN = 0x3, + AMMO_COUNTER_CLIP_ROCKET = 0x4, + AMMO_COUNTER_CLIP_BELTFED = 0x5, + AMMO_COUNTER_CLIP_ALTWEAPON = 0x6, + AMMO_COUNTER_CLIP_COUNT = 0x7, + }; + + enum weapOverlayReticle_t + { + WEAPOVERLAYRETICLE_NONE = 0x0, + WEAPOVERLAYRETICLE_CROSSHAIR = 0x1, + WEAPOVERLAYRETICLE_NUM = 0x2, + }; + + enum WeapOverlayInteface_t + { + WEAPOVERLAYINTERFACE_NONE = 0x0, + WEAPOVERLAYINTERFACE_JAVELIN = 0x1, + WEAPOVERLAYINTERFACE_TURRETSCOPE = 0x2, + WEAPOVERLAYINTERFACECOUNT = 0x3, + }; + + enum weapProjExposion_t + { + WEAPPROJEXP_GRENADE = 0x0, + WEAPPROJEXP_ROCKET = 0x1, + WEAPPROJEXP_FLASHBANG = 0x2, + WEAPPROJEXP_NONE = 0x3, + WEAPPROJEXP_DUD = 0x4, + WEAPPROJEXP_SMOKE = 0x5, + WEAPPROJEXP_HEAVY = 0x6, + WEAPPROJEXP_NUM = 0x7, + }; + + enum WeapStickinessType + { + WEAPSTICKINESS_NONE = 0x0, + WEAPSTICKINESS_ALL = 0x1, + WEAPSTICKINESS_GROUND = 0x2, + WEAPSTICKINESS_GROUND_WITH_YAW = 0x3, + WEAPSTICKINESS_COUNT = 0x4, + }; + + enum guidedMissileType_t + { + MISSILE_GUIDANCE_NONE = 0x0, + MISSILE_GUIDANCE_SIDEWINDER = 0x1, + MISSILE_GUIDANCE_HELLFIRE = 0x2, + MISSILE_GUIDANCE_JAVELIN = 0x3, + MISSILE_GUIDANCE_BALLISTIC = 0x4, + MISSILE_GUIDANCE_COUNT = 0x5, + }; + + enum hitLocation_t + { + HITLOC_NONE = 0x0, + HITLOC_HELMET = 0x1, + HITLOC_HEAD = 0x2, + HITLOC_NECK = 0x3, + HITLOC_TORSO_UPR = 0x4, + HITLOC_TORSO_LWR = 0x5, + HITLOC_R_ARM_UPR = 0x6, + HITLOC_L_ARM_UPR = 0x7, + HITLOC_R_ARM_LWR = 0x8, + HITLOC_L_ARM_LWR = 0x9, + HITLOC_R_HAND = 0xA, + HITLOC_L_HAND = 0xB, + HITLOC_R_LEG_UPR = 0xC, + HITLOC_L_LEG_UPR = 0xD, + HITLOC_R_LEG_LWR = 0xE, + HITLOC_L_LEG_LWR = 0xF, + HITLOC_R_FOOT = 0x10, + HITLOC_L_FOOT = 0x11, + HITLOC_GUN = 0x12, + + HITLOC_COUNT, + }; + + struct snd_alias_list_name + { + const char* soundName; + }; + + union SndAliasCustom + { + snd_alias_list_name* name; + snd_alias_list_t* sound; + }; + + union FxEffectDefRef + { + FxEffectDef* handle; + const char* name; + }; + + struct DestructibleModel + { + XModel* model; + float breakHealth; + unsigned int flags; + FxEffectDef* breakEffect; + SndAliasCustom breakSound; + const char* breakNotify; + const char* loopSound; + XModel* spawnModel[3]; + }; + + struct DestructiblePiece + { + DestructibleModel dmodels[5]; + const char* attachBone; + ScriptString attachBoneHash; + unsigned char parentPiece; + float parentDamagePercent; + float bulletDamageScale; + float explosiveDamageScale; + float entityDamageTransfer; + PhysConstraints* physConstraints; + int health; + SndAliasCustom damageSound; + FxEffectDef* burnEffect; + SndAliasCustom burnSound; + ScriptString enableLabel; + }; + + struct DestructibleDef + { + const char* name; + XModel* baseModel; + int numPieces; + DestructiblePiece* pieces; + int clientOnly; + }; + + struct flameTable + { + float flameVar_streamChunkGravityStart; + float flameVar_streamChunkGravityEnd; + float flameVar_streamChunkMaxSize; + float flameVar_streamChunkStartSize; + float flameVar_streamChunkEndSize; + float flameVar_streamChunkStartSizeRand; + float flameVar_streamChunkEndSizeRand; + float flameVar_streamChunkDistScalar; + float flameVar_streamChunkDistSwayScale; + float flameVar_streamChunkDistSwayVelMax; + float flameVar_streamChunkSpeed; + float flameVar_streamChunkDecel; + float flameVar_streamChunkVelocityAddScale; + float flameVar_streamChunkDuration; + float flameVar_streamChunkDurationScaleMaxVel; + float flameVar_streamChunkDurationVelScalar; + float flameVar_streamChunkSizeSpeedScale; + float flameVar_streamChunkSizeAgeScale; + float flameVar_streamChunkSpawnFireIntervalStart; + float flameVar_streamChunkSpawnFireIntervalEnd; + float flameVar_streamChunkSpawnFireMinLifeFrac; + float flameVar_streamChunkSpawnFireMaxLifeFrac; + float flameVar_streamChunkFireMinLifeFrac; + float flameVar_streamChunkFireMinLifeFracStart; + float flameVar_streamChunkFireMinLifeFracEnd; + float flameVar_streamChunkDripsMinLifeFrac; + float flameVar_streamChunkDripsMinLifeFracStart; + float flameVar_streamChunkDripsMinLifeFracEnd; + float flameVar_streamChunkRotationRange; + float flameVar_streamSizeRandSinWave; + float flameVar_streamSizeRandCosWave; + float flameVar_streamDripsChunkInterval; + float flameVar_streamDripsChunkMinFrac; + float flameVar_streamDripsChunkRandFrac; + float flameVar_streamSmokeChunkInterval; + float flameVar_streamSmokeChunkMinFrac; + float flameVar_streamSmokeChunkRandFrac; + float flameVar_streamChunkCullDistSizeFrac; + float flameVar_streamChunkCullMinLife; + float flameVar_streamChunkCullMaxLife; + float flameVar_streamFuelSizeStart; + float flameVar_streamFuelSizeEnd; + float flameVar_streamFuelLength; + float flameVar_streamFuelNumSegments; + float flameVar_streamFuelAnimLoopTime; + float flameVar_streamFlameSizeStart; + float flameVar_streamFlameSizeEnd; + float flameVar_streamFlameLength; + float flameVar_streamFlameNumSegments; + float flameVar_streamFlameAnimLoopTime; + float flameVar_streamPrimaryLightRadius; + float flameVar_streamPrimaryLightRadiusFlutter; + float flameVar_streamPrimaryLightR; + float flameVar_streamPrimaryLightG; + float flameVar_streamPrimaryLightB; + float flameVar_streamPrimaryLightFlutterR; + float flameVar_streamPrimaryLightFlutterG; + float flameVar_streamPrimaryLightFlutterB; + float flameVar_fireLife; + float flameVar_fireLifeRand; + float flameVar_fireSpeedScale; + float flameVar_fireSpeedScaleRand; + float flameVar_fireVelocityAddZ; + float flameVar_fireVelocityAddZRand; + float flameVar_fireVelocityAddSideways; + float flameVar_fireGravity; + float flameVar_fireGravityEnd; + float flameVar_fireMaxRotVel; + float flameVar_fireFriction; + float flameVar_fireEndSizeAdd; + float flameVar_fireStartSizeScale; + float flameVar_fireEndSizeScale; + float flameVar_dripsLife; + float flameVar_dripsLifeRand; + float flameVar_dripsSpeedScale; + float flameVar_dripsSpeedScaleRand; + float flameVar_dripsVelocityAddZ; + float flameVar_dripsVelocityAddZRand; + float flameVar_dripsVelocityAddSideways; + float flameVar_dripsGravity; + float flameVar_dripsGravityEnd; + float flameVar_dripsMaxRotVel; + float flameVar_dripsFriction; + float flameVar_dripsEndSizeAdd; + float flameVar_dripsStartSizeScale; + float flameVar_dripsEndSizeScale; + float flameVar_smokeLife; + float flameVar_smokeLifeRand; + float flameVar_smokeSpeedScale; + float flameVar_smokeVelocityAddZ; + float flameVar_smokeGravity; + float flameVar_smokeGravityEnd; + float flameVar_smokeMaxRotation; + float flameVar_smokeMaxRotVel; + float flameVar_smokeFriction; + float flameVar_smokeEndSizeAdd; + float flameVar_smokeStartSizeAdd; + float flameVar_smokeOriginSizeOfsZScale; + float flameVar_smokeOriginOfsZ; + float flameVar_smokeFadein; + float flameVar_smokeFadeout; + float flameVar_smokeMaxAlpha; + float flameVar_smokeBrightness; + float flameVar_smokeOriginOffset; + float flameVar_collisionSpeedScale; + float flameVar_collisionVolumeScale; + const char* name; + Material* fire; + Material* smoke; + Material* heat; + Material* drips; + Material* streamFuel; + Material* streamFuel2; + Material* streamFlame; + Material* streamFlame2; + SndAliasCustom flameOffLoopSound; + SndAliasCustom flameIgniteSound; + SndAliasCustom flameOnLoopSound; + SndAliasCustom flameCooldownSound; + }; + + struct WeaponDef + { + const char* szInternalName; + const char* szDisplayName; + const char* szOverlayName; + XModel* gunXModel[16]; + XModel* handXModel; + const char* szXAnims[35]; + const char* szModeName; + uint16_t hideTags[8]; + uint16_t notetrackSoundMapKeys[20]; + uint16_t notetrackSoundMapValues[20]; + int playerAnimType; + weapType_t weapType; + weapClass_t weapClass; + PenetrateType penetrateType; + ImpactType impactType; + weapInventoryType_t inventoryType; + weapFireType_t fireType; + weapClipType_t clipType; + int overheatWeapon; + float overheatRate; + float cooldownRate; + float overheatEndVal; + int coolWhileFiring; + OffhandClass offhandClass; + weapStance_t stance; + FxEffectDef* viewFlashEffect; + FxEffectDef* worldFlashEffect; + SndAliasCustom pickupSound; + SndAliasCustom pickupSoundPlayer; + SndAliasCustom ammoPickupSound; + SndAliasCustom ammoPickupSoundPlayer; + SndAliasCustom projectileSound; + SndAliasCustom pullbackSound; + SndAliasCustom pullbackSoundPlayer; + SndAliasCustom fireSound; + SndAliasCustom fireSoundPlayer; + SndAliasCustom fireLoopSound; + SndAliasCustom fireLoopSoundPlayer; + SndAliasCustom fireStopSound; + SndAliasCustom fireStopSoundPlayer; + SndAliasCustom fireLastSound; + SndAliasCustom fireLastSoundPlayer; + SndAliasCustom emptyFireSound; + SndAliasCustom emptyFireSoundPlayer; + SndAliasCustom crackSound; + SndAliasCustom whizbySound; + SndAliasCustom meleeSwipeSound; + SndAliasCustom meleeSwipeSoundPlayer; + SndAliasCustom meleeHitSound; + SndAliasCustom meleeMissSound; + SndAliasCustom rechamberSound; + SndAliasCustom rechamberSoundPlayer; + SndAliasCustom reloadSound; + SndAliasCustom reloadSoundPlayer; + SndAliasCustom reloadEmptySound; + SndAliasCustom reloadEmptySoundPlayer; + SndAliasCustom reloadStartSound; + SndAliasCustom reloadStartSoundPlayer; + SndAliasCustom reloadEndSound; + SndAliasCustom reloadEndSoundPlayer; + SndAliasCustom rotateLoopSound; + SndAliasCustom rotateLoopSoundPlayer; + SndAliasCustom deploySound; + SndAliasCustom deploySoundPlayer; + SndAliasCustom finishDeploySound; + SndAliasCustom finishDeploySoundPlayer; + SndAliasCustom breakdownSound; + SndAliasCustom breakdownSoundPlayer; + SndAliasCustom finishBreakdownSound; + SndAliasCustom finishBreakdownSoundPlayer; + SndAliasCustom detonateSound; + SndAliasCustom detonateSoundPlayer; + SndAliasCustom nightVisionWearSound; + SndAliasCustom nightVisionWearSoundPlayer; + SndAliasCustom nightVisionRemoveSound; + SndAliasCustom nightVisionRemoveSoundPlayer; + SndAliasCustom altSwitchSound; + SndAliasCustom altSwitchSoundPlayer; + SndAliasCustom raiseSound; + SndAliasCustom raiseSoundPlayer; + SndAliasCustom firstRaiseSound; + SndAliasCustom firstRaiseSoundPlayer; + SndAliasCustom putawaySound; + SndAliasCustom putawaySoundPlayer; + SndAliasCustom overheatSound; + SndAliasCustom overheatSoundPlayer; + SndAliasCustom* bounceSound; + const char* standMountedWeapdef; + const char* crouchMountedWeapdef; + const char* proneMountedWeapdef; + int standMountedIndex; + int crouchMountedIndex; + int proneMountedIndex; + FxEffectDef* viewShellEjectEffect; + FxEffectDef* worldShellEjectEffect; + FxEffectDef* viewLastShotEjectEffect; + FxEffectDef* worldLastShotEjectEffect; + Material* reticleCenter; + Material* reticleSide; + int iReticleCenterSize; + int iReticleSideSize; + int iReticleMinOfs; + activeReticleType_t activeReticleType; + float vStandMove[3]; + float vStandRot[3]; + float vDuckedOfs[3]; + float vDuckedMove[3]; + float duckedSprintOfs[3]; + float duckedSprintRot[3]; + float duckedSprintBob[2]; + float duckedSprintScale; + float sprintOfs[3]; + float sprintRot[3]; + float sprintBob[2]; + float sprintScale; + float vDuckedRot[3]; + float vProneOfs[3]; + float vProneMove[3]; + float vProneRot[3]; + float fPosMoveRate; + float fPosProneMoveRate; + float fStandMoveMinSpeed; + float fDuckedMoveMinSpeed; + float fProneMoveMinSpeed; + float fPosRotRate; + float fPosProneRotRate; + float fStandRotMinSpeed; + float fDuckedRotMinSpeed; + float fProneRotMinSpeed; + XModel* worldModel[16]; + XModel* worldClipModel; + XModel* rocketModel; + XModel* knifeModel; + XModel* worldKnifeModel; + XModel* mountedModel; + Material* hudIcon; + weaponIconRatioType_t hudIconRatio; + Material* ammoCounterIcon; + weaponIconRatioType_t ammoCounterIconRatio; + ammoCounterClipType_t ammoCounterClip; + int iStartAmmo; + const char* szAmmoName; + int iAmmoIndex; + const char* szClipName; + int iClipIndex; + int iHeatIndex; + int iMaxAmmo; + int iClipSize; + int shotCount; + const char* szSharedAmmoCapName; + int iSharedAmmoCapIndex; + int iSharedAmmoCap; + int unlimitedAmmo; + int damage; + int damageDuration; + int damageInterval; + int playerDamage; + int iMeleeDamage; + int iDamageType; + int iFireDelay; + int iMeleeDelay; + int meleeChargeDelay; + int iDetonateDelay; + int iFireTime; + int iRechamberTime; + int iRechamberBoltTime; + int iHoldFireTime; + int iDetonateTime; + int iMeleeTime; + int meleeChargeTime; + int iReloadTime; + int reloadShowRocketTime; + int iReloadEmptyTime; + int iReloadAddTime; + int reloadEmptyAddTime; + int iReloadStartTime; + int iReloadStartAddTime; + int iReloadEndTime; + int iDropTime; + int iRaiseTime; + int iAltDropTime; + int iAltRaiseTime; + int quickDropTime; + int quickRaiseTime; + int iFirstRaiseTime; + int iEmptyRaiseTime; + int iEmptyDropTime; + int sprintInTime; + int sprintLoopTime; + int sprintOutTime; + int deployTime; + int breakdownTime; + int nightVisionWearTime; + int nightVisionWearTimeFadeOutEnd; + int nightVisionWearTimePowerUp; + int nightVisionRemoveTime; + int nightVisionRemoveTimePowerDown; + int nightVisionRemoveTimeFadeInStart; + int fuseTime; + int aiFuseTime; + int requireLockonToFire; + int noAdsWhenMagEmpty; + int avoidDropCleanup; + float autoAimRange; + float aimAssistRange; + float aimAssistRangeAds; + int mountableWeapon; + float aimPadding; + float enemyCrosshairRange; + int crosshairColorChange; + float moveSpeedScale; + float adsMoveSpeedScale; + float sprintDurationScale; + float fAdsZoomFov; + float fAdsZoomInFrac; + float fAdsZoomOutFrac; + Material* overlayMaterial; + Material* overlayMaterialLowRes; + weapOverlayReticle_t overlayReticle; + WeapOverlayInteface_t overlayInterface; + float overlayWidth; + float overlayHeight; + float fAdsBobFactor; + float fAdsViewBobMult; + float fHipSpreadStandMin; + float fHipSpreadDuckedMin; + float fHipSpreadProneMin; + float hipSpreadStandMax; + float hipSpreadDuckedMax; + float hipSpreadProneMax; + float fHipSpreadDecayRate; + float fHipSpreadFireAdd; + float fHipSpreadTurnAdd; + float fHipSpreadMoveAdd; + float fHipSpreadDuckedDecay; + float fHipSpreadProneDecay; + float fHipReticleSidePos; + int iAdsTransInTime; + int iAdsTransOutTime; + float fAdsIdleAmount; + float fHipIdleAmount; + float adsIdleSpeed; + float hipIdleSpeed; + float fIdleCrouchFactor; + float fIdleProneFactor; + float fGunMaxPitch; + float fGunMaxYaw; + float swayMaxAngle; + float swayLerpSpeed; + float swayPitchScale; + float swayYawScale; + float swayHorizScale; + float swayVertScale; + float swayShellShockScale; + float adsSwayMaxAngle; + float adsSwayLerpSpeed; + float adsSwayPitchScale; + float adsSwayYawScale; + float adsSwayHorizScale; + float adsSwayVertScale; + int bRifleBullet; + int armorPiercing; + int bBoltAction; + int aimDownSight; + int bRechamberWhileAds; + float adsViewErrorMin; + float adsViewErrorMax; + int bCookOffHold; + int bClipOnly; + int canUseInVehicle; + int noDropsOrRaises; + int adsFireOnly; + int cancelAutoHolsterWhenEmpty; + int suppressAmmoReserveDisplay; + int enhanced; + int laserSightDuringNightvision; + int bayonet; + Material* killIcon; + weaponIconRatioType_t killIconRatio; + int flipKillIcon; + Material* dpadIcon; + weaponIconRatioType_t dpadIconRatio; + int bNoPartialReload; + int bSegmentedReload; + int noADSAutoReload; + int iReloadAmmoAdd; + int iReloadStartAdd; + const char* szAltWeaponName; + unsigned int altWeaponIndex; + int iDropAmmoMin; + int iDropAmmoMax; + int blocksProne; + int silenced; + int iExplosionRadius; + int iExplosionRadiusMin; + int iExplosionInnerDamage; + int iExplosionOuterDamage; + float damageConeAngle; + int iProjectileSpeed; + int iProjectileSpeedUp; + int iProjectileSpeedForward; + int iProjectileActivateDist; + float projLifetime; + float timeToAccelerate; + float projectileCurvature; + XModel* projectileModel; + weapProjExposion_t projExplosion; + FxEffectDef* projExplosionEffect; + int projExplosionEffectForceNormalUp; + FxEffectDef* projDudEffect; + SndAliasCustom projExplosionSound; + SndAliasCustom projDudSound; + SndAliasCustom mortarShellSound; + SndAliasCustom tankShellSound; + int bProjImpactExplode; + WeapStickinessType stickiness; + int hasDetonator; + int timedDetonation; + int rotate; + int holdButtonToThrow; + int freezeMovementWhenFiring; + float lowAmmoWarningThreshold; + float parallelBounce[31]; + float perpendicularBounce[31]; + FxEffectDef* projTrailEffect; + float vProjectileColor[3]; + guidedMissileType_t guidedMissileType; + float maxSteeringAccel; + int projIgnitionDelay; + FxEffectDef* projIgnitionEffect; + SndAliasCustom projIgnitionSound; + float fAdsAimPitch; + float fAdsCrosshairInFrac; + float fAdsCrosshairOutFrac; + int adsGunKickReducedKickBullets; + float adsGunKickReducedKickPercent; + float fAdsGunKickPitchMin; + float fAdsGunKickPitchMax; + float fAdsGunKickYawMin; + float fAdsGunKickYawMax; + float fAdsGunKickAccel; + float fAdsGunKickSpeedMax; + float fAdsGunKickSpeedDecay; + float fAdsGunKickStaticDecay; + float fAdsViewKickPitchMin; + float fAdsViewKickPitchMax; + float fAdsViewKickYawMin; + float fAdsViewKickYawMax; + float fAdsViewKickCenterSpeed; + float fAdsViewScatterMin; + float fAdsViewScatterMax; + float fAdsSpread; + int hipGunKickReducedKickBullets; + float hipGunKickReducedKickPercent; + float fHipGunKickPitchMin; + float fHipGunKickPitchMax; + float fHipGunKickYawMin; + float fHipGunKickYawMax; + float fHipGunKickAccel; + float fHipGunKickSpeedMax; + float fHipGunKickSpeedDecay; + float fHipGunKickStaticDecay; + float fHipViewKickPitchMin; + float fHipViewKickPitchMax; + float fHipViewKickYawMin; + float fHipViewKickYawMax; + float fHipViewKickCenterSpeed; + float fHipViewScatterMin; + float fHipViewScatterMax; + float fightDist; + float maxDist; + const char* aiVsAiAccuracyGraphName; + const char* aiVsPlayerAccuracyGraphName; + vec2_t* aiVsAiAccuracyGraphKnots; + vec2_t* aiVsPlayerAccuracyGraphKnots; + vec2_t* originalAiVsAiAccuracyGraphKnots; + vec2_t* originalAiVsPlayerAccuracyGraphKnots; + int aiVsAiAccuracyGraphKnotCount; + int aiVsPlayerAccuracyGraphKnotCount; + int originalAiVsAiAccuracyGraphKnotCount; + int originalAiVsPlayerAccuracyGraphKnotCount; + int iPositionReloadTransTime; + float leftArc; + float rightArc; + float topArc; + float bottomArc; + float accuracy; + float aiSpread; + float playerSpread; + float minTurnSpeed[2]; + float maxTurnSpeed[2]; + float pitchConvergenceTime; + float yawConvergenceTime; + float suppressTime; + float maxRange; + float fAnimHorRotateInc; + float fPlayerPositionDist; + const char* szUseHintString; + const char* dropHintString; + int iUseHintStringIndex; + int dropHintStringIndex; + float horizViewJitter; + float vertViewJitter; + const char* szScript; + float fOOPosAnimLength[2]; + int minDamage; + int minPlayerDamage; + float fMaxDamageRange; + float fMinDamageRange; + float destabilizationRateTime; + float destabilizationCurvatureMax; + int destabilizeDistance; + float locationDamageMultipliers[HITLOC_COUNT]; + const char* fireRumble; + const char* meleeImpactRumble; + float adsDofStart; + float adsDofEnd; + float hipDofStart; + float hipDofEnd; + const char* flameTableFirstPerson; + const char* flameTableThirdPerson; + flameTable* flameTableFirstPersonPtr; + flameTable* flameTableThirdPersonPtr; + FxEffectDef* tagFx_preparationEffect; + FxEffectDef* tagFlash_preparationEffect; + }; + + struct snd_reverb_patch_t + { + char name[32]; + float room; + float roomHF; + float roomRolloffFactor; + float decayTime; + float decayHFRatio; + float reflections; + float reflectionsDelay; + float reverb; + float reverbDelay; + float diffusion; + float density; + float HFReference; + }; + + struct snd_bus_info_t + { + char name[32]; + float volumeMod; + int maxVoices; + int restricted; + int pausable; + int stopOnDeath; + int isMusic; + snd_category_t category; + snd_limit_type_t voiceLimitType; + }; + + struct snd_curve_t + { + char name[32]; + int pointCount; + float points[8][2]; + }; + + struct snd_speaker_map + { + int input_channel_count; + int output_channel_count; + float volumes[16]; + }; + + struct snd_speaker_map_set + { + char name[32]; + snd_speaker_map channelMaps[4]; + }; + + struct snd_master_effect_t + { + char name[32]; + float masterRingmod; + float reverbRingmod; + float masterLPRatio; + float masterLPDB; + float masterHPRatio; + float masterHPDB; + }; + + struct SndDriverGlobals + { + const char* name; + snd_reverb_patch_t reverbPatches[64]; + snd_bus_info_t buses[64]; + snd_curve_t curves[32]; + snd_speaker_map_set speakerMaps[32]; + snd_master_effect_t masterEffects[16]; + }; + + struct FxIntRange + { + int base; + int amplitude; + }; + + struct FxFloatRange + { + float base; + float amplitude; + }; + + struct FxSpawnDefOneShot + { + FxIntRange count; + }; + + struct FxSpawnDefLooping + { + int intervalMsec; + int count; + }; + + union FxSpawnDef + { + FxSpawnDefLooping looping; + FxSpawnDefOneShot oneShot; + }; + + struct FxElemAtlas + { + char behavior; + char index; + char fps; + char loopCount; + char colIndexBits; + char rowIndexBits; + int16_t entryCount; + }; + + struct FxElemVec3Range + { + float base[3]; + float amplitude[3]; + }; + + struct FxElemVelStateInFrame + { + FxElemVec3Range velocity; + FxElemVec3Range totalDelta; + }; + + struct FxElemVelStateSample + { + FxElemVelStateInFrame local; + FxElemVelStateInFrame world; + }; + + struct FxElemVisualState + { + char color[4]; + float rotationDelta; + float rotationTotal; + float size[2]; + float scale; + }; + + struct FxElemVisStateSample + { + FxElemVisualState base; + FxElemVisualState amplitude; + }; + + enum FxElemType + { + FX_ELEM_TYPE_SPRITE_BILLBOARD = 0x0, + FX_ELEM_TYPE_SPRITE_ORIENTED = 0x1, + FX_ELEM_TYPE_TAIL = 0x2, + FX_ELEM_TYPE_TRAIL = 0x3, + FX_ELEM_TYPE_CLOUD = 0x4, + FX_ELEM_TYPE_SPARK_CLOUD = 0x5, + FX_ELEM_TYPE_MODEL = 0x6, + FX_ELEM_TYPE_OMNI_LIGHT = 0x7, + FX_ELEM_TYPE_SPOT_LIGHT = 0x8, + FX_ELEM_TYPE_SOUND = 0x9, + FX_ELEM_TYPE_DECAL = 0xA, + FX_ELEM_TYPE_RUNNER = 0xB, + FX_ELEM_TYPE_COUNT = 0xC, + FX_ELEM_TYPE_LAST_SPRITE = 0x3, + FX_ELEM_TYPE_LAST_DRAWN = 0x8, + }; + + union FxElemVisuals + { + const void* anonymous; + Material* material; + XModel* model; + FxEffectDefRef effectDef; + const char* soundName; + }; + + struct FxElemMarkVisuals + { + Material* materials[2]; + }; + + union FxElemDefVisuals + { + FxElemMarkVisuals* markArray; + FxElemVisuals* array; + FxElemVisuals instance; + }; + + struct FxTrailVertex + { + float pos[2]; + float normal[2]; + float texCoord; + }; + + struct FxTrailDef + { + int scrollTimeMsec; + int repeatDist; + int splitDist; + int vertCount; + FxTrailVertex* verts; + int indCount; + uint16_t* inds; + }; + + struct FxElemDef + { + int flags; + FxSpawnDef spawn; + FxFloatRange spawnRange; + FxFloatRange fadeInRange; + FxFloatRange fadeOutRange; + float spawnFrustumCullRadius; + FxIntRange spawnDelayMsec; + FxIntRange lifeSpanMsec; + FxFloatRange spawnOrigin[3]; + FxFloatRange spawnOffsetRadius; + FxFloatRange spawnOffsetHeight; + FxFloatRange spawnAngles[3]; + FxFloatRange angularVelocity[3]; + FxFloatRange initialRotation; + FxFloatRange gravity; + FxFloatRange reflectionFactor; + FxElemAtlas atlas; + float windInfluence; + char elemType; + char visualCount; + char velIntervalCount; + char visStateIntervalCount; + FxElemVelStateSample* velSamples; + FxElemVisStateSample* visSamples; + FxElemDefVisuals visuals; + float collMins[3]; + float collMaxs[3]; + FxEffectDefRef effectOnImpact; + FxEffectDefRef effectOnDeath; + FxEffectDefRef effectEmitted; + FxFloatRange emitDist; + FxFloatRange emitDistVariance; + FxTrailDef* trailDef; + char sortOrder; + char lightingFrac; + char useItemClip; + char unused[1]; + }; + + struct FxEffectDef + { + const char* name; + int flags; + int totalSize; + int msecLoopingLife; + int elemDefCountLooping; + int elemDefCountOneShot; + int elemDefCountEmission; + char efPriority; + FxElemDef* elemDefs; + }; + + struct FxImpactEntry + { + FxEffectDef* nonflesh[31]; + FxEffectDef* flesh[4]; + }; + + struct FxImpactTable + { + const char* name; + FxImpactEntry* table; + }; + + struct RawFile + { + const char* name; + int len; + const char* buffer; + }; + + struct StringTable + { + const char* name; + int columnCount; + int rowCount; + const char** values; + }; + + struct PackIndexEntry + { + unsigned int hash; + unsigned int offset; + unsigned int size; + }; + + struct PackIndexHeader + { + unsigned int magic; + unsigned int timestamp; + unsigned int count; + unsigned int alignment; + unsigned int data_start; + }; + + struct PackIndex + { + const char* name; + PackIndexHeader header; + PackIndexEntry* entries; + }; + +#ifndef __zonecodegenerator +} +#endif + +#endif + +// EOF diff --git a/src/ModMan/Web/Binds/ZoneBinds.cpp b/src/ModMan/Web/Binds/ZoneBinds.cpp index 31b93b6e..81744136 100644 --- a/src/ModMan/Web/Binds/ZoneBinds.cpp +++ b/src/ModMan/Web/Binds/ZoneBinds.cpp @@ -10,6 +10,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(GameId, {GameId::IW3, "IW3"}, {GameId::IW4, "IW4"}, {GameId::IW5, "IW5"}, + {GameId::T4, "T4" }, {GameId::T5, "T5" }, {GameId::T6, "T6" }, }); diff --git a/src/ModManUi/src/native/ZoneBinds.ts b/src/ModManUi/src/native/ZoneBinds.ts index 1be14aad..19b5693f 100644 --- a/src/ModManUi/src/native/ZoneBinds.ts +++ b/src/ModManUi/src/native/ZoneBinds.ts @@ -2,6 +2,7 @@ export enum GameId { IW3 = "IW3", IW4 = "IW4", IW5 = "IW5", + T4 = "T4", T5 = "T5", T6 = "T6", } diff --git a/src/ObjCompiling/Game/T4/ObjCompilerT4.cpp b/src/ObjCompiling/Game/T4/ObjCompilerT4.cpp new file mode 100644 index 00000000..aaae5282 --- /dev/null +++ b/src/ObjCompiling/Game/T4/ObjCompilerT4.cpp @@ -0,0 +1,39 @@ +#include "ObjCompilerT4.h" + +#include "Game/T4/T4.h" +#include "Image/ImageIwdPostProcessor.h" + +#include + +using namespace T4; + +namespace +{ + void ConfigureCompilers(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath) {} + + void ConfigurePostProcessors(AssetCreatorCollection& collection, + Zone& zone, + const ZoneDefinitionContext& zoneDefinition, + ISearchPath& searchPath, + ZoneAssetCreationStateContainer& zoneStates, + IOutputPath& outDir) + { + auto& memory = zone.Memory(); + + if (image::IwdPostProcessor::AppliesToZoneDefinition(zoneDefinition)) + collection.AddAssetPostProcessor(std::make_unique>(zoneDefinition, searchPath, zoneStates, outDir)); + } +} // namespace + +void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection, + Zone& zone, + const ZoneDefinitionContext& zoneDefinition, + ISearchPath& searchPath, + IGdtQueryable& gdt, + ZoneAssetCreationStateContainer& zoneStates, + IOutputPath& outDir, + IOutputPath& cacheDir) const +{ + ConfigureCompilers(collection, zone, searchPath); + ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, zoneStates, outDir); +} diff --git a/src/ObjCompiling/Game/T4/ObjCompilerT4.h b/src/ObjCompiling/Game/T4/ObjCompilerT4.h new file mode 100644 index 00000000..010f7df7 --- /dev/null +++ b/src/ObjCompiling/Game/T4/ObjCompilerT4.h @@ -0,0 +1,19 @@ +#pragma once + +#include "IObjCompiler.h" + +namespace T4 +{ + class ObjCompiler final : public IObjCompiler + { + public: + void ConfigureCreatorCollection(AssetCreatorCollection& collection, + Zone& zone, + const ZoneDefinitionContext& zoneDefinition, + ISearchPath& searchPath, + IGdtQueryable& gdt, + ZoneAssetCreationStateContainer& zoneStates, + IOutputPath& outDir, + IOutputPath& cacheDir) const override; + }; +} // namespace T4 diff --git a/src/ObjCompiling/IObjCompiler.cpp b/src/ObjCompiling/IObjCompiler.cpp index 702f8865..f3632f46 100644 --- a/src/ObjCompiling/IObjCompiler.cpp +++ b/src/ObjCompiling/IObjCompiler.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/ObjCompilerIW3.h" #include "Game/IW4/ObjCompilerIW4.h" #include "Game/IW5/ObjCompilerIW5.h" +#include "Game/T4/ObjCompilerT4.h" #include "Game/T5/ObjCompilerT5.h" #include "Game/T6/ObjCompilerT6.h" @@ -10,10 +11,11 @@ const IObjCompiler* IObjCompiler::GetObjCompilerForGame(GameId game) { - static const IObjCompiler* objCompilers[static_cast(GameId::COUNT)]{ + static const IObjCompiler* objCompilers[]{ new IW3::ObjCompiler(), new IW4::ObjCompiler(), new IW5::ObjCompiler(), + new T4::ObjCompiler(), new T5::ObjCompiler(), new T6::ObjCompiler(), }; diff --git a/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.cpp b/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.cpp new file mode 100644 index 00000000..dabe0c8d --- /dev/null +++ b/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.cpp @@ -0,0 +1,45 @@ +#include "AssetLoaderLocalizeT4.h" + +#include "Localize/CommonLocalizeLoader.h" + +using namespace T4; + +namespace +{ + class LocalizeLoader final : public AssetCreator, public CommonLocalizeLoader + { + public: + LocalizeLoader(MemoryManager& memory, ISearchPath& searchPath, Zone& zone) + : CommonLocalizeLoader(searchPath, zone), + m_memory(memory) + { + } + + AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override + { + return CreateLocalizeAsset(assetName, context); + } + + protected: + AssetCreationResult CreateAssetFromCommonAsset(const CommonLocalizeEntry& localizeEntry, AssetCreationContext& context) override + + { + auto* asset = m_memory.Alloc(); + asset->name = m_memory.Dup(localizeEntry.m_key.c_str()); + asset->value = m_memory.Dup(localizeEntry.m_value.c_str()); + + return AssetCreationResult::Success(context.AddAsset(localizeEntry.m_key, asset)); + } + + private: + MemoryManager& m_memory; + }; +} // namespace + +namespace localize +{ + std::unique_ptr> CreateLoaderT4(MemoryManager& memory, ISearchPath& searchPath, Zone& zone) + { + return std::make_unique(memory, searchPath, zone); + } +} // namespace localize diff --git a/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.h b/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.h new file mode 100644 index 00000000..b5b18a6c --- /dev/null +++ b/src/ObjLoading/Game/T4/Localize/AssetLoaderLocalizeT4.h @@ -0,0 +1,14 @@ +#pragma once + +#include "Asset/IAssetCreator.h" +#include "Game/T4/T4.h" +#include "SearchPath/ISearchPath.h" +#include "Utils/MemoryManager.h" +#include "Zone/Zone.h" + +#include + +namespace localize +{ + std::unique_ptr> CreateLoaderT4(MemoryManager& memory, ISearchPath& searchPath, Zone& zone); +} // namespace localize diff --git a/src/ObjLoading/Game/T4/ObjLoaderT4.cpp b/src/ObjLoading/Game/T4/ObjLoaderT4.cpp new file mode 100644 index 00000000..5eb38700 --- /dev/null +++ b/src/ObjLoading/Game/T4/ObjLoaderT4.cpp @@ -0,0 +1,97 @@ +#include "ObjLoaderT4.h" + +#include "Asset/GlobalAssetPoolsLoader.h" +#include "Game/T4/AssetMarkerT4.h" +#include "Game/T4/T4.h" +#include "Localize/AssetLoaderLocalizeT4.h" + +using namespace T4; + +void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const {} + +void ObjLoader::UnloadContainersOfZone(Zone& zone) const {} + +namespace +{ + void ConfigureDefaultCreators(AssetCreatorCollection& collection, const Zone& zone) + { + auto& memory = zone.Memory(); + + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + collection.AddDefaultAssetCreator(std::make_unique>(memory)); + } + + void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone) + { + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + collection.AddAssetCreator(std::make_unique>(zone)); + } + + void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt) + { + auto& memory = zone.Memory(); + + collection.AddAssetCreator(localize::CreateLoaderT4(memory, searchPath, zone)); + } +} // namespace + +void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt) const +{ + ConfigureDefaultCreators(collection, zone); + ConfigureLoaders(collection, zone, searchPath, gdt); + ConfigureGlobalAssetPoolsLoaders(collection, zone); +} diff --git a/src/ObjLoading/Game/T4/ObjLoaderT4.h b/src/ObjLoading/Game/T4/ObjLoaderT4.h new file mode 100644 index 00000000..5538a2bd --- /dev/null +++ b/src/ObjLoading/Game/T4/ObjLoaderT4.h @@ -0,0 +1,16 @@ +#pragma once + +#include "IObjLoader.h" +#include "SearchPath/ISearchPath.h" + +namespace T4 +{ + class ObjLoader final : public IObjLoader + { + public: + void LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const override; + void UnloadContainersOfZone(Zone& zone) const override; + + void ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt) const override; + }; +} // namespace T4 diff --git a/src/ObjLoading/IObjLoader.cpp b/src/ObjLoading/IObjLoader.cpp index de841138..334f707b 100644 --- a/src/ObjLoading/IObjLoader.cpp +++ b/src/ObjLoading/IObjLoader.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/ObjLoaderIW3.h" #include "Game/IW4/ObjLoaderIW4.h" #include "Game/IW5/ObjLoaderIW5.h" +#include "Game/T4/ObjLoaderT4.h" #include "Game/T5/ObjLoaderT5.h" #include "Game/T6/ObjLoaderT6.h" @@ -10,10 +11,11 @@ const IObjLoader* IObjLoader::GetObjLoaderForGame(GameId game) { - static const IObjLoader* zoneCreators[static_cast(GameId::COUNT)]{ + static const IObjLoader* zoneCreators[]{ new IW3::ObjLoader(), new IW4::ObjLoader(), new IW5::ObjLoader(), + new T4::ObjLoader(), new T5::ObjLoader(), new T6::ObjLoader(), }; diff --git a/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.cpp b/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.cpp new file mode 100644 index 00000000..32087c18 --- /dev/null +++ b/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.cpp @@ -0,0 +1,44 @@ +#include "LocalizeDumperT4.h" + +#include "Dumping/Localize/StringFileDumper.h" +#include "Localize/LocalizeCommon.h" +#include "Utils/Logging/Log.h" + +#include + +using namespace T4; + +namespace localize +{ + void DumperT4::Dump(AssetDumpingContext& context) + { + auto localizeAssets = context.m_zone.m_pools.PoolAssets(); + if (localizeAssets.empty()) + return; + + const auto language = LocalizeCommon::GetNameOfLanguage(context.m_zone.m_language); + const auto assetFile = context.OpenAssetFile(std::format("{}/localizedstrings/{}.str", language, context.m_zone.m_name)); + + if (assetFile) + { + StringFileDumper stringFileDumper(context.m_zone, *assetFile); + + stringFileDumper.SetLanguageName(language); + stringFileDumper.SetConfigFile(R"(G:\CoD5\cod\cod5\bin\StringEd.cfg)"); + stringFileDumper.SetNotes(""); + + for (const auto* localizeEntry : localizeAssets) + { + stringFileDumper.WriteLocalizeEntry(localizeEntry->m_name, localizeEntry->Asset()->value); + } + + stringFileDumper.Finalize(); + } + else + { + con::error("Could not create string file for dumping localized strings of zone '{}'", context.m_zone.m_name); + } + + context.IncrementProgress(); + } +} // namespace localize diff --git a/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.h b/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.h new file mode 100644 index 00000000..33e3eea6 --- /dev/null +++ b/src/ObjWriting/Game/T4/Localize/LocalizeDumperT4.h @@ -0,0 +1,13 @@ +#pragma once + +#include "Dumping/AbstractAssetDumper.h" +#include "Game/T4/T4.h" + +namespace localize +{ + class DumperT4 final : public AbstractSingleProgressAssetDumper + { + public: + void Dump(AssetDumpingContext& context) override; + }; +} // namespace localize diff --git a/src/ObjWriting/Game/T4/ObjWriterT4.cpp b/src/ObjWriting/Game/T4/ObjWriterT4.cpp new file mode 100644 index 00000000..47ea2d9a --- /dev/null +++ b/src/ObjWriting/Game/T4/ObjWriterT4.cpp @@ -0,0 +1,16 @@ +#include "ObjWriterT4.h" + +#include "Game/T4/Image/ImageDumperT4.h" +#include "Localize/LocalizeDumperT4.h" +#include "RawFile/RawFileDumperT4.h" +#include "StringTable/StringTableDumperT4.h" + +using namespace T4; + +void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context) +{ + RegisterAssetDumper(std::make_unique()); + RegisterAssetDumper(std::make_unique()); + RegisterAssetDumper(std::make_unique()); + RegisterAssetDumper(std::make_unique()); +} diff --git a/src/ObjWriting/Game/T4/ObjWriterT4.h b/src/ObjWriting/Game/T4/ObjWriterT4.h new file mode 100644 index 00000000..a2e123c0 --- /dev/null +++ b/src/ObjWriting/Game/T4/ObjWriterT4.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ObjWriter.h" + +namespace T4 +{ + class ObjWriter final : public IObjWriter + { + protected: + void RegisterAssetDumpers(AssetDumpingContext& context) override; + }; +} // namespace T4 diff --git a/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.cpp b/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.cpp new file mode 100644 index 00000000..55a663fe --- /dev/null +++ b/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.cpp @@ -0,0 +1,18 @@ +#include "RawFileDumperT4.h" + +using namespace T4; + +namespace raw_file +{ + void DumperT4::DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) + { + const auto* rawFile = asset.Asset(); + const auto assetFile = context.OpenAssetFile(asset.m_name); + + if (!assetFile) + return; + + auto& stream = *assetFile; + stream.write(rawFile->buffer, rawFile->len); + } +} // namespace raw_file diff --git a/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.h b/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.h new file mode 100644 index 00000000..ebd5bdef --- /dev/null +++ b/src/ObjWriting/Game/T4/RawFile/RawFileDumperT4.h @@ -0,0 +1,13 @@ +#pragma once + +#include "Dumping/AbstractAssetDumper.h" +#include "Game/T4/T4.h" + +namespace raw_file +{ + class DumperT4 final : public AbstractAssetDumper + { + protected: + void DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) override; + }; +} // namespace raw_file diff --git a/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.cpp b/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.cpp new file mode 100644 index 00000000..98593f52 --- /dev/null +++ b/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.cpp @@ -0,0 +1,29 @@ +#include "StringTableDumperT4.h" + +#include "Csv/CsvStream.h" + +using namespace T4; + +namespace string_table +{ + void DumperT4::DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) + { + const auto* stringTable = asset.Asset(); + const auto assetFile = context.OpenAssetFile(asset.m_name); + + if (!assetFile) + return; + + CsvOutputStream csv(*assetFile); + + for (auto row = 0; row < stringTable->rowCount; row++) + { + for (auto column = 0; column < stringTable->columnCount; column++) + { + csv.WriteColumn(stringTable->values[column + row * stringTable->columnCount]); + } + + csv.NextRow(); + } + } +} // namespace string_table diff --git a/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.h b/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.h new file mode 100644 index 00000000..716cacc7 --- /dev/null +++ b/src/ObjWriting/Game/T4/StringTable/StringTableDumperT4.h @@ -0,0 +1,13 @@ +#pragma once + +#include "Dumping/AbstractAssetDumper.h" +#include "Game/T4/T4.h" + +namespace string_table +{ + class DumperT4 final : public AbstractAssetDumper + { + protected: + void DumpAsset(AssetDumpingContext& context, const XAssetInfo& asset) override; + }; +} // namespace string_table diff --git a/src/ObjWriting/Image/ImageDumper.cpp.template b/src/ObjWriting/Image/ImageDumper.cpp.template index 5fbaf830..27430a1f 100644 --- a/src/ObjWriting/Image/ImageDumper.cpp.template +++ b/src/ObjWriting/Image/ImageDumper.cpp.template @@ -1,4 +1,4 @@ -#options GAME (IW3, IW4, IW5, T5, T6) +#options GAME (IW3, IW4, IW5, T4, T5, T6) #filename "Game/" + GAME + "/Image/ImageDumper" + GAME + ".cpp" @@ -8,6 +8,10 @@ #define FEATURE_IW3 #define DX9 #define IWI6 +#elif GAME == "T4" +#define FEATURE_T4 +#define DX9 +#define IWI6 #elif GAME == "IW4" #define FEATURE_IW4 #define DX9 @@ -80,7 +84,7 @@ namespace #endif const auto& loadDef = *image.texture.loadDef; -#ifdef FEATURE_IW3 +#if defined(FEATURE_IW3) || defined(FEATURE_T4) textureLoader.Width(loadDef.dimensions[0]).Height(loadDef.dimensions[1]).Depth(loadDef.dimensions[2]); #else textureLoader.Width(image.width).Height(image.height).Depth(image.depth); diff --git a/src/ObjWriting/Image/ImageDumper.h.template b/src/ObjWriting/Image/ImageDumper.h.template index 1b8d14a3..9755553c 100644 --- a/src/ObjWriting/Image/ImageDumper.h.template +++ b/src/ObjWriting/Image/ImageDumper.h.template @@ -1,4 +1,4 @@ -#options GAME(IW3, IW4, IW5, T5, T6) +#options GAME(IW3, IW4, IW5, T4, T5, T6) #filename "Game/" + GAME + "/Image/ImageDumper" + GAME + ".h" diff --git a/src/ObjWriting/ObjWriter.cpp b/src/ObjWriting/ObjWriter.cpp index ea3004c5..8059a365 100644 --- a/src/ObjWriting/ObjWriter.cpp +++ b/src/ObjWriting/ObjWriter.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/ObjWriterIW3.h" #include "Game/IW4/ObjWriterIW4.h" #include "Game/IW5/ObjWriterIW5.h" +#include "Game/T4/ObjWriterT4.h" #include "Game/T5/ObjWriterT5.h" #include "Game/T6/ObjWriterT6.h" #include "ObjWriting.h" @@ -40,10 +41,11 @@ void IObjWriter::RegisterAssetDumper(std::unique_ptr dumper) IObjWriter* IObjWriter::GetObjWriterForGame(GameId game) { - static IObjWriter* objWriters[static_cast(GameId::COUNT)]{ + static IObjWriter* objWriters[]{ new IW3::ObjWriter(), new IW4::ObjWriter(), new IW5::ObjWriter(), + new T4::ObjWriter(), new T5::ObjWriter(), new T6::ObjWriter(), }; diff --git a/src/ZoneCode.lua b/src/ZoneCode.lua index 661fe05b..7a45683f 100644 --- a/src/ZoneCode.lua +++ b/src/ZoneCode.lua @@ -110,6 +110,37 @@ ZoneCode.Assets = { "AddonMapEnts", }, + T4 = { + "PhysPreset", + "PhysConstraints", + "DestructibleDef", + "XAnimParts", + "XModel", + "Material", + "MaterialTechniqueSet", + "GfxImage", + "snd_alias_list_t", + "SndDriverGlobals", + "LoadedSound", + "clipMap_t", + "ComWorld", + "GameWorldSp", + "GameWorldMp", + "MapEnts", + "GfxWorld", + "GfxLightDef", + "Font_s", + "MenuList", + "menuDef_t", + "LocalizeEntry", + "WeaponDef", + "FxEffectDef", + "FxImpactTable", + "RawFile", + "StringTable", + "PackIndex", + }, + T5 = { "PhysPreset", "PhysConstraints", diff --git a/src/ZoneCode/Game/T4/T4.gen b/src/ZoneCode/Game/T4/T4.gen new file mode 100644 index 00000000..7bd8cb1e --- /dev/null +++ b/src/ZoneCode/Game/T4/T4.gen @@ -0,0 +1 @@ +# This file exists for automatically generating zone loading code. \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/T4_Commands.txt b/src/ZoneCode/Game/T4/T4_Commands.txt new file mode 100644 index 00000000..e6d2317b --- /dev/null +++ b/src/ZoneCode/Game/T4/T4_Commands.txt @@ -0,0 +1,71 @@ +// Game: World at War (T4) +game T4; +wordsize 32; + +// Game Assets +asset PhysPreset AssetPhysPreset; +asset PhysConstraints AssetPhysConstraints; +asset DestructibleDef AssetDestructibleDef; +asset XAnimParts AssetXAnim; +asset XModel AssetXModel; +asset Material AssetMaterial; +asset MaterialTechniqueSet AssetTechniqueSet; +asset GfxImage AssetImage; +asset snd_alias_list_t AssetSound; +asset SndDriverGlobals AssetSoundDriverGlobals; +asset LoadedSound AssetLoadedSound; +asset clipMap_t AssetClipMapPvs; +asset ComWorld AssetComWorld; +asset GameWorldSp AssetGameWorldSp; +asset GameWorldMp AssetGameWorldMp; +asset MapEnts AssetMapEnts; +asset GfxWorld AssetGfxWorld; +asset GfxLightDef AssetLightDef; +asset Font_s AssetFont; +asset MenuList AssetMenuList; +asset menuDef_t AssetMenu; +asset LocalizeEntry AssetLocalize; +asset WeaponDef AssetWeapon; +asset FxEffectDef AssetFx; +asset FxImpactTable AssetImpactFx; +asset RawFile AssetRawFile; +asset StringTable AssetStringTable; +asset PackIndex AssetPackIndex; + +// Setup blocks +block temp XFILE_BLOCK_TEMP default; +block runtime XFILE_BLOCK_RUNTIME default; +block runtime XFILE_BLOCK_LARGE_RUNTIME; +block runtime XFILE_BLOCK_PHYSICAL_RUNTIME; +block normal XFILE_BLOCK_VIRTUAL default; +block normal XFILE_BLOCK_LARGE; +block normal XFILE_BLOCK_PHYSICAL; + +#include "XAssets/PhysPreset.txt" +#include "XAssets/PhysConstraints.txt" +#include "XAssets/DestructibleDef.txt" +#include "XAssets/XAnimParts.txt" +#include "XAssets/XModel.txt" +#include "XAssets/Material.txt" +#include "XAssets/MaterialTechniqueSet.txt" +#include "XAssets/GfxImage.txt" +#include "XAssets/snd_alias_list_t.txt" +#include "XAssets/SndDriverGlobals.txt" +#include "XAssets/LoadedSound.txt" +#include "XAssets/clipMap_t.txt" +#include "XAssets/ComWorld.txt" +#include "XAssets/GameWorldSp.txt" +#include "XAssets/GameWorldMp.txt" +#include "XAssets/MapEnts.txt" +#include "XAssets/GfxWorld.txt" +#include "XAssets/FxEffectDef.txt" +#include "XAssets/LocalizeEntry.txt" +#include "XAssets/WeaponDef.txt" +#include "XAssets/MenuList.txt" +#include "XAssets/menuDef_t.txt" +#include "XAssets/FxImpactTable.txt" +#include "XAssets/GfxLightDef.txt" +#include "XAssets/Font_s.txt" +#include "XAssets/RawFile.txt" +#include "XAssets/StringTable.txt" +#include "XAssets/PackIndex.txt" diff --git a/src/ZoneCode/Game/T4/T4_ZoneCode.h b/src/ZoneCode/Game/T4/T4_ZoneCode.h new file mode 100644 index 00000000..3a5393ac --- /dev/null +++ b/src/ZoneCode/Game/T4/T4_ZoneCode.h @@ -0,0 +1,12 @@ +#pragma once + +// Entry point for T4 code generation + +// clang-format off: Order of includes matters here + +#include "../Common.h" +#include "../../../Common/Game/T4/T4_Assets.h" + +// clang-format on + +// EOF diff --git a/src/ZoneCode/Game/T4/XAssets/ComWorld.txt b/src/ZoneCode/Game/T4/XAssets/ComWorld.txt new file mode 100644 index 00000000..85d38882 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/ComWorld.txt @@ -0,0 +1,18 @@ +// ========================================= +// ComWorld +// ========================================= +use ComWorld; +set block XFILE_BLOCK_TEMP; +set string name; +set count primaryLights primaryLightCount; +set allocalign waterCells 4; +set count waterCells numWaterCells; +set count burnableCells numBurnableCells; + +// ComPrimaryLight +use ComPrimaryLight; +set string defName; + +// ComBurnableCell +use ComBurnableCell; +set count data 32; diff --git a/src/ZoneCode/Game/T4/XAssets/DestructibleDef.txt b/src/ZoneCode/Game/T4/XAssets/DestructibleDef.txt new file mode 100644 index 00000000..7efa8246 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/DestructibleDef.txt @@ -0,0 +1,27 @@ +// ========================================= +// DestructibleDef +// ========================================= +use DestructibleDef; +set block XFILE_BLOCK_TEMP; +set string name; +set count pieces numPieces; + +// DestructiblePiece +use DestructiblePiece; +set string attachBone; +set scriptstring attachBoneHash; +set scriptstring enableLabel; + +// DestructibleModel +use DestructibleModel; +set string breakNotify; +set string loopSound; + +// SndAliasCustom +use SndAliasCustom; +set count name 1; +set reusable name; +set condition sound never; + +// snd_alias_list_name +set string snd_alias_list_name::soundName; diff --git a/src/ZoneCode/Game/T4/XAssets/Font_s.txt b/src/ZoneCode/Game/T4/XAssets/Font_s.txt new file mode 100644 index 00000000..dcc89931 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/Font_s.txt @@ -0,0 +1,8 @@ +// ========================================= +// Font_s +// ========================================= +use Font_s; +set block XFILE_BLOCK_TEMP; +set string fontName; +set reusable glyphs; +set count glyphs glyphCount; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/FxEffectDef.txt b/src/ZoneCode/Game/T4/XAssets/FxEffectDef.txt new file mode 100644 index 00000000..a67beac5 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/FxEffectDef.txt @@ -0,0 +1,44 @@ +// ========================================= +// FxEffectDef +// ========================================= +use FxEffectDef; +set block XFILE_BLOCK_TEMP; +set string name; +set count elemDefs elemDefCountEmission + elemDefCountLooping + elemDefCountOneShot; + +// FxElemDef +use FxElemDef; +set count velSamples velIntervalCount + 1; +set count visSamples visStateIntervalCount + 1; + +// FxElemDefVisuals +use FxElemDefVisuals; +set condition markArray FxElemDef::elemType == FX_ELEM_TYPE_DECAL; +set count markArray FxElemDef::visualCount; +set condition array FxElemDef::visualCount > 1; +set count array FxElemDef::visualCount; + +// FxElemVisuals +use FxElemVisuals; +set condition anonymous never; +set condition model FxElemDef::elemType == FX_ELEM_TYPE_MODEL; +set condition effectDef FxElemDef::elemType == FX_ELEM_TYPE_RUNNER; +set condition soundName FxElemDef::elemType == FX_ELEM_TYPE_SOUND; +set string soundName; +set condition material FxElemDef::elemType == FX_ELEM_TYPE_SPRITE_BILLBOARD +|| FxElemDef::elemType == FX_ELEM_TYPE_SPRITE_ORIENTED +|| FxElemDef::elemType == FX_ELEM_TYPE_TAIL +|| FxElemDef::elemType == FX_ELEM_TYPE_TRAIL +|| FxElemDef::elemType == FX_ELEM_TYPE_CLOUD +|| FxElemDef::elemType == FX_ELEM_TYPE_SPARK_CLOUD; + +// FxEffectDefRef +use FxEffectDefRef; +set condition handle never; +set string name; +set assetref name AssetFx; + +// FxTrailDef +use FxTrailDef; +set count verts vertCount; +set count inds indCount; diff --git a/src/ZoneCode/Game/T4/XAssets/FxImpactTable.txt b/src/ZoneCode/Game/T4/XAssets/FxImpactTable.txt new file mode 100644 index 00000000..8c48a85a --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/FxImpactTable.txt @@ -0,0 +1,7 @@ +// ========================================= +// FxImpactTable +// ========================================= +use FxImpactTable; +set block XFILE_BLOCK_TEMP; +set string name; +set count table 16; diff --git a/src/ZoneCode/Game/T4/XAssets/GameWorldMp.txt b/src/ZoneCode/Game/T4/XAssets/GameWorldMp.txt new file mode 100644 index 00000000..f93945f3 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/GameWorldMp.txt @@ -0,0 +1,6 @@ +// ========================================= +// GameWorldMp +// ========================================= +use GameWorldMp; +set block XFILE_BLOCK_TEMP; +set string name; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/GameWorldSp.txt b/src/ZoneCode/Game/T4/XAssets/GameWorldSp.txt new file mode 100644 index 00000000..e073093b --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/GameWorldSp.txt @@ -0,0 +1,39 @@ +// ========================================= +// GameWorldSp +// ========================================= +use GameWorldSp; +set block XFILE_BLOCK_TEMP; +set string name; + +// PathData +use PathData; +set count nodes nodeCount; +set block basenodes XFILE_BLOCK_RUNTIME; +set count basenodes nodeCount; +set count chainNodeForNode nodeCount; +set count nodeForChainNode nodeCount; +set count pathVis visBytes; +set count nodeTree nodeTreeCount; + +// pathnode_t +set condition pathnode_t::transient never; + +// pathnode_constant_t +use pathnode_constant_t; +set scriptstring targetname; +set scriptstring script_linkName; +set scriptstring script_noteworthy; +set scriptstring target; +set scriptstring animscript; +set count Links totalLinkCount; + +// pathnode_dynamic_t +set condition pathnode_dynamic_t::pOwner never; + +// pathnode_tree_t +use pathnode_tree_t; +set condition u::child axis >= 0; +set reusable u::child; + +// pathnode_tree_nodes_t +set count pathnode_tree_nodes_t::nodes nodeCount; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/GfxImage.txt b/src/ZoneCode/Game/T4/XAssets/GfxImage.txt new file mode 100644 index 00000000..f7fc37a0 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/GfxImage.txt @@ -0,0 +1,20 @@ +// ========================================= +// GfxImage +// ========================================= +use GfxImage; +set block XFILE_BLOCK_TEMP; +set action OnImageLoaded(GfxImage); +set string name; +reorder: + name + texture; + +// GfxTexture +use GfxTexture; +set reusable loadDef; +set block loadDef XFILE_BLOCK_TEMP; + +// GfxImageLoadDef +use GfxImageLoadDef; +set action LoadImageData(GfxImageLoadDef, GfxImage); +set arraysize data resourceSize; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/GfxLightDef.txt b/src/ZoneCode/Game/T4/XAssets/GfxLightDef.txt new file mode 100644 index 00000000..4a2ea7c6 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/GfxLightDef.txt @@ -0,0 +1,6 @@ +// ========================================= +// GfxLightDef +// ========================================= +use GfxLightDef; +set block XFILE_BLOCK_TEMP; +set string name; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/GfxWorld.txt b/src/ZoneCode/Game/T4/XAssets/GfxWorld.txt new file mode 100644 index 00000000..779f5754 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/GfxWorld.txt @@ -0,0 +1,138 @@ +// ========================================= +// GfxWorld +// ========================================= +use GfxWorld; +set block XFILE_BLOCK_TEMP; +set string name; +set string baseName; +set count indices indexCount; +set count skyStartSurfs skySurfCount; +set string skyBoxModel; +set reusable sunLight; +set count reflectionProbes reflectionProbeCount; +set block reflectionProbeTextures XFILE_BLOCK_RUNTIME; +set count reflectionProbeTextures reflectionProbeCount; +set count coronas coronaCount; +set count cells dpvsPlanes::cellCount; +set count lightmaps lightmapCount; +set block lightmapPrimaryTextures XFILE_BLOCK_RUNTIME; +set count lightmapPrimaryTextures lightmapCount; +set block lightmapSecondaryTextures XFILE_BLOCK_RUNTIME; +set count lightmapSecondaryTextures lightmapCount; +set count models modelCount; +set count materialMemory materialMemoryCount; +set block cellCasterBits XFILE_BLOCK_RUNTIME; +set count cellCasterBits dpvsPlanes::cellCount * ((dpvsPlanes::cellCount + 31) / 32); +set block sceneDynModel XFILE_BLOCK_RUNTIME; +set count sceneDynModel dpvsDyn::dynEntClientCount[0]; +set block sceneDynBrush XFILE_BLOCK_RUNTIME; +set count sceneDynBrush dpvsDyn::dynEntClientCount[1]; +set block primaryLightEntityShadowVis XFILE_BLOCK_RUNTIME; +set count primaryLightEntityShadowVis (primaryLightCount - sunPrimaryLightIndex - 1) * 0x2000; +set block primaryLightDynEntShadowVis XFILE_BLOCK_RUNTIME; +set count primaryLightDynEntShadowVis[0] dpvsDyn::dynEntClientCount[0] * (primaryLightCount - sunPrimaryLightIndex - 1); +set count primaryLightDynEntShadowVis[1] dpvsDyn::dynEntClientCount[1] * (primaryLightCount - sunPrimaryLightIndex - 1); +set block nonSunPrimaryLightForModelDynEnt XFILE_BLOCK_RUNTIME; +set count nonSunPrimaryLightForModelDynEnt dpvsDyn::dynEntClientCount[0]; +set count shadowGeom primaryLightCount; +set count lightRegion primaryLightCount; +set count worldLodChains worldLodChainCount; +set count worldLodInfos worldLodInfoCount; +set count worldLodSurfaces worldLodSurfaceCount; +reorder: + ... + materialMemory + vd + vld; + +// GfxWorldDpvsPlanes +use GfxWorldDpvsPlanes; +set reusable planes; +set count planes GfxWorld::planeCount; +set count nodes GfxWorld::nodeCount; +set block sceneEntCellBits XFILE_BLOCK_RUNTIME; +set count sceneEntCellBits cellCount * 0x100; + +// GfxCell +use GfxCell; +set count aabbTree aabbTreeCount; +set count portals portalCount; +set count cullGroups cullGroupCount; +set count reflectionProbes reflectionProbeCount; + +// GfxAabbTree +use GfxAabbTree; +set reusable smodelIndexes; +set count smodelIndexes smodelIndexCount; + +// GfxPortal +use GfxPortal; +set condition writable never; +set reusable cell; +set count vertices vertexCount; + +// GfxLightGrid +use GfxLightGrid; +set count rowDataStart maxs[rowAxis] - mins[rowAxis] + 1; +set count rawRowData rawRowDataSize; +set count entries entryCount; +set count colors colorCount; + +// GfxWorldVertexData +use GfxWorldVertexData; +set count vertices GfxWorld::vertexCount; +set condition worldVb never; + +// GfxWorldVertexLayerData +use GfxWorldVertexLayerData; +set count data GfxWorld::vertexLayerDataSize; +set condition layerVb never; + +// GfxShadowGeometry +use GfxShadowGeometry; +set count sortedSurfIndex surfaceCount; +set count smodelIndex smodelCount; + +// GfxLightRegion +use GfxLightRegion; +set count hulls hullCount; + +// GfxLightRegionHull +use GfxLightRegionHull; +set count axis axisCount; + +// GfxWorldDpvsStatic +use GfxWorldDpvsStatic; +set block smodelVisData XFILE_BLOCK_RUNTIME; +set count smodelVisData smodelCount; +set block surfaceVisData XFILE_BLOCK_RUNTIME; +set count surfaceVisData staticSurfaceCount; +set block lodData XFILE_BLOCK_RUNTIME; +set count lodData 2 * smodelVisDataCount; +set count sortedSurfIndex staticSurfaceCount; +set count smodelInsts smodelCount; +set count surfaces GfxWorld::surfaceCount; +set count cullGroups GfxWorld::cullGroupCount; +set count smodelDrawInsts smodelCount; +set block surfaceMaterials XFILE_BLOCK_RUNTIME; +set count surfaceMaterials staticSurfaceCount; +set allocalign surfaceMaterials 4; +set block surfaceCastsSunShadow XFILE_BLOCK_RUNTIME; +set count surfaceCastsSunShadow surfaceVisDataCount; + +// GfxWorldDpvsDynamic +use GfxWorldDpvsDynamic; +set block dynEntCellBits XFILE_BLOCK_RUNTIME; +set count dynEntCellBits[0] dynEntClientWordCount[0] * GfxWorld::dpvsPlanes::cellCount; +set count dynEntCellBits[1] dynEntClientWordCount[1] * GfxWorld::dpvsPlanes::cellCount; +set block dynEntVisData XFILE_BLOCK_RUNTIME; +set count dynEntVisData[0][0] 32 * dynEntClientWordCount[0]; +set count dynEntVisData[1][0] 32 * dynEntClientWordCount[1]; +set count dynEntVisData[0][1] 32 * dynEntClientWordCount[0]; +set count dynEntVisData[1][1] 32 * dynEntClientWordCount[1]; +set count dynEntVisData[0][2] 32 * dynEntClientWordCount[0]; +set count dynEntVisData[1][2] 32 * dynEntClientWordCount[1]; + +// GfxWaterBuffer +use GfxWaterBuffer; +set count buffer bufferSize / 16; diff --git a/src/ZoneCode/Game/T4/XAssets/LoadedSound.txt b/src/ZoneCode/Game/T4/XAssets/LoadedSound.txt new file mode 100644 index 00000000..e9cb10cc --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/LoadedSound.txt @@ -0,0 +1,10 @@ +// ========================================= +// LoadedSound +// ========================================= +use LoadedSound; +set block XFILE_BLOCK_TEMP; +set string name; + +// snd_asset +use snd_asset; +set count data data_size; diff --git a/src/ZoneCode/Game/T4/XAssets/LocalizeEntry.txt b/src/ZoneCode/Game/T4/XAssets/LocalizeEntry.txt new file mode 100644 index 00000000..6b3d560e --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/LocalizeEntry.txt @@ -0,0 +1,7 @@ +// ========================================= +// LocalizeEntry +// ========================================= +use LocalizeEntry; +set block XFILE_BLOCK_TEMP; +set string name; +set string value; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/MapEnts.txt b/src/ZoneCode/Game/T4/XAssets/MapEnts.txt new file mode 100644 index 00000000..f5c82f08 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/MapEnts.txt @@ -0,0 +1,7 @@ +// ========================================= +// MapEnts +// ========================================= +use MapEnts; +set block XFILE_BLOCK_TEMP; +set string name; +set count entityString numEntityChars; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/Material.txt b/src/ZoneCode/Game/T4/XAssets/Material.txt new file mode 100644 index 00000000..66200379 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/Material.txt @@ -0,0 +1,23 @@ +// ========================================= +// Material +// ========================================= +use Material; +set block XFILE_BLOCK_TEMP; +set allocalign Material 4; +set string info::name; +set reusable textureTable; +set count textureTable textureCount; +set reusable constantTable; +set count constantTable constantCount; +set reusable stateBitsTable; +set count stateBitsTable stateBitsCount; + +// MaterialTextureDef +use MaterialTextureDef; +set condition u::water semantic == TS_WATER_MAP; +set reusable u::water; + +// water_t +use water_t; +set count H0 N * M; +set count wTerm N * M; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/MaterialTechniqueSet.txt b/src/ZoneCode/Game/T4/XAssets/MaterialTechniqueSet.txt new file mode 100644 index 00000000..50fda5da --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/MaterialTechniqueSet.txt @@ -0,0 +1,55 @@ +// ========================================= +// MaterialTechniqueSet +// ========================================= +use MaterialTechniqueSet; +set block XFILE_BLOCK_TEMP; +set string name; +set condition remappedTechniqueSet never; +set reusable techniques; + +// MaterialTechnique +use MaterialTechnique; +set string name; +set arraysize passArray passCount; +reorder: + passArray + name; + +// MaterialPass +use MaterialPass; +set count args perPrimArgCount + perObjArgCount + stableArgCount; +set reusable vertexDecl; +set reusable vertexShader; +set reusable pixelShader; + +// MaterialShaderArgument +use MaterialShaderArgument; +set condition u::literalConst type == MTL_ARG_LITERAL_VERTEX_CONST +|| type == MTL_ARG_LITERAL_PIXEL_CONST; +set reusable u::literalConst; +set condition u::codeConst type == MTL_ARG_CODE_VERTEX_CONST +|| type == MTL_ARG_CODE_PIXEL_CONST; +set condition u::codeSampler type == MTL_ARG_CODE_PIXEL_SAMPLER; +set condition u::nameHash type == MTL_ARG_MATERIAL_VERTEX_CONST +|| type == MTL_ARG_MATERIAL_PIXEL_CONST || type == MTL_ARG_MATERIAL_PIXEL_SAMPLER; + +// MaterialPixelShader +set string MaterialPixelShader::name; + +// GfxPixelShaderLoadDef +set count GfxPixelShaderLoadDef::program programSize; + +// MaterialPixelShaderProgram +set condition MaterialPixelShaderProgram::ps never; + +// MaterialVertexStreamRouting +set condition MaterialVertexStreamRouting::decl never; + +// MaterialVertexShader +set string MaterialVertexShader::name; + +// GfxVertexShaderLoadDef +set count GfxVertexShaderLoadDef::program programSize; + +// MaterialVertexShaderProgram +set condition MaterialVertexShaderProgram::vs never; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/MenuList.txt b/src/ZoneCode/Game/T4/XAssets/MenuList.txt new file mode 100644 index 00000000..640e6160 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/MenuList.txt @@ -0,0 +1,7 @@ +// ========================================= +// MenuList +// ========================================= +use MenuList; +set block XFILE_BLOCK_TEMP; +set string name; +set count menus menuCount; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/PackIndex.txt b/src/ZoneCode/Game/T4/XAssets/PackIndex.txt new file mode 100644 index 00000000..a710c389 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/PackIndex.txt @@ -0,0 +1,7 @@ +// ========================================= +// PackIndex +// ========================================= +use PackIndex; +set block XFILE_BLOCK_TEMP; +set string name; +set count entries header::count; diff --git a/src/ZoneCode/Game/T4/XAssets/PhysConstraints.txt b/src/ZoneCode/Game/T4/XAssets/PhysConstraints.txt new file mode 100644 index 00000000..a4375453 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/PhysConstraints.txt @@ -0,0 +1,13 @@ +// ========================================= +// PhysConstraints +// ========================================= +use PhysConstraints; +set block XFILE_BLOCK_TEMP; +set string name; + +use PhysConstraint; +set scriptstring targetname; +set scriptstring target_ent1; +set string target_bone1; +set scriptstring target_ent2; +set string target_bone2; diff --git a/src/ZoneCode/Game/T4/XAssets/PhysPreset.txt b/src/ZoneCode/Game/T4/XAssets/PhysPreset.txt new file mode 100644 index 00000000..511d1189 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/PhysPreset.txt @@ -0,0 +1,7 @@ +// ========================================= +// PhysPreset +// ========================================= +use PhysPreset; +set block XFILE_BLOCK_TEMP; +set string name; +set string sndAliasPrefix; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/RawFile.txt b/src/ZoneCode/Game/T4/XAssets/RawFile.txt new file mode 100644 index 00000000..befbf1ec --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/RawFile.txt @@ -0,0 +1,7 @@ +// ========================================= +// RawFile +// ========================================= +use RawFile; +set block XFILE_BLOCK_TEMP; +set string name; +set count buffer len + 1; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/SndDriverGlobals.txt b/src/ZoneCode/Game/T4/XAssets/SndDriverGlobals.txt new file mode 100644 index 00000000..0050ebd7 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/SndDriverGlobals.txt @@ -0,0 +1,6 @@ +// ========================================= +// SndDriverGlobals +// ========================================= +use SndDriverGlobals; +set block XFILE_BLOCK_TEMP; +set string name; diff --git a/src/ZoneCode/Game/T4/XAssets/StringTable.txt b/src/ZoneCode/Game/T4/XAssets/StringTable.txt new file mode 100644 index 00000000..99f21013 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/StringTable.txt @@ -0,0 +1,8 @@ +// ========================================= +// StringTable +// ========================================= +use StringTable; +// String table is not in the temp block for some reason. nice. +set string name; +set string values; +set count values columnCount * rowCount; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/WeaponDef.txt b/src/ZoneCode/Game/T4/XAssets/WeaponDef.txt new file mode 100644 index 00000000..fc8f1b12 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/WeaponDef.txt @@ -0,0 +1,64 @@ +// ========================================= +// WeaponDef +// ========================================= +use WeaponDef; +set block XFILE_BLOCK_TEMP; +set string szInternalName; +set string szDisplayName; +set string szOverlayName; +set string szXAnims; +set assetref szXAnims AssetXAnim; +set string szModeName; +set scriptstring hideTags; +set scriptstring notetrackSoundMapKeys; +set scriptstring notetrackSoundMapValues; +set reusable bounceSound; +set count bounceSound 31; +set string standMountedWeapdef; +set string crouchMountedWeapdef; +set string proneMountedWeapdef; +set string szAmmoName; +set string szClipName; +set string szSharedAmmoCapName; +set string szAltWeaponName; +set string aiVsAiAccuracyGraphName; +set string aiVsPlayerAccuracyGraphName; +set reusable aiVsAiAccuracyGraphKnots; +set count aiVsAiAccuracyGraphKnots aiVsAiAccuracyGraphKnotCount; +set reusable aiVsPlayerAccuracyGraphKnots; +set count aiVsPlayerAccuracyGraphKnots aiVsPlayerAccuracyGraphKnotCount; +set reusable originalAiVsAiAccuracyGraphKnots; +set count originalAiVsAiAccuracyGraphKnots aiVsAiAccuracyGraphKnotCount; // yeah it does not use original count +set reusable originalAiVsPlayerAccuracyGraphKnots; +set count originalAiVsPlayerAccuracyGraphKnots aiVsPlayerAccuracyGraphKnotCount; // yeah it does not use original count +set string szUseHintString; +set string dropHintString; +set string szScript; +set string fireRumble; +set string meleeImpactRumble; +set string flameTableFirstPerson; +set string flameTableThirdPerson; +set reusable flameTableFirstPersonPtr; +set reusable flameTableThirdPersonPtr; + +reorder: +... +aiVsAiAccuracyGraphName +aiVsAiAccuracyGraphKnots +originalAiVsAiAccuracyGraphKnots +aiVsPlayerAccuracyGraphName +aiVsPlayerAccuracyGraphKnots +originalAiVsPlayerAccuracyGraphKnots; + +// SndAliasCustom +use SndAliasCustom; +set count name 1; +set reusable name; +set condition sound never; + +// snd_alias_list_name +set string snd_alias_list_name::soundName; + +// flameTable +use flameTable; +set string name; diff --git a/src/ZoneCode/Game/T4/XAssets/XAnimParts.txt b/src/ZoneCode/Game/T4/XAssets/XAnimParts.txt new file mode 100644 index 00000000..52c89d2f --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/XAnimParts.txt @@ -0,0 +1,68 @@ +// ========================================= +// XAnimParts +// ========================================= +use XAnimParts; +set block XFILE_BLOCK_TEMP; +set string name; +set scriptstring names; +set count names boneCount[9]; +set count notify notifyCount; +set count deltaPart 1; +set count dataByte dataByteCount; +set count dataShort dataShortCount; +set count dataInt dataIntCount; +set count randomDataShort randomDataShortCount; +set count randomDataByte randomDataByteCount; +set count randomDataInt randomDataIntCount; +set count indices::_1 indexCount; +set count indices::_2 indexCount; +set condition indices::_1 numframes < 256; +set condition indices::data never; +reorder: + name + names + notify + deltaPart + dataByte + dataShort + dataInt + randomDataShort + randomDataByte + randomDataInt + indices; + +// XAnimNotifyInfo +set scriptstring XAnimNotifyInfo::name; + +// XAnimDeltaPart +use XAnimDeltaPart; +set count trans 1; +set count quat 1; + +// XAnimPartTrans +use XAnimPartTrans; +set condition u::frames size > 0; +set condition u::frames::indices::_1 XAnimParts::numframes < 256; +set arraysize u::frames::indices::_1 size + 1; +set arraysize u::frames::indices::_2 size + 1; +set condition u::frames::frames::_1 smallTrans; +set count u::frames::frames::_1 size + 1; +set count u::frames::frames::_2 size + 1; + +// XAnimPartTransFrames +reorder XAnimPartTransFrames: + indices + frames; + +// XAnimDeltaPartQuat +use XAnimDeltaPartQuat; +set condition u::frames size > 0; +set condition u::frames::indices::_1 XAnimParts::numframes < 256; +set arraysize u::frames::indices::_1 size + 1; +set arraysize u::frames::indices::_2 size + 1; +set count u::frames::frames size + 1; + +// XAnimDeltaPartQuatDataFrames +reorder XAnimDeltaPartQuatDataFrames: + indices + frames; \ No newline at end of file diff --git a/src/ZoneCode/Game/T4/XAssets/XModel.txt b/src/ZoneCode/Game/T4/XAssets/XModel.txt new file mode 100644 index 00000000..114b1ee7 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/XModel.txt @@ -0,0 +1,88 @@ +// ========================================= +// XModel +// ========================================= +use XModel; +set block XFILE_BLOCK_TEMP; +set string name; +set scriptstring boneNames; +set reusable boneNames; +set count boneNames numBones; +set reusable parentList; +set count parentList numBones - numRootBones; +set reusable quats; +set count quats numBones - numRootBones; +set reusable trans; +// This is actually the count but it looks like a bug? It is used like a vec3, but it takes as much memory as vec4 +set count trans (numBones - numRootBones) * 4; +set reusable partClassification; +set count partClassification numBones; +set reusable baseMat; +set count baseMat numBones; +set count surfs numsurfs; +set count materialHandles numsurfs; +set count collSurfs numCollSurfs; +set count boneInfo numBones; +set reusable physGeoms; +set count physGeoms 1; +set reusable collmap; +set count collmap 1; + +// PhysGeomList +use PhysGeomList; +set reusable geoms; +set count geoms count; + +// PhysGeomInfo +set reusable PhysGeomInfo::brush; +set allocalign PhysGeomInfo::brush 4; + +// BrushWrapper +use BrushWrapper; +set count sides numsides; +set count baseAdjacentSide totalEdgeCount; +set reusable verts; +set count verts numverts; +set reusable planes; +set count planes numsides; + +// cbrushside_t +set reusable cbrushside_t::plane; + +// XSurface +use XSurface; +set reusable verts0; +set block verts0 XFILE_BLOCK_VIRTUAL; +set count verts0 vertCount; +set condition vb0 never; +set reusable vertList; +set count vertList vertListCount; +set reusable triIndices; +set block triIndices XFILE_BLOCK_VIRTUAL; +set allocalign triIndices 16; +set count triIndices triCount; +set condition indexBuffer never; +reorder: + zoneHandle + vertInfo + verts0 + vertList + triIndices; + +// XSurfaceVertexInfo +use XSurfaceVertexInfo; +set reusable vertsBlend; +set count vertsBlend vertCount[0] + + 3 * vertCount[1] + + 5 * vertCount[2] + + 7 * vertCount[3]; + +// XRigidVertList +set reusable XRigidVertList::collisionTree; + +// XSurfaceCollisionTree +use XSurfaceCollisionTree; +set count nodes nodeCount; +set count leafs leafCount; + +// XModelCollSurf_s +set count XModelCollSurf_s::collTris numCollTris; diff --git a/src/ZoneCode/Game/T4/XAssets/clipMap_t.txt b/src/ZoneCode/Game/T4/XAssets/clipMap_t.txt new file mode 100644 index 00000000..2da9294b --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/clipMap_t.txt @@ -0,0 +1,85 @@ +// ========================================= +// clipMap_t +// ========================================= +use clipMap_t; +set block XFILE_BLOCK_TEMP; +set string name; +set reusable planes; +set count planes planeCount; +set count staticModelList numStaticModels; +set count materials numMaterials; +set count brushsides numBrushSides; +set count brushEdges numBrushEdges; +set count nodes numNodes; +set count leafs numLeafs; +set count leafbrushNodes leafbrushNodesCount; +set count leafbrushes numLeafBrushes; +set count leafsurfaces numLeafSurfaces; +set count verts vertCount; +set count brushVerts numBrushVerts; +set count uinds nuinds; +set count triIndices 3 * triCount; +set count triEdgeIsWalkable ((3 * triCount + 31) / 32) * 4; +set count borders borderCount; +set count partitions partitionCount; +set allocalign aabbTrees 16; +set count aabbTrees aabbTreeCount; +set count cmodels numSubModels; +set count brushes numBrushes; +set count visibility numClusters * clusterBytes; +set reusable box_brush; +set count dynEntDefList[0] dynEntCount[0]; +set count dynEntDefList[1] dynEntCount[1]; +set block dynEntPoseList XFILE_BLOCK_RUNTIME; +set count dynEntPoseList[0] dynEntCount[0]; +set count dynEntPoseList[1] dynEntCount[1]; +set block dynEntClientList XFILE_BLOCK_RUNTIME; +set count dynEntClientList[0] dynEntCount[0]; +set count dynEntClientList[1] dynEntCount[1]; +set block dynEntServerList XFILE_BLOCK_RUNTIME; +set count dynEntServerList[0] dynEntCount[2]; +set count dynEntServerList[1] dynEntCount[3]; +set block dynEntCollList XFILE_BLOCK_RUNTIME; +set count dynEntCollList[0] dynEntCount[0]; +set count dynEntCollList[1] dynEntCount[1]; +set count dynEntCollList[2] dynEntCount[2]; +set count dynEntCollList[3] dynEntCount[3]; +set count constraints num_constraints; +reorder: + ... + leafs + leafbrushes + leafbrushNodes + leafsurfaces; + +// cbrushside_t +set reusable cbrushside_t::plane; + +// cNode_t +set reusable cNode_t::plane; + +// cLeafBrushNode_s +use cLeafBrushNode_s; +set condition data::leaf leafBrushCount > 0; +set reusable data::leaf::brushes; +set count data::leaf::brushes leafBrushCount; + +// CollisionPartition +use CollisionPartition; +set reusable borders; + +// cbrush_t +use cbrush_t; +set reusable sides; +set reusable baseAdjacentSide; +set reusable verts; + +// DynEntityDef +use DynEntityDef; +set reusable destroyPieces; +set scriptstring targetname; + +// XModelPieces +use XModelPieces; +set string name; +set count pieces numpieces; diff --git a/src/ZoneCode/Game/T4/XAssets/menuDef_t.txt b/src/ZoneCode/Game/T4/XAssets/menuDef_t.txt new file mode 100644 index 00000000..38198715 --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/menuDef_t.txt @@ -0,0 +1,80 @@ +// ========================================= +// menuDef_t +// ========================================= +use menuDef_t; +set block XFILE_BLOCK_TEMP; +set string window::name; +set string font; +set string onOpen; +set string onFocus; +set string onClose; +set string onESC; +set reusable visibleExp; +set string allowedBinding; +set string soundName; +set reusable rectXExp; +set reusable rectYExp; +set count items itemCount; + +// windowDef_t +use windowDef_t; +set string name; +set string group; + +// ItemKeyHandler +set string ItemKeyHandler::action; + +// statement_s +set count statement_s::entries numEntries; + +// expressionEntry +set condition expressionEntry::data::operand type == EET_OPERAND; + +// Operand +use Operand; +set condition internals::intVal dataType == VAL_INT; +set condition internals::floatVal dataType == VAL_FLOAT; +set condition internals::string dataType == VAL_STRING; +set string internals::string; + +// itemDef_s +use itemDef_s; +set string text; +set condition parent never; +set string mouseEnterText; +set string mouseExitText; +set string mouseEnter; +set string mouseExit; +set string action; +set string onAccept; +set string onFocus; +set string leaveFocus; +set string dvar; +set string dvarTest; +set string onListboxSelectionChange; +set string enableDvar; + +// itemDefData_t +use itemDefData_t; +set string enumDvarName; +set condition data never; +set condition listBox itemDef_s::type == ITEM_TYPE_LISTBOX; +set condition editField itemDef_s::type == ITEM_TYPE_TEXT + || itemDef_s::type == ITEM_TYPE_EDITFIELD + || itemDef_s::type == ITEM_TYPE_NUMERICFIELD + || itemDef_s::type == ITEM_TYPE_SLIDER + || itemDef_s::type == ITEM_TYPE_YESNO + || itemDef_s::type == ITEM_TYPE_BIND + || itemDef_s::type == ITEM_TYPE_VALIDFILEFIELD + || itemDef_s::type == ITEM_TYPE_DECIMALFIELD + || itemDef_s::type == ITEM_TYPE_UPREDITFIELD; +set condition multi itemDef_s::type == ITEM_TYPE_MULTI; +set condition enumDvarName itemDef_s::type == ITEM_TYPE_DVARENUM; + +// listBoxDef_s +set string listBoxDef_s::doubleClick; + +// multiDef_s +use multiDef_s; +set string dvarList; +set string dvarStr; diff --git a/src/ZoneCode/Game/T4/XAssets/snd_alias_list_t.txt b/src/ZoneCode/Game/T4/XAssets/snd_alias_list_t.txt new file mode 100644 index 00000000..d861afcf --- /dev/null +++ b/src/ZoneCode/Game/T4/XAssets/snd_alias_list_t.txt @@ -0,0 +1,44 @@ +// ========================================= +// snd_alias_list_t +// ========================================= +use snd_alias_list_t; +set block XFILE_BLOCK_TEMP; +set string aliasName; +set reusable head; +set count head count; + +// snd_alias_t +use snd_alias_t; +set string aliasName; +set string subtitle; +set string secondaryAliasName; +set string chainAliasName; +set reusable soundFile; + +// SoundFile +use SoundFile; +set condition u::loadSnd type == SAT_LOADED; +set reusable u::streamSnd; + +// LoadedSound +set string LoadedSound::name; + +// snd_asset +use snd_asset; +set count data data_size; + +// StreamedSound +use StreamedSound; +set reusable primeSnd; + +// StreamFileName +use StreamFileName; +set string dir; +set string name; + +// PrimedSound +use PrimedSound; +set string name; +set count buffer size; +set block buffer XFILE_BLOCK_LARGE; +set allocalign buffer 2048; diff --git a/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.cpp b/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.cpp new file mode 100644 index 00000000..cff985f3 --- /dev/null +++ b/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.cpp @@ -0,0 +1,33 @@ +#include "ZoneDefWriterT4.h" + +#include "Game/T4/T4.h" + +using namespace T4; + +void ZoneDefWriter::WriteMetaData(ZoneDefinitionOutputStream& stream, const Zone& zone) const {} + +void ZoneDefWriter::WriteContent(ZoneDefinitionOutputStream& stream, const Zone& zone, const ZoneDefFilter& filter) const +{ + const auto* game = IGame::GetGameById(zone.m_game_id); + + // Localized strings are all collected in one string file. So only add this to the zone file. + auto localizePoolAssets = zone.m_pools.PoolAssets(); + if (localizePoolAssets.begin() != localizePoolAssets.end()) + stream.WriteEntry(*game->GetAssetTypeName(ASSET_TYPE_LOCALIZE_ENTRY), zone.m_name); + + for (const auto& asset : zone.m_pools) + { + if (!filter.ShouldWriteAsset(*asset)) + continue; + + switch (asset->m_type) + { + case ASSET_TYPE_LOCALIZE_ENTRY: + break; + + default: + stream.WriteEntry(*game->GetAssetTypeName(asset->m_type), asset->m_name); + break; + } + } +} diff --git a/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.h b/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.h new file mode 100644 index 00000000..a8375c3a --- /dev/null +++ b/src/ZoneCommon/Game/T4/Zone/Definition/ZoneDefWriterT4.h @@ -0,0 +1,13 @@ +#pragma once + +#include "Zone/Definition/ZoneDefWriter.h" + +namespace T4 +{ + class ZoneDefWriter final : public AbstractZoneDefWriter + { + protected: + void WriteMetaData(ZoneDefinitionOutputStream& stream, const Zone& zone) const override; + void WriteContent(ZoneDefinitionOutputStream& stream, const Zone& zone, const ZoneDefFilter& filter) const override; + }; +} // namespace T4 diff --git a/src/ZoneCommon/Game/T4/ZoneConstantsT4.h b/src/ZoneCommon/Game/T4/ZoneConstantsT4.h new file mode 100644 index 00000000..4b3ff034 --- /dev/null +++ b/src/ZoneCommon/Game/T4/ZoneConstantsT4.h @@ -0,0 +1,24 @@ +#pragma once +#include "Game/T4/T4.h" +#include "Zone/ZoneTypes.h" + +#include +#include + +namespace T4 +{ + class ZoneConstants final + { + ZoneConstants() = default; + + public: + static constexpr const char* MAGIC_UNSIGNED = "IWffu100"; + static constexpr int ZONE_VERSION_PC = 387; + + static_assert(std::char_traits::length(MAGIC_UNSIGNED) == sizeof(ZoneHeader::m_magic)); + + static constexpr size_t AUTHED_CHUNK_SIZE = 0x2000; + static constexpr unsigned OFFSET_BLOCK_BIT_COUNT = 3u; + static constexpr block_t INSERT_BLOCK = XFILE_BLOCK_VIRTUAL; + }; +} // namespace T4 diff --git a/src/ZoneCommon/Pool/GlobalAssetPool.cpp b/src/ZoneCommon/Pool/GlobalAssetPool.cpp index e5769778..a7a0027d 100644 --- a/src/ZoneCommon/Pool/GlobalAssetPool.cpp +++ b/src/ZoneCommon/Pool/GlobalAssetPool.cpp @@ -196,13 +196,15 @@ XAssetInfoGeneric* GameGlobalAssetPools::GetAsset(const asset_type_t assetType, GameGlobalAssetPools* GameGlobalAssetPools::GetGlobalPoolsForGame(GameId gameId) { - static GameGlobalAssetPools* globalAssetPools[static_cast(GameId::COUNT)]{ + static GameGlobalAssetPools* globalAssetPools[]{ new GameGlobalAssetPools(GameId::IW3), new GameGlobalAssetPools(GameId::IW4), new GameGlobalAssetPools(GameId::IW5), + new GameGlobalAssetPools(GameId::T4), new GameGlobalAssetPools(GameId::T5), new GameGlobalAssetPools(GameId::T6), }; + static_assert(std::extent_v == static_cast(GameId::COUNT)); assert(static_cast(gameId) < static_cast(GameId::COUNT)); auto* result = globalAssetPools[static_cast(gameId)]; diff --git a/src/ZoneCommon/Zone/Definition/ZoneDefWriter.cpp b/src/ZoneCommon/Zone/Definition/ZoneDefWriter.cpp index bb1a59b8..7c164ca8 100644 --- a/src/ZoneCommon/Zone/Definition/ZoneDefWriter.cpp +++ b/src/ZoneCommon/Zone/Definition/ZoneDefWriter.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/Zone/Definition/ZoneDefWriterIW3.h" #include "Game/IW4/Zone/Definition/ZoneDefWriterIW4.h" #include "Game/IW5/Zone/Definition/ZoneDefWriterIW5.h" +#include "Game/T4/Zone/Definition/ZoneDefWriterT4.h" #include "Game/T5/Zone/Definition/ZoneDefWriterT5.h" #include "Game/T6/Zone/Definition/ZoneDefWriterT6.h" #include "Pool/XAssetInfo.h" @@ -43,13 +44,15 @@ bool ZoneDefFilter::ShouldWriteAsset(const XAssetInfoGeneric& asset) const const IZoneDefWriter* IZoneDefWriter::GetZoneDefWriterForGame(GameId game) { - static const IZoneDefWriter* zoneDefWriters[static_cast(GameId::COUNT)]{ + static const IZoneDefWriter* zoneDefWriters[]{ new IW3::ZoneDefWriter(), new IW4::ZoneDefWriter(), new IW5::ZoneDefWriter(), + new T4::ZoneDefWriter(), new T5::ZoneDefWriter(), new T6::ZoneDefWriter(), }; + static_assert(std::extent_v == static_cast(GameId::COUNT)); assert(static_cast(game) < static_cast(GameId::COUNT)); const auto* result = zoneDefWriters[static_cast(game)]; diff --git a/src/ZoneLoading/Game/IW3/XAssets/gfximage/gfximage_actions.cpp b/src/ZoneLoading/Game/IW3/XAssets/gfximage/gfximage_actions.cpp index b2585045..e4a46d3b 100644 --- a/src/ZoneLoading/Game/IW3/XAssets/gfximage/gfximage_actions.cpp +++ b/src/ZoneLoading/Game/IW3/XAssets/gfximage/gfximage_actions.cpp @@ -17,7 +17,7 @@ void Actions_GfxImage::OnImageLoaded(GfxImage* image) const void Actions_GfxImage::LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const { - const size_t loadDefSize = offsetof(IW3::GfxImageLoadDef, data) + loadDef->resourceSize; + const size_t loadDefSize = offsetof(GfxImageLoadDef, data) + loadDef->resourceSize; image->texture.loadDef = static_cast(m_zone.Memory().AllocRaw(loadDefSize)); memcpy(image->texture.loadDef, loadDef, loadDefSize); diff --git a/src/ZoneLoading/Game/IW4/XAssets/gfximage/gfximage_actions.cpp b/src/ZoneLoading/Game/IW4/XAssets/gfximage/gfximage_actions.cpp index 31e30897..7a986086 100644 --- a/src/ZoneLoading/Game/IW4/XAssets/gfximage/gfximage_actions.cpp +++ b/src/ZoneLoading/Game/IW4/XAssets/gfximage/gfximage_actions.cpp @@ -17,7 +17,7 @@ void Actions_GfxImage::OnImageLoaded(GfxImage* image) const void Actions_GfxImage::LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const { - const size_t loadDefSize = offsetof(IW4::GfxImageLoadDef, data) + loadDef->resourceSize; + const size_t loadDefSize = offsetof(GfxImageLoadDef, data) + loadDef->resourceSize; image->texture.loadDef = static_cast(m_zone.Memory().AllocRaw(loadDefSize)); memcpy(image->texture.loadDef, loadDef, loadDefSize); diff --git a/src/ZoneLoading/Game/IW5/XAssets/gfximage/gfximage_actions.cpp b/src/ZoneLoading/Game/IW5/XAssets/gfximage/gfximage_actions.cpp index 70b58e51..4f693263 100644 --- a/src/ZoneLoading/Game/IW5/XAssets/gfximage/gfximage_actions.cpp +++ b/src/ZoneLoading/Game/IW5/XAssets/gfximage/gfximage_actions.cpp @@ -17,7 +17,7 @@ void Actions_GfxImage::OnImageLoaded(GfxImage* image) const void Actions_GfxImage::LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const { - const size_t loadDefSize = offsetof(IW5::GfxImageLoadDef, data) + loadDef->resourceSize; + const size_t loadDefSize = offsetof(GfxImageLoadDef, data) + loadDef->resourceSize; image->texture.loadDef = static_cast(m_zone.Memory().AllocRaw(loadDefSize)); memcpy(image->texture.loadDef, loadDef, loadDefSize); diff --git a/src/ZoneLoading/Game/T4/ContentLoaderT4.cpp b/src/ZoneLoading/Game/T4/ContentLoaderT4.cpp new file mode 100644 index 00000000..7ec3c387 --- /dev/null +++ b/src/ZoneLoading/Game/T4/ContentLoaderT4.cpp @@ -0,0 +1,174 @@ +#include "ContentLoaderT4.h" + +#include "Game/T4/AssetLoaderT4.h" +#include "Game/T4/T4.h" +#include "Loading/Exception/UnsupportedAssetTypeException.h" + +#include + +using namespace T4; + +ContentLoader::ContentLoader(Zone& zone, ZoneInputStream& stream) + : ContentLoaderBase(zone, stream), + varXAssetList(nullptr), + varXAsset(nullptr), + varScriptStringList(nullptr) +{ +} + +void ContentLoader::LoadScriptStringList(const bool atStreamStart) +{ + assert(!atStreamStart); + + if (varScriptStringList->strings != nullptr) + { + assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING); + +#ifdef ARCH_x86 + varScriptStringList->strings = m_stream.Alloc(4); +#else + varScriptStringList->strings = m_stream.AllocOutOfBlock(4, varScriptStringList->count); +#endif + varXString = varScriptStringList->strings; + LoadXStringArray(true, varScriptStringList->count); + + if (varScriptStringList->strings && varScriptStringList->count > 0) + m_zone.m_script_strings.InitializeForExistingZone(varScriptStringList->strings, static_cast(varScriptStringList->count)); + } + + assert(m_zone.m_script_strings.Count() <= SCR_STRING_MAX + 1); +} + +void ContentLoader::LoadXAsset(const bool atStreamStart) const +{ +#define LOAD_ASSET(type_index, typeName, headerEntry) \ + case type_index: \ + { \ + Loader_##typeName loader(m_zone, m_stream); \ + loader.Load(&varXAsset->header.headerEntry); \ + break; \ + } +#define SKIP_ASSET(type_index, typeName, headerEntry) \ + case type_index: \ + break; + + assert(varXAsset != nullptr); + + if (atStreamStart) + m_stream.Load(varXAsset); + + switch (varXAsset->type) + { + SKIP_ASSET(ASSET_TYPE_XMODELPIECES, XModelPieces, data) + LOAD_ASSET(ASSET_TYPE_PHYSPRESET, PhysPreset, physPreset) + LOAD_ASSET(ASSET_TYPE_PHYSCONSTRAINTS, PhysConstraints, physConstraints) + LOAD_ASSET(ASSET_TYPE_DESTRUCTIBLEDEF, DestructibleDef, destructibleDef) + LOAD_ASSET(ASSET_TYPE_XANIMPARTS, XAnimParts, parts) + LOAD_ASSET(ASSET_TYPE_XMODEL, XModel, model) + LOAD_ASSET(ASSET_TYPE_MATERIAL, Material, material) + LOAD_ASSET(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet, techniqueSet) + LOAD_ASSET(ASSET_TYPE_IMAGE, GfxImage, image) + LOAD_ASSET(ASSET_TYPE_SOUND, snd_alias_list_t, sound) + LOAD_ASSET(ASSET_TYPE_LOADED_SOUND, LoadedSound, loadSnd) + LOAD_ASSET(ASSET_TYPE_CLIPMAP, clipMap_t, clipMap) + LOAD_ASSET(ASSET_TYPE_CLIPMAP_PVS, clipMap_t, clipMap) + LOAD_ASSET(ASSET_TYPE_COMWORLD, ComWorld, comWorld) + LOAD_ASSET(ASSET_TYPE_GAMEWORLD_SP, GameWorldSp, gameWorldSp) + LOAD_ASSET(ASSET_TYPE_GAMEWORLD_MP, GameWorldMp, gameWorldMp) + LOAD_ASSET(ASSET_TYPE_MAP_ENTS, MapEnts, mapEnts) + LOAD_ASSET(ASSET_TYPE_GFXWORLD, GfxWorld, gfxWorld) + LOAD_ASSET(ASSET_TYPE_LIGHT_DEF, GfxLightDef, lightDef) + SKIP_ASSET(ASSET_TYPE_UI_MAP, UiMap, data) + LOAD_ASSET(ASSET_TYPE_FONT, Font_s, font) + LOAD_ASSET(ASSET_TYPE_MENULIST, MenuList, menuList) + LOAD_ASSET(ASSET_TYPE_MENU, menuDef_t, menu) + LOAD_ASSET(ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry, localize) + LOAD_ASSET(ASSET_TYPE_WEAPON, WeaponDef, weapon) + LOAD_ASSET(ASSET_TYPE_SNDDRIVER_GLOBALS, SndDriverGlobals, sndDriverGlobals) + LOAD_ASSET(ASSET_TYPE_FX, FxEffectDef, fx) + LOAD_ASSET(ASSET_TYPE_IMPACT_FX, FxImpactTable, impactFx) + SKIP_ASSET(ASSET_TYPE_AITYPE, AiType, data) + SKIP_ASSET(ASSET_TYPE_MPTYPE, MpType, data) + SKIP_ASSET(ASSET_TYPE_CHARACTER, Character, data) + SKIP_ASSET(ASSET_TYPE_XMODELALIAS, XModelAlias, data) + LOAD_ASSET(ASSET_TYPE_RAWFILE, RawFile, rawfile) + LOAD_ASSET(ASSET_TYPE_STRINGTABLE, StringTable, stringTable) + LOAD_ASSET(ASSET_TYPE_PACK_INDEX, PackIndex, packIndex) + + default: + { + throw UnsupportedAssetTypeException(varXAsset->type); + } + } + +#undef LOAD_ASSET +} + +void ContentLoader::LoadXAssetArray(const bool atStreamStart, const size_t count) +{ + assert(varXAsset != nullptr); + + if (atStreamStart) + { +#ifdef ARCH_x86 + m_stream.Load(varXAsset, count); +#else + const auto fill = m_stream.LoadWithFill(8u * count); + + for (size_t index = 0; index < count; index++) + { + fill.Fill(varXAsset[index].type, 8u * index); + fill.FillPtr(varXAsset[index].header.data, 8u * index + 4u); + m_stream.AddPointerLookup(&varXAsset[index].header.data, fill.BlockBuffer(8u * index + 4u)); + } +#endif + } + + for (size_t index = 0; index < count; index++) + { + LoadXAsset(false); + varXAsset++; + +#ifdef DEBUG_OFFSETS + m_stream.DebugOffsets(index); +#endif + } +} + +void ContentLoader::Load() +{ + XAssetList assetList{}; + varXAssetList = &assetList; + +#ifdef ARCH_x86 + m_stream.LoadDataRaw(&assetList, sizeof(assetList)); +#else + const auto fillAccessor = m_stream.LoadWithFill(16u); + varScriptStringList = &varXAssetList->stringList; + fillAccessor.Fill(varScriptStringList->count, 0u); + fillAccessor.FillPtr(varScriptStringList->strings, 4u); + + fillAccessor.Fill(varXAssetList->assetCount, 8u); + fillAccessor.FillPtr(varXAssetList->assets, 12u); +#endif + + m_stream.PushBlock(XFILE_BLOCK_VIRTUAL); + + varScriptStringList = &assetList.stringList; + LoadScriptStringList(false); + + if (assetList.assets != nullptr) + { + assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING); + +#ifdef ARCH_x86 + assetList.assets = m_stream.Alloc(4); +#else + assetList.assets = m_stream.AllocOutOfBlock(4, assetList.assetCount); +#endif + varXAsset = assetList.assets; + LoadXAssetArray(true, assetList.assetCount); + } + + m_stream.PopBlock(); +} diff --git a/src/ZoneLoading/Game/T4/ContentLoaderT4.h b/src/ZoneLoading/Game/T4/ContentLoaderT4.h new file mode 100644 index 00000000..9c20b91e --- /dev/null +++ b/src/ZoneLoading/Game/T4/ContentLoaderT4.h @@ -0,0 +1,25 @@ +#pragma once + +#include "Game/T4/T4.h" +#include "Loading/ContentLoaderBase.h" +#include "Loading/IContentLoadingEntryPoint.h" + +namespace T4 +{ + class ContentLoader final : public ContentLoaderBase, public IContentLoadingEntryPoint + { + public: + ContentLoader(Zone& zone, ZoneInputStream& stream); + void Load() override; + + private: + void LoadScriptStringList(bool atStreamStart); + + void LoadXAsset(bool atStreamStart) const; + void LoadXAssetArray(bool atStreamStart, size_t count); + + XAssetList* varXAssetList; + XAsset* varXAsset; + ScriptStringList* varScriptStringList; + }; +} // namespace T4 diff --git a/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.cpp b/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.cpp new file mode 100644 index 00000000..16679217 --- /dev/null +++ b/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.cpp @@ -0,0 +1,24 @@ +#include "gfximage_actions.h" + +#include +#include + +using namespace T4; + +Actions_GfxImage::Actions_GfxImage(Zone& zone) + : AssetLoadingActions(zone) +{ +} + +void Actions_GfxImage::OnImageLoaded(GfxImage* image) const +{ + image->cardMemory.platform[0] = 0; +} + +void Actions_GfxImage::LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const +{ + const size_t loadDefSize = offsetof(GfxImageLoadDef, data) + loadDef->resourceSize; + + image->texture.loadDef = static_cast(m_zone.Memory().AllocRaw(loadDefSize)); + memcpy(image->texture.loadDef, loadDef, loadDefSize); +} diff --git a/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.h b/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.h new file mode 100644 index 00000000..5f07f708 --- /dev/null +++ b/src/ZoneLoading/Game/T4/XAssets/gfximage/gfximage_actions.h @@ -0,0 +1,16 @@ +#pragma once + +#include "Game/T4/T4.h" +#include "Loading/AssetLoadingActions.h" + +namespace T4 +{ + class Actions_GfxImage final : public AssetLoadingActions + { + public: + explicit Actions_GfxImage(Zone& zone); + + void OnImageLoaded(GfxImage* image) const; + void LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const; + }; +} // namespace T4 diff --git a/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp new file mode 100644 index 00000000..ad74e200 --- /dev/null +++ b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp @@ -0,0 +1,89 @@ +#include "ZoneLoaderFactoryT4.h" + +#include "ContentLoaderT4.h" +#include "Game/GameLanguage.h" +#include "Game/T4/T4.h" +#include "Game/T4/ZoneConstantsT4.h" +#include "Loading/Processor/ProcessorInflate.h" +#include "Loading/Steps/StepAddProcessor.h" +#include "Loading/Steps/StepAllocXBlocks.h" +#include "Loading/Steps/StepLoadZoneContent.h" +#include "Loading/Steps/StepLoadZoneSizes.h" +#include "Utils/ClassUtils.h" +#include "Utils/Endianness.h" + +#include + +using namespace T4; + +namespace +{ + void SetupBlock(ZoneLoader& zoneLoader) + { +#define XBLOCK_DEF(name, type) std::make_unique(STR(name), name, type) + + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL)); + zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL)); + +#undef XBLOCK_DEF + } +} // namespace + +std::optional ZoneLoaderFactory::InspectZoneHeader(const ZoneHeader& header) const +{ + if (endianness::FromLittleEndian(header.m_version) == ZoneConstants::ZONE_VERSION_PC + && !memcmp(header.m_magic, ZoneConstants::MAGIC_UNSIGNED, std::char_traits::length(ZoneConstants::MAGIC_UNSIGNED))) + { + return ZoneLoaderInspectionResult{ + .m_game_id = GameId::T4, + .m_endianness = GameEndianness::LE, + .m_word_size = GameWordSize::ARCH_32, + .m_platform = GamePlatform::PC, + // There is no way to know whether unsigned zones are official. + .m_is_official = false, + .m_is_signed = false, + .m_is_encrypted = false, + }; + } + + return std::nullopt; +} + +std::unique_ptr ZoneLoaderFactory::CreateLoaderForHeader(const ZoneHeader& header, + const std::string& fileName, + std::optional> progressCallback) const +{ + const auto inspectResult = InspectZoneHeader(header); + if (!inspectResult) + return nullptr; + + // Create new zone + auto zone = std::make_unique(fileName, 0, GameId::T4, inspectResult->m_platform); + auto* zonePtr = zone.get(); + zone->m_language = GameLanguage::LANGUAGE_NONE; + + // File is supported. Now setup all required steps for loading this file. + auto zoneLoader = std::make_unique(std::move(zone)); + + SetupBlock(*zoneLoader); + zoneLoader->AddLoadingStep(step::CreateStepAddProcessor(processor::CreateProcessorInflate(ZoneConstants::AUTHED_CHUNK_SIZE))); + zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes()); + zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks()); + zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent( + [zonePtr](ZoneInputStream& stream) + { + return std::make_unique(*zonePtr, stream); + }, + 32u, + ZoneConstants::OFFSET_BLOCK_BIT_COUNT, + ZoneConstants::INSERT_BLOCK, + zonePtr->Memory(), + std::move(progressCallback))); + + return zoneLoader; +} diff --git a/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.h b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.h new file mode 100644 index 00000000..ef89e6b9 --- /dev/null +++ b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.h @@ -0,0 +1,17 @@ +#pragma once + +#include "Loading/IZoneLoaderFactory.h" + +#include + +namespace T4 +{ + class ZoneLoaderFactory final : public IZoneLoaderFactory + { + public: + [[nodiscard]] std::optional InspectZoneHeader(const ZoneHeader& header) const override; + [[nodiscard]] std::unique_ptr CreateLoaderForHeader(const ZoneHeader& header, + const std::string& fileName, + std::optional> progressCallback) const override; + }; +} // namespace T4 diff --git a/src/ZoneLoading/Game/T6/XAssets/gfximage/gfximage_actions.cpp b/src/ZoneLoading/Game/T6/XAssets/gfximage/gfximage_actions.cpp index 41763a0d..e22cef3d 100644 --- a/src/ZoneLoading/Game/T6/XAssets/gfximage/gfximage_actions.cpp +++ b/src/ZoneLoading/Game/T6/XAssets/gfximage/gfximage_actions.cpp @@ -17,7 +17,7 @@ void Actions_GfxImage::OnImageLoaded(GfxImage* image) const void Actions_GfxImage::LoadImageData(GfxImageLoadDef* loadDef, GfxImage* image) const { - const size_t loadDefSize = offsetof(T6::GfxImageLoadDef, data) + loadDef->resourceSize; + const size_t loadDefSize = offsetof(GfxImageLoadDef, data) + loadDef->resourceSize; image->texture.loadDef = static_cast(m_zone.Memory().AllocRaw(loadDefSize)); memcpy(image->texture.loadDef, loadDef, loadDefSize); diff --git a/src/ZoneLoading/Loading/IZoneLoaderFactory.cpp b/src/ZoneLoading/Loading/IZoneLoaderFactory.cpp index a02f025a..c9636197 100644 --- a/src/ZoneLoading/Loading/IZoneLoaderFactory.cpp +++ b/src/ZoneLoading/Loading/IZoneLoaderFactory.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/ZoneLoaderFactoryIW3.h" #include "Game/IW4/ZoneLoaderFactoryIW4.h" #include "Game/IW5/ZoneLoaderFactoryIW5.h" +#include "Game/T4/ZoneLoaderFactoryT4.h" #include "Game/T5/ZoneLoaderFactoryT5.h" #include "Game/T6/ZoneLoaderFactoryT6.h" @@ -10,10 +11,11 @@ const IZoneLoaderFactory* IZoneLoaderFactory::GetZoneLoaderFactoryForGame(GameId game) { - static const IZoneLoaderFactory* zoneCreators[static_cast(GameId::COUNT)]{ + static const IZoneLoaderFactory* zoneCreators[]{ new IW3::ZoneLoaderFactory(), new IW4::ZoneLoaderFactory(), new IW5::ZoneLoaderFactory(), + new T4::ZoneLoaderFactory(), new T5::ZoneLoaderFactory(), new T6::ZoneLoaderFactory(), }; diff --git a/src/ZoneWriting/Game/T4/ContentWriterT4.cpp b/src/ZoneWriting/Game/T4/ContentWriterT4.cpp new file mode 100644 index 00000000..28fccf37 --- /dev/null +++ b/src/ZoneWriting/Game/T4/ContentWriterT4.cpp @@ -0,0 +1,220 @@ +#include "ContentWriterT4.h" + +#include "Game/T4/AssetWriterT4.h" +#include "Writing/WritingException.h" + +#include +#include + +using namespace T4; + +ContentWriter::ContentWriter(const Zone& zone) + : ContentWriterBase(zone), + varXAssetList(nullptr), + varXAsset(nullptr), + varScriptStringList(nullptr) +{ +} + +void ContentWriter::CreateXAssetList(XAssetList& xAssetList, MemoryManager& memory) const +{ + if (!m_zone.m_script_strings.Empty()) + { + assert(m_zone.m_script_strings.Count() <= SCR_STRING_MAX + 1); + xAssetList.stringList.count = static_cast(m_zone.m_script_strings.Count()); + xAssetList.stringList.strings = memory.Alloc(m_zone.m_script_strings.Count()); + + for (auto i = 0u; i < m_zone.m_script_strings.Count(); i++) + xAssetList.stringList.strings[i] = m_zone.m_script_strings.CValue(i); + } + else + { + xAssetList.stringList.count = 0; + xAssetList.stringList.strings = nullptr; + } + + const auto assetCount = m_zone.m_pools.GetTotalAssetCount(); + if (assetCount > 0) + { + xAssetList.assetCount = static_cast(assetCount); + xAssetList.assets = memory.Alloc(assetCount); + + const auto end = m_zone.m_pools.end(); + auto index = 0u; + for (auto i = m_zone.m_pools.begin(); i != end; ++i) + { + auto& asset = xAssetList.assets[index++]; + asset.type = static_cast((*i)->m_type); + asset.header.data = (*i)->m_ptr; + } + } + else + { + xAssetList.assetCount = 0; + xAssetList.assets = nullptr; + } +} + +void ContentWriter::WriteScriptStringList(const bool atStreamStart) +{ + assert(!atStreamStart); + + if (varScriptStringList->strings != nullptr) + { + m_stream->Align(4); + varXString = varScriptStringList->strings; + WriteXStringArray(true, varScriptStringList->count); + +#ifdef ARCH_x86 + static_assert(offsetof(ScriptStringList, strings) == 4u); +#endif + m_stream->MarkFollowing(varScriptStringListWritten.AtOffset(4)); + } +} + +void ContentWriter::WriteXAsset(const bool atStreamStart) +{ +#ifdef ARCH_x86 + static_assert(offsetof(XAsset, header.data) == 4u); +#endif +#define WRITE_ASSET(type_index, typeName, headerEntry) \ + case type_index: \ + { \ + Writer_##typeName writer(varXAsset->header.headerEntry, m_zone, *m_stream); \ + writer.Write(varXAsset->header.headerEntry, varXAssetWritten.AtOffset(4)); \ + break; \ + } +#define SKIP_ASSET(type_index, typeName, headerEntry) \ + case type_index: \ + break; + + assert(varXAsset != nullptr); + + if (atStreamStart) + varXAssetWritten = m_stream->Write(varXAsset); + + switch (varXAsset->type) + { + SKIP_ASSET(ASSET_TYPE_XMODELPIECES, XModelPieces, data) + WRITE_ASSET(ASSET_TYPE_PHYSPRESET, PhysPreset, physPreset) + WRITE_ASSET(ASSET_TYPE_PHYSCONSTRAINTS, PhysConstraints, physConstraints) + WRITE_ASSET(ASSET_TYPE_DESTRUCTIBLEDEF, DestructibleDef, destructibleDef) + WRITE_ASSET(ASSET_TYPE_XANIMPARTS, XAnimParts, parts) + WRITE_ASSET(ASSET_TYPE_XMODEL, XModel, model) + WRITE_ASSET(ASSET_TYPE_MATERIAL, Material, material) + WRITE_ASSET(ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet, techniqueSet) + WRITE_ASSET(ASSET_TYPE_IMAGE, GfxImage, image) + WRITE_ASSET(ASSET_TYPE_SOUND, snd_alias_list_t, sound) + WRITE_ASSET(ASSET_TYPE_LOADED_SOUND, LoadedSound, loadSnd) + WRITE_ASSET(ASSET_TYPE_CLIPMAP, clipMap_t, clipMap) + WRITE_ASSET(ASSET_TYPE_CLIPMAP_PVS, clipMap_t, clipMap) + WRITE_ASSET(ASSET_TYPE_COMWORLD, ComWorld, comWorld) + WRITE_ASSET(ASSET_TYPE_GAMEWORLD_SP, GameWorldSp, gameWorldSp) + WRITE_ASSET(ASSET_TYPE_GAMEWORLD_MP, GameWorldMp, gameWorldMp) + WRITE_ASSET(ASSET_TYPE_MAP_ENTS, MapEnts, mapEnts) + WRITE_ASSET(ASSET_TYPE_GFXWORLD, GfxWorld, gfxWorld) + WRITE_ASSET(ASSET_TYPE_LIGHT_DEF, GfxLightDef, lightDef) + SKIP_ASSET(ASSET_TYPE_UI_MAP, UiMap, data) + WRITE_ASSET(ASSET_TYPE_FONT, Font_s, font) + WRITE_ASSET(ASSET_TYPE_MENULIST, MenuList, menuList) + WRITE_ASSET(ASSET_TYPE_MENU, menuDef_t, menu) + WRITE_ASSET(ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry, localize) + WRITE_ASSET(ASSET_TYPE_WEAPON, WeaponDef, weapon) + WRITE_ASSET(ASSET_TYPE_SNDDRIVER_GLOBALS, SndDriverGlobals, sndDriverGlobals) + WRITE_ASSET(ASSET_TYPE_FX, FxEffectDef, fx) + WRITE_ASSET(ASSET_TYPE_IMPACT_FX, FxImpactTable, impactFx) + SKIP_ASSET(ASSET_TYPE_AITYPE, AiType, data) + SKIP_ASSET(ASSET_TYPE_MPTYPE, MpType, data) + SKIP_ASSET(ASSET_TYPE_CHARACTER, Character, data) + SKIP_ASSET(ASSET_TYPE_XMODELALIAS, XModelAlias, data) + WRITE_ASSET(ASSET_TYPE_RAWFILE, RawFile, rawfile) + WRITE_ASSET(ASSET_TYPE_STRINGTABLE, StringTable, stringTable) + WRITE_ASSET(ASSET_TYPE_PACK_INDEX, PackIndex, packIndex) + + default: + { + throw WritingException(std::format("Unsupported asset type: {}.", static_cast(varXAsset->type))); + } + } + +#undef WRITE_ASSET +#undef SKIP_ASSET +} + +void ContentWriter::WriteXAssetArray(const bool atStreamStart, const size_t count) +{ + assert(varXAsset != nullptr); + +#ifdef ARCH_x86 + static_assert(sizeof(XAsset) == 8u); +#endif + + if (atStreamStart) + { +#ifdef ARCH_x86 + varXAssetWritten = m_stream->Write(varXAsset, count); +#else + const auto fill = m_stream->WriteWithFill(8u * count); + varXAssetWritten = fill.Offset(); + + for (size_t index = 0; index < count; index++) + fill.Fill(varXAsset[index].type, 8u * index); +#endif + } + + for (size_t index = 0; index < count; index++) + { + WriteXAsset(false); + varXAsset++; + varXAssetWritten.Inc(8u); + } +} + +void ContentWriter::WriteContent(ZoneOutputStream& stream) +{ + m_stream = &stream; + + MemoryManager memory; + XAssetList assetList{}; + + CreateXAssetList(assetList, memory); + + varXAssetList = &assetList; + +#ifdef ARCH_x86 + static_assert(sizeof(XAssetList) == 16); + static_assert(offsetof(XAssetList, assetCount) == 8u); + varXAssetListWritten = m_stream->WriteDataRaw(&assetList, sizeof(assetList)); +#else + const auto fillAccessor = m_stream->WriteWithFill(16u); + varXAssetListWritten = fillAccessor.Offset(); + + varScriptStringList = &varXAssetList->stringList; + fillAccessor.Fill(varScriptStringList->count, 0u); + + fillAccessor.Fill(varXAssetList->assetCount, 8u); +#endif + + m_stream->PushBlock(XFILE_BLOCK_VIRTUAL); + +#ifdef ARCH_x86 + static_assert(offsetof(XAssetList, stringList) == 0u); +#endif + varScriptStringList = &varXAssetList->stringList; + varScriptStringListWritten = varXAssetListWritten.AtOffset(0); + WriteScriptStringList(false); + + if (varXAssetList->assets != nullptr) + { + m_stream->Align(4); + varXAsset = varXAssetList->assets; + WriteXAssetArray(true, varXAssetList->assetCount); + +#ifdef ARCH_x86 + static_assert(offsetof(XAssetList, assets) == 12u); +#endif + m_stream->MarkFollowing(varXAssetListWritten.AtOffset(12)); + } + + m_stream->PopBlock(); +} diff --git a/src/ZoneWriting/Game/T4/ContentWriterT4.h b/src/ZoneWriting/Game/T4/ContentWriterT4.h new file mode 100644 index 00000000..cd9bd351 --- /dev/null +++ b/src/ZoneWriting/Game/T4/ContentWriterT4.h @@ -0,0 +1,32 @@ +#pragma once + +#include "Game/T4/T4.h" +#include "Writing/ContentWriterBase.h" +#include "Writing/IContentWritingEntryPoint.h" + +namespace T4 +{ + class ContentWriter final : public ContentWriterBase, public IContentWritingEntryPoint + { + public: + explicit ContentWriter(const Zone& zone); + + void WriteContent(ZoneOutputStream& stream) override; + + private: + void CreateXAssetList(XAssetList& xAssetList, MemoryManager& memory) const; + + void WriteScriptStringList(bool atStreamStart); + + void WriteXAsset(bool atStreamStart); + void WriteXAssetArray(bool atStreamStart, size_t count); + + XAssetList* varXAssetList; + XAsset* varXAsset; + ScriptStringList* varScriptStringList; + + ZoneOutputOffset varXAssetListWritten; + ZoneOutputOffset varXAssetWritten; + ZoneOutputOffset varScriptStringListWritten; + }; +} // namespace T4 diff --git a/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.cpp b/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.cpp new file mode 100644 index 00000000..d065bcd1 --- /dev/null +++ b/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.cpp @@ -0,0 +1,71 @@ +#include "ZoneWriterFactoryT4.h" + +#include "ContentWriterT4.h" +#include "Game/T4/GameT4.h" +#include "Game/T4/T4.h" +#include "Game/T4/ZoneConstantsT4.h" +#include "Utils/ClassUtils.h" +#include "Writing/Processor/OutputProcessorDeflate.h" +#include "Writing/Steps/StepAddOutputProcessor.h" +#include "Writing/Steps/StepWriteXBlockSizes.h" +#include "Writing/Steps/StepWriteZoneContentToFile.h" +#include "Writing/Steps/StepWriteZoneContentToMemory.h" +#include "Writing/Steps/StepWriteZoneHeader.h" +#include "Writing/Steps/StepWriteZoneSizes.h" + +#include + +using namespace T4; + +namespace +{ + void SetupBlocks(ZoneWriter& writer) + { +#define XBLOCK_DEF(name, type) std::make_unique(STR(name), name, type) + + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL)); + writer.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL)); + +#undef XBLOCK_DEF + } + + ZoneHeader CreateHeaderForParams() + { + ZoneHeader header{}; + header.m_version = ZoneConstants::ZONE_VERSION_PC; + memcpy(header.m_magic, ZoneConstants::MAGIC_UNSIGNED, sizeof(ZoneHeader::m_magic)); + + return header; + } +} // namespace + +std::unique_ptr ZoneWriterFactory::CreateWriter(const Zone& zone) const +{ + auto writer = std::make_unique(); + + SetupBlocks(*writer); + + auto contentInMemory = std::make_unique( + std::make_unique(zone), zone, 32u, ZoneConstants::OFFSET_BLOCK_BIT_COUNT, ZoneConstants::INSERT_BLOCK); + auto* contentInMemoryPtr = contentInMemory.get(); + writer->AddWritingStep(std::move(contentInMemory)); + + // Write zone header + writer->AddWritingStep(std::make_unique(CreateHeaderForParams())); + + writer->AddWritingStep(std::make_unique(std::make_unique())); + + // Start of the XFile struct + writer->AddWritingStep(std::make_unique(contentInMemoryPtr)); + writer->AddWritingStep(std::make_unique(zone)); + + // Start of the zone content + writer->AddWritingStep(std::make_unique(contentInMemoryPtr)); + + return std::move(writer); +} diff --git a/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.h b/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.h new file mode 100644 index 00000000..751e077a --- /dev/null +++ b/src/ZoneWriting/Game/T4/ZoneWriterFactoryT4.h @@ -0,0 +1,14 @@ +#pragma once + +#include "Writing/IZoneWriterFactory.h" + +#include + +namespace T4 +{ + class ZoneWriterFactory final : public IZoneWriterFactory + { + public: + [[nodiscard]] std::unique_ptr CreateWriter(const Zone& zone) const override; + }; +} // namespace T4 diff --git a/src/ZoneWriting/Writing/IZoneWriterFactory.cpp b/src/ZoneWriting/Writing/IZoneWriterFactory.cpp index 193c4c84..d01aa613 100644 --- a/src/ZoneWriting/Writing/IZoneWriterFactory.cpp +++ b/src/ZoneWriting/Writing/IZoneWriterFactory.cpp @@ -3,6 +3,7 @@ #include "Game/IW3/ZoneWriterFactoryIW3.h" #include "Game/IW4/ZoneWriterFactoryIW4.h" #include "Game/IW5/ZoneWriterFactoryIW5.h" +#include "Game/T4/ZoneWriterFactoryT4.h" #include "Game/T5/ZoneWriterFactoryT5.h" #include "Game/T6/ZoneWriterFactoryT6.h" @@ -10,10 +11,11 @@ const IZoneWriterFactory* IZoneWriterFactory::GetZoneWriterFactoryForGame(GameId game) { - static const IZoneWriterFactory* zoneCreators[static_cast(GameId::COUNT)]{ + static const IZoneWriterFactory* zoneCreators[]{ new IW3::ZoneWriterFactory(), new IW4::ZoneWriterFactory(), new IW5::ZoneWriterFactory(), + new T4::ZoneWriterFactory(), new T5::ZoneWriterFactory(), new T6::ZoneWriterFactory(), };