feat(profile): update 3.3.5a profile

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

@@ -0,0 +1,17 @@
+#ifndef GX_BATCH_H
+#define GX_BATCH_H
+
+#include "gx/types.h"
+
+DECLARE_STRUCT(CGxBatch);
+
+struct CGxBatch {
+  // Member variables
+  EGxPrim m_primType;
+  uint32_t m_start;
+  uint32_t m_count;
+  uint16_t m_minIndex;
+  uint16_t m_maxIndex;
+};
+
+#endif

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

@@ -0,0 +1,130 @@
+#ifndef GX_BUFFER_H
+#define GX_BUFFER_H
+
+#include "system/types.h"
+
+#include "storm/list.h"
+#include "tempest/vector.h"
+
+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,
+  GxPoolHintBit_Unk1 = 1,
+  GxPoolHintBit_Unk2 = 2,
+  GxPoolHintBit_Unk3 = 3
+};
+
+enum EGxPoolTarget {
+  GxPoolTarget_Vertex = 0,
+  GxPoolTarget_Index = 1,
+  GxPoolTargets_Last = 2
+};
+
+enum EGxPoolUsage {
+  GxPoolUsage_Static = 0,
+  GxPoolUsage_Dynamic = 1,
+  GxPoolUsage_Stream = 2,
+  GxPoolUsages_Last = 3
+};
+
+enum EGxVertexAttrib {
+  GxVA_Position = 0,
+  GxVA_BlendWeight = 1,
+  GxVA_BlendIndices = 2,
+  GxVA_Normal = 3,
+  GxVA_Color0 = 4,
+  GxVA_Color1 = 5,
+  GxVA_TexCoord0 = 6,
+  GxVA_TexCoord1 = 7,
+  GxVA_TexCoord2 = 8,
+  GxVA_TexCoord3 = 9,
+  GxVA_TexCoord4 = 10,
+  GxVA_TexCoord5 = 11,
+  GxVA_TexCoord6 = 12,
+  GxVA_TexCoord7 = 13,
+  GxVAs_Last = 14
+};
+
+enum EGxVertexBufferFormat {
+  GxVBF_P = 0,
+  GxVBF_PN = 1,
+  GxVBF_PNC = 2,
+  GxVBF_PNT = 3,
+  GxVBF_PNCT = 4,
+  GxVBF_PNT2 = 5,
+  GxVBF_PNCT2 = 6,
+  GxVBF_PC = 7,
+  GxVBF_PCT = 8,
+  GxVBF_PCT2 = 9,
+  GxVBF_PT = 10,
+  GxVBF_PT2 = 11,
+  GxVBF_PBNT2 = 12,
+  GxVBF_PNC2T2 = 13,
+  GxVertexBufferFormats_Last = 14
+};
+
+struct CGxVertexAttrib {
+  EGxVertexAttrib attrib;
+  uint32_t type;
+  uint32_t offset;
+  uint32_t bufSize;
+};
+
+struct CGxVertexPBNT2 {
+  C3Vector p;
+  ubyte4 bw;
+  ubyte4 bi;
+  C3Vector n;
+  C2Vector tc[2];
+};
+
+struct CGxVertexPCT {
+  C3Vector p;
+  CImVector c;
+  C2Vector tc[1];
+};
+
+STORM_TS_LIST(CGxBuf);
+STORM_TS_LIST(CGxPool);
+
+// class CGxPool : public TSLinkedNode<CGxPool>
+struct CGxPool {
+  TSLinkedNode_CGxPool b_base;
+  EGxPoolTarget m_target;
+  EGxPoolUsage m_usage;
+  int32_t m_size;
+  void* m_apiSpecific;
+  void* m_mem;
+  int32_t unk1C; // TODO
+  TSList_CGxBuf m_bufList;
+  EGxPoolHintBits m_hint;
+  const char* m_name;
+};
+
+// class CGxBuf : public TSLinkedNode<CGxBuf>
+struct CGxBuf {
+  TSLinkedNode_CGxBuf b_base;
+  CGxPool* m_pool;
+  uint32_t m_itemSize;
+  uint32_t m_itemCount;
+  uint32_t m_size;
+  uint32_t m_index;
+  uint8_t unk1C; // TODO
+  uint8_t unk1D; // TODO
+  uint8_t unk1E; // TODO
+  uint8_t unk1F; // TODO
+};
+
+#endif

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

@@ -0,0 +1,61 @@
+#ifndef GX_CAPS_H
+#define GX_CAPS_H
+
+#include "system/types.h"
+
+#include "gx/types.h"
+
+typedef struct CGxCaps CGxCaps;
+
+struct CGxCaps {
+  int32_t m_numTmus;
+  int32_t m_pixelCenterOnEdge;
+  int32_t m_texelCenterOnEdge;
+  int32_t m_numStreams;
+  int32_t int10;
+  EGxColorFormat m_colorFormat;
+  uint32_t unk18;
+  uint32_t m_maxIndex;
+  int32_t m_generateMipMaps;
+  // int32_t m_texFmt[GxTexFormats_Last];
+  int32_t m_texFmt[13];
+  // int32_t m_texTarget[GxTexTargets_Last];
+  int32_t m_texTarget[4];
+  uint32_t unk68;
+  // uint32_t m_texMaxSize[GxTexTargets_Last];
+  uint32_t m_texMaxSize[4];
+  uint32_t unk7C;
+  uint32_t unk80;
+  uint32_t unk84;
+  uint32_t unk88;
+  uint32_t unk8C;
+  uint32_t unk90;
+  uint32_t unk94;
+  uint32_t unk98;
+  uint32_t unk9C;
+  uint32_t unkA0;
+  uint32_t unkA4;
+  uint32_t unkA8;
+  int32_t hwPcf;
+  uint32_t unkB0;
+  // int32_t m_shaderTargets[GxShTargets_Last];
+  int32_t m_shaderTargets[6];
+  // Evidence for this: go to 0x00684CD8
+  uint32_t m_shaderConstants[6];
+  int32_t m_texFilterTrilinear;
+  int32_t m_texFilterAnisotropic;
+  uint32_t m_maxTexAnisotropy;
+  int32_t m_depthBias;
+  uint32_t unkF4;
+  int32_t m_maxClipPlanes;
+  // CGxDeviceD3d::ISetCaps
+  int32_t m_hardwareCursor;
+  uint32_t unk100[5];
+  uint32_t unk114[6];
+  int32_t m_stereoAvailable;
+  int32_t int130;
+  int32_t int134;
+  int32_t int138;
+};
+
+#endif

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

