OpenAssetTools/src/ZoneCommon/Game/T6/T6_Assets.h

#define __int8 char
#define __int16 short
#define __int32 int
#define __int64 long long

struct dvar_t;
struct MenuCell;
struct cplane_s;
struct cbrushside_t;
struct MaterialVertexDeclaration;
struct MaterialVertexShader;
struct MaterialPixelShader;
struct MaterialShaderArgument;
struct MaterialTechnique;
struct MaterialTechniqueSet;
struct GfxImageLoadDef;
struct GfxImage;
struct MaterialTextureDef;
struct MaterialConstantDef;
struct GfxStateBits;
struct Material;
struct MenuRow;
struct Glyph;
struct KerningPairs;
struct Font_s;
struct BrushWrapper;
struct multiDef_s;
struct XModelCollTri_s;
struct PhysConstraints;
struct ScriptCondition;
struct listBoxDef_s;
struct expressionRpn;
struct GenericEventScript;
struct GenericEventHandler;
struct animParamsDef_t;
struct enumDvarDef_s;
struct PhysPreset;
struct profileMultiDef_s;
struct PhysGeomInfo;
struct XModelCollSurf_s;
struct gameMsgDef_s;
struct SndAlias;
struct SndAliasList;
struct XBoneInfo;
struct editFieldDef_s;
struct WeaponCamoMaterial;
struct PhysGeomList;
struct textExp_s;
struct ItemKeyHandler;
struct focusItemDef_s;
struct textDef_s;
struct imageDef_s;
struct ownerDrawDef_s;
struct menuDef_t;
struct rectData_s;
struct UIAnimInfo;
struct itemDef_s;
struct WeaponCamoMaterialSet;
struct Collmap;
struct TracerDef;
struct WeaponAttachment;
struct DObjAnimMat;
struct GfxPackedVertex;
struct XSurfaceCollisionNode;
struct XSurfaceCollisionLeaf;
struct XSurfaceCollisionTree;
struct XRigidVertList;
struct XSurface;
struct XModel;
struct flameTable;
struct cStaticModel_s;
struct FxElemVelStateSample;
struct FxElemVisStateSample;
struct FxElemMarkVisuals;
struct FxEffectDef;
struct GfxLightDef;
union FxElemVisuals;
struct FxTrailVertex;
struct FxTrailDef;
struct FxSpotLightDef;
struct FxElemDef;
struct WeaponCamoSet;
struct WeaponCamo;
struct WeaponDef;
struct WeaponAttachmentUnique;
struct WeaponVariantDef;
struct cLeafBrushNode_s;
struct cbrush_t;
struct ClipMaterial;
struct Bounds;
struct cLeaf_s;
struct cmodel_t;
struct CollisionAabbTree;
struct pathlink_s;
struct pathnode_t;
struct DestructiblePiece;
struct DestructibleDef;
struct GraphFloat;
struct VehicleDef;
struct XAnimNotifyInfo;
struct XAnimPartTrans;
struct XAnimDeltaPartQuat2;
struct XAnimDeltaPartQuat;
struct XAnimDeltaPart;
struct XAnimParts;
struct ZBarrierDef;
struct GfxLight;
struct ddlHash_t;
struct ddlEnumDef_t;
struct SndVolumeGroup;
struct XModelPiece;
struct XModelPieces;
struct DynEntityDef;
struct CollisionPartition;
struct ddlMemberDef_t;
struct ddlStructDef_t;
struct ddlDef_t;
struct GlassDef;
struct Glass;
struct GfxAabbTree;
struct FxImpactEntry;
struct StringTableCell;
struct ddlRoot_t;
struct StringTable;
struct FxImpactTable;
struct SndIndexEntry;
struct SndRadverb;
struct SndDuck;
struct SndAssetBankEntry;
struct SndDialogScriptIdLookup;
struct SndBank;
struct SndPatch;
struct cNode_t;
struct TriggerModel;
struct TriggerHull;
struct TriggerSlab;
struct MapEnts;
struct DynEntityPose;
struct DynEntityClient;
struct DynEntityServer;
struct DynEntityColl;
struct rope_t;
struct clipMap_t;
struct ComPrimaryLight;
struct ComWorld;
struct pathbasenode_t;
struct pathnode_tree_t;
struct GameWorldSp;
struct GameWorldMp;
struct GfxStreamingAabbTree;
struct GfxLightCorona;
struct GfxShadowMapVolume;
struct GfxVolumePlane;
struct GfxExposureVolume;
struct GfxWorldFogVolume;
struct GfxWorldFogModifierVolume;
struct GfxLutVolume;
struct GfxPortal;
struct GfxCell;
struct GfxReflectionProbeVolumeData;
struct GfxReflectionProbe;
struct GfxLightmapArray;
struct GfxLightGridEntry;
struct GfxCompressedLightGridColors;
struct GfxCompressedLightGridCoeffs;
struct GfxSkyGridVolume;
struct GfxBrushModel;
struct MaterialMemory;
struct GfxSceneDynModel;
struct GfxSceneDynBrush;
struct SSkinShaders;
struct SSkinVert;
struct SSkinModel;
struct SSkinAnim;
struct SSkinInstance;
struct GfxShadowGeometry;
struct GfxLightRegionAxis;
struct GfxLightRegionHull;
struct GfxLightRegion;
struct GfxStaticModelInst;
struct GfxSurface;
struct GfxStaticModelDrawInst;
struct Occluder;
struct GfxOutdoorBounds;
struct GfxHeroLight;
struct GfxHeroLightTree;
struct GfxWorld;
struct FontIconEntry;
struct FontIconAlias;
struct FontIcon;
struct MenuList;
struct LocalizeEntry;
struct SndCurve;
struct SndPan;
struct SndDuckGroup;
struct SndContext;
struct SndMaster;
struct SndSidechainDuck;
struct SndFutz;
struct SndDriverGlobals;
struct RawFile;
struct LbColumnDef;
struct LeaderboardDef;
struct XGlobals;
struct Glasses;
struct EmblemSet;
struct ScriptParseTree;
struct KeyValuePair;
struct KeyValuePairs;
struct MemoryBlock;
struct AddonMapEnts;
struct SkinnedVertsDef;
struct Qdb;
struct Slug;
struct FootstepTableDef;
struct FootstepFXTableDef;

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

union XAssetHeader
{
  //XModelPieces *xmodelPieces; // Not an asset
  PhysPreset *physPreset;
  PhysConstraints *physConstraints;
  DestructibleDef *destructibleDef;
  XAnimParts *parts;
  XModel *model;
  Material *material;
  //MaterialPixelShader *pixelShader; // Not an asset
  //MaterialVertexShader *vertexShader; // Not an asset
  MaterialTechniqueSet *techniqueSet;
  GfxImage *image;
  SndBank *sound;
  SndPatch *soundPatch;
  clipMap_t *clipMap;
  ComWorld *comWorld;
  GameWorldSp *gameWorldSp;
  GameWorldMp *gameWorldMp;
  MapEnts *mapEnts;
  GfxWorld *gfxWorld;
  GfxLightDef *lightDef;
  Font_s *font;
  FontIcon *fontIcon;
  MenuList *menuList;
  menuDef_t *menu;
  LocalizeEntry *localize;
  WeaponVariantDef *weapon;
  WeaponAttachment *attachment;
  WeaponAttachmentUnique *attachmentUnique;
  WeaponCamo *weaponCamo;
  SndDriverGlobals *sndDriverGlobals;
  FxEffectDef *fx;
  FxImpactTable *impactFx;
  RawFile *rawfile;
  StringTable *stringTable;
  LeaderboardDef *leaderboardDef;
  XGlobals *xGlobals;
  ddlRoot_t *ddlRoot;
  Glasses *glasses;
  //TextureList *textureList; // Does not exist in this game
  EmblemSet *emblemSet;
  ScriptParseTree *scriptParseTree;
  KeyValuePairs *keyValuePairs;
  VehicleDef *vehicleDef;
  MemoryBlock *memoryBlock;
  AddonMapEnts *addonMapEnts;
  TracerDef *tracerDef;
  SkinnedVertsDef *skinnedVertsDef;
  Qdb *qdb;
  Slug *slug;
  FootstepTableDef *footstepTableDef;
  FootstepFXTableDef *footstepFXTableDef;
  ZBarrierDef *zbarrierDef;
  void *data;
};

struct XModelPieces
{
  const char *name;
  int numpieces;
  XModelPiece *pieces;
};

union vec3_t
{
  struct
  {
    float x;
    float y;
    float z;
  };
  float v[3];
};

struct PhysPreset
{
  const char *name;
  int flags;
  float mass;
  float bounce;
  float friction;
  float bulletForceScale;
  float explosiveForceScale;
  const char *sndAliasPrefix;
  float piecesSpreadFraction;
  float piecesUpwardVelocity;
  int canFloat;
  float gravityScale;
  vec3_t centerOfMassOffset;
  vec3_t buoyancyBoxMin;
  vec3_t buoyancyBoxMax;
};

enum ConstraintType
{
  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,
  CONSTRAINT_LIGHT = 0x9,
  NUM_CONSTRAINT_TYPES = 0xA,
};

enum AttachPointType
{
  ATTACH_POINT_WORLD = 0x0,
  ATTACH_POINT_DYNENT = 0x1,
  ATTACH_POINT_ENT = 0x2,
  ATTACH_POINT_BONE = 0x3,
};

struct PhysConstraint
{
  unsigned __int16 targetname;
  ConstraintType type;
  AttachPointType attach_point_type1;
  int target_index1;
  unsigned __int16 target_ent1;
  const char *target_bone1;
  AttachPointType attach_point_type2;
  int target_index2;
  unsigned __int16 target_ent2;
  const char *target_bone2;
  vec3_t offset;
  vec3_t pos;
  vec3_t pos2;
  vec3_t dir;
  int flags;
  int timeout;
  int min_health;
  int max_health;
  float distance;
  float damp;
  float power;
  vec3_t scale;
  float spin_scale;
  float minAngle;
  float maxAngle;
  Material *material;
  int constraintHandle;
  int rope_index;
  int centity_num[4];
};

struct PhysConstraints
{
  const char *name;
  unsigned int count;
  PhysConstraint data[16];
};

struct DestructibleDef
{
  const char *name;
  XModel *model;
  XModel *pristineModel;
  int numPieces;
  DestructiblePiece *pieces;
  int clientOnly;
};

union XAnimIndices
{
  char *_1;
  unsigned __int16 *_2;
  void *data;
};

struct XAnimParts
{
  const char *name;
  unsigned __int16 dataByteCount;
  unsigned __int16 dataShortCount;
  unsigned __int16 dataIntCount;
  unsigned __int16 randomDataByteCount;
  unsigned __int16 randomDataIntCount;
  unsigned __int16 numframes;
  bool bLoop;
  bool bDelta;
  bool bDelta3D;
  bool bLeftHandGripIK;
  unsigned int streamedFileSize;
  char boneCount[10];
  char notifyCount;
  char assetType;
  bool isDefault;
  unsigned int randomDataShortCount;
  unsigned int indexCount;
  float framerate;
  float frequency;
  float primedLength;
  float loopEntryTime;
  unsigned __int16 *names;
  char *dataByte;
  __int16 *dataShort;
  int *dataInt;
  __int16 *randomDataShort;
  char *randomDataByte;
  int *randomDataInt;
  XAnimIndices indices;
  XAnimNotifyInfo *notify;
  XAnimDeltaPart *deltaPart;
};

struct XModelLodInfo
{
  float dist;
  unsigned __int16 numsurfs;
  unsigned __int16 surfIndex;
  int partBits[5];
};

struct XModel
{
  const char *name;
  char numBones;
  char numRootBones;
  char numsurfs;
  char lodRampType;
  unsigned __int16 *boneNames;
  char *parentList;
  __int16 (*quats)[4];
  float (*trans)[4];
  char *partClassification;
  DObjAnimMat *baseMat;
  XSurface *surfs;
  Material **materialHandles;
  XModelLodInfo lodInfo[4];
  XModelCollSurf_s *collSurfs;
  int numCollSurfs;
  int contents;
  XBoneInfo *boneInfo;
  float radius;
  vec3_t mins;
  vec3_t maxs;
  __int16 numLods;
  __int16 collLod;
  float *himipInvSqRadii;
  int memUsage;
  int flags;
  bool bad;
  PhysPreset *physPreset;
  char numCollmaps;
  Collmap *collmaps;
  PhysConstraints *physConstraints;
  vec3_t lightingOriginOffset;
  float lightingOriginRange;
};

struct GfxDrawSurfFields
{
  unsigned __int64 objectId : 16;
  unsigned __int64 customIndex : 9;
  unsigned __int64 reflectionProbeIndex : 5;
  unsigned __int64 dlightMask : 2;
  unsigned __int64 materialSortedIndex : 12;
  unsigned __int64 primaryLightIndex : 8;
  unsigned __int64 surfType : 4;
  unsigned __int64 prepass : 2;
  unsigned __int64 primarySortKey : 6;
};

union GfxDrawSurf
{
  GfxDrawSurfFields fields;
  unsigned __int64 packed;
};

struct __declspec(align(8)) MaterialInfo
{
  const char *name;
  unsigned int gameFlags;
  char pad;
  char sortKey;
  char textureAtlasRowCount;
  char textureAtlasColumnCount;
  GfxDrawSurf drawSurf;
  unsigned int surfaceTypeBits;
  unsigned int layeredSurfaceTypes;
  unsigned __int16 hashIndex;
  int surfaceFlags;
  int contents;
};

struct Material
{
  MaterialInfo info;
  char stateBitsEntry[36];
  char textureCount;
  char constantCount;
  char stateBitsCount;
  char stateFlags;
  char cameraRegion;
  char probeMipBits;
  MaterialTechniqueSet *techniqueSet;
  MaterialTextureDef *textureTable;
  MaterialConstantDef *constantTable;
  GfxStateBits *stateBitsTable;
  Material *thermalMaterial;
};

struct GfxPixelShaderLoadDef
{
  char *program;
  unsigned int programSize;
};

struct MaterialPixelShaderProgram
{
  ID3D11PixelShader *ps;
  GfxPixelShaderLoadDef loadDef;
};

struct MaterialPixelShader
{
  const char *name;
  MaterialPixelShaderProgram prog;
};

struct GfxVertexShaderLoadDef
{
  char *program;
  unsigned int programSize;
};

struct MaterialVertexShaderProgram
{
  ID3D11VertexShader *vs;
  GfxVertexShaderLoadDef loadDef;
};

struct MaterialVertexShader
{
  const char *name;
  MaterialVertexShaderProgram prog;
};

struct MaterialTechniqueSet
{
  const char *name;
  char worldVertFormat;
  MaterialTechnique *techniques[36];
};

union GfxTexture
{
  ID3D11ShaderResourceView *basemap;
  GfxImageLoadDef *loadDef;
};

struct Picmip
{
  char platform[2];
};

struct CardMemory
{
  int platform[2];
};

struct GfxStreamedPartInfo
{
  unsigned int levelCountAndSize;
  unsigned int hash;
  unsigned __int16 width;
  unsigned __int16 height;
  unsigned __int32 offset : 32;
  unsigned __int32 size : 28;
  unsigned __int32 ipakIndex : 4;
  unsigned __int32 adjacentLeft : 15;
  unsigned __int32 adjacentRight : 15;
  unsigned __int32 compressed : 1;
  unsigned __int32 valid : 1;
};

struct GfxImage
{
  GfxTexture texture;
  char mapType;
  char semantic;
  char category;
  bool delayLoadPixels;
  Picmip picmip;
  bool noPicmip;
  char track;
  CardMemory cardMemory;
  unsigned __int16 width;
  unsigned __int16 height;
  unsigned __int16 depth;
  char levelCount;
  char streaming;
  unsigned int baseSize;
  char *pixels;
  GfxStreamedPartInfo streamedParts[1];
  char streamedPartCount;
  unsigned int loadedSize;
  char skippedMipLevels;
  const char *name;
  unsigned int hash;
};

struct SndAssetBankHeader
{
  unsigned int magic;
  unsigned int version;
  unsigned int entrySize;
  unsigned int checksumSize;
  unsigned int dependencySize;
  unsigned int entryCount;
  unsigned int dependencyCount;
  unsigned int pad32;
  __int64 fileSize;
  __int64 entryOffset;
  __int64 checksumOffset;
  char checksumChecksum[16];
  char dependencies[512];
  char padding[1464];
};

#pragma pack(push, 1)
struct __declspec(align(2)) SndRuntimeAssetBank
{
  const char *zone;
  const char *language;
  int fileHandle;
  SndAssetBankHeader header;
  unsigned int entryOffset;
  char linkTimeChecksum[16];
  char filename[256];
  bool indicesLoaded;
  bool indicesAllocated;
};
#pragma pack(pop)

struct SndLoadedAssets
{
  const char *zone;
  const char *language;
  unsigned int loadedCount;
  unsigned int entryCount;
  SndAssetBankEntry *entries;
  unsigned int dataSize;
  char *data;
};

enum SndBankState
{
  SND_BANK_STATE_NEW = 0x0,
  SND_BANK_STATE_STREAM_HEADER = 0x1,
  SND_BANK_STATE_STREAM_TOC = 0x2,
  SND_BANK_STATE_LOADED_HEADER = 0x3,
  SND_BANK_STATE_LOADED_TOC = 0x4,
  SND_BANK_STATE_LOADED_ASSET_WAIT = 0x5,
  SND_BANK_STATE_LOADED_ASSETS = 0x6,
  SND_BANK_STATE_READY_TO_USE = 0x7,
  SND_BANK_STATE_ERROR = 0x8,
};

struct SndBank
{
  const char *name;
  unsigned int aliasCount;
  SndAliasList *alias;
  SndIndexEntry *aliasIndex;
  unsigned int radverbCount;
  SndRadverb *radverbs;
  unsigned int duckCount;
  SndDuck *ducks;
  SndRuntimeAssetBank streamAssetBank;
  SndRuntimeAssetBank loadAssetBank;
  SndLoadedAssets loadedAssets;
  unsigned int scriptIdLookupCount;
  SndDialogScriptIdLookup *scriptIdLookups;
  SndBankState state;
  int streamRequestId;
  bool pendingIo;
  bool ioError;
  bool runtimeAssetLoad;
};

struct SndPatch
{
  char *name;
  unsigned int elementCount;
  unsigned int *elements;
};

