2823 lines
57 KiB
C
2823 lines
57 KiB
C
#ifndef ASSETS_H
|
|
#define ASSETS_H
|
|
|
|
#include "xgfxpixelshaderloaddef.h"
|
|
#include "xmodel.h"
|
|
#include <QDebug>
|
|
#include <QObject>
|
|
|
|
typedef quint32 _DWORD;
|
|
|
|
|
|
enum _D3DRESOURCETYPE : __int32
|
|
{
|
|
D3DRTYPE_NONE = 0x0,
|
|
D3DRTYPE_VERTEXBUFFER = 0x1,
|
|
D3DRTYPE_INDEXBUFFER = 0x2,
|
|
D3DRTYPE_TEXTURE = 0x3,
|
|
D3DRTYPE_SURFACE = 0x4,
|
|
D3DRTYPE_VERTEXDECLARATION = 0x5,
|
|
D3DRTYPE_VERTEXSHADER = 0x6,
|
|
D3DRTYPE_PIXELSHADER = 0x7,
|
|
D3DRTYPE_CONSTANTBUFFER = 0x8,
|
|
D3DRTYPE_COMMANDBUFFER = 0x9,
|
|
D3DRTYPE_VOLUME = 0x10,
|
|
D3DRTYPE_VOLUMETEXTURE = 0x11,
|
|
D3DRTYPE_CUBETEXTURE = 0x12,
|
|
D3DRTYPE_ARRAYTEXTURE = 0x13,
|
|
D3DRTYPE_LINETEXTURE = 0x14,
|
|
D3DRTYPE_FORCE_DWORD = 0x7FFFFFFF,
|
|
};
|
|
|
|
enum _D3DFORMAT : __int32
|
|
{
|
|
D3DFMT_DXT1 = 0x1A200152,
|
|
D3DFMT_LIN_DXT1 = 0x1A200052,
|
|
D3DFMT_DXT2 = 0x1A200153,
|
|
D3DFMT_LIN_DXT2 = 0x1A200053,
|
|
D3DFMT_DXT3 = 0x1A200153,
|
|
D3DFMT_LIN_DXT3 = 0x1A200053,
|
|
D3DFMT_DXT3A = 0x1A20017A,
|
|
D3DFMT_LIN_DXT3A = 0x1A20007A,
|
|
D3DFMT_DXT3A_1111 = 0x1A20017D,
|
|
D3DFMT_LIN_DXT3A_1111 = 0x1A20007D,
|
|
D3DFMT_DXT4 = 0x1A200154,
|
|
D3DFMT_LIN_DXT4 = 0x1A200054,
|
|
D3DFMT_DXT5 = 0x1A200154,
|
|
D3DFMT_LIN_DXT5 = 0x1A200054,
|
|
D3DFMT_DXT5A = 0x1A20017B,
|
|
D3DFMT_LIN_DXT5A = 0x1A20007B,
|
|
D3DFMT_DXN = 0x1A200171,
|
|
D3DFMT_LIN_DXN = 0x1A200071,
|
|
D3DFMT_CTX1 = 0x1A20017C,
|
|
D3DFMT_LIN_CTX1 = 0x1A20007C,
|
|
D3DFMT_A8 = 0x4900102,
|
|
D3DFMT_LIN_A8 = 0x4900002,
|
|
D3DFMT_L8 = 0x28000102,
|
|
D3DFMT_LIN_L8 = 0x28000002,
|
|
D3DFMT_R5G6B5 = 0x28280144,
|
|
D3DFMT_LIN_R5G6B5 = 0x28280044,
|
|
D3DFMT_R6G5B5 = 0x28280145,
|
|
D3DFMT_LIN_R6G5B5 = 0x28280045,
|
|
D3DFMT_L6V5U5 = 0x2A200B45,
|
|
D3DFMT_LIN_L6V5U5 = 0x2A200A45,
|
|
D3DFMT_X1R5G5B5 = 0x28280143,
|
|
D3DFMT_LIN_X1R5G5B5 = 0x28280043,
|
|
D3DFMT_A1R5G5B5 = 0x18280143,
|
|
D3DFMT_LIN_A1R5G5B5 = 0x18280043,
|
|
D3DFMT_A4R4G4B4 = 0x1828014F,
|
|
D3DFMT_LIN_A4R4G4B4 = 0x1828004F,
|
|
D3DFMT_X4R4G4B4 = 0x2828014F,
|
|
D3DFMT_LIN_X4R4G4B4 = 0x2828004F,
|
|
D3DFMT_Q4W4V4U4 = 0x1A20AB4F,
|
|
D3DFMT_LIN_Q4W4V4U4 = 0x1A20AA4F,
|
|
D3DFMT_A8L8 = 0x800014A,
|
|
D3DFMT_LIN_A8L8 = 0x800004A,
|
|
D3DFMT_G8R8 = 0x2D20014A,
|
|
D3DFMT_LIN_G8R8 = 0x2D20004A,
|
|
D3DFMT_V8U8 = 0x2D20AB4A,
|
|
D3DFMT_LIN_V8U8 = 0x2D20AA4A,
|
|
D3DFMT_D16 = 0x1A220158,
|
|
D3DFMT_LIN_D16 = 0x1A220058,
|
|
D3DFMT_L16 = 0x28000158,
|
|
D3DFMT_LIN_L16 = 0x28000058,
|
|
D3DFMT_R16F = 0x2DA2AB5E,
|
|
D3DFMT_LIN_R16F = 0x2DA2AA5E,
|
|
D3DFMT_R16F_EXPAND = 0x2DA2AB5B,
|
|
D3DFMT_LIN_R16F_EXPAND = 0x2DA2AA5B,
|
|
D3DFMT_UYVY = 0x1A20014C,
|
|
D3DFMT_LIN_UYVY = 0x1A20004C,
|
|
D3DFMT_LE_UYVY = 0x1A20010C,
|
|
D3DFMT_LE_LIN_UYVY = 0x1A20000C,
|
|
D3DFMT_G8R8_G8B8 = 0x1828014C,
|
|
D3DFMT_LIN_G8R8_G8B8 = 0x1828004C,
|
|
D3DFMT_R8G8_B8G8 = 0x1828014B,
|
|
D3DFMT_LIN_R8G8_B8G8 = 0x1828004B,
|
|
D3DFMT_YUY2 = 0x1A20014B,
|
|
D3DFMT_LIN_YUY2 = 0x1A20004B,
|
|
D3DFMT_LE_YUY2 = 0x1A20010B,
|
|
D3DFMT_LE_LIN_YUY2 = 0x1A20000B,
|
|
D3DFMT_A8R8G8B8 = 0x18280186,
|
|
D3DFMT_LIN_A8R8G8B8 = 0x18280086,
|
|
D3DFMT_X8R8G8B8 = 0x28280186,
|
|
D3DFMT_LIN_X8R8G8B8 = 0x28280086,
|
|
D3DFMT_A8B8G8R8 = 0x1A200186,
|
|
D3DFMT_LIN_A8B8G8R8 = 0x1A200086,
|
|
D3DFMT_X8B8G8R8 = 0x2A200186,
|
|
D3DFMT_LIN_X8B8G8R8 = 0x2A200086,
|
|
D3DFMT_X8L8V8U8 = 0x2A200B86,
|
|
D3DFMT_LIN_X8L8V8U8 = 0x2A200A86,
|
|
D3DFMT_Q8W8V8U8 = 0x1A20AB86,
|
|
D3DFMT_LIN_Q8W8V8U8 = 0x1A20AA86,
|
|
D3DFMT_A2R10G10B10 = 0x182801B6,
|
|
D3DFMT_LIN_A2R10G10B10 = 0x182800B6,
|
|
D3DFMT_X2R10G10B10 = 0x282801B6,
|
|
D3DFMT_LIN_X2R10G10B10 = 0x282800B6,
|
|
D3DFMT_A2B10G10R10 = 0x1A2001B6,
|
|
D3DFMT_LIN_A2B10G10R10 = 0x1A2000B6,
|
|
D3DFMT_A2W10V10U10 = 0x1A202BB6,
|
|
D3DFMT_LIN_A2W10V10U10 = 0x1A202AB6,
|
|
D3DFMT_A16L16 = 0x8000199,
|
|
D3DFMT_LIN_A16L16 = 0x8000099,
|
|
D3DFMT_G16R16 = 0x2D200199,
|
|
D3DFMT_LIN_G16R16 = 0x2D200099,
|
|
D3DFMT_V16U16 = 0x2D20AB99,
|
|
D3DFMT_LIN_V16U16 = 0x2D20AA99,
|
|
D3DFMT_R10G11B11 = 0x282801B7,
|
|
D3DFMT_LIN_R10G11B11 = 0x282800B7,
|
|
D3DFMT_R11G11B10 = 0x282801B8,
|
|
D3DFMT_LIN_R11G11B10 = 0x282800B8,
|
|
D3DFMT_W10V11U11 = 0x2A20ABB7,
|
|
D3DFMT_LIN_W10V11U11 = 0x2A20AAB7,
|
|
D3DFMT_W11V11U10 = 0x2A20ABB8,
|
|
D3DFMT_LIN_W11V11U10 = 0x2A20AAB8,
|
|
D3DFMT_G16R16F = 0x2D22AB9F,
|
|
D3DFMT_LIN_G16R16F = 0x2D22AA9F,
|
|
D3DFMT_G16R16F_EXPAND = 0x2D22AB9C,
|
|
D3DFMT_LIN_G16R16F_EXPAND = 0x2D22AA9C,
|
|
D3DFMT_L32 = 0x280001A1,
|
|
D3DFMT_LIN_L32 = 0x280000A1,
|
|
D3DFMT_R32F = 0x2DA2ABA4,
|
|
D3DFMT_LIN_R32F = 0x2DA2AAA4,
|
|
D3DFMT_D24S8 = 0x2D200196,
|
|
D3DFMT_LIN_D24S8 = 0x2D200096,
|
|
D3DFMT_D24X8 = 0x2DA00196,
|
|
D3DFMT_LIN_D24X8 = 0x2DA00096,
|
|
D3DFMT_D24FS8 = 0x1A220197,
|
|
D3DFMT_LIN_D24FS8 = 0x1A220097,
|
|
D3DFMT_D32 = 0x1A2201A1,
|
|
D3DFMT_LIN_D32 = 0x1A2200A1,
|
|
D3DFMT_A16B16G16R16 = 0x1A20015A,
|
|
D3DFMT_LIN_A16B16G16R16 = 0x1A20005A,
|
|
D3DFMT_Q16W16V16U16 = 0x1A20AB5A,
|
|
D3DFMT_LIN_Q16W16V16U16 = 0x1A20AA5A,
|
|
D3DFMT_A16B16G16R16F = 0x1A22AB60,
|
|
D3DFMT_LIN_A16B16G16R16F = 0x1A22AA60,
|
|
D3DFMT_A16B16G16R16F_EXPAND = 0x1A22AB5D,
|
|
D3DFMT_LIN_A16B16G16R16F_EXPAND = 0x1A22AA5D,
|
|
D3DFMT_A32L32 = 0x80001A2,
|
|
D3DFMT_LIN_A32L32 = 0x80000A2,
|
|
D3DFMT_G32R32 = 0x2D2001A2,
|
|
D3DFMT_LIN_G32R32 = 0x2D2000A2,
|
|
D3DFMT_V32U32 = 0x2D20ABA2,
|
|
D3DFMT_LIN_V32U32 = 0x2D20AAA2,
|
|
D3DFMT_G32R32F = 0x2D22ABA5,
|
|
D3DFMT_LIN_G32R32F = 0x2D22AAA5,
|
|
D3DFMT_A32B32G32R32 = 0x1A2001A3,
|
|
D3DFMT_LIN_A32B32G32R32 = 0x1A2000A3,
|
|
D3DFMT_Q32W32V32U32 = 0x1A20ABA3,
|
|
D3DFMT_LIN_Q32W32V32U32 = 0x1A20AAA3,
|
|
D3DFMT_A32B32G32R32F = 0x1A22ABA6,
|
|
D3DFMT_LIN_A32B32G32R32F = 0x1A22AAA6,
|
|
D3DFMT_A2B10G10R10F_EDRAM = 0x1A2201BF,
|
|
D3DFMT_G16R16_EDRAM = 0x2D20AB8D,
|
|
D3DFMT_A16B16G16R16_EDRAM = 0x1A20AB55,
|
|
D3DFMT_LE_X8R8G8B8 = 0x28280106,
|
|
D3DFMT_LE_A8R8G8B8 = 0x18280106,
|
|
D3DFMT_LE_X2R10G10B10 = 0x28280136,
|
|
D3DFMT_LE_A2R10G10B10 = 0x18280136,
|
|
D3DFMT_INDEX16 = 0x1,
|
|
D3DFMT_INDEX32 = 0x6,
|
|
D3DFMT_LE_INDEX16 = 0x0,
|
|
D3DFMT_LE_INDEX32 = 0x4,
|
|
D3DFMT_VERTEXDATA = 0x8,
|
|
//D3DFMT_UNKNOWN = 0xFFFFFFFF,
|
|
D3DFMT_FORCE_DWORD = 0x7FFFFFFF,
|
|
};
|
|
|
|
enum _D3DMULTISAMPLE_TYPE : __int32
|
|
{
|
|
D3DMULTISAMPLE_NONE = 0x0,
|
|
D3DMULTISAMPLE_2_SAMPLES = 0x1,
|
|
D3DMULTISAMPLE_4_SAMPLES = 0x2,
|
|
D3DMULTISAMPLE_FORCE_DWORD = 0x7FFFFFFF,
|
|
};
|
|
|
|
struct _XGTEXTURE_DESC
|
|
{
|
|
_D3DRESOURCETYPE ResourceType;
|
|
uint Width;
|
|
uint Height;
|
|
uint Depth;
|
|
_D3DFORMAT Format;
|
|
uint RowPitch;
|
|
uint SlicePitch;
|
|
uint BitsPerPixel;
|
|
uint WidthInBlocks;
|
|
uint HeightInBlocks;
|
|
uint DepthInBlocks;
|
|
uint BytesPerBlock;
|
|
int ExpBias;
|
|
uint Flags;
|
|
_D3DMULTISAMPLE_TYPE MultiSampleType;
|
|
};
|
|
|
|
|
|
|
|
union MaterialPixelShaderProgram
|
|
{
|
|
qint32 psPtr;
|
|
XD3DPixelShader ps;
|
|
XGfxPixelShaderLoadDef loadDef;
|
|
};
|
|
|
|
struct __declspec(align(4)) XMALOOPREGION
|
|
{
|
|
uint LoopStart;
|
|
uint LoopEnd;
|
|
quint8 LoopSubframeEnd;
|
|
quint8 LoopSubframeSkip;
|
|
};
|
|
|
|
struct XAUDIOPACKET_ALIGNED
|
|
{
|
|
qint32 pBufferPtr;
|
|
QVector<char> pBuffer;
|
|
uint BufferSize;
|
|
uint LoopCount;
|
|
XMALOOPREGION XMALoop[6];
|
|
qint32 pContextPtr;
|
|
char pContext;
|
|
};
|
|
|
|
struct __declspec(align(4)) XAUDIOXMAFORMAT
|
|
{
|
|
uint SampleRate;
|
|
quint8 ChannelCount;
|
|
quint8 DecodeBufferSize;
|
|
};
|
|
|
|
union $A914CD29B804E77ACE08D070A31DB5AB
|
|
{
|
|
quint8 NumStreams;
|
|
quint8 ChannelCount;
|
|
};
|
|
|
|
union $9C5A25260C9CC66355FE8A35CC8403E0
|
|
{
|
|
XAUDIOXMAFORMAT Stream[6];
|
|
uint SampleRate;
|
|
};
|
|
|
|
struct XAUDIOSOURCEFORMAT
|
|
{
|
|
quint8 SampleType;
|
|
__declspec(align(4)) $A914CD29B804E77ACE08D070A31DB5AB ___u1;
|
|
$9C5A25260C9CC66355FE8A35CC8403E0 ___u2;
|
|
};
|
|
|
|
struct XaIwXmaDataInfo
|
|
{
|
|
int totalMsec;
|
|
};
|
|
|
|
struct XaSeekTable
|
|
{
|
|
int size;
|
|
qint32 dataPtr;
|
|
QVector<uint> data;
|
|
};
|
|
|
|
struct XaSound
|
|
{
|
|
XAUDIOPACKET_ALIGNED packet;
|
|
XAUDIOSOURCEFORMAT format;
|
|
XaIwXmaDataInfo xaIwXmaDataInfo;
|
|
XaSeekTable seekTable;
|
|
};
|
|
|
|
struct LoadedSound
|
|
{
|
|
const char *name;
|
|
XaSound sound;
|
|
};
|
|
|
|
struct StreamFileNameRaw
|
|
{
|
|
qint32 dirPtr;
|
|
QString dir;
|
|
qint32 namePtr;
|
|
QString name;
|
|
};
|
|
|
|
struct StreamFileNamePacked
|
|
{
|
|
uint offset;
|
|
uint length;
|
|
};
|
|
|
|
union StreamFileInfo
|
|
{
|
|
StreamFileNameRaw raw;
|
|
StreamFileNamePacked packed;
|
|
};
|
|
|
|
struct StreamFileName
|
|
{
|
|
uint fileIndex;
|
|
StreamFileInfo info;
|
|
};
|
|
|
|
struct StreamedSound
|
|
{
|
|
StreamFileName filename;
|
|
};
|
|
|
|
union SoundFileRef
|
|
{
|
|
LoadedSound *loadSnd;
|
|
StreamedSound streamSnd;
|
|
};
|
|
|
|
struct SoundFile
|
|
{
|
|
quint8 type;
|
|
quint8 exists;
|
|
SoundFileRef u;
|
|
};
|
|
|
|
struct SndCurve
|
|
{
|
|
qint32 filenamePtr;
|
|
QString filename;
|
|
int knotCount;
|
|
float knots[8][2];
|
|
};
|
|
|
|
struct XAUDIOCHANNELMAPENTRY
|
|
{
|
|
quint8 InputChannel;
|
|
quint8 OutputChannel;
|
|
float Volume;
|
|
};
|
|
|
|
struct XAUDIOCHANNELMAP
|
|
{
|
|
quint8 EntryCount;
|
|
qint32 paEntriesPtr;
|
|
QVector<XAUDIOCHANNELMAPENTRY> paEntries;
|
|
};
|
|
|
|
struct SpeakerMap
|
|
{
|
|
bool isDefault;
|
|
const char *name;
|
|
XAUDIOCHANNELMAP channelMaps[2][2];
|
|
};
|
|
|
|
struct snd_alias_t
|
|
{
|
|
const char *aliasName;
|
|
const char *subtitle;
|
|
const char *secondaryAliasName;
|
|
const char *chainAliasName;
|
|
SoundFile *soundFile;
|
|
int sequence;
|
|
float volMin;
|
|
float volMax;
|
|
float pitchMin;
|
|
float pitchMax;
|
|
float distMin;
|
|
float distMax;
|
|
int flags;
|
|
float slavePercentage;
|
|
float probability;
|
|
float lfePercentage;
|
|
float centerPercentage;
|
|
int startDelay;
|
|
SndCurve *volumeFalloffCurve;
|
|
float envelopMin;
|
|
float envelopMax;
|
|
float envelopPercentage;
|
|
SpeakerMap *speakerMap;
|
|
};
|
|
|
|
struct SoundAliasList
|
|
{
|
|
const char *aliasName;
|
|
snd_alias_t *head;
|
|
int count;
|
|
};
|
|
|
|
enum XAssetType : __int32
|
|
{
|
|
ASSET_TYPE_XMODELPIECES = 0x0,
|
|
ASSET_TYPE_PHYSPRESET = 0x1,
|
|
ASSET_TYPE_XANIMPARTS = 0x2,
|
|
ASSET_TYPE_XMODEL = 0x3,
|
|
ASSET_TYPE_MATERIAL = 0x4,
|
|
ASSET_TYPE_PIXELSHADER = 0x5,
|
|
ASSET_TYPE_TECHNIQUE_SET = 0x6,
|
|
ASSET_TYPE_IMAGE = 0x7,
|
|
ASSET_TYPE_SOUND = 0x8,
|
|
ASSET_TYPE_SOUND_CURVE = 0x9,
|
|
ASSET_TYPE_LOADED_SOUND = 0xA,
|
|
ASSET_TYPE_CLIPMAP = 0xB,
|
|
ASSET_TYPE_CLIPMAP_PVS = 0xC,
|
|
ASSET_TYPE_COMWORLD = 0xD,
|
|
ASSET_TYPE_GAMEWORLD_SP = 0xE,
|
|
ASSET_TYPE_GAMEWORLD_MP = 0xF,
|
|
ASSET_TYPE_MAP_ENTS = 0x10,
|
|
ASSET_TYPE_GFXWORLD = 0x11,
|
|
ASSET_TYPE_LIGHT_DEF = 0x12,
|
|
ASSET_TYPE_UI_MAP = 0x13,
|
|
ASSET_TYPE_FONT = 0x14,
|
|
ASSET_TYPE_MENULIST = 0x15,
|
|
ASSET_TYPE_MENU = 0x16,
|
|
ASSET_TYPE_LOCALIZE_ENTRY = 0x17,
|
|
ASSET_TYPE_WEAPON = 0x18,
|
|
ASSET_TYPE_SNDDRIVER_GLOBALS = 0x19,
|
|
ASSET_TYPE_FX = 0x1A,
|
|
ASSET_TYPE_IMPACT_FX = 0x1B,
|
|
ASSET_TYPE_AITYPE = 0x1C,
|
|
ASSET_TYPE_MPTYPE = 0x1D,
|
|
ASSET_TYPE_CHARACTER = 0x1E,
|
|
ASSET_TYPE_XMODELALIAS = 0x1F,
|
|
ASSET_TYPE_RAWFILE = 0x20,
|
|
ASSET_TYPE_STRINGTABLE = 0x21,
|
|
ASSET_TYPE_COUNT = 0x22,
|
|
ASSET_TYPE_STRING = 0x22,
|
|
ASSET_TYPE_ASSETLIST = 0x23,
|
|
};
|
|
|
|
|
|
union GfxDrawSurf
|
|
{
|
|
GfxDrawSurfFields fields;
|
|
unsigned __int64 packed;
|
|
};
|
|
|
|
struct MaterialTechniqueSet
|
|
{
|
|
const char *name;
|
|
quint8 worldVertFormat;
|
|
quint8 unused[2];
|
|
MaterialTechniqueSet *remappedTechniqueSet;
|
|
MaterialTechnique *techniques[26];
|
|
};
|
|
|
|
struct XModelPiece
|
|
{
|
|
XModel *model;
|
|
float offset[3];
|
|
};
|
|
|
|
struct XModelPieces
|
|
{
|
|
const char *name;
|
|
int numpieces;
|
|
XModelPiece *pieces;
|
|
};
|
|
|
|
union XAnimIndices
|
|
{
|
|
quint8 *_1;
|
|
quint16 *_2;
|
|
void *data;
|
|
};
|
|
|
|
struct XAnimNotifyInfo
|
|
{
|
|
quint16 name;
|
|
float time;
|
|
};
|
|
|
|
union XAnimDynamicFrames
|
|
{
|
|
quint8 (*_1)[3];
|
|
quint16 (*_2)[3];
|
|
};
|
|
|
|
union XAnimDynamicIndices
|
|
{
|
|
quint8 _1[1];
|
|
quint16 _2[1];
|
|
};
|
|
|
|
struct XAnimPartTransFrames
|
|
{
|
|
float mins[3];
|
|
float size[3];
|
|
XAnimDynamicFrames frames;
|
|
XAnimDynamicIndices indices;
|
|
};
|
|
|
|
union XAnimPartTransData
|
|
{
|
|
XAnimPartTransFrames frames;
|
|
float frame0[3];
|
|
};
|
|
|
|
struct XAnimPartTrans
|
|
{
|
|
quint16 size;
|
|
quint8 smallTrans;
|
|
XAnimPartTransData u;
|
|
};
|
|
|
|
struct __declspec(align(4)) XAnimDeltaPartQuatDataFrames
|
|
{
|
|
qint16 (*frames)[2];
|
|
XAnimDynamicIndices indices;
|
|
};
|
|
|
|
union XAnimDeltaPartQuatData
|
|
{
|
|
XAnimDeltaPartQuatDataFrames frames;
|
|
qint16 frame0[2];
|
|
};
|
|
|
|
struct XAnimDeltaPartQuat
|
|
{
|
|
quint16 size;
|
|
XAnimDeltaPartQuatData u;
|
|
};
|
|
|
|
struct XAnimDeltaPart
|
|
{
|
|
XAnimPartTrans *trans;
|
|
XAnimDeltaPartQuat *quat;
|
|
};
|
|
|
|
struct XAnimParts
|
|
{
|
|
const char *name;
|
|
quint16 dataByteCount;
|
|
quint16 dataShortCount;
|
|
quint16 dataIntCount;
|
|
quint16 randomDataByteCount;
|
|
quint16 randomDataIntCount;
|
|
quint16 numframes;
|
|
bool bLoop;
|
|
bool bDelta;
|
|
quint8 boneCount[12];
|
|
quint8 notifyCount;
|
|
quint8 assetType;
|
|
bool pad;
|
|
uint randomDataShortCount;
|
|
uint indexCount;
|
|
float framerate;
|
|
float frequency;
|
|
quint16 *names;
|
|
quint8 *dataByte;
|
|
qint16 *dataShort;
|
|
int *dataInt;
|
|
qint16 *randomDataShort;
|
|
quint8 *randomDataByte;
|
|
int *randomDataInt;
|
|
XAnimIndices indices;
|
|
XAnimNotifyInfo *notify;
|
|
XAnimDeltaPart *deltaPart;
|
|
};
|
|
|
|
struct cStaticModelWritable
|
|
{
|
|
quint16 nextModelInWorldSector;
|
|
};
|
|
|
|
struct cStaticModel_s
|
|
{
|
|
cStaticModelWritable writable;
|
|
XModel *xmodel;
|
|
float origin[3];
|
|
float invScaledAxis[3][3];
|
|
float absmin[3];
|
|
float absmax[3];
|
|
};
|
|
|
|
struct dmaterial_t
|
|
{
|
|
char material[64];
|
|
int surfaceFlags;
|
|
int contentFlags;
|
|
};
|
|
|
|
struct cNode_t
|
|
{
|
|
qint32 planePtr;
|
|
CPlane plane;
|
|
qint16 children[2];
|
|
};
|
|
|
|
struct __declspec(align(4)) CLeaf
|
|
{
|
|
quint16 firstCollAabbIndex;
|
|
quint16 collAabbCount;
|
|
int brushContents;
|
|
int terrainContents;
|
|
float mins[3];
|
|
float maxs[3];
|
|
int leafBrushNode;
|
|
qint16 cluster;
|
|
};
|
|
|
|
struct CLeafBrushNodeLeaf;
|
|
struct CLeafBrushNodeChildren;
|
|
|
|
struct CLeafBrushNodeData
|
|
{
|
|
// Make these not ptrs
|
|
CLeafBrushNodeLeaf *leaf;
|
|
CLeafBrushNodeChildren *children;
|
|
};
|
|
|
|
struct CLeafBrushNodeLeaf : CLeafBrushNodeData
|
|
{
|
|
qint32 brushesPtr;
|
|
QVector<quint16> brushes;
|
|
};
|
|
|
|
struct CLeafBrushNodeChildren : CLeafBrushNodeData
|
|
{
|
|
float dist;
|
|
float range;
|
|
quint16 childOffset[2];
|
|
};
|
|
|
|
struct CLeafBrushNode
|
|
{
|
|
quint8 axis;
|
|
qint16 leafBrushCount;
|
|
int contents;
|
|
CLeafBrushNodeData data;
|
|
};
|
|
|
|
struct CollisionBorder
|
|
{
|
|
float distEq[3];
|
|
float zBase;
|
|
float zSlope;
|
|
float start;
|
|
float length;
|
|
};
|
|
|
|
struct CollisionPartition
|
|
{
|
|
quint8 triCount;
|
|
quint8 borderCount;
|
|
int firstTri;
|
|
qint32 bordersPtr;
|
|
CollisionBorder borders;
|
|
};
|
|
|
|
union CollisionAabbTreeIndex
|
|
{
|
|
int firstChildIndex;
|
|
int partitionIndex;
|
|
};
|
|
|
|
struct CollisionAabbTree
|
|
{
|
|
float origin[3];
|
|
float halfSize[3];
|
|
quint16 materialIndex;
|
|
quint16 childCount;
|
|
CollisionAabbTreeIndex u;
|
|
};
|
|
|
|
struct XCModel
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
float radius;
|
|
CLeaf leaf;
|
|
};
|
|
|
|
struct XCBrush
|
|
{
|
|
float mins[3];
|
|
int contents;
|
|
float maxs[3];
|
|
uint numsides;
|
|
qint32 sidesPtr;
|
|
QVector<XCBrushSide> sides;
|
|
qint16 axialMaterialNum[2][3];
|
|
qint32 baseAdjacentSidePtr;
|
|
quint8 baseAdjacentSide;
|
|
qint16 firstAdjacentSideOffsets[2][3];
|
|
quint8 edgeCount[2][3];
|
|
};
|
|
|
|
struct MapEnts
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
qint32 entityStringPtr;
|
|
QString entityString;
|
|
int numEntityChars;
|
|
};
|
|
|
|
enum DynEntityType : __int32
|
|
{
|
|
DYNENT_TYPE_INVALID = 0x0,
|
|
DYNENT_TYPE_CLUTTER = 0x1,
|
|
DYNENT_TYPE_DESTRUCT = 0x2,
|
|
DYNENT_TYPE_COUNT = 0x3,
|
|
};
|
|
|
|
struct GfxPlacement
|
|
{
|
|
float quat[4];
|
|
float origin[3];
|
|
};
|
|
|
|
struct FxSpawnDefLooping
|
|
{
|
|
int intervalMsec;
|
|
int count;
|
|
};
|
|
|
|
struct FxIntRange
|
|
{
|
|
int base;
|
|
int amplitude;
|
|
};
|
|
|
|
struct FxSpawnDefOneShot
|
|
{
|
|
FxIntRange count;
|
|
};
|
|
|
|
union FxSpawnDef
|
|
{
|
|
FxSpawnDefLooping looping;
|
|
FxSpawnDefOneShot oneShot;
|
|
};
|
|
|
|
struct FxFloatRange
|
|
{
|
|
float base;
|
|
float amplitude;
|
|
};
|
|
|
|
struct FxElemAtlas
|
|
{
|
|
quint8 behavior;
|
|
quint8 index;
|
|
quint8 fps;
|
|
quint8 loopCount;
|
|
quint8 colIndexBits;
|
|
quint8 rowIndexBits;
|
|
qint16 entryCount;
|
|
};
|
|
|
|
struct FxElemVec3Range
|
|
{
|
|
float base[3];
|
|
float amplitude[3];
|
|
};
|
|
|
|
struct FxElemVelStateInFrame
|
|
{
|
|
FxElemVec3Range velocity;
|
|
FxElemVec3Range totalDelta;
|
|
};
|
|
|
|
struct FxElemVelStateSample
|
|
{
|
|
FxElemVelStateInFrame local;
|
|
FxElemVelStateInFrame world;
|
|
};
|
|
|
|
struct FxElemVisualState
|
|
{
|
|
quint8 color[4];
|
|
float rotationDelta;
|
|
float rotationTotal;
|
|
float size[2];
|
|
float scale;
|
|
};
|
|
|
|
struct FxElemVisStateSample
|
|
{
|
|
FxElemVisualState base;
|
|
FxElemVisualState amplitude;
|
|
};
|
|
|
|
struct FxElemMarkVisuals
|
|
{
|
|
Material *materials[2];
|
|
};
|
|
|
|
struct FxEffectDef;
|
|
|
|
union FxEffectDefRef
|
|
{
|
|
qint32 namePtr;
|
|
};
|
|
|
|
union FxElemVisuals
|
|
{
|
|
const void *anonymous;
|
|
Material *material;
|
|
XModel *model;
|
|
FxEffectDefRef effectDef;
|
|
const char *soundName;
|
|
};
|
|
|
|
union FxElemDefVisuals
|
|
{
|
|
FxElemMarkVisuals *markArray;
|
|
FxElemVisuals *array;
|
|
FxElemVisuals instance;
|
|
};
|
|
|
|
struct FxTrailVertex
|
|
{
|
|
float pos[2];
|
|
float normal[2];
|
|
float texCoord;
|
|
};
|
|
|
|
struct FxTrailDef
|
|
{
|
|
int scrollTimeMsec;
|
|
int repeatDist;
|
|
int splitDist;
|
|
|
|
int vertCount;
|
|
qint32 vertsPtr;
|
|
QVector<FxTrailVertex> verts;
|
|
|
|
int indCount;
|
|
qint32 indsPtr;
|
|
QVector<quint16> inds;
|
|
};
|
|
|
|
struct FxElemDef
|
|
{
|
|
int flags;
|
|
FxSpawnDef spawn;
|
|
FxFloatRange spawnRange;
|
|
FxFloatRange fadeInRange;
|
|
FxFloatRange fadeOutRange;
|
|
float spawnFrustumCullRadius;
|
|
FxIntRange spawnDelayMsec;
|
|
FxIntRange lifeSpanMsec;
|
|
FxFloatRange spawnOrigin[3];
|
|
FxFloatRange spawnOffsetRadius;
|
|
FxFloatRange spawnOffsetHeight;
|
|
FxFloatRange spawnAngles[3];
|
|
FxFloatRange angularVelocity[3];
|
|
FxFloatRange initialRotation;
|
|
FxFloatRange gravity;
|
|
FxFloatRange reflectionFactor;
|
|
FxElemAtlas atlas;
|
|
quint8 elemType;
|
|
quint8 visualCount;
|
|
quint8 velIntervalCount;
|
|
quint8 visStateIntervalCount;
|
|
const FxElemVelStateSample *velSamples;
|
|
const FxElemVisStateSample *visSamples;
|
|
FxElemDefVisuals visuals;
|
|
float collMins[3];
|
|
float collMaxs[3];
|
|
FxEffectDefRef effectOnImpact;
|
|
FxEffectDefRef effectOnDeath;
|
|
FxEffectDefRef effectEmitted;
|
|
FxFloatRange emitDist;
|
|
FxFloatRange emitDistVariance;
|
|
FxTrailDef *trailDef;
|
|
quint8 sortOrder;
|
|
quint8 lightingFrac;
|
|
quint8 useItemClip;
|
|
quint8 unused[1];
|
|
};
|
|
|
|
struct FxEffectDef
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
int flags;
|
|
int totalSize;
|
|
int msecLoopingLife;
|
|
int elemDefCountLooping;
|
|
int elemDefCountOneShot;
|
|
int elemDefCountEmission;
|
|
qint32 elemDefsPtr;
|
|
QVector<FxElemDef> elemDefs;
|
|
};
|
|
|
|
struct DynEntityDef
|
|
{
|
|
DynEntityType type;
|
|
GfxPlacement pose;
|
|
qint32 xModelPtr;
|
|
XModel xModel;
|
|
quint16 brushModel;
|
|
quint16 physicsBrushModel;
|
|
qint32 destroyFxPtr;
|
|
FxEffectDef destroyFx;
|
|
qint32 destroyPiecesPtr;
|
|
XModelPieces destroyPieces;
|
|
qint32 physPresetPtr;
|
|
PhysPreset physPreset;
|
|
int health;
|
|
PhysMass mass;
|
|
int contents;
|
|
};
|
|
|
|
struct DynEntityPose
|
|
{
|
|
GfxPlacement pose;
|
|
float radius;
|
|
};
|
|
|
|
struct DynEntityClient
|
|
{
|
|
int physObjId;
|
|
quint16 flags;
|
|
quint16 lightingHandle;
|
|
int health;
|
|
};
|
|
|
|
struct DynEntityColl
|
|
{
|
|
quint16 sector;
|
|
quint16 nextEntInSector;
|
|
float linkMins[2];
|
|
float linkMaxs[2];
|
|
};
|
|
|
|
struct clipMap_t
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
|
|
int isInUse;
|
|
|
|
int planeCount;
|
|
qint32 planesPtr;
|
|
QVector<CPlane> planes;
|
|
|
|
uint numStaticModels;
|
|
qint32 staticModelListPtr;
|
|
QVector<cStaticModel_s> staticModelList;
|
|
|
|
uint numMaterials;
|
|
qint32 materialsPtr;
|
|
QVector<dmaterial_t> materials;
|
|
|
|
uint numBrushSides;
|
|
qint32 brushsidesPtr;
|
|
QVector<CBrushSide> brushsides;
|
|
|
|
uint numBrushEdges;
|
|
qint32 brushEdgesPtr;
|
|
QVector<quint8> brushEdges;
|
|
|
|
uint numNodes;
|
|
qint32 nodesPtr;
|
|
QVector<cNode_t> nodes;
|
|
|
|
uint numLeafs;
|
|
qint32 leafsPtr;
|
|
QVector<CLeaf> leafs;
|
|
|
|
uint leafbrushNodesCount;
|
|
qint32 leafbrushNodesPtr;
|
|
QVector<CLeafBrushNode> leafbrushNodes;
|
|
|
|
uint numLeafBrushes;
|
|
qint32 leafbrushesPtr;
|
|
QVector<quint16> leafbrushes;
|
|
|
|
uint numLeafSurfaces;
|
|
qint32 leafsurfacesPtr;
|
|
QVector<uint> leafsurfaces;
|
|
|
|
uint vertCount;
|
|
float (*verts)[3];
|
|
|
|
int triCount;
|
|
qint32 triIndicesPtr;
|
|
QVector<quint16> triIndices;
|
|
qint32 triEdgeIsWalkablePtr;
|
|
QVector<quint8> triEdgeIsWalkable;
|
|
|
|
int borderCount;
|
|
qint32 bordersPtr;
|
|
QVector<CollisionBorder> borders;
|
|
|
|
int partitionCount;
|
|
qint32 partitionsPtr;
|
|
QVector<CollisionPartition> partitions;
|
|
|
|
int aabbTreeCount;
|
|
qint32 aabbTreesPtr;
|
|
QVector<CollisionAabbTree> aabbTrees;
|
|
|
|
uint numSubModels;
|
|
qint32 cmodelsPtr;
|
|
QVector<CModel> cmodels;
|
|
|
|
quint16 numBrushes;
|
|
qint32 brushesPtr;
|
|
QVector<CBrush> brushes;
|
|
|
|
int numClusters;
|
|
int clusterBytes;
|
|
|
|
qint32 visibilityPtr;
|
|
QVector<quint8> visibility;
|
|
int vised;
|
|
QVector<MapEnts> mapEnts;
|
|
CBrush *box_brush;
|
|
CModel box_model;
|
|
quint16 dynEntCount[2];
|
|
DynEntityDef *dynEntDefList[2];
|
|
DynEntityPose *dynEntPoseList[2];
|
|
DynEntityClient *dynEntClientList[2];
|
|
DynEntityColl *dynEntCollList[2];
|
|
uint checksum;
|
|
};
|
|
|
|
struct XComPrimaryLight
|
|
{
|
|
quint8 type;
|
|
quint8 canUseShadowMap;
|
|
quint8 exponent;
|
|
quint8 unused;
|
|
float color[3];
|
|
float dir[3];
|
|
float origin[3];
|
|
float radius;
|
|
float cosHalfFovOuter;
|
|
float cosHalfFovInner;
|
|
float cosHalfFovExpanded;
|
|
float rotationLimit;
|
|
float translationLimit;
|
|
qint32 defNamePtr;
|
|
QString defName;
|
|
};
|
|
|
|
struct ComWorld
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
int isInUse;
|
|
uint primaryLightCount;
|
|
qint32 primaryLightsPtr;
|
|
QVector<XComPrimaryLight> primaryLights;
|
|
};
|
|
|
|
enum nodeType : qint32
|
|
{
|
|
NODE_BADNODE = 0x0,
|
|
NODE_PATHNODE = 0x1,
|
|
NODE_COVER_STAND = 0x2,
|
|
NODE_COVER_CROUCH = 0x3,
|
|
NODE_COVER_CROUCH_WINDOW = 0x4,
|
|
NODE_COVER_PRONE = 0x5,
|
|
NODE_COVER_RIGHT = 0x6,
|
|
NODE_COVER_LEFT = 0x7,
|
|
NODE_COVER_WIDE_RIGHT = 0x8,
|
|
NODE_COVER_WIDE_LEFT = 0x9,
|
|
NODE_CONCEALMENT_STAND = 0xA,
|
|
NODE_CONCEALMENT_CROUCH = 0xB,
|
|
NODE_CONCEALMENT_PRONE = 0xC,
|
|
NODE_REACQUIRE = 0xD,
|
|
NODE_BALCONY = 0xE,
|
|
NODE_SCRIPTED = 0xF,
|
|
NODE_NEGOTIATION_BEGIN = 0x10,
|
|
NODE_NEGOTIATION_END = 0x11,
|
|
NODE_TURRET = 0x12,
|
|
NODE_GUARD = 0x13,
|
|
NODE_NUMTYPES = 0x14,
|
|
NODE_DONTLINK = 0x14,
|
|
};
|
|
|
|
struct PathLink
|
|
{
|
|
float fDist;
|
|
quint16 nodeNum;
|
|
quint8 disconnectCount;
|
|
quint8 negotiationLink;
|
|
quint8 ubBadPlaceCount[4];
|
|
};
|
|
|
|
struct PathNodeConstant
|
|
{
|
|
nodeType type;
|
|
quint16 spawnflags;
|
|
quint16 targetname;
|
|
quint16 script_linkName;
|
|
quint16 script_noteworthy;
|
|
quint16 target;
|
|
quint16 animscript;
|
|
int animscriptfunc;
|
|
float vOrigin[3];
|
|
float fAngle;
|
|
float forward[2];
|
|
float fRadius;
|
|
float minUseDistSq;
|
|
qint16 wOverlapNode[2];
|
|
qint16 wChainId;
|
|
qint16 wChainDepth;
|
|
qint16 wChainParent;
|
|
quint16 totalLinkCount;
|
|
qint32 LinksPtr;
|
|
PathLink Links;
|
|
};
|
|
|
|
struct pathnode_dynamic_t
|
|
{
|
|
void *pOwner;
|
|
int iFreeTime;
|
|
int iValidTime[3];
|
|
int inPlayerLOSTime;
|
|
qint16 wLinkCount;
|
|
qint16 wOverlapCount;
|
|
qint16 turretEntNumber;
|
|
qint16 userCount;
|
|
};
|
|
|
|
struct pathnode_t;
|
|
|
|
struct pathnode_transient_t
|
|
{
|
|
int iSearchFrame;
|
|
pathnode_t *pNextOpen;
|
|
pathnode_t *pPrevOpen;
|
|
pathnode_t *pParent;
|
|
float fCost;
|
|
float fHeuristic;
|
|
float costFactor;
|
|
};
|
|
|
|
struct pathnode_t
|
|
{
|
|
PathNodeConstant constant;
|
|
pathnode_dynamic_t dynamic;
|
|
pathnode_transient_t transient;
|
|
};
|
|
|
|
struct PathBaseNode
|
|
{
|
|
float vOrigin[3];
|
|
uint type;
|
|
};
|
|
|
|
struct PathNodeTree;
|
|
|
|
struct PathNodeTreeNodes
|
|
{
|
|
int nodeCount;
|
|
QVector<quint16> nodes;
|
|
};
|
|
|
|
union PathNodeTreeInfo
|
|
{
|
|
PathNodeTree *child[2];
|
|
PathNodeTreeNodes s;
|
|
};
|
|
|
|
struct PathNodeTree
|
|
{
|
|
int axis;
|
|
float dist;
|
|
qint32 infoPtr;
|
|
PathNodeTreeInfo info;
|
|
};
|
|
|
|
struct PathData
|
|
{
|
|
uint nodeCount;
|
|
pathnode_t *nodes;
|
|
PathBaseNode *basenodes;
|
|
uint chainNodeCount;
|
|
quint16 *chainNodeForNode;
|
|
quint16 *nodeForChainNode;
|
|
int visBytes;
|
|
quint8 *pathVis;
|
|
int nodeTreeCount;
|
|
PathNodeTree *nodeTree;
|
|
};
|
|
|
|
struct GameWorldSp
|
|
{
|
|
const char *name;
|
|
PathData path;
|
|
};
|
|
|
|
struct GameWorldMp
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
};
|
|
|
|
struct GfxStreamingAabbTree
|
|
{
|
|
quint16 firstItem;
|
|
quint16 itemCount;
|
|
quint16 firstChild;
|
|
quint16 childCount;
|
|
float mins[3];
|
|
float maxs[3];
|
|
};
|
|
|
|
struct GfxWorldStreamInfo
|
|
{
|
|
int aabbTreeCount;
|
|
qint32 aabbTreesPtr;
|
|
QVector<GfxStreamingAabbTree> aabbTrees;
|
|
|
|
int leafRefCount;
|
|
qint32 leafRefsPtr;
|
|
QVector<int> leafRefs;
|
|
};
|
|
|
|
struct GfxWorldVertex
|
|
{
|
|
float xyz[3];
|
|
float binormalSign;
|
|
GfxColor color;
|
|
float texCoord[2];
|
|
float lmapCoord[2];
|
|
PackedUnitVec normal;
|
|
PackedUnitVec tangent;
|
|
};
|
|
|
|
struct GfxWorldVertexData
|
|
{
|
|
qint32 verticesPtr;
|
|
QVector<GfxWorldVertex> vertices;
|
|
D3DVertexBuffer worldVb;
|
|
};
|
|
|
|
struct GfxWorldVertexLayerData
|
|
{
|
|
qint32 dataPtr;
|
|
QVector<quint8> data;
|
|
D3DVertexBuffer layerVb;
|
|
};
|
|
|
|
struct SunLightParseParams
|
|
{
|
|
char name[64];
|
|
float ambientScale;
|
|
float ambientColor[3];
|
|
float diffuseFraction;
|
|
float sunLight;
|
|
float sunColor[3];
|
|
float diffuseColor[3];
|
|
bool diffuseColorHasBeenSet;
|
|
float angles[3];
|
|
};
|
|
|
|
struct __declspec(align(4)) XGfxLightImage
|
|
{
|
|
GfxImage *image;
|
|
quint8 samplerState;
|
|
};
|
|
|
|
struct XGfxLightDef
|
|
{
|
|
const char *name;
|
|
XGfxLightImage attenuation;
|
|
int lmapLookupStart;
|
|
};
|
|
|
|
struct GfxLight
|
|
{
|
|
quint8 type;
|
|
quint8 canUseShadowMap;
|
|
quint8 unused[2];
|
|
float color[3];
|
|
float dir[3];
|
|
float origin[3];
|
|
float radius;
|
|
float cosHalfFovOuter;
|
|
float cosHalfFovInner;
|
|
int exponent;
|
|
uint spotShadowIndex;
|
|
XGfxLightDef *def;
|
|
};
|
|
|
|
struct GfxReflectionProbe
|
|
{
|
|
float origin[3];
|
|
GfxImage *reflectionImage;
|
|
};
|
|
|
|
struct GfxWorldDpvsPlanes
|
|
{
|
|
int cellCount;
|
|
qint32 planesPtr;
|
|
QVector<CPlane> planes;
|
|
qint32 nodesPtr;
|
|
QVector<quint16> nodes;
|
|
qint32 sceneEntCellBitsPtr;
|
|
QVector<uint> sceneEntCellBits;
|
|
};
|
|
|
|
struct GfxAabbTree
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
quint16 childCount;
|
|
quint16 surfaceCount;
|
|
quint16 startSurfIndex;
|
|
|
|
quint16 smodelIndexCount;
|
|
qint32 smodelIndexesPtr;
|
|
QVector<quint16> smodelIndexes;
|
|
|
|
int childrenOffset;
|
|
};
|
|
|
|
struct GfxPortal;
|
|
|
|
struct GfxPortalWritable
|
|
{
|
|
bool isQueued;
|
|
bool isAncestor;
|
|
quint8 recursionDepth;
|
|
quint8 hullPointCount;
|
|
quint32 hullPointPtrs[2];
|
|
float hullPoints[2];
|
|
qint32 queuedParentPtr;
|
|
GfxPortal *queuedParent;
|
|
};
|
|
|
|
struct DpvsPlane
|
|
{
|
|
float coeffs[4];
|
|
quint8 side[3];
|
|
quint8 pad;
|
|
};
|
|
|
|
struct GfxCell;
|
|
|
|
struct GfxPortal
|
|
{
|
|
GfxPortalWritable writable;
|
|
DpvsPlane plane;
|
|
|
|
qint32 cellPtr;
|
|
GfxCell *cell;
|
|
|
|
qint32 verticesPtr;
|
|
float vertices[3];
|
|
quint8 vertexCount;
|
|
|
|
float hullAxis[2][3];
|
|
};
|
|
|
|
struct GfxCell
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
|
|
int aabbTreeCount;
|
|
qint32 aabbTreePtr;
|
|
QVector<GfxAabbTree> aabbTree;
|
|
|
|
int portalCount;
|
|
qint32 portalsPtr;
|
|
QVector<GfxPortal> portals;
|
|
|
|
int cullGroupCount;
|
|
qint32 cullGroupsPtr;
|
|
QVector<int> cullGroups;
|
|
|
|
quint8 reflectionProbeCount;
|
|
qint32 reflectionProbesPtr;
|
|
QVector<quint8> reflectionProbes;
|
|
};
|
|
|
|
struct GfxLightmapArray
|
|
{
|
|
GfxImage *primary;
|
|
GfxImage *secondary;
|
|
};
|
|
|
|
struct GfxLightGridEntry
|
|
{
|
|
quint16 colorsIndex;
|
|
quint8 primaryLightIndex;
|
|
quint8 needsTrace;
|
|
};
|
|
|
|
struct GfxLightGridColors
|
|
{
|
|
quint8 rgb[56][3];
|
|
};
|
|
|
|
struct GfxLightGrid
|
|
{
|
|
bool hasLightRegions;
|
|
uint sunPrimaryLightIndex;
|
|
quint16 mins[3];
|
|
quint16 maxs[3];
|
|
uint rowAxis;
|
|
uint colAxis;
|
|
qint32 rowDataStartPtr;
|
|
QVector<quint16> rowDataStart;
|
|
uint rawRowDataSize;
|
|
qint32 rawRowDataPtr;
|
|
QVector<quint8> rawRowData;
|
|
uint entryCount;
|
|
qint32 entriesPtr;
|
|
QVector<GfxLightGridEntry> entries;
|
|
uint colorCount;
|
|
qint32 colorsPtr;
|
|
QVector<GfxLightGridColors> colors;
|
|
};
|
|
|
|
struct GfxBrushModelWritable
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
};
|
|
|
|
struct GfxBrushModel
|
|
{
|
|
GfxBrushModelWritable writable;
|
|
float bounds[2][3];
|
|
uint surfaceCount;
|
|
uint startSurfIndex;
|
|
};
|
|
|
|
struct MaterialMemory
|
|
{
|
|
Material *material;
|
|
int memory;
|
|
};
|
|
|
|
struct sunflare_t
|
|
{
|
|
bool hasValidData;
|
|
Material *spriteMaterial;
|
|
Material *flareMaterial;
|
|
float spriteSize;
|
|
float flareMinSize;
|
|
float flareMinDot;
|
|
float flareMaxSize;
|
|
float flareMaxDot;
|
|
float flareMaxAlpha;
|
|
int flareFadeInTime;
|
|
int flareFadeOutTime;
|
|
float blindMinDot;
|
|
float blindMaxDot;
|
|
float blindMaxDarken;
|
|
int blindFadeInTime;
|
|
int blindFadeOutTime;
|
|
float glareMinDot;
|
|
float glareMaxDot;
|
|
float glareMaxLighten;
|
|
int glareFadeInTime;
|
|
int glareFadeOutTime;
|
|
float sunFxPosition[3];
|
|
};
|
|
|
|
struct XModelDrawInfo
|
|
{
|
|
quint16 lod;
|
|
quint16 surfId;
|
|
};
|
|
|
|
struct GfxSceneDynModel
|
|
{
|
|
XModelDrawInfo info;
|
|
quint16 dynEntId;
|
|
};
|
|
|
|
struct BModelDrawInfo
|
|
{
|
|
quint16 surfId;
|
|
};
|
|
|
|
struct GfxSceneDynBrush
|
|
{
|
|
BModelDrawInfo info;
|
|
quint16 dynEntId;
|
|
};
|
|
|
|
struct GfxShadowGeometry
|
|
{
|
|
quint16 surfaceCount;
|
|
quint16 smodelCount;
|
|
qint32 sortedSurfIndexPtr;
|
|
QVector<quint16> sortedSurfIndex;
|
|
qint32 smodelIndexPtr;
|
|
QVector<quint16> smodelIndex;
|
|
};
|
|
|
|
struct GfxLightRegionAxis
|
|
{
|
|
float dir[3];
|
|
float midPoint;
|
|
float halfSize;
|
|
};
|
|
|
|
struct GfxLightRegionHull
|
|
{
|
|
float kdopMidPoint[9];
|
|
float kdopHalfSize[9];
|
|
uint axisCount;
|
|
qint32 axisPtr;
|
|
QVector<GfxLightRegionAxis> axis;
|
|
};
|
|
|
|
struct GfxLightRegion
|
|
{
|
|
uint hullCount;
|
|
qint32 hullsPtr;
|
|
QVector<GfxLightRegionHull> hulls;
|
|
};
|
|
|
|
struct GfxStaticModelInst
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
GfxColor groundLighting;
|
|
};
|
|
|
|
struct srfTriangles_t
|
|
{
|
|
int vertexLayerData;
|
|
int firstVertex;
|
|
quint16 vertexCount;
|
|
quint16 triCount;
|
|
int baseIndex;
|
|
float topMipMins[3];
|
|
float topMipMaxs[3];
|
|
};
|
|
|
|
struct GfxSurface
|
|
{
|
|
srfTriangles_t tris;
|
|
Material *material;
|
|
quint8 lightmapIndex;
|
|
quint8 reflectionProbeIndex;
|
|
quint8 primaryLightIndex;
|
|
bool castsSunShadow;
|
|
float bounds[2][3];
|
|
};
|
|
|
|
struct GfxCullGroup
|
|
{
|
|
float mins[3];
|
|
float maxs[3];
|
|
int surfaceCount;
|
|
int startSurfIndex;
|
|
};
|
|
|
|
struct GfxPackedPlacement
|
|
{
|
|
float origin[3];
|
|
PackedUnitVec axis[3];
|
|
float scale;
|
|
};
|
|
|
|
struct __declspec(align(4)) GfxStaticModelDrawInst
|
|
{
|
|
float cullDist;
|
|
GfxPackedPlacement placement;
|
|
XModel *model;
|
|
quint8 reflectionProbeIndex;
|
|
quint8 primaryLightIndex;
|
|
quint16 lightingHandle;
|
|
quint8 flags;
|
|
};
|
|
|
|
struct GfxWorldDpvsStatic
|
|
{
|
|
uint smodelCount;
|
|
uint staticSurfaceCount;
|
|
uint litSurfsBegin;
|
|
uint litSurfsEnd;
|
|
uint decalSurfsBegin;
|
|
uint decalSurfsEnd;
|
|
uint emissiveSurfsBegin;
|
|
uint emissiveSurfsEnd;
|
|
uint smodelVisDataCount;
|
|
uint surfaceVisDataCount;
|
|
quint8 *smodelVisData[3];
|
|
quint8 *surfaceVisData[3];
|
|
uint *lodData;
|
|
quint16 *sortedSurfIndex;
|
|
GfxStaticModelInst *smodelInsts;
|
|
GfxSurface *surfaces;
|
|
GfxCullGroup *cullGroups;
|
|
GfxStaticModelDrawInst *smodelDrawInsts;
|
|
GfxDrawSurfFields *surfaceMaterials;
|
|
uint *surfaceCastsSunShadow;
|
|
volatile int usageCount;
|
|
};
|
|
|
|
struct GfxWorldDpvsDynamic
|
|
{
|
|
uint dynEntClientWordCount[2];
|
|
uint dynEntClientCount[2];
|
|
qint32 dynEntCellBitsPtrs[2];
|
|
uint dynEntCellBits[2];
|
|
qint32 dynEntVisDataPtrs[2][3];
|
|
quint8 dynEntVisData[2][3];
|
|
};
|
|
|
|
struct GfxWorld
|
|
{
|
|
const char *name;
|
|
const char *baseName;
|
|
int planeCount;
|
|
int nodeCount;
|
|
int indexCount;
|
|
quint16 *indices;
|
|
D3DIndexBuffer indexBuffer;
|
|
int surfaceCount;
|
|
GfxWorldStreamInfo streamInfo;
|
|
int skySurfCount;
|
|
int *skyStartSurfs;
|
|
GfxImage *skyImage;
|
|
quint8 skySamplerState;
|
|
uint vertexCount;
|
|
GfxWorldVertexData vd;
|
|
uint vertexLayerDataSize;
|
|
GfxWorldVertexLayerData vld;
|
|
SunLightParseParams sunParse;
|
|
GfxLight *sunLight;
|
|
float sunColorFromBsp[3];
|
|
uint sunPrimaryLightIndex;
|
|
uint primaryLightCount;
|
|
int cullGroupCount;
|
|
uint reflectionProbeCount;
|
|
GfxReflectionProbe *reflectionProbes;
|
|
GfxTexture *reflectionProbeTextures;
|
|
GfxWorldDpvsPlanes dpvsPlanes;
|
|
int cellBitsCount;
|
|
GfxCell *cells;
|
|
int lightmapCount;
|
|
GfxLightmapArray *lightmaps;
|
|
GfxLightGrid lightGrid;
|
|
GfxTexture *lightmapPrimaryTextures;
|
|
GfxTexture *lightmapSecondaryTextures;
|
|
int modelCount;
|
|
GfxBrushModel *models;
|
|
float mins[3];
|
|
float maxs[3];
|
|
uint checksum;
|
|
int materialMemoryCount;
|
|
MaterialMemory *materialMemory;
|
|
sunflare_t sun;
|
|
float outdoorLookupMatrix[4][4];
|
|
GfxImage *outdoorImage;
|
|
uint *cellCasterBits;
|
|
GfxSceneDynModel *sceneDynModel;
|
|
GfxSceneDynBrush *sceneDynBrush;
|
|
uint *primaryLightEntityShadowVis;
|
|
uint *primaryLightDynEntShadowVis[2];
|
|
quint8 *nonSunPrimaryLightForModelDynEnt;
|
|
GfxShadowGeometry *shadowGeom;
|
|
GfxLightRegion *lightRegion;
|
|
GfxWorldDpvsStatic dpvs;
|
|
GfxWorldDpvsDynamic dpvsDyn;
|
|
};
|
|
|
|
struct Glyph
|
|
{
|
|
quint16 letter;
|
|
char x0;
|
|
char y0;
|
|
quint8 dx;
|
|
quint8 pixelWidth;
|
|
quint8 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 XRectDef
|
|
{
|
|
float x;
|
|
float y;
|
|
float w;
|
|
float h;
|
|
int horzAlign;
|
|
int vertAlign;
|
|
};
|
|
|
|
struct XWindowDef
|
|
{
|
|
const char *name;
|
|
XRectDef rect;
|
|
XRectDef rectClient;
|
|
const char *group;
|
|
int style;
|
|
int border;
|
|
int ownerDraw;
|
|
int ownerDrawFlags;
|
|
float borderSize;
|
|
int staticFlags;
|
|
int dynamicFlags[4];
|
|
int nextTime;
|
|
float foreColor[4];
|
|
float backColor[4];
|
|
float borderColor[4];
|
|
float outlineColor[4];
|
|
Material *background;
|
|
};
|
|
|
|
struct XItemKeyHandler
|
|
{
|
|
int key;
|
|
qint32 actionPtr;
|
|
QString action;
|
|
qint32 nextPtr;
|
|
XItemKeyHandler *next;
|
|
};
|
|
|
|
enum OperationEnum : qint32
|
|
{
|
|
OP_NOOP = 0x0,
|
|
OP_RIGHTPAREN = 0x1,
|
|
OP_MULTIPLY = 0x2,
|
|
OP_DIVIDE = 0x3,
|
|
OP_MODULUS = 0x4,
|
|
OP_ADD = 0x5,
|
|
OP_SUBTRACT = 0x6,
|
|
OP_NOT = 0x7,
|
|
OP_LESSTHAN = 0x8,
|
|
OP_LESSTHANEQUALTO = 0x9,
|
|
OP_GREATERTHAN = 0xA,
|
|
OP_GREATERTHANEQUALTO = 0xB,
|
|
OP_EQUALS = 0xC,
|
|
OP_NOTEQUAL = 0xD,
|
|
OP_AND = 0xE,
|
|
OP_OR = 0xF,
|
|
OP_LEFTPAREN = 0x10,
|
|
OP_COMMA = 0x11,
|
|
OP_BITWISEAND = 0x12,
|
|
OP_BITWISEOR = 0x13,
|
|
OP_BITWISENOT = 0x14,
|
|
OP_BITSHIFTLEFT = 0x15,
|
|
OP_BITSHIFTRIGHT = 0x16,
|
|
OP_SIN = 0x17,
|
|
OP_FIRSTFUNCTIONCALL = 0x17,
|
|
OP_COS = 0x18,
|
|
OP_MIN = 0x19,
|
|
OP_MAX = 0x1A,
|
|
OP_MILLISECONDS = 0x1B,
|
|
OP_DVARINT = 0x1C,
|
|
OP_DVARBOOL = 0x1D,
|
|
OP_DVARFLOAT = 0x1E,
|
|
OP_DVARSTRING = 0x1F,
|
|
OP_STAT = 0x20,
|
|
OP_UIACTIVE = 0x21,
|
|
OP_FLASHBANGED = 0x22,
|
|
OP_SCOPED = 0x23,
|
|
OP_SCOREBOARDVISIBLE = 0x24,
|
|
OP_INKILLCAM = 0x25,
|
|
OP_PLAYERFIELD = 0x26,
|
|
OP_SELECTINGLOCATION = 0x27,
|
|
OP_TEAMFIELD = 0x28,
|
|
OP_OTHERTEAMFIELD = 0x29,
|
|
OP_MARINESFIELD = 0x2A,
|
|
OP_OPFORFIELD = 0x2B,
|
|
OP_MENUISOPEN = 0x2C,
|
|
OP_WRITINGDATA = 0x2D,
|
|
OP_INLOBBY = 0x2E,
|
|
OP_INPRIVATEPARTY = 0x2F,
|
|
OP_PRIVATEPARTYHOST = 0x30,
|
|
OP_PRIVATEPARTYHOSTINLOBBY = 0x31,
|
|
OP_ALONEINPARTY = 0x32,
|
|
OP_ADSJAVELIN = 0x33,
|
|
OP_WEAPLOCKBLINK = 0x34,
|
|
OP_WEAPATTACKTOP = 0x35,
|
|
OP_WEAPATTACKDIRECT = 0x36,
|
|
OP_SECONDSASTIME = 0x37,
|
|
OP_TABLELOOKUP = 0x38,
|
|
OP_LOCALIZESTRING = 0x39,
|
|
OP_LOCALVARINT = 0x3A,
|
|
OP_LOCALVARBOOL = 0x3B,
|
|
OP_LOCALVARFLOAT = 0x3C,
|
|
OP_LOCALVARSTRING = 0x3D,
|
|
OP_TIMELEFT = 0x3E,
|
|
OP_SECONDSASCOUNTDOWN = 0x3F,
|
|
OP_GAMEMSGWNDACTIVE = 0x40,
|
|
OP_TOINT = 0x41,
|
|
OP_TOSTRING = 0x42,
|
|
OP_TOFLOAT = 0x43,
|
|
OP_GAMETYPENAME = 0x44,
|
|
OP_GAMETYPE = 0x45,
|
|
OP_GAMETYPEDESCRIPTION = 0x46,
|
|
OP_SCORE = 0x47,
|
|
OP_FRIENDSONLINE = 0x48,
|
|
OP_FOLLOWING = 0x49,
|
|
OP_STATRANGEBITSSET = 0x4A,
|
|
OP_KEYBINDING = 0x4B,
|
|
OP_ACTIONSLOTUSABLE = 0x4C,
|
|
OP_HUDFADE = 0x4D,
|
|
OP_MAXPLAYERS = 0x4E,
|
|
OP_ACCEPTINGINVITE = 0x4F,
|
|
NUM_OPERATORS = 0x50,
|
|
};
|
|
|
|
enum XExpDataType : __int32
|
|
{
|
|
VAL_INT = 0x0,
|
|
VAL_FLOAT = 0x1,
|
|
VAL_STRING = 0x2,
|
|
};
|
|
|
|
struct XOperand
|
|
{
|
|
XExpDataType dataType;
|
|
int intVal;
|
|
float floatVal;
|
|
QString stringVal;
|
|
};
|
|
|
|
union entryInternalData
|
|
{
|
|
OperationEnum op;
|
|
XOperand operand;
|
|
};
|
|
|
|
struct XExpressionEntry
|
|
{
|
|
int type;
|
|
entryInternalData data;
|
|
};
|
|
|
|
struct XStatement
|
|
{
|
|
int numEntries;
|
|
XExpressionEntry **entries;
|
|
};
|
|
|
|
struct ItemDef;
|
|
|
|
struct menuDef_t
|
|
{
|
|
XWindowDef window;
|
|
const char *font;
|
|
int fullScreen;
|
|
int itemCount;
|
|
int fontIndex;
|
|
int cursorItem[4];
|
|
int fadeCycle;
|
|
float fadeClamp;
|
|
float fadeAmount;
|
|
float fadeInAmount;
|
|
float blurRadius;
|
|
const char *onOpen;
|
|
const char *onClose;
|
|
const char *onESC;
|
|
XItemKeyHandler *onKey;
|
|
XStatement visibleExp;
|
|
const char *allowedBinding;
|
|
const char *soundName;
|
|
int imageTrack;
|
|
float focusColor[4];
|
|
float disableColor[4];
|
|
XStatement rectXExp;
|
|
XStatement rectYExp;
|
|
ItemDef **items;
|
|
};
|
|
|
|
struct XColumnInfo
|
|
{
|
|
int pos;
|
|
int width;
|
|
int maxChars;
|
|
int alignment;
|
|
};
|
|
|
|
struct XListBoxDef
|
|
{
|
|
int startPos[4];
|
|
int endPos[4];
|
|
int drawPadding;
|
|
float elementWidth;
|
|
float elementHeight;
|
|
int elementStyle;
|
|
int numColumns;
|
|
XColumnInfo columnInfo[16];
|
|
const char *doubleClick;
|
|
int notselectable;
|
|
int noScrollBars;
|
|
int usePaging;
|
|
float selectBorder[4];
|
|
float disableColor[4];
|
|
Material *selectIcon;
|
|
};
|
|
|
|
struct XEditFieldDef
|
|
{
|
|
float minVal;
|
|
float maxVal;
|
|
float defVal;
|
|
float range;
|
|
int maxChars;
|
|
int maxCharsGotoNext;
|
|
int maxPaintChars;
|
|
int paintOffset;
|
|
};
|
|
|
|
struct XMultiDef
|
|
{
|
|
QVector<qint32> dvarListPtrs;
|
|
QStringList dvarList;
|
|
QVector<qint32> dvarStrPtrs;
|
|
QStringList dvarStr;
|
|
QVector<float> dvarValue[32];
|
|
int count;
|
|
int strDef;
|
|
};
|
|
|
|
union XItemDefData
|
|
{
|
|
XListBoxDef *listBox;
|
|
XEditFieldDef *editField;
|
|
XMultiDef *multi;
|
|
const char *enumDvarName;
|
|
void *data;
|
|
};
|
|
|
|
struct ItemDef
|
|
{
|
|
XWindowDef window;
|
|
XRectDef textRect[4];
|
|
int type;
|
|
int dataType;
|
|
int alignment;
|
|
int fontEnum;
|
|
int textAlignMode;
|
|
float textalignx;
|
|
float textaligny;
|
|
float textscale;
|
|
int textStyle;
|
|
int gameMsgWindowIndex;
|
|
int gameMsgWindowMode;
|
|
const char *text;
|
|
int itemFlags;
|
|
menuDef_t *parent;
|
|
const char *mouseEnterText;
|
|
const char *mouseExitText;
|
|
const char *mouseEnter;
|
|
const char *mouseExit;
|
|
const char *action;
|
|
const char *onAccept;
|
|
const char *onFocus;
|
|
const char *leaveFocus;
|
|
const char *dvar;
|
|
const char *dvarTest;
|
|
XItemKeyHandler *onKey;
|
|
const char *enableDvar;
|
|
int dvarFlags;
|
|
SoundAliasList *focusSound;
|
|
float special;
|
|
int cursorPos[4];
|
|
XItemDefData typeData;
|
|
int imageTrack;
|
|
XStatement visibleExp;
|
|
XStatement textExp;
|
|
XStatement materialExp;
|
|
XStatement rectXExp;
|
|
XStatement rectYExp;
|
|
XStatement rectWExp;
|
|
XStatement rectHExp;
|
|
XStatement forecolorAExp;
|
|
};
|
|
|
|
struct MenuList
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
int menuCount;
|
|
qint32 menusPtr;
|
|
QVector<menuDef_t> menus;
|
|
};
|
|
|
|
struct XLocalizeEntry
|
|
{
|
|
qint32 valuePtr;
|
|
QString value;
|
|
|
|
qint32 namePtr;
|
|
QString name;
|
|
};
|
|
|
|
enum WeaponType : __int32
|
|
{
|
|
WEAPTYPE_BULLET = 0x0,
|
|
WEAPTYPE_GRENADE = 0x1,
|
|
WEAPTYPE_PROJECTILE = 0x2,
|
|
WEAPTYPE_BINOCULARS = 0x3,
|
|
WEAPTYPE_NUM = 0x4,
|
|
};
|
|
|
|
enum WeaponClass : __int32
|
|
{
|
|
WEAPCLASS_RIFLE = 0x0,
|
|
WEAPCLASS_MG = 0x1,
|
|
WEAPCLASS_SMG = 0x2,
|
|
WEAPCLASS_SPREAD = 0x3,
|
|
WEAPCLASS_PISTOL = 0x4,
|
|
WEAPCLASS_GRENADE = 0x5,
|
|
WEAPCLASS_ROCKETLAUNCHER = 0x6,
|
|
WEAPCLASS_TURRET = 0x7,
|
|
WEAPCLASS_NON_PLAYER = 0x8,
|
|
WEAPCLASS_ITEM = 0x9,
|
|
WEAPCLASS_NUM = 0xA,
|
|
};
|
|
|
|
enum PenetrateType : __int32
|
|
{
|
|
PENETRATE_TYPE_NONE = 0x0,
|
|
PENETRATE_TYPE_SMALL = 0x1,
|
|
PENETRATE_TYPE_MEDIUM = 0x2,
|
|
PENETRATE_TYPE_LARGE = 0x3,
|
|
PENETRATE_TYPE_COUNT = 0x4,
|
|
};
|
|
|
|
enum ImpactType : __int32
|
|
{
|
|
IMPACT_TYPE_NONE = 0x0,
|
|
IMPACT_TYPE_BULLET_SMALL = 0x1,
|
|
IMPACT_TYPE_BULLET_LARGE = 0x2,
|
|
IMPACT_TYPE_BULLET_AP = 0x3,
|
|
IMPACT_TYPE_SHOTGUN = 0x4,
|
|
IMPACT_TYPE_GRENADE_BOUNCE = 0x5,
|
|
IMPACT_TYPE_GRENADE_EXPLODE = 0x6,
|
|
IMPACT_TYPE_ROCKET_EXPLODE = 0x7,
|
|
IMPACT_TYPE_PROJECTILE_DUD = 0x8,
|
|
IMPACT_TYPE_COUNT = 0x9,
|
|
};
|
|
|
|
enum WeaponInventoryType : __int32
|
|
{
|
|
WEAPINVENTORY_PRIMARY = 0x0,
|
|
WEAPINVENTORY_OFFHAND = 0x1,
|
|
WEAPINVENTORY_ITEM = 0x2,
|
|
WEAPINVENTORY_ALTMODE = 0x3,
|
|
WEAPINVENTORYCOUNT = 0x4,
|
|
};
|
|
|
|
enum WeaponFireType : __int32
|
|
{
|
|
WEAPON_FIRETYPE_FULLAUTO = 0x0,
|
|
WEAPON_FIRETYPE_SINGLESHOT = 0x1,
|
|
WEAPON_FIRETYPE_BURSTFIRE2 = 0x2,
|
|
WEAPON_FIRETYPE_BURSTFIRE3 = 0x3,
|
|
WEAPON_FIRETYPE_BURSTFIRE4 = 0x4,
|
|
WEAPON_FIRETYPECOUNT = 0x5,
|
|
};
|
|
|
|
enum OffhandClass : __int32
|
|
{
|
|
OFFHAND_CLASS_NONE = 0x0,
|
|
OFFHAND_CLASS_FRAG_GRENADE = 0x1,
|
|
OFFHAND_CLASS_SMOKE_GRENADE = 0x2,
|
|
OFFHAND_CLASS_FLASH_GRENADE = 0x3,
|
|
OFFHAND_CLASS_COUNT = 0x4,
|
|
};
|
|
|
|
enum WeaponStance : __int32
|
|
{
|
|
WEAPSTANCE_STAND = 0x0,
|
|
WEAPSTANCE_DUCK = 0x1,
|
|
WEAPSTANCE_PRONE = 0x2,
|
|
WEAPSTANCE_NUM = 0x3,
|
|
};
|
|
|
|
enum ActiveReticleType : __int32
|
|
{
|
|
VEH_ACTIVE_RETICLE_NONE = 0x0,
|
|
VEH_ACTIVE_RETICLE_PIP_ON_A_STICK = 0x1,
|
|
VEH_ACTIVE_RETICLE_BOUNCING_DIAMOND = 0x2,
|
|
VEH_ACTIVE_RETICLE_COUNT = 0x3,
|
|
};
|
|
|
|
enum WeaponIconRatioType : __int32
|
|
{
|
|
WEAPON_ICON_RATIO_1TO1 = 0x0,
|
|
WEAPON_ICON_RATIO_2TO1 = 0x1,
|
|
WEAPON_ICON_RATIO_4TO1 = 0x2,
|
|
WEAPON_ICON_RATIO_COUNT = 0x3,
|
|
};
|
|
|
|
enum AmmoCounterClipType : __int32
|
|
{
|
|
AMMO_COUNTER_CLIP_NONE = 0x0,
|
|
AMMO_COUNTER_CLIP_MAGAZINE = 0x1,
|
|
AMMO_COUNTER_CLIP_SHORTMAGAZINE = 0x2,
|
|
AMMO_COUNTER_CLIP_SHOTGUN = 0x3,
|
|
AMMO_COUNTER_CLIP_ROCKET = 0x4,
|
|
AMMO_COUNTER_CLIP_BELTFED = 0x5,
|
|
AMMO_COUNTER_CLIP_ALTWEAPON = 0x6,
|
|
AMMO_COUNTER_CLIP_COUNT = 0x7,
|
|
};
|
|
|
|
enum WeaponOverlayReticle : __int32
|
|
{
|
|
WEAPOVERLAYRETICLE_NONE = 0x0,
|
|
WEAPOVERLAYRETICLE_CROSSHAIR = 0x1,
|
|
WEAPOVERLAYRETICLE_NUM = 0x2,
|
|
};
|
|
|
|
enum WeapOverlayInteface_t : __int32
|
|
{
|
|
WEAPOVERLAYINTERFACE_NONE = 0x0,
|
|
WEAPOVERLAYINTERFACE_JAVELIN = 0x1,
|
|
WEAPOVERLAYINTERFACE_TURRETSCOPE = 0x2,
|
|
WEAPOVERLAYINTERFACECOUNT = 0x3,
|
|
};
|
|
|
|
enum WeaponProjExposion : __int32
|
|
{
|
|
WEAPPROJEXP_GRENADE = 0x0,
|
|
WEAPPROJEXP_ROCKET = 0x1,
|
|
WEAPPROJEXP_FLASHBANG = 0x2,
|
|
WEAPPROJEXP_NONE = 0x3,
|
|
WEAPPROJEXP_DUD = 0x4,
|
|
WEAPPROJEXP_SMOKE = 0x5,
|
|
WEAPPROJEXP_HEAVY = 0x6,
|
|
WEAPPROJEXP_NUM = 0x7,
|
|
};
|
|
|
|
enum WeapStickinessType : __int32
|
|
{
|
|
WEAPSTICKINESS_NONE = 0x0,
|
|
WEAPSTICKINESS_ALL = 0x1,
|
|
WEAPSTICKINESS_GROUND = 0x2,
|
|
WEAPSTICKINESS_GROUND_WITH_YAW = 0x3,
|
|
WEAPSTICKINESS_COUNT = 0x4,
|
|
};
|
|
|
|
enum GuidedMissileType : __int32
|
|
{
|
|
MISSILE_GUIDANCE_NONE = 0x0,
|
|
MISSILE_GUIDANCE_SIDEWINDER = 0x1,
|
|
MISSILE_GUIDANCE_HELLFIRE = 0x2,
|
|
MISSILE_GUIDANCE_JAVELIN = 0x3,
|
|
MISSILE_GUIDANCE_COUNT = 0x4,
|
|
};
|
|
|
|
struct WeaponDef
|
|
{
|
|
qint32 szInternalNamePtr;
|
|
QString szInternalName;
|
|
|
|
qint32 szDisplayNamePtr;
|
|
QString szDisplayName;
|
|
|
|
qint32 szOverlayNamePtr;
|
|
QString szOverlayName;
|
|
|
|
qint32 gunXModelPtr;
|
|
QVector<XModel> gunXModel;
|
|
|
|
qint32 handXModelPtr;
|
|
XModel handXModel;
|
|
|
|
qint32 szXAnimsPtr[33];
|
|
QStringList szXAnims;
|
|
|
|
qint32 szModeNamePtr;
|
|
QString szModeName;
|
|
|
|
quint16 hideTags[8];
|
|
quint16 notetrackSoundMapKeys[16];
|
|
quint16 notetrackSoundMapValues[16];
|
|
int playerAnimType;
|
|
WeaponType weapType;
|
|
WeaponClass weapClass;
|
|
PenetrateType penetrateType;
|
|
ImpactType impactType;
|
|
WeaponInventoryType inventoryType;
|
|
WeaponFireType fireType;
|
|
OffhandClass offhandClass;
|
|
WeaponStance stance;
|
|
|
|
qint32 viewFlashEffectPtr;
|
|
FxEffectDef viewFlashEffect;
|
|
|
|
qint32 worldFlashEffectPtr;
|
|
FxEffectDef worldFlashEffect;
|
|
|
|
qint32 pickupSoundPtr;
|
|
SoundAliasList pickupSound;
|
|
|
|
qint32 pickupSoundPlayerPtr;
|
|
SoundAliasList pickupSoundPlayer;
|
|
|
|
qint32 ammoPickupSoundPtr;
|
|
SoundAliasList ammoPickupSound;
|
|
|
|
qint32 ammoPickupSoundPlayerPtr;
|
|
SoundAliasList ammoPickupSoundPlayer;
|
|
|
|
qint32 projectileSoundPtr;
|
|
SoundAliasList projectileSound;
|
|
|
|
qint32 pullbackSoundPtr;
|
|
SoundAliasList pullbackSound;
|
|
|
|
qint32 pullbackSoundPlayerPtr;
|
|
SoundAliasList pullbackSoundPlayer;
|
|
|
|
qint32 fireSoundPtr;
|
|
SoundAliasList fireSound;
|
|
|
|
qint32 fireSoundPlayerPtr;
|
|
SoundAliasList fireSoundPlayer;
|
|
|
|
qint32 fireLoopSoundPtr;
|
|
SoundAliasList fireLoopSound;
|
|
|
|
qint32 fireLoopSoundPlayerPtr;
|
|
SoundAliasList fireLoopSoundPlayer;
|
|
|
|
qint32 fireStopSoundPtr;
|
|
SoundAliasList fireStopSound;
|
|
|
|
qint32 fireStopSoundPlayerPtr;
|
|
SoundAliasList fireStopSoundPlayer;
|
|
|
|
qint32 fireLastSoundPtr;
|
|
SoundAliasList fireLastSound;
|
|
|
|
qint32 fireLastSoundPlayerPtr;
|
|
SoundAliasList fireLastSoundPlayer;
|
|
|
|
qint32 emptyFireSoundPtr;
|
|
SoundAliasList emptyFireSound;
|
|
|
|
qint32 emptyFireSoundPlayerPtr;
|
|
SoundAliasList emptyFireSoundPlayer;
|
|
|
|
qint32 meleeSwipeSoundPtr;
|
|
SoundAliasList meleeSwipeSound;
|
|
|
|
qint32 meleeSwipeSoundPlayerPtr;
|
|
SoundAliasList meleeSwipeSoundPlayer;
|
|
|
|
qint32 meleeHitSoundPtr;
|
|
SoundAliasList meleeHitSound;
|
|
|
|
qint32 meleeMissSoundPtr;
|
|
SoundAliasList meleeMissSound;
|
|
|
|
qint32 rechamberSoundPtr;
|
|
SoundAliasList rechamberSound;
|
|
|
|
qint32 rechamberSoundPlayerPtr;
|
|
SoundAliasList rechamberSoundPlayer;
|
|
|
|
qint32 reloadSoundPtr;
|
|
SoundAliasList reloadSound;
|
|
|
|
qint32 reloadSoundPlayerPtr;
|
|
SoundAliasList reloadSoundPlayer;
|
|
|
|
qint32 reloadEmptySoundPtr;
|
|
SoundAliasList reloadEmptySound;
|
|
|
|
qint32 reloadEmptySoundPlayerPtr;
|
|
SoundAliasList reloadEmptySoundPlayer;
|
|
|
|
qint32 reloadStartSoundPtr;
|
|
SoundAliasList reloadStartSound;
|
|
|
|
qint32 reloadStartSoundPlayerPtr;
|
|
SoundAliasList reloadStartSoundPlayer;
|
|
|
|
qint32 reloadEndSoundPtr;
|
|
SoundAliasList reloadEndSound;
|
|
|
|
qint32 reloadEndSoundPlayerPtr;
|
|
SoundAliasList reloadEndSoundPlayer;
|
|
|
|
qint32 detonateSoundPtr;
|
|
SoundAliasList detonateSound;
|
|
|
|
qint32 detonateSoundPlayerPtr;
|
|
SoundAliasList detonateSoundPlayer;
|
|
|
|
qint32 nightVisionWearSoundPtr;
|
|
SoundAliasList nightVisionWearSound;
|
|
|
|
qint32 nightVisionWearSoundPlayerPtr;
|
|
SoundAliasList nightVisionWearSoundPlayer;
|
|
|
|
qint32 nightVisionRemoveSoundPtr;
|
|
SoundAliasList nightVisionRemoveSound;
|
|
|
|
qint32 nightVisionRemoveSoundPlayerPtr;
|
|
SoundAliasList nightVisionRemoveSoundPlayer;
|
|
|
|
qint32 altSwitchSoundPtr;
|
|
SoundAliasList altSwitchSound;
|
|
|
|
qint32 altSwitchSoundPlayerPtr;
|
|
SoundAliasList altSwitchSoundPlayer;
|
|
|
|
qint32 raiseSoundPtr;
|
|
SoundAliasList raiseSound;
|
|
|
|
qint32 raiseSoundPlayerPtr;
|
|
SoundAliasList raiseSoundPlayer;
|
|
|
|
qint32 firstRaiseSoundPtr;
|
|
SoundAliasList firstRaiseSound;
|
|
|
|
qint32 firstRaiseSoundPlayerPtr;
|
|
SoundAliasList firstRaiseSoundPlayer;
|
|
|
|
qint32 putawaySoundPtr;
|
|
SoundAliasList putawaySound;
|
|
|
|
qint32 putawaySoundPlayerPtr;
|
|
SoundAliasList putawaySoundPlayer;
|
|
|
|
qint32 bounceSoundPtr;
|
|
SoundAliasList *bounceSound;
|
|
|
|
qint32 viewShellEjectEffectPtr;
|
|
FxEffectDef viewShellEjectEffect;
|
|
|
|
qint32 worldShellEjectEffectPtr;
|
|
FxEffectDef worldShellEjectEffect;
|
|
|
|
qint32 viewLastShotEjectEffectPtr;
|
|
FxEffectDef viewLastShotEjectEffect;
|
|
|
|
qint32 worldLastShotEjectEffectPtr;
|
|
FxEffectDef worldLastShotEjectEffect;
|
|
|
|
qint32 reticleCenterPtr;
|
|
Material reticleCenter;
|
|
|
|
qint32 reticleSidePtr;
|
|
Material reticleSide;
|
|
|
|
int iReticleCenterSize;
|
|
int iReticleSideSize;
|
|
int iReticleMinOfs;
|
|
ActiveReticleType activeReticleType;
|
|
float vStandMove[3];
|
|
float vStandRot[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;
|
|
|
|
qint32 worldModelPtr;
|
|
QVector<XModel> worldModel;
|
|
|
|
qint32 worldClipModelPtr;
|
|
XModel worldClipModel;
|
|
|
|
qint32 rocketModelPtr;
|
|
XModel rocketModel;
|
|
|
|
qint32 knifeModelPtr;
|
|
XModel knifeModel;
|
|
|
|
qint32 worldKnifeModelPtr;
|
|
XModel worldKnifeModel;
|
|
|
|
qint32 hudIconPtr;
|
|
Material hudIcon;
|
|
WeaponIconRatioType hudIconRatio;
|
|
|
|
qint32 ammoCounterIconPtr;
|
|
Material ammoCounterIcon;
|
|
|
|
WeaponIconRatioType ammoCounterIconRatio;
|
|
AmmoCounterClipType ammoCounterClip;
|
|
int iStartAmmo;
|
|
|
|
qint32 szAmmoNamePtr;
|
|
QString szAmmoName;
|
|
int iAmmoIndex;
|
|
|
|
qint32 szClipNamePtr;
|
|
QString szClipName;
|
|
|
|
int iClipIndex;
|
|
int iMaxAmmo;
|
|
int iClipSize;
|
|
int shotCount;
|
|
|
|
qint32 szSharedAmmoCapNamePtr;
|
|
QString szSharedAmmoCapName;
|
|
|
|
int iSharedAmmoCapIndex;
|
|
int iSharedAmmoCap;
|
|
int damage;
|
|
int playerDamage;
|
|
int iMeleeDamage;
|
|
int iDamageType;
|
|
int iFireDelay;
|
|
int iMeleeDelay;
|
|
int meleeChargeDelay;
|
|
int iDetonateDelay;
|
|
int iFireTime;
|
|
int iRechamberTime;
|
|
int iRechamberBoltTime;
|
|
int iHoldFireTime;
|
|
int iDetonateTime;
|
|
int iMeleeTime;
|
|
int meleeChargeTime;
|
|
int iReloadTime;
|
|
int reloadShowRocketTime;
|
|
int iReloadEmptyTime;
|
|
int iReloadAddTime;
|
|
int iReloadStartTime;
|
|
int iReloadStartAddTime;
|
|
int iReloadEndTime;
|
|
int iDropTime;
|
|
int iRaiseTime;
|
|
int iAltDropTime;
|
|
int iAltRaiseTime;
|
|
int quickDropTime;
|
|
int quickRaiseTime;
|
|
int iFirstRaiseTime;
|
|
int iEmptyRaiseTime;
|
|
int iEmptyDropTime;
|
|
int sprintInTime;
|
|
int sprintLoopTime;
|
|
int sprintOutTime;
|
|
int nightVisionWearTime;
|
|
int nightVisionWearTimeFadeOutEnd;
|
|
int nightVisionWearTimePowerUp;
|
|
int nightVisionRemoveTime;
|
|
int nightVisionRemoveTimePowerDown;
|
|
int nightVisionRemoveTimeFadeInStart;
|
|
int fuseTime;
|
|
int aiFuseTime;
|
|
int requireLockonToFire;
|
|
int noAdsWhenMagEmpty;
|
|
int avoidDropCleanup;
|
|
float autoAimRange;
|
|
float aimAssistRange;
|
|
float aimAssistRangeAds;
|
|
float aimPadding;
|
|
float enemyCrosshairRange;
|
|
int crosshairColorChange;
|
|
float moveSpeedScale;
|
|
float adsMoveSpeedScale;
|
|
float sprintDurationScale;
|
|
float fAdsZoomFov;
|
|
float fAdsZoomInFrac;
|
|
float fAdsZoomOutFrac;
|
|
|
|
qint32 overlayMaterialPtr;
|
|
Material overlayMaterial;
|
|
|
|
qint32 overlayMaterialLowResPtr;
|
|
Material overlayMaterialLowRes;
|
|
|
|
WeaponOverlayReticle overlayReticle;
|
|
WeapOverlayInteface_t overlayInterface;
|
|
float overlayWidth;
|
|
float overlayHeight;
|
|
float fAdsBobFactor;
|
|
float fAdsViewBobMult;
|
|
float fHipSpreadStandMin;
|
|
float fHipSpreadDuckedMin;
|
|
float fHipSpreadProneMin;
|
|
float hipSpreadStandMax;
|
|
float hipSpreadDuckedMax;
|
|
float hipSpreadProneMax;
|
|
float fHipSpreadDecayRate;
|
|
float fHipSpreadFireAdd;
|
|
float fHipSpreadTurnAdd;
|
|
float fHipSpreadMoveAdd;
|
|
float fHipSpreadDuckedDecay;
|
|
float fHipSpreadProneDecay;
|
|
float fHipReticleSidePos;
|
|
int iAdsTransInTime;
|
|
int iAdsTransOutTime;
|
|
float fAdsIdleAmount;
|
|
float fHipIdleAmount;
|
|
float adsIdleSpeed;
|
|
float hipIdleSpeed;
|
|
float fIdleCrouchFactor;
|
|
float fIdleProneFactor;
|
|
float fGunMaxPitch;
|
|
float fGunMaxYaw;
|
|
float swayMaxAngle;
|
|
float swayLerpSpeed;
|
|
float swayPitchScale;
|
|
float swayYawScale;
|
|
float swayHorizScale;
|
|
float swayVertScale;
|
|
float swayShellShockScale;
|
|
float adsSwayMaxAngle;
|
|
float adsSwayLerpSpeed;
|
|
float adsSwayPitchScale;
|
|
float adsSwayYawScale;
|
|
float adsSwayHorizScale;
|
|
float adsSwayVertScale;
|
|
int bRifleBullet;
|
|
int armorPiercing;
|
|
int bBoltAction;
|
|
int aimDownSight;
|
|
int bRechamberWhileAds;
|
|
float adsViewErrorMin;
|
|
float adsViewErrorMax;
|
|
int bCookOffHold;
|
|
int bClipOnly;
|
|
int adsFireOnly;
|
|
int cancelAutoHolsterWhenEmpty;
|
|
int suppressAmmoReserveDisplay;
|
|
int enhanced;
|
|
int laserSightDuringNightvision;
|
|
|
|
qint32 killIconPtr;
|
|
Material killIcon;
|
|
WeaponIconRatioType killIconRatio;
|
|
int flipKillIcon;
|
|
|
|
qint32 dpadIconPtr;
|
|
Material dpadIcon;
|
|
|
|
WeaponIconRatioType dpadIconRatio;
|
|
int bNoPartialReload;
|
|
int bSegmentedReload;
|
|
int iReloadAmmoAdd;
|
|
int iReloadStartAdd;
|
|
|
|
qint32 szAltWeaponNamePtr;
|
|
QString szAltWeaponName;
|
|
|
|
uint altWeaponIndex;
|
|
int iDropAmmoMin;
|
|
int iDropAmmoMax;
|
|
int blocksProne;
|
|
int silenced;
|
|
int iExplosionRadius;
|
|
int iExplosionRadiusMin;
|
|
int iExplosionInnerDamage;
|
|
int iExplosionOuterDamage;
|
|
float damageConeAngle;
|
|
int iProjectileSpeed;
|
|
int iProjectileSpeedUp;
|
|
int iProjectileSpeedForward;
|
|
int iProjectileActivateDist;
|
|
float projLifetime;
|
|
float timeToAccelerate;
|
|
float projectileCurvature;
|
|
|
|
qint32 projectileModelPtr;
|
|
XModel projectileModel;
|
|
WeaponProjExposion projExplosion;
|
|
|
|
qint32 projExplosionEffectPtr;
|
|
FxEffectDef projExplosionEffect;
|
|
int projExplosionEffectForceNormalUp;
|
|
|
|
qint32 projDudEffectPtr;
|
|
FxEffectDef projDudEffect;
|
|
|
|
qint32 projExplosionSoundPtr;
|
|
SoundAliasList projExplosionSound;
|
|
|
|
qint32 projDudSoundPtr;
|
|
SoundAliasList projDudSound;
|
|
|
|
int bProjImpactExplode;
|
|
WeapStickinessType stickiness;
|
|
int hasDetonator;
|
|
int timedDetonation;
|
|
int rotate;
|
|
int holdButtonToThrow;
|
|
int freezeMovementWhenFiring;
|
|
float lowAmmoWarningThreshold;
|
|
float parallelBounce[29];
|
|
float perpendicularBounce[29];
|
|
|
|
qint32 projTrailEffectPtr;
|
|
FxEffectDef projTrailEffect;
|
|
|
|
float vProjectileColor[3];
|
|
GuidedMissileType guidedMissileType;
|
|
float maxSteeringAccel;
|
|
int projIgnitionDelay;
|
|
FxEffectDef projIgnitionEffect;
|
|
|
|
qint32 projIgnitionSoundPtr;
|
|
SoundAliasList projIgnitionSound;
|
|
|
|
float fAdsAimPitch;
|
|
float fAdsCrosshairInFrac;
|
|
float fAdsCrosshairOutFrac;
|
|
int adsGunKickReducedKickBullets;
|
|
float adsGunKickReducedKickPercent;
|
|
float fAdsGunKickPitchMin;
|
|
float fAdsGunKickPitchMax;
|
|
float fAdsGunKickYawMin;
|
|
float fAdsGunKickYawMax;
|
|
float fAdsGunKickAccel;
|
|
float fAdsGunKickSpeedMax;
|
|
float fAdsGunKickSpeedDecay;
|
|
float fAdsGunKickStaticDecay;
|
|
float fAdsViewKickPitchMin;
|
|
float fAdsViewKickPitchMax;
|
|
float fAdsViewKickYawMin;
|
|
float fAdsViewKickYawMax;
|
|
float fAdsViewKickCenterSpeed;
|
|
float fAdsViewScatterMin;
|
|
float fAdsViewScatterMax;
|
|
float fAdsSpread;
|
|
int hipGunKickReducedKickBullets;
|
|
float hipGunKickReducedKickPercent;
|
|
float fHipGunKickPitchMin;
|
|
float fHipGunKickPitchMax;
|
|
float fHipGunKickYawMin;
|
|
float fHipGunKickYawMax;
|
|
float fHipGunKickAccel;
|
|
float fHipGunKickSpeedMax;
|
|
float fHipGunKickSpeedDecay;
|
|
float fHipGunKickStaticDecay;
|
|
float fHipViewKickPitchMin;
|
|
float fHipViewKickPitchMax;
|
|
float fHipViewKickYawMin;
|
|
float fHipViewKickYawMax;
|
|
float fHipViewKickCenterSpeed;
|
|
float fHipViewScatterMin;
|
|
float fHipViewScatterMax;
|
|
float fightDist;
|
|
float maxDist;
|
|
|
|
qint32 accuracyGraphNamePtr[2];
|
|
QString accuracyGraphName[2];
|
|
|
|
qint32 accuracyGraphKnotsPtr[2];
|
|
float accuracyGraphKnots[2];
|
|
|
|
qint32 originalAccuracyGraphKnotsPtr[2];
|
|
float 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;
|
|
|
|
qint32 szUseHintStringPtr;
|
|
QString szUseHintString;
|
|
|
|
qint32 dropHintStringPtr;
|
|
QString dropHintString;
|
|
|
|
int iUseHintStringIndex;
|
|
int dropHintStringIndex;
|
|
float horizViewJitter;
|
|
float vertViewJitter;
|
|
|
|
qint32 szScriptPtr;
|
|
const char *szScript;
|
|
|
|
float fOOPosAnimLength[2];
|
|
int minDamage;
|
|
int minPlayerDamage;
|
|
float fMaxDamageRange;
|
|
float fMinDamageRange;
|
|
float destabilizationRateTime;
|
|
float destabilizationCurvatureMax;
|
|
int destabilizeDistance;
|
|
float locationDamageMultipliers[19];
|
|
|
|
qint32 fireRumblePtr;
|
|
QString fireRumble;
|
|
|
|
qint32 meleeImpactRumblePtr;
|
|
QString meleeImpactRumble;
|
|
|
|
float adsDofStart;
|
|
float adsDofEnd;
|
|
};
|
|
|
|
struct XReverbSettings
|
|
{
|
|
uint ReflectionsDelay;
|
|
quint8 ReverbDelay;
|
|
quint8 RearDelay;
|
|
quint8 PositionLeft;
|
|
quint8 PositionRight;
|
|
quint8 PositionMatrixLeft;
|
|
quint8 PositionMatrixRight;
|
|
quint8 EarlyDiffusion;
|
|
quint8 LateDiffusion;
|
|
quint8 LowEQGain;
|
|
quint8 LowEQCutoff;
|
|
quint8 HighEQGain;
|
|
quint8 HighEQCutoff;
|
|
float RoomFilterFreq;
|
|
float RoomFilterMain;
|
|
float RoomFilterHF;
|
|
float ReflectionsGain;
|
|
float ReverbGain;
|
|
float DecayTime;
|
|
float Density;
|
|
float RoomSize;
|
|
};
|
|
|
|
struct XAudioReverbSettings
|
|
{
|
|
int presetOverridden;
|
|
XReverbSettings reverbSettings;
|
|
};
|
|
|
|
struct XSoundDriverGlobals
|
|
{
|
|
qint32 reverbSettingsPtr;
|
|
XAudioReverbSettings reverbSettings;
|
|
qint32 namePtr;
|
|
QString name;
|
|
};
|
|
|
|
struct FxImpactEntry
|
|
{
|
|
qint32 nonFleshPtrs[29];
|
|
QVector<FxEffectDef> nonflesh;
|
|
qint32 fleshPtrs[4];
|
|
QVector<FxEffectDef> flesh;
|
|
};
|
|
|
|
struct FxImpactTable
|
|
{
|
|
qint32 namePtr;
|
|
QString name;
|
|
qint32 tablePtr;
|
|
QVector<FxImpactEntry> table;
|
|
};
|
|
|
|
union XAssetHeader
|
|
{
|
|
XModelPieces *xmodelPieces;
|
|
XPhysPreset *physPreset;
|
|
XAnimParts *parts;
|
|
XModel *model;
|
|
XMaterial *material;
|
|
XMaterialPixelShader *pixelShader;
|
|
XMaterialVertexShader *vertexShader;
|
|
MaterialTechniqueSet *techniqueSet;
|
|
XGfxImage *image;
|
|
SoundAliasList *sound;
|
|
SndCurve *sndCurve;
|
|
LoadedSound *loadSnd;
|
|
clipMap_t *clipMap;
|
|
ComWorld *comWorld;
|
|
GameWorldSp *gameWorldSp;
|
|
GameWorldMp *gameWorldMp;
|
|
MapEnts *mapEnts;
|
|
GfxWorld *gfxWorld;
|
|
XGfxLightDef *lightDef;
|
|
Font_s *font;
|
|
MenuList *menuList;
|
|
menuDef_t *menu;
|
|
XLocalizeEntry *localize;
|
|
WeaponDef *weapon;
|
|
XSoundDriverGlobals *sndDriverGlobals;
|
|
const FxEffectDef *fx;
|
|
FxImpactTable *impactFx;
|
|
XRawFile *rawfile;
|
|
XStringTable *stringTable;
|
|
void *data;
|
|
};
|
|
|
|
#endif // ASSETS_H
|