@@ -0,0 +1,59 @@
+#ifndef GX_D3D9_H
+#define GX_D3D9_H
+
+#include "gx/device.h"
+
+#include "external/d3d9/device.h"
+
+#include "storm/array.h"
+
+DECLARE_STRUCT(CGxDeviceD3d);
+DECLARE_STRUCT(CGxDeviceD3d__GxVertexDecl);
+
+struct CGxDeviceD3d__GxVertexDecl {
+  uint32_t m_unk00;
+};
+STORM_TS_GROWABLE_ARRAY(CGxDeviceD3d__GxVertexDecl);
+
+struct CGxDeviceD3d {
+  CGxDevice b_base;
+  void* m_hwnd;
+  uint16_t m_hwndClass;
+  uint16_t unk396E;
+  int32_t m_ownhwnd;
+  void* m_d3dLib;
+  IDirect3D9* m_d3d;
+  IDirect3DDevice9* m_d3dDevice;
+  D3DCAPS9 m_d3dCaps;
+  int32_t m_d3dIsHwDevice;
+  int32_t m_d3dNVAPI;
+  uint32_t unk3AB8;
+  uint32_t unk3ABC;
+  uint32_t m_d3dStereoHandle;
+  uint32_t unk3AC4[3]; //TSList?
+  TSGrowableArray_CGxDeviceD3d__GxVertexDecl m_vertexDecl;
+  IDirect3DVertexDeclaration9* m_d3dVertexDecl[14];
+  D3DDISPLAYMODE m_desktopDisplayMode;
+  int32_t m_inScene;
+  uint32_t unk3B2C;
+  D3DFORMAT m_devDepthFormat;
+  D3DFORMAT m_devAdapterFormat;
+  uint32_t unk3B38;
+  IDirect3DSurface9* m_defColorSurface;
+  IDirect3DSurface9* m_defDepthSurface;
+  uint32_t unk3B44;
+  uint32_t unk3B48;
+  int32_t m_hwCursorNeedsUpdate;
+  IDirect3DTexture9* m_hwCursorTexture;
+  IDirect3DSurface9* m_hwCursorBitmap;
+  uint32_t unk3B58;
+  IDirect3DVertexDeclaration9* m_d3dCurrentVertexDecl;
+  IDirect3DIndexBuffer9* m_d3dCurrentIndexBuf;
+  IDirect3DVertexBuffer9* m_d3dVertexStreamBuf[8];
+  uint32_t m_d3dVertexStreamOfs[8];
+  uint32_t m_d3dVertexStreamStride[8];
+  uint32_t m_deviceStates[182];
+  bool m_texEnabled[8];
+};
+
+#endif

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

