Future/T4SP-Server-Plugin
1
0
Fork 0
mirror of https://github.com/JezuzLizard/T4SP-Server-Plugin.git synced 2025-04-20 21:45:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
T4SP-Server-Plugin/src/game/xasset.hpp
ineed bots 469e8f9630 The decomp is compiling!
2023-08-31 18:56:00 -06:00

5424 lines
227 KiB
C++
Raw Blame History

#pragma once
#ifdef __cplusplus
#include <d3d9helper.h>
#endif
#ifdef __cplusplus
namespace game
{
#endif
struct pathnode_t;
struct pathnode_tree_t;
struct GfxPortal;
struct GfxCell;
struct menuDef_t;
enum XAssetType
{
ASSET_TYPE_XMODELPIECES = 0x0,
ASSET_TYPE_PHYSPRESET = 0x1,
ASSET_TYPE_PHYSCONSTRAINTS = 0x2,
ASSET_TYPE_DESTRUCTIBLEDEF = 0x3,
ASSET_TYPE_XANIMPARTS = 0x4,
ASSET_TYPE_XMODEL = 0x5,
ASSET_TYPE_MATERIAL = 0x6,
ASSET_TYPE_TECHNIQUE_SET = 0x7,
ASSET_TYPE_IMAGE = 0x8,
ASSET_TYPE_SOUND = 0x9,
ASSET_TYPE_LOADED_SOUND = 0xA,
ASSET_TYPE_CLIPMAP = 0xB,
ASSET_TYPE_CLIPMAP_PVS = 0xC,
ASSET_TYPE_COMWORLD = 0xD,
ASSET_TYPE_GAMEWORLD_SP = 0xE,
ASSET_TYPE_GAMEWORLD_MP = 0xF,
ASSET_TYPE_MAP_ENTS = 0x10,
ASSET_TYPE_GFXWORLD = 0x11,
ASSET_TYPE_LIGHT_DEF = 0x12,
ASSET_TYPE_UI_MAP = 0x13,
ASSET_TYPE_FONT = 0x14,
ASSET_TYPE_MENULIST = 0x15,
ASSET_TYPE_MENU = 0x16,
ASSET_TYPE_LOCALIZE_ENTRY = 0x17,
ASSET_TYPE_WEAPON = 0x18,
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x19,
ASSET_TYPE_FX = 0x1A,
ASSET_TYPE_IMPACT_FX = 0x1B,
ASSET_TYPE_AITYPE = 0x1C,
ASSET_TYPE_MPTYPE = 0x1D,
ASSET_TYPE_CHARACTER = 0x1E,
ASSET_TYPE_XMODELALIAS = 0x1F,
ASSET_TYPE_RAWFILE = 0x20,
ASSET_TYPE_STRINGTABLE = 0x21,
ASSET_TYPE_PACK_INDEX = 0x22,
ASSET_TYPE_COUNT = 0x23,
ASSET_TYPE_STRING = 0x23,
ASSET_TYPE_ASSETLIST = 0x24,
};
enum MapType
{
MAPTYPE_NONE = 0x0,
MAPTYPE_INVALID1 = 0x1,
MAPTYPE_INVALID2 = 0x2,
MAPTYPE_2D = 0x3,
MAPTYPE_3D = 0x4,
MAPTYPE_CUBE = 0x5,
MAPTYPE_COUNT = 0x6,
};
enum ConstraintType : __int32
{
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 : __int32
{
ATTACH_POINT_WORLD = 0x0,
ATTACH_POINT_DYNENT = 0x1,
ATTACH_POINT_ENT = 0x2,
ATTACH_POINT_BONE = 0x3,
};
enum snd_limit_type_t : __int32
{
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 : __int32
{
SND_RANDOMIZE_INSTANCE = 0x0,
SND_RANDOMIZE_ENTITY_VOLUME = 0x1,
SND_RANDOMIZE_ENTITY_PITCH = 0x2,
SND_RANDOMIZE_ENTITY_VARIANT = 0x4,
};
enum DynEntityType : __int32
{
DYNENT_TYPE_INVALID = 0x0,
DYNENT_TYPE_CLUTTER = 0x1,
DYNENT_TYPE_DESTRUCT = 0x2,
DYNENT_TYPE_COUNT = 0x3,
};
enum nodeType : __int32
{
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,
};
enum expDataType : __int32
{
VAL_INT = 0x0,
VAL_FLOAT = 0x1,
VAL_STRING = 0x2,
};
enum expOperationEnum
{
OP_NEGATE = 0x7,
NUM_EXPRESSION_OPERATORS = 0x18,
MAX_OPERATOR_VALUE = 0x4000,
};
enum snd_category_t : __int32
{
SND_CATEGORY_SFX = 0x0,
SND_CATEGORY_MUSIC = 0x1,
SND_CATEGORY_VOICE = 0x2,
};
enum weapType_t : __int32
{
WEAPTYPE_BULLET = 0x0,
WEAPTYPE_GRENADE = 0x1,
WEAPTYPE_PROJECTILE = 0x2,
WEAPTYPE_BINOCULARS = 0x3,
WEAPTYPE_GAS = 0x4,
WEAPTYPE_BOMB = 0x5,
WEAPTYPE_MINE = 0x6,
WEAPTYPE_NUM = 0x7,
};
enum weapClass_t : __int32
{
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_GAS = 0x9,
WEAPCLASS_ITEM = 0xA,
WEAPCLASS_NUM = 0xB,
};
enum PenetrateType : __int32
{
PENETRATE_TYPE_NONE = 0x0,
PENETRATE_TYPE_SMALL = 0x1,
PENETRATE_TYPE_MEDIUM = 0x2,
PENETRATE_TYPE_LARGE = 0x3,
PENETRATE_TYPE_COUNT = 0x4,
};
enum ImpactType : __int32
{
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_RIFLE_GRENADE = 0x7,
IMPACT_TYPE_ROCKET_EXPLODE = 0x8,
IMPACT_TYPE_PROJECTILE_DUD = 0x9,
IMPACT_TYPE_MORTAR_SHELL = 0xA,
IMPACT_TYPE_TANK_SHELL = 0xB,
IMPACT_TYPE_COUNT = 0xC,
};
enum weapInventoryType_t : __int32
{
WEAPINVENTORY_PRIMARY = 0x0,
WEAPINVENTORY_OFFHAND = 0x1,
WEAPINVENTORY_ITEM = 0x2,
WEAPINVENTORY_ALTMODE = 0x3,
WEAPINVENTORYCOUNT = 0x4,
};
enum weapFireType_t : __int32
{
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 : __int32
{
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 : __int32
{
WEAPSTANCE_STAND = 0x0,
WEAPSTANCE_DUCK = 0x1,
WEAPSTANCE_PRONE = 0x2,
WEAPSTANCE_NUM = 0x3,
};
enum activeReticleType_t : __int32
{
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 : __int32
{
WEAPON_ICON_RATIO_1TO1 = 0x0,
WEAPON_ICON_RATIO_2TO1 = 0x1,
WEAPON_ICON_RATIO_4TO1 = 0x2,
WEAPON_ICON_RATIO_COUNT = 0x3,
};
enum ammoCounterClipType_t : __int32
{
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 : __int32
{
WEAPOVERLAYRETICLE_NONE = 0x0,
WEAPOVERLAYRETICLE_CROSSHAIR = 0x1,
WEAPOVERLAYRETICLE_NUM = 0x2,
};
enum WeapOverlayInteface_t : __int32
{
WEAPOVERLAYINTERFACE_NONE = 0x0,
WEAPOVERLAYINTERFACE_JAVELIN = 0x1,
WEAPOVERLAYINTERFACE_TURRETSCOPE = 0x2,
WEAPOVERLAYINTERFACECOUNT = 0x3,
};
enum weapProjExposion_t : __int32
{
WEAPPROJEXP_GRENADE = 0x0,
WEAPPROJEXP_ROCKET = 0x1,
WEAPPROJEXP_FLASHBANG = 0x2,
WEAPPROJEXP_NONE = 0x3,
WEAPPROJEXP_DUD = 0x4,
WEAPPROJEXP_SMOKE = 0x5,
WEAPPROJEXP_HEAVY = 0x6,
WEAPPROJEXP_FIRE = 0x7,
WEAPPROJEXP_NAPALMBLOB = 0x8,
WEAPPROJEXP_NUM = 0x9,
};
enum WeapStickinessType : __int32
{
WEAPSTICKINESS_NONE = 0x0,
WEAPSTICKINESS_ALL = 0x1,
WEAPSTICKINESS_GROUND = 0x2,
WEAPSTICKINESS_GROUND_WITH_YAW = 0x3,
WEAPSTICKINESS_COUNT = 0x4,
};
enum guidedMissileType_t : __int32
{
MISSILE_GUIDANCE_NONE = 0x0,
MISSILE_GUIDANCE_SIDEWINDER = 0x1,
MISSILE_GUIDANCE_HELLFIRE = 0x2,
MISSILE_GUIDANCE_JAVELIN = 0x3,
MISSILE_GUIDANCE_BALLISTIC = 0x4,
MISSILE_GUIDANCE_COUNT = 0x5,
};
struct DObjAnimMat
{
float quat[4]; //OFS: 0x0 SIZE: 0x10
float trans[3]; //OFS: 0x10 SIZE: 0xC
float transWeight; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(DObjAnimMat, 0x20);
ASSERT_STRUCT_OFFSET(DObjAnimMat, quat, 0x0);
ASSERT_STRUCT_OFFSET(DObjAnimMat, trans, 0x10);
ASSERT_STRUCT_OFFSET(DObjAnimMat, transWeight, 0x1C);
struct XSurfaceVertexInfo
{
__int16 vertCount[4]; //OFS: 0x0 SIZE: 0x8
unsigned __int16* vertsBlend; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XSurfaceVertexInfo, 0xC);
ASSERT_STRUCT_OFFSET(XSurfaceVertexInfo, vertCount, 0x0);
ASSERT_STRUCT_OFFSET(XSurfaceVertexInfo, vertsBlend, 0x8);
union GfxColor
{
unsigned int packed; //OFS: 0x0 SIZE: 0x4
unsigned __int8 array[4]; //OFS: 0x1 SIZE: 0x4
};
union PackedTexCoords
{
unsigned int packed; //OFS: 0x0 SIZE: 0x4
};
union PackedUnitVec
{
unsigned int packed; //OFS: 0x0 SIZE: 0x4
};
struct GfxPackedVertex
{
float xyz[3]; //OFS: 0x0 SIZE: 0xC
float binormalSign; //OFS: 0xC SIZE: 0x4
GfxColor color; //OFS: 0x10 SIZE: 0x4
PackedTexCoords texCoord; //OFS: 0x14 SIZE: 0x4
PackedUnitVec normal; //OFS: 0x18 SIZE: 0x4
PackedUnitVec tangent; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxPackedVertex, 0x20);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, xyz, 0x0);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, binormalSign, 0xC);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, color, 0x10);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, texCoord, 0x14);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, normal, 0x18);
ASSERT_STRUCT_OFFSET(GfxPackedVertex, tangent, 0x1C);
struct __declspec(align(2)) XSurfaceCollisionAabb
{
unsigned __int16 mins[3]; //OFS: 0x0 SIZE: 0x6
unsigned __int16 maxs[3]; //OFS: 0x6 SIZE: 0x6
};
ASSERT_STRUCT_SIZE(XSurfaceCollisionAabb, 0xC);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionAabb, mins, 0x0);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionAabb, maxs, 0x6);
struct __declspec(align(2)) XSurfaceCollisionNode
{
XSurfaceCollisionAabb aabb; //OFS: 0x0 SIZE: 0xC
unsigned __int16 childBeginIndex; //OFS: 0xC SIZE: 0x2
unsigned __int16 childCount; //OFS: 0xE SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XSurfaceCollisionNode, 0x10);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionNode, aabb, 0x0);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionNode, childBeginIndex, 0xC);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionNode, childCount, 0xE);
struct __declspec(align(2)) XSurfaceCollisionLeaf
{
unsigned __int16 triangleBeginIndex; //OFS: 0x0 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XSurfaceCollisionLeaf, 0x2);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionLeaf, triangleBeginIndex, 0x0);
struct XSurfaceCollisionTree
{
float trans[3]; //OFS: 0x0 SIZE: 0xC
float scale[3]; //OFS: 0xC SIZE: 0xC
unsigned int nodeCount; //OFS: 0x18 SIZE: 0x4
XSurfaceCollisionNode* nodes; //OFS: 0x1C SIZE: 0x4
unsigned int leafCount; //OFS: 0x20 SIZE: 0x4
XSurfaceCollisionLeaf* leafs; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XSurfaceCollisionTree, 0x28);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, trans, 0x0);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, scale, 0xC);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, nodeCount, 0x18);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, nodes, 0x1C);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, leafCount, 0x20);
ASSERT_STRUCT_OFFSET(XSurfaceCollisionTree, leafs, 0x24);
struct XRigidVertList
{
unsigned __int16 boneOffset; //OFS: 0x0 SIZE: 0x2
unsigned __int16 vertCount; //OFS: 0x2 SIZE: 0x2
unsigned __int16 triOffset; //OFS: 0x4 SIZE: 0x2
unsigned __int16 triCount; //OFS: 0x6 SIZE: 0x2
XSurfaceCollisionTree* collisionTree; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XRigidVertList, 0xC);
ASSERT_STRUCT_OFFSET(XRigidVertList, boneOffset, 0x0);
ASSERT_STRUCT_OFFSET(XRigidVertList, vertCount, 0x2);
ASSERT_STRUCT_OFFSET(XRigidVertList, triOffset, 0x4);
ASSERT_STRUCT_OFFSET(XRigidVertList, triCount, 0x6);
ASSERT_STRUCT_OFFSET(XRigidVertList, collisionTree, 0x8);
struct XSurface
{
char tileMode; //OFS: 0x0 SIZE: 0x1
bool deformed; //OFS: 0x1 SIZE: 0x1
unsigned __int16 vertCount; //OFS: 0x2 SIZE: 0x2
unsigned __int16 triCount; //OFS: 0x4 SIZE: 0x2
char zoneHandle; //OFS: 0x6 SIZE: 0x1
unsigned __int16 baseTriIndex; //OFS: 0x8 SIZE: 0x2
unsigned __int16 baseVertIndex; //OFS: 0xA SIZE: 0x2
unsigned __int16* triIndices; //OFS: 0xC SIZE: 0x4
XSurfaceVertexInfo vertInfo; //OFS: 0x10 SIZE: 0xC
GfxPackedVertex* verts0; //OFS: 0x1C SIZE: 0x4
IDirect3DVertexBuffer9* vb0; //OFS: 0x20 SIZE: 0x4
unsigned int vertListCount; //OFS: 0x24 SIZE: 0x4
XRigidVertList* vertList; //OFS: 0x28 SIZE: 0x4
int partBits[4]; //OFS: 0x2C SIZE: 0x10
IDirect3DIndexBuffer9* indexBuffer; //OFS: 0x3C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XSurface, 0x40);
ASSERT_STRUCT_OFFSET(XSurface, tileMode, 0x0);
ASSERT_STRUCT_OFFSET(XSurface, deformed, 0x1);
ASSERT_STRUCT_OFFSET(XSurface, vertCount, 0x2);
ASSERT_STRUCT_OFFSET(XSurface, triCount, 0x4);
ASSERT_STRUCT_OFFSET(XSurface, zoneHandle, 0x6);
ASSERT_STRUCT_OFFSET(XSurface, baseTriIndex, 0x8);
ASSERT_STRUCT_OFFSET(XSurface, baseVertIndex, 0xA);
ASSERT_STRUCT_OFFSET(XSurface, triIndices, 0xC);
ASSERT_STRUCT_OFFSET(XSurface, vertInfo, 0x10);
ASSERT_STRUCT_OFFSET(XSurface, verts0, 0x1C);
ASSERT_STRUCT_OFFSET(XSurface, vb0, 0x20);
ASSERT_STRUCT_OFFSET(XSurface, vertListCount, 0x24);
ASSERT_STRUCT_OFFSET(XSurface, vertList, 0x28);
ASSERT_STRUCT_OFFSET(XSurface, partBits, 0x2C);
ASSERT_STRUCT_OFFSET(XSurface, indexBuffer, 0x3C);
struct GfxDrawSurfFields
{
unsigned __int64 objectId : 16;
unsigned __int64 reflectionProbeIndex : 8;
unsigned __int64 customIndex : 5;
unsigned __int64 materialSortedIndex : 11;
unsigned __int64 prepass : 2;
unsigned __int64 primaryLightIndex : 8;
unsigned __int64 surfType : 4;
unsigned __int64 primarySortKey : 6;
unsigned __int64 unused : 4;
};
ASSERT_STRUCT_SIZE(GfxDrawSurfFields, 0x8);
union GfxDrawSurf
{
GfxDrawSurfFields fields; //OFS: 0x0 SIZE: 0x8
unsigned __int64 packed; //OFS: 0x1 SIZE: 0x8
};
struct __declspec(align(8)) MaterialInfo
{
const char* name; //OFS: 0x0 SIZE: 0x4
char gameFlags; //OFS: 0x4 SIZE: 0x1
char sortKey; //OFS: 0x5 SIZE: 0x1
char textureAtlasRowCount; //OFS: 0x6 SIZE: 0x1
char textureAtlasColumnCount; //OFS: 0x7 SIZE: 0x1
GfxDrawSurf drawSurf; //OFS: 0x8 SIZE: 0x8
unsigned int surfaceTypeBits; //OFS: 0x10 SIZE: 0x4
unsigned __int16 hashIndex; //OFS: 0x14 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(MaterialInfo, 0x18);
ASSERT_STRUCT_OFFSET(MaterialInfo, name, 0x0);
ASSERT_STRUCT_OFFSET(MaterialInfo, gameFlags, 0x4);
ASSERT_STRUCT_OFFSET(MaterialInfo, sortKey, 0x5);
ASSERT_STRUCT_OFFSET(MaterialInfo, textureAtlasRowCount, 0x6);
ASSERT_STRUCT_OFFSET(MaterialInfo, textureAtlasColumnCount, 0x7);
ASSERT_STRUCT_OFFSET(MaterialInfo, drawSurf, 0x8);
ASSERT_STRUCT_OFFSET(MaterialInfo, surfaceTypeBits, 0x10);
ASSERT_STRUCT_OFFSET(MaterialInfo, hashIndex, 0x14);
struct __declspec(align(1)) MaterialStreamRouting
{
char source; //OFS: 0x0 SIZE: 0x1
char dest; //OFS: 0x1 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(MaterialStreamRouting, 0x2);
ASSERT_STRUCT_OFFSET(MaterialStreamRouting, source, 0x0);
ASSERT_STRUCT_OFFSET(MaterialStreamRouting, dest, 0x1);
struct MaterialVertexStreamRouting
{
MaterialStreamRouting data[16]; //OFS: 0x0 SIZE: 0x20
IDirect3DVertexDeclaration9* decl[17]; //OFS: 0x20 SIZE: 0x44
};
ASSERT_STRUCT_SIZE(MaterialVertexStreamRouting, 0x64);
ASSERT_STRUCT_OFFSET(MaterialVertexStreamRouting, data, 0x0);
ASSERT_STRUCT_OFFSET(MaterialVertexStreamRouting, decl, 0x20);
struct MaterialVertexDeclaration
{
char streamCount; //OFS: 0x0 SIZE: 0x1
bool hasOptionalSource; //OFS: 0x1 SIZE: 0x1
bool isLoaded; //OFS: 0x2 SIZE: 0x1
MaterialVertexStreamRouting routing; //OFS: 0x4 SIZE: 0x64
};
ASSERT_STRUCT_SIZE(MaterialVertexDeclaration, 0x68);
ASSERT_STRUCT_OFFSET(MaterialVertexDeclaration, streamCount, 0x0);
ASSERT_STRUCT_OFFSET(MaterialVertexDeclaration, hasOptionalSource, 0x1);
ASSERT_STRUCT_OFFSET(MaterialVertexDeclaration, isLoaded, 0x2);
ASSERT_STRUCT_OFFSET(MaterialVertexDeclaration, routing, 0x4);
struct GfxVertexShaderLoadDef
{
unsigned int* program; //OFS: 0x0 SIZE: 0x4
unsigned __int16 programSize; //OFS: 0x4 SIZE: 0x2
unsigned __int16 loadForRenderer; //OFS: 0x6 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxVertexShaderLoadDef, 0x8);
ASSERT_STRUCT_OFFSET(GfxVertexShaderLoadDef, program, 0x0);
ASSERT_STRUCT_OFFSET(GfxVertexShaderLoadDef, programSize, 0x4);
ASSERT_STRUCT_OFFSET(GfxVertexShaderLoadDef, loadForRenderer, 0x6);
struct MaterialVertexShaderProgram
{
IDirect3DVertexShader9* vs; //OFS: 0x0 SIZE: 0x4
GfxVertexShaderLoadDef loadDef; //OFS: 0x4 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(MaterialVertexShaderProgram, 0xC);
ASSERT_STRUCT_OFFSET(MaterialVertexShaderProgram, vs, 0x0);
ASSERT_STRUCT_OFFSET(MaterialVertexShaderProgram, loadDef, 0x4);
struct MaterialVertexShader
{
const char* name; //OFS: 0x0 SIZE: 0x4
MaterialVertexShaderProgram prog; //OFS: 0x4 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(MaterialVertexShader, 0x10);
ASSERT_STRUCT_OFFSET(MaterialVertexShader, name, 0x0);
ASSERT_STRUCT_OFFSET(MaterialVertexShader, prog, 0x4);
struct GfxPixelShaderLoadDef
{
unsigned int* program; //OFS: 0x0 SIZE: 0x4
unsigned __int16 programSize; //OFS: 0x4 SIZE: 0x2
unsigned __int16 loadForRenderer; //OFS: 0x6 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxPixelShaderLoadDef, 0x8);
ASSERT_STRUCT_OFFSET(GfxPixelShaderLoadDef, program, 0x0);
ASSERT_STRUCT_OFFSET(GfxPixelShaderLoadDef, programSize, 0x4);
ASSERT_STRUCT_OFFSET(GfxPixelShaderLoadDef, loadForRenderer, 0x6);
struct MaterialPixelShaderProgram
{
IDirect3DPixelShader9* ps; //OFS: 0x0 SIZE: 0x4
GfxPixelShaderLoadDef loadDef; //OFS: 0x4 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(MaterialPixelShaderProgram, 0xC);
ASSERT_STRUCT_OFFSET(MaterialPixelShaderProgram, ps, 0x0);
ASSERT_STRUCT_OFFSET(MaterialPixelShaderProgram, loadDef, 0x4);
struct MaterialPixelShader
{
const char* name; //OFS: 0x0 SIZE: 0x4
MaterialPixelShaderProgram prog; //OFS: 0x4 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(MaterialPixelShader, 0x10);
ASSERT_STRUCT_OFFSET(MaterialPixelShader, name, 0x0);
ASSERT_STRUCT_OFFSET(MaterialPixelShader, prog, 0x4);
struct __declspec(align(2)) MaterialArgumentCodeConst
{
unsigned __int16 index; //OFS: 0x0 SIZE: 0x2
char firstRow; //OFS: 0x2 SIZE: 0x1
char rowCount; //OFS: 0x3 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(MaterialArgumentCodeConst, 0x4);
ASSERT_STRUCT_OFFSET(MaterialArgumentCodeConst, index, 0x0);
ASSERT_STRUCT_OFFSET(MaterialArgumentCodeConst, firstRow, 0x2);
ASSERT_STRUCT_OFFSET(MaterialArgumentCodeConst, rowCount, 0x3);
union MaterialArgumentDef
{
const float* literalConst; //OFS: 0x0 SIZE: 0x4
MaterialArgumentCodeConst codeConst; //OFS: 0x1 SIZE: 0x4
unsigned int codeSampler; //OFS: 0x2 SIZE: 0x4
unsigned int nameHash; //OFS: 0x3 SIZE: 0x4
};
struct MaterialShaderArgument
{
unsigned __int16 type; //OFS: 0x0 SIZE: 0x2
unsigned __int16 dest; //OFS: 0x2 SIZE: 0x2
MaterialArgumentDef u; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MaterialShaderArgument, 0x8);
ASSERT_STRUCT_OFFSET(MaterialShaderArgument, type, 0x0);
ASSERT_STRUCT_OFFSET(MaterialShaderArgument, dest, 0x2);
ASSERT_STRUCT_OFFSET(MaterialShaderArgument, u, 0x4);
struct MaterialPass
{
MaterialVertexDeclaration* vertexDecl; //OFS: 0x0 SIZE: 0x4
MaterialVertexShader* vertexShader; //OFS: 0x4 SIZE: 0x4
MaterialPixelShader* pixelShader; //OFS: 0x8 SIZE: 0x4
char perPrimArgCount; //OFS: 0xC SIZE: 0x1
char perObjArgCount; //OFS: 0xD SIZE: 0x1
char stableArgCount; //OFS: 0xE SIZE: 0x1
char customSamplerFlags; //OFS: 0xF SIZE: 0x1
MaterialShaderArgument* args; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MaterialPass, 0x14);
ASSERT_STRUCT_OFFSET(MaterialPass, vertexDecl, 0x0);
ASSERT_STRUCT_OFFSET(MaterialPass, vertexShader, 0x4);
ASSERT_STRUCT_OFFSET(MaterialPass, pixelShader, 0x8);
ASSERT_STRUCT_OFFSET(MaterialPass, perPrimArgCount, 0xC);
ASSERT_STRUCT_OFFSET(MaterialPass, perObjArgCount, 0xD);
ASSERT_STRUCT_OFFSET(MaterialPass, stableArgCount, 0xE);
ASSERT_STRUCT_OFFSET(MaterialPass, customSamplerFlags, 0xF);
ASSERT_STRUCT_OFFSET(MaterialPass, args, 0x10);
struct MaterialTechnique
{
const char* name; //OFS: 0x0 SIZE: 0x4
unsigned __int16 flags; //OFS: 0x4 SIZE: 0x2
unsigned __int16 passCount; //OFS: 0x6 SIZE: 0x2
MaterialPass passArray[1]; //OFS: 0x8 SIZE: 0x14
};
ASSERT_STRUCT_SIZE(MaterialTechnique, 0x1C);
ASSERT_STRUCT_OFFSET(MaterialTechnique, name, 0x0);
ASSERT_STRUCT_OFFSET(MaterialTechnique, flags, 0x4);
ASSERT_STRUCT_OFFSET(MaterialTechnique, passCount, 0x6);
ASSERT_STRUCT_OFFSET(MaterialTechnique, passArray, 0x8);
struct MaterialTechniqueSet
{
const char* name; //OFS: 0x0 SIZE: 0x4
char worldVertFormat; //OFS: 0x4 SIZE: 0x1
bool hasBeenUploaded; //OFS: 0x5 SIZE: 0x1
char unused[1]; //OFS: 0x6 SIZE: 0x1
MaterialTechniqueSet* remappedTechniqueSet; //OFS: 0x8 SIZE: 0x4
MaterialTechnique* techniques[59]; //OFS: 0xC SIZE: 0xEC
};
ASSERT_STRUCT_SIZE(MaterialTechniqueSet, 0xF8);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, name, 0x0);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, worldVertFormat, 0x4);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, hasBeenUploaded, 0x5);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, unused, 0x6);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, remappedTechniqueSet, 0x8);
ASSERT_STRUCT_OFFSET(MaterialTechniqueSet, techniques, 0xC);
struct GfxImageLoadDef
{
char levelCount; //OFS: 0x0 SIZE: 0x1
char flags; //OFS: 0x1 SIZE: 0x1
__int16 dimensions[3]; //OFS: 0x2 SIZE: 0x6
int format; //OFS: 0x8 SIZE: 0x4
int resourceSize; //OFS: 0xC SIZE: 0x4
char data[1]; //OFS: 0x10 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(GfxImageLoadDef, 0x14);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, levelCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, flags, 0x1);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, dimensions, 0x2);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, format, 0x8);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, resourceSize, 0xC);
ASSERT_STRUCT_OFFSET(GfxImageLoadDef, data, 0x10);
union GfxTexture
{
IDirect3DBaseTexture9* basemap; //OFS: 0x0 SIZE: 0x4
IDirect3DTexture9* map; //OFS: 0x1 SIZE: 0x4
IDirect3DVolumeTexture9* volmap; //OFS: 0x2 SIZE: 0x4
IDirect3DCubeTexture9* cubemap; //OFS: 0x3 SIZE: 0x4
GfxImageLoadDef* loadDef; //OFS: 0x4 SIZE: 0x4
};
struct __declspec(align(1)) Picmip
{
char platform[2]; //OFS: 0x0 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(Picmip, 0x2);
ASSERT_STRUCT_OFFSET(Picmip, platform, 0x0);
struct CardMemory
{
int platform[2]; //OFS: 0x0 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(CardMemory, 0x8);
ASSERT_STRUCT_OFFSET(CardMemory, platform, 0x0);
struct GfxImage
{
MapType mapType; //OFS: 0x0 SIZE: 0x4
GfxTexture texture; //OFS: 0x4 SIZE: 0x4
Picmip picmip; //OFS: 0x8 SIZE: 0x2
bool noPicmip; //OFS: 0xA SIZE: 0x1
char semantic; //OFS: 0xB SIZE: 0x1
char track; //OFS: 0xC SIZE: 0x1
CardMemory cardMemory; //OFS: 0x10 SIZE: 0x8
unsigned __int16 width; //OFS: 0x18 SIZE: 0x2
unsigned __int16 height; //OFS: 0x1A SIZE: 0x2
unsigned __int16 depth; //OFS: 0x1C SIZE: 0x2
char category; //OFS: 0x1E SIZE: 0x1
bool delayLoadPixels; //OFS: 0x1F SIZE: 0x1
const char* name; //OFS: 0x20 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxImage, 0x24);
ASSERT_STRUCT_OFFSET(GfxImage, mapType, 0x0);
ASSERT_STRUCT_OFFSET(GfxImage, texture, 0x4);
ASSERT_STRUCT_OFFSET(GfxImage, picmip, 0x8);
ASSERT_STRUCT_OFFSET(GfxImage, noPicmip, 0xA);
ASSERT_STRUCT_OFFSET(GfxImage, semantic, 0xB);
ASSERT_STRUCT_OFFSET(GfxImage, track, 0xC);
ASSERT_STRUCT_OFFSET(GfxImage, cardMemory, 0x10);
ASSERT_STRUCT_OFFSET(GfxImage, width, 0x18);
ASSERT_STRUCT_OFFSET(GfxImage, height, 0x1A);
ASSERT_STRUCT_OFFSET(GfxImage, depth, 0x1C);
ASSERT_STRUCT_OFFSET(GfxImage, category, 0x1E);
ASSERT_STRUCT_OFFSET(GfxImage, delayLoadPixels, 0x1F);
ASSERT_STRUCT_OFFSET(GfxImage, name, 0x20);
struct WaterWritable
{
float floatTime; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(WaterWritable, 0x4);
ASSERT_STRUCT_OFFSET(WaterWritable, floatTime, 0x0);
struct complex_s
{
float real; //OFS: 0x0 SIZE: 0x4
float imag; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(complex_s, 0x8);
ASSERT_STRUCT_OFFSET(complex_s, real, 0x0);
ASSERT_STRUCT_OFFSET(complex_s, imag, 0x4);
struct water_t
{
WaterWritable writable; //OFS: 0x0 SIZE: 0x4
complex_s* H0; //OFS: 0x4 SIZE: 0x4
float* wTerm; //OFS: 0x8 SIZE: 0x4
int M; //OFS: 0xC SIZE: 0x4
int N; //OFS: 0x10 SIZE: 0x4
float Lx; //OFS: 0x14 SIZE: 0x4
float Lz; //OFS: 0x18 SIZE: 0x4
float gravity; //OFS: 0x1C SIZE: 0x4
float windvel; //OFS: 0x20 SIZE: 0x4
float winddir[2]; //OFS: 0x24 SIZE: 0x8
float amplitude; //OFS: 0x2C SIZE: 0x4
float codeConstant[4]; //OFS: 0x30 SIZE: 0x10
GfxImage* image; //OFS: 0x40 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(water_t, 0x44);
ASSERT_STRUCT_OFFSET(water_t, writable, 0x0);
ASSERT_STRUCT_OFFSET(water_t, H0, 0x4);
ASSERT_STRUCT_OFFSET(water_t, wTerm, 0x8);
ASSERT_STRUCT_OFFSET(water_t, M, 0xC);
ASSERT_STRUCT_OFFSET(water_t, N, 0x10);
ASSERT_STRUCT_OFFSET(water_t, Lx, 0x14);
ASSERT_STRUCT_OFFSET(water_t, Lz, 0x18);
ASSERT_STRUCT_OFFSET(water_t, gravity, 0x1C);
ASSERT_STRUCT_OFFSET(water_t, windvel, 0x20);
ASSERT_STRUCT_OFFSET(water_t, winddir, 0x24);
ASSERT_STRUCT_OFFSET(water_t, amplitude, 0x2C);
ASSERT_STRUCT_OFFSET(water_t, codeConstant, 0x30);
ASSERT_STRUCT_OFFSET(water_t, image, 0x40);
union MaterialTextureDefInfo
{
GfxImage* image; //OFS: 0x0 SIZE: 0x4
water_t* water; //OFS: 0x1 SIZE: 0x4
};
struct MaterialTextureDef
{
unsigned int nameHash; //OFS: 0x0 SIZE: 0x4
char nameStart; //OFS: 0x4 SIZE: 0x1
char nameEnd; //OFS: 0x5 SIZE: 0x1
char samplerState; //OFS: 0x6 SIZE: 0x1
char semantic; //OFS: 0x7 SIZE: 0x1
char isMatureContent; //OFS: 0x8 SIZE: 0x1
MaterialTextureDefInfo u; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MaterialTextureDef, 0x10);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, nameHash, 0x0);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, nameStart, 0x4);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, nameEnd, 0x5);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, samplerState, 0x6);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, semantic, 0x7);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, isMatureContent, 0x8);
ASSERT_STRUCT_OFFSET(MaterialTextureDef, u, 0xC);
struct MaterialConstantDef
{
unsigned int nameHash; //OFS: 0x0 SIZE: 0x4
char name[12]; //OFS: 0x4 SIZE: 0xC
float literal[4]; //OFS: 0x10 SIZE: 0x10
};
ASSERT_STRUCT_SIZE(MaterialConstantDef, 0x20);
ASSERT_STRUCT_OFFSET(MaterialConstantDef, nameHash, 0x0);
ASSERT_STRUCT_OFFSET(MaterialConstantDef, name, 0x4);
ASSERT_STRUCT_OFFSET(MaterialConstantDef, literal, 0x10);
struct GfxStateBits
{
unsigned int loadBits[2]; //OFS: 0x0 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(GfxStateBits, 0x8);
ASSERT_STRUCT_OFFSET(GfxStateBits, loadBits, 0x0);
struct Material
{
MaterialInfo info; //OFS: 0x0 SIZE: 0x18
char stateBitsEntry[67]; //OFS: 0x18 SIZE: 0x43
char textureCount; //OFS: 0x5B SIZE: 0x1
char constantCount; //OFS: 0x5C SIZE: 0x1
char stateBitsCount; //OFS: 0x5D SIZE: 0x1
char stateFlags; //OFS: 0x5E SIZE: 0x1
char cameraRegion; //OFS: 0x5F SIZE: 0x1
MaterialTechniqueSet* techniqueSet; //OFS: 0x60 SIZE: 0x4
MaterialTextureDef* textureTable; //OFS: 0x64 SIZE: 0x4
MaterialConstantDef* constantTable; //OFS: 0x68 SIZE: 0x4
GfxStateBits* stateBitsTable; //OFS: 0x6C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(Material, 0x70);
ASSERT_STRUCT_OFFSET(Material, info, 0x0);
ASSERT_STRUCT_OFFSET(Material, stateBitsEntry, 0x18);
ASSERT_STRUCT_OFFSET(Material, textureCount, 0x5B);
ASSERT_STRUCT_OFFSET(Material, constantCount, 0x5C);
ASSERT_STRUCT_OFFSET(Material, stateBitsCount, 0x5D);
ASSERT_STRUCT_OFFSET(Material, stateFlags, 0x5E);
ASSERT_STRUCT_OFFSET(Material, cameraRegion, 0x5F);
ASSERT_STRUCT_OFFSET(Material, techniqueSet, 0x60);
ASSERT_STRUCT_OFFSET(Material, textureTable, 0x64);
ASSERT_STRUCT_OFFSET(Material, constantTable, 0x68);
ASSERT_STRUCT_OFFSET(Material, stateBitsTable, 0x6C);
struct XModelLodInfo
{
float dist; //OFS: 0x0 SIZE: 0x4
unsigned __int16 numsurfs; //OFS: 0x4 SIZE: 0x2
unsigned __int16 surfIndex; //OFS: 0x6 SIZE: 0x2
int partBits[4]; //OFS: 0x8 SIZE: 0x10
char lod; //OFS: 0x18 SIZE: 0x1
char smcIndexPlusOne; //OFS: 0x19 SIZE: 0x1
char smcAllocBits; //OFS: 0x1A SIZE: 0x1
char unused; //OFS: 0x1B SIZE: 0x1
};
ASSERT_STRUCT_SIZE(XModelLodInfo, 0x1C);
ASSERT_STRUCT_OFFSET(XModelLodInfo, dist, 0x0);
ASSERT_STRUCT_OFFSET(XModelLodInfo, numsurfs, 0x4);
ASSERT_STRUCT_OFFSET(XModelLodInfo, surfIndex, 0x6);
ASSERT_STRUCT_OFFSET(XModelLodInfo, partBits, 0x8);
ASSERT_STRUCT_OFFSET(XModelLodInfo, lod, 0x18);
ASSERT_STRUCT_OFFSET(XModelLodInfo, smcIndexPlusOne, 0x19);
ASSERT_STRUCT_OFFSET(XModelLodInfo, smcAllocBits, 0x1A);
ASSERT_STRUCT_OFFSET(XModelLodInfo, unused, 0x1B);
struct XModelCollTri_s
{
float plane[4]; //OFS: 0x0 SIZE: 0x10
float svec[4]; //OFS: 0x10 SIZE: 0x10
float tvec[4]; //OFS: 0x20 SIZE: 0x10
};
ASSERT_STRUCT_SIZE(XModelCollTri_s, 0x30);
ASSERT_STRUCT_OFFSET(XModelCollTri_s, plane, 0x0);
ASSERT_STRUCT_OFFSET(XModelCollTri_s, svec, 0x10);
ASSERT_STRUCT_OFFSET(XModelCollTri_s, tvec, 0x20);
struct XModelCollSurf_s
{
XModelCollTri_s* collTris; //OFS: 0x0 SIZE: 0x4
int numCollTris; //OFS: 0x4 SIZE: 0x4
float mins[3]; //OFS: 0x8 SIZE: 0xC
float maxs[3]; //OFS: 0x14 SIZE: 0xC
int boneIdx; //OFS: 0x20 SIZE: 0x4
int contents; //OFS: 0x24 SIZE: 0x4
int surfFlags; //OFS: 0x28 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XModelCollSurf_s, 0x2C);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, collTris, 0x0);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, numCollTris, 0x4);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, mins, 0x8);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, maxs, 0x14);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, boneIdx, 0x20);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, contents, 0x24);
ASSERT_STRUCT_OFFSET(XModelCollSurf_s, surfFlags, 0x28);
struct XBoneInfo
{
float bounds[2][3]; //OFS: 0x0 SIZE: 0x18
float offset[3]; //OFS: 0x18 SIZE: 0xC
float radiusSquared; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XBoneInfo, 0x28);
ASSERT_STRUCT_OFFSET(XBoneInfo, bounds, 0x0);
ASSERT_STRUCT_OFFSET(XBoneInfo, offset, 0x18);
ASSERT_STRUCT_OFFSET(XBoneInfo, radiusSquared, 0x24);
struct XModelHighMipBounds
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS 0xC SIZE: 0xC
};
ASSERT_STRUCT_SIZE(XModelHighMipBounds, 0x18);
ASSERT_STRUCT_OFFSET(XModelHighMipBounds, mins, 0x0);
ASSERT_STRUCT_OFFSET(XModelHighMipBounds, maxs, 0xC);
struct XModelStreamInfo
{
XModelHighMipBounds* highMipBounds; //OFS 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XModelStreamInfo, 0x4);
ASSERT_STRUCT_OFFSET(XModelStreamInfo, highMipBounds, 0x0);
struct PhysPreset
{
const char* name; //OFS: 0x0 SIZE: 0x4
int type; //OFS: 0x4 SIZE: 0x4
float mass; //OFS: 0x8 SIZE: 0x4
float bounce; //OFS: 0xC SIZE: 0x4
float friction; //OFS: 0x10 SIZE: 0x4
float bulletForceScale; //OFS: 0x14 SIZE: 0x4
float explosiveForceScale; //OFS: 0x18 SIZE: 0x4
const char* sndAliasPrefix; //OFS: 0x1C SIZE: 0x4
float piecesSpreadFraction; //OFS: 0x20 SIZE: 0x4
float piecesUpwardVelocity; //OFS: 0x24 SIZE: 0x4
bool tempDefaultToCylinder; //OFS: 0x28 SIZE: 0x1
int canFloat; //OFS: 0x2C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PhysPreset, 0x30);
ASSERT_STRUCT_OFFSET(PhysPreset, name, 0x0);
ASSERT_STRUCT_OFFSET(PhysPreset, type, 0x4);
ASSERT_STRUCT_OFFSET(PhysPreset, mass, 0x8);
ASSERT_STRUCT_OFFSET(PhysPreset, bounce, 0xC);
ASSERT_STRUCT_OFFSET(PhysPreset, friction, 0x10);
ASSERT_STRUCT_OFFSET(PhysPreset, bulletForceScale, 0x14);
ASSERT_STRUCT_OFFSET(PhysPreset, explosiveForceScale, 0x18);
ASSERT_STRUCT_OFFSET(PhysPreset, sndAliasPrefix, 0x1C);
ASSERT_STRUCT_OFFSET(PhysPreset, piecesSpreadFraction, 0x20);
ASSERT_STRUCT_OFFSET(PhysPreset, piecesUpwardVelocity, 0x24);
ASSERT_STRUCT_OFFSET(PhysPreset, tempDefaultToCylinder, 0x28);
ASSERT_STRUCT_OFFSET(PhysPreset, canFloat, 0x2C);
struct cplane_s
{
float normal[3]; //OFS: 0x0 SIZE: 0xC
float dist; //OFS: 0xC SIZE: 0x4
char type; //OFS: 0x10 SIZE: 0x1
char signbits; //OFS: 0x11 SIZE: 0x1
char pad[2]; //OFS: 0x12 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(cplane_s, 0x14);
ASSERT_STRUCT_OFFSET(cplane_s, normal, 0x0);
ASSERT_STRUCT_OFFSET(cplane_s, dist, 0xC);
ASSERT_STRUCT_OFFSET(cplane_s, type, 0x10);
ASSERT_STRUCT_OFFSET(cplane_s, signbits, 0x11);
ASSERT_STRUCT_OFFSET(cplane_s, pad, 0x12);
struct cbrushside_t
{
cplane_s* plane; //OFS: 0x0 SIZE: 0x4
unsigned int materialNum; //OFS: 0x4 SIZE: 0x4
__int16 firstAdjacentSideOffset; //OFS: 0x8 SIZE: 0x2
char edgeCount; //OFS: 0xA SIZE: 0x1
};
ASSERT_STRUCT_SIZE(cbrushside_t, 0xC);
ASSERT_STRUCT_OFFSET(cbrushside_t, plane, 0x0);
ASSERT_STRUCT_OFFSET(cbrushside_t, materialNum, 0x4);
ASSERT_STRUCT_OFFSET(cbrushside_t, firstAdjacentSideOffset, 0x8);
ASSERT_STRUCT_OFFSET(cbrushside_t, edgeCount, 0xA);
struct __declspec(align(16)) BrushWrapper
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
int contents; //OFS: 0xC SIZE: 0x4
float maxs[3]; //OFS: 0x10 SIZE: 0xC
unsigned int numsides; //OFS: 0x1C SIZE: 0x4
cbrushside_t* sides; //OFS: 0x20 SIZE: 0x4
__int16 axialMaterialNum[2][3]; //OFS: 0x24 SIZE: 0xC
char* baseAdjacentSide; //OFS: 0x30 SIZE: 0x4
__int16 firstAdjacentSideOffsets[2][3]; //OFS: 0x34 SIZE: 0xC
char edgeCount[2][3]; //OFS: 0x40 SIZE: 0x6
unsigned int numverts; //OFS: 0x48 SIZE: 0x4
float (*verts)[3]; //OFS: 0x4C SIZE: 0x4
int totalEdgeCount; //OFS: 0x50 SIZE: 0x4
cplane_s* planes; //OFS: 0x54 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(BrushWrapper, 0x60);
ASSERT_STRUCT_OFFSET(BrushWrapper, mins, 0x0);
ASSERT_STRUCT_OFFSET(BrushWrapper, contents, 0xC);
ASSERT_STRUCT_OFFSET(BrushWrapper, maxs, 0x10);
ASSERT_STRUCT_OFFSET(BrushWrapper, numsides, 0x1C);
ASSERT_STRUCT_OFFSET(BrushWrapper, sides, 0x20);
ASSERT_STRUCT_OFFSET(BrushWrapper, axialMaterialNum, 0x24);
ASSERT_STRUCT_OFFSET(BrushWrapper, baseAdjacentSide, 0x30);
ASSERT_STRUCT_OFFSET(BrushWrapper, firstAdjacentSideOffsets, 0x34);
ASSERT_STRUCT_OFFSET(BrushWrapper, edgeCount, 0x40);
ASSERT_STRUCT_OFFSET(BrushWrapper, numverts, 0x48);
ASSERT_STRUCT_OFFSET(BrushWrapper, verts, 0x4C);
ASSERT_STRUCT_OFFSET(BrushWrapper, totalEdgeCount, 0x50);
ASSERT_STRUCT_OFFSET(BrushWrapper, planes, 0x54);
struct PhysGeomInfo
{
BrushWrapper* brush; //OFS: 0x0 SIZE: 0x4
int type; //OFS: 0x4 SIZE: 0x4
float orientation[3][3]; //OFS: 0x8 SIZE: 0x24
float offset[3]; //OFS: 0x2C SIZE: 0xC
float halfLengths[3]; //OFS: 0x38 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(PhysGeomInfo, 0x44);
ASSERT_STRUCT_OFFSET(PhysGeomInfo, brush, 0x0);
ASSERT_STRUCT_OFFSET(PhysGeomInfo, type, 0x4);
ASSERT_STRUCT_OFFSET(PhysGeomInfo, orientation, 0x8);
ASSERT_STRUCT_OFFSET(PhysGeomInfo, offset, 0x2C);
ASSERT_STRUCT_OFFSET(PhysGeomInfo, halfLengths, 0x38);
struct PhysMass
{
float centerOfMass[3]; //OFS: 0x0 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(PhysMass, 0xC);
ASSERT_STRUCT_OFFSET(PhysMass, centerOfMass, 0x0);
struct PhysGeomList
{
unsigned int count; //OFS: 0x0 SIZE: 0x4
PhysGeomInfo* geoms; //OFS: 0x4 SIZE: 0x4
PhysMass mass; //OFS: 0x8 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(PhysGeomList, 0x14);
ASSERT_STRUCT_OFFSET(PhysGeomList, count, 0x0);
ASSERT_STRUCT_OFFSET(PhysGeomList, geoms, 0x4);
ASSERT_STRUCT_OFFSET(PhysGeomList, mass, 0x8);
struct PhysConstraint
{
unsigned __int16 targetname; //OFS: 0x0 SIZE: 0x2
ConstraintType type; //OFS: 0x4 SIZE: 0x4
AttachPointType attach_point_type1; //OFS: 0x8 SIZE: 0x4
int target_index1; //OFS: 0xC SIZE: 0x4
unsigned __int16 target_ent1; //OFS: 0x10 SIZE: 0x2
char* target_bone1; //OFS: 0x14 SIZE: 0x4
AttachPointType attach_point_type2; //OFS: 0x18 SIZE: 0x4
int target_index2; //OFS: 0x1C SIZE: 0x4
unsigned __int16 target_ent2; //OFS: 0x20 SIZE: 0x2
char* target_bone2; //OFS: 0x24 SIZE: 0x4
float offset[3]; //OFS: 0x28 SIZE: 0xC
float pos[3]; //OFS: 0x34 SIZE: 0xC
float pos2[3]; //OFS: 0x40 SIZE: 0xC
float dir[3]; //OFS: 0x4C SIZE: 0xC
int flags; //OFS: 0x58 SIZE: 0x4
int timeout; //OFS: 0x5C SIZE: 0x4
int min_health; //OFS: 0x60 SIZE: 0x4
int max_health; //OFS: 0x64 SIZE: 0x4
float distance; //OFS: 0x68 SIZE: 0x4
float damp; //OFS: 0x6C SIZE: 0x4
float power; //OFS: 0x70 SIZE: 0x4
float scale[3]; //OFS: 0x74 SIZE: 0xC
float spin_scale; //OFS: 0x80 SIZE: 0x4
float minAngle; //OFS: 0x84 SIZE: 0x4
float maxAngle; //OFS: 0x88 SIZE: 0x4
Material* material; //OFS: 0x8C SIZE: 0x4
int constraintHandle; //OFS: 0x90 SIZE: 0x4
int rope_index; //OFS: 0x94 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PhysConstraint, 0x98);
ASSERT_STRUCT_OFFSET(PhysConstraint, targetname, 0x0);
ASSERT_STRUCT_OFFSET(PhysConstraint, type, 0x4);
ASSERT_STRUCT_OFFSET(PhysConstraint, attach_point_type1, 0x8);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_index1, 0xC);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_ent1, 0x10);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_bone1, 0x14);
ASSERT_STRUCT_OFFSET(PhysConstraint, attach_point_type2, 0x18);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_index2, 0x1C);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_ent2, 0x20);
ASSERT_STRUCT_OFFSET(PhysConstraint, target_bone2, 0x24);
ASSERT_STRUCT_OFFSET(PhysConstraint, offset, 0x28);
ASSERT_STRUCT_OFFSET(PhysConstraint, pos, 0x34);
ASSERT_STRUCT_OFFSET(PhysConstraint, pos2, 0x40);
ASSERT_STRUCT_OFFSET(PhysConstraint, dir, 0x4C);
ASSERT_STRUCT_OFFSET(PhysConstraint, flags, 0x58);
ASSERT_STRUCT_OFFSET(PhysConstraint, timeout, 0x5C);
ASSERT_STRUCT_OFFSET(PhysConstraint, min_health, 0x60);
ASSERT_STRUCT_OFFSET(PhysConstraint, max_health, 0x64);
ASSERT_STRUCT_OFFSET(PhysConstraint, distance, 0x68);
ASSERT_STRUCT_OFFSET(PhysConstraint, damp, 0x6C);
ASSERT_STRUCT_OFFSET(PhysConstraint, power, 0x70);
ASSERT_STRUCT_OFFSET(PhysConstraint, scale, 0x74);
ASSERT_STRUCT_OFFSET(PhysConstraint, spin_scale, 0x80);
ASSERT_STRUCT_OFFSET(PhysConstraint, minAngle, 0x84);
ASSERT_STRUCT_OFFSET(PhysConstraint, maxAngle, 0x88);
ASSERT_STRUCT_OFFSET(PhysConstraint, material, 0x8C);
ASSERT_STRUCT_OFFSET(PhysConstraint, constraintHandle, 0x90);
ASSERT_STRUCT_OFFSET(PhysConstraint, rope_index, 0x94);
struct PhysConstraints
{
char* name; //OFS: 0x0 SIZE: 0x4
unsigned int count; //OFS: 0x4 SIZE: 0x4
PhysConstraint data[16]; //OFS: 0x8 SIZE: 0x980
};
ASSERT_STRUCT_SIZE(PhysConstraints, 0x988);
ASSERT_STRUCT_OFFSET(PhysConstraints, name, 0x0);
ASSERT_STRUCT_OFFSET(PhysConstraints, count, 0x4);
ASSERT_STRUCT_OFFSET(PhysConstraints, data, 0x8);
struct XModel
{
const char* name; //OFS: 0x0 SIZE: 0x4
char numBones; //OFS: 0x4 SIZE: 0x1
char numRootBones; //OFS: 0x5 SIZE: 0x1
char numsurfs; //OFS: 0x6 SIZE: 0x1
char lodRampType; //OFS: 0x7 SIZE: 0x1
unsigned __int16* boneNames; //OFS: 0x8 SIZE: 0x4
char* parentList; //OFS: 0xC SIZE: 0x4
__int16* quats; //OFS: 0x10 SIZE: 0x4
float* trans; //OFS: 0x14 SIZE: 0x4
char* partClassification; //OFS: 0x18 SIZE: 0x4
DObjAnimMat* baseMat; //OFS: 0x1C SIZE: 0x4
XSurface* surfs; //OFS: 0x20 SIZE: 0x4
Material** materialHandles; //OFS: 0x24 SIZE: 0x4
XModelLodInfo lodInfo[4]; //OFS: 0x28 SIZE: 0x70
XModelCollSurf_s* collSurfs; //OFS: 0x98 SIZE: 0x4
int numCollSurfs; //OFS: 0x9C SIZE: 0x4
int contents; //OFS: 0xA0 SIZE: 0x4
XBoneInfo* boneInfo; //OFS: 0xA4 SIZE: 0x4
float radius; //OFS: 0xA8 SIZE: 0x4
float mins[3]; //OFS: 0xAC SIZE: 0xC
float maxs[3]; //OFS: 0xB8 SIZE: 0xC
__int16 numLods; //OFS: 0xC4 SIZE: 0x2
__int16 collLod; //OFS: 0xC6 SIZE: 0x2
XModelStreamInfo streamInfo; //OFS: 0xC8 SIZE: 0x4
int memUsage; //OFS: 0xCC SIZE: 0x4
char flags; //OFS: 0xD0 SIZE: 0x1
bool bad; //OFS: 0xD1 SIZE: 0x1
PhysPreset* physPreset; //OFS: 0xD4 SIZE: 0x4
PhysGeomList* physGeoms; //OFS: 0xD8 SIZE: 0x4
PhysGeomList* collmap; //OFS: 0xDC SIZE: 0x4
PhysConstraints* physConstraints; //OFS: 0xE0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XModel, 0xE4);
ASSERT_STRUCT_OFFSET(XModel, name, 0x0);
ASSERT_STRUCT_OFFSET(XModel, numBones, 0x4);
ASSERT_STRUCT_OFFSET(XModel, numRootBones, 0x5);
ASSERT_STRUCT_OFFSET(XModel, numsurfs, 0x6);
ASSERT_STRUCT_OFFSET(XModel, lodRampType, 0x7);
ASSERT_STRUCT_OFFSET(XModel, boneNames, 0x8);
ASSERT_STRUCT_OFFSET(XModel, parentList, 0xC);
ASSERT_STRUCT_OFFSET(XModel, quats, 0x10);
ASSERT_STRUCT_OFFSET(XModel, trans, 0x14);
ASSERT_STRUCT_OFFSET(XModel, partClassification, 0x18);
ASSERT_STRUCT_OFFSET(XModel, baseMat, 0x1C);
ASSERT_STRUCT_OFFSET(XModel, surfs, 0x20);
ASSERT_STRUCT_OFFSET(XModel, materialHandles, 0x24);
ASSERT_STRUCT_OFFSET(XModel, lodInfo, 0x28);
ASSERT_STRUCT_OFFSET(XModel, collSurfs, 0x98);
ASSERT_STRUCT_OFFSET(XModel, numCollSurfs, 0x9C);
ASSERT_STRUCT_OFFSET(XModel, contents, 0xA0);
ASSERT_STRUCT_OFFSET(XModel, boneInfo, 0xA4);
ASSERT_STRUCT_OFFSET(XModel, radius, 0xA8);
ASSERT_STRUCT_OFFSET(XModel, mins, 0xAC);
ASSERT_STRUCT_OFFSET(XModel, maxs, 0xB8);
ASSERT_STRUCT_OFFSET(XModel, numLods, 0xC4);
ASSERT_STRUCT_OFFSET(XModel, collLod, 0xC6);
ASSERT_STRUCT_OFFSET(XModel, streamInfo, 0xC8);
ASSERT_STRUCT_OFFSET(XModel, memUsage, 0xCC);
ASSERT_STRUCT_OFFSET(XModel, flags, 0xD0);
ASSERT_STRUCT_OFFSET(XModel, bad, 0xD1);
ASSERT_STRUCT_OFFSET(XModel, physPreset, 0xD4);
ASSERT_STRUCT_OFFSET(XModel, physGeoms, 0xD8);
ASSERT_STRUCT_OFFSET(XModel, collmap, 0xDC);
ASSERT_STRUCT_OFFSET(XModel, physConstraints, 0xE0);
struct XModelPiece
{
XModel* model; //OFS: 0x0 SIZE: 0x4
float offset[3]; //OFS: 0x4 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(XModelPiece, 0x10);
ASSERT_STRUCT_OFFSET(XModelPiece, model, 0x0);
ASSERT_STRUCT_OFFSET(XModelPiece, offset, 0x4);
struct XModelPieces
{
char* name; //OFS: 0x0 SIZE: 0x4
int numpieces; //OFS: 0x4 SIZE: 0x4
XModelPiece* pieces; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XModelPieces, 0xC);
ASSERT_STRUCT_OFFSET(XModelPieces, name, 0x0);
ASSERT_STRUCT_OFFSET(XModelPieces, numpieces, 0x4);
ASSERT_STRUCT_OFFSET(XModelPieces, pieces, 0x8);
struct FxSpawnDefLooping
{
int intervalMsec; //OFS: 0x0 SIZE: 0x4
int count; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxSpawnDefLooping, 0x8);
ASSERT_STRUCT_OFFSET(FxSpawnDefLooping, intervalMsec, 0x0);
ASSERT_STRUCT_OFFSET(FxSpawnDefLooping, count, 0x4);
struct FxIntRange
{
int base; //OFS: 0x0 SIZE: 0x4
int amplitude; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxIntRange, 0x8);
ASSERT_STRUCT_OFFSET(FxIntRange, base, 0x0);
ASSERT_STRUCT_OFFSET(FxIntRange, amplitude, 0x4);
struct FxSpawnDefOneShot
{
FxIntRange count; //OFS: 0x0 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(FxSpawnDefOneShot, 0x8);
ASSERT_STRUCT_OFFSET(FxSpawnDefOneShot, count, 0x0);
union FxSpawnDef
{
FxSpawnDefLooping looping; //OFS: 0x0 SIZE: 0x8
FxSpawnDefOneShot oneShot; //OFS: 0x1 SIZE: 0x8
};
struct FxFloatRange
{
float base; //OFS: 0x0 SIZE: 0x4
float amplitude; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxFloatRange, 0x8);
ASSERT_STRUCT_OFFSET(FxFloatRange, base, 0x0);
ASSERT_STRUCT_OFFSET(FxFloatRange, amplitude, 0x4);
struct __declspec(align(2)) FxElemAtlas
{
unsigned __int8 behavior; //OFS: 0x0 SIZE: 0x1
unsigned __int8 index; //OFS: 0x1 SIZE: 0x1
unsigned __int8 fps; //OFS: 0x2 SIZE: 0x1
unsigned __int8 loopCount; //OFS: 0x3 SIZE: 0x1
unsigned __int8 colIndexBits; //OFS: 0x4 SIZE: 0x1
unsigned __int8 rowIndexBits; //OFS: 0x5 SIZE: 0x1
__int16 entryCount; //OFS: 0x6 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(FxElemAtlas, 0x8);
ASSERT_STRUCT_OFFSET(FxElemAtlas, behavior, 0x0);
ASSERT_STRUCT_OFFSET(FxElemAtlas, index, 0x1);
ASSERT_STRUCT_OFFSET(FxElemAtlas, fps, 0x2);
ASSERT_STRUCT_OFFSET(FxElemAtlas, loopCount, 0x3);
ASSERT_STRUCT_OFFSET(FxElemAtlas, colIndexBits, 0x4);
ASSERT_STRUCT_OFFSET(FxElemAtlas, rowIndexBits, 0x5);
ASSERT_STRUCT_OFFSET(FxElemAtlas, entryCount, 0x6);
struct FxElemVec3Range
{
float base[3]; //OFS: 0x0 SIZE: 0xC
float amplitude[3]; //OFS: 0xC SIZE: 0xC
};
ASSERT_STRUCT_SIZE(FxElemVec3Range, 0x18);
ASSERT_STRUCT_OFFSET(FxElemVec3Range, base, 0x0);
ASSERT_STRUCT_OFFSET(FxElemVec3Range, amplitude, 0xC);
struct FxElemVelStateInFrame
{
FxElemVec3Range velocity; //OFS: 0x0 SIZE: 0x18
FxElemVec3Range totalDelta; //OFS: 0x18 SIZE: 0x18
};
ASSERT_STRUCT_SIZE(FxElemVelStateInFrame, 0x30);
ASSERT_STRUCT_OFFSET(FxElemVelStateInFrame, velocity, 0x0);
ASSERT_STRUCT_OFFSET(FxElemVelStateInFrame, totalDelta, 0x18);
struct FxElemVelStateSample
{
FxElemVelStateInFrame local; //OFS: 0x0 SIZE: 0x30
FxElemVelStateInFrame world; //OFS: 0x30 SIZE: 0x30
};
ASSERT_STRUCT_SIZE(FxElemVelStateSample, 0x60);
ASSERT_STRUCT_OFFSET(FxElemVelStateSample, local, 0x0);
ASSERT_STRUCT_OFFSET(FxElemVelStateSample, world, 0x30);
struct FxElemVisualState
{
unsigned __int8 color[4]; //OFS: 0x0 SIZE: 0x4
float rotationDelta; //OFS: 0x4 SIZE: 0x4
float rotationTotal; //OFS: 0x8 SIZE: 0x4
float size[2]; //OFS: 0xC SIZE: 0x8
float scale; //OFS: 0x14 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxElemVisualState, 0x18);
ASSERT_STRUCT_OFFSET(FxElemVisualState, color, 0x0);
ASSERT_STRUCT_OFFSET(FxElemVisualState, rotationDelta, 0x4);
ASSERT_STRUCT_OFFSET(FxElemVisualState, rotationTotal, 0x8);
ASSERT_STRUCT_OFFSET(FxElemVisualState, size, 0xC);
ASSERT_STRUCT_OFFSET(FxElemVisualState, scale, 0x14);
struct FxElemVisStateSample
{
FxElemVisualState base; //OFS: 0x0 SIZE: 0x18
FxElemVisualState amplitude; //OFS: 0x18 SIZE: 0x18
};
ASSERT_STRUCT_SIZE(FxElemVisStateSample, 0x30);
ASSERT_STRUCT_OFFSET(FxElemVisStateSample, base, 0x0);
ASSERT_STRUCT_OFFSET(FxElemVisStateSample, amplitude, 0x18);
struct FxElemMarkVisuals
{
Material* materials[2]; //OFS: 0x0 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(FxElemMarkVisuals, 0x8);
ASSERT_STRUCT_OFFSET(FxElemMarkVisuals, materials, 0x0);
struct FxEffectDefRef
{
char* name; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxEffectDefRef, 0x4);
ASSERT_STRUCT_OFFSET(FxEffectDefRef, name, 0x0);
union FxElemVisuals
{
const void* anonymous; //OFS: 0x0 SIZE: 0x4
Material* material; //OFS: 0x1 SIZE: 0x4
XModel* model; //OFS: 0x2 SIZE: 0x4
FxEffectDefRef effectDef; //OFS: 0x3 SIZE: 0x4
const char* soundName; //OFS: 0x4 SIZE: 0x4
};
union FxElemDefVisuals
{
FxElemMarkVisuals* markArray; //OFS: 0x0 SIZE: 0x4
FxElemVisuals* array; //OFS: 0x1 SIZE: 0x4
FxElemVisuals instance; //OFS: 0x2 SIZE: 0x4
};
struct FxTrailVertex
{
float pos[2]; //OFS: 0x0 SIZE: 0x8
float normal[2]; //OFS: 0x8 SIZE: 0x8
float texCoord; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxTrailVertex, 0x14);
ASSERT_STRUCT_OFFSET(FxTrailVertex, pos, 0x0);
ASSERT_STRUCT_OFFSET(FxTrailVertex, normal, 0x8);
ASSERT_STRUCT_OFFSET(FxTrailVertex, texCoord, 0x10);
struct FxTrailDef
{
int scrollTimeMsec; //OFS: 0x0 SIZE: 0x4
int repeatDist; //OFS: 0x4 SIZE: 0x4
int splitDist; //OFS: 0x8 SIZE: 0x4
int vertCount; //OFS: 0xC SIZE: 0x4
FxTrailVertex* verts; //OFS: 0x10 SIZE: 0x4
int indCount; //OFS: 0x14 SIZE: 0x4
unsigned __int16* inds; //OFS: 0x18 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxTrailDef, 0x1C);
ASSERT_STRUCT_OFFSET(FxTrailDef, scrollTimeMsec, 0x0);
ASSERT_STRUCT_OFFSET(FxTrailDef, repeatDist, 0x4);
ASSERT_STRUCT_OFFSET(FxTrailDef, splitDist, 0x8);
ASSERT_STRUCT_OFFSET(FxTrailDef, vertCount, 0xC);
ASSERT_STRUCT_OFFSET(FxTrailDef, verts, 0x10);
ASSERT_STRUCT_OFFSET(FxTrailDef, indCount, 0x14);
ASSERT_STRUCT_OFFSET(FxTrailDef, inds, 0x18);
struct FxElemDef
{
int flags; //OFS: 0x0 SIZE: 0x4
FxSpawnDef spawn; //OFS: 0x4 SIZE: 0x8
FxFloatRange spawnRange; //OFS: 0xC SIZE: 0x8
FxFloatRange fadeInRange; //OFS: 0x14 SIZE: 0x8
FxFloatRange fadeOutRange; //OFS: 0x1C SIZE: 0x8
float spawnFrustumCullRadius; //OFS: 0x24 SIZE: 0x4
FxIntRange spawnDelayMsec; //OFS: 0x28 SIZE: 0x8
FxIntRange lifeSpanMsec; //OFS: 0x30 SIZE: 0x8
FxFloatRange spawnOrigin[3]; //OFS: 0x38 SIZE: 0x18
FxFloatRange spawnOffsetRadius; //OFS: 0x50 SIZE: 0x8
FxFloatRange spawnOffsetHeight; //OFS: 0x58 SIZE: 0x8
FxFloatRange spawnAngles[3]; //OFS: 0x60 SIZE: 0x18
FxFloatRange angularVelocity[3]; //OFS: 0x78 SIZE: 0x18
FxFloatRange initialRotation; //OFS: 0x90 SIZE: 0x8
FxFloatRange gravity; //OFS: 0x98 SIZE: 0x8
FxFloatRange reflectionFactor; //OFS: 0xA0 SIZE: 0x8
FxElemAtlas atlas; //OFS: 0xA8 SIZE: 0x8
float windInfluence; //OFS: 0xB0 SIZE: 0x4
unsigned __int8 elemType; //OFS: 0xB4 SIZE: 0x1
unsigned __int8 visualCount; //OFS: 0xB5 SIZE: 0x1
unsigned __int8 velIntervalCount; //OFS: 0xB6 SIZE: 0x1
unsigned __int8 visStateIntervalCount; //OFS: 0xB7 SIZE: 0x1
FxElemVelStateSample* velSamples; //OFS: 0xB8 SIZE: 0x4
FxElemVisStateSample* visSamples; //OFS: 0xBC SIZE: 0x4
FxElemDefVisuals visuals; //OFS: 0xC0 SIZE: 0x4
float collMins[3]; //OFS: 0xC4 SIZE: 0xC
float collMaxs[3]; //OFS: 0xD0 SIZE: 0xC
FxEffectDefRef effectOnImpact; //OFS: 0xDC SIZE: 0x4
FxEffectDefRef effectOnDeath; //OFS: 0xE0 SIZE: 0x4
FxEffectDefRef effectEmitted; //OFS: 0xE4 SIZE: 0x4
FxFloatRange emitDist; //OFS: 0xE8 SIZE: 0x8
FxFloatRange emitDistVariance; //OFS: 0xF0 SIZE: 0x8
FxTrailDef* trailDef; //OFS: 0xF8 SIZE: 0x4
unsigned __int8 sortOrder; //OFS: 0xFC SIZE: 0x1
unsigned __int8 lightingFrac; //OFS: 0xFD SIZE: 0x1
unsigned __int8 useItemClip; //OFS: 0xFE SIZE: 0x1
unsigned __int8 unused[1]; //OFS: 0xFF SIZE: 0x1
};
ASSERT_STRUCT_SIZE(FxElemDef, 0x100);
ASSERT_STRUCT_OFFSET(FxElemDef, flags, 0x0);
ASSERT_STRUCT_OFFSET(FxElemDef, spawn, 0x4);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnRange, 0xC);
ASSERT_STRUCT_OFFSET(FxElemDef, fadeInRange, 0x14);
ASSERT_STRUCT_OFFSET(FxElemDef, fadeOutRange, 0x1C);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnFrustumCullRadius, 0x24);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnDelayMsec, 0x28);
ASSERT_STRUCT_OFFSET(FxElemDef, lifeSpanMsec, 0x30);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnOrigin, 0x38);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnOffsetRadius, 0x50);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnOffsetHeight, 0x58);
ASSERT_STRUCT_OFFSET(FxElemDef, spawnAngles, 0x60);
ASSERT_STRUCT_OFFSET(FxElemDef, angularVelocity, 0x78);
ASSERT_STRUCT_OFFSET(FxElemDef, initialRotation, 0x90);
ASSERT_STRUCT_OFFSET(FxElemDef, gravity, 0x98);
ASSERT_STRUCT_OFFSET(FxElemDef, reflectionFactor, 0xA0);
ASSERT_STRUCT_OFFSET(FxElemDef, atlas, 0xA8);
ASSERT_STRUCT_OFFSET(FxElemDef, windInfluence, 0xB0);
ASSERT_STRUCT_OFFSET(FxElemDef, elemType, 0xB4);
ASSERT_STRUCT_OFFSET(FxElemDef, visualCount, 0xB5);
ASSERT_STRUCT_OFFSET(FxElemDef, velIntervalCount, 0xB6);
ASSERT_STRUCT_OFFSET(FxElemDef, visStateIntervalCount, 0xB7);
ASSERT_STRUCT_OFFSET(FxElemDef, velSamples, 0xB8);
ASSERT_STRUCT_OFFSET(FxElemDef, visSamples, 0xBC);
ASSERT_STRUCT_OFFSET(FxElemDef, visuals, 0xC0);
ASSERT_STRUCT_OFFSET(FxElemDef, collMins, 0xC4);
ASSERT_STRUCT_OFFSET(FxElemDef, collMaxs, 0xD0);
ASSERT_STRUCT_OFFSET(FxElemDef, effectOnImpact, 0xDC);
ASSERT_STRUCT_OFFSET(FxElemDef, effectOnDeath, 0xE0);
ASSERT_STRUCT_OFFSET(FxElemDef, effectEmitted, 0xE4);
ASSERT_STRUCT_OFFSET(FxElemDef, emitDist, 0xE8);
ASSERT_STRUCT_OFFSET(FxElemDef, emitDistVariance, 0xF0);
ASSERT_STRUCT_OFFSET(FxElemDef, trailDef, 0xF8);
ASSERT_STRUCT_OFFSET(FxElemDef, sortOrder, 0xFC);
ASSERT_STRUCT_OFFSET(FxElemDef, lightingFrac, 0xFD);
ASSERT_STRUCT_OFFSET(FxElemDef, useItemClip, 0xFE);
ASSERT_STRUCT_OFFSET(FxElemDef, unused, 0xFF);
struct FxEffectDef
{
char* name; //OFS: 0x0 SIZE: 0x4
int flags; //OFS: 0x4 SIZE: 0x4
int totalSize; //OFS: 0x8 SIZE: 0x4
int msecLoopingLife; //OFS: 0xC SIZE: 0x4
int elemDefCountLooping; //OFS: 0x10 SIZE: 0x4
int elemDefCountOneShot; //OFS: 0x14 SIZE: 0x4
int elemDefCountEmission; //OFS: 0x18 SIZE: 0x4
unsigned __int8 efPriority; //OFS: 0x1C SIZE: 0x1
FxElemDef* elemDefs; //OFS: 0x20 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxEffectDef, 0x24);
ASSERT_STRUCT_OFFSET(FxEffectDef, name, 0x0);
ASSERT_STRUCT_OFFSET(FxEffectDef, flags, 0x4);
ASSERT_STRUCT_OFFSET(FxEffectDef, totalSize, 0x8);
ASSERT_STRUCT_OFFSET(FxEffectDef, msecLoopingLife, 0xC);
ASSERT_STRUCT_OFFSET(FxEffectDef, elemDefCountLooping, 0x10);
ASSERT_STRUCT_OFFSET(FxEffectDef, elemDefCountOneShot, 0x14);
ASSERT_STRUCT_OFFSET(FxEffectDef, elemDefCountEmission, 0x18);
ASSERT_STRUCT_OFFSET(FxEffectDef, efPriority, 0x1C);
ASSERT_STRUCT_OFFSET(FxEffectDef, elemDefs, 0x20);
struct snd_asset
{
char* data; //OFS: 0x0 SIZE: 0x4
int data_size; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_asset, 0x8);
ASSERT_STRUCT_OFFSET(snd_asset, data, 0x0);
ASSERT_STRUCT_OFFSET(snd_asset, data_size, 0x4);
struct LoadedSound
{
char* name; //OFS: 0x0 SIZE: 0x4
snd_asset sound; //OFS: 0x4 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(LoadedSound, 0xC);
ASSERT_STRUCT_OFFSET(LoadedSound, name, 0x0);
ASSERT_STRUCT_OFFSET(LoadedSound, sound, 0x4);
struct StreamFileName
{
unsigned int hash; //OFS: 0x0 SIZE: 0x4
const char* dir; //OFS: 0x4 SIZE: 0x4
const char* name; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(StreamFileName, 0xC);
ASSERT_STRUCT_OFFSET(StreamFileName, hash, 0x0);
ASSERT_STRUCT_OFFSET(StreamFileName, dir, 0x4);
ASSERT_STRUCT_OFFSET(StreamFileName, name, 0x8);
struct PrimedSound
{
const char* name; //OFS: 0x0 SIZE: 0x4
unsigned __int8* buffer; //OFS: 0x4 SIZE: 0x4
unsigned int size; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PrimedSound, 0xC);
ASSERT_STRUCT_OFFSET(PrimedSound, name, 0x0);
ASSERT_STRUCT_OFFSET(PrimedSound, buffer, 0x4);
ASSERT_STRUCT_OFFSET(PrimedSound, size, 0x8);
struct StreamedSound
{
StreamFileName filename; //OFS: 0x0 SIZE: 0xC
PrimedSound* primeSnd; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(StreamedSound, 0x10);
ASSERT_STRUCT_OFFSET(StreamedSound, filename, 0x0);
ASSERT_STRUCT_OFFSET(StreamedSound, primeSnd, 0xC);
union SoundFileRef
{
LoadedSound* loadSnd; //OFS: 0x0 SIZE: 0x4
StreamedSound streamSnd; //OFS: 0x1 SIZE: 0x10
};
struct SoundFile
{
unsigned __int8 type; //OFS: 0x0 SIZE: 0x1
unsigned __int8 exists; //OFS: 0x1 SIZE: 0x1
SoundFileRef u; //OFS: 0x4 SIZE: 0x10
};
ASSERT_STRUCT_SIZE(SoundFile, 0x14);
ASSERT_STRUCT_OFFSET(SoundFile, type, 0x0);
ASSERT_STRUCT_OFFSET(SoundFile, exists, 0x1);
ASSERT_STRUCT_OFFSET(SoundFile, u, 0x4);
struct snd_alias_t
{
char* aliasName; //OFS: 0x0 SIZE: 0x4
int aliasNameHash; //OFS: 0x4 SIZE: 0x4
char* subtitle; //OFS: 0x8 SIZE: 0x4
char* secondaryAliasName; //OFS: 0xC SIZE: 0x4
char* chainAliasName; //OFS: 0x10 SIZE: 0x4
SoundFile* soundFile; //OFS: 0x14 SIZE: 0x4
unsigned int sequence; //OFS: 0x18 SIZE: 0x4
float volMin; //OFS: 0x1C SIZE: 0x4
float volMax; //OFS: 0x20 SIZE: 0x4
float pitchMin; //OFS: 0x24 SIZE: 0x4
float pitchMax; //OFS: 0x28 SIZE: 0x4
float distMin; //OFS: 0x2C SIZE: 0x4
float distMax; //OFS: 0x30 SIZE: 0x4
float distReverbMax; //OFS: 0x34 SIZE: 0x4
float slavePercentage; //OFS: 0x38 SIZE: 0x4
float probability; //OFS: 0x3C SIZE: 0x4
float lfePercentage; //OFS: 0x40 SIZE: 0x4
float centerPercentage; //OFS: 0x44 SIZE: 0x4
float envelopMin; //OFS: 0x48 SIZE: 0x4
float envelopMax; //OFS: 0x4C SIZE: 0x4
float envelopPercentage; //OFS: 0x50 SIZE: 0x4
float minPriority; //OFS: 0x54 SIZE: 0x4
float maxPriority; //OFS: 0x58 SIZE: 0x4
float minPriorityThreshold; //OFS: 0x5C SIZE: 0x4
float maxPriorityThreshold; //OFS: 0x60 SIZE: 0x4
float reverbSend; //OFS: 0x64 SIZE: 0x4
int gap2; //OFS: 0x68 SIZE: 0x4
int gap3; //OFS: 0x6C SIZE: 0x4
float occlusionLevel; //OFS: 0x70 SIZE: 0x4
float occlusionWetDry; //OFS: 0x74 SIZE: 0x4
unsigned int moveTime; //OFS: 0x78 SIZE: 0x4
unsigned int startDelay; //OFS: 0x7C SIZE: 0x4
unsigned int speakerMap; //OFS: 0x80 SIZE: 0x4
int flags; //OFS: 0x84 SIZE: 0x4
unsigned int volumeFalloffCurve; //OFS: 0x88 SIZE: 0x4
unsigned int reverbFalloffCurve; //OFS: 0x8C SIZE: 0x4
unsigned int volumeMinFalloffCurve; //OFS: 0x90 SIZE: 0x4
unsigned int reverbMinFalloffCurve; //OFS: 0x94 SIZE: 0x4
snd_limit_type_t limitType; //OFS: 0x98 SIZE: 0x4
int gap5; //OFS: 0x9C SIZE: 0x4
unsigned int entityLimitCount; //OFS: 0xA0 SIZE: 0x4
int gap6; //OFS: 0xA4 SIZE: 0x4
snd_randomize_type_t randomizeType; //OFS: 0xA8 SIZE: 0x4
int gap7; //OFS: 0xAC SIZE: 0x4
int gap8; //OFS: 0xB0 SIZE: 0x4
int gap9; //OFS: 0xB4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_alias_t, 0xB8);
ASSERT_STRUCT_OFFSET(snd_alias_t, aliasName, 0x0);
ASSERT_STRUCT_OFFSET(snd_alias_t, aliasNameHash, 0x4);
ASSERT_STRUCT_OFFSET(snd_alias_t, subtitle, 0x8);
ASSERT_STRUCT_OFFSET(snd_alias_t, secondaryAliasName, 0xC);
ASSERT_STRUCT_OFFSET(snd_alias_t, chainAliasName, 0x10);
ASSERT_STRUCT_OFFSET(snd_alias_t, soundFile, 0x14);
ASSERT_STRUCT_OFFSET(snd_alias_t, sequence, 0x18);
ASSERT_STRUCT_OFFSET(snd_alias_t, volMin, 0x1C);
ASSERT_STRUCT_OFFSET(snd_alias_t, volMax, 0x20);
ASSERT_STRUCT_OFFSET(snd_alias_t, pitchMin, 0x24);
ASSERT_STRUCT_OFFSET(snd_alias_t, pitchMax, 0x28);
ASSERT_STRUCT_OFFSET(snd_alias_t, distMin, 0x2C);
ASSERT_STRUCT_OFFSET(snd_alias_t, distMax, 0x30);
ASSERT_STRUCT_OFFSET(snd_alias_t, distReverbMax, 0x34);
ASSERT_STRUCT_OFFSET(snd_alias_t, slavePercentage, 0x38);
ASSERT_STRUCT_OFFSET(snd_alias_t, probability, 0x3C);
ASSERT_STRUCT_OFFSET(snd_alias_t, lfePercentage, 0x40);
ASSERT_STRUCT_OFFSET(snd_alias_t, centerPercentage, 0x44);
ASSERT_STRUCT_OFFSET(snd_alias_t, envelopMin, 0x48);
ASSERT_STRUCT_OFFSET(snd_alias_t, envelopMax, 0x4C);
ASSERT_STRUCT_OFFSET(snd_alias_t, envelopPercentage, 0x50);
ASSERT_STRUCT_OFFSET(snd_alias_t, minPriority, 0x54);
ASSERT_STRUCT_OFFSET(snd_alias_t, maxPriority, 0x58);
ASSERT_STRUCT_OFFSET(snd_alias_t, minPriorityThreshold, 0x5C);
ASSERT_STRUCT_OFFSET(snd_alias_t, maxPriorityThreshold, 0x60);
ASSERT_STRUCT_OFFSET(snd_alias_t, reverbSend, 0x64);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap2, 0x68);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap3, 0x6C);
ASSERT_STRUCT_OFFSET(snd_alias_t, occlusionLevel, 0x70);
ASSERT_STRUCT_OFFSET(snd_alias_t, occlusionWetDry, 0x74);
ASSERT_STRUCT_OFFSET(snd_alias_t, moveTime, 0x78);
ASSERT_STRUCT_OFFSET(snd_alias_t, startDelay, 0x7C);
ASSERT_STRUCT_OFFSET(snd_alias_t, speakerMap, 0x80);
ASSERT_STRUCT_OFFSET(snd_alias_t, flags, 0x84);
ASSERT_STRUCT_OFFSET(snd_alias_t, volumeFalloffCurve, 0x88);
ASSERT_STRUCT_OFFSET(snd_alias_t, reverbFalloffCurve, 0x8C);
ASSERT_STRUCT_OFFSET(snd_alias_t, volumeMinFalloffCurve, 0x90);
ASSERT_STRUCT_OFFSET(snd_alias_t, reverbMinFalloffCurve, 0x94);
ASSERT_STRUCT_OFFSET(snd_alias_t, limitType, 0x98);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap5, 0x9C);
ASSERT_STRUCT_OFFSET(snd_alias_t, entityLimitCount, 0xA0);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap6, 0xA4);
ASSERT_STRUCT_OFFSET(snd_alias_t, randomizeType, 0xA8);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap7, 0xAC);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap8, 0xB0);
ASSERT_STRUCT_OFFSET(snd_alias_t, gap9, 0xB4);
struct snd_alias_list_t
{
char* aliasName; //OFS: 0x0 SIZE: 0x4
snd_alias_t* head; //OFS: 0x4 SIZE: 0x4
int count; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_alias_list_t, 0xC);
ASSERT_STRUCT_OFFSET(snd_alias_list_t, aliasName, 0x0);
ASSERT_STRUCT_OFFSET(snd_alias_list_t, head, 0x4);
ASSERT_STRUCT_OFFSET(snd_alias_list_t, count, 0x8);
struct DestructibleModel
{
XModel* model; //OFS: 0x0 SIZE: 0x4
float breakHealth; //OFS: 0x4 SIZE: 0x4
unsigned int flags; //OFS: 0x8 SIZE: 0x4
FxEffectDef* breakEffect; //OFS: 0xC SIZE: 0x4
snd_alias_list_t* breakSound; //OFS: 0x10 SIZE: 0x4
char* breakNotify; //OFS: 0x14 SIZE: 0x4
char* loopSound; //OFS: 0x18 SIZE: 0x4
XModel* spawnModel[3]; //OFS: 0x1C SIZE: 0xC
};
ASSERT_STRUCT_SIZE(DestructibleModel, 0x28);
ASSERT_STRUCT_OFFSET(DestructibleModel, model, 0x0);
ASSERT_STRUCT_OFFSET(DestructibleModel, breakHealth, 0x4);
ASSERT_STRUCT_OFFSET(DestructibleModel, flags, 0x8);
ASSERT_STRUCT_OFFSET(DestructibleModel, breakEffect, 0xC);
ASSERT_STRUCT_OFFSET(DestructibleModel, breakSound, 0x10);
ASSERT_STRUCT_OFFSET(DestructibleModel, breakNotify, 0x14);
ASSERT_STRUCT_OFFSET(DestructibleModel, loopSound, 0x18);
ASSERT_STRUCT_OFFSET(DestructibleModel, spawnModel, 0x1C);
struct DestructiblePiece
{
DestructibleModel dmodels[5]; //OFS: 0x0 SIZE: 0xC8
char* attachBone; //OFS: 0xC8 SIZE: 0x4
unsigned __int16 attachBoneHash; //OFS: 0xCC SIZE: 0x2
unsigned __int8 parentPiece; //OFS: 0xCE SIZE: 0x1
float parentDamagePercent; //OFS: 0xD0 SIZE: 0x4
float bulletDamageScale; //OFS: 0xD4 SIZE: 0x4
float explosiveDamageScale; //OFS: 0xD8 SIZE: 0x4
float entityDamageTransfer; //OFS: 0xDC SIZE: 0x4
PhysConstraints* physConstraints; //OFS: 0xE0 SIZE: 0x4
int health; //OFS: 0xE4 SIZE: 0x4
snd_alias_t* damageSound; //OFS: 0xE8 SIZE: 0x4
FxEffectDef* burnEffect; //OFS: 0xEC SIZE: 0x4
snd_alias_t* burnSound; //OFS: 0xF0 SIZE: 0x4
unsigned __int16 enableLabel; //OFS: 0xF4 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(DestructiblePiece, 0xF8);
ASSERT_STRUCT_OFFSET(DestructiblePiece, dmodels, 0x0);
ASSERT_STRUCT_OFFSET(DestructiblePiece, attachBone, 0xC8);
ASSERT_STRUCT_OFFSET(DestructiblePiece, attachBoneHash, 0xCC);
ASSERT_STRUCT_OFFSET(DestructiblePiece, parentPiece, 0xCE);
ASSERT_STRUCT_OFFSET(DestructiblePiece, parentDamagePercent, 0xD0);
ASSERT_STRUCT_OFFSET(DestructiblePiece, bulletDamageScale, 0xD4);
ASSERT_STRUCT_OFFSET(DestructiblePiece, explosiveDamageScale, 0xD8);
ASSERT_STRUCT_OFFSET(DestructiblePiece, entityDamageTransfer, 0xDC);
ASSERT_STRUCT_OFFSET(DestructiblePiece, physConstraints, 0xE0);
ASSERT_STRUCT_OFFSET(DestructiblePiece, health, 0xE4);
ASSERT_STRUCT_OFFSET(DestructiblePiece, damageSound, 0xE8);
ASSERT_STRUCT_OFFSET(DestructiblePiece, burnEffect, 0xEC);
ASSERT_STRUCT_OFFSET(DestructiblePiece, burnSound, 0xF0);
ASSERT_STRUCT_OFFSET(DestructiblePiece, enableLabel, 0xF4);
struct DestructibleDef
{
char* name; //OFS: 0x0 SIZE: 0x4
XModel* baseModel; //OFS: 0x4 SIZE: 0x4
int numPieces; //OFS: 0x8 SIZE: 0x4
DestructiblePiece* pieces; //OFS: 0xC SIZE: 0x4
int clientOnly; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(DestructibleDef, 0x14);
ASSERT_STRUCT_OFFSET(DestructibleDef, name, 0x0);
ASSERT_STRUCT_OFFSET(DestructibleDef, baseModel, 0x4);
ASSERT_STRUCT_OFFSET(DestructibleDef, numPieces, 0x8);
ASSERT_STRUCT_OFFSET(DestructibleDef, pieces, 0xC);
ASSERT_STRUCT_OFFSET(DestructibleDef, clientOnly, 0x10);
union XAnimIndices
{
char* _1; //OFS: 0x0 SIZE: 0x4
unsigned __int16* _2; //OFS: 0x1 SIZE: 0x4
void* data; //OFS: 0x2 SIZE: 0x4
};
struct XAnimNotifyInfo
{
unsigned __int16 name; //OFS: 0x0 SIZE: 0x2
float time; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XAnimNotifyInfo, 0x8);
ASSERT_STRUCT_OFFSET(XAnimNotifyInfo, name, 0x0);
ASSERT_STRUCT_OFFSET(XAnimNotifyInfo, time, 0x4);
union XAnimDynamicFrames
{
unsigned __int8 (*_1)[3]; //OFS: 0x0 SIZE: 0x4
unsigned __int16 (*_2)[3]; //OFS: 0x1 SIZE: 0x4
};
union XAnimDynamicIndices
{
char _1[1]; //OFS: 0x0 SIZE: 0x1
unsigned __int16 _2[1]; //OFS: 0x1 SIZE: 0x2
};
struct XAnimPartTransFrames
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float size[3]; //OFS: 0xC SIZE: 0xC
XAnimDynamicFrames frames; //OFS: 0x18 SIZE: 0x4
XAnimDynamicIndices indices; //OFS: 0x1C SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XAnimPartTransFrames, 0x20);
ASSERT_STRUCT_OFFSET(XAnimPartTransFrames, mins, 0x0);
ASSERT_STRUCT_OFFSET(XAnimPartTransFrames, size, 0xC);
ASSERT_STRUCT_OFFSET(XAnimPartTransFrames, frames, 0x18);
ASSERT_STRUCT_OFFSET(XAnimPartTransFrames, indices, 0x1C);
union XAnimPartTransData
{
XAnimPartTransFrames frames; //OFS: 0x0 SIZE: 0x20
float frame0[3]; //OFS: 0x1 SIZE: 0xC
};
struct XAnimPartTrans
{
unsigned __int16 size; //OFS: 0x0 SIZE: 0x2
char smallTrans; //OFS: 0x2 SIZE: 0x1
XAnimPartTransData u; //OFS: 0x4 SIZE: 0x20
};
ASSERT_STRUCT_SIZE(XAnimPartTrans, 0x24);
ASSERT_STRUCT_OFFSET(XAnimPartTrans, size, 0x0);
ASSERT_STRUCT_OFFSET(XAnimPartTrans, smallTrans, 0x2);
ASSERT_STRUCT_OFFSET(XAnimPartTrans, u, 0x4);
struct XAnimDeltaPartQuatDataFrames
{
__int16 (*frames)[2]; //OFS: 0x0 SIZE: 0x4
XAnimDynamicIndices indices; //OFS: 0x4 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XAnimDeltaPartQuatDataFrames, 0x8);
ASSERT_STRUCT_OFFSET(XAnimDeltaPartQuatDataFrames, frames, 0x0);
ASSERT_STRUCT_OFFSET(XAnimDeltaPartQuatDataFrames, indices, 0x4);
union XAnimDeltaPartQuatData
{
XAnimDeltaPartQuatDataFrames frames; //OFS: 0x0 SIZE: 0x8
__int16 frame0[2]; //OFS: 0x1 SIZE: 0x4
};
struct XAnimDeltaPartQuat
{
unsigned __int16 size; //OFS: 0x0 SIZE: 0x2
XAnimDeltaPartQuatData u; //OFS: 0x4 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(XAnimDeltaPartQuat, 0xC);
ASSERT_STRUCT_OFFSET(XAnimDeltaPartQuat, size, 0x0);
ASSERT_STRUCT_OFFSET(XAnimDeltaPartQuat, u, 0x4);
struct XAnimDeltaPart
{
XAnimPartTrans* trans; //OFS: 0x0 SIZE: 0x4
XAnimDeltaPartQuat* quat; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XAnimDeltaPart, 0x8);
ASSERT_STRUCT_OFFSET(XAnimDeltaPart, trans, 0x0);
ASSERT_STRUCT_OFFSET(XAnimDeltaPart, quat, 0x4);
struct XAnimParts
{
const char* name; //OFS: 0x0 SIZE: 0x4
unsigned __int16 dataByteCount; //OFS: 0x4 SIZE: 0x2
unsigned __int16 dataShortCount; //OFS: 0x6 SIZE: 0x2
unsigned __int16 dataIntCount; //OFS: 0x8 SIZE: 0x2
unsigned __int16 randomDataByteCount; //OFS: 0xA SIZE: 0x2
unsigned __int16 randomDataIntCount; //OFS: 0xC SIZE: 0x2
unsigned __int16 numframes; //OFS: 0xE SIZE: 0x2
bool bLoop; //OFS: 0x10 SIZE: 0x1
bool bDelta; //OFS: 0x11 SIZE: 0x1
char boneCount[10]; //OFS: 0x12 SIZE: 0xA
char notifyCount; //OFS: 0x1C SIZE: 0x1
char assetType; //OFS: 0x1D SIZE: 0x1
bool isDefault; //OFS: 0x1E SIZE: 0x1
unsigned int randomDataShortCount; //OFS: 0x20 SIZE: 0x4
unsigned int indexCount; //OFS: 0x24 SIZE: 0x4
float framerate; //OFS: 0x28 SIZE: 0x4
float frequency; //OFS: 0x2C SIZE: 0x4
unsigned __int16* names; //OFS: 0x30 SIZE: 0x4
char* dataByte; //OFS: 0x34 SIZE: 0x4
__int16* dataShort; //OFS: 0x38 SIZE: 0x4
int* dataInt; //OFS: 0x3C SIZE: 0x4
__int16* randomDataShort; //OFS: 0x40 SIZE: 0x4
char* randomDataByte; //OFS: 0x44 SIZE: 0x4
int* randomDataInt; //OFS: 0x48 SIZE: 0x4
XAnimIndices indices; //OFS: 0x4C SIZE: 0x4
XAnimNotifyInfo* notify; //OFS: 0x50 SIZE: 0x4
XAnimDeltaPart* deltaPart; //OFS: 0x54 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XAnimParts, 0x58);
ASSERT_STRUCT_OFFSET(XAnimParts, name, 0x0);
ASSERT_STRUCT_OFFSET(XAnimParts, dataByteCount, 0x4);
ASSERT_STRUCT_OFFSET(XAnimParts, dataShortCount, 0x6);
ASSERT_STRUCT_OFFSET(XAnimParts, dataIntCount, 0x8);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataByteCount, 0xA);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataIntCount, 0xC);
ASSERT_STRUCT_OFFSET(XAnimParts, numframes, 0xE);
ASSERT_STRUCT_OFFSET(XAnimParts, bLoop, 0x10);
ASSERT_STRUCT_OFFSET(XAnimParts, bDelta, 0x11);
ASSERT_STRUCT_OFFSET(XAnimParts, boneCount, 0x12);
ASSERT_STRUCT_OFFSET(XAnimParts, notifyCount, 0x1C);
ASSERT_STRUCT_OFFSET(XAnimParts, assetType, 0x1D);
ASSERT_STRUCT_OFFSET(XAnimParts, isDefault, 0x1E);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataShortCount, 0x20);
ASSERT_STRUCT_OFFSET(XAnimParts, indexCount, 0x24);
ASSERT_STRUCT_OFFSET(XAnimParts, framerate, 0x28);
ASSERT_STRUCT_OFFSET(XAnimParts, frequency, 0x2C);
ASSERT_STRUCT_OFFSET(XAnimParts, names, 0x30);
ASSERT_STRUCT_OFFSET(XAnimParts, dataByte, 0x34);
ASSERT_STRUCT_OFFSET(XAnimParts, dataShort, 0x38);
ASSERT_STRUCT_OFFSET(XAnimParts, dataInt, 0x3C);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataShort, 0x40);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataByte, 0x44);
ASSERT_STRUCT_OFFSET(XAnimParts, randomDataInt, 0x48);
ASSERT_STRUCT_OFFSET(XAnimParts, indices, 0x4C);
ASSERT_STRUCT_OFFSET(XAnimParts, notify, 0x50);
ASSERT_STRUCT_OFFSET(XAnimParts, deltaPart, 0x54);
struct __declspec(align(2)) cStaticModelWritable
{
unsigned __int16 nextModelInWorldSector; //OFS: 0x0 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(cStaticModelWritable, 0x2);
ASSERT_STRUCT_OFFSET(cStaticModelWritable, nextModelInWorldSector, 0x0);
struct cStaticModel_s
{
cStaticModelWritable writable; //OFS: 0x0 SIZE: 0x2
XModel* xmodel; //OFS: 0x4 SIZE: 0x4
float origin[3]; //OFS: 0x8 SIZE: 0xC
float invScaledAxis[3][3]; //OFS: 0x14 SIZE: 0x24
float absmin[3]; //OFS: 0x38 SIZE: 0xC
float absmax[3]; //OFS: 0x44 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(cStaticModel_s, 0x50);
ASSERT_STRUCT_OFFSET(cStaticModel_s, writable, 0x0);
ASSERT_STRUCT_OFFSET(cStaticModel_s, xmodel, 0x4);
ASSERT_STRUCT_OFFSET(cStaticModel_s, origin, 0x8);
ASSERT_STRUCT_OFFSET(cStaticModel_s, invScaledAxis, 0x14);
ASSERT_STRUCT_OFFSET(cStaticModel_s, absmin, 0x38);
ASSERT_STRUCT_OFFSET(cStaticModel_s, absmax, 0x44);
struct dmaterial_t
{
char material[64]; //OFS: 0x0 SIZE: 0x40
int surfaceFlags; //OFS: 0x40 SIZE: 0x4
int contentFlags; //OFS: 0x44 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(dmaterial_t, 0x48);
ASSERT_STRUCT_OFFSET(dmaterial_t, material, 0x0);
ASSERT_STRUCT_OFFSET(dmaterial_t, surfaceFlags, 0x40);
ASSERT_STRUCT_OFFSET(dmaterial_t, contentFlags, 0x44);
struct cNode_t
{
cplane_s* plane; //OFS: 0x0 SIZE: 0x4
__int16 children[2]; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(cNode_t, 0x8);
ASSERT_STRUCT_OFFSET(cNode_t, plane, 0x0);
ASSERT_STRUCT_OFFSET(cNode_t, children, 0x4);
struct cLeaf_s
{
unsigned __int16 firstCollAabbIndex; //OFS: 0x0 SIZE: 0x2
unsigned __int16 collAabbCount; //OFS: 0x2 SIZE: 0x2
int brushContents; //OFS: 0x4 SIZE: 0x4
int terrainContents; //OFS: 0x8 SIZE: 0x4
float mins[3]; //OFS: 0xC SIZE: 0xC
float maxs[3]; //OFS: 0x18 SIZE: 0xC
int leafBrushNode; //OFS: 0x24 SIZE: 0x4
__int16 cluster; //OFS: 0x28 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(cLeaf_s, 0x2C);
ASSERT_STRUCT_OFFSET(cLeaf_s, firstCollAabbIndex, 0x0);
ASSERT_STRUCT_OFFSET(cLeaf_s, collAabbCount, 0x2);
ASSERT_STRUCT_OFFSET(cLeaf_s, brushContents, 0x4);
ASSERT_STRUCT_OFFSET(cLeaf_s, terrainContents, 0x8);
ASSERT_STRUCT_OFFSET(cLeaf_s, mins, 0xC);
ASSERT_STRUCT_OFFSET(cLeaf_s, maxs, 0x18);
ASSERT_STRUCT_OFFSET(cLeaf_s, leafBrushNode, 0x24);
ASSERT_STRUCT_OFFSET(cLeaf_s, cluster, 0x28);
struct cLeafBrushNodeLeaf_t
{
unsigned __int16* brushes; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(cLeafBrushNodeLeaf_t, 0x4);
ASSERT_STRUCT_OFFSET(cLeafBrushNodeLeaf_t, brushes, 0x0);
struct cLeafBrushNodeChildren_t
{
float dist; //OFS: 0x0 SIZE: 0x4
float range; //OFS: 0x4 SIZE: 0x4
unsigned __int16 childOffset[2]; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(cLeafBrushNodeChildren_t, 0xC);
ASSERT_STRUCT_OFFSET(cLeafBrushNodeChildren_t, dist, 0x0);
ASSERT_STRUCT_OFFSET(cLeafBrushNodeChildren_t, range, 0x4);
ASSERT_STRUCT_OFFSET(cLeafBrushNodeChildren_t, childOffset, 0x8);
union cLeafBrushNodeData_t
{
cLeafBrushNodeLeaf_t leaf; //OFS: 0x0 SIZE: 0x4
cLeafBrushNodeChildren_t children; //OFS: 0x1 SIZE: 0xC
};
struct cLeafBrushNode_s
{
unsigned __int8 axis; //OFS: 0x0 SIZE: 0x1
__int16 leafBrushCount; //OFS: 0x2 SIZE: 0x2
int contents; //OFS: 0x4 SIZE: 0x4
cLeafBrushNodeData_t data; //OFS: 0x8 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(cLeafBrushNode_s, 0x14);
ASSERT_STRUCT_OFFSET(cLeafBrushNode_s, axis, 0x0);
ASSERT_STRUCT_OFFSET(cLeafBrushNode_s, leafBrushCount, 0x2);
ASSERT_STRUCT_OFFSET(cLeafBrushNode_s, contents, 0x4);
ASSERT_STRUCT_OFFSET(cLeafBrushNode_s, data, 0x8);
struct CollisionBorder
{
float distEq[3]; //OFS: 0x0 SIZE: 0xC
float zBase; //OFS: 0xC SIZE: 0x4
float zSlope; //OFS: 0x10 SIZE: 0x4
float start; //OFS: 0x14 SIZE: 0x4
float length; //OFS: 0x18 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(CollisionBorder, 0x1C);
ASSERT_STRUCT_OFFSET(CollisionBorder, distEq, 0x0);
ASSERT_STRUCT_OFFSET(CollisionBorder, zBase, 0xC);
ASSERT_STRUCT_OFFSET(CollisionBorder, zSlope, 0x10);
ASSERT_STRUCT_OFFSET(CollisionBorder, start, 0x14);
ASSERT_STRUCT_OFFSET(CollisionBorder, length, 0x18);
struct CollisionPartition
{
unsigned __int8 triCount; //OFS: 0x0 SIZE: 0x1
unsigned __int8 borderCount; //OFS: 0x1 SIZE: 0x1
int firstTri; //OFS: 0x4 SIZE: 0x4
int nuinds; //OFS: 0x8 SIZE: 0x4
int fuind; //OFS: 0xC SIZE: 0x4
CollisionBorder* borders; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(CollisionPartition, 0x14);
ASSERT_STRUCT_OFFSET(CollisionPartition, triCount, 0x0);
ASSERT_STRUCT_OFFSET(CollisionPartition, borderCount, 0x1);
ASSERT_STRUCT_OFFSET(CollisionPartition, firstTri, 0x4);
ASSERT_STRUCT_OFFSET(CollisionPartition, nuinds, 0x8);
ASSERT_STRUCT_OFFSET(CollisionPartition, fuind, 0xC);
ASSERT_STRUCT_OFFSET(CollisionPartition, borders, 0x10);
union CollisionAabbTreeIndex
{
int firstChildIndex; //OFS: 0x0 SIZE: 0x4
int partitionIndex; //OFS: 0x1 SIZE: 0x4
};
struct CollisionAabbTree
{
float origin[3]; //OFS: 0x0 SIZE: 0xC
unsigned __int16 materialIndex; //OFS: 0xC SIZE: 0x2
unsigned __int16 childCount; //OFS: 0xE SIZE: 0x2
float halfSize[3]; //OFS: 0x10 SIZE: 0xC
CollisionAabbTreeIndex u; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(CollisionAabbTree, 0x20);
ASSERT_STRUCT_OFFSET(CollisionAabbTree, origin, 0x0);
ASSERT_STRUCT_OFFSET(CollisionAabbTree, materialIndex, 0xC);
ASSERT_STRUCT_OFFSET(CollisionAabbTree, childCount, 0xE);
ASSERT_STRUCT_OFFSET(CollisionAabbTree, halfSize, 0x10);
ASSERT_STRUCT_OFFSET(CollisionAabbTree, u, 0x1C);
struct cmodel_t
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
float radius; //OFS: 0x18 SIZE: 0x4
cLeaf_s leaf; //OFS: 0x1C SIZE: 0x2C
};
ASSERT_STRUCT_SIZE(cmodel_t, 0x48);
ASSERT_STRUCT_OFFSET(cmodel_t, mins, 0x0);
ASSERT_STRUCT_OFFSET(cmodel_t, maxs, 0xC);
ASSERT_STRUCT_OFFSET(cmodel_t, radius, 0x18);
ASSERT_STRUCT_OFFSET(cmodel_t, leaf, 0x1C);
struct cbrush_t
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
int contents; //OFS: 0xC SIZE: 0x4
float maxs[3]; //OFS: 0x10 SIZE: 0xC
unsigned int numsides; //OFS: 0x1C SIZE: 0x4
cbrushside_t* sides; //OFS: 0x20 SIZE: 0x4
__int16 axialMaterialNum[2][3]; //OFS: 0x24 SIZE: 0xC
unsigned __int8* baseAdjacentSide; //OFS: 0x30 SIZE: 0x4
__int16 firstAdjacentSideOffsets[2][3]; //OFS: 0x34 SIZE: 0xC
unsigned __int8 edgeCount[2][3]; //OFS: 0x40 SIZE: 0x6
unsigned int numverts; //OFS: 0x48 SIZE: 0x4
float(*verts)[3]; //OFS: 0x4C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(cbrush_t, 0x50);
ASSERT_STRUCT_OFFSET(cbrush_t, mins, 0x0);
ASSERT_STRUCT_OFFSET(cbrush_t, contents, 0xC);
ASSERT_STRUCT_OFFSET(cbrush_t, maxs, 0x10);
ASSERT_STRUCT_OFFSET(cbrush_t, numsides, 0x1C);
ASSERT_STRUCT_OFFSET(cbrush_t, sides, 0x20);
ASSERT_STRUCT_OFFSET(cbrush_t, axialMaterialNum, 0x24);
ASSERT_STRUCT_OFFSET(cbrush_t, baseAdjacentSide, 0x30);
ASSERT_STRUCT_OFFSET(cbrush_t, firstAdjacentSideOffsets, 0x34);
ASSERT_STRUCT_OFFSET(cbrush_t, edgeCount, 0x40);
ASSERT_STRUCT_OFFSET(cbrush_t, numverts, 0x48);
ASSERT_STRUCT_OFFSET(cbrush_t, verts, 0x4C);
struct MapEnts
{
char* name; //OFS: 0x0 SIZE: 0x4
char* entityString; //OFS: 0x4 SIZE: 0x4
int numEntityChars; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MapEnts, 0xC);
ASSERT_STRUCT_OFFSET(MapEnts, name, 0x0);
ASSERT_STRUCT_OFFSET(MapEnts, entityString, 0x4);
ASSERT_STRUCT_OFFSET(MapEnts, numEntityChars, 0x8);
struct GfxPlacement
{
float quat[4]; //OFS: 0x0 SIZE: 0x10
float origin[3]; //OFS: 0x10 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(GfxPlacement, 0x1C);
ASSERT_STRUCT_OFFSET(GfxPlacement, quat, 0x0);
ASSERT_STRUCT_OFFSET(GfxPlacement, origin, 0x10);
struct DynEntityDef
{
DynEntityType type; //OFS: 0x0 SIZE: 0x4
GfxPlacement pose; //OFS: 0x4 SIZE: 0x1C
XModel* xModel; //OFS: 0x20 SIZE: 0x4
unsigned __int16 brushModel; //OFS: 0x24 SIZE: 0x2
unsigned __int16 physicsBrushModel; //OFS: 0x26 SIZE: 0x2
FxEffectDef* destroyFx; //OFS: 0x28 SIZE: 0x4
XModelPieces* destroyPieces; //OFS: 0x2C SIZE: 0x4
PhysPreset* physPreset; //OFS: 0x30 SIZE: 0x4
unsigned __int8 physConstraints[4]; //OFS: 0x34 SIZE: 0x4
int health; //OFS: 0x38 SIZE: 0x4
PhysMass mass; //OFS: 0x3C SIZE: 0xC
int flags; //OFS: 0x48 SIZE: 0x4
int contents; //OFS: 0x4C SIZE: 0x4
unsigned __int16 targetname; //OFS: 0x50 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(DynEntityDef, 0x54);
ASSERT_STRUCT_OFFSET(DynEntityDef, type, 0x0);
ASSERT_STRUCT_OFFSET(DynEntityDef, pose, 0x4);
ASSERT_STRUCT_OFFSET(DynEntityDef, xModel, 0x20);
ASSERT_STRUCT_OFFSET(DynEntityDef, brushModel, 0x24);
ASSERT_STRUCT_OFFSET(DynEntityDef, physicsBrushModel, 0x26);
ASSERT_STRUCT_OFFSET(DynEntityDef, destroyFx, 0x28);
ASSERT_STRUCT_OFFSET(DynEntityDef, destroyPieces, 0x2C);
ASSERT_STRUCT_OFFSET(DynEntityDef, physPreset, 0x30);
ASSERT_STRUCT_OFFSET(DynEntityDef, physConstraints, 0x34);
ASSERT_STRUCT_OFFSET(DynEntityDef, health, 0x38);
ASSERT_STRUCT_OFFSET(DynEntityDef, mass, 0x3C);
ASSERT_STRUCT_OFFSET(DynEntityDef, flags, 0x48);
ASSERT_STRUCT_OFFSET(DynEntityDef, contents, 0x4C);
ASSERT_STRUCT_OFFSET(DynEntityDef, targetname, 0x50);
struct DynEntityPose
{
GfxPlacement pose; //OFS: 0x0 SIZE: 0x1C
float radius; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(DynEntityPose, 0x20);
ASSERT_STRUCT_OFFSET(DynEntityPose, pose, 0x0);
ASSERT_STRUCT_OFFSET(DynEntityPose, radius, 0x1C);
struct DynEntityClient
{
int physObjId; //OFS: 0x0 SIZE: 0x4
unsigned __int16 flags; //OFS: 0x4 SIZE: 0x2
unsigned __int16 lightingHandle; //OFS: 0x6 SIZE: 0x2
int health; //OFS: 0x8 SIZE: 0x4
unsigned __int16 burnTime; //OFS: 0xC SIZE: 0x2
unsigned __int16 fadeTime; //OFS: 0xE SIZE: 0x2
};
ASSERT_STRUCT_SIZE(DynEntityClient, 0x10);
ASSERT_STRUCT_OFFSET(DynEntityClient, physObjId, 0x0);
ASSERT_STRUCT_OFFSET(DynEntityClient, flags, 0x4);
ASSERT_STRUCT_OFFSET(DynEntityClient, lightingHandle, 0x6);
ASSERT_STRUCT_OFFSET(DynEntityClient, health, 0x8);
ASSERT_STRUCT_OFFSET(DynEntityClient, burnTime, 0xC);
ASSERT_STRUCT_OFFSET(DynEntityClient, fadeTime, 0xE);
struct DynEntityServer
{
unsigned __int16 flags; //OFS: 0x0 SIZE: 0x2
int health; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(DynEntityServer, 0x8);
ASSERT_STRUCT_OFFSET(DynEntityServer, flags, 0x0);
ASSERT_STRUCT_OFFSET(DynEntityServer, health, 0x4);
struct DynEntityColl
{
unsigned __int16 sector; //OFS: 0x0 SIZE: 0x2
unsigned __int16 nextEntInSector; //OFS: 0x2 SIZE: 0x2
float linkMins[3]; //OFS: 0x4 SIZE: 0xC
float linkMaxs[3]; //OFS: 0x10 SIZE: 0xC
int contents; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(DynEntityColl, 0x20);
ASSERT_STRUCT_OFFSET(DynEntityColl, sector, 0x0);
ASSERT_STRUCT_OFFSET(DynEntityColl, nextEntInSector, 0x2);
ASSERT_STRUCT_OFFSET(DynEntityColl, linkMins, 0x4);
ASSERT_STRUCT_OFFSET(DynEntityColl, linkMaxs, 0x10);
ASSERT_STRUCT_OFFSET(DynEntityColl, contents, 0x1C);
struct clipMap_t
{
char* name; //OFS: 0x0 SIZE: 0x4
int isInUse; //OFS: 0x4 SIZE: 0x4
int planeCount; //OFS: 0x8 SIZE: 0x4
cplane_s* planes; //OFS: 0xC SIZE: 0x4
unsigned int numStaticModels; //OFS: 0x10 SIZE: 0x4
cStaticModel_s* staticModelList; //OFS: 0x14 SIZE: 0x4
unsigned int numMaterials; //OFS: 0x18 SIZE: 0x4
dmaterial_t* materials; //OFS: 0x1C SIZE: 0x4
unsigned int numBrushSides; //OFS: 0x20 SIZE: 0x4
cbrushside_t* brushsides; //OFS: 0x24 SIZE: 0x4
unsigned int numBrushEdges; //OFS: 0x28 SIZE: 0x4
unsigned __int8* brushEdges; //OFS: 0x2C SIZE: 0x4
unsigned int numNodes; //OFS: 0x30 SIZE: 0x4
cNode_t* nodes; //OFS: 0x34 SIZE: 0x4
unsigned int numLeafs; //OFS: 0x38 SIZE: 0x4
cLeaf_s* leafs; //OFS: 0x3C SIZE: 0x4
unsigned int leafbrushNodesCount; //OFS: 0x40 SIZE: 0x4
cLeafBrushNode_s* leafbrushNodes; //OFS: 0x44 SIZE: 0x4
unsigned int numLeafBrushes; //OFS: 0x48 SIZE: 0x4
unsigned __int16* leafbrushes; //OFS: 0x4C SIZE: 0x4
unsigned int numLeafSurfaces; //OFS: 0x50 SIZE: 0x4
unsigned int* leafsurfaces; //OFS: 0x54 SIZE: 0x4
unsigned int vertCount; //OFS: 0x58 SIZE: 0x4
float(*verts)[3]; //OFS: 0x5C SIZE: 0x4
unsigned int numBrushVerts; //OFS: 0x60 SIZE: 0x4
float(*brushVerts)[3]; //OFS: 0x64 SIZE: 0x4
unsigned int nuinds; //OFS: 0x68 SIZE: 0x4
unsigned __int16* uinds; //OFS: 0x6C SIZE: 0x4
int triCount; //OFS: 0x70 SIZE: 0x4
unsigned __int16* triIndices; //OFS: 0x74 SIZE: 0x4
unsigned __int8* triEdgeIsWalkable; //OFS: 0x78 SIZE: 0x4
int borderCount; //OFS: 0x7C SIZE: 0x4
CollisionBorder* borders; //OFS: 0x80 SIZE: 0x4
int partitionCount; //OFS: 0x84 SIZE: 0x4
CollisionPartition* partitions; //OFS: 0x88 SIZE: 0x4
int aabbTreeCount; //OFS: 0x8C SIZE: 0x4
CollisionAabbTree* aabbTrees; //OFS: 0x90 SIZE: 0x4
unsigned int numSubModels; //OFS: 0x94 SIZE: 0x4
cmodel_t* cmodels; //OFS: 0x98 SIZE: 0x4
unsigned __int16 numBrushes; //OFS: 0x9C SIZE: 0x2
cbrush_t* brushes; //OFS: 0xA0 SIZE: 0x4
int numClusters; //OFS: 0xA4 SIZE: 0x4
int clusterBytes; //OFS: 0xA8 SIZE: 0x4
unsigned __int8* visibility; //OFS: 0xAC SIZE: 0x4
int vised; //OFS: 0xB0 SIZE: 0x4
MapEnts* mapEnts; //OFS: 0xB4 SIZE: 0x4
cbrush_t* box_brush; //OFS: 0xB8 SIZE: 0x4
cmodel_t box_model; //OFS: 0xBC SIZE: 0x48
unsigned __int16 originalDynEntCount; //OFS: 0x104 SIZE: 0x2
unsigned __int16 dynEntCount[4]; //OFS: 0x106 SIZE: 0x8
DynEntityDef* dynEntDefList[2]; //OFS: 0x110 SIZE: 0x8
DynEntityPose* dynEntPoseList[2]; //OFS: 0x118 SIZE: 0x8
DynEntityClient* dynEntClientList[2]; //OFS: 0x120 SIZE: 0x8
DynEntityServer* dynEntServerList[2]; //OFS: 0x128 SIZE: 0x8
DynEntityColl* dynEntCollList[4]; //OFS: 0x130 SIZE: 0x10
int num_constraints; //OFS: 0x140 SIZE: 0x4
PhysConstraint* constraints; //OFS: 0x144 SIZE: 0x4
unsigned int checksum; //OFS: 0x148 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(clipMap_t, 0x14C);
ASSERT_STRUCT_OFFSET(clipMap_t, name, 0x0);
ASSERT_STRUCT_OFFSET(clipMap_t, isInUse, 0x4);
ASSERT_STRUCT_OFFSET(clipMap_t, planeCount, 0x8);
ASSERT_STRUCT_OFFSET(clipMap_t, planes, 0xC);
ASSERT_STRUCT_OFFSET(clipMap_t, numStaticModels, 0x10);
ASSERT_STRUCT_OFFSET(clipMap_t, staticModelList, 0x14);
ASSERT_STRUCT_OFFSET(clipMap_t, numMaterials, 0x18);
ASSERT_STRUCT_OFFSET(clipMap_t, materials, 0x1C);
ASSERT_STRUCT_OFFSET(clipMap_t, numBrushSides, 0x20);
ASSERT_STRUCT_OFFSET(clipMap_t, brushsides, 0x24);
ASSERT_STRUCT_OFFSET(clipMap_t, numBrushEdges, 0x28);
ASSERT_STRUCT_OFFSET(clipMap_t, brushEdges, 0x2C);
ASSERT_STRUCT_OFFSET(clipMap_t, numNodes, 0x30);
ASSERT_STRUCT_OFFSET(clipMap_t, nodes, 0x34);
ASSERT_STRUCT_OFFSET(clipMap_t, numLeafs, 0x38);
ASSERT_STRUCT_OFFSET(clipMap_t, leafs, 0x3C);
ASSERT_STRUCT_OFFSET(clipMap_t, leafbrushNodesCount, 0x40);
ASSERT_STRUCT_OFFSET(clipMap_t, leafbrushNodes, 0x44);
ASSERT_STRUCT_OFFSET(clipMap_t, numLeafBrushes, 0x48);
ASSERT_STRUCT_OFFSET(clipMap_t, leafbrushes, 0x4C);
ASSERT_STRUCT_OFFSET(clipMap_t, numLeafSurfaces, 0x50);
ASSERT_STRUCT_OFFSET(clipMap_t, leafsurfaces, 0x54);
ASSERT_STRUCT_OFFSET(clipMap_t, vertCount, 0x58);
ASSERT_STRUCT_OFFSET(clipMap_t, verts, 0x5C);
ASSERT_STRUCT_OFFSET(clipMap_t, numBrushVerts, 0x60);
ASSERT_STRUCT_OFFSET(clipMap_t, brushVerts, 0x64);
ASSERT_STRUCT_OFFSET(clipMap_t, nuinds, 0x68);
ASSERT_STRUCT_OFFSET(clipMap_t, uinds, 0x6C);
ASSERT_STRUCT_OFFSET(clipMap_t, triCount, 0x70);
ASSERT_STRUCT_OFFSET(clipMap_t, triIndices, 0x74);
ASSERT_STRUCT_OFFSET(clipMap_t, triEdgeIsWalkable, 0x78);
ASSERT_STRUCT_OFFSET(clipMap_t, borderCount, 0x7C);
ASSERT_STRUCT_OFFSET(clipMap_t, borders, 0x80);
ASSERT_STRUCT_OFFSET(clipMap_t, partitionCount, 0x84);
ASSERT_STRUCT_OFFSET(clipMap_t, partitions, 0x88);
ASSERT_STRUCT_OFFSET(clipMap_t, aabbTreeCount, 0x8C);
ASSERT_STRUCT_OFFSET(clipMap_t, aabbTrees, 0x90);
ASSERT_STRUCT_OFFSET(clipMap_t, numSubModels, 0x94);
ASSERT_STRUCT_OFFSET(clipMap_t, cmodels, 0x98);
ASSERT_STRUCT_OFFSET(clipMap_t, numBrushes, 0x9C);
ASSERT_STRUCT_OFFSET(clipMap_t, brushes, 0xA0);
ASSERT_STRUCT_OFFSET(clipMap_t, numClusters, 0xA4);
ASSERT_STRUCT_OFFSET(clipMap_t, clusterBytes, 0xA8);
ASSERT_STRUCT_OFFSET(clipMap_t, visibility, 0xAC);
ASSERT_STRUCT_OFFSET(clipMap_t, vised, 0xB0);
ASSERT_STRUCT_OFFSET(clipMap_t, mapEnts, 0xB4);
ASSERT_STRUCT_OFFSET(clipMap_t, box_brush, 0xB8);
ASSERT_STRUCT_OFFSET(clipMap_t, box_model, 0xBC);
ASSERT_STRUCT_OFFSET(clipMap_t, originalDynEntCount, 0x104);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntCount, 0x106);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntDefList, 0x110);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntPoseList, 0x118);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntClientList, 0x120);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntServerList, 0x128);
ASSERT_STRUCT_OFFSET(clipMap_t, dynEntCollList, 0x130);
ASSERT_STRUCT_OFFSET(clipMap_t, num_constraints, 0x140);
ASSERT_STRUCT_OFFSET(clipMap_t, constraints, 0x144);
ASSERT_STRUCT_OFFSET(clipMap_t, checksum, 0x148);
struct ComPrimaryLight
{
unsigned __int8 type; //OFS: 0x0 SIZE: 0x1
unsigned __int8 canUseShadowMap; //OFS: 0x1 SIZE: 0x1
unsigned __int8 exponent; //OFS: 0x2 SIZE: 0x1
char priority; //OFS: 0x3 SIZE: 0x1
__int16 cullDist; //OFS: 0x4 SIZE: 0x2
float color[3]; //OFS: 0x8 SIZE: 0xC
float dir[3]; //OFS: 0x14 SIZE: 0xC
float origin[3]; //OFS: 0x20 SIZE: 0xC
float radius; //OFS: 0x2C SIZE: 0x4
float cosHalfFovOuter; //OFS: 0x30 SIZE: 0x4
float cosHalfFovInner; //OFS: 0x34 SIZE: 0x4
float cosHalfFovExpanded; //OFS: 0x38 SIZE: 0x4
float rotationLimit; //OFS: 0x3C SIZE: 0x4
float translationLimit; //OFS: 0x40 SIZE: 0x4
char* defName; //OFS: 0x44 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComPrimaryLight, 0x48);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, type, 0x0);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, canUseShadowMap, 0x1);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, exponent, 0x2);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, priority, 0x3);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, cullDist, 0x4);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, color, 0x8);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, dir, 0x14);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, origin, 0x20);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, radius, 0x2C);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, cosHalfFovOuter, 0x30);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, cosHalfFovInner, 0x34);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, cosHalfFovExpanded, 0x38);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, rotationLimit, 0x3C);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, translationLimit, 0x40);
ASSERT_STRUCT_OFFSET(ComPrimaryLight, defName, 0x44);
struct ComWaterHeader
{
int minx; //OFS: 0x0 SIZE: 0x4
int miny; //OFS: 0x4 SIZE: 0x4
int maxx; //OFS: 0x8 SIZE: 0x4
int maxy; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComWaterHeader, 0x10);
ASSERT_STRUCT_OFFSET(ComWaterHeader, minx, 0x0);
ASSERT_STRUCT_OFFSET(ComWaterHeader, miny, 0x4);
ASSERT_STRUCT_OFFSET(ComWaterHeader, maxx, 0x8);
ASSERT_STRUCT_OFFSET(ComWaterHeader, maxy, 0xC);
struct __declspec(align(2)) ComWaterCell
{
__int16 waterheight; //OFS: 0x0 SIZE: 0x2
char flooroffset; //OFS: 0x2 SIZE: 0x1
unsigned __int8 shoredist; //OFS: 0x3 SIZE: 0x1
unsigned __int8 color[4]; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComWaterCell, 0x8);
ASSERT_STRUCT_OFFSET(ComWaterCell, waterheight, 0x0);
ASSERT_STRUCT_OFFSET(ComWaterCell, flooroffset, 0x2);
ASSERT_STRUCT_OFFSET(ComWaterCell, shoredist, 0x3);
ASSERT_STRUCT_OFFSET(ComWaterCell, color, 0x4);
struct ComBurnableHeader
{
int minx; //OFS: 0x0 SIZE: 0x4
int miny; //OFS: 0x4 SIZE: 0x4
int maxx; //OFS: 0x8 SIZE: 0x4
int maxy; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComBurnableHeader, 0x10);
ASSERT_STRUCT_OFFSET(ComBurnableHeader, minx, 0x0);
ASSERT_STRUCT_OFFSET(ComBurnableHeader, miny, 0x4);
ASSERT_STRUCT_OFFSET(ComBurnableHeader, maxx, 0x8);
ASSERT_STRUCT_OFFSET(ComBurnableHeader, maxy, 0xC);
struct __declspec(align(1)) ComBurnableSample
{
unsigned __int8 state; //OFS: 0x0 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(ComBurnableSample, 0x1);
ASSERT_STRUCT_OFFSET(ComBurnableSample, state, 0x0);
struct ComBurnableCell
{
int x; //OFS: 0x0 SIZE: 0x4
int y; //OFS: 0x4 SIZE: 0x4
ComBurnableSample* data; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComBurnableCell, 0xC);
ASSERT_STRUCT_OFFSET(ComBurnableCell, x, 0x0);
ASSERT_STRUCT_OFFSET(ComBurnableCell, y, 0x4);
ASSERT_STRUCT_OFFSET(ComBurnableCell, data, 0x8);
struct ComWorld
{
char* name; //OFS: 0x0 SIZE: 0x4
int isInUse; //OFS: 0x4 SIZE: 0x4
unsigned int primaryLightCount; //OFS: 0x8 SIZE: 0x4
ComPrimaryLight* primaryLights; //OFS: 0xC SIZE: 0x4
ComWaterHeader waterHeader; //OFS: 0x10 SIZE: 0x10
unsigned int numWaterCells; //OFS: 0x20 SIZE: 0x4
ComWaterCell* waterCells; //OFS: 0x24 SIZE: 0x4
ComBurnableHeader burnableHeader; //OFS: 0x28 SIZE: 0x10
unsigned int numBurnableCells; //OFS: 0x38 SIZE: 0x4
ComBurnableCell* burnableCells; //OFS: 0x3C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ComWorld, 0x40);
ASSERT_STRUCT_OFFSET(ComWorld, name, 0x0);
ASSERT_STRUCT_OFFSET(ComWorld, isInUse, 0x4);
ASSERT_STRUCT_OFFSET(ComWorld, primaryLightCount, 0x8);
ASSERT_STRUCT_OFFSET(ComWorld, primaryLights, 0xC);
ASSERT_STRUCT_OFFSET(ComWorld, waterHeader, 0x10);
ASSERT_STRUCT_OFFSET(ComWorld, numWaterCells, 0x20);
ASSERT_STRUCT_OFFSET(ComWorld, waterCells, 0x24);
ASSERT_STRUCT_OFFSET(ComWorld, burnableHeader, 0x28);
ASSERT_STRUCT_OFFSET(ComWorld, numBurnableCells, 0x38);
ASSERT_STRUCT_OFFSET(ComWorld, burnableCells, 0x3C);
struct pathlink_s
{
float fDist; //OFS: 0x0 SIZE: 0x4
unsigned __int16 nodeNum; //OFS: 0x4 SIZE: 0x2
unsigned __int8 disconnectCount; //OFS: 0x6 SIZE: 0x1
unsigned __int8 negotiationLink; //OFS: 0x7 SIZE: 0x1
unsigned __int8 ubBadPlaceCount[4]; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(pathlink_s, 0xC);
ASSERT_STRUCT_OFFSET(pathlink_s, fDist, 0x0);
ASSERT_STRUCT_OFFSET(pathlink_s, nodeNum, 0x4);
ASSERT_STRUCT_OFFSET(pathlink_s, disconnectCount, 0x6);
ASSERT_STRUCT_OFFSET(pathlink_s, negotiationLink, 0x7);
ASSERT_STRUCT_OFFSET(pathlink_s, ubBadPlaceCount, 0x8);
struct pathnode_constant_t
{
nodeType type; //OFS: 0x0 SIZE: 0x4
unsigned __int16 spawnflags; //OFS: 0x4 SIZE: 0x2
unsigned __int16 targetname; //OFS: 0x6 SIZE: 0x2
unsigned __int16 script_linkName; //OFS: 0x8 SIZE: 0x2
unsigned __int16 script_noteworthy; //OFS: 0xA SIZE: 0x2
unsigned __int16 target; //OFS: 0xC SIZE: 0x2
unsigned __int16 animscript; //OFS: 0xE SIZE: 0x2
int animscriptfunc; //OFS: 0x10 SIZE: 0x4
float vOrigin[3]; //OFS: 0x14 SIZE: 0xC
float fAngle; //OFS: 0x20 SIZE: 0x4
float forward[2]; //OFS: 0x24 SIZE: 0x8
float fRadius; //OFS: 0x2C SIZE: 0x4
float minUseDistSq; //OFS: 0x30 SIZE: 0x4
__int16 wOverlapNode[2]; //OFS: 0x34 SIZE: 0x4
__int16 wChainId; //OFS: 0x38 SIZE: 0x2
__int16 wChainDepth; //OFS: 0x3A SIZE: 0x2
__int16 wChainParent; //OFS: 0x3C SIZE: 0x2
unsigned __int16 totalLinkCount; //OFS: 0x3E SIZE: 0x2
pathlink_s* Links; //OFS: 0x40 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(pathnode_constant_t, 0x44);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, type, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, spawnflags, 0x4);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, targetname, 0x6);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, script_linkName, 0x8);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, script_noteworthy, 0xA);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, target, 0xC);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, animscript, 0xE);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, animscriptfunc, 0x10);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, vOrigin, 0x14);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, fAngle, 0x20);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, forward, 0x24);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, fRadius, 0x2C);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, minUseDistSq, 0x30);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, wOverlapNode, 0x34);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, wChainId, 0x38);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, wChainDepth, 0x3A);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, wChainParent, 0x3C);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, totalLinkCount, 0x3E);
ASSERT_STRUCT_OFFSET(pathnode_constant_t, Links, 0x40);
struct __declspec(align(2)) SentientHandle
{
unsigned __int16 number; //OFS: 0x0 SIZE: 0x2
unsigned __int16 infoIndex; //OFS: 0x2 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(SentientHandle, 0x4);
ASSERT_STRUCT_OFFSET(SentientHandle, number, 0x0);
ASSERT_STRUCT_OFFSET(SentientHandle, infoIndex, 0x2);
struct pathnode_dynamic_t
{
SentientHandle pOwner; //OFS: 0x0 SIZE: 0x4
int iFreeTime; //OFS: 0x4 SIZE: 0x4
int iValidTime[3]; //OFS: 0x8 SIZE: 0xC
int inPlayerLOSTime; //OFS: 0x14 SIZE: 0x4
__int16 wLinkCount; //OFS: 0x18 SIZE: 0x2
__int16 wOverlapCount; //OFS: 0x1A SIZE: 0x2
__int16 turretEntNumber; //OFS: 0x1C SIZE: 0x2
__int16 userCount; //OFS: 0x1E SIZE: 0x2
};
ASSERT_STRUCT_SIZE(pathnode_dynamic_t, 0x20);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, pOwner, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, iFreeTime, 0x4);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, iValidTime, 0x8);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, inPlayerLOSTime, 0x14);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, wLinkCount, 0x18);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, wOverlapCount, 0x1A);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, turretEntNumber, 0x1C);
ASSERT_STRUCT_OFFSET(pathnode_dynamic_t, userCount, 0x1E);
struct pathnode_transient_t
{
int iSearchFrame; //OFS: 0x0 SIZE: 0x4
pathnode_t* pNextOpen; //OFS: 0x4 SIZE: 0x4
pathnode_t* pPrevOpen; //OFS: 0x8 SIZE: 0x4
pathnode_t* pParent; //OFS: 0xC SIZE: 0x4
float fCost; //OFS: 0x10 SIZE: 0x4
float fHeuristic; //OFS: 0x14 SIZE: 0x4
float costFactor; //OFS: 0x18 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(pathnode_transient_t, 0x1C);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, iSearchFrame, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, pNextOpen, 0x4);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, pPrevOpen, 0x8);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, pParent, 0xC);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, fCost, 0x10);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, fHeuristic, 0x14);
ASSERT_STRUCT_OFFSET(pathnode_transient_t, costFactor, 0x18);
struct pathnode_t
{
pathnode_constant_t constant; //OFS: 0x0 SIZE: 0x44
pathnode_dynamic_t dynamic; //OFS: 0x44 SIZE: 0x20
pathnode_transient_t transient; //OFS: 0x64 SIZE: 0x1C
};
ASSERT_STRUCT_SIZE(pathnode_t, 0x80);
ASSERT_STRUCT_OFFSET(pathnode_t, constant, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_t, dynamic, 0x44);
ASSERT_STRUCT_OFFSET(pathnode_t, transient, 0x64);
struct pathbasenode_t
{
float vOrigin[3]; //OFS: 0x0 SIZE: 0xC
unsigned int type; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(pathbasenode_t, 0x10);
ASSERT_STRUCT_OFFSET(pathbasenode_t, vOrigin, 0x0);
ASSERT_STRUCT_OFFSET(pathbasenode_t, type, 0xC);
struct pathnode_tree_nodes_t
{
int nodeCount; //OFS: 0x0 SIZE: 0x4
unsigned __int16* nodes; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(pathnode_tree_nodes_t, 0x8);
ASSERT_STRUCT_OFFSET(pathnode_tree_nodes_t, nodeCount, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_tree_nodes_t, nodes, 0x4);
union pathnode_tree_info_t
{
pathnode_tree_t* child[2]; //OFS: 0x0 SIZE: 0x8
pathnode_tree_nodes_t s; //OFS: 0x1 SIZE: 0x8
};
struct pathnode_tree_t
{
int axis; //OFS: 0x0 SIZE: 0x4
float dist; //OFS: 0x4 SIZE: 0x4
pathnode_tree_info_t u; //OFS: 0x8 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(pathnode_tree_t, 0x10);
ASSERT_STRUCT_OFFSET(pathnode_tree_t, axis, 0x0);
ASSERT_STRUCT_OFFSET(pathnode_tree_t, dist, 0x4);
ASSERT_STRUCT_OFFSET(pathnode_tree_t, u, 0x8);
struct PathData
{
unsigned int nodeCount; //OFS: 0x0 SIZE: 0x4
pathnode_t* nodes; //OFS: 0x4 SIZE: 0x4
pathbasenode_t* basenodes; //OFS: 0x8 SIZE: 0x4
unsigned int chainNodeCount; //OFS: 0xC SIZE: 0x4
unsigned __int16* chainNodeForNode; //OFS: 0x10 SIZE: 0x4
unsigned __int16* nodeForChainNode; //OFS: 0x14 SIZE: 0x4
int visBytes; //OFS: 0x18 SIZE: 0x4
unsigned __int8* pathVis; //OFS: 0x1C SIZE: 0x4
int nodeTreeCount; //OFS: 0x20 SIZE: 0x4
pathnode_tree_t* nodeTree; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PathData, 0x28);
ASSERT_STRUCT_OFFSET(PathData, nodeCount, 0x0);
ASSERT_STRUCT_OFFSET(PathData, nodes, 0x4);
ASSERT_STRUCT_OFFSET(PathData, basenodes, 0x8);
ASSERT_STRUCT_OFFSET(PathData, chainNodeCount, 0xC);
ASSERT_STRUCT_OFFSET(PathData, chainNodeForNode, 0x10);
ASSERT_STRUCT_OFFSET(PathData, nodeForChainNode, 0x14);
ASSERT_STRUCT_OFFSET(PathData, visBytes, 0x18);
ASSERT_STRUCT_OFFSET(PathData, pathVis, 0x1C);
ASSERT_STRUCT_OFFSET(PathData, nodeTreeCount, 0x20);
ASSERT_STRUCT_OFFSET(PathData, nodeTree, 0x24);
struct GameWorldSp
{
const char* name; //OFS: 0x0 SIZE: 0x4
PathData path; //OFS: 0x4 SIZE: 0x28
};
ASSERT_STRUCT_SIZE(GameWorldSp, 0x2C);
ASSERT_STRUCT_OFFSET(GameWorldSp, name, 0x0);
ASSERT_STRUCT_OFFSET(GameWorldSp, path, 0x4);
struct GameWorldMp
{
char* name; //OFS: 0x0 SIZE: 0x4
PathData path; //OFS: 0x4 SIZE: 0x28
};
ASSERT_STRUCT_SIZE(GameWorldMp, 0x2C);
ASSERT_STRUCT_OFFSET(GameWorldMp, name, 0x0);
ASSERT_STRUCT_OFFSET(GameWorldMp, path, 0x4);
struct GfxWorldVertex
{
float xyz[3]; //OFS: 0x0 SIZE: 0xC
float binormalSign; //OFS: 0xC SIZE: 0x4
GfxColor color; //OFS: 0x10 SIZE: 0x4
float texCoord[2]; //OFS: 0x14 SIZE: 0x8
float lmapCoord[2]; //OFS: 0x1C SIZE: 0x8
PackedUnitVec normal; //OFS: 0x24 SIZE: 0x4
PackedUnitVec tangent; //OFS: 0x28 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorldVertex, 0x2C);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, xyz, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, binormalSign, 0xC);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, color, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, texCoord, 0x14);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, lmapCoord, 0x1C);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, normal, 0x24);
ASSERT_STRUCT_OFFSET(GfxWorldVertex, tangent, 0x28);
struct GfxVertexBuffer
{
void* data; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxVertexBuffer, 0x4);
ASSERT_STRUCT_OFFSET(GfxVertexBuffer, data, 0x0);
struct GfxWorldVertexData
{
GfxWorldVertex* vertices; //OFS: 0x0 SIZE: 0x4
GfxVertexBuffer worldVb; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorldVertexData, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorldVertexData, vertices, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldVertexData, worldVb, 0x4);
struct GfxWorldVertexLayerData
{
unsigned __int8* data; //OFS: 0x0 SIZE: 0x4
GfxVertexBuffer layerVb; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorldVertexLayerData, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorldVertexLayerData, data, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldVertexLayerData, layerVb, 0x4);
struct SunLightParseParams
{
char name[64]; //OFS: 0x0 SIZE: 0x40
float ambientScale; //OFS: 0x40 SIZE: 0x4
float ambientColor[3]; //OFS: 0x44 SIZE: 0xC
float diffuseFraction; //OFS: 0x50 SIZE: 0x4
float sunLight; //OFS: 0x54 SIZE: 0x4
float sunColor[3]; //OFS: 0x58 SIZE: 0xC
float diffuseColor[3]; //OFS: 0x64 SIZE: 0xC
bool diffuseColorHasBeenSet; //OFS: 0x70 SIZE: 0x1
float angles[3]; //OFS: 0x74 SIZE: 0xC
float treeScatterIntensity; //OFS: 0x80 SIZE: 0x4
float treeScatterAmount; //OFS: 0x84 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(SunLightParseParams, 0x88);
ASSERT_STRUCT_OFFSET(SunLightParseParams, name, 0x0);
ASSERT_STRUCT_OFFSET(SunLightParseParams, ambientScale, 0x40);
ASSERT_STRUCT_OFFSET(SunLightParseParams, ambientColor, 0x44);
ASSERT_STRUCT_OFFSET(SunLightParseParams, diffuseFraction, 0x50);
ASSERT_STRUCT_OFFSET(SunLightParseParams, sunLight, 0x54);
ASSERT_STRUCT_OFFSET(SunLightParseParams, sunColor, 0x58);
ASSERT_STRUCT_OFFSET(SunLightParseParams, diffuseColor, 0x64);
ASSERT_STRUCT_OFFSET(SunLightParseParams, diffuseColorHasBeenSet, 0x70);
ASSERT_STRUCT_OFFSET(SunLightParseParams, angles, 0x74);
ASSERT_STRUCT_OFFSET(SunLightParseParams, treeScatterIntensity, 0x80);
ASSERT_STRUCT_OFFSET(SunLightParseParams, treeScatterAmount, 0x84);
struct GfxLightImage
{
GfxImage* image; //OFS: 0x0 SIZE: 0x4
unsigned __int8 samplerState; //OFS: 0x4 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(GfxLightImage, 0x8);
ASSERT_STRUCT_OFFSET(GfxLightImage, image, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightImage, samplerState, 0x4);
struct GfxLightDef
{
char* name; //OFS: 0x0 SIZE: 0x4
GfxLightImage attenuation; //OFS: 0x4 SIZE: 0x8
int lmapLookupStart; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightDef, 0x10);
ASSERT_STRUCT_OFFSET(GfxLightDef, name, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightDef, attenuation, 0x4);
ASSERT_STRUCT_OFFSET(GfxLightDef, lmapLookupStart, 0xC);
struct GfxLight
{
unsigned __int8 type; //OFS: 0x0 SIZE: 0x1
unsigned __int8 canUseShadowMap; //OFS: 0x1 SIZE: 0x1
__int16 cullDist; //OFS: 0x2 SIZE: 0x2
float color[3]; //OFS: 0x4 SIZE: 0xC
float dir[3]; //OFS: 0x10 SIZE: 0xC
float origin[3]; //OFS: 0x1C SIZE: 0xC
float radius; //OFS: 0x28 SIZE: 0x4
float cosHalfFovOuter; //OFS: 0x2C SIZE: 0x4
float cosHalfFovInner; //OFS: 0x30 SIZE: 0x4
int exponent; //OFS: 0x34 SIZE: 0x4
unsigned int spotShadowIndex; //OFS: 0x38 SIZE: 0x4
GfxLightDef* def; //OFS: 0x3C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLight, 0x40);
ASSERT_STRUCT_OFFSET(GfxLight, type, 0x0);
ASSERT_STRUCT_OFFSET(GfxLight, canUseShadowMap, 0x1);
ASSERT_STRUCT_OFFSET(GfxLight, cullDist, 0x2);
ASSERT_STRUCT_OFFSET(GfxLight, color, 0x4);
ASSERT_STRUCT_OFFSET(GfxLight, dir, 0x10);
ASSERT_STRUCT_OFFSET(GfxLight, origin, 0x1C);
ASSERT_STRUCT_OFFSET(GfxLight, radius, 0x28);
ASSERT_STRUCT_OFFSET(GfxLight, cosHalfFovOuter, 0x2C);
ASSERT_STRUCT_OFFSET(GfxLight, cosHalfFovInner, 0x30);
ASSERT_STRUCT_OFFSET(GfxLight, exponent, 0x34);
ASSERT_STRUCT_OFFSET(GfxLight, spotShadowIndex, 0x38);
ASSERT_STRUCT_OFFSET(GfxLight, def, 0x3C);
struct GfxReflectionProbe
{
float origin[3]; //OFS: 0x0 SIZE: 0xC
GfxImage* reflectionImage; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxReflectionProbe, 0x10);
ASSERT_STRUCT_OFFSET(GfxReflectionProbe, origin, 0x0);
ASSERT_STRUCT_OFFSET(GfxReflectionProbe, reflectionImage, 0xC);
struct GfxLightCorona
{
float origin[3]; //OFS: 0x0 SIZE: 0xC
float radius; //OFS: 0xC SIZE: 0x4
float color[3]; //OFS: 0x10 SIZE: 0xC
float intensity; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightCorona, 0x20);
ASSERT_STRUCT_OFFSET(GfxLightCorona, origin, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightCorona, radius, 0xC);
ASSERT_STRUCT_OFFSET(GfxLightCorona, color, 0x10);
ASSERT_STRUCT_OFFSET(GfxLightCorona, intensity, 0x1C);
struct GfxWorldDpvsPlanes
{
int cellCount; //OFS: 0x0 SIZE: 0x4
cplane_s* planes; //OFS: 0x4 SIZE: 0x4
unsigned __int16* nodes; //OFS: 0x8 SIZE: 0x4
unsigned int* sceneEntCellBits; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorldDpvsPlanes, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsPlanes, cellCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsPlanes, planes, 0x4);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsPlanes, nodes, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsPlanes, sceneEntCellBits, 0xC);
struct GfxAabbTree
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
unsigned __int16 childCount; //OFS: 0x18 SIZE: 0x2
unsigned __int16 surfaceCount; //OFS: 0x1A SIZE: 0x2
unsigned __int16 startSurfIndex; //OFS: 0x1C SIZE: 0x2
unsigned __int16 smodelIndexCount; //OFS: 0x1E SIZE: 0x2
unsigned __int16* smodelIndexes; //OFS: 0x20 SIZE: 0x4
int childrenOffset; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxAabbTree, 0x28);
ASSERT_STRUCT_OFFSET(GfxAabbTree, mins, 0x0);
ASSERT_STRUCT_OFFSET(GfxAabbTree, maxs, 0xC);
ASSERT_STRUCT_OFFSET(GfxAabbTree, childCount, 0x18);
ASSERT_STRUCT_OFFSET(GfxAabbTree, surfaceCount, 0x1A);
ASSERT_STRUCT_OFFSET(GfxAabbTree, startSurfIndex, 0x1C);
ASSERT_STRUCT_OFFSET(GfxAabbTree, smodelIndexCount, 0x1E);
ASSERT_STRUCT_OFFSET(GfxAabbTree, smodelIndexes, 0x20);
ASSERT_STRUCT_OFFSET(GfxAabbTree, childrenOffset, 0x24);
struct GfxPortalWritable
{
bool isQueued; //OFS: 0x0 SIZE: 0x1
bool isAncestor; //OFS: 0x1 SIZE: 0x1
unsigned __int8 recursionDepth; //OFS: 0x2 SIZE: 0x1
unsigned __int8 hullPointCount; //OFS: 0x3 SIZE: 0x1
float (*hullPoints)[2]; //OFS: 0x4 SIZE: 0x4
GfxPortal* queuedParent; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxPortalWritable, 0xC);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, isQueued, 0x0);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, isAncestor, 0x1);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, recursionDepth, 0x2);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, hullPointCount, 0x3);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, hullPoints, 0x4);
ASSERT_STRUCT_OFFSET(GfxPortalWritable, queuedParent, 0x8);
struct DpvsPlane
{
float coeffs[4]; //OFS: 0x0 SIZE: 0x10
unsigned __int8 side[3]; //OFS: 0x10 SIZE: 0x3
unsigned __int8 pad; //OFS: 0x13 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(DpvsPlane, 0x14);
ASSERT_STRUCT_OFFSET(DpvsPlane, coeffs, 0x0);
ASSERT_STRUCT_OFFSET(DpvsPlane, side, 0x10);
ASSERT_STRUCT_OFFSET(DpvsPlane, pad, 0x13);
struct GfxPortal
{
GfxPortalWritable writable; //OFS: 0x0 SIZE: 0xC
DpvsPlane plane; //OFS: 0xC SIZE: 0x14
GfxCell* cell; //OFS: 0x20 SIZE: 0x4
float (*vertices)[3]; //OFS: 0x24 SIZE: 0x4
unsigned __int8 vertexCount; //OFS: 0x28 SIZE: 0x1
float hullAxis[2][3]; //OFS: 0x2C SIZE: 0x18
};
ASSERT_STRUCT_SIZE(GfxPortal, 0x44);
ASSERT_STRUCT_OFFSET(GfxPortal, writable, 0x0);
ASSERT_STRUCT_OFFSET(GfxPortal, plane, 0xC);
ASSERT_STRUCT_OFFSET(GfxPortal, cell, 0x20);
ASSERT_STRUCT_OFFSET(GfxPortal, vertices, 0x24);
ASSERT_STRUCT_OFFSET(GfxPortal, vertexCount, 0x28);
ASSERT_STRUCT_OFFSET(GfxPortal, hullAxis, 0x2C);
struct GfxCell
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
int aabbTreeCount; //OFS: 0x18 SIZE: 0x4
GfxAabbTree* aabbTree; //OFS: 0x1C SIZE: 0x4
int portalCount; //OFS: 0x20 SIZE: 0x4
GfxPortal* portals; //OFS: 0x24 SIZE: 0x4
int cullGroupCount; //OFS: 0x28 SIZE: 0x4
int* cullGroups; //OFS: 0x2C SIZE: 0x4
unsigned __int8 reflectionProbeCount; //OFS: 0x30 SIZE: 0x1
unsigned __int8* reflectionProbes; //OFS: 0x34 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxCell, 0x38);
ASSERT_STRUCT_OFFSET(GfxCell, mins, 0x0);
ASSERT_STRUCT_OFFSET(GfxCell, maxs, 0xC);
ASSERT_STRUCT_OFFSET(GfxCell, aabbTreeCount, 0x18);
ASSERT_STRUCT_OFFSET(GfxCell, aabbTree, 0x1C);
ASSERT_STRUCT_OFFSET(GfxCell, portalCount, 0x20);
ASSERT_STRUCT_OFFSET(GfxCell, portals, 0x24);
ASSERT_STRUCT_OFFSET(GfxCell, cullGroupCount, 0x28);
ASSERT_STRUCT_OFFSET(GfxCell, cullGroups, 0x2C);
ASSERT_STRUCT_OFFSET(GfxCell, reflectionProbeCount, 0x30);
ASSERT_STRUCT_OFFSET(GfxCell, reflectionProbes, 0x34);
struct __declspec(align(2)) GfxLightGridEntry
{
unsigned __int16 colorsIndex; //OFS: 0x0 SIZE: 0x2
unsigned __int8 primaryLightIndex; //OFS: 0x2 SIZE: 0x1
unsigned __int8 needsTrace; //OFS: 0x3 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(GfxLightGridEntry, 0x4);
ASSERT_STRUCT_OFFSET(GfxLightGridEntry, colorsIndex, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightGridEntry, primaryLightIndex, 0x2);
ASSERT_STRUCT_OFFSET(GfxLightGridEntry, needsTrace, 0x3);
struct __declspec(align(1)) GfxLightGridColors
{
unsigned __int8 rgb[56][3]; //OFS: 0x0 SIZE: 0xA8
};
ASSERT_STRUCT_SIZE(GfxLightGridColors, 0xA8);
ASSERT_STRUCT_OFFSET(GfxLightGridColors, rgb, 0x0);
struct GfxLightGrid
{
bool hasLightRegions; //OFS: 0x0 SIZE: 0x1
unsigned int sunPrimaryLightIndex; //OFS: 0x4 SIZE: 0x4
unsigned __int16 mins[3]; //OFS: 0x8 SIZE: 0x6
unsigned __int16 maxs[3]; //OFS: 0xE SIZE: 0x6
unsigned int rowAxis; //OFS: 0x14 SIZE: 0x4
unsigned int colAxis; //OFS: 0x18 SIZE: 0x4
unsigned __int16* rowDataStart; //OFS: 0x1C SIZE: 0x4
unsigned int rawRowDataSize; //OFS: 0x20 SIZE: 0x4
unsigned __int8* rawRowData; //OFS: 0x24 SIZE: 0x4
unsigned int entryCount; //OFS: 0x28 SIZE: 0x4
GfxLightGridEntry* entries; //OFS: 0x2C SIZE: 0x4
unsigned int colorCount; //OFS: 0x30 SIZE: 0x4
GfxLightGridColors* colors; //OFS: 0x34 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightGrid, 0x38);
ASSERT_STRUCT_OFFSET(GfxLightGrid, hasLightRegions, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightGrid, sunPrimaryLightIndex, 0x4);
ASSERT_STRUCT_OFFSET(GfxLightGrid, mins, 0x8);
ASSERT_STRUCT_OFFSET(GfxLightGrid, maxs, 0xE);
ASSERT_STRUCT_OFFSET(GfxLightGrid, rowAxis, 0x14);
ASSERT_STRUCT_OFFSET(GfxLightGrid, colAxis, 0x18);
ASSERT_STRUCT_OFFSET(GfxLightGrid, rowDataStart, 0x1C);
ASSERT_STRUCT_OFFSET(GfxLightGrid, rawRowDataSize, 0x20);
ASSERT_STRUCT_OFFSET(GfxLightGrid, rawRowData, 0x24);
ASSERT_STRUCT_OFFSET(GfxLightGrid, entryCount, 0x28);
ASSERT_STRUCT_OFFSET(GfxLightGrid, entries, 0x2C);
ASSERT_STRUCT_OFFSET(GfxLightGrid, colorCount, 0x30);
ASSERT_STRUCT_OFFSET(GfxLightGrid, colors, 0x34);
struct _GXTlutObj
{
unsigned int dummy[3]; //OFS: 0x0 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(_GXTlutObj, 0xC);
ASSERT_STRUCT_OFFSET(_GXTlutObj, dummy, 0x0);
struct nglPalette
{
_GXTlutObj TlutObj; //OFS: 0x0 SIZE: 0xC
unsigned int PaletteFormat; //OFS: 0xC SIZE: 0x4
unsigned int PaletteSize; //OFS: 0x10 SIZE: 0x4
unsigned __int8* PaletteData; //OFS: 0x14 SIZE: 0x4
bool InPlace; //OFS: 0x18 SIZE: 0x1
bool Dirty; //OFS: 0x19 SIZE: 0x1
};
ASSERT_STRUCT_SIZE(nglPalette, 0x1C);
ASSERT_STRUCT_OFFSET(nglPalette, TlutObj, 0x0);
ASSERT_STRUCT_OFFSET(nglPalette, PaletteFormat, 0xC);
ASSERT_STRUCT_OFFSET(nglPalette, PaletteSize, 0x10);
ASSERT_STRUCT_OFFSET(nglPalette, PaletteData, 0x14);
ASSERT_STRUCT_OFFSET(nglPalette, InPlace, 0x18);
ASSERT_STRUCT_OFFSET(nglPalette, Dirty, 0x19);
struct _GXTexObj
{
unsigned int dummy[8]; //OFS: 0x0 SIZE: 0x20
};
ASSERT_STRUCT_SIZE(_GXTexObj, 0x20);
ASSERT_STRUCT_OFFSET(_GXTexObj, dummy, 0x0);
struct gpuTexture
{
unsigned __int16 Width; //OFS: 0x0 SIZE: 0x2
unsigned __int16 Height; //OFS: 0x2 SIZE: 0x2
unsigned __int8 TexelFormat; //OFS: 0x4 SIZE: 0x1
unsigned __int8 Levels; //OFS: 0x5 SIZE: 0x1
unsigned __int16 Dummy; //OFS: 0x6 SIZE: 0x2
void* Data; //OFS: 0x8 SIZE: 0x4
nglPalette* Palette; //OFS: 0xC SIZE: 0x4
_GXTexObj texObj; //OFS: 0x10 SIZE: 0x20
};
ASSERT_STRUCT_SIZE(gpuTexture, 0x30);
ASSERT_STRUCT_OFFSET(gpuTexture, Width, 0x0);
ASSERT_STRUCT_OFFSET(gpuTexture, Height, 0x2);
ASSERT_STRUCT_OFFSET(gpuTexture, TexelFormat, 0x4);
ASSERT_STRUCT_OFFSET(gpuTexture, Levels, 0x5);
ASSERT_STRUCT_OFFSET(gpuTexture, Dummy, 0x6);
ASSERT_STRUCT_OFFSET(gpuTexture, Data, 0x8);
ASSERT_STRUCT_OFFSET(gpuTexture, Palette, 0xC);
ASSERT_STRUCT_OFFSET(gpuTexture, texObj, 0x10);
struct GfxBrushModelWritable
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
};
ASSERT_STRUCT_SIZE(GfxBrushModelWritable, 0x18);
ASSERT_STRUCT_OFFSET(GfxBrushModelWritable, mins, 0x0);
ASSERT_STRUCT_OFFSET(GfxBrushModelWritable, maxs, 0xC);
struct GfxBrushModel
{
GfxBrushModelWritable writable; //OFS: 0x0 SIZE: 0x18
float bounds[2][3]; //OFS: 0x18 SIZE: 0x18
unsigned int surfaceCount; //OFS: 0x30 SIZE: 0x4
unsigned int startSurfIndex; //OFS: 0x34 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxBrushModel, 0x38);
ASSERT_STRUCT_OFFSET(GfxBrushModel, writable, 0x0);
ASSERT_STRUCT_OFFSET(GfxBrushModel, bounds, 0x18);
ASSERT_STRUCT_OFFSET(GfxBrushModel, surfaceCount, 0x30);
ASSERT_STRUCT_OFFSET(GfxBrushModel, startSurfIndex, 0x34);
struct MaterialMemory
{
Material* material; //OFS: 0x0 SIZE: 0x4
int memory; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MaterialMemory, 0x8);
ASSERT_STRUCT_OFFSET(MaterialMemory, material, 0x0);
ASSERT_STRUCT_OFFSET(MaterialMemory, memory, 0x4);
struct sunflare_t
{
bool hasValidData; //OFS: 0x0 SIZE: 0x1
Material* spriteMaterial; //OFS: 0x4 SIZE: 0x4
Material* flareMaterial; //OFS: 0x8 SIZE: 0x4
float spriteSize; //OFS: 0xC SIZE: 0x4
float flareMinSize; //OFS: 0x10 SIZE: 0x4
float flareMinDot; //OFS: 0x14 SIZE: 0x4
float flareMaxSize; //OFS: 0x18 SIZE: 0x4
float flareMaxDot; //OFS: 0x1C SIZE: 0x4
float flareMaxAlpha; //OFS: 0x20 SIZE: 0x4
int flareFadeInTime; //OFS: 0x24 SIZE: 0x4
int flareFadeOutTime; //OFS: 0x28 SIZE: 0x4
float blindMinDot; //OFS: 0x2C SIZE: 0x4
float blindMaxDot; //OFS: 0x30 SIZE: 0x4
float blindMaxDarken; //OFS: 0x34 SIZE: 0x4
int blindFadeInTime; //OFS: 0x38 SIZE: 0x4
int blindFadeOutTime; //OFS: 0x3C SIZE: 0x4
float glareMinDot; //OFS: 0x40 SIZE: 0x4
float glareMaxDot; //OFS: 0x44 SIZE: 0x4
float glareMaxLighten; //OFS: 0x48 SIZE: 0x4
int glareFadeInTime; //OFS: 0x4C SIZE: 0x4
int glareFadeOutTime; //OFS: 0x50 SIZE: 0x4
float sunFxPosition[3]; //OFS: 0x54 SIZE: 0xC
};
ASSERT_STRUCT_SIZE(sunflare_t, 0x60);
ASSERT_STRUCT_OFFSET(sunflare_t, hasValidData, 0x0);
ASSERT_STRUCT_OFFSET(sunflare_t, spriteMaterial, 0x4);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMaterial, 0x8);
ASSERT_STRUCT_OFFSET(sunflare_t, spriteSize, 0xC);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMinSize, 0x10);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMinDot, 0x14);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMaxSize, 0x18);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMaxDot, 0x1C);
ASSERT_STRUCT_OFFSET(sunflare_t, flareMaxAlpha, 0x20);
ASSERT_STRUCT_OFFSET(sunflare_t, flareFadeInTime, 0x24);
ASSERT_STRUCT_OFFSET(sunflare_t, flareFadeOutTime, 0x28);
ASSERT_STRUCT_OFFSET(sunflare_t, blindMinDot, 0x2C);
ASSERT_STRUCT_OFFSET(sunflare_t, blindMaxDot, 0x30);
ASSERT_STRUCT_OFFSET(sunflare_t, blindMaxDarken, 0x34);
ASSERT_STRUCT_OFFSET(sunflare_t, blindFadeInTime, 0x38);
ASSERT_STRUCT_OFFSET(sunflare_t, blindFadeOutTime, 0x3C);
ASSERT_STRUCT_OFFSET(sunflare_t, glareMinDot, 0x40);
ASSERT_STRUCT_OFFSET(sunflare_t, glareMaxDot, 0x44);
ASSERT_STRUCT_OFFSET(sunflare_t, glareMaxLighten, 0x48);
ASSERT_STRUCT_OFFSET(sunflare_t, glareFadeInTime, 0x4C);
ASSERT_STRUCT_OFFSET(sunflare_t, glareFadeOutTime, 0x50);
ASSERT_STRUCT_OFFSET(sunflare_t, sunFxPosition, 0x54);
struct __declspec(align(2)) XModelDrawInfo
{
unsigned __int16 lod; //OFS: 0x0 SIZE: 0x2
unsigned __int16 surfId; //OFS: 0x2 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XModelDrawInfo, 0x4);
ASSERT_STRUCT_OFFSET(XModelDrawInfo, lod, 0x0);
ASSERT_STRUCT_OFFSET(XModelDrawInfo, surfId, 0x2);
struct __declspec(align(2)) GfxSceneDynModel
{
XModelDrawInfo info; //OFS: 0x0 SIZE: 0x4
unsigned __int16 dynEntId; //OFS: 0x4 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxSceneDynModel, 0x6);
ASSERT_STRUCT_OFFSET(GfxSceneDynModel, info, 0x0);
ASSERT_STRUCT_OFFSET(GfxSceneDynModel, dynEntId, 0x4);
struct __declspec(align(2)) BModelDrawInfo
{
unsigned __int16 surfId; //OFS: 0x0 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(BModelDrawInfo, 0x2);
ASSERT_STRUCT_OFFSET(BModelDrawInfo, surfId, 0x0);
struct __declspec(align(2)) GfxSceneDynBrush
{
BModelDrawInfo info; //OFS: 0x0 SIZE: 0x2
unsigned __int16 dynEntId; //OFS: 0x2 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxSceneDynBrush, 0x4);
ASSERT_STRUCT_OFFSET(GfxSceneDynBrush, info, 0x0);
ASSERT_STRUCT_OFFSET(GfxSceneDynBrush, dynEntId, 0x2);
struct GfxShadowGeometry
{
unsigned __int16 surfaceCount; //OFS: 0x0 SIZE: 0x2
unsigned __int16 smodelCount; //OFS: 0x2 SIZE: 0x2
unsigned __int16* sortedSurfIndex; //OFS: 0x4 SIZE: 0x4
unsigned __int16* smodelIndex; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxShadowGeometry, 0xC);
ASSERT_STRUCT_OFFSET(GfxShadowGeometry, surfaceCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxShadowGeometry, smodelCount, 0x2);
ASSERT_STRUCT_OFFSET(GfxShadowGeometry, sortedSurfIndex, 0x4);
ASSERT_STRUCT_OFFSET(GfxShadowGeometry, smodelIndex, 0x8);
struct GfxLightRegionAxis
{
float dir[3]; //OFS: 0x0 SIZE: 0xC
float midPoint; //OFS: 0xC SIZE: 0x4
float halfSize; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightRegionAxis, 0x14);
ASSERT_STRUCT_OFFSET(GfxLightRegionAxis, dir, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightRegionAxis, midPoint, 0xC);
ASSERT_STRUCT_OFFSET(GfxLightRegionAxis, halfSize, 0x10);
struct GfxLightRegionHull
{
float kdopMidPoint[9]; //OFS: 0x0 SIZE: 0x24
float kdopHalfSize[9]; //OFS: 0x24 SIZE: 0x24
unsigned int axisCount; //OFS: 0x48 SIZE: 0x4
GfxLightRegionAxis* axis; //OFS: 0x4C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightRegionHull, 0x50);
ASSERT_STRUCT_OFFSET(GfxLightRegionHull, kdopMidPoint, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightRegionHull, kdopHalfSize, 0x24);
ASSERT_STRUCT_OFFSET(GfxLightRegionHull, axisCount, 0x48);
ASSERT_STRUCT_OFFSET(GfxLightRegionHull, axis, 0x4C);
struct GfxLightRegion
{
unsigned int hullCount; //OFS: 0x0 SIZE: 0x4
GfxLightRegionHull* hulls; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxLightRegion, 0x8);
ASSERT_STRUCT_OFFSET(GfxLightRegion, hullCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxLightRegion, hulls, 0x4);
struct GfxStaticModelInst
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
GfxColor groundLighting; //OFS: 0x18 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxStaticModelInst, 0x1C);
ASSERT_STRUCT_OFFSET(GfxStaticModelInst, mins, 0x0);
ASSERT_STRUCT_OFFSET(GfxStaticModelInst, maxs, 0xC);
ASSERT_STRUCT_OFFSET(GfxStaticModelInst, groundLighting, 0x18);
struct srfTriangles_t
{
int vertexLayerData; //OFS: 0x0 SIZE: 0x4
int firstVertex; //OFS: 0x4 SIZE: 0x4
unsigned __int16 vertexCount; //OFS: 0x8 SIZE: 0x2
unsigned __int16 triCount; //OFS: 0xA SIZE: 0x2
int baseIndex; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(srfTriangles_t, 0x10);
ASSERT_STRUCT_OFFSET(srfTriangles_t, vertexLayerData, 0x0);
ASSERT_STRUCT_OFFSET(srfTriangles_t, firstVertex, 0x4);
ASSERT_STRUCT_OFFSET(srfTriangles_t, vertexCount, 0x8);
ASSERT_STRUCT_OFFSET(srfTriangles_t, triCount, 0xA);
ASSERT_STRUCT_OFFSET(srfTriangles_t, baseIndex, 0xC);
struct GfxSurface
{
srfTriangles_t tris; //OFS: 0x0 SIZE: 0x10
int pad; //OFS: 0x10 SIZE: 0x4
Material* material; //OFS: 0x14 SIZE: 0x4
char lightmapIndex; //OFS: 0x18 SIZE: 0x1
char reflectionProbeIndex; //OFS: 0x19 SIZE: 0x1
char primaryLightIndex; //OFS: 0x1A SIZE: 0x1
char flags; //OFS: 0x1B SIZE: 0x1
float bounds[2][3]; //OFS: 0x1C SIZE: 0x18
};
ASSERT_STRUCT_SIZE(GfxSurface, 0x34);
ASSERT_STRUCT_OFFSET(GfxSurface, tris, 0x0);
ASSERT_STRUCT_OFFSET(GfxSurface, pad, 0x10);
ASSERT_STRUCT_OFFSET(GfxSurface, material, 0x14);
ASSERT_STRUCT_OFFSET(GfxSurface, lightmapIndex, 0x18);
ASSERT_STRUCT_OFFSET(GfxSurface, reflectionProbeIndex, 0x19);
ASSERT_STRUCT_OFFSET(GfxSurface, primaryLightIndex, 0x1A);
ASSERT_STRUCT_OFFSET(GfxSurface, flags, 0x1B);
ASSERT_STRUCT_OFFSET(GfxSurface, bounds, 0x1C);
struct GfxCullGroup
{
float mins[3]; //OFS: 0x0 SIZE: 0xC
float maxs[3]; //OFS: 0xC SIZE: 0xC
int surfaceCount; //OFS: 0x18 SIZE: 0x4
int startSurfIndex; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxCullGroup, 0x20);
ASSERT_STRUCT_OFFSET(GfxCullGroup, mins, 0x0);
ASSERT_STRUCT_OFFSET(GfxCullGroup, maxs, 0xC);
ASSERT_STRUCT_OFFSET(GfxCullGroup, surfaceCount, 0x18);
ASSERT_STRUCT_OFFSET(GfxCullGroup, startSurfIndex, 0x1C);
struct GfxPackedPlacement
{
float origin[3]; //OFS: 0x0 SIZE: 0xC
float axis[3][3]; //OFS: 0xC SIZE: 0x24
float scale; //OFS: 0x30 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxPackedPlacement, 0x34);
ASSERT_STRUCT_OFFSET(GfxPackedPlacement, origin, 0x0);
ASSERT_STRUCT_OFFSET(GfxPackedPlacement, axis, 0xC);
ASSERT_STRUCT_OFFSET(GfxPackedPlacement, scale, 0x30);
struct ModelLodFade
{
unsigned int value; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ModelLodFade, 0x4);
ASSERT_STRUCT_OFFSET(ModelLodFade, value, 0x0);
struct GfxStaticModelDrawInst
{
float cullDist; //OFS: 0x0 SIZE: 0x4
GfxPackedPlacement placement; //OFS: 0x4 SIZE: 0x34
XModel* model; //OFS: 0x38 SIZE: 0x4
ModelLodFade lodFade_idk; //OFS: 0x3C SIZE: 0x4
int cachedLightSettingIndex_idk; //OFS: 0x40 SIZE: 0x4
char field_44; //OFS: 0x44 SIZE: 0x1
char field_45; //OFS: 0x45 SIZE: 0x1
unsigned __int8 reflectionProbeIndex; //OFS: 0x46 SIZE: 0x1
unsigned __int8 primaryLightIndex; //OFS: 0x47 SIZE: 0x1
int flags; //OFS: 0x48 SIZE: 0x4
unsigned int sModelCacheIndex_idk[4]; //OFS: 0x4C SIZE: 0x10
};
ASSERT_STRUCT_SIZE(GfxStaticModelDrawInst, 0x5C);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, cullDist, 0x0);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, placement, 0x4);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, model, 0x38);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, lodFade_idk, 0x3C);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, cachedLightSettingIndex_idk, 0x40);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, field_44, 0x44);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, field_45, 0x45);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, reflectionProbeIndex, 0x46);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, primaryLightIndex, 0x47);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, flags, 0x48);
ASSERT_STRUCT_OFFSET(GfxStaticModelDrawInst, sModelCacheIndex_idk, 0x4C);
struct GfxWorldDpvsStatic
{
unsigned int smodelCount; //OFS: 0x0 SIZE: 0x4
unsigned int staticSurfaceCount; //OFS: 0x4 SIZE: 0x4
unsigned int litSurfsBegin; //OFS: 0x8 SIZE: 0x4
unsigned int litSurfsEnd; //OFS: 0xC SIZE: 0x4
unsigned int decalSurfsBegin; //OFS: 0x10 SIZE: 0x4
unsigned int decalSurfsEnd; //OFS: 0x14 SIZE: 0x4
unsigned int emissiveSurfsBegin; //OFS: 0x18 SIZE: 0x4
unsigned int emissiveSurfsEnd; //OFS: 0x1C SIZE: 0x4
unsigned int smodelVisDataCount; //OFS: 0x20 SIZE: 0x4
unsigned int surfaceVisDataCount; //OFS: 0x24 SIZE: 0x4
unsigned __int8* smodelVisData[3]; //OFS: 0x28 SIZE: 0xC
unsigned __int8* surfaceVisData[3]; //OFS: 0x34 SIZE: 0xC
unsigned int* lodData; //OFS: 0x40 SIZE: 0x4
unsigned __int16* sortedSurfIndex; //OFS: 0x44 SIZE: 0x4
GfxStaticModelInst* smodelInsts; //OFS: 0x48 SIZE: 0x4
GfxSurface* surfaces; //OFS: 0x4C SIZE: 0x4
GfxCullGroup* cullGroups; //OFS: 0x50 SIZE: 0x4
GfxStaticModelDrawInst* smodelDrawInsts; //OFS: 0x54 SIZE: 0x4
GfxDrawSurf* surfaceMaterials; //OFS: 0x58 SIZE: 0x4
unsigned int* surfaceCastsSunShadow; //OFS: 0x5C SIZE: 0x4
int usageCount; //OFS: 0x60 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorldDpvsStatic, 0x64);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, smodelCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, staticSurfaceCount, 0x4);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, litSurfsBegin, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, litSurfsEnd, 0xC);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, decalSurfsBegin, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, decalSurfsEnd, 0x14);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, emissiveSurfsBegin, 0x18);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, emissiveSurfsEnd, 0x1C);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, smodelVisDataCount, 0x20);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, surfaceVisDataCount, 0x24);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, smodelVisData, 0x28);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, surfaceVisData, 0x34);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, lodData, 0x40);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, sortedSurfIndex, 0x44);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, smodelInsts, 0x48);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, surfaces, 0x4C);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, cullGroups, 0x50);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, smodelDrawInsts, 0x54);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, surfaceMaterials, 0x58);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, surfaceCastsSunShadow, 0x5C);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsStatic, usageCount, 0x60);
struct GfxWorldDpvsDynamic
{
unsigned int dynEntClientWordCount[2]; //OFS: 0x0 SIZE: 0x8
unsigned int dynEntClientCount[2]; //OFS: 0x8 SIZE: 0x8
unsigned int* dynEntCellBits[2]; //OFS: 0x10 SIZE: 0x8
unsigned __int8* dynEntVisData[2][3]; //OFS: 0x18 SIZE: 0x18
};
ASSERT_STRUCT_SIZE(GfxWorldDpvsDynamic, 0x30);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsDynamic, dynEntClientWordCount, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsDynamic, dynEntClientCount, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsDynamic, dynEntCellBits, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorldDpvsDynamic, dynEntVisData, 0x18);
struct GfxWorldLodChain
{
float origin[3]; //OFS: 0x0 SIZE: 0xC
float lastDist; //OFS: 0xC SIZE: 0x4
unsigned int firstLodInfo; //OFS: 0x10 SIZE: 0x4
unsigned __int16 lodInfoCount; //OFS: 0x14 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxWorldLodChain, 0x18);
ASSERT_STRUCT_OFFSET(GfxWorldLodChain, origin, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldLodChain, lastDist, 0xC);
ASSERT_STRUCT_OFFSET(GfxWorldLodChain, firstLodInfo, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorldLodChain, lodInfoCount, 0x14);
struct GfxWorldLodInfo
{
float dist; //OFS: 0x0 SIZE: 0x4
unsigned int firstSurf; //OFS: 0x4 SIZE: 0x4
unsigned __int16 surfCount; //OFS: 0x8 SIZE: 0x2
};
ASSERT_STRUCT_SIZE(GfxWorldLodInfo, 0xC);
ASSERT_STRUCT_OFFSET(GfxWorldLodInfo, dist, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorldLodInfo, firstSurf, 0x4);
ASSERT_STRUCT_OFFSET(GfxWorldLodInfo, surfCount, 0x8);
struct GfxWaterBuffer
{
unsigned int bufferSize; //OFS: 0x0 SIZE: 0x4
float (*buffer)[4]; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWaterBuffer, 0x8);
ASSERT_STRUCT_OFFSET(GfxWaterBuffer, bufferSize, 0x0);
ASSERT_STRUCT_OFFSET(GfxWaterBuffer, buffer, 0x4);
struct GfxWorld
{
const char* name; //OFS: 0x0 SIZE: 0x4
const char* baseName; //OFS: 0x4 SIZE: 0x4
int planeCount; //OFS: 0x8 SIZE: 0x4
int nodeCount; //OFS: 0xC SIZE: 0x4
int indexCount; //OFS: 0x10 SIZE: 0x4
unsigned __int16* indices; //OFS: 0x14 SIZE: 0x4
int surfaceCount; //OFS: 0x18 SIZE: 0x4
int streamInfo; //OFS: 0x1C SIZE: 0x4
int skySurfCount; //OFS: 0x20 SIZE: 0x4
int* skyStartSurfs; //OFS: 0x24 SIZE: 0x4
GfxImage* skyImage; //OFS: 0x28 SIZE: 0x4
unsigned __int8 skySamplerState; //OFS: 0x2C SIZE: 0x1
char* skyBoxModel; //OFS: 0x30 SIZE: 0x4
unsigned int vertexCount; //OFS: 0x34 SIZE: 0x4
GfxWorldVertexData vd; //OFS: 0x38 SIZE: 0x8
unsigned int vertexLayerDataSize; //OFS: 0x40 SIZE: 0x4
GfxWorldVertexLayerData vld; //OFS: 0x44 SIZE: 0x8
unsigned int vertexStream2DataSize; //OFS: 0x4C SIZE: 0x4
SunLightParseParams sunParse; //OFS: 0x50 SIZE: 0x88
GfxLight* sunLight; //OFS: 0xD8 SIZE: 0x4
float sunColorFromBsp[3]; //OFS: 0xDC SIZE: 0xC
unsigned int sunPrimaryLightIndex; //OFS: 0xE8 SIZE: 0x4
unsigned int primaryLightCount; //OFS: 0xEC SIZE: 0x4
int cullGroupCount; //OFS: 0xF0 SIZE: 0x4
unsigned int reflectionProbeCount; //OFS: 0xF4 SIZE: 0x4
GfxReflectionProbe* reflectionProbes; //OFS: 0xF8 SIZE: 0x4
GfxTexture* reflectionProbeTextures; //OFS: 0xFC SIZE: 0x4
unsigned int coronaCount; //OFS: 0x100 SIZE: 0x4
GfxLightCorona* coronas; //OFS: 0x104 SIZE: 0x4
GfxWorldDpvsPlanes dpvsPlanes; //OFS: 0x108 SIZE: 0x10
int cellBitsCount; //OFS: 0x118 SIZE: 0x4
GfxCell* cells; //OFS: 0x11C SIZE: 0x4
int lightmapCount; //OFS: 0x120 SIZE: 0x4
GfxImage** lightmaps; //OFS: 0x124 SIZE: 0x4
GfxLightGrid lightGrid; //OFS: 0x128 SIZE: 0x38
gpuTexture* lightmapPrimaryTextures; //OFS: 0x160 SIZE: 0x4
gpuTexture* lightmapSecondaryTextures; //OFS: 0x164 SIZE: 0x4
int modelCount; //OFS: 0x168 SIZE: 0x4
GfxBrushModel* models; //OFS: 0x16C SIZE: 0x4
float mins[3]; //OFS: 0x170 SIZE: 0xC
float maxs[3]; //OFS: 0x17C SIZE: 0xC
unsigned int checksum; //OFS: 0x188 SIZE: 0x4
int materialMemoryCount; //OFS: 0x18C SIZE: 0x4
MaterialMemory* materialMemory; //OFS: 0x190 SIZE: 0x4
sunflare_t sun; //OFS: 0x194 SIZE: 0x60
float outdoorLookupMatrix[4][4]; //OFS: 0x1F4 SIZE: 0x40
GfxImage* outdoorImage; //OFS: 0x234 SIZE: 0x4
unsigned int* cellCasterBits; //OFS: 0x238 SIZE: 0x4
GfxSceneDynModel* sceneDynModel; //OFS: 0x23C SIZE: 0x4
GfxSceneDynBrush* sceneDynBrush; //OFS: 0x240 SIZE: 0x4
unsigned int* primaryLightEntityShadowVis; //OFS: 0x244 SIZE: 0x4
unsigned int* primaryLightDynEntShadowVis[2]; //OFS: 0x248 SIZE: 0x8
char* nonSunPrimaryLightForModelDynEnt; //OFS: 0x250 SIZE: 0x4
GfxShadowGeometry* shadowGeom; //OFS: 0x254 SIZE: 0x4
GfxLightRegion* lightRegion; //OFS: 0x258 SIZE: 0x4
GfxWorldDpvsStatic dpvs; //OFS: 0x25C SIZE: 0x64
GfxWorldDpvsDynamic dpvsDyn; //OFS: 0x2C0 SIZE: 0x30
unsigned int worldLodChainCount; //OFS: 0x2F0 SIZE: 0x4
GfxWorldLodChain* worldLodChains; //OFS: 0x2F4 SIZE: 0x4
unsigned int worldLodInfoCount; //OFS: 0x2F8 SIZE: 0x4
GfxWorldLodInfo* worldLodInfos; //OFS: 0x2FC SIZE: 0x4
unsigned int worldLodSurfaceCount; //OFS: 0x300 SIZE: 0x4
unsigned int* worldLodSurfaces; //OFS: 0x304 SIZE: 0x4
float waterDirection; //OFS: 0x308 SIZE: 0x4
GfxWaterBuffer waterBuffers[2]; //OFS: 0x30C SIZE: 0x10
Material* waterMaterial; //OFS: 0x31C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(GfxWorld, 0x320);
ASSERT_STRUCT_OFFSET(GfxWorld, name, 0x0);
ASSERT_STRUCT_OFFSET(GfxWorld, baseName, 0x4);
ASSERT_STRUCT_OFFSET(GfxWorld, planeCount, 0x8);
ASSERT_STRUCT_OFFSET(GfxWorld, nodeCount, 0xC);
ASSERT_STRUCT_OFFSET(GfxWorld, indexCount, 0x10);
ASSERT_STRUCT_OFFSET(GfxWorld, indices, 0x14);
ASSERT_STRUCT_OFFSET(GfxWorld, surfaceCount, 0x18);
ASSERT_STRUCT_OFFSET(GfxWorld, streamInfo, 0x1C);
ASSERT_STRUCT_OFFSET(GfxWorld, skySurfCount, 0x20);
ASSERT_STRUCT_OFFSET(GfxWorld, skyStartSurfs, 0x24);
ASSERT_STRUCT_OFFSET(GfxWorld, skyImage, 0x28);
ASSERT_STRUCT_OFFSET(GfxWorld, skySamplerState, 0x2C);
ASSERT_STRUCT_OFFSET(GfxWorld, skyBoxModel, 0x30);
ASSERT_STRUCT_OFFSET(GfxWorld, vertexCount, 0x34);
ASSERT_STRUCT_OFFSET(GfxWorld, vd, 0x38);
ASSERT_STRUCT_OFFSET(GfxWorld, vertexLayerDataSize, 0x40);
ASSERT_STRUCT_OFFSET(GfxWorld, vld, 0x44);
ASSERT_STRUCT_OFFSET(GfxWorld, vertexStream2DataSize, 0x4C);
ASSERT_STRUCT_OFFSET(GfxWorld, sunParse, 0x50);
ASSERT_STRUCT_OFFSET(GfxWorld, sunLight, 0xD8);
ASSERT_STRUCT_OFFSET(GfxWorld, sunColorFromBsp, 0xDC);
ASSERT_STRUCT_OFFSET(GfxWorld, sunPrimaryLightIndex, 0xE8);
ASSERT_STRUCT_OFFSET(GfxWorld, primaryLightCount, 0xEC);
ASSERT_STRUCT_OFFSET(GfxWorld, cullGroupCount, 0xF0);
ASSERT_STRUCT_OFFSET(GfxWorld, reflectionProbeCount, 0xF4);
ASSERT_STRUCT_OFFSET(GfxWorld, reflectionProbes, 0xF8);
ASSERT_STRUCT_OFFSET(GfxWorld, reflectionProbeTextures, 0xFC);
ASSERT_STRUCT_OFFSET(GfxWorld, coronaCount, 0x100);
ASSERT_STRUCT_OFFSET(GfxWorld, coronas, 0x104);
ASSERT_STRUCT_OFFSET(GfxWorld, dpvsPlanes, 0x108);
ASSERT_STRUCT_OFFSET(GfxWorld, cellBitsCount, 0x118);
ASSERT_STRUCT_OFFSET(GfxWorld, cells, 0x11C);
ASSERT_STRUCT_OFFSET(GfxWorld, lightmapCount, 0x120);
ASSERT_STRUCT_OFFSET(GfxWorld, lightmaps, 0x124);
ASSERT_STRUCT_OFFSET(GfxWorld, lightGrid, 0x128);
ASSERT_STRUCT_OFFSET(GfxWorld, lightmapPrimaryTextures, 0x160);
ASSERT_STRUCT_OFFSET(GfxWorld, lightmapSecondaryTextures, 0x164);
ASSERT_STRUCT_OFFSET(GfxWorld, modelCount, 0x168);
ASSERT_STRUCT_OFFSET(GfxWorld, models, 0x16C);
ASSERT_STRUCT_OFFSET(GfxWorld, mins, 0x170);
ASSERT_STRUCT_OFFSET(GfxWorld, maxs, 0x17C);
ASSERT_STRUCT_OFFSET(GfxWorld, checksum, 0x188);
ASSERT_STRUCT_OFFSET(GfxWorld, materialMemoryCount, 0x18C);
ASSERT_STRUCT_OFFSET(GfxWorld, materialMemory, 0x190);
ASSERT_STRUCT_OFFSET(GfxWorld, sun, 0x194);
ASSERT_STRUCT_OFFSET(GfxWorld, outdoorLookupMatrix, 0x1F4);
ASSERT_STRUCT_OFFSET(GfxWorld, outdoorImage, 0x234);
ASSERT_STRUCT_OFFSET(GfxWorld, cellCasterBits, 0x238);
ASSERT_STRUCT_OFFSET(GfxWorld, sceneDynModel, 0x23C);
ASSERT_STRUCT_OFFSET(GfxWorld, sceneDynBrush, 0x240);
ASSERT_STRUCT_OFFSET(GfxWorld, primaryLightEntityShadowVis, 0x244);
ASSERT_STRUCT_OFFSET(GfxWorld, primaryLightDynEntShadowVis, 0x248);
ASSERT_STRUCT_OFFSET(GfxWorld, nonSunPrimaryLightForModelDynEnt, 0x250);
ASSERT_STRUCT_OFFSET(GfxWorld, shadowGeom, 0x254);
ASSERT_STRUCT_OFFSET(GfxWorld, lightRegion, 0x258);
ASSERT_STRUCT_OFFSET(GfxWorld, dpvs, 0x25C);
ASSERT_STRUCT_OFFSET(GfxWorld, dpvsDyn, 0x2C0);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodChainCount, 0x2F0);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodChains, 0x2F4);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodInfoCount, 0x2F8);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodInfos, 0x2FC);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodSurfaceCount, 0x300);
ASSERT_STRUCT_OFFSET(GfxWorld, worldLodSurfaces, 0x304);
ASSERT_STRUCT_OFFSET(GfxWorld, waterDirection, 0x308);
ASSERT_STRUCT_OFFSET(GfxWorld, waterBuffers, 0x30C);
ASSERT_STRUCT_OFFSET(GfxWorld, waterMaterial, 0x31C);
struct Glyph
{
unsigned __int16 letter; //OFS: 0x0 SIZE: 0x2
char x0; //OFS: 0x2 SIZE: 0x1
char y0; //OFS: 0x3 SIZE: 0x1
unsigned __int8 _dx; //OFS: 0x4 SIZE: 0x1
unsigned __int8 pixelWidth; //OFS: 0x5 SIZE: 0x1
unsigned __int8 pixelHeight; //OFS: 0x6 SIZE: 0x1
float s0; //OFS: 0x8 SIZE: 0x4
float t0; //OFS: 0xC SIZE: 0x4
float s1; //OFS: 0x10 SIZE: 0x4
float t1; //OFS: 0x14 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(Glyph, 0x18);
ASSERT_STRUCT_OFFSET(Glyph, letter, 0x0);
ASSERT_STRUCT_OFFSET(Glyph, x0, 0x2);
ASSERT_STRUCT_OFFSET(Glyph, y0, 0x3);
ASSERT_STRUCT_OFFSET(Glyph, _dx, 0x4);
ASSERT_STRUCT_OFFSET(Glyph, pixelWidth, 0x5);
ASSERT_STRUCT_OFFSET(Glyph, pixelHeight, 0x6);
ASSERT_STRUCT_OFFSET(Glyph, s0, 0x8);
ASSERT_STRUCT_OFFSET(Glyph, t0, 0xC);
ASSERT_STRUCT_OFFSET(Glyph, s1, 0x10);
ASSERT_STRUCT_OFFSET(Glyph, t1, 0x14);
struct Font_s
{
char* fontName; //OFS: 0x0 SIZE: 0x4
int pixelHeight; //OFS: 0x4 SIZE: 0x4
int glyphCount; //OFS: 0x8 SIZE: 0x4
Material* material; //OFS: 0xC SIZE: 0x4
Material* glowMaterial; //OFS: 0x10 SIZE: 0x4
Glyph* glyphs; //OFS: 0x14 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(Font_s, 0x18);
ASSERT_STRUCT_OFFSET(Font_s, fontName, 0x0);
ASSERT_STRUCT_OFFSET(Font_s, pixelHeight, 0x4);
ASSERT_STRUCT_OFFSET(Font_s, glyphCount, 0x8);
ASSERT_STRUCT_OFFSET(Font_s, material, 0xC);
ASSERT_STRUCT_OFFSET(Font_s, glowMaterial, 0x10);
ASSERT_STRUCT_OFFSET(Font_s, glyphs, 0x14);
struct rectDef_s
{
float x; //OFS: 0x0 SIZE: 0x4
float y; //OFS: 0x4 SIZE: 0x4
float w; //OFS: 0x8 SIZE: 0x4
float h; //OFS: 0xC SIZE: 0x4
int horzAlign; //OFS: 0x10 SIZE: 0x4
int vertAlign; //OFS: 0x14 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(rectDef_s, 0x18);
ASSERT_STRUCT_OFFSET(rectDef_s, x, 0x0);
ASSERT_STRUCT_OFFSET(rectDef_s, y, 0x4);
ASSERT_STRUCT_OFFSET(rectDef_s, w, 0x8);
ASSERT_STRUCT_OFFSET(rectDef_s, h, 0xC);
ASSERT_STRUCT_OFFSET(rectDef_s, horzAlign, 0x10);
ASSERT_STRUCT_OFFSET(rectDef_s, vertAlign, 0x14);
struct windowDef_t
{
const char* name; //OFS: 0x0 SIZE: 0x4
rectDef_s rect; //OFS: 0x4 SIZE: 0x18
rectDef_s rectClient; //OFS: 0x1C SIZE: 0x18
const char* group; //OFS: 0x34 SIZE: 0x4
int style; //OFS: 0x38 SIZE: 0x4
int border; //OFS: 0x3C SIZE: 0x4
int ownerDraw; //OFS: 0x40 SIZE: 0x4
int ownerDrawFlags; //OFS: 0x44 SIZE: 0x4
float borderSize; //OFS: 0x48 SIZE: 0x4
int staticFlags; //OFS: 0x4C SIZE: 0x4
int dynamicFlags[1]; //OFS: 0x50 SIZE: 0x4
int nextTime; //OFS: 0x54 SIZE: 0x4
float foreColor[4]; //OFS: 0x58 SIZE: 0x10
float backColor[4]; //OFS: 0x68 SIZE: 0x10
float borderColor[4]; //OFS: 0x78 SIZE: 0x10
float outlineColor[4]; //OFS: 0x88 SIZE: 0x10
Material* background; //OFS: 0x98 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(windowDef_t, 0x9C);
ASSERT_STRUCT_OFFSET(windowDef_t, name, 0x0);
ASSERT_STRUCT_OFFSET(windowDef_t, rect, 0x4);
ASSERT_STRUCT_OFFSET(windowDef_t, rectClient, 0x1C);
ASSERT_STRUCT_OFFSET(windowDef_t, group, 0x34);
ASSERT_STRUCT_OFFSET(windowDef_t, style, 0x38);
ASSERT_STRUCT_OFFSET(windowDef_t, border, 0x3C);
ASSERT_STRUCT_OFFSET(windowDef_t, ownerDraw, 0x40);
ASSERT_STRUCT_OFFSET(windowDef_t, ownerDrawFlags, 0x44);
ASSERT_STRUCT_OFFSET(windowDef_t, borderSize, 0x48);
ASSERT_STRUCT_OFFSET(windowDef_t, staticFlags, 0x4C);
ASSERT_STRUCT_OFFSET(windowDef_t, dynamicFlags, 0x50);
ASSERT_STRUCT_OFFSET(windowDef_t, nextTime, 0x54);
ASSERT_STRUCT_OFFSET(windowDef_t, foreColor, 0x58);
ASSERT_STRUCT_OFFSET(windowDef_t, backColor, 0x68);
ASSERT_STRUCT_OFFSET(windowDef_t, borderColor, 0x78);
ASSERT_STRUCT_OFFSET(windowDef_t, outlineColor, 0x88);
ASSERT_STRUCT_OFFSET(windowDef_t, background, 0x98);
struct ItemKeyHandler
{
int key; //OFS: 0x0 SIZE: 0x4
const char* action; //OFS: 0x4 SIZE: 0x4
ItemKeyHandler* next; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ItemKeyHandler, 0xC);
ASSERT_STRUCT_OFFSET(ItemKeyHandler, key, 0x0);
ASSERT_STRUCT_OFFSET(ItemKeyHandler, action, 0x4);
ASSERT_STRUCT_OFFSET(ItemKeyHandler, next, 0x8);
union operandInternalDataUnion
{
int intVal; //OFS: 0x0 SIZE: 0x4
float floatVal; //OFS: 0x1 SIZE: 0x4
const char* string; //OFS: 0x2 SIZE: 0x4
};
struct Operand
{
expDataType dataType; //OFS: 0x0 SIZE: 0x4
operandInternalDataUnion internals; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(Operand, 0x8);
ASSERT_STRUCT_OFFSET(Operand, dataType, 0x0);
ASSERT_STRUCT_OFFSET(Operand, internals, 0x4);
union entryInternalData
{
expOperationEnum op; //OFS: 0x0 SIZE: 0x4
Operand operand; //OFS: 0x1 SIZE: 0x8
};
struct expressionEntry
{
int type; //OFS: 0x0 SIZE: 0x4
entryInternalData data; //OFS: 0x4 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(expressionEntry, 0xC);
ASSERT_STRUCT_OFFSET(expressionEntry, type, 0x0);
ASSERT_STRUCT_OFFSET(expressionEntry, data, 0x4);
struct statement_s
{
int numEntries; //OFS: 0x0 SIZE: 0x4
expressionEntry** entries; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(statement_s, 0x8);
ASSERT_STRUCT_OFFSET(statement_s, numEntries, 0x0);
ASSERT_STRUCT_OFFSET(statement_s, entries, 0x4);
struct columnInfo_s
{
int pos; //OFS: 0x0 SIZE: 0x4
int width; //OFS: 0x4 SIZE: 0x4
int maxChars; //OFS: 0x8 SIZE: 0x4
int alignment; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(columnInfo_s, 0x10);
ASSERT_STRUCT_OFFSET(columnInfo_s, pos, 0x0);
ASSERT_STRUCT_OFFSET(columnInfo_s, width, 0x4);
ASSERT_STRUCT_OFFSET(columnInfo_s, maxChars, 0x8);
ASSERT_STRUCT_OFFSET(columnInfo_s, alignment, 0xC);
struct listBoxDef_s
{
int mousePos; //OFS: 0x0 SIZE: 0x4
int startPos[1]; //OFS: 0x4 SIZE: 0x4
int endPos[1]; //OFS: 0x8 SIZE: 0x4
int drawPadding; //OFS: 0xC SIZE: 0x4
float elementWidth; //OFS: 0x10 SIZE: 0x4
float elementHeight; //OFS: 0x14 SIZE: 0x4
int elementStyle; //OFS: 0x18 SIZE: 0x4
int numColumns; //OFS: 0x1C SIZE: 0x4
columnInfo_s columnInfo[16]; //OFS: 0x20 SIZE: 0x100
const char* doubleClick; //OFS: 0x120 SIZE: 0x4
int notselectable; //OFS: 0x124 SIZE: 0x4
int noScrollBars; //OFS: 0x128 SIZE: 0x4
int usePaging; //OFS: 0x12C SIZE: 0x4
float selectBorder[4]; //OFS: 0x130 SIZE: 0x10
float disableColor[4]; //OFS: 0x140 SIZE: 0x10
float focusColor[4]; //OFS: 0x150 SIZE: 0x10
Material* selectIcon; //OFS: 0x160 SIZE: 0x4
Material* backgroundItemListbox; //OFS: 0x164 SIZE: 0x4
Material* highlightTexture; //OFS: 0x168 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(listBoxDef_s, 0x16C);
ASSERT_STRUCT_OFFSET(listBoxDef_s, mousePos, 0x0);
ASSERT_STRUCT_OFFSET(listBoxDef_s, startPos, 0x4);
ASSERT_STRUCT_OFFSET(listBoxDef_s, endPos, 0x8);
ASSERT_STRUCT_OFFSET(listBoxDef_s, drawPadding, 0xC);
ASSERT_STRUCT_OFFSET(listBoxDef_s, elementWidth, 0x10);
ASSERT_STRUCT_OFFSET(listBoxDef_s, elementHeight, 0x14);
ASSERT_STRUCT_OFFSET(listBoxDef_s, elementStyle, 0x18);
ASSERT_STRUCT_OFFSET(listBoxDef_s, numColumns, 0x1C);
ASSERT_STRUCT_OFFSET(listBoxDef_s, columnInfo, 0x20);
ASSERT_STRUCT_OFFSET(listBoxDef_s, doubleClick, 0x120);
ASSERT_STRUCT_OFFSET(listBoxDef_s, notselectable, 0x124);
ASSERT_STRUCT_OFFSET(listBoxDef_s, noScrollBars, 0x128);
ASSERT_STRUCT_OFFSET(listBoxDef_s, usePaging, 0x12C);
ASSERT_STRUCT_OFFSET(listBoxDef_s, selectBorder, 0x130);
ASSERT_STRUCT_OFFSET(listBoxDef_s, disableColor, 0x140);
ASSERT_STRUCT_OFFSET(listBoxDef_s, focusColor, 0x150);
ASSERT_STRUCT_OFFSET(listBoxDef_s, selectIcon, 0x160);
ASSERT_STRUCT_OFFSET(listBoxDef_s, backgroundItemListbox, 0x164);
ASSERT_STRUCT_OFFSET(listBoxDef_s, highlightTexture, 0x168);
struct editFieldDef_s
{
float minVal; //OFS: 0x0 SIZE: 0x4
float maxVal; //OFS: 0x4 SIZE: 0x4
float defVal; //OFS: 0x8 SIZE: 0x4
float range; //OFS: 0xC SIZE: 0x4
int maxChars; //OFS: 0x10 SIZE: 0x4
int maxCharsGotoNext; //OFS: 0x14 SIZE: 0x4
int maxPaintChars; //OFS: 0x18 SIZE: 0x4
int paintOffset; //OFS: 0x1C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(editFieldDef_s, 0x20);
ASSERT_STRUCT_OFFSET(editFieldDef_s, minVal, 0x0);
ASSERT_STRUCT_OFFSET(editFieldDef_s, maxVal, 0x4);
ASSERT_STRUCT_OFFSET(editFieldDef_s, defVal, 0x8);
ASSERT_STRUCT_OFFSET(editFieldDef_s, range, 0xC);
ASSERT_STRUCT_OFFSET(editFieldDef_s, maxChars, 0x10);
ASSERT_STRUCT_OFFSET(editFieldDef_s, maxCharsGotoNext, 0x14);
ASSERT_STRUCT_OFFSET(editFieldDef_s, maxPaintChars, 0x18);
ASSERT_STRUCT_OFFSET(editFieldDef_s, paintOffset, 0x1C);
struct multiDef_s
{
const char* dvarList[32]; //OFS: 0x0 SIZE: 0x80
const char* dvarStr[32]; //OFS: 0x80 SIZE: 0x80
float dvarValue[32]; //OFS: 0x100 SIZE: 0x80
int count; //OFS: 0x180 SIZE: 0x4
int strDef; //OFS: 0x184 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(multiDef_s, 0x188);
ASSERT_STRUCT_OFFSET(multiDef_s, dvarList, 0x0);
ASSERT_STRUCT_OFFSET(multiDef_s, dvarStr, 0x80);
ASSERT_STRUCT_OFFSET(multiDef_s, dvarValue, 0x100);
ASSERT_STRUCT_OFFSET(multiDef_s, count, 0x180);
ASSERT_STRUCT_OFFSET(multiDef_s, strDef, 0x184);
union itemDefData_t
{
listBoxDef_s* listBox; //OFS: 0x0 SIZE: 0x4
editFieldDef_s* editField; //OFS: 0x1 SIZE: 0x4
multiDef_s* multi; //OFS: 0x2 SIZE: 0x4
const char* enumDvarName; //OFS: 0x3 SIZE: 0x4
void* data; //OFS: 0x4 SIZE: 0x4
};
struct itemDef_s
{
windowDef_t window; //OFS: 0x0 SIZE: 0x9C
rectDef_s textRect[1]; //OFS: 0x9C SIZE: 0x18
int type; //OFS: 0xB4 SIZE: 0x4
int dataType; //OFS: 0xB8 SIZE: 0x4
int alignment; //OFS: 0xBC SIZE: 0x4
int fontEnum; //OFS: 0xC0 SIZE: 0x4
int textAlignMode; //OFS: 0xC4 SIZE: 0x4
float textalignx; //OFS: 0xC8 SIZE: 0x4
float textaligny; //OFS: 0xCC SIZE: 0x4
float textscale; //OFS: 0xD0 SIZE: 0x4
int textStyle; //OFS: 0xD4 SIZE: 0x4
int gameMsgWindowIndex; //OFS: 0xD8 SIZE: 0x4
int gameMsgWindowMode; //OFS: 0xDC SIZE: 0x4
const char* text; //OFS: 0xE0 SIZE: 0x4
int itemFlags; //OFS: 0xE4 SIZE: 0x4
menuDef_t* parent; //OFS: 0xE8 SIZE: 0x4
const char* mouseEnterText; //OFS: 0xEC SIZE: 0x4
const char* mouseExitText; //OFS: 0xF0 SIZE: 0x4
const char* mouseEnter; //OFS: 0xF4 SIZE: 0x4
const char* mouseExit; //OFS: 0xF8 SIZE: 0x4
const char* action; //OFS: 0xFC SIZE: 0x4
const char* onAccept; //OFS: 0x100 SIZE: 0x4
const char* onFocus; //OFS: 0x104 SIZE: 0x4
const char* leaveFocus; //OFS: 0x108 SIZE: 0x4
const char* dvar; //OFS: 0x10C SIZE: 0x4
const char* dvarTest; //OFS: 0x110 SIZE: 0x4
const char* onListboxSelectionChange; //OFS: 0x114 SIZE: 0x4
ItemKeyHandler* onKey; //OFS: 0x118 SIZE: 0x4
const char* enableDvar; //OFS: 0x11C SIZE: 0x4
int dvarFlags; //OFS: 0x120 SIZE: 0x4
void* focusSound; //OFS: 0x124 SIZE: 0x4
float special; //OFS: 0x128 SIZE: 0x4
int cursorPos[1]; //OFS: 0x12C SIZE: 0x4
itemDefData_t typeData; //OFS: 0x130 SIZE: 0x4
int imageTrack; //OFS: 0x134 SIZE: 0x4
statement_s visibleExp; //OFS: 0x138 SIZE: 0x8
statement_s textExp; //OFS: 0x140 SIZE: 0x8
statement_s materialExp; //OFS: 0x148 SIZE: 0x8
statement_s rectXExp; //OFS: 0x150 SIZE: 0x8
statement_s rectYExp; //OFS: 0x158 SIZE: 0x8
statement_s rectWExp; //OFS: 0x160 SIZE: 0x8
statement_s rectHExp; //OFS: 0x168 SIZE: 0x8
statement_s forecolorAExp; //OFS: 0x170 SIZE: 0x8
};
ASSERT_STRUCT_SIZE(itemDef_s, 0x178);
ASSERT_STRUCT_OFFSET(itemDef_s, window, 0x0);
ASSERT_STRUCT_OFFSET(itemDef_s, textRect, 0x9C);
ASSERT_STRUCT_OFFSET(itemDef_s, type, 0xB4);
ASSERT_STRUCT_OFFSET(itemDef_s, dataType, 0xB8);
ASSERT_STRUCT_OFFSET(itemDef_s, alignment, 0xBC);
ASSERT_STRUCT_OFFSET(itemDef_s, fontEnum, 0xC0);
ASSERT_STRUCT_OFFSET(itemDef_s, textAlignMode, 0xC4);
ASSERT_STRUCT_OFFSET(itemDef_s, textalignx, 0xC8);
ASSERT_STRUCT_OFFSET(itemDef_s, textaligny, 0xCC);
ASSERT_STRUCT_OFFSET(itemDef_s, textscale, 0xD0);
ASSERT_STRUCT_OFFSET(itemDef_s, textStyle, 0xD4);
ASSERT_STRUCT_OFFSET(itemDef_s, gameMsgWindowIndex, 0xD8);
ASSERT_STRUCT_OFFSET(itemDef_s, gameMsgWindowMode, 0xDC);
ASSERT_STRUCT_OFFSET(itemDef_s, text, 0xE0);
ASSERT_STRUCT_OFFSET(itemDef_s, itemFlags, 0xE4);
ASSERT_STRUCT_OFFSET(itemDef_s, parent, 0xE8);
ASSERT_STRUCT_OFFSET(itemDef_s, mouseEnterText, 0xEC);
ASSERT_STRUCT_OFFSET(itemDef_s, mouseExitText, 0xF0);
ASSERT_STRUCT_OFFSET(itemDef_s, mouseEnter, 0xF4);
ASSERT_STRUCT_OFFSET(itemDef_s, mouseExit, 0xF8);
ASSERT_STRUCT_OFFSET(itemDef_s, action, 0xFC);
ASSERT_STRUCT_OFFSET(itemDef_s, onAccept, 0x100);
ASSERT_STRUCT_OFFSET(itemDef_s, onFocus, 0x104);
ASSERT_STRUCT_OFFSET(itemDef_s, leaveFocus, 0x108);
ASSERT_STRUCT_OFFSET(itemDef_s, dvar, 0x10C);
ASSERT_STRUCT_OFFSET(itemDef_s, dvarTest, 0x110);
ASSERT_STRUCT_OFFSET(itemDef_s, onListboxSelectionChange, 0x114);
ASSERT_STRUCT_OFFSET(itemDef_s, onKey, 0x118);
ASSERT_STRUCT_OFFSET(itemDef_s, enableDvar, 0x11C);
ASSERT_STRUCT_OFFSET(itemDef_s, dvarFlags, 0x120);
ASSERT_STRUCT_OFFSET(itemDef_s, focusSound, 0x124);
ASSERT_STRUCT_OFFSET(itemDef_s, special, 0x128);
ASSERT_STRUCT_OFFSET(itemDef_s, cursorPos, 0x12C);
ASSERT_STRUCT_OFFSET(itemDef_s, typeData, 0x130);
ASSERT_STRUCT_OFFSET(itemDef_s, imageTrack, 0x134);
ASSERT_STRUCT_OFFSET(itemDef_s, visibleExp, 0x138);
ASSERT_STRUCT_OFFSET(itemDef_s, textExp, 0x140);
ASSERT_STRUCT_OFFSET(itemDef_s, materialExp, 0x148);
ASSERT_STRUCT_OFFSET(itemDef_s, rectXExp, 0x150);
ASSERT_STRUCT_OFFSET(itemDef_s, rectYExp, 0x158);
ASSERT_STRUCT_OFFSET(itemDef_s, rectWExp, 0x160);
ASSERT_STRUCT_OFFSET(itemDef_s, rectHExp, 0x168);
ASSERT_STRUCT_OFFSET(itemDef_s, forecolorAExp, 0x170);
struct menuDef_t
{
windowDef_t window; //OFS: 0x0 SIZE: 0x9C
const char* font; //OFS: 0x9C SIZE: 0x4
int fullScreen; //OFS: 0xA0 SIZE: 0x4
int itemCount; //OFS: 0xA4 SIZE: 0x4
int fontIndex; //OFS: 0xA8 SIZE: 0x4
int cursorItem[1]; //OFS: 0xAC SIZE: 0x4
int fadeCycle; //OFS: 0xB0 SIZE: 0x4
float fadeClamp; //OFS: 0xB4 SIZE: 0x4
float fadeAmount; //OFS: 0xB8 SIZE: 0x4
float fadeInAmount; //OFS: 0xBC SIZE: 0x4
float blurRadius; //OFS: 0xC0 SIZE: 0x4
const char* onOpen; //OFS: 0xC4 SIZE: 0x4
const char* onFocus; //OFS: 0xC8 SIZE: 0x4
const char* onClose; //OFS: 0xCC SIZE: 0x4
const char* onESC; //OFS: 0xD0 SIZE: 0x4
ItemKeyHandler* onKey; //OFS: 0xD4 SIZE: 0x4
statement_s visibleExp; //OFS: 0xD8 SIZE: 0x8
const char* allowedBinding; //OFS: 0xE0 SIZE: 0x4
const char* soundName; //OFS: 0xE4 SIZE: 0x4
int imageTrack; //OFS: 0xE8 SIZE: 0x4
float focusColor[4]; //OFS: 0xEC SIZE: 0x10
float disableColor[4]; //OFS: 0xFC SIZE: 0x10
statement_s rectXExp; //OFS: 0x10C SIZE: 0x8
statement_s rectYExp; //OFS: 0x114 SIZE: 0x8
itemDef_s** items; //OFS: 0x11C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(menuDef_t, 0x120);
ASSERT_STRUCT_OFFSET(menuDef_t, window, 0x0);
ASSERT_STRUCT_OFFSET(menuDef_t, font, 0x9C);
ASSERT_STRUCT_OFFSET(menuDef_t, fullScreen, 0xA0);
ASSERT_STRUCT_OFFSET(menuDef_t, itemCount, 0xA4);
ASSERT_STRUCT_OFFSET(menuDef_t, fontIndex, 0xA8);
ASSERT_STRUCT_OFFSET(menuDef_t, cursorItem, 0xAC);
ASSERT_STRUCT_OFFSET(menuDef_t, fadeCycle, 0xB0);
ASSERT_STRUCT_OFFSET(menuDef_t, fadeClamp, 0xB4);
ASSERT_STRUCT_OFFSET(menuDef_t, fadeAmount, 0xB8);
ASSERT_STRUCT_OFFSET(menuDef_t, fadeInAmount, 0xBC);
ASSERT_STRUCT_OFFSET(menuDef_t, blurRadius, 0xC0);
ASSERT_STRUCT_OFFSET(menuDef_t, onOpen, 0xC4);
ASSERT_STRUCT_OFFSET(menuDef_t, onFocus, 0xC8);
ASSERT_STRUCT_OFFSET(menuDef_t, onClose, 0xCC);
ASSERT_STRUCT_OFFSET(menuDef_t, onESC, 0xD0);
ASSERT_STRUCT_OFFSET(menuDef_t, onKey, 0xD4);
ASSERT_STRUCT_OFFSET(menuDef_t, visibleExp, 0xD8);
ASSERT_STRUCT_OFFSET(menuDef_t, allowedBinding, 0xE0);
ASSERT_STRUCT_OFFSET(menuDef_t, soundName, 0xE4);
ASSERT_STRUCT_OFFSET(menuDef_t, imageTrack, 0xE8);
ASSERT_STRUCT_OFFSET(menuDef_t, focusColor, 0xEC);
ASSERT_STRUCT_OFFSET(menuDef_t, disableColor, 0xFC);
ASSERT_STRUCT_OFFSET(menuDef_t, rectXExp, 0x10C);
ASSERT_STRUCT_OFFSET(menuDef_t, rectYExp, 0x114);
ASSERT_STRUCT_OFFSET(menuDef_t, items, 0x11C);
struct MenuList
{
const char* name; //OFS: 0x0 SIZE: 0x4
int menuCount; //OFS: 0x4 SIZE: 0x4
menuDef_t** menus; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(MenuList, 0xC);
ASSERT_STRUCT_OFFSET(MenuList, name, 0x0);
ASSERT_STRUCT_OFFSET(MenuList, menuCount, 0x4);
ASSERT_STRUCT_OFFSET(MenuList, menus, 0x8);
struct LocalizeEntry
{
char* value; //OFS: 0x0 SIZE: 0x4
char* name; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(LocalizeEntry, 0x8);
ASSERT_STRUCT_OFFSET(LocalizeEntry, value, 0x0);
ASSERT_STRUCT_OFFSET(LocalizeEntry, name, 0x4);
struct flameTable
{
float flameVar_streamChunkGravityStart; //OFS: 0x0 SIZE: 0x4
float flameVar_streamChunkGravityEnd; //OFS: 0x4 SIZE: 0x4
float flameVar_streamChunkMaxSize; //OFS: 0x8 SIZE: 0x4
float flameVar_streamChunkStartSize; //OFS: 0xC SIZE: 0x4
float flameVar_streamChunkEndSize; //OFS: 0x10 SIZE: 0x4
float flameVar_streamChunkStartSizeRand; //OFS: 0x14 SIZE: 0x4
float flameVar_streamChunkEndSizeRand; //OFS: 0x18 SIZE: 0x4
float flameVar_streamChunkDistScalar; //OFS: 0x1C SIZE: 0x4
float flameVar_streamChunkDistSwayScale; //OFS: 0x20 SIZE: 0x4
float flameVar_streamChunkDistSwayVelMax; //OFS: 0x24 SIZE: 0x4
float flameVar_streamChunkSpeed; //OFS: 0x28 SIZE: 0x4
float flameVar_streamChunkDecel; //OFS: 0x2C SIZE: 0x4
float flameVar_streamChunkVelocityAddScale; //OFS: 0x30 SIZE: 0x4
float flameVar_streamChunkDuration; //OFS: 0x34 SIZE: 0x4
float flameVar_streamChunkDurationScaleMaxVel; //OFS: 0x38 SIZE: 0x4
float flameVar_streamChunkDurationVelScalar; //OFS: 0x3C SIZE: 0x4
float flameVar_streamChunkSizeSpeedScale; //OFS: 0x40 SIZE: 0x4
float flameVar_streamChunkSizeAgeScale; //OFS: 0x44 SIZE: 0x4
float flameVar_streamChunkSpawnFireIntervalStart; //OFS: 0x48 SIZE: 0x4
float flameVar_streamChunkSpawnFireIntervalEnd; //OFS: 0x4C SIZE: 0x4
float flameVar_streamChunkSpawnFireMinLifeFrac; //OFS: 0x50 SIZE: 0x4
float flameVar_streamChunkSpawnFireMaxLifeFrac; //OFS: 0x54 SIZE: 0x4
float flameVar_streamChunkFireMinLifeFrac; //OFS: 0x58 SIZE: 0x4
float flameVar_streamChunkFireMinLifeFracStart; //OFS: 0x5C SIZE: 0x4
float flameVar_streamChunkFireMinLifeFracEnd; //OFS: 0x60 SIZE: 0x4
float flameVar_streamChunkDripsMinLifeFrac; //OFS: 0x64 SIZE: 0x4
float flameVar_streamChunkDripsMinLifeFracStart; //OFS: 0x68 SIZE: 0x4
float flameVar_streamChunkDripsMinLifeFracEnd; //OFS: 0x6C SIZE: 0x4
float flameVar_streamChunkRotationRange; //OFS: 0x70 SIZE: 0x4
float flameVar_streamSizeRandSinWave; //OFS: 0x74 SIZE: 0x4
float flameVar_streamSizeRandCosWave; //OFS: 0x78 SIZE: 0x4
float flameVar_streamDripsChunkInterval; //OFS: 0x7C SIZE: 0x4
float flameVar_streamDripsChunkMinFrac; //OFS: 0x80 SIZE: 0x4
float flameVar_streamDripsChunkRandFrac; //OFS: 0x84 SIZE: 0x4
float flameVar_streamSmokeChunkInterval; //OFS: 0x88 SIZE: 0x4
float flameVar_streamSmokeChunkMinFrac; //OFS: 0x8C SIZE: 0x4
float flameVar_streamSmokeChunkRandFrac; //OFS: 0x90 SIZE: 0x4
float flameVar_streamChunkCullDistSizeFrac; //OFS: 0x94 SIZE: 0x4
float flameVar_streamChunkCullMinLife; //OFS: 0x98 SIZE: 0x4
float flameVar_streamChunkCullMaxLife; //OFS: 0x9C SIZE: 0x4
float flameVar_streamFuelSizeStart; //OFS: 0xA0 SIZE: 0x4
float flameVar_streamFuelSizeEnd; //OFS: 0xA4 SIZE: 0x4
float flameVar_streamFuelLength; //OFS: 0xA8 SIZE: 0x4
float flameVar_streamFuelNumSegments; //OFS: 0xAC SIZE: 0x4
float flameVar_streamFuelAnimLoopTime; //OFS: 0xB0 SIZE: 0x4
float flameVar_streamFlameSizeStart; //OFS: 0xB4 SIZE: 0x4
float flameVar_streamFlameSizeEnd; //OFS: 0xB8 SIZE: 0x4
float flameVar_streamFlameLength; //OFS: 0xBC SIZE: 0x4
float flameVar_streamFlameNumSegments; //OFS: 0xC0 SIZE: 0x4
float flameVar_streamFlameAnimLoopTime; //OFS: 0xC4 SIZE: 0x4
float flameVar_streamPrimaryLightRadius; //OFS: 0xC8 SIZE: 0x4
float flameVar_streamPrimaryLightRadiusFlutter; //OFS: 0xCC SIZE: 0x4
float flameVar_streamPrimaryLightR; //OFS: 0xD0 SIZE: 0x4
float flameVar_streamPrimaryLightG; //OFS: 0xD4 SIZE: 0x4
float flameVar_streamPrimaryLightB; //OFS: 0xD8 SIZE: 0x4
float flameVar_streamPrimaryLightFlutterR; //OFS: 0xDC SIZE: 0x4
float flameVar_streamPrimaryLightFlutterG; //OFS: 0xE0 SIZE: 0x4
float flameVar_streamPrimaryLightFlutterB; //OFS: 0xE4 SIZE: 0x4
float flameVar_fireLife; //OFS: 0xE8 SIZE: 0x4
float flameVar_fireLifeRand; //OFS: 0xEC SIZE: 0x4
float flameVar_fireSpeedScale; //OFS: 0xF0 SIZE: 0x4
float flameVar_fireSpeedScaleRand; //OFS: 0xF4 SIZE: 0x4
float flameVar_fireVelocityAddZ; //OFS: 0xF8 SIZE: 0x4
float flameVar_fireVelocityAddZRand; //OFS: 0xFC SIZE: 0x4
float flameVar_fireVelocityAddSideways; //OFS: 0x100 SIZE: 0x4
float flameVar_fireGravity; //OFS: 0x104 SIZE: 0x4
float flameVar_fireGravityEnd; //OFS: 0x108 SIZE: 0x4
float flameVar_fireMaxRotVel; //OFS: 0x10C SIZE: 0x4
float flameVar_fireFriction; //OFS: 0x110 SIZE: 0x4
float flameVar_fireEndSizeAdd; //OFS: 0x114 SIZE: 0x4
float flameVar_fireStartSizeScale; //OFS: 0x118 SIZE: 0x4
float flameVar_fireEndSizeScale; //OFS: 0x11C SIZE: 0x4
float flameVar_dripsLife; //OFS: 0x120 SIZE: 0x4
float flameVar_dripsLifeRand; //OFS: 0x124 SIZE: 0x4
float flameVar_dripsSpeedScale; //OFS: 0x128 SIZE: 0x4
float flameVar_dripsSpeedScaleRand; //OFS: 0x12C SIZE: 0x4
float flameVar_dripsVelocityAddZ; //OFS: 0x130 SIZE: 0x4
float flameVar_dripsVelocityAddZRand; //OFS: 0x134 SIZE: 0x4
float flameVar_dripsVelocityAddSideways; //OFS: 0x138 SIZE: 0x4
float flameVar_dripsGravity; //OFS: 0x13C SIZE: 0x4
float flameVar_dripsGravityEnd; //OFS: 0x140 SIZE: 0x4
float flameVar_dripsMaxRotVel; //OFS: 0x144 SIZE: 0x4
float flameVar_dripsFriction; //OFS: 0x148 SIZE: 0x4
float flameVar_dripsEndSizeAdd; //OFS: 0x14C SIZE: 0x4
float flameVar_dripsStartSizeScale; //OFS: 0x150 SIZE: 0x4
float flameVar_dripsEndSizeScale; //OFS: 0x154 SIZE: 0x4
float flameVar_smokeLife; //OFS: 0x158 SIZE: 0x4
float flameVar_smokeLifeRand; //OFS: 0x15C SIZE: 0x4
float flameVar_smokeSpeedScale; //OFS: 0x160 SIZE: 0x4
float flameVar_smokeVelocityAddZ; //OFS: 0x164 SIZE: 0x4
float flameVar_smokeGravity; //OFS: 0x168 SIZE: 0x4
float flameVar_smokeGravityEnd; //OFS: 0x16C SIZE: 0x4
float flameVar_smokeMaxRotation; //OFS: 0x170 SIZE: 0x4
float flameVar_smokeMaxRotVel; //OFS: 0x174 SIZE: 0x4
float flameVar_smokeFriction; //OFS: 0x178 SIZE: 0x4
float flameVar_smokeEndSizeAdd; //OFS: 0x17C SIZE: 0x4
float flameVar_smokeStartSizeAdd; //OFS: 0x180 SIZE: 0x4
float flameVar_smokeOriginSizeOfsZScale; //OFS: 0x184 SIZE: 0x4
float flameVar_smokeOriginOfsZ; //OFS: 0x188 SIZE: 0x4
float flameVar_smokeFadein; //OFS: 0x18C SIZE: 0x4
float flameVar_smokeFadeout; //OFS: 0x190 SIZE: 0x4
float flameVar_smokeMaxAlpha; //OFS: 0x194 SIZE: 0x4
float flameVar_smokeBrightness; //OFS: 0x198 SIZE: 0x4
float flameVar_smokeOriginOffset; //OFS: 0x19C SIZE: 0x4
float flameVar_collisionSpeedScale; //OFS: 0x1A0 SIZE: 0x4
float flameVar_collisionVolumeScale; //OFS: 0x1A4 SIZE: 0x4
const char* name; //OFS: 0x1A8 SIZE: 0x4
Material* fire; //OFS: 0x1AC SIZE: 0x4
Material* smoke; //OFS: 0x1B0 SIZE: 0x4
Material* heat; //OFS: 0x1B4 SIZE: 0x4
Material* drips; //OFS: 0x1B8 SIZE: 0x4
Material* streamFuel; //OFS: 0x1BC SIZE: 0x4
Material* streamFuel2; //OFS: 0x1C0 SIZE: 0x4
Material* streamFlame; //OFS: 0x1C4 SIZE: 0x4
Material* streamFlame2; //OFS: 0x1C8 SIZE: 0x4
snd_alias_list_t* flameOffLoopSound; //OFS: 0x1CC SIZE: 0x4
snd_alias_list_t* flameIgniteSound; //OFS: 0x1D0 SIZE: 0x4
snd_alias_list_t* flameOnLoopSound; //OFS: 0x1D4 SIZE: 0x4
snd_alias_list_t* flameCooldownSound; //OFS: 0x1D8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(flameTable, 0x1DC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkGravityStart, 0x0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkGravityEnd, 0x4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkMaxSize, 0x8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkStartSize, 0xC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkEndSize, 0x10);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkStartSizeRand, 0x14);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkEndSizeRand, 0x18);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDistScalar, 0x1C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDistSwayScale, 0x20);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDistSwayVelMax, 0x24);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSpeed, 0x28);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDecel, 0x2C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkVelocityAddScale, 0x30);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDuration, 0x34);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDurationScaleMaxVel, 0x38);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDurationVelScalar, 0x3C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSizeSpeedScale, 0x40);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSizeAgeScale, 0x44);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSpawnFireIntervalStart, 0x48);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSpawnFireIntervalEnd, 0x4C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSpawnFireMinLifeFrac, 0x50);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkSpawnFireMaxLifeFrac, 0x54);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkFireMinLifeFrac, 0x58);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkFireMinLifeFracStart, 0x5C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkFireMinLifeFracEnd, 0x60);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDripsMinLifeFrac, 0x64);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDripsMinLifeFracStart, 0x68);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkDripsMinLifeFracEnd, 0x6C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkRotationRange, 0x70);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamSizeRandSinWave, 0x74);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamSizeRandCosWave, 0x78);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamDripsChunkInterval, 0x7C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamDripsChunkMinFrac, 0x80);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamDripsChunkRandFrac, 0x84);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamSmokeChunkInterval, 0x88);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamSmokeChunkMinFrac, 0x8C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamSmokeChunkRandFrac, 0x90);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkCullDistSizeFrac, 0x94);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkCullMinLife, 0x98);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamChunkCullMaxLife, 0x9C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFuelSizeStart, 0xA0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFuelSizeEnd, 0xA4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFuelLength, 0xA8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFuelNumSegments, 0xAC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFuelAnimLoopTime, 0xB0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFlameSizeStart, 0xB4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFlameSizeEnd, 0xB8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFlameLength, 0xBC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFlameNumSegments, 0xC0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamFlameAnimLoopTime, 0xC4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightRadius, 0xC8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightRadiusFlutter, 0xCC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightR, 0xD0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightG, 0xD4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightB, 0xD8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightFlutterR, 0xDC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightFlutterG, 0xE0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_streamPrimaryLightFlutterB, 0xE4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireLife, 0xE8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireLifeRand, 0xEC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireSpeedScale, 0xF0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireSpeedScaleRand, 0xF4);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireVelocityAddZ, 0xF8);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireVelocityAddZRand, 0xFC);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireVelocityAddSideways, 0x100);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireGravity, 0x104);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireGravityEnd, 0x108);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireMaxRotVel, 0x10C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireFriction, 0x110);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireEndSizeAdd, 0x114);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireStartSizeScale, 0x118);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_fireEndSizeScale, 0x11C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsLife, 0x120);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsLifeRand, 0x124);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsSpeedScale, 0x128);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsSpeedScaleRand, 0x12C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsVelocityAddZ, 0x130);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsVelocityAddZRand, 0x134);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsVelocityAddSideways, 0x138);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsGravity, 0x13C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsGravityEnd, 0x140);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsMaxRotVel, 0x144);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsFriction, 0x148);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsEndSizeAdd, 0x14C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsStartSizeScale, 0x150);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_dripsEndSizeScale, 0x154);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeLife, 0x158);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeLifeRand, 0x15C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeSpeedScale, 0x160);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeVelocityAddZ, 0x164);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeGravity, 0x168);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeGravityEnd, 0x16C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeMaxRotation, 0x170);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeMaxRotVel, 0x174);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeFriction, 0x178);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeEndSizeAdd, 0x17C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeStartSizeAdd, 0x180);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeOriginSizeOfsZScale, 0x184);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeOriginOfsZ, 0x188);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeFadein, 0x18C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeFadeout, 0x190);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeMaxAlpha, 0x194);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeBrightness, 0x198);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_smokeOriginOffset, 0x19C);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_collisionSpeedScale, 0x1A0);
ASSERT_STRUCT_OFFSET(flameTable, flameVar_collisionVolumeScale, 0x1A4);
ASSERT_STRUCT_OFFSET(flameTable, name, 0x1A8);
ASSERT_STRUCT_OFFSET(flameTable, fire, 0x1AC);
ASSERT_STRUCT_OFFSET(flameTable, smoke, 0x1B0);
ASSERT_STRUCT_OFFSET(flameTable, heat, 0x1B4);
ASSERT_STRUCT_OFFSET(flameTable, drips, 0x1B8);
ASSERT_STRUCT_OFFSET(flameTable, streamFuel, 0x1BC);
ASSERT_STRUCT_OFFSET(flameTable, streamFuel2, 0x1C0);
ASSERT_STRUCT_OFFSET(flameTable, streamFlame, 0x1C4);
ASSERT_STRUCT_OFFSET(flameTable, streamFlame2, 0x1C8);
ASSERT_STRUCT_OFFSET(flameTable, flameOffLoopSound, 0x1CC);
ASSERT_STRUCT_OFFSET(flameTable, flameIgniteSound, 0x1D0);
ASSERT_STRUCT_OFFSET(flameTable, flameOnLoopSound, 0x1D4);
ASSERT_STRUCT_OFFSET(flameTable, flameCooldownSound, 0x1D8);
struct WeaponDef
{
const char* szInternalName; //OFS: 0x0 SIZE: 0x4
const char* szDisplayName; //OFS: 0x4 SIZE: 0x4
const char* szOverlayName; //OFS: 0x8 SIZE: 0x4
XModel* gunXModel[16]; //OFS: 0xC SIZE: 0x40
XModel* handXModel; //OFS: 0x4C SIZE: 0x4
const char* someAnim; //OFS: 0x50 SIZE: 0x4
const char* sidleAnim; //OFS: 0x54 SIZE: 0x4
const char* semptyIdleAnim; //OFS: 0x58 SIZE: 0x4
const char* sfireAnim; //OFS: 0x5C SIZE: 0x4
const char* sholdFireAnim; //OFS: 0x60 SIZE: 0x4
const char* slastShotAnim; //OFS: 0x64 SIZE: 0x4
const char* srechamberAnim; //OFS: 0x68 SIZE: 0x4
const char* smeleeAnim; //OFS: 0x6C SIZE: 0x4
const char* smeleeChargeAnim; //OFS: 0x70 SIZE: 0x4
const char* sreloadAnim; //OFS: 0x74 SIZE: 0x4
const char* sreloadEmptyAnim; //OFS: 0x78 SIZE: 0x4
const char* sreloadStartAnim; //OFS: 0x7C SIZE: 0x4
const char* sreloadEndAnim; //OFS: 0x80 SIZE: 0x4
const char* sraiseAnim; //OFS: 0x84 SIZE: 0x4
const char* sfirstRaiseAnim; //OFS: 0x88 SIZE: 0x4
const char* sdropAnim; //OFS: 0x8C SIZE: 0x4
const char* saltRaiseAnim; //OFS: 0x90 SIZE: 0x4
const char* saltDropAnim; //OFS: 0x94 SIZE: 0x4
const char* squickRaiseAnim; //OFS: 0x98 SIZE: 0x4
const char* squickDropAnim; //OFS: 0x9C SIZE: 0x4
const char* semptyRaiseAnim; //OFS: 0xA0 SIZE: 0x4
const char* semptyDropAnim; //OFS: 0xA4 SIZE: 0x4
const char* ssprintInAnim; //OFS: 0xA8 SIZE: 0x4
const char* ssprintLoopAnim; //OFS: 0xAC SIZE: 0x4
const char* ssprintOutAnim; //OFS: 0xB0 SIZE: 0x4
const char* sdeployAnim; //OFS: 0xB4 SIZE: 0x4
const char* sbreakdownAnim; //OFS: 0xB8 SIZE: 0x4
const char* sdetonateAnim; //OFS: 0xBC SIZE: 0x4
const char* snightVisionWearAnim; //OFS: 0xC0 SIZE: 0x4
const char* snightVisionRemoveAnim; //OFS: 0xC4 SIZE: 0x4
const char* sadsFireAnim; //OFS: 0xC8 SIZE: 0x4
const char* sadsLastShotAnim; //OFS: 0xCC SIZE: 0x4
const char* sadsRechamberAnim; //OFS: 0xD0 SIZE: 0x4
const char* sadsUpAnim; //OFS: 0xD4 SIZE: 0x4
const char* sadsDownAnim; //OFS: 0xD8 SIZE: 0x4
const char* szModeName; //OFS: 0xDC SIZE: 0x4
unsigned __int16 hideTags[8]; //OFS: 0xE0 SIZE: 0x10
unsigned __int16 notetrackSoundMapKeys[20]; //OFS: 0xF0 SIZE: 0x28
unsigned __int16 notetrackSoundMapValues[20]; //OFS: 0x118 SIZE: 0x28
int playerAnimType; //OFS: 0x140 SIZE: 0x4
weapType_t weapType; //OFS: 0x144 SIZE: 0x4
weapClass_t weapClass; //OFS: 0x148 SIZE: 0x4
PenetrateType penetrateType; //OFS: 0x14C SIZE: 0x4
ImpactType impactType; //OFS: 0x150 SIZE: 0x4
weapInventoryType_t inventoryType; //OFS: 0x154 SIZE: 0x4
weapFireType_t fireType; //OFS: 0x158 SIZE: 0x4
int clipType; //OFS: 0x15C SIZE: 0x4
int overheatWeapon; //OFS: 0x160 SIZE: 0x4
float overheatRate; //OFS: 0x164 SIZE: 0x4
float cooldownRate; //OFS: 0x168 SIZE: 0x4
float overheatEndVal; //OFS: 0x16C SIZE: 0x4
int coolWhileFiring; //OFS: 0x170 SIZE: 0x4
OffhandClass offhandClass; //OFS: 0x174 SIZE: 0x4
weapStance_t stance; //OFS: 0x178 SIZE: 0x4
FxEffectDef* viewFlashEffect; //OFS: 0x17C SIZE: 0x4
FxEffectDef* worldFlashEffect; //OFS: 0x180 SIZE: 0x4
snd_alias_list_t* pickupSound; //OFS: 0x184 SIZE: 0x4
snd_alias_list_t* pickupSoundPlayer; //OFS: 0x188 SIZE: 0x4
snd_alias_list_t* ammoPickupSound; //OFS: 0x18C SIZE: 0x4
snd_alias_list_t* ammoPickupSoundPlayer; //OFS: 0x190 SIZE: 0x4
snd_alias_list_t* projectileSound; //OFS: 0x194 SIZE: 0x4
snd_alias_list_t* pullbackSound; //OFS: 0x198 SIZE: 0x4
snd_alias_list_t* pullbackSoundPlayer; //OFS: 0x19C SIZE: 0x4
snd_alias_list_t* fireSound; //OFS: 0x1A0 SIZE: 0x4
snd_alias_list_t* fireSoundPlayer; //OFS: 0x1A4 SIZE: 0x4
snd_alias_list_t* fireLoopSound; //OFS: 0x1A8 SIZE: 0x4
snd_alias_list_t* fireLoopSoundPlayer; //OFS: 0x1AC SIZE: 0x4
snd_alias_list_t* fireStopSound; //OFS: 0x1B0 SIZE: 0x4
snd_alias_list_t* fireStopSoundPlayer; //OFS: 0x1B4 SIZE: 0x4
snd_alias_list_t* fireLastSound; //OFS: 0x1B8 SIZE: 0x4
snd_alias_list_t* fireLastSoundPlayer; //OFS: 0x1BC SIZE: 0x4
snd_alias_list_t* emptyFireSound; //OFS: 0x1C0 SIZE: 0x4
snd_alias_list_t* emptyFireSoundPlayer; //OFS: 0x1C4 SIZE: 0x4
snd_alias_list_t* crackSound; //OFS: 0x1C8 SIZE: 0x4
snd_alias_list_t* whizbySound; //OFS: 0x1CC SIZE: 0x4
snd_alias_list_t* meleeSwipeSound; //OFS: 0x1D0 SIZE: 0x4
snd_alias_list_t* meleeSwipeSoundPlayer; //OFS: 0x1D4 SIZE: 0x4
snd_alias_list_t* meleeHitSound; //OFS: 0x1D8 SIZE: 0x4
snd_alias_list_t* meleeMissSound; //OFS: 0x1DC SIZE: 0x4
snd_alias_list_t* rechamberSound; //OFS: 0x1E0 SIZE: 0x4
snd_alias_list_t* rechamberSoundPlayer; //OFS: 0x1E4 SIZE: 0x4
snd_alias_list_t* reloadSound; //OFS: 0x1E8 SIZE: 0x4
snd_alias_list_t* reloadSoundPlayer; //OFS: 0x1EC SIZE: 0x4
snd_alias_list_t* reloadEmptySound; //OFS: 0x1F0 SIZE: 0x4
snd_alias_list_t* reloadEmptySoundPlayer; //OFS: 0x1F4 SIZE: 0x4
snd_alias_list_t* reloadStartSound; //OFS: 0x1F8 SIZE: 0x4
snd_alias_list_t* reloadStartSoundPlayer; //OFS: 0x1FC SIZE: 0x4
snd_alias_list_t* reloadEndSound; //OFS: 0x200 SIZE: 0x4
snd_alias_list_t* reloadEndSoundPlayer; //OFS: 0x204 SIZE: 0x4
snd_alias_list_t* rotateLoopSound; //OFS: 0x208 SIZE: 0x4
snd_alias_list_t* rotateLoopSoundPlayer; //OFS: 0x20C SIZE: 0x4
snd_alias_list_t* deploySound; //OFS: 0x210 SIZE: 0x4
snd_alias_list_t* deploySoundPlayer; //OFS: 0x214 SIZE: 0x4
snd_alias_list_t* finishDeploySound; //OFS: 0x218 SIZE: 0x4
snd_alias_list_t* finishDeploySoundPlayer; //OFS: 0x21C SIZE: 0x4
snd_alias_list_t* breakdownSound; //OFS: 0x220 SIZE: 0x4
snd_alias_list_t* breakdownSoundPlayer; //OFS: 0x224 SIZE: 0x4
snd_alias_list_t* finishBreakdownSound; //OFS: 0x228 SIZE: 0x4
snd_alias_list_t* finishBreakdownSoundPlayer; //OFS: 0x22C SIZE: 0x4
snd_alias_list_t* detonateSound; //OFS: 0x230 SIZE: 0x4
snd_alias_list_t* detonateSoundPlayer; //OFS: 0x234 SIZE: 0x4
snd_alias_list_t* nightVisionWearSound; //OFS: 0x238 SIZE: 0x4
snd_alias_list_t* nightVisionWearSoundPlayer; //OFS: 0x23C SIZE: 0x4
snd_alias_list_t* nightVisionRemoveSound; //OFS: 0x240 SIZE: 0x4
snd_alias_list_t* nightVisionRemoveSoundPlayer; //OFS: 0x244 SIZE: 0x4
snd_alias_list_t* altSwitchSound; //OFS: 0x248 SIZE: 0x4
snd_alias_list_t* altSwitchSoundPlayer; //OFS: 0x24C SIZE: 0x4
snd_alias_list_t* raiseSound; //OFS: 0x250 SIZE: 0x4
snd_alias_list_t* raiseSoundPlayer; //OFS: 0x254 SIZE: 0x4
snd_alias_list_t* firstRaiseSound; //OFS: 0x258 SIZE: 0x4
snd_alias_list_t* firstRaiseSoundPlayer; //OFS: 0x25C SIZE: 0x4
snd_alias_list_t* putawaySound; //OFS: 0x260 SIZE: 0x4
snd_alias_list_t* putawaySoundPlayer; //OFS: 0x264 SIZE: 0x4
snd_alias_list_t* overheatSound; //OFS: 0x268 SIZE: 0x4
snd_alias_list_t* overheatSoundPlayer; //OFS: 0x26C SIZE: 0x4
snd_alias_list_t** bounceSound; //OFS: 0x270 SIZE: 0x4
WeaponDef* standMountedWeapdef; //OFS: 0x274 SIZE: 0x4
WeaponDef* crouchMountedWeapdef; //OFS: 0x278 SIZE: 0x4
WeaponDef* proneMountedWeapdef; //OFS: 0x27C SIZE: 0x4
int StandMountedIndex; //OFS: 0x280 SIZE: 0x4
int CrouchMountedIndex; //OFS: 0x284 SIZE: 0x4
int ProneMountedIndex; //OFS: 0x288 SIZE: 0x4
FxEffectDef* viewShellEjectEffect; //OFS: 0x28C SIZE: 0x4
FxEffectDef* worldShellEjectEffect; //OFS: 0x290 SIZE: 0x4
FxEffectDef* viewLastShotEjectEffect; //OFS: 0x294 SIZE: 0x4
FxEffectDef* worldLastShotEjectEffect; //OFS: 0x298 SIZE: 0x4
Material* reticleCenter; //OFS: 0x29C SIZE: 0x4
Material* reticleSide; //OFS: 0x2A0 SIZE: 0x4
int iReticleCenterSize; //OFS: 0x2A4 SIZE: 0x4
int iReticleSideSize; //OFS: 0x2A8 SIZE: 0x4
int iReticleMinOfs; //OFS: 0x2AC SIZE: 0x4
activeReticleType_t activeReticleType; //OFS: 0x2B0 SIZE: 0x4
float vStandMove[3]; //OFS: 0x2B4 SIZE: 0xC
float vStandRot[3]; //OFS: 0x2C0 SIZE: 0xC
float vDuckedOfs[3]; //OFS: 0x2CC SIZE: 0xC
float vDuckedMove[3]; //OFS: 0x2D8 SIZE: 0xC
float duckedSprintOfs[3]; //OFS: 0x2E4 SIZE: 0xC
float duckedSprintRot[3]; //OFS: 0x2F0 SIZE: 0xC
float duckedSprintBob[2]; //OFS: 0x2FC SIZE: 0x8
float duckedSprintScale; //OFS: 0x304 SIZE: 0x4
float sprintOfs[3]; //OFS: 0x308 SIZE: 0xC
float sprintRot[3]; //OFS: 0x314 SIZE: 0xC
float sprintBob[2]; //OFS: 0x320 SIZE: 0x8
float sprintScale; //OFS: 0x328 SIZE: 0x4
float vDuckedRot[3]; //OFS: 0x32C SIZE: 0xC
float vProneOfs[3]; //OFS: 0x338 SIZE: 0xC
float vProneMove[3]; //OFS: 0x344 SIZE: 0xC
float vProneRot[3]; //OFS: 0x350 SIZE: 0xC
float fPosMoveRate; //OFS: 0x35C SIZE: 0x4
float fPosProneMoveRate; //OFS: 0x360 SIZE: 0x4
float fStandMoveMinSpeed; //OFS: 0x364 SIZE: 0x4
float fDuckedMoveMinSpeed; //OFS: 0x368 SIZE: 0x4
float fProneMoveMinSpeed; //OFS: 0x36C SIZE: 0x4
float fPosRotRate; //OFS: 0x370 SIZE: 0x4
float fPosProneRotRate; //OFS: 0x374 SIZE: 0x4
float fStandRotMinSpeed; //OFS: 0x378 SIZE: 0x4
float fDuckedRotMinSpeed; //OFS: 0x37C SIZE: 0x4
float fProneRotMinSpeed; //OFS: 0x380 SIZE: 0x4
XModel* worldModel[16]; //OFS: 0x384 SIZE: 0x40
XModel* worldClipModel; //OFS: 0x3C4 SIZE: 0x4
XModel* rocketModel; //OFS: 0x3C8 SIZE: 0x4
XModel* knifeModel; //OFS: 0x3CC SIZE: 0x4
XModel* worldKnifeModel; //OFS: 0x3D0 SIZE: 0x4
XModel* mountedModel; //OFS: 0x3D4 SIZE: 0x4
Material* hudIcon; //OFS: 0x3D8 SIZE: 0x4
weaponIconRatioType_t hudIconRatio; //OFS: 0x3DC SIZE: 0x4
Material* ammoCounterIcon; //OFS: 0x3E0 SIZE: 0x4
weaponIconRatioType_t ammoCounterIconRatio; //OFS: 0x3E4 SIZE: 0x4
ammoCounterClipType_t ammoCounterClip; //OFS: 0x3E8 SIZE: 0x4
int iStartAmmo; //OFS: 0x3EC SIZE: 0x4
const char* szAmmoName; //OFS: 0x3F0 SIZE: 0x4
int iAmmoIndex; //OFS: 0x3F4 SIZE: 0x4
const char* szClipName; //OFS: 0x3F8 SIZE: 0x4
int iClipIndex; //OFS: 0x3FC SIZE: 0x4
int iHeatIndex; //OFS: 0x400 SIZE: 0x4
int iMaxAmmo; //OFS: 0x404 SIZE: 0x4
int iClipSize; //OFS: 0x408 SIZE: 0x4
int shotCount; //OFS: 0x40C SIZE: 0x4
const char* szSharedAmmoCapName; //OFS: 0x410 SIZE: 0x4
int iSharedAmmoCapIndex; //OFS: 0x414 SIZE: 0x4
int iSharedAmmoCap; //OFS: 0x418 SIZE: 0x4
int unlimitedAmmo; //OFS: 0x41C SIZE: 0x4
int damage; //OFS: 0x420 SIZE: 0x4
int damageDuration; //OFS: 0x424 SIZE: 0x4
int damageInterval; //OFS: 0x428 SIZE: 0x4
int playerDamage; //OFS: 0x42C SIZE: 0x4
int iMeleeDamage; //OFS: 0x430 SIZE: 0x4
int iDamageType; //OFS: 0x434 SIZE: 0x4
int iFireDelay; //OFS: 0x438 SIZE: 0x4
int iMeleeDelay; //OFS: 0x43C SIZE: 0x4
int meleeChargeDelay; //OFS: 0x440 SIZE: 0x4
int iDetonateDelay; //OFS: 0x444 SIZE: 0x4
int iFireTime; //OFS: 0x448 SIZE: 0x4
int iRechamberTime; //OFS: 0x44C SIZE: 0x4
int iRechamberBoltTime; //OFS: 0x450 SIZE: 0x4
int iHoldFireTime; //OFS: 0x454 SIZE: 0x4
int iDetonateTime; //OFS: 0x458 SIZE: 0x4
int iMeleeTime; //OFS: 0x45C SIZE: 0x4
int meleeChargeTime; //OFS: 0x460 SIZE: 0x4
int iReloadTime; //OFS: 0x464 SIZE: 0x4
int reloadShowRocketTime; //OFS: 0x468 SIZE: 0x4
int iReloadEmptyTime; //OFS: 0x46C SIZE: 0x4
int iReloadAddTime; //OFS: 0x470 SIZE: 0x4
int reloadEmptyAddTime; //OFS: 0x474 SIZE: 0x4
int iReloadStartTime; //OFS: 0x478 SIZE: 0x4
int iReloadStartAddTime; //OFS: 0x47C SIZE: 0x4
int iReloadEndTime; //OFS: 0x480 SIZE: 0x4
int iDropTime; //OFS: 0x484 SIZE: 0x4
int iRaiseTime; //OFS: 0x488 SIZE: 0x4
int iAltDropTime; //OFS: 0x48C SIZE: 0x4
int iAltRaiseTime; //OFS: 0x490 SIZE: 0x4
int quickDropTime; //OFS: 0x494 SIZE: 0x4
int quickRaiseTime; //OFS: 0x498 SIZE: 0x4
int iFirstRaiseTime; //OFS: 0x49C SIZE: 0x4
int iEmptyRaiseTime; //OFS: 0x4A0 SIZE: 0x4
int iEmptyDropTime; //OFS: 0x4A4 SIZE: 0x4
int sprintInTime; //OFS: 0x4A8 SIZE: 0x4
int sprintLoopTime; //OFS: 0x4AC SIZE: 0x4
int sprintOutTime; //OFS: 0x4B0 SIZE: 0x4
int deployTime; //OFS: 0x4B4 SIZE: 0x4
int breakdownTime; //OFS: 0x4B8 SIZE: 0x4
int nightVisionWearTime; //OFS: 0x4BC SIZE: 0x4
int nightVisionWearTimeFadeOutEnd; //OFS: 0x4C0 SIZE: 0x4
int nightVisionWearTimePowerUp; //OFS: 0x4C4 SIZE: 0x4
int nightVisionRemoveTime; //OFS: 0x4C8 SIZE: 0x4
int nightVisionRemoveTimePowerDown; //OFS: 0x4CC SIZE: 0x4
int nightVisionRemoveTimeFadeInStart; //OFS: 0x4D0 SIZE: 0x4
int fuseTime; //OFS: 0x4D4 SIZE: 0x4
int aiFuseTime; //OFS: 0x4D8 SIZE: 0x4
int requireLockonToFire; //OFS: 0x4DC SIZE: 0x4
int noAdsWhenMagEmpty; //OFS: 0x4E0 SIZE: 0x4
int avoidDropCleanup; //OFS: 0x4E4 SIZE: 0x4
float autoAimRange; //OFS: 0x4E8 SIZE: 0x4
float aimAssistRange; //OFS: 0x4EC SIZE: 0x4
float aimAssistRangeAds; //OFS: 0x4F0 SIZE: 0x4
int mountableWeapon; //OFS: 0x4F4 SIZE: 0x4
float aimPadding; //OFS: 0x4F8 SIZE: 0x4
float enemyCrosshairRange; //OFS: 0x4FC SIZE: 0x4
int crosshairColorChange; //OFS: 0x500 SIZE: 0x4
float moveSpeedScale; //OFS: 0x504 SIZE: 0x4
float adsMoveSpeedScale; //OFS: 0x508 SIZE: 0x4
float sprintDurationScale; //OFS: 0x50C SIZE: 0x4
float fAdsZoomFov; //OFS: 0x510 SIZE: 0x4
float fAdsZoomInFrac; //OFS: 0x514 SIZE: 0x4
float fAdsZoomOutFrac; //OFS: 0x518 SIZE: 0x4
Material* overlayMaterial; //OFS: 0x51C SIZE: 0x4
Material* overlayMaterialLowRes; //OFS: 0x520 SIZE: 0x4
weapOverlayReticle_t overlayReticle; //OFS: 0x524 SIZE: 0x4
WeapOverlayInteface_t overlayInterface; //OFS: 0x528 SIZE: 0x4
float overlayWidth; //OFS: 0x52C SIZE: 0x4
float overlayHeight; //OFS: 0x530 SIZE: 0x4
float fAdsBobFactor; //OFS: 0x534 SIZE: 0x4
float fAdsViewBobMult; //OFS: 0x538 SIZE: 0x4
float fHipSpreadStandMin; //OFS: 0x53C SIZE: 0x4
float fHipSpreadDuckedMin; //OFS: 0x540 SIZE: 0x4
float fHipSpreadProneMin; //OFS: 0x544 SIZE: 0x4
float hipSpreadStandMax; //OFS: 0x548 SIZE: 0x4
float hipSpreadDuckedMax; //OFS: 0x54C SIZE: 0x4
float hipSpreadProneMax; //OFS: 0x550 SIZE: 0x4
float fHipSpreadDecayRate; //OFS: 0x554 SIZE: 0x4
float fHipSpreadFireAdd; //OFS: 0x558 SIZE: 0x4
float fHipSpreadTurnAdd; //OFS: 0x55C SIZE: 0x4
float fHipSpreadMoveAdd; //OFS: 0x560 SIZE: 0x4
float fHipSpreadDuckedDecay; //OFS: 0x564 SIZE: 0x4
float fHipSpreadProneDecay; //OFS: 0x568 SIZE: 0x4
float fHipReticleSidePos; //OFS: 0x56C SIZE: 0x4
int iAdsTransInTime; //OFS: 0x570 SIZE: 0x4
int iAdsTransOutTime; //OFS: 0x574 SIZE: 0x4
float fAdsIdleAmount; //OFS: 0x578 SIZE: 0x4
float fHipIdleAmount; //OFS: 0x57C SIZE: 0x4
float adsIdleSpeed; //OFS: 0x580 SIZE: 0x4
float hipIdleSpeed; //OFS: 0x584 SIZE: 0x4
float fIdleCrouchFactor; //OFS: 0x588 SIZE: 0x4
float fIdleProneFactor; //OFS: 0x58C SIZE: 0x4
float fGunMaxPitch; //OFS: 0x590 SIZE: 0x4
float fGunMaxYaw; //OFS: 0x594 SIZE: 0x4
float swayMaxAngle; //OFS: 0x598 SIZE: 0x4
float swayLerpSpeed; //OFS: 0x59C SIZE: 0x4
float swayPitchScale; //OFS: 0x5A0 SIZE: 0x4
float swayYawScale; //OFS: 0x5A4 SIZE: 0x4
float swayHorizScale; //OFS: 0x5A8 SIZE: 0x4
float swayVertScale; //OFS: 0x5AC SIZE: 0x4
float swayShellShockScale; //OFS: 0x5B0 SIZE: 0x4
float adsSwayMaxAngle; //OFS: 0x5B4 SIZE: 0x4
float adsSwayLerpSpeed; //OFS: 0x5B8 SIZE: 0x4
float adsSwayPitchScale; //OFS: 0x5BC SIZE: 0x4
float adsSwayYawScale; //OFS: 0x5C0 SIZE: 0x4
float adsSwayHorizScale; //OFS: 0x5C4 SIZE: 0x4
float adsSwayVertScale; //OFS: 0x5C8 SIZE: 0x4
int bRifleBullet; //OFS: 0x5CC SIZE: 0x4
int armorPiercing; //OFS: 0x5D0 SIZE: 0x4
int bBoltAction; //OFS: 0x5D4 SIZE: 0x4
int aimDownSight; //OFS: 0x5D8 SIZE: 0x4
int bRechamberWhileAds; //OFS: 0x5DC SIZE: 0x4
float adsViewErrorMin; //OFS: 0x5E0 SIZE: 0x4
float adsViewErrorMax; //OFS: 0x5E4 SIZE: 0x4
int bCookOffHold; //OFS: 0x5E8 SIZE: 0x4
int bClipOnly; //OFS: 0x5EC SIZE: 0x4
int canUseInVehicle; //OFS: 0x5F0 SIZE: 0x4
int noDropsOrRaises; //OFS: 0x5F4 SIZE: 0x4
int adsFireOnly; //OFS: 0x5F8 SIZE: 0x4
int cancelAutoHolsterWhenEmpty; //OFS: 0x5FC SIZE: 0x4
int suppressAmmoReserveDisplay; //OFS: 0x600 SIZE: 0x4
int enhanced; //OFS: 0x604 SIZE: 0x4
int laserSightDuringNightvision; //OFS: 0x608 SIZE: 0x4
int bayonet; //OFS: 0x60C SIZE: 0x4
Material* killIcon; //OFS: 0x610 SIZE: 0x4
weaponIconRatioType_t killIconRatio; //OFS: 0x614 SIZE: 0x4
int flipKillIcon; //OFS: 0x618 SIZE: 0x4
Material* dpadIcon; //OFS: 0x61C SIZE: 0x4
weaponIconRatioType_t dpadIconRatio; //OFS: 0x620 SIZE: 0x4
int bNoPartialReload; //OFS: 0x624 SIZE: 0x4
int bSegmentedReload; //OFS: 0x628 SIZE: 0x4
int noADSAutoReload; //OFS: 0x62C SIZE: 0x4
int iReloadAmmoAdd; //OFS: 0x630 SIZE: 0x4
int iReloadStartAdd; //OFS: 0x634 SIZE: 0x4
const char* szAltWeaponName; //OFS: 0x638 SIZE: 0x4
unsigned int altWeaponIndex; //OFS: 0x63C SIZE: 0x4
int iDropAmmoMin; //OFS: 0x640 SIZE: 0x4
int iDropAmmoMax; //OFS: 0x644 SIZE: 0x4
int blocksProne; //OFS: 0x648 SIZE: 0x4
int silenced; //OFS: 0x64C SIZE: 0x4
int iExplosionRadius; //OFS: 0x650 SIZE: 0x4
int iExplosionRadiusMin; //OFS: 0x654 SIZE: 0x4
int iExplosionInnerDamage; //OFS: 0x658 SIZE: 0x4
int iExplosionOuterDamage; //OFS: 0x65C SIZE: 0x4
float damageConeAngle; //OFS: 0x660 SIZE: 0x4
int iProjectileSpeed; //OFS: 0x664 SIZE: 0x4
int iProjectileSpeedUp; //OFS: 0x668 SIZE: 0x4
int iProjectileSpeedForward; //OFS: 0x66C SIZE: 0x4
int iProjectileActivateDist; //OFS: 0x670 SIZE: 0x4
float projLifetime; //OFS: 0x674 SIZE: 0x4
float timeToAccelerate; //OFS: 0x678 SIZE: 0x4
float projectileCurvature; //OFS: 0x67C SIZE: 0x4
XModel* projectileModel; //OFS: 0x680 SIZE: 0x4
weapProjExposion_t projExplosion; //OFS: 0x684 SIZE: 0x4
FxEffectDef* projExplosionEffect; //OFS: 0x688 SIZE: 0x4
int projExplosionEffectForceNormalUp; //OFS: 0x68C SIZE: 0x4
FxEffectDef* projDudEffect; //OFS: 0x690 SIZE: 0x4
snd_alias_list_t* projExplosionSound; //OFS: 0x694 SIZE: 0x4
snd_alias_list_t* projDudSound; //OFS: 0x698 SIZE: 0x4
snd_alias_list_t* mortarShellSound; //OFS: 0x69C SIZE: 0x4
snd_alias_list_t* tankShellSound; //OFS: 0x6A0 SIZE: 0x4
int bProjImpactExplode; //OFS: 0x6A4 SIZE: 0x4
WeapStickinessType stickiness; //OFS: 0x6A8 SIZE: 0x4
int hasDetonator; //OFS: 0x6AC SIZE: 0x4
int timedDetonation; //OFS: 0x6B0 SIZE: 0x4
int rotate; //OFS: 0x6B4 SIZE: 0x4
int holdButtonToThrow; //OFS: 0x6B8 SIZE: 0x4
int freezeMovementWhenFiring; //OFS: 0x6BC SIZE: 0x4
float lowAmmoWarningThreshold; //OFS: 0x6C0 SIZE: 0x4
float parallelBounce[31]; //OFS: 0x6C4 SIZE: 0x7C
float perpendicularBounce[31]; //OFS: 0x740 SIZE: 0x7C
FxEffectDef* projTrailEffect; //OFS: 0x7BC SIZE: 0x4
float vProjectileColor[3]; //OFS: 0x7C0 SIZE: 0xC
guidedMissileType_t guidedMissileType; //OFS: 0x7CC SIZE: 0x4
float maxSteeringAccel; //OFS: 0x7D0 SIZE: 0x4
int projIgnitionDelay; //OFS: 0x7D4 SIZE: 0x4
FxEffectDef* projIgnitionEffect; //OFS: 0x7D8 SIZE: 0x4
snd_alias_list_t* projIgnitionSound; //OFS: 0x7DC SIZE: 0x4
float fAdsAimPitch; //OFS: 0x7E0 SIZE: 0x4
float fAdsCrosshairInFrac; //OFS: 0x7E4 SIZE: 0x4
float fAdsCrosshairOutFrac; //OFS: 0x7E8 SIZE: 0x4
int adsGunKickReducedKickBullets; //OFS: 0x7EC SIZE: 0x4
float adsGunKickReducedKickPercent; //OFS: 0x7F0 SIZE: 0x4
float fAdsGunKickPitchMin; //OFS: 0x7F4 SIZE: 0x4
float fAdsGunKickPitchMax; //OFS: 0x7F8 SIZE: 0x4
float fAdsGunKickYawMin; //OFS: 0x7FC SIZE: 0x4
float fAdsGunKickYawMax; //OFS: 0x800 SIZE: 0x4
float fAdsGunKickAccel; //OFS: 0x804 SIZE: 0x4
float fAdsGunKickSpeedMax; //OFS: 0x808 SIZE: 0x4
float fAdsGunKickSpeedDecay; //OFS: 0x80C SIZE: 0x4
float fAdsGunKickStaticDecay; //OFS: 0x810 SIZE: 0x4
float fAdsViewKickPitchMin; //OFS: 0x814 SIZE: 0x4
float fAdsViewKickPitchMax; //OFS: 0x818 SIZE: 0x4
float fAdsViewKickYawMin; //OFS: 0x81C SIZE: 0x4
float fAdsViewKickYawMax; //OFS: 0x820 SIZE: 0x4
float fAdsViewKickCenterSpeed; //OFS: 0x824 SIZE: 0x4
float fAdsViewScatterMin; //OFS: 0x828 SIZE: 0x4
float fAdsViewScatterMax; //OFS: 0x82C SIZE: 0x4
float fAdsSpread; //OFS: 0x830 SIZE: 0x4
int hipGunKickReducedKickBullets; //OFS: 0x834 SIZE: 0x4
float hipGunKickReducedKickPercent; //OFS: 0x838 SIZE: 0x4
float fHipGunKickPitchMin; //OFS: 0x83C SIZE: 0x4
float fHipGunKickPitchMax; //OFS: 0x840 SIZE: 0x4
float fHipGunKickYawMin; //OFS: 0x844 SIZE: 0x4
float fHipGunKickYawMax; //OFS: 0x848 SIZE: 0x4
float fHipGunKickAccel; //OFS: 0x84C SIZE: 0x4
float fHipGunKickSpeedMax; //OFS: 0x850 SIZE: 0x4
float fHipGunKickSpeedDecay; //OFS: 0x854 SIZE: 0x4
float fHipGunKickStaticDecay; //OFS: 0x858 SIZE: 0x4
float fHipViewKickPitchMin; //OFS: 0x85C SIZE: 0x4
float fHipViewKickPitchMax; //OFS: 0x860 SIZE: 0x4
float fHipViewKickYawMin; //OFS: 0x864 SIZE: 0x4
float fHipViewKickYawMax; //OFS: 0x868 SIZE: 0x4
float fHipViewKickCenterSpeed; //OFS: 0x86C SIZE: 0x4
float fHipViewScatterMin; //OFS: 0x870 SIZE: 0x4
float fHipViewScatterMax; //OFS: 0x874 SIZE: 0x4
float fightDist; //OFS: 0x878 SIZE: 0x4
float maxDist; //OFS: 0x87C SIZE: 0x4
const char* accuracyGraphName[2]; //OFS: 0x880 SIZE: 0x8
float(*accuracyGraphKnots[2])[2]; //OFS: 0x888 SIZE: 0x8
float(*originalAccuracyGraphKnots[2])[2]; //OFS: 0x890 SIZE: 0x8
int accuracyGraphKnotCount[2]; //OFS: 0x898 SIZE: 0x8
int originalAccuracyGraphKnotCount[2]; //OFS: 0x8A0 SIZE: 0x8
int iPositionReloadTransTime; //OFS: 0x8A8 SIZE: 0x4
float leftArc; //OFS: 0x8AC SIZE: 0x4
float rightArc; //OFS: 0x8B0 SIZE: 0x4
float topArc; //OFS: 0x8B4 SIZE: 0x4
float bottomArc; //OFS: 0x8B8 SIZE: 0x4
float accuracy; //OFS: 0x8BC SIZE: 0x4
float aiSpread; //OFS: 0x8C0 SIZE: 0x4
float playerSpread; //OFS: 0x8C4 SIZE: 0x4
float minTurnSpeed[2]; //OFS: 0x8C8 SIZE: 0x8
float maxTurnSpeed[2]; //OFS: 0x8D0 SIZE: 0x8
float pitchConvergenceTime; //OFS: 0x8D8 SIZE: 0x4
float yawConvergenceTime; //OFS: 0x8DC SIZE: 0x4
float suppressTime; //OFS: 0x8E0 SIZE: 0x4
float maxRange; //OFS: 0x8E4 SIZE: 0x4
float fAnimHorRotateInc; //OFS: 0x8E8 SIZE: 0x4
float fPlayerPositionDist; //OFS: 0x8EC SIZE: 0x4
const char* szUseHintString; //OFS: 0x8F0 SIZE: 0x4
const char* dropHintString; //OFS: 0x8F4 SIZE: 0x4
int iUseHintStringIndex; //OFS: 0x8F8 SIZE: 0x4
int dropHintStringIndex; //OFS: 0x8FC SIZE: 0x4
float horizViewJitter; //OFS: 0x900 SIZE: 0x4
float vertViewJitter; //OFS: 0x904 SIZE: 0x4
const char* szScript; //OFS: 0x908 SIZE: 0x4
float fOOPosAnimLength[2]; //OFS: 0x90C SIZE: 0x8
int minDamage; //OFS: 0x914 SIZE: 0x4
int minPlayerDamage; //OFS: 0x918 SIZE: 0x4
float fMaxDamageRange; //OFS: 0x91C SIZE: 0x4
float fMinDamageRange; //OFS: 0x920 SIZE: 0x4
float destabilizationRateTime; //OFS: 0x924 SIZE: 0x4
float destabilizationCurvatureMax; //OFS: 0x928 SIZE: 0x4
int destabilizeDistance; //OFS: 0x92C SIZE: 0x4
float locNone; //OFS: 0x930 SIZE: 0x4
float locHelmet; //OFS: 0x934 SIZE: 0x4
float locHead; //OFS: 0x938 SIZE: 0x4
float locNeck; //OFS: 0x93C SIZE: 0x4
float locTorsoUpper; //OFS: 0x940 SIZE: 0x4
float locTorsoLower; //OFS: 0x944 SIZE: 0x4
float locRightArmUpper; //OFS: 0x948 SIZE: 0x4
float locLeftArmUpper; //OFS: 0x94C SIZE: 0x4
float locRightArmLower; //OFS: 0x950 SIZE: 0x4
float locLeftArmLower; //OFS: 0x954 SIZE: 0x4
float locRightHand; //OFS: 0x958 SIZE: 0x4
float locLeftHand; //OFS: 0x95C SIZE: 0x4
float locRightLegUpper; //OFS: 0x960 SIZE: 0x4
float locLeftLegUpper; //OFS: 0x964 SIZE: 0x4
float locRightLegLower; //OFS: 0x968 SIZE: 0x4
float locLeftLegLower; //OFS: 0x96C SIZE: 0x4
float locRightFoot; //OFS: 0x970 SIZE: 0x4
float locLeftFoot; //OFS: 0x974 SIZE: 0x4
float locGun; //OFS: 0x978 SIZE: 0x4
const char* fireRumble; //OFS: 0x97C SIZE: 0x4
const char* meleeImpactRumble; //OFS: 0x980 SIZE: 0x4
float adsDofStart; //OFS: 0x984 SIZE: 0x4
float adsDofEnd; //OFS: 0x988 SIZE: 0x4
float hipDofStart; //OFS: 0x98C SIZE: 0x4
float hipDofEnd; //OFS: 0x990 SIZE: 0x4
const char* flameTableFirstPerson; //OFS: 0x994 SIZE: 0x4
const char* flameTableThirdPerson; //OFS: 0x998 SIZE: 0x4
flameTable* flameTableFirstPersonPtr; //OFS: 0x99C SIZE: 0x4
flameTable* flameTableThirdPersonPtr; //OFS: 0x9A0 SIZE: 0x4
FxEffectDef* tagFx_preparationEffect; //OFS: 0x9A4 SIZE: 0x4
FxEffectDef* tagFlash_preparationEffect; //OFS: 0x9A8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(WeaponDef, 0x9AC);
ASSERT_STRUCT_OFFSET(WeaponDef, szInternalName, 0x0);
ASSERT_STRUCT_OFFSET(WeaponDef, szDisplayName, 0x4);
ASSERT_STRUCT_OFFSET(WeaponDef, szOverlayName, 0x8);
ASSERT_STRUCT_OFFSET(WeaponDef, gunXModel, 0xC);
ASSERT_STRUCT_OFFSET(WeaponDef, handXModel, 0x4C);
ASSERT_STRUCT_OFFSET(WeaponDef, someAnim, 0x50);
ASSERT_STRUCT_OFFSET(WeaponDef, sidleAnim, 0x54);
ASSERT_STRUCT_OFFSET(WeaponDef, semptyIdleAnim, 0x58);
ASSERT_STRUCT_OFFSET(WeaponDef, sfireAnim, 0x5C);
ASSERT_STRUCT_OFFSET(WeaponDef, sholdFireAnim, 0x60);
ASSERT_STRUCT_OFFSET(WeaponDef, slastShotAnim, 0x64);
ASSERT_STRUCT_OFFSET(WeaponDef, srechamberAnim, 0x68);
ASSERT_STRUCT_OFFSET(WeaponDef, smeleeAnim, 0x6C);
ASSERT_STRUCT_OFFSET(WeaponDef, smeleeChargeAnim, 0x70);
ASSERT_STRUCT_OFFSET(WeaponDef, sreloadAnim, 0x74);
ASSERT_STRUCT_OFFSET(WeaponDef, sreloadEmptyAnim, 0x78);
ASSERT_STRUCT_OFFSET(WeaponDef, sreloadStartAnim, 0x7C);
ASSERT_STRUCT_OFFSET(WeaponDef, sreloadEndAnim, 0x80);
ASSERT_STRUCT_OFFSET(WeaponDef, sraiseAnim, 0x84);
ASSERT_STRUCT_OFFSET(WeaponDef, sfirstRaiseAnim, 0x88);
ASSERT_STRUCT_OFFSET(WeaponDef, sdropAnim, 0x8C);
ASSERT_STRUCT_OFFSET(WeaponDef, saltRaiseAnim, 0x90);
ASSERT_STRUCT_OFFSET(WeaponDef, saltDropAnim, 0x94);
ASSERT_STRUCT_OFFSET(WeaponDef, squickRaiseAnim, 0x98);
ASSERT_STRUCT_OFFSET(WeaponDef, squickDropAnim, 0x9C);
ASSERT_STRUCT_OFFSET(WeaponDef, semptyRaiseAnim, 0xA0);
ASSERT_STRUCT_OFFSET(WeaponDef, semptyDropAnim, 0xA4);
ASSERT_STRUCT_OFFSET(WeaponDef, ssprintInAnim, 0xA8);
ASSERT_STRUCT_OFFSET(WeaponDef, ssprintLoopAnim, 0xAC);
ASSERT_STRUCT_OFFSET(WeaponDef, ssprintOutAnim, 0xB0);
ASSERT_STRUCT_OFFSET(WeaponDef, sdeployAnim, 0xB4);
ASSERT_STRUCT_OFFSET(WeaponDef, sbreakdownAnim, 0xB8);
ASSERT_STRUCT_OFFSET(WeaponDef, sdetonateAnim, 0xBC);
ASSERT_STRUCT_OFFSET(WeaponDef, snightVisionWearAnim, 0xC0);
ASSERT_STRUCT_OFFSET(WeaponDef, snightVisionRemoveAnim, 0xC4);
ASSERT_STRUCT_OFFSET(WeaponDef, sadsFireAnim, 0xC8);
ASSERT_STRUCT_OFFSET(WeaponDef, sadsLastShotAnim, 0xCC);
ASSERT_STRUCT_OFFSET(WeaponDef, sadsRechamberAnim, 0xD0);
ASSERT_STRUCT_OFFSET(WeaponDef, sadsUpAnim, 0xD4);
ASSERT_STRUCT_OFFSET(WeaponDef, sadsDownAnim, 0xD8);
ASSERT_STRUCT_OFFSET(WeaponDef, szModeName, 0xDC);
ASSERT_STRUCT_OFFSET(WeaponDef, hideTags, 0xE0);
ASSERT_STRUCT_OFFSET(WeaponDef, notetrackSoundMapKeys, 0xF0);
ASSERT_STRUCT_OFFSET(WeaponDef, notetrackSoundMapValues, 0x118);
ASSERT_STRUCT_OFFSET(WeaponDef, playerAnimType, 0x140);
ASSERT_STRUCT_OFFSET(WeaponDef, weapType, 0x144);
ASSERT_STRUCT_OFFSET(WeaponDef, weapClass, 0x148);
ASSERT_STRUCT_OFFSET(WeaponDef, penetrateType, 0x14C);
ASSERT_STRUCT_OFFSET(WeaponDef, impactType, 0x150);
ASSERT_STRUCT_OFFSET(WeaponDef, inventoryType, 0x154);
ASSERT_STRUCT_OFFSET(WeaponDef, fireType, 0x158);
ASSERT_STRUCT_OFFSET(WeaponDef, clipType, 0x15C);
ASSERT_STRUCT_OFFSET(WeaponDef, overheatWeapon, 0x160);
ASSERT_STRUCT_OFFSET(WeaponDef, overheatRate, 0x164);
ASSERT_STRUCT_OFFSET(WeaponDef, cooldownRate, 0x168);
ASSERT_STRUCT_OFFSET(WeaponDef, overheatEndVal, 0x16C);
ASSERT_STRUCT_OFFSET(WeaponDef, coolWhileFiring, 0x170);
ASSERT_STRUCT_OFFSET(WeaponDef, offhandClass, 0x174);
ASSERT_STRUCT_OFFSET(WeaponDef, stance, 0x178);
ASSERT_STRUCT_OFFSET(WeaponDef, viewFlashEffect, 0x17C);
ASSERT_STRUCT_OFFSET(WeaponDef, worldFlashEffect, 0x180);
ASSERT_STRUCT_OFFSET(WeaponDef, pickupSound, 0x184);
ASSERT_STRUCT_OFFSET(WeaponDef, pickupSoundPlayer, 0x188);
ASSERT_STRUCT_OFFSET(WeaponDef, ammoPickupSound, 0x18C);
ASSERT_STRUCT_OFFSET(WeaponDef, ammoPickupSoundPlayer, 0x190);
ASSERT_STRUCT_OFFSET(WeaponDef, projectileSound, 0x194);
ASSERT_STRUCT_OFFSET(WeaponDef, pullbackSound, 0x198);
ASSERT_STRUCT_OFFSET(WeaponDef, pullbackSoundPlayer, 0x19C);
ASSERT_STRUCT_OFFSET(WeaponDef, fireSound, 0x1A0);
ASSERT_STRUCT_OFFSET(WeaponDef, fireSoundPlayer, 0x1A4);
ASSERT_STRUCT_OFFSET(WeaponDef, fireLoopSound, 0x1A8);
ASSERT_STRUCT_OFFSET(WeaponDef, fireLoopSoundPlayer, 0x1AC);
ASSERT_STRUCT_OFFSET(WeaponDef, fireStopSound, 0x1B0);
ASSERT_STRUCT_OFFSET(WeaponDef, fireStopSoundPlayer, 0x1B4);
ASSERT_STRUCT_OFFSET(WeaponDef, fireLastSound, 0x1B8);
ASSERT_STRUCT_OFFSET(WeaponDef, fireLastSoundPlayer, 0x1BC);
ASSERT_STRUCT_OFFSET(WeaponDef, emptyFireSound, 0x1C0);
ASSERT_STRUCT_OFFSET(WeaponDef, emptyFireSoundPlayer, 0x1C4);
ASSERT_STRUCT_OFFSET(WeaponDef, crackSound, 0x1C8);
ASSERT_STRUCT_OFFSET(WeaponDef, whizbySound, 0x1CC);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeSwipeSound, 0x1D0);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeSwipeSoundPlayer, 0x1D4);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeHitSound, 0x1D8);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeMissSound, 0x1DC);
ASSERT_STRUCT_OFFSET(WeaponDef, rechamberSound, 0x1E0);
ASSERT_STRUCT_OFFSET(WeaponDef, rechamberSoundPlayer, 0x1E4);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadSound, 0x1E8);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadSoundPlayer, 0x1EC);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadEmptySound, 0x1F0);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadEmptySoundPlayer, 0x1F4);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadStartSound, 0x1F8);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadStartSoundPlayer, 0x1FC);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadEndSound, 0x200);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadEndSoundPlayer, 0x204);
ASSERT_STRUCT_OFFSET(WeaponDef, rotateLoopSound, 0x208);
ASSERT_STRUCT_OFFSET(WeaponDef, rotateLoopSoundPlayer, 0x20C);
ASSERT_STRUCT_OFFSET(WeaponDef, deploySound, 0x210);
ASSERT_STRUCT_OFFSET(WeaponDef, deploySoundPlayer, 0x214);
ASSERT_STRUCT_OFFSET(WeaponDef, finishDeploySound, 0x218);
ASSERT_STRUCT_OFFSET(WeaponDef, finishDeploySoundPlayer, 0x21C);
ASSERT_STRUCT_OFFSET(WeaponDef, breakdownSound, 0x220);
ASSERT_STRUCT_OFFSET(WeaponDef, breakdownSoundPlayer, 0x224);
ASSERT_STRUCT_OFFSET(WeaponDef, finishBreakdownSound, 0x228);
ASSERT_STRUCT_OFFSET(WeaponDef, finishBreakdownSoundPlayer, 0x22C);
ASSERT_STRUCT_OFFSET(WeaponDef, detonateSound, 0x230);
ASSERT_STRUCT_OFFSET(WeaponDef, detonateSoundPlayer, 0x234);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionWearSound, 0x238);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionWearSoundPlayer, 0x23C);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionRemoveSound, 0x240);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionRemoveSoundPlayer, 0x244);
ASSERT_STRUCT_OFFSET(WeaponDef, altSwitchSound, 0x248);
ASSERT_STRUCT_OFFSET(WeaponDef, altSwitchSoundPlayer, 0x24C);
ASSERT_STRUCT_OFFSET(WeaponDef, raiseSound, 0x250);
ASSERT_STRUCT_OFFSET(WeaponDef, raiseSoundPlayer, 0x254);
ASSERT_STRUCT_OFFSET(WeaponDef, firstRaiseSound, 0x258);
ASSERT_STRUCT_OFFSET(WeaponDef, firstRaiseSoundPlayer, 0x25C);
ASSERT_STRUCT_OFFSET(WeaponDef, putawaySound, 0x260);
ASSERT_STRUCT_OFFSET(WeaponDef, putawaySoundPlayer, 0x264);
ASSERT_STRUCT_OFFSET(WeaponDef, overheatSound, 0x268);
ASSERT_STRUCT_OFFSET(WeaponDef, overheatSoundPlayer, 0x26C);
ASSERT_STRUCT_OFFSET(WeaponDef, bounceSound, 0x270);
ASSERT_STRUCT_OFFSET(WeaponDef, standMountedWeapdef, 0x274);
ASSERT_STRUCT_OFFSET(WeaponDef, crouchMountedWeapdef, 0x278);
ASSERT_STRUCT_OFFSET(WeaponDef, proneMountedWeapdef, 0x27C);
ASSERT_STRUCT_OFFSET(WeaponDef, StandMountedIndex, 0x280);
ASSERT_STRUCT_OFFSET(WeaponDef, CrouchMountedIndex, 0x284);
ASSERT_STRUCT_OFFSET(WeaponDef, ProneMountedIndex, 0x288);
ASSERT_STRUCT_OFFSET(WeaponDef, viewShellEjectEffect, 0x28C);
ASSERT_STRUCT_OFFSET(WeaponDef, worldShellEjectEffect, 0x290);
ASSERT_STRUCT_OFFSET(WeaponDef, viewLastShotEjectEffect, 0x294);
ASSERT_STRUCT_OFFSET(WeaponDef, worldLastShotEjectEffect, 0x298);
ASSERT_STRUCT_OFFSET(WeaponDef, reticleCenter, 0x29C);
ASSERT_STRUCT_OFFSET(WeaponDef, reticleSide, 0x2A0);
ASSERT_STRUCT_OFFSET(WeaponDef, iReticleCenterSize, 0x2A4);
ASSERT_STRUCT_OFFSET(WeaponDef, iReticleSideSize, 0x2A8);
ASSERT_STRUCT_OFFSET(WeaponDef, iReticleMinOfs, 0x2AC);
ASSERT_STRUCT_OFFSET(WeaponDef, activeReticleType, 0x2B0);
ASSERT_STRUCT_OFFSET(WeaponDef, vStandMove, 0x2B4);
ASSERT_STRUCT_OFFSET(WeaponDef, vStandRot, 0x2C0);
ASSERT_STRUCT_OFFSET(WeaponDef, vDuckedOfs, 0x2CC);
ASSERT_STRUCT_OFFSET(WeaponDef, vDuckedMove, 0x2D8);
ASSERT_STRUCT_OFFSET(WeaponDef, duckedSprintOfs, 0x2E4);
ASSERT_STRUCT_OFFSET(WeaponDef, duckedSprintRot, 0x2F0);
ASSERT_STRUCT_OFFSET(WeaponDef, duckedSprintBob, 0x2FC);
ASSERT_STRUCT_OFFSET(WeaponDef, duckedSprintScale, 0x304);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintOfs, 0x308);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintRot, 0x314);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintBob, 0x320);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintScale, 0x328);
ASSERT_STRUCT_OFFSET(WeaponDef, vDuckedRot, 0x32C);
ASSERT_STRUCT_OFFSET(WeaponDef, vProneOfs, 0x338);
ASSERT_STRUCT_OFFSET(WeaponDef, vProneMove, 0x344);
ASSERT_STRUCT_OFFSET(WeaponDef, vProneRot, 0x350);
ASSERT_STRUCT_OFFSET(WeaponDef, fPosMoveRate, 0x35C);
ASSERT_STRUCT_OFFSET(WeaponDef, fPosProneMoveRate, 0x360);
ASSERT_STRUCT_OFFSET(WeaponDef, fStandMoveMinSpeed, 0x364);
ASSERT_STRUCT_OFFSET(WeaponDef, fDuckedMoveMinSpeed, 0x368);
ASSERT_STRUCT_OFFSET(WeaponDef, fProneMoveMinSpeed, 0x36C);
ASSERT_STRUCT_OFFSET(WeaponDef, fPosRotRate, 0x370);
ASSERT_STRUCT_OFFSET(WeaponDef, fPosProneRotRate, 0x374);
ASSERT_STRUCT_OFFSET(WeaponDef, fStandRotMinSpeed, 0x378);
ASSERT_STRUCT_OFFSET(WeaponDef, fDuckedRotMinSpeed, 0x37C);
ASSERT_STRUCT_OFFSET(WeaponDef, fProneRotMinSpeed, 0x380);
ASSERT_STRUCT_OFFSET(WeaponDef, worldModel, 0x384);
ASSERT_STRUCT_OFFSET(WeaponDef, worldClipModel, 0x3C4);
ASSERT_STRUCT_OFFSET(WeaponDef, rocketModel, 0x3C8);
ASSERT_STRUCT_OFFSET(WeaponDef, knifeModel, 0x3CC);
ASSERT_STRUCT_OFFSET(WeaponDef, worldKnifeModel, 0x3D0);
ASSERT_STRUCT_OFFSET(WeaponDef, mountedModel, 0x3D4);
ASSERT_STRUCT_OFFSET(WeaponDef, hudIcon, 0x3D8);
ASSERT_STRUCT_OFFSET(WeaponDef, hudIconRatio, 0x3DC);
ASSERT_STRUCT_OFFSET(WeaponDef, ammoCounterIcon, 0x3E0);
ASSERT_STRUCT_OFFSET(WeaponDef, ammoCounterIconRatio, 0x3E4);
ASSERT_STRUCT_OFFSET(WeaponDef, ammoCounterClip, 0x3E8);
ASSERT_STRUCT_OFFSET(WeaponDef, iStartAmmo, 0x3EC);
ASSERT_STRUCT_OFFSET(WeaponDef, szAmmoName, 0x3F0);
ASSERT_STRUCT_OFFSET(WeaponDef, iAmmoIndex, 0x3F4);
ASSERT_STRUCT_OFFSET(WeaponDef, szClipName, 0x3F8);
ASSERT_STRUCT_OFFSET(WeaponDef, iClipIndex, 0x3FC);
ASSERT_STRUCT_OFFSET(WeaponDef, iHeatIndex, 0x400);
ASSERT_STRUCT_OFFSET(WeaponDef, iMaxAmmo, 0x404);
ASSERT_STRUCT_OFFSET(WeaponDef, iClipSize, 0x408);
ASSERT_STRUCT_OFFSET(WeaponDef, shotCount, 0x40C);
ASSERT_STRUCT_OFFSET(WeaponDef, szSharedAmmoCapName, 0x410);
ASSERT_STRUCT_OFFSET(WeaponDef, iSharedAmmoCapIndex, 0x414);
ASSERT_STRUCT_OFFSET(WeaponDef, iSharedAmmoCap, 0x418);
ASSERT_STRUCT_OFFSET(WeaponDef, unlimitedAmmo, 0x41C);
ASSERT_STRUCT_OFFSET(WeaponDef, damage, 0x420);
ASSERT_STRUCT_OFFSET(WeaponDef, damageDuration, 0x424);
ASSERT_STRUCT_OFFSET(WeaponDef, damageInterval, 0x428);
ASSERT_STRUCT_OFFSET(WeaponDef, playerDamage, 0x42C);
ASSERT_STRUCT_OFFSET(WeaponDef, iMeleeDamage, 0x430);
ASSERT_STRUCT_OFFSET(WeaponDef, iDamageType, 0x434);
ASSERT_STRUCT_OFFSET(WeaponDef, iFireDelay, 0x438);
ASSERT_STRUCT_OFFSET(WeaponDef, iMeleeDelay, 0x43C);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeChargeDelay, 0x440);
ASSERT_STRUCT_OFFSET(WeaponDef, iDetonateDelay, 0x444);
ASSERT_STRUCT_OFFSET(WeaponDef, iFireTime, 0x448);
ASSERT_STRUCT_OFFSET(WeaponDef, iRechamberTime, 0x44C);
ASSERT_STRUCT_OFFSET(WeaponDef, iRechamberBoltTime, 0x450);
ASSERT_STRUCT_OFFSET(WeaponDef, iHoldFireTime, 0x454);
ASSERT_STRUCT_OFFSET(WeaponDef, iDetonateTime, 0x458);
ASSERT_STRUCT_OFFSET(WeaponDef, iMeleeTime, 0x45C);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeChargeTime, 0x460);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadTime, 0x464);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadShowRocketTime, 0x468);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadEmptyTime, 0x46C);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadAddTime, 0x470);
ASSERT_STRUCT_OFFSET(WeaponDef, reloadEmptyAddTime, 0x474);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadStartTime, 0x478);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadStartAddTime, 0x47C);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadEndTime, 0x480);
ASSERT_STRUCT_OFFSET(WeaponDef, iDropTime, 0x484);
ASSERT_STRUCT_OFFSET(WeaponDef, iRaiseTime, 0x488);
ASSERT_STRUCT_OFFSET(WeaponDef, iAltDropTime, 0x48C);
ASSERT_STRUCT_OFFSET(WeaponDef, iAltRaiseTime, 0x490);
ASSERT_STRUCT_OFFSET(WeaponDef, quickDropTime, 0x494);
ASSERT_STRUCT_OFFSET(WeaponDef, quickRaiseTime, 0x498);
ASSERT_STRUCT_OFFSET(WeaponDef, iFirstRaiseTime, 0x49C);
ASSERT_STRUCT_OFFSET(WeaponDef, iEmptyRaiseTime, 0x4A0);
ASSERT_STRUCT_OFFSET(WeaponDef, iEmptyDropTime, 0x4A4);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintInTime, 0x4A8);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintLoopTime, 0x4AC);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintOutTime, 0x4B0);
ASSERT_STRUCT_OFFSET(WeaponDef, deployTime, 0x4B4);
ASSERT_STRUCT_OFFSET(WeaponDef, breakdownTime, 0x4B8);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionWearTime, 0x4BC);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionWearTimeFadeOutEnd, 0x4C0);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionWearTimePowerUp, 0x4C4);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionRemoveTime, 0x4C8);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionRemoveTimePowerDown, 0x4CC);
ASSERT_STRUCT_OFFSET(WeaponDef, nightVisionRemoveTimeFadeInStart, 0x4D0);
ASSERT_STRUCT_OFFSET(WeaponDef, fuseTime, 0x4D4);
ASSERT_STRUCT_OFFSET(WeaponDef, aiFuseTime, 0x4D8);
ASSERT_STRUCT_OFFSET(WeaponDef, requireLockonToFire, 0x4DC);
ASSERT_STRUCT_OFFSET(WeaponDef, noAdsWhenMagEmpty, 0x4E0);
ASSERT_STRUCT_OFFSET(WeaponDef, avoidDropCleanup, 0x4E4);
ASSERT_STRUCT_OFFSET(WeaponDef, autoAimRange, 0x4E8);
ASSERT_STRUCT_OFFSET(WeaponDef, aimAssistRange, 0x4EC);
ASSERT_STRUCT_OFFSET(WeaponDef, aimAssistRangeAds, 0x4F0);
ASSERT_STRUCT_OFFSET(WeaponDef, mountableWeapon, 0x4F4);
ASSERT_STRUCT_OFFSET(WeaponDef, aimPadding, 0x4F8);
ASSERT_STRUCT_OFFSET(WeaponDef, enemyCrosshairRange, 0x4FC);
ASSERT_STRUCT_OFFSET(WeaponDef, crosshairColorChange, 0x500);
ASSERT_STRUCT_OFFSET(WeaponDef, moveSpeedScale, 0x504);
ASSERT_STRUCT_OFFSET(WeaponDef, adsMoveSpeedScale, 0x508);
ASSERT_STRUCT_OFFSET(WeaponDef, sprintDurationScale, 0x50C);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsZoomFov, 0x510);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsZoomInFrac, 0x514);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsZoomOutFrac, 0x518);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayMaterial, 0x51C);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayMaterialLowRes, 0x520);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayReticle, 0x524);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayInterface, 0x528);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayWidth, 0x52C);
ASSERT_STRUCT_OFFSET(WeaponDef, overlayHeight, 0x530);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsBobFactor, 0x534);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewBobMult, 0x538);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadStandMin, 0x53C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadDuckedMin, 0x540);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadProneMin, 0x544);
ASSERT_STRUCT_OFFSET(WeaponDef, hipSpreadStandMax, 0x548);
ASSERT_STRUCT_OFFSET(WeaponDef, hipSpreadDuckedMax, 0x54C);
ASSERT_STRUCT_OFFSET(WeaponDef, hipSpreadProneMax, 0x550);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadDecayRate, 0x554);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadFireAdd, 0x558);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadTurnAdd, 0x55C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadMoveAdd, 0x560);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadDuckedDecay, 0x564);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipSpreadProneDecay, 0x568);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipReticleSidePos, 0x56C);
ASSERT_STRUCT_OFFSET(WeaponDef, iAdsTransInTime, 0x570);
ASSERT_STRUCT_OFFSET(WeaponDef, iAdsTransOutTime, 0x574);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsIdleAmount, 0x578);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipIdleAmount, 0x57C);
ASSERT_STRUCT_OFFSET(WeaponDef, adsIdleSpeed, 0x580);
ASSERT_STRUCT_OFFSET(WeaponDef, hipIdleSpeed, 0x584);
ASSERT_STRUCT_OFFSET(WeaponDef, fIdleCrouchFactor, 0x588);
ASSERT_STRUCT_OFFSET(WeaponDef, fIdleProneFactor, 0x58C);
ASSERT_STRUCT_OFFSET(WeaponDef, fGunMaxPitch, 0x590);
ASSERT_STRUCT_OFFSET(WeaponDef, fGunMaxYaw, 0x594);
ASSERT_STRUCT_OFFSET(WeaponDef, swayMaxAngle, 0x598);
ASSERT_STRUCT_OFFSET(WeaponDef, swayLerpSpeed, 0x59C);
ASSERT_STRUCT_OFFSET(WeaponDef, swayPitchScale, 0x5A0);
ASSERT_STRUCT_OFFSET(WeaponDef, swayYawScale, 0x5A4);
ASSERT_STRUCT_OFFSET(WeaponDef, swayHorizScale, 0x5A8);
ASSERT_STRUCT_OFFSET(WeaponDef, swayVertScale, 0x5AC);
ASSERT_STRUCT_OFFSET(WeaponDef, swayShellShockScale, 0x5B0);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayMaxAngle, 0x5B4);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayLerpSpeed, 0x5B8);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayPitchScale, 0x5BC);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayYawScale, 0x5C0);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayHorizScale, 0x5C4);
ASSERT_STRUCT_OFFSET(WeaponDef, adsSwayVertScale, 0x5C8);
ASSERT_STRUCT_OFFSET(WeaponDef, bRifleBullet, 0x5CC);
ASSERT_STRUCT_OFFSET(WeaponDef, armorPiercing, 0x5D0);
ASSERT_STRUCT_OFFSET(WeaponDef, bBoltAction, 0x5D4);
ASSERT_STRUCT_OFFSET(WeaponDef, aimDownSight, 0x5D8);
ASSERT_STRUCT_OFFSET(WeaponDef, bRechamberWhileAds, 0x5DC);
ASSERT_STRUCT_OFFSET(WeaponDef, adsViewErrorMin, 0x5E0);
ASSERT_STRUCT_OFFSET(WeaponDef, adsViewErrorMax, 0x5E4);
ASSERT_STRUCT_OFFSET(WeaponDef, bCookOffHold, 0x5E8);
ASSERT_STRUCT_OFFSET(WeaponDef, bClipOnly, 0x5EC);
ASSERT_STRUCT_OFFSET(WeaponDef, canUseInVehicle, 0x5F0);
ASSERT_STRUCT_OFFSET(WeaponDef, noDropsOrRaises, 0x5F4);
ASSERT_STRUCT_OFFSET(WeaponDef, adsFireOnly, 0x5F8);
ASSERT_STRUCT_OFFSET(WeaponDef, cancelAutoHolsterWhenEmpty, 0x5FC);
ASSERT_STRUCT_OFFSET(WeaponDef, suppressAmmoReserveDisplay, 0x600);
ASSERT_STRUCT_OFFSET(WeaponDef, enhanced, 0x604);
ASSERT_STRUCT_OFFSET(WeaponDef, laserSightDuringNightvision, 0x608);
ASSERT_STRUCT_OFFSET(WeaponDef, bayonet, 0x60C);
ASSERT_STRUCT_OFFSET(WeaponDef, killIcon, 0x610);
ASSERT_STRUCT_OFFSET(WeaponDef, killIconRatio, 0x614);
ASSERT_STRUCT_OFFSET(WeaponDef, flipKillIcon, 0x618);
ASSERT_STRUCT_OFFSET(WeaponDef, dpadIcon, 0x61C);
ASSERT_STRUCT_OFFSET(WeaponDef, dpadIconRatio, 0x620);
ASSERT_STRUCT_OFFSET(WeaponDef, bNoPartialReload, 0x624);
ASSERT_STRUCT_OFFSET(WeaponDef, bSegmentedReload, 0x628);
ASSERT_STRUCT_OFFSET(WeaponDef, noADSAutoReload, 0x62C);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadAmmoAdd, 0x630);
ASSERT_STRUCT_OFFSET(WeaponDef, iReloadStartAdd, 0x634);
ASSERT_STRUCT_OFFSET(WeaponDef, szAltWeaponName, 0x638);
ASSERT_STRUCT_OFFSET(WeaponDef, altWeaponIndex, 0x63C);
ASSERT_STRUCT_OFFSET(WeaponDef, iDropAmmoMin, 0x640);
ASSERT_STRUCT_OFFSET(WeaponDef, iDropAmmoMax, 0x644);
ASSERT_STRUCT_OFFSET(WeaponDef, blocksProne, 0x648);
ASSERT_STRUCT_OFFSET(WeaponDef, silenced, 0x64C);
ASSERT_STRUCT_OFFSET(WeaponDef, iExplosionRadius, 0x650);
ASSERT_STRUCT_OFFSET(WeaponDef, iExplosionRadiusMin, 0x654);
ASSERT_STRUCT_OFFSET(WeaponDef, iExplosionInnerDamage, 0x658);
ASSERT_STRUCT_OFFSET(WeaponDef, iExplosionOuterDamage, 0x65C);
ASSERT_STRUCT_OFFSET(WeaponDef, damageConeAngle, 0x660);
ASSERT_STRUCT_OFFSET(WeaponDef, iProjectileSpeed, 0x664);
ASSERT_STRUCT_OFFSET(WeaponDef, iProjectileSpeedUp, 0x668);
ASSERT_STRUCT_OFFSET(WeaponDef, iProjectileSpeedForward, 0x66C);
ASSERT_STRUCT_OFFSET(WeaponDef, iProjectileActivateDist, 0x670);
ASSERT_STRUCT_OFFSET(WeaponDef, projLifetime, 0x674);
ASSERT_STRUCT_OFFSET(WeaponDef, timeToAccelerate, 0x678);
ASSERT_STRUCT_OFFSET(WeaponDef, projectileCurvature, 0x67C);
ASSERT_STRUCT_OFFSET(WeaponDef, projectileModel, 0x680);
ASSERT_STRUCT_OFFSET(WeaponDef, projExplosion, 0x684);
ASSERT_STRUCT_OFFSET(WeaponDef, projExplosionEffect, 0x688);
ASSERT_STRUCT_OFFSET(WeaponDef, projExplosionEffectForceNormalUp, 0x68C);
ASSERT_STRUCT_OFFSET(WeaponDef, projDudEffect, 0x690);
ASSERT_STRUCT_OFFSET(WeaponDef, projExplosionSound, 0x694);
ASSERT_STRUCT_OFFSET(WeaponDef, projDudSound, 0x698);
ASSERT_STRUCT_OFFSET(WeaponDef, mortarShellSound, 0x69C);
ASSERT_STRUCT_OFFSET(WeaponDef, tankShellSound, 0x6A0);
ASSERT_STRUCT_OFFSET(WeaponDef, bProjImpactExplode, 0x6A4);
ASSERT_STRUCT_OFFSET(WeaponDef, stickiness, 0x6A8);
ASSERT_STRUCT_OFFSET(WeaponDef, hasDetonator, 0x6AC);
ASSERT_STRUCT_OFFSET(WeaponDef, timedDetonation, 0x6B0);
ASSERT_STRUCT_OFFSET(WeaponDef, rotate, 0x6B4);
ASSERT_STRUCT_OFFSET(WeaponDef, holdButtonToThrow, 0x6B8);
ASSERT_STRUCT_OFFSET(WeaponDef, freezeMovementWhenFiring, 0x6BC);
ASSERT_STRUCT_OFFSET(WeaponDef, lowAmmoWarningThreshold, 0x6C0);
ASSERT_STRUCT_OFFSET(WeaponDef, parallelBounce, 0x6C4);
ASSERT_STRUCT_OFFSET(WeaponDef, perpendicularBounce, 0x740);
ASSERT_STRUCT_OFFSET(WeaponDef, projTrailEffect, 0x7BC);
ASSERT_STRUCT_OFFSET(WeaponDef, vProjectileColor, 0x7C0);
ASSERT_STRUCT_OFFSET(WeaponDef, guidedMissileType, 0x7CC);
ASSERT_STRUCT_OFFSET(WeaponDef, maxSteeringAccel, 0x7D0);
ASSERT_STRUCT_OFFSET(WeaponDef, projIgnitionDelay, 0x7D4);
ASSERT_STRUCT_OFFSET(WeaponDef, projIgnitionEffect, 0x7D8);
ASSERT_STRUCT_OFFSET(WeaponDef, projIgnitionSound, 0x7DC);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsAimPitch, 0x7E0);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsCrosshairInFrac, 0x7E4);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsCrosshairOutFrac, 0x7E8);
ASSERT_STRUCT_OFFSET(WeaponDef, adsGunKickReducedKickBullets, 0x7EC);
ASSERT_STRUCT_OFFSET(WeaponDef, adsGunKickReducedKickPercent, 0x7F0);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickPitchMin, 0x7F4);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickPitchMax, 0x7F8);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickYawMin, 0x7FC);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickYawMax, 0x800);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickAccel, 0x804);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickSpeedMax, 0x808);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickSpeedDecay, 0x80C);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsGunKickStaticDecay, 0x810);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewKickPitchMin, 0x814);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewKickPitchMax, 0x818);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewKickYawMin, 0x81C);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewKickYawMax, 0x820);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewKickCenterSpeed, 0x824);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewScatterMin, 0x828);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsViewScatterMax, 0x82C);
ASSERT_STRUCT_OFFSET(WeaponDef, fAdsSpread, 0x830);
ASSERT_STRUCT_OFFSET(WeaponDef, hipGunKickReducedKickBullets, 0x834);
ASSERT_STRUCT_OFFSET(WeaponDef, hipGunKickReducedKickPercent, 0x838);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickPitchMin, 0x83C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickPitchMax, 0x840);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickYawMin, 0x844);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickYawMax, 0x848);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickAccel, 0x84C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickSpeedMax, 0x850);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickSpeedDecay, 0x854);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipGunKickStaticDecay, 0x858);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewKickPitchMin, 0x85C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewKickPitchMax, 0x860);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewKickYawMin, 0x864);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewKickYawMax, 0x868);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewKickCenterSpeed, 0x86C);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewScatterMin, 0x870);
ASSERT_STRUCT_OFFSET(WeaponDef, fHipViewScatterMax, 0x874);
ASSERT_STRUCT_OFFSET(WeaponDef, fightDist, 0x878);
ASSERT_STRUCT_OFFSET(WeaponDef, maxDist, 0x87C);
ASSERT_STRUCT_OFFSET(WeaponDef, accuracyGraphName, 0x880);
ASSERT_STRUCT_OFFSET(WeaponDef, accuracyGraphKnots, 0x888);
ASSERT_STRUCT_OFFSET(WeaponDef, originalAccuracyGraphKnots, 0x890);
ASSERT_STRUCT_OFFSET(WeaponDef, accuracyGraphKnotCount, 0x898);
ASSERT_STRUCT_OFFSET(WeaponDef, originalAccuracyGraphKnotCount, 0x8A0);
ASSERT_STRUCT_OFFSET(WeaponDef, iPositionReloadTransTime, 0x8A8);
ASSERT_STRUCT_OFFSET(WeaponDef, leftArc, 0x8AC);
ASSERT_STRUCT_OFFSET(WeaponDef, rightArc, 0x8B0);
ASSERT_STRUCT_OFFSET(WeaponDef, topArc, 0x8B4);
ASSERT_STRUCT_OFFSET(WeaponDef, bottomArc, 0x8B8);
ASSERT_STRUCT_OFFSET(WeaponDef, accuracy, 0x8BC);
ASSERT_STRUCT_OFFSET(WeaponDef, aiSpread, 0x8C0);
ASSERT_STRUCT_OFFSET(WeaponDef, playerSpread, 0x8C4);
ASSERT_STRUCT_OFFSET(WeaponDef, minTurnSpeed, 0x8C8);
ASSERT_STRUCT_OFFSET(WeaponDef, maxTurnSpeed, 0x8D0);
ASSERT_STRUCT_OFFSET(WeaponDef, pitchConvergenceTime, 0x8D8);
ASSERT_STRUCT_OFFSET(WeaponDef, yawConvergenceTime, 0x8DC);
ASSERT_STRUCT_OFFSET(WeaponDef, suppressTime, 0x8E0);
ASSERT_STRUCT_OFFSET(WeaponDef, maxRange, 0x8E4);
ASSERT_STRUCT_OFFSET(WeaponDef, fAnimHorRotateInc, 0x8E8);
ASSERT_STRUCT_OFFSET(WeaponDef, fPlayerPositionDist, 0x8EC);
ASSERT_STRUCT_OFFSET(WeaponDef, szUseHintString, 0x8F0);
ASSERT_STRUCT_OFFSET(WeaponDef, dropHintString, 0x8F4);
ASSERT_STRUCT_OFFSET(WeaponDef, iUseHintStringIndex, 0x8F8);
ASSERT_STRUCT_OFFSET(WeaponDef, dropHintStringIndex, 0x8FC);
ASSERT_STRUCT_OFFSET(WeaponDef, horizViewJitter, 0x900);
ASSERT_STRUCT_OFFSET(WeaponDef, vertViewJitter, 0x904);
ASSERT_STRUCT_OFFSET(WeaponDef, szScript, 0x908);
ASSERT_STRUCT_OFFSET(WeaponDef, fOOPosAnimLength, 0x90C);
ASSERT_STRUCT_OFFSET(WeaponDef, minDamage, 0x914);
ASSERT_STRUCT_OFFSET(WeaponDef, minPlayerDamage, 0x918);
ASSERT_STRUCT_OFFSET(WeaponDef, fMaxDamageRange, 0x91C);
ASSERT_STRUCT_OFFSET(WeaponDef, fMinDamageRange, 0x920);
ASSERT_STRUCT_OFFSET(WeaponDef, destabilizationRateTime, 0x924);
ASSERT_STRUCT_OFFSET(WeaponDef, destabilizationCurvatureMax, 0x928);
ASSERT_STRUCT_OFFSET(WeaponDef, destabilizeDistance, 0x92C);
ASSERT_STRUCT_OFFSET(WeaponDef, locNone, 0x930);
ASSERT_STRUCT_OFFSET(WeaponDef, locHelmet, 0x934);
ASSERT_STRUCT_OFFSET(WeaponDef, locHead, 0x938);
ASSERT_STRUCT_OFFSET(WeaponDef, locNeck, 0x93C);
ASSERT_STRUCT_OFFSET(WeaponDef, locTorsoUpper, 0x940);
ASSERT_STRUCT_OFFSET(WeaponDef, locTorsoLower, 0x944);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightArmUpper, 0x948);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftArmUpper, 0x94C);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightArmLower, 0x950);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftArmLower, 0x954);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightHand, 0x958);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftHand, 0x95C);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightLegUpper, 0x960);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftLegUpper, 0x964);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightLegLower, 0x968);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftLegLower, 0x96C);
ASSERT_STRUCT_OFFSET(WeaponDef, locRightFoot, 0x970);
ASSERT_STRUCT_OFFSET(WeaponDef, locLeftFoot, 0x974);
ASSERT_STRUCT_OFFSET(WeaponDef, locGun, 0x978);
ASSERT_STRUCT_OFFSET(WeaponDef, fireRumble, 0x97C);
ASSERT_STRUCT_OFFSET(WeaponDef, meleeImpactRumble, 0x980);
ASSERT_STRUCT_OFFSET(WeaponDef, adsDofStart, 0x984);
ASSERT_STRUCT_OFFSET(WeaponDef, adsDofEnd, 0x988);
ASSERT_STRUCT_OFFSET(WeaponDef, hipDofStart, 0x98C);
ASSERT_STRUCT_OFFSET(WeaponDef, hipDofEnd, 0x990);
ASSERT_STRUCT_OFFSET(WeaponDef, flameTableFirstPerson, 0x994);
ASSERT_STRUCT_OFFSET(WeaponDef, flameTableThirdPerson, 0x998);
ASSERT_STRUCT_OFFSET(WeaponDef, flameTableFirstPersonPtr, 0x99C);
ASSERT_STRUCT_OFFSET(WeaponDef, flameTableThirdPersonPtr, 0x9A0);
ASSERT_STRUCT_OFFSET(WeaponDef, tagFx_preparationEffect, 0x9A4);
ASSERT_STRUCT_OFFSET(WeaponDef, tagFlash_preparationEffect, 0x9A8);
struct snd_reverb_patch_t
{
char name[32]; //OFS: 0x0 SIZE: 0x20
float room; //OFS: 0x20 SIZE: 0x4
float roomHF; //OFS: 0x24 SIZE: 0x4
float roomRolloffFactor; //OFS: 0x28 SIZE: 0x4
float decayTime; //OFS: 0x2C SIZE: 0x4
float decayHFRatio; //OFS: 0x30 SIZE: 0x4
float reflections; //OFS: 0x34 SIZE: 0x4
float reflectionsDelay; //OFS: 0x38 SIZE: 0x4
float reverb; //OFS: 0x3C SIZE: 0x4
float reverbDelay; //OFS: 0x40 SIZE: 0x4
float diffusion; //OFS: 0x44 SIZE: 0x4
float density; //OFS: 0x48 SIZE: 0x4
float HFReference; //OFS: 0x4C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_reverb_patch_t, 0x50);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, name, 0x0);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, room, 0x20);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, roomHF, 0x24);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, roomRolloffFactor, 0x28);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, decayTime, 0x2C);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, decayHFRatio, 0x30);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, reflections, 0x34);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, reflectionsDelay, 0x38);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, reverb, 0x3C);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, reverbDelay, 0x40);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, diffusion, 0x44);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, density, 0x48);
ASSERT_STRUCT_OFFSET(snd_reverb_patch_t, HFReference, 0x4C);
struct snd_bus_info_t
{
char name[32]; //OFS: 0x0 SIZE: 0x20
float volumeMod; //OFS: 0x20 SIZE: 0x4
int maxVoices; //OFS: 0x24 SIZE: 0x4
int restricted; //OFS: 0x28 SIZE: 0x4
int pausable; //OFS: 0x2C SIZE: 0x4
int stopOnDeath; //OFS: 0x30 SIZE: 0x4
int isMusic; //OFS: 0x34 SIZE: 0x4
snd_category_t category; //OFS: 0x38 SIZE: 0x4
snd_limit_type_t voiceLimitType; //OFS: 0x3C SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_bus_info_t, 0x40);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, name, 0x0);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, volumeMod, 0x20);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, maxVoices, 0x24);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, restricted, 0x28);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, pausable, 0x2C);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, stopOnDeath, 0x30);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, isMusic, 0x34);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, category, 0x38);
ASSERT_STRUCT_OFFSET(snd_bus_info_t, voiceLimitType, 0x3C);
struct snd_curve_t
{
char name[32]; //OFS: 0x0 SIZE: 0x20
int pointCount; //OFS: 0x20 SIZE: 0x4
float points[8][2]; //OFS: 0x24 SIZE: 0x40
};
ASSERT_STRUCT_SIZE(snd_curve_t, 0x64);
ASSERT_STRUCT_OFFSET(snd_curve_t, name, 0x0);
ASSERT_STRUCT_OFFSET(snd_curve_t, pointCount, 0x20);
ASSERT_STRUCT_OFFSET(snd_curve_t, points, 0x24);
struct snd_speaker_map
{
int input_channel_count; //OFS: 0x0 SIZE: 0x4
int output_channel_count; //OFS: 0x4 SIZE: 0x4
float volumes[16]; //OFS: 0x8 SIZE: 0x40
};
ASSERT_STRUCT_SIZE(snd_speaker_map, 0x48);
ASSERT_STRUCT_OFFSET(snd_speaker_map, input_channel_count, 0x0);
ASSERT_STRUCT_OFFSET(snd_speaker_map, output_channel_count, 0x4);
ASSERT_STRUCT_OFFSET(snd_speaker_map, volumes, 0x8);
struct snd_speaker_map_set
{
char name[32]; //OFS: 0x0 SIZE: 0x20
snd_speaker_map channelMaps[4]; //OFS: 0x20 SIZE: 0x120
};
ASSERT_STRUCT_SIZE(snd_speaker_map_set, 0x140);
ASSERT_STRUCT_OFFSET(snd_speaker_map_set, name, 0x0);
ASSERT_STRUCT_OFFSET(snd_speaker_map_set, channelMaps, 0x20);
struct snd_master_effect_t
{
char name[32]; //OFS: 0x0 SIZE: 0x20
float masterRingmod; //OFS: 0x20 SIZE: 0x4
float reverbRingmod; //OFS: 0x24 SIZE: 0x4
float masterLPRatio; //OFS: 0x28 SIZE: 0x4
float masterLPDB; //OFS: 0x2C SIZE: 0x4
float masterHPRatio; //OFS: 0x30 SIZE: 0x4
float masterHPDB; //OFS: 0x34 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(snd_master_effect_t, 0x38);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, name, 0x0);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, masterRingmod, 0x20);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, reverbRingmod, 0x24);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, masterLPRatio, 0x28);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, masterLPDB, 0x2C);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, masterHPRatio, 0x30);
ASSERT_STRUCT_OFFSET(snd_master_effect_t, masterHPDB, 0x34);
struct SndDriverGlobals
{
const char* name; //OFS: 0x0 SIZE: 0x4
snd_reverb_patch_t reverbPatches[64]; //OFS: 0x4 SIZE: 0x1400
snd_bus_info_t buses[64]; //OFS: 0x1404 SIZE: 0x1000
snd_curve_t curves[32]; //OFS: 0x2404 SIZE: 0xC80
snd_speaker_map_set speakerMaps[32]; //OFS: 0x3084 SIZE: 0x2800
snd_master_effect_t masterEffects[16]; //OFS: 0x5884 SIZE: 0x380
};
ASSERT_STRUCT_SIZE(SndDriverGlobals, 0x5C04);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, name, 0x0);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, reverbPatches, 0x4);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, buses, 0x1404);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, curves, 0x2404);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, speakerMaps, 0x3084);
ASSERT_STRUCT_OFFSET(SndDriverGlobals, masterEffects, 0x5884);
struct FxImpactEntry
{
FxEffectDef* nonflesh[31]; //OFS: 0x0 SIZE: 0x7C
FxEffectDef* flesh[4]; //OFS: 0x7C SIZE: 0x10
};
ASSERT_STRUCT_SIZE(FxImpactEntry, 0x8C);
ASSERT_STRUCT_OFFSET(FxImpactEntry, nonflesh, 0x0);
ASSERT_STRUCT_OFFSET(FxImpactEntry, flesh, 0x7C);
struct FxImpactTable
{
char* name; //OFS: 0x0 SIZE: 0x4
FxImpactEntry* table; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(FxImpactTable, 0x8);
ASSERT_STRUCT_OFFSET(FxImpactTable, name, 0x0);
ASSERT_STRUCT_OFFSET(FxImpactTable, table, 0x4);
struct RawFile
{
char* name; //OFS: 0x0 SIZE: 0x4
int len; //OFS: 0x4 SIZE: 0x4
char* buffer; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(RawFile, 0xC);
ASSERT_STRUCT_OFFSET(RawFile, name, 0x0);
ASSERT_STRUCT_OFFSET(RawFile, len, 0x4);
ASSERT_STRUCT_OFFSET(RawFile, buffer, 0x8);
struct StringTableCell
{
const char * string; //OFS: 0x0 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(StringTableCell, 0x4);
ASSERT_STRUCT_OFFSET(StringTableCell, string, 0x0);
struct StringTable
{
char* name; //OFS: 0x0 SIZE: 0x4
int columnCount; //OFS: 0x4 SIZE: 0x4
int rowCount; //OFS: 0x8 SIZE: 0x4
StringTableCell* values; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(StringTable, 0x10);
ASSERT_STRUCT_OFFSET(StringTable, name, 0x0);
ASSERT_STRUCT_OFFSET(StringTable, columnCount, 0x4);
ASSERT_STRUCT_OFFSET(StringTable, rowCount, 0x8);
ASSERT_STRUCT_OFFSET(StringTable, values, 0xC);
struct PackIndexHeader
{
unsigned int magic; //OFS: 0x0 SIZE: 0x4
unsigned int timestamp; //OFS: 0x4 SIZE: 0x4
unsigned int count; //OFS: 0x8 SIZE: 0x4
unsigned int alignment; //OFS: 0xC SIZE: 0x4
unsigned int data_start; //OFS: 0x10 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PackIndexHeader, 0x14);
ASSERT_STRUCT_OFFSET(PackIndexHeader, magic, 0x0);
ASSERT_STRUCT_OFFSET(PackIndexHeader, timestamp, 0x4);
ASSERT_STRUCT_OFFSET(PackIndexHeader, count, 0x8);
ASSERT_STRUCT_OFFSET(PackIndexHeader, alignment, 0xC);
ASSERT_STRUCT_OFFSET(PackIndexHeader, data_start, 0x10);
struct PackIndexEntry
{
unsigned int hash; //OFS: 0x0 SIZE: 0x4
unsigned int offset; //OFS: 0x4 SIZE: 0x4
unsigned int size; //OFS: 0x8 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PackIndexEntry, 0xC);
ASSERT_STRUCT_OFFSET(PackIndexEntry, hash, 0x0);
ASSERT_STRUCT_OFFSET(PackIndexEntry, offset, 0x4);
ASSERT_STRUCT_OFFSET(PackIndexEntry, size, 0x8);
struct PackIndex
{
char* name; //OFS: 0x0 SIZE: 0x4
PackIndexHeader header; //OFS: 0x4 SIZE: 0x14
PackIndexEntry* entries; //OFS: 0x18 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(PackIndex, 0x1C);
ASSERT_STRUCT_OFFSET(PackIndex, name, 0x0);
ASSERT_STRUCT_OFFSET(PackIndex, header, 0x4);
ASSERT_STRUCT_OFFSET(PackIndex, entries, 0x18);
union XAssetHeader
{
XModelPieces* xmodelPieces; //OFS: 0x0 SIZE: 0x4
PhysPreset* physPreset; //OFS: 0x1 SIZE: 0x4
PhysConstraints* physConstraints; //OFS: 0x2 SIZE: 0x4
DestructibleDef* destructibleDef; //OFS: 0x3 SIZE: 0x4
XAnimParts* parts; //OFS: 0x4 SIZE: 0x4
XModel* model; //OFS: 0x5 SIZE: 0x4
Material* material; //OFS: 0x6 SIZE: 0x4
MaterialPixelShader* pixelShader; //OFS: 0x7 SIZE: 0x4
MaterialVertexShader* vertexShader; //OFS: 0x8 SIZE: 0x4
MaterialTechniqueSet* techniqueSet; //OFS: 0x9 SIZE: 0x4
GfxImage* image; //OFS: 0xA SIZE: 0x4
clipMap_t* clipMap; //OFS: 0xB SIZE: 0x4
ComWorld* comWorld; //OFS: 0xC SIZE: 0x4
GameWorldSp* gameWorldSp; //OFS: 0xD SIZE: 0x4
GameWorldMp* gameWorldMp; //OFS: 0xE SIZE: 0x4
MapEnts* mapEnts; //OFS: 0xF SIZE: 0x4
GfxWorld* gfxWorld; //OFS: 0x10 SIZE: 0x4
GfxLightDef* lightDef; //OFS: 0x11 SIZE: 0x4
Font_s* font; //OFS: 0x12 SIZE: 0x4
MenuList* menuList; //OFS: 0x13 SIZE: 0x4
menuDef_t* menu; //OFS: 0x14 SIZE: 0x4
LocalizeEntry* localize; //OFS: 0x15 SIZE: 0x4
WeaponDef* weapon; //OFS: 0x16 SIZE: 0x4
SndDriverGlobals* sndDriverGlobals; //OFS: 0x17 SIZE: 0x4
const FxEffectDef* fx; //OFS: 0x18 SIZE: 0x4
FxImpactTable* impactFx; //OFS: 0x19 SIZE: 0x4
RawFile* rawfile; //OFS: 0x1A SIZE: 0x4
StringTable* stringTable; //OFS: 0x1B SIZE: 0x4
PackIndex* packIndex; //OFS: 0x1C SIZE: 0x4
void* data; //OFS: 0x1D SIZE: 0x4
};
struct XAsset
{
XAssetType type; //OFS: 0x0 SIZE: 0x4
XAssetHeader header; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XAsset, 0x8);
ASSERT_STRUCT_OFFSET(XAsset, type, 0x0);
ASSERT_STRUCT_OFFSET(XAsset, header, 0x4);
struct XAssetEntry
{
XAsset asset; //OFS: 0x0 SIZE: 0x8
char zoneIndex; //OFS: 0x8 SIZE: 0x1
bool inuse; //OFS: 0x9 SIZE: 0x1
unsigned __int16 nextHash; //OFS: 0xA SIZE: 0x2
unsigned __int16 nextOverride; //OFS: 0xC SIZE: 0x2
unsigned __int16 usageFrame; //OFS: 0xE SIZE: 0x2
};
ASSERT_STRUCT_SIZE(XAssetEntry, 0x10);
ASSERT_STRUCT_OFFSET(XAssetEntry, asset, 0x0);
ASSERT_STRUCT_OFFSET(XAssetEntry, zoneIndex, 0x8);
ASSERT_STRUCT_OFFSET(XAssetEntry, inuse, 0x9);
ASSERT_STRUCT_OFFSET(XAssetEntry, nextHash, 0xA);
ASSERT_STRUCT_OFFSET(XAssetEntry, nextOverride, 0xC);
ASSERT_STRUCT_OFFSET(XAssetEntry, usageFrame, 0xE);
union XAssetEntryPoolEntry
{
XAssetEntry entry; //OFS: 0x0 SIZE: 0x10
XAssetEntryPoolEntry * next; //OFS: 0x1 SIZE: 0x4
};
struct ScriptStringList
{
int count; //OFS: 0x0 SIZE: 0x4
char ** strings; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(ScriptStringList, 0x8);
ASSERT_STRUCT_OFFSET(ScriptStringList, count, 0x0);
ASSERT_STRUCT_OFFSET(ScriptStringList, strings, 0x4);
struct XAssetList
{
ScriptStringList stringList; //OFS: 0x0 SIZE: 0x8
int assetCount; //OFS: 0x8 SIZE: 0x4
XAsset * assets; //OFS: 0xC SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XAssetList, 0x10);
ASSERT_STRUCT_OFFSET(XAssetList, stringList, 0x0);
ASSERT_STRUCT_OFFSET(XAssetList, assetCount, 0x8);
ASSERT_STRUCT_OFFSET(XAssetList, assets, 0xC);
struct XZoneInfoInternal
{
char name[64];
int flags;
};
ASSERT_STRUCT_SIZE(XZoneInfoInternal, 0x44);
ASSERT_STRUCT_OFFSET(XZoneInfoInternal, name, 0x0);
ASSERT_STRUCT_OFFSET(XZoneInfoInternal, flags, 0x40);
struct XZoneName
{
char name[64]; //OFS: 0x0 SIZE: 0x40
int flags; //OFS: 0x40 SIZE: 0x4
int fileSize; //OFS: 0x44 SIZE: 0x4
FF_DIR dir; //OFS: 0x48 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XZoneName, 0x4C);
ASSERT_STRUCT_OFFSET(XZoneName, name, 0x0);
ASSERT_STRUCT_OFFSET(XZoneName, flags, 0x40);
ASSERT_STRUCT_OFFSET(XZoneName, fileSize, 0x44);
ASSERT_STRUCT_OFFSET(XZoneName, dir, 0x48);
struct XBlock
{
char * data; //OFS: 0x0 SIZE: 0x4
unsigned int size; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(XBlock, 0x8);
ASSERT_STRUCT_OFFSET(XBlock, data, 0x0);
ASSERT_STRUCT_OFFSET(XBlock, size, 0x4);
struct XZone
{
__int16 index; //OFS: 0x0 SIZE: 0x2
int flags; //OFS: 0x4 SIZE: 0x4
int allocType; //OFS: 0x8 SIZE: 0x4
XBlock blocks[7]; //OFS: 0xC SIZE: 0x38
};
ASSERT_STRUCT_SIZE(XZone, 0x44);
ASSERT_STRUCT_OFFSET(XZone, index, 0x0);
ASSERT_STRUCT_OFFSET(XZone, flags, 0x4);
ASSERT_STRUCT_OFFSET(XZone, allocType, 0x8);
ASSERT_STRUCT_OFFSET(XZone, blocks, 0xC);
#ifdef __cplusplus
WEAK symbol<XAssetHeader(XAssetType type, const char* name, bool errorIfMissing, int waitTime)>DB_FindXAssetHeader{ 0x0, 0x48DA30 };
}
#endif
Reference in New Issue View Git Blame Copy Permalink