struct ClipInfo
{
  int planeCount;
  cplane_s *planes;
  unsigned int numMaterials;
  ClipMaterial *materials;
  unsigned int numBrushSides;
  cbrushside_t *brushsides;
  unsigned int leafbrushNodesCount;
  cLeafBrushNode_s *leafbrushNodes;
  unsigned int numLeafBrushes;
  unsigned __int16 *leafbrushes;
  unsigned int numBrushVerts;
  vec3_t *brushVerts;
  unsigned int nuinds;
  unsigned __int16 *uinds;
  unsigned __int16 numBrushes;
  cbrush_t *brushes;
  Bounds *brushBounds;
  int *brushContents;
};

struct __declspec(align(4)) cLeaf_s
{
  unsigned __int16 firstCollAabbIndex;
  unsigned __int16 collAabbCount;
  int brushContents;
  int terrainContents;
  vec3_t mins;
  vec3_t maxs;
  int leafBrushNode;
  __int16 cluster;
};

struct cmodel_t
{
  vec3_t mins;
  vec3_t maxs;
  float radius;
  ClipInfo *info;
  cLeaf_s leaf;
};

struct clipMap_t
{
  const char *name;
  int isInUse;
  ClipInfo info;
  ClipInfo *pInfo;
  unsigned int numStaticModels;
  cStaticModel_s *staticModelList;
  unsigned int numNodes;
  cNode_t *nodes;
  unsigned int numLeafs;
  cLeaf_s *leafs;
  unsigned int vertCount;
  vec3_t *verts;
  int triCount;
  unsigned __int16 *triIndices;
  char *triEdgeIsWalkable;
  int partitionCount;
  CollisionPartition *partitions;
  int aabbTreeCount;
  CollisionAabbTree *aabbTrees;
  unsigned int numSubModels;
  cmodel_t *cmodels;
  int numClusters;
  int clusterBytes;
  char *visibility;
  int vised;
  MapEnts *mapEnts;
  cbrush_t *box_brush;
  cmodel_t box_model;
  unsigned __int16 originalDynEntCount;
  unsigned __int16 dynEntCount[4];
  DynEntityDef *dynEntDefList[2];
  DynEntityPose *dynEntPoseList[2];
  DynEntityClient *dynEntClientList[2];
  DynEntityServer *dynEntServerList[2];
  DynEntityColl *dynEntCollList[4];
  int num_constraints;
  PhysConstraint *constraints;
  int max_ropes;
  rope_t *ropes;
  unsigned int checksum;
};

struct ComWorld
{
  const char *name;
  int isInUse;
  unsigned int primaryLightCount;
  ComPrimaryLight *primaryLights;
};

struct PathData
{
  unsigned int nodeCount;
  unsigned int originalNodeCount;
  pathnode_t *nodes;
  pathbasenode_t *basenodes;
  int visBytes;
  char *pathVis;
  int smoothBytes;
  char *smoothCache;
  int nodeTreeCount;
  pathnode_tree_t *nodeTree;
};

struct GameWorldSp
{
  const char *name;
  PathData path;
};

struct GameWorldMp
{
  const char *name;
  PathData path;
};

struct MapTriggers
{
  unsigned int count;
  TriggerModel *models;
  unsigned int hullCount;
  TriggerHull *hulls;
  unsigned int slabCount;
  TriggerSlab *slabs;
};

struct MapEnts
{
  const char *name;
  char *entityString;
  int numEntityChars;
  MapTriggers trigger;
};

struct GfxWorldStreamInfo
{
  int aabbTreeCount;
  GfxStreamingAabbTree *aabbTrees;
  int leafRefCount;
  int *leafRefs;
};

union vec4_t
{
  float v[4];
  struct
  {
    float x;
    float y;
    float z;
    float w;
  };
  struct
  {
    float r;
    float g;
    float b;
    float a;
  };
};

struct GfxWorldSun
{
  unsigned int control;
  vec3_t angles;
  vec4_t ambientColor;
  vec4_t sunCd;
  vec4_t sunCs;
  vec4_t skyColor;
  float exposure;
};

struct GfxWorldFog
{
  float baseDist;
  float halfDist;
  float baseHeight;
  float halfHeight;
  float sunFogPitch;
  float sunFogYaw;
  float sunFogInner;
  float sunFogOuter;
  vec3_t fogColor;
  float fogOpacity;
  vec3_t sunFogColor;
  float sunFogOpacity;
};

struct SunLightParseParams
{
  char name[64];
  GfxWorldSun initWorldSun[1];
  float fogTransitionTime;
  GfxWorldFog initWorldFog[1];
};

struct GfxSkyDynamicIntensity
{
  float angle0;
  float angle1;
  float factor0;
  float factor1;
};

struct GfxWorldDpvsPlanes
{
  int cellCount;
  cplane_s *planes;
  unsigned __int16 *nodes;
  unsigned int *sceneEntCellBits;
};

struct GfxWorldVertexData0
{
  char *data;
  ID3D11Buffer *vb;
};

struct GfxWorldVertexData1
{
  char *data;
  ID3D11Buffer *vb;
};

struct GfxWorldDraw
{
  unsigned int reflectionProbeCount;
  GfxReflectionProbe *reflectionProbes;
  GfxTexture *reflectionProbeTextures;
  int lightmapCount;
  GfxLightmapArray *lightmaps;
  GfxTexture *lightmapPrimaryTextures;
  GfxTexture *lightmapSecondaryTextures;
  unsigned int vertexCount;
  unsigned int vertexDataSize0;
  GfxWorldVertexData0 vd0;
  unsigned int vertexDataSize1;
  GfxWorldVertexData1 vd1;
  int indexCount;
  unsigned __int16 *indices;
  ID3D11Buffer *indexBuffer;
};

struct GfxLightGrid
{
  unsigned int sunPrimaryLightIndex;
  unsigned __int16 mins[3];
  unsigned __int16 maxs[3];
  float offset;
  unsigned int rowAxis;
  unsigned int colAxis;
  unsigned __int16 *rowDataStart;
  unsigned int rawRowDataSize;
  char *rawRowData;
  unsigned int entryCount;
  GfxLightGridEntry *entries;
  unsigned int colorCount;
  GfxCompressedLightGridColors *colors;
  unsigned int coeffCount;
  GfxCompressedLightGridCoeffs *coeffs;
  unsigned int skyGridVolumeCount;
  GfxSkyGridVolume *skyGridVolumes;
};

struct sunflare_t
{
  bool hasValidData;
  Material *spriteMaterial;
  Material *flareMaterial;
  float spriteSize;
  float flareMinSize;
  float flareMinDot;
  float flareMaxSize;
  float flareMaxDot;
  float flareMaxAlpha;
  int flareFadeInTime;
  int flareFadeOutTime;
  float blindMinDot;
  float blindMaxDot;
  float blindMaxDarken;
  int blindFadeInTime;
  int blindFadeOutTime;
  float glareMinDot;
  float glareMaxDot;
  float glareMaxLighten;
  int glareFadeInTime;
  int glareFadeOutTime;
  vec3_t sunFxPosition;
};

struct GfxWorldDpvsStatic
{
  unsigned int smodelCount;
  unsigned int staticSurfaceCount;
  unsigned int litSurfsBegin;
  unsigned int litSurfsEnd;
  unsigned int litTransSurfsBegin;
  unsigned int litTransSurfsEnd;
  unsigned int emissiveOpaqueSurfsBegin;
  unsigned int emissiveOpaqueSurfsEnd;
  unsigned int emissiveTransSurfsBegin;
  unsigned int emissiveTransSurfsEnd;
  unsigned int smodelVisDataCount;
  unsigned int surfaceVisDataCount;
  char *smodelVisData[3];
  char *surfaceVisData[3];
  char *smodelVisDataCameraSaved;
  char *surfaceVisDataCameraSaved;
  unsigned __int16 *sortedSurfIndex;
  GfxStaticModelInst *smodelInsts;
  GfxSurface *surfaces;
  GfxStaticModelDrawInst *smodelDrawInsts;
  GfxDrawSurf *surfaceMaterials;
  char *surfaceCastsSunShadow;
  char *surfaceCastsShadow;
  char *smodelCastsShadow;
  volatile int usageCount;
};

struct GfxWorldDpvsDynamic
{
  unsigned int dynEntClientWordCount[2];
  unsigned int dynEntClientCount[2];
  unsigned int *dynEntCellBits[2];
  char *dynEntVisData[2][3];
  volatile int usageCount;
};

struct GfxWaterBuffer
{
  unsigned int bufferSize;
  vec4_t *buffer;
};

struct GfxWorld
{
  const char *name;
  const char *baseName;
  int planeCount;
  int nodeCount;
  int surfaceCount;
  GfxWorldStreamInfo streamInfo;
  const char *skyBoxModel;
  SunLightParseParams sunParse;
  GfxLight *sunLight;
  unsigned int sunPrimaryLightIndex;
  unsigned int primaryLightCount;
  unsigned int coronaCount;
  GfxLightCorona *coronas;
  unsigned int shadowMapVolumeCount;
  GfxShadowMapVolume *shadowMapVolumes;
  unsigned int shadowMapVolumePlaneCount;
  GfxVolumePlane *shadowMapVolumePlanes;
  unsigned int exposureVolumeCount;
  GfxExposureVolume *exposureVolumes;
  unsigned int exposureVolumePlaneCount;
  GfxVolumePlane *exposureVolumePlanes;
  unsigned int worldFogVolumeCount;
  GfxWorldFogVolume *worldFogVolumes;
  unsigned int worldFogVolumePlaneCount;
  GfxVolumePlane *worldFogVolumePlanes;
  unsigned int worldFogModifierVolumeCount;
  GfxWorldFogModifierVolume *worldFogModifierVolumes;
  unsigned int worldFogModifierVolumePlaneCount;
  GfxVolumePlane *worldFogModifierVolumePlanes;
  unsigned int lutVolumeCount;
  GfxLutVolume *lutVolumes;
  unsigned int lutVolumePlaneCount;
  GfxVolumePlane *lutVolumePlanes;
  GfxSkyDynamicIntensity skyDynIntensity;
  GfxWorldDpvsPlanes dpvsPlanes;
  int cellBitsCount;
  GfxCell *cells;
  GfxWorldDraw draw;
  GfxLightGrid lightGrid;
  int modelCount;
  GfxBrushModel *models;
  vec3_t mins;
  vec3_t maxs;
  unsigned int checksum;
  int materialMemoryCount;
  MaterialMemory *materialMemory;
  sunflare_t sun;
  vec4_t outdoorLookupMatrix[4];
  GfxImage *outdoorImage;
  unsigned int *cellCasterBits;
  GfxSceneDynModel *sceneDynModel;
  GfxSceneDynBrush *sceneDynBrush;
  unsigned int *primaryLightEntityShadowVis;
  unsigned int *primaryLightDynEntShadowVis[2];
  unsigned int numSiegeSkinInsts;
  SSkinInstance *siegeSkinInsts;
  GfxShadowGeometry *shadowGeom;
  GfxLightRegion *lightRegion;
  GfxWorldDpvsStatic dpvs;
  GfxWorldDpvsDynamic dpvsDyn;
  float waterDirection;
  GfxWaterBuffer waterBuffers[2];
  Material *waterMaterial;
  Material *coronaMaterial;
  Material *ropeMaterial;
  Material *lutMaterial;
  unsigned int numOccluders;
  Occluder *occluders;
  unsigned int numOutdoorBounds;
  GfxOutdoorBounds *outdoorBounds;
  unsigned int heroLightCount;
  unsigned int heroLightTreeCount;
  GfxHeroLight *heroLights;
  GfxHeroLightTree *heroLightTree;
  unsigned int lightingFlags;
  int lightingQuality;
};

struct __declspec(align(4)) GfxLightImage
{
  GfxImage *image;
  char samplerState;
};

struct GfxLightDef
{
  const char *name;
  GfxLightImage attenuation;
  int lmapLookupStart;
};

struct Font_s
{
  const char *fontName;
  int pixelHeight;
  int isScalingAllowed;
  int glyphCount;
  int kerningPairsCount;
  Material *material;
  Material *glowMaterial;
  Glyph *glyphs;
  KerningPairs *kerningPairs;
};

struct FontIcon
{
  const char *name;
  int numEntries;
  int numAliasEntries;
  FontIconEntry *fontIconEntry;
  FontIconAlias *fontIconAlias;
};

struct MenuList
{
  const char *name;
  int menuCount;
  menuDef_t **menus;
};

struct rectDef_s
{
  float x;
  float y;
  float w;
  float h;
  int horzAlign;
  int vertAlign;
};

struct windowDef_t
{
  const char *name;
  rectDef_s rect;
  rectDef_s rectClient;
  const char *group;
  char style;
  char border;
  char modal;
  char frameSides;
  float frameTexSize;
  float frameSize;
  int ownerDraw;
  int ownerDrawFlags;
  float borderSize;
  int staticFlags;
  int dynamicFlags[1];
  int nextTime;
  vec4_t foreColor;
  vec4_t backColor;
  vec4_t borderColor;
  vec4_t outlineColor;
  float rotation;
  Material *background;
};

struct ExpressionStatement
{
  char *filename;
  int line;
  int numRpn;
  expressionRpn *rpn;
};

struct __declspec(align(8)) menuDef_t
{
  windowDef_t window;
  const char *font;
  int fullScreen;
  int ui3dWindowId;
  int itemCount;
  int fontIndex;
  int cursorItem[1];
  int fadeCycle;
  int priority;
  float fadeClamp;
  float fadeAmount;
  float fadeInAmount;
  float blurRadius;
  int openSlideSpeed;
  int closeSlideSpeed;
  int openSlideDirection;
  int closeSlideDirection;
  rectDef_s initialRectInfo;
  int openFadingTime;
  int closeFadingTime;
  int fadeTimeCounter;
  int slideTimeCounter;
  GenericEventHandler *onEvent;
  ItemKeyHandler *onKey;
  ExpressionStatement visibleExp;
  unsigned __int64 showBits;
  unsigned __int64 hideBits;
  const char *allowedBinding;
  const char *soundName;
  int imageTrack;
  int control;
  vec4_t focusColor;
  vec4_t disableColor;
  ExpressionStatement rectXExp;
  ExpressionStatement rectYExp;
  itemDef_s **items;
};

struct LocalizeEntry
{
  const char *value;
  const char *name;
};

enum weaponIconRatioType_t
{
  WEAPON_ICON_RATIO_1TO1 = 0x0,
  WEAPON_ICON_RATIO_2TO1 = 0x1,
  WEAPON_ICON_RATIO_4TO1 = 0x2,
  WEAPON_ICON_RATIO_COUNT = 0x3,
};

struct WeaponVariantDef
{
  const char *szInternalName;
  int iVariantCount;
  WeaponDef *weapDef;
  const char *szDisplayName;
  const char *szAltWeaponName;
  const char *szAttachmentUnique;
  WeaponAttachment **attachments;
  WeaponAttachmentUnique **attachmentUniques;
  const char **szXAnims;
  unsigned __int16 *hideTags;
  XModel **attachViewModel;
  XModel **attachWorldModel;
  const char **attachViewModelTag;
  const char **attachWorldModelTag;
  float attachViewModelOffsets[24];
  float attachWorldModelOffsets[24];
  float attachViewModelRotations[24];
  float attachWorldModelRotations[24];
  vec3_t stowedModelOffsets;
  vec3_t stowedModelRotations;
  unsigned int altWeaponIndex;
  int iAttachments;
  bool bIgnoreAttachments;
  int iClipSize;
  int iReloadTime;
  int iReloadEmptyTime;
  int iReloadQuickTime;
  int iReloadQuickEmptyTime;
  int iAdsTransInTime;
  int iAdsTransOutTime;
  int iAltRaiseTime;
  const char *szAmmoDisplayName;
  const char *szAmmoName;
  int iAmmoIndex;
  const char *szClipName;
  int iClipIndex;
  float fAimAssistRangeAds;
  float fAdsSwayHorizScale;
  float fAdsSwayVertScale;
  float fAdsViewKickCenterSpeed;
  float fHipViewKickCenterSpeed;
  float fAdsZoomFov1;
  float fAdsZoomFov2;
  float fAdsZoomFov3;
  float fAdsZoomInFrac;
  float fAdsZoomOutFrac;
  float fOverlayAlphaScale;
  float fOOPosAnimLength[2];
  bool bSilenced;
  bool bDualMag;
  bool bInfraRed;
  bool bTVGuided;
  unsigned int perks[2];
  bool bAntiQuickScope;
  Material *overlayMaterial;
  Material *overlayMaterialLowRes;
  Material *dpadIcon;
  weaponIconRatioType_t dpadIconRatio;
  bool noAmmoOnDpadIcon;
  bool mmsWeapon;
  bool mmsInScope;
  float mmsFOV;
  float mmsAspect;
  float mmsMaxDist;
  vec3_t ikLeftHandIdlePos;
  vec3_t ikLeftHandOffset;
  vec3_t ikLeftHandRotation;
  bool bUsingLeftHandProneIK;
  vec3_t ikLeftHandProneOffset;
  vec3_t ikLeftHandProneRotation;
  vec3_t ikLeftHandUiViewerOffset;
  vec3_t ikLeftHandUiViewerRotation;
};

enum eAttachment
{
  ATTACHMENT_NONE = 0x0,
  ATTACHMENT_ACOG = 0x1,
  ATTACHMENT_DUALCLIP = 0x2,
  ATTACHMENT_DUALOPTIC = 0x3,
  ATTACHMENT_DW = 0x4,
  ATTACHMENT_EXTBARREL = 0x5,
  ATTACHMENT_EXTCLIP = 0x6,
  ATTACHMENT_EXTRAMAGS = 0x7,
  ATTACHMENT_FASTADS = 0x8,
  ATTACHMENT_FASTRELOAD = 0x9,
  ATTACHMENT_FMJ = 0xA,
  ATTACHMENT_GL = 0xB,
  ATTACHMENT_GRIP = 0xC,
  ATTACHMENT_HOLO = 0xD,
  ATTACHMENT_IR = 0xE,
  ATTACHMENT_IRONSIGHTS = 0xF,
  ATTACHMENT_LONGBREATH = 0x10,
  ATTACHMENT_MK = 0x11,
  ATTACHMENT_MMS = 0x12,
  ATTACHMENT_RANGEFINDER = 0x13,
  ATTACHMENT_REFLEX = 0x14,
  ATTACHMENT_RF = 0x15,
  ATTACHMENT_SELECTFIRE = 0x16,
  ATTACHMENT_SILENCER = 0x17,
  ATTACHMENT_STACKFIRE = 0x18,
  ATTACHMENT_STALKER = 0x19,
  ATTACHMENT_STEADYAIM = 0x1A,
  ATTACHMENT_SWAYREDUC = 0x1B,
  ATTACHMENT_TACKNIFE = 0x1C,
  ATTACHMENT_VZOOM = 0x1D,
  ATTACHMENT_TYPE_COUNT = 0x1E,
  ATTACHMENT_INVALID = 0x1E,
};