@@ -0,0 +1,351 @@
+#ifndef GX_DEVICE_H
+#define GX_DEVICE_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+#include "storm/array/uint16_t.h"
+#include "storm/array/uint32_t.h"
+#include "storm/array/c2vector.h"
+#include "storm/array/c3vector.h"
+#include "storm/array/cimvector.h"
+
+#include "tempest/box.h"
+#include "tempest/matrix.h"
+#include "tempest/rect.h"
+#include "tempest/vector.h"
+
+#include "gx/types.h"
+#include "gx/caps.h"
+#include "gx/format.h"
+#include "gx/state_bom.h"
+#include "gx/shader.h"
+#include "gx/matrix_stack.h"
+#include "gx/buffer.h"
+#include "gx/texture.h"
+
+DECLARE_STRUCT(CGxAppRenderState);
+DECLARE_STRUCT(CGxPushedRenderState);
+DECLARE_STRUCT(ShaderConstants);
+DECLARE_STRUCT(CGxDevice);
+DECLARE_STRUCT(CGxDevice__vtable);
+
+typedef void (*DEVICERESTOREDCALLBACK)();
+STORM_TS_GROWABLE_ARRAY(DEVICERESTOREDCALLBACK);
+
+typedef void (*TEXTURERECREATIONCALLBACK)();
+STORM_TS_GROWABLE_ARRAY(TEXTURERECREATIONCALLBACK);
+
+typedef void (*STEREOCHANGEDCALLBACK)();
+STORM_TS_GROWABLE_ARRAY(STEREOCHANGEDCALLBACK);
+
+struct CGxAppRenderState {
+  CGxStateBom m_value;
+  uint32_t m_stackDepth;
+  int32_t m_dirty;
+};
+STORM_TS_FIXED_ARRAY(CGxAppRenderState);
+
+struct CGxPushedRenderState {
+  EGxRenderState m_which;
+  CGxStateBom m_value;
+  uint32_t m_stackDepth;
+};
+STORM_TS_GROWABLE_ARRAY(CGxPushedRenderState);
+
+struct ShaderConstants {
+  C4Vector constants[256];
+  uint32_t unk1;
+  uint32_t unk2;
+};
+
+// 84 functions
+struct CGxDevice__vtable {
+  // void ITexMarkAsUpdated(CGxTex* texId);
+  void* v_fn_0_ITexMarkAsUpdated;
+  // void IRsSendToHw(EGxRenderState rs);
+  // no base implementation
+  void* v_fn_1_IRsSendToHw;
+  // void ICursorCreate(const CGxFormat& format);
+  void* v_fn_2_ICursorCreate;
+  // void ICursorDestroy();
+  void* v_fn_3_ICursorDestroy;
+  // void ICursorDraw();
+  void* v_fn_4_ICursorDraw;
+  // This gets called when window is resized. It runs a list of callbacks in an array.
+  // two functions that are in this array (ONLY once in-game, not in login screen):
+  // * 007E7FE0
+  // * 00512920
+  // void NotifyOnDeviceRestored();
+  void* v_fn_5_NotifyOnDeviceRestored;
+  // void NotifyOnTextureRecreation();
+  void* v_fn_6_NotifyOnTextureRecreation;
+  // void NotifyOnDisplayChange();
+  void* v_fn_7_NotifyOnDisplayChange; 
+  // void `scalar deleting destructor'(uint32_t __flags)
+  void* v_fn_8_scalar_deleting_destructor;
+  // int32_t DeviceCreate(const CGxFormat& format);
+  void* v_fn_9_DeviceCreate;
+  // 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& format);
+  void* v_fn_13_DeviceSetFormat;
+  // void DeviceSetBaseMipLevel(uint32_t mipLevel);
+  void* v_fn_14_DeviceSetBaseMipLevel;
+  // void DeviceSetGamma(CGxGammaRamp const& ramp);
+  void* v_fn_15_DeviceSetGamma;
+  // 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& w, uint32_t& h, const CImVector*& pixels) */
+  void* v_fn_19_DeviceReadScreenShot;
+  // void DeviceReadPixels(CiRect& rect, TSGrowableArray<CImVector>& pixels);
+  void* v_fn_20_DeviceReadPixels;
+  // void DeviceReadDepths(CiRect& rect, TSGrowableArray<float>& depths);
+  void* v_fn_21_DeviceReadDepths;
+  // void DeviceWM(EGxWM wm, int32_t param1, int32_t param2);
+  void* v_fn_22_DeviceWM;
+  // 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 callback);
+  void* v_fn_29_AddDeviceRestoredCallback;
+  // int32_t RemoveDeviceRestoredCallback(DEVICERESTOREDCALLBACK callback);
+  void* v_fn_30_RemoveDeviceRestoredCallback;
+  // void AddTextureRecreationCallback(TEXTURERECREATIONCALLBACK callback);
+  void* v_fn_31_AddTextureRecreationCallback;
+  // int32_t RemoveTextureRecreationCallback(TEXTURERECREATIONCALLBACK callback);
+  void* v_fn_32_RemoveTextureRecreationCallback;
+  // 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& dst);
+  void* v_fn_36_CapsWindowSizeInScreenCoords;
+  // 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 mask, CImVector color);
+  void* v_fn_39_SceneClear;
+  // void XformSetProjection(const C44Matrix& matrix);
+  void* v_fn_40_XformSetProjection;
+  // void XformSetView(const C44Matrix& matrix);
+  void* v_fn_41_XformSetView;
+  // void Draw(CGxBatch*, int32_t);
+  void* v_fn_42_Draw;
+  // 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* pool, uint32_t size);
+  void* v_fn_52_PoolSizeSet;
+  // void PoolDestroy(CGxPool* pool);
+  void* v_fn_53_PoolDestroy;
+  // char* BufLock(CGxBuf* buf);
+  void* v_fn_54_BufLock;
+  // int32_t BufUnlock(CGxBuf* buf, uint32_t size);
+  void* v_fn_55_BufUnlock;
+  // void BufData(CGxBuf* buf, const void* data, uint32_t size, uint32_t offset); 
+  void* v_fn_56_BufData;
+  // 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* texId);
+  void* v_fn_58_TexDestroy;
+  // int32_t TexCopy(CGxTex* a1, CGxTex* a2, const C2iVector& a3, const C2iVector& a4, const C2iVector& a5, uint32_t a6);
+  void* v_fn_59_TexCopy;
+  // 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 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 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 visible);
+  void* v_fn_73_CursorSetVisible;
+  // uint32_t* CursorLock();
+  void* v_fn_74_CursorLock;
+  // void CursorUnlock(uint32_t x, uint32_t y);
+  void* v_fn_75_CursorUnlock;
+  // void StereoSetConvergence(float c);
+  void* v_fn_76_StereoSetConvergence;
+  // double StereoGetConvergence();
+  void* v_fn_77_StereoGetConvergence;
+  // 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* a1, char* a2);
+  void* v_fn_81_DebugGroupBegin;
+  // void DebugGroupEnd();
+  void* v_fn_82_DebugGroupEnd;
+  // void DebugEvent(const char* a1, char* a2);
+  void* v_fn_83_DebugEvent;
+};
+
+// 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)
+  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;
+  CImVector m_primColor;
+  TSGrowableArray_C3Vector m_primVertexArray;
+  TSGrowableArray_C2Vector m_primTexCoordArray[8];
+  TSGrowableArray_C3Vector m_primNormalArray;
+  TSGrowableArray_CImVector m_primColorArray;
+  TSGrowableArray_uint16_t m_primIndexArray;
+  uint32_t m_primMask;
+  CRect m_defWindowRect; // 0x164 (size: 0x10)
+  CRect m_curWindowRect; // 0x174 (size: 0x10)
+  TSGrowableArray_DEVICERESTOREDCALLBACK m_deviceRestoredCallbacks; // 0x184
+  TSGrowableArray_TEXTURERECREATIONCALLBACK m_textureRecreationCallbacks;
+  TSGrowableArray_STEREOCHANGEDCALLBACK m_stereoChangedCallbacks; // check darwin @ 00a2b779
+  EGxApi m_api; // 0x1b4
+  uint32_t m_cpuFeatures;
+  CGxFormat m_format;
+  CGxCaps m_caps;
+  uint32_t m_baseMipLevel;
+  CGxGammaRamp m_gammaRamp;
+  CGxGammaRamp m_systemGammaRamp;
+  // TSHashTable_CGxShader_HASHKEY_STRI m_shaderList[GxShTargets_Last];
+  // TSHashTable_CGxShader_HASHKEY_STRI m_shaderList[6];
+  int32_t (*m_windowProc)(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam);
+  int32_t m_context;
+  int32_t intF5C;
+  int32_t m_windowVisible;
+  int32_t intF64;
+  int32_t intF68;
+  // Invented name, though seems to have the same place as CGxDeviceD3d::m_d3dNeedsReset (Alpha) 
+  int32_t m_needsReset;
+  CBoundingBox m_viewport;
+  C44Matrix m_projection;
+  C44Matrix m_projNative;
+  // CGxMatrixStack m_xforms[GxXforms_Last];
+  CGxMatrixStack m_xforms[11];
+  CGxMatrixStack m_texGen[8];
+  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;
+  uint32_t unk276C[3];
+  // CGxBuf* m_bufLocked[GxPoolTargets_Last];
+  CGxBuf* m_bufLocked[2];
+  CGxPool* m_vertexPool;
+  CGxPool* m_indexPool;
+  // CGxBuf* m_streamBufs[GxPoolTargets_Last];
+  CGxBuf* m_streamBufs[2];
+  // CGxVertexAttrib m_primVertexFormatAttrib[GxVertexBufferFormats_Last];
+  CGxVertexAttrib m_primVertexFormatAttrib[14];
+  // CGxBuf* m_primVertexFormatBuf[GxVertexBufferFormats_Last];
+  CGxBuf* m_primVertexFormatBuf[14];
+  uint32_t m_primVertexMask;
+  uint32_t m_primVertexDirty;
+  EGxVertexBufferFormat m_primVertexFormat;
+  CGxBuf* m_primVertexBuf;
+  uint32_t m_primVertexSize;
+  CGxBuf* m_primIndexBuf;
+  int32_t m_primIndexDirty;
+  uint32_t unk28C4;
+  uint32_t unk28C8;
+  uint32_t unk28CC;
+  uint32_t unk28D0;
+  uint32_t unk28D4;
+  uint32_t unk28D8;
+  uint32_t unk28DC;
+  uint32_t unk28E0;
+  uint32_t unk28E4;
+  uint32_t unk28E8;
+  TSFixedArray_CGxAppRenderState m_appRenderStates;
+  TSFixedArray_CGxStateBom m_hwRenderStates;
+  uint32_t unk2904[19]; // 0x2904 (size 0x4C) 
+  int32_t m_cursorVisible;
+  int32_t m_hardwareCursor; // 0x2954 (size 0x4)
+  uint32_t m_cursorHotspotX;
+  uint32_t m_cursorHotspotY;
+  uint32_t m_cursor[1024]; // 0x2960 (size 0x4)
+  CGxTex* m_cursorTexture; // 0x3960 (size 0x4)
+  float m_cursorDepth; // 0x3964 (size 0x4)
+  // 0x3968 == 14692 (the complete size of CGxDevice)
+};
+
+#endif

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

