refactor(profile): profiles are now stored in profile/ subdirectory

profile/3.3.5a-windows/include/common/datarecycler.h

@@ -0,0 +1,39 @@
+#ifndef COMMON_DATA_RECYCLER_H
+#define COMMON_DATA_RECYCLER_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(CDataRecycler);
+DECLARE_STRUCT(CDataRecycler__vtable);
+DECLARE_STRUCT(CDataRecycler__NodeBlock);
+DECLARE_STRUCT(CDataRecycler__Node);
+
+struct CDataRecycler__vtable {
+  void* v_fn_00;
+  void* v_fn_01;
+  void* v_fn_02;
+  void* v_fn_03;
+  void* v_fn_04;
+};
+
+struct CDataRecycler__Node {
+  CDataRecycler__Node* m_next;
+  void* m_data;
+  uint32_t m_bytes;
+};
+
+struct CDataRecycler__NodeBlock {
+  CDataRecycler__NodeBlock* m_next;
+  CDataRecycler__Node m_nodes[1];
+};
+
+struct CDataRecycler {
+  CDataRecycler__vtable* v_vtable;
+  int32_t m_nodesRecyclable;
+  uint32_t m_nodesPerBlock;
+  CDataRecycler__NodeBlock* m_nodeBlockList;
+  CDataRecycler__Node* m_nodeFullList;
+  CDataRecycler__Node* m_nodeEmptyList;
+};
+
+#endif

profile/3.3.5a-windows/include/common/handle.h

@@ -0,0 +1,13 @@
+#ifndef COMMON_HANDLE_H
+#define COMMON_HANDLE_H
+
+#include "system/types.h"
+
+#if !defined(DECLARE_HANDLE)
+#define DECLARE_HANDLE(name) \
+typedef struct name##__ { \
+    int32_t unused; \
+}* name
+#endif
+
+#endif

profile/3.3.5a-windows/include/common/instance.h

@@ -0,0 +1,43 @@
+#ifndef COMMON_INSTANCE_H
+#define COMMON_INSTANCE_H
+
+#include "system/types.h"
+
+#include "storm/list.h"
+#include "storm/thread.h"
+
+// TSList<T>
+// TSLinkedNode<T>
+// TInstanceId<T>
+// TSingletonInstanceId<T>
+#define COMMON_INSTANCE_ID(T) \
+STORM_TS_LIST(T) \
+typedef struct TInstanceId_##T TInstanceId_##T; \
+typedef struct TSingletonInstanceId_##T TSingletonInstanceId_##T; \
+struct TInstanceId_##T { \
+  TSLinkedNode_##T b_base; \
+  uint32_t m_id; \
+}; \
+struct TSingletonInstanceId_##T { \
+  TInstanceId_##T b_base; \
+}; 
+
+#define COMMON_INSTANCE_ID_TABLE(T) \
+STORM_TS_LIST(T) \
+typedef struct TInstanceIdTable_##T TInstanceIdTable_##T; \
+struct TInstanceIdTable_##T { \
+  SCritSect m_idCritSect; \
+  uint32_t m_id; \
+  int32_t m_idWrapped; \
+  CSRWLock m_idLock[8]; \
+  TSList_##T m_idList[8]; \
+};
+
+// template <class T>
+// class TExtraInstanceRecyclable
+typedef struct TExtraInstanceRecyclable TExtraInstanceRecyclable;
+struct TExtraInstanceRecyclable {
+  uint32_t m_recycleBytes;
+};
+
+#endif

profile/3.3.5a-windows/include/common/status.h

@@ -0,0 +1,36 @@
+#ifndef COMMON_STATUS_H
+#define COMMON_STATUS_H
+
+#include "storm/list.h"
+
+DECLARE_ENUM(STATUS_TYPE);
+DECLARE_STRUCT(CStatus);
+DECLARE_STRUCT(CStatus__STATUSENTRY);
+
+enum STATUS_TYPE {
+  STATUS_INFO = 0x0,
+  STATUS_WARNING = 0x1,
+  STATUS_ERROR = 0x2,
+  STATUS_FATAL = 0x3,
+  STATUS_NUMTYPES = 0x4
+};
+
+STORM_TS_LIST(CStatus__STATUSENTRY);
+
+struct CStatus__STATUSENTRY {
+  char* text;
+  STATUS_TYPE severity;
+  TSLink_CStatus__STATUSENTRY link;
+};
+
+struct CStatus {
+  TSExplicitList_CStatus__STATUSENTRY statusList;
+};
+
+// class CWOWClientStatus : public CStatus {
+//     public:
+//         HSLOG m_logFile = nullptr;
+// };
+
+
+#endif

profile/3.3.5a-windows/include/cursor/types.h

@@ -0,0 +1,69 @@
+#ifndef CURSOR_TYPES_H
+#define CURSOR_TYPES_H
+
+enum CURSORITEMTYPE {
+  CURSOR_EMPTY = 0,
+  CURSOR_ITEM = 1,
+  CURSOR_MONEY = 2,
+  CURSOR_SPELL = 3,
+  NUM_CURSOR_ITEM_TYPES = 4
+};
+
+enum CURSORMODE {
+  NO_CURSOR = 0,
+  POINT_CURSOR = 1,
+  CAST_CURSOR = 2,
+  BUY_CURSOR = 3,
+  ATTACK_CURSOR = 4,
+  INTERACT_CURSOR = 5,
+  SPEAK_CURSOR = 6,
+  INSPECT_CURSOR = 7,
+  PICKUP_CURSOR = 8,
+  TAXI_CURSOR = 9,
+  TRAINER_CURSOR = 10,
+  MINE_CURSOR = 11,
+  SKIN_CURSOR = 12,
+  GATHER_CURSOR = 13,
+  LOCK_CURSOR = 14,
+  MAIL_CURSOR = 15,
+  LOOT_ALL_CURSOR = 16,
+  REPAIR_CURSOR = 17,
+  REPAIRNPC_CURSOR = 18,
+  ITEM_CURSOR = 19,
+  SKIN_HORDE_CURSOR = 20,
+  SKIN_ALLIANCE_CURSOR = 21,
+  INNKEEPER_CURSOR = 22,
+  QUEST_CURSOR = 23,
+  QUEST_REPEATABLE_CURSOR = 24,
+  QUEST_TURNIN_CURSOR = 25,
+  VEHICLE_CURSOR = 26,
+  POINT_ERROR_CURSOR = 27,
+  CAST_ERROR_CURSOR = 28,
+  BUY_ERROR_CURSOR = 29,
+  ATTACK_ERROR_CURSOR = 30,
+  INTERACT_ERROR_CURSOR = 31,
+  SPEAK_ERROR_CURSOR = 32,
+  INSPECT_ERROR_CURSOR = 33,
+  PICKUP_ERROR_CURSOR = 34,
+  TAXI_ERROR_CURSOR = 35,
+  TRAINER_ERROR_CURSOR = 36,
+  MINE_ERROR_CURSOR = 37,
+  SKIN_ERROR_CURSOR = 38,
+  GATHER_ERROR_CURSOR = 39,
+  LOCK_ERROR_CURSOR = 40,
+  MAIL_ERROR_CURSOR = 41,
+  LOOT_ALL_ERROR_CURSOR = 42,
+  REPAIR_ERROR_CURSOR = 43,
+  REPAIRNPC_ERROR_CURSOR = 44,
+  ITEM_ERROR_CURSOR = 45,
+  SKIN_HORDE_ERROR_CURSOR = 46,
+  SKIN_ALLIANCE_ERROR_CURSOR = 47,
+  INNKEEPER_ERROR_CURSOR = 48,
+  QUEST_ERROR_CURSOR = 49,
+  QUEST_REPEATABLE_ERROR_CURSOR = 50,
+  QUEST_TURNIN_ERROR_CURSOR = 51,
+  VEHICLE_ERROR_CURSOR = 52,
+  NUM_CURSOR_MODES = 53
+};
+
+#endif