enum eAttachmentPoint
{
  ATTACHMENT_POINT_NONE = 0x0,
  ATTACHMENT_POINT_TOP = 0x1,
  ATTACHMENT_POINT_FIRST = 0x1,
  ATTACHMENT_POINT_BOTTOM = 0x2,
  ATTACHMENT_POINT_TRIGGER = 0x3,
  ATTACHMENT_POINT_MUZZLE = 0x4,
  ATTACHMENT_POINT_GUNPERK = 0x5,
  ATTACHMENT_POINT_COUNT = 0x6,
  ATTACHMENT_POINT_INVALID = 0x6,
};

enum PenetrateType
{
  PENETRATE_TYPE_NONE = 0x0,
  PENETRATE_TYPE_SMALL = 0x1,
  PENETRATE_TYPE_MEDIUM = 0x2,
  PENETRATE_TYPE_LARGE = 0x3,
  PENETRATE_TYPE_COUNT = 0x4,
};

enum weapFireType_t
{
  WEAPON_FIRETYPE_FULLAUTO = 0x0,
  WEAPON_FIRETYPE_SINGLESHOT = 0x1,
  WEAPON_FIRETYPE_BURSTFIRE2 = 0x2,
  WEAPON_FIRETYPE_BURSTFIRE3 = 0x3,
  WEAPON_FIRETYPE_BURSTFIRE4 = 0x4,
  WEAPON_FIRETYPE_BURSTFIRE5 = 0x5,
  WEAPON_FIRETYPE_STACKED = 0x6,
  WEAPON_FIRETYPE_MINIGUN = 0x7,
  WEAPON_FIRETYPE_CHARGESHOT = 0x8,
  WEAPON_FIRETYPE_JETGUN = 0x9,
  WEAPON_FIRETYPECOUNT = 0xA,
};

struct WeaponAttachment
{
  const char *szInternalName;
  const char *szDisplayName;
  eAttachment attachmentType;
  eAttachmentPoint attachmentPoint;
  PenetrateType penetrateType;
  weapFireType_t fireType;
  int firstRaisePriority;
  float fHipIdleAmount;
  bool bAltWeaponAdsOnly;
  bool bAltWeaponDisableSwitching;
  float altScopeADSTransInTime;
  float altScopeADSTransOutTime;
  bool bSilenced;
  bool bDualMag;
  bool laserSight;
  bool bInfraRed;
  bool bUseAsMelee;
  bool bDualWield;
  bool sharedAmmo;
  float fDamageRangeScale;
  float fAdsZoomFov1;
  float fAdsZoomFov2;
  float fAdsZoomFov3;
  float fAdsZoomInFrac;
  float fAdsZoomOutFrac;
  float fAdsTransInTimeScale;
  float fAdsTransOutTimeScale;
  float fAdsRecoilReductionRate;
  float fAdsRecoilReductionLimit;
  float fAdsViewKickCenterSpeedScale;
  float fAdsIdleAmountScale;
  bool swayOverride;
  float swayMaxAngle;
  float swayLerpSpeed;
  float swayPitchScale;
  float swayYawScale;
  float swayHorizScale;
  float swayVertScale;
  bool adsSwayOverride;
  float adsSwayMaxAngle;
  float adsSwayLerpSpeed;
  float adsSwayPitchScale;
  float adsSwayYawScale;
  float fAdsSwayHorizScale;
  float fAdsSwayVertScale;
  float adsMoveSpeedScale;
  float fHipSpreadMinScale;
  float fHipSpreadMaxScale;
  float strafeRotR;
  float standMoveF;
  vec3_t vStandRot;
  float fFireTimeScale;
  float fReloadTimeScale;
  float fReloadEmptyTimeScale;
  float fReloadAddTimeScale;
  float fReloadQuickTimeScale;
  float fReloadQuickEmptyTimeScale;
  float fReloadQuickAddTimeScale;
  bool mmsWeapon;
  bool mmsInScope;
  float mmsFOV;
  float mmsAspect;
  float mmsMaxDist;
  float clipSizeScale;
  int iClipSize;
  unsigned int stackFire;
  float stackFireSpread;
  float stackFireAccuracyDecay;
  unsigned int perks[2];
  float customFloat0;
  float customFloat1;
  float customFloat2;
  int customBool0;
  int customBool1;
  int customBool2;
};

enum weapOverlayReticle_t
{
  WEAPOVERLAYRETICLE_NONE = 0x0,
  WEAPOVERLAYRETICLE_CROSSHAIR = 0x1,
  WEAPOVERLAYRETICLE_NUM = 0x2,
};

struct WeaponAttachmentUnique
{
  const char *szInternalName;
  eAttachment attachmentType;
  int siblingLink;
  int childLink;
  int combinedAttachmentTypeMask;
  const char *szAltWeaponName;
  unsigned int altWeaponIndex;
  const char *szDualWieldWeaponName;
  unsigned int dualWieldWeaponIndex;
  unsigned __int16 *hideTags;
  XModel *viewModel;
  XModel *viewModelAdditional;
  XModel *viewModelADS;
  XModel *worldModel;
  XModel *worldModelAdditional;
  const char *viewModelTag;
  const char *worldModelTag;
  vec3_t viewModelOffsets;
  vec3_t worldModelOffsets;
  vec3_t viewModelRotations;
  vec3_t worldModelRotations;
  vec3_t viewModelAddOffsets;
  vec3_t worldModelAddOffsets;
  vec3_t viewModelAddRotations;
  vec3_t worldModelAddRotations;
  WeaponCamo *weaponCamo;
  bool disableBaseWeaponAttachment;
  bool disableBaseWeaponClip;
  bool overrideBaseWeaponAttachmentOffsets;
  vec3_t viewModelOffsetBaseAttachment;
  vec3_t worldModelOffsetBaseAttachment;
  Material *overlayMaterial;
  Material *overlayMaterialLowRes;
  weapOverlayReticle_t overlayReticle;
  int iFirstRaiseTime;
  int iAltRaiseTime;
  int iAltDropTime;
  int iReloadAmmoAdd;
  int iReloadStartAdd;
  bool bSegmentedReload;
  const char **szXAnims;
  int animationOverrides[3];
  float *locationDamageMultipliers;
  int soundOverrides;
  const char *fireSound;
  const char *fireSoundPlayer;
  const char *fireLoopSound;
  const char *fireLoopSoundPlayer;
  const char *fireLoopEndSound;
  const char *fireLoopEndSoundPlayer;
  const char *fireStartSound;
  const char *fireStopSound;
  const char *fireStartSoundPlayer;
  const char *fireStopSoundPlayer;
  const char *fireLastSound;
  const char *fireLastSoundPlayer;
  const char *fireKillcamSound;
  const char *fireKillcamSoundPlayer;
  int effectOverrides;
  FxEffectDef *viewFlashEffect;
  FxEffectDef *worldFlashEffect;
  TracerDef *tracerType;
  TracerDef *enemyTracerType;
  float adsDofStart;
  float adsDofEnd;
  int iAmmoIndex;
  int iClipIndex;
  bool bOverrideLeftHandIK;
  bool bOverrideLeftHandProneIK;
  vec3_t ikLeftHandOffset;
  vec3_t ikLeftHandRotation;
  vec3_t ikLeftHandProneOffset;
  vec3_t ikLeftHandProneRotation;
  float customFloat0;
  float customFloat1;
  float customFloat2;
  int customBool0;
  int customBool1;
  int customBool2;
};

struct WeaponCamo
{
  const char *name;
  GfxImage *solidBaseImage;
  GfxImage *patternBaseImage;
  WeaponCamoSet *camoSets;
  unsigned int numCamoSets;
  WeaponCamoMaterialSet *camoMaterials;
  unsigned int numCamoMaterials;
};

struct SndDriverGlobals
{
  const char *name;
  unsigned int groupCount;
  SndVolumeGroup *groups;
  unsigned int curveCount;
  SndCurve *curves;
  unsigned int panCount;
  SndPan *pans;
  unsigned int duckGroupCount;
  SndDuckGroup *duckGroups;
  unsigned int contextCount;
  SndContext *contexts;
  unsigned int masterCount;
  SndMaster *masters;
  unsigned int voiceDuckCount;
  SndSidechainDuck *voiceDucks;
  unsigned int futzCount;
  SndFutz *futzes;
};

struct FxFloatRange
{
  float base;
  float amplitude;
};

const struct FxEffectDef
{
  const char *name;
  unsigned __int16 flags;
  char efPriority;
  __int16 elemDefCountLooping;
  __int16 elemDefCountOneShot;
  __int16 elemDefCountEmission;
  int totalSize;
  int msecLoopingLife;
  int msecNonLoopingLife;
  FxElemDef *elemDefs;
  vec3_t boundingBoxDim;
  vec3_t boundingBoxCentre;
  float occlusionQueryDepthBias;
  int occlusionQueryFadeIn;
  int occlusionQueryFadeOut;
  FxFloatRange occlusionQueryScaleRange;
};

struct FxImpactTable
{
  const char *name;
  FxImpactEntry *table;
};

struct RawFile
{
  const char *name;
  int len;
  const char *buffer;
};

struct StringTable
{
  const char *name;
  int columnCount;
  int rowCount;
  StringTableCell *values;
  __int16 *cellIndex;
};

enum LbUpdateType
{
  LBUPDATE_TYPE_NORMAL = 0x0,
  LBUPDATE_TYPE_RANK = 0x1,
  LBUPDATE_TYPE_COMBINE = 0x2,
  LBUPDATE_TYPE_COUNT = 0x3,
};

struct LeaderboardDef
{
  const char *name;
  unsigned int id;
  int columnCount;
  int dwColumnCount;
  int xpColId;
  int prestigeColId;
  LbColumnDef *columns;
  LbUpdateType updateType;
  int trackTypes;
};

struct gump_info_t
{
  char *name;
  int size;
};

struct overlay_info_t
{
  char *name;
  int size;
};

struct XGlobals
{
  const char *name;
  int xanimStreamBufferSize;
  int cinematicMaxWidth;
  int cinematicMaxHeight;
  int extracamResolution;
  vec4_t screenClearColor;
  int bigestGumpSize;
  int gumpsCount;
  gump_info_t gumps[32];
  int bigestOverlaySize;
  int overlayCount;
  overlay_info_t overlays[32];
};

struct ddlRoot_t
{
  const char *name;
  ddlDef_t *ddlDef;
};

struct Glasses
{
  const char *name;
  unsigned int numGlasses;
  Glass *glasses;
  char *workMemory;
  unsigned int workMemorySize;
  unsigned int smallAllocatorBlocks;
  unsigned int maxGroups;
  unsigned int maxShards;
  unsigned int maxPhysics;
  unsigned int shardMemorySize;
  unsigned int maxFreeCmd;
  unsigned int numSlots;
  unsigned int numVerts;
  unsigned int numIndices;
};

struct EmblemLayer
{
  int cost;
  int unlockLevel;
  int unlockPLevel;
};

struct EmblemCategory
{
  const char *name;
  const char *description;
};

struct EmblemIconType
{
  const char *name;
  const char *description;
};

struct EmblemBGCategory
{
  const char *name;
  const char *description;
};

struct EmblemIcon
{
  GfxImage *image;
  const char *description;
  float outlineSize;
  int cost;
  int unlockLevel;
  int unlockPLevel;
  int unclassifyAt;
  int sortKey;
  unsigned __int16 iconType;
  unsigned __int16 category;
};

struct EmblemBackground
{
  Material *material;
  const char *description;
  int cost;
  int unlockLevel;
  int unlockPLevel;
  int unclassifyAt;
  int sortKey;
  unsigned __int16 bgCategory;
  int mtxIndex;
};

struct EmblemSet
{
  int colorCount;
  int layerCount;
  EmblemLayer layers[32];
  int categoryCount;
  EmblemCategory categories[16];
  int iconTypeCount;
  EmblemIconType iconTypes[16];
  int bgCategoryCount;
  EmblemBGCategory bgCategories[16];
  int iconCount;
  EmblemIcon icons[1024];
  int backgroundCount;
  EmblemBackground backgrounds[550];
  int backgroundLookupCount;
  __int16 backgroundLookup[550];
};

struct ScriptParseTree
{
  const char *name;
  int len;
  char *buffer;
};

struct KeyValuePairs
{
  const char *name;
  int numVariables;
  KeyValuePair *keyValuePairs;
};

struct view_limits_t
{
  float horizSpanLeft;
  float horizSpanRight;
  float vertSpanUp;
  float vertSpanDown;
  float horizResistLeft;
  float horizResistRight;
  float vertResistUp;
  float vertResistDown;
};

union vec2_t
{
  float v[2];
  struct
  {
    float x;
    float y;
  };
};

enum TractionType
{
  TRACTION_TYPE_FRONT = 0x0,
  TRACTION_TYPE_BACK = 0x1,
  TRACTION_TYPE_ALL_WD = 0x2,
  NUM_TRACTION_TYPES = 0x3,
};

struct VehicleParameter
{
  float m_speed_max;
  float m_accel_max;
  float m_reverse_scale;
  float m_steer_angle_max;
  float m_steer_angle_speed_scale;
  float m_steer_speed;
  float m_wheel_radius;
  float m_susp_spring_k;
  float m_susp_damp_k;
  float m_susp_adj;
  float m_susp_hard_limit;
  float m_susp_min_height;
  float m_tire_fric_fwd;
  float m_tire_fric_side;
  float m_tire_fric_brake;
  float m_tire_fric_hand_brake;
  float m_body_mass;
  float m_roll_stability;
  float m_pitch_stability;
  float m_pitch_roll_resistance;
  float m_yaw_resistance;
  float m_upright_strength;
  float m_tilt_fakey;
  float m_peel_out_max_speed;
  float m_tire_damp_coast;
  float m_tire_damp_brake;
  float m_tire_damp_hand;
  float m_auto_hand_brake_min_speed;
  TractionType m_traction_type;
  const char *m_name;
  vec3_t m_bbox_min;
  vec3_t m_bbox_max;
  vec3_t m_mass_center_offset;
  vec3_t m_buoyancybox_min;
  vec3_t m_buoyancybox_max;
  float m_water_speed_max;
  float m_water_accel_max;
  float m_water_turn_accel;
  float m_water_turn_speed_max;
  float m_water_ebrake_power;
  vec3_t m_boat_motor_offset;
  float m_boat_speed_rise;
  float m_boat_speed_tilt;
  float m_boat_side_fric_scale;
  float m_boat_forward_fric_scale;
  float m_boat_vertical_fric_scale;
  float m_jump_force;
  float m_tire_fric_side_max;
  bool m_drive_on_walls;
  float m_linear_drag_scale;
  float m_angular_drag_scale;
};

struct VehicleDriveBySound
{
  int apex;
  const char *name;
  unsigned int alias;
};

struct VehicleEngineSound
{
  const char *name;
  unsigned int alias;
  float params[5];
};

struct VehicleGearData
{
  float minRPM;
  float maxRPM;
  float ratio;
};

struct VehicleEngine
{
  float idleRpms;
  float maxRpms;
  float maxTorque;
  float brakingCoeff;
  vec4_t loadFadeParams;
  float loadScale;
  float loadSmoothing;
  float throttleLag;
  float pitchScale;
  VehicleEngineSound onload[5];
  VehicleEngineSound offload[5];
  int numGears;
  int loopLastGear;
  VehicleGearData gears[10];
};

struct VehicleAntenna
{
  float springK;
  float damp;
  float length;
  float gravity;
};