@@ -0,0 +1,99 @@
+#ifndef GX_FONT_H
+#define GX_FONT_H
+
+#include "system/types.h"
+#include "tempest/rect.h"
+#include "storm/list.h"
+#include "storm/hash.h"
+#include "gx/string.h"
+
+DECLARE_HANDLE(HFACE);
+
+DECLARE_STRUCT(CGxFont);
+DECLARE_STRUCT(GLYPHBITMAPDATA);
+DECLARE_STRUCT(CHARCODEDESC);
+
+DECLARE_STRUCT(KERNNODE);
+DECLARE_STRUCT(KERNINGHASHKEY);
+
+DECLARE_STRUCT(TEXTURECACHE);
+DECLARE_STRUCT(TEXTURECACHEROW);
+
+STORM_TS_LIST(CGxFont);
+STORM_TS_LIST(CHARCODEDESC);
+
+STORM_TS_HASH(CHARCODEDESC, HASHKEY_NONE);
+
+struct GLYPHBITMAPDATA {
+  void* m_data;
+  uint32_t m_dataSize;
+  uint32_t m_glyphWidth;
+  uint32_t m_glyphHeight;
+  uint32_t m_glyphCellWidth;
+  float m_glyphAdvance;
+  float m_glyphBearing;
+  uint32_t m_glyphPitch;
+  int32_t m_yOffset;
+  int32_t m_yStart;
+  CRect m_textureCoords;
+};
+
+// struct CHARCODEDESC : TSHashObject<CHARCODEDESC,HASHKEY_NONE>
+struct CHARCODEDESC {
+  TSHashObject_CHARCODEDESC_HASHKEY_NONE b_base;
+  TSLink_CHARCODEDESC textureRowLink;
+  TSLink_CHARCODEDESC fontGlyphLink;
+  uint32_t textureNumber;
+  uint32_t rowNumber;
+  uint32_t glyphStartPixel;
+  uint32_t glyphEndPixel;
+  GLYPHBITMAPDATA bitmapData;
+};
+
+// 
+// struct KERNNODE : TSHashObject<KERNNODE,KERNINGHASHKEY>
+struct KERNNODE {
+  uint32_t flags;
+  float proporportionalSpacing;
+  float fixedWidthSpacing;
+};
+
+struct KERNINGHASHKEY {
+  uint32_t code;
+};
+
+struct TEXTURECACHEROW {
+  uint32_t widestFreeSlot;
+  TSExplicitList_CHARCODEDESC glyphList;
+};
+STORM_TS_FIXED_ARRAY(TEXTURECACHEROW);
+
+struct TEXTURECACHE {
+  void* m_texture;
+  CGxFont* m_theFace;
+  uint8_t m_anyDirtyGlyphs;
+  uint8_t pad[3];
+  TSFixedArray_TEXTURECACHEROW m_textureRows;
+};
+
+STORM_TS_HASH(KERNNODE, KERNINGHASHKEY);
+
+// struct CGxFont : TSLinkedNode<CGxFont>
+struct CGxFont {
+  TSLinkedNode_CGxFont b_base;
+  TSExplicitList_CGxString m_strings;
+  TSHashTable_CHARCODEDESC_HASHKEY_NONE m_activeCharacters;
+  TSHashTable_KERNNODE_KERNINGHASHKEY m_kernInfo;
+  TSExplicitList_CHARCODEDESC m_activeCharacterCache;
+  HFACE m_faceHandle;
+  char m_fontName[260];
+  uint32_t m_cellHeight;
+  uint32_t m_baseline;
+  uint32_t m_flags;
+  float float184;
+  float m_pixelsPerUnit;
+  TEXTURECACHE m_textureCache[8];
+  uint32_t m_pixelSize;
+};
+
+#endif

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

