zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-08-19 21:44:26 +00:00
Code Activity

feat: QOS (007: Quantum of Solace) support (#894)

Browse Source 
* feat: QOS (007: Quantum of Solace) support

* feat: add qos localize loader

* feat: add qos stringtable loader

* chore: comment about official zones

* fix: add qos gfximage runtime fields

* chore: remove useless dev time comments

* fix: remove all `static_asserts`s from asset headers causing build fail on x64

* chore: change union ordering of qos `entryInternalData`

* chore: move qos asset type enum to qos.h

* fix: qos and t4 xsurface index buffer

* chore: implement qos MaterialInfo struct

* chore: adjust some gfxworld struct members

* chore: implement qos PhysPreset and PhysConstraints

* chore: fix and adjust slight inconsistencies with qos zone code

* chore: reorder qos ZoneCode.lua entries in order of asset type enum

* chore: remove asset types that are not actual asset types in zones

* chore: check common asset arrays with static_assert

* chore: rename qos assets

* chore: reorder qos in templates to be in alphabetical order

* chore: use function for CopyMipLevel in Dx9TextureLoader

* chore: use templates for qos MapEntsDumper

* chore: add missing braces in XModelToCommonConverter

* chore: add generic way to peek at zone data

* Qos does not use a classic ZoneHeader so code needs to be more generic

* fix: do not use raw_byte and raw_uint typedefs for qos

* fix: not being able to write clipmapmp

* chore: additional research on qos vertex property and stuff

---------

Co-authored-by: Jan Laupetin <[email protected]>
This commit is contained in:
mo
2026-08-05 00:32:23 +02:00
committed by GitHub
co-authored by Jan Laupetin
parent 5c0a7257fd
commit 9f49e0e31c
142 changed files with 6000 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+1
View File
@@ -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)
- [QOS (007: Quantum of Solace - 2008)](https://en.wikipedia.org/wiki/007:_Quantum_of_Solace)
- [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)
docs/SupportedAssetTypes.md
+36
View File
@@ -123,6 +123,42 @@ using `Linker`):
| VehicleDef | ✅ | ✅ | |
| AddonMapEnts | ⁉️ | ❌ | MapEnts String can be exported. Binary data currently not. |
## QOS (007: Quantum of Solace)
| Asset Type | Dumping Support | Loading Support | Notes |
|----------------------|-----------------|-----------------|------------------------------------------------------------------------------|
| PhysPreset | ❌ | ❌ | |
| PhysConstraints | ❌ | ❌ | |
| DestructibleDef | ❌ | ❌ | |
| XAnimParts | ❌ | ❌ | |
| XModel | ✅ | ❌ | Model data can be exported to `XMODEL_EXPORT/XMODEL_BIN`, `OBJ`, `GLB/GLTF`. |
| Material | ❌ | ❌ | |
| MaterialTechniqueSet | ❌ | ❌ | |
| GfxImage | ✅ | ❌ | |
| snd_alias_list_t | ❌ | ❌ | |
| SndCurve | ❌ | ❌ | |
| clipMap_t | ❌ | ❌ | |
| ComWorld | ❌ | ❌ | |
| GameWorldSp | ❌ | ❌ | |
| GameWorldMp | ❌ | ❌ | |
| MapEnts | ✅ | ❌ | |
| GfxWorld | ❌ | ❌ | |
| GfxLightDef | ❌ | ❌ | |
| Font_s | ✅ | ❌ | |
| MenuList | ❌ | ❌ | |
| menuDef_t | ❌ | ❌ | |
| LocalizeEntry | ✅ | ✅ | |
| WeaponDef | ❌ | ❌ | |
| SndDriverGlobals | ❌ | ❌ | |
| FxEffectDef | ❌ | ❌ | |
| FxImpactTable | ❌ | ❌ | |
| RawFile | ✅ | ✅ | |
| StringTable | ✅ | ✅ | |
| XmlTree | ❌ | ❌ | |
| SceneAnimation | ❌ | ❌ | |
| Cutscene | ❌ | ❌ | |
| CustomCamera | ❌ | ❌ | |
## T4 (Call of Duty: World at War)
| Asset Type | Dumping Support | Loading Support | Notes |
src/Common/Game/CommonAsset.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "IW3/CommonAssetIW3.h"
#include "IW4/CommonAssetIW4.h"
#include "IW5/CommonAssetIW5.h"
#include "QOS/CommonAssetQOS.h"
#include "T4/CommonAssetT4.h"
#include "T5/CommonAssetT5.h"
#include "T6/CommonAssetT6.h"
@@ -15,6 +16,7 @@ ICommonAssetTypeMapper* ICommonAssetTypeMapper::GetCommonAssetMapperByGame(GameI
new IW3::CommonAssetTypeMapper(),
new IW4::CommonAssetTypeMapper(),
new IW5::CommonAssetTypeMapper(),
new QOS::CommonAssetTypeMapper(),
new T4::CommonAssetTypeMapper(),
new T5::CommonAssetTypeMapper(),
new T6::CommonAssetTypeMapper(),
src/Common/Game/CommonAsset.h
+6
View File
@@ -160,6 +160,12 @@ enum class CommonAssetType : std::uint8_t
// T6
ZBARRIER,
// QOS
XML_TREE,
SCENE_ANIMATION,
CUTSCENE,
CUSTOM_CAMERA,
COUNT,
};
src/Common/Game/IGame.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "IW3/GameIW3.h"
#include "IW4/GameIW4.h"
#include "IW5/GameIW5.h"
#include "QOS/GameQOS.h"
#include "T4/GameT4.h"
#include "T5/GameT5.h"
#include "T6/GameT6.h"
@@ -16,6 +17,7 @@ IGame* IGame::GetGameById(GameId gameId)
new IW3::Game(),
new IW4::Game(),
new IW5::Game(),
new QOS::Game(),
new T4::Game(),
new T5::Game(),
new T6::Game(),
src/Common/Game/IGame.h
+2
View File
@@ -15,6 +15,7 @@ enum class GameId : std::uint8_t
IW3,
IW4,
IW5,
QOS,
T4,
T5,
T6,
@@ -50,6 +51,7 @@ static constexpr const char* GameId_Names[]{
"IW3",
"IW4",
"IW5",
"QOS",
"T4",
"T5",
"T6",
src/Common/Game/IW3/CommonAssetIW3.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "IW3.h"
#include <cassert>
#include <type_traits>
namespace IW3
{
@@ -10,7 +11,7 @@ namespace IW3
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::XMODEL_PIECES, // ASSET_TYPE_XMODELPIECES
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::XANIM, // ASSET_TYPE_XANIMPARTS
@@ -45,6 +46,7 @@ namespace IW3
CommonAssetType::RAW_FILE, // ASSET_TYPE_RAWFILE
CommonAssetType::STRING_TABLE, // ASSET_TYPE_STRINGTABLE
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/IW3/IW3_Assets.h
+23 -1
View File
@@ -1268,10 +1268,32 @@ namespace IW3
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_WORLD = 0x2,
VERTDECL_WORLD_T1N0 = 0x3,
VERTDECL_WORLD_T1N1 = 0x4,
VERTDECL_WORLD_T2N0 = 0x5,
VERTDECL_WORLD_T2N1 = 0x6,
VERTDECL_WORLD_T2N2 = 0x7,
VERTDECL_WORLD_T3N0 = 0x8,
VERTDECL_WORLD_T3N1 = 0x9,
VERTDECL_WORLD_T3N2 = 0xA,
VERTDECL_WORLD_T4N0 = 0xB,
VERTDECL_WORLD_T4N1 = 0xC,
VERTDECL_WORLD_T4N2 = 0xD,
VERTDECL_POS_TEX = 0xE,
VERTDECL_STATICMODELCACHE = 0xF,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[16];
void /*IDirect3DVertexDeclaration9*/* decl[16];
void /*IDirect3DVertexDeclaration9*/* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
src/Common/Game/IW4/CommonAssetIW4.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "IW4.h"
#include <cassert>
#include <type_traits>
namespace IW4
{
@@ -10,7 +11,7 @@ namespace IW4
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::PHYS_COLL_MAP, // ASSET_TYPE_PHYSCOLLMAP
CommonAssetType::XANIM, // ASSET_TYPE_XANIMPARTS
@@ -55,6 +56,7 @@ namespace IW4
CommonAssetType::VEHICLE, // ASSET_TYPE_VEHICLE
CommonAssetType::ADDON_MAP_ENTS, // ASSET_TYPE_ADDON_MAP_ENTS
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/IW4/IW4_Assets.h
+23 -1
View File
@@ -1270,10 +1270,32 @@ namespace IW4
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_WORLD = 0x2,
VERTDECL_WORLD_T1N0 = 0x3,
VERTDECL_WORLD_T1N1 = 0x4,
VERTDECL_WORLD_T2N0 = 0x5,
VERTDECL_WORLD_T2N1 = 0x6,
VERTDECL_WORLD_T2N2 = 0x7,
VERTDECL_WORLD_T3N0 = 0x8,
VERTDECL_WORLD_T3N1 = 0x9,
VERTDECL_WORLD_T3N2 = 0xA,
VERTDECL_WORLD_T4N0 = 0xB,
VERTDECL_WORLD_T4N1 = 0xC,
VERTDECL_WORLD_T4N2 = 0xD,
VERTDECL_POS_TEX = 0xE,
VERTDECL_STATICMODELCACHE = 0xF,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[13];
void /*IDirect3DVertexDeclaration9*/* decl[16];
void /*IDirect3DVertexDeclaration9*/* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
src/Common/Game/IW5/CommonAssetIW5.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "IW5.h"
#include <cassert>
#include <type_traits>
namespace IW5
{
@@ -10,7 +11,7 @@ namespace IW5
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::PHYS_COLL_MAP, // ASSET_TYPE_PHYSCOLLMAP
CommonAssetType::XANIM, // ASSET_TYPE_XANIMPARTS
@@ -58,6 +59,7 @@ namespace IW5
CommonAssetType::VEHICLE, // ASSET_TYPE_VEHICLE
CommonAssetType::ADDON_MAP_ENTS, // ASSET_TYPE_ADDON_MAP_ENTS
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/IW5/IW5_Assets.h
+24 -2
View File
@@ -1272,16 +1272,38 @@ namespace IW5
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_WORLD = 0x2,
VERTDECL_WORLD_T1N0 = 0x3,
VERTDECL_WORLD_T1N1 = 0x4,
VERTDECL_WORLD_T2N0 = 0x5,
VERTDECL_WORLD_T2N1 = 0x6,
VERTDECL_WORLD_T2N2 = 0x7,
VERTDECL_WORLD_T3N0 = 0x8,
VERTDECL_WORLD_T3N1 = 0x9,
VERTDECL_WORLD_T3N2 = 0xA,
VERTDECL_WORLD_T4N0 = 0xB,
VERTDECL_WORLD_T4N1 = 0xC,
VERTDECL_WORLD_T4N2 = 0xD,
VERTDECL_POS_TEX = 0xE,
VERTDECL_STATICMODELCACHE = 0xF,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[13];
void* decl[16];
void* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
{
const char* name;
char streamCount;
unsigned char streamCount;
bool hasOptionalSource;
MaterialVertexStreamRouting routing;
};
src/Common/Game/QOS/CommonAssetQOS.cpp
+112
View File
@@ -0,0 +1,112 @@
#include "CommonAssetQOS.h"
#include "QOS.h"
#include <cassert>
#include <type_traits>
namespace QOS
{
CommonAssetTypeMapper::CommonAssetTypeMapper() = default;
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[]{
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::SOUND_CURVE, // ASSET_TYPE_SND_CURVE
CommonAssetType::CLIP_MAP, // ASSET_TYPE_CLIPMAP_SP
CommonAssetType::CLIP_MAP, // ASSET_TYPE_CLIPMAP_MP
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_MENUFILE
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::XML_TREE, // ASSET_TYPE_XMLTREE
CommonAssetType::SCENE_ANIMATION, // ASSET_TYPE_SCENE_ANIMATION
CommonAssetType::CUTSCENE, // ASSET_TYPE_CUTSCENE
CommonAssetType::CUSTOM_CAMERA, // ASSET_TYPE_CUSTOM_CAMERA
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
}
std::optional<asset_type_t> 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::SOUND_CURVE, ASSET_TYPE_SND_CURVE)
MAP_COMMON(CommonAssetType::CLIP_MAP, ASSET_TYPE_CLIPMAP_MP)
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_MENUFILE)
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::XML_TREE, ASSET_TYPE_XMLTREE)
MAP_COMMON(CommonAssetType::SCENE_ANIMATION, ASSET_TYPE_SCENE_ANIMATION)
MAP_COMMON(CommonAssetType::CUTSCENE, ASSET_TYPE_CUTSCENE)
MAP_COMMON(CommonAssetType::CUSTOM_CAMERA, ASSET_TYPE_CUSTOM_CAMERA)
default:
return std::nullopt;
}
#undef MAP_COMMON
}
} // namespace QOS
src/Common/Game/QOS/CommonAssetQOS.h
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "Game/CommonAsset.h"
namespace QOS
{
class CommonAssetTypeMapper final : public ICommonAssetTypeMapper
{
public:
CommonAssetTypeMapper();
[[nodiscard]] CommonAssetType GameToCommonAssetType(asset_type_t gameAssetType) const override;
[[nodiscard]] std::optional<asset_type_t> CommonToGameAssetType(CommonAssetType commonAssetType) const override;
};
} // namespace QOS
src/Common/Game/QOS/CommonQOS.cpp
+37
View File
@@ -0,0 +1,37 @@
#include "CommonQOS.h"
#include "Utils/Pack.h"
#include <cmath>
using namespace QOS;
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);
}
src/Common/Game/QOS/CommonQOS.h
+30
View File
@@ -0,0 +1,30 @@
#pragma once
#include "QOS.h"
#include "Utils/Djb2.h"
#include <cstdint>
namespace QOS
{
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)
{
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 QOS
src/Common/Game/QOS/GameQOS.cpp
+88
View File
@@ -0,0 +1,88 @@
#include "GameQOS.h"
#include "QOS.h"
#include <type_traits>
using namespace QOS;
namespace
{
constexpr const char* ASSET_TYPE_NAMES[]{
"xmodelpieces",
"physpreset",
"physconstraints",
"destructibledef",
"xanim",
"xmodel",
"material",
"techniqueset",
"image",
"sound",
"soundcurve",
"clipmap_unused",
"clipmap",
"comworld",
"gameworldsp",
"gameworldmp",
"mapents",
"gfxworld",
"lightdef",
"uimap",
"font",
"menulist",
"menu",
"localize",
"weapon",
"snddriverglobals",
"fx",
"impactfx",
"aitype",
"mptype",
"character",
"xmodelalias",
"rawfile",
"stringtable",
"xmltree",
"sceneanimation",
"cutscene",
"customcamera",
};
static_assert(std::extent_v<decltype(ASSET_TYPE_NAMES)> == ASSET_TYPE_COUNT);
constexpr const char* SUB_ASSET_TYPE_NAMES[]{
"technique",
"vertexdecl",
"vertexshader",
"pixelshader",
"accuracygraph",
};
static_assert(std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)> == SUB_ASSET_TYPE_COUNT);
} // namespace
namespace QOS
{
Game::Game()
: AbstractGame(ASSET_TYPE_NAMES, std::extent_v<decltype(ASSET_TYPE_NAMES)>, SUB_ASSET_TYPE_NAMES, std::extent_v<decltype(SUB_ASSET_TYPE_NAMES)>)
{
AddAssetTypeNameAlias<AssetTechniqueSet>("techset");
AddAssetTypeNameAlias<AssetLightDef>("gfxlightdef");
}
GameId Game::GetId() const
{
return GameId::QOS;
}
const std::string& Game::GetFullName() const
{
static std::string fullName = "007: Quantum of Solace";
return fullName;
}
const std::string& Game::GetShortName() const
{
static std::string shortName = "QOS";
return shortName;
}
} // namespace QOS
src/Common/Game/QOS/GameQOS.h
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "Game/IGame.h"
namespace QOS
{
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 QOS
src/Common/Game/QOS/QOS.h
+163
View File
@@ -0,0 +1,163 @@
#pragma once
// clang-format off: Order of includes matters here
#include "Game/IAsset.h"
#include "QOS_Assets.h"
// clang-format on
namespace QOS
{
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_SND_CURVE,
ASSET_TYPE_CLIPMAP_SP,
ASSET_TYPE_CLIPMAP_MP,
ASSET_TYPE_COMWORLD,
ASSET_TYPE_GAMEWORLD_SP,
ASSET_TYPE_GAMEWORLD_MP,
ASSET_TYPE_MAP_ENTS,
ASSET_TYPE_GFXWORLD,
ASSET_TYPE_LIGHT_DEF,
ASSET_TYPE_UI_MAP,
ASSET_TYPE_FONT,
ASSET_TYPE_MENUFILE,
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_XMLTREE,
ASSET_TYPE_SCENE_ANIMATION,
ASSET_TYPE_CUTSCENE,
ASSET_TYPE_CUSTOM_CAMERA,
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_ACCURACY_GRAPH,
SUB_ASSET_TYPE_COUNT
};
struct ZoneHeaderQos
{
uint32_t version;
};
struct ScriptStringList
{
int count;
const char** strings;
};
struct XAsset
{
XAssetType type;
XAssetHeader header;
};
struct XAssetList
{
ScriptStringList stringList;
int assetCount;
XAsset* assets;
};
using AssetPhysPreset = Asset<ASSET_TYPE_PHYSPRESET, PhysPreset>;
using AssetPhysConstraints = Asset<ASSET_TYPE_PHYSCONSTRAINTS, PhysConstraints>;
using AssetDestructibleDef = Asset<ASSET_TYPE_DESTRUCTIBLEDEF, DestructibleDef>;
using AssetXAnim = Asset<ASSET_TYPE_XANIMPARTS, XAnimParts>;
using AssetXModel = Asset<ASSET_TYPE_XMODEL, XModel>;
using AssetMaterial = Asset<ASSET_TYPE_MATERIAL, Material>;
using AssetTechniqueSet = Asset<ASSET_TYPE_TECHNIQUE_SET, MaterialTechniqueSet>;
using AssetImage = Asset<ASSET_TYPE_IMAGE, GfxImage>;
using AssetSound = Asset<ASSET_TYPE_SOUND, snd_alias_list_t>;
using AssetSoundCurve = Asset<ASSET_TYPE_SND_CURVE, SndCurve>;
using AssetClipMapSp = Asset<ASSET_TYPE_CLIPMAP_SP, clipMap_t>;
using AssetClipMapMp = Asset<ASSET_TYPE_CLIPMAP_MP, clipMap_t>;
using AssetComWorld = Asset<ASSET_TYPE_COMWORLD, ComWorld>;
using AssetGameWorldSp = Asset<ASSET_TYPE_GAMEWORLD_SP, GameWorldSp>;
using AssetGameWorldMp = Asset<ASSET_TYPE_GAMEWORLD_MP, GameWorldMp>;
using AssetMapEnts = Asset<ASSET_TYPE_MAP_ENTS, MapEnts>;
using AssetGfxWorld = Asset<ASSET_TYPE_GFXWORLD, GfxWorld>;
using AssetLightDef = Asset<ASSET_TYPE_LIGHT_DEF, GfxLightDef>;
using AssetFont = Asset<ASSET_TYPE_FONT, Font_s>;
using AssetMenuList = Asset<ASSET_TYPE_MENUFILE, MenuList>;
using AssetMenu = Asset<ASSET_TYPE_MENU, menuDef_t>;
using AssetLocalize = Asset<ASSET_TYPE_LOCALIZE_ENTRY, LocalizeEntry>;
using AssetWeapon = Asset<ASSET_TYPE_WEAPON, WeaponDef>;
using AssetFx = Asset<ASSET_TYPE_FX, FxEffectDef>;
using AssetImpactFx = Asset<ASSET_TYPE_IMPACT_FX, FxImpactTable>;
using AssetRawFile = Asset<ASSET_TYPE_RAWFILE, RawFile>;
using AssetStringTable = Asset<ASSET_TYPE_STRINGTABLE, StringTable>;
using AssetXmlTree = Asset<ASSET_TYPE_XMLTREE, XmlTree>;
using AssetSceneAnimation = Asset<ASSET_TYPE_SCENE_ANIMATION, SceneAnimation>;
using AssetCutscene = Asset<ASSET_TYPE_CUTSCENE, Cutscene>;
using AssetCustomCamera = Asset<ASSET_TYPE_CUSTOM_CAMERA, CustomCamera>;
using SubAssetTechnique = SubAsset<SUB_ASSET_TYPE_TECHNIQUE, MaterialTechnique>;
using SubAssetVertexDecl = SubAsset<SUB_ASSET_TYPE_VERTEX_DECL, MaterialVertexDeclaration>;
using SubAssetVertexShader = SubAsset<SUB_ASSET_TYPE_VERTEX_SHADER, MaterialVertexShader>;
using SubAssetPixelShader = SubAsset<SUB_ASSET_TYPE_PIXEL_SHADER, MaterialPixelShader>;
} // namespace QOS
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetPhysPreset, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetPhysConstraints, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetDestructibleDef, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetXAnim, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetXModel, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetMaterial, info.name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetTechniqueSet, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetImage, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetSound, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetSoundCurve, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetClipMapSp, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetClipMapMp, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetComWorld, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetGameWorldSp, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetGameWorldMp, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetMapEnts, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetGfxWorld, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetLightDef, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetFont, fontName);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetMenuList, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetMenu, window.name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetLocalize, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetWeapon, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetFx, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetImpactFx, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetRawFile, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetStringTable, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetXmlTree, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetSceneAnimation, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetCutscene, name);
DEFINE_ASSET_NAME_ACCESSOR(QOS::AssetCustomCamera, name);
src/Common/Game/QOS/QOS_Assets.h
+2648
View File
File diff suppressed because it is too large Load Diff
src/Common/Game/T4/CommonAssetT4.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "T4.h"
#include <cassert>
#include <type_traits>
namespace T4
{
@@ -10,7 +11,7 @@ namespace T4
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::XMODEL_PIECES, // ASSET_TYPE_XMODELPIECES
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::PHYS_CONSTRAINTS, // ASSET_TYPE_PHYSCONSTRAINTS
@@ -47,6 +48,7 @@ namespace T4
CommonAssetType::STRING_TABLE, // ASSET_TYPE_STRINGTABLE
CommonAssetType::PACK_INDEX, // ASSET_TYPE_PACK_INDEX
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/T4/T4_Assets.h
+25 -2
View File
@@ -448,8 +448,8 @@ namespace T4
void /*IDirect3DVertexBuffer9*/* vb0;
unsigned int vertListCount;
XRigidVertList* vertList;
int partBits[4];
void /*IDirect3DIndexBuffer9*/* indexBuffer;
int partBits[4];
};
struct XModelLodInfo
@@ -1356,10 +1356,33 @@ namespace T4
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_WORLD = 0x2,
VERTDECL_3 = 0x3,
VERTDECL_4 = 0x4,
VERTDECL_5 = 0x5,
VERTDECL_6 = 0x6,
VERTDECL_7 = 0x7,
VERTDECL_8 = 0x8,
VERTDECL_9 = 0x9,
VERTDECL_A = 0xA,
VERTDECL_B = 0xB,
VERTDECL_C = 0xC,
VERTDECL_D = 0xD,
VERTDECL_E = 0xE,
VERTDECL_F = 0xF,
VERTDECL_10 = 0x10,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[16];
void /*IDirect3DVertexDeclaration9*/* decl[17];
void /*IDirect3DVertexDeclaration9*/* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
src/Common/Game/T5/CommonAssetT5.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "T5.h"
#include <cassert>
#include <type_traits>
namespace T5
{
@@ -10,7 +11,7 @@ namespace T5
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::XMODEL_PIECES, // ASSET_TYPE_XMODELPIECES
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::PHYS_CONSTRAINTS, // ASSET_TYPE_PHYSCONSTRAINTS
@@ -55,6 +56,7 @@ namespace T5
CommonAssetType::GLASSES, // ASSET_TYPE_GLASSES
CommonAssetType::EMBLEM_SET, // ASSET_TYPE_EMBLEMSET
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/T5/T5_Assets.h
+28 -4
View File
@@ -1123,19 +1123,43 @@ namespace T5
struct MaterialStreamRouting
{
char source;
char dest;
unsigned char source;
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_WORLD = 0x2,
VERTDECL_WORLD_T1N0 = 0x3,
VERTDECL_WORLD_T1N1 = 0x4,
VERTDECL_WORLD_T2N0 = 0x5,
VERTDECL_WORLD_T2N1 = 0x6,
VERTDECL_WORLD_T2N2 = 0x7,
VERTDECL_WORLD_T3N0 = 0x8,
VERTDECL_WORLD_T3N1 = 0x9,
VERTDECL_WORLD_T3N2 = 0xA,
VERTDECL_WORLD_T4N0 = 0xB,
VERTDECL_WORLD_T4N1 = 0xC,
VERTDECL_WORLD_T4N2 = 0xD,
VERTDECL_POS_TEX = 0xE,
VERTDECL_STATICMODELCACHE = 0xF,
VERTDECL_WATER = 0x10,
VERTDECL_PARTICLECLOUD = 0x11,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[16];
void /*IDirect3DVertexDeclaration9*/* decl[18];
void /*IDirect3DVertexDeclaration9*/* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
{
char streamCount;
unsigned char streamCount;
bool hasOptionalSource;
bool isLoaded;
MaterialVertexStreamRouting routing;
src/Common/Game/T6/CommonAssetT6.cpp
+3 -1
View File
@@ -3,6 +3,7 @@
#include "T6.h"
#include <cassert>
#include <type_traits>
namespace T6
{
@@ -10,7 +11,7 @@ namespace T6
CommonAssetType CommonAssetTypeMapper::GameToCommonAssetType(const asset_type_t gameAssetType) const
{
static CommonAssetType lookupTable[static_cast<unsigned>(ASSET_TYPE_COUNT)]{
static CommonAssetType lookupTable[]{
CommonAssetType::XMODEL_PIECES, // ASSET_TYPE_XMODELPIECES
CommonAssetType::PHYS_PRESET, // ASSET_TYPE_PHYSPRESET
CommonAssetType::PHYS_CONSTRAINTS, // ASSET_TYPE_PHYSCONSTRAINTS
@@ -72,6 +73,7 @@ namespace T6
CommonAssetType::FOOTSTEP_FX_TABLE, // ASSET_TYPE_FOOTSTEPFX_TABLE
CommonAssetType::ZBARRIER, // ASSET_TYPE_ZBARRIER
};
static_assert(std::extent_v<decltype(lookupTable)> == static_cast<unsigned>(ASSET_TYPE_COUNT));
assert(gameAssetType < ASSET_TYPE_COUNT);
return lookupTable[gameAssetType];
src/Common/Game/T6/T6_Assets.h
+27 -1
View File
@@ -5831,10 +5831,36 @@ namespace T6
unsigned char dest;
};
enum MaterialVertexDeclType
{
VERTDECL_GENERIC = 0x0,
VERTDECL_PACKED = 0x1,
VERTDECL_PACKED_LMAP_VC = 0x2,
VERTDECL_WORLD = 0x3,
VERTDECL_PACKED_WORLD = 0x4,
VERTDECL_PACKED_WORLD_T1N0 = 0x5,
VERTDECL_PACKED_WORLD_T1N1 = 0x6,
VERTDECL_PACKED_WORLD_T2N0 = 0x7,
VERTDECL_PACKED_WORLD_T2N1 = 0x8,
VERTDECL_PACKED_WORLD_T2N2 = 0x9,
VERTDECL_PACKED_WORLD_T3N0 = 0xA,
VERTDECL_PACKED_WORLD_T3N1 = 0xB,
VERTDECL_PACKED_WORLD_T3N2 = 0xC,
VERTDECL_PACKED_WORLD_T4N0 = 0xD,
VERTDECL_PACKED_WORLD_T4N1 = 0xE,
VERTDECL_PACKED_WORLD_T4N2 = 0xF,
VERTDECL_POS_TEX = 0x10,
VERTDECL_PARTICLECLOUD = 0x11,
VERTDECL_POS_COLOR = 0x12,
VERTDECL_POS_FP16TEX = 0x13,
VERTDECL_COUNT
};
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[16];
void /*ID3D11InputLayout*/* decl[20];
void /*ID3D11InputLayout*/* decl[VERTDECL_COUNT];
};
struct MaterialVertexDeclaration
src/ModMan/Web/Binds/AssetBinds.cpp
+4
View File
@@ -82,6 +82,10 @@ NLOHMANN_JSON_SERIALIZE_ENUM(CommonAssetType,
{CommonAssetType::FOOTSTEP_TABLE, "footstep_table" },
{CommonAssetType::FOOTSTEP_FX_TABLE, "footstep_fx_table" },
{CommonAssetType::ZBARRIER, "zbarrier" },
{CommonAssetType::XML_TREE, "xml_tree" },
{CommonAssetType::SCENE_ANIMATION, "scene_animation" },
{CommonAssetType::CUTSCENE, "cutscene" },
{CommonAssetType::CUSTOM_CAMERA, "custom_camera" },
});
namespace
src/ModMan/Web/Binds/ZoneBinds.cpp
+1
View File
@@ -10,6 +10,7 @@ NLOHMANN_JSON_SERIALIZE_ENUM(GameId,
{GameId::IW3, "iw3"},
{GameId::IW4, "iw4"},
{GameId::IW5, "iw5"},
{GameId::QOS, "qos"},
{GameId::T4, "t4" },
{GameId::T5, "t5" },
{GameId::T6, "t6" },
src/ModManUi/src/i18n/i18n.ts
+4
View File
@@ -89,6 +89,10 @@ const ASSET_TYPE_LOOKUP: Record<CommonAssetType, string> = {
footstep_table: "Footstep table",
footstep_fx_table: "Footstep FX table",
zbarrier: "ZBarrier",
xml_tree: "XML tree",
scene_animation: "Scene animation",
cutscene: "Cutscene",
custom_camera: "Custom camera",
};
export function localizeAssetType(assetType: CommonAssetType): string {
src/ModManUi/src/meta/GameAssetTypes.ts
+40
View File
@@ -130,6 +130,46 @@ const ASSET_TYPES_BY_GAME: Record<GameId, CommonAssetType[]> = {
"vehicle",
"addon_map_ents",
],
qos: [
"xmodel_pieces",
"phys_preset",
"phys_constraints",
"destructible_def",
"xanim",
"xmodel",
"material",
"technique_set",
"image",
"sound",
"sound_curve",
"clip_map",
"clip_map",
"com_world",
"game_world_sp",
"game_world_mp",
"map_ents",
"gfx_world",
"light_def",
"ui_map",
"font",
"menu_list",
"menu",
"localize_entry",
"weapon",
"sound_driver_globals",
"fx",
"impact_fx",
"ai_type",
"mp_type",
"character",
"xmodel_alias",
"raw_file",
"string_table",
"xml_tree",
"scene_animation",
"cutscene",
"custom_camera",
],
t4: [
"xmodel_pieces",
"phys_preset",
src/ModManUi/src/native/AssetBinds.ts
+5 -1
View File
@@ -73,7 +73,11 @@ export type CommonAssetType =
| "slug"
| "footstep_table"
| "footstep_fx_table"
| "zbarrier";
| "zbarrier"
| "xml_tree"
| "scene_animation"
| "cutscene"
| "custom_camera";
export interface AssetDto {
type: CommonAssetType;
src/ModManUi/src/native/ZoneBinds.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import { getBinds } from "@webwindowed/web-api";
export type GameId = "iw3" | "iw4" | "iw5" | "t4" | "t5" | "t6";
export type GameId = "iw3" | "iw4" | "iw5" | "qos" | "t4" | "t5" | "t6";
export type GamePlatform = "pc" | "xbox" | "ps3" | "wiiu";
src/ObjCommon/Font/JsonFont.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Font/JsonFont" + GAME + ".h"
src/ObjCommon/InfoString/InfoString.h
+1 -1
View File
@@ -43,7 +43,7 @@ private:
class EqualValue
{
public:
constexpr bool operator()(const std::string& lhs, const std::string& rhs) const
bool operator()(const std::string& lhs, const std::string& rhs) const
{
return utils::StringEqualsIgnoreCase(lhs, rhs);
}
src/ObjCommon/XModel/JsonXModel.h.template
+5 -3
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/XModel/JsonXModel" + GAME + ".h"
@@ -10,6 +10,8 @@
#define FEATURE_IW4
#elif GAME == "IW5"
#define FEATURE_IW5
#elif GAME == "QOS"
#define FEATURE_QOS
#elif GAME == "T4"
#define FEATURE_T4
#elif GAME == "T5"
@@ -63,7 +65,7 @@ namespace GAME
std::optional<std::string> physPreset;
#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
std::optional<std::string> physCollmap;
#elif defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
#elif defined(FEATURE_QOS) || defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
std::optional<std::string> physConstraints;
#endif
#if defined(FEATURE_T6)
@@ -82,7 +84,7 @@ namespace GAME
physPreset,
#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
physCollmap,
#elif defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
#elif defined(FEATURE_QOS) || defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
physConstraints,
#endif
#if defined(FEATURE_T6)
src/ObjCompiling/Game/QOS/ObjCompilerQOS.cpp
+22
View File
@@ -0,0 +1,22 @@
#include "ObjCompilerQOS.h"
using namespace QOS;
void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
Zone& zone,
const ZoneDefinitionContext& zoneDefinition,
ISearchPath& searchPath,
IGdtQueryable& gdt,
ZoneAssetCreationStateContainer& zoneStates,
IOutputPath& outDir,
IOutputPath& cacheDir) const
{
(void)collection;
(void)zone;
(void)zoneDefinition;
(void)searchPath;
(void)gdt;
(void)zoneStates;
(void)outDir;
(void)cacheDir;
}
src/ObjCompiling/Game/QOS/ObjCompilerQOS.h
+19
View File
@@ -0,0 +1,19 @@
#pragma once
#include "IObjCompiler.h"
namespace QOS
{
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 QOS
src/ObjCompiling/IObjCompiler.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "Game/IW3/ObjCompilerIW3.h"
#include "Game/IW4/ObjCompilerIW4.h"
#include "Game/IW5/ObjCompilerIW5.h"
#include "Game/QOS/ObjCompilerQOS.h"
#include "Game/T4/ObjCompilerT4.h"
#include "Game/T5/ObjCompilerT5.h"
#include "Game/T6/ObjCompilerT6.h"
@@ -15,6 +16,7 @@ const IObjCompiler* IObjCompiler::GetObjCompilerForGame(GameId game)
new IW3::ObjCompiler(),
new IW4::ObjCompiler(),
new IW5::ObjCompiler(),
new QOS::ObjCompiler(),
new T4::ObjCompiler(),
new T5::ObjCompiler(),
new T6::ObjCompiler(),
src/ObjImage/Image/Dx9TextureLoader.cpp
+29 -8
View File
@@ -2,12 +2,26 @@
#include <cstring>
namespace
{
void CopyMipLevel(image::Texture& texture, const int currentMipLevel, const int faceCount, const uint8_t*& currentDataOffset)
{
for (auto currentFace = 0; currentFace < faceCount; currentFace++)
{
const auto mipSize = texture.GetSizeOfMipLevel(currentMipLevel);
memcpy(texture.GetBufferForMipLevel(currentMipLevel, currentFace), currentDataOffset, mipSize);
currentDataOffset += mipSize;
}
}
} // namespace
namespace image
{
Dx9TextureLoader::Dx9TextureLoader()
: m_format(oat::D3DFMT_UNKNOWN),
m_type(TextureType::T_2D),
m_has_mip_maps(false),
m_mip_map_order(MipMapDataOrder::LargestToSmallest),
m_width(1u),
m_height(1u),
m_depth(1u)
@@ -43,6 +57,12 @@ namespace image
return *this;
}
Dx9TextureLoader& Dx9TextureLoader::MipMapOrder(const MipMapDataOrder mipMapOrder)
{
m_mip_map_order = mipMapOrder;
return *this;
}
Dx9TextureLoader& Dx9TextureLoader::Width(const unsigned width)
{
m_width = width;
@@ -90,16 +110,17 @@ namespace image
texture->Allocate();
const auto mipMapCount = m_has_mip_maps ? texture->GetMipMapCount() : 1;
const auto faceCount = m_type == TextureType::T_CUBE ? 6 : 1;
const void* currentDataOffset = data;
auto* currentDataOffset = static_cast<const uint8_t*>(data);
for (auto currentMipLevel = 0; currentMipLevel < mipMapCount; currentMipLevel++)
if (m_mip_map_order == MipMapDataOrder::LargestToSmallest)
{
for (auto currentFace = 0; currentFace < faceCount; currentFace++)
{
const auto mipSize = texture->GetSizeOfMipLevel(currentMipLevel);
memcpy(texture->GetBufferForMipLevel(currentMipLevel, currentFace), currentDataOffset, mipSize);
currentDataOffset = reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(currentDataOffset) + mipSize);
}
for (auto currentMipLevel = 0; currentMipLevel < mipMapCount; currentMipLevel++)
CopyMipLevel(*texture, currentMipLevel, faceCount, currentDataOffset);
}
else
{
for (auto currentMipLevel = mipMapCount - 1; currentMipLevel >= 0; currentMipLevel--)
CopyMipLevel(*texture, currentMipLevel, faceCount, currentDataOffset);
}
return texture;
src/ObjImage/Image/Dx9TextureLoader.h
+8
View File
@@ -10,11 +10,18 @@ namespace image
class Dx9TextureLoader
{
public:
enum class MipMapDataOrder
{
LargestToSmallest,
SmallestToLargest,
};
Dx9TextureLoader();
Dx9TextureLoader& Format(oat::D3DFORMAT format);
Dx9TextureLoader& Type(TextureType textureType);
Dx9TextureLoader& HasMipMaps(bool hasMipMaps);
Dx9TextureLoader& MipMapOrder(MipMapDataOrder mipMapOrder);
Dx9TextureLoader& Width(unsigned width);
Dx9TextureLoader& Height(unsigned height);
Dx9TextureLoader& Depth(unsigned depth);
@@ -27,6 +34,7 @@ namespace image
oat::D3DFORMAT m_format;
TextureType m_type;
bool m_has_mip_maps;
MipMapDataOrder m_mip_map_order;
unsigned m_width;
unsigned m_height;
unsigned m_depth;
src/ObjLoading/Game/AutoSearchPaths.cpp
+2
View File
@@ -4,6 +4,7 @@
#include "IW4/AutoSearchPathsIW4.h"
#include "IW4/InfoString/InfoStringToStructConverter.h"
#include "IW5/AutoSearchPathsIW5.h"
#include "QOS/AutoSearchPathsQOS.h"
#include "T4/AutoSearchPathsT4.h"
#include "T5/AutoSearchPathsT5.h"
#include "T6/AutoSearchPathsT6.h"
@@ -76,6 +77,7 @@ AutoSearchPaths* AutoSearchPaths::GetForGame(GameId gameId)
new AutoSearchPathsIW3(),
new AutoSearchPathsIW4(),
new AutoSearchPathsIW5(),
new AutoSearchPathsQOS(),
new AutoSearchPathsT4(),
new AutoSearchPathsT5(),
new AutoSearchPathsT6(),
src/ObjLoading/Game/QOS/AutoSearchPathsQOS.cpp
+22
View File
@@ -0,0 +1,22 @@
#include "AutoSearchPathsQOS.h"
const std::vector<std::string>& AutoSearchPathsQOS::RecognizedZoneDirs() const
{
static std::vector<std::string> recognizedZoneDirs = {
"zone",
"zone/english",
"zone/french",
"zone/german",
"zone/italian",
"zone/spanish",
};
return recognizedZoneDirs;
}
const std::vector<std::string>& AutoSearchPathsQOS::AdditionalSearchPaths() const
{
static std::vector<std::string> additionalSearchPaths = {
"main",
};
return additionalSearchPaths;
}
src/ObjLoading/Game/QOS/AutoSearchPathsQOS.h
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#include "Game/AutoSearchPaths.h"
class AutoSearchPathsQOS final : public AutoSearchPaths
{
protected:
[[nodiscard]] const std::vector<std::string>& RecognizedZoneDirs() const override;
[[nodiscard]] const std::vector<std::string>& AdditionalSearchPaths() const override;
};
src/ObjLoading/Game/QOS/Localize/AssetLoaderLocalizeQOS.cpp
+44
View File
@@ -0,0 +1,44 @@
#include "AssetLoaderLocalizeQOS.h"
#include "Localize/CommonLocalizeLoader.h"
using namespace QOS;
namespace
{
class LocalizeLoader final : public AssetCreator<AssetLocalize>, 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<LocalizeEntry>();
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<AssetLocalize>(localizeEntry.m_key, asset));
}
private:
MemoryManager& m_memory;
};
} // namespace
namespace localize
{
std::unique_ptr<AssetCreator<AssetLocalize>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath, Zone& zone)
{
return std::make_unique<LocalizeLoader>(memory, searchPath, zone);
}
} // namespace localize
src/ObjLoading/Game/QOS/Localize/AssetLoaderLocalizeQOS.h
+14
View File
@@ -0,0 +1,14 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/QOS/QOS.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include "Zone/Zone.h"
#include <memory>
namespace localize
{
std::unique_ptr<AssetCreator<QOS::AssetLocalize>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath, Zone& zone);
} // namespace localize
src/ObjLoading/Game/QOS/ObjLoaderQOS.cpp
+113
View File
@@ -0,0 +1,113 @@
#include "ObjLoaderQOS.h"
#include "Asset/GlobalAssetPoolsLoader.h"
#include "Game/QOS/AssetMarkerQOS.h"
#include "Game/QOS/QOS.h"
#include "Localize/AssetLoaderLocalizeQOS.h"
#include "RawFile/AssetLoaderRawFileQOS.h"
#include "StringTable/AssetLoaderStringTableQOS.h"
using namespace QOS;
void ObjLoader::LoadReferencedContainersForZone(ISearchPath& searchPath, Zone& zone) const
{
(void)searchPath;
(void)zone;
}
void ObjLoader::UnloadContainersOfZone(Zone& zone) const
{
(void)zone;
}
namespace
{
void ConfigureDefaultCreators(AssetCreatorCollection& collection, Zone& zone)
{
auto& memory = zone.Memory();
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysPreset>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetPhysConstraints>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetDestructibleDef>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetXAnim>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetXModel>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetMaterial>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetTechniqueSet>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetImage>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetSound>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetSoundCurve>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetClipMapMp>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetComWorld>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetGameWorldSp>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetGameWorldMp>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetMapEnts>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetGfxWorld>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetLightDef>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetFont>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetMenuList>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetMenu>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetLocalize>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetWeapon>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetFx>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetImpactFx>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetRawFile>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetStringTable>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetXmlTree>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetSceneAnimation>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetCutscene>>(memory));
collection.AddDefaultAssetCreator(std::make_unique<DefaultAssetCreator<AssetCustomCamera>>(memory));
}
void ConfigureGlobalAssetPoolsLoaders(AssetCreatorCollection& collection, Zone& zone)
{
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysPreset>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetPhysConstraints>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetDestructibleDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXAnim>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXModel>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMaterial>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetTechniqueSet>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImage>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSound>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSoundCurve>>(zone));
// collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetClipMapMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetComWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldSp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGameWorldMp>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMapEnts>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetGfxWorld>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLightDef>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFont>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenuList>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetMenu>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetLocalize>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetWeapon>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetImpactFx>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetRawFile>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetStringTable>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetXmlTree>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetSceneAnimation>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetCutscene>>(zone));
collection.AddAssetCreator(std::make_unique<GlobalAssetPoolsLoader<AssetCustomCamera>>(zone));
}
void ConfigureLoaders(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath)
{
auto& memory = zone.Memory();
collection.AddAssetCreator(localize::CreateLoaderQOS(memory, searchPath, zone));
collection.AddAssetCreator(raw_file::CreateLoaderQOS(memory, searchPath));
collection.AddAssetCreator(string_table::CreateLoaderQOS(memory, searchPath));
}
} // namespace
void ObjLoader::ConfigureCreatorCollection(AssetCreatorCollection& collection, Zone& zone, ISearchPath& searchPath, IGdtQueryable& gdt) const
{
(void)gdt;
ConfigureDefaultCreators(collection, zone);
ConfigureLoaders(collection, zone, searchPath);
ConfigureGlobalAssetPoolsLoaders(collection, zone);
}
src/ObjLoading/Game/QOS/ObjLoaderQOS.h
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "IObjLoader.h"
#include "SearchPath/ISearchPath.h"
namespace QOS
{
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 QOS
src/ObjLoading/Game/QOS/RawFile/AssetLoaderRawFileQOS.cpp
+51
View File
@@ -0,0 +1,51 @@
#include "AssetLoaderRawFileQOS.h"
#include "Game/QOS/QOS.h"
using namespace QOS;
namespace
{
class RawFileLoader final : public AssetCreator<AssetRawFile>
{
public:
RawFileLoader(MemoryManager& memory, ISearchPath& searchPath)
: m_memory(memory),
m_search_path(searchPath)
{
}
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
{
const auto file = m_search_path.Open(assetName);
if (!file.IsOpen())
return AssetCreationResult::NoAction();
auto* rawFile = m_memory.Alloc<RawFile>();
rawFile->name = m_memory.Dup(assetName.c_str());
rawFile->len = static_cast<int>(file.m_length);
auto* fileBuffer = m_memory.Alloc<char>(static_cast<size_t>(file.m_length + 1));
file.m_stream->read(fileBuffer, file.m_length);
if (file.m_stream->gcount() != file.m_length)
return AssetCreationResult::Failure();
fileBuffer[rawFile->len] = '\0';
rawFile->buffer = fileBuffer;
return AssetCreationResult::Success(context.AddAsset<AssetRawFile>(assetName, rawFile));
}
private:
MemoryManager& m_memory;
ISearchPath& m_search_path;
};
} // namespace
namespace raw_file
{
std::unique_ptr<AssetCreator<AssetRawFile>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath)
{
return std::make_unique<RawFileLoader>(memory, searchPath);
}
} // namespace raw_file
src/ObjLoading/Game/QOS/RawFile/AssetLoaderRawFileQOS.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/QOS/QOS.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include <memory>
namespace raw_file
{
std::unique_ptr<AssetCreator<QOS::AssetRawFile>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath);
} // namespace raw_file
src/ObjLoading/Game/QOS/StringTable/AssetLoaderStringTableQOS.cpp
+45
View File
@@ -0,0 +1,45 @@
#include "AssetLoaderStringTableQOS.h"
#include "Game/QOS/QOS.h"
#include "StringTable/StringTableLoader.h"
using namespace QOS;
namespace
{
class StringTableLoader final : public AssetCreator<AssetStringTable>
{
public:
StringTableLoader(MemoryManager& memory, ISearchPath& searchPath)
: m_memory(memory),
m_search_path(searchPath)
{
}
AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
{
const auto file = m_search_path.Open(assetName);
if (!file.IsOpen())
return AssetCreationResult::NoAction();
string_table::StringTableLoaderV1<StringTable> loader;
auto* stringTable = loader.LoadFromStream(assetName, m_memory, *file.m_stream);
if (!stringTable)
return AssetCreationResult::Failure();
return AssetCreationResult::Success(context.AddAsset<AssetStringTable>(assetName, stringTable));
}
private:
MemoryManager& m_memory;
ISearchPath& m_search_path;
};
} // namespace
namespace string_table
{
std::unique_ptr<AssetCreator<AssetStringTable>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath)
{
return std::make_unique<StringTableLoader>(memory, searchPath);
}
} // namespace string_table
src/ObjLoading/Game/QOS/StringTable/AssetLoaderStringTableQOS.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "Asset/IAssetCreator.h"
#include "Game/QOS/QOS.h"
#include "SearchPath/ISearchPath.h"
#include "Utils/MemoryManager.h"
#include <memory>
namespace string_table
{
std::unique_ptr<AssetCreator<QOS::AssetStringTable>> CreateLoaderQOS(MemoryManager& memory, ISearchPath& searchPath);
} // namespace string_table
src/ObjLoading/IObjLoader.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "Game/IW3/ObjLoaderIW3.h"
#include "Game/IW4/ObjLoaderIW4.h"
#include "Game/IW5/ObjLoaderIW5.h"
#include "Game/QOS/ObjLoaderQOS.h"
#include "Game/T4/ObjLoaderT4.h"
#include "Game/T5/ObjLoaderT5.h"
#include "Game/T6/ObjLoaderT6.h"
@@ -15,6 +16,7 @@ const IObjLoader* IObjLoader::GetObjLoaderForGame(GameId game)
new IW3::ObjLoader(),
new IW4::ObjLoader(),
new IW5::ObjLoader(),
new QOS::ObjLoader(),
new T4::ObjLoader(),
new T5::ObjLoader(),
new T6::ObjLoader(),
src/ObjWriting/Font/FontDumper.cpp.template
+4 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Font/FontDumper" + GAME + ".cpp"
@@ -8,6 +8,9 @@
#define GAME_LOWER "iw4"
#elif GAME == "IW5"
#define GAME_LOWER "iw5"
#elif GAME == "QOS"
#define FEATURE_QOS
#define GAME_LOWER "qos"
#elif GAME == "T4"
#define GAME_LOWER "t4"
#elif GAME == "T5"
src/ObjWriting/Font/FontDumper.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Font/FontDumper" + GAME + ".h"
src/ObjWriting/Game/QOS/Localize/LocalizeDumperQOS.cpp
+42
View File
@@ -0,0 +1,42 @@
#include "LocalizeDumperQOS.h"
#include "Dumping/Localize/StringFileDumper.h"
#include "Localize/LocalizeCommon.h"
#include "Utils/Logging/Log.h"
#include <format>
using namespace QOS;
namespace localize
{
void DumperQOS::Dump(AssetDumpingContext& context)
{
auto localizeAssets = context.m_zone.m_pools.PoolAssets<AssetLocalize>();
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"(C:/trees/cod3/cod3/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
src/ObjWriting/Game/QOS/Localize/LocalizeDumperQOS.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "Dumping/AbstractAssetDumper.h"
#include "Game/QOS/QOS.h"
namespace localize
{
class DumperQOS final : public AbstractSingleProgressAssetDumper<QOS::AssetLocalize>
{
public:
void Dump(AssetDumpingContext& context) override;
};
} // namespace localize
src/ObjWriting/Game/QOS/ObjWriterQOS.cpp
+22
View File
@@ -0,0 +1,22 @@
#include "ObjWriterQOS.h"
#include "Game/QOS/Font/FontDumperQOS.h"
#include "Game/QOS/Image/ImageDumperQOS.h"
#include "Game/QOS/Maps/MapEntsDumperQOS.h"
#include "Game/QOS/XModel/XModelDumperQOS.h"
#include "Localize/LocalizeDumperQOS.h"
#include "RawFile/RawFileDumperQOS.h"
#include "StringTable/StringTableDumperQOS.h"
using namespace QOS;
void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context)
{
RegisterAssetDumper(std::make_unique<font::JsonDumperQOS>());
RegisterAssetDumper(std::make_unique<image::DumperQOS>());
RegisterAssetDumper(std::make_unique<localize::DumperQOS>());
RegisterAssetDumper(std::make_unique<map_ents::DumperQOS>());
RegisterAssetDumper(std::make_unique<raw_file::DumperQOS>());
RegisterAssetDumper(std::make_unique<string_table::DumperQOS>());
RegisterAssetDumper(std::make_unique<xmodel::DumperQOS>());
}
src/ObjWriting/Game/QOS/ObjWriterQOS.h
+12
View File
@@ -0,0 +1,12 @@
#pragma once
#include "ObjWriter.h"
namespace QOS
{
class ObjWriter final : public IObjWriter
{
protected:
void RegisterAssetDumpers(AssetDumpingContext& context) override;
};
} // namespace QOS
src/ObjWriting/Game/QOS/RawFile/RawFileDumperQOS.cpp
+18
View File
@@ -0,0 +1,18 @@
#include "RawFileDumperQOS.h"
using namespace QOS;
namespace raw_file
{
void DumperQOS::DumpAsset(AssetDumpingContext& context, const XAssetInfo<RawFile>& 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
src/ObjWriting/Game/QOS/RawFile/RawFileDumperQOS.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "Dumping/AbstractAssetDumper.h"
#include "Game/QOS/QOS.h"
namespace raw_file
{
class DumperQOS final : public AbstractAssetDumper<QOS::AssetRawFile>
{
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<QOS::RawFile>& asset) override;
};
} // namespace raw_file
src/ObjWriting/Game/QOS/StringTable/StringTableDumperQOS.cpp
+29
View File
@@ -0,0 +1,29 @@
#include "StringTableDumperQOS.h"
#include "Csv/CsvStream.h"
using namespace QOS;
namespace string_table
{
void DumperQOS::DumpAsset(AssetDumpingContext& context, const XAssetInfo<StringTable>& 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
src/ObjWriting/Game/QOS/StringTable/StringTableDumperQOS.h
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "Dumping/AbstractAssetDumper.h"
#include "Game/QOS/QOS.h"
namespace string_table
{
class DumperQOS final : public AbstractAssetDumper<QOS::AssetStringTable>
{
protected:
void DumpAsset(AssetDumpingContext& context, const XAssetInfo<QOS::StringTable>& asset) override;
};
} // namespace string_table
src/ObjWriting/Image/ImageDumper.cpp.template
+5 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Image/ImageDumper" + GAME + ".cpp"
@@ -18,6 +18,10 @@
#define FEATURE_IW5
#define DX9
#define IWI8
#elif GAME == "QOS"
#define FEATURE_QOS
#define DX9
#define IWI6
#elif GAME == "T4"
#define FEATURE_T4
#define DX9
src/ObjWriting/Image/ImageDumper.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME(IW3, IW4, IW5, T4, T5, T6)
#options GAME(IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Image/ImageDumper" + GAME + ".h"
src/ObjWriting/Image/ImageToCommonConverter.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "Game/IW3/Image/ImageToCommonConverterIW3.h"
#include "Game/IW4/Image/ImageToCommonConverterIW4.h"
#include "Game/IW5/Image/ImageToCommonConverterIW5.h"
#include "Game/QOS/Image/ImageToCommonConverterQOS.h"
#include "Game/T4/Image/ImageToCommonConverterT4.h"
#include "Game/T5/Image/ImageToCommonConverterT5.h"
#include "Game/T6/Image/ImageToCommonConverterT6.h"
@@ -17,6 +18,7 @@ namespace image
new ToCommonConverterIW3(),
new ToCommonConverterIW4(),
new ToCommonConverterIW5(),
new ToCommonConverterQOS(),
new ToCommonConverterT4(),
new ToCommonConverterT5(),
new ToCommonConverterT6(),
src/ObjWriting/Image/ImageToCommonConverter.cpp.template
+10 -2
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Image/ImageToCommonConverter" + GAME + ".cpp"
@@ -16,6 +16,10 @@
#define FEATURE_IW5
#define DX9
#define IWI8
#elif GAME == "QOS"
#define FEATURE_QOS
#define DX9
#define IWI6
#elif GAME == "T4"
#define FEATURE_T4
#define DX9
@@ -82,7 +86,7 @@ namespace
#endif
const auto& loadDef = *image.texture.loadDef;
#if defined(FEATURE_IW3) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_QOS) || 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);
@@ -106,6 +110,10 @@ namespace
#ifdef DX9
textureLoader.Format(static_cast<oat::D3DFORMAT>(loadDef.format));
#ifdef FEATURE_QOS
// The QOS executable uploads embedded load-def mip data from the smallest mip to the largest.
textureLoader.MipMapOrder(Dx9TextureLoader::MipMapDataOrder::SmallestToLargest);
#endif
#else
textureLoader.Format(static_cast<oat::DXGI_FORMAT>(loadDef.format));
#endif
src/ObjWriting/Image/ImageToCommonConverter.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME(IW3, IW4, IW5, T4, T5, T6)
#options GAME(IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Image/ImageToCommonConverter" + GAME + ".h"
src/ObjWriting/Maps/MapEntsDumper.cpp.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Maps/MapEntsDumper" + GAME + ".cpp"
src/ObjWriting/Maps/MapEntsDumper.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/Maps/MapEntsDumper" + GAME + ".h"
src/ObjWriting/ObjWriter.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "Game/IW3/ObjWriterIW3.h"
#include "Game/IW4/ObjWriterIW4.h"
#include "Game/IW5/ObjWriterIW5.h"
#include "Game/QOS/ObjWriterQOS.h"
#include "Game/T4/ObjWriterT4.h"
#include "Game/T5/ObjWriterT5.h"
#include "Game/T6/ObjWriterT6.h"
@@ -45,6 +46,7 @@ IObjWriter* IObjWriter::GetObjWriterForGame(GameId game)
new IW3::ObjWriter(),
new IW4::ObjWriter(),
new IW5::ObjWriter(),
new QOS::ObjWriter(),
new T4::ObjWriter(),
new T5::ObjWriter(),
new T6::ObjWriter(),
src/ObjWriting/XModel/XModelDumper.cpp.template
+6 -3
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/XModel/XModelDumper" + GAME + ".cpp"
@@ -16,6 +16,9 @@
#elif GAME == "IW5"
#define FEATURE_IW5
#define GAME_LOWER "iw5"
#elif GAME == "QOS"
#define FEATURE_QOS
#define GAME_LOWER "qos"
#elif GAME == "T4"
#define FEATURE_T4
#define GAME_LOWER "t4"
@@ -334,7 +337,7 @@ namespace
return false;
const auto& vertList = surface.vertList[0];
#if defined(FEATURE_IW3) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_QOS) || defined(FEATURE_T4)
// IW3 has some models that are missing 1 (a single) tri in its first lod.
// It is not contained in any vert list or blend
// I think this is a bug (?), so omit anyway.
@@ -398,7 +401,7 @@ namespace
jXModel.physCollmap = AssetName(model.physCollmap->name);
#endif
#if defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
#if defined(FEATURE_QOS) || defined(FEATURE_T4) || defined(FEATURE_T5) || defined(FEATURE_T6)
if (model.physConstraints && model.physConstraints->name)
jXModel.physConstraints = AssetName(model.physConstraints->name);
#endif
src/ObjWriting/XModel/XModelDumper.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/XModel/XModelDumper" + GAME + ".h"
src/ObjWriting/XModel/XModelToCommonConverter.cpp
+2
View File
@@ -3,6 +3,7 @@
#include "Game/IW3/XModel/XModelToCommonConverterIW3.h"
#include "Game/IW4/XModel/XModelToCommonConverterIW4.h"
#include "Game/IW5/XModel/XModelToCommonConverterIW5.h"
#include "Game/QOS/XModel/XModelToCommonConverterQOS.h"
#include "Game/T4/XModel/XModelToCommonConverterT4.h"
#include "Game/T5/XModel/XModelToCommonConverterT5.h"
#include "Game/T6/XModel/XModelToCommonConverterT6.h"
@@ -17,6 +18,7 @@ namespace xmodel
new ToCommonConverterIW3(),
new ToCommonConverterIW4(),
new ToCommonConverterIW5(),
new ToCommonConverterQOS(),
new ToCommonConverterT4(),
new ToCommonConverterT5(),
new ToCommonConverterT6(),
src/ObjWriting/XModel/XModelToCommonConverter.cpp.template
+47 -6
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/XModel/XModelToCommonConverter" + GAME + ".cpp"
@@ -11,6 +11,8 @@
#define FEATURE_IW4
#elif GAME == "IW5"
#define FEATURE_IW5
#elif GAME == "QOS"
#define FEATURE_QOS
#elif GAME == "T4"
#define FEATURE_T4
#elif GAME == "T5"
@@ -34,6 +36,7 @@
#include <cassert>
#include <format>
#include <string_view>
using namespace GAME;
@@ -56,7 +59,7 @@ namespace
{
MaterialTextureDef* def = &material->textureTable[textureIndex];
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_IW5) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_IW5) || defined(FEATURE_QOS) || defined(FEATURE_T4)
if (def->semantic == TS_COLOR_MAP)
potentialTextureDefs.push_back(def);
#else
@@ -70,6 +73,32 @@ namespace
if (potentialTextureDefs.size() == 1)
return GetImageFromTextureDef(*potentialTextureDefs[0]);
#ifdef FEATURE_QOS
// QoS can tag helper maps like *_edge as TS_COLOR_MAP; prefer diffuse-style names when several candidates exist.
GfxImage* qosFallback = nullptr;
for (const auto* def : potentialTextureDefs)
{
auto* image = GetImageFromTextureDef(*def);
if (!image || !image->name)
continue;
auto name = std::string_view(image->name);
while (!name.empty() && (name.front() == ',' || name.front() == '*'))
name.remove_prefix(1);
if (name.ends_with("_c") || name.ends_with("_col") || name.ends_with("_color") || name.ends_with("_diff"))
return image;
if (!qosFallback && !name.ends_with("_edge") && !name.ends_with("_print") && !name.ends_with("_prsz")
&& name.find("_edge_") == std::string_view::npos)
{
qosFallback = image;
}
}
if (qosFallback)
return qosFallback;
#endif
for (const auto* def : potentialTextureDefs)
{
if (tolower(def->nameStart) == 'c' && tolower(def->nameEnd) == 'p')
@@ -180,7 +209,7 @@ namespace
return false;
const auto& vertList = surface.vertList[0];
#if defined(FEATURE_IW3) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_QOS) || defined(FEATURE_T4)
// IW3 has some models that are missing 1 (a single) tri in its first lod.
// It is not contained in any vert list or blend
// I think this is a bug (?), so omit anyway.
@@ -298,9 +327,12 @@ namespace
if (colorMap)
xMaterial.colorMapName = AssetName(colorMap->name);
#ifndef FEATURE_QOS
// QoS normal map decoding/selection is not verified yet; exporting them makes the preview shading misleading.
const auto* normalMap = GetMaterialNormalMap(material);
if (normalMap)
xMaterial.normalMapName = AssetName(normalMap->name);
#endif
const auto* specularMap = GetMaterialSpecularMap(material);
if (specularMap)
@@ -346,8 +378,17 @@ namespace
vertex.coordinates[1] = v.xyz.y;
vertex.coordinates[2] = v.xyz.z;
Common::Vec3UnpackUnitVec(v.normal, vertex.normal);
#ifdef FEATURE_QOS
vertex.color[0] = 1.0f;
vertex.color[1] = 1.0f;
vertex.color[2] = 1.0f;
vertex.color[3] = 1.0f;
vertex.uv[0] = v.texCoord.x;
vertex.uv[1] = v.texCoord.y;
#else
Common::Vec4UnpackGfxColor(v.color, vertex.color);
Common::Vec2UnpackTexCoords(v.texCoord, vertex.uv);
#endif
out.m_vertices.emplace_back(vertex);
}
@@ -405,7 +446,7 @@ namespace
if (surface.vertList)
{
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_QOS) || defined(FEATURE_T4)
assert(!surface.deformed);
#else
assert((surface.flags & XSURFACE_FLAG_DEFORMED) == 0);
@@ -430,7 +471,7 @@ namespace
auto vertsBlendOffset = 0u;
if (surface.vertInfo.vertsBlend)
{
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_T4)
#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_QOS) || defined(FEATURE_T4)
assert(surface.deformed);
#else
assert((surface.flags & XSURFACE_FLAG_DEFORMED) > 0);
@@ -532,7 +573,7 @@ namespace
auto& object = out.m_objects[surfIndex];
object.m_faces.reserve(surface.triCount);
#ifdef FEATURE_T4
#if defined(FEATURE_QOS) || defined(FEATURE_T4)
// T4 tri indices are local to the surface, while baseVertIndex does not match
// the flattened common vertex buffer we build here.
auto surfaceVertexOffset = 0u;
src/ObjWriting/XModel/XModelToCommonConverter.h.template
+1 -1
View File
@@ -1,4 +1,4 @@
#options GAME (IW3, IW4, IW5, T4, T5, T6)
#options GAME (IW3, IW4, IW5, QOS, T4, T5, T6)
#filename "Game/" + GAME + "/XModel/XModelToCommonConverter" + GAME + ".h"
src/ZoneCode.lua
+33
View File
@@ -110,6 +110,39 @@ ZoneCode.Assets = {
"AddonMapEnts",
},
QOS = {
"PhysPreset",
"PhysConstraints",
"DestructibleDef",
"XAnimParts",
"XModel",
"Material",
"MaterialTechniqueSet",
"GfxImage",
"snd_alias_list_t",
"SndCurve",
"clipMap_t",
"ComWorld",
"GameWorldSp",
"GameWorldMp",
"MapEnts",
"GfxWorld",
"GfxLightDef",
"Font_s",
"MenuList",
"menuDef_t",
"LocalizeEntry",
"WeaponDef",
"FxEffectDef",
"FxImpactTable",
"RawFile",
"StringTable",
"XmlTree",
"SceneAnimation",
"Cutscene",
"CustomCamera",
},
T4 = {
"PhysPreset",
"PhysConstraints",
src/ZoneCode/Game/QOS/QOS.gen
+1
View File
@@ -0,0 +1 @@
// Game: 007 Quantum of Solace (QOS)
src/ZoneCode/Game/QOS/QOS_Commands.txt
+73
View File
@@ -0,0 +1,73 @@
// Game: 007 Quantum of Solace (QOS)
game QOS;
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 SndCurve AssetSoundCurve;
asset clipMap_t AssetClipMapMp;
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 XmlTree AssetXmlTree;
asset SceneAnimation AssetSceneAnimation;
asset Cutscene AssetCutscene;
asset CustomCamera AssetCustomCamera;
// Setup blocks
block temp XFILE_BLOCK_TEMP default;
block runtime XFILE_BLOCK_RUNTIME default;
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/SndCurve.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/GfxLightDef.txt"
#include "XAssets/Font_s.txt"
#include "XAssets/MenuList.txt"
#include "XAssets/menuDef_t.txt"
#include "XAssets/LocalizeEntry.txt"
#include "XAssets/WeaponDef.txt"
#include "XAssets/FxEffectDef.txt"
#include "XAssets/FxImpactTable.txt"
#include "XAssets/RawFile.txt"
#include "XAssets/StringTable.txt"
#include "XAssets/XmlTree.txt"
#include "XAssets/SceneAnimation.txt"
#include "XAssets/Cutscene.txt"
#include "XAssets/CustomCamera.txt"
src/ZoneCode/Game/QOS/QOS_ZoneCode.h
+12
View File
@@ -0,0 +1,12 @@
#pragma once
// Entry point for QOS code generation
// clang-format off: Order of includes matters here
#include "../Common.h"
#include "../../../Common/Game/QOS/QOS_Assets.h"
// clang-format on
// EOF
src/ZoneCode/Game/QOS/XAssets/ComWorld.txt
+16
View File
@@ -0,0 +1,16 @@
// =========================================
// ComWorld
// =========================================
use ComWorld;
set block XFILE_BLOCK_TEMP;
set string name;
set count primaryLights primaryLightCount;
set count unknownCells unknownCellCount;
// ComPrimaryLight
use ComPrimaryLight;
set string defName;
// ComWorldUnknownCell
use ComWorldUnknownCell;
set count data 5120;
src/ZoneCode/Game/QOS/XAssets/CustomCamera.txt
+13
View File
@@ -0,0 +1,13 @@
// =========================================
// CustomCamera
// =========================================
use CustomCamera;
set block XFILE_BLOCK_TEMP;
set string name;
set count cameras cameraCount;
// CustomCameraDef
use CustomCameraDef;
set string name;
set string unknownString0;
set string unknownString1;
src/ZoneCode/Game/QOS/XAssets/Cutscene.txt
+25
View File
@@ -0,0 +1,25 @@
// =========================================
// Cutscene
// =========================================
use Cutscene;
set block XFILE_BLOCK_TEMP;
set string name;
set count entities entityCount;
set count sections sectionCount;
// CutsceneEntityDef
use CutsceneEntityDef;
set string unknownString0;
set string unknownString1;
set scriptstring unknownScriptString0;
set count modelAttachments modelAttachmentCount;
// CutsceneModelAttachment
use CutsceneModelAttachment;
set string unknownString0;
set string unknownString1;
// CutsceneSectionDef
use CutsceneSectionDef;
set count entities entityCount;
set count sceneAnimations sceneAnimationCount;
src/ZoneCode/Game/QOS/XAssets/DestructibleDef.txt
+25
View File
@@ -0,0 +1,25 @@
// =========================================
// DestructibleDef
// =========================================
use DestructibleDef;
set block XFILE_BLOCK_TEMP;
set string name;
set count pieces numPieces;
// DestructiblePiece
use DestructiblePiece;
set string attachBone;
set scriptstring attachBoneHash;
// DestructibleModel
use DestructibleModel;
set string breakNotify;
// 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;
src/ZoneCode/Game/QOS/XAssets/Font_s.txt
+8
View File
@@ -0,0 +1,8 @@
// =========================================
// Font_s
// =========================================
use Font_s;
set block XFILE_BLOCK_TEMP;
set string fontName;
set reusable glyphs;
set count glyphs glyphCount;
src/ZoneCode/Game/QOS/XAssets/FxEffectDef.txt
+43
View File
@@ -0,0 +1,43 @@
// =========================================
// 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;
// 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;
src/ZoneCode/Game/QOS/XAssets/FxImpactTable.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// FxImpactTable
// =========================================
use FxImpactTable;
set block XFILE_BLOCK_TEMP;
set string name;
set count table 13;
src/ZoneCode/Game/QOS/XAssets/GameWorldMp.txt
+6
View File
@@ -0,0 +1,6 @@
// =========================================
// GameWorldMp
// =========================================
use GameWorldMp;
set block XFILE_BLOCK_TEMP;
set string name;
src/ZoneCode/Game/QOS/XAssets/GameWorldSp.txt
+39
View File
@@ -0,0 +1,39 @@
// =========================================
// GameWorldSp
// =========================================
use GameWorldSp;
set block XFILE_BLOCK_TEMP;
set string name;
// PathData
use PathData;
set count nodes nodeCount;
set condition basenodes never;
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;
set reusable pathnode_tree_nodes_t::nodes;
src/ZoneCode/Game/QOS/XAssets/GfxImage.txt
+20
View File
@@ -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;
src/ZoneCode/Game/QOS/XAssets/GfxLightDef.txt
+6
View File
@@ -0,0 +1,6 @@
// =========================================
// GfxLightDef
// =========================================
use GfxLightDef;
set block XFILE_BLOCK_TEMP;
set string name;
src/ZoneCode/Game/QOS/XAssets/GfxWorld.txt
+190
View File
@@ -0,0 +1,190 @@
// =========================================
// GfxWorld
// =========================================
use GfxWorld;
set block XFILE_BLOCK_TEMP;
set string name;
set string baseName;
set reusable planes;
set count planes planeCount;
set count nodes nodeCount;
set count indices indexCount;
set count surfaces surfaceCount;
set count skyStartSurfs skySurfCount;
set string skyBoxModel;
set reusable sunLight;
set count reflectionProbes reflectionProbeCount;
set count cullGroups cullGroupCount;
set count smodelDrawInsts smodelCount;
set count smodelInsts smodelCount;
set count cells cellCount;
set count lightmaps lightmapCount;
set count models modelCount;
set count materialMemory materialMemoryCount;
set block smodelVisData0 XFILE_BLOCK_RUNTIME;
set count smodelVisData0 smodelCount;
set block smodelVisData1 XFILE_BLOCK_RUNTIME;
set count smodelVisData1 smodelCount;
set block smodelVisData2 XFILE_BLOCK_RUNTIME;
set count smodelVisData2 smodelCount;
set block smodelVisData3 XFILE_BLOCK_RUNTIME;
set count smodelVisData3 smodelCount;
set block surfaceVisData0 XFILE_BLOCK_RUNTIME;
set count surfaceVisData0 models::surfaceCount;
set block surfaceVisData1 XFILE_BLOCK_RUNTIME;
set count surfaceVisData1 models::surfaceCount;
set block surfaceVisData2 XFILE_BLOCK_RUNTIME;
set count surfaceVisData2 models::surfaceCount;
set block surfaceVisData3 XFILE_BLOCK_RUNTIME;
set count surfaceVisData3 models::surfaceCount;
set block surfaceMaterials XFILE_BLOCK_RUNTIME;
set count surfaceMaterials models::surfaceCount;
set allocalign surfaceMaterials 4;
set block surfaceCastsSunShadow XFILE_BLOCK_RUNTIME;
set count surfaceCastsSunShadow (models::surfaceCount / 32) + 1;
set block cellCasterBits XFILE_BLOCK_RUNTIME;
set count cellCasterBits cellCount * ((cellCount + 31) / 32);
set block cellHasSunLitSurfsBits XFILE_BLOCK_RUNTIME;
set count cellHasSunLitSurfsBits (cellCount * 512) + 1;
set block dynEntVisData0_0 XFILE_BLOCK_RUNTIME;
set count dynEntVisData0_0 gfxSceneDynModelCount;
set block dynEntVisData0_1 XFILE_BLOCK_RUNTIME;
set count dynEntVisData0_1 gfxSceneDynModelCount;
set block dynEntVisData0_2 XFILE_BLOCK_RUNTIME;
set count dynEntVisData0_2 gfxSceneDynModelCount;
set block dynEntVisData0_3 XFILE_BLOCK_RUNTIME;
set count dynEntVisData0_3 gfxSceneDynModelCount;
set block dynEntVisData1_0 XFILE_BLOCK_RUNTIME;
set count dynEntVisData1_0 gfxSceneDynBrushCount;
set block dynEntVisData1_1 XFILE_BLOCK_RUNTIME;
set count dynEntVisData1_1 gfxSceneDynBrushCount;
set block dynEntVisData1_2 XFILE_BLOCK_RUNTIME;
set count dynEntVisData1_2 gfxSceneDynBrushCount;
set block dynEntVisData1_3 XFILE_BLOCK_RUNTIME;
set count dynEntVisData1_3 gfxSceneDynBrushCount;
set block dynEntCellBits0 XFILE_BLOCK_RUNTIME;
set count dynEntCellBits0 (cellCount * gfxSceneDynModelCount / 8) + 1;
set block dynEntCellBits1 XFILE_BLOCK_RUNTIME;
set count dynEntCellBits1 (cellCount * gfxSceneDynBrushCount / 8) + 1;
set block dynEntSortList0 XFILE_BLOCK_RUNTIME;
set count dynEntSortList0 gfxSceneDynModelCount;
set block dynEntSortList1 XFILE_BLOCK_RUNTIME;
set count dynEntSortList1 gfxSceneDynBrushCount;
set block unknownGfxDynEntCellRef0 XFILE_BLOCK_RUNTIME;
set count unknownGfxDynEntCellRef0 unknownGfxDynEntCellRefCount0;
set block unknownGfxDynEntCellRef1 XFILE_BLOCK_RUNTIME;
set count unknownGfxDynEntCellRef1 unknownGfxDynEntCellRefCount1;
set block gfxSceneDynModel XFILE_BLOCK_RUNTIME;
set count gfxSceneDynModel gfxSceneDynModelCount;
set block gfxSceneDynBrush XFILE_BLOCK_RUNTIME;
set count gfxSceneDynBrush gfxSceneDynBrushCount;
set count sortedSurfIndex models::surfaceCount;
set block primaryLightEntityShadowVis XFILE_BLOCK_RUNTIME;
set count primaryLightEntityShadowVis (primaryLightCount - sunPrimaryLightIndex - 1) * 0x1000;
set block primaryLightDynEntShadowVis0 XFILE_BLOCK_RUNTIME;
set count primaryLightDynEntShadowVis0 gfxSceneDynModelCount * (primaryLightCount - sunPrimaryLightIndex - 1);
set block primaryLightDynEntShadowVis1 XFILE_BLOCK_RUNTIME;
set count primaryLightDynEntShadowVis1 gfxSceneDynBrushCount * (primaryLightCount - sunPrimaryLightIndex - 1);
set count shadowGeom primaryLightCount;
set count massiveAdSurface massiveAdSurfaceCount;
reorder:
name
baseName
planes
nodes
indices
surfaces
skyStartSurfs
skyImage
skyBoxModel
sunLight
reflectionProbes
cullGroups
smodelDrawInsts
smodelInsts
cells
lightmaps
lightGrid
models
materialMemory
vd
vld
sun
outdoorImage
smodelVisData0
smodelVisData1
smodelVisData2
smodelVisData3
surfaceVisData0
surfaceVisData1
surfaceVisData2
surfaceVisData3
surfaceMaterials
surfaceCastsSunShadow
cellCasterBits
cellHasSunLitSurfsBits
dynEntVisData0_0
dynEntVisData1_0
dynEntVisData0_1
dynEntVisData1_1
dynEntVisData0_2
dynEntVisData1_2
dynEntVisData0_3
dynEntVisData1_3
dynEntCellBits0
dynEntCellBits1
dynEntSortList0
dynEntSortList1
unknownGfxDynEntCellRef0
unknownGfxDynEntCellRef1
gfxSceneDynModel
gfxSceneDynBrush
primaryLightEntityShadowVis
primaryLightDynEntShadowVis0
primaryLightDynEntShadowVis1
sortedSurfIndex
shadowGeom
massiveAdSurface
unknownMaterial;
// GfxWorldVertexData
use GfxWorldVertexData;
set count vertices GfxWorld::vertexCount;
set condition worldVb never;
// GfxWorldVertexLayerData
use GfxWorldVertexLayerData;
set count data GfxWorld::vertexLayerDataSize;
set condition layerVb never;
// GfxCell
use GfxCell;
set count portals portalCount;
set count cullGroups cullGroupCount;
set count reflectionProbes reflectionProbeCount;
// GfxAabbTree
use GfxAabbTree;
set reusable smodelIndexes;
set count smodelIndexes smodelIndexCount;
set count children childCount;
// GfxAabbTreeChildren
use GfxAabbTreeChildren;
// GfxPortal
use GfxPortal;
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;
// GfxShadowGeometry
use GfxShadowGeometry;
set count sortedSurfIndex surfaceCount;
set count smodelIndex smodelCount;
src/ZoneCode/Game/QOS/XAssets/LocalizeEntry.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// LocalizeEntry
// =========================================
use LocalizeEntry;
set block XFILE_BLOCK_TEMP;
set string name;
set string value;
src/ZoneCode/Game/QOS/XAssets/MapEnts.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// MapEnts
// =========================================
use MapEnts;
set block XFILE_BLOCK_TEMP;
set string name;
set count entityString numEntityChars;
src/ZoneCode/Game/QOS/XAssets/Material.txt
+28
View File
@@ -0,0 +1,28 @@
// =========================================
// 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 block constantTable XFILE_BLOCK_VIRTUAL;
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;
// MaterialWaterDef
use MaterialWaterDef;
set reusable water;
// water_t
use water_t;
set count H0 N * M;
set count wTerm N * M;
src/ZoneCode/Game/QOS/XAssets/MaterialTechniqueSet.txt
+52
View File
@@ -0,0 +1,52 @@
// =========================================
// MaterialTechniqueSet
// =========================================
use MaterialTechniqueSet;
set block XFILE_BLOCK_TEMP;
set string name;
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;
// MaterialVertexShader
use MaterialVertexShader;
set string name;
// GfxVertexShaderLoadDef
use GfxVertexShaderLoadDef;
set count program programSize;
// MaterialPixelShader
use MaterialPixelShader;
set string name;
// GfxPixelShaderLoadDef
use GfxPixelShaderLoadDef;
set count program programSize;
// MaterialVertexStreamRouting
set condition MaterialVertexStreamRouting::decl never;
src/ZoneCode/Game/QOS/XAssets/MenuList.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// MenuList
// =========================================
use MenuList;
set block XFILE_BLOCK_TEMP;
set string name;
set count menus menuCount;
src/ZoneCode/Game/QOS/XAssets/PhysConstraints.txt
+11
View File
@@ -0,0 +1,11 @@
// =========================================
// PhysConstraints
// =========================================
use PhysConstraints;
set block XFILE_BLOCK_TEMP;
set string name;
// PhysConstraint
use PhysConstraint;
set string target_bone1;
set string target_bone2;
src/ZoneCode/Game/QOS/XAssets/PhysPreset.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// PhysPreset
// =========================================
use PhysPreset;
set block XFILE_BLOCK_TEMP;
set string name;
set string sndAliasPrefix;
src/ZoneCode/Game/QOS/XAssets/RawFile.txt
+7
View File
@@ -0,0 +1,7 @@
// =========================================
// RawFile
// =========================================
use RawFile;
set block XFILE_BLOCK_TEMP;
set string name;
set count buffer len + 1;
src/ZoneCode/Game/QOS/XAssets/SceneAnimation.txt
+12
View File
@@ -0,0 +1,12 @@
// =========================================
// SceneAnimation
// =========================================
use SceneAnimation;
set block XFILE_BLOCK_TEMP;
set string name;
set count animReferences animReferenceCount;
// AnimReference
use AnimReference;
set string unknownString0;
set scriptstring unknownScriptString0;

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