profile/3.3.5a-windows/include/d3d9/caps.h

@@ -0,0 +1,125 @@
+#ifndef D3D9_CAPS_H
+#define D3D9_CAPS_H
+
+#include "system/types.h"
+
+typedef enum D3DDEVTYPE D3DDEVTYPE;
+typedef struct D3DVSHADERCAPS2_0 D3DVSHADERCAPS2_0;
+typedef struct D3DPSHADERCAPS2_0 D3DPSHADERCAPS2_0;
+typedef struct D3DCAPS9 D3DCAPS9;
+
+enum D3DDEVTYPE {
+  D3DDEVTYPE_HAL = 1,
+  D3DDEVTYPE_REF = 2,
+  D3DDEVTYPE_SW = 3,
+  D3DDEVTYPE_NULLREF = 4,
+
+  D3DDEVTYPE_FORCE_uint32_t = 0xffffffff
+};
+
+struct D3DVSHADERCAPS2_0 {
+  uint32_t Caps;
+  int32_t DynamicFlowControlDepth;
+  int32_t NumTemps;
+  int32_t StaticFlowControlDepth;
+};
+
+struct D3DPSHADERCAPS2_0 {
+  uint32_t Caps;
+  int32_t DynamicFlowControlDepth;
+  int32_t NumTemps;
+  int32_t StaticFlowControlDepth;
+  int32_t NumInstructionSlots;
+};
+
+struct D3DCAPS9 {
+  D3DDEVTYPE DeviceType;
+  uint32_t AdapterOrdinal;
+
+  uint32_t Caps;
+  uint32_t Caps2;
+  uint32_t Caps3;
+  uint32_t PresentationIntervals;
+
+  uint32_t CursorCaps;
+
+  uint32_t DevCaps;
+
+  uint32_t PrimitiveMiscCaps;
+  uint32_t RasterCaps;
+  uint32_t ZCmpCaps;
+  uint32_t SrcBlendCaps;
+  uint32_t DestBlendCaps;
+  uint32_t AlphaCmpCaps;
+  uint32_t ShadeCaps;
+  uint32_t TextureCaps;
+  uint32_t TextureFilterCaps;
+  uint32_t CubeTextureFilterCaps;
+  uint32_t VolumeTextureFilterCaps;
+  uint32_t TextureAddressCaps;
+  uint32_t VolumeTextureAddressCaps;
+
+  uint32_t LineCaps;
+
+  uint32_t MaxTextureWidth, MaxTextureHeight;
+  uint32_t MaxVolumeExtent;
+
+  uint32_t MaxTextureRepeat;
+  uint32_t MaxTextureAspectRatio;
+  uint32_t MaxAnisotropy;
+  float MaxVertexW;
+
+  float GuardBandLeft;
+  float GuardBandTop;
+  float GuardBandRight;
+  float GuardBandBottom;
+
+  float ExtentsAdjust;
+  uint32_t StencilCaps;
+
+  uint32_t FVFCaps;
+  uint32_t TextureOpCaps;
+  uint32_t MaxTextureBlendStages;
+  uint32_t MaxSimultaneousTextures;
+
+  uint32_t VertexProcessingCaps;
+  uint32_t MaxActiveLights;
+  uint32_t MaxUserClipPlanes;
+  uint32_t MaxVertexBlendMatrices;
+  uint32_t MaxVertexBlendMatrixIndex;
+
+  float MaxPointSize;
+
+  uint32_t MaxPrimitiveCount;
+  uint32_t MaxVertexIndex;
+  uint32_t MaxStreams;
+  uint32_t MaxStreamStride;
+
+  uint32_t VertexShaderVersion;
+  uint32_t MaxVertexShaderConst;
+
+  uint32_t PixelShaderVersion;
+  float PixelShader1xMaxValue;
+
+  /* DX 9 */
+  uint32_t DevCaps2;
+
+  float MaxNpatchTessellationLevel;
+  uint32_t Reserved5;
+
+  uint32_t MasterAdapterOrdinal;
+  uint32_t AdapterOrdinalInGroup;
+  uint32_t NumberOfAdaptersInGroup;
+  uint32_t DeclTypes;
+  uint32_t NumSimultaneousRTs;
+  uint32_t StretchRectFilterCaps;
+  D3DVSHADERCAPS2_0 VS20Caps;
+  D3DPSHADERCAPS2_0 PS20Caps;
+  uint32_t VertexTextureFilterCaps;
+  uint32_t MaxVShaderInstructionsExecuted;
+  uint32_t MaxPShaderInstructionsExecuted;
+  uint32_t MaxVertexShader30InstructionSlots;
+  uint32_t MaxPixelShader30InstructionSlots;
+};
+
+#endif

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

@@ -0,0 +1,60 @@
+#ifndef D3D9_DEVICE_H
+#define D3D9_DEVICE_H
+
+#include "system/types.h"
+
+#include "d3d9/caps.h"
+
+typedef int32_t D3DFORMAT;
+typedef struct D3DDISPLAYMODE D3DDISPLAYMODE;
+typedef struct IDirect3D9 IDirect3D9;
+typedef struct IDirect3DDevice9 IDirect3DDevice9;
+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;
+
+struct D3DDISPLAYMODE {
+  uint32_t Width;
+  uint32_t Height;
+  uint32_t RefreshRate;
+  D3DFORMAT Format;
+};
+
+struct IDirect3D9 {
+  void** v_vtable;
+};
+
+struct IDirect3DDevice9 {
+  void** v_vtable;
+};
+
+struct IDirect3DVertexDeclaration9 {
+  void** v_vtable;
+};
+
+struct IDirect3DSurface9 {
+  void** v_vtable;
+};
+
+struct IDirect3DIndexBuffer9 {
+  void** v_vtable;
+};
+
+struct IDirect3DVertexBuffer9 {
+  void** v_vtable;
+};
+
+struct IDirect3DTexture9 {
+  void** v_vtable;
+};
+
+struct D3DLOCKED_RECT {
+  int32_t Pitch;
+  void* pBits;
+};
+
+#endif

profile/3.3.5a-windows/include/event/context.h

@@ -0,0 +1,66 @@
+#ifndef EVENT_CONTEXT_H
+#define EVENT_CONTEXT_H
+
+#include "storm/thread.h"
+
+#include "common/instance.h"
+#include "storm/queue/timer_priority_uint32_t.h"
+
+#include "event/message.h"
+#include "event/handler.h"
+#include "event/keydown.h"
+#include "event/types.h"
+#include "event/timer.h"
+#include "event/id_table.h"
+
+DECLARE_ENUM(SCHEDSTATE);
+DECLARE_STRUCT(EvtContext);
+DECLARE_STRUCT(EvtTimer);
+DECLARE_HANDLE(HPROPCONTEXT);
+
+// EvtContext::SCHEDSTATE
+enum SCHEDSTATE {
+  SCHEDSTATE_ACTIVE = 0x0,
+  SCHEDSTATE_CLOSED = 0x1,
+  SCHEDSTATE_DESTROYED = 0x2,
+  _UNIQUE_SYMBOL_SCHEDSTATE_96 = 0xFFFFFFFF
+};
+
+COMMON_INSTANCE_ID(EvtContext);
+
+// class EvtContext : public TSingletonInstanceId<EvtContext, offsetof(TInstanceId<EvtContext>, m_id)> 
+struct EvtContext {
+  TSingletonInstanceId_EvtContext b_base;
+  uint32_t unkA;
+  // Member variables
+  SCritSect m_critsect;
+  uint32_t m_currTime;
+  SCHEDSTATE m_schedState;
+  TSTimerPriority_uint32_t m_schedNextWakeTime;
+  uint32_t m_schedLastIdle;
+  uint32_t m_schedFlags;
+  uint32_t m_schedIdleTime;
+  uint32_t m_schedInitialIdleTime;
+  uint32_t m_schedWeight;
+  uint32_t m_schedSmoothWeight;
+  int32_t m_schedRebalance;
+  int32_t unkXX;
+  int32_t unkXY;
+  int32_t unkXZ;
+  int32_t unkYY;
+  int32_t unkYZ;
+  // TSExplicitList<EvtHandler, offsetof(EvtHandler, link)> m_queueHandlerList[EVENTIDS];
+  TSExplicitList_EvtHandler m_queueHandlerList[36];
+  // TSExplicitList<EvtMessage, offsetof(EvtMessage, link)> m_queueMessageList;
+  TSExplicitList_EvtMessage m_queueMessageList;
+  uint32_t m_queueSyncButtonState;
+  // TSExplicitList<EvtKeyDown, offsetof(EvtKeyDown, link)> m_queueSyncKeyDownList;
+  TSExplicitList_EvtKeyDown m_queueSyncKeyDownList;
+  EvtIdTable_pointer_to_EvtTimer m_timerIdTable;
+  EvtTimerQueue m_timerQueue;
+  HPROPCONTEXT m_propContext;
+  void* m_callContext;
+  uint32_t m_startWatchdog;
+};
+
+#endif