@@ -0,0 +1,50 @@
+#ifndef GX_FORMAT_H
+#define GX_FORMAT_H
+
+#include "system/types.h"
+
+#include "tempest/vector.h"
+
+DECLARE_ENUM(CGxFormat__Format);
+typedef struct CGxFormat CGxFormat;
+
+enum CGxFormat__Format {
+  Fmt_Rgb565 = 0,
+  Fmt_ArgbX888 = 1,
+  Fmt_Argb8888 = 2,
+  Fmt_Argb2101010 = 3,
+  Fmt_Ds160 = 4,
+  Fmt_Ds24X = 5,
+  Fmt_Ds248 = 6,
+  Fmt_Ds320 = 7,
+  Formats_Last = 8
+};
+
+struct CGxFormat {
+  uint32_t unk0;
+  bool hwTnL;
+  // TODO: verify this name 
+  bool hwCursor; // 0x5
+  int8_t fixLag;
+  int8_t window;
+  uint32_t unk8;
+  int32_t maximize;
+  CGxFormat__Format depthFormat;
+  C2iVector size;
+  uint32_t unk1C;
+  uint32_t sampleCount;
+  float float24;
+  CGxFormat__Format colorFormat;
+  uint32_t refreshRate;
+  uint32_t vsync;
+  uint32_t unk34;
+  uint32_t unk38;
+  uint32_t unk3C;
+  uint32_t unk40;
+  uint32_t unk44;
+  uint32_t unk48;
+  uint32_t unk4C;
+  C2iVector pos;
+};
+
+#endif

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

@@ -0,0 +1,21 @@
+#ifndef GX_LIGHT_H
+#define GX_LIGHT_H
+
+#include "tempest/vector.h"
+
+DECLARE_STRUCT(CGxLight);
+
+struct CGxLight {
+  // int32_t m_enabled : 1;
+  // int32_t m_isOmni : 1;
+  int32_t m_flags;
+  C3Vector m_dir;
+  C3Vector m_ambColor;
+  C3Vector m_dirColor;
+  C3Vector m_specColor;
+  float m_constantAttenuation;
+  float m_linearAttenuation;
+  float m_quadraticAttenuation;
+};
+
+#endif

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

@@ -0,0 +1,22 @@
+#ifndef GX_MATRIX_STACK_H
+#define GX_MATRIX_STACK_H
+
+#include "system/types.h"
+
+#include "tempest/matrix.h"
+
+DECLARE_ENUM(CGxMatrixStack__EMatrixFlags);
+DECLARE_STRUCT(CGxMatrixStack);
+
+enum CGxMatrixStack__EMatrixFlags {
+  F_Identity = 0x1
+};
+
+struct CGxMatrixStack {
+  uint32_t m_level;
+  int8_t m_dirty;
+  C44Matrix m_mtx[4];
+  uint32_t m_flags[4];
+};
+
+#endif

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

@@ -0,0 +1,32 @@
+#ifndef GX_SHADER_H
+#define GX_SHADER_H
+
+#include "storm/hash.h"
+#include "storm/array/uint8_t.h"
+
+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;
+  int32_t int28;
+  int32_t valid;
+  int32_t loaded;
+  int32_t int34;
+  int32_t patched;
+  int32_t int3C;
+  int32_t int40;
+  int16_t int44;
+  int16_t int46;
+  TSGrowableArray_uint8_t code;
+  // bool IsEnabled();
+};
+
+#endif
+

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

@@ -0,0 +1,21 @@
+#ifndef GX_STATE_BOM_H
+#define GX_STATE_BOM_H
+
+#include "system/types.h"
+#include "storm/array.h"
+
+DECLARE_STRUCT(CGxStateBom);
+
+struct CGxStateBom {
+  union {
+    int32_t i[3];
+    uint32_t u[3];
+    float f[3];
+    void* p;
+  } m_data;
+
+  int32_t filler;
+};
+STORM_TS_FIXED_ARRAY(CGxStateBom);
+
+#endif

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

@@ -0,0 +1,50 @@
+#ifndef GX_STRING_H
+#define GX_STRING_H
+
+#include "tempest/vector.h"
+
+DECLARE_STRUCT(CGxString);
+
+STORM_TS_LIST(CGxString);
+
+// struct CGxString : TSLinkedNode<CGxString>
+struct CGxString {
+  TSLinkedNode_CGxString b_base;
+  TSLink_CGxString m_fontStringLink;
+  TSLink_CGxString m_batchedStringLink;
+  float m_requestedFontHeight;
+  float m_currentFontHeight;
+  C3Vector m_position;
+  CImVector m_fontColor;
+  CImVector m_shadowColor;
+  C2Vector m_shadowOffset;
+  float m_blockWidth;
+  float m_blockHeight;
+  void* m_currentFace;
+  char* m_text;
+  int32_t m_textLen;
+  int32_t m_vertJust;
+  int32_t m_horzJust;
+  float m_spacing;
+  uint32_t m_flags;
+  uint32_t m_texturePagesUsed;
+  int32_t m_textureEvicted;
+  uint32_t m_lastGradientStart;
+  uint32_t m_lastGradientLength;
+  C3Vector m_viewTranslation;
+  float m_scale;
+  uint32_t m_hyperlinkInfo[4];
+  uint32_t dword90;
+  uint32_t dword94;
+  uint32_t dword98;
+  uint32_t dword9C;
+  uint32_t dwordA0;
+  uint32_t dwordA4;
+  uint32_t dwordA8;
+  uint32_t dwordAC;
+  int32_t m_intB0;
+  void* m_textLines[8];
+  int32_t m_intD4;
+};
+
+#endif

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