const struct VehicleDef
{
  const char *name;
  __int16 type;
  int remoteControl;
  int bulletDamage;
  int armorPiercingDamage;
  int grenadeDamage;
  int projectileDamage;
  int projectileSplashDamage;
  int heavyExplosiveDamage;
  __int16 cameraMode;
  int autoRecenterOnAccel;
  int thirdPersonDriver;
  int thirdPersonUseVehicleRoll;
  int thirdPersonCameraPitchVehicleRelative;
  int thirdPersonCameraHeightWorldRelative;
  float thirdPersonCameraRange;
  float thirdPersonCameraMinPitchClamp;
  float thirdPersonCameraMaxPitchClamp;
  float thirdPersonCameraHeight[2];
  float thirdPersonCameraPitch[2];
  int cameraAlwaysAutoCenter;
  float cameraAutoCenterLerpRate;
  float cameraAutoCenterMaxLerpRate;
  float thirdPersonCameraSpringDistance;
  float thirdPersonCameraSpringTime;
  float thirdPersonCameraHandbrakeTurnRateInc;
  float cameraFOV;
  float cameraRollFraction;
  vec3_t tagPlayerOffset;
  int killcamCollision;
  float killcamDist;
  float killcamZDist;
  float killcamMinDist;
  float killcamZTargetOffset;
  float killcamFOV;
  float killcamNearBlur;
  float killcamNearBlurStart;
  float killcamNearBlurEnd;
  float killcamFarBlur;
  float killcamFarBlurStart;
  float killcamFarBlurEnd;
  int isDrivable;
  int numberOfSeats;
  int numberOfGunners;
  int seatSwitchOrder[11];
  int driverControlledGunPos;
  float entryPointRadius[5];
  float texScrollScale;
  float wheelRotRate;
  float extraWheelRotScale;
  int wheelChildTakesSteerYaw;
  float maxSpeed;
  float maxSpeedVertical;
  float accel;
  float accelVertical;
  float rotRate;
  float rotAccel;
  float maxBodyPitch;
  float maxBodyRoll;
  float collisionDamage;
  float collisionSpeed;
  float suspensionTravel;
  float heliCollisionScalar;
  float viewPitchOffset;
  float viewInfluence;
  float tiltFromAcceleration[2];
  float tiltFromDeceleration[2];
  float tiltFromVelocity[2];
  float tiltSpeed[2];
  const char *turretWeapon;
  view_limits_t turretViewLimits;
  float turretRotRate;
  int turretClampPlayerView;
  int turretLockTurretToPlayerView;
  const char *gunnerWeapon[4];
  unsigned __int16 gunnerWeaponIndex[4];
  float gunnerRotRate;
  vec2_t gunnerRestAngles[4];
  view_limits_t passengerViewLimits[6];
  const char *sndNames[2];
  unsigned int sndIndices[2];
  const char *sndMaterialNames[3];
  float skidSpeedMin;
  float skidSpeedMax;
  const char *futzName;
  float futzBlend;
  int animType;
  const char *animSet;
  int scriptedAnimationEntry;
  float mantleAngles[4];
  unsigned __int16 extraWheelTags[4];
  unsigned __int16 driverHideTag;
  XModel *attachmentModels[4];
  unsigned __int16 attachmentTags[4];
  XModel *deathAttachmentModels[4];
  unsigned __int16 deathAttachmentTags[4];
  float tracerOffset[2];
  XModel *model;
  XModel *viewModel;
  XModel *deathModel;
  XModel *enemyModel;
  float modelSwapDelay;
  FxEffectDef *exhaustFx;
  int oneExhaust;
  FxEffectDef *treadFx[32];
  FxEffectDef *deathFx;
  unsigned __int16 deathFxTag;
  const char *deathFxSound;
  FxEffectDef *lightFx[4];
  unsigned __int16 lightFxTag[4];
  FxEffectDef *friendlyLightFx;
  unsigned __int16 friendlyLightFxTag;
  FxEffectDef *enemyLightFx;
  unsigned __int16 enemyLightFxTag;
  float radiusDamageMin;
  float radiusDamageMax;
  float radiusDamageRadius;
  const char *shootShock;
  const char *shootRumble;
  float deathQuakeScale;
  float deathQuakeDuration;
  float deathQuakeRadius;
  const char *rumbleType;
  float rumbleScale;
  float rumbleDuration;
  float rumbleRadius;
  float rumbleBaseTime;
  float rumbleAdditionalTime;
  int healthDefault;
  int healthMin;
  int healthMax;
  int eTeam;
  int boostAccelMultiplier;
  float boostDuration;
  float boostSpeedIncrease;
  int addToCompass;
  int addToCompassEnemy;
  const char *compassIcon;
  Material *compassIconMaterial;
  const char *gasButtonName;
  int gasButton;
  const char *reverseBrakeButtonName;
  int reverseBrakeButton;
  const char *handBrakeButtonName;
  int handBrakeButton;
  const char *attackButtonName;
  int attackButton;
  const char *attackSecondaryButtonName;
  int attackSecondaryButton;
  const char *boostButtonName;
  int boostButton;
  const char *moveUpButtonName;
  int moveUpButton;
  const char *moveDownButtonName;
  int moveDownButton;
  const char *switchSeatButtonName;
  int switchSeatButton;
  const char *steerGraphName;
  GraphFloat *steerGraph;
  const char *accelGraphName;
  GraphFloat *accelGraph;
  int isNitrous;
  int isFourWheelSteering;
  int useCollmap;
  float radius;
  float minHeight;
  float maxHeight;
  float max_fric_tilt_angle;
  float max_fric_tilt;
  int noDirectionalDamage;
  int fakeBodyStabilizer;
  float vehHelicopterBoundsRadius;
  float vehHelicopterDecelerationFwd;
  float vehHelicopterDecelerationSide;
  float vehHelicopterDecelerationUp;
  float vehHelicopterTiltFromControllerAxes;
  float vehHelicopterTiltFromFwdAndYaw;
  float vehHelicopterTiltFromFwdAndYaw_VelAtMaxTilt;
  float vehHelicopterTiltMomentum;
  int vehHelicopterQuadRotor;
  int vehHelicopterAccelTwardsView;
  float maxRotorArmMovementAngle;
  float maxRotorArmRotationAngle;
  int vehHelicopterMaintainHeight;
  int vehHelicopterMaintainMaxHeight;
  float vehHelicopterMaintainHeightLimit;
  float vehHelicopterMaintainHeightAccel;
  float vehHelicopterMaintainHeightMinimum;
  float vehHelicopterMaintainHeightMaximum;
  float vehHelicopterMaintainCeilingMinimum;
  int joltVehicle;
  int joltVehicleDriver;
  float joltMaxTime;
  float joltTime;
  float joltWaves;
  float joltIntensity;
  VehicleParameter nitrousVehParams;
  float driveBySoundRadius[2];
  VehicleDriveBySound driveBySounds[40];
  int doFootSteps;
  int isSentient;
  VehicleEngine engine;
  VehicleAntenna antenna[2];
  char *csvInclude;
  float customFloat0;
  float customFloat1;
  float customFloat2;
  int customBool0;
  int customBool1;
  int customBool2;
};

struct MemoryBlock
{
  const char *name;
  bool mainMem;
  bool videoMem;
  bool streamMem;
  unsigned int size;
  unsigned int alignment;
  char *data;
};

struct AddonMapEnts
{
  const char *name;
  char *entityString;
  int numEntityChars;
  MapTriggers trigger;
  ClipInfo *info;
  unsigned int numSubModels;
  cmodel_t *cmodels;
  GfxBrushModel *models;
};

enum tracerType_t
{
  TRACERTYPE_LASER = 0x0,
  TRACERTYPE_SMOKE = 0x1,
  TRACERTYPE_NUM = 0x2,
};

struct TracerDef
{
  const char *name;
  tracerType_t type;
  Material *material;
  unsigned int drawInterval;
  float speed;
  float beamLength;
  float beamWidth;
  float screwRadius;
  float screwDist;
  float fadeTime;
  float fadeScale;
  float texRepeatRate;
  vec4_t colors[5];
};

struct SkinnedVertsDef
{
  const char *name;
  unsigned int maxSkinnedVerts;
};

struct Qdb
{
  const char *name;
  int len;
  char *buffer;
};

struct Slug
{
  const char *name;
  int len;
  char *buffer;
};

struct FootstepTableDef
{
  const char *name;
  unsigned int sndAliasTable[32][7];
};

struct FootstepFXTableDef
{
  const char *name;
  FxEffectDef *footstepFX[32];
};

struct ZBarrierBoard
{
  XModel *pBoardModel;
  XModel *pAlternateBoardModel;
  XModel *pUpgradedBoardModel;
  const char *pTearAnim;
  const char *pBoardAnim;
  FxEffectDef *repairEffect1;
  FxEffectDef *repairEffect2;
  vec3_t repairEffect1Offset;
  vec3_t repairEffect2Offset;
  unsigned int boardRepairSound;
  unsigned int boardRepairHoverSound;
  unsigned int pauseAndRepeatRepSound;
  float minPause;
  float maxPause;
  unsigned __int16 zombieBoardTearStateName;
  unsigned __int16 zombieBoardTearSubStateName;
  unsigned int numRepsToPullProBoard;
};

struct ZBarrierDef
{
  const char *name;
  unsigned int generalRepairSound1;
  unsigned int generalRepairSound2;
  unsigned int upgradedGeneralRepairSound1;
  unsigned int upgradedGeneralRepairSound2;
  unsigned int delayBetweenRepSounds;
  float delayBetweenRepSoundsDuration;
  unsigned int earthquakeOnRepair;
  float earthquakeMinScale;
  float earthquakeMaxScale;
  float earthquakeMinDuration;
  float earthquakeMaxDuration;
  float earthquakeRadius;
  int numBoardsInBarrier;
  unsigned int autoHideOpenPieces;
  unsigned int taunts;
  unsigned int reachThroughAttacks;
  unsigned __int16 zombieTauntAnimState;
  unsigned __int16 zombieReachThroughAnimState;
  int numAttackSlots;
  float attackSpotHorzOffset;
  ZBarrierBoard boards[6];
};

struct XModelPiece
{
  XModel *model;
  vec3_t offset;
};

struct DestructibleStage
{
  unsigned __int16 showBone;
  float breakHealth;
  float maxTime;
  unsigned int flags;
  FxEffectDef *breakEffect;
  const char *breakSound;
  const char *breakNotify;
  const char *loopSound;
  XModel *spawnModel[3];
  PhysPreset *physPreset;
};

struct DestructiblePiece
{
  DestructibleStage stages[5];
  char parentPiece;
  float parentDamagePercent;
  float bulletDamageScale;
  float explosiveDamageScale;
  float meleeDamageScale;
  float impactDamageScale;
  float entityDamageTransfer;
  PhysConstraints *physConstraints;
  int health;
  const char *damageSound;
  FxEffectDef *burnEffect;
  const char *burnSound;
  unsigned __int16 enableLabel;
  int hideBones[5];
};

struct XAnimNotifyInfo
{
  unsigned __int16 name;
  float time;
};

struct XAnimDeltaPart
{
  XAnimPartTrans *trans;
  XAnimDeltaPartQuat2 *quat2;
  XAnimDeltaPartQuat *quat;
};

struct DObjAnimMat
{
  vec4_t quat;
  vec3_t trans;
  float transWeight;
};

struct XSurfaceVertexInfo
{
  __int16 vertCount[4];
  unsigned __int16 *vertsBlend;
  float *tensionData;
};

struct __declspec(align(16)) XSurface
{
  char tileMode;
  char vertListCount;
  unsigned __int16 flags;
  unsigned __int16 vertCount;
  unsigned __int16 triCount;
  unsigned __int16 baseVertIndex;
  unsigned __int16 (*triIndices)[3];
  XSurfaceVertexInfo vertInfo;
  GfxPackedVertex *verts0;
  ID3D11Buffer *vb0;
  XRigidVertList *vertList;
  ID3D11Buffer *indexBuffer;
  int partBits[5];
};

struct XModelCollSurf_s
{
  XModelCollTri_s *collTris;
  int numCollTris;
  vec3_t mins;
  vec3_t maxs;
  int boneIdx;
  int contents;
  int surfFlags;
};

struct __declspec(align(4)) XBoneInfo
{
  vec3_t bounds[2];
  vec3_t offset;
  float radiusSquared;
  char collmap;
};

struct Collmap
{
  PhysGeomList *geomList;
};

struct MaterialTextureDef
{
  unsigned int nameHash;
  char nameStart;
  char nameEnd;
  char samplerState;
  char semantic;
  char isMatureContent;
  char pad[3];
  GfxImage *image;
};

struct MaterialConstantDef
{
  unsigned int nameHash;
  char name[12];
  vec4_t literal;
};

struct GfxStateBits
{
  unsigned int loadBits[2];
  ID3D11BlendState *blendState;
  ID3D11DepthStencilState *depthStencilState;
  ID3D11RasterizerState *rasterizerState;
};

/*struct IUnknown
{
  IUnknownVtbl *vfptr;
};*/

/*struct __cppobj ID3D11DeviceChild : IUnknown
{
};*/

/*struct __cppobj ID3D11PixelShader : ID3D11DeviceChild
{
};*/

/*struct __cppobj ID3D11VertexShader : ID3D11DeviceChild
{
};*/

struct MaterialPass
{
  MaterialVertexDeclaration *vertexDecl;
  MaterialVertexShader *vertexShader;
  MaterialPixelShader *pixelShader;
  char perPrimArgCount;
  char perObjArgCount;
  char stableArgCount;
  char customSamplerFlags;
  char precompiledIndex;
  char materialType;
  MaterialShaderArgument *args;
};

struct MaterialTechnique
{
  const char *name;
  unsigned __int16 flags;
  unsigned __int16 passCount;
  MaterialPass passArray[1];
};

/*struct __cppobj ID3D11View : ID3D11DeviceChild
{
};*/

/*struct __cppobj ID3D11ShaderResourceView : ID3D11View
{
};*/

struct __declspec(align(4)) GfxImageLoadDef
{
  char levelCount;
  char flags;
  int format;
  int resourceSize;
  char data[1];
};

struct SndAliasList
{
  const char *name;
  unsigned int id;
  SndAlias *head;
  int count;
  int sequence;
};

struct SndIndexEntry
{
  unsigned __int16 value;
  unsigned __int16 next;
};

struct SndRadverb
{
  char name[32];
  unsigned int id;
  float smoothing;
  float earlyTime;
  float lateTime;
  float earlyGain;
  float lateGain;
  float returnGain;
  float earlyLpf;
  float lateLpf;
  float inputLpf;
  float dampLpf;
  float wallReflect;
  float dryGain;
  float earlySize;
  float lateSize;
  float diffusion;
  float returnHighpass;
};

struct SndDuck
{
  char name[32];
  unsigned int id;
  float fadeIn;
  float fadeOut;
  float startDelay;
  float distance;
  float length;
  unsigned int fadeInCurve;
  unsigned int fadeOutCurve;
  float *attenuation;
  float *filter;
  int updateWhilePaused;
};

struct SndAssetBankEntry
{
  unsigned int id;
  unsigned int size;
  unsigned int offset;
  unsigned int frameCount;
  char frameRateIndex;
  char channelCount;
  char looping;
  char format;
};

struct SndDialogScriptIdLookup
{
  unsigned int scriptId;
  unsigned int aliasId;
};

struct cplane_s
{
  vec3_t normal;
  float dist;
  char type;
  char signbits;
  char pad[2];
};

struct ClipMaterial
{
  const char *name;
  int surfaceFlags;
  int contentFlags;
};

struct cbrushside_t
{
  cplane_s *plane;
  int cflags;
  int sflags;
};

struct cLeafBrushNodeLeaf_t
{
  unsigned __int16 *brushes;
};

struct cLeafBrushNodeChildren_t
{
  float dist;
  float range;
  unsigned __int16 childOffset[2];
};

union cLeafBrushNodeData_t
{
  cLeafBrushNodeLeaf_t leaf;
  cLeafBrushNodeChildren_t children;
};

struct cLeafBrushNode_s
{
  char axis;
  __int16 leafBrushCount;
  int contents;
  cLeafBrushNodeData_t data;
};

struct __declspec(align(8)) cbrush_t
{
  vec3_t mins;
  int contents;
  vec3_t maxs;
  unsigned int numsides;
  cbrushside_t *sides;
  int axial_cflags[2][3];
  int axial_sflags[2][3];
  unsigned int numverts;
  vec3_t *verts;
};

struct Bounds
{
  vec3_t midPoint;
  vec3_t halfSize;
};

struct cStaticModelWritable
{
  unsigned __int16 nextModelInWorldSector;
};

struct cStaticModel_s
{
  cStaticModelWritable writable;
  XModel *xmodel;
  int contents;
  vec3_t origin;
  vec3_t invScaledAxis[3];
  vec3_t absmin;
  vec3_t absmax;
};

struct cNode_t
{
  cplane_s *plane;
  __int16 children[2];
};

const struct CollisionPartition
{
  char triCount;
  int firstTri;
  int nuinds;
  int fuind;
};

union CollisionAabbTreeIndex
{
  int firstChildIndex;
  int partitionIndex;
};

struct CollisionAabbTree
{
  vec3_t origin;
  unsigned __int16 materialIndex;
  unsigned __int16 childCount;
  vec3_t halfSize;
  CollisionAabbTreeIndex u;
};

enum DynEntityType
{
  DYNENT_TYPE_INVALID = 0x0,
  DYNENT_TYPE_CLUTTER = 0x1,
  DYNENT_TYPE_DESTRUCT = 0x2,
  DYNENT_TYPE_COUNT = 0x3,
};

struct GfxPlacement
{
  vec4_t quat;
  vec3_t origin;
};

struct DynEntityDef
{
  DynEntityType type;
  GfxPlacement pose;
  XModel *xModel;
  XModel *destroyedxModel;
  unsigned __int16 brushModel;
  unsigned __int16 physicsBrushModel;
  FxEffectDef *destroyFx;
  unsigned int destroySound;
  XModelPieces *destroyPieces;
  PhysPreset *physPreset;
  __int16 physConstraints[4];
  int health;
  int flags;
  int contents;
  unsigned __int16 targetname;
  unsigned __int16 target;
};

struct DynEntityPose
{
  GfxPlacement pose;
  float radius;
};

struct DynEntityClient
{
  int physObjId;
  unsigned __int16 flags;
  unsigned __int16 lightingHandle;
  int health;
  unsigned __int16 burnTime;
  unsigned __int16 fadeTime;
  int physicsStartTime;
};

struct DynEntityServer
{
  unsigned __int16 flags;
  int health;
};

struct DynEntityColl
{
  unsigned __int16 sector;
  unsigned __int16 nextEntInSector;
  vec3_t linkMins;
  vec3_t linkMaxs;
  int contents;
};

struct par_t
{
  vec3_t p;
  vec3_t p0;
  vec3_t p_prev;
  int flags;
};

enum rope_constraint_e
{
  ROPE_PAIR_CONSTRAINT = 0x0,
  ROPE_WORLD_CONSTRAINT = 0x1,
  ROPE_DENTITY_CONSTRAINT = 0x2,
  ROPE_CENTITY_CONSTRAINT = 0x3,
};

struct __declspec(align(4)) constraint_t
{
  vec3_t p;
  rope_constraint_e type;
  int entity_index;
  int bone_name_hash;
  char pi1;
  char pi2;
};

struct rope_frame_verts_t
{
  int num_verts;
  vec3_t v[50];
};

struct rope_client_verts_t
{
  rope_frame_verts_t frame_verts[2];
  unsigned int frame_index;
};

struct __declspec(align(4)) rope_t
{
  par_t m_particles[25];
  constraint_t m_constraints[30];
  int m_entity_anchors[3];
  int m_num_particles;
  int m_num_constraints;
  int m_num_entity_anchors;
  int m_num_draw_verts;
  rope_client_verts_t m_client_verts;
  vec3_t m_min;
  vec3_t m_max;
  vec3_t m_start;
  vec3_t m_end;
  int m_in_use;
  int m_visible;
  int m_dist_constraint;
  int m_flags;
  Material *m_material;
  float m_seglen;
  float m_length;
  float m_width;
  float m_scale;
  float m_force_scale;
  int m_health;
  int m_frame;
  int m_stable_count;
  int m_static_rope;
  unsigned __int16 m_lightingHandle;
};

struct ComPrimaryLight
{
  char type;
  char canUseShadowMap;
  char exponent;
  char priority;
  __int16 cullDist;
  char useCookie;
  char shadowmapVolume;
  vec3_t color;
  vec3_t dir;
  vec3_t origin;
  float radius;
  float cosHalfFovOuter;
  float cosHalfFovInner;
  float cosHalfFovExpanded;
  float rotationLimit;
  float translationLimit;
  float mipDistance;
  float dAttenuation;
  float roundness;
  vec4_t diffuseColor;
  vec4_t falloff;
  vec4_t angle;
  vec4_t aAbB;
  vec4_t cookieControl0;
  vec4_t cookieControl1;
  vec4_t cookieControl2;
  const char *defName;
};