profile/3.3.5a-windows/include/event/handler.h

@@ -0,0 +1,20 @@
+#ifndef EVENT_HANDLER_H
+#define EVENT_HANDLER_H
+
+#include "system/types.h"
+
+#include "storm/list.h"
+
+DECLARE_STRUCT(EvtHandler);
+
+STORM_TS_LIST(EvtHandler);
+
+struct EvtHandler {
+  TSLink_EvtHandler link;
+  int32_t (*func)(const void*, void*);
+  void* param;
+  float priority;
+  int32_t marker;
+};
+
+#endif

profile/3.3.5a-windows/include/event/id_table.h

@@ -0,0 +1,15 @@
+#ifndef EVENT_ID_TABLE_H
+#define EVENT_ID_TABLE_H
+
+#include "storm/array.h"
+#include "storm/array/uint32_t.h"
+#include "event/timer.h"
+
+DECLARE_STRUCT(EvtIdTable_pointer_to_EvtTimer);
+
+struct EvtIdTable_pointer_to_EvtTimer {
+  TSGrowableArray_pointer_to_EvtTimer m_allocArray;
+  TSGrowableArray_uint32_t m_freeArray;
+};
+
+#endif

profile/3.3.5a-windows/include/event/keydown.h

@@ -0,0 +1,16 @@
+#ifndef EVENT_KEY_DOWN_H
+#define EVENT_KEY_DOWN_H
+
+#include "storm/list.h"
+#include "event/types.h"
+
+typedef struct EvtKeyDown EvtKeyDown;
+
+STORM_TS_LIST(EvtKeyDown);
+
+struct EvtKeyDown {
+  TSLink_EvtKeyDown link;
+  KEY key;
+};
+
+#endif

profile/3.3.5a-windows/include/event/message.h

@@ -0,0 +1,23 @@
+#ifndef EVENT_MESSAGE_H
+#define EVENT_MESSAGE_H
+
+#include "system/types.h"
+
+#include "common/instance.h"
+#include "storm/list.h"
+
+#include "event/types.h"
+
+typedef struct EvtMessage EvtMessage;
+
+STORM_TS_LIST(EvtMessage);
+
+// class EvtMessage : public TExtraInstanceRecyclable<EvtMessage>
+struct EvtMessage {
+  TExtraInstanceRecyclable b_base;
+  TSLink_EvtMessage link;
+  EVENTID id;
+  char data[4];
+};
+
+#endif

profile/3.3.5a-windows/include/event/timer.h

@@ -0,0 +1,32 @@
+#ifndef EVENT_TIMER_H
+#define EVENT_TIMER_H
+
+#include "system/types.h"
+
+#include "storm/queue/timer_priority_uint32_t.h"
+
+DECLARE_STRUCT(EvtTimer);
+DECLARE_STRUCT(EvtTimerQueue);
+
+// class EvtTimer 
+struct EvtTimer {
+  // Member variables
+  uint32_t id;
+  TSTimerPriority_uint32_t targetTime;
+  float timeout;
+  int32_t (*handler)(const void*, void*);
+  void* param;
+  int32_t (*guidHandler)(const void*, uint64_t, void*);
+  uint64_t guidParam;
+  void* guidParam2;
+};
+
+STORM_TS_PRIORITY_QUEUE(EvtTimer);
+STORM_TS_GROWABLE_ARRAY_POINTER_TO(EvtTimer);
+
+// class EvtTimerQueue : public TSPriorityQueue<EvtTimer>
+struct EvtTimerQueue {
+  TSPriorityQueue_EvtTimer b_base;
+};
+
+#endif

profile/3.3.5a-windows/include/event/types.h