@@ -0,0 +1,30 @@
+#ifndef GX_STRING_BATCH_H
+#define GX_STRING_BATCH_H
+
+#include "storm/list.h"
+#include "storm/hash.h"
+#include "gx/font.h"
+
+DECLARE_STRUCT(CGxStringBatch);
+DECLARE_STRUCT(BATCHEDRENDERFONTDESC);
+
+STORM_TS_HASH(BATCHEDRENDERFONTDESC, HASHKEY_PTR);
+
+STORM_TS_LIST(CGxStringBatch);
+
+// struct BATCHEDRENDERFONTDESC : TSHashObject<BATCHEDRENDERFONTDESC, HASHKEY_PTR>
+struct BATCHEDRENDERFONTDESC {
+  TSHashObject_BATCHEDRENDERFONTDESC_HASHKEY_PTR b_base;
+  CGxFont* m_face;
+  // STORM_EXPLICIT_LIST(CGxString, m_batchedStringLink) m_strings;
+  TSExplicitList_CGxString m_strings;
+};
+
+// CGxStringBatch : TSLinkedNode<CGxStringBatch>
+struct CGxStringBatch {
+  TSLinkedNode_CGxStringBatch b_base;
+  TSHashTable_BATCHEDRENDERFONTDESC_HASHKEY_PTR m_fontBatch;
+  uint32_t m_flags;
+};
+
+#endif

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

@@ -0,0 +1,56 @@
+#ifndef GX_TEXTURE_H
+#define GX_TEXTURE_H
+
+#include "tempest/rect.h"
+#include "common/handle.h"
+
+#include "storm/array.h"
+
+typedef HOBJECT HTEXTURE;
+STORM_TS_GROWABLE_ARRAY(HTEXTURE);
+
+typedef struct CGxTexFlags CGxTexFlags;
+typedef struct CGxTex CGxTex;
+
+struct CGxTexFlags {
+  // unsigned __int32 m_filter : 3;
+  // unsigned __int32 m_wrapU : 1;
+  // unsigned __int32 m_wrapV : 1;
+  // unsigned __int32 m_forceMipTracking : 1;
+  // unsigned __int32 m_generateMipMaps : 1;
+  // unsigned __int32 m_renderTarget : 1;
+  // unsigned __int32 m_maxAnisotropy : 5;
+  uint32_t f_flags;
+};
+
+struct CGxTex {
+  CiRect m_updateRect;
+  int16_t m_updatePlaneMin;
+  int16_t m_updatePlaneMax;
+  uint32_t m_width;
+  uint32_t m_height;
+  uint32_t m_depth;
+  uint32_t m_target;
+  uint32_t m_format;
+  uint32_t m_dataFormat;
+  CGxTexFlags m_flags;
+  void* m_userArg;
+  void* m_userFunc;
+  void* m_apiSpecificData;
+  void* m_apiSpecificData2;
+  uint32_t unk40;
+  uint32_t unk44;
+  uint32_t unk48;
+  uint32_t unk4C;
+  uint32_t unk50;
+  uint32_t unk54;
+  int8_t char58;
+  int8_t char59;
+  int8_t m_needsUpdate;
+  int8_t m_needsCreation;
+  int8_t m_needsFlagUpdate;
+  int8_t char5D;
+  uint16_t m_pad;
+};
+
+#endif

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