enum nodeType
{
  NODE_BADNODE = 0x0,
  NODE_PATHNODE = 0x1,
  NODE_COVER_STAND = 0x2,
  NODE_COVER_CROUCH = 0x3,
  NODE_COVER_CROUCH_WINDOW = 0x4,
  NODE_COVER_PRONE = 0x5,
  NODE_COVER_RIGHT = 0x6,
  NODE_COVER_LEFT = 0x7,
  NODE_COVER_PILLAR = 0x8,
  NODE_AMBUSH = 0x9,
  NODE_EXPOSED = 0xA,
  NODE_CONCEALMENT_STAND = 0xB,
  NODE_CONCEALMENT_CROUCH = 0xC,
  NODE_CONCEALMENT_PRONE = 0xD,
  NODE_REACQUIRE = 0xE,
  NODE_BALCONY = 0xF,
  NODE_SCRIPTED = 0x10,
  NODE_NEGOTIATION_BEGIN = 0x11,
  NODE_NEGOTIATION_END = 0x12,
  NODE_TURRET = 0x13,
  NODE_GUARD = 0x14,
  NODE_NUMTYPES = 0x15,
  NODE_DONTLINK = 0x15,
};

struct pathnode_constant_t
{
  nodeType type;
  int spawnflags;
  unsigned __int16 targetname;
  unsigned __int16 script_linkName;
  unsigned __int16 script_noteworthy;
  unsigned __int16 target;
  unsigned __int16 animscript;
  int animscriptfunc;
  vec3_t vOrigin;
  float fAngle;
  vec2_t forward;
  float fRadius;
  float minUseDistSq;
  __int16 wOverlapNode[2];
  unsigned __int16 totalLinkCount;
  pathlink_s *Links;
};

struct SentientHandle
{
  unsigned __int16 number;
  unsigned __int16 infoIndex;
};

struct __declspec(align(4)) pathnode_dynamic_t
{
  SentientHandle pOwner;
  int iFreeTime;
  int iValidTime[3];
  int dangerousNodeTime[3];
  int inPlayerLOSTime;
  __int16 wLinkCount;
  __int16 wOverlapCount;
  __int16 turretEntNumber;
  __int16 userCount;
  bool hasBadPlaceLink;
};

struct pathnode_transient_t
{
  int iSearchFrame;
  pathnode_t *pNextOpen;
  pathnode_t *pPrevOpen;
  pathnode_t *pParent;
  float fCost;
  float fHeuristic;
  union
  {  
    float nodeCost;
    int linkIndex;
  };
};

struct pathnode_t
{
  pathnode_constant_t constant;
  pathnode_dynamic_t dynamic;
  pathnode_transient_t transient;
};

struct pathbasenode_t
{
  vec3_t vOrigin;
  unsigned int type;
};

struct pathnode_tree_nodes_t
{
  int nodeCount;
  unsigned __int16 *nodes;
};

union pathnode_tree_info_t
{
  pathnode_tree_t *child[2];
  pathnode_tree_nodes_t s;
};

struct pathnode_tree_t
{
  int axis;
  float dist;
  pathnode_tree_info_t u;
};

struct TriggerModel
{
  int contents;
  unsigned __int16 hullCount;
  unsigned __int16 firstHull;
};

struct TriggerHull
{
  Bounds bounds;
  int contents;
  unsigned __int16 slabCount;
  unsigned __int16 firstSlab;
};

struct TriggerSlab
{
  vec3_t dir;
  float midPoint;
  float halfSize;
};

struct GfxStreamingAabbTree
{
  vec4_t mins;
  vec4_t maxs;
  float maxStreamingDistance;
  unsigned __int16 firstItem;
  unsigned __int16 itemCount;
  unsigned __int16 firstChild;
  unsigned __int16 childCount;
  unsigned __int16 smodelCount;
  unsigned __int16 surfaceCount;
};

struct float44
{
  union
  {  
    vec4_t m[4];
    float member[16];
  };
};

struct GfxLight
{
  char type;
  char canUseShadowMap;
  char shadowmapVolume;
  __int16 cullDist;
  vec3_t color;
  vec3_t dir;
  vec3_t origin;
  float radius;
  float cosHalfFovOuter;
  float cosHalfFovInner;
  int exponent;
  unsigned int spotShadowIndex;
  float dAttenuation;
  float roundness;
  vec3_t angles;
  float spotShadowHiDistance;
  vec4_t diffuseColor;
  vec4_t shadowColor;
  vec4_t falloff;
  vec4_t aAbB;
  vec4_t cookieControl0;
  vec4_t cookieControl1;
  vec4_t cookieControl2;
  /*__declspec(align(16))*/ float44 viewMatrix;
  float44 projMatrix;
  GfxLightDef *def;
};

struct GfxLightCorona
{
  vec3_t origin;
  float radius;
  vec3_t color;
  float intensity;
};

struct GfxShadowMapVolume
{
  unsigned int control;
  unsigned int padding1;
  unsigned int padding2;
  unsigned int padding3;
};

struct GfxVolumePlane
{
  vec4_t plane;
};

struct GfxExposureVolume
{
  unsigned int control;
  float exposure;
  float luminanceIncreaseScale;
  float luminanceDecreaseScale;
  float featherRange;
  float featherAdjust;
};

struct GfxWorldFogVolume
{
  vec3_t mins;
  unsigned int control;
  vec3_t maxs;
  float fogTransitionTime;
  unsigned int controlEx;
  GfxWorldFog volumeWorldFog[1];
};

struct GfxWorldFogModifierVolume
{
  unsigned int control;
  unsigned __int16 minX;
  unsigned __int16 minY;
  unsigned __int16 minZ;
  unsigned __int16 maxX;
  unsigned __int16 maxY;
  unsigned __int16 maxZ;
  unsigned int controlEx;
  float transitionTime;
  float depthScale;
  float heightScale;
  vec4_t colorAdjust;
};

struct GfxLutVolume
{
  vec3_t mins;
  unsigned int control;
  vec3_t maxs;
  float lutTransitionTime;
  unsigned int lutIndex;
};

struct GfxCell
{
  vec3_t mins;
  vec3_t maxs;
  int aabbTreeCount;
  GfxAabbTree *aabbTree;
  int portalCount;
  GfxPortal *portals;
  char reflectionProbeCount;
  char *reflectionProbes;
};

struct GfxLightingSH
{
  vec4_t V0;
  vec4_t V1;
  vec4_t V2;
};

struct GfxReflectionProbe
{
  vec3_t origin;
  GfxLightingSH lightingSH;
  GfxImage *reflectionImage;
  GfxReflectionProbeVolumeData *probeVolumes;
  unsigned int probeVolumeCount;
  float mipLodBias;
};

struct GfxLightmapArray
{
  GfxImage *primary;
  GfxImage *secondary;
};

/*struct __cppobj ID3D11Resource : ID3D11DeviceChild
{
};*/

/*struct __cppobj ID3D11Buffer : ID3D11Resource
{
};*/

struct GfxLightGridEntry
{
  unsigned __int16 colorsIndex;
  char primaryLightIndex;
  char visibility;
};

struct GfxCompressedLightGridColors
{
  char rgb[56][3];
};

struct GfxCompressedLightGridCoeffs
{
  unsigned __int16 coeffs[9][3];
};

struct GfxSkyGridVolume
{
  vec3_t mins;
  vec3_t maxs;
  vec3_t lightingOrigin;
  unsigned __int16 colorsIndex;
  char primaryLightIndex;
  char visibility;
};

struct GfxBrushModelWritable
{
  vec3_t mins;
  float padding1;
  vec3_t maxs;
  float padding2;
};

struct GfxBrushModel
{
  GfxBrushModelWritable writable;
  vec3_t bounds[2];
  unsigned int surfaceCount;
  unsigned int startSurfIndex;
};

struct MaterialMemory
{
  Material *material;
  int memory;
};

union XModelDrawInfo
{
  struct
  {
    char state;
    char lod;
    unsigned __int16 surfId;
  };
  unsigned int packed;
};

struct GfxSceneDynModel
{
  XModelDrawInfo info;
  unsigned __int16 dynEntId;
  char primaryLightIndex;
  char reflectionProbeIndex;
};

struct BModelDrawInfo
{
  unsigned __int16 surfId;
};

struct GfxSceneDynBrush
{
  BModelDrawInfo info;
  unsigned __int16 dynEntId;
};

union __m128
{
  float m128_f32[4];
  unsigned __int64 m128_u64[2];
  char m128_i8[16];
  __int16 m128_i16[8];
  int m128_i32[4];
  __int64 m128_i64[2];
  char m128_u8[16];
  unsigned __int16 m128_u16[8];
  unsigned int m128_u32[4];
};

struct vector3
{
  __m128 x;
  __m128 y;
  __m128 z;
};

struct vector4 : vector3
{
  __m128 w;
};

struct SSkinInstance
{
  union
  {  
    vector4 mat;
    float disk_mat[16];
  };
  SSkinShaders *shaders;
  SSkinModel *model;
  SSkinAnim *anim;
  SSkinVert *instVerts;
  float frame;
  int pad1;
  int pad2;
  int pad3;
};

struct GfxShadowGeometry
{
  unsigned __int16 surfaceCount;
  unsigned __int16 smodelCount;
  unsigned __int16 *sortedSurfIndex;
  unsigned __int16 *smodelIndex;
};

struct GfxLightRegion
{
  unsigned int hullCount;
  GfxLightRegionHull *hulls;
};

struct GfxStaticModelInst
{
  vec3_t mins;
  vec3_t maxs;
  vec3_t lightingOrigin;
};

struct srfTriangles_t
{
  vec3_t mins;
  int vertexDataOffset0;
  vec3_t maxs;
  int vertexDataOffset1;
  int firstVertex;
  float himipRadiusInvSq;
  unsigned __int16 vertexCount;
  unsigned __int16 triCount;
  int baseIndex;
};

struct GfxSurface
{
  srfTriangles_t tris;
  Material *material;
  char lightmapIndex;
  char reflectionProbeIndex;
  char primaryLightIndex;
  char flags;
  vec3_t bounds[2];
};

struct GfxPackedPlacement
{
  vec3_t origin;
  vec3_t axis[3];
  float scale;
};

struct GfxLightingSHQuantized
{
  unsigned __int16 V0[4];
  unsigned __int16 V1[4];
  unsigned __int16 V2[4];
};

struct __declspec(align(4)) GfxStaticModelLmapVertexInfo
{
  unsigned int *lmapVertexColors;
  ID3D11Buffer *lmapVertexColorsVB;
  unsigned __int16 numLmapVertexColors;
};

struct GfxStaticModelDrawInst
{
  float cullDist;
  GfxPackedPlacement placement;
  XModel *model;
  int flags;
  float invScaleSq;
  unsigned __int16 lightingHandle;
  unsigned __int16 colorsIndex;
  GfxLightingSHQuantized lightingSH;
  char primaryLightIndex;
  char visibility;
  char reflectionProbeIndex;
  unsigned int smid;
  GfxStaticModelLmapVertexInfo lmapVertexInfo[4];
};

struct Occluder
{
  unsigned int flags;
  char name[16];
  vec3_t points[4];
};

struct GfxOutdoorBounds
{
  vec3_t bounds[2];
};

struct GfxHeroLight
{
  char type;
  char unused[3];
  vec3_t color;
  vec3_t dir;
  vec3_t origin;
  float radius;
  float cosHalfFovOuter;
  float cosHalfFovInner;
  int exponent;
};

struct GfxHeroLightTree
{
  vec3_t mins;
  vec3_t maxs;
  int leftNode;
  int rightNode;
};

struct Glyph
{
  unsigned __int16 letter;
  char x0;
  char y0;
  char dx;
  char pixelWidth;
  char pixelHeight;
  float s0;
  float t0;
  float s1;
  float t1;
};

struct KerningPairs
{
  unsigned __int16 wFirst;
  unsigned __int16 wSecond;
  int iKernAmount;
};

struct FontIconName
{
  const char *string;
  int hash;
};

struct FontIconEntry
{
  FontIconName fontIconName;
  Material *fontIconMaterialHandle;
  int fontIconSize;
  float xScale;
  float yScale;
};

struct FontIconAlias
{
  int aliasHash;
  int buttonHash;
};

struct GenericEventHandler
{
  const char *name;
  GenericEventScript *eventScript;
  GenericEventHandler *next;
};

struct ItemKeyHandler
{
  int key;
  GenericEventScript *keyScript;
  ItemKeyHandler *next;
};

enum expDataType
{
  VAL_INT = 0x0,
  VAL_FLOAT = 0x1,
  VAL_STRING = 0x2,
  VAL_ADDRESS = 0x3,
  VAL_DVAR = 0x4,
};

union operandInternalDataUnion
{
  int intVal;
  float floatVal;
  const char *string;
  dvar_t *dvar;
};

struct Operand
{
  expDataType dataType;
  operandInternalDataUnion internals;
};

union expressionRpnDataUnion
{
  Operand constant;
  void *cmd;
  int cmdIdx;
};

struct expressionRpn
{
  int type;
  expressionRpnDataUnion data;
};

union itemDefData_t
{
  textDef_s *textDef;
  imageDef_s *imageDef;
  focusItemDef_s *blankButtonDef;
  ownerDrawDef_s *ownerDrawDef;
  void *data;
};

struct __declspec(align(8)) itemDef_s
{
  windowDef_t window;
  int type;
  int dataType;
  int imageTrack;
  const char *dvar;
  const char *profileVar;
  const char *dvarTest;
  const char *enableDvar;
  int dvarFlags;
  itemDefData_t typeData;
  menuDef_t *parent;
  rectData_s *rectExpData;
  ExpressionStatement visibleExp;
  unsigned __int64 showBits;
  unsigned __int64 hideBits;
  ExpressionStatement forecolorAExp;
  int ui3dWindowId;
  GenericEventHandler *onEvent;
  UIAnimInfo *animInfo;
};

enum weapType_t
{
  WEAPTYPE_BULLET = 0x0,
  WEAPTYPE_GRENADE = 0x1,
  WEAPTYPE_PROJECTILE = 0x2,
  WEAPTYPE_BINOCULARS = 0x3,
  WEAPTYPE_GAS = 0x4,
  WEAPTYPE_BOMB = 0x5,
  WEAPTYPE_MINE = 0x6,
  WEAPTYPE_MELEE = 0x7,
  WEAPTYPE_RIOTSHIELD = 0x8,
  WEAPTYPE_NUM = 0x9,
};

enum weapClass_t
{
  WEAPCLASS_RIFLE = 0x0,
  WEAPCLASS_MG = 0x1,
  WEAPCLASS_SMG = 0x2,
  WEAPCLASS_SPREAD = 0x3,
  WEAPCLASS_PISTOL = 0x4,
  WEAPCLASS_GRENADE = 0x5,
  WEAPCLASS_ROCKETLAUNCHER = 0x6,
  WEAPCLASS_TURRET = 0x7,
  WEAPCLASS_NON_PLAYER = 0x8,
  WEAPCLASS_GAS = 0x9,
  WEAPCLASS_ITEM = 0xA,
  WEAPCLASS_MELEE = 0xB,
  WEAPCLASS_KILLSTREAK_ALT_STORED_WEAPON = 0xC,
  WEAPCLASS_PISTOL_SPREAD = 0xD,
  WEAPCLASS_NUM = 0xE,
};

enum ImpactType
{
  IMPACT_TYPE_NONE = 0x0,
  IMPACT_TYPE_BULLET_SMALL = 0x1,
  IMPACT_TYPE_BULLET_LARGE = 0x2,
  IMPACT_TYPE_BULLET_AP = 0x3,
  IMPACT_TYPE_BULLET_XTREME = 0x4,
  IMPACT_TYPE_SHOTGUN = 0x5,
  IMPACT_TYPE_GRENADE_BOUNCE = 0x6,
  IMPACT_TYPE_GRENADE_EXPLODE = 0x7,
  IMPACT_TYPE_RIFLE_GRENADE = 0x8,
  IMPACT_TYPE_ROCKET_EXPLODE = 0x9,
  IMPACT_TYPE_ROCKET_EXPLODE_XTREME = 0xA,
  IMPACT_TYPE_PROJECTILE_DUD = 0xB,
  IMPACT_TYPE_MORTAR_SHELL = 0xC,
  IMPACT_TYPE_TANK_SHELL = 0xD,
  IMPACT_TYPE_BOLT = 0xE,
  IMPACT_TYPE_BLADE = 0xF,
  IMPACT_TYPE_COUNT = 0x10,
};

enum weapInventoryType_t
{
  WEAPINVENTORY_PRIMARY = 0x0,
  WEAPINVENTORY_OFFHAND = 0x1,
  WEAPINVENTORY_ITEM = 0x2,
  WEAPINVENTORY_ALTMODE = 0x3,
  WEAPINVENTORY_MELEE = 0x4,
  WEAPINVENTORY_DWLEFTHAND = 0x5,
  WEAPINVENTORYCOUNT = 0x6,
};

enum weapClipType_t
{
  WEAPON_CLIPTYPE_BOTTOM = 0x0,
  WEAPON_CLIPTYPE_TOP = 0x1,
  WEAPON_CLIPTYPE_LEFT = 0x2,
  WEAPON_CLIPTYPE_DP28 = 0x3,
  WEAPON_CLIPTYPE_PTRS = 0x4,
  WEAPON_CLIPTYPE_LMG = 0x5,
  WEAPON_CLIPTYPECOUNT = 0x6,
};

enum barrelType_t
{
  BARREL_TYPE_SINGLE = 0x0,
  BARREL_TYPE_DUAL = 0x1,
  BARREL_TYPE_DUAL_ALTERNATE = 0x2,
  BARREL_TYPE_QUAD = 0x3,
  BARREL_TYPE_QUAD_ALTERNATE = 0x4,
  BARREL_TYPE_QUAD_DOUBLE_ALTERNATE = 0x5,
  BARREL_TYPE_COUNT = 0x6,
};

enum OffhandClass
{
  OFFHAND_CLASS_NONE = 0x0,
  OFFHAND_CLASS_FRAG_GRENADE = 0x1,
  OFFHAND_CLASS_SMOKE_GRENADE = 0x2,
  OFFHAND_CLASS_FLASH_GRENADE = 0x3,
  OFFHAND_CLASS_GEAR = 0x4,
  OFFHAND_CLASS_SUPPLYDROP_MARKER = 0x5,
  OFFHAND_CLASS_COUNT = 0x6,
};

enum OffhandSlot
{
  OFFHAND_SLOT_NONE = 0x0,
  OFFHAND_SLOT_LETHAL_GRENADE = 0x1,
  OFFHAND_SLOT_TACTICAL_GRENADE = 0x2,
  OFFHAND_SLOT_EQUIPMENT = 0x3,
  OFFHAND_SLOT_SPECIFIC_USE = 0x4,
  OFFHAND_SLOT_COUNT = 0x5,
};

enum weapStance_t
{
  WEAPSTANCE_STAND = 0x0,
  WEAPSTANCE_DUCK = 0x1,
  WEAPSTANCE_PRONE = 0x2,
  WEAPSTANCE_NUM = 0x3,
};

