XPlor/libs/assets/assets.h

#ifndef ASSETS_H
#define ASSETS_H

#include "model.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;
};

struct GfxImageLoadDef;

struct GfxTexture
{
    qint32 basemapPtr;
    D3DBaseTexture *basemap;
    qint32 mapPtr;
    D3DTexture *map;
    qint32 volmapPtr;
    D3DVolumeTexture *volmap;
    qint32 cubemapPtr;
    D3DCubeTexture *cubemap;
    qint32 loadDefPtr;
    GfxImageLoadDef *loadDef;
};

struct GfxImageLoadDef
{
    quint8 levelCount;
    quint8 flags;
    qint16 dimensions[3];
    int format;
    GfxTexture texture;
};

struct CardMemory
{
    int platform[1];
};

struct GfxImage
{
    MapType mapType;
    GfxTexture texture;
    quint8 semantic;
    CardMemory cardMemory;
    quint16 width;
    quint16 height;
    quint16 depth;
    quint8 category;
    bool delayLoadPixels;
    qint32 pixelsPtr;
    QVector<quint8> pixels;
    uint baseSize;
    quint16 streamSlot;
    bool streaming;
    qint32 namePtr;
    QString name;
};


union MaterialPixelShaderProgram
{
    qint32 psPtr;
    D3DPixelShader ps;
    GfxPixelShaderLoadDef loadDef;
};

struct stream_source_info_t
{
    quint16 Stream;
    quint16 Offset;
    uint Type;
};

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 XModel
{
    const char *name;
    quint8 numBones;
    quint8 numRootBones;
    quint8 numsurfs;
    quint8 lodRampType;
    quint16 *boneNames;
    quint8 *parentList;
    qint16 *quats;
    float *trans;
    quint8 *partClassification;
    DObjAnimMat *baseMat;
    XSurface *surfs;
    Material **materialHandles;
    XModelLodInfo lodInfo[4];
    XModelCollSurf *collSurfs;
    int numCollSurfs;
    int contents;
    XBoneInfo *boneInfo;
    float radius;
    float mins[3];
    float maxs[3];
    qint16 numLods;
    qint16 collLod;
    XModelStreamInfo streamInfo;
    int memUsage;
    quint8 flags;
    PhysPreset *physPreset;
    PhysGeomList *physGeoms;
};

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 CModel
{
    float mins[3];
    float maxs[3];
    float radius;
    CLeaf leaf;
};

struct CBrush
{
    float mins[3];
    int contents;
    float maxs[3];
    uint numsides;
    qint32 sidesPtr;
    QVector<CBrushSide> 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 ComPrimaryLight
{
    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<ComPrimaryLight> 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)) GfxLightImage
{
    GfxImage *image;
    quint8 samplerState;
};