@@ -0,0 +1,401 @@
+#ifndef GX_TYPES_H
+#define GX_TYPES_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+
+DECLARE_ENUM(BlitAlpha);
+DECLARE_ENUM(BlitFormat);
+DECLARE_ENUM(EGxApi);
+DECLARE_ENUM(EGxBlend);
+DECLARE_ENUM(EGxColorFormat);
+DECLARE_ENUM(EGxFontHJusts);
+DECLARE_ENUM(EGxFontVJusts);
+DECLARE_ENUM(EGxMasterEnables);
+DECLARE_ENUM(EGxPrim);
+DECLARE_ENUM(EGxPrimMask);
+DECLARE_ENUM(EGxRenderState);
+DECLARE_ENUM(EGxShPS);
+DECLARE_ENUM(EGxShTarget);
+DECLARE_ENUM(EGxShVS);
+DECLARE_ENUM(EGxTexCommand);
+DECLARE_ENUM(EGxTexFilter);
+DECLARE_ENUM(EGxTexFormat);
+DECLARE_ENUM(EGxTexTarget);
+DECLARE_ENUM(EGxTexWrapMode);
+DECLARE_ENUM(EGxXform);
+DECLARE_ENUM(EGxuDrawListCategory);
+DECLARE_ENUM(EGxWM);
+DECLARE_ENUM(COLOR_FILE_FORMAT);
+DECLARE_ENUM(PIXEL_FORMAT);
+
+DECLARE_STRUCT(C4Pixel);
+DECLARE_STRUCT(C4LargePixel);
+DECLARE_STRUCT(MipBits);
+DECLARE_STRUCT(CGxGammaRamp);
+
+enum BlitAlpha {
+  BlitAlpha_0 = 0,
+  BlitAlpha_1 = 1,
+  BlitAlpha_8 = 2,
+  BlitAlpha_Filler = 3,
+  BlitAlphas_Last = 4
+};
+
+enum BlitFormat {
+  BlitFormat_Unknown = 0,
+  BlitFormat_Abgr8888 = 1,
+  BlitFormat_Argb8888 = 2,
+  BlitFormat_Argb4444 = 3,
+  BlitFormat_Argb1555 = 4,
+  BlitFormat_Rgb565 = 5,
+  BlitFormat_Dxt1 = 6,
+  BlitFormat_Dxt3 = 7,
+  BlitFormat_Dxt5 = 8,
+  BlitFormat_Uv88 = 9,
+  BlitFormat_Gr1616F = 10,
+  BlitFormat_R32F = 11,
+  BlitFormat_D24X8 = 12,
+  BlitFormats_Last = 13
+};
+
+enum EGxApi {
+  GxApi_OpenGl = 0,
+  GxApi_D3d9 = 1,
+  GxApi_D3d9Ex = 2,
+  GxApi_D3d10 = 3,
+  GxApi_D3d11 = 4,
+  GxApi_GLL = 5,
+  GxApis_Last = 6
+};
+
+enum EGxBlend {
+  GxBlend_Opaque = 0,
+  GxBlend_AlphaKey = 1,
+  GxBlend_Alpha = 2,
+  GxBlend_Add = 3,
+  GxBlend_Mod = 4,
+  GxBlend_Mod2x = 5,
+  GxBlend_ModAdd = 6,
+  GxBlend_InvSrcAlphaAdd = 7,
+  GxBlend_InvSrcAlphaOpaque = 8,
+  GxBlend_SrcAlphaOpaque = 9,
+  GxBlend_NoAlphaAdd = 10,
+  GxBlend_ConstantAlpha = 11,
+  GxBlends_Last = 12
+};
+
+enum EGxColorFormat {
+  GxCF_argb = 0,
+  GxCF_rgba = 1,
+  GxColorFormats_Last = 2,
+};
+
+enum EGxFontHJusts {
+  GxHJ_Left = 0,
+  GxHJ_Center = 1,
+  GxHJ_Right = 2,
+  GxHJ_Last = 3
+};
+
+enum EGxFontVJusts {
+  GxVJ_Top = 0,
+  GxVJ_Middle = 1,
+  GxVJ_Bottom = 2,
+  GxVJ_Last = 3
+};
+
+enum EGxMasterEnables {
+  GxMasterEnable_Lighting = 0,
+  GxMasterEnable_Fog = 1,
+  GxMasterEnable_DepthTest = 2,
+  GxMasterEnable_DepthWrite = 3,
+  GxMasterEnable_ColorWrite = 4,
+  GxMasterEnable_Culling = 5,
+  GxMasterEnable_DoubleBuffering = 6,
+  GxMasterEnable_NormalProjection = 7,
+  GxMasterEnable_PolygonFill = 8,
+  GxMasterEnables_Last = 9
+};
+
+enum EGxPrim {
+  GxPrim_Points = 0,
+  GxPrim_Lines = 1,
+  GxPrim_LineStrip = 2,
+  GxPrim_Triangles = 3,
+  GxPrim_TriangleStrip = 4,
+  GxPrim_TriangleFan = 5,
+  GxPrims_Last = 6
+};
+
+enum EGxPrimMask {
+  GxPrim_Position = 0x1,
+  GxPrim_BlendWeight = 0x2,
+  GxPrim_BlendIndices = 0x4,
+  GxPrim_Normal = 0x8,
+  GxPrim_Color0 = 0x10,
+  GxPrim_Color1 = 0x20,
+  GxPrim_TexCoord0 = 0x40,
+  GxPrim_TexCoord1 = 0x80
+};
+
+enum EGxRenderState {
+  GxRs_PolygonOffset = 0,
+  GxRs_MatDiffuse = 1,
+  GxRs_MatEmissive = 2,
+  GxRs_MatSpecular = 3,
+  GxRs_MatSpecularExp = 4,
+  GxRs_NormalizeNormals = 5,
+  GxRs_BlendingMode = 6,
+  GxRs_AlphaRef = 7,
+  GxRs_FogStart = 8,
+  GxRs_FogEnd = 9,
+  GxRs_FogColor = 10,
+  GxRs_Lighting = 11,
+  GxRs_Fog = 12,
+  GxRs_DepthTest = 13,
+  GxRs_DepthFunc = 14,
+  GxRs_DepthWrite = 15,
+  GxRs_ColorWrite = 16,
+  GxRs_Culling = 17,
+  GxRs_ClipPlaneMask = 18,
+  GxRs_Multisample = 19,
+  GxRs_ScissorTest = 20,
+  GxRs_Texture0 = 21,
+  GxRs_Texture1 = 22,
+  GxRs_Texture2 = 23,
+  GxRs_Texture3 = 24,
+  GxRs_Texture4 = 25,
+  GxRs_Texture5 = 26,
+  GxRs_Texture6 = 27,
+  GxRs_Texture7 = 28,
+  GxRs_Texture8 = 29,
+  GxRs_Texture9 = 30,
+  GxRs_Texture10 = 31,
+  GxRs_Texture11 = 32,
+  GxRs_Texture12 = 33,
+  GxRs_Texture13 = 34,
+  GxRs_Texture14 = 35,
+  GxRs_Texture15 = 36,
+  GxRs_ColorOp0 = 37,
+  GxRs_ColorOp1 = 38,
+  GxRs_ColorOp2 = 39,
+  GxRs_ColorOp3 = 40,
+  GxRs_ColorOp4 = 41,
+  GxRs_ColorOp5 = 42,
+  GxRs_ColorOp6 = 43,
+  GxRs_ColorOp7 = 44,
+  GxRs_AlphaOp0 = 45,
+  GxRs_AlphaOp1 = 46,
+  GxRs_AlphaOp2 = 47,
+  GxRs_AlphaOp3 = 48,
+  GxRs_AlphaOp4 = 49,
+  GxRs_AlphaOp5 = 50,
+  GxRs_AlphaOp6 = 51,
+  GxRs_AlphaOp7 = 52,
+  GxRs_TexGen0 = 53,
+  GxRs_TexGen1 = 54,
+  GxRs_TexGen2 = 55,
+  GxRs_TexGen3 = 56,
+  GxRs_TexGen4 = 57,
+  GxRs_TexGen5 = 58,
+  GxRs_TexGen6 = 59,
+  GxRs_TexGen7 = 60,
+  GxRs_Unk61 = 61,
+  GxRs_Unk62 = 62,
+  GxRs_Unk63 = 63,
+  GxRs_Unk64 = 64,
+  GxRs_Unk65 = 65,
+  GxRs_Unk66 = 66,
+  GxRs_Unk67 = 67,
+  GxRs_Unk68 = 68,
+  GxRs_Unk69 = 69,
+  GxRs_Unk70 = 70,
+  GxRs_Unk71 = 71,
+  GxRs_Unk72 = 72,
+  GxRs_Unk73 = 73,
+  GxRs_Unk74 = 74,
+  GxRs_Unk75 = 75,
+  GxRs_Unk76 = 76,
+  GxRs_VertexShader = 77,
+  GxRs_PixelShader = 78,
+  GxRs_PointScale = 79,
+  GxRs_PointScaleAttenuation = 80,
+  GxRs_PointScaleMin = 81,
+  GxRs_PointScaleMax = 82,
+  GxRs_PointSprite = 83,
+  GxRs_Unk84 = 84,
+  GxRs_ColorMaterial = 85,
+  GxRenderStates_Last = 86
+};
+STORM_TS_GROWABLE_ARRAY(EGxRenderState);
+
+enum EGxShPS {
+  GxShPS_none = 0,
+  GxShPS_ps_1_1 = 1,
+  GxShPS_ps_1_4 = 2,
+  GxShPS_ps_2_0 = 3,
+  GxShPS_ps_3_0 = 4,
+  GxShPS_ps_4_0 = 5,
+  GxShPS_ps_5_0 = 6,
+  GxShPS_nvrc = 7,
+  GxShPS_nvts = 8,
+  GxShPS_nvts2 = 9,
+  GxShPS_nvts3 = 10,
+  GxShPS_nvfp2 = 11,
+  GxShPS_arbfp1 = 12,
+  GxShPS_glsl = 13,
+};
+
+enum EGxShTarget {
+  GxSh_Vertex = 0,
+  GxSh_Hull = 1,
+  GxSh_Domain = 2,
+  GxSh_Geometry = 3,
+  GxSh_Pixel = 4,
+  GxSh_Compute = 5,
+  GxShTargets_Last = 6
+};
+
+enum EGxShVS {
+  GxShVS_none = 0,
+  GxShVS_vs_1_1 = 1,
+  GxShVS_vs_2_0 = 2,
+  GxShVS_vs_3_0 = 3,
+  GxShVS_vs_4_0 = 4,
+  GxShVS_vs_5_0 = 5,
+  GxShVS_arbvp1 = 6,
+  GxShVS_arbvp1_cg12 = 7,
+  GxShVS_nvvp = 8,
+  GxShVS_nvvp2 = 9,
+  GxShVS_nvvp3 = 10,
+  GxShVS_glsl = 11
+};
+
+enum EGxTexCommand {
+  GxTex_Lock = 0,
+  GxTex_Latch = 1,
+  GxTex_Unlock = 2,
+  GxTexCommands_Last = 3
+};
+
+enum EGxTexFilter {
+  GxTex_Nearest = 0x0,
+  GxTex_Linear = 0x1,
+  GxTex_NearestMipNearest = 0x2,
+  GxTex_LinearMipNearest = 0x3,
+  GxTex_LinearMipLinear = 0x4,
+  GxTex_Anisotropic = 0x5,
+  GxTexFilters_Last = 0x6,
+};
+
+enum EGxTexFormat {
+  GxTex_Unknown = 0x0,
+  GxTex_Abgr8888 = 0x1,
+  GxTex_Argb8888 = 0x2,
+  GxTex_Argb4444 = 0x3,
+  GxTex_Argb1555 = 0x4,
+  GxTex_Rgb565 = 0x5,
+  GxTex_Dxt1 = 0x6,
+  GxTex_Dxt3 = 0x7,
+  GxTex_Dxt5 = 0x8,
+  GxTex_Uv88 = 0x9,
+  GxTex_Gr1616F = 0xA,
+  GxTex_R32F = 0xB,
+  GxTex_D24X8 = 0xC,
+  GxTexFormats_Last = 0xD,
+};
+
+enum EGxTexTarget {
+  GxTex_2d = 0x0,
+  GxTex_CubeMap = 0x1,
+  GxTex_Rectangle = 0x2,
+  GxTex_NonPow2 = 0x3,
+  GxTexTargets_Last = 0x4
+};
+
+enum EGxTexWrapMode {
+  GxTex_Clamp = 0,
+  GxTex_Wrap = 1
+};
+
+enum EGxQueryType {
+  GxQueryType_Occlusion = 0,
+};
+
+enum EGxXform {
+  GxXform_Tex0 = 0,
+  GxXform_Tex1 = 1,
+  GxXform_Tex2 = 2,
+  GxXform_Tex3 = 3,
+  GxXform_Tex4 = 4,
+  GxXform_Tex5 = 5,
+  GxXform_Tex6 = 6,
+  GxXform_Tex7 = 7,
+  GxXform_World = 8,
+  GxXform_Projection = 9,
+  GxXform_View = 10,
+  GxXforms_Last = 11
+};
+
+enum EGxuDrawListCategory {
+  GxuCat_0 = 0,
+  GxuCat_1 = 1,
+  GxuCat_2 = 2
+};
+
+enum EGxWM {
+  GxWM_Size = 0,
+  GxWM_DisplayChange = 1,
+  GxWM_Destroy = 2,
+  GxWM_SetFocus = 3,
+  GxWM_KillFocus = 4,
+};
+
+enum COLOR_FILE_FORMAT {
+  COLOR_JPEG = 0,
+  COLOR_PAL = 1,
+  COLOR_DXT = 2,
+  COLOR_3 = 3
+};
+
+enum PIXEL_FORMAT {
+  PIXEL_DXT1 = 0x0,
+  PIXEL_DXT3 = 0x1,
+  PIXEL_ARGB8888 = 0x2,
+  PIXEL_ARGB1555 = 0x3,
+  PIXEL_ARGB4444 = 0x4,
+  PIXEL_RGB565 = 0x5,
+  PIXEL_A8 = 0x6,
+  PIXEL_DXT5 = 0x7,
+  PIXEL_UNSPECIFIED = 0x8,
+  PIXEL_ARGB2565 = 0x9,
+  NUM_PIXEL_FORMATS = 0xA
+};
+
+struct C4Pixel {
+  uint8_t b;
+  uint8_t g;
+  uint8_t r;
+  uint8_t a;
+};
+
+struct C4LargePixel {
+  uint64_t b;
+  uint64_t g;
+  uint64_t r;
+  uint64_t a;
+};
+
+struct MipBits {
+  C4Pixel* mip[1];
+};
+
+struct CGxGammaRamp {
+  uint16_t red[256];
+  uint16_t green[256];
+  uint16_t blue[256];
+};
+
+#endif