enum activeReticleType_t
{
  VEH_ACTIVE_RETICLE_NONE = 0x0,
  VEH_ACTIVE_RETICLE_PIP_ON_A_STICK = 0x1,
  VEH_ACTIVE_RETICLE_BOUNCING_DIAMOND = 0x2,
  VEH_ACTIVE_RETICLE_MISSILE_LOCK = 0x3,
  VEH_ACTIVE_RETICLE_COUNT = 0x4,
};

enum ammoCounterClipType_t
{
  AMMO_COUNTER_CLIP_NONE = 0x0,
  AMMO_COUNTER_CLIP_MAGAZINE = 0x1,
  AMMO_COUNTER_CLIP_SHORTMAGAZINE = 0x2,
  AMMO_COUNTER_CLIP_SHOTGUN = 0x3,
  AMMO_COUNTER_CLIP_ROCKET = 0x4,
  AMMO_COUNTER_CLIP_BELTFED = 0x5,
  AMMO_COUNTER_CLIP_ALTWEAPON = 0x6,
  AMMO_COUNTER_CLIP_COUNT = 0x7,
};

enum WeapOverlayInteface_t
{
  WEAPOVERLAYINTERFACE_NONE = 0x0,
  WEAPOVERLAYINTERFACE_JAVELIN = 0x1,
  WEAPOVERLAYINTERFACE_TURRETSCOPE = 0x2,
  WEAPOVERLAYINTERFACECOUNT = 0x3,
};

enum weapProjExposion_t
{
  WEAPPROJEXP_GRENADE = 0x0,
  WEAPPROJEXP_ROCKET = 0x1,
  WEAPPROJEXP_FLASHBANG = 0x2,
  WEAPPROJEXP_NONE = 0x3,
  WEAPPROJEXP_DUD = 0x4,
  WEAPPROJEXP_SMOKE = 0x5,
  WEAPPROJEXP_HEAVY = 0x6,
  WEAPPROJEXP_FIRE = 0x7,
  WEAPPROJEXP_NAPALMBLOB = 0x8,
  WEAPPROJEXP_BOLT = 0x9,
  WEAPPROJEXP_SHRAPNELSPAN = 0xA,
  WEAPPROJEXP_NUM = 0xB,
};

enum WeapStickinessType
{
  WEAPSTICKINESS_NONE = 0x0,
  WEAPSTICKINESS_ALL = 0x1,
  WEAPSTICKINESS_ALL_NO_SENTIENTS = 0x2,
  WEAPSTICKINESS_GROUND = 0x3,
  WEAPSTICKINESS_GROUND_WITH_YAW = 0x4,
  WEAPSTICKINESS_FLESH = 0x5,
  WEAPSTICKINESS_COUNT = 0x6,
};

enum WeapRotateType
{
  WEAPROTATE_GRENADE_ROTATE = 0x0,
  WEAPROTATE_BLADE_ROTATE = 0x1,
  WEAPROTATE_CYLINDER_ROTATE = 0x2,
  WEAPROTATE_COUNT = 0x3,
};

enum guidedMissileType_t
{
  MISSILE_GUIDANCE_NONE = 0x0,
  MISSILE_GUIDANCE_SIDEWINDER = 0x1,
  MISSILE_GUIDANCE_HELLFIRE = 0x2,
  MISSILE_GUIDANCE_JAVELIN = 0x3,
  MISSILE_GUIDANCE_BALLISTIC = 0x4,
  MISSILE_GUIDANCE_WIREGUIDED = 0x5,
  MISSILE_GUIDANCE_TVGUIDED = 0x6,
  MISSILE_GUIDANCE_DRONE = 0x7,
  MISSILE_GUIDANCE_HEATSEEKING = 0x8,
  MISSILE_GUIDANCE_COUNT = 0x9,
};

struct WeaponDef
{
  const char *szOverlayName;
  XModel **gunXModel;
  XModel *handXModel;
  const char *szModeName;
  unsigned __int16 *notetrackSoundMapKeys;
  unsigned __int16 *notetrackSoundMapValues;
  int playerAnimType;
  weapType_t weapType;
  weapClass_t weapClass;
  PenetrateType penetrateType;
  ImpactType impactType;
  weapInventoryType_t inventoryType;
  weapFireType_t fireType;
  weapClipType_t clipType;
  barrelType_t barrelType;
  int itemIndex;
  const char *parentWeaponName;
  int iJamFireTime;
  int overheatWeapon;
  float overheatRate;
  float cooldownRate;
  float overheatEndVal;
  bool coolWhileFiring;
  bool fuelTankWeapon;
  int iTankLifeTime;
  OffhandClass offhandClass;
  OffhandSlot offhandSlot;
  weapStance_t stance;
  FxEffectDef *viewFlashEffect;
  FxEffectDef *worldFlashEffect;
  FxEffectDef *barrelCooldownEffect;
  int barrelCooldownMinCount;
  vec3_t vViewFlashOffset;
  vec3_t vWorldFlashOffset;
  const char *pickupSound;
  const char *pickupSoundPlayer;
  const char *ammoPickupSound;
  const char *ammoPickupSoundPlayer;
  const char *projectileSound;
  const char *pullbackSound;
  const char *pullbackSoundPlayer;
  const char *fireSound;
  const char *fireSoundPlayer;
  const char *fireLoopSound;
  const char *fireLoopSoundPlayer;
  const char *fireLoopEndSound;
  const char *fireLoopEndSoundPlayer;
  const char *fireStartSound;
  const char *fireStopSound;
  const char *fireKillcamSound;
  const char *fireStartSoundPlayer;
  const char *fireStopSoundPlayer;
  const char *fireKillcamSoundPlayer;
  const char *fireLastSound;
  const char *fireLastSoundPlayer;
  const char *emptyFireSound;
  const char *emptyFireSoundPlayer;
  const char *crackSound;
  const char *whizbySound;
  const char *meleeSwipeSound;
  const char *meleeSwipeSoundPlayer;
  const char *meleeHitSound;
  const char *meleeMissSound;
  const char *rechamberSound;
  const char *rechamberSoundPlayer;
  const char *reloadSound;
  const char *reloadSoundPlayer;
  const char *reloadEmptySound;
  const char *reloadEmptySoundPlayer;
  const char *reloadStartSound;
  const char *reloadStartSoundPlayer;
  const char *reloadEndSound;
  const char *reloadEndSoundPlayer;
  const char *rotateLoopSound;
  const char *rotateLoopSoundPlayer;
  const char *rotateStopSound;
  const char *rotateStopSoundPlayer;
  const char *deploySound;
  const char *deploySoundPlayer;
  const char *finishDeploySound;
  const char *finishDeploySoundPlayer;
  const char *breakdownSound;
  const char *breakdownSoundPlayer;
  const char *finishBreakdownSound;
  const char *finishBreakdownSoundPlayer;
  const char *detonateSound;
  const char *detonateSoundPlayer;
  const char *nightVisionWearSound;
  const char *nightVisionWearSoundPlayer;
  const char *nightVisionRemoveSound;
  const char *nightVisionRemoveSoundPlayer;
  const char *altSwitchSound;
  const char *altSwitchSoundPlayer;
  const char *raiseSound;
  const char *raiseSoundPlayer;
  const char *firstRaiseSound;
  const char *firstRaiseSoundPlayer;
  const char *adsRaiseSoundPlayer;
  const char *adsLowerSoundPlayer;
  const char *putawaySound;
  const char *putawaySoundPlayer;
  const char *overheatSound;
  const char *overheatSoundPlayer;
  const char *adsZoomSound;
  const char *shellCasing;
  const char *shellCasingPlayer;
  const char **bounceSound;
  const char *standMountedWeapdef;
  const char *crouchMountedWeapdef;
  const char *proneMountedWeapdef;
  int standMountedIndex;
  int crouchMountedIndex;
  int proneMountedIndex;
  FxEffectDef *viewShellEjectEffect;
  FxEffectDef *worldShellEjectEffect;
  FxEffectDef *viewLastShotEjectEffect;
  FxEffectDef *worldLastShotEjectEffect;
  vec3_t vViewShellEjectOffset;
  vec3_t vWorldShellEjectOffset;
  vec3_t vViewShellEjectRotation;
  vec3_t vWorldShellEjectRotation;
  Material *reticleCenter;
  Material *reticleSide;
  int iReticleCenterSize;
  int iReticleSideSize;
  int iReticleMinOfs;
  activeReticleType_t activeReticleType;
  vec3_t vStandMove;
  vec3_t vStandRot;
  vec3_t vDuckedOfs;
  vec3_t vDuckedMove;
  vec3_t vDuckedSprintOfs;
  vec3_t vDuckedSprintRot;
  vec2_t vDuckedSprintBob;
  float fDuckedSprintCycleScale;
  vec3_t vSprintOfs;
  vec3_t vSprintRot;
  vec2_t vSprintBob;
  float fSprintCycleScale;
  vec3_t vLowReadyOfs;
  vec3_t vLowReadyRot;
  vec3_t vRideOfs;
  vec3_t vRideRot;
  vec3_t vDtpOfs;
  vec3_t vDtpRot;
  vec2_t vDtpBob;
  float fDtpCycleScale;
  vec3_t vMantleOfs;
  vec3_t vMantleRot;
  vec3_t vSlideOfs;
  vec3_t vSlideRot;
  vec3_t vDuckedRot;
  vec3_t vProneOfs;
  vec3_t vProneMove;
  vec3_t vProneRot;
  vec3_t vStrafeMove;
  vec3_t vStrafeRot;
  float fPosMoveRate;
  float fPosProneMoveRate;
  float fStandMoveMinSpeed;
  float fDuckedMoveMinSpeed;
  float fProneMoveMinSpeed;
  float fPosRotRate;
  float fPosProneRotRate;
  float fStandRotMinSpeed;
  float fDuckedRotMinSpeed;
  float fProneRotMinSpeed;
  XModel **worldModel;
  XModel *worldClipModel;
  XModel *rocketModel;
  XModel *mountedModel;
  XModel *additionalMeleeModel;
  Material *fireTypeIcon;
  Material *hudIcon;
  weaponIconRatioType_t hudIconRatio;
  Material *indicatorIcon;
  weaponIconRatioType_t indicatorIconRatio;
  Material *ammoCounterIcon;
  weaponIconRatioType_t ammoCounterIconRatio;
  ammoCounterClipType_t ammoCounterClip;
  int iStartAmmo;
  int iMaxAmmo;
  int shotCount;
  const char *szSharedAmmoCapName;
  int iSharedAmmoCapIndex;
  int iSharedAmmoCap;
  bool unlimitedAmmo;
  bool ammoCountClipRelative;
  int damage[6];
  float damageRange[6];
  int minPlayerDamage;
  float damageDuration;
  float damageInterval;
  int playerDamage;
  int iMeleeDamage;
  int iDamageType;
  unsigned __int16 explosionTag;
  int iFireDelay;
  int iMeleeDelay;
  int meleeChargeDelay;
  int iDetonateDelay;
  int iSpinUpTime;
  int iSpinDownTime;
  float spinRate;
  const char *spinLoopSound;
  const char *spinLoopSoundPlayer;
  const char *startSpinSound;
  const char *startSpinSoundPlayer;
  const char *stopSpinSound;
  const char *stopSpinSoundPlayer;
  bool applySpinPitch;
  int iFireTime;
  int iLastFireTime;
  int iRechamberTime;
  int iRechamberBoltTime;
  int iHoldFireTime;
  int iDetonateTime;
  int iMeleeTime;
  int iBurstDelayTime;
  int meleeChargeTime;
  int iReloadTimeRight;
  int iReloadTimeLeft;
  int reloadShowRocketTime;
  int iReloadEmptyTimeLeft;
  int iReloadAddTime;
  int iReloadEmptyAddTime;
  int iReloadQuickAddTime;
  int iReloadQuickEmptyAddTime;
  int iReloadStartTime;
  int iReloadStartAddTime;
  int iReloadEndTime;
  int iDropTime;
  int iRaiseTime;
  int iAltDropTime;
  int quickDropTime;
  int quickRaiseTime;
  int iFirstRaiseTime;
  int iEmptyRaiseTime;
  int iEmptyDropTime;
  int sprintInTime;
  int sprintLoopTime;
  int sprintOutTime;
  int lowReadyInTime;
  int lowReadyLoopTime;
  int lowReadyOutTime;
  int contFireInTime;
  int contFireLoopTime;
  int contFireOutTime;
  int dtpInTime;
  int dtpLoopTime;
  int dtpOutTime;
  int crawlInTime;
  int crawlForwardTime;
  int crawlBackTime;
  int crawlRightTime;
  int crawlLeftTime;
  int crawlOutFireTime;
  int crawlOutTime;
  int slideInTime;
  int deployTime;
  int breakdownTime;
  int iFlourishTime;
  int nightVisionWearTime;
  int nightVisionWearTimeFadeOutEnd;
  int nightVisionWearTimePowerUp;
  int nightVisionRemoveTime;
  int nightVisionRemoveTimePowerDown;
  int nightVisionRemoveTimeFadeInStart;
  int fuseTime;
  int aiFuseTime;
  int lockOnRadius;
  int lockOnSpeed;
  bool requireLockonToFire;
  bool noAdsWhenMagEmpty;
  bool avoidDropCleanup;
  unsigned int stackFire;
  float stackFireSpread;
  float stackFireAccuracyDecay;
  const char *stackSound;
  float autoAimRange;
  float aimAssistRange;
  bool mountableWeapon;
  float aimPadding;
  float enemyCrosshairRange;
  bool crosshairColorChange;
  float moveSpeedScale;
  float adsMoveSpeedScale;
  float sprintDurationScale;
  weapOverlayReticle_t overlayReticle;
  WeapOverlayInteface_t overlayInterface;
  float overlayWidth;
  float overlayHeight;
  float fAdsBobFactor;
  float fAdsViewBobMult;
  bool bHoldBreathToSteady;
  float fHipSpreadStandMin;
  float fHipSpreadDuckedMin;
  float fHipSpreadProneMin;
  float hipSpreadStandMax;
  float hipSpreadDuckedMax;
  float hipSpreadProneMax;
  float fHipSpreadDecayRate;
  float fHipSpreadFireAdd;
  float fHipSpreadTurnAdd;
  float fHipSpreadMoveAdd;
  float fHipSpreadDuckedDecay;
  float fHipSpreadProneDecay;
  float fHipReticleSidePos;
  float fAdsIdleAmount;
  float fHipIdleAmount;
  float adsIdleSpeed;
  float hipIdleSpeed;
  float fIdleCrouchFactor;
  float fIdleProneFactor;
  float fGunMaxPitch;
  float fGunMaxYaw;
  float swayMaxAngle;
  float swayLerpSpeed;
  float swayPitchScale;
  float swayYawScale;
  float swayHorizScale;
  float swayVertScale;
  float swayShellShockScale;
  float adsSwayMaxAngle;
  float adsSwayLerpSpeed;
  float adsSwayPitchScale;
  float adsSwayYawScale;
  bool sharedAmmo;
  bool bRifleBullet;
  bool armorPiercing;
  bool bAirburstWeapon;
  bool bBoltAction;
  bool bUseAltTagFlash;
  bool bUseAntiLagRewind;
  bool bIsCarriedKillstreakWeapon;
  bool aimDownSight;
  bool bRechamberWhileAds;
  bool bReloadWhileAds;
  float adsViewErrorMin;
  float adsViewErrorMax;
  bool bCookOffHold;
  bool bClipOnly;
  bool bCanUseInVehicle;
  bool bNoDropsOrRaises;
  bool adsFireOnly;
  bool cancelAutoHolsterWhenEmpty;
  bool suppressAmmoReserveDisplay;
  bool laserSight;
  bool laserSightDuringNightvision;
  bool bHideThirdPerson;
  bool bHasBayonet;
  bool bDualWield;
  bool bExplodeOnGround;
  bool bThrowBack;
  bool bRetrievable;
  bool bDieOnRespawn;
  bool bNoThirdPersonDropsOrRaises;
  bool bContinuousFire;
  bool bNoPing;
  bool bForceBounce;
  bool bUseDroppedModelAsStowed;
  bool bNoQuickDropWhenEmpty;
  bool bKeepCrosshairWhenADS;
  bool bUseOnlyAltWeaoponHideTagsInAltMode;
  bool bAltWeaponAdsOnly;
  bool bAltWeaponDisableSwitching;
  Material *killIcon;
  weaponIconRatioType_t killIconRatio;
  bool flipKillIcon;
  bool bNoPartialReload;
  bool bSegmentedReload;
  bool bNoADSAutoReload;
  int iReloadAmmoAdd;
  int iReloadStartAdd;
  const char *szSpawnedGrenadeWeaponName;
  const char *szDualWieldWeaponName;
  unsigned int dualWieldWeaponIndex;
  int iDropAmmoMin;
  int iDropAmmoMax;
  int iDropClipAmmoMin;
  int iDropClipAmmoMax;
  int iShotsBeforeRechamber;
  bool blocksProne;
  bool bShowIndicator;
  int isRollingGrenade;
  int useBallisticPrediction;
  int isValuable;
  int isTacticalInsertion;
  bool isReviveWeapon;
  bool bUseRigidBodyOnVehicle;
  int iExplosionRadius;
  int iExplosionRadiusMin;
  int iIndicatorRadius;
  int iExplosionInnerDamage;
  int iExplosionOuterDamage;
  float damageConeAngle;
  int iProjectileSpeed;
  int iProjectileSpeedUp;
  int iProjectileSpeedRelativeUp;
  int iProjectileSpeedForward;
  float fProjectileTakeParentVelocity;
  int iProjectileActivateDist;
  float projLifetime;
  float timeToAccelerate;
  float projectileCurvature;
  XModel *projectileModel;
  weapProjExposion_t projExplosion;
  FxEffectDef *projExplosionEffect;
  bool projExplosionEffectForceNormalUp;
  FxEffectDef *projExplosionEffect2;
  bool projExplosionEffect2ForceNormalUp;
  FxEffectDef *projExplosionEffect3;
  bool projExplosionEffect3ForceNormalUp;
  FxEffectDef *projExplosionEffect4;
  bool projExplosionEffect4ForceNormalUp;
  FxEffectDef *projExplosionEffect5;
  bool projExplosionEffect5ForceNormalUp;
  FxEffectDef *projDudEffect;
  const char *projExplosionSound;
  const char *projDudSound;
  const char *mortarShellSound;
  const char *tankShellSound;
  bool bProjImpactExplode;
  bool bProjSentientImpactExplode;
  bool bProjExplodeWhenStationary;
  bool bBulletImpactExplode;
  WeapStickinessType stickiness;
  WeapRotateType rotateType;
  bool plantable;
  bool hasDetonator;
  bool timedDetonation;
  bool bNoCrumpleMissile;
  bool rotate;
  bool bKeepRolling;
  bool holdButtonToThrow;
  bool offhandHoldIsCancelable;
  bool freezeMovementWhenFiring;
  float lowAmmoWarningThreshold;
  bool bDisallowAtMatchStart;
  float meleeChargeRange;
  bool bUseAsMelee;
  bool isCameraSensor;
  bool isAcousticSensor;
  bool isLaserSensor;
  bool isHoldUseGrenade;
  float *parallelBounce;
  float *perpendicularBounce;
  FxEffectDef *projTrailEffect;
  vec3_t vProjectileColor;
  guidedMissileType_t guidedMissileType;
  float maxSteeringAccel;
  int projIgnitionDelay;
  FxEffectDef *projIgnitionEffect;
  const char *projIgnitionSound;
  float fAdsAimPitch;
  float fAdsCrosshairInFrac;
  float fAdsCrosshairOutFrac;
  int adsGunKickReducedKickBullets;
  float adsGunKickReducedKickPercent;
  float fAdsGunKickPitchMin;
  float fAdsGunKickPitchMax;
  float fAdsGunKickYawMin;
  float fAdsGunKickYawMax;
  float fAdsGunKickAccel;
  float fAdsGunKickSpeedMax;
  float fAdsGunKickSpeedDecay;
  float fAdsGunKickStaticDecay;
  float fAdsViewKickPitchMin;
  float fAdsViewKickPitchMax;
  float fAdsViewKickMinMagnitude;
  float fAdsViewKickYawMin;
  float fAdsViewKickYawMax;
  float fAdsRecoilReductionRate;
  float fAdsRecoilReductionLimit;
  float fAdsRecoilReturnRate;
  float fAdsViewScatterMin;
  float fAdsViewScatterMax;
  float fAdsSpread;
  int hipGunKickReducedKickBullets;
  float hipGunKickReducedKickPercent;
  float fHipGunKickPitchMin;
  float fHipGunKickPitchMax;
  float fHipGunKickYawMin;
  float fHipGunKickYawMax;
  float fHipGunKickAccel;
  float fHipGunKickSpeedMax;
  float fHipGunKickSpeedDecay;
  float fHipGunKickStaticDecay;
  float fHipViewKickPitchMin;
  float fHipViewKickPitchMax;
  float fHipViewKickMinMagnitude;
  float fHipViewKickYawMin;
  float fHipViewKickYawMax;
  float fHipViewScatterMin;
  float fHipViewScatterMax;
  float fAdsViewKickCenterDuckedScale;
  float fAdsViewKickCenterProneScale;
  float fAntiQuickScopeTime;
  float fAntiQuickScopeScale;
  float fAntiQuickScopeSpreadMultiplier;
  float fAntiQuickScopeSpreadMax;
  float fAntiQuickScopeSwayFactor;
  float fightDist;
  float maxDist;
  const char *accuracyGraphName[2];
  vec2_t *accuracyGraphKnots[2];
  vec2_t *originalAccuracyGraphKnots[2];
  int accuracyGraphKnotCount[2];
  int originalAccuracyGraphKnotCount[2];
  int iPositionReloadTransTime;
  float leftArc;
  float rightArc;
  float topArc;
  float bottomArc;
  float accuracy;
  float aiSpread;
  float playerSpread;
  float minTurnSpeed[2];
  float maxTurnSpeed[2];
  float pitchConvergenceTime;
  float yawConvergenceTime;
  float suppressTime;
  float maxRange;
  float fAnimHorRotateInc;
  float fPlayerPositionDist;
  const char *szUseHintString;
  const char *dropHintString;
  int iUseHintStringIndex;
  int dropHintStringIndex;
  float horizViewJitter;
  float vertViewJitter;
  float cameraShakeScale;
  int cameraShakeDuration;
  int cameraShakeRadius;
  float explosionCameraShakeScale;
  int explosionCameraShakeDuration;
  int explosionCameraShakeRadius;
  const char *szScript;
  float destabilizationRateTime;
  float destabilizationCurvatureMax;
  int destabilizeDistance;
  float *locationDamageMultipliers;
  const char *fireRumble;
  const char *meleeImpactRumble;
  const char *reloadRumble;
  const char *explosionRumble;
  TracerDef *tracerType;
  TracerDef *enemyTracerType;
  float adsDofStart;
  float adsDofEnd;
  float hipDofStart;
  float hipDofEnd;
  float scanSpeed;
  float scanAccel;
  int scanPauseTime;
  const char *flameTableFirstPerson;
  const char *flameTableThirdPerson;
  flameTable *flameTableFirstPersonPtr;
  flameTable *flameTableThirdPersonPtr;
  FxEffectDef *tagFx_preparationEffect;
  FxEffectDef *tagFlash_preparationEffect;
  bool doGibbing;
  float maxGibDistance;
  float altScopeADSTransInTime;
  float altScopeADSTransOutTime;
  int iIntroFireTime;
  int iIntroFireLength;
  FxEffectDef *meleeSwipeEffect;
  FxEffectDef *meleeImpactEffect;
  FxEffectDef *meleeImpactNoBloodEffect;
  const char *throwBackType;
  WeaponCamo *weaponCamo;
  float customFloat0;
  float customFloat1;
  float customFloat2;
  int customBool0;
  int customBool1;
  int customBool2;
};