@@ -0,0 +1,277 @@
+#ifndef EVENT_TYPES_H
+#define EVENT_TYPES_H
+
+#include "system/types.h"
+
+DECLARE_ENUM(EVENTID);
+DECLARE_ENUM(KEY);
+DECLARE_ENUM(MOUSEBUTTON);
+DECLARE_ENUM(MOUSEMODE);
+DECLARE_ENUM(OSINPUT);
+DECLARE_ENUM(OS_MOUSE_MODE);
+
+DECLARE_STRUCT(OSEVENT);
+DECLARE_STRUCT(EVENT_DATA_CHAR);
+DECLARE_STRUCT(EVENT_DATA_FOCUS);
+DECLARE_STRUCT(EVENT_DATA_IDLE);
+DECLARE_STRUCT(EVENT_DATA_KEY);
+DECLARE_STRUCT(EVENT_DATA_MOUSE);
+DECLARE_STRUCT(EVENT_DATA_SIZE);
+
+typedef void* HEVENTCONTEXT;
+typedef int32_t (*EVENTHANDLERFUNC)(const void*, void*);
+
+enum EVENTID {
+  EVENT_ID_0                  = 0,
+  EVENT_ID_CHAR               = 1,
+  EVENT_ID_FOCUS              = 2,
+  EVENT_ID_3                  = 3,
+  EVENT_ID_DESTROY            = 4,
+  EVENT_ID_5                  = 5,
+  EVENT_ID_IDLE               = 6,
+  EVENT_ID_POLL               = 7,
+  EVENT_ID_INITIALIZE         = 8,
+  EVENT_ID_KEYDOWN            = 9,
+  EVENT_ID_KEYUP              = 10,
+  EVENT_ID_KEYDOWN_REPEATING  = 11,
+  EVENT_ID_MOUSEDOWN          = 12,
+  EVENT_ID_MOUSEMOVE          = 13,
+  EVENT_ID_MOUSEMOVE_RELATIVE = 14,
+  EVENT_ID_MOUSEUP            = 15,
+  EVENT_ID_MOUSEMODE_CHANGED  = 16,
+  EVENT_ID_MOUSEWHEEL         = 17,
+  EVENT_ID_18                 = 18,
+  EVENT_ID_19                 = 19,
+  EVENT_ID_20                 = 20,
+  EVENT_ID_21                 = 21,
+  EVENT_ID_22                 = 22,
+  EVENT_ID_PAINT              = 23,
+  EVENT_ID_NET_DATA           = 24,
+  EVENT_ID_NET_CONNECT        = 25,
+  EVENT_ID_NET_DISCONNECT     = 26,
+  EVENT_ID_NET_CANTCONNECT    = 27,
+  EVENT_ID_NET_DESTROY        = 28,
+  EVENT_ID_NET_AUTH_CHALLENGE = 29,
+  EVENT_ID_30                 = 30,
+  EVENT_ID_31                 = 31,
+  EVENT_ID_32                 = 32,
+  EVENT_ID_33                 = 33,
+  EVENT_ID_IME                = 34,
+  EVENT_ID_SIZE               = 35,
+  EVENTIDS                    = 36
+};
+
+enum KEY {
+  KEY_NONE = 0xFFFFFFFF,
+  KEY_LSHIFT = 0x0,
+  KEY_RSHIFT = 0x1,
+  KEY_LCONTROL = 0x2,
+  KEY_RCONTROL = 0x3,
+  KEY_LALT = 0x4,
+  KEY_RALT = 0x5,
+  KEY_LASTMETAKEY = 0x5,
+  KEY_SPACE = 0x20,
+  KEY_0 = 0x30,
+  KEY_1 = 0x31,
+  KEY_2 = 0x32,
+  KEY_3 = 0x33,
+  KEY_4 = 0x34,
+  KEY_5 = 0x35,
+  KEY_6 = 0x36,
+  KEY_7 = 0x37,
+  KEY_8 = 0x38,
+  KEY_9 = 0x39,
+  KEY_A = 0x41,
+  KEY_B = 0x42,
+  KEY_C = 0x43,
+  KEY_D = 0x44,
+  KEY_E = 0x45,
+  KEY_F = 0x46,
+  KEY_G = 0x47,
+  KEY_H = 0x48,
+  KEY_I = 0x49,
+  KEY_J = 0x4A,
+  KEY_K = 0x4B,
+  KEY_L = 0x4C,
+  KEY_M = 0x4D,
+  KEY_N = 0x4E,
+  KEY_O = 0x4F,
+  KEY_P = 0x50,
+  KEY_Q = 0x51,
+  KEY_R = 0x52,
+  KEY_S = 0x53,
+  KEY_T = 0x54,
+  KEY_U = 0x55,
+  KEY_V = 0x56,
+  KEY_W = 0x57,
+  KEY_X = 0x58,
+  KEY_Y = 0x59,
+  KEY_Z = 0x5A,
+  KEY_TILDE = 0x60,
+  KEY_NUMPAD0 = 0x100,
+  KEY_NUMPAD1 = 0x101,
+  KEY_NUMPAD2 = 0x102,
+  KEY_NUMPAD3 = 0x103,
+  KEY_NUMPAD4 = 0x104,
+  KEY_NUMPAD5 = 0x105,
+  KEY_NUMPAD6 = 0x106,
+  KEY_NUMPAD7 = 0x107,
+  KEY_NUMPAD8 = 0x108,
+  KEY_NUMPAD9 = 0x109,
+  KEY_NUMPAD_PLUS = 0x10A,
+  KEY_NUMPAD_MINUS = 0x10B,
+  KEY_NUMPAD_MULTIPLY = 0x10C,
+  KEY_NUMPAD_DIVIDE = 0x10D,
+  KEY_NUMPAD_DECIMAL = 0x10E,
+  KEY_NUMPAD_EQUALS = 0x30C,
+  KEY_PLUS = 0x3D,
+  KEY_MINUS = 0x2D,
+  KEY_BRACKET_OPEN = 0x5B,
+  KEY_BRACKET_CLOSE = 0x5D,
+  KEY_SLASH = 0x2F,
+  KEY_BACKSLASH = 0x5C,
+  KEY_SEMICOLON = 0x3B,
+  KEY_APOSTROPHE = 0x27,
+  KEY_COMMA = 0x2C,
+  KEY_PERIOD = 0x2E,
+  KEY_ESCAPE = 0x200,
+  KEY_ENTER = 0x201,
+  KEY_BACKSPACE = 0x202,
+  KEY_TAB = 0x203,
+  KEY_LEFT = 0x204,
+  KEY_UP = 0x205,
+  KEY_RIGHT = 0x206,
+  KEY_DOWN = 0x207,
+  KEY_INSERT = 0x208,
+  KEY_DELETE = 0x209,
+  KEY_HOME = 0x20A,
+  KEY_END = 0x20B,
+  KEY_PAGEUP = 0x20C,
+  KEY_PAGEDOWN = 0x20D,
+  KEY_CAPSLOCK = 0x20E,
+  KEY_NUMLOCK = 0x20F,
+  KEY_SCROLLLOCK = 0x210,
+  KEY_PAUSE = 0x211,
+  KEY_PRINTSCREEN = 0x212,
+  KEY_F1 = 0x300,
+  KEY_F2 = 0x301,
+  KEY_F3 = 0x302,
+  KEY_F4 = 0x303,
+  KEY_F5 = 0x304,
+  KEY_F6 = 0x305,
+  KEY_F7 = 0x306,
+  KEY_F8 = 0x307,
+  KEY_F9 = 0x308,
+  KEY_F10 = 0x309,
+  KEY_F11 = 0x30A,
+  KEY_F12 = 0x30B,
+  KEY_F13 = 0x212,
+  KEY_F14 = 0x30D,
+  KEY_F15 = 0x30E,
+  KEY_F16 = 0x30F,
+  KEY_F17 = 0x310,
+  KEY_F18 = 0x311,
+  KEY_F19 = 0x312,
+  KEY_LAST = 0x313
+};
+
+enum MOUSEBUTTON {
+  MOUSE_BUTTON_NONE               = 0x0,
+  MOUSE_BUTTON_LEFT               = 0x1,
+  MOUSE_BUTTON_MIDDLE             = 0x2,
+  MOUSE_BUTTON_RIGHT              = 0x4,
+  MOUSE_BUTTON_XBUTTON1           = 0x8,
+  MOUSE_BUTTON_XBUTTON2           = 0x10,
+  MOUSE_BUTTON_XBUTTON3           = 0x20,
+  MOUSE_BUTTON_XBUTTON4           = 0x40,
+  MOUSE_BUTTON_XBUTTON5           = 0x80,
+  MOUSE_BUTTON_XBUTTON6           = 0x100,
+  MOUSE_BUTTON_XBUTTON7           = 0x200,
+  MOUSE_BUTTON_XBUTTON8           = 0x400,
+  MOUSE_BUTTON_XBUTTON9           = 0x800,
+  MOUSE_BUTTON_XBUTTON10          = 0x1000,
+  MOUSE_BUTTON_XBUTTON11          = 0x2000,
+  MOUSE_BUTTON_XBUTTON12          = 0x4000,
+  MOUSE_BUTTON_ALL                = 0xFFFFFFFF
+};
+
+enum MOUSEMODE {
+  MOUSE_MODE_NORMAL               = 0x0,
+  MOUSE_MODE_RELATIVE             = 0x1,
+  MOUSE_MODES                     = 0x2
+};
+
+enum OSINPUT {
+  OS_INPUT_CAPTURE_CHANGED        = 0,
+  OS_INPUT_CHAR                   = 1,
+  OS_INPUT_STRING                 = 2,
+  OS_INPUT_IME                    = 3,
+  OS_INPUT_SIZE                   = 4,
+  OS_INPUT_CLOSE                  = 5,
+  OS_INPUT_FOCUS                  = 6,
+  OS_INPUT_KEY_DOWN               = 7,
+  OS_INPUT_KEY_UP                 = 8,
+  OS_INPUT_MOUSE_DOWN             = 9,
+  OS_INPUT_MOUSE_MOVE             = 10,
+  OS_INPUT_MOUSE_WHEEL            = 11,
+  OS_INPUT_MOUSE_MOVE_RELATIVE    = 12,
+  OS_INPUT_MOUSE_UP               = 13,
+  OS_INPUT_14                     = 14,
+  OS_INPUT_15                     = 15,
+  OS_INPUT_16                     = 16,
+  OS_INPUT_17                     = 17,
+  OS_INPUT_18                     = 18,
+  OS_INPUT_SHUTDOWN               = 19
+};
+
+enum OS_MOUSE_MODE {
+  OS_MOUSE_MODE_NORMAL            = 0,
+  OS_MOUSE_MODE_RELATIVE          = 1,
+  OS_MOUSE_MODES                  = 2,
+};
+
+struct OSEVENT {
+  OSINPUT id;
+  int32_t param[4];
+};
+
+struct EVENT_DATA_CHAR {
+  int32_t ch;
+  uint32_t metaKeyState;
+  uint32_t repeat;
+};
+
+struct EVENT_DATA_FOCUS {
+  int32_t focus;
+};
+
+struct EVENT_DATA_IDLE {
+  float elapsedSec;
+  uint32_t time;
+};
+
+struct EVENT_DATA_KEY {
+  KEY key;
+  uint32_t metaKeyState;
+  uint32_t repeat;
+  uint32_t time;
+};
+
+struct EVENT_DATA_MOUSE {
+  MOUSEMODE mode;
+  MOUSEBUTTON button;
+  uint32_t buttonState;
+  uint32_t metaKeyState;
+  uint32_t flags;
+  float x;
+  float y;
+  int32_t wheelDistance;
+  uint32_t time;
+};
+
+struct EVENT_DATA_SIZE {
+  int32_t w;
+  int32_t h;
+};
+
+#endif