struct GfxLightDef
{
    const char *name;
    GfxLightImage 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;
    GfxLightDef *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 rectDef_s
{
    float x;
    float y;
    float w;
    float h;
    int horzAlign;
    int vertAlign;
};

struct windowDef_t
{
    const char *name;
    rectDef_s rect;
    rectDef_s rectClient;
    const char *group;
    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 ItemKeyHandler
{
    int key;
    qint32 actionPtr;
    QString action;
    qint32 nextPtr;
    ItemKeyHandler *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 expDataType : __int32
{
    VAL_INT = 0x0,
    VAL_FLOAT = 0x1,
    VAL_STRING = 0x2,
};

struct Operand
{
    expDataType dataType;
    int intVal;
    float floatVal;
    QString stringVal;
};

union entryInternalData
{
    OperationEnum op;
    Operand operand;
};

struct expressionEntry
{
    int type;
    entryInternalData data;
};

struct statement_s
{
    int numEntries;
    expressionEntry **entries;
};

struct ItemDef;

struct menuDef_t
{
    windowDef_t 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;
    ItemKeyHandler *onKey;
    statement_s visibleExp;
    const char *allowedBinding;
    const char *soundName;
    int imageTrack;
    float focusColor[4];
    float disableColor[4];
    statement_s rectXExp;
    statement_s rectYExp;
    ItemDef **items;
};

struct columnInfo_s
{
    int pos;
    int width;
    int maxChars;
    int alignment;
};

struct listBoxDef_s
{
    int startPos[4];
    int endPos[4];
    int drawPadding;
    float elementWidth;
    float elementHeight;
    int elementStyle;
    int numColumns;
    columnInfo_s columnInfo[16];
    const char *doubleClick;
    int notselectable;
    int noScrollBars;
    int usePaging;
    float selectBorder[4];
    float disableColor[4];
    Material *selectIcon;
};

struct EditFieldDef
{
    float minVal;
    float maxVal;
    float defVal;
    float range;
    int maxChars;
    int maxCharsGotoNext;
    int maxPaintChars;
    int paintOffset;
};

struct MultiDef
{
    QVector<qint32> dvarListPtrs;
    QStringList dvarList;
    QVector<qint32> dvarStrPtrs;
    QStringList dvarStr;
    QVector<float> dvarValue[32];
    int count;
    int strDef;
};

union ItemDefData
{
    listBoxDef_s *listBox;
    EditFieldDef *editField;
    MultiDef *multi;
    const char *enumDvarName;
    void *data;
};

struct ItemDef
{
    windowDef_t window;
    rectDef_s 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;
    ItemKeyHandler *onKey;
    const char *enableDvar;
    int dvarFlags;
    SoundAliasList *focusSound;
    float special;
    int cursorPos[4];
    ItemDefData typeData;
    int imageTrack;
    statement_s visibleExp;
    statement_s textExp;
    statement_s materialExp;
    statement_s rectXExp;
    statement_s rectYExp;
    statement_s rectWExp;
    statement_s rectHExp;
    statement_s forecolorAExp;
};

struct MenuList
{
    qint32 namePtr;
    QString name;
    int menuCount;
    qint32 menusPtr;
    QVector<menuDef_t> menus;
};

struct LocalizeEntry
{
    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 XAUDIOREVERBSETTINGS
{
    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 XaReverbSettings
{
    int presetOverridden;
    XAUDIOREVERBSETTINGS reverbSettings;
};

struct SndDriverGlobals
{
    qint32 reverbSettingsPtr;
    XaReverbSettings 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;
};

struct RawFile
{
    qint32 namePtr;
    QString name;
    int len;
    qint32 bufferPtr;
    QString buffer;
};

struct StringTable
{
    qint32 namePtr;
    QString name;
    int columnCount;
    int rowCount;
    qint32 valuesPtr;
    QStringList values;
};

union XAssetHeader
{
    XModelPieces *xmodelPieces;
    PhysPreset *physPreset;
    XAnimParts *parts;
    XModel *model;
    Material *material;
    MaterialPixelShader *pixelShader;
    MaterialVertexShader *vertexShader;
    MaterialTechniqueSet *techniqueSet;
    GfxImage *image;
    SoundAliasList *sound;
    SndCurve *sndCurve;
    LoadedSound *loadSnd;
    clipMap_t *clipMap;
    ComWorld *comWorld;
    GameWorldSp *gameWorldSp;
    GameWorldMp *gameWorldMp;
    MapEnts *mapEnts;
    GfxWorld *gfxWorld;
    GfxLightDef *lightDef;
    Font_s *font;
    MenuList *menuList;
    menuDef_t *menu;
    LocalizeEntry *localize;
    WeaponDef *weapon;
    SndDriverGlobals *sndDriverGlobals;
    const FxEffectDef *fx;
    FxImpactTable *impactFx;
    RawFile *rawfile;
    StringTable *stringTable;
    void *data;
};

struct StreamDelayInfo
{
    const void *ptr;
    int size;
};

class Assets : public QObject
{
    Q_OBJECT
public:
    explicit Assets(QObject *parent = nullptr);
    ~Assets();

private:
    QVector<Glyph> Load_GlyphArray(QDataStream *aStream, int count);
    QVector<GfxLightRegionAxis> Load_GfxLightRegionAxisArray(QDataStream *aStream, int count);
    QVector<GfxDrawSurf> Load_GfxDrawSurfArray(QDataStream *aStream, int count);
    QVector<GfxSceneDynBrush> Load_GfxSceneDynBrushArray(QDataStream *aStream, int count);
    QVector<GfxSceneDynModel> Load_GfxSceneDynModelArray(QDataStream *aStream, int count);
    QVector<GfxStreamingAabbTree> Load_GfxStreamingAabbTreeArray(QDataStream *aStream, int count);
    GfxLightGridColors Load_GfxLightGridColors(QDataStream *aStream);
    QVector<GfxLightGridColors> Load_GfxLightGridColorsArray(QDataStream *aStream, int count);
    QVector<GfxLightGridEntry> Load_GfxLightGridEntryArray(QDataStream *aStream, int count);
    QVector<GfxCullGroup> Load_GfxCullGroupArray(QDataStream *aStream, int count);
    QVector<quint16> Load_StaticModelIndexArray(QDataStream *aStream, int count);
    QVector<GfxStaticModelInst> Load_GfxStaticModelInstArray(QDataStream *aStream, int count);
    ItemKeyHandler Load_ItemKeyHandler(QDataStream *aStream);
    ItemKeyHandler Load_ItemKeyHandlerNext(QDataStream *aStream);
    EditFieldDef Load_EditFieldDef(QDataStream *aStream);
    OperationEnum Load_Operator(QDataStream *aStream);
    QVector<quint16> Load_LeafBrushArray(QDataStream *aStream, int count);
    CLeaf Load_CLeaf(QDataStream *aStream);
    QVector<CModel> Load_CModelArray(QDataStream *aStream, int count);
    QVector<CollisionAabbTree> Load_CollisionAabbTreeArray(QDataStream *aStream, int count);
    CollisionBorder Load_CollisionBorder(QDataStream *aStream);
    QVector<CollisionBorder> Load_CollisionBorderArray(QDataStream *aStream, int count);
    CLeafBrushNodeChildren Load_cLeafBrushNodeChildren_t(QDataStream *aStream);
    QVector<CLeaf> Load_cLeaf_tArray(QDataStream *aStream, int count);
    QVector<DynEntityClient> Load_DynEntityClientArray(QDataStream *aStream, int count);
    QVector<DynEntityPose> Load_DynEntityPoseArray(QDataStream *aStream, int count);
    QVector<DynEntityColl> Load_DynEntityCollArray(QDataStream *aStream, int count);
    QVector<FxTrailVertex> Load_FxTrailVertexArray(QDataStream *aStream, int count);
    QVector<FxElemVelStateSample> Load_FxElemVelStateSampleArray(QDataStream *aStream, int count);
    QVector<FxElemVisStateSample> Load_FxElemVisStateSampleArray(QDataStream *aStream, int count);
    QVector<PathBaseNode> Load_pathbasenode_tArray(QDataStream *aStream, int count);
    QVector<PathLink> Load_pathlink_tArray(QDataStream *aStream, int count);
    QVector<XModelHighMipBounds> Load_XModelHighMipBoundsArray(QDataStream *aStream, int count);
    XModelCollSurf Load_XModelCollSurf(QDataStream *aStream);
    quint8 Load_cbrushedge_t(QDataStream *aStream);
    QVector<quint8> Load_cbrushedge_tArray(QDataStream *aStream, size_t count);
    CPlane Load_cplane_t(QDataStream *aStream);
    CPlane Load_CPlane(QDataStream *aStream);
    QVector<CPlane> Load_cplane_tArray(QDataStream *aStream, int count);
    QVector<MaterialConstantDef> Load_MaterialConstantDefArray(QDataStream *aStream, int count);
    QVector<GfxStateBits> Load_GfxStateBitsArray(QDataStream *aStream, int count);
    MaterialArgumentCodeConst Load_MaterialArgumentCodeConst(QDataStream *aStream);
    MaterialVertexDeclaration Load_MaterialVertexDeclaration(QDataStream *aStream);
    QVector<quint8> Load_byteShaderArray(QDataStream *aStream, size_t count);
    QVector<quint8> Load_byte4Array(QDataStream *aStream, size_t count);
    QVector<GfxTexture> Load_GfxRawTextureArray(QDataStream *aStream, int count);
    D3DCubeTexture Load_IDirect3DCubeTexture9(QDataStream *aStream);
    D3DVolumeTexture Load_IDirect3DVolumeTexture9(QDataStream *aStream);
    D3DTexture Load_IDirect3DTexture9(QDataStream *aStream);
    QVector<quint16> Load_r_index16_tArray(QDataStream *aStream, int count);
    QVector<quint16> Load_r_index_tArray(QDataStream *aStream, int count);
    D3DIndexBuffer Load_GfxIndexBuffer(QDataStream *aStream);
    QVector<quint16> Load_XBlendInfoArray(QDataStream *aStream, int count);
    D3DVertexBuffer Load_GfxVertexBuffer(QDataStream *aStream);
    QVector<XSurfaceCollisionNode> Load_XSurfaceCollisionNodeArray(QDataStream *aStream, int count);
    QVector<XSurfaceCollisionLeaf> Load_XSurfaceCollisionLeafArray(QDataStream *aStream, int count);
    QVector<GfxBrushModel> Load_GfxBrushModelArray(QDataStream *aStream, int count);
    QVector<GfxPackedVertex> Load_GfxPackedVertex0Array(QDataStream *aStream, int count);
    void Load_GfxWorldVertex0Array(QDataStream *aStream, int count);
    QVector<XAUDIOCHANNELMAPENTRY> Load_XAUDIOCHANNELMAPENTRYArray(QDataStream *aStream, int count);
    StreamFileNamePacked Load_StreamFileNamePacked(QDataStream *aStream);
    QVector<XaReverbSettings> Load_XaReverbSettingsArray(QDataStream *aStream, int count);
    QVector<char> Load_char2048Array(QDataStream *aStream, size_t count);
    QVector<DObjAnimMat> Load_DObjAnimMatArray(QDataStream *aStream, int count);
    QVector<XBoneInfo> Load_XBoneInfoArray(QDataStream *aStream, int count);
    QVector<QVector<quint16>> Load_UShortVecArray(QDataStream *aStream, int count);
    QVector<QVector<quint8>> Load_ByteVecArray(QDataStream *aStream, int count);
    QVector<dmaterial_t> Load_dmaterial_tArray(QDataStream *aStream, int count);
    QVector<const char> Load_ConstCharArray(QDataStream *aStream, size_t count);
    quint16 Load_ScriptString(QDataStream *aStream);
    QVector<quint16> Load_UnsignedShortArray(QDataStream *aStream, int count);
    QVector<qint16> Load_XQuat2(QDataStream *aStream);
    QVector<QVector<quint16>> Load_XQuat2Array(QDataStream *aStream, int count);
    QVector<ushort> Load_ushortArray(QDataStream *aStream, int count);
    QVector<short> Load_shortArray(QDataStream *aStream, int count);
    QVector<float> Load_vec3_t(QDataStream *aStream);
    QVector<QVector<float>> Load_vec3_tArray(QDataStream *aStream, int count);
    QVector<QVector<float>> Load_vec2_tArray(QDataStream *aStream, int count);
    QVector<quint16> Load_raw_byte16Array(QDataStream *aStream, size_t count);
    QVector<quint8> Load_raw_byteArray(QDataStream *aStream, size_t count);
    QVector<uint> Load_raw_uint128Array(QDataStream *aStream, int count);
    QVector<uint> Load_raw_uintArray(QDataStream *aStream, int count);
    float Load_float(QDataStream *aStream);
    QVector<float> Load_floatArray(QDataStream *aStream, int count);
    uint Load_uint(QDataStream *aStream);
    QVector<uint> Load_uintArray(QDataStream *aStream, int count);
    QVector<_DWORD> Load_DWORDArray(QDataStream *aStream, int count);
    QVector<quint8> Load_byte4096Array(QDataStream *aStream, size_t count);
    int Load_int(QDataStream *aStream);
    QVector<int> Load_intArray(QDataStream *aStream, int count);
    char Load_char(QDataStream *aStream);
    QVector<char> Load_charArray(QDataStream *aStream, size_t count);
    QVector<quint8> Load_byteArray(QDataStream *aStream, size_t count);
    GfxWorldDpvsPlanes Load_GfxWorldDpvsPlanes(QDataStream *aStream, GfxWorld aGfxWorld);
    GfxWorldDpvsDynamic Load_GfxWorldDpvsDynamic(QDataStream *aStream, GfxWorld aGfxWorld);
    GfxLightRegionHull Load_GfxLightRegionHull(QDataStream *aStream);
    quint16 __ROL4__(quint16 value, quint16 bits);
    GfxShadowGeometry Load_GfxShadowGeometry(QDataStream *aStream);
    GfxWorldStreamInfo Load_GfxWorldStreamInfo(QDataStream *aStream);
    GfxLightGrid Load_GfxLightGrid(QDataStream *aStream);
    GfxWorldVertexLayerData Load_GfxWorldVertexLayerData(QDataStream *aStream, GfxWorld aGfxWorld);
    GfxWorldVertexData Load_GfxWorldVertexData(QDataStream *aStream, GfxWorld aGfxWorld);
    GfxAabbTree Load_GfxAabbTree(QDataStream *aStream);
    QVector<GfxAabbTree> Load_GfxAabbTreeArray(QDataStream *aStream, int count);
    GfxCell Load_GfxCell(QDataStream *aStream);
    GfxPortal Load_GfxPortal(QDataStream *aStream);
    QVector<GfxPortal> Load_GfxPortalArray(QDataStream *aStream, int count);
    QString Load_XStringCustom(QDataStream *aStream);
    QString Load_XString(QDataStream *aStream);
    RawFile Load_RawFile(QDataStream *aStream);
    LocalizeEntry Load_LocalizeEntry(QDataStream *aStream);
    void Load_operandInternalDataUnion(QDataStream *aStream);
    ComPrimaryLight Load_ComPrimaryLight(QDataStream *aStream);
    CollisionPartition Load_CollisionPartition(QDataStream *aStream);
    CLeafBrushNodeLeaf Load_CLeafBrushNodeLeaf(QDataStream *aStream, int leafBrushCount);
    CLeafBrushNodeData Load_CLeafBrushNodeData(QDataStream *aStream, int aNodeCount);
    MapEnts Load_MapEnts(QDataStream *aStream);
    FxTrailDef Load_FxTrailDef(QDataStream *aStream);
    FxEffectDefRef Load_FxEffectDefRef(QDataStream *aStream);
    GameWorldMp Load_GameWorldMp(QDataStream *aStream);
    QVector<PathNodeTree> LoadPathNodeTreeArray(QDataStream *aStream, int count);
    PathNodeTreeNodes Load_PathNodeTreeNodes(QDataStream *aStream);
    PathNodeConstant Load_PathNodeConstant(QDataStream *aStream);
    QVector<XModelCollSurf> Load_XModelCollSurfArray(QDataStream *aStream, int count);
    PhysPreset Load_PhysPreset(QDataStream *aStream);
    MaterialArgumentDef Load_MaterialArgumentDef(QDataStream *aStream, MaterialShaderArgument aArgument);
    GfxPixelShaderLoadDef Load_GfxPixelShaderLoadDef(QDataStream *aStream);
    GfxVertexShaderLoadDef Load_GfxVertexShaderLoadDef(QDataStream *aStream);
    QVector<quint8> Load_GfxImagePixels(QDataStream *aStream, GfxImage aGfxImage);
    GfxTexture Load_GfxTexture(QDataStream *aStream, GfxTexture aGfxTexture, GfxImageLoadDef aGfxImageLoadDef);
    XSurfaceVertexInfo Load_XSurfaceVertexInfo(QDataStream *aStream);
    XSurfaceCollisionTree Load_XSurfaceCollisionTree(QDataStream *aStream);
    MaterialInfo Load_MaterialInfo(QDataStream *aStream);
    XAUDIOCHANNELMAP Load_XAUDIOCHANNELMAP(QDataStream *aStream);
    SndCurve Load_SndCurve(QDataStream *aStream);
    StreamFileNameRaw Load_StreamFileNameRaw(QDataStream *aStream);
    SndDriverGlobals Load_SndDriverGlobals(QDataStream *aStream);
    XaSeekTable Load_XaSeekTable(QDataStream *aStream);
    XAUDIOPACKET_ALIGNED Load_XAUDIOPACKET_ALIGNED(QDataStream *aStream);
    XAnimNotifyInfo Load_XAnimNotifyInfo(QDataStream *aStream);
    XAnimDynamicFrames Load_XAnimDynamicFrames(QDataStream *aStream, XAnimPartTrans aXAnimPartTrans, XAnimDynamicIndices aXAnimDynamicIndices, XAnimDynamicFrames aXAnimDynamicFrames);
    XAnimDynamicIndices Load_XAnimDynamicIndicesTrans(QDataStream *aStream, XAnimParts aXAnimParts, XAnimPartTrans aXAnimPartTrans);
    XAnimDynamicIndices Load_XAnimDynamicIndicesDeltaQuat(QDataStream *aStream);
    XAnimIndices Load_XAnimIndices(QDataStream *aStream, XAnimParts aXAnimParts, XAnimIndices aXAnimIndices);
    QStringList Load_XStringArray(QDataStream *aStream, int count);
    QVector<quint16> Load_ScriptStringArray(QDataStream *aStream, int count);
    QVector<GfxLightRegionHull> Load_GfxLightRegionHullArray(QDataStream *aStream, int count);
    QVector<GfxShadowGeometry> Load_GfxShadowGeometryArray(QDataStream *aStream, int count);
    StringTable Load_StringTable(QDataStream *aStream);
    RawFile Load_RawFilePtr(QDataStream *aStream);
    void Load_LocalizeEntryPtr(QDataStream *aStream);
    MultiDef Load_MultiDef(QDataStream *aStream);
    Operand Load_Operand(QDataStream *aStream);
    QVector<ComPrimaryLight> Load_ComPrimaryLightArray(QDataStream *aStream, int count);
    CBrushSide Load_cbrushside_t(QDataStream *aStream);
    CBrush Load_CBrush(QDataStream *aStream);
    QVector<CollisionPartition> Load_CollisionPartitionArray(QDataStream *aStream, int count);
    CLeafBrushNode Load_CLeafBrushNode(QDataStream *aStream);
    QVector<cNode_t> Load_cNode_tArray(QDataStream *aStream, int count);
    void Load_MapEntsPtr(QDataStream *aStream);
    void Load_GameWorldMpPtr(QDataStream *aStream);
    void Load_pathnode_tree_info_t(QDataStream *aStream);
    void Load_pathnode_t(QDataStream *aStream);
    void Load_cbrushside_tArray(QDataStream *aStream, int count);
    void Load_PhysPresetPtr(QDataStream *aStream);
    MaterialShaderArgument Load_MaterialShaderArgument(QDataStream *aStream);
    MaterialPixelShaderProgram Load_MaterialPixelShaderProgram(QDataStream *aStream);
    void Load_MaterialVertexShaderProgram(QDataStream *aStream);
    GfxImageLoadDef Load_GfxImageLoadDef(QDataStream *aStream);
    GfxTexture Load_GfxTextureLoad(QDataStream *aStream);
    XRigidVertList Load_XRigidVertList(QDataStream *aStream);
    void Load_snd_alias_list_name(QDataStream *aStream);
    QVector<XAUDIOCHANNELMAP> Load_XAUDIOCHANNELMAPArray(QDataStream *aStream, int count);
    SndCurve Load_SndCurvePtr(QDataStream *aStream);
    void Load_StreamFileInfo(QDataStream *aStream);
    void Load_SndDriverGlobalsPtr(QDataStream *aStream);
    XaSound Load_XaSound(QDataStream *aStream);
    QVector<XAnimNotifyInfo> Load_XAnimNotifyInfoArray(QDataStream *aStream, int count);
    void Load_XAnimPartTransFrames(QDataStream *aStream);
    void Load_XAnimDeltaPartQuatDataFrames(QDataStream *aStream);
    void Load_TempStringArray(QDataStream *aStream, int count);
    GfxLightRegion Load_GfxLightRegion(QDataStream *aStream);
    StringTable Load_StringTablePtr(QDataStream *aStream);
    void Load_entryInternalData(QDataStream *aStream);
    ComWorld Load_ComWorld(QDataStream *aStream);
    QVector<CBrush> Load_cbrush_tArray(QDataStream *aStream, int count);
    QVector<CLeafBrushNode> Load_cLeafBrushNode_tArray(QDataStream *aStream, int count);
    PathNodeTree Load_PathNodeTree(QDataStream *aStream);
    void Load_pathnode_tArray(QDataStream *aStream, int count);
    BrushWrapper Load_BrushWrapper(QDataStream *aStream);
    void Load_MaterialShaderArgumentArray(QDataStream *aStream, int count);
    MaterialPixelShader Load_MaterialPixelShader(QDataStream *aStream);
    void Load_MaterialVertexShader(QDataStream *aStream);
    GfxImage Load_GfxImage(QDataStream *aStream);
    void Load_XRigidVertListArray(QDataStream *aStream, int count);
    void Load_snd_alias_list_nameArray(QDataStream *aStream, int count);
    void Load_SpeakerMapChannel(QDataStream *aStream);
    void Load_LoadedSound(QDataStream *aStream);
    void Load_StreamFileName(QDataStream *aStream);
    void Load_XAnimPartTransData(QDataStream *aStream);
    void Load_XAnimDeltaPartQuatData(QDataStream *aStream);
    void Load_ScriptStringList(QDataStream *aStream);
    void Load_GfxLightRegionArray(QDataStream *aStream, int count);
    void Load_GfxCellArray(QDataStream *aStream, int count);
    void Load_expressionEntry(QDataStream *aStream);
    void Load_ComWorldPtr(QDataStream *aStream);
    void Load_pathnode_tree_tArray(QDataStream *aStream, int count);
    void Load_MaterialPixelShaderPtr(QDataStream *aStream);
    void Load_GfxImagePtr(QDataStream *aStream);
    void Load_XSurface(QDataStream *aStream);
    void Load_SpeakerMapChannelArray(QDataStream *aStream, int count);
    void Load_StreamedSound(QDataStream *aStream);
    void Load_LoadedSoundPtr(QDataStream *aStream);
    void Load_XAnimPartTrans(QDataStream *aStream);
    void Load_XAnimDeltaPartQuat(QDataStream *aStream);
    void Load_GfxReflectionProbe(QDataStream *aStream);
    void Load_PathData(QDataStream *aStream);
    void Load_PhysGeomInfoArray(QDataStream *aStream, int count);
    void Load_GfxLightmapArray(QDataStream *aStream);
    void Load_GfxLightImage(QDataStream *aStream);
    void Load_MaterialVertexShaderPtrArray(QDataStream *aStream, int count);
    void Load_water_t(QDataStream *aStream);
    void Load_XSurfaceArray(QDataStream *aStream, int count);
    void Load_SpeakerMap(QDataStream *aStream);
    void Load_SoundFileRef(QDataStream *aStream);
    void Load_XAnimDeltaPart(QDataStream *aStream);
    void Load_GfxReflectionProbeArray(QDataStream *aStream, int count);
    void Load_expressionEntry_ptrArray(QDataStream *aStream, int count);
    void Load_GameWorldSp(QDataStream *aStream);
    void Load_PhysGeomList(QDataStream *aStream);
    void Load_GfxLightmapArrayArray(QDataStream *aStream, int count);
    void Load_GfxLightDef(QDataStream *aStream);
    void Load_MaterialTextureDefInfo(QDataStream *aStream);
    void Load_MaterialPass(QDataStream *aStream);
    void Load_SoundFile(QDataStream *aStream);
    void Load_XAnimParts(QDataStream *aStream);
    void Load_statement(QDataStream *aStream);
    void Load_GameWorldSpPtr(QDataStream *aStream);
    void Load_GfxLightDefPtr(QDataStream *aStream);
    void Load_MaterialTextureDef(QDataStream *aStream);
    void Load_MaterialPassArray(QDataStream *aStream, int count);
    void Load_snd_alias_t(QDataStream *aStream);
    void Load_XAnimPartsPtr(QDataStream *aStream);
    void Load_GfxLight(QDataStream *aStream);
    void Load_MaterialTextureDefArray(QDataStream *aStream, int count);
    void Load_MaterialTechnique(QDataStream *aStream);
    void Load_snd_alias_tArray(QDataStream *aStream, int count);
    void Load_snd_alias_list_t(QDataStream *aStream);
    void Load_MaterialTechniquePtrArray(QDataStream *aStream, int count);
    void Load_snd_alias_list_ptr(QDataStream *aStream);
    void Load_MaterialTechniqueSet(QDataStream *aStream);
    void Load_MaterialTechniqueSetPtr(QDataStream *aStream);
    void Load_Material(QDataStream *aStream);
    void Load_MaterialHandle(QDataStream *aStream);
    void Load_Font(QDataStream *aStream);
    void Load_MaterialMemory(QDataStream *aStream);
    void Load_sunflare_t(QDataStream *aStream);
    void Load_windowDef_t(QDataStream *aStream);
    void Load_listBoxDef_t(QDataStream *aStream);
    void Load_GfxSurface(QDataStream *aStream);
    void Load_MaterialHandleArray(QDataStream *aStream, int count);
    void Load_FontHandle(QDataStream *aStream);
    void Load_MaterialMemoryArray(QDataStream *aStream, int count);
    void Load_Window(QDataStream *aStream);
    void Load_FxElemMarkVisuals(QDataStream *aStream);
    void Load_XModel(QDataStream *aStream);
    void Load_GfxSurfaceArray(QDataStream *aStream, int count);
    void Load_itemDefData_t(QDataStream *aStream);
    void Load_FxElemMarkVisualsArray(QDataStream *aStream, int count);
    void Load_XModelPtr(QDataStream *aStream);
    void Load_GfxStaticModelDrawInst(QDataStream *aStream);
    void Load_itemDef_t(QDataStream *aStream);
    void Load_cStaticModel_t(QDataStream *aStream);
    void Load_FxElemVisuals(QDataStream *aStream);
    void Load_XModelPiece(QDataStream *aStream);
};

#endif // ASSETS_H