struct WeaponCamoSet
{
  GfxImage *solidCamoImage;
  GfxImage *patternCamoImage;
  vec2_t patternOffset;
  float patternScale;
};

struct WeaponCamoMaterialSet
{
  unsigned int numMaterials;
  WeaponCamoMaterial *materials;
};

enum SndMenuCategory
{
  SND_CATEGORY_SFX = 0x0,
  SND_CATEGORY_MUSIC = 0x1,
  SND_CATEGORY_VOICE = 0x2,
  SND_CATEGORY_UI = 0x3,
  SND_CATEGORY_CINEMATIC = 0x4,
  SND_CATEGORY_COUNT = 0x5,
};

struct SndVolumeGroup
{
  char name[32];
  char parentName[32];
  unsigned int id;
  int parentIndex;
  SndMenuCategory category;
  unsigned __int16 attenuationSp;
  unsigned __int16 attenuationMp;
};

struct SndCurve
{
  char name[32];
  unsigned int id;
  vec2_t points[8];
};

struct SndPan
{
  char name[32];
  unsigned int id;
  float front;
  float back;
  float center;
  float lfe;
  float left;
  float right;
};

struct SndDuckGroup
{
  char name[32];
  unsigned int id;
};

struct SndContext
{
  unsigned int type;
  unsigned int values[8];
};

struct SndMaster
{
  char name[32];
  unsigned int id;
  int lowE;
  float lowG;
  float lowF;
  float lowQ;
  int peak1E;
  float peak1G;
  float peak1F;
  float peak1Q;
  int peak2E;
  float peak2G;
  float peak2F;
  float peak2Q;
  int hiE;
  float hiG;
  float hiF;
  float hiQ;
  float eqG;
  int compE;
  float compPG;
  float compMG;
  float compT;
  float compR;
  float compTA;
  float compTR;
  int limitE;
  float limitPG;
  float limitMG;
  float limitT;
  float limitR;
  float limitTA;
  float limitTR;
  float busReverbG;
  float busFxG;
  float busVoiceG;
  float busPfutzG;
  float busHdrfxG;
  float busUiG;
  float busMusicG;
  float busMovieG;
  float busVcsG;
  int busReverbE;
  int busFxE;
  int busVoiceE;
  int busPfutzE;
  int busHdrfxE;
  int busUiE;
  int busMusicE;
  int busMovieE;
  int hdrfxCompE;
  int voiceEqE;
  int voiceCompE;
};

struct SndSidechainDuck
{
  char name[32];
  unsigned int id;
  float g;
  float f;
  float q;
  float ta;
  float tr;
  float tf;
};

struct SndFutz
{
  char name[32];
  unsigned int id;
  float bpfF;
  float bpfQ;
  float lsG;
  float lsF;
  float lsQ;
  float dist;
  float preG;
  float postG;
  float th;
  float tg;
  float clippre;
  float clippost;
  float blend;
  unsigned int startAliasId;
  unsigned int stopAliasId;
  unsigned int loopAliasId;
};

struct FxSpawnDefLooping
{
  int intervalMsec;
  int count;
};

struct FxIntRange
{
  int base;
  int amplitude;
};

struct FxSpawnDefOneShot
{
  FxIntRange count;
};

union FxSpawnDef
{
  FxSpawnDefLooping looping;
  FxSpawnDefOneShot oneShot;
};

struct FxElemAtlas
{
  char behavior;
  char index;
  char fps;
  char loopCount;
  char colIndexBits;
  char rowIndexBits;
  unsigned __int16 entryCountAndIndexRange;
};

union FxEffectDefRef
{
  FxEffectDef *handle;
  const char *name;
};

union FxElemVisuals
{
  void *anonymous;
  Material *material;
  XModel *model;
  FxEffectDefRef effectDef;
  const char *soundName;
  GfxLightDef *lightDef;
};

union FxElemDefVisuals
{
  FxElemMarkVisuals *markArray;
  FxElemVisuals *array;
  FxElemVisuals instance;
};

union FxElemExtendedDefPtr
{
  FxTrailDef *localTrailDef;
  FxTrailDef *trailDef;
  FxSpotLightDef *localSpotLightDef;
  FxSpotLightDef *spotLightDef;
  void *unknownDef;
};

struct FxBillboardTrim
{
  float topWidth;
  float bottomWidth;
};

union FxElemDefUnion
{
  FxBillboardTrim billboard;
  FxIntRange cloudDensityRange;
};

struct FxElemSpawnSound
{
  const char *spawnSound;
};

const struct FxElemDef
{
  int flags;
  FxSpawnDef spawn;
  FxFloatRange spawnRange;
  FxFloatRange fadeInRange;
  FxFloatRange fadeOutRange;
  float spawnFrustumCullRadius;
  FxIntRange spawnDelayMsec;
  FxIntRange lifeSpanMsec;
  FxFloatRange spawnOrigin[3];
  FxFloatRange spawnOffsetRadius;
  FxFloatRange spawnOffsetHeight;
  FxFloatRange spawnAngles[3];
  FxFloatRange angularVelocity[3];
  FxFloatRange initialRotation;
  unsigned int rotationAxis;
  FxFloatRange gravity;
  FxFloatRange reflectionFactor;
  FxElemAtlas atlas;
  float windInfluence;
  char elemType;
  char visualCount;
  char velIntervalCount;
  char visStateIntervalCount;
  FxElemVelStateSample *velSamples;
  FxElemVisStateSample *visSamples;
  FxElemDefVisuals visuals;
  vec3_t collMins;
  vec3_t collMaxs;
  FxEffectDefRef effectOnImpact;
  FxEffectDefRef effectOnDeath;
  FxEffectDefRef effectEmitted;
  FxFloatRange emitDist;
  FxFloatRange emitDistVariance;
  FxEffectDefRef effectAttached;
  FxElemExtendedDefPtr extended;
  char sortOrder;
  char lightingFrac;
  char unused[2];
  unsigned __int16 alphaFadeTimeMsec;
  unsigned __int16 maxWindStrength;
  unsigned __int16 spawnIntervalAtMaxWind;
  unsigned __int16 lifespanAtMaxWind;
  FxElemDefUnion u;
  FxElemSpawnSound spawnSound;
  vec2_t billboardPivot;
};

struct FxImpactEntry
{
  FxEffectDef *nonflesh[32];
  FxEffectDef *flesh[4];
};

struct StringTableCell
{
  const char *string;
  int hash;
};

enum LbColType
{
  LBCOL_TYPE_NUMBER = 0x0,
  LBCOL_TYPE_TIME = 0x1,
  LBCOL_TYPE_LEVELXP = 0x2,
  LBCOL_TYPE_PRESTIGE = 0x3,
  LBCOL_TYPE_BIGNUMBER = 0x4,
  LBCOL_TYPE_PERCENT = 0x5,
  LBCOL_TYPE_TIME_FULL = 0x6,
  LBCOL_TYPE_COUNT = 0x7,
};

enum LbAggType
{
  LBAGG_TYPE_MIN = 0x0,
  LBAGG_TYPE_MAX = 0x1,
  LBAGG_TYPE_ADD = 0x2,
  LBAGG_TYPE_REPLACE = 0x3,
  LBAGG_TYPE_COUNT = 0x4,
};

struct LbColumnDef
{
  const char *name;
  int colId;
  int dwColIndex;
  bool hidden;
  const char *statName;
  LbColType type;
  int precision;
  LbAggType agg;
  const char *localization;
  int uiCalColX;
  int uiCalColY;
};

struct ddlDef_t
{
  int version;
  int size;
  ddlStructDef_t *structList;
  int structCount;
  ddlEnumDef_t *enumList;
  int enumCount;
  ddlDef_t *next;
};

struct Glass
{
  unsigned int numCellIndices;
  unsigned __int16 cellIndices[6];
  GlassDef *glassDef;
  unsigned int index;
  unsigned int brushModel;
  vec3_t origin;
  vec3_t angles;
  vec3_t absmin;
  vec3_t absmax;
  bool isPlanar;
  char numOutlineVerts;
  char binormalSign;
  vec2_t *outline;
  vec3_t outlineAxis[3];
  vec3_t outlineOrigin;
  float uvScale;
  float thickness;
};

struct KeyValuePair
{
  int keyHash;
  int namespaceHash;
  const char *value;
};

enum DevEventType
{
  EVENT_ACTIVATE = 0x0,
  EVENT_DEACTIVATE = 0x1,
  EVENT_ACCEPT = 0x2,
  EVENT_UPDATE = 0x3,
  EVENT_DRAW = 0x4,
  EVENT_SAVE = 0x5,
};

enum LocalClientNum_t
{
  INVALID_LOCAL_CLIENT = 0xFFFFFFFF,
  LOCAL_CLIENT_FIRST = 0x0,
  LOCAL_CLIENT_0 = 0x0,
  ONLY_LOCAL_CLIENT = 0x0,
  LOCAL_CLIENT_COUNT = 0x1,
};

struct __declspec(align(4)) DevGraph
{
  vec2_t *knots;
  int *knotCount;
  int knotCountMax;
  int selectedKnot;
  void* eventCallback; //void (__cdecl *eventCallback)(DevGraph *, DevEventType, LocalClientNum_t);
  void* textCallback; //void (__cdecl *textCallback)(DevGraph *, const float, const float, char *, const int);
  void *data;
  bool disableEditingEndPoints;
};

struct GraphFloat
{
  char name[64];
  vec2_t knots[32];
  int knotCount;
  float scale;
  DevGraph devguiGraph;
};

union XAnimDynamicFrames
{
  char (*_1)[3];
  unsigned __int16 (*_2)[3];
};

union XAnimDynamicIndices
{
  char _1[1];
  unsigned __int16 _2[1];
};

struct __declspec(align(4)) XAnimPartTransFrames
{
  vec3_t mins;
  vec3_t size;
  XAnimDynamicFrames frames;
  XAnimDynamicIndices indices;
};

union XAnimPartTransData
{
  XAnimPartTransFrames frames;
  vec3_t frame0;
};

struct XAnimPartTrans
{
  unsigned __int16 size;
  char smallTrans;
  XAnimPartTransData u;
};

struct __declspec(align(4)) XAnimDeltaPartQuatDataFrames2
{
  __int16 (*frames)[2];
  XAnimDynamicIndices indices;
};

union XAnimDeltaPartQuatData2
{
  XAnimDeltaPartQuatDataFrames2 frames;
  __int16 frame0[2];
};

struct XAnimDeltaPartQuat2
{
  unsigned __int16 size;
  XAnimDeltaPartQuatData2 u;
};

struct __declspec(align(4)) XAnimDeltaPartQuatDataFrames
{
  __int16 (*frames)[4];
  XAnimDynamicIndices indices;
};

union XAnimDeltaPartQuatData
{
  XAnimDeltaPartQuatDataFrames frames;
  __int16 frame0[4];
};

struct XAnimDeltaPartQuat
{
  unsigned __int16 size;
  XAnimDeltaPartQuatData u;
};

union GfxColor
{
  unsigned int packed;
  char array[4];
};

union PackedTexCoords
{
  unsigned int packed;
};

union PackedUnitVec
{
  unsigned int packed;
};

struct GfxPackedVertex
{
  vec3_t xyz;
  float binormalSign;
  GfxColor color;
  PackedTexCoords texCoord;
  PackedUnitVec normal;
  PackedUnitVec tangent;
};

struct XRigidVertList
{
  unsigned __int16 boneOffset;
  unsigned __int16 vertCount;
  unsigned __int16 triOffset;
  unsigned __int16 triCount;
  XSurfaceCollisionTree *collisionTree;
};

struct XModelCollTri_s
{
  vec4_t plane;
  vec4_t svec;
  vec4_t tvec;
};

struct PhysGeomList
{
  unsigned int count;
  PhysGeomInfo *geoms;
  int contents;
};

/*struct __cppobj ID3D11BlendState : ID3D11DeviceChild
{
};*/

/*struct __cppobj ID3D11DepthStencilState : ID3D11DeviceChild
{
};*/

/*struct __cppobj ID3D11RasterizerState : ID3D11DeviceChild
{
};*/

/*struct IUnknownVtbl
{
  HRESULT (__stdcall *QueryInterface)(IUnknown *this, _GUID *, void **);
  unsigned int (__stdcall *AddRef)(IUnknown *this);
  unsigned int (__stdcall *Release)(IUnknown *this);
};*/

struct MaterialStreamRouting
{
  char source;
  char dest;
};

struct MaterialVertexStreamRouting
{
  MaterialStreamRouting data[16];
  ID3D11InputLayout *decl[20];
};

struct MaterialVertexDeclaration
{
  char streamCount;
  bool hasOptionalSource;
  bool isLoaded;
  MaterialVertexStreamRouting routing;
};

union MaterialArgumentLocation
{
  unsigned __int16 offset;
  struct
  {  
    char textureIndex;
    char samplerIndex;
  };
};

struct MaterialArgumentCodeConst
{
  unsigned __int16 index;
  char firstRow;
  char rowCount;
};

union MaterialArgumentDef
{
  /*const*/ float *literalConst;
  MaterialArgumentCodeConst codeConst;
  unsigned int codeSampler;
  unsigned int nameHash;
};

struct MaterialShaderArgument
{
  unsigned __int16 type;
  MaterialArgumentLocation location;
  unsigned __int16 size;
  unsigned __int16 buffer;
  MaterialArgumentDef u;
};