profile/3.3.5a-windows/include/framescript/event_object.h

@@ -0,0 +1,35 @@
+#ifndef FRAMESCRIPT_EVENT_OBJECT_H
+#define FRAMESCRIPT_EVENT_OBJECT_H
+
+#include "storm/hash.h"
+
+#include "framescript/object.h"
+
+#include "ui/simpleframe.h"
+
+DECLARE_STRUCT(FrameScript_EventObject);
+DECLARE_STRUCT(SIMPLEFRAMENODE);
+DECLARE_STRUCT(EVENTLISTENERNODE);
+
+STORM_TS_LIST(SIMPLEFRAMENODE);
+STORM_TS_LIST(EVENTLISTENERNODE);
+
+// struct SIMPLEFRAMENODE : TSLinkedNode<SIMPLEFRAMENODE> 
+struct SIMPLEFRAMENODE {
+  TSLinkedNode_SIMPLEFRAMENODE b_base;
+  CSimpleFrame* frame;
+};
+
+// struct EVENTLISTENERNODE : TSLinkedNode<EVENTLISTENERNODE> {
+struct EVENTLISTENERNODE {
+  TSLinkedNode_EVENTLISTENERNODE b_base;
+  FrameScript_Object* listener;
+};
+
+STORM_TS_HASH(FrameScript_EventObject, HASHKEY_STRI)
+
+struct FrameScript_EventObject {
+  TSHashObject_FrameScript_EventObject_HASHKEY_STRI b_base;
+};
+
+#endif

profile/3.3.5a-windows/include/framescript/object.h

@@ -0,0 +1,15 @@
+#ifndef FRAMESCRIPT_OBJECT_H
+#define FRAMESCRIPT_OBJECT_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(FrameScript_Object);
+
+struct FrameScript_Object {
+  void** v_vtable;
+  int32_t lua_registered;
+  int32_t lua_objectRef;
+  int32_t m_onEvent;
+};
+
+#endif

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

@@ -0,0 +1,17 @@
+#ifndef GX_BATCH_H
+#define GX_BATCH_H
+
+#include "gx/types.h"
+
+typedef struct CGxBatch 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/include/gx/buffer.h

@@ -0,0 +1,136 @@
+#ifndef GX_BUFFER_H
+#define GX_BUFFER_H
+
+#include "system/types.h"
+
+#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;
+
+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 ubyte4 {
+  union {
+    uint8_t b[4];
+    uint32_t u;
+  };
+};
+
+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/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/include/gx/d3d9.h

@@ -0,0 +1,46 @@
+#ifndef GX_D3D9_H
+#define GX_D3D9_H
+
+#include "gx/device.h"
+
+#include "d3d9/device.h"
+
+typedef struct CGxDeviceD3d CGxDeviceD3d;
+
+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;
+  uint32_t unk3AB4[11];
+  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/include/gx/device.h

@@ -0,0 +1,254 @@
+#ifndef GX_DEVICE_H
+#define GX_DEVICE_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+#include "storm/array/uint32_t.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"
+
+typedef struct CGxAppRenderState CGxAppRenderState;
+typedef struct CGxPushedRenderState CGxPushedRenderState;
+typedef struct ShaderConstants ShaderConstants;
+typedef struct CGxDevice CGxDevice;
+typedef struct CGxDevice__vtable CGxDevice__vtable;
+
+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*, uint32_t);
+  void* v_fn_0_ITexMarkAsUpdated;
+  // void IRsSendToHw(EGxRenderState);
+  void* v_fn_1_IRsSendToHw;
+  // void ICursorCreate(const CGxFormat&);
+  void* v_fn_2_ICursorCreate;
+  // void ICursorDestroy();
+  void* v_fn_3_ICursorDestroy;
+  // void ICursorDraw();
+  void* v_fn_4_ICursorDraw;
+  // don't know if this ever gets called (IStateSync something?)
+  void* v_fn_5;
+  // don't know if this ever gets called (IStateSync something?)
+  void* v_fn_6;
+  // don't know if this ever gets called (IStateSync something?)
+  void* v_fn_7; 
+  // don't know if this ever gets called (something deleted?)
+  void* v_fn_8;
+  void* v_fn_9;
+  // int32_t DeviceCreate(long (*)(void*, uint32_t, uint32_t, int32_t), CGxFormat const&);
+  void* v_fn_10_DeviceCreate;
+  // void DeviceDestroy();
+  void* v_fn_11_DeviceDestroy;
+  void* v_fn_12;
+  // int32_t DeviceSetFormat(struct CGxFormat const &);
+  void* v_fn_13_DeviceSetFormat;
+  // void DeviceSetBaseMipLevel(uint32_t);
+  void* v_fn_14_DeviceSetBaseMipLevel;
+  // void DeviceSetGamma(CGxGammaRamp const&);
+  void* v_fn_15_DeviceSetGamma;
+  void* v_fn_16;
+  void* v_fn_17;
+  void* v_fn_18;
+  void* v_fn_19;
+  void* v_fn_20;
+  void* v_fn_21;
+  // void DeviceWM(EGxWM, int32_t, int32_t);
+  void* v_fn_22_DeviceWM;
+  void* v_fn_23;
+  void* v_fn_24;
+  void* v_fn_25;
+  void* v_fn_26;
+  void* v_fn_27;
+  // void DeviceOverride(EGxOverride, uint32_t);
+  void* v_fn_28_DeviceOverride;
+  void* v_fn_29;
+  void* v_fn_30;
+  void* v_fn_31;
+  void* v_fn_32;
+  void* v_fn_33;
+  void* v_fn_34;
+  // void CapsWindowSize(CRect&);
+  void* v_fn_35_CapsWindowSize;
+  // void CapsWindowSize(CRect&);
+  void* v_fn_36_CapsWindowSizeInScreenCoords;
+  void* v_fn_37;
+  // void ScenePresent(uint32_t);
+  void* v_fn_38_ScenePresent;
+  // void SceneClear(uint32_t, CImVector);
+  void* v_fn_39_SceneClear;
+  // void XformSetProjection(const C44Matrix&);
+  void* v_fn_40_XformSetProjection;
+  // void XformSetView(const C44Matrix&);
+  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* v_fn_51_MasterEnableSet;
+  // void PoolSizeSet(CGxPool*, uint32_t);
+  void* v_fn_52_PoolSizeSet;
+  // void PoolDestroy(CGxPool*);
+  void* v_fn_53_PoolDestroy;
+  // char* BufLock(CGxBuf*);
+  void* v_fn_54_BufLock;
+  // int32_t BufUnlock(CGxBuf*, uint32_t);
+  void* v_fn_55_BufUnlock;
+  // void BufData(CGxBuf*, void const*, uint32_t, uint32_t); 
+  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*&);
+  void* v_fn_57_TexCreate;
+  // void TexDestroy(CGxTex*);
+  void* v_fn_58_TexDestroy;
+  // int32_t TexCopy(CGxTex*, CGxTex*, const C2iVector&, const C2iVector&, const C2iVector&, uint32_t);
+  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);
+  void* v_fn_68_ShaderCreate;
+  void* v_fn_69;
+  // void ShaderConstantsSet(EGxShTarget, uint32_t, const float*, uint32_t);
+  void* v_fn_70_ShaderConstantsSet;
+  void* v_fn_71;
+  // void IShaderCreate(CGxShader*);
+  void* v_fn_72_IShaderCreate;
+  // void CursorSetVisible(int32_t);
+  void* v_fn_73_CursorSetVisible;
+  // void* CursorLock();
+  void* v_fn_74_CursorLock;
+  // void CursorUnlock(uint32_t, uint32_t);
+  void* v_fn_75_CursorUnlock;
+  void* v_fn_76;
+  void* v_fn_77;
+  void* v_fn_78;
+  void* v_fn_79;
+  // bool StereoEnabled();
+  void* v_fn_80_StereoEnabled;
+  void* v_fn_81;
+  void* v_fn_82;
+  void* v_fn_83;
+};
+
+// this class is at least 14688 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[76];
+  CRect m_defWindowRect; // 0x164 (size: 0x10)
+  CRect m_curWindowRect; // 0x174 (size: 0x10)
+  uint32_t m_unk184[12];
+  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;
+  int32_t intF6C;
+  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[162];
+  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;
+  CImVector 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/include/gx/format.h

