feat(profile): update 3.3.5a profile

profile/3.3.5a-windows-386/ida/batch/import_data_types.idc

@@ -2,8 +2,13 @@
 
 static import_data_types() {
 	// Give types to data labels
+	apply_type(0x00401010, "void* __stdcall func(uint32_t count)");
+	apply_type(0x00401030, "void __stdcall func(void* ptr)");
 	apply_type(0x00408070, "void __stdcall func(float* minX, float* maxX, float* minY, float* maxY, float* minZ, float* maxZ)");
 	apply_type(0x00409670, "void __thiscall func(CGxDevice* this)");
+	apply_type(0x0047B6F0, "int32_t __stdcall func(CMDOPT)");
+	apply_type(0x0047B700, "char* __stdcall func(CMDOPT)");
+	apply_type(0x0047B720, "int32_t __stdcall func()");
 	apply_type(0x004804F0, "void __cdecl func(EvtContext* context, EVENTID id, void* handler, void* param, float priority)");
 	apply_type(0x004806A0, "int32_t __cdecl func(EvtContext* context, EVENTID id, void *data, size_t bytes)");
 	apply_type(0x00494EE0, "int32_t __thiscall func(CFrameStrata* this, int32_t a2)");
@@ -17,7 +22,10 @@ static import_data_types() {
 	apply_type(0x00532AF0, "CGxCaps* __thiscall func(CGxDevice* this)");
 	apply_type(0x006160B0, "int32_t __usercall func@<eax>(uint32_t** image@<eax>, MipBits* mipImages@<ecx>, uint32_t width@<edx>, uint32_t height)");
 	apply_type(0x00616800, "void __stdcall func(CURSORMODE mode)");
+	apply_type(0x00681A60, "void __stdcall func()");
 	apply_type(0x00681F60, "void __stdcall func(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)");
+	apply_type(0x00682340, "void __stdcall func(EGxPrim primType, uint32_t, uint16_t*)");
+	apply_type(0x006823A0, "void __stdcall func(EGxPrim primType, uint32_t indexCount, uint16_t* indices)");
 	apply_type(0x00682CB0, "void __thiscall func(CGxDevice* this, int32_t (*windowProc)(void*, uint32_t, uintptr_t, intptr_t), CGxFormat* format)");
 	apply_type(0x00682CD0, "void __thiscall func(CGxDevice* this, CGxFormat* format)");
 	apply_type(0x00682CF0, "void __thiscall func(CGxDevice* this)");
@@ -28,6 +36,7 @@ static import_data_types() {
 	apply_type(0x00682DC0, "int32_t __thiscall func(CGxDevice* this, int32_t a2)");
 	apply_type(0x00682E20, "int32_t __thiscall func(CGxDevice* this, int32_t a2)");
 	apply_type(0x00682E50, "void __thiscall func(CGxDevice* this)");
+	apply_type(0x00682F10, "void __thiscall func(CGxDevice* this, CGxBuf* buf)");
 	apply_type(0x00682F40, "uint32_t __stdcall func(EGxPrim primType, uint32_t indexCount)");
 	apply_type(0x00683080, "void __thiscall func(CGxDevice* this, uint32_t whichLight, int32_t enable)");
 	apply_type(0x006830B0, "int32_t __thiscall func(CGxDevice* this, uint32_t app, uint32_t hw, uint32_t appDisables, uint32_t hwDisables, uint32_t flagPos, int32_t* enable)");
@@ -119,17 +128,58 @@ static import_data_types() {
 	apply_type(0x006AFCE0, "int32_t __thiscall func(CBLPFile* this, char* fileName, PIXEL_FORMAT format, uint32_t mipLevel, unsigned char* data, uint32_t* stride)");
 	apply_type(0x006AFF10, "int32_t __thiscall func(CBLPFile* this, char* filename)");
 	apply_type(0x006AFFD0, "int32_t __thiscall func(CBLPFile* this, char* fileName, PIXEL_FORMAT format, MipBits** images, uint32_t mipLevel, int32_t a6)");
-	apply_type(0x006BF4C0, "void __stdcall GxuXformCreateOrtho(float minX, float maxX, float minY, float maxY, float minZ, float maxZ, C44Matrix* dst)");
+	apply_type(0x006BF4C0, "void __stdcall func(float minX, float maxX, float minY, float maxY, float minZ, float maxZ, C44Matrix* dst)");
+	apply_type(0x0076E4A0, "void __stdcall func(uint32_t flags, uint8_t changeMask)");
 	apply_type(0x0076E540, "void* __stdcall func(uint32_t bytes, char* filename, int32_t linenumber, uint32_t flags)");
 	apply_type(0x0076E5A0, "int32_t __stdcall func(void* ptr, char* filename, int32_t linenumber, uint32_t flags)");
 	apply_type(0x0076E5E0, "void* __stdcall func(void* ptr, uint32_t bytes, char* filename, int32_t linenumber, uint32_t flags)");
 	apply_type(0x0076F070, "int32_t __stdcall func(char* dest, size_t maxchars, char* format, ...)");
+	apply_type(0x00773590, "int32_t __stdcall func(ARGLIST* listptr, uint32_t numargs)");
+	apply_type(0x00773890, "int32_t __stdcall func(char* cmdline, int32_t skipprogname, CMDEXTRACALLBACK extracallback, CMDERRORCALLBACK errorcallback)");
+	apply_type(0x00773990, "int32_t __stdcall func(CMDEXTRACALLBACK extracallback, CMDERRORCALLBACK errorcallback)");
 	apply_type(0x00774620, "SCritSect* __thiscall func(SCritSect* this)");
 	apply_type(0x00774630, "void __thiscall func(SCritSect *this)");
 	apply_type(0x00774640, "void __thiscall func(SCritSect *this)");
 	apply_type(0x00774650, "void __thiscall func(SCritSect *this)");
 	apply_type(0x00777420, "void __stdcall func(HSRGN handle, RECTF* rect, void* param, int32_t combinemode)");
 	apply_type(0x00777590, "void __stdcall func(HSRGN handle, RECTF* rect)");
+	apply_type(0x00777940, "void __stdcall func(HSRGN handle)");
+	apply_type(0x00777980, "void __stdcall func(HSRGN* handlePtr, uint32_t reserved)");
+	apply_type(0x0077AC80, "void __thiscall func(TSFixedArray_uint32_t* this, uint32_t count, uint32_t* data)");
+	apply_type(0x0077ACF0, "uint32_t __thiscall func(BigBuffer* this, uint32_t index)");
+	apply_type(0x0077AD10, "int32_t __fastcall func(BigBuffer* a, BigBuffer* b)");
+	apply_type(0x0077ADD0, "uint32_t __stdcall func(BigBuffer* a)");
+	apply_type(0x0077AE60, "int32_t __stdcall func(BigData* b, BigData* c)");
+	apply_type(0x0077AE80, "void __thiscall func(BigStack* this)");
+	apply_type(0x0077AEC0, "uint32_t* __thiscall func(BigBuffer* this, uint32_t index)");
+	apply_type(0x0077AF30, "void __thiscall func(BigBuffer* this, uint32_t count)");
+	apply_type(0x0077AF80, "void __thiscall func(BigBuffer* this)");
+	apply_type(0x0077AFF0, "void __thiscall func(BigBuffer* this)");
+	apply_type(0x0077B020, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigBuffer* c@<esi>)");
+	apply_type(0x0077B160, "void __stdcall func(BigBuffer* a, uint32_t* b, BigBuffer* c, uint64_t d)");
+	apply_type(0x0077B2B0, "void __stdcall func(BigBuffer* a, BigBuffer* b, uint64_t c)");
+	apply_type(0x0077B3E0, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigBuffer* c)");
+	apply_type(0x0077B530, "void __stdcall func(BigBuffer@<edi>* a)");
+	apply_type(0x0077B590, "void __stdcall func(BigBuffer* a, BigBuffer* b, uint32_t shift)");
+	apply_type(0x0077B700, "void __stdcall func(BigBuffer* a, BigBuffer* b, uint32_t shift)");
+	apply_type(0x0077B7F0, "void __stdcall func(BigBuffer* buffer@<edi>, void* data, uint32_t bytes)");
+	apply_type(0x0077B8B0, "void __stdcall func(BigBuffer* buffer@<edi>, uint32_t value)");
+	apply_type(0x0077B910, "void __stdcall func(TSGrowableArray_uint8_t* output, BigBuffer* buffer)");
+	apply_type(0x0077B9E0, "void __stdcall func(BigData* a, BigData* b, BigData* c)");
+	apply_type(0x0077BA00, "void __stdcall func(BigData* a, uint32_t* bits)");
+	apply_type(0x0077BA60, "void __stdcall func(BigData* num, void* data, uint32_t bytes)");
+	apply_type(0x0077BA80, "void __stdcall func(BigData* num, uint32_t val)");
+	apply_type(0x0077BAA0, "void __stdcall func(BigData* a, BigData* b, BigData* c)");
+	apply_type(0x0077BAC0, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigBuffer* c, BigBuffer* d, BigStack* stack)");
+	apply_type(0x0077BEE0, "void __stdcall func(BigData* a, BigData* b, BigData* c)");
+	apply_type(0x0077BF20, "void __stdcall func(BigData** num)");
+	apply_type(0x0077BF90, "void __stdcall func(BigData* num, uint8_t* data, uint32_t maxBytes, uint32_t* bytes)");
+	apply_type(0x0077BFF0, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigBuffer* c, BigStack* stack)");
+	apply_type(0x0077C330, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigStack* stack)");
+	apply_type(0x0077C6A0, "void __stdcall func(BigData* num)");
+	apply_type(0x0077C700, "void __stdcall func(BigData* a, BigData* b, BigData* c)");
+	apply_type(0x0077C720, "void __stdcall func(BigBuffer* a, BigBuffer* b, BigBuffer* c, BigBuffer* d, BigStack* stack)");
+	apply_type(0x0077C980, "void __stdcall func(BigData* a, BigData* b, BigData* c, BigData* d)");
 	apply_type(0x00819EA0, "void __stdcall func(int32_t function, FrameScript_Object* object, int32_t args, char* args_fmt, FrameScript_EventObject* eventObject)");
 	apply_type(0x0095F3A0, "void __thiscall func(CSimpleModel* this)");
 	apply_type(0x0095F420, "FrameScript_Object__ScriptIx* __thiscall func(CSimpleModel* this, char* name, FrameScript_Object__ScriptData* data)");

profile/3.3.5a-windows-386/ida/batch/import_functions.idc

@@ -0,0 +1,68 @@
+#include <idc.idc>
+
+static import_functions() {
+	// Import function addresses and comments
+	msg("Importing function addresses and comments");
+	set_func_cmt(0x00401030, "void operator delete(void*)", 0);
+	set_func_cmt(0x00401070, "protected: int __thiscall CDataStore::FetchWrite(unsigned int,unsigned int,char const *,int)", 0);
+	set_func_cmt(0x004010D0, "CDataStore::IsRead() const", 0);
+	set_func_cmt(0x004010E0, "CDataStore::Reset()", 0);
+	set_func_cmt(0x00401130, "CDataStore::Finalize()", 0);
+	set_func_cmt(0x004038A0, "CDataStore::~CDataStore()", 0);
+	set_func_cmt(0x0047ADE0, "CDataStore::GetBufferParams(void const**, unsigned int*, unsigned int*)", 0);
+	set_func_cmt(0x0047AE10, "CDataStore::DetachBuffer(void**, unsigned int*, unsigned int*)", 0);
+	set_func_cmt(0x0047AE50, "virtual void __thiscall CDataStore::InternalDestroy(unsigned char * &,unsigned int &,unsigned int &)", 0);
+	set_func_cmt(0x0047AEA0, "CDataStore::InternalFetchWrite(unsigned int, unsigned int, unsigned char*&, unsigned int&, unsigned int&, char const*, int)", 0);
+	set_func_cmt(0x0047AF40, "CDataStore::Set(unsigned int, unsigned short)", 0);
+	set_func_cmt(0x0047AFE0, "CDataStore::Put(unsigned char)", 0);
+	set_func_cmt(0x0047B040, "CDataStore::Put(unsigned short)", 0);
+	set_func_cmt(0x0047B0A0, "CDataStore::Put(unsigned int)", 0);
+	set_func_cmt(0x0047B100, "CDataStore::Put(unsigned long long)", 0);
+	set_func_cmt(0x0047B1C0, "CDataStore::PutArray(unsigned char const*, unsigned int)", 0);
+	set_func_cmt(0x0047B280, "CDataStore::PutData(void const*, unsigned long)", 0);
+	set_func_cmt(0x0047B290, "CDataStore::FetchRead(unsigned int, unsigned int)", 0);
+	set_func_cmt(0x0047B300, "CDataStore::PutString(char const*)", 0);
+	set_func_cmt(0x0047B340, "CDataStore::Get(unsigned char&)", 0);
+	set_func_cmt(0x0047B380, "CDataStore::Get(unsigned short&)", 0);
+	set_func_cmt(0x0047B3C0, "CDataStore::Get(unsigned int&)", 0);
+	set_func_cmt(0x0047B400, "CDataStore::Get(unsigned long long&)", 0);
+	set_func_cmt(0x0047B440, "CDataStore::Get(float&)", 0);
+	set_func_cmt(0x0047B480, "CDataStore::GetString(char*, unsigned int)", 0);
+	set_func_cmt(0x0047B560, "CDataStore::GetArray(unsigned char*, unsigned int)", 0);
+	set_func_cmt(0x0047B6B0, "CDataStore::GetDataInSitu(void*&, unsigned int)", 0);
+	set_func_cmt(0x0047F230, "IEvtSchedulerProcess as an independent function appears to be optimized out", 0);
+	set_func_cmt(0x004DBFD0, "thanks namreeb :^)", 0);
+	set_func_cmt(0x00532AF0, "public: class CGxCaps const & __thiscall CGxDevice::Caps(void)const", 0);
+	set_func_cmt(0x005EEB70, "SErrDisplayAppFatal resolves to this in release mode?", 0);
+	set_func_cmt(0x00681BE0, "UC", 0);
+	set_func_cmt(0x00682400, "this is one of the functions named 'GxPrimVertexPtr' that uses the fixed-function pipeline", 0);
+	set_func_cmt(0x00684C40, "CGxDevice::Log(CGxCaps const&) const", 0);
+	set_func_cmt(0x006859E0, "CGxDevice::IRsForceUpdate(EGxRenderState)", 0);
+	set_func_cmt(0x00685A70, "CGxDevice::IRsForceUpdate()", 0);
+	set_func_cmt(0x006AA350, "UC", 0);
+	set_func_cmt(0x006AA420, "private utility method", 0);
+	set_func_cmt(0x006AB390, "public method", 0);
+	set_func_cmt(0x00763730, "UC", 0);
+	set_func_cmt(0x00763B40, "UC", 0);
+	set_func_cmt(0x00763B90, "UC", 0);
+	set_func_cmt(0x0077ACF0, "public: unsigned int __thiscall BigBuffer::operator[](unsigned int)const", 0);
+	set_func_cmt(0x0077AE80, "public: __thiscall BigStack::~BigStack(void)", 0);
+	set_func_cmt(0x0077AEC0, "public: unsigned int & __thiscall BigBuffer::operator[](unsigned int)const", 0);
+	set_func_cmt(0x0077AF80, "public: void __thiscall BigBuffer::Trim(void)const", 0);
+	set_func_cmt(0x0077B020, "void Add(class BigBuffer &,class BigBuffer const &,class BigBuffer const &)", 0);
+	set_func_cmt(0x0077B160, "void Div(class BigBuffer &,unsigned int *,class BigBuffer const &,unsigned __int64)", 0);
+	set_func_cmt(0x0077B2B0, "void Mul(class BigBuffer &,class BigBuffer const &,unsigned __int64)", 0);
+	set_func_cmt(0x0077B3E0, "void Sub(class BigBuffer &,class BigBuffer const &,class BigBuffer const &)", 0);
+	set_func_cmt(0x0077B590, "void Shl(class BigBuffer &,class BigBuffer const &,unsigned int)", 0);
+	set_func_cmt(0x0077B700, "void Shl(class BigBuffer &,class BigBuffer const &,unsigned int)", 0);
+	set_func_cmt(0x0077B7F0, "void FromBinary(class BigBuffer &,void const *,unsigned int)", 0);
+	set_func_cmt(0x0077B8B0, "void FromUnsigned(class BigBuffer &,unsigned int)", 0);
+	set_func_cmt(0x0077B910, "_ToBinaryAppend(TSGrowableArray<unsigned char>&, BigBuffer const&)", 0);
+	set_func_cmt(0x0077BAC0, "void __fastcall Div(class BigBuffer &,class BigBuffer &,class BigBuffer const &,class BigBuffer const &,class BigStack &)", 0);
+	set_func_cmt(0x0077BFF0, "void Mul(class BigBuffer &,class BigBuffer const &,class BigBuffer const &,class BigStack &)", 0);
+	set_func_cmt(0x0077C330, "void __fastcall Square(class BigBuffer &,class BigBuffer const &,class BigStack &)", 0);
+	set_func_cmt(0x00869720, "actually called by IEvtInputInitialize, but this is optimized out", 0);
+	set_func_cmt(0x008E5250, "Script_ToggleTris", 0);
+	set_func_cmt(0x0095D110, "CDataAllocator::GetData(int, char const*, int)", 0);
+	set_func_cmt(0x0095D1B0, "CDataAllocator::PutData(void*, char const*, int)", 0);
+}

profile/3.3.5a-windows-386/ida/batch/import_symbols.idc

@@ -2,6 +2,8 @@
 
 static import_symbols() {
 	// Set/create names
+	set_name(0x00401010, "operator_new");
+	set_name(0x00401030, "operator_delete_array");
 	set_name(0x00401070, "CDataStore__FetchWrite");
 	set_name(0x004010D0, "CDataStore__IsRead");
 	set_name(0x004010E0, "CDataStore__Reset");
@@ -23,8 +25,11 @@ static import_symbols() {
 	set_name(0x00409670, "CGxDevice__RsPush");
 	set_name(0x0040BAA5, "purecall");
 	set_name(0x0040D3B5, "nullsub_1");
+	set_name(0x00421750, "SFile__DisableSFileCheckDisk");
+	set_name(0x00421760, "SFile__EnableDirectAccess");
 	set_name(0x004217C0, "SFile__FileIsLocal");
 	set_name(0x004218C0, "SFile__GetFileSize");
+	set_name(0x00421A80, "SFile__SetBasePath");
 	set_name(0x00421AF0, "SFile__SetDataPath");
 	set_name(0x00421BB0, "SFile__SetFilePointer");
 	set_name(0x00421CA0, "SFile__Unload");
@@ -62,6 +67,8 @@ static import_symbols() {
 	set_name(0x0047B480, "CDataStore__GetString");
 	set_name(0x0047B560, "CDataStore__GetArray");
 	set_name(0x0047B6B0, "CDataStore__GetDataInSitu");
+	set_name(0x0047B6F0, "CmdLineGetBool");
+	set_name(0x0047B700, "CmdLineGetString");
 	set_name(0x0047B720, "CmdLineProcess");
 	set_name(0x0047B760, "j_nullsub_3");
 	set_name(0x0047BF30, "HandleClose");
@@ -2090,12 +2097,14 @@ static import_symbols() {
 	set_name(0x006813B0, "GxSceneClear");
 	set_name(0x006813D0, "GxTexUpdate");
 	set_name(0x006817E0, "GxLog");
+	set_name(0x00681A60, "GxDrawLockedElements");
 	set_name(0x00681AB0, "GxPrimIndexPtr");
 	set_name(0x00681B00, "GxPrimVertexPtr");
 	set_name(0x00681BE0, "CGxTexFlags__CGxTexFlags");
 	set_name(0x00681CB0, "GxTexCreate");
 	set_name(0x00681F60, "GxXformSetViewport");
-	set_name(0x00682340, "GxDrawLockedElements");
+	set_name(0x00682340, "GxDrawLockedElements@2");
+	set_name(0x006823A0, "GxPrimLockIndexPtr");
 	set_name(0x00682400, "GxPrimVertexPtr_FFP");
 	set_name(0x006828C0, "GxPrimLockVertexPtrs");
 	set_name(0x00682A00, "GxScenePresent");
@@ -2109,6 +2118,7 @@ static import_symbols() {
 	set_name(0x00682DC0, "CGxDevice__CapsIsWindowVisible");
 	set_name(0x00682E20, "CGxDevice__CapsHasContext");
 	set_name(0x00682E50, "CGxDevice__ScenePresent");
+	set_name(0x00682F10, "CGxDevice__PrimIndexPtr");
 	set_name(0x00682F40, "CGxDevice__PrimCalcCount");
 	set_name(0x00683080, "CGxDevice__LightEnable");
 	set_name(0x006830B0, "CGxDevice__NeedsUpdate");
@@ -2419,6 +2429,41 @@ static import_symbols() {
 	set_name(0x00777590, "SRgnGetBoundingRectf");
 	set_name(0x00777940, "SRgnDelete");
 	set_name(0x00777980, "SRgnCreate");
+	set_name(0x0077AC80, "TSFixedArray_uint32_t_Set");
+	set_name(0x0077ACF0, "BigBuffer__operator_index");
+	set_name(0x0077AD10, "Compare");
+	set_name(0x0077ADD0, "HighBitPos");
+	set_name(0x0077AE60, "SBigCompare");
+	set_name(0x0077AE80, "BigStack__destructor");
+	set_name(0x0077AEC0, "BigBuffer__operator_index@2");
+	set_name(0x0077AF30, "BigBuffer__SetCount");
+	set_name(0x0077AF80, "BigBuffer__Trim");
+	set_name(0x0077AFF0, "BigStack__BigStack");
+	set_name(0x0077B020, "Add");
+	set_name(0x0077B160, "Div");
+	set_name(0x0077B2B0, "Mul");
+	set_name(0x0077B3E0, "Sub");
+	set_name(0x0077B530, "SetOne");
+	set_name(0x0077B590, "Shl");
+	set_name(0x0077B700, "Shr");
+	set_name(0x0077B7F0, "FromBinary");
+	set_name(0x0077B8B0, "FromUnsigned");
+	set_name(0x0077B910, "ToBinaryAppend");
+	set_name(0x0077B9E0, "SBigAdd");
+	set_name(0x0077BA00, "SBigBitLen");
+	set_name(0x0077BA60, "SBigFromBinary");
+	set_name(0x0077BA80, "SBigFromUnsigned");
+	set_name(0x0077BAA0, "SBigSub");
+	set_name(0x0077BAC0, "Div@2");
+	set_name(0x0077BEE0, "SBigMod");
+	set_name(0x0077BF20, "SBigNew");
+	set_name(0x0077BF90, "SBigToBinaryBuffer");
+	set_name(0x0077BFF0, "Mul@2");
+	set_name(0x0077C330, "Square");
+	set_name(0x0077C6A0, "SBigDel");
+	set_name(0x0077C700, "SBigMul");
+	set_name(0x0077C720, "PowMod");
+	set_name(0x0077C980, "SBigPowMod");
 	set_name(0x007DAB80, "Script_VoiceEnumerateOutputDevices");
 	set_name(0x007DAC40, "Script_VoiceEnumerateCaptureDevices");
 	set_name(0x007DACF0, "Script_VoiceSelectOutputDevice");
@@ -2523,7 +2568,7 @@ static import_symbols() {
 	set_name(0x0095FBA0, "CSimpleModel__UpdateModel");
 	set_name(0x0095FC30, "CSimpleModel__RenderModel");
 	set_name(0x00960070, "CSimpleModel__LightingCallback");
-	set_name(0x009600E0, "CSimpleModel__SetModel");
+	set_name(0x009600E0, "CSimpleModel__SetModel@2");
 	set_name(0x00960190, "CSimpleModel__OnModelLoaded");
 	set_name(0x00960280, "CSimpleModel__OnLayerUpdate");
 	set_name(0x009603D0, "CSimpleModel__RegisterScriptMethods");

profile/3.3.5a-windows-386/include/async/object.h

@@ -1,15 +1,14 @@
 #ifndef ASYNC_OBJECT_H
 #define ASYNC_OBJECT_H
 
-#include "system/types.h"
 #include "storm/list.h"
-#include "async/queue.h"
 
 DECLARE_STRUCT(CAsyncObject);
-DECLARE_STRUCT(TSLink_CAsyncObject);
-
 STORM_TS_LIST(CAsyncObject);
 
+#include "system/types.h"
+#include "async/queue.h"
+
 struct CAsyncObject {
   void* file;
   void* buffer;

profile/3.3.5a-windows-386/include/async/queue.h

@@ -1,17 +1,14 @@
 #ifndef ASYNC_QUEUE_H
 #define ASYNC_QUEUE_H
 
+DECLARE_STRUCT(CAsyncQueue);
+STORM_TS_LIST(CAsyncQueue);
+
 #include "system/types.h"
 #include "storm/list.h"
 
 #include "async/object.h"
 
-DECLARE_STRUCT(TSLink_CAsyncQueue);
-DECLARE_STRUCT(TSExplicitList_CAsyncObject);
-
-DECLARE_STRUCT(CAsyncQueue);
-STORM_TS_LIST(CAsyncQueue);
-
 struct CAsyncQueue {
   TSLink_CAsyncQueue link;
   TSExplicitList_CAsyncObject readList;

profile/3.3.5a-windows-386/include/cmd/option.h

@@ -0,0 +1,26 @@
+#ifndef CMD_OPTION_H
+#define CMD_OPTION_H
+
+DECLARE_ENUM(CMDOPT);
+
+enum CMDOPT {
+  CMD_D3D = 0,
+  CMD_D3D9EX = 1,
+  CMD_DATA_DIR = 2,
+  CMD_NO_LAG_FIX = 3,
+  CMD_LOADFILE = 4,
+  CMD_GAMETYPE = 5,
+  CMD_OPENGL = 6,
+  CMD_SW_TNL = 7,
+  CMD_TIMEDEMO = 8,
+  CMD_DEMOREZ = 9,
+  CMD_DEMODEPTH = 10,
+  CMD_DEMODETAIL = 11,
+  CMD_DEMOSOUND = 12,
+  CMD_FULL_SCREEN = 13,
+  CMD_22050HZ = 14,
+  CMD_NO_WARNINGS = 15,
+  CMDOPTS = 16
+};
+
+#endif

profile/3.3.5a-windows-386/include/external/d3d9/device.h

@@ -6,17 +6,23 @@
 #include "external/d3d9/caps.h"
 
 typedef int32_t D3DFORMAT;
-typedef struct D3DDISPLAYMODE D3DDISPLAYMODE;
-typedef struct IDirect3D9 IDirect3D9;
-typedef struct IDirect3DDevice9 IDirect3DDevice9;
-typedef struct IDirect3DDevice9_vtable IDirect3DDevice9_vtable;
-typedef struct IDirect3DVertexDeclaration9 IDirect3DVertexDeclaration9;
-typedef struct IDirect3DSurface9 IDirect3DSurface9;
-typedef struct IDirect3DIndexBuffer9 IDirect3DIndexBuffer9;
-typedef struct IDirect3DVertexBuffer9 IDirect3DVertexBuffer9;
-typedef struct IDirect3DTexture9 IDirect3DTexture9;
 
-typedef struct D3DLOCKED_RECT D3DLOCKED_RECT;
+DECLARE_STRUCT(D3DDISPLAYMODE);
+DECLARE_STRUCT(IDirect3D9);
+DECLARE_STRUCT(IDirect3DDevice9);
+DECLARE_STRUCT(IDirect3DDevice9_vtable);
+DECLARE_STRUCT(IDirect3DVertexDeclaration9);
+DECLARE_STRUCT(IDirect3DSurface9__vtable);
+DECLARE_STRUCT(IDirect3DSurface9);
+DECLARE_STRUCT(IDirect3DIndexBuffer9);
+DECLARE_STRUCT(IDirect3DVertexBuffer9);
+DECLARE_STRUCT(IDirect3DTexture9);
+DECLARE_STRUCT(IDirect3DVertexShader9__vtable);
+DECLARE_STRUCT(IDirect3DVertexShader9);
+DECLARE_STRUCT(IDirect3DPixelShader9__vtable);
+DECLARE_STRUCT(IDirect3DPixelShader9);
+
+DECLARE_STRUCT(D3DLOCKED_RECT);
 
 struct D3DDISPLAYMODE {
   uint32_t Width;
@@ -160,8 +166,31 @@ struct IDirect3DVertexDeclaration9 {
   void** v_vtable;
 };
 
+struct IDirect3DSurface9__vtable {
+  /*** IUnknown methods ***/
+  void* v_fn_0_QueryInterface;
+  void* v_fn_1_AddRef;
+  void* v_fn_2_Release;
+  /*** IDirect3DResource9 methods ***/
+  void* v_fn_3_GetDevice;
+  void* v_fn_4_SetPrivateData;
+  void* v_fn_5_GetPrivateData;
+  void* v_fn_6_FreePrivateData;
+  void* v_fn_7_SetPriority;
+  void* v_fn_8_GetPriority;
+  void* v_fn_9_PreLoad;
+  void* v_fn_10_GetType;
+  /*** IDirect3DSurface9 methods ***/
+  void* v_fn_11_GetContainer;
+  void* v_fn_12_GetDesc;
+  void* v_fn_13_LockRect;
+  void* v_fn_14_UnlockRect;
+  void* v_fn_15_GetDC;
+  void* v_fn_16_ReleaseDC;
+};
+
 struct IDirect3DSurface9 {
-  void** v_vtable;
+  IDirect3DSurface9__vtable* v_vtable;
 };
 
 struct IDirect3DIndexBuffer9 {
@@ -181,4 +210,28 @@ struct D3DLOCKED_RECT {
   void* pBits;
 };
 
+struct IDirect3DVertexShader9__vtable {
+  void* v_fn_0_QueryInterface;
+  void* v_fn_1_AddRef;
+  void* v_fn_2_Release;
+  void* v_fn_3_GetDevice;
+  void* v_fn_4_GetFunction;
+};
+
+struct IDirect3DVertexShader9 {
+  IDirect3DVertexShader9__vtable* v_vtable;
+};
+
+struct IDirect3DPixelShader9__vtable {
+  void* v_fn_0_QueryInterface;
+  void* v_fn_1_AddRef;
+  void* v_fn_2_Release;
+  void* v_fn_3_GetDevice;
+  void* v_fn_4_GetFunction;
+};
+
+struct IDirect3DPixelShader9 {
+  IDirect3DPixelShader9__vtable* v_vtable;
+};
+
 #endif

profile/3.3.5a-windows-386/include/gx/buffer.h

@@ -6,17 +6,18 @@
 #include "storm/list.h"
 #include "tempest/vector.h"
 
-typedef enum EGxPoolHintBits EGxPoolHintBits;
-typedef enum EGxPoolTarget EGxPoolTarget;
-typedef enum EGxPoolUsage EGxPoolUsage;
-typedef enum EGxVertexAttrib EGxVertexAttrib;
-typedef enum EGxVertexBufferFormat EGxVertexBufferFormat;
-typedef struct ubyte4 ubyte4;
-typedef struct CGxVertexAttrib CGxVertexAttrib;
-typedef struct CGxVertexPBNT2 CGxVertexPBNT2;
-typedef struct CGxVertexPCT CGxVertexPCT;
-typedef struct CGxPool CGxPool;
-typedef struct CGxBuf CGxBuf;
+DECLARE_ENUM(EGxPoolHintBits);
+DECLARE_ENUM(EGxPoolTarget);
+DECLARE_ENUM(EGxPoolUsage);
+DECLARE_ENUM(EGxVertexAttrib);
+DECLARE_ENUM(EGxVertexBufferFormat);
+
+DECLARE_STRUCT(ubyte4);
+DECLARE_STRUCT(CGxVertexAttrib);
+DECLARE_STRUCT(CGxVertexPBNT2);
+DECLARE_STRUCT(CGxVertexPCT);
+DECLARE_STRUCT(CGxPool);
+DECLARE_STRUCT(CGxBuf);
 
 enum EGxPoolHintBits {
   GxPoolHintBit_Unk0 = 0,

profile/3.3.5a-windows-386/include/gx/device.h

@@ -24,11 +24,11 @@
 #include "gx/buffer.h"
 #include "gx/texture.h"
 
-typedef struct CGxAppRenderState CGxAppRenderState;
-typedef struct CGxPushedRenderState CGxPushedRenderState;
-typedef struct ShaderConstants ShaderConstants;
-typedef struct CGxDevice CGxDevice;
-typedef struct CGxDevice__vtable CGxDevice__vtable;
+DECLARE_STRUCT(CGxAppRenderState);
+DECLARE_STRUCT(CGxPushedRenderState);
+DECLARE_STRUCT(ShaderConstants);
+DECLARE_STRUCT(CGxDevice);
+DECLARE_STRUCT(CGxDevice__vtable);
 
 typedef void (*DEVICERESTOREDCALLBACK)();
 STORM_TS_GROWABLE_ARRAY(DEVICERESTOREDCALLBACK);
@@ -36,8 +36,8 @@ STORM_TS_GROWABLE_ARRAY(DEVICERESTOREDCALLBACK);
 typedef void (*TEXTURERECREATIONCALLBACK)();
 STORM_TS_GROWABLE_ARRAY(TEXTURERECREATIONCALLBACK);
 
-typedef void (*DISPLAYCHANGECALLBACK)();
-STORM_TS_GROWABLE_ARRAY(DISPLAYCHANGECALLBACK);
+typedef void (*STEREOCHANGEDCALLBACK)();
+STORM_TS_GROWABLE_ARRAY(STEREOCHANGEDCALLBACK);
 
 struct CGxAppRenderState {
   CGxStateBom m_value;
@@ -61,12 +61,12 @@ struct ShaderConstants {
 
 // 84 functions
 struct CGxDevice__vtable {
-  // void ITexMarkAsUpdated(CGxTex*, uint32_t);
+  // void ITexMarkAsUpdated(CGxTex* texId);
   void* v_fn_0_ITexMarkAsUpdated;
-  // void IRsSendToHw(EGxRenderState);
+  // void IRsSendToHw(EGxRenderState rs);
   // no base implementation
   void* v_fn_1_IRsSendToHw;
-  // void ICursorCreate(const CGxFormat&);
+  // void ICursorCreate(const CGxFormat& format);
   void* v_fn_2_ICursorCreate;
   // void ICursorDestroy();
   void* v_fn_3_ICursorDestroy;
@@ -82,147 +82,187 @@ struct CGxDevice__vtable {
   void* v_fn_6_NotifyOnTextureRecreation;
   // void NotifyOnDisplayChange();
   void* v_fn_7_NotifyOnDisplayChange; 
-  // void `scalar deleting destructor'(unsigned int)
+  // void `scalar deleting destructor'(uint32_t __flags)
   void* v_fn_8_scalar_deleting_destructor;
-  // int32_t DeviceCreate(const CGxFormat&);
+  // int32_t DeviceCreate(const CGxFormat& format);
   void* v_fn_9_DeviceCreate;
-  // int32_t DeviceCreate(long (*)(void*, uint32_t, uint32_t, int32_t), CGxFormat const&);
+  // int32_t DeviceCreate(long (*windowProc)(void*, uint32_t, uint32_t, int32_t), CGxFormat const& format);
   void* v_fn_10_DeviceCreate;
   // void DeviceDestroy();
   void* v_fn_11_DeviceDestroy;
   // void DeviceEvictResources();
   void* v_fn_12_DeviceEvictResources;
-  // int32_t DeviceSetFormat(const CGxFormat&);
+  // int32_t DeviceSetFormat(const CGxFormat& format);
   void* v_fn_13_DeviceSetFormat;
-  // void DeviceSetBaseMipLevel(uint32_t);
+  // void DeviceSetBaseMipLevel(uint32_t mipLevel);
   void* v_fn_14_DeviceSetBaseMipLevel;
-  // void DeviceSetGamma(CGxGammaRamp const&);
+  // void DeviceSetGamma(CGxGammaRamp const& ramp);
   void* v_fn_15_DeviceSetGamma;
-  // void DeviceSetGamma(float);
+  // void DeviceSetGamma(float gamma);
   void* v_fn_16_DeviceSetGamma;
   // no base implementation
   // void* DeviceWindow();
   void* v_fn_17_DeviceWindow;
   // void DeviceTakeScreenShot();
   void* v_fn_18_DeviceTakeScreenShot;
-  // void DeviceReadScreenShot(uint32_t&, uint32_t&, const CImVector*&) */
+  // void DeviceReadScreenShot(uint32_t& w, uint32_t& h, const CImVector*& pixels) */
   void* v_fn_19_DeviceReadScreenShot;
-  // void DeviceReadPixels(CiRect&, TSGrowableArray<CImVector>&);
+  // void DeviceReadPixels(CiRect& rect, TSGrowableArray<CImVector>& pixels);
   void* v_fn_20_DeviceReadPixels;
-  // void DeviceReadDepths(CiRect&, TSGrowableArray<float>&);
+  // void DeviceReadDepths(CiRect& rect, TSGrowableArray<float>& depths);
   void* v_fn_21_DeviceReadDepths;
-  // void DeviceWM(EGxWM, int32_t, int32_t);
+  // void DeviceWM(EGxWM wm, int32_t param1, int32_t param2);
   void* v_fn_22_DeviceWM;
-  // void DeviceSetRenderTarget(EGxBuffer, CGxTex*, uint32_t);
-  void* v_fn_23;
-  // void DeviceCopyTex(CGxTex*, uint32_t, CGxTex*, uint32_t);
-  void* v_fn_24;
-  void* v_fn_25;
-  void* v_fn_26;
-  void* v_fn_27;
-  // void DeviceOverride(EGxOverride, uint32_t);
+  // void DeviceSetRenderTarget(EGxBuffer buffer, CGxTex* texture, uint32_t plane);
+  void* v_fn_23_DeviceSetRenderTarget;
+  // void v_fn_24(); DeviceReleaseDepthBuffer?
+  // d3d:
+  //   this->m_d3dDevice->GetDepthStencilSurface(&PTR_00C6033C);
+  //   PTR_00C6033C->Release();
+  void* v_fn_24; 
+  // void v_fn_25(); DeviceResetDepthBuffer?
+  // d3d:
+  //   this->m_d3dDevice->SetDepthStencilSurface(PTR_00C6033C);
+  void* v_fn_25; 
+  // void v_fn_26(CGxTex* texId); DeviceResolveDepthBuffer(CGxTex*) seems to be the most logical candidate for this
+  // d3d:
+  //   if (this->m_context) {
+  //     if (texId &&
+  //          (texId->m_needsCreation ||
+  //            (texId->m_apiSpecificData == nullptr &&
+  //             texId->m_apiSpecificData2 == nullptr)) {
+  //        this->ITexCreate(texId);
+  //      }
+  //      this->m_d3dDevice->SetDepthStencilSurface(texId->m_apiSpecificData);
+  //   }
+  // void DeviceResolveDepthBuffer(CGxTex* texId);
+  void* v_fn_26_DeviceResolveDepthBuffer;
+  // void DeviceCopyTex(CGxTex* a1, int32_t a2, CGxTex* a3, int32_t a4);
+  void* v_fn_27_DeviceCopyTex;
+  // void DeviceOverride(EGxOverride override, uint32_t value);
   void* v_fn_28_DeviceOverride;
-  // void AddDeviceRestoredCallback(DEVICERESTOREDCALLBACK);
+  // void AddDeviceRestoredCallback(DEVICERESTOREDCALLBACK callback);
   void* v_fn_29_AddDeviceRestoredCallback;
-  // int32_t RemoveDeviceRestoredCallback(DEVICERESTOREDCALLBACK);
+  // int32_t RemoveDeviceRestoredCallback(DEVICERESTOREDCALLBACK callback);
   void* v_fn_30_RemoveDeviceRestoredCallback;
-  // void AddTextureRecreationCallback(TEXTURERECREATIONCALLBACK);
+  // void AddTextureRecreationCallback(TEXTURERECREATIONCALLBACK callback);
   void* v_fn_31_AddTextureRecreationCallback;
-  // int32_t RemoveTextureRecreationCallback(TEXTURERECREATIONCALLBACK);
+  // int32_t RemoveTextureRecreationCallback(TEXTURERECREATIONCALLBACK callback);
   void* v_fn_32_RemoveTextureRecreationCallback;
-  // void AddDisplayChangeCallback(DISPLAYCHANGECALLBACK);
-  void* v_fn_33_AddDisplayChangeCallback;
-  // int32_t RemoveDisplayChangeCallback(DISPLAYCHANGECALLBACK);
-  void* v_fn_34_RemoveDisplayChangeCallback;
-  // void CapsWindowSize(CRect&);
+  // void AddStereoChangedCallback(STEREOCHANGEDCALLBACK callback);
+  void* v_fn_33_AddStereoChangedCallback;
+  // int32_t RemoveStereoChangeCallback(STEREOCHANGEDCALLBACK callback);
+  void* v_fn_34_RemoveStereoChangedCallback;
+  // void CapsWindowSize(CRect& dst);
   void* v_fn_35_CapsWindowSize;
-  // void CapsWindowSize(CRect&);
+  // void CapsWindowSize(CRect& dst);
   void* v_fn_36_CapsWindowSizeInScreenCoords;
-  void* v_fn_37;
-  // void ScenePresent(uint32_t);
+  // void LogCrashInfo(char* buffer, uint32_t size);
+  void* v_fn_37_LogCrashInfo;
+  // void ScenePresent(uint32_t mask);
   void* v_fn_38_ScenePresent;
-  // void SceneClear(uint32_t, CImVector);
+  // void SceneClear(uint32_t mask, CImVector color);
   void* v_fn_39_SceneClear;
-  // void XformSetProjection(const C44Matrix&);
+  // void XformSetProjection(const C44Matrix& matrix);
   void* v_fn_40_XformSetProjection;
-  // void XformSetView(const C44Matrix&);
+  // void XformSetView(const C44Matrix& matrix);
   void* v_fn_41_XformSetView;
   // void Draw(CGxBatch*, int32_t);
   void* v_fn_42_Draw;
-  void* v_fn_43;
-  void* v_fn_44;
-  void* v_fn_45;
-  void* v_fn_46;
-  void* v_fn_47;
-  void* v_fn_48;
-  void* v_fn_49;
-  void* v_fn_50;
-  // void MasterEnableSet(EGxMasterEnables, int);
+  // void PrimBegin(EGxPrim primType);
+  void* v_fn_43_PrimBegin;
+  // void PrimDrawElements();
+  void* v_fn_44_PrimDrawElements;
+  // void PrimVertex(const C3Vector& v);
+  void* v_fn_45_PrimVertex;
+  // void PrimTexCoord(uint32_t tmu, const C2Vector& t);
+  void* v_fn_46_PrimTexCoord;
+  // void PrimNormal(const C3Vector& n);
+  void* v_fn_47_PrimNormal;
+  // void PrimColor(const CImVector& c);
+  void* v_fn_48_PrimColor;
+  // void PrimPointSize(float s);
+  void* v_fn_49_PrimPointSize;
+  // void PrimeLineWidth(float w);
+  void* v_fn_50_PrimLineWidth;
+  // void MasterEnableSet(EGxMasterEnables state, int32_t enable);
   void* v_fn_51_MasterEnableSet;
-  // void PoolSizeSet(CGxPool*, uint32_t);
+  // void PoolSizeSet(CGxPool* pool, uint32_t size);
   void* v_fn_52_PoolSizeSet;
-  // void PoolDestroy(CGxPool*);
+  // void PoolDestroy(CGxPool* pool);
   void* v_fn_53_PoolDestroy;
-  // char* BufLock(CGxBuf*);
+  // char* BufLock(CGxBuf* buf);
   void* v_fn_54_BufLock;
-  // int32_t BufUnlock(CGxBuf*, uint32_t);
+  // int32_t BufUnlock(CGxBuf* buf, uint32_t size);
   void* v_fn_55_BufUnlock;
-  // void BufData(CGxBuf*, void const*, uint32_t, uint32_t); 
+  // void BufData(CGxBuf* buf, const void* data, uint32_t size, uint32_t offset); 
   void* v_fn_56_BufData;
-  // int32_t TexCreate(EGxTexTarget, uint32_t, uint32_t, uint32_t, EGxTexFormat, EGxTexFormat, CGxTexFlags, void*, void (*)(EGxTexCommand, uint32_t, uint32_t, uint32_t, uint32_t, void*, uint32_t&, void const*&), char const*, CGxTex*&);
+  // int32_t TexCreate(EGxTexTarget target, uint32_t width, uint32_t height, uint32_t depth, EGxTexFormat format, EGxTexFormat dataFormat, CGxTexFlags flags, void* userArg, void (*userFunc)(EGxTexCommand, uint32_t, uint32_t, uint32_t, uint32_t, void*, uint32_t&, void const*&), const char* name, CGxTex*& texId);
   void* v_fn_57_TexCreate;
-  // void TexDestroy(CGxTex*);
+  // void TexDestroy(CGxTex* texId);
   void* v_fn_58_TexDestroy;
-  // int32_t TexCopy(CGxTex*, CGxTex*, const C2iVector&, const C2iVector&, const C2iVector&, uint32_t);
+  // int32_t TexCopy(CGxTex* a1, CGxTex* a2, const C2iVector& a3, const C2iVector& a4, const C2iVector& a5, uint32_t a6);
   void* v_fn_59_TexCopy;
-  void* v_fn_60;
-  void* v_fn_61;
-  void* v_fn_62;
-  void* v_fn_63;
-  void* v_fn_64;
-  void* v_fn_65;
-  void* v_fn_66;
-  void* v_fn_67;
-  // void ShaderCreate(CGxShader*[], EGxShTarget, const char*, const char*, int32_t);
+  // bool TexStretch(CGxTex* a1, CGxTex* a2, const CiRect* a3, const CiRect* a4, uint32_t a5, uint32_t a6);
+  void* v_fn_60_TexStretch;
+  // void TexSetCacheSize(int32_t cacheSize);
+  void* v_fn_61_TexSetCacheSize;
+  // void QueryCreate(CGxQuery*& query, EGxQueryType queryType);
+  void* v_fn_62_QueryCreate;
+  // bool QueryDestroy(CGxQuery* query);
+  void* v_fn_63_QueryDestroy;
+  // bool QueryBegin(CGxQuery* query);
+  void* v_fn_64_QueryBegin;
+  // bool QueryEnd(CGxQuery* query);
+  void* v_fn_65_QueryEnd;
+  // bool QueryGetParam(CGxQuery* query, EGxQueryParam param, uint32_t* data);
+  void* v_fn_66_QueryGetParam;
+  // bool QueryGetData(CGxQuery* query, uint32_t* data);
+  void* v_fn_67_QueryGetData;
+  // void ShaderCreate(CGxShader*[] shaders, EGxShTarget target, const char* a3, const char* a4, int32_t permutations);
   void* v_fn_68_ShaderCreate;
-  void* v_fn_69;
-  // void ShaderConstantsSet(EGxShTarget, uint32_t, const float*, uint32_t);
+  // void ShaderRelease(CGxShader*& shader);
+  void* v_fn_69_ShaderRelease;
+  // void ShaderConstantsSet(EGxShTarget target, uint32_t index, const float* constraints, uint32_t count);
   void* v_fn_70_ShaderConstantsSet;
-  void* v_fn_71_IShaderDestroy;
-  // void IShaderCreate(CGxShader*);
+  // void IShaderReload(CGxShader* shader, const char* a2, const char* a3);
+  void* v_fn_71_IShaderReload;
+  // void IShaderCreate(CGxShader* shader);
   void* v_fn_72_IShaderCreate;
-  // void CursorSetVisible(int32_t);
+  // void CursorSetVisible(int32_t visible);
   void* v_fn_73_CursorSetVisible;
-  // void* CursorLock();
+  // uint32_t* CursorLock();
   void* v_fn_74_CursorLock;
-  // void CursorUnlock(uint32_t, uint32_t);
+  // void CursorUnlock(uint32_t x, uint32_t y);
   void* v_fn_75_CursorUnlock;
-  // void StereoSetConvergence(float);
+  // void StereoSetConvergence(float c);
   void* v_fn_76_StereoSetConvergence;
   // double StereoGetConvergence();
   void* v_fn_77_StereoGetConvergence;
-  // void StereoSetSeparation(float);
+  // void StereoSetSeparation(float s);
   void* v_fn_78_StereoSetSeparation;
   // double StereoGetSeparation();
   void* v_fn_79_StereoGetSeparation;
   // bool StereoEnabled();
   void* v_fn_80_StereoEnabled;
-  // void DebugGroupBegin(const char*, char*);
+  // void DebugGroupBegin(const char* a1, char* a2);
   void* v_fn_81_DebugGroupBegin;
   // void DebugGroupEnd();
   void* v_fn_82_DebugGroupEnd;
-  // void DebugEvent(const char*, char*);
+  // void DebugEvent(const char* a1, char* a2);
   void* v_fn_83_DebugEvent;
 };
 
-// this class is at least 14688 bytes in size
+// this class is 14692 bytes in size
 struct CGxDevice {
   // pointer to struct CGxDevice__vtable
   CGxDevice__vtable* v_vtable; // 0x0 (size: 0x4)
   TSGrowableArray_CGxPushedRenderState m_pushedStates; // 0x4 (size: 0x14)
   TSGrowableArray_uint32_t m_stackOffsets; // 0x18 (size: 0x14)
   TSGrowableArray_EGxRenderState m_dirtyStates; // 0x2C (size: 0x14)
-  uint32_t m_unk34[4];
+  EGxPrim m_primType;
+  uint32_t m_unk38[2]; // m_indexLocked-m_vertexLocked?
+  int32_t m_inBeginEnd;
   C3Vector m_primVertex;
   C2Vector m_primTexCoord[8];
   C3Vector m_primNormal;
@@ -237,7 +277,7 @@ struct CGxDevice {
   CRect m_curWindowRect; // 0x174 (size: 0x10)
   TSGrowableArray_DEVICERESTOREDCALLBACK m_deviceRestoredCallbacks; // 0x184
   TSGrowableArray_TEXTURERECREATIONCALLBACK m_textureRecreationCallbacks;
-  TSGrowableArray_DISPLAYCHANGECALLBACK m_displayChangeCallbacks;
+  TSGrowableArray_STEREOCHANGEDCALLBACK m_stereoChangedCallbacks; // check darwin @ 00a2b779
   EGxApi m_api; // 0x1b4
   uint32_t m_cpuFeatures;
   CGxFormat m_format;
@@ -261,7 +301,9 @@ struct CGxDevice {
   // CGxMatrixStack m_xforms[GxXforms_Last];
   CGxMatrixStack m_xforms[11];
   CGxMatrixStack m_texGen[8];
-  uint32_t unk24D0[162];
+  uint32_t unk24D0[102];
+  // uint32_t unk2536[60];
+  TSHashTable_CGxShader_HASHKEY_STRI m_shaderList[6];
   uint32_t m_appMasterEnables;
   uint32_t m_hwMasterEnables;
   TSList_CGxPool m_poolList;

profile/3.3.5a-windows-386/include/gx/format.h

@@ -5,7 +5,7 @@
 
 #include "tempest/vector.h"
 
-typedef enum CGxFormat__Format CGxFormat__Format;
+DECLARE_ENUM(CGxFormat__Format);
 typedef struct CGxFormat CGxFormat;
 
 enum CGxFormat__Format {

profile/3.3.5a-windows-386/include/gx/matrix_stack.h

@@ -5,8 +5,8 @@
 
 #include "tempest/matrix.h"
 
-typedef enum CGxMatrixStack__EMatrixFlags CGxMatrixStack__EMatrixFlags;
-typedef struct CGxMatrixStack CGxMatrixStack;
+DECLARE_ENUM(CGxMatrixStack__EMatrixFlags);
+DECLARE_STRUCT(CGxMatrixStack);
 
 enum CGxMatrixStack__EMatrixFlags {
   F_Identity = 0x1

profile/3.3.5a-windows-386/include/gx/opengl.h

@@ -0,0 +1,14 @@
+#ifndef GX_OPENGL_H
+#define GX_OPENGL_H
+
+DECLARE_STRUCT(CGxDeviceOpenGl);
+
+#include "gx/device.h"
+
+// 15264 bytes - 14696 cgxdevice = 568
+struct CGxDeviceOpenGl {
+  CGxDevice b_base;
+  uint32_t unk3968[142];
+};
+
+#endif

profile/3.3.5a-windows-386/include/gx/shader.h

@@ -4,13 +4,14 @@
 #include "storm/hash.h"
 #include "storm/array/uint8_t.h"
 
-typedef struct CGxShader CGxShader;
+DECLARE_STRUCT(CGxShader);
 
 STORM_TS_HASH(CGxShader, HASHKEY_STRI);
 
 // class CGxShader : public TSHashObject<CGxShader, HASHKEY_STRI>
 struct CGxShader {
   TSHashObject_CGxShader_HASHKEY_STRI b_base;
+  void* v_table;
   uint32_t refCount;
   void* apiSpecific;
   int32_t target;
@@ -24,6 +25,7 @@ struct CGxShader {
   int16_t int44;
   int16_t int46;
   TSGrowableArray_uint8_t code;
+  // bool IsEnabled();
 };
 
 #endif

profile/3.3.5a-windows-386/include/gx/state_bom.h

@@ -4,7 +4,7 @@
 #include "system/types.h"
 #include "storm/array.h"
 
-typedef struct CGxStateBom CGxStateBom;
+DECLARE_STRUCT(CGxStateBom);
 
 struct CGxStateBom {
   union {

profile/3.3.5a-windows-386/include/gx/types.h

@@ -320,6 +320,10 @@ enum EGxTexWrapMode {
   GxTex_Wrap = 1
 };
 
+enum EGxQueryType {
+  GxQueryType_Occlusion = 0,
+};
+
 enum EGxXform {
   GxXform_Tex0 = 0,
   GxXform_Tex1 = 1,

profile/3.3.5a-windows-386/include/main.h

@@ -15,6 +15,8 @@
 
 #include "camera/camera.h"
 
+#include "cmd/option.h"
+
 #include "common/array.h"
 #include "common/handle.h"
 #include "common/instance.h"
@@ -42,6 +44,7 @@
 #include "gx/device.h"
 #include "gx/format.h"
 #include "gx/matrix_stack.h"
+#include "gx/opengl.h"
 #include "gx/shader.h"
 #include "gx/state_bom.h"
 #include "gx/string.h"
@@ -65,6 +68,8 @@
 #include "screen/layer.h"
 
 #include "storm/array.h"
+#include "storm/big.h"
+#include "storm/cmd.h"
 #include "storm/list.h"
 #include "storm/hash.h"
 #include "storm/queue.h"

profile/3.3.5a-windows-386/include/storm/big.h

@@ -0,0 +1,27 @@
+#ifndef STORM_BIG_H
+#define STORM_BIG_H
+
+DECLARE_STRUCT(BigData);
+DECLARE_STRUCT(BigBuffer);
+DECLARE_STRUCT(BigStack);
+
+#include "storm/array/uint8_t.h"
+#include "storm/array/uint32_t.h"
+
+struct BigBuffer {
+  TSGrowableArray_uint32_t m_data;
+  uint32_t m_offset;
+};
+
+struct BigStack {
+  BigBuffer m_buffer[16];
+  uint32_t m_used;
+};
+
+struct BigData {
+  BigBuffer m_primary;
+  BigStack m_stack;
+  TSGrowableArray_uint8_t m_output;
+};
+
+#endif

profile/3.3.5a-windows-386/include/storm/cmd.h

@@ -0,0 +1,78 @@
+#ifndef STORM_CMD_H
+#define STORM_CMD_H
+
+DECLARE_STRUCT(ARGLIST);
+DECLARE_STRUCT(CMDPARAMS);
+DECLARE_STRUCT(CMDDEF);
+STORM_TS_LIST(CMDDEF);
+DECLARE_STRUCT(CMDERROR);
+DECLARE_STRUCT(PROCESSING);
+
+#include "storm/list.h"
+
+// Callback types
+typedef int32_t (*CMDEXTRACALLBACK)(const char*);
+typedef int32_t (*CMDERRORCALLBACK)(CMDERROR*);
+typedef int32_t (*CMDPARAMSCALLBACK)(CMDPARAMS*, const char*);
+
+// Details a command line argument
+// class ARGLIST
+struct ARGLIST {
+  uint32_t          flags;
+  uint32_t          id;
+  const char*       name;
+  CMDPARAMSCALLBACK callback;
+};
+
+// Parameters passed to argument callback
+// class CMDPARAMS
+struct CMDPARAMS {
+  uint32_t      flags;
+  uint32_t      id;
+  const char*   name;
+  void*         variable;
+  uint32_t      setvalue;
+  uint32_t      setmask;
+  union {
+    int32_t     boolvalue;
+    int32_t     signedvalue;
+    uint32_t    unsignedvalue;
+    const char* stringvalue;
+  };
+};
+
+// Command definitions
+// class CMDDEF : public TSLinkedNode<CMDDEF>
+struct CMDDEF {
+  TSLinkedNode_CMDDEF b_base;
+  uint32_t            flags;
+  uint32_t            id;
+  char                name[16];
+  int32_t             namelength;
+  uint32_t            setvalue;
+  uint32_t            setmask;
+  void*               variableptr;
+  uint32_t            variablebytes;
+  CMDPARAMSCALLBACK   callback;
+  int32_t             found;
+  union {
+    uint32_t          currvalue;
+    char*             currvaluestr;
+  };
+};
+
+// class CMDERROR
+struct CMDERROR {
+  uint32_t    errorcode;
+  const char* itemstr;
+  const char* errorstr;
+};
+
+// class PROCESSING 
+struct PROCESSING {
+  CMDDEF* ptr;
+  char    name[16];
+  int32_t namelength;
+};
+
+#endif

profile/3.3.5a-windows-386/include/storm/hash.h

@@ -12,6 +12,7 @@ STORM_TS_GROWABLE_ARRAY(TSList_##T); \
 typedef struct TSHashTable_##T##_##K TSHashTable_##T##_##K; \
 typedef struct TSHashObject_##T##_##K TSHashObject_##T##_##K; \
 struct TSHashTable_##T##_##K { \
+  void** v_table; \
   TSList_##T m_fulllist; \
   uint32_t m_fullnessIndicator; \
   TSGrowableArray_TSList_##T m_slotlistarray; \