struct SndAlias
{
  const char *name;
  unsigned int id;
  const char *subtitle;
  const char *secondaryname;
  unsigned int assetId;
  const char *assetFileName;
  unsigned int flags0;
  unsigned int flags1;
  unsigned int duck;
  unsigned int contextType;
  unsigned int contextValue;
  unsigned int stopOnPlay;
  unsigned int futzPatch;
  unsigned __int16 fluxTime;
  unsigned __int16 startDelay;
  unsigned __int16 reverbSend;
  unsigned __int16 centerSend;
  unsigned __int16 volMin;
  unsigned __int16 volMax;
  unsigned __int16 pitchMin;
  unsigned __int16 pitchMax;
  unsigned __int16 distMin;
  unsigned __int16 distMax;
  unsigned __int16 distReverbMax;
  unsigned __int16 envelopMin;
  unsigned __int16 envelopMax;
  unsigned __int16 envelopPercentage;
  __int16 fadeIn;
  __int16 fadeOut;
  __int16 dopplerScale;
  char minPriorityThreshold;
  char maxPriorityThreshold;
  char probability;
  char occlusionLevel;
  char minPriority;
  char maxPriority;
  char pan;
  char limitCount;
  char entityLimitCount;
  char duckGroup;
};

struct __declspec(align(4)) pathlink_s
{
  float fDist;
  unsigned __int16 nodeNum;
  char disconnectCount;
  char negotiationLink;
  char flags;
  char ubBadPlaceCount[5];
};

struct GfxAabbTree
{
  vec3_t mins;
  vec3_t maxs;
  unsigned __int16 childCount;
  unsigned __int16 surfaceCount;
  unsigned __int16 startSurfIndex;
  unsigned __int16 smodelIndexCount;
  unsigned __int16 *smodelIndexes;
  int childrenOffset;
};

struct GfxPortalWritable
{
  bool isQueued;
  bool isAncestor;
  char recursionDepth;
  char hullPointCount;
  vec2_t *hullPoints;
  GfxPortal *queuedParent;
};

struct DpvsPlane
{
  vec4_t coeffs;
  char side[3];
  char pad;
};

struct GfxPortal
{
  GfxPortalWritable writable;
  DpvsPlane plane;
  GfxCell *cell;
  vec3_t *vertices;
  char vertexCount;
  vec3_t hullAxis[2];
  vec3_t bounds[2];
};

struct GfxReflectionProbeVolumeData
{
  vec4_t volumePlanes[6];
};

struct SSkinShaders
{
  char *pixelShaderAlign;
  char *pixelShader;
  char *vertexShader;
  int pixelShaderSize;
  int vertexShaderSize;
};

struct SSkinModel
{
  int numVerts;
  int numTris;
  SSkinVert *verts;
  unsigned __int16 *tris;
};

struct SSkinAnim
{
  int bones;
  int width;
  int frames;
  float *data;
};

struct half
{
  unsigned __int16 v;
};

union half4
{
  struct
  {
    half x;
    half y;
    half z;
    half w;
  };
  unsigned __int64 v;
};

union half2
{
  struct
  {
    half x;
    half y;
  };
  unsigned int v;
};

struct SSkinVert
{
  half4 pos_bone;
  PackedUnitVec normal;
  half2 uv;
};

struct GfxLightRegionHull
{
  float kdopMidPoint[9];
  float kdopHalfSize[9];
  unsigned int axisCount;
  GfxLightRegionAxis *axis;
};

struct GenericEventScript
{
  ScriptCondition *prerequisites;
  ExpressionStatement condition;
  int type;
  bool fireOnTrue;
  const char *action;
  int blockID;
  int constructID;
  GenericEventScript *next;
};

enum dvarType_t
{
  DVAR_TYPE_INVALID = 0x0,
  DVAR_TYPE_BOOL = 0x1,
  DVAR_TYPE_FLOAT = 0x2,
  DVAR_TYPE_FLOAT_2 = 0x3,
  DVAR_TYPE_FLOAT_3 = 0x4,
  DVAR_TYPE_FLOAT_4 = 0x5,
  DVAR_TYPE_INT = 0x6,
  DVAR_TYPE_ENUM = 0x7,
  DVAR_TYPE_STRING = 0x8,
  DVAR_TYPE_COLOR = 0x9,
  DVAR_TYPE_INT64 = 0xA,
  DVAR_TYPE_LINEAR_COLOR_RGB = 0xB,
  DVAR_TYPE_COLOR_XYZ = 0xC,
  DVAR_TYPE_COUNT = 0xD,
};

union DvarValue
{
  bool enabled;
  int integer;
  unsigned int unsignedInt;
  __int64 integer64;
  unsigned __int64 unsignedInt64;
  float value;
  vec4_t vector;
  const char *string;
  char color[4];
};

union DvarLimits
{
  struct
  {
    int stringCount;
    const char **strings;
  } enumeration;

  struct
  {
    int min;
    int max;
  } integer;

  struct
  {
    __int64 min;
    __int64 max;
  } integer64;

  struct
  {
    float min;
    float max;
  } value;

  struct
  {
    float min;
    float max;
  } vector;
};

struct __declspec(align(8)) dvar_t
{
  const char *name;
  const char *description;
  int hash;
  unsigned int flags;
  dvarType_t type;
  bool modified;
  DvarValue current;
  DvarValue latched;
  DvarValue reset;
  DvarLimits domain;
  dvar_t *hashNext;
};

union textDefData_t
{
  focusItemDef_s *focusItemDef;
  gameMsgDef_s *gameMsgDef;
  void *data;
};

struct textDef_s
{
  rectDef_s textRect[1];
  int alignment;
  int fontEnum;
  int itemFlags;
  int textAlignMode;
  float textalignx;
  float textaligny;
  float textscale;
  float textpadding;
  int textStyle;
  vec4_t fontColor;
  vec4_t glowColor;
  vec4_t shadowColor;
  float fontBlur;
  float glowSize;
  float shadowSize;
  vec2_t shadowOffset;
  const char *text;
  textExp_s *textExpData;
  textDefData_t textTypeData;
};

struct imageDef_s
{
  ExpressionStatement materialExp;
};

union focusDefData_t
{
  listBoxDef_s *listBox;
  multiDef_s *multi;
  profileMultiDef_s *profileMulti;
  editFieldDef_s *editField;
  enumDvarDef_s *enumDvar;
  void *data;
};

struct focusItemDef_s
{
  const char *mouseEnterText;
  const char *mouseExitText;
  const char *mouseEnter;
  const char *mouseExit;
  ItemKeyHandler *onKey;
  focusDefData_t focusTypeData;
};

struct ownerDrawDef_s
{
  ExpressionStatement dataExp;
};

struct rectData_s
{
  ExpressionStatement rectXExp;
  ExpressionStatement rectYExp;
  ExpressionStatement rectWExp;
  ExpressionStatement rectHExp;
};

struct animParamsDef_t
{
  const char *name;
  rectDef_s rectClient;
  float borderSize;
  vec4_t foreColor;
  vec4_t backColor;
  vec4_t borderColor;
  vec4_t outlineColor;
  float textScale;
  float rotation;
  GenericEventHandler *onEvent;
};

struct UIAnimInfo
{
  int animStateCount;
  animParamsDef_t **animStates;
  animParamsDef_t currentAnimState;
  animParamsDef_t nextAnimState;
  int animating;
  int animStartTime;
  int animDuration;
};

struct flameTable
{
  float flameVar_streamChunkGravityStart;
  float flameVar_streamChunkGravityEnd;
  float flameVar_streamChunkMaxSize;
  float flameVar_streamChunkStartSize;
  float flameVar_streamChunkEndSize;
  float flameVar_streamChunkStartSizeRand;
  float flameVar_streamChunkEndSizeRand;
  float flameVar_streamChunkDistScalar;
  float flameVar_streamChunkDistSwayScale;
  float flameVar_streamChunkDistSwayVelMax;
  float flameVar_streamChunkSpeed;
  float flameVar_streamChunkDecel;
  float flameVar_streamChunkVelocityAddScale;
  float flameVar_streamChunkDuration;
  float flameVar_streamChunkDurationScaleMaxVel;
  float flameVar_streamChunkDurationVelScalar;
  float flameVar_streamChunkSizeSpeedScale;
  float flameVar_streamChunkSizeAgeScale;
  float flameVar_streamChunkSpawnFireIntervalStart;
  float flameVar_streamChunkSpawnFireIntervalEnd;
  float flameVar_streamChunkSpawnFireMinLifeFrac;
  float flameVar_streamChunkSpawnFireMaxLifeFrac;
  float flameVar_streamChunkFireMinLifeFrac;
  float flameVar_streamChunkFireMinLifeFracStart;
  float flameVar_streamChunkFireMinLifeFracEnd;
  float flameVar_streamChunkDripsMinLifeFrac;
  float flameVar_streamChunkDripsMinLifeFracStart;
  float flameVar_streamChunkDripsMinLifeFracEnd;
  float flameVar_streamChunkRotationRange;
  float flameVar_streamSizeRandSinWave;
  float flameVar_streamSizeRandCosWave;
  float flameVar_streamDripsChunkInterval;
  float flameVar_streamDripsChunkMinFrac;
  float flameVar_streamDripsChunkRandFrac;
  float flameVar_streamSmokeChunkInterval;
  float flameVar_streamSmokeChunkMinFrac;
  float flameVar_streamSmokeChunkRandFrac;
  float flameVar_streamChunkCullDistSizeFrac;
  float flameVar_streamChunkCullMinLife;
  float flameVar_streamChunkCullMaxLife;
  float flameVar_streamFuelSizeStart;
  float flameVar_streamFuelSizeEnd;
  float flameVar_streamFuelLength;
  float flameVar_streamFuelNumSegments;
  float flameVar_streamFuelAnimLoopTime;
  float flameVar_streamFlameSizeStart;
  float flameVar_streamFlameSizeEnd;
  float flameVar_streamFlameLength;
  float flameVar_streamFlameNumSegments;
  float flameVar_streamFlameAnimLoopTime;
  float flameVar_streamPrimaryLightRadius;
  float flameVar_streamPrimaryLightRadiusFlutter;
  float flameVar_streamPrimaryLightR;
  float flameVar_streamPrimaryLightG;
  float flameVar_streamPrimaryLightB;
  float flameVar_streamPrimaryLightFlutterR;
  float flameVar_streamPrimaryLightFlutterG;
  float flameVar_streamPrimaryLightFlutterB;
  float flameVar_fireLife;
  float flameVar_fireLifeRand;
  float flameVar_fireSpeedScale;
  float flameVar_fireSpeedScaleRand;
  float flameVar_fireVelocityAddZ;
  float flameVar_fireVelocityAddZRand;
  float flameVar_fireVelocityAddSideways;
  float flameVar_fireGravity;
  float flameVar_fireGravityEnd;
  float flameVar_fireMaxRotVel;
  float flameVar_fireFriction;
  float flameVar_fireEndSizeAdd;
  float flameVar_fireStartSizeScale;
  float flameVar_fireEndSizeScale;
  float flameVar_fireBrightness;
  float flameVar_dripsLife;
  float flameVar_dripsLifeRand;
  float flameVar_dripsSpeedScale;
  float flameVar_dripsSpeedScaleRand;
  float flameVar_dripsVelocityAddZ;
  float flameVar_dripsVelocityAddZRand;
  float flameVar_dripsVelocityAddSideways;
  float flameVar_dripsGravity;
  float flameVar_dripsGravityEnd;
  float flameVar_dripsMaxRotVel;
  float flameVar_dripsFriction;
  float flameVar_dripsEndSizeAdd;
  float flameVar_dripsStartSizeScale;
  float flameVar_dripsEndSizeScale;
  float flameVar_dripsBrightness;
  float flameVar_smokeLife;
  float flameVar_smokeLifeRand;
  float flameVar_smokeSpeedScale;
  float flameVar_smokeVelocityAddZ;
  float flameVar_smokeGravity;
  float flameVar_smokeGravityEnd;
  float flameVar_smokeMaxRotation;
  float flameVar_smokeMaxRotVel;
  float flameVar_smokeFriction;
  float flameVar_smokeEndSizeAdd;
  float flameVar_smokeStartSizeAdd;
  float flameVar_smokeOriginSizeOfsZScale;
  float flameVar_smokeOriginOfsZ;
  float flameVar_smokeFadein;
  float flameVar_smokeFadeout;
  float flameVar_smokeMaxAlpha;
  float flameVar_smokeBrightness;
  float flameVar_smokeOriginOffset;
  float flameVar_collisionSpeedScale;
  float flameVar_collisionVolumeScale;
  const char *name;
  Material *fire;
  Material *smoke;
  Material *heat;
  Material *drips;
  Material *streamFuel;
  Material *streamFuel2;
  Material *streamFlame;
  Material *streamFlame2;
  const char *flameOffLoopSound;
  const char *flameIgniteSound;
  const char *flameOnLoopSound;
  const char *flameCooldownSound;
};

struct WeaponCamoMaterial
{
  unsigned __int16 replaceFlags;
  unsigned __int16 numBaseMaterials;
  Material **baseMaterials;
  Material **camoMaterials;
  float shaderConsts[8];
};

struct FxElemVec3Range
{
  vec3_t base;
  vec3_t amplitude;
};

struct FxElemVelStateInFrame
{
  FxElemVec3Range velocity;
  FxElemVec3Range totalDelta;
};

const struct FxElemVelStateSample
{
  FxElemVelStateInFrame local;
  FxElemVelStateInFrame world;
};

struct FxElemVisualState
{
  char color[4];
  float rotationDelta;
  float rotationTotal;
  float size[2];
  float scale;
};

const struct FxElemVisStateSample
{
  FxElemVisualState base;
  FxElemVisualState amplitude;
};

struct FxElemMarkVisuals
{
  Material *materials[2];
};

struct FxTrailDef
{
  int scrollTimeMsec;
  int repeatDist;
  int splitDist;
  int vertCount;
  FxTrailVertex *verts;
  int indCount;
  unsigned __int16 *inds;
};

struct FxSpotLightDef
{
  float fovInnerFraction;
  float startRadius;
  float endRadius;
};

struct ddlStructDef_t
{
  const char *name;
  int size;
  int memberCount;
  ddlMemberDef_t *members;
  ddlHash_t *hashTable;
};

struct ddlEnumDef_t
{
  const char *name;
  int memberCount;
  const char **members;
  ddlHash_t *hashTable;
};

struct GlassDef
{
  const char *name;
  int maxHealth;
  float thickness;
  float minShardSize;
  float maxShardSize;
  float shardLifeProbablility;
  int maxShards;
  Material *pristineMaterial;
  Material *crackedMaterial;
  Material *shardMaterial;
  const char *crackSound;
  const char *shatterShound;
  const char *autoShatterShound;
  FxEffectDef *crackEffect;
  FxEffectDef *shatterEffect;
};

struct XSurfaceCollisionTree
{
  vec3_t trans;
  vec3_t scale;
  unsigned int nodeCount;
  XSurfaceCollisionNode *nodes;
  unsigned int leafCount;
  XSurfaceCollisionLeaf *leafs;
};

struct PhysGeomInfo
{
  BrushWrapper *brush;
  int type;
  vec3_t orientation[3];
  vec3_t offset;
  vec3_t halfLengths;
};

/*struct __cppobj ID3D11InputLayout : ID3D11DeviceChild
{
};*/

struct GfxLightRegionAxis
{
  vec3_t dir;
  float midPoint;
  float halfSize;
};

struct ScriptCondition
{
  bool fireOnTrue;
  int constructID;
  int blockID;
  ScriptCondition *next;
};

struct textExp_s
{
  ExpressionStatement textExp;
};

struct gameMsgDef_s
{
  int gameMsgWindowIndex;
  int gameMsgWindowMode;
};

struct columnInfo_s
{
  int elementStyle;
  int maxChars;
  rectDef_s rect;
};

struct listBoxDef_s
{
  int mousePos;
  int cursorPos[1];
  int startPos[1];
  int endPos[1];
  int drawPadding;
  float elementWidth;
  float elementHeight;
  int numColumns;
  float special;
  columnInfo_s columnInfo[16];
  int notselectable;
  int noScrollBars;
  int usePaging;
  vec4_t selectBorder;
  vec4_t disableColor;
  vec4_t focusColor;
  vec4_t elementHighlightColor;
  vec4_t elementBackgroundColor;
  Material *selectIcon;
  Material *backgroundItemListbox;
  Material *highlightTexture;
  int noBlinkingHighlight;
  MenuRow *rows;
  int maxRows;
  int rowCount;
};

struct multiDef_s
{
  const char *dvarList[32];
  const char *dvarStr[32];
  float dvarValue[32];
  int count;
  int actionOnEnterPressOnly;
  int strDef;
};

struct profileMultiDef_s
{
  const char *profileVarList[32];
  const char *profileVarStr[32];
  float profileVarValue[32];
  int count;
  int actionOnEnterPressOnly;
  int strDef;
};

struct editFieldDef_s
{
  int cursorPos[1];
  float minVal;
  float maxVal;
  float defVal;
  float range;
  int maxChars;
  int maxCharsGotoNext;
  int maxPaintChars;
  int paintOffset;
};

struct enumDvarDef_s
{
  const char *enumDvarName;
};

struct FxTrailVertex
{
  vec2_t pos;
  vec2_t normal;
  float texCoord;
};

struct ddlMemberDef_t
{
  const char *name;
  int size;
  int offset;
  int type;
  int externalIndex;
  unsigned int rangeLimit;
  unsigned int serverDelta;
  unsigned int clientDelta;
  int arraySize;
  int enumIndex;
  int permission;
};

struct ddlHash_t
{
  int hash;
  int index;
};

struct XSurfaceCollisionAabb
{
  unsigned __int16 mins[3];
  unsigned __int16 maxs[3];
};

struct XSurfaceCollisionNode
{
  XSurfaceCollisionAabb aabb;
  unsigned __int16 childBeginIndex;
  unsigned __int16 childCount;
};

struct XSurfaceCollisionLeaf
{
  unsigned __int16 triangleBeginIndex;
};

struct BrushWrapper
{
  vec3_t mins;
  int contents;
  vec3_t maxs;
  unsigned int numsides;
  cbrushside_t *sides;
  int axial_cflags[2][3];
  int axial_sflags[2][3];
  unsigned int numverts;
  vec3_t *verts;
  cplane_s *planes;
};

struct MenuRow
{
  MenuCell *cells;
  char *eventName;
  char *onFocusEventName;
  bool disableArg;
  int status;
  int name;
};

struct MenuCell
{
  int type;
  int maxChars;
  char *stringValue;
};