@@ -0,0 +1,50 @@
+#ifndef GX_FORMAT_H
+#define GX_FORMAT_H
+
+#include "system/types.h"
+
+#include "tempest/vector.h"
+
+typedef enum CGxFormat__Format 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/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"
+
+typedef enum CGxMatrixStack__EMatrixFlags CGxMatrixStack__EMatrixFlags;
+typedef struct CGxMatrixStack 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/include/gx/shader.h

@@ -0,0 +1,30 @@
+#ifndef GX_SHADER_H
+#define GX_SHADER_H
+
+#include "storm/hash.h"
+#include "storm/array/uint8_t.h"
+
+typedef struct CGxShader CGxShader;
+
+STORM_TS_HASH(CGxShader, HASHKEY_STRI);
+
+// class CGxShader : public TSHashObject<CGxShader, HASHKEY_STRI>
+struct CGxShader {
+  TSHashObject_CGxShader_HASHKEY_STRI b_base;
+  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;
+};
+
+#endif
+

profile/3.3.5a-windows/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"
+
+typedef struct CGxStateBom 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/include/gx/texture.h

@@ -0,0 +1,50 @@
+#ifndef GX_TEXTURE_H
+#define GX_TEXTURE_H
+
+#include "tempest/rect.h"
+
+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 m_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/include/gx/types.h

@@ -0,0 +1,397 @@
+#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 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

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

@@ -0,0 +1,68 @@
+// Defines
+
+#include "system/detect.h"
+
+// Types
+
+#include "common/handle.h"
+#include "common/instance.h"
+#include "common/datarecycler.h"
+#include "common/status.h"
+
+#include "cursor/types.h"
+
+#include "d3d9/caps.h"
+#include "d3d9/device.h"
+
+#include "event/types.h"
+#include "event/context.h"
+#include "event/handler.h"
+#include "event/id_table.h"
+#include "event/keydown.h"
+#include "event/message.h"
+#include "event/timer.h"
+
+#include "framescript/object.h"
+#include "framescript/event_object.h"
+
+#include "gx/buffer.h"
+#include "gx/caps.h"
+#include "gx/device.h"
+#include "gx/format.h"
+#include "gx/matrix_stack.h"
+#include "gx/shader.h"
+#include "gx/state_bom.h"
+#include "gx/types.h"
+#include "gx/batch.h"
+#include "gx/d3d9.h"
+
+#include "storm/array.h"
+#include "storm/list.h"
+#include "storm/hash.h"
+
+#include "tempest/box.h"
+#include "tempest/matrix.h"
+#include "tempest/plane.h"
+#include "tempest/quaternion.h"
+#include "tempest/range.h"
+#include "tempest/rect.h"
+#include "tempest/sphere.h"
+#include "tempest/vector.h"
+
+#include "texture/blp.h"
+#include "texture/tga.h"
+
+#include "ui/simpleframe.h"
+
+// include files that define the use of template classes for standard library types
+// template classes for whoa types should be entered immediately after where the type is
+
+#include "storm/array/pointer_to_void.h"
+#include "storm/array/uint8_t.h"
+#include "storm/array/uint32_t.h"
+
+#include "storm/queue/timer_priority_uint32_t.h"
+
+// template types that are defined in our headers, should be declared immediately after the base type
+// and not used anywhere else
+

profile/3.3.5a-windows/include/storm/array.h

@@ -0,0 +1,52 @@
+#ifndef STORM_ARRAY_H
+#define STORM_ARRAY_H
+
+#include "system/types.h"
+
+#define STORM_TS_BASE_ARRAY(T) typedef struct TSBaseArray_##T TSBaseArray_##T; \
+struct TSBaseArray_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T* m_data; \
+};
+
+#define STORM_TS_FIXED_ARRAY(T) typedef struct TSFixedArray_##T TSFixedArray_##T; \
+struct TSFixedArray_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T* m_data; \
+};
+
+#define STORM_TS_GROWABLE_ARRAY(T) typedef struct TSGrowableArray_##T TSGrowableArray_##T; \
+struct TSGrowableArray_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T* m_data; \
+  uint32_t m_chunk; \
+};
+
+// "pointer-to" types hack
+
+#define STORM_TS_BASE_ARRAY_POINTER_TO(T) typedef struct TSBaseArray_pointer_to_##T TSBaseArray_pointer_to_##T; \
+struct TSBaseArray_pointer_to_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T** m_data; \
+};
+
+#define STORM_TS_FIXED_ARRAY_POINTER_TO(T) typedef struct TSFixedArray_pointer_to_##T TSFixedArray_pointer_to_##T; \
+struct TSFixedArray_pointer_to_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T** m_data; \
+};
+
+#define STORM_TS_GROWABLE_ARRAY_POINTER_TO(T) typedef struct TSGrowableArray_pointer_to_##T TSGrowableArray_pointer_to_##T; \
+struct TSGrowableArray_pointer_to_##T { \
+  uint32_t m_alloc; \
+  uint32_t m_count; \
+  T** m_data; \
+  uint32_t m_chunk; \
+};
+
+#endif

profile/3.3.5a-windows/include/storm/array/pointer_to_void.h

@@ -0,0 +1,10 @@
+#ifndef STORM_ARRAY_POINTER_TO_VOID_H
+#define STORM_ARRAY_POINTER_TO_VOID_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+
+STORM_TS_GROWABLE_ARRAY_POINTER_TO(void);
+
+#endif

profile/3.3.5a-windows/include/storm/array/uint32_t.h

@@ -0,0 +1,10 @@
+#ifndef STORM_ARRAY_UINT32_T_H
+#define STORM_ARRAY_UINT32_T_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+
+STORM_TS_GROWABLE_ARRAY(uint32_t);
+
+#endif

profile/3.3.5a-windows/include/storm/array/uint8_t.h

