#pragma once #ifndef __IW4_ASSETS_H #define __IW4_ASSETS_H #ifndef __zonecodegenerator namespace IW4 { #endif enum XAssetType { ASSET_TYPE_PHYSPRESET = 0x0, ASSET_TYPE_PHYSCOLLMAP = 0x1, ASSET_TYPE_XANIMPARTS = 0x2, ASSET_TYPE_XMODEL_SURFS = 0x3, ASSET_TYPE_XMODEL = 0x4, ASSET_TYPE_MATERIAL = 0x5, ASSET_TYPE_PIXELSHADER = 0x6, ASSET_TYPE_VERTEXSHADER = 0x7, ASSET_TYPE_VERTEXDECL = 0x8, ASSET_TYPE_TECHNIQUE_SET = 0x9, ASSET_TYPE_IMAGE = 0xA, ASSET_TYPE_SOUND = 0xB, ASSET_TYPE_SOUND_CURVE = 0xC, ASSET_TYPE_LOADED_SOUND = 0xD, ASSET_TYPE_CLIPMAP_SP = 0xE, ASSET_TYPE_CLIPMAP_MP = 0xF, ASSET_TYPE_COMWORLD = 0x10, ASSET_TYPE_GAMEWORLD_SP = 0x11, ASSET_TYPE_GAMEWORLD_MP = 0x12, ASSET_TYPE_MAP_ENTS = 0x13, ASSET_TYPE_FXWORLD = 0x14, ASSET_TYPE_GFXWORLD = 0x15, ASSET_TYPE_LIGHT_DEF = 0x16, ASSET_TYPE_UI_MAP = 0x17, ASSET_TYPE_FONT = 0x18, ASSET_TYPE_MENULIST = 0x19, ASSET_TYPE_MENU = 0x1A, ASSET_TYPE_LOCALIZE_ENTRY = 0x1B, ASSET_TYPE_WEAPON = 0x1C, ASSET_TYPE_SNDDRIVER_GLOBALS = 0x1D, ASSET_TYPE_FX = 0x1E, ASSET_TYPE_IMPACT_FX = 0x1F, ASSET_TYPE_AITYPE = 0x20, ASSET_TYPE_MPTYPE = 0x21, ASSET_TYPE_CHARACTER = 0x22, ASSET_TYPE_XMODELALIAS = 0x23, ASSET_TYPE_RAWFILE = 0x24, ASSET_TYPE_STRINGTABLE = 0x25, ASSET_TYPE_LEADERBOARD = 0x26, ASSET_TYPE_STRUCTURED_DATA_DEF = 0x27, ASSET_TYPE_TRACER = 0x28, ASSET_TYPE_VEHICLE = 0x29, ASSET_TYPE_ADDON_MAP_ENTS = 0x2A, ASSET_TYPE_COUNT, ASSET_TYPE_STRING = ASSET_TYPE_COUNT, ASSET_TYPE_ASSETLIST = 0x2C, ASSET_TYPE_FULLCOUNT }; enum XFileBlock { XFILE_BLOCK_TEMP, XFILE_BLOCK_PHYSICAL, XFILE_BLOCK_RUNTIME, XFILE_BLOCK_VIRTUAL, XFILE_BLOCK_LARGE, XFILE_BLOCK_CALLBACK, XFILE_BLOCK_VERTEX, XFILE_BLOCK_INDEX, MAX_XFILE_COUNT, }; struct PhysPreset; struct PhysCollmap; struct XAnimParts; struct XModel; struct Material; struct MaterialPixelShader; struct MaterialVertexShader; struct MaterialVertexDeclaration; struct MaterialTechniqueSet; struct GfxImage; struct snd_alias_list_t; struct SndCurve; struct LoadedSound; struct clipMap_t; // struct ComWorld; // struct GameWorldSp; // struct GameWorldMp; struct MapEnts; // struct FxWorld; // struct GfxWorld; struct GfxLightDef; struct Font_s; struct MenuList; struct menuDef_t; struct LocalizeEntry; struct WeaponCompleteDef; // struct SndDriverGlobals; struct FxEffectDef; struct FxImpactTable; struct RawFile; struct StringTable; struct LeaderboardDef; struct StructuredDataDefSet; struct TracerDef; struct VehicleDef; struct AddonMapEnts; union XAssetHeader { PhysPreset* physPreset; PhysCollmap* physCollmap; XAnimParts* parts; // XModelSurfs* modelSurfs; // NOT AN ASSET XModel* model; Material* material; MaterialPixelShader* pixelShader; MaterialVertexShader* vertexShader; MaterialVertexDeclaration* vertexDecl; MaterialTechniqueSet* techniqueSet; GfxImage* image; snd_alias_list_t* sound; SndCurve* sndCurve; LoadedSound* loadSnd; clipMap_t* clipMap; // ComWorld* comWorld; // GameWorldSp* gameWorldSp; // GameWorldMp* gameWorldMp; MapEnts* mapEnts; // FxWorld* fxWorld; // GfxWorld* gfxWorld; GfxLightDef* lightDef; Font_s* font; MenuList* menuList; menuDef_t* menu; LocalizeEntry* localize; WeaponCompleteDef* weapon; // SndDriverGlobals* sndDriverGlobals; // UNUSED ON PC FxEffectDef* fx; FxImpactTable* impactFx; RawFile* rawfile; StringTable* stringTable; LeaderboardDef* leaderboardDef; StructuredDataDefSet* structuredDataDefSet; TracerDef* tracerDef; VehicleDef* vehDef; AddonMapEnts* addonMapEnts; void* data; }; typedef char cbrushedge_t; typedef float vec2_t[2]; typedef float vec3_t[3]; struct PhysPreset { const char* name; int type; float mass; float bounce; float friction; float bulletForceScale; float explosiveForceScale; const char* sndAliasPrefix; float piecesSpreadFraction; float piecesUpwardVelocity; bool tempDefaultToCylinder; bool perSurfaceSndAlias; }; struct Bounds { float midPoint[3]; float halfSize[3]; }; struct cplane_s { float normal[3]; float dist; char type; char pad[3]; }; struct cbrushside_t { cplane_s* plane; unsigned __int16 materialNum; char firstAdjacentSideOffset; char edgeCount; }; struct cbrushWrapper_t { unsigned __int16 numsides; unsigned __int16 glassPieceIndex; cbrushside_t* sides; cbrushedge_t* baseAdjacentSide; __int16 axialMaterialNum[2][3]; char firstAdjacentSideOffsets[2][3]; char edgeCount[2][3]; }; struct BrushWrapper { Bounds bounds; cbrushWrapper_t brush; int totalEdgeCount; cplane_s* planes; }; struct PhysGeomInfo { BrushWrapper* brushWrapper; int type; float orientation[3][3]; Bounds bounds; }; struct PhysMass { float centerOfMass[3]; float momentsOfInertia[3]; float productsOfInertia[3]; }; struct PhysCollmap { const char* name; unsigned int count; PhysGeomInfo* geoms; PhysMass mass; Bounds bounds; }; union XAnimIndices { char* _1; unsigned __int16* _2; void* data; }; struct XAnimNotifyInfo { unsigned __int16 name; float time; }; union XAnimDynamicFrames { char (*_1)[3]; unsigned __int16 (*_2)[3]; }; union XAnimDynamicIndices { char _1[1]; unsigned __int16 _2[1]; }; struct __declspec(align(4)) XAnimPartTransFrames { float mins[3]; float size[3]; 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 XAnimDeltaPartQuatDataFrames { __int16 (*frames)[4]; XAnimDynamicIndices indices; }; union XAnimDeltaPartQuatData { XAnimDeltaPartQuatDataFrames frames; __int16 frame0[4]; }; struct XAnimDeltaPartQuat { unsigned __int16 size; XAnimDeltaPartQuatData u; }; struct XAnimDeltaPart { XAnimPartTrans* trans; XAnimDeltaPartQuat2* quat2; XAnimDeltaPartQuat* quat; }; struct XAnimParts { const char* name; unsigned __int16 dataByteCount; unsigned __int16 dataShortCount; unsigned __int16 dataIntCount; unsigned __int16 randomDataByteCount; unsigned __int16 randomDataIntCount; unsigned __int16 numframes; char flags; char boneCount[10]; char notifyCount; char assetType; bool isDefault; unsigned int randomDataShortCount; unsigned int indexCount; float framerate; float frequency; unsigned __int16* names; char* dataByte; __int16* dataShort; int* dataInt; __int16* randomDataShort; char* randomDataByte; int* randomDataInt; XAnimIndices indices; XAnimNotifyInfo* notify; XAnimDeltaPart* deltaPart; }; struct XSurfaceVertexInfo { __int16 vertCount[4]; unsigned __int16* vertsBlend; }; union GfxColor { unsigned int packed; char array[4]; }; union PackedTexCoords { unsigned int packed; }; union PackedUnitVec { unsigned int packed; char array[4]; }; struct __declspec(align(16)) GfxPackedVertex { float xyz[3]; float binormalSign; GfxColor color; PackedTexCoords texCoord; PackedUnitVec normal; PackedUnitVec tangent; }; struct XSurfaceCollisionAabb { unsigned __int16 mins[3]; unsigned __int16 maxs[3]; }; struct __declspec(align(16)) XSurfaceCollisionNode { XSurfaceCollisionAabb aabb; unsigned __int16 childBeginIndex; unsigned __int16 childCount; }; struct XSurfaceCollisionLeaf { unsigned __int16 triangleBeginIndex; }; struct XSurfaceCollisionTree { float trans[3]; float scale[3]; unsigned int nodeCount; XSurfaceCollisionNode* nodes; unsigned int leafCount; XSurfaceCollisionLeaf* leafs; }; struct XRigidVertList { unsigned __int16 boneOffset; unsigned __int16 vertCount; unsigned __int16 triOffset; unsigned __int16 triCount; XSurfaceCollisionTree* collisionTree; }; typedef __declspec(align(16)) unsigned __int16 r_index16_t; struct XSurface { char tileMode; bool deformed; unsigned __int16 vertCount; unsigned __int16 triCount; char zoneHandle; unsigned __int16 baseTriIndex; unsigned __int16 baseVertIndex; r_index16_t (*triIndices)[3]; XSurfaceVertexInfo vertInfo; GfxPackedVertex* verts0; unsigned int vertListCount; XRigidVertList* vertList; int partBits[6]; }; struct XModelSurfs { const char* name; XSurface* surfs; unsigned __int16 numsurfs; int partBits[6]; }; struct XModelLodInfo { float dist; unsigned __int16 numsurfs; unsigned __int16 surfIndex; XModelSurfs* modelSurfs; int partBits[6]; XSurface* surfs; char lod; char smcBaseIndexPlusOne; char smcSubIndexMask; char smcBucket; }; struct XModelCollTri_s { float plane[4]; float svec[4]; float tvec[4]; }; struct XModelCollSurf_s { XModelCollTri_s* collTris; int numCollTris; Bounds bounds; int boneIdx; int contents; int surfFlags; }; struct XBoneInfo { Bounds bounds; float radiusSquared; }; struct DObjAnimMat { float quat[4]; float trans[3]; float transWeight; }; struct XModel { const char* name; char numBones; char numRootBones; char numsurfs; char lodRampType; float scale; unsigned int noScalePartBits[6]; unsigned __int16* boneNames; char* parentList; __int16* quats; float* trans; char* partClassification; DObjAnimMat* baseMat; Material** materialHandles; XModelLodInfo lodInfo[4]; char maxLoadedLod; char numLods; char collLod; char flags; XModelCollSurf_s* collSurfs; int numCollSurfs; int contents; XBoneInfo* boneInfo; float radius; Bounds bounds; int memUsage; bool bad; PhysPreset* physPreset; PhysCollmap* physCollmap; }; struct WaterWritable { float floatTime; }; struct complex_s { float real; float imag; }; struct water_t { WaterWritable writable; complex_s* H0; float* wTerm; int M; int N; float Lx; float Lz; float gravity; float windvel; float winddir[2]; float amplitude; float codeConstant[4]; GfxImage* image; }; union MaterialTextureDefInfo { GfxImage* image; water_t* water; }; struct MaterialTextureDef { unsigned int nameHash; char nameStart; char nameEnd; char samplerState; char semantic; MaterialTextureDefInfo u; }; struct __declspec(align(16)) MaterialConstantDef { unsigned int nameHash; char name[12]; float literal[4]; }; struct GfxStateBits { unsigned int loadBits[2]; }; struct GfxDrawSurfFields { unsigned __int64 objectId : 16; unsigned __int64 reflectionProbeIndex : 8; unsigned __int64 hasGfxEntIndex : 1; unsigned __int64 customIndex : 5; unsigned __int64 materialSortedIndex : 12; unsigned __int64 prepass : 2; unsigned __int64 useHeroLighting : 1; unsigned __int64 sceneLightIndex : 8; unsigned __int64 surfType : 4; unsigned __int64 primarySortKey : 6; unsigned __int64 unused : 1; }; union GfxDrawSurf { GfxDrawSurfFields fields; unsigned __int64 packed; }; struct MaterialInfo { const char* name; char gameFlags; char sortKey; char textureAtlasRowCount; char textureAtlasColumnCount; GfxDrawSurf drawSurf; unsigned int surfaceTypeBits; unsigned __int16 hashIndex; }; struct Material { MaterialInfo info; char stateBitsEntry[48]; char textureCount; char constantCount; char stateBitsCount; char stateFlags; char cameraRegion; MaterialTechniqueSet* techniqueSet; MaterialTextureDef* textureTable; MaterialConstantDef* constantTable; GfxStateBits* stateBitsTable; }; struct __declspec(align(4)) GfxImageLoadDef { char levelCount; char pad[3]; int flags; int format; int resourceSize; char data[1]; }; union GfxTexture { // IDirect3DBaseTexture9* basemap; // IDirect3DTexture9* map; // IDirect3DVolumeTexture9* volmap; // IDirect3DCubeTexture9* cubemap; Texture* texture; GfxImageLoadDef* loadDef; }; struct Picmip { char platform[2]; }; struct CardMemory { int platform[2]; }; enum TextureSemantic { TS_2D = 0x0, TS_FUNCTION = 0x1, TS_COLOR_MAP = 0x2, TS_DETAIL_MAP = 0x3, TS_UNUSED_2 = 0x4, TS_NORMAL_MAP = 0x5, TS_UNUSED_3 = 0x6, TS_UNUSED_4 = 0x7, TS_SPECULAR_MAP = 0x8, TS_UNUSED_5 = 0x9, TS_UNUSED_6 = 0xA, TS_WATER_MAP = 0xB, }; struct GfxImage { GfxTexture texture; char mapType; char semantic; char category; bool useSrgbReads; Picmip picmip; bool noPicmip; char track; CardMemory cardMemory; unsigned __int16 width; unsigned __int16 height; unsigned __int16 depth; bool delayLoadPixels; const char* name; }; struct GfxPixelShaderLoadDef { unsigned int* program; unsigned __int16 programSize; unsigned __int16 loadForRenderer; }; struct GfxVertexShaderLoadDef { unsigned int* program; unsigned __int16 programSize; unsigned __int16 loadForRenderer; }; struct MaterialStreamRouting { char source; char dest; }; struct MaterialVertexStreamRouting { MaterialStreamRouting data[13]; void/*IDirect3DVertexDeclaration9*/* decl[16]; }; struct MaterialVertexDeclaration { const char* name; char streamCount; bool hasOptionalSource; MaterialVertexStreamRouting routing; }; struct MaterialVertexShaderProgram { void/*IDirect3DVertexShader9*/* vs; GfxVertexShaderLoadDef loadDef; }; struct MaterialVertexShader { const char* name; MaterialVertexShaderProgram prog; }; struct MaterialPixelShaderProgram { void/*IDirect3DPixelShader9*/* ps; GfxPixelShaderLoadDef loadDef; }; struct MaterialPixelShader { const char* name; MaterialPixelShaderProgram prog; }; struct MaterialArgumentCodeConst { unsigned __int16 index; char firstRow; char rowCount; }; union MaterialArgumentDef { const float (*literalConst)[4]; MaterialArgumentCodeConst codeConst; unsigned int codeSampler; unsigned int nameHash; }; enum MaterialShaderArgumentType { MTL_ARG_MATERIAL_VERTEX_CONST = 0x0, MTL_ARG_LITERAL_VERTEX_CONST = 0x1, MTL_ARG_MATERIAL_PIXEL_SAMPLER = 0x2, MTL_ARG_CODE_PRIM_BEGIN = 0x3, MTL_ARG_CODE_VERTEX_CONST = 0x3, MTL_ARG_CODE_PIXEL_SAMPLER = 0x4, MTL_ARG_CODE_PIXEL_CONST = 0x5, MTL_ARG_CODE_PRIM_END = 0x6, MTL_ARG_MATERIAL_PIXEL_CONST = 0x6, MTL_ARG_LITERAL_PIXEL_CONST = 0x7, MTL_ARG_COUNT = 0x8, }; struct MaterialShaderArgument { unsigned __int16 type; unsigned __int16 dest; MaterialArgumentDef u; }; struct MaterialPass { MaterialVertexDeclaration* vertexDecl; MaterialVertexShader* vertexShader; MaterialPixelShader* pixelShader; char perPrimArgCount; char perObjArgCount; char stableArgCount; char customSamplerFlags; MaterialShaderArgument* args; }; struct MaterialTechnique { const char* name; unsigned __int16 flags; unsigned __int16 passCount; MaterialPass passArray[1]; }; struct MaterialTechniqueSet { const char* name; char worldVertFormat; bool hasBeenUploaded; char unused[1]; MaterialTechniqueSet* remappedTechniqueSet; MaterialTechnique* techniques[48]; }; union RawFileBuffer { const char* compressedBuffer; const char* buffer; }; struct RawFile { const char* name; int compressedLen; int len; RawFileBuffer data; }; struct StringTableCell { const char* string; int hash; }; struct StringTable { const char* name; int columnCount; int rowCount; StringTableCell* values; }; struct _AILSOUNDINFO { int format; const void* data_ptr; unsigned int data_len; unsigned int rate; int bits; int channels; unsigned int samples; unsigned int block_size; const void* initial_ptr; }; struct MssSound { _AILSOUNDINFO info; char* data; }; struct LoadedSound { const char* name; MssSound sound; }; struct StreamedSound { const char* dir; const char* name; }; union SoundFileRef { LoadedSound* loadSnd; StreamedSound streamSnd; }; enum snd_alias_type_t : char { SAT_UNKNOWN = 0x0, SAT_LOADED = 0x1, SAT_STREAMED = 0x2, SAT_VOICED = 0x3, SAT_COUNT, }; struct SoundFile { snd_alias_type_t type; char exists; SoundFileRef u; }; struct MSSSpeakerLevels { int speaker; int numLevels; float levels[2]; }; struct MSSChannelMap { int speakerCount; MSSSpeakerLevels speakers[6]; }; struct SpeakerMap { bool isDefault; const char* name; MSSChannelMap channelMaps[2][2]; }; struct snd_alias_t { const char* aliasName; const char* subtitle; const char* secondaryAliasName; const char* chainAliasName; const char* mixerGroup; SoundFile* soundFile; int sequence; float volMin; float volMax; float pitchMin; float pitchMax; float distMin; float distMax; float velocityMin; int flags; union { float slavePercentage; float masterPercentage; }; float probability; float lfePercentage; float centerPercentage; int startDelay; SndCurve* volumeFalloffCurve; float envelopMin; float envelopMax; float envelopPercentage; SpeakerMap* speakerMap; }; struct snd_alias_list_t { const char* aliasName; snd_alias_t* head; int count; }; struct SndCurve { const char* filename; unsigned __int16 knotCount; float knots[16][2]; }; struct LocalizeEntry { const char* value; const char* name; }; struct StringList { int totalStrings; const char** strings; }; union DvarLimits { struct { int stringCount; const char** strings; } enumeration; struct { int min; int max; } integer; struct { float min; float max; } value; struct { float min; float max; } vector; }; union DvarValue { bool enabled; int integer; unsigned int unsignedInt; float value; float vector[4]; const char* string; char color[4]; }; struct dvar_t { const char* name; const char* description; unsigned int flags; char type; bool modified; DvarValue current; DvarValue latched; DvarValue reset; DvarLimits domain; //bool (__cdecl* domainFunc)(dvar_t*, DvarValue); void* domainFunc; dvar_t* hashNext; }; struct StaticDvar { dvar_t* dvar; char* dvarName; }; struct StaticDvarList { int numStaticDvars; StaticDvar** staticDvars; }; struct ExpressionString { const char* string; }; struct Statement_s; union operandInternalDataUnion { int intVal; float floatVal; ExpressionString stringVal; Statement_s* function; }; enum expDataType { VAL_INT = 0x0, VAL_FLOAT = 0x1, VAL_STRING = 0x2, NUM_INTERNAL_DATATYPES = 0x3, VAL_FUNCTION = 0x3, NUM_DATATYPES = 0x4, }; struct Operand { expDataType dataType; operandInternalDataUnion internals; }; union entryInternalData { int op; Operand operand; }; enum expressionEntryType : int { EET_OPERATOR = 0x0, EET_OPERAND = 0x1, }; struct expressionEntry { expressionEntryType type; entryInternalData data; }; struct ExpressionSupportingData; struct Statement_s { int numEntries; expressionEntry* entries; ExpressionSupportingData* supportingData; int lastExecuteTime; Operand lastResult; }; struct UIFunctionList { int totalFunctions; Statement_s** functions; }; struct ExpressionSupportingData { UIFunctionList uifunctions; StaticDvarList staticDvarList; StringList uiStrings; }; struct menuTransition { int transitionType; int targetField; int startTime; float startVal; float endVal; float time; int endTriggerType; }; struct ItemFloatExpression { int target; Statement_s* expression; }; struct columnInfo_s { int pos; int width; int maxChars; int alignment; }; struct MenuEventHandlerSet; struct ConditionalScript { MenuEventHandlerSet* eventHandlerSet; Statement_s* eventExpression; }; struct SetLocalVarData { const char* localVarName; Statement_s* expression; }; union EventData { const char* unconditionalScript; ConditionalScript* conditionalScript; MenuEventHandlerSet* elseScript; SetLocalVarData* setLocalVarData; }; enum EventType : char { EVENT_UNCONDITIONAL = 0x0, EVENT_IF = 0x1, EVENT_ELSE = 0x2, EVENT_SET_LOCAL_VAR_BOOL = 0x3, EVENT_SET_LOCAL_VAR_INT = 0x4, EVENT_SET_LOCAL_VAR_FLOAT = 0x5, EVENT_SET_LOCAL_VAR_STRING = 0x6, EVENT_COUNT, }; struct MenuEventHandler { EventData eventData; EventType eventType; }; struct MenuEventHandlerSet { int eventHandlerCount; MenuEventHandler** eventHandlers; }; struct listBoxDef_s { int mousePos; int startPos[1]; int endPos[1]; int drawPadding; float elementWidth; float elementHeight; int elementStyle; int numColumns; columnInfo_s columnInfo[16]; MenuEventHandlerSet* onDoubleClick; int notselectable; int noScrollBars; int usePaging; float selectBorder[4]; Material* selectIcon; }; struct editFieldDef_s { float minVal; float maxVal; float defVal; float range; int maxChars; int maxCharsGotoNext; int maxPaintChars; int paintOffset; }; struct multiDef_s { const char* dvarList[32]; const char* dvarStr[32]; float dvarValue[32]; int count; int strDef; }; struct newsTickerDef_s { int feedId; int speed; int spacing; int lastTime; int start; int end; float x; }; struct textScrollDef_s { int startTime; }; union itemDefData_t { listBoxDef_s* listBox; editFieldDef_s* editField; multiDef_s* multi; const char* enumDvarName; newsTickerDef_s* ticker; textScrollDef_s* scroll; void* data; }; struct ItemKeyHandler { int key; MenuEventHandlerSet* action; ItemKeyHandler* next; }; struct __declspec(align(4)) rectDef_s { float x; float y; float w; float h; char horzAlign; char vertAlign; }; struct windowDef_t { const char* name; rectDef_s rect; rectDef_s rectClient; const char* group; int style; int border; int ownerDraw; int ownerDrawFlags; float borderSize; int staticFlags; int dynamicFlags[1]; int nextTime; float foreColor[4]; float backColor[4]; float borderColor[4]; float outlineColor[4]; float disableColor[4]; Material* background; }; struct itemDef_s { windowDef_t window; rectDef_s textRect[1]; int type; int dataType; int alignment; int fontEnum; int textAlignMode; float textalignx; float textaligny; float textscale; int textStyle; int gameMsgWindowIndex; int gameMsgWindowMode; const char* text; int itemFlags; menuDef_t* parent; MenuEventHandlerSet* mouseEnterText; MenuEventHandlerSet* mouseExitText; MenuEventHandlerSet* mouseEnter; MenuEventHandlerSet* mouseExit; MenuEventHandlerSet* action; MenuEventHandlerSet* accept; MenuEventHandlerSet* onFocus; MenuEventHandlerSet* leaveFocus; const char* dvar; const char* dvarTest; ItemKeyHandler* onKey; const char* enableDvar; const char* localVar; int dvarFlags; snd_alias_list_t* focusSound; float special; int cursorPos[1]; itemDefData_t typeData; int imageTrack; int floatExpressionCount; ItemFloatExpression* floatExpressions; Statement_s* visibleExp; Statement_s* disabledExp; Statement_s* textExp; Statement_s* materialExp; float glowColor[4]; bool decayActive; int fxBirthTime; int fxLetterTime; int fxDecayStartTime; int fxDecayDuration; int lastSoundPlayedTime; }; struct menuDef_t { windowDef_t window; const char* font; int fullScreen; int itemCount; int fontIndex; int cursorItem[1]; int fadeCycle; float fadeClamp; float fadeAmount; float fadeInAmount; float blurRadius; MenuEventHandlerSet* onOpen; MenuEventHandlerSet* onCloseRequest; MenuEventHandlerSet* onClose; MenuEventHandlerSet* onESC; ItemKeyHandler* onKey; Statement_s* visibleExp; const char* allowedBinding; const char* soundName; int imageTrack; float focusColor[4]; Statement_s* rectXExp; Statement_s* rectYExp; Statement_s* rectWExp; Statement_s* rectHExp; Statement_s* openSoundExp; Statement_s* closeSoundExp; itemDef_s** items; menuTransition scaleTransition[1]; menuTransition alphaTransition[1]; menuTransition xTransition[1]; menuTransition yTransition[1]; ExpressionSupportingData* expressionData; }; struct MenuList { const char* name; int menuCount; menuDef_t** menus; }; enum FxElemType { FX_ELEM_TYPE_SPRITE_BILLBOARD = 0x0, FX_ELEM_TYPE_SPRITE_ORIENTED = 0x1, FX_ELEM_TYPE_TAIL = 0x2, FX_ELEM_TYPE_TRAIL = 0x3, FX_ELEM_TYPE_CLOUD = 0x4, FX_ELEM_TYPE_SPARK_CLOUD = 0x5, FX_ELEM_TYPE_SPARK_FOUNTAIN = 0x6, FX_ELEM_TYPE_MODEL = 0x7, FX_ELEM_TYPE_OMNI_LIGHT = 0x8, FX_ELEM_TYPE_SPOT_LIGHT = 0x9, FX_ELEM_TYPE_SOUND = 0xA, FX_ELEM_TYPE_DECAL = 0xB, FX_ELEM_TYPE_RUNNER = 0xC, FX_ELEM_TYPE_COUNT = 0xD, FX_ELEM_TYPE_LAST_SPRITE = 0x3, FX_ELEM_TYPE_LAST_DRAWN = 0x9, }; struct FxIntRange { int base; int amplitude; }; struct FxSpawnDefOneShot { FxIntRange count; }; struct FxSpawnDefLooping { int intervalMsec; int count; }; union FxSpawnDef { FxSpawnDefLooping looping; FxSpawnDefOneShot oneShot; }; struct FxFloatRange { float base; float amplitude; }; struct FxElemAtlas { char behavior; char index; char fps; char loopCount; char colIndexBits; char rowIndexBits; __int16 entryCount; }; struct FxElemVec3Range { float base[3]; float amplitude[3]; }; struct FxElemVelStateInFrame { FxElemVec3Range velocity; FxElemVec3Range totalDelta; }; struct FxElemVelStateSample { FxElemVelStateInFrame local; FxElemVelStateInFrame world; }; struct FxElemVisualState { char color[4]; float rotationDelta; float rotationTotal; float size[2]; float scale; }; struct FxElemVisStateSample { FxElemVisualState base; FxElemVisualState amplitude; }; union FxEffectDefRef { FxEffectDef* handle; const char* name; }; union FxElemVisuals { const void* anonymous; Material* material; XModel* model; FxEffectDefRef effectDef; const char* soundName; }; struct FxElemMarkVisuals { Material* materials[2]; }; union FxElemDefVisuals { FxElemMarkVisuals* markArray; FxElemVisuals* array; FxElemVisuals instance; }; struct FxTrailVertex { float pos[2]; float normal[2]; float texCoord; }; struct FxTrailDef { int scrollTimeMsec; int repeatDist; float invSplitDist; float invSplitArcDist; float invSplitTime; int vertCount; FxTrailVertex* verts; int indCount; unsigned __int16* inds; }; struct FxSparkFountainDef { float gravity; float bounceFrac; float bounceRand; float sparkSpacing; float sparkLength; int sparkCount; float loopTime; float velMin; float velMax; float velConeFrac; float restSpeed; float boostTime; float boostFactor; }; union FxElemExtendedDefPtr { FxTrailDef* trailDef; FxSparkFountainDef* sparkFountainDef; char* unknownDef; }; struct FxElemDef { int flags; FxSpawnDef spawn; FxFloatRange spawnRange; FxFloatRange fadeInRange; FxFloatRange fadeOutRange; float spawnFrustumCullRadius; FxIntRange spawnDelayMsec; FxIntRange lifeSpanMsec; FxFloatRange spawnOrigin[3]; FxFloatRange spawnOffsetRadius; FxFloatRange spawnOffsetHeight; FxFloatRange spawnAngles[3]; FxFloatRange angularVelocity[3]; FxFloatRange initialRotation; FxFloatRange gravity; FxFloatRange reflectionFactor; FxElemAtlas atlas; char elemType; char visualCount; char velIntervalCount; char visStateIntervalCount; FxElemVelStateSample* velSamples; FxElemVisStateSample* visSamples; FxElemDefVisuals visuals; Bounds collBounds; FxEffectDefRef effectOnImpact; FxEffectDefRef effectOnDeath; FxEffectDefRef effectEmitted; FxFloatRange emitDist; FxFloatRange emitDistVariance; FxElemExtendedDefPtr extended; char sortOrder; char lightingFrac; char useItemClip; char fadeInfo; }; struct FxEffectDef { const char* name; int flags; int totalSize; int msecLoopingLife; int elemDefCountLooping; int elemDefCountOneShot; int elemDefCountEmission; FxElemDef* elemDefs; }; struct GfxLightImage { GfxImage* image; char samplerState; }; struct GfxLightDef { const char* name; GfxLightImage attenuation; int lmapLookupStart; }; struct Glyph { unsigned __int16 letter; char x0; char y0; char dx; char pixelWidth; char pixelHeight; float s0; float t0; float s1; float t1; }; struct Font_s { const char* fontName; int pixelHeight; int glyphCount; Material* material; Material* glowMaterial; Glyph* glyphs; }; struct FxImpactEntry { FxEffectDef* nonflesh[31]; FxEffectDef* flesh[4]; }; struct FxImpactTable { const char* name; FxImpactEntry* table; }; 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_COUNT = 0x6, }; enum LbAggType { LBAGG_TYPE_MIN = 0x0, LBAGG_TYPE_MAX = 0x1, LBAGG_TYPE_SUM = 0x2, LBAGG_TYPE_LAST = 0x3, LBAGG_TYPE_COUNT = 0x4, }; struct LbColumnDef { const char* name; int id; int propertyId; bool hidden; const char* statName; LbColType type; int precision; LbAggType agg; }; struct LeaderboardDef { const char* name; int id; int columnCount; int xpColId; int prestigeColId; LbColumnDef* columns; }; struct TracerDef { const char* name; Material* material; unsigned int drawInterval; float speed; float beamLength; float beamWidth; float screwRadius; float screwDist; float colors[5][4]; }; enum StructuredDataTypeCategory { DATA_INT = 0x0, DATA_BYTE = 0x1, DATA_BOOL = 0x2, DATA_STRING = 0x3, DATA_ENUM = 0x4, DATA_STRUCT = 0x5, DATA_INDEXED_ARRAY = 0x6, DATA_ENUM_ARRAY = 0x7, DATA_FLOAT = 0x8, DATA_SHORT = 0x9, DATA_COUNT = 0xA, }; struct __declspec(align(4)) StructuredDataEnumEntry { const char* string; unsigned __int16 index; }; struct StructuredDataEnum { int entryCount; int reservedEntryCount; StructuredDataEnumEntry* entries; }; union StructuredDataTypeUnion { unsigned int stringDataLength; int enumIndex; int structIndex; int indexedArrayIndex; int enumedArrayIndex; }; struct StructuredDataType { StructuredDataTypeCategory type; StructuredDataTypeUnion u; }; struct StructuredDataStructProperty { const char* name; StructuredDataType type; unsigned int offset; }; struct StructuredDataStruct { int propertyCount; StructuredDataStructProperty* properties; int size; unsigned int bitOffset; }; struct StructuredDataIndexedArray { int arraySize; StructuredDataType elementType; unsigned int elementSize; }; struct StructuredDataEnumedArray { int enumIndex; StructuredDataType elementType; unsigned int elementSize; }; struct StructuredDataDef { int version; unsigned int formatChecksum; int enumCount; StructuredDataEnum* enums; int structCount; StructuredDataStruct* structs; int indexedArrayCount; StructuredDataIndexedArray* indexedArrays; int enumedArrayCount; StructuredDataEnumedArray* enumedArrays; StructuredDataType rootType; unsigned int size; }; struct StructuredDataDefSet { const char* name; unsigned int defCount; StructuredDataDef* defs; }; struct TriggerModel { int contents; unsigned __int16 hullCount; unsigned __int16 firstHull; }; struct TriggerHull { Bounds bounds; int contents; unsigned __int16 slabCount; unsigned __int16 firstSlab; }; struct TriggerSlab { float dir[3]; float midPoint; float halfSize; }; struct MapTriggers { unsigned int count; TriggerModel* models; unsigned int hullCount; TriggerHull* hulls; unsigned int slabCount; TriggerSlab* slabs; }; struct Stage { const char* name; float origin[3]; unsigned __int16 triggerIndex; char sunPrimaryLightIndex; }; struct MapEnts { const char* name; char* entityString; int numEntityChars; MapTriggers trigger; Stage* stages; char stageCount; }; struct AddonMapEnts { const char* name; char* entityString; int numEntityChars; MapTriggers trigger; }; typedef unsigned short LeafBrush; struct cStaticModel_s { XModel* xmodel; float origin[3]; float invScaledAxis[3][3]; Bounds absBounds; }; struct ClipMaterial { const char* name; int surfaceFlags; int contents; }; struct cNode_t { cplane_s* plane; __int16 children[2]; }; struct cLeafBrushNodeLeaf_t { LeafBrush* 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 CollisionBorder { float distEq[3]; float zBase; float zSlope; float start; float length; }; struct CollisionPartition { char triCount; char borderCount; char firstVertSegment; int firstTri; CollisionBorder* borders; }; union CollisionAabbTreeIndex { int firstChildIndex; int partitionIndex; }; struct __declspec(align(16)) CollisionAabbTree { float midPoint[3]; unsigned __int16 materialIndex; unsigned __int16 childCount; float halfSize[3]; CollisionAabbTreeIndex u; }; struct cLeaf_t { unsigned __int16 firstCollAabbIndex; unsigned __int16 collAabbCount; int brushContents; int terrainContents; Bounds bounds; int leafBrushNode; }; struct cmodel_t { Bounds bounds; float radius; cLeaf_t leaf; }; struct cbrush_t { unsigned __int16 numsides; unsigned __int16 glassPieceIndex; cbrushside_t* sides; char* baseAdjacentSide; __int16 axialMaterialNum[2][3]; char firstAdjacentSideOffsets[2][3]; char edgeCount[2][3]; }; struct SModelAabbNode { Bounds bounds; unsigned __int16 firstChild; unsigned __int16 childCount; }; struct GfxPlacement { float quat[4]; float origin[3]; }; enum DynEntityType { DYNENT_TYPE_INVALID = 0x0, DYNENT_TYPE_CLUTTER = 0x1, DYNENT_TYPE_DESTRUCT = 0x2, DYNENT_TYPE_COUNT = 0x3, }; struct DynEntityDef { DynEntityType type; GfxPlacement pose; XModel* xModel; unsigned __int16 brushModel; unsigned __int16 physicsBrushModel; FxEffectDef* destroyFx; PhysPreset* physPreset; int health; PhysMass mass; int contents; }; struct DynEntityPose { GfxPlacement pose; float radius; }; struct DynEntityClient { int physObjId; unsigned __int16 flags; unsigned __int16 lightingHandle; int health; }; struct DynEntityColl { unsigned __int16 sector; unsigned __int16 nextEntInSector; float linkMins[2]; float linkMaxs[2]; }; typedef __declspec(align(128)) cbrush_t cbrush_array_t; typedef __declspec(align(128)) Bounds BoundsArray; struct clipMap_t { const char* name; int isInUse; int planeCount; cplane_s* planes; unsigned int numStaticModels; cStaticModel_s* staticModelList; unsigned int numMaterials; ClipMaterial* materials; unsigned int numBrushSides; cbrushside_t* brushsides; unsigned int numBrushEdges; cbrushedge_t* brushEdges; unsigned int numNodes; cNode_t* nodes; unsigned int numLeafs; cLeaf_t* leafs; unsigned int leafbrushNodesCount; cLeafBrushNode_s* leafbrushNodes; unsigned int numLeafBrushes; LeafBrush* leafbrushes; unsigned int numLeafSurfaces; unsigned int* leafsurfaces; unsigned int vertCount; vec3_t* verts; int triCount; unsigned __int16* triIndices; char* triEdgeIsWalkable; int borderCount; CollisionBorder* borders; int partitionCount; CollisionPartition* partitions; int aabbTreeCount; CollisionAabbTree* aabbTrees; unsigned int numSubModels; cmodel_t* cmodels; unsigned __int16 numBrushes; cbrush_array_t* brushes; BoundsArray* brushBounds; int* brushContents; MapEnts* mapEnts; unsigned __int16 smodelNodeCount; SModelAabbNode* smodelNodes; unsigned __int16 dynEntCount[2]; DynEntityDef* dynEntDefList[2]; DynEntityPose* dynEntPoseList[2]; DynEntityClient* dynEntClientList[2]; DynEntityColl* dynEntCollList[2]; unsigned int checksum; char padding[48]; }; enum ImpactType { IMPACT_TYPE_NONE = 0x0, IMPACT_TYPE_BULLET_SMALL = 0x1, IMPACT_TYPE_BULLET_LARGE = 0x2, IMPACT_TYPE_BULLET_AP = 0x3, IMPACT_TYPE_BULLET_EXPLODE = 0x4, IMPACT_TYPE_SHOTGUN = 0x5, IMPACT_TYPE_SHOTGUN_EXPLODE = 0x6, IMPACT_TYPE_GRENADE_BOUNCE = 0x7, IMPACT_TYPE_GRENADE_EXPLODE = 0x8, IMPACT_TYPE_ROCKET_EXPLODE = 0x9, IMPACT_TYPE_PROJECTILE_DUD = 0xA, IMPACT_TYPE_COUNT }; enum weaponIconRatioType_t { WEAPON_ICON_RATIO_1TO1 = 0x0, WEAPON_ICON_RATIO_2TO1 = 0x1, WEAPON_ICON_RATIO_4TO1 = 0x2, WEAPON_ICON_RATIO_COUNT }; enum weapType_t { WEAPTYPE_BULLET = 0x0, WEAPTYPE_GRENADE = 0x1, WEAPTYPE_PROJECTILE = 0x2, WEAPTYPE_RIOTSHIELD = 0x3, WEAPTYPE_NUM }; enum weapClass_t { WEAPCLASS_RIFLE = 0x0, WEAPCLASS_SNIPER = 0x1, WEAPCLASS_MG = 0x2, WEAPCLASS_SMG = 0x3, WEAPCLASS_SPREAD = 0x4, WEAPCLASS_PISTOL = 0x5, WEAPCLASS_GRENADE = 0x6, WEAPCLASS_ROCKETLAUNCHER = 0x7, WEAPCLASS_TURRET = 0x8, WEAPCLASS_THROWINGKNIFE = 0x9, WEAPCLASS_NON_PLAYER = 0xA, WEAPCLASS_ITEM = 0xB, WEAPCLASS_NUM }; enum PenetrateType { PENETRATE_TYPE_NONE = 0x0, PENETRATE_TYPE_SMALL = 0x1, PENETRATE_TYPE_MEDIUM = 0x2, PENETRATE_TYPE_LARGE = 0x3, PENETRATE_TYPE_COUNT }; enum weapInventoryType_t { WEAPINVENTORY_PRIMARY = 0x0, WEAPINVENTORY_OFFHAND = 0x1, WEAPINVENTORY_ITEM = 0x2, WEAPINVENTORY_ALTMODE = 0x3, WEAPINVENTORY_EXCLUSIVE = 0x4, WEAPINVENTORY_SCAVENGER = 0x5, WEAPINVENTORYCOUNT }; 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_DOUBLEBARREL = 0x5, WEAPON_FIRETYPECOUNT = 0x6, WEAPON_FIRETYPE_BURSTFIRE_FIRST = 0x2, WEAPON_FIRETYPE_BURSTFIRE_LAST = 0x4, }; enum OffhandClass { OFFHAND_CLASS_NONE = 0x0, OFFHAND_CLASS_FRAG_GRENADE = 0x1, OFFHAND_CLASS_SMOKE_GRENADE = 0x2, OFFHAND_CLASS_FLASH_GRENADE = 0x3, OFFHAND_CLASS_THROWINGKNIFE = 0x4, OFFHAND_CLASS_OTHER = 0x5, OFFHAND_CLASS_COUNT }; enum weapStance_t { WEAPSTANCE_STAND = 0x0, WEAPSTANCE_DUCK = 0x1, WEAPSTANCE_PRONE = 0x2, WEAPSTANCE_NUM }; enum activeReticleType_t { VEH_ACTIVE_RETICLE_NONE = 0x0, VEH_ACTIVE_RETICLE_PIP_ON_A_STICK = 0x1, VEH_ACTIVE_RETICLE_BOUNCING_DIAMOND = 0x2, VEH_ACTIVE_RETICLE_COUNT }; 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 }; enum weapOverlayReticle_t { WEAPOVERLAYRETICLE_NONE = 0x0, WEAPOVERLAYRETICLE_CROSSHAIR = 0x1, WEAPOVERLAYRETICLE_NUM }; enum WeapOverlayInteface_t { WEAPOVERLAYINTERFACE_NONE = 0x0, WEAPOVERLAYINTERFACE_JAVELIN = 0x1, WEAPOVERLAYINTERFACE_TURRETSCOPE = 0x2, WEAPOVERLAYINTERFACECOUNT }; enum weapProjExposion_t { WEAPPROJEXP_GRENADE = 0x0, WEAPPROJEXP_ROCKET = 0x1, WEAPPROJEXP_FLASHBANG = 0x2, WEAPPROJEXP_NONE = 0x3, WEAPPROJEXP_DUD = 0x4, WEAPPROJEXP_SMOKE = 0x5, WEAPPROJEXP_HEAVY = 0x6, WEAPPROJEXP_NUM }; enum WeapStickinessType { WEAPSTICKINESS_NONE = 0x0, WEAPSTICKINESS_ALL = 0x1, WEAPSTICKINESS_ALL_ORIENT = 0x2, WEAPSTICKINESS_GROUND = 0x3, WEAPSTICKINESS_GROUND_WITH_YAW = 0x4, WEAPSTICKINESS_KNIFE = 0x5, WEAPSTICKINESS_COUNT }; enum guidedMissileType_t { MISSILE_GUIDANCE_NONE = 0x0, MISSILE_GUIDANCE_SIDEWINDER = 0x1, MISSILE_GUIDANCE_HELLFIRE = 0x2, MISSILE_GUIDANCE_JAVELIN = 0x3, MISSILE_GUIDANCE_COUNT }; struct snd_alias_list_name { const char* soundName; }; union SndAliasCustom { snd_alias_list_name* name; snd_alias_list_t* sound; }; struct WeaponDef { const char* szOverlayName; XModel** gunXModel; XModel* handXModel; const char** szXAnimsRightHanded; const char** szXAnimsLeftHanded; const char* szModeName; unsigned __int16* notetrackSoundMapKeys; unsigned __int16* notetrackSoundMapValues; unsigned __int16* notetrackRumbleMapKeys; unsigned __int16* notetrackRumbleMapValues; int playerAnimType; weapType_t weapType; weapClass_t weapClass; PenetrateType penetrateType; weapInventoryType_t inventoryType; weapFireType_t fireType; OffhandClass offhandClass; weapStance_t stance; FxEffectDef* viewFlashEffect; FxEffectDef* worldFlashEffect; SndAliasCustom pickupSound; SndAliasCustom pickupSoundPlayer; SndAliasCustom ammoPickupSound; SndAliasCustom ammoPickupSoundPlayer; SndAliasCustom projectileSound; SndAliasCustom pullbackSound; SndAliasCustom pullbackSoundPlayer; SndAliasCustom fireSound; SndAliasCustom fireSoundPlayer; SndAliasCustom fireSoundPlayerAkimbo; SndAliasCustom fireLoopSound; SndAliasCustom fireLoopSoundPlayer; SndAliasCustom fireStopSound; SndAliasCustom fireStopSoundPlayer; SndAliasCustom fireLastSound; SndAliasCustom fireLastSoundPlayer; SndAliasCustom emptyFireSound; SndAliasCustom emptyFireSoundPlayer; SndAliasCustom meleeSwipeSound; SndAliasCustom meleeSwipeSoundPlayer; SndAliasCustom meleeHitSound; SndAliasCustom meleeMissSound; SndAliasCustom rechamberSound; SndAliasCustom rechamberSoundPlayer; SndAliasCustom reloadSound; SndAliasCustom reloadSoundPlayer; SndAliasCustom reloadEmptySound; SndAliasCustom reloadEmptySoundPlayer; SndAliasCustom reloadStartSound; SndAliasCustom reloadStartSoundPlayer; SndAliasCustom reloadEndSound; SndAliasCustom reloadEndSoundPlayer; SndAliasCustom detonateSound; SndAliasCustom detonateSoundPlayer; SndAliasCustom nightVisionWearSound; SndAliasCustom nightVisionWearSoundPlayer; SndAliasCustom nightVisionRemoveSound; SndAliasCustom nightVisionRemoveSoundPlayer; SndAliasCustom altSwitchSound; SndAliasCustom altSwitchSoundPlayer; SndAliasCustom raiseSound; SndAliasCustom raiseSoundPlayer; SndAliasCustom firstRaiseSound; SndAliasCustom firstRaiseSoundPlayer; SndAliasCustom putawaySound; SndAliasCustom putawaySoundPlayer; SndAliasCustom scanSound; SndAliasCustom* bounceSound; FxEffectDef* viewShellEjectEffect; FxEffectDef* worldShellEjectEffect; FxEffectDef* viewLastShotEjectEffect; FxEffectDef* worldLastShotEjectEffect; Material* reticleCenter; Material* reticleSide; int iReticleCenterSize; int iReticleSideSize; int iReticleMinOfs; activeReticleType_t activeReticleType; float vStandMove[3]; float vStandRot[3]; float strafeMove[3]; float strafeRot[3]; float vDuckedOfs[3]; float vDuckedMove[3]; float vDuckedRot[3]; float vProneOfs[3]; float vProneMove[3]; float vProneRot[3]; float fPosMoveRate; float fPosProneMoveRate; float fStandMoveMinSpeed; float fDuckedMoveMinSpeed; float fProneMoveMinSpeed; float fPosRotRate; float fPosProneRotRate; float fStandRotMinSpeed; float fDuckedRotMinSpeed; float fProneRotMinSpeed; XModel** worldModel; XModel* worldClipModel; XModel* rocketModel; XModel* knifeModel; XModel* worldKnifeModel; Material* hudIcon; weaponIconRatioType_t hudIconRatio; Material* pickupIcon; weaponIconRatioType_t pickupIconRatio; Material* ammoCounterIcon; weaponIconRatioType_t ammoCounterIconRatio; ammoCounterClipType_t ammoCounterClip; int iStartAmmo; const char* szAmmoName; int iAmmoIndex; const char* szClipName; int iClipIndex; int iMaxAmmo; int shotCount; const char* szSharedAmmoCapName; int iSharedAmmoCapIndex; int iSharedAmmoCap; int damage; int playerDamage; int iMeleeDamage; int iDamageType; int iFireDelay; int iMeleeDelay; int meleeChargeDelay; int iDetonateDelay; int iRechamberTime; int rechamberTimeOneHanded; int iRechamberBoltTime; int iHoldFireTime; int iDetonateTime; int iMeleeTime; int meleeChargeTime; int iReloadTime; int reloadShowRocketTime; int iReloadEmptyTime; int iReloadAddTime; int iReloadStartTime; int iReloadStartAddTime; int iReloadEndTime; int iDropTime; int iRaiseTime; int iAltDropTime; int quickDropTime; int quickRaiseTime; int iBreachRaiseTime; int iEmptyRaiseTime; int iEmptyDropTime; int sprintInTime; int sprintLoopTime; int sprintOutTime; int stunnedTimeBegin; int stunnedTimeLoop; int stunnedTimeEnd; int nightVisionWearTime; int nightVisionWearTimeFadeOutEnd; int nightVisionWearTimePowerUp; int nightVisionRemoveTime; int nightVisionRemoveTimePowerDown; int nightVisionRemoveTimeFadeInStart; int fuseTime; int aiFuseTime; float autoAimRange; float aimAssistRange; float aimAssistRangeAds; float aimPadding; float enemyCrosshairRange; float moveSpeedScale; float adsMoveSpeedScale; float sprintDurationScale; float fAdsZoomInFrac; float fAdsZoomOutFrac; Material* overlayMaterial; Material* overlayMaterialLowRes; Material* overlayMaterialEMP; Material* overlayMaterialEMPLowRes; weapOverlayReticle_t overlayReticle; WeapOverlayInteface_t overlayInterface; float overlayWidth; float overlayHeight; float overlayWidthSplitscreen; float overlayHeightSplitscreen; float fAdsBobFactor; float fAdsViewBobMult; float fHipSpreadStandMin; float fHipSpreadDuckedMin; float fHipSpreadProneMin; float hipSpreadStandMax; float hipSpreadDuckedMax; float hipSpreadProneMax; float fHipSpreadDecayRate; float fHipSpreadFireAdd; float fHipSpreadTurnAdd; float fHipSpreadMoveAdd; float fHipSpreadDuckedDecay; float fHipSpreadProneDecay; float fHipReticleSidePos; float fAdsIdleAmount; float fHipIdleAmount; float adsIdleSpeed; float hipIdleSpeed; float fIdleCrouchFactor; float fIdleProneFactor; float fGunMaxPitch; float fGunMaxYaw; float swayMaxAngle; float swayLerpSpeed; float swayPitchScale; float swayYawScale; float swayHorizScale; float swayVertScale; float swayShellShockScale; float adsSwayMaxAngle; float adsSwayLerpSpeed; float adsSwayPitchScale; float adsSwayYawScale; float adsSwayHorizScale; float adsSwayVertScale; float adsViewErrorMin; float adsViewErrorMax; PhysCollmap* physCollmap; float dualWieldViewModelOffset; weaponIconRatioType_t killIconRatio; int iReloadAmmoAdd; int iReloadStartAdd; int ammoDropStockMin; int ammoDropClipPercentMin; int ammoDropClipPercentMax; int iExplosionRadius; int iExplosionRadiusMin; int iExplosionInnerDamage; int iExplosionOuterDamage; float damageConeAngle; float bulletExplDmgMult; float bulletExplRadiusMult; int iProjectileSpeed; int iProjectileSpeedUp; int iProjectileSpeedForward; int iProjectileActivateDist; float projLifetime; float timeToAccelerate; float projectileCurvature; XModel* projectileModel; weapProjExposion_t projExplosion; FxEffectDef* projExplosionEffect; FxEffectDef* projDudEffect; SndAliasCustom projExplosionSound; SndAliasCustom projDudSound; WeapStickinessType stickiness; float lowAmmoWarningThreshold; float ricochetChance; float* parallelBounce; float* perpendicularBounce; FxEffectDef* projTrailEffect; FxEffectDef* projBeaconEffect; float vProjectileColor[3]; guidedMissileType_t guidedMissileType; float maxSteeringAccel; int projIgnitionDelay; FxEffectDef* projIgnitionEffect; SndAliasCustom projIgnitionSound; float fAdsAimPitch; float fAdsCrosshairInFrac; float fAdsCrosshairOutFrac; int adsGunKickReducedKickBullets; float adsGunKickReducedKickPercent; float fAdsGunKickPitchMin; float fAdsGunKickPitchMax; float fAdsGunKickYawMin; float fAdsGunKickYawMax; float fAdsGunKickAccel; float fAdsGunKickSpeedMax; float fAdsGunKickSpeedDecay; float fAdsGunKickStaticDecay; float fAdsViewKickPitchMin; float fAdsViewKickPitchMax; float fAdsViewKickYawMin; float fAdsViewKickYawMax; float fAdsViewScatterMin; float fAdsViewScatterMax; float fAdsSpread; int hipGunKickReducedKickBullets; float hipGunKickReducedKickPercent; float fHipGunKickPitchMin; float fHipGunKickPitchMax; float fHipGunKickYawMin; float fHipGunKickYawMax; float fHipGunKickAccel; float fHipGunKickSpeedMax; float fHipGunKickSpeedDecay; float fHipGunKickStaticDecay; float fHipViewKickPitchMin; float fHipViewKickPitchMax; float fHipViewKickYawMin; float fHipViewKickYawMax; float fHipViewScatterMin; float fHipViewScatterMax; float fightDist; float maxDist; // const char* accuracyGraphName[2];// TODO: Order is accuracyGraphName[0] -> originalAccuracyGraphKnots[0] -> accuracyGraphName[1] -> ... // Which is currently not possible to do in code generation. Afaik this is the only place where this is the case. // So might be something to fix but on the other hand it might be too much work for this little inconvenience. // vec2_t* originalAccuracyGraphKnots[2]; const char* accuracyGraphName0; const char* accuracyGraphName1; vec2_t* originalAccuracyGraphKnots0; vec2_t* originalAccuracyGraphKnots1; unsigned __int16 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 scanSpeed; float scanAccel; int scanPauseTime; const char* szScript; float fOOPosAnimLength[2]; int minDamage; int minPlayerDamage; float fMaxDamageRange; float fMinDamageRange; float destabilizationRateTime; float destabilizationCurvatureMax; int destabilizeDistance; float* locationDamageMultipliers; const char* fireRumble; const char* meleeImpactRumble; TracerDef* tracerType; float turretScopeZoomRate; float turretScopeZoomMin; float turretScopeZoomMax; float turretOverheatUpRate; float turretOverheatDownRate; float turretOverheatPenalty; SndAliasCustom turretOverheatSound; FxEffectDef* turretOverheatEffect; const char* turretBarrelSpinRumble; float turretBarrelSpinSpeed; float turretBarrelSpinUpTime; float turretBarrelSpinDownTime; SndAliasCustom turretBarrelSpinMaxSnd; SndAliasCustom turretBarrelSpinUpSnd[4]; SndAliasCustom turretBarrelSpinDownSnd[4]; SndAliasCustom missileConeSoundAlias; SndAliasCustom missileConeSoundAliasAtBase; float missileConeSoundRadiusAtTop; float missileConeSoundRadiusAtBase; float missileConeSoundHeight; float missileConeSoundOriginOffset; float missileConeSoundVolumescaleAtCore; float missileConeSoundVolumescaleAtEdge; float missileConeSoundVolumescaleCoreSize; float missileConeSoundPitchAtTop; float missileConeSoundPitchAtBottom; float missileConeSoundPitchTopSize; float missileConeSoundPitchBottomSize; float missileConeSoundCrossfadeTopSize; float missileConeSoundCrossfadeBottomSize; bool sharedAmmo; bool lockonSupported; bool requireLockonToFire; bool bigExplosion; bool noAdsWhenMagEmpty; bool avoidDropCleanup; bool inheritsPerks; bool crosshairColorChange; bool bRifleBullet; bool armorPiercing; bool bBoltAction; bool aimDownSight; bool bRechamberWhileAds; bool bBulletExplosiveDamage; bool bCookOffHold; bool bClipOnly; bool noAmmoPickup; bool adsFireOnly; bool cancelAutoHolsterWhenEmpty; bool disableSwitchToWhenEmpty; bool suppressAmmoReserveDisplay; bool laserSightDuringNightvision; bool markableViewmodel; bool noDualWield; bool flipKillIcon; bool bNoPartialReload; bool bSegmentedReload; bool blocksProne; bool silenced; bool isRollingGrenade; bool projExplosionEffectForceNormalUp; bool bProjImpactExplode; bool stickToPlayers; bool hasDetonator; bool disableFiring; bool timedDetonation; bool rotate; bool holdButtonToThrow; bool freezeMovementWhenFiring; bool thermalScope; bool altModeSameWeapon; bool turretBarrelSpinEnabled; bool missileConeSoundEnabled; bool missileConeSoundPitchshiftEnabled; bool missileConeSoundCrossfadeEnabled; bool offhandHoldIsCancelable; }; struct WeaponCompleteDef { const char* szInternalName; WeaponDef* weapDef; const char* szDisplayName; unsigned __int16* hideTags; const char** szXAnims; float fAdsZoomFov; int iAdsTransInTime; int iAdsTransOutTime; int iClipSize; ImpactType impactType; int iFireTime; weaponIconRatioType_t dpadIconRatio; float penetrateMultiplier; float fAdsViewKickCenterSpeed; float fHipViewKickCenterSpeed; const char* szAltWeaponName; unsigned int altWeaponIndex; int iAltRaiseTime; Material* killIcon; Material* dpadIcon; int fireAnimLength; int iFirstRaiseTime; int ammoDropStockMax; float adsDofStart; float adsDofEnd; unsigned __int16 accuracyGraphKnotCount[2]; vec2_t* accuracyGraphKnots[2]; bool motionTracker; bool enhanced; bool dpadIconShowsAmmo; }; enum VehicleAxleType { VEH_AXLE_FRONT = 0x0, VEH_AXLE_REAR = 0x1, VEH_AXLE_ALL = 0x2, VEH_AXLE_COUNT = 0x3, }; struct VehiclePhysDef { int physicsEnabled; const char* physPresetName; PhysPreset* physPreset; const char* accelGraphName; VehicleAxleType steeringAxle; VehicleAxleType powerAxle; VehicleAxleType brakingAxle; float topSpeed; float reverseSpeed; float maxVelocity; float maxPitch; float maxRoll; float suspensionTravelFront; float suspensionTravelRear; float suspensionStrengthFront; float suspensionDampingFront; float suspensionStrengthRear; float suspensionDampingRear; float frictionBraking; float frictionCoasting; float frictionTopSpeed; float frictionSide; float frictionSideRear; float velocityDependentSlip; float rollStability; float rollResistance; float pitchResistance; float yawResistance; float uprightStrengthPitch; float uprightStrengthRoll; float targetAirPitch; float airYawTorque; float airPitchTorque; float minimumMomentumForCollision; float collisionLaunchForceScale; float wreckedMassScale; float wreckedBodyFriction; float minimumJoltForNotify; float slipThresholdFront; float slipThresholdRear; float slipFricScaleFront; float slipFricScaleRear; float slipFricRateFront; float slipFricRateRear; float slipYawTorque; }; enum VehicleType { VEH_WHEELS_4 = 0x0, VEH_TANK = 0x1, VEH_PLANE = 0x2, VEH_BOAT = 0x3, VEH_ARTILLERY = 0x4, VEH_HELICOPTER = 0x5, VEH_SNOWMOBILE = 0x6, VEH_TYPE_COUNT = 0x7, }; struct VehicleDef { const char* name; VehicleType type; const char* useHintString; int health; int quadBarrel; float texScrollScale; float topSpeed; float accel; float rotRate; float rotAccel; float maxBodyPitch; float maxBodyRoll; float fakeBodyAccelPitch; float fakeBodyAccelRoll; float fakeBodyVelPitch; float fakeBodyVelRoll; float fakeBodySideVelPitch; float fakeBodyPitchStrength; float fakeBodyRollStrength; float fakeBodyPitchDampening; float fakeBodyRollDampening; float fakeBodyBoatRockingAmplitude; float fakeBodyBoatRockingPeriod; float fakeBodyBoatRockingRotationPeriod; float fakeBodyBoatRockingFadeoutSpeed; float boatBouncingMinForce; float boatBouncingMaxForce; float boatBouncingRate; float boatBouncingFadeinSpeed; float boatBouncingFadeoutSteeringAngle; float collisionDamage; float collisionSpeed; float killcamOffset[3]; int playerProtected; int bulletDamage; int armorPiercingDamage; int grenadeDamage; int projectileDamage; int projectileSplashDamage; int heavyExplosiveDamage; VehiclePhysDef vehPhysDef; float boostDuration; float boostRechargeTime; float boostAcceleration; float suspensionTravel; float maxSteeringAngle; float steeringLerp; float minSteeringScale; float minSteeringSpeed; int camLookEnabled; float camLerp; float camPitchInfluence; float camRollInfluence; float camFovIncrease; float camFovOffset; float camFovSpeed; const char* turretWeaponName; WeaponCompleteDef* turretWeapon; float turretHorizSpanLeft; float turretHorizSpanRight; float turretVertSpanUp; float turretVertSpanDown; float turretRotRate; SndAliasCustom turretSpinSnd; SndAliasCustom turretStopSnd; int trophyEnabled; float trophyRadius; float trophyInactiveRadius; int trophyAmmoCount; float trophyReloadTime; unsigned __int16 trophyTags[4]; Material* compassFriendlyIcon; Material* compassEnemyIcon; int compassIconWidth; int compassIconHeight; SndAliasCustom idleLowSnd; SndAliasCustom idleHighSnd; SndAliasCustom engineLowSnd; SndAliasCustom engineHighSnd; float engineSndSpeed; SndAliasCustom engineStartUpSnd; int engineStartUpLength; SndAliasCustom engineShutdownSnd; SndAliasCustom engineIdleSnd; SndAliasCustom engineSustainSnd; SndAliasCustom engineRampUpSnd; int engineRampUpLength; SndAliasCustom engineRampDownSnd; int engineRampDownLength; SndAliasCustom suspensionSoftSnd; float suspensionSoftCompression; SndAliasCustom suspensionHardSnd; float suspensionHardCompression; SndAliasCustom collisionSnd; float collisionBlendSpeed; SndAliasCustom speedSnd; float speedSndBlendSpeed; const char* surfaceSndPrefix; SndAliasCustom surfaceSnds[31]; float surfaceSndBlendSpeed; float slideVolume; float slideBlendSpeed; float inAirPitch; }; #ifndef __zonecodegenerator } #endif #endif // EOF