@@ -0,0 +1,10 @@
+#ifndef STORM_ARRAY_UINT8_T_H
+#define STORM_ARRAY_UINT8_T_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+
+STORM_TS_GROWABLE_ARRAY(uint8_t);
+
+#endif

profile/3.3.5a-windows/include/storm/file.h

@@ -0,0 +1,9 @@
+#ifndef STORM_FILE_H
+#define STORM_FILE_H
+
+DECLARE_STRUCT(SFile);
+
+struct SFile {
+};
+
+#endif

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

@@ -0,0 +1,48 @@
+#ifndef STORM_HASH_H
+#define STORM_HASH_H
+
+#include "system/types.h"
+
+#include "storm/array.h"
+#include "storm/list.h"
+
+#define STORM_TS_HASH(T, K) \
+STORM_TS_LIST(T) \
+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 { \
+  TSList_##T m_fulllist; \
+  uint32_t m_fullnessIndicator; \
+  TSGrowableArray_TSList_##T m_slotlistarray; \
+  uint32_t m_slotmask; \
+}; \
+struct TSHashObject_##T##_##K { \
+  uint32_t m_hashval; \
+  TSLink_##T m_linktoslot; \
+  TSLink_##T m_linktofull; \
+  K m_key; \
+};
+
+DECLARE_STRUCT(HASHKEY_PTR);
+DECLARE_STRUCT(HASHKEY_STR);
+DECLARE_STRUCT(HASHKEY_STRI);
+DECLARE_STRUCT(HASHKEY_NONE);
+
+struct HASHKEY_PTR {
+  void* m_key;
+};
+
+struct HASHKEY_STR {
+  char* m_str;
+};
+
+struct HASHKEY_STRI {
+  char* m_str;
+};
+
+struct HASHKEY_NONE {
+  int32_t m_unused;
+};
+
+#endif

profile/3.3.5a-windows/include/storm/list.h

@@ -0,0 +1,33 @@
+#ifndef STORM_LIST_H
+#define STORM_LIST_H
+
+#include "system/types.h"
+
+// to make an object self referential
+// forward-declare 'struct Object_type' as 'Object_type'
+// then define 'struct Object_type'
+
+// TSLink<T>
+#define STORM_TS_LINK(T) typedef struct TSLink_##T TSLink_##T; \
+struct TSLink_##T { \
+  TSLink_##T* m_prevlink; \
+  T* m_next; \
+};
+
+// TSList<T>
+// TSExplicitList<T>
+// TSLinkedNode<T>
+#define STORM_TS_LIST(T) \
+STORM_TS_LINK(T) \
+typedef struct TSList_##T TSList_##T; \
+typedef struct TSList_##T TSExplicitList_##T; \
+typedef struct TSLinkedNode_##T TSLinkedNode_##T; \
+struct TSList_##T { \
+  ptrdiff_t m_linkoffset; \
+  TSLink_##T m_terminator; \
+}; \
+struct TSLinkedNode_##T { \
+  TSLink_##T m_link; \
+};
+
+#endif

profile/3.3.5a-windows/include/storm/queue.h

@@ -0,0 +1,31 @@
+#ifndef STORM_QUEUE_H
+#define STORM_QUEUE_H
+
+#include "system/types.h"
+
+#include "storm/array/pointer_to_void.h"
+
+DECLARE_STRUCT(CSBasePriorityQueue);
+DECLARE_STRUCT(CSBasePriority);
+
+struct CSBasePriorityQueue {
+  TSGrowableArray_pointer_to_void b_base;
+  uint32_t m_linkOffset;
+};
+
+struct CSBasePriority {
+  CSBasePriorityQueue* m_queue;
+  uint32_t m_index;
+};
+
+#define STORM_TS_TIMER_PRIORITY(T) \
+typedef struct TSTimerPriority_##T TSTimerPriority_##T; \
+struct TSTimerPriority_##T { \
+  CSBasePriority b_base; \
+  T m_val; \
+};
+
+#define STORM_TS_PRIORITY_QUEUE(T) \
+typedef CSBasePriorityQueue TSPriorityQueue_##T; 
+
+#endif

profile/3.3.5a-windows/include/storm/queue/timer_priority_uint32_t.h

@@ -0,0 +1,10 @@
+#ifndef STORM_QUEUE_TIMER_PRIORITY_UINT32_T_H
+#define STORM_QUEUE_TIMER_PRIORITY_UINT32_T_H
+
+#include "system/types.h"
+
+#include "storm/queue.h"
+
+STORM_TS_TIMER_PRIORITY(uint32_t);
+
+#endif

profile/3.3.5a-windows/include/storm/thread.h

@@ -0,0 +1,17 @@
+#ifndef STORM_THREAD_H
+#define STORM_THREAD_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(SCritSect);
+typedef struct CSRWLock CSRWLock;
+
+struct SCritSect {
+  uint8_t m_critsect[24];
+};
+
+struct CSRWLock {
+  uint8_t m_opaqueData[12];
+};
+
+#endif

profile/3.3.5a-windows/include/system/detect.h

@@ -0,0 +1,23 @@
+#ifndef SYSTEM_DETECT_H
+#define SYSTEM_DETECT_H
+
+#if !defined(IDA) && !defined(GHIDRA) && !defined(BINANA_GENERATOR)
+
+#error "Preprocessor mode not detected! You must define either IDA or GHIDRA or BINANA_GENERATOR"
+
+#endif
+
+#if defined(IDA)
+
+// why does this work? 
+#define DECLARE_ENUM(E) typedef enum E##__ E
+
+#else
+
+#define DECLARE_ENUM(E) typedef enum E E
+
+#endif
+
+#define DECLARE_STRUCT(T) typedef struct T T
+
+#endif

profile/3.3.5a-windows/include/system/types.h

@@ -0,0 +1,40 @@
+#ifndef SYSTEM_TYPES_H
+#define SYSTEM_TYPES_H
+
+// stdint
+#if defined(IDA) || defined(BINANA_GENERATOR)
+
+typedef signed char        int8_t;
+typedef short              int16_t;
+typedef int                int32_t;
+typedef long long          int64_t;
+typedef unsigned char      uint8_t;
+typedef unsigned short     uint16_t;
+typedef unsigned int       uint32_t;
+typedef unsigned long long uint64_t;
+
+typedef int32_t ptrdiff_t;
+typedef uint32_t uintptr_t;
+typedef int32_t intptr_t;
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+// stdbool
+
+#if defined(BINANA_GENERATOR)
+
+typedef char bool;
+
+#endif
+
+#if defined(GHIDRA)
+
+#include <stdbool.h>
+
+#endif
+
+#endif

profile/3.3.5a-windows/include/tempest/box.h

@@ -0,0 +1,21 @@
+#ifndef TEMPEST_BOX_H
+#define TEMPEST_BOX_H
+
+#include "tempest/vector.h"
+#include "tempest/range.h"
+
+DECLARE_STRUCT(CAaBox);
+DECLARE_STRUCT(CBoundingBox);
+
+struct CAaBox {
+  C3Vector b;
+  C3Vector t;
+};
+
+struct CBoundingBox {
+  CRange x;
+  CRange y;
+  CRange z;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/matrix.h

@@ -0,0 +1,55 @@
+#ifndef TEMPEST_MATRIX_H
+#define TEMPEST_MATRIX_H
+
+DECLARE_STRUCT(C33Matrix);
+DECLARE_STRUCT(C34Matrix);
+DECLARE_STRUCT(C44Matrix);
+
+struct C33Matrix {
+  float a0;
+  float a1;
+  float a2;
+  float b0;
+  float b1;
+  float b2;
+  float c0;
+  float c1;
+  float c2;
+};
+
+struct C34Matrix {
+  float a0;
+  float a1;
+  float a2;
+  float b0;
+  float b1;
+  float b2;
+  float c0;
+  float c1;
+  float c2;
+  float d0;
+  float d1;
+  float d2;
+};
+
+struct C44Matrix {
+  float a0;
+  float a1;
+  float a2;
+  float a3;
+  float b0;
+  float b1;
+  float b2;
+  float b3;
+  float c0;
+  float c1;
+  float c2;
+  float c3;
+  float d0;
+  float d1;
+  float d2;
+  float d3;
+};
+
+
+#endif

profile/3.3.5a-windows/include/tempest/plane.h

@@ -0,0 +1,13 @@
+#ifndef TEMPEST_PLANE_H
+#define TEMPEST_PLANE_H
+
+#include "tempest/vector.h"
+
+DECLARE_STRUCT(C4Plane);
+
+struct C4Plane {
+  C3Vector n;
+  float d;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/quaternion.h

@@ -0,0 +1,13 @@
+#ifndef TEMPEST_QUATERNION_H
+#define TEMPEST_QUATERNION_H
+
+DECLARE_STRUCT(C4Quaternion);
+
+struct C4Quaternion {
+  float x;
+  float y;
+  float z;
+  float w;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/range.h

@@ -0,0 +1,19 @@
+#ifndef TEMPEST_RANGE_H
+#define TEMPEST_RANGE_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(CRange);
+DECLARE_STRUCT(CiRange);
+
+struct CRange {
+  float l;
+  float h;
+};
+
+struct CiRange {
+  int32_t l;
+  int32_t h;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/rect.h

@@ -0,0 +1,23 @@
+#ifndef TEMPEST_RECT_H
+#define TEMPEST_RECT_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(CRect);
+DECLARE_STRUCT(CiRect);
+
+struct CRect {
+  float minY; // t
+  float minX; // l
+  float maxY; // b
+  float maxX; // r
+};
+
+struct CiRect {
+  int32_t minY;
+  int32_t minX;
+  int32_t maxY;
+  int32_t maxX;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/sphere.h

@@ -0,0 +1,13 @@
+#ifndef TEMPEST_SPHERE_H
+#define TEMPEST_SPHERE_H
+
+#include "tempest/vector.h"
+
+DECLARE_STRUCT(CAaSphere);
+
+struct CAaSphere {
+  C3Vector n;
+  float d;
+};
+
+#endif

profile/3.3.5a-windows/include/tempest/vector.h

@@ -0,0 +1,43 @@
+#ifndef TEMPEST_VECTOR_H
+#define TEMPEST_VECTOR_H
+
+#include "system/types.h"
+
+DECLARE_STRUCT(C2Vector);
+DECLARE_STRUCT(C2iVector);
+DECLARE_STRUCT(C3Vector);
+DECLARE_STRUCT(C4Vector);
+DECLARE_STRUCT(CImVector);
+
+struct C2Vector {
+  float x;
+  float y;
+};
+
+struct C2iVector {
+  int32_t x;
+  int32_t y;
+};
+
+struct C3Vector {
+  float x;
+  float y;
+  float z;
+};
+
+struct C4Vector {
+  float x;
+  float y;
+  float z;
+  float w;
+};
+
+struct CImVector {
+  uint8_t b;
+  uint8_t g;
+  uint8_t r;
+  uint8_t a;
+};
+
+
+#endif

profile/3.3.5a-windows/include/texture/blp.h

@@ -0,0 +1,70 @@
+#ifndef TEXTURE_BLP_H
+#define TEXTURE_BLP_H
+
+#include "system/types.h"
+
+#include "storm/file.h"
+
+#include "gx/types.h"
+
+DECLARE_HANDLE(HCOLORMAP);
+
+DECLARE_ENUM(MipMapAlgorithm);
+
+DECLARE_STRUCT(CBLPFile);
+DECLARE_STRUCT(BlpPalPixel);
+DECLARE_STRUCT(BLPHeader);
+DECLARE_STRUCT(BLPJPEGHeader);
+
+enum MipMapAlgorithm {
+  MMA_BOX = 0x0,
+  MMA_CUBIC = 0x1,
+  MMA_FULLDFT = 0x2,
+  MMA_KAISER = 0x3,
+  MMA_LINEARLIGHTKAISER = 0x4
+};
+
+struct BlpPalPixel {
+  uint8_t b;
+  uint8_t g;
+  uint8_t r;
+  uint8_t pad;
+};
+
+struct BLPJPEGHeader {
+  uint32_t headerSize;
+  uint8_t headerData[1020];
+};
+
+struct BLPHeader {
+  uint32_t magic;
+  uint32_t formatVersion;
+  uint8_t colorEncoding;
+  uint8_t alphaSize;
+  uint8_t preferredFormat;
+  uint8_t hasMips;
+  uint32_t width;
+  uint32_t height;
+  uint32_t mipOffsets[16];
+  uint32_t mipSizes[16];
+
+  union {
+    BlpPalPixel palette[256];
+
+    BLPJPEGHeader jpeg;
+  } extended;
+};
+
+struct CBLPFile {
+  MipBits* m_images;
+  BLPHeader m_header;
+  void* m_inMemoryImage;
+  int32_t m_inMemoryNeedsFree;
+  uint32_t m_numLevels;
+  uint32_t m_quality;
+  HCOLORMAP m_colorMapping;
+  MipMapAlgorithm m_mipMapAlgorithm;
+  uint8_t* m_lockDecompMem;
+};
+
+#endif

profile/3.3.5a-windows/include/texture/tga.h

@@ -0,0 +1,66 @@
+#ifndef TEXTURE_TGA_H
+#define TEXTURE_TGA_H
+
+#include "system/types.h"
+
+#include "storm/file.h"
+
+DECLARE_STRUCT(TGAFooter);
+DECLARE_STRUCT(TGAHeader);
+DECLARE_STRUCT(TGA32Pixel);
+DECLARE_STRUCT(TGAImageDesc);
+DECLARE_STRUCT(CTgaFile);
+
+struct TGAFooter {
+  uint32_t dwExtensionOffset;
+  uint32_t dwDeveloperOffset;
+  uint8_t szSigniture[18];
+};
+
+#pragma pack(push, 1)
+
+struct TGAImageDesc {
+  uint8_t bAlphaChannelBits : 4;
+  uint8_t bLeftRightOrder : 1;
+  uint8_t bTopBottomOrder : 1;
+  uint8_t bReserved : 2;
+};
+
+struct TGAHeader {
+  uint8_t bIDLength;
+  uint8_t bColorMapType;
+  uint8_t bImageType;
+  // byte packed
+  uint16_t wColorMapStartIndex;
+  uint16_t wColorMapEntries;
+  uint8_t bColorMapEntrySize;
+  uint16_t wXOrigin;
+  uint16_t wYOrigin;
+  uint16_t wWidth;
+  uint16_t wHeight;
+  uint8_t bPixelDepth;
+  union {
+    uint8_t bImageDescriptor;
+    TGAImageDesc desc;
+  };
+};
+#pragma pack(pop)
+
+struct TGA32Pixel {
+  uint8_t b;
+  uint8_t g;
+  uint8_t r;
+  uint8_t a;
+};
+
+struct CTgaFile {
+  SFile* m_file;
+  uint8_t* m_image;
+  TGAHeader m_header;
+  uint8_t* m_addlHeaderData;
+  TGAFooter m_footer;
+  uint32_t m_imageBytes;
+  uint8_t* m_colorMap;
+};
+
+#endif

profile/3.3.5a-windows/include/ui/simpleframe.h

@@ -0,0 +1,9 @@
+#ifndef UI_SIMPLE_FRAME_H
+#define UI_SIMPLE_FRAME_H
+
+DECLARE_STRUCT(CSimpleFrame);
+
+struct CSimpleFrame {
+};
+
+#endif