Merge branch 'Rainchus:main' into main

include/dolphin/CARDPriv.h

@@ -0,0 +1,132 @@
+#ifndef _DOLPHIN_CARDPRIV
+#define _DOLPHIN_CARDPRIV
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CARD_FAT_AVAIL 0x0000u
+#define CARD_FAT_CHECKSUM 0x0000u
+#define CARD_FAT_CHECKSUMINV 0x0001u
+#define CARD_FAT_CHECKCODE 0x0002u
+#define CARD_FAT_FREEBLOCKS 0x0003u
+#define CARD_FAT_LASTSLOT 0x0004u
+
+#define CARD_PAGE_SIZE 128u
+#define CARD_SEG_SIZE 512u
+
+#define CARD_NUM_SYSTEM_BLOCK 5
+#define CARD_SYSTEM_BLOCK_SIZE (8 * 1024u)
+
+#define CARD_MAX_MOUNT_STEP (CARD_NUM_SYSTEM_BLOCK + 2)
+
+typedef struct CARDDir {
+  u8 gameName[4];
+  u8 company[2];
+  u8 _padding0;
+  u8 bannerFormat;
+  u8 fileName[CARD_FILENAME_MAX];
+  u32 time; // seconds since 01/01/2000 midnight
+
+  u32 iconAddr; // 0xffffffff if not used
+  u16 iconFormat;
+  u16 iconSpeed;
+
+  u8 permission;
+  u8 copyTimes;
+  u16 startBlock;
+  u16 length;
+  u8 _padding1[2];
+
+  u32 commentAddr; // 0xffffffff if not used
+} CARDDir;
+
+typedef struct CARDDirCheck {
+  u8 padding0[64 - 2 * 4];
+  u16 padding1;
+  s16 checkCode;
+  u16 checkSum;
+  u16 checkSumInv;
+} CARDDirCheck;
+
+typedef struct CARDControl {
+  BOOL attached;
+  s32 result;
+  u16 size;
+  u16 pageSize;
+  s32 sectorSize;
+  u16 cBlock;
+  u16 vendorID;
+  s32 latency;
+  u8 id[12];
+  int mountStep;
+  int formatStep;
+  u32 scramble;
+  DSPTaskInfo task;
+  void* workArea;
+  CARDDir* currentDir;
+  u16* currentFat;
+  OSThreadQueue threadQueue;
+  u8 cmd[9];
+  s32 cmdlen;
+  vu32 mode;
+  int retry;
+  int repeat;
+  u32 addr;
+  void* buffer;
+  s32 xferred;
+  u16 freeNo;
+  u16 startBlock;
+  CARDFileInfo* fileInfo;
+  CARDCallback extCallback;
+  CARDCallback txCallback;
+  CARDCallback exiCallback;
+  CARDCallback apiCallback;
+  CARDCallback xferCallback;
+  CARDCallback eraseCallback;
+  CARDCallback unlockCallback;
+  OSAlarm alarm;
+  u32 cid;
+  const DVDDiskID* diskID;
+} CARDControl;
+
+typedef struct CARDID {
+  u8 serial[32]; // flashID[12] + timebase[8] + counterBias[4] + language[4] + XXX[4]
+  u16 deviceID;
+  u16 size;
+  u16 encode; // character set -- 0: S-JIS, 1: ANSI
+
+  u8 padding[512 - 32 - 5 * 2];
+
+  u16 checkSum;
+  u16 checkSumInv;
+} CARDID;
+
+void __CARDDefaultApiCallback(s32 chan, s32 result);
+
+#define CARDIsValidBlockNo(card, iBlock)                                                           \
+  (CARD_NUM_SYSTEM_BLOCK <= (iBlock) && (iBlock) < (card)->cBlock)
+#define __CARDGetDirCheck(dir) ((CARDDirCheck*)&(dir)[CARD_MAX_FILE])
+
+CARDDir* __CARDGetDirBlock(CARDControl* card);
+u16* __CARDGetFatBlock(CARDControl* card);
+s32 __CARDUpdateFatBlock(s32 chan, u16* fat, CARDCallback callback);
+void __CARDCheckSum(void* ptr, int length, u16* checkSum, u16* checkSumInv);
+u16 __CARDGetFontEncode();
+void __CARDExiHandler(s32 chan, OSContext* context);
+void __CARDExtHandler(s32 chan, OSContext* context);
+void __CARDUnlockedHandler(s32 chan, OSContext* context);
+s32 __CARDAccess(CARDControl* card, CARDDir* ent);
+BOOL __CARDIsWritable(CARDDir* ent);
+
+#define TRUNC(n, a) (((u32)(n)) & ~((a)-1))
+#define OFFSET(n, a) (((u32)(n)) & ((a)-1))
+
+extern CARDControl __CARDBlock[2];
+extern DVDDiskID __CARDDiskNone;
+extern u16 __CARDVendorID;
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _DOLPHIN_CARDPRIV

include/dolphin/DVDPriv.h

@@ -0,0 +1,50 @@
+#ifndef _DOLPHIN_DVDPRIV
+#define _DOLPHIN_DVDPRIV
+
+#include <dolphin/dvd.h>
+#include <dolphin/hw_regs.h>
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct DVDDriveInfo {
+  u16 revisionLevel;
+  u16 deviceCode;
+  u32 releaseDate;
+  u8 padding[24];
+} DVDDriveInfo;
+
+typedef struct DVDBB1 {
+  u32 appLoaderLength;
+  void* appLoaderFunc1;
+  void* appLoaderFunc2;
+  void* appLoaderFunc3;
+} DVDBB1;
+
+typedef struct DVDBB2 {
+  u32 bootFilePosition;
+  u32 FSTPosition;
+  u32 FSTLength;
+  u32 FSTMaxLength;
+  void* FSTAddress;
+  u32 userPosition;
+  u32 userLength;
+
+  u32 padding0;
+} DVDBB2;
+
+typedef void (*DVDOptionalCommandChecker)(DVDCommandBlock* block, void (*cb)(u32 intType));
+typedef void (*DVDLowCallback)(u32 intType);
+extern DVDDiskID* DVDGetCurrentDiskID();
+DVDLowCallback DVDLowClearCallback();
+BOOL DVDLowSeek(u32 offset, DVDLowCallback callback);
+void __DVDLowSetWAType(u32 type, u32 location);
+DVDCommandBlock* __DVDPopWaitingQueue();
+
+#ifdef __cplusplus
+}
+#endif // _DOLPHIN_DVDPRIV
+
+#endif __DVDPRIV_H__

include/dolphin/GBAPriv.h

@@ -0,0 +1,80 @@
+#ifndef _DOLPHIN_GBAPRIV
+#define _DOLPHIN_GBAPRIV
+
+#include "types.h"
+
+#include <dolphin/gba.h>
+#include <dolphin/os.h>
+#include <dolphin/dsp.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*GBATransferCallback)(s32 chan);
+
+typedef struct GBASecParam {
+  u8 readbuf[4];
+  s32 paletteColor;
+  s32 paletteSpeed;
+  s32 length;
+  u32* out;
+  u8 _padding0[12];
+  u32 keyA;
+  s32 keyB;
+  u8 _padding1[24];
+} GBASecParam;
+
+typedef struct GBABootInfo {
+  s32 paletteColor;
+  s32 paletteSpeed;
+  u8* programp;
+  s32 length;
+  u8* status;
+  GBACallback callback;
+  u8 readbuf[4];
+  u8 writebuf[4];
+  int i;
+  OSTick start;
+  OSTime begin;
+  int firstXfer;
+  int curOffset;
+  u32 crc;
+  u32 dummyWord[7];
+  u32 keyA;
+  s32 keyB;
+  u32 initialCode;
+  int realLength;
+} GBABootInfo;
+
+typedef struct GBAControl {
+  u8 output[5];
+  u8 input[5];
+  s32 outputBytes;
+  s32 inputBytes;
+  u8* status;
+  u8* ptr;
+  GBACallback callback;
+  s32 ret;
+  OSThreadQueue threadQueue;
+  OSTime delay;
+  GBATransferCallback proc;
+  GBABootInfo bootInfo;
+  DSPTaskInfo task;
+  GBASecParam* param;
+} GBAControl;
+
+extern GBAControl __GBA[4];
+extern BOOL __GBAReset;
+
+void __GBAHandler(s32 chan, u32 error, OSContext* context);
+void __GBASyncCallback(s32 chan, s32 ret);
+s32 __GBASync(s32 chan);
+OSTime __GBASetDelay(s32 chan, OSTime delay);
+s32 __GBATransfer(s32 chan, s32 w1, s32 w2, GBATransferCallback callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GBAPRIV

include/dolphin/OSRtcPriv.h

@@ -0,0 +1,34 @@
+#ifndef _DOLPHIN_OSRTCPRIV
+#define _DOLPHIN_OSRTCPRIV
+
+#include <types.h>
+
+typedef struct OSSram {
+  u16 checkSum;
+  u16 checkSumInv;
+  u32 ead0;
+  u32 ead1;
+  u32 counterBias;
+  s8 displayOffsetH;
+  u8 ntd;
+  u8 language;
+  u8 flags;
+} OSSram;
+
+typedef struct OSSramEx {
+  u8 flashID[2][12];
+  u32 wirelessKeyboardID;
+  u16 wirelessPadID[4];
+  u8 dvdErrorCode;
+  u8 _padding0;
+  u8 flashIDCheckSum[2];
+  u16 gbs;
+  u8 _padding1[2];
+} OSSramEx;
+
+OSSram* __OSLockSram();
+OSSramEx* __OSLockSramEx();
+void OSSetWirelessID(s32 chan, u16 id);
+u16 OSGetWirelessID(s32 chan);
+
+#endif // _DOLPHIN_OSRTCPRIV

include/dolphin/PPCArch.h

@@ -0,0 +1,500 @@
+#ifndef _DOLPHIN_PPCARCH
+#define _DOLPHIN_PPCARCH
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CTR     9
+#define XER     1
+#define LR      8
+
+#define UPMC1   937
+#define UPMC2   938
+#define UPMC3   941
+#define UPMC4   942
+
+#define USIA    939
+
+#define UMMCR0  936
+#define UMMCR1  940
+
+#define HID0    1008
+#define HID1    1009
+
+#define PVR     287
+
+#define IBAT0U  528
+#define IBAT0L  529
+#define IBAT1U  530
+#define IBAT1L  531
+#define IBAT2U  532
+#define IBAT2L  533
+#define IBAT3U  534
+#define IBAT3L  535
+
+#define DBAT0U  536
+#define DBAT0L  537
+#define DBAT1U  538
+#define DBAT1L  539
+#define DBAT2U  540
+#define DBAT2L  541
+#define DBAT3U  542
+#define DBAT3L  543
+
+#define SDR1    25
+
+#define SPRG0   272
+#define SPRG1   273
+#define SPRG2   274
+#define SPRG3   275
+
+#define DAR     19
+#define DSISR   18
+
+#define SRR0    26
+#define SRR1    27
+
+#define EAR     282
+
+#define DABR    1013
+
+#define TBL     284
+#define TBU     285
+
+#define L2CR    1017
+
+#define DEC     22
+
+#define IABR    1010
+
+#define PMC1    953
+#define PMC2    954
+#define PMC3    957
+#define PMC4    958
+
+#define SIA     955
+
+#define MMCR0   952
+#define MMCR1   956
+
+#define THRM1   1020
+#define THRM2   1021
+#define THRM3   1022
+
+#define ICTC    1019
+
+#define GQR0    912
+#define GQR1    913
+#define GQR2    914
+#define GQR3    915
+#define GQR4    916
+#define GQR5    917
+#define GQR6    918
+#define GQR7    919
+
+#define HID2    920
+
+#define WPAR    921
+
+#define DMA_U   922
+#define DMA_L   923
+
+#define MSR_POW         0x00040000  // Power Management
+#define MSR_ILE         0x00010000  // Interrupt Little Endian
+#define MSR_EE          0x00008000  // external interrupt
+#define MSR_PR          0x00004000  // privilege level(should be 0)
+#define MSR_FP          0x00002000  // floating point available
+#define MSR_ME          0x00001000  // machine check enable
+#define MSR_FE0         0x00000800  // floating point exception enable
+#define MSR_SE          0x00000400  // single step trace enable
+#define MSR_BE          0x00000200  // branch trace enable
+#define MSR_FE1         0x00000100  // floating point exception enable
+#define MSR_IP          0x00000040  // Exception prefix
+#define MSR_IR          0x00000020  // instruction relocate
+#define MSR_DR          0x00000010  // data relocate
+#define MSR_PM          0x00000004  // Performance monitor marked mode
+#define MSR_RI          0x00000002  // Recoverable interrupt
+#define MSR_LE          0x00000001  // Little Endian
+
+#define MSR_POW_BIT     13          // Power Management
+#define MSR_ILE_BIT     15          // Interrupt Little Endian
+#define MSR_EE_BIT      16          // external interrupt
+#define MSR_PR_BIT      17          // privilege level (should be 0)
+#define MSR_FP_BIT      18          // floating point available
+#define MSR_ME_BIT      19          // machine check enable
+#define MSR_FE0_BIT     20          // floating point exception enable
+#define MSR_SE_BIT      21          // single step trace enable
+#define MSR_BE_BIT      22          // branch trace enable
+#define MSR_FE1_BIT     23          // floating point exception enable
+#define MSR_IP_BIT      25          // Exception prefix
+#define MSR_IR_BIT      26          // instruction relocate
+#define MSR_DR_BIT      27          // data relocate
+#define MSR_PM_BIT      29          // Performance monitor marked mode
+#define MSR_RI_BIT      30          // Recoverable interrupt
+#define MSR_LE_BIT      31          // Little Endian
+
+/*---------------------------------------------------------------------------*
+    HID0 bits
+ *---------------------------------------------------------------------------*/
+#define HID0_EMCP       0x80000000  // Enable MCP
+#define HID0_DBP        0x40000000  // Enable 60x bus address and data parity chk
+#define HID0_EBA        0x20000000  // Enable 60x address parity checking
+#define HID0_EBD        0x10000000  // Enable 60x data parity checking
+#define HID0_BCLK       0x08000000  // CLK_OUT output enable and clk selection
+#define HID0_ECLK       0x02000000  // CLK_OUT output enable and clk selection
+#define HID0_PAR        0x01000000  // Disable !ARTRY precharge
+#define HID0_DOZE       0x00800000  // Doze mode enable
+#define HID0_NAP        0x00400000  // Nap mode enable
+#define HID0_SLEEP      0x00200000  // Sleep mode enable
+#define HID0_DPM        0x00100000  // Dynamic power management enable
+#define HID0_NHR        0x00010000  // Not hard reset (0 hard reset if s/w set it)
+#define HID0_ICE        0x00008000  // Instruction cache enable
+#define HID0_DCE        0x00004000  // Data cache enable
+#define HID0_ILOCK      0x00002000  // ICache lock
+#define HID0_DLOCK      0x00001000  // DCache lock
+#define HID0_ICFI       0x00000800  // ICache flash invalidate
+#define HID0_DCFI       0x00000400  // DCache flash invalidate
+#define HID0_SPD        0x00000200  // Speculative cache access enable (0 enable)
+#define HID0_IFEM       0x00000100  // Enable M bit on bus for Ifetch
+#define HID0_SGE        0x00000080  // Store gathering enable
+#define HID0_DCFA       0x00000040  // DCache flush assist - set before a flush
+#define HID0_BTIC       0x00000020  // Branch target icache enable
+#define HID0_ABE        0x00000008  // Address bcast enable
+#define HID0_BHT        0x00000004  // Branch history table enable
+#define HID0_NOOPTI     0x00000001  // No-op Dcache touch instructions
+
+#define HID0_ICE_BIT    16          // Instruction cache enable
+#define HID0_DCE_BIT    17          // Data cache enable
+#define HID0_ILOCK_BIT  18          // ICache lock
+#define HID0_DLOCK_BIT  19          // DCache lock
+
+#define HID2_LSQE           0x80000000  // L/S quantize enable
+#define HID2_WPE            0x40000000  // Write pipe enable
+#define HID2_PSE            0x20000000  // Paired single enable
+#define HID2_LCE            0x10000000  // Locked cache enable
+
+#define HID2_DCHERR         0x00800000  // ERROR: dcbz_l cache hit
+#define HID2_DNCERR         0x00400000  // ERROR: DMA access to normal cache
+#define HID2_DCMERR         0x00200000  // ERROR: DMA cache miss error
+#define HID2_DQOERR         0x00100000  // ERROR: DMA queue overflow
+#define HID2_DCHEE          0x00080000  // dcbz_l cache hit error enable
+#define HID2_DNCEE          0x00040000  // DMA access to normal cache error enable
+#define HID2_DCMEE          0x00020000  // DMA cache miss error error enable
+#define HID2_DQOEE          0x00010000  // DMA queue overflow error enable
+
+#define HID2_DMAQL_MASK     0x0F000000  // DMA queue length mask
+#define HID2_DMAQL_SHIFT    24          // DMA queue shift
+
+#define HID2_LSQE_BIT       0
+#define HID2_WPE_BIT        1
+#define HID2_PSE_BIT        2
+#define HID2_LCE_BIT        3
+
+#define HID2_DCHERR_BIT     8
+#define HID2_DNCERR_BIT     9
+#define HID2_DCMERR_BIT     10
+#define HID2_DQOERR_BIT     11
+#define HID2_DCHEE_BIT      12
+#define HID2_DNCEE_BIT      13
+#define HID2_DCMEE_BIT      14
+#define HID2_DQOEE_BIT      15
+
+#define GQR_LOAD_SCALE_MASK         0x3F000000  // load scale field
+#define GQR_LOAD_TYPE_MASK          0x00070000  // load type field
+#define GQR_STORE_SCALE_MASK        0x00003F00  // store scale field
+#define GQR_STORE_TYPE_MASK         0x00000007  // store type field
+
+typedef struct
+{
+    u32 _pad0       :2;
+    u32 loadScale   :6;
+    u32 _pad1       :5;
+    u32 loadType    :3;
+    u32 _pad2       :2;
+    u32 storeScale  :6;
+    u32 _pad3       :5;
+    u32 storeType   :3;
+} PPC_GQR_t;
+
+typedef union
+{
+    u32         val;
+    PPC_GQR_t   f;
+} PPC_GQR_u;
+
+
+#define DMA_U_ADDR_MASK             0xFFFFFFE0  // Start addr in memory
+#define DMA_U_LEN_U_MASK            0x0000001F  // lines to transfer (U)
+
+#define DMA_L_LC_ADDR_MASK          0xFFFFFFE0  // Start addr in LC
+#define DMA_L_LOAD                  0x00000010  // 0 - store, 1 - load
+#define DMA_L_STORE                 0x00000000  // 0 - store, 1 - load
+#define DMA_L_LEN_MASK              0x0000000C  // lines to transfer (L)
+#define DMA_L_TRIGGER               0x00000002  // 0 - cmd inactive, 1 - cmd rdy
+#define DMA_L_FLUSH                 0x00000001  // 1 - Flush DMA queue
+
+typedef struct
+{
+    u32 memAddr     :27;
+    u32 dmaLenU     :5;
+} PPC_DMA_U_t;
+
+typedef union
+{
+    u32             val;
+    PPC_DMA_U_t     f;
+} PPC_DMA_U_u;
+
+
+typedef struct
+{
+    u32 lcAddr      :27;
+    u32 dmaLd       :1;
+    u32 dmaLenL     :2;
+    u32 dmaTrigger  :1;
+    u32 dmaFlush    :1;
+} PPC_DMA_L_t;
+
+
+typedef union
+{
+    u32             val;
+    PPC_DMA_L_t     f;
+} PPC_DMA_L_u;
+
+
+#define WPAR_ADDR                   0xFFFFFFE0  // 32byte gather address
+#define WPAR_BNE                    0x00000001  // Buffer not empty (R)
+
+#define SRR1_DMA_BIT                0x00200000
+#define SRR1_L2DP_BIT               0x00100000
+
+#define L2CR_L2E                    0x80000000  // L2 Enable
+#define L2CR_L2PE                   0x40000000  // L2 data parity generation and checking enable
+
+#define L2CR_L2SIZ_256K             0x10000000  // L2 size 256K
+#define L2CR_L2SIZ_512K             0x20000000  // L2 size 512
+#define L2CR_L2SIZ_1M               0x30000000  // L2 size 1M
+
+#define L2CR_L2CLK_1_0              0x02000000  // L2 clock ratio 1
+#define L2CR_L2CLK_1_5              0x04000000  // L2 clock ratio 1.5
+#define L2CR_L2CLK_2_0              0x08000000  // L2 clock ratio 2
+#define L2CR_L2CLK_2_5              0x0A000000  // L2 clock ratio 2.5
+#define L2CR_L2CLK_3_0              0x0C000000  // L2 clock ratio 3
+
+#define L2CR_RAM_FLOW_THRU_BURST    0x00000000  // L2 RAM type flow-through sync. burst SRAM
+#define L2CR_RAM_PIPELINE_BURST     0x01000000  // L2 RAM type pipelined sync. burst SRAM
+#define L2CR_RAM_PIPELINE_LATE      0x01800000  // L2 RAM type pipelined sync. late-write SRAM
+
+#define L2CR_L2DO                   0x00400000  // Data only
+#define L2CR_L2I                    0x00200000  // Global invalidate
+#define L2CR_L2CTL                  0x00100000  // ZZ enable
+#define L2CR_L2WT                   0x00080000  // L2 write through
+#define L2CR_L2TS                   0x00040000  // L2 test support
+
+#define L2CR_L2OH_0_5               0x00000000  // L2 output hold 0.5 ns
+#define L2CR_L2OH_1_0               0x00010000  // L2 output hold 1.0 ns
+
+#define L2CR_L2SL                   0x00008000  // L2 DLL slow
+#define L2CR_L2DF                   0x00004000  // L2 differential clock
+#define L2CR_L2BYP                  0x00002000  // L2 DLL bypass
+#define L2CR_L2CS                   0x00000200  // L2 clock stop
+#define L2CR_L2DRO                  0x00000100  // L2 DLL rollover checkstop enable
+#define L2CR_L2CTR_MASK             0x000000FE  // L2 counter value mask
+#define L2CR_L2IP                   0x00000001  // L2 global invalidate in progress
+
+#define MMCR0_DIS                   0x80000000  // Disables counting unconditionally
+#define MMCR0_DP                    0x40000000  // Disables counting while in supervisor mode
+#define MMCR0_DU                    0x20000000  // Disables counting while in user mode
+#define MMCR0_DMS                   0x10000000  // Disables counting while MSR[PM] is set
+#define MMCR0_DMR                   0x08000000  // Disables counting while MSR[PM] is zero
+#define MMCR0_ENINT                 0x04000000  // Enables performance monitor interrupt signaling
+#define MMCR0_DISCOUNT              0x02000000  // Disables counting of PMCn when a performance monitor interrupt is signaled or...
+#define MMCR0_RTCSELECT_MASK        0x01800000  // 64-bit time base, bit selection enable
+#define MMCR0_RTCSELECT_63          0x00000000  // Pick bit 63 to count
+#define MMCR0_RTCSELECT_55          0x00800000  // Pick bit 55 to count
+#define MMCR0_RTCSELECT_51          0x01000000  // Pick bit 51 to count
+#define MMCR0_RTCSELECT_47          0x01800000  // Pick bit 47 to count
+#define MMCR0_INTONBITTRANS         0x00400000  // Causes interrupt signaling on bit transition from off to on
+#define MMCR0_THRESHOLD_MASK        0x003F0000  // Threshold value
+#define MMCR0_THRESHOLD(n)          ((n) << 16) // Threshold value (0 - 63)
+#define MMCR0_PMC1INTCONTROL        0x00008000  // Enables interrupt signaling due to PMC1 counter overflow
+#define MMCR0_PMC2INTCONTROL        0x00004000  // Enables interrupt signaling due to PMC2-PMC4 counter overflow
+#define MMCR0_PMCTRIGGER            0x00002000  // Can be used to trigger counting of PMC2-PMC4 after PMC1 has overflowed or...
+#define MMCR0_PMC1SELECT_MASK       0x00001FC0  // PMC1 input selector
+#define MMCR0_PMC2SELECT_MASK       0x0000003F  // PMC2 input selector
+
+#define MMCR1_PMC3SELECT_MASK       0xF8000000  // PMC3 input selector
+#define MMCR1_PMC4SELECT_MASK       0x07C00000  // PMC4 input selector
+
+#define PMC1_OV                     0x80000000  // Overflow
+#define PMC1_COUNTER                0x7FFFFFFF  // Counter value
+#define PMC2_OV                     0x80000000  // Overflow
+#define PMC2_COUNTER                0x7FFFFFFF  // Counter value
+#define PMC3_OV                     0x80000000  // Overflow
+#define PMC3_COUNTER                0x7FFFFFFF  // Counter value
+#define PMC4_OV                     0x80000000  // Overflow
+#define PMC4_COUNTER                0x7FFFFFFF  // Counter value
+
+/*---------------------------------------------------------------------------*
+    PMC1 Events
+ *---------------------------------------------------------------------------*/
+#define MMCR0_PMC1_HOLD             0x00000000  // Register holds current value
+#define MMCR0_PMC1_CYCLE            0x00000040  // Processor cycles
+#define MMCR0_PMC1_INSTRUCTION      0x00000080  // # of instructions completed.
+#define MMCR0_PMC1_TRANSITION       0x000000C0  // # of transitions for 0 to 1
+#define MMCR0_PMC1_DISPATCHED       0x00000100  // # of instructions dispatched
+#define MMCR0_PMC1_EIEIO            0x00000140  // # of eieio instructions completed
+#define MMCR0_PMC1_ITLB_CYCLE       0x00000180  // # of cycles spent performing table search op. for the ITLB
+#define MMCR0_PMC1_L2_HIT           0x000001C0  // # of access that hit the L2.
+#define MMCR0_PMC1_EA               0x00000200  // # of valid instruction EAs delivered to the memory subsystem
+#define MMCR0_PMC1_IABR             0x00000240  // # of time the address of an instruction matches the IABR
+#define MMCR0_PMC1_L1_MISS          0x00000280  // # of loads that miss the L1
+#define MMCR0_PMC1_Bx_UNRESOLVED    0x000002C0  // # of branches that are unresolved when processed
+#define MMCR0_PMC1_Bx_STALL_CYCLE   0x00000300  // # of cycles that dispatcher stalls due to a second
+                                                //      unresolved branch in the instruction stream
+#define MMCR0_PMC1_IC_FETCH_MISS    0x00000340  // # of times an instruction fetch missed the L1 Icache
+#define MMCR0_PMC2_HOLD             0x00000000  // Register holds current value
+#define MMCR0_PMC2_CYCLE            0x00000001  // Processor cycles
+#define MMCR0_PMC2_INSTRUCTION      0x00000002  // # of instructions completed
+#define MMCR0_PMC2_TRANSITION       0x00000003  // # of time-base (lower) bit transitions
+#define MMCR0_PMC2_DISPATCHED       0x00000004  // # of instructions dispatched
+#define MMCR0_PMC2_IC_MISS          0x00000005  // # of L1 instruction cache misses
+#define MMCR0_PMC2_ITLB_MISS        0x00000006  // # of ITLB misses
+#define MMCR0_PMC2_L2_I_MISS        0x00000007  // # of L2 instruction misses
+#define MMCR0_PMC2_Bx_FALL_TROUGH   0x00000008  // # of fall-through branches
+#define MMCR0_PMC2_PR_SWITCH        0x00000009  // # of MSR[PR] bit toggles
+#define MMCR0_PMC2_RESERVED_LOAD    0x0000000A  // # of reserved loads completed
+#define MMCR0_PMC2_LOAD_STORE       0x0000000B  // # of completed loads and stores
+#define MMCR0_PMC2_SNOOP            0x0000000C  // # of snoops
+#define MMCR0_PMC2_L1_CASTOUT       0x0000000D  // # of L1 castouts to L2
+#define MMCR0_PMC2_SYSTEM           0x0000000E  // # of completed system unit instructions
+#define MMCR0_PMC2_IC_FETCH_MISS    0x0000000F  // # of instruction fetch misses in the L1
+#define MMCR0_PMC2_Bx_OUT_OF_ORDER  0x00000010  // # of branches allowing out-of-order execution
+
+/*---------------------------------------------------------------------------*
+    PMC3 Events
+ *---------------------------------------------------------------------------*/
+#define MMCR1_PMC3_HOLD             0x00000000  // Register holds current value
+#define MMCR1_PMC3_CYCLE            0x08000000  // Processor cycles
+#define MMCR1_PMC3_INSTRUCTION      0x10000000  // # of instructions completed
+#define MMCR1_PMC3_TRANSITION       0x18000000  // # of time-base (lower) bit transitions
+#define MMCR1_PMC3_DISPATCHED       0x20000000  // # of instructions dispatched
+#define MMCR1_PMC3_DC_MISS          0x28000000  // # of L1 data cache misses
+#define MMCR1_PMC3_DTLB_MISS        0x30000000  // # of DTLB misses
+#define MMCR1_PMC3_L2_D_MISS        0x38000000  // # of L2 data misses
+#define MMCR1_PMC3_Bx_TAKEN         0x40000000  // # predicted branches that were taken
+#define MMCR1_PMC3_PM_SWITCH        0x48000000  // # of transitions between marked and unmarked processes
+#define MMCR1_PMC3_COND_STORE       0x50000000  // # of store conditional instructions completed
+#define MMCR1_PMC3_FPU              0x58000000  // # of instructions completed from the FPU
+#define MMCR1_PMC3_L2_SNOOP_CASTOUT 0x60000000  // # of L2 castout caused by snoops to modified lines
+#define MMCR1_PMC3_L2_HIT           0x68000000  // # of cache operations that hit in the L2 cache
+#define MMCR1_PMC3_L1_MISS_CYCLE    0x78000000  // # of cycles generated by L1 load misses
+#define MMCR1_PMC3_Bx_SECOND        0x80000000  // # of branches in the second speculative branch
+                                                //   resolved correctly
+#define MMCR1_PMC3_BPU_LR_CR        0x88000000  // # of cycles the BPU stalls due to LR or CR unresolved
+                                                //   dependencies
+
+#define MMCR1_PMC4_HOLD             0x00000000  // Register holds current value
+#define MMCR1_PMC4_CYCLE            0x00400000  // Processor cycles
+#define MMCR1_PMC4_INSTRUCTION      0x00800000  // # of instructions completed
+#define MMCR1_PMC4_TRANSITION       0x00C00000  // # of time-base (lower) bit transitions
+#define MMCR1_PMC4_DISPATCHED       0x01000000  // # of instructions dispatched
+#define MMCR1_PMC4_L2_CASTOUT       0x01400000  // # of L2 castouts
+#define MMCR1_PMC4_DTLB_CYCLE       0x01800000  // # of cycles spent performing table searches for DTLB accesses
+#define MMCR1_PMC4_Bx_MISSED        0x02000000  // # of mispredicted branches
+#define MMCR1_PMC4_COND_STORE_INT   0x02800000  // # of store conditional instructions completed
+                                                //   with reservation intact
+#define MMCR1_PMC4_SYNC             0x02C00000  // # of completed sync instructions
+#define MMCR1_PMC4_SNOOP_RETRY      0x03000000  // # of snoop request retries
+#define MMCR1_PMC4_INTEGER          0x03400000  // # of completed integer operations
+#define MMCR1_PMC4_BPU_THIRD        0x03800000  // # of cycles the BPU cannot process new branches
+                                                //   due to having two unresolved branches
+#define MMCR1_PMC4_DC_MISS          0x07C00000  // # of L1 data cache misses
+
+/*---------------------------------------------------------------------------*
+    FPSCR bits
+ *---------------------------------------------------------------------------*/
+#ifndef FPSCR_FX
+#define FPSCR_FX            0x80000000  // Exception summary
+#define FPSCR_FEX           0x40000000  // Enabled exception summary
+#define FPSCR_VX            0x20000000  // Invalid operation
+#define FPSCR_OX            0x10000000  // Overflow exception
+#define FPSCR_UX            0x08000000  // Underflow exception
+#define FPSCR_ZX            0x04000000  // Zero divide exception
+#define FPSCR_XX            0x02000000  // Inexact exception
+#define FPSCR_VXSNAN        0x01000000  // SNaN
+#define FPSCR_VXISI         0x00800000  // Infinity - Infinity
+#define FPSCR_VXIDI         0x00400000  // Infinity / Infinity
+#define FPSCR_VXZDZ         0x00200000  // 0 / 0
+#define FPSCR_VXIMZ         0x00100000  // Infinity * 0
+#define FPSCR_VXVC          0x00080000  // Invalid compare
+#define FPSCR_FR            0x00040000  // Fraction rounded
+#define FPSCR_FI            0x00020000  // Fraction inexact
+#define FPSCR_VXSOFT        0x00000400  // Software request
+#define FPSCR_VXSQRT        0x00000200  // Invalid square root
+#define FPSCR_VXCVI         0x00000100  // Invalid integer convert
+#define FPSCR_VE            0x00000080  // Invalid operation exception enable
+#define FPSCR_OE            0x00000040  // Overflow exception enable
+#define FPSCR_UE            0x00000020  // Underflow exception enable
+#define FPSCR_ZE            0x00000010  // Zero divide exception enable
+#define FPSCR_XE            0x00000008  // Inexact exception enable
+#define FPSCR_NI            0x00000004  // Non-IEEE mode
+#endif
+
+#ifndef FPSCR_FX_BIT
+#define FPSCR_FX_BIT        0           // Exception summary
+#define FPSCR_FEX_BIT       1           // Enabled exception summary
+#define FPSCR_VX_BIT        2           // Invalid operation
+#define FPSCR_OX_BIT        3           // Overflow exception
+#define FPSCR_UX_BIT        4           // Underflow exception
+#define FPSCR_ZX_BIT        5           // Zero divide exception
+#define FPSCR_XX_BIT        6           // Inexact exception
+#define FPSCR_VXSNAN_BIT    7           // SNaN
+#define FPSCR_VXISI_BIT     8           // Infinity - Infinity
+#define FPSCR_VXIDI_BIT     9           // Infinity / Infinity
+#define FPSCR_VXZDZ_BIT     10          // 0 / 0
+#define FPSCR_VXIMZ_BIT     11          // Infinity * 0
+#define FPSCR_VXVC_BIT      12          // Invalid compare
+#define FPSCR_FR_BIT        13          // Fraction rounded
+#define FPSCR_FI_BIT        14          // Fraction inexact
+#define FPSCR_VXSOFT_BIT    21          // Software request
+#define FPSCR_VXSQRT_BIT    22          // Invalid square root
+#define FPSCR_VXCVI_BIT     23          // Invalid integer convert
+#define FPSCR_VE_BIT        24          // Invalid operation exception enable
+#define FPSCR_OE_BIT        25          // Overflow exception enable
+#define FPSCR_UE_BIT        26          // Underflow exception enable
+#define FPSCR_ZE_BIT        27          // Zero divide exception enable
+#define FPSCR_XE_BIT        28          // Inexact exception enable
+#define FPSCR_NI_BIT        29          // Non-IEEE mode
+#endif
+
+u32 PPCMfmsr();
+void PPCMtmsr(u32 newMSR);
+u32 PPCOrMsr(u32 value);
+u32 PPCMfhid0();
+void PPCMthid0(u32 newHID0);
+u32 PPCMfl2cr();
+void PPCMtl2cr(u32 newL2cr);
+void PPCMtdec(u32 newDec);
+void PPCSync();
+void PPCHalt();
+u32 PPCMffpscr();
+void PPCMtfpscr(u32 newFPSCR);
+u32 PPCMfhid2();
+void PPCMthid2(u32 newhid2);
+u32 PPCMfwpar();
+void PPCMtwpar(u32 newwpar);
+void PPCEnableSpeculation();
+void PPCDisableSpeculation();
+void PPCSetFpIEEEMode();
+void PPCSetFpNonIEEEMode();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_PPCARCH

include/dolphin/__ppc_eabi_init.h

@@ -0,0 +1,19 @@
+#ifndef _DOLPHIN__PPC_EABI_INIT
+#define _DOLPHIN__PPC_EABI_INIT
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+__declspec(section ".init") void __init_hardware(void);
+__declspec(section ".init") void __flush_cache(register void* address, register unsigned int size);
+
+void __init_user(void);
+void __init_cpp(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN__PPC_EABI_INIT

include/dolphin/__start.h

@@ -0,0 +1,44 @@
+#ifndef _DOLPHIN__START
+#define _DOLPHIN__START
+
+#include "dolphin/db.h"
+#include "types.h"
+
+#define PAD3_BUTTON_ADDR 0x800030E4
+#define OS_RESET_RESTART 0
+#define EXCEPTIONMASK_ADDR 0x80000044
+#define BOOTINFO2_ADDR 0x800000F4
+#define OS_BI2_DEBUGFLAG_OFFSET 0xC
+#define ARENAHI_ADDR 0x80000034
+#define DEBUGFLAG_ADDR 0x800030E8
+#define DVD_DEVICECODE_ADDR 0x800030E6
+
+#define MSR_FP 0x2000
+
+extern void InitMetroTRK();
+
+u16 Pad3Button : PAD3_BUTTON_ADDR;
+static u8 Debug_BBA = 0;
+
+extern void memset(void*, int, int);
+extern int main(int argc, char* argv[]);
+extern void exit(int);
+extern void __init_user(void);
+extern void OSInit(void);
+extern void DBInit(void);
+extern void OSResetSystem(BOOL reset, u32 resetCode, BOOL forceMenu);
+extern void __OSCacheInit(void);
+extern void __OSPSInit(void);
+
+__declspec(section ".init") extern void __check_pad3(void);
+__declspec(section ".init") extern void __start(void);
+__declspec(section ".init") extern void __init_registers(void);
+__declspec(section ".init") extern void __init_data(void);
+__declspec(section ".init") extern void __init_hardware(void);
+__declspec(section ".init") extern void __flush_cache(void* address, unsigned int size);
+
+__declspec(section ".init") extern char _stack_addr[];
+__declspec(section ".init") extern char _SDA_BASE_[];
+__declspec(section ".init") extern char _SDA2_BASE_[];
+
+#endif // _DOLPHIN__START

include/dolphin/ai.h

@@ -0,0 +1,43 @@
+#ifndef _DOLPHIN_AI
+#define _DOLPHIN_AI
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void (*AISCallback)(u32 count);
+typedef void (*AIDCallback)();
+
+AIDCallback AIRegisterDMACallback(AIDCallback callback);
+void AIInitDMA(u32 start_addr, u32 length);
+BOOL AIGetDMAEnableFlag();
+void AIStartDMA();
+void AIStopDMA();
+u32 AIGetDMABytesLeft();
+u32 AIGetDMAStartAddr();
+u32 AIGetDMALength();
+u32 AIGetDSPSampleRate();
+void AISetDSPSampleRate(u32 rate);
+AISCallback AIRegisterStreamCallback(AISCallback callback);
+u32 AIGetStreamSampleCount();
+void AIResetStreamSampleCount();
+void AISetStreamTrigger(u32 trigger);
+u32 AIGetStreamTrigger();
+void AISetStreamPlayState(u32 state);
+u32 AIGetStreamPlayState();
+void AISetStreamSampleRate(u32 rate);
+u32 AIGetStreamSampleRate();
+void AISetStreamVolLeft(u8 vol);
+void AISetStreamVolRight(u8 vol);
+u8 AIGetStreamVolLeft();
+u8 AIGetStreamVolRight();
+void AIInit(u8* stack);
+BOOL AICheckInit();
+void AIReset();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_AI

include/dolphin/ar.h

@@ -0,0 +1,45 @@
+#ifndef _DOLPHIN_AR
+#define _DOLPHIN_AR
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define AR_STACK_INDEX_ENTRY_SIZE sizeof(u32)
+
+#define ARAM_DIR_MRAM_TO_ARAM 0x00
+#define ARAM_DIR_ARAM_TO_MRAM 0x01
+
+#define AR_CLEAR_INTERNAL_ALL 0x00
+#define AR_CLEAR_INTERNAL_USER 0x01
+#define AR_CLEAR_EXPANSION 0x02
+
+typedef void (*ARCallback)(void);
+
+ARCallback ARRegisterDMACallback(ARCallback callback);
+u32 ARGetDMAStatus(void);
+void ARStartDMA(u32 type, u32 mainmem_addr, u32 aram_addr, u32 length);
+u32 ARInit(u32* stack_index_addr, u32 num_entries);
+u32 ARGetBaseAddress(void);
+BOOL ARCheckInit(void);
+void ARReset(void);
+u32 ARAlloc(u32 length);
+u32 ARFree(u32* length);
+u32 ARGetSize(void);
+u32 ARGetInternalSize(void);
+void ARSetSize(void);
+void ARClear(u32 flag);
+
+void __ARClearInterrupt(void);
+u16 __ARGetInterruptStatus(void);
+
+#define ARStartDMARead(mmem, aram, len) ARStartDMA(ARAM_DIR_ARAM_TO_MRAM, mmem, aram, len)
+#define ARStartDMAWrite(mmem, aram, len) ARStartDMA(ARAM_DIR_MRAM_TO_ARAM, mmem, aram, len)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_AR

include/dolphin/arq.h

@@ -0,0 +1,53 @@
+#ifndef _DOLPHIN_ARQ
+#define _DOLPHIN_ARQ
+
+#include "types.h"
+
+#include "dolphin/ar.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "dolphin/ar.h"
+
+#define ARQ_DMA_ALIGNMENT 32
+#define ARQ_CHUNK_SIZE_DEFAULT 4096
+
+#define ARQ_TYPE_MRAM_TO_ARAM ARAM_DIR_MRAM_TO_ARAM
+#define ARQ_TYPE_ARAM_TO_MRAM ARAM_DIR_ARAM_TO_MRAM
+
+#define ARQ_PRIORITY_LOW 0
+#define ARQ_PRIORITY_HIGH 1
+
+typedef void (*ARQCallback)(u32 pointerToARQRequest);
+
+typedef struct ARQRequest {
+
+  struct ARQRequest* next;
+  u32 owner;
+  u32 type;
+  u32 priority;
+  u32 source;
+  u32 dest;
+  u32 length;
+  ARQCallback callback;
+
+} ARQRequest;
+
+void ARQInit(void);
+void ARQReset(void);
+void ARQPostRequest(ARQRequest* task, u32 owner, u32 type, u32 priority, u32 source, u32 dest,
+                    u32 length, ARQCallback callback);
+void ARQRemoveRequest(ARQRequest* task);
+void ARQRemoveOwnerRequest(u32 owner);
+void ARQFlushQueue(void);
+void ARQSetChunkSize(u32 size);
+u32 ARQGetChunkSize(void);
+BOOL ARQCheckInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_ARQ

include/dolphin/card.h

@@ -0,0 +1,176 @@
+#ifndef _DOLPHIN_CARD
+#define _DOLPHIN_CARD
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define CARD_ENCODE_ANSI 0u
+#define CARD_ENCODE_SJIS 1u
+
+/* Sizes */
+#define CARD_WORKAREA_SIZE (5 * 8 * 1024)
+#define CARD_READ_SIZE 512
+#define CARD_MAX_FILE 127
+#define CARD_COMMENT_SIZE 64
+#define CARD_FILENAME_MAX 32
+#define CARD_ICON_MAX 8
+#define CARD_ICON_WIDTH 32
+#define CARD_ICON_HEIGHT 32
+#define CARD_BANNER_WIDTH 96
+#define CARD_BANNER_HEIGHT 32
+
+/* Icon animation */
+#define CARD_MODE_NORMAL 0
+#define CARD_MODE_FAST 1
+
+#define CARDGetBannerFormat(stat) (((stat)->bannerFormat) & CARD_STAT_BANNER_MASK)
+#define CARDGetIconAnim(stat) (((stat)->bannerFormat) & CARD_STAT_ANIM_MASK)
+#define CARDGetIconFormat(stat, n) (((stat)->iconFormat >> (2 * (n))) & CARD_STAT_ICON_MASK)
+#define CARDGetIconSpeed(stat, n) (((stat)->iconSpeed >> (2 * (n))) & CARD_STAT_SPEED_MASK)
+#define CARDSetBannerFormat(stat, f)                                                               \
+  ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_BANNER_MASK) | (f)))
+#define CARDSetIconAnim(stat, f)                                                                   \
+  ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_ANIM_MASK) | (f)))
+#define CARDSetIconFormat(stat, n, f)                                                              \
+  ((stat)->iconFormat =                                                                            \
+       (u16)(((stat)->iconFormat & ~(CARD_STAT_ICON_MASK << (2 * (n)))) | ((f) << (2 * (n)))))
+#define CARDSetIconSpeed(stat, n, f)                                                               \
+  ((stat)->iconSpeed =                                                                             \
+       (u16)(((stat)->iconSpeed & ~(CARD_STAT_SPEED_MASK << (2 * (n)))) | ((f) << (2 * (n)))))
+#define CARDSetIconAddress(stat, addr) ((stat)->iconAddr = (u32)(addr))
+#define CARDSetCommentAddress(stat, addr) ((stat)->commentAddr = (u32)(addr))
+#define CARDGetFileNo(fileInfo) ((fileInfo)->fileNo)
+
+#define CARD_RESULT_UNLOCKED 1
+#define CARD_RESULT_READY 0
+#define CARD_RESULT_BUSY -1
+#define CARD_RESULT_WRONGDEVICE -2
+#define CARD_RESULT_NOCARD -3
+#define CARD_RESULT_NOFILE -4
+#define CARD_RESULT_IOERROR -5
+#define CARD_RESULT_BROKEN -6
+#define CARD_RESULT_EXIST -7
+#define CARD_RESULT_NOENT -8
+#define CARD_RESULT_INSSPACE -9
+#define CARD_RESULT_NOPERM -10
+#define CARD_RESULT_LIMIT -11
+#define CARD_RESULT_NAMETOOLONG -12
+#define CARD_RESULT_ENCODING -13
+#define CARD_RESULT_CANCELED -14
+#define CARD_RESULT_FATAL_ERROR -128
+
+#define CARD_STAT_ICON_NONE 0
+#define CARD_STAT_ICON_C8 1
+#define CARD_STAT_ICON_RGB5A3 2
+#define CARD_STAT_ICON_MASK 3
+
+#define CARD_STAT_BANNER_NONE 0
+#define CARD_STAT_BANNER_C8 1
+#define CARD_STAT_BANNER_RGB5A3 2
+#define CARD_STAT_BANNER_MASK 3
+
+#define CARD_STAT_ANIM_LOOP 0x00
+#define CARD_STAT_ANIM_BOUNCE 0x04
+#define CARD_STAT_ANIM_MASK 0x04
+
+#define CARD_STAT_SPEED_END 0
+#define CARD_STAT_SPEED_FAST 1
+#define CARD_STAT_SPEED_MIDDLE 2
+#define CARD_STAT_SPEED_SLOW 3
+#define CARD_STAT_SPEED_MASK 3
+
+#define CARD_ATTR_PUBLIC 0x04u
+#define CARD_ATTR_NO_COPY 0x08u
+#define CARD_ATTR_NO_MOVE 0x10u
+#define CARD_ATTR_GLOBAL 0x20u
+#define CARD_ATTR_COMPANY 0x40u
+
+typedef struct CARDFileInfo {
+  s32 chan;
+  s32 fileNo;
+
+  s32 offset;
+  s32 length;
+  u16 iBlock;
+  u16 __padding;
+} CARDFileInfo;
+
+typedef struct CARDStat {
+  char fileName[CARD_FILENAME_MAX];
+  u32 length;
+  u32 time; // seconds since 01/01/2000 midnight
+  u8 gameName[4];
+  u8 company[2];
+
+  u8 bannerFormat;
+  u8 __padding;
+  u32 iconAddr; // offset to the banner, bannerTlut, icon, iconTlut data set.
+  u16 iconFormat;
+  u16 iconSpeed;
+  u32 commentAddr; // offset to the pair of 32 byte character strings.
+
+  u32 offsetBanner;
+  u32 offsetBannerTlut;
+  u32 offsetIcon[CARD_ICON_MAX];
+  u32 offsetIconTlut;
+  u32 offsetData;
+} CARDStat;
+
+typedef void (*CARDCallback)(s32 chan, s32 result);
+
+void CARDInit(void);
+BOOL CARDGetFastMode(void);
+BOOL CARDSetFastMode(BOOL enable);
+
+s32 CARDCheck(s32 chan);
+s32 CARDCheckAsync(s32 chan, CARDCallback callback);
+s32 CARDCheckEx(s32 chan, s32* xferBytes);
+s32 CARDCheckExAsync(s32 chan, s32* xferBytes, CARDCallback callback);
+s32 CARDCreate(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo);
+s32 CARDCreateAsync(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo,
+                    CARDCallback callback);
+s32 CARDDelete(s32 chan, const char* fileName);
+s32 CARDDeleteAsync(s32 chan, const char* fileName, CARDCallback callback);
+s32 CARDFastDelete(s32 chan, s32 fileNo);
+s32 CARDFastDeleteAsync(s32 chan, s32 fileNo, CARDCallback callback);
+s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo* fileInfo);
+s32 CARDFormat(s32 chan);
+s32 CARDFormatAsync(s32 chan, CARDCallback callback);
+s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed);
+s32 CARDGetAttributes(s32 chan, s32 fileNo, u8* attr);
+s32 CARDGetEncoding(s32 chan, u16* encode);
+s32 CARDGetMemSize(s32 chan, u16* size);
+s32 CARDGetResultCode(s32 chan);
+s32 CARDGetSectorSize(s32 chan, u32* size);
+s32 CARDGetSerialNo(s32 chan, u64* serialNo);
+s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat* stat);
+s32 CARDGetXferredBytes(s32 chan);
+s32 CARDMount(s32 chan, void* workArea, CARDCallback detachCallback);
+s32 CARDMountAsync(s32 chan, void* workArea, CARDCallback detachCallback,
+                   CARDCallback attachCallback);
+s32 CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo);
+BOOL CARDProbe(s32 chan);
+s32 CARDProbeEx(s32 chan, s32* memSize, s32* sectorSize);
+s32 CARDRename(s32 chan, const char* oldName, const char* newName);
+s32 CARDRenameAsync(s32 chan, const char* oldName, const char* newName, CARDCallback callback);
+s32 CARDSetAttributesAsync(s32 chan, s32 fileNo, u8 attr, CARDCallback callback);
+s32 CARDSetAttributes(s32 chan, s32 fileNo, u8 attr);
+s32 CARDSetStatus(s32 chan, s32 fileNo, CARDStat* stat);
+s32 CARDSetStatusAsync(s32 chan, s32 fileNo, CARDStat* stat, CARDCallback callback);
+s32 CARDUnmount(s32 chan);
+s32 CARDGetCurrentMode(s32 chan, u32* mode);
+s32 CARDCancel(CARDFileInfo* fileInfo);
+s32 CARDClose(CARDFileInfo* fileInfo);
+s32 CARDRead(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset);
+s32 CARDReadAsync(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset,
+                  CARDCallback callback);
+s32 CARDWrite(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset);
+s32 CARDWriteAsync(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset,
+                   CARDCallback callback);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _DOLPHIN_CARD

include/dolphin/db.h

@@ -0,0 +1,31 @@
+#ifndef _DOLPHIN_DB
+#define _DOLPHIN_DB
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_DBINTERFACE_ADDR 0x00000040
+
+typedef struct DBInterface
+{
+    u32     bPresent;
+    u32     exceptionMask;
+    void    (*ExceptionDestination) ( void );
+    void    *exceptionReturn;
+} DBInterface;
+
+extern DBInterface* __DBInterface;
+
+void DBInit(void);
+void DBInitComm(int* inputFlagPtr, int* mtrCallback);
+static void __DBExceptionDestination(void);
+void DBPrintf(char* format, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_DB

include/dolphin/dsp.h

@@ -0,0 +1,70 @@
+#ifndef _DOLPHIN_DSP
+#define _DOLPHIN_DSP
+
+#include "types.h"
+#include <dolphin/os.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DSP_TASK_FLAG_CLEARALL 0x00000000
+#define DSP_TASK_FLAG_ATTACHED 0x00000001
+#define DSP_TASK_FLAG_CANCEL 0x00000002
+
+#define DSP_TASK_STATE_INIT 0
+#define DSP_TASK_STATE_RUN 1
+#define DSP_TASK_STATE_YIELD 2
+#define DSP_TASK_STATE_DONE 3
+
+typedef void (*DSPCallback)(void* task);
+
+typedef struct STRUCT_DSP_TASK {
+  vu32 state;
+  vu32 priority;
+  vu32 flags;
+  u16* iram_mmem_addr;
+  u32 iram_length;
+  u32 iram_addr;
+
+  u16* dram_mmem_addr;
+  u32 dram_length;
+  u32 dram_addr;
+
+  u16 dsp_init_vector;
+  u16 dsp_resume_vector;
+
+  DSPCallback init_cb;
+  DSPCallback res_cb;
+  DSPCallback done_cb;
+  DSPCallback req_cb;
+
+  struct STRUCT_DSP_TASK* next;
+  struct STRUCT_DSP_TASK* prev;
+
+  OSTime t_context;
+  OSTime t_task;
+
+} DSPTaskInfo;
+
+void DSPInit();
+void DSPReset();
+void DSPHalt();
+void DSPSendMailToDSP(u32 mail);
+u32 DSPCheckMailToDSP();
+u32 DSPCheckMailFromDSP();
+u32 DSPGetDMAStatus();
+
+DSPTaskInfo* DSPAddTask(DSPTaskInfo* task);
+
+void __DSP_exec_task(DSPTaskInfo* curr, DSPTaskInfo* next);
+void __DSP_boot_task(DSPTaskInfo* task);
+void __DSP_remove_task(DSPTaskInfo* task);
+void __DSP_add_task(DSPTaskInfo* task);
+void __DSP_debug_printf(const char* fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_DSP

include/dolphin/dtk.h

@@ -0,0 +1,47 @@
+#ifndef _DOLPHIN_DTK
+#define _DOLPHIN_DTK
+
+#include <dolphin/dvd.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void (*DTKCallback)(u32 eventMask);
+typedef void (*DTKFlushCallback)(void);
+
+typedef struct DTKTrack {
+  struct DTKTrack* prev;
+  struct DTKTrack* next;
+  char* fileName;
+  u32 eventMask;
+  DTKCallback callback;
+  DVDFileInfo dvdFileInfo;
+
+} DTKTrack;
+
+void DTKInit(void);
+void DTKShutdown(void);
+u32 DTKQueueTrack(char* fileName, DTKTrack* track, u32 eventMask, DTKCallback callback);
+u32 DTKRemoveTrack(DTKTrack* track);
+void DTKFlushTracks(DTKFlushCallback callback);
+void DTKSetSampleRate(u32 samplerate);
+u32 DTKGetSampleRate(void);
+void DTKSetInterruptFrequency(u32 samples);
+u32 DTKGetInterruptFrequency(void);
+void DTKSetRepeatMode(u32 repeat);
+u32 DTKGetRepeatMode(void);
+void DTKSetState(u32 state);
+u32 DTKGetState(void);
+void DTKNextTrack(void);
+void DTKPrevTrack(void);
+u32 DTKGetPosition(void);
+DTKTrack* DTKGetCurrentTrack(void);
+void DTKSetVolume(u8 left, u8 right);
+u16 DTKGetVolume(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_DTK

include/dolphin/dvd.h

@@ -0,0 +1,131 @@
+#ifndef _DOLPHIN_DVD
+#define _DOLPHIN_DVD
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DVD_MIN_TRANSFER_SIZE 32
+
+#define DVD_STATE_FATAL_ERROR -1
+#define DVD_STATE_END 0
+#define DVD_STATE_BUSY 1
+#define DVD_STATE_WAITING 2
+#define DVD_STATE_COVER_CLOSED 3
+#define DVD_STATE_NO_DISK 4
+#define DVD_STATE_COVER_OPEN 5
+#define DVD_STATE_WRONG_DISK 6
+#define DVD_STATE_MOTOR_STOPPED 7
+#define DVD_STATE_PAUSING 8
+#define DVD_STATE_IGNORED 9
+#define DVD_STATE_CANCELED 10
+#define DVD_STATE_RETRY 11
+
+#define DVD_FILEINFO_READY 0
+#define DVD_FILEINFO_BUSY 1
+
+#define DVD_RESULT_GOOD 0
+#define DVD_RESULT_FATAL_ERROR -1
+#define DVD_RESULT_IGNORED -2
+#define DVD_RESULT_CANCELED -3
+
+#define DVD_AIS_SUCCESS 0x0
+
+typedef struct DVDDiskID {
+  char gameName[4];
+  char company[2];
+  u8 diskNumber;
+  u8 gameVersion;
+  u8 streaming;
+  u8 streamingBufSize; // 0 = default
+  u8 padding[22];      // 0's are stored
+} DVDDiskID;
+
+typedef struct DVDCommandBlock DVDCommandBlock;
+
+typedef void (*DVDCBCallback)(s32 result, DVDCommandBlock* block);
+
+struct DVDCommandBlock {
+  DVDCommandBlock* next;
+  DVDCommandBlock* prev;
+  u32 command;
+  s32 state;
+  u32 offset;
+  u32 length;
+  void* addr;
+  u32 currTransferSize;
+  u32 transferredSize;
+  DVDDiskID* id;
+  DVDCBCallback callback;
+  void* userData;
+};
+
+typedef struct DVDFileInfo DVDFileInfo;
+
+typedef void (*DVDCallback)(s32 result, DVDFileInfo* fileInfo);
+
+struct DVDFileInfo {
+  DVDCommandBlock cb;
+  u32 startAddr;
+  u32 length;
+  DVDCallback callback;
+};
+
+typedef struct {
+  u32 entryNum;
+  u32 location;
+  u32 next;
+} DVDDir;
+
+typedef struct {
+  u32 entryNum;
+  BOOL isDir;
+  char* name;
+} DVDDirEntry;
+
+void DVDInit();
+BOOL DVDClose(DVDFileInfo* f);
+BOOL DVDSetAutoFatalMessaging(BOOL);
+void DVDReset();
+s32 DVDCancel(DVDCommandBlock* block);
+BOOL DVDOpen(char* fileName, DVDFileInfo* fileInfo);
+BOOL DVDFastOpen(s32 entrynum, DVDFileInfo* fileInfo);
+s32 DVDGetCommandBlockStatus(const DVDCommandBlock* block);
+BOOL DVDCancelAsync(DVDCommandBlock* block, DVDCBCallback callback);
+s32 DVDCancel(DVDCommandBlock* block);
+BOOL DVDCancelAllAsync(DVDCBCallback callback);
+s32 DVDCancelAll(void);
+BOOL DVDPrepareStreamAsync(DVDFileInfo* fInfo, u32 length, u32 offset, DVDCallback callback);
+s32 DVDPrepareStream(DVDFileInfo* fInfo, u32 length, u32 offset);
+
+BOOL DVDCancelStreamAsync(DVDCommandBlock* block, DVDCBCallback callback);
+s32 DVDCancelStream(DVDCommandBlock* block);
+
+BOOL DVDStopStreamAtEndAsync(DVDCommandBlock* block, DVDCBCallback callback);
+s32 DVDStopStreamAtEnd(DVDCommandBlock* block);
+
+BOOL DVDGetStreamErrorStatusAsync(DVDCommandBlock* block, DVDCBCallback callback);
+s32 DVDGetStreamErrorStatus(DVDCommandBlock* block);
+
+BOOL DVDGetStreamPlayAddrAsync(DVDCommandBlock* block, DVDCBCallback callback);
+s32 DVDGetStreamPlayAddr(DVDCommandBlock* block);
+
+s32 DVDGetDriveStatus();
+
+s32 DVDConvertPathToEntrynum(char* pathPtr);
+
+BOOL DVDReadAsyncPrio(DVDFileInfo* fileInfo, void* addr, s32 length, s32 offset,
+                      DVDCallback callback, s32 prio);
+                      
+#define DVDReadAsync(fileInfo, addr, length, offset, callback)                                     \
+  DVDReadAsyncPrio((fileInfo), (addr), (length), (offset), (callback), 2)
+#define DVDSeekAsync(fileInfo, offset, callback)                                                   \
+  DVDSeekAsyncPrio((fileInfo), (offset), (callback), 2)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_DVD

include/dolphin/gba.h

@@ -0,0 +1,65 @@
+#ifndef _DOLPHIN_GBA
+#define _DOLPHIN_GBA
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GBA_CHAN0 0
+#define GBA_CHAN1 1
+#define GBA_CHAN2 2
+#define GBA_CHAN3 3
+#define GBA_MAX_CHAN 4
+
+#define GBA_ALL_KEY_MASK 0x03ff
+#define GBA_A_BUTTON 0x0001
+#define GBA_B_BUTTON 0x0002
+#define GBA_SELECT_BUTTON 0x0004
+#define GBA_START_BUTTON 0x0008
+#define GBA_R_KEY 0x0010
+#define GBA_L_KEY 0x0020
+#define GBA_U_KEY 0x0040
+#define GBA_D_KEY 0x0080
+#define GBA_R_BUTTON 0x0100
+#define GBA_L_BUTTON 0x0200
+
+#define GBA_JSTAT_MASK 0x3a
+#define GBA_JSTAT_FLAGS_SHIFT 4
+#define GBA_JSTAT_FLAGS_MASK 0x30
+#define GBA_JSTAT_PSF1 0x20
+#define GBA_JSTAT_PSF0 0x10
+#define GBA_JSTAT_SEND 0x08
+#define GBA_JSTAT_RECV 0x02
+
+#define GBA_READY 0
+#define GBA_NOT_READY 1
+#define GBA_BUSY 2
+#define GBA_JOYBOOT_UNKNOWN_STATE 3
+#define GBA_JOYBOOT_ERR_INVALID 4
+
+#define GBA_JOYBOOT_PROGRAM_SIZE_MAX 0x40000
+
+#define GBA_JOYBOOT_BOOTPARAM_OFFSET 0xc8
+#define GBA_JOYBOOT_BOOTPARAM_SIZE 0x18
+typedef void (*GBACallback)(s32 chan, s32 ret);
+void GBAInit(void);
+s32 GBAGetStatus(s32 chan, u8* status);
+s32 GBAGetStatusAsync(s32 chan, u8* status, GBACallback callback);
+s32 GBAReset(s32 chan, u8* status);
+s32 GBAResetAsync(s32 chan, u8* status, GBACallback callback);
+s32 GBAGetProcessStatus(s32 chan, u8* percentp);
+s32 GBARead(s32 chan, u8* dst, u8* status);
+s32 GBAReadAsync(s32 chan, u8* dst, u8* status, GBACallback callback);
+s32 GBAWrite(s32 chan, u8* src, u8* status);
+s32 GBAWriteAsync(s32 chan, u8* src, u8* status, GBACallback callback);
+s32 GBAJoyBoot(s32 chan, s32 palette_color, s32 palette_speed, u8* programp, s32 length,
+               u8* status);
+s32 GBAJoyBootAsync(s32 chan, s32 palette_color, s32 palette_speed, u8* programp, s32 length,
+                    u8* status, GBACallback callback);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GBA

include/dolphin/gx.h

@@ -0,0 +1,26 @@
+#ifndef _DOLPHIN_GX
+#define _DOLPHIN_GX
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#include <dolphin/gx/GXBump.h>
+#include <dolphin/gx/GXCommandList.h>
+#include <dolphin/gx/GXCull.h>
+#include <dolphin/gx/GXDispList.h>
+#include <dolphin/gx/GXDraw.h>
+#include <dolphin/gx/GXExtra.h>
+#include <dolphin/gx/GXFifo.h>
+#include <dolphin/gx/GXFrameBuffer.h>
+#include <dolphin/gx/GXGeometry.h>
+#include <dolphin/gx/GXGet.h>
+#include <dolphin/gx/GXLighting.h>
+#include <dolphin/gx/GXManage.h>
+#include <dolphin/gx/GXPerf.h>
+#include <dolphin/gx/GXPixel.h>
+#include <dolphin/gx/GXTev.h>
+#include <dolphin/gx/GXTexture.h>
+#include <dolphin/gx/GXTransform.h>
+#include <dolphin/gx/GXVert.h>
+
+#endif // _DOLPHIN_GX

include/dolphin/gx/GXBump.h

@@ -0,0 +1,30 @@
+#ifndef _DOLPHIN_GXBUMP
+#define _DOLPHIN_GXBUMP
+
+#include <dolphin/gx/GXEnum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetTevDirect(GXTevStageID tev_stage);
+void GXSetNumIndStages(u8 nIndStages);
+#ifdef TARGET_PC
+void GXSetIndTexMtx(GXIndTexMtxID mtx_sel, const void* offset, s8 scale_exp);
+#else
+void GXSetIndTexMtx(GXIndTexMtxID mtx_sel, f32 offset[2][3], s8 scale_exp);
+#endif
+void GXSetIndTexOrder(GXIndTexStageID ind_stage, GXTexCoordID tex_coord, GXTexMapID tex_map);
+void GXSetTevIndirect(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexFormat format,
+                      GXIndTexBiasSel bias_sel, GXIndTexMtxID matrix_sel, GXIndTexWrap wrap_s,
+                      GXIndTexWrap wrap_t, GXBool add_prev, GXBool ind_lod,
+                      GXIndTexAlphaSel alpha_sel);
+void GXSetTevIndWarp(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXBool signed_offsets,
+                     GXBool replace_mode, GXIndTexMtxID matrix_sel);
+void GXSetIndTexCoordScale(GXIndTexStageID ind_state, GXIndTexScale scale_s, GXIndTexScale scale_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXBUMP

include/dolphin/gx/GXCommandList.h

@@ -0,0 +1,35 @@
+#ifndef _DOLPHIN_GXCOMMANDLIST
+#define _DOLPHIN_GXCOMMANDLIST
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GX_NOP 0x00
+#define GX_DRAW_QUADS 0x80
+#define GX_DRAW_TRIANGLES 0x90
+#define GX_DRAW_TRIANGLE_STRIP 0x98
+#define GX_DRAW_TRIANGLE_FAN 0xA0
+#define GX_DRAW_LINES 0xA8
+#define GX_DRAW_LINE_STRIP 0xB0
+#define GX_DRAW_POINTS 0xB8
+
+#define GX_LOAD_BP_REG 0x61
+#define GX_LOAD_CP_REG 0x08
+#define GX_LOAD_XF_REG 0x10
+#define GX_LOAD_INDX_A 0x20
+#define GX_LOAD_INDX_B 0x28
+#define GX_LOAD_INDX_C 0x30
+#define GX_LOAD_INDX_D 0x38
+
+#define GX_CMD_CALL_DL 0x40
+#define GX_CMD_INVL_VC 0x48
+
+#define GX_OPCODE_MASK 0xF8
+#define GX_VAT_MASK 0x07
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXCOMMANDLIST

include/dolphin/gx/GXCull.h

@@ -0,0 +1,18 @@
+#ifndef _DOLPHIN_GXCULL
+#define _DOLPHIN_GXCULL
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetScissor(u32 left, u32 top, u32 wd, u32 ht);
+void GXSetCullMode(GXCullMode mode);
+void GXSetCoPlanar(GXBool enable);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXCULL

include/dolphin/gx/GXDispList.h

@@ -0,0 +1,18 @@
+#ifndef _DOLPHIN_GXDISPLIST
+#define _DOLPHIN_GXDISPLIST
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXBeginDisplayList(void* list, u32 size);
+u32 GXEndDisplayList(void);
+void GXCallDisplayList(const void* list, u32 nbytes);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXDISPLIST

include/dolphin/gx/GXDraw.h

@@ -0,0 +1,16 @@
+#ifndef _DOLPHIN_GXDRAW
+#define _DOLPHIN_GXDRAW
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXDrawSphere(u8 numMajor, u8 numMinor);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXDRAW

include/dolphin/gx/GXEnum.h

@@ -0,0 +1,910 @@
+#ifndef _DOLPHIN_GXENUM
+#define _DOLPHIN_GXENUM
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef TARGET_PC
+#include <stdbool.h>
+
+typedef bool GXBool;
+#else
+typedef u8 GXBool;
+#endif
+
+#define GX_FALSE ((GXBool)0)
+#define GX_TRUE ((GXBool)1)
+
+#define GX_ENABLE ((GXBool)1)
+#define GX_DISABLE ((GXBool)0)
+
+typedef enum _GXProjectionType {
+  GX_PERSPECTIVE,
+  GX_ORTHOGRAPHIC,
+} GXProjectionType;
+
+typedef enum _GXCompare {
+  GX_NEVER,
+  GX_LESS,
+  GX_EQUAL,
+  GX_LEQUAL,
+  GX_GREATER,
+  GX_NEQUAL,
+  GX_GEQUAL,
+  GX_ALWAYS,
+} GXCompare;
+
+typedef enum _GXAlphaOp {
+  GX_AOP_AND,
+  GX_AOP_OR,
+  GX_AOP_XOR,
+  GX_AOP_XNOR,
+  GX_MAX_ALPHAOP,
+} GXAlphaOp;
+
+typedef enum _GXZFmt16 {
+  GX_ZC_LINEAR,
+  GX_ZC_NEAR,
+  GX_ZC_MID,
+  GX_ZC_FAR,
+} GXZFmt16;
+
+typedef enum _GXGamma {
+  GX_GM_1_0,
+  GX_GM_1_7,
+  GX_GM_2_2,
+} GXGamma;
+
+typedef enum _GXPixelFmt {
+  GX_PF_RGB8_Z24,
+  GX_PF_RGBA6_Z24,
+  GX_PF_RGB565_Z16,
+  GX_PF_Z24,
+  GX_PF_Y8,
+  GX_PF_U8,
+  GX_PF_V8,
+  GX_PF_YUV420,
+} GXPixelFmt;
+
+typedef enum _GXPrimitive {
+  GX_QUADS = 0x80,
+  GX_TRIANGLES = 0x90,
+  GX_TRIANGLESTRIP = 0x98,
+  GX_TRIANGLEFAN = 0xA0,
+  GX_LINES = 0xA8,
+  GX_LINESTRIP = 0xB0,
+  GX_POINTS = 0xB8,
+} GXPrimitive;
+
+typedef enum _GXVtxFmt {
+  GX_VTXFMT0,
+  GX_VTXFMT1,
+  GX_VTXFMT2,
+  GX_VTXFMT3,
+  GX_VTXFMT4,
+  GX_VTXFMT5,
+  GX_VTXFMT6,
+  GX_VTXFMT7,
+  GX_MAX_VTXFMT,
+} GXVtxFmt;
+
+typedef enum _GXAttr {
+  GX_VA_PNMTXIDX,
+  GX_VA_TEX0MTXIDX,
+  GX_VA_TEX1MTXIDX,
+  GX_VA_TEX2MTXIDX,
+  GX_VA_TEX3MTXIDX,
+  GX_VA_TEX4MTXIDX,
+  GX_VA_TEX5MTXIDX,
+  GX_VA_TEX6MTXIDX,
+  GX_VA_TEX7MTXIDX,
+  GX_VA_POS,
+  GX_VA_NRM,
+  GX_VA_CLR0,
+  GX_VA_CLR1,
+  GX_VA_TEX0,
+  GX_VA_TEX1,
+  GX_VA_TEX2,
+  GX_VA_TEX3,
+  GX_VA_TEX4,
+  GX_VA_TEX5,
+  GX_VA_TEX6,
+  GX_VA_TEX7,
+  GX_POS_MTX_ARRAY,
+  GX_NRM_MTX_ARRAY,
+  GX_TEX_MTX_ARRAY,
+  GX_LIGHT_ARRAY,
+  GX_VA_NBT,
+  GX_VA_MAX_ATTR,
+  GX_VA_NULL = 0xFF,
+} GXAttr;
+
+#define GX_MAX_VTXDESCLIST_SZ (GX_VA_MAX_ATTR + 1)
+
+typedef enum _GXAttrType {
+  GX_NONE,
+  GX_DIRECT,
+  GX_INDEX8,
+  GX_INDEX16,
+} GXAttrType;
+
+#define _GX_TF_CTF 0x20
+#define _GX_TF_ZTF 0x10
+
+typedef enum _GXTexFmt {
+  GX_TF_I4 = 0x0,
+  GX_TF_I8 = 0x1,
+  GX_TF_IA4 = 0x2,
+  GX_TF_IA8 = 0x3,
+  GX_TF_RGB565 = 0x4,
+  GX_TF_RGB5A3 = 0x5,
+  GX_TF_RGBA8 = 0x6,
+  GX_TF_CMPR = 0xE,
+
+  GX_CTF_R4 = 0x0 | _GX_TF_CTF,
+  GX_CTF_RA4 = 0x2 | _GX_TF_CTF,
+  GX_CTF_RA8 = 0x3 | _GX_TF_CTF,
+  GX_CTF_YUVA8 = 0x6 | _GX_TF_CTF,
+  GX_CTF_A8 = 0x7 | _GX_TF_CTF,
+  GX_CTF_R8 = 0x8 | _GX_TF_CTF,
+  GX_CTF_G8 = 0x9 | _GX_TF_CTF,
+  GX_CTF_B8 = 0xA | _GX_TF_CTF,
+  GX_CTF_RG8 = 0xB | _GX_TF_CTF,
+  GX_CTF_GB8 = 0xC | _GX_TF_CTF,
+
+  GX_TF_Z8 = 0x1 | _GX_TF_ZTF,
+  GX_TF_Z16 = 0x3 | _GX_TF_ZTF,
+  GX_TF_Z24X8 = 0x6 | _GX_TF_ZTF,
+
+  GX_CTF_Z4 = 0x0 | _GX_TF_ZTF | _GX_TF_CTF,
+  GX_CTF_Z8M = 0x9 | _GX_TF_ZTF | _GX_TF_CTF,
+  GX_CTF_Z8L = 0xA | _GX_TF_ZTF | _GX_TF_CTF,
+  GX_CTF_Z16L = 0xC | _GX_TF_ZTF | _GX_TF_CTF,
+
+  GX_TF_A8 = GX_CTF_A8,
+} GXTexFmt;
+
+typedef enum _GXCITexFmt {
+  GX_TF_C4 = 0x8,
+  GX_TF_C8 = 0x9,
+  GX_TF_C14X2 = 0xa,
+} GXCITexFmt;
+
+typedef enum _GXTexWrapMode {
+  GX_CLAMP,
+  GX_REPEAT,
+  GX_MIRROR,
+  GX_MAX_TEXWRAPMODE,
+} GXTexWrapMode;
+
+typedef enum _GXTexFilter {
+  GX_NEAR,
+  GX_LINEAR,
+  GX_NEAR_MIP_NEAR,
+  GX_LIN_MIP_NEAR,
+  GX_NEAR_MIP_LIN,
+  GX_LIN_MIP_LIN,
+} GXTexFilter;
+
+typedef enum _GXAnisotropy {
+  GX_ANISO_1,
+  GX_ANISO_2,
+  GX_ANISO_4,
+  GX_MAX_ANISOTROPY,
+} GXAnisotropy;
+
+typedef enum _GXTexMapID {
+  GX_TEXMAP0,
+  GX_TEXMAP1,
+  GX_TEXMAP2,
+  GX_TEXMAP3,
+  GX_TEXMAP4,
+  GX_TEXMAP5,
+  GX_TEXMAP6,
+  GX_TEXMAP7,
+  GX_MAX_TEXMAP,
+  GX_TEXMAP_NULL = 0xFF,
+  GX_TEX_DISABLE = 0x100,
+} GXTexMapID;
+
+typedef enum _GXTexCoordID {
+  GX_TEXCOORD0,
+  GX_TEXCOORD1,
+  GX_TEXCOORD2,
+  GX_TEXCOORD3,
+  GX_TEXCOORD4,
+  GX_TEXCOORD5,
+  GX_TEXCOORD6,
+  GX_TEXCOORD7,
+  GX_MAX_TEXCOORD,
+  GX_TEXCOORD_NULL = 0xFF,
+} GXTexCoordID;
+
+typedef enum _GXTevStageID {
+  GX_TEVSTAGE0,
+  GX_TEVSTAGE1,
+  GX_TEVSTAGE2,
+  GX_TEVSTAGE3,
+  GX_TEVSTAGE4,
+  GX_TEVSTAGE5,
+  GX_TEVSTAGE6,
+  GX_TEVSTAGE7,
+  GX_TEVSTAGE8,
+  GX_TEVSTAGE9,
+  GX_TEVSTAGE10,
+  GX_TEVSTAGE11,
+  GX_TEVSTAGE12,
+  GX_TEVSTAGE13,
+  GX_TEVSTAGE14,
+  GX_TEVSTAGE15,
+  GX_MAX_TEVSTAGE,
+} GXTevStageID;
+
+typedef enum _GXTevMode {
+  GX_MODULATE,
+  GX_DECAL,
+  GX_BLEND,
+  GX_REPLACE,
+  GX_PASSCLR,
+} GXTevMode;
+
+typedef enum _GXTexMtxType {
+  GX_MTX3x4,
+  GX_MTX2x4,
+} GXTexMtxType;
+
+typedef enum _GXTexGenType {
+  GX_TG_MTX3x4,
+  GX_TG_MTX2x4,
+  GX_TG_BUMP0,
+  GX_TG_BUMP1,
+  GX_TG_BUMP2,
+  GX_TG_BUMP3,
+  GX_TG_BUMP4,
+  GX_TG_BUMP5,
+  GX_TG_BUMP6,
+  GX_TG_BUMP7,
+  GX_TG_SRTG,
+} GXTexGenType;
+
+typedef enum _GXPosNrmMtx {
+  GX_PNMTX0 = 0,
+  GX_PNMTX1 = 3,
+  GX_PNMTX2 = 6,
+  GX_PNMTX3 = 9,
+  GX_PNMTX4 = 12,
+  GX_PNMTX5 = 15,
+  GX_PNMTX6 = 18,
+  GX_PNMTX7 = 21,
+  GX_PNMTX8 = 24,
+  GX_PNMTX9 = 27,
+} GXPosNrmMtx;
+
+typedef enum _GXTexMtx {
+  GX_TEXMTX0 = 30,
+  GX_TEXMTX1 = 33,
+  GX_TEXMTX2 = 36,
+  GX_TEXMTX3 = 39,
+  GX_TEXMTX4 = 42,
+  GX_TEXMTX5 = 45,
+  GX_TEXMTX6 = 48,
+  GX_TEXMTX7 = 51,
+  GX_TEXMTX8 = 54,
+  GX_TEXMTX9 = 57,
+  GX_IDENTITY = 60,
+} GXTexMtx;
+
+typedef enum _GXChannelID {
+  GX_COLOR0,
+  GX_COLOR1,
+  GX_ALPHA0,
+  GX_ALPHA1,
+  GX_COLOR0A0,
+  GX_COLOR1A1,
+  GX_COLOR_ZERO,
+  GX_ALPHA_BUMP,
+  GX_ALPHA_BUMPN,
+  GX_COLOR_NULL = 0xFF,
+} GXChannelID;
+
+typedef enum _GXTexGenSrc {
+  GX_TG_POS,
+  GX_TG_NRM,
+  GX_TG_BINRM,
+  GX_TG_TANGENT,
+  GX_TG_TEX0,
+  GX_TG_TEX1,
+  GX_TG_TEX2,
+  GX_TG_TEX3,
+  GX_TG_TEX4,
+  GX_TG_TEX5,
+  GX_TG_TEX6,
+  GX_TG_TEX7,
+  GX_TG_TEXCOORD0,
+  GX_TG_TEXCOORD1,
+  GX_TG_TEXCOORD2,
+  GX_TG_TEXCOORD3,
+  GX_TG_TEXCOORD4,
+  GX_TG_TEXCOORD5,
+  GX_TG_TEXCOORD6,
+  GX_TG_COLOR0,
+  GX_TG_COLOR1,
+  GX_MAX_TEXGENSRC,
+} GXTexGenSrc;
+
+typedef enum _GXBlendMode {
+  GX_BM_NONE,
+  GX_BM_BLEND,
+  GX_BM_LOGIC,
+  GX_BM_SUBTRACT,
+  GX_MAX_BLENDMODE,
+} GXBlendMode;
+
+typedef enum _GXBlendFactor {
+  GX_BL_ZERO,
+  GX_BL_ONE,
+  GX_BL_SRCCLR,
+  GX_BL_INVSRCCLR,
+  GX_BL_SRCALPHA,
+  GX_BL_INVSRCALPHA,
+  GX_BL_DSTALPHA,
+  GX_BL_INVDSTALPHA,
+  GX_BL_DSTCLR = GX_BL_SRCCLR,
+  GX_BL_INVDSTCLR = GX_BL_INVSRCCLR,
+} GXBlendFactor;
+
+typedef enum _GXLogicOp {
+  GX_LO_CLEAR,
+  GX_LO_AND,
+  GX_LO_REVAND,
+  GX_LO_COPY,
+  GX_LO_INVAND,
+  GX_LO_NOOP,
+  GX_LO_XOR,
+  GX_LO_OR,
+  GX_LO_NOR,
+  GX_LO_EQUIV,
+  GX_LO_INV,
+  GX_LO_REVOR,
+  GX_LO_INVCOPY,
+  GX_LO_INVOR,
+  GX_LO_NAND,
+  GX_LO_SET,
+} GXLogicOp;
+
+typedef enum _GXCompCnt {
+  GX_POS_XY = 0,
+  GX_POS_XYZ = 1,
+  GX_NRM_XYZ = 0,
+  GX_NRM_NBT = 1,
+  GX_NRM_NBT3 = 2,
+  GX_CLR_RGB = 0,
+  GX_CLR_RGBA = 1,
+  GX_TEX_S = 0,
+  GX_TEX_ST = 1,
+} GXCompCnt;
+
+typedef enum _GXCompType {
+  GX_U8 = 0,
+  GX_S8 = 1,
+  GX_U16 = 2,
+  GX_S16 = 3,
+  GX_F32 = 4,
+  GX_RGB565 = 0,
+  GX_RGB8 = 1,
+  GX_RGBX8 = 2,
+  GX_RGBA4 = 3,
+  GX_RGBA6 = 4,
+  GX_RGBA8 = 5,
+} GXCompType;
+
+typedef enum _GXPTTexMtx {
+  GX_PTTEXMTX0 = 64,
+  GX_PTTEXMTX1 = 67,
+  GX_PTTEXMTX2 = 70,
+  GX_PTTEXMTX3 = 73,
+  GX_PTTEXMTX4 = 76,
+  GX_PTTEXMTX5 = 79,
+  GX_PTTEXMTX6 = 82,
+  GX_PTTEXMTX7 = 85,
+  GX_PTTEXMTX8 = 88,
+  GX_PTTEXMTX9 = 91,
+  GX_PTTEXMTX10 = 94,
+  GX_PTTEXMTX11 = 97,
+  GX_PTTEXMTX12 = 100,
+  GX_PTTEXMTX13 = 103,
+  GX_PTTEXMTX14 = 106,
+  GX_PTTEXMTX15 = 109,
+  GX_PTTEXMTX16 = 112,
+  GX_PTTEXMTX17 = 115,
+  GX_PTTEXMTX18 = 118,
+  GX_PTTEXMTX19 = 121,
+  GX_PTIDENTITY = 125,
+} GXPTTexMtx;
+
+typedef enum _GXTevRegID {
+  GX_TEVPREV,
+  GX_TEVREG0,
+  GX_TEVREG1,
+  GX_TEVREG2,
+  GX_MAX_TEVREG,
+} GXTevRegID;
+
+typedef enum _GXDiffuseFn {
+  GX_DF_NONE,
+  GX_DF_SIGN,
+  GX_DF_CLAMP,
+} GXDiffuseFn;
+
+typedef enum _GXColorSrc {
+  GX_SRC_REG,
+  GX_SRC_VTX,
+} GXColorSrc;
+
+typedef enum _GXAttnFn {
+  GX_AF_SPEC,
+  GX_AF_SPOT,
+  GX_AF_NONE,
+} GXAttnFn;
+
+typedef enum _GXLightID {
+  GX_LIGHT0 = 0x001,
+  GX_LIGHT1 = 0x002,
+  GX_LIGHT2 = 0x004,
+  GX_LIGHT3 = 0x008,
+  GX_LIGHT4 = 0x010,
+  GX_LIGHT5 = 0x020,
+  GX_LIGHT6 = 0x040,
+  GX_LIGHT7 = 0x080,
+  GX_MAX_LIGHT = 0x100,
+  GX_LIGHT_NULL = 0,
+} GXLightID;
+
+typedef enum _GXTexOffset {
+  GX_TO_ZERO,
+  GX_TO_SIXTEENTH,
+  GX_TO_EIGHTH,
+  GX_TO_FOURTH,
+  GX_TO_HALF,
+  GX_TO_ONE,
+  GX_MAX_TEXOFFSET,
+} GXTexOffset;
+
+typedef enum _GXSpotFn {
+  GX_SP_OFF,
+  GX_SP_FLAT,
+  GX_SP_COS,
+  GX_SP_COS2,
+  GX_SP_SHARP,
+  GX_SP_RING1,
+  GX_SP_RING2,
+} GXSpotFn;
+
+typedef enum _GXDistAttnFn {
+  GX_DA_OFF,
+  GX_DA_GENTLE,
+  GX_DA_MEDIUM,
+  GX_DA_STEEP,
+} GXDistAttnFn;
+
+typedef enum _GXCullMode {
+  GX_CULL_NONE,
+  GX_CULL_FRONT,
+  GX_CULL_BACK,
+  GX_CULL_ALL,
+} GXCullMode;
+
+typedef enum _GXTevSwapSel {
+  GX_TEV_SWAP0 = 0,
+  GX_TEV_SWAP1,
+  GX_TEV_SWAP2,
+  GX_TEV_SWAP3,
+  GX_MAX_TEVSWAP,
+} GXTevSwapSel;
+
+typedef enum _GXTevColorChan {
+  GX_CH_RED = 0,
+  GX_CH_GREEN,
+  GX_CH_BLUE,
+  GX_CH_ALPHA,
+} GXTevColorChan;
+
+typedef enum _GXFogType {
+  GX_FOG_NONE = 0,
+  GX_FOG_PERSP_LIN = 2,
+  GX_FOG_PERSP_EXP = 4,
+  GX_FOG_PERSP_EXP2 = 5,
+  GX_FOG_PERSP_REVEXP = 6,
+  GX_FOG_PERSP_REVEXP2 = 7,
+  GX_FOG_ORTHO_LIN = 10,
+  GX_FOG_ORTHO_EXP = 12,
+  GX_FOG_ORTHO_EXP2 = 13,
+  GX_FOG_ORTHO_REVEXP = 14,
+  GX_FOG_ORTHO_REVEXP2 = 15,
+  GX_FOG_LIN = GX_FOG_PERSP_LIN,
+  GX_FOG_EXP = GX_FOG_PERSP_EXP,
+  GX_FOG_EXP2 = GX_FOG_PERSP_EXP2,
+  GX_FOG_REVEXP = GX_FOG_PERSP_REVEXP,
+  GX_FOG_REVEXP2 = GX_FOG_PERSP_REVEXP2,
+} GXFogType;
+
+typedef enum _GXTevColorArg {
+  GX_CC_CPREV,
+  GX_CC_APREV,
+  GX_CC_C0,
+  GX_CC_A0,
+  GX_CC_C1,
+  GX_CC_A1,
+  GX_CC_C2,
+  GX_CC_A2,
+  GX_CC_TEXC,
+  GX_CC_TEXA,
+  GX_CC_RASC,
+  GX_CC_RASA,
+  GX_CC_ONE,
+  GX_CC_HALF,
+  GX_CC_KONST,
+  GX_CC_ZERO,
+} GXTevColorArg;
+
+typedef enum _GXTevAlphaArg {
+  GX_CA_APREV,
+  GX_CA_A0,
+  GX_CA_A1,
+  GX_CA_A2,
+  GX_CA_TEXA,
+  GX_CA_RASA,
+  GX_CA_KONST,
+  GX_CA_ZERO,
+} GXTevAlphaArg;
+
+typedef enum _GXTevOp {
+  GX_TEV_ADD = 0,
+  GX_TEV_SUB = 1,
+  GX_TEV_COMP_R8_GT = 8,
+  GX_TEV_COMP_R8_EQ = 9,
+  GX_TEV_COMP_GR16_GT = 10,
+  GX_TEV_COMP_GR16_EQ = 11,
+  GX_TEV_COMP_BGR24_GT = 12,
+  GX_TEV_COMP_BGR24_EQ = 13,
+  GX_TEV_COMP_RGB8_GT = 14,
+  GX_TEV_COMP_RGB8_EQ = 15,
+  GX_TEV_COMP_A8_GT = GX_TEV_COMP_RGB8_GT,
+  GX_TEV_COMP_A8_EQ = GX_TEV_COMP_RGB8_EQ,
+} GXTevOp;
+
+typedef enum _GXTevBias {
+  GX_TB_ZERO,
+  GX_TB_ADDHALF,
+  GX_TB_SUBHALF,
+  GX_MAX_TEVBIAS,
+} GXTevBias;
+
+typedef enum _GXTevScale {
+  GX_CS_SCALE_1,
+  GX_CS_SCALE_2,
+  GX_CS_SCALE_4,
+  GX_CS_DIVIDE_2,
+  GX_MAX_TEVSCALE,
+} GXTevScale;
+
+typedef enum _GXTevKColorSel {
+  GX_TEV_KCSEL_8_8 = 0x00,
+  GX_TEV_KCSEL_7_8 = 0x01,
+  GX_TEV_KCSEL_6_8 = 0x02,
+  GX_TEV_KCSEL_5_8 = 0x03,
+  GX_TEV_KCSEL_4_8 = 0x04,
+  GX_TEV_KCSEL_3_8 = 0x05,
+  GX_TEV_KCSEL_2_8 = 0x06,
+  GX_TEV_KCSEL_1_8 = 0x07,
+  GX_TEV_KCSEL_1 = GX_TEV_KCSEL_8_8,
+  GX_TEV_KCSEL_3_4 = GX_TEV_KCSEL_6_8,
+  GX_TEV_KCSEL_1_2 = GX_TEV_KCSEL_4_8,
+  GX_TEV_KCSEL_1_4 = GX_TEV_KCSEL_2_8,
+  GX_TEV_KCSEL_K0 = 0x0C,
+  GX_TEV_KCSEL_K1 = 0x0D,
+  GX_TEV_KCSEL_K2 = 0x0E,
+  GX_TEV_KCSEL_K3 = 0x0F,
+  GX_TEV_KCSEL_K0_R = 0x10,
+  GX_TEV_KCSEL_K1_R = 0x11,
+  GX_TEV_KCSEL_K2_R = 0x12,
+  GX_TEV_KCSEL_K3_R = 0x13,
+  GX_TEV_KCSEL_K0_G = 0x14,
+  GX_TEV_KCSEL_K1_G = 0x15,
+  GX_TEV_KCSEL_K2_G = 0x16,
+  GX_TEV_KCSEL_K3_G = 0x17,
+  GX_TEV_KCSEL_K0_B = 0x18,
+  GX_TEV_KCSEL_K1_B = 0x19,
+  GX_TEV_KCSEL_K2_B = 0x1A,
+  GX_TEV_KCSEL_K3_B = 0x1B,
+  GX_TEV_KCSEL_K0_A = 0x1C,
+  GX_TEV_KCSEL_K1_A = 0x1D,
+  GX_TEV_KCSEL_K2_A = 0x1E,
+  GX_TEV_KCSEL_K3_A = 0x1F,
+} GXTevKColorSel;
+
+typedef enum _GXTevKAlphaSel {
+  GX_TEV_KASEL_8_8 = 0x00,
+  GX_TEV_KASEL_7_8 = 0x01,
+  GX_TEV_KASEL_6_8 = 0x02,
+  GX_TEV_KASEL_5_8 = 0x03,
+  GX_TEV_KASEL_4_8 = 0x04,
+  GX_TEV_KASEL_3_8 = 0x05,
+  GX_TEV_KASEL_2_8 = 0x06,
+  GX_TEV_KASEL_1_8 = 0x07,
+  GX_TEV_KASEL_1 = GX_TEV_KASEL_8_8,
+  GX_TEV_KASEL_3_4 = GX_TEV_KASEL_6_8,
+  GX_TEV_KASEL_1_2 = GX_TEV_KASEL_4_8,
+  GX_TEV_KASEL_1_4 = GX_TEV_KASEL_2_8,
+  GX_TEV_KASEL_K0_R = 0x10,
+  GX_TEV_KASEL_K1_R = 0x11,
+  GX_TEV_KASEL_K2_R = 0x12,
+  GX_TEV_KASEL_K3_R = 0x13,
+  GX_TEV_KASEL_K0_G = 0x14,
+  GX_TEV_KASEL_K1_G = 0x15,
+  GX_TEV_KASEL_K2_G = 0x16,
+  GX_TEV_KASEL_K3_G = 0x17,
+  GX_TEV_KASEL_K0_B = 0x18,
+  GX_TEV_KASEL_K1_B = 0x19,
+  GX_TEV_KASEL_K2_B = 0x1A,
+  GX_TEV_KASEL_K3_B = 0x1B,
+  GX_TEV_KASEL_K0_A = 0x1C,
+  GX_TEV_KASEL_K1_A = 0x1D,
+  GX_TEV_KASEL_K2_A = 0x1E,
+  GX_TEV_KASEL_K3_A = 0x1F,
+} GXTevKAlphaSel;
+
+typedef enum _GXTevKColorID {
+  GX_KCOLOR0 = 0,
+  GX_KCOLOR1,
+  GX_KCOLOR2,
+  GX_KCOLOR3,
+  GX_MAX_KCOLOR,
+} GXTevKColorID;
+
+typedef enum _GXZTexOp {
+  GX_ZT_DISABLE,
+  GX_ZT_ADD,
+  GX_ZT_REPLACE,
+  GX_MAX_ZTEXOP,
+} GXZTexOp;
+
+typedef enum _GXIndTexFormat {
+  GX_ITF_8,
+  GX_ITF_5,
+  GX_ITF_4,
+  GX_ITF_3,
+  GX_MAX_ITFORMAT,
+} GXIndTexFormat;
+
+typedef enum _GXIndTexBiasSel {
+  GX_ITB_NONE,
+  GX_ITB_S,
+  GX_ITB_T,
+  GX_ITB_ST,
+  GX_ITB_U,
+  GX_ITB_SU,
+  GX_ITB_TU,
+  GX_ITB_STU,
+  GX_MAX_ITBIAS,
+} GXIndTexBiasSel;
+
+typedef enum _GXIndTexAlphaSel {
+  GX_ITBA_OFF,
+  GX_ITBA_S,
+  GX_ITBA_T,
+  GX_ITBA_U,
+  GX_MAX_ITBALPHA,
+} GXIndTexAlphaSel;
+
+typedef enum _GXIndTexMtxID {
+  GX_ITM_OFF,
+  GX_ITM_0,
+  GX_ITM_1,
+  GX_ITM_2,
+  GX_ITM_S0 = 5,
+  GX_ITM_S1,
+  GX_ITM_S2,
+  GX_ITM_T0 = 9,
+  GX_ITM_T1,
+  GX_ITM_T2,
+} GXIndTexMtxID;
+
+typedef enum _GXIndTexWrap {
+  GX_ITW_OFF,
+  GX_ITW_256,
+  GX_ITW_128,
+  GX_ITW_64,
+  GX_ITW_32,
+  GX_ITW_16,
+  GX_ITW_0,
+  GX_MAX_ITWRAP,
+} GXIndTexWrap;
+
+typedef enum _GXIndTexStageID {
+  GX_INDTEXSTAGE0,
+  GX_INDTEXSTAGE1,
+  GX_INDTEXSTAGE2,
+  GX_INDTEXSTAGE3,
+  GX_MAX_INDTEXSTAGE,
+} GXIndTexStageID;
+
+typedef enum _GXIndTexScale {
+  GX_ITS_1,
+  GX_ITS_2,
+  GX_ITS_4,
+  GX_ITS_8,
+  GX_ITS_16,
+  GX_ITS_32,
+  GX_ITS_64,
+  GX_ITS_128,
+  GX_ITS_256,
+  GX_MAX_ITSCALE,
+} GXIndTexScale;
+
+typedef enum _GXClipMode {
+  GX_CLIP_ENABLE = 0,
+  GX_CLIP_DISABLE = 1,
+} GXClipMode;
+
+typedef enum _GXTlut {
+  GX_TLUT0 = 0,
+  GX_TLUT1 = 1,
+  GX_TLUT2 = 2,
+  GX_TLUT3 = 3,
+  GX_TLUT4 = 4,
+  GX_TLUT5 = 5,
+  GX_TLUT6 = 6,
+  GX_TLUT7 = 7,
+  GX_TLUT8 = 8,
+  GX_TLUT9 = 9,
+  GX_TLUT10 = 10,
+  GX_TLUT11 = 11,
+  GX_TLUT12 = 12,
+  GX_TLUT13 = 13,
+  GX_TLUT14 = 14,
+  GX_TLUT15 = 15,
+  GX_BIGTLUT0 = 16,
+  GX_BIGTLUT1 = 17,
+  GX_BIGTLUT2 = 18,
+  GX_BIGTLUT3 = 19,
+} GXTlut;
+
+typedef enum _GXTlutFmt {
+  GX_TL_IA8,
+  GX_TL_RGB565,
+  GX_TL_RGB5A3,
+  GX_MAX_TLUTFMT,
+} GXTlutFmt;
+
+typedef enum _GXMiscToken {
+  GX_MT_NULL = 0,
+  GX_MT_XF_FLUSH = 1,
+  GX_MT_DL_SAVE_CONTEXT = 2,
+  GX_MT_ABORT_WAIT_COPYOUT = 3,
+} GXMiscToken;
+
+typedef enum _GXTexCacheSize {
+  GX_TEXCACHE_32K,
+  GX_TEXCACHE_128K,
+  GX_TEXCACHE_512K,
+  GX_TEXCACHE_NONE
+} GXTexCacheSize;
+
+typedef enum _GXPerf0 {
+  GX_PERF0_VERTICES,
+  GX_PERF0_CLIP_VTX,
+  GX_PERF0_CLIP_CLKS,
+  GX_PERF0_XF_WAIT_IN,
+  GX_PERF0_XF_WAIT_OUT,
+  GX_PERF0_XF_XFRM_CLKS,
+  GX_PERF0_XF_LIT_CLKS,
+  GX_PERF0_XF_BOT_CLKS,
+  GX_PERF0_XF_REGLD_CLKS,
+  GX_PERF0_XF_REGRD_CLKS,
+  GX_PERF0_CLIP_RATIO,
+
+  GX_PERF0_TRIANGLES,
+  GX_PERF0_TRIANGLES_CULLED,
+  GX_PERF0_TRIANGLES_PASSED,
+  GX_PERF0_TRIANGLES_SCISSORED,
+  GX_PERF0_TRIANGLES_0TEX,
+  GX_PERF0_TRIANGLES_1TEX,
+  GX_PERF0_TRIANGLES_2TEX,
+  GX_PERF0_TRIANGLES_3TEX,
+  GX_PERF0_TRIANGLES_4TEX,
+  GX_PERF0_TRIANGLES_5TEX,
+  GX_PERF0_TRIANGLES_6TEX,
+  GX_PERF0_TRIANGLES_7TEX,
+  GX_PERF0_TRIANGLES_8TEX,
+  GX_PERF0_TRIANGLES_0CLR,
+  GX_PERF0_TRIANGLES_1CLR,
+  GX_PERF0_TRIANGLES_2CLR,
+
+  GX_PERF0_QUAD_0CVG,
+  GX_PERF0_QUAD_NON0CVG,
+  GX_PERF0_QUAD_1CVG,
+  GX_PERF0_QUAD_2CVG,
+  GX_PERF0_QUAD_3CVG,
+  GX_PERF0_QUAD_4CVG,
+  GX_PERF0_AVG_QUAD_CNT,
+
+  GX_PERF0_CLOCKS,
+  GX_PERF0_NONE
+
+} GXPerf0;
+
+typedef enum _GXPerf1 {
+  GX_PERF1_TEXELS,
+  GX_PERF1_TX_IDLE,
+  GX_PERF1_TX_REGS,
+  GX_PERF1_TX_MEMSTALL,
+  GX_PERF1_TC_CHECK1_2,
+  GX_PERF1_TC_CHECK3_4,
+  GX_PERF1_TC_CHECK5_6,
+  GX_PERF1_TC_CHECK7_8,
+  GX_PERF1_TC_MISS,
+
+  GX_PERF1_VC_ELEMQ_FULL,
+  GX_PERF1_VC_MISSQ_FULL,
+  GX_PERF1_VC_MEMREQ_FULL,
+  GX_PERF1_VC_STATUS7,
+  GX_PERF1_VC_MISSREP_FULL,
+  GX_PERF1_VC_STREAMBUF_LOW,
+  GX_PERF1_VC_ALL_STALLS,
+  GX_PERF1_VERTICES,
+
+  GX_PERF1_FIFO_REQ,
+  GX_PERF1_CALL_REQ,
+  GX_PERF1_VC_MISS_REQ,
+  GX_PERF1_CP_ALL_REQ,
+
+  GX_PERF1_CLOCKS,
+  GX_PERF1_NONE
+
+} GXPerf1;
+
+typedef enum _GXVCachePerf {
+  GX_VC_POS,
+  GX_VC_NRM,
+  GX_VC_CLR0,
+  GX_VC_CLR1,
+  GX_VC_TEX0,
+  GX_VC_TEX1,
+  GX_VC_TEX2,
+  GX_VC_TEX3,
+  GX_VC_TEX4,
+  GX_VC_TEX5,
+  GX_VC_TEX6,
+  GX_VC_TEX7,
+  GX_VC_ALL = 0xf
+
+} GXVCachePerf;
+
+typedef enum _GXFBClamp {
+  GX_CLAMP_NONE = 0,
+  GX_CLAMP_TOP = 1,
+  GX_CLAMP_BOTTOM = 2,
+} GXFBClamp;
+
+typedef enum _GXCopyMode {
+  GX_COPY_PROGRESSIVE = 0,
+  GX_COPY_INTLC_EVEN = 2,
+  GX_COPY_INTLC_ODD = 3,
+} GXCopyMode;
+
+typedef enum _GXAlphaReadMode {
+  GX_READ_00 = 0,
+  GX_READ_FF = 1,
+  GX_READ_NONE = 2,
+
+} _GXAlphaReadMode;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXENUM

include/dolphin/gx/GXExtra.h

@@ -0,0 +1,36 @@
+#ifndef _DOLPHIN_GXEXTRA
+#define _DOLPHIN_GXEXTRA
+
+// Extra types for PC
+#ifdef TARGET_PC
+#include <dolphin/gx/GXStruct.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  float r;
+  float g;
+  float b;
+  float a;
+} GXColorF32;
+
+typedef enum {
+  GX_TF_R8_PC = 0x60,
+  GX_TF_RGBA8_PC = 0x61,
+} GXPCTexFmt;
+
+void GXDestroyTexObj(GXTexObj* obj);
+void GXDestroyTlutObj(GXTlutObj* obj);
+
+void GXColor4f32(float r, float g, float b, float a);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TARGET_PC
+
+#endif // _DOLPHIN_GXEXTRA

include/dolphin/gx/GXFifo.h

@@ -0,0 +1,37 @@
+#ifndef _DOLPHIN_GXFIFO
+#define _DOLPHIN_GXFIFO
+
+#include <dolphin/gx/GXEnum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  u8 pad[128];
+} GXFifoObj;
+
+typedef void (*GXBreakPtCallback)(void);
+
+void GXInitFifoBase(GXFifoObj* fifo, void* base, u32 size);
+void GXInitFifoPtrs(GXFifoObj* fifo, void* readPtr, void* writePtr);
+void GXGetFifoPtrs(GXFifoObj* fifo, void** readPtr, void** writePtr);
+GXFifoObj* GXGetCPUFifo(void);
+GXFifoObj* GXGetGPFifo(void);
+void GXSetCPUFifo(GXFifoObj* fifo);
+void GXSetGPFifo(GXFifoObj* fifo);
+void GXSaveCPUFifo(GXFifoObj* fifo);
+void GXGetFifoStatus(GXFifoObj* fifo, GXBool* overhi, GXBool* underlow, u32* fifoCount,
+                     GXBool* cpu_write, GXBool* gp_read, GXBool* fifowrap);
+void GXGetGPStatus(GXBool* overhi, GXBool* underlow, GXBool* readIdle, GXBool* cmdIdle,
+                   GXBool* brkpt);
+void GXInitFifoLimits(GXFifoObj* fifo, u32 hiWaterMark, u32 loWaterMark);
+GXBreakPtCallback GXSetBreakPtCallback(GXBreakPtCallback cb);
+void GXEnableBreakPt(void* breakPt);
+void GXDisableBreakPt(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXFIFO

include/dolphin/gx/GXFrameBuffer.h

@@ -0,0 +1,62 @@
+#ifndef _DOLPHIN_GXFRAMEBUFFER
+#define _DOLPHIN_GXFRAMEBUFFER
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// extern GXRenderModeObj GXNtsc240Ds;
+// extern GXRenderModeObj GXNtsc240DsAa;
+// extern GXRenderModeObj GXNtsc240Int;
+// extern GXRenderModeObj GXNtsc240IntAa;
+extern GXRenderModeObj GXNtsc480IntDf;
+// extern GXRenderModeObj GXNtsc480Int;
+// extern GXRenderModeObj GXNtsc480IntAa;
+// extern GXRenderModeObj GXNtsc480Prog;
+// extern GXRenderModeObj GXNtsc480ProgSoft;
+// extern GXRenderModeObj GXNtsc480ProgAa;
+// extern GXRenderModeObj GXMpal240Ds;
+// extern GXRenderModeObj GXMpal240DsAa;
+// extern GXRenderModeObj GXMpal240Int;
+// extern GXRenderModeObj GXMpal240IntAa;
+extern GXRenderModeObj GXMpal480IntDf;
+// extern GXRenderModeObj GXMpal480Int;
+// extern GXRenderModeObj GXMpal480IntAa;
+// extern GXRenderModeObj GXPal264Ds;
+// extern GXRenderModeObj GXPal264DsAa;
+// extern GXRenderModeObj GXPal264Int;
+// extern GXRenderModeObj GXPal264IntAa;
+extern GXRenderModeObj GXPal528IntDf;
+// extern GXRenderModeObj GXPal528Int;
+// extern GXRenderModeObj GXPal524IntAa;
+// extern GXRenderModeObj GXEurgb60Hz240Ds;
+// extern GXRenderModeObj GXEurgb60Hz240DsAa;
+// extern GXRenderModeObj GXEurgb60Hz240Int;
+// extern GXRenderModeObj GXEurgb60Hz240IntAa;
+extern GXRenderModeObj GXEurgb60Hz480IntDf;
+// extern GXRenderModeObj GXEurgb60Hz480Int;
+// extern GXRenderModeObj GXEurgb60Hz480IntAa;
+
+#define GX_MAX_Z24 0x00FFFFFF
+
+void GXSetCopyClear(GXColor clear_clr, u32 clear_z);
+void GXAdjustForOverscan(GXRenderModeObj* rmin, GXRenderModeObj* rmout, u16 hor, u16 ver);
+void GXCopyDisp(void* dest, GXBool clear);
+void GXSetDispCopyGamma(GXGamma gamma);
+void GXSetDispCopySrc(u16 left, u16 top, u16 wd, u16 ht);
+void GXSetDispCopyDst(u16 wd, u16 ht);
+u32 GXSetDispCopyYScale(f32 vscale);
+void GXSetCopyFilter(GXBool aa, u8 sample_pattern[12][2], GXBool vf, u8 vfilter[7]);
+void GXSetPixelFmt(GXPixelFmt pix_fmt, GXZFmt16 z_fmt);
+void GXSetTexCopySrc(u16 left, u16 top, u16 wd, u16 ht);
+void GXSetTexCopyDst(u16 wd, u16 ht, GXTexFmt fmt, GXBool mipmap);
+void GXCopyTex(void* dest, GXBool clear);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXFRAMEBUFFER

include/dolphin/gx/GXGeometry.h

@@ -0,0 +1,37 @@
+#ifndef _DOLPHIN_GXGEOMETRY
+#define _DOLPHIN_GXGEOMETRY
+
+#include <dolphin/gx/GXEnum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetVtxDesc(GXAttr attr, GXAttrType type);
+void GXSetVtxDescv(GXVtxDescList* list);
+void GXClearVtxDesc(void);
+void GXSetVtxAttrFmt(GXVtxFmt vtxfmt, GXAttr attr, GXCompCnt cnt, GXCompType type, u8 frac);
+void GXSetNumTexGens(u8 nTexGens);
+void GXBegin(GXPrimitive type, GXVtxFmt vtxfmt, u16 nverts);
+void GXSetTexCoordGen2(GXTexCoordID dst_coord, GXTexGenType func, GXTexGenSrc src_param, u32 mtx,
+                       GXBool normalize, u32 postmtx);
+void GXSetLineWidth(u8 width, GXTexOffset texOffsets);
+void GXSetPointSize(u8 pointSize, GXTexOffset texOffsets);
+void GXEnableTexOffsets(GXTexCoordID coord, GXBool line_enable, GXBool point_enable);
+#ifdef TARGET_PC
+void GXSetArray(GXAttr attr, const void* data, u32 size, u8 stride);
+#else
+void GXSetArray(GXAttr attr, const void* data, u8 stride);
+#endif
+void GXInvalidateVtxCache(void);
+
+static inline void GXSetTexCoordGen(GXTexCoordID dst_coord, GXTexGenType func,
+                                    GXTexGenSrc src_param, u32 mtx) {
+  GXSetTexCoordGen2(dst_coord, func, src_param, mtx, GX_FALSE, GX_PTIDENTITY);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXGEOMETRY

include/dolphin/gx/GXGet.h

@@ -0,0 +1,28 @@
+#ifndef _DOLPHIN_GXGET
+#define _DOLPHIN_GXGET
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+GXBool GXGetTexObjMipMap(const GXTexObj* obj);
+GXTexFmt GXGetTexObjFmt(const GXTexObj* obj);
+u16 GXGetTexObjHeight(const GXTexObj* obj);
+u16 GXGetTexObjWidth(const GXTexObj* obj);
+GXTexWrapMode GXGetTexObjWrapS(const GXTexObj* obj);
+GXTexWrapMode GXGetTexObjWrapT(const GXTexObj* obj);
+void* GXGetTexObjData(const GXTexObj* obj);
+void GXGetProjectionv(f32* p);
+void GXGetLightPos(const GXLightObj* lt_obj, f32* x, f32* y, f32* z);
+void GXGetLightColor(const GXLightObj* lt_obj, GXColor* color);
+void GXGetVtxAttrFmt(GXVtxFmt idx, GXAttr attr, GXCompCnt* compCnt, GXCompType* compType,
+                     u8* shift);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXGET

include/dolphin/gx/GXLighting.h

@@ -0,0 +1,32 @@
+#ifndef _DOLPHIN_GXLIGHTING
+#define _DOLPHIN_GXLIGHTING
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetNumChans(u8 nChans);
+void GXSetChanCtrl(GXChannelID chan, GXBool enable, GXColorSrc amb_src, GXColorSrc mat_src,
+                   u32 light_mask, GXDiffuseFn diff_fn, GXAttnFn attn_fn);
+void GXSetChanAmbColor(GXChannelID chan, GXColor amb_color);
+void GXSetChanMatColor(GXChannelID chan, GXColor mat_color);
+
+void GXInitLightSpot(GXLightObj* lt_obj, f32 cutoff, GXSpotFn spot_func);
+void GXInitLightDistAttn(GXLightObj* lt_obj, f32 ref_distance, f32 ref_brightness,
+                         GXDistAttnFn dist_func);
+void GXInitLightPos(GXLightObj* lt_obj, f32 x, f32 y, f32 z);
+void GXInitLightDir(GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz);
+void GXInitLightColor(GXLightObj* lt_obj, GXColor color);
+void GXInitLightAttn(GXLightObj* lt_obj, f32 a0, f32 a1, f32 a2, f32 k0, f32 k1, f32 k2);
+void GXInitLightAttnA(GXLightObj* lt_obj, f32 a0, f32 a1, f32 a2);
+void GXInitLightAttnK(GXLightObj* lt_obj, f32 k0, f32 k1, f32 k2);
+void GXLoadLightObjImm(GXLightObj* lt_obj, GXLightID light);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXLIGHTING

include/dolphin/gx/GXManage.h

@@ -0,0 +1,24 @@
+#ifndef _DOLPHIN_GXMANAGE
+#define _DOLPHIN_GXMANAGE
+
+#include <dolphin/gx/GXFifo.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*GXDrawDoneCallback)(void);
+
+GXFifoObj* GXInit(void* base, u32 size);
+GXDrawDoneCallback GXSetDrawDoneCallback(GXDrawDoneCallback cb);
+void GXDrawDone(void);
+void GXSetDrawDone(void);
+void GXFlush(void);
+void GXPixModeSync(void);
+void GXSetMisc(GXMiscToken token, u32 val);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXMANAGE

include/dolphin/gx/GXPerf.h

@@ -0,0 +1,16 @@
+#ifndef _DOLPHIN_GXPERF
+#define _DOLPHIN_GXPERF
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXReadXfRasMetric(u32* xf_wait_in, u32* xf_wait_out, u32* ras_busy, u32* clocks);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXPERF

include/dolphin/gx/GXPixel.h

@@ -0,0 +1,29 @@
+#ifndef _DOLPHIN_GXPIXEL
+#define _DOLPHIN_GXPIXEL
+
+#include <dolphin/gx/GXEnum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetFog(GXFogType type, f32 startz, f32 endz, f32 nearz, f32 farz, GXColor color);
+void GXSetFogColor(GXColor color);
+// ? GXSetFogRangeAdj();
+void GXSetBlendMode(GXBlendMode type, GXBlendFactor src_factor, GXBlendFactor dst_factor,
+                    GXLogicOp op);
+void GXSetColorUpdate(GXBool update_enable);
+void GXSetAlphaUpdate(GXBool update_enable);
+void GXSetZMode(GXBool compare_enable, GXCompare func, GXBool update_enable);
+void GXSetZCompLoc(GXBool before_tex);
+void GXSetPixelFmt(GXPixelFmt pix_fmt, GXZFmt16 z_fmt);
+void GXSetDither(GXBool dither);
+void GXSetDstAlpha(GXBool enable, u8 alpha);
+// ? GXSetFieldMask();
+void GXSetFieldMode(u8 field_mode, u8 half_aspect_ratio);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXPIXEL

include/dolphin/gx/GXPriv.h

@@ -0,0 +1,361 @@
+#ifndef _DOLPHIN_GXPRIV
+#define _DOLPHIN_GXPRIV
+
+#include "dolphin/gx/GXVert.h"
+
+typedef struct GXLightObjInt {
+  u32 padding[3];
+  u32 color;
+  float a0;
+  float a1;
+  float a2;
+  float k0;
+  float k1;
+  float k2;
+  float px;
+  float py;
+  float pz;
+  float nx;
+  float ny;
+  float nz;
+} GXLightObjInt;
+
+#define XF_LIGHT_BASE 0x0600
+#define XF_LIGHT_SIZE 0x10
+
+#define GX_FIFO_ADDR 0xCC008000
+
+#define GX_WRITE_U8(v) (GXWGFifo.u8 = v)
+#define GX_WRITE_U32(v) (GXWGFifo.u32 = v)
+
+typedef struct __GXData_struct {
+  u16 vNumNot;
+  u16 bpSentNot;
+  u16 vNum;
+  u16 vLim;
+  u32 cpEnable;
+  u32 cpStatus;
+  u32 cpClr;
+  u32 vcdLo;
+  u32 vcdHi;
+  u32 vatA[8];
+  u32 vatB[8];
+  u32 vatC[8];
+  u32 lpSize;
+  u32 matIdxA;
+  u32 matIdxB;
+  u32 indexBase[4];
+  u32 indexStride[4];
+  u32 ambColor[2];
+  u32 matColor[2];
+  u32 suTs0[8];
+  u32 suTs1[8];
+  u32 suScis0;
+  u32 suScis1;
+  u32 tref[8];
+  u32 iref;
+  u32 bpMask;
+  u32 IndTexScale0;
+  u32 IndTexScale1;
+  u32 tevc[16];
+  u32 teva[16];
+  u32 tevKsel[8];
+  u32 cmode0;
+  u32 cmode1;
+  u32 zmode;
+  u32 peCtrl;
+  u32 cpDispSrc;
+  u32 cpDispSize;
+  u32 cpDispStride;
+  u32 cpDisp;
+  u32 cpTexSrc;
+  u32 cpTexSize;
+  u32 cpTexStride;
+  u32 cpTex;
+  GXBool cpTexZ;
+  u32 genMode;
+  GXTexRegion TexRegions[8];
+  GXTexRegion TexRegionsCI[4];
+  u32 nextTexRgn;
+  u32 nextTexRgnCI;
+  GXTlutRegion TlutRegions[20];
+  GXTexRegion* (*texRegionCallback)(GXTexObj*, GXTexMapID);
+  GXTlutRegion* (*tlutRegionCallback)(u32);
+  GXAttrType nrmType;
+  GXBool hasNrms;
+  GXBool hasBiNrms;
+  u32 projType;
+  f32 projMtx[6];
+  f32 vpLeft;
+  f32 vpTop;
+  f32 vpWd;
+  f32 vpHt;
+  f32 vpNearz;
+  f32 vpFarz;
+  u8 fgRange;
+  f32 fgSideX;
+  u32 tImage0[8];
+  u32 tMode0[8];
+  u32 texmapId[16];
+  u32 tcsManEnab;
+  u32 tevTcEnab;
+  GXPerf0 perf0;
+  GXPerf1 perf1;
+  u32 perfSel;
+  GXBool inDispList;
+  GXBool dlSaveContext;
+  u8 dirtyVAT;
+  u32 dirtyState;
+} GXData;
+
+extern GXData* gx;
+// #define gx __GXData
+
+void __GXInitGX();
+
+#define GX_REG_ASSERT(c) ASSERTMSG(c, "GX Internal: Register field out of range")
+
+#define GX_FLAG_SET(regOrg, newFlag, regName)                                                      \
+  do {                                                                                             \
+    GX_REG_ASSERT(!((newFlag) & ~((1 << (regName##_SIZE)) - 1)));                                  \
+    (regOrg) = (((u32)(regOrg) & ~(regName##_MASK)) |                                              \
+                (((u32)(newFlag) << (regName##_SHIFT)) & (regName##_MASK)));                       \
+  } while (0)
+
+#define GX_GENMODE_ID 0
+#define GX_GENMODE_REG_ID_SIZE 8
+#define GX_GENMODE_REG_ID_SHIFT 24
+#define GX_GENMODE_REG_ID_MASK 0xff000000
+#define GX_GENMODE_GET_REG_ID(genMode)                                                               \
+  ((((u32)(genMode)) & GX_GENMODE_REG_ID_MASK) >> GX_GENMODE_REG_ID_SHIFT)
+
+#define GX_BPMASK_ID 15
+#define GX_BPMASK_REG_ID_SIZE 8
+#define GX_BPMASK_REG_ID_SHIFT 24
+#define GX_BPMASK_REG_ID_MASK 0xff000000
+
+#define GX_LPSIZE_ID 34
+#define GX_LPSIZE_REG_ID_SIZE 8
+#define GX_LPSIZE_REG_ID_SHIFT 24
+#define GX_LPSIZE_REG_ID_MASK 0xff000000
+
+#define TEV_COLOR_ENV_REG_ID_SIZE 8
+#define TEV_COLOR_ENV_REG_ID_SHIFT 24
+#define TEV_COLOR_ENV_REG_ID_MASK 0xff000000
+
+#define TEV_ALPHA_ENV_REG_ID_SIZE 8
+#define TEV_ALPHA_ENV_REG_ID_SHIFT 24
+#define TEV_ALPHA_ENV_REG_ID_MASK 0xff000000
+
+#define TEV_COLOR_ENV_0_ID 0x000000c0
+#define TEV_ALPHA_ENV_0_ID 0x000000c1
+#define TEV_COLOR_ENV_1_ID 0x000000c2
+#define TEV_ALPHA_ENV_1_ID 0x000000c3
+#define TEV_COLOR_ENV_2_ID 0x000000c4
+#define TEV_ALPHA_ENV_2_ID 0x000000c5
+#define TEV_COLOR_ENV_3_ID 0x000000c6
+#define TEV_ALPHA_ENV_3_ID 0x000000c7
+#define TEV_COLOR_ENV_4_ID 0x000000c8
+#define TEV_ALPHA_ENV_4_ID 0x000000c9
+#define TEV_COLOR_ENV_5_ID 0x000000ca
+#define TEV_ALPHA_ENV_5_ID 0x000000cb
+#define TEV_COLOR_ENV_6_ID 0x000000cc
+#define TEV_ALPHA_ENV_6_ID 0x000000cd
+#define TEV_COLOR_ENV_7_ID 0x000000ce
+#define TEV_ALPHA_ENV_7_ID 0x000000cf
+#define TEV_COLOR_ENV_8_ID 0x000000d0
+#define TEV_ALPHA_ENV_8_ID 0x000000d1
+#define TEV_COLOR_ENV_9_ID 0x000000d2
+#define TEV_ALPHA_ENV_9_ID 0x000000d3
+#define TEV_COLOR_ENV_A_ID 0x000000d4
+#define TEV_ALPHA_ENV_A_ID 0x000000d5
+#define TEV_COLOR_ENV_B_ID 0x000000d6
+#define TEV_ALPHA_ENV_B_ID 0x000000d7
+#define TEV_COLOR_ENV_C_ID 0x000000d8
+#define TEV_ALPHA_ENV_C_ID 0x000000d9
+#define TEV_COLOR_ENV_D_ID 0x000000da
+#define TEV_ALPHA_ENV_D_ID 0x000000db
+#define TEV_COLOR_ENV_E_ID 0x000000dc
+#define TEV_ALPHA_ENV_E_ID 0x000000dd
+#define TEV_COLOR_ENV_F_ID 0x000000de
+#define TEV_ALPHA_ENV_F_ID 0x000000df
+
+#define TEV_KSEL_REG_ID_SIZE 8
+#define TEV_KSEL_REG_ID_SHIFT 24
+#define TEV_KSEL_REG_ID_MASK 0xff000000
+
+#define TEV_KSEL_0_ID 0x000000f6
+#define TEV_KSEL_1_ID 0x000000f7
+#define TEV_KSEL_2_ID 0x000000f8
+#define TEV_KSEL_3_ID 0x000000f9
+#define TEV_KSEL_4_ID 0x000000fa
+#define TEV_KSEL_5_ID 0x000000fb
+#define TEV_KSEL_6_ID 0x000000fc
+#define TEV_KSEL_7_ID 0x000000fd
+
+#define RAS_IREF_ID 39
+#define RAS_IREF_REG_ID_SIZE 8
+#define RAS_IREF_REG_ID_SHIFT 24
+#define RAS_IREF_REG_ID_MASK 0xff000000
+
+#define RAS_TREF0_ID 40
+#define RAS_TREF_REG_ID_SIZE 8
+#define RAS_TREF_REG_ID_SHIFT 24
+#define RAS_TREF_REG_ID_MASK 0xff000000
+
+#define SU_TS0_REG_ID_SIZE 8
+#define SU_TS0_REG_ID_SHIFT 24
+#define SU_TS0_REG_ID_MASK 0xff000000
+
+#define SU_TS1_REG_ID_SIZE 8
+#define SU_TS1_REG_ID_SHIFT 24
+#define SU_TS1_REG_ID_MASK 0xff000000
+
+#define SU_SCIS0_ID 0x00000020
+#define SU_SCIS1_ID 0x00000021
+
+#define SU_SCIS0_REG_ID_SIZE 8
+#define SU_SCIS0_REG_ID_SHIFT 24
+#define SU_SCIS0_REG_ID_MASK 0xff000000
+
+#define SU_SCIS1_REG_ID_SIZE 8
+#define SU_SCIS1_REG_ID_SHIFT 24
+#define SU_SCIS1_REG_ID_MASK 0xff000000
+
+#define SU_SSIZE0_ID 0x00000030
+#define SU_TSIZE0_ID 0x00000031
+#define SU_SSIZE1_ID 0x00000032
+#define SU_TSIZE1_ID 0x00000033
+#define SU_SSIZE2_ID 0x00000034
+#define SU_TSIZE2_ID 0x00000035
+#define SU_SSIZE3_ID 0x00000036
+#define SU_TSIZE3_ID 0x00000037
+#define SU_SSIZE4_ID 0x00000038
+#define SU_TSIZE4_ID 0x00000039
+#define SU_SSIZE5_ID 0x0000003a
+#define SU_TSIZE5_ID 0x0000003b
+#define SU_SSIZE6_ID 0x0000003c
+#define SU_TSIZE6_ID 0x0000003d
+#define SU_SSIZE7_ID 0x0000003e
+#define SU_TSIZE7_ID 0x0000003f
+
+#define GX_ZMODE_ID 64
+#define GX_ZMODE_REG_ID_SIZE 8
+#define GX_ZMODE_REG_ID_SHIFT 24
+#define GX_ZMODE_REG_ID_MASK 0xff000000
+
+#define GX_CMODE0_ID 65
+#define GX_CMODE0_REG_ID_SIZE 8
+#define GX_CMODE0_REG_ID_SHIFT 24
+#define GX_CMODE0_REG_ID_MASK 0xff000000
+
+#define GX_CMODE1_ID 66
+#define GX_CMODE1_REG_ID_SIZE 8
+#define GX_CMODE1_REG_ID_SHIFT 24
+#define GX_CMODE1_REG_ID_MASK 0xff000000
+
+#define PE_CONTROL_ID 67
+#define PE_CONTROL_REG_ID_SIZE 8
+#define PE_CONTROL_REG_ID_SHIFT 24
+#define PE_CONTROL_REG_ID_MASK 0xff000000
+
+#define PE_COPY_CMD_GAMMA_SIZE 2
+#define PE_COPY_CMD_GAMMA_SHIFT 7
+#define PE_COPY_CMD_GAMMA_MASK 0x00000180
+
+#define GEN_MODE_REG_ID_SIZE 8
+#define GEN_MODE_REG_ID_SHIFT 24
+#define GEN_MODE_REG_ID_MASK 0xff000000
+
+#define GX_OPCODE_INDEX_SIZE 3
+#define GX_OPCODE_INDEX_SHIFT 0
+#define GX_OPCODE_INDEX_MASK 0x00000007
+
+#define GX_OPCODE_CMD_SHIFT 3
+
+#define GX_OPCODE(index, cmd)                                                                      \
+  ((((u32)(index)) << GX_OPCODE_INDEX_SHIFT) | (((u32)(cmd)) << GX_OPCODE_CMD_SHIFT))
+
+#ifdef _DEBUG
+#define GX_WRITE_RA_REG(reg)                                                                       \
+  {                                                                                                \
+    GX_WRITE_U8(GX_OPCODE(1, 12));                                                                 \
+    GX_WRITE_U32((reg));                                                                           \
+    __gxVerif->rasRegs[GX_GENMODE_GET_REG_ID(reg)] = reg;                                             \
+  }
+#else
+#define GX_WRITE_RA_REG(reg)                                                                       \
+  {                                                                                                \
+    GX_WRITE_U8(GX_OPCODE(1, 12));                                                                 \
+    GX_WRITE_U32((reg));                                                                           \
+  }
+#endif
+
+#define CP_STREAM_REG_INDEX_SIZE 4
+#define CP_STREAM_REG_INDEX_SHIFT 0
+#define CP_STREAM_REG_INDEX_MASK 0x0000000f
+
+#define CP_STREAM_REG_ADDR_SIZE 4
+#define CP_STREAM_REG_ADDR_SHIFT    4
+#define CP_STREAM_REG_ADDR_MASK 0x000000f0
+
+#define CP_STREAM_REG(index, addr)                                                                 \
+  ((((unsigned long)(index)) << CP_STREAM_REG_INDEX_SHIFT) |                                       \
+   (((unsigned long)(addr)) << CP_STREAM_REG_ADDR_SHIFT))
+
+#ifdef _DEBUG
+#define GX_WRITE_CP_STRM_REG(addr, vtxfmt, data)                                                   \
+  {                                                                                                \
+    s32 regAddr;                                                                                   \
+    GX_WRITE_U8(GX_OPCODE(0, 1));                                                                  \
+    GX_WRITE_U8(CP_STREAM_REG((vtxfmt), (addr)));                                                  \
+    GX_WRITE_U32((data));                                                                          \
+    regAddr = (vtxfmt)-GX_POS_MTX_ARRAY + GX_VA_POS;                                               \
+    if ((addr) == 10) {                                                                            \
+      if (regAddr >= 0 && regAddr < 4)                                                             \
+        gx->indexBase[regAddr] = (data);                                                           \
+    } else if ((addr) == 11) {                                                                     \
+      if (regAddr >= 0 && regAddr < 4)                                                             \
+        gx->indexStride[regAddr] = (data);                                                         \
+    }                                                                                              \
+  }
+#else
+#define GX_WRITE_CP_STRM_REG(addr, vtxfmt, data)                                                   \
+  {                                                                                                \
+    GX_WRITE_U8(GX_OPCODE(0, 1));                                                                  \
+    GX_WRITE_U8(CP_STREAM_REG((vtxfmt), (addr)));                                                  \
+    GX_WRITE_U32((data));                                                                          \
+  }
+#endif
+
+#define PE_REFRESH_REG_ID_SIZE 8
+#define PE_REFRESH_REG_ID_SHIFT 24
+#define PE_REFRESH_REG_ID_MASK 0xff000000
+
+#define PE_REFRESH_INTERVAL_SHIFT 0
+#define PE_REFRESH_ENABLE_SHIFT 9
+#define PE_REFRESH_TOTAL_SIZE 32
+#define PE_REFRESH(interval, enable, rid)                                                          \
+  ((((u32)(interval)) << PE_REFRESH_INTERVAL_SHIFT) |                                              \
+   (((u32)(enable)) << PE_REFRESH_ENABLE_SHIFT) | (((u32)(rid)) << PE_REFRESH_REG_ID_SHIFT))
+
+#define TX_REFRESH_REG_ID_SIZE 8
+#define TX_REFRESH_REG_ID_SHIFT 24
+#define TX_REFRESH_REG_ID_MASK 0xff000000
+
+#define TX_REFRESH_INTERVAL_SHIFT 0
+#define TX_REFRESH_ENABLE_SHIFT 10
+#define TX_REFRESH_TOTAL_SIZE 32
+#define TX_REFRESH(interval, enable, rid)                                                          \
+  ((((u32)(interval)) << TX_REFRESH_INTERVAL_SHIFT) |                                              \
+   (((u32)(enable)) << TX_REFRESH_ENABLE_SHIFT) | (((u32)(rid)) << TX_REFRESH_REG_ID_SHIFT))
+
+#define GX_VAT_REG_A_UNK_SIZE 1
+#define GX_VAT_REG_A_UNK_SHIFT 30
+#define GX_VAT_REG_A_UNK_MASK 0x40000000
+
+#define GX_VAT_REG_B_UNK_SIZE 1
+#define GX_VAT_REG_B_UNK_SHIFT 31
+#define GX_VAT_REG_B_UNK_MASK 0x80000000
+
+#endif // _DOLPHIN_GXPRIV

include/dolphin/gx/GXStruct.h

@@ -0,0 +1,87 @@
+#ifndef _DOLPHIN_GXSTRUCT
+#define _DOLPHIN_GXSTRUCT
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/types.h>
+#include <dolphin/vitypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _GXRenderModeObj {
+  /*0x00*/ VITVMode viTVmode;
+  /*0x04*/ u16 fbWidth;
+  /*0x06*/ u16 efbHeight;
+  /*0x08*/ u16 xfbHeight;
+  /*0x0A*/ u16 viXOrigin;
+  /*0x0C*/ u16 viYOrigin;
+  /*0x0E*/ u16 viWidth;
+  /*0x10*/ u16 viHeight;
+  /*0x14*/ VIXFBMode xFBmode;
+  /*0x18*/ u8 field_rendering;
+  u8 aa;
+  u8 sample_pattern[12][2];
+  u8 vfilter[7];
+} GXRenderModeObj;
+
+typedef struct _GXColor {
+  u8 r;
+  u8 g;
+  u8 b;
+  u8 a;
+} GXColor;
+
+typedef struct _GXTexObj {
+#ifdef TARGET_PC
+  u32 dummy[22];
+#else
+  u32 dummy[8];
+#endif
+} GXTexObj;
+
+typedef struct _GXTlutObj {
+#ifdef TARGET_PC
+  u32 dummy[4];
+#else
+  u32 dummy[3];
+#endif
+} GXTlutObj;
+
+typedef struct _GXLightObj {
+  u32 dummy[16];
+} GXLightObj;
+
+typedef struct _GXVtxDescList {
+  GXAttr attr;
+  GXAttrType type;
+} GXVtxDescList;
+
+typedef struct _GXColorS10 {
+  s16 r;
+  s16 g;
+  s16 b;
+  s16 a;
+} GXColorS10;
+
+typedef struct _GXTexRegion {
+  u32 dummy[4];
+} GXTexRegion;
+
+typedef struct _GXTlutRegion {
+  u32 dummy[4];
+} GXTlutRegion;
+
+typedef struct _GXVtxAttrFmtList {
+  // total size: 0x10
+  GXAttr attr;     // offset 0x0, size 0x4
+  GXCompCnt cnt;   // offset 0x4, size 0x4
+  GXCompType type; // offset 0x8, size 0x4
+  u8 frac;         // offset 0xC, size 0x1
+} GXVtxAttrFmtList;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXSTRUCT

include/dolphin/gx/GXTev.h

@@ -0,0 +1,37 @@
+#ifndef _DOLPHIN_GXTEV
+#define _DOLPHIN_GXTEV
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GXSetTevOp(GXTevStageID id, GXTevMode mode);
+void GXSetTevColorIn(GXTevStageID stage, GXTevColorArg a, GXTevColorArg b, GXTevColorArg c,
+                     GXTevColorArg d);
+void GXSetTevAlphaIn(GXTevStageID stage, GXTevAlphaArg a, GXTevAlphaArg b, GXTevAlphaArg c,
+                     GXTevAlphaArg d);
+void GXSetTevColorOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp,
+                     GXTevRegID out_reg);
+void GXSetTevAlphaOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp,
+                     GXTevRegID out_reg);
+void GXSetTevColor(GXTevRegID id, GXColor color);
+void GXSetTevColorS10(GXTevRegID id, GXColorS10 color);
+void GXSetTevKColor(GXTevKColorID id, GXColor color);
+void GXSetTevKColorSel(GXTevStageID stage, GXTevKColorSel sel);
+void GXSetTevKAlphaSel(GXTevStageID stage, GXTevKAlphaSel sel);
+void GXSetTevSwapMode(GXTevStageID stage, GXTevSwapSel ras_sel, GXTevSwapSel tex_sel);
+void GXSetTevSwapModeTable(GXTevSwapSel table, GXTevColorChan red, GXTevColorChan green,
+                           GXTevColorChan blue, GXTevColorChan alpha);
+void GXSetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1);
+void GXSetZTexture(GXZTexOp op, GXTexFmt fmt, u32 bias);
+void GXSetTevOrder(GXTevStageID stage, GXTexCoordID coord, GXTexMapID map, GXChannelID color);
+void GXSetNumTevStages(u8 nStages);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXTEV

include/dolphin/gx/GXTexture.h

@@ -0,0 +1,37 @@
+#ifndef _DOLPHIN_GXTEXTURE
+#define _DOLPHIN_GXTEXTURE
+
+#include <dolphin/gx/GXEnum.h>
+#include <dolphin/gx/GXStruct.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef GXTexRegion* (*GXTexRegionCallback)(const GXTexObj* obj, GXTexMapID id);
+
+void GXInitTexObj(GXTexObj* obj, const void* data, u16 width, u16 height, u32 format,
+                  GXTexWrapMode wrapS, GXTexWrapMode wrapT, GXBool mipmap);
+void GXInitTexObjCI(GXTexObj* obj, const void* data, u16 width, u16 height, GXCITexFmt format,
+                    GXTexWrapMode wrapS, GXTexWrapMode wrapT, GXBool mipmap, u32 tlut);
+void GXInitTexObjData(GXTexObj* obj, const void* data);
+void GXInitTexObjLOD(GXTexObj* obj, GXTexFilter min_filt, GXTexFilter mag_filt, f32 min_lod,
+                     f32 max_lod, f32 lod_bias, GXBool bias_clamp, GXBool do_edge_lod,
+                     GXAnisotropy max_aniso);
+void GXLoadTexObj(GXTexObj* obj, GXTexMapID id);
+u32 GXGetTexBufferSize(u16 width, u16 height, u32 format, GXBool mipmap, u8 max_lod);
+void GXInvalidateTexAll();
+void GXInitTexObjWrapMode(GXTexObj* obj, GXTexWrapMode s, GXTexWrapMode t);
+void GXInitTlutObj(GXTlutObj* obj, void* data, GXTlutFmt format, u16 entries);
+void GXLoadTlut(const GXTlutObj* obj, GXTlut idx);
+void GXSetTexCoordScaleManually(GXTexCoordID coord, GXBool enable, u16 ss, u16 ts);
+void GXInitTexCacheRegion(GXTexRegion* region, GXBool is_32b_mipmap, u32 tmem_even,
+                          GXTexCacheSize size_even, u32 tmem_odd, GXTexCacheSize size_odd);
+GXTexRegionCallback GXSetTexRegionCallback(GXTexRegionCallback callback);
+void GXInvalidateTexRegion(const GXTexRegion* region);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXTEXTURE

include/dolphin/gx/GXTransform.h

@@ -0,0 +1,33 @@
+#ifndef _DOLPHIN_GXTRANSFORM
+#define _DOLPHIN_GXTRANSFORM
+
+#include <dolphin/gx/GXEnum.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GX_PROJECTION_SZ 7
+
+#ifdef TARGET_PC
+void GXSetProjection(const void* mtx, GXProjectionType type);
+void GXLoadPosMtxImm(const void* mtx, u32 id);
+void GXLoadNrmMtxImm(const void* mtx, u32 id);
+void GXLoadTexMtxImm(const void* mtx, u32 id, GXTexMtxType type);
+#else
+void GXSetProjection(f32 mtx[4][4], GXProjectionType type);
+void GXLoadPosMtxImm(f32 mtx[3][4], u32 id);
+void GXLoadNrmMtxImm(f32 mtx[3][4], u32 id);
+void GXLoadTexMtxImm(f32 mtx[][4], u32 id, GXTexMtxType type);
+#endif
+void GXSetViewport(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz);
+void GXSetCurrentMtx(u32 id);
+void GXSetViewportJitter(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz, u32 field);
+void GXSetScissorBoxOffset(s32 x_off, s32 y_off);
+void GXSetClipMode(GXClipMode mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXTRANSFORM

include/dolphin/gx/GXVerify.h

@@ -0,0 +1,47 @@
+#ifndef _DOLPHIN_GXVERIFY
+#define _DOLPHIN_GXVERIFY
+
+#include <dolphin/types.h>
+
+typedef enum {
+  GX_WARN_NONE,
+  GX_WARN_SEVERE,
+  GX_WARN_MEDIUM,
+  GX_WARN_ALL,
+} GXWarningLevel;
+
+#ifdef _DEBUG
+extern void GXSetVerifyLevel(GXWarningLevel level);
+#else
+#define GXSetVerifyLevel(level) ((void)0)
+#endif
+
+typedef void (*GXVerifyCallback)(GXWarningLevel level, u32 id, const char* msg);
+
+typedef struct __GXVerifyData {
+  GXVerifyCallback cb;        // offset 0x0, size 0x4
+  GXWarningLevel verifyLevel; // offset 0x4, size 0x4
+  u32 xfRegs[80];             // offset 0x8, size 0x140
+  u32 xfMtx[256];             // offset 0x148, size 0x400
+  u32 xfNrm[96];              // offset 0x548, size 0x180
+  u32 xfDMtx[256];            // offset 0x6C8, size 0x400
+  u32 xfLight[128];           // offset 0xAC8, size 0x200
+  u32 rasRegs[256];           // offset 0xCC8, size 0x400
+  u8 xfRegsDirty[80];         // offset 0x10C8, size 0x50
+  u8 xfMtxDirty[256];         // offset 0x1118, size 0x100
+  u8 xfNrmDirty[96];          // offset 0x1218, size 0x60
+  u8 xfDMtxDirty[256];        // offset 0x1278, size 0x100
+  u8 xfLightDirty[128];       // offset 0x1378, size 0x80
+} GXVerifyData;
+
+#ifdef _DEBUG
+GXVerifyCallback GXSetVerifyCallback(GXVerifyCallback cb);
+#else
+#define GXSetVerifyCallback(cb) ((GXVerifyCallback)0)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXVERIFY

include/dolphin/gx/GXVert.h

@@ -0,0 +1,141 @@
+#ifndef _DOLPHIN_GXVERT
+#define _DOLPHIN_GXVERT
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GXFIFO_ADDR 0xCC008000
+
+typedef union {
+  u8 u8;
+  u16 u16;
+  u32 u32;
+  u64 u64;
+  s8 s8;
+  s16 s16;
+  s32 s32;
+  s64 s64;
+  f32 f32;
+  f64 f64;
+} PPCWGPipe;
+
+#ifdef __MWERKS__
+/*volatile*/ PPCWGPipe GXWGFifo : GXFIFO_ADDR;
+#else
+#define GXWGFifo (*(volatile PPCWGPipe*)GXFIFO_ADDR)
+#endif
+
+#ifdef TARGET_PC
+
+void GXPosition3f32(f32 x, f32 y, f32 z);
+void GXPosition3u16(u16 x, u16 y, u16 z);
+void GXPosition3s16(s16 x, s16 y, s16 z);
+void GXPosition3u8(u8 x, u8 y, u8 z);
+void GXPosition3s8(s8 x, s8 y, s8 z);
+
+void GXPosition2f32(f32 x, f32 y);
+void GXPosition2u16(u16 x, u16 y);
+void GXPosition2s16(s16 x, s16 y);
+void GXPosition2u8(u8 x, u8 y);
+void GXPosition2s8(s8 x, s8 y);
+
+void GXPosition1x16(u16 index);
+void GXPosition1x8(u8 index);
+
+void GXNormal3f32(f32 x, f32 y, f32 z);
+void GXNormal3s16(s16 x, s16 y, s16 z);
+void GXNormal3s8(s8 x, s8 y, s8 z);
+
+void GXNormal1x16(u16 index);
+void GXNormal1x8(u8 index);
+
+void GXColor4u8(u8 r, u8 g, u8 b, u8 a);
+
+void GXColor3u8(u8 r, u8 g, u8 b);
+
+void GXColor1u32(u32 clr);
+void GXColor1u16(u16 clr);
+
+void GXColor1x16(u16 index);
+void GXColor1x8(u8 index);
+
+void GXTexCoord2f32(f32 s, f32 t);
+void GXTexCoord2u16(u16 s, u16 t);
+void GXTexCoord2s16(s16 s, s16 t);
+void GXTexCoord2u8(u8 s, u8 t);
+void GXTexCoord2s8(s8 s, s8 t);
+
+void GXTexCoord1f32(f32 s, f32 t);
+void GXTexCoord1u16(u16 s, u16 t);
+void GXTexCoord1s16(s16 s, s16 t);
+void GXTexCoord1u8(u8 s, u8 t);
+void GXTexCoord1s8(s8 s, s8 t);
+
+void GXTexCoord1x16(u16 index);
+void GXTexCoord1x8(u8 index);
+
+extern void GXEnd(void);
+
+#else
+
+static inline void GXPosition2f32(const f32 x, const f32 y) {
+  GXWGFifo.f32 = x;
+  GXWGFifo.f32 = y;
+}
+
+static inline void GXPosition3s16(const s16 x, const s16 y, const s16 z) {
+  GXWGFifo.s16 = x;
+  GXWGFifo.s16 = y;
+  GXWGFifo.s16 = z;
+}
+
+static inline void GXPosition3f32(const f32 x, const f32 y, const f32 z) {
+  GXWGFifo.f32 = x;
+  GXWGFifo.f32 = y;
+  GXWGFifo.f32 = z;
+}
+
+static inline void GXNormal3f32(const f32 x, const f32 y, const f32 z) {
+  GXWGFifo.f32 = x;
+  GXWGFifo.f32 = y;
+  GXWGFifo.f32 = z;
+}
+
+static inline void GXColor1u32(const u32 v) {
+  GXWGFifo.u32 = v;
+}
+
+static inline void GXColor4u8(const u8 r, const u8 g, const u8 b, const u8 a) {
+  GXWGFifo.u8 = r;
+  GXWGFifo.u8 = g;
+  GXWGFifo.u8 = b;
+  GXWGFifo.u8 = a;
+}
+
+static inline void GXTexCoord2s16(const s16 u, const s16 v) {
+  GXWGFifo.s16 = u;
+  GXWGFifo.s16 = v;
+}
+
+static inline void GXTexCoord2f32(const f32 u, const f32 v) {
+  GXWGFifo.f32 = u;
+  GXWGFifo.f32 = v;
+}
+
+
+static inline void GXPosition1x8(u8 index) {
+  GXWGFifo.u8 = index;
+}
+
+static inline void GXEnd(void) {}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GXVERT

include/dolphin/hw_regs.h

@@ -0,0 +1,237 @@
+#ifndef _DOLPHIN_HW_REGS
+#define _DOLPHIN_HW_REGS
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __MWERKS__
+
+vu16 __VIRegs[59] : 0xCC002000;
+
+// offsets for __VIRegs[i]
+#define VI_VERT_TIMING        (0)
+#define VI_DISP_CONFIG        (1)
+#define VI_HORIZ_TIMING_0L    (2)
+#define VI_HORIZ_TIMING_0U    (3)
+#define VI_HORIZ_TIMING_1L    (4)
+#define VI_HORIZ_TIMING_1U    (5)
+#define VI_VERT_TIMING_ODD    (6)
+#define VI_VERT_TIMING_ODD_U  (7)
+#define VI_VERT_TIMING_EVEN   (8)
+#define VI_VERT_TIMING_EVEN_U (9)
+
+#define VI_BBI_ODD    (10) // burst blanking interval
+#define VI_BBI_ODD_U  (11) // burst blanking interval
+#define VI_BBI_EVEN   (12) // burst blanking interval
+#define VI_BBI_EVEN_U (13) // burst blanking interval
+
+#define VI_TOP_FIELD_BASE_LEFT   (14) // top in 2d, top of left pic in 3d
+#define VI_TOP_FIELD_BASE_LEFT_U (15) // top in 2d, top of left pic in 3d
+
+#define VI_TOP_FIELD_BASE_RIGHT   (16) // top of right pic in 3d
+#define VI_TOP_FIELD_BASE_RIGHT_U (17) // top of right pic in 3d
+
+#define VI_BTTM_FIELD_BASE_LEFT   (18) // bottom in 2d, bottom of left pic in 3d
+#define VI_BTTM_FIELD_BASE_LEFT_U (19) // bottom in 2d, bottom of left pic in 3d
+
+#define VI_BTTM_FIELD_BASE_RIGHT   (20) // bottom of right pic in 3d
+#define VI_BTTM_FIELD_BASE_RIGHT_U (21) // bottom of right pic in 3d
+
+#define VI_VERT_COUNT  (22) // vertical display position
+#define VI_HORIZ_COUNT (23) // horizontal display position
+
+#define VI_DISP_INT_0  (24) // display interrupt 0L
+#define VI_DISP_INT_0U (25) // display interrupt 0U
+#define VI_DISP_INT_1  (26) // display interrupt 1L
+#define VI_DISP_INT_1U (27) // display interrupt 1U
+#define VI_DISP_INT_2  (28) // display interrupt 2L
+#define VI_DISP_INT_2U (29) // display interrupt 2U
+#define VI_DISP_INT_3  (30) // display interrupt 3L
+#define VI_DISP_INT_3U (31) // display interrupt 3U
+
+#define VI_HSW (36) // horizontal scaling width
+#define VI_HSR (37) // horizontal scaling register
+
+#define VI_FCT_0  (38) // filter coefficient table 0L
+#define VI_FCT_0U (39) // filter coefficient table 0U
+#define VI_FCT_1  (40) // filter coefficient table 1L
+#define VI_FCT_1U (41) // filter coefficient table 1U
+#define VI_FCT_2  (42) // filter coefficient table 2L
+#define VI_FCT_2U (43) // filter coefficient table 2U
+#define VI_FCT_3  (44) // filter coefficient table 3L
+#define VI_FCT_3U (45) // filter coefficient table 3U
+#define VI_FCT_4  (46) // filter coefficient table 4L
+#define VI_FCT_4U (47) // filter coefficient table 4U
+#define VI_FCT_5  (48) // filter coefficient table 5L
+#define VI_FCT_5U (49) // filter coefficient table 5U
+#define VI_FCT_6  (50) // filter coefficient table 6L
+#define VI_FCT_6U (51) // filter coefficient table 6U
+
+#define VI_CLOCK_SEL (54) // clock select
+#define VI_DTV_STAT  (55) // DTV status
+
+#define VI_WIDTH (56)
+
+vu32 __PIRegs[12] : 0xCC003000;
+
+// offsets for __PIRegs[i]
+
+#define PI_INTRPT_SRC  (0) // interrupt cause
+#define PI_INTRPT_MASK (1) // interrupt mask
+#define PI_FIFO_START  (3) // FIFO base start
+#define PI_FIFO_END    (4) // FIFO base end
+#define PI_FIFO_PTR    (5) // FIFO current write pointer
+
+#define PI_RESETCODE (9) // reset code, used by OSReset
+
+// PI Interrupt causes.
+#define PI_INTRPT_ERR       (0x1) // GP runtime error
+#define PI_INTRPT_RSW       (0x2) // reset switch
+#define PI_INTRPT_DVD       (0x4) // DVD/DI interrupt
+#define PI_INTRPT_SI        (0x8) // serial/controller interrupt
+#define PI_INTRPT_EXI       (0x10) // external mem interrupt
+#define PI_INTRPT_AI        (0x20) // audio streaming interrupt
+#define PI_INTRPT_DSP       (0x40) // digital signal proc interrupt
+#define PI_INTRPT_MEM       (0x80) // memory interface interrupt
+#define PI_INTRPT_VI        (0x100) // video interface interrupt
+#define PI_INTRPT_PE_TOKEN  (0x200) // pixel engine token
+#define PI_INTRPT_PE_FINISH (0x400) // pixel engine finish
+#define PI_INTRPT_CP        (0x800) // command FIFO
+#define PI_INTRPT_DEBUG     (0x1000) // external debugger
+#define PI_INTRPT_HSP       (0x2000) // high speed port
+#define PI_INTRPT_RSWST     (0x10000) // reset switch state (1 when pressed)
+
+
+vu16 __MEMRegs[64] : 0xCC004000;
+
+// offsets for __MEMRegs[i]
+#define MEM_PROT_1    (0) // protected region 1
+#define MEM_PROT_2    (2) // protected region 1
+#define MEM_PROT_3    (4) // protected region 1
+#define MEM_PROT_4    (6) // protected region 1
+#define MEM_PROT_TYPE (8) // protection type
+
+#define MEM_INTRPT_MASK    (14) // interrupt mask
+#define MEM_INTRPT_SRC     (15) // interrupt cause
+#define MEM_INTRPT_FLAG    (16) // set when interrupt happens
+#define MEM_INTRPT_ADDR_LO (17) // address that caused interrupt
+#define MEM_INTRPT_ADDR_HI (18) // address that caused interrupt
+
+#define MEM_UNK_FLAG (20) // unknown memory flag, set in __OSInitMemoryProtection
+
+vu16 __DSPRegs[32] : 0xCC005000;
+
+// offsets for __DSPRegs[i]
+#define DSP_MAILBOX_IN_HI  (0)
+#define DSP_MAILBOX_IN_LO  (1)
+#define DSP_MAILBOX_OUT_HI (2)
+#define DSP_MAILBOX_OUT_LO (3)
+#define DSP_CONTROL_STATUS (5)
+
+#define DSP_ARAM_SIZE        (9)
+#define DSP_ARAM_MODE        (11)
+#define DSP_ARAM_REFRESH     (13)
+#define DSP_ARAM_DMA_MM_HI   (16) // Main mem address
+#define DSP_ARAM_DMA_MM_LO   (17)
+#define DSP_ARAM_DMA_ARAM_HI (18) // ARAM address
+#define DSP_ARAM_DMA_ARAM_LO (19)
+#define DSP_ARAM_DMA_SIZE_HI (20) // DMA buffer size
+#define DSP_ARAM_DMA_SIZE_LO (21)
+
+#define DSP_DMA_START_HI    (24) // DMA start address
+#define DSP_DMA_START_LO    (25)
+#define DSP_DMA_CONTROL_LEN (27)
+#define DSP_DMA_BYTES_LEFT  (29)
+
+
+vu32 __DIRegs[16] : 0xCC006000;
+
+// offsets for __DIRegs[i]
+#define DI_STATUS       (0)
+#define DI_COVER_STATUS (1) // cover status - 0=normal, 1=interrupt/open
+#define DI_CMD_BUF_0    (2) // command buffer 0
+#define DI_CMD_BUF_1    (3) // command buffer 1
+#define DI_CMD_BUF_2    (4) // command buffer 2
+#define DI_DMA_MEM_ADDR (5) // DMA address
+#define DI_DMA_LENGTH   (6) // transfer length address
+#define DI_CONTROL      (7)
+#define DI_MM_BUF       (8) // Main memory buffer
+#define DI_CONFIG       (9)
+
+vu32 __SIRegs[64] : 0xCC006400;
+
+// offsets for __SIRegs[i]
+// Channel 0/Joy-channel 1
+#define SI_CHAN_0_BUF   (0) // output buffer
+#define SI_CHAN_0_BTN_1 (1) // button 1
+#define SI_CHAN_0_BTN_2 (2) // button 2
+// Channel 1/Joy-channel 2
+#define SI_CHAN_1_BUF   (3) // output buffer
+#define SI_CHAN_1_BTN_1 (4) // button 1
+#define SI_CHAN_1_BTN_2 (5) // button 2
+// Channel 2/Joy-channel 3
+#define SI_CHAN_2_BUF   (6) // output buffer
+#define SI_CHAN_2_BTN_1 (7) // button 1
+#define SI_CHAN_2_BTN_2 (8) // button 2
+// Channel 3/Joy-channel 4
+#define SI_CHAN_3_BUF   (9) // output buffer
+#define SI_CHAN_3_BTN_1 (10) // button 1
+#define SI_CHAN_3_BTN_2 (11) // button 2
+
+#define SI_POLL     (12)
+#define SI_CC_STAT  (13) // communication control status
+#define SI_STAT     (14)
+#define SI_EXI_LOCK (15) // exi clock lock
+
+#define SI_IO_BUFFER (32) // start of buffer (32 to 63)
+
+vu32 __EXIRegs[16] : 0xCC006800;
+
+// offsets for __EXIRegs[i]
+// Channel 0
+#define EXI_CHAN_0_STAT     (0) // parameters/status
+#define EXI_CHAN_0_DMA_ADDR (1) // DMA start address
+#define EXI_CHAN_0_LEN      (2) // DMA transfer length
+#define EXI_CHAN_0_CONTROL  (3) // control register
+#define EXI_CHAN_0_IMM      (4) // immediate data
+// Channel 1
+#define EXI_CHAN_1_STAT     (5) // parameters/status
+#define EXI_CHAN_1_DMA_ADDR (6) // DMA start address
+#define EXI_CHAN_1_LEN      (7) // DMA transfer length
+#define EXI_CHAN_1_CONTROL  (8) // control register
+#define EXI_CHAN_1_IMM      (9) // immediate data
+// Channel 2
+#define EXI_CHAN_2_STAT     (10) // parameters/status
+#define EXI_CHAN_2_DMA_ADDR (11) // DMA start address
+#define EXI_CHAN_2_LEN      (12) // DMA transfer length
+#define EXI_CHAN_2_CONTROL  (13) // control register
+#define EXI_CHAN_2_IMM      (14) // immediate data
+
+
+vu32 __AIRegs[8] : 0xCC006C00;
+
+// offsets for __AIRegs[i]
+#define AI_CONTROL        (0) // control
+#define AI_VOLUME         (1) // volume
+#define AI_SAMPLE_COUNTER (2) // number of stereo samples output
+#define AI_INTRPT_TIMING  (3) // interrupt timing
+
+#else
+#define __VIRegs ((vu16*)0xCC002000)
+#define __PIRegs ((vu32*)0xCC003000)
+#define __MEMRegs ((vu16*)0xCC004000)
+#define __DSPRegs ((vu16*)0xCC005000)
+#define __DIRegs ((vu32*)0xCC006000)
+#define __SIRegs ((vu32*)0xCC006400)
+#define __EXIRegs ((vu32*)0xCC006800)
+#define __AIRegs ((vu32*)0xCC006C00)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_HW_REGS

include/dolphin/mtx.h

@@ -0,0 +1,322 @@
+#ifndef _DOLPHIN_MTX
+#define _DOLPHIN_MTX
+
+#include <dolphin/mtx/GeoTypes.h>
+#include <dolphin/types.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define GEKKO
+#ifndef GEKKO
+#define MTX_USE_C
+#undef MTX_USE_PS
+#endif
+
+#if (!defined(MTX_USE_PS) && !defined(MTX_USE_C))
+#ifndef _DEBUG
+#define MTX_USE_PS
+#endif
+#endif
+
+
+#define MTX_PTR_OFFSET 3
+
+#define MTX44_PTR_OFFSET 4
+
+typedef struct {
+
+  u32 numMtx;
+  MtxPtr stackBase;
+  MtxPtr stackPtr;
+
+} MtxStack, *MtxStackPtr;
+
+#define MTXDegToRad(a) ((a)*0.01745329252f)
+#define MTXRadToDeg(a) ((a)*57.29577951f)
+#define MTXRowCol(m, r, c) ((m)[(r)][(c)])
+
+void C_MTXIdentity(Mtx m);
+void C_MTXCopy(const Mtx src, Mtx dst);
+void C_MTXConcat(const Mtx a, const Mtx b, Mtx ab);
+void C_MTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count);
+void C_MTXTranspose(const Mtx src, Mtx xPose);
+u32 C_MTXInverse(const Mtx src, Mtx inv);
+u32 C_MTXInvXpose(const Mtx src, Mtx invX);
+
+#ifdef GEKKO
+void PSMTXIdentity(Mtx m);
+void PSMTXCopy(const Mtx src, Mtx dst);
+void PSMTXConcat(const Mtx a, const Mtx b, Mtx ab);
+void PSMTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count);
+void PSMTXTranspose(const Mtx src, Mtx xPose);
+u32 PSMTXInverse(const Mtx src, Mtx inv);
+u32 PSMTXInvXpose(const Mtx src, Mtx invX);
+#endif
+
+#ifdef MTX_USE_PS
+#define MTXIdentity PSMTXIdentity
+#define MTXCopy PSMTXCopy
+#define MTXConcat PSMTXConcat
+#define MTXConcatArray PSMTXConcatArray
+#define MTXTranspose PSMTXTranspose
+#define MTXInverse PSMTXInverse
+#define MTXInvXpose PSMTXInvXpose
+#else
+#define MTXIdentity C_MTXIdentity
+#define MTXCopy C_MTXCopy
+#define MTXConcat C_MTXConcat
+#define MTXConcatArray C_MTXConcatArray
+#define MTXTranspose C_MTXTranspose
+#define MTXInverse C_MTXInverse
+#define MTXInvXpose C_MTXInvXpose
+#endif
+
+void C_MTXMultVec(const Mtx m, const Vec* src, Vec* dst);
+void C_MTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count);
+void C_MTXMultVecSR(const Mtx m, const Vec* src, Vec* dst);
+void C_MTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count);
+
+#ifdef GEKKO
+void PSMTXMultVec(const Mtx m, const Vec* src, Vec* dst);
+void PSMTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count);
+void PSMTXMultVecSR(const Mtx m, const Vec* src, Vec* dst);
+void PSMTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count);
+#endif
+
+#ifdef MTX_USE_PS
+#define MTXMultVec PSMTXMultVec
+#define MTXMultVecArray PSMTXMultVecArray
+#define MTXMultVecSR PSMTXMultVecSR
+#define MTXMultVecArraySR PSMTXMultVecArraySR
+#else // MTX_USE_C
+#define MTXMultVec C_MTXMultVec
+#define MTXMultVecArray C_MTXMultVecArray
+#define MTXMultVecSR C_MTXMultVecSR
+#define MTXMultVecArraySR C_MTXMultVecArraySR
+#endif
+
+void C_MTXQuat(Mtx m, const Quaternion* q);
+void C_MTXReflect(Mtx m, const Vec* p, const Vec* n);
+
+void C_MTXTrans(Mtx m, f32 xT, f32 yT, f32 zT);
+void C_MTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT);
+void C_MTXScale(Mtx m, f32 xS, f32 yS, f32 zS);
+void C_MTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS);
+
+void C_MTXRotRad(Mtx m, char axis, f32 rad);
+void C_MTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA);
+void C_MTXRotAxisRad(Mtx m, const Vec* axis, f32 rad);
+
+#ifdef GEKKO
+void PSMTXQuat(Mtx m, const Quaternion* q);
+void PSMTXReflect(Mtx m, const Vec* p, const Vec* n);
+
+void PSMTXTrans(Mtx m, f32 xT, f32 yT, f32 zT);
+void PSMTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT);
+void PSMTXScale(Mtx m, f32 xS, f32 yS, f32 zS);
+void PSMTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS);
+
+void PSMTXRotRad(Mtx m, char axis, f32 rad);
+void PSMTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA);
+void PSMTXRotAxisRad(Mtx m, const Vec* axis, f32 rad);
+#endif
+
+#ifdef MTX_USE_PS
+#define MTXQuat PSMTXQuat
+#define MTXReflect PSMTXReflect
+#define MTXTrans PSMTXTrans
+#define MTXTransApply PSMTXTransApply
+#define MTXScale PSMTXScale
+#define MTXScaleApply PSMTXScaleApply
+#define MTXRotRad PSMTXRotRad
+#define MTXRotTrig PSMTXRotTrig
+#define MTXRotAxisRad PSMTXRotAxisRad
+
+#define MTXRotDeg(m, axis, deg) PSMTXRotRad(m, axis, MTXDegToRad(deg))
+#define MTXRotAxisDeg(m, axis, deg) PSMTXRotAxisRad(m, axis, MTXDegToRad(deg))
+
+#else // MTX_USE_C
+#define MTXQuat C_MTXQuat
+#define MTXReflect C_MTXReflect
+#define MTXTrans C_MTXTrans
+#define MTXTransApply C_MTXTransApply
+#define MTXScale C_MTXScale
+#define MTXScaleApply C_MTXScaleApply
+#define MTXRotRad C_MTXRotRad
+#define MTXRotTrig C_MTXRotTrig
+#define MTXRotAxisRad C_MTXRotAxisRad
+
+#define MTXRotDeg(m, axis, deg) C_MTXRotRad(m, axis, MTXDegToRad(deg))
+#define MTXRotAxisDeg(m, axis, deg) C_MTXRotAxisRad(m, axis, MTXDegToRad(deg))
+
+#endif
+
+void C_MTXLookAt(Mtx m, const Point3d* camPos, const Vec* camUp, const Point3d* target);
+
+#define MTXLookAt C_MTXLookAt
+
+void C_MTXFrustum(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f);
+void C_MTXPerspective(Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f);
+void C_MTXOrtho(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f);
+
+#define MTXFrustum C_MTXFrustum
+#define MTXPerspective C_MTXPerspective
+#define MTXOrtho C_MTXOrtho
+
+void C_MTXLightFrustum(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 scaleS, f32 scaleT, f32 transS,
+                       f32 transT);
+
+void C_MTXLightPerspective(Mtx m, f32 fovY, f32 aspect, f32 scaleS, f32 scaleT, f32 transS,
+                           f32 transT);
+
+void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT, f32 transS,
+                     f32 transT);
+
+#define MTXLightFrustum C_MTXLightFrustum
+#define MTXLightPerspective C_MTXLightPerspective
+#define MTXLightOrtho C_MTXLightOrtho
+
+void C_VECAdd(const Vec* a, const Vec* b, Vec* ab);
+void C_VECSubtract(const Vec* a, const Vec* b, Vec* a_b);
+void C_VECScale(const Vec* src, Vec* dst, f32 scale);
+void C_VECNormalize(const Vec* src, Vec* unit);
+f32 C_VECSquareMag(const Vec* v);
+f32 C_VECMag(const Vec* v);
+f32 C_VECDotProduct(const Vec* a, const Vec* b);
+void C_VECCrossProduct(const Vec* a, const Vec* b, Vec* axb);
+f32 C_VECSquareDistance(const Vec* a, const Vec* b);
+f32 C_VECDistance(const Vec* a, const Vec* b);
+void C_VECReflect(const Vec* src, const Vec* normal, Vec* dst);
+void C_VECHalfAngle(const Vec* a, const Vec* b, Vec* half);
+
+#ifdef GEKKO
+void PSVECAdd(const Vec* a, const Vec* b, Vec* ab);
+void PSVECSubtract(const Vec* a, const Vec* b, Vec* a_b);
+void PSVECScale(const Vec* src, Vec* dst, f32 scale);
+void PSVECNormalize(const Vec* src, Vec* unit);
+f32 PSVECSquareMag(const Vec* v);
+f32 PSVECMag(const Vec* v);
+f32 PSVECDotProduct(const Vec* a, const Vec* b);
+void PSVECCrossProduct(const Vec* a, const Vec* b, Vec* axb);
+f32 PSVECSquareDistance(const Vec* a, const Vec* b);
+f32 PSVECDistance(const Vec* a, const Vec* b);
+#endif
+
+// TODO
+#if defined( MTX_USE_PS) && 0
+#define VECAdd PSVECAdd
+#define VECSubtract PSVECSubtract
+#define VECScale PSVECScale
+#define VECNormalize PSVECNormalize
+#define VECSquareMag PSVECSquareMag
+#define VECMag PSVECMag
+#define VECDotProduct PSVECDotProduct
+#define VECCrossProduct PSVECCrossProduct
+#define VECSquareDistance PSVECSquareDistance
+#define VECDistance PSVECDistance
+#else // MTX_USE_C
+#define VECAdd C_VECAdd
+#define VECSubtract C_VECSubtract
+#define VECScale C_VECScale
+#define VECNormalize C_VECNormalize
+#define VECSquareMag C_VECSquareMag
+#define VECMag C_VECMag
+#define VECDotProduct C_VECDotProduct
+#define VECCrossProduct C_VECCrossProduct
+#define VECSquareDistance C_VECSquareDistance
+#define VECDistance C_VECDistance
+#endif
+
+#define VECReflect C_VECReflect
+#define VECHalfAngle C_VECHalfAngle
+
+void C_QUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void C_QUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void C_QUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq);
+void C_QUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void C_QUATScale(const Quaternion* q, Quaternion* r, f32 scale);
+f32 C_QUATDotProduct(const Quaternion* p, const Quaternion* q);
+void C_QUATNormalize(const Quaternion* src, Quaternion* unit);
+void C_QUATInverse(const Quaternion* src, Quaternion* inv);
+void C_QUATExp(const Quaternion* q, Quaternion* r);
+void C_QUATLogN(const Quaternion* q, Quaternion* r);
+
+void C_QUATMakeClosest(const Quaternion* q, const Quaternion* qto, Quaternion* r);
+void C_QUATRotAxisRad(Quaternion* r, const Vec* axis, f32 rad);
+void C_QUATMtx(Quaternion* r, const Mtx m);
+
+void C_QUATLerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t);
+void C_QUATSlerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t);
+void C_QUATSquad(const Quaternion* p, const Quaternion* a, const Quaternion* b, const Quaternion* q,
+                 Quaternion* r, f32 t);
+void C_QUATCompA(const Quaternion* qprev, const Quaternion* q, const Quaternion* qnext,
+                 Quaternion* a);
+
+#ifdef GEKKO
+void PSQUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void PSQUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void PSQUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq);
+void PSQUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r);
+void PSQUATScale(const Quaternion* q, Quaternion* r, f32 scale);
+f32 PSQUATDotProduct(const Quaternion* p, const Quaternion* q);
+void PSQUATNormalize(const Quaternion* src, Quaternion* unit);
+void PSQUATInverse(const Quaternion* src, Quaternion* inv);
+#endif
+
+#ifdef MTX_USE_PS
+#define QUATAdd PSQUATAdd
+#define QUATSubtract PSQUATSubtract
+#define QUATMultiply PSQUATMultiply
+#define QUATDivide PSQUATDivide
+#define QUATScale PSQUATScale
+#define QUATDotProduct PSQUATDotProduct
+#define QUATNormalize PSQUATNormalize
+#define QUATInverse PSQUATInverse
+#else // MTX_USE_C
+#define QUATAdd C_QUATAdd
+#define QUATSubtract C_QUATSubtract
+#define QUATMultiply C_QUATMultiply
+#define QUATDivide C_QUATDivide
+#define QUATScale C_QUATScale
+#define QUATDotProduct C_QUATDotProduct
+#define QUATNormalize C_QUATNormalize
+#define QUATInverse C_QUATInverse
+#endif
+
+#define QUATExp C_QUATExp
+#define QUATLogN C_QUATLogN
+#define QUATMakeClosest C_QUATMakeClosest
+#define QUATRotAxisRad C_QUATRotAxisRad
+#define QUATMtx C_QUATMtx
+#define QUATLerp C_QUATLerp
+#define QUATSlerp C_QUATSlerp
+#define QUATSquad C_QUATSquad
+#define QUATCompA C_QUATCompA
+
+#ifdef GEKKO
+void PSMTXReorder(const Mtx src, ROMtx dest);
+void PSMTXROMultVecArray(const ROMtx m, const Vec* srcBase, Vec* dstBase, u32 count);
+void PSMTXROSkin2VecArray(const ROMtx m0, const ROMtx m1, const f32* wtBase, const Vec* srcBase,
+                          Vec* dstBase, u32 count);
+void PSMTXMultS16VecArray(const Mtx m, const S16Vec* srcBase, Vec* dstBase, u32 count);
+void PSMTXROMultS16VecArray(const ROMtx m, const S16Vec* srcBase, Vec* dstBase, u32 count);
+#endif
+
+void MTXInitStack(MtxStack* sPtr, u32 numMtx);
+MtxPtr MTXPush(MtxStack* sPtr, const Mtx m);
+MtxPtr MTXPushFwd(MtxStack* sPtr, const Mtx m);
+MtxPtr MTXPushInv(MtxStack* sPtr, const Mtx m);
+MtxPtr MTXPushInvXpose(MtxStack* sPtr, const Mtx m);
+MtxPtr MTXPop(MtxStack* sPtr);
+MtxPtr MTXGetStackPtr(const MtxStack* sPtr);
+
+#define MTXAllocStack(sPtr, numMtx)                                                                \
+  (((MtxStackPtr)(sPtr))->stackBase = (MtxPtr)OSAlloc(((numMtx) * sizeof(Mtx))))
+
+#define MTXFreeStack(sPtr) (OSFree((void*)(((MtxStackPtr)(sPtr))->stackBase)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_MTX

include/dolphin/mtx/GeoTypes.h

@@ -0,0 +1,39 @@
+#ifndef _DOLPHIN_GEOTYPES
+#define _DOLPHIN_GEOTYPES
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  f32 x, y, z;
+} Vec, *VecPtr, Point3d, *Point3dPtr;
+
+typedef struct {
+  s16 x;
+  s16 y;
+  s16 z;
+} S16Vec, *S16VecPtr;
+
+typedef struct {
+  f32 x, y, z, w;
+} Quaternion, *QuaternionPtr, Qtrn, *QtrnPtr;
+
+typedef f32 Mtx[3][4];
+
+typedef f32 (*MtxPtr)[4];
+
+typedef f32 ROMtx[4][3];
+
+typedef f32 (*ROMtxPtr)[3];
+
+typedef f32 Mtx44[4][4];
+
+typedef f32 (*Mtx44Ptr)[4];
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_GEOTYPES

include/dolphin/os.h

@@ -0,0 +1,244 @@
+#ifndef _DOLPHIN_OS
+#define _DOLPHIN_OS
+
+#include <dolphin/gx.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Upper words of the masks, since UIMM is only 16 bits
+#define OS_CACHED_REGION_PREFIX 0x8000
+#define OS_UNCACHED_REGION_PREFIX 0xC000
+#define OS_PHYSICAL_MASK 0x3FFF
+
+#define OS_BASE_CACHED (OS_CACHED_REGION_PREFIX << 16)
+#define OS_BASE_UNCACHED (OS_UNCACHED_REGION_PREFIX << 16)
+
+#ifdef __MWERKS__
+#define AT_ADDRESS(xyz) : (xyz)
+#else
+#define AT_ADDRESS
+#endif
+typedef s64 OSTime;
+typedef u32 OSTick;
+u32 __OSBusClock AT_ADDRESS(OS_BASE_CACHED | 0x00F8);  // sync with OSLoMem.h
+u32 __OSCoreClock AT_ADDRESS(OS_BASE_CACHED | 0x00FC); // sync with OSLoMem.h
+#define OS_BUS_CLOCK (u32)__OSBusClock
+#define OS_CORE_CLOCK __OSCoreClock
+#define OS_TIMER_CLOCK (OS_BUS_CLOCK / 4)
+
+#ifndef _DEBUG
+#define OSPhysicalToCached(paddr) ((void*)((u32)(paddr) + OS_BASE_CACHED))
+#define OSPhysicalToUncached(paddr) ((void*)((u32)(paddr) + OS_BASE_UNCACHED))
+#define OSCachedToPhysical(caddr) ((u32)((u8*)(caddr)-OS_BASE_CACHED))
+#define OSUncachedToPhysical(ucaddr) ((u32)((u8*)(ucaddr)-OS_BASE_UNCACHED))
+#define OSCachedToUncached(caddr) ((void*)((u8*)(caddr) + (OS_BASE_UNCACHED - OS_BASE_CACHED)))
+#define OSUncachedToCached(ucaddr) ((void*)((u8*)(ucaddr) - (OS_BASE_UNCACHED - OS_BASE_CACHED)))
+#else
+u32 OSPhysicalToCached(void* paddr);
+u32 OSPhysicalToUncached(void* paddr);
+u32 OSCachedToPhysical(void* caddr);
+u32 OSUncachedToPhysical(void* ucaddr);
+u32 OSCachedToUncached(void* caddr);
+u32 OSUncachedToCached(void* ucaddr);
+#endif
+
+#define OSTicksToCycles(ticks) (((ticks) * ((OS_CORE_CLOCK * 2) / OS_TIMER_CLOCK)) / 2)
+#define OSTicksToSeconds(ticks) ((ticks) / OS_TIMER_CLOCK)
+#define OSTicksToMilliseconds(ticks) ((ticks) / (OS_TIMER_CLOCK / 1000))
+#define OSTicksToMicroseconds(ticks) (((ticks)*8) / (OS_TIMER_CLOCK / 125000))
+#define OSTicksToNanoseconds(ticks) (((ticks)*8000) / (OS_TIMER_CLOCK / 125000))
+#define OSSecondsToTicks(sec) ((sec)*OS_TIMER_CLOCK) 
+#define OSMillisecondsToTicks(msec) ((msec) * (OS_TIMER_CLOCK / 1000))
+#define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8)
+#define OSNanosecondsToTicks(nsec) (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000)
+
+#define OSDiffTick(tick1, tick0) ((s32)(tick1) - (s32)(tick0))
+
+#define OSRoundUp32B(v) (((u32)(v + 31) & ~31))
+
+void* OSGetArenaHi(void);
+void* OSGetArenaLo(void);
+void OSSetArenaHi(void* newHi);
+void OSSetArenaLo(void* newLo);
+
+void* OSAllocFromArenaLo(u32 size, u32 align);
+void* OSAllocFromArenaHi(u32 size, u32 align);
+
+void OSInit();
+
+OSTime OSGetTime();
+OSTick OSGetTick();
+
+typedef struct OSCalendarTime {
+  int sec;  // seconds after the minute [0, 61]
+  int min;  // minutes after the hour [0, 59]
+  int hour; // hours since midnight [0, 23]
+  int mday; // day of the month [1, 31]
+  int mon;  // month since January [0, 11]
+  int year; // years in AD [1, ...]
+  int wday; // days since Sunday [0, 6]
+  int yday; // days since January 1 [0, 365]
+
+  int msec; // milliseconds after the second [0,999]
+  int usec; // microseconds after the millisecond [0,999]
+} OSCalendarTime;
+
+OSTime OSCalendarTimeToTicks(OSCalendarTime* td);
+void OSTicksToCalendarTime(OSTime ticks, OSCalendarTime* td);
+
+#define OS_CONSOLE_MASK 0xf0000000
+#define OS_CONSOLE_RETAIL 0x00000000
+#define OS_CONSOLE_DEVELOPMENT 0x10000000
+#define OS_CONSOLE_TDEV 0x20000000
+
+#define OS_CONSOLE_RETAIL4 0x00000004
+#define OS_CONSOLE_RETAIL3 0x00000003
+#define OS_CONSOLE_RETAIL2 0x00000002
+#define OS_CONSOLE_RETAIL1 0x00000001
+#define OS_CONSOLE_TDEVHW4 0x20000007
+#define OS_CONSOLE_TDEVHW3 0x20000006
+#define OS_CONSOLE_TDEVHW2 0x20000005
+#define OS_CONSOLE_TDEVHW1 0x20000004
+#define OS_CONSOLE_DEVHW4 0x10000007
+#define OS_CONSOLE_DEVHW3 0x10000006
+#define OS_CONSOLE_DEVHW2 0x10000005
+#define OS_CONSOLE_DEVHW1 0x10000004
+#define OS_CONSOLE_MINNOW 0x10000003
+#define OS_CONSOLE_ARTHUR 0x10000002
+#define OS_CONSOLE_PC_EMULATOR 0x10000001
+#define OS_CONSOLE_EMULATOR 0x10000000
+
+u32 OSGetConsoleType();
+
+#define OS_SOUND_MODE_MONO 0u
+#define OS_SOUND_MODE_STEREO 1u
+
+u32 OSGetSoundMode(void);
+void OSSetSoundMode(u32 mode);
+
+#define OS_PROGRESSIVE_MODE_OFF 0u
+#define OS_PROGRESSIVE_MODE_ON 1u
+
+u32 OSGetProgressiveMode(void);
+void OSSetProgressiveMode(u32 on);
+
+#define OS_LANG_ENGLISH 0u
+#define OS_LANG_GERMAN 1u
+#define OS_LANG_FRENCH 2u
+#define OS_LANG_SPANISH 3u
+#define OS_LANG_ITALIAN 4u
+#define OS_LANG_DUTCH 5u
+
+u8 OSGetLanguage(void);
+void OSSetLanguage(u8 language);
+
+#define OS_EURGB60_OFF 0u
+#define OS_EURGB60_ON 1u
+
+u32 OSGetEuRgb60Mode(void);
+void OSSetEuRgb60Mode(u32 on);
+
+void OSRegisterVersion(const char* id);
+
+BOOL OSDisableInterrupts(void);
+BOOL OSEnableInterrupts(void);
+BOOL OSRestoreInterrupts(BOOL level);
+
+#define OSHalt(msg) OSPanic(__FILE__, __LINE__, msg)
+
+#ifdef _DEBUG
+
+#ifndef ASSERT
+#define ASSERT(exp) (void)((exp) || (OSPanic(__FILE__, __LINE__, "Failed assertion " #exp), 0))
+#endif
+
+#ifndef ASSERTMSG
+#if defined(__STDC_VERSION__) && (199901L <= __STDC_VERSION__) || defined(__MWERKS__) ||           \
+    defined(__SN__)
+#define ASSERTMSG(exp, ...) (void)((exp) || (OSPanic(__FILE__, __LINE__, __VA_ARGS__), 0))
+#else
+#define ASSERTMSG(exp, msg) (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg)), 0))
+#endif
+#endif
+
+#ifndef ASSERTMSG1
+#define ASSERTMSG1(exp, msg, param1)                                                               \
+  (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1)), 0))
+#endif
+
+#ifndef ASSERTMSG2
+#define ASSERTMSG2(exp, msg, param1, param2)                                                       \
+  (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2)), 0))
+#endif
+
+#ifndef ASSERTMSG3
+#define ASSERTMSG3(exp, msg, param1, param2, param3)                                               \
+  (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2), (param3)), 0))
+#endif
+
+#ifndef ASSERTMSG4
+#define ASSERTMSG4(exp, msg, param1, param2, param3, param4)                                       \
+  (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2), (param3), (param4)), 0))
+#endif
+
+#else // _DEBUG
+
+#ifndef ASSERT
+#define ASSERT(exp) ((void)0)
+#endif
+
+#ifndef ASSERTMSG
+#if defined(__STDC_VERSION__) && (199901L <= __STDC_VERSION__) || defined(__MWERKS__) ||           \
+    defined(__SN__)
+#define ASSERTMSG(exp, ...) ((void)0)
+#else
+#define ASSERTMSG(exp, msg) ((void)0)
+#endif
+#endif
+
+#ifndef ASSERTMSG1
+#define ASSERTMSG1(exp, msg, param1) ((void)0)
+#endif
+#ifndef ASSERTMSG2
+#define ASSERTMSG2(exp, msg, param1, param2) ((void)0)
+#endif
+#ifndef ASSERTMSG3
+#define ASSERTMSG3(exp, msg, param1, param2, param3) ((void)0)
+#endif
+#ifndef ASSERTMSG4
+#define ASSERTMSG4(exp, msg, param1, param2, param3, param4) ((void)0)
+#endif
+
+#endif // _DEBUG
+
+void OSReport(const char* msg, ...);
+void OSPanic(const char* file, int line, const char* msg, ...);
+void OSFatal(GXColor fg, GXColor bg, const char* msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <dolphin/os/OSAlarm.h>
+#include <dolphin/os/OSAlloc.h>
+#include <dolphin/os/OSArena.h>
+#include <dolphin/os/OSCache.h>
+#include <dolphin/os/OSContext.h>
+#include <dolphin/os/OSError.h>
+#include <dolphin/os/OSException.h>
+#include <dolphin/os/OSExpansion.h>
+#include <dolphin/os/OSFastCast.h>
+#include <dolphin/os/OSFont.h>
+#include <dolphin/os/OSInterrupt.h>
+#include <dolphin/os/OSMemory.h>
+#include <dolphin/os/OSMessage.h>
+#include <dolphin/os/OSModule.h>
+#include <dolphin/os/OSMutex.h>
+#include <dolphin/os/OSReset.h>
+#include <dolphin/os/OSResetSW.h>
+#include <dolphin/os/OSSerial.h>
+#include <dolphin/os/OSThread.h>
+#endif // _DOLPHIN_OS

include/dolphin/os/OSAlarm.h

@@ -0,0 +1,39 @@
+#ifndef _DOLPHIN_OSALARM
+#define _DOLPHIN_OSALARM
+
+#include <dolphin/os/OSContext.h>
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OSAlarm OSAlarm;
+typedef void (*OSAlarmHandler)(OSAlarm* alarm, OSContext* context);
+
+struct OSAlarm {
+  OSAlarmHandler handler;
+  u32 tag;
+  OSTime fire;
+  OSAlarm* prev;
+  OSAlarm* next;
+  OSTime period;
+  OSTime start;
+};
+
+void OSInitAlarm(void);
+void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler);
+void OSSetAlarmTag(OSAlarm* alarm, u32 tag);
+void OSSetAbsAlarm(OSAlarm* alarm, OSTime time, OSAlarmHandler handler);
+void OSSetPeriodicAlarm(OSAlarm* alarm, OSTime start, OSTime period, OSAlarmHandler handler);
+void OSCreateAlarm(OSAlarm* alarm);
+void OSCancelAlarm(OSAlarm* alarm);
+void OSCancelAlarms(u32 tag);
+
+BOOL OSCheckAlarmQueue(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSALARM

include/dolphin/os/OSAlloc.h

@@ -0,0 +1,30 @@
+#ifndef _DOLPHIN_OSALLOC
+#define _DOLPHIN_OSALLOC
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef int OSHeapHandle;
+typedef void (*OSAllocVisitor)(void* obj, u32 size);
+void* OSInitAlloc(void* arenaStart, void* arenaEnd, int maxHeaps);
+OSHeapHandle OSCreateHeap(void* start, void* end);
+void OSDestroyHeap(OSHeapHandle heap);
+void OSAddToHeap(OSHeapHandle heap, void* start, void* end);
+OSHeapHandle OSSetCurrentHeap(OSHeapHandle heap);
+void* OSAllocFromHeap(OSHeapHandle heap, u32 size);
+void* OSAllocFixed(void** rstart, void** rend);
+void OSFreeToHeap(OSHeapHandle heap, void* ptr);
+long OSCheckHeap(OSHeapHandle heap);
+void OSDumpHeap(OSHeapHandle heap);
+u32 OSReferentSize(void* ptr);
+void OSVisitAllocated(OSAllocVisitor visitor);
+extern volatile OSHeapHandle __OSCurrHeap;
+#define OSAlloc(size) OSAllocFromHeap(__OSCurrHeap, (size))
+#define OSFree(ptr) OSFreeToHeap(__OSCurrHeap, (ptr))
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSALLOC

include/dolphin/os/OSArena.h

@@ -0,0 +1,13 @@
+#ifndef _DOLPHIN_OSARENA
+#define _DOLPHIN_OSARENA
+
+#include <dolphin/types.h>
+
+void* OSGetArenaHi(void);
+void* OSGetArenaLo(void);
+void OSSetArenaHi(void* addr);
+void OSSetArenaLo(void* addr);
+void* OSAllocFromArenaLo(u32 size, u32 align);
+void* OSAllocFromArenaLo(u32 size, u32 align);
+
+#endif // _DOLPHIN_OSARENA

include/dolphin/os/OSBootInfo.h

@@ -0,0 +1,50 @@
+#ifndef _DOLPHIN_OSBOOTINFO
+#define _DOLPHIN_OSBOOTINFO
+
+#include "dolphin/DVDPriv.h"
+#include "dolphin/types.h"
+
+typedef struct OSBootInfo {
+  DVDDiskID DVDDiskID;
+  u32 magic;
+  u32 version;
+  u32 memorySize;
+  u32 consoleType;
+  void* arenaLo;
+  void* arenaHi;
+  void* FSTLocation;
+  u32 FSTMaxLength;
+} OSBootInfo;
+
+typedef struct {
+  BOOL valid;
+  u32 restartCode;
+  u32 bootDol;
+  void* regionStart;
+  void* regionEnd;
+  BOOL argsUseDefault;
+  void* argsAddr; // valid only when argsUseDefault = FALSE
+
+} OSExecParams;
+
+typedef struct BI2Debug {
+  s32 debugMonSize;  // 0x0
+  s32 simMemSize;    // 0x4
+  u32 argOffset;     // 0x8
+  u32 debugFlag;     // 0xC
+  int trackLocation; // 0x10
+  int trackSize;     // 0x14
+  u32 countryCode;   // 0x18
+  u8 unk[8];         // 0x1C
+  u32 padSpec;       // 0x24
+} BI2Debug;
+
+// Magic number defines.
+#define OS_BOOTINFO_MAGIC 0x0D15EA5E
+#define OS_BOOTINFO_MAGIC_JTAG 0xE5207C22
+#define OS_DVD_MAGIC_NINTENDO 0xC2339F3D
+#define OS_THREAD_STACK_MAGIC 0xDEADBABE
+
+#define OS_BOOTROM_ADDR 0x81300000
+
+#endif // _DOLPHIN_OSBOOTINFO

include/dolphin/os/OSCache.h

@@ -0,0 +1,37 @@
+#ifndef _DOLPHIN_OSCACHE
+#define _DOLPHIN_OSCACHE
+
+#include "dolphin/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void DCInvalidateRange(void* addr, u32 nBytes);
+void DCFlushRange(void* addr, u32 nBytes);
+void DCStoreRange(void* addr, u32 nBytes);
+void DCFlushRangeNoSync(void* addr, u32 nBytes);
+void DCStoreRangeNoSync(void* addr, u32 nBytes);
+void DCZeroRange(void* addr, u32 nBytes);
+void DCTouchRange(void* addr, u32 nBytes);
+void ICInvalidateRange(void* addr, u32 nBytes);
+
+#define LC_BASE_PREFIX 0xE000
+#define LC_BASE (LC_BASE_PREFIX << 16)
+#define LCGetBase() ((void*)LC_BASE)
+
+void LCEnable();
+void LCDisable(void);
+void LCLoadBlocks(void* destTag, void* srcAddr, u32 numBlocks);
+void LCStoreBlocks(void* destAddr, void* srcTag, u32 numBlocks);
+u32 LCLoadData(void* destAddr, void* srcAddr, u32 nBytes);
+u32 LCStoreData(void* destAddr, void* srcAddr, u32 nBytes);
+u32 LCQueueLength(void);
+void LCQueueWait(u32 len);
+void LCFlushQueue(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSCACHE

include/dolphin/os/OSContext.h

@@ -0,0 +1,170 @@
+#ifndef _DOLPHIN_OSCONTEXT
+#define _DOLPHIN_OSCONTEXT
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __OS_CONTEXT_FRAME 768
+
+#define OS_CONTEXT_R0 0
+#define OS_CONTEXT_R1 4
+#define OS_CONTEXT_R2 8
+#define OS_CONTEXT_R3 12
+#define OS_CONTEXT_R4 16
+#define OS_CONTEXT_R5 20
+#define OS_CONTEXT_R6 24
+#define OS_CONTEXT_R7 28
+#define OS_CONTEXT_R8 32
+#define OS_CONTEXT_R9 36
+#define OS_CONTEXT_R10 40
+#define OS_CONTEXT_R11 44
+#define OS_CONTEXT_R12 48
+#define OS_CONTEXT_R13 52
+#define OS_CONTEXT_R14 56
+#define OS_CONTEXT_R15 60
+#define OS_CONTEXT_R16 64
+#define OS_CONTEXT_R17 68
+#define OS_CONTEXT_R18 72
+#define OS_CONTEXT_R19 76
+#define OS_CONTEXT_R20 80
+#define OS_CONTEXT_R21 84
+#define OS_CONTEXT_R22 88
+#define OS_CONTEXT_R23 92
+#define OS_CONTEXT_R24 96
+#define OS_CONTEXT_R25 100
+#define OS_CONTEXT_R26 104
+#define OS_CONTEXT_R27 108
+#define OS_CONTEXT_R28 112
+#define OS_CONTEXT_R29 116
+#define OS_CONTEXT_R30 120
+#define OS_CONTEXT_R31 124
+
+#define OS_CONTEXT_CR 128
+#define OS_CONTEXT_LR 132
+#define OS_CONTEXT_CTR 136
+#define OS_CONTEXT_XER 140
+
+#define OS_CONTEXT_FPR0 144
+#define OS_CONTEXT_FPR1 152
+#define OS_CONTEXT_FPR2 160
+#define OS_CONTEXT_FPR3 168
+#define OS_CONTEXT_FPR4 176
+#define OS_CONTEXT_FPR5 184
+#define OS_CONTEXT_FPR6 192
+#define OS_CONTEXT_FPR7 200
+#define OS_CONTEXT_FPR8 208
+#define OS_CONTEXT_FPR9 216
+#define OS_CONTEXT_FPR10 224
+#define OS_CONTEXT_FPR11 232
+#define OS_CONTEXT_FPR12 240
+#define OS_CONTEXT_FPR13 248
+#define OS_CONTEXT_FPR14 256
+#define OS_CONTEXT_FPR15 264
+#define OS_CONTEXT_FPR16 272
+#define OS_CONTEXT_FPR17 280
+#define OS_CONTEXT_FPR18 288
+#define OS_CONTEXT_FPR19 296
+#define OS_CONTEXT_FPR20 304
+#define OS_CONTEXT_FPR21 312
+#define OS_CONTEXT_FPR22 320
+#define OS_CONTEXT_FPR23 328
+#define OS_CONTEXT_FPR24 336
+#define OS_CONTEXT_FPR25 344
+#define OS_CONTEXT_FPR26 352
+#define OS_CONTEXT_FPR27 360
+#define OS_CONTEXT_FPR28 368
+#define OS_CONTEXT_FPR29 376
+#define OS_CONTEXT_FPR30 384
+#define OS_CONTEXT_FPR31 392
+
+#define OS_CONTEXT_FPSCR 400
+
+#define OS_CONTEXT_SRR0 408
+#define OS_CONTEXT_SRR1 412
+
+#define OS_CONTEXT_MODE 416
+#define OS_CONTEXT_STATE 418
+
+#define OS_CONTEXT_GQR0 420
+#define OS_CONTEXT_GQR1 424
+#define OS_CONTEXT_GQR2 428
+#define OS_CONTEXT_GQR3 432
+#define OS_CONTEXT_GQR4 436
+#define OS_CONTEXT_GQR5 440
+#define OS_CONTEXT_GQR6 444
+#define OS_CONTEXT_GQR7 448
+#define __OSCONTEXT_PADDING 452
+
+#define OS_CONTEXT_PSF0 456
+#define OS_CONTEXT_PSF1 464
+#define OS_CONTEXT_PSF2 472
+#define OS_CONTEXT_PSF3 480
+#define OS_CONTEXT_PSF4 488
+#define OS_CONTEXT_PSF5 496
+#define OS_CONTEXT_PSF6 504
+#define OS_CONTEXT_PSF7 512
+#define OS_CONTEXT_PSF8 520
+#define OS_CONTEXT_PSF9 528
+#define OS_CONTEXT_PSF10 536
+#define OS_CONTEXT_PSF11 544
+#define OS_CONTEXT_PSF12 552
+#define OS_CONTEXT_PSF13 560
+#define OS_CONTEXT_PSF14 568
+#define OS_CONTEXT_PSF15 576
+#define OS_CONTEXT_PSF16 584
+#define OS_CONTEXT_PSF17 592
+#define OS_CONTEXT_PSF18 600
+#define OS_CONTEXT_PSF19 608
+#define OS_CONTEXT_PSF20 616
+#define OS_CONTEXT_PSF21 624
+#define OS_CONTEXT_PSF22 632
+#define OS_CONTEXT_PSF23 640
+#define OS_CONTEXT_PSF24 648
+#define OS_CONTEXT_PSF25 656
+#define OS_CONTEXT_PSF26 664
+#define OS_CONTEXT_PSF27 672
+#define OS_CONTEXT_PSF28 680
+#define OS_CONTEXT_PSF29 688
+#define OS_CONTEXT_PSF30 696
+#define OS_CONTEXT_PSF31 704
+#define OS_CONTEXT_STATE_EXC 0x02u
+
+#define OS_CONTEXT_STATE_FPSAVED 0x01u
+
+typedef struct OSContext {
+  u32 gpr[32];
+  u32 cr;
+  u32 lr;
+  u32 ctr;
+  u32 xer;
+
+  f64 fpr[32];
+
+  u32 fpscr_pad;
+  u32 fpscr;
+
+  u32 srr0;
+  u32 srr1;
+
+  u16 mode;
+  u16 state;
+
+  u32 gqr[8];
+  u32 psf_pad;
+  f64 psf[32];
+
+} OSContext;
+
+u32 OSSaveContext(OSContext* context);
+void OSClearContext(OSContext* context);
+OSContext* OSGetCurrentContext();
+void OSSetCurrentContext(OSContext* context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSCONTEXT

include/dolphin/os/OSError.h

@@ -0,0 +1,39 @@
+#ifndef _DOLPHIN_OSERROR
+#define _DOLPHIN_OSERROR
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_ERROR_SYSTEM_RESET 0
+#define OS_ERROR_MACHINE_CHECK 1
+#define OS_ERROR_DSI 2
+#define OS_ERROR_ISI 3
+#define OS_ERROR_EXTERNAL_INTERRUPT 4
+#define OS_ERROR_ALIGNMENT 5
+#define OS_ERROR_PROGRAM 6
+#define OS_ERROR_FLOATING_POINT 7
+#define OS_ERROR_DECREMENTER 8
+#define OS_ERROR_SYSTEM_CALL 9
+#define OS_ERROR_TRACE 10
+#define OS_ERROR_PERFORMACE_MONITOR 11
+#define OS_ERROR_BREAKPOINT 12
+#define OS_ERROR_SYSTEM_INTERRUPT 13
+#define OS_ERROR_THERMAL_INTERRUPT 14
+#define OS_ERROR_PROTECTION 15
+#define OS_ERROR_FPE 16
+
+#define OS_ERROR_MAX (OS_ERROR_FPE + 1)
+
+typedef u16 OSError;
+typedef void (*OSErrorHandler)( OSError error, OSContext* context, ... );
+
+OSErrorHandler OSSetErrorHandler(OSError code, OSErrorHandler handler);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSERROR

include/dolphin/os/OSException.h

@@ -0,0 +1,56 @@
+
+#ifndef _DOLPHIN_OSEXCEPTION
+#define _DOLPHIN_OSEXCEPTION
+
+#include <dolphin/os/OSContext.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define __OS_EXCEPTION_SYSTEM_RESET         0
+#define __OS_EXCEPTION_MACHINE_CHECK        1
+#define __OS_EXCEPTION_DSI                  2
+#define __OS_EXCEPTION_ISI                  3
+#define __OS_EXCEPTION_EXTERNAL_INTERRUPT   4
+#define __OS_EXCEPTION_ALIGNMENT            5
+#define __OS_EXCEPTION_PROGRAM              6
+#define __OS_EXCEPTION_FLOATING_POINT       7
+#define __OS_EXCEPTION_DECREMENTER          8
+#define __OS_EXCEPTION_SYSTEM_CALL          9
+#define __OS_EXCEPTION_TRACE                10
+#define __OS_EXCEPTION_PERFORMACE_MONITOR   11
+#define __OS_EXCEPTION_BREAKPOINT           12
+#define __OS_EXCEPTION_SYSTEM_INTERRUPT     13
+#define __OS_EXCEPTION_THERMAL_INTERRUPT    14
+#define __OS_EXCEPTION_MAX                  \
+        (__OS_EXCEPTION_THERMAL_INTERRUPT+1)
+
+typedef u8 __OSException;
+typedef void (*__OSExceptionHandler)(__OSException exception, OSContext* context);
+
+#define OS_EXCEPTION_SAVE_GPRS(context)                                                            \
+  stw r0, OS_CONTEXT_R0(context);                                                                  \
+  stw r1, OS_CONTEXT_R1(context);                                                                  \
+  stw r2, OS_CONTEXT_R2(context);                                                                  \
+  stmw r6, OS_CONTEXT_R6(context);                                                                 \
+  mfspr r0, GQR1;                                                                                  \
+  stw r0, OS_CONTEXT_GQR1(context);                                                                \
+  mfspr r0, GQR2;                                                                                  \
+  stw r0, OS_CONTEXT_GQR2(context);                                                                \
+  mfspr r0, GQR3;                                                                                  \
+  stw r0, OS_CONTEXT_GQR3(context);                                                                \
+  mfspr r0, GQR4;                                                                                  \
+  stw r0, OS_CONTEXT_GQR4(context);                                                                \
+  mfspr r0, GQR5;                                                                                  \
+  stw r0, OS_CONTEXT_GQR5(context);                                                                \
+  mfspr r0, GQR6;                                                                                  \
+  stw r0, OS_CONTEXT_GQR6(context);                                                                \
+  mfspr r0, GQR7;                                                                                  \
+  stw r0, OS_CONTEXT_GQR7(context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSEXCEPTION

include/dolphin/os/OSExpansion.h

@@ -0,0 +1,79 @@
+#ifndef _DOLPHIN_OSEXPANSION
+#define _DOLPHIN_OSEXPANSION
+
+#include <dolphin/os.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EXI_MEMORY_CARD_59 0x00000004
+#define EXI_MEMORY_CARD_123 0x00000008
+#define EXI_MEMORY_CARD_251 0x00000010
+#define EXI_MEMORY_CARD_507 0x00000020
+
+#define EXI_MEMORY_CARD_1019 0x00000040
+#define EXI_MEMORY_CARD_2043 0x00000080
+
+#define EXI_MEMORY_CARD_1019A 0x00000140
+#define EXI_MEMORY_CARD_1019B 0x00000240
+#define EXI_MEMORY_CARD_1019C 0x00000340
+#define EXI_MEMORY_CARD_1019D 0x00000440
+#define EXI_MEMORY_CARD_1019E 0x00000540
+#define EXI_MEMORY_CARD_1019F 0x00000640
+#define EXI_MEMORY_CARD_1019G 0x00000740
+
+#define EXI_MEMORY_CARD_2043A 0x00000180
+#define EXI_MEMORY_CARD_2043B 0x00000280
+#define EXI_MEMORY_CARD_2043C 0x00000380
+#define EXI_MEMORY_CARD_2043D 0x00000480
+#define EXI_MEMORY_CARD_2043E 0x00000580
+#define EXI_MEMORY_CARD_2043F 0x00000680
+#define EXI_MEMORY_CARD_2043G 0x00000780
+
+#define EXI_USB_ADAPTER 0x01010000
+#define EXI_NPDP_GDEV 0x01020000
+
+#define EXI_MODEM 0x02020000
+#define EXI_ETHER 0x04020200
+#define EXI_ETHER_VIEWER 0x04220001
+#define EXI_STREAM_HANGER 0x04130000
+
+#define EXI_MARLIN 0x03010000
+
+#define EXI_IS_VIEWER 0x05070000
+
+#define EXI_FREQ_1M 0
+#define EXI_FREQ_2M 1
+#define EXI_FREQ_4M 2
+#define EXI_FREQ_8M 3
+#define EXI_FREQ_16M 4
+#define EXI_FREQ_32M 5
+
+#define EXI_READ 0
+#define EXI_WRITE 1
+
+#define EXI_STATE_IDLE 0x00
+#define EXI_STATE_DMA 0x01
+#define EXI_STATE_IMM 0x02
+#define EXI_STATE_BUSY (EXI_STATE_DMA | EXI_STATE_IMM)
+#define EXI_STATE_SELECTED 0x04
+#define EXI_STATE_ATTACHED 0x08
+#define EXI_STATE_LOCKED 0x10
+
+BOOL EXIProbe(s32 chan);
+s32 EXIProbeEx(s32 chan);
+
+s32 EXIGetType(s32 chan, u32 dev, u32* type);
+char* EXIGetTypeString(u32 type);
+u32 EXIClearInterrupts(s32 chan, BOOL exi, BOOL tc, BOOL ext);
+s32 EXIGetID(s32 chan, u32 dev, u32* id);
+
+typedef void (*EXICallback)(s32 chan, OSContext* context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSEXPANSION

include/dolphin/os/OSFastCast.h

@@ -0,0 +1,48 @@
+#ifndef _DOLPHIN_OSFASTCAST
+#define _DOLPHIN_OSFASTCAST
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_GQR_F32 0x0000
+#define OS_GQR_U8 0x0004
+#define OS_GQR_U16 0x0005
+#define OS_GQR_S8 0x0006
+#define OS_GQR_S16 0x0007
+
+#define OS_FASTCAST_U8 2
+#define OS_FASTCAST_U16 3
+#define OS_FASTCAST_S16 5
+// clang-format off
+static inline void OSInitFastCast(void) {
+#ifdef __MWERKS__
+  asm
+  {
+        li      r3, OS_GQR_U8
+        oris    r3, r3, OS_GQR_U8
+        mtspr   GQR2, r3
+
+        li      r3, OS_GQR_U16
+        oris    r3, r3, OS_GQR_U16
+        mtspr   GQR3, r3
+
+        li      r3, OS_GQR_S8
+        oris    r3, r3, OS_GQR_S8
+        mtspr   GQR4, r3
+
+        li      r3, OS_GQR_S16
+        oris    r3, r3, OS_GQR_S16
+        mtspr   GQR5, r3
+  }
+#else
+
+#endif
+}
+// clang-format off
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSFASTCAST

include/dolphin/os/OSFont.h

@@ -0,0 +1,28 @@
+#ifndef _DOLPHIN_OSFONT
+#define _DOLPHIN_OSFONT
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_FONT_ENCODE_ANSI 0u
+#define OS_FONT_ENCODE_SJIS 1u
+#define OS_FONT_ENCODE_UTF8 3u  // UTF-8 [RFC 3629]
+#define OS_FONT_ENCODE_UTF16 4u // UTF-16BE [RFC 2781]
+#define OS_FONT_ENCODE_UTF32 5u // UTF-32
+#define OS_FONT_ENCODE_MAX 5u
+#define OS_FONT_ENCODE_VOID 0xffffu
+
+#define OS_FONT_PROPORTIONAL FALSE
+#define OS_FONT_FIXED TRUE
+
+u16 OSGetFontEncode(void);
+u16 OSSetFontEncode(u16 encode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSFONT

include/dolphin/os/OSInterrupt.h

@@ -0,0 +1,115 @@
+#ifndef _DOLPHIN_OSINTERRUPT
+#define _DOLPHIN_OSINTERRUPT
+
+#include <dolphin/os/OSContext.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __OS_INTERRUPT_MEM_0 0
+#define __OS_INTERRUPT_MEM_1 1
+#define __OS_INTERRUPT_MEM_2 2
+#define __OS_INTERRUPT_MEM_3 3
+#define __OS_INTERRUPT_MEM_ADDRESS 4
+#define __OS_INTERRUPT_DSP_AI 5
+#define __OS_INTERRUPT_DSP_ARAM 6
+#define __OS_INTERRUPT_DSP_DSP 7
+#define __OS_INTERRUPT_AI_AI 8
+#define __OS_INTERRUPT_EXI_0_EXI 9
+#define __OS_INTERRUPT_EXI_0_TC 10
+#define __OS_INTERRUPT_EXI_0_EXT 11
+#define __OS_INTERRUPT_EXI_1_EXI 12
+#define __OS_INTERRUPT_EXI_1_TC 13
+#define __OS_INTERRUPT_EXI_1_EXT 14
+#define __OS_INTERRUPT_EXI_2_EXI 15
+#define __OS_INTERRUPT_EXI_2_TC 16
+#define __OS_INTERRUPT_PI_CP 17
+#define __OS_INTERRUPT_PI_PE_TOKEN 18
+#define __OS_INTERRUPT_PI_PE_FINISH 19
+#define __OS_INTERRUPT_PI_SI 20
+#define __OS_INTERRUPT_PI_DI 21
+#define __OS_INTERRUPT_PI_RSW 22
+#define __OS_INTERRUPT_PI_ERROR 23
+#define __OS_INTERRUPT_PI_VI 24
+#define __OS_INTERRUPT_PI_DEBUG 25
+#define __OS_INTERRUPT_PI_HSP 26
+#define __OS_INTERRUPT_MAX 32
+
+#define OS_INTERRUPTMASK(interrupt) (0x80000000u >> (interrupt))
+
+#define OS_INTERRUPTMASK_MEM_0 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_0)
+#define OS_INTERRUPTMASK_MEM_1 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_1)
+#define OS_INTERRUPTMASK_MEM_2 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_2)
+#define OS_INTERRUPTMASK_MEM_3 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_3)
+#define OS_INTERRUPTMASK_MEM_ADDRESS OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_ADDRESS)
+#define OS_INTERRUPTMASK_MEM                                                                       \
+  (OS_INTERRUPTMASK_MEM_0 | OS_INTERRUPTMASK_MEM_1 | OS_INTERRUPTMASK_MEM_2 |                      \
+   OS_INTERRUPTMASK_MEM_3 | OS_INTERRUPTMASK_MEM_ADDRESS)
+#define OS_INTERRUPTMASK_DSP_AI OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_AI)
+#define OS_INTERRUPTMASK_DSP_ARAM OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_ARAM)
+#define OS_INTERRUPTMASK_DSP_DSP OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_DSP)
+#define OS_INTERRUPTMASK_DSP                                                                       \
+  (OS_INTERRUPTMASK_DSP_AI | OS_INTERRUPTMASK_DSP_ARAM | OS_INTERRUPTMASK_DSP_DSP)
+#define OS_INTERRUPTMASK_AI_AI OS_INTERRUPTMASK(__OS_INTERRUPT_AI_AI)
+#define OS_INTERRUPTMASK_AI (OS_INTERRUPTMASK_AI_AI)
+#define OS_INTERRUPTMASK_EXI_0_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_EXI)
+#define OS_INTERRUPTMASK_EXI_0_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_TC)
+#define OS_INTERRUPTMASK_EXI_0_EXT OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_EXT)
+#define OS_INTERRUPTMASK_EXI_0                                                                     \
+  (OS_INTERRUPTMASK_EXI_0_EXI | OS_INTERRUPTMASK_EXI_0_TC | OS_INTERRUPTMASK_EXI_0_EXT)
+#define OS_INTERRUPTMASK_EXI_1_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_EXI)
+#define OS_INTERRUPTMASK_EXI_1_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_TC)
+#define OS_INTERRUPTMASK_EXI_1_EXT OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_EXT)
+#define OS_INTERRUPTMASK_EXI_1                                                                     \
+  (OS_INTERRUPTMASK_EXI_1_EXI | OS_INTERRUPTMASK_EXI_1_TC | OS_INTERRUPTMASK_EXI_1_EXT)
+#define OS_INTERRUPTMASK_EXI_2_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_2_EXI)
+#define OS_INTERRUPTMASK_EXI_2_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_2_TC)
+#define OS_INTERRUPTMASK_EXI_2 (OS_INTERRUPTMASK_EXI_2_EXI | OS_INTERRUPTMASK_EXI_2_TC)
+#define OS_INTERRUPTMASK_EXI                                                                       \
+  (OS_INTERRUPTMASK_EXI_0_EXI | OS_INTERRUPTMASK_EXI_0_TC | OS_INTERRUPTMASK_EXI_0_EXT |           \
+   OS_INTERRUPTMASK_EXI_1_EXI | OS_INTERRUPTMASK_EXI_1_TC | OS_INTERRUPTMASK_EXI_1_EXT |           \
+   OS_INTERRUPTMASK_EXI_2_EXI | OS_INTERRUPTMASK_EXI_2_TC)
+#define OS_INTERRUPTMASK_PI_PE_TOKEN OS_INTERRUPTMASK(__OS_INTERRUPT_PI_PE_TOKEN)
+#define OS_INTERRUPTMASK_PI_PE_FINISH OS_INTERRUPTMASK(__OS_INTERRUPT_PI_PE_FINISH)
+#define OS_INTERRUPTMASK_PI_PE (OS_INTERRUPTMASK_PI_PE_TOKEN | OS_INTERRUPTMASK_PI_PE_FINISH)
+#define OS_INTERRUPTMASK_PI_CP OS_INTERRUPTMASK(__OS_INTERRUPT_PI_CP)
+#define OS_INTERRUPTMASK_PI_SI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_SI)
+#define OS_INTERRUPTMASK_PI_DI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_DI)
+#define OS_INTERRUPTMASK_PI_RSW OS_INTERRUPTMASK(__OS_INTERRUPT_PI_RSW)
+#define OS_INTERRUPTMASK_PI_ERROR OS_INTERRUPTMASK(__OS_INTERRUPT_PI_ERROR)
+#define OS_INTERRUPTMASK_PI_VI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_VI)
+#define OS_INTERRUPTMASK_PI_DEBUG OS_INTERRUPTMASK(__OS_INTERRUPT_PI_DEBUG)
+#define OS_INTERRUPTMASK_PI_HSP OS_INTERRUPTMASK(__OS_INTERRUPT_PI_HSP)
+#define OS_INTERRUPTMASK_PI                                                                        \
+  (OS_INTERRUPTMASK_PI_CP | OS_INTERRUPTMASK_PI_SI | OS_INTERRUPTMASK_PI_DI |                      \
+   OS_INTERRUPTMASK_PI_RSW | OS_INTERRUPTMASK_PI_ERROR | OS_INTERRUPTMASK_PI_VI |                  \
+   OS_INTERRUPTMASK_PI_PE_TOKEN | OS_INTERRUPTMASK_PI_PE_FINISH | OS_INTERRUPTMASK_PI_DEBUG |      \
+   OS_INTERRUPTMASK_PI_HSP)
+
+typedef s16 __OSInterrupt;
+typedef void (*__OSInterruptHandler)(__OSInterrupt interrupt, OSContext* context);
+
+typedef u32 OSInterruptMask;
+
+extern volatile __OSInterrupt __OSLastInterrupt;
+extern volatile u32 __OSLastInterruptSrr0;
+extern volatile OSTime __OSLastInterruptTime;
+
+__OSInterruptHandler __OSSetInterruptHandler(__OSInterrupt interrupt, __OSInterruptHandler handler);
+
+__OSInterruptHandler __OSGetInterruptHandler(__OSInterrupt interrupt);
+
+void __OSDispatchInterrupt(__OSException exception, OSContext* context);
+
+OSInterruptMask OSGetInterruptMask(void);
+OSInterruptMask OSSetInterruptMask(OSInterruptMask mask);
+OSInterruptMask __OSMaskInterrupts(OSInterruptMask mask);
+OSInterruptMask __OSUnmaskInterrupts(OSInterruptMask mask);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSINTERRUPT

include/dolphin/os/OSMemory.h

@@ -0,0 +1,26 @@
+#ifndef _DOLPHIN_OSMEMORY
+#define _DOLPHIN_OSMEMORY
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_PROTECT_CHAN0 0
+#define OS_PROTECT_CHAN1 1
+#define OS_PROTECT_CHAN2 2
+#define OS_PROTECT_CHAN3 3
+
+#define OS_PROTECT_CONTROL_NONE 0x00
+#define OS_PROTECT_CONTROL_READ 0x01
+#define OS_PROTECT_CONTROL_WRITE 0x02
+#define OS_PROTECT_CONTROL_RDWR (OS_PROTECT_CONTROL_READ | OS_PROTECT_CONTROL_WRITE)
+
+void OSProtectRange(u32 chan, void* addr, u32 nBytes, u32 control);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSMEMORY

include/dolphin/os/OSMessage.h

@@ -0,0 +1,34 @@
+#ifndef _DOLPHIN_OSMESSAGE
+#define _DOLPHIN_OSMESSAGE
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <dolphin/os/OSThread.h>
+typedef struct OSMessageQueue OSMessageQueue;
+typedef void* OSMessage;
+
+struct OSMessageQueue {
+  OSThreadQueue queueSend;
+  OSThreadQueue queueReceive;
+  OSMessage* msgArray;
+  s32 msgCount;
+  s32 firstIndex;
+  s32 usedCount;
+};
+
+// Flags to turn blocking on/off when sending/receiving message
+#define OS_MESSAGE_NOBLOCK 0
+#define OS_MESSAGE_BLOCK 1
+
+void OSInitMessageQueue(OSMessageQueue* mq, OSMessage* msgArray, s32 msgCount);
+BOOL OSSendMessage(OSMessageQueue* mq, OSMessage msg, s32 flags);
+BOOL OSJamMessage(OSMessageQueue* mq, OSMessage msg, s32 flags);
+BOOL OSReceiveMessage(OSMessageQueue* mq, OSMessage* msg, s32 flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSMESSAGE

include/dolphin/os/OSModule.h

@@ -0,0 +1,115 @@
+#ifndef _DOLPHIN_OSMODULE
+#define _DOLPHIN_OSMODULE
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_MODULE_VERSION 2
+typedef struct OSModuleHeader OSModuleHeader;
+
+typedef u32 OSModuleID;
+typedef struct OSModuleQueue OSModuleQueue;
+typedef struct OSModuleLink OSModuleLink;
+typedef struct OSModuleInfo OSModuleInfo;
+typedef struct OSSectionInfo OSSectionInfo;
+typedef struct OSImportInfo OSImportInfo;
+typedef struct OSRel OSRel;
+
+struct OSModuleQueue {
+  OSModuleInfo* head;
+  OSModuleInfo* tail;
+};
+
+struct OSModuleLink {
+  OSModuleInfo* next;
+  OSModuleInfo* prev;
+};
+
+struct OSModuleInfo {
+  OSModuleID id;         // unique identifier for the module
+  OSModuleLink link;     // doubly linked list of modules
+  u32 numSections;       // # of sections
+  u32 sectionInfoOffset; // offset to section info table
+  u32 nameOffset;        // offset to module name
+  u32 nameSize;          // size of module name
+  u32 version;           // version number
+};
+
+struct OSModuleHeader {
+  // CAUTION: info must be the 1st member
+  OSModuleInfo info;
+
+  // OS_MODULE_VERSION == 1
+  u32 bssSize; // total size of bss sections in bytes
+  u32 relOffset;
+  u32 impOffset;
+  u32 impSize;          // size in bytes
+  u8 prologSection;     // section # for prolog function
+  u8 epilogSection;     // section # for epilog function
+  u8 unresolvedSection; // section # for unresolved function
+  u8 bssSection;        // section # for bss section (set at run-time)
+  u32 prolog;           // prolog function offset
+  u32 epilog;           // epilog function offset
+  u32 unresolved;       // unresolved function offset
+
+  // OS_MODULE_VERSION == 2
+#if (2 <= OS_MODULE_VERSION)
+  u32 align;    // module alignment constraint
+  u32 bssAlign; // bss alignment constraint
+#endif
+
+  // OS_MODULE_VERSION == 3
+#if (3 <= OS_MODULE_VERSION)
+  u32 fixSize;
+#endif
+};
+
+#define OSGetSectionInfo(module) ((OSSectionInfo*)(((OSModuleInfo*)(module))->sectionInfoOffset))
+
+struct OSSectionInfo {
+  u32 offset;
+  u32 size;
+};
+
+// OSSectionInfo.offset bit
+#define OS_SECTIONINFO_EXEC 0x1
+#define OS_SECTIONINFO_OFFSET(offset) ((offset) & ~0x1)
+
+struct OSImportInfo {
+  OSModuleID id; // external module id
+  u32 offset;    // offset to OSRel instructions
+};
+
+struct OSRel {
+  u16 offset; // byte offset from the previous entry
+  u8 type;
+  u8 section;
+  u32 addend;
+};
+
+#define R_DOLPHIN_NOP 201     //  C9h current offset += OSRel.offset
+#define R_DOLPHIN_SECTION 202 //  CAh current section = OSRel.section
+#define R_DOLPHIN_END 203     //  CBh
+#define R_DOLPHIN_MRKREF 204  //  CCh
+
+void OSSetStringTable(const void* stringTable);
+BOOL OSLink(OSModuleInfo* newModule, void* bss);
+#if (3 <= OS_MODULE_VERSION)
+BOOL OSLinkFixed(OSModuleInfo* newModule, void* bss);
+#endif
+BOOL OSUnlink(OSModuleInfo* oldModule);
+
+OSModuleInfo* OSSearchModule(void* ptr, u32* section, u32* offset);
+
+// debugger notification
+void OSNotifyLink(OSModuleInfo* module);
+void OSNotifyUnlink(OSModuleInfo* module);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSMODULE

include/dolphin/os/OSMutex.h

@@ -0,0 +1,35 @@
+#ifndef _DOLPHIN_OSMUTEX
+#define _DOLPHIN_OSMUTEX
+
+#include "types.h"
+
+#include "dolphin/os/OSThread.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OSMutex {
+  OSThreadQueue queue;
+  OSThread* thread; // the current owner
+  s32 count;        // lock count
+  OSMutexLink link; // for OSThread.queueMutex
+};
+
+struct OSCond {
+  OSThreadQueue queue;
+};
+
+void OSInitMutex(OSMutex* mutex);
+void OSLockMutex(OSMutex* mutex);
+void OSUnlockMutex(OSMutex* mutex);
+BOOL OSTryLockMutex(OSMutex* mutex);
+void OSInitCond(OSCond* cond);
+void OSWaitCond(OSCond* cond, OSMutex* mutex);
+void OSSignalCond(OSCond* cond);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSMUTEX

include/dolphin/os/OSPriv.h

@@ -0,0 +1,18 @@
+#ifndef _DOLPHIN_OSPRIV
+#define _DOLPHIN_OSPRIV
+
+#include "dolphin/os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__OSExceptionHandler __OSGetExceptionHandler(__OSException exception);
+OSTime __OSGetSystemTime();
+OSTime __OSTimeToSystemTime(OSTime);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSPRIV

include/dolphin/os/OSReset.h

@@ -0,0 +1,46 @@
+#ifndef _DOLPHIN_OSRESET
+#define _DOLPHIN_OSRESET
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_RESETCODE_RESTART 0x80000000
+#define OS_RESETCODE_SYSTEM 0x40000000
+
+#define OS_RESETCODE_EXEC 0xC0000000
+#define OS_RESETCODE_NETCONFIG 0xC0010000
+
+#define OS_RESET_TIMEOUT OSMillisecondsToTicks(1000)
+
+#define OS_RESET_RESTART 0
+#define OS_RESET_HOTRESET 1
+#define OS_RESET_SHUTDOWN 2
+
+#define OS_RESET_PRIO_SO 110
+#define OS_RESET_PRIO_IP 111
+#define OS_RESET_PRIO_CARD 127
+#define OS_RESET_PRIO_PAD 127
+#define OS_RESET_PRIO_GX 127
+#define OS_RESET_PRIO_ALARM 4294967295
+
+typedef BOOL (*OSResetFunction)(BOOL final);
+typedef struct OSResetFunctionInfo OSResetFunctionInfo;
+
+struct OSResetFunctionInfo {
+  // public
+  OSResetFunction func;
+  u32 priority;
+
+  // private
+  OSResetFunctionInfo* next;
+  OSResetFunctionInfo* prev;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSRESET

include/dolphin/os/OSResetSW.h

@@ -0,0 +1,22 @@
+#ifndef _DOLPHIN_OSRESETSW
+#define _DOLPHIN_OSRESETSW
+
+#include <dolphin/os/OSContext.h>
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*OSResetCallback)(void);
+
+BOOL OSGetResetButtonState(void);
+
+BOOL OSGetResetSwitchState(void);
+OSResetCallback OSSetResetCallback(OSResetCallback callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSRESETSW

include/dolphin/os/OSSerial.h

@@ -0,0 +1,69 @@
+#ifndef _DOLPHIN_OSSERIAL
+#define _DOLPHIN_OSSERIAL
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SI_MAX_CHAN 4
+#define SI_MAX_COMCSR_INLNGTH 128
+#define SI_MAX_COMCSR_OUTLNGTH 128
+#define SI_ERROR_UNDER_RUN 0x0001
+#define SI_ERROR_OVER_RUN 0x0002
+#define SI_ERROR_COLLISION 0x0004
+#define SI_ERROR_NO_RESPONSE 0x0008
+#define SI_ERROR_WRST 0x0010
+#define SI_ERROR_RDST 0x0020
+#define SI_ERROR_UNKNOWN 0x0040
+#define SI_ERROR_BUSY 0x0080
+#define SI_CHAN0 0
+#define SI_CHAN1 1
+#define SI_CHAN2 2
+#define SI_CHAN3 3
+#define SI_CHAN0_BIT 0x80000000
+#define SI_CHAN1_BIT 0x40000000
+#define SI_CHAN2_BIT 0x20000000
+#define SI_CHAN3_BIT 0x10000000
+#define SI_CHAN_BIT(chan) (SI_CHAN0_BIT >> (chan))
+#define SI_TYPE_MASK 0x18000000u
+#define SI_TYPE_N64 0x00000000u
+#define SI_TYPE_DOLPHIN 0x08000000u
+#define SI_TYPE_GC SI_TYPE_DOLPHIN
+#define SI_GC_WIRELESS 0x80000000
+#define SI_GC_NOMOTOR 0x20000000
+#define SI_GC_STANDARD 0x01000000
+#define SI_WIRELESS_RECEIVED 0x40000000
+#define SI_WIRELESS_IR 0x04000000
+#define SI_WIRELESS_STATE 0x02000000
+#define SI_WIRELESS_ORIGIN 0x00200000
+#define SI_WIRELESS_FIX_ID 0x00100000
+#define SI_WIRELESS_TYPE 0x000f0000
+#define SI_WIRELESS_LITE_MASK 0x000c0000
+#define SI_WIRELESS_LITE 0x00040000
+#define SI_WIRELESS_CONT_MASK 0x00080000
+#define SI_WIRELESS_CONT 0x00000000
+#define SI_WIRELESS_ID 0x00c0ff00
+#define SI_WIRELESS_TYPE_ID (SI_WIRELESS_TYPE | SI_WIRELESS_ID)
+#define SI_N64_CONTROLLER (SI_TYPE_N64 | 0x05000000)
+#define SI_N64_MIC (SI_TYPE_N64 | 0x00010000)
+#define SI_N64_KEYBOARD (SI_TYPE_N64 | 0x00020000)
+#define SI_N64_MOUSE (SI_TYPE_N64 | 0x02000000)
+#define SI_GBA (SI_TYPE_N64 | 0x00040000)
+#define SI_GC_CONTROLLER (SI_TYPE_GC | SI_GC_STANDARD)
+#define SI_GC_RECEIVER (SI_TYPE_GC | SI_GC_WIRELESS)
+#define SI_GC_WAVEBIRD                                                                             \
+  (SI_TYPE_GC | SI_GC_WIRELESS | SI_GC_STANDARD | SI_WIRELESS_STATE | SI_WIRELESS_FIX_ID)
+#define SI_GC_KEYBOARD (SI_TYPE_GC | 0x00200000)
+#define SI_GC_STEERING (SI_TYPE_GC | 0x00000000)
+
+u32 SIProbe(s32 chan);
+char* SIGetTypeString(u32 type);
+void SIRefreshSamplingRate(void);
+void SISetSamplingRate(u32 msec);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _DOLPHIN_OSSERIAL

include/dolphin/os/OSThread.h

@@ -0,0 +1,113 @@
+#ifndef _DOLPHIN_OSTHREAD
+#define _DOLPHIN_OSTHREAD
+
+#include <dolphin/os/OSContext.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OS_THREAD_SPECIFIC_MAX 2
+
+typedef struct OSThread OSThread;
+typedef struct OSThreadQueue OSThreadQueue;
+typedef struct OSThreadLink OSThreadLink;
+typedef s32 OSPriority; //  0 highest, 31 lowest
+
+typedef struct OSMutex OSMutex;
+typedef struct OSMutexQueue OSMutexQueue;
+typedef struct OSMutexLink OSMutexLink;
+typedef struct OSCond OSCond;
+
+typedef void (*OSIdleFunction)(void* param);
+typedef void (*OSSwitchThreadCallback)(OSThread* from, OSThread* to);
+
+struct OSThreadQueue {
+  OSThread* head;
+  OSThread* tail;
+};
+
+struct OSThreadLink {
+  OSThread* next;
+  OSThread* prev;
+};
+
+struct OSMutexQueue {
+  OSMutex* head;
+  OSMutex* tail;
+};
+
+struct OSMutexLink {
+  OSMutex* next;
+  OSMutex* prev;
+};
+
+struct OSThread {
+  OSContext context;
+  u16 state;
+  u16 attr;
+  s32 suspend;
+  OSPriority priority;
+  OSPriority base;
+  void* val;
+  OSThreadQueue* queue;
+  OSThreadLink link;
+  OSThreadQueue queueJoin;
+  OSMutex* mutex;
+  OSMutexQueue queueMutex;
+  OSThreadLink linkActive;
+  u8* stackBase;
+  u32* stackEnd;
+  s32 error;
+  void* specific[OS_THREAD_SPECIFIC_MAX];
+};
+
+enum OS_THREAD_STATE {
+  OS_THREAD_STATE_READY = 1,
+  OS_THREAD_STATE_RUNNING = 2,
+  OS_THREAD_STATE_WAITING = 4,
+  OS_THREAD_STATE_MORIBUND = 8
+};
+
+#define OS_THREAD_ATTR_DETACH 0x0001u
+
+#define OS_THREAD_STACK_MAGIC 0xDEADBABE
+
+#define OS_PRIORITY_MIN 0  // highest
+#define OS_PRIORITY_MAX 31 // lowest
+#define OS_PRIORITY_IDLE OS_PRIORITY_MAX
+
+
+void OSInitThreadQueue(OSThreadQueue* queue);
+OSThread* OSGetCurrentThread(void);
+BOOL OSIsThreadSuspended(OSThread* thread);
+BOOL OSIsThreadTerminated(OSThread* thread);
+s32 OSDisableScheduler(void);
+s32 OSEnableScheduler(void);
+void OSYieldThread(void);
+BOOL OSCreateThread(OSThread* thread, void* (*func)(void*), void* param, void* stack, u32 stackSize,
+                    OSPriority priority, u16 attr);
+void OSExitThread(void* val);
+void OSCancelThread(OSThread* thread);
+BOOL OSJoinThread(OSThread* thread, void** val);
+void OSDetachThread(OSThread* thread);
+s32 OSResumeThread(OSThread* thread);
+s32 OSSuspendThread(OSThread* thread);
+BOOL OSSetThreadPriority(OSThread* thread, OSPriority priority);
+OSPriority OSGetThreadPriority(OSThread* thread);
+void OSSleepThread(OSThreadQueue* queue);
+void OSWakeupThread(OSThreadQueue* queue);
+
+void* OSGetThreadSpecific(s32 index);
+void OSSetThreadSpecific(s32 index, void* ptr);
+
+OSThread* OSSetIdleFunction(OSIdleFunction idleFunction, void* param, void* stack, u32 stackSize);
+OSThread* OSGetIdleFunction(void);
+void OSClearStack(u8 val);
+long OSCheckActiveThreads(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_OSTHREAD

include/dolphin/pad.h

@@ -0,0 +1,128 @@
+#ifndef _DOLPHIN_PAD
+#define _DOLPHIN_PAD
+
+#include <dolphin/types.h>
+
+extern u32 __PADFixBits;
+
+#define PAD_SPEC_0 0
+#define PAD_SPEC_1 1
+#define PAD_SPEC_2 2
+#define PAD_SPEC_3 3
+#define PAD_SPEC_4 4
+#define PAD_SPEC_5 5
+
+#define PAD_CHAN0 0
+#define PAD_CHAN1 1
+#define PAD_CHAN2 2
+#define PAD_CHAN3 3
+#define PAD_CHANMAX 4
+
+#define PAD_MOTOR_STOP 0
+#define PAD_MOTOR_RUMBLE 1
+#define PAD_MOTOR_STOP_HARD 2
+
+#define PAD_ERR_NONE 0
+#define PAD_ERR_NO_CONTROLLER -1
+#define PAD_ERR_NOT_READY -2
+#define PAD_ERR_TRANSFER -3
+
+#define PAD_BUTTON_LEFT 0x0001
+#define PAD_BUTTON_RIGHT 0x0002
+#define PAD_BUTTON_DOWN 0x0004
+#define PAD_BUTTON_UP 0x0008
+#define PAD_TRIGGER_Z 0x0010
+#define PAD_TRIGGER_R 0x0020
+#define PAD_TRIGGER_L 0x0040
+#define PAD_BUTTON_A 0x0100
+#define PAD_BUTTON_B 0x0200
+#define PAD_BUTTON_X 0x0400
+#define PAD_BUTTON_Y 0x0800
+#define PAD_BUTTON_MENU 0x1000
+#define PAD_BUTTON_START 0x1000
+
+#define PAD_CHAN0_BIT 0x80000000
+#define PAD_CHAN1_BIT 0x40000000
+#define PAD_CHAN2_BIT 0x20000000
+#define PAD_CHAN3_BIT 0x10000000
+
+#define PADButtonDown(buttonLast, button) ((((buttonLast) ^ (button)) & (button)))
+
+#define PADButtonUp(buttonLast, button) ((((buttonLast) ^ (button)) & (buttonLast)))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*PADSamplingCallback)(void);
+
+typedef struct PADStatus {
+  u16 button;
+  s8 stickX;
+  s8 stickY;
+  s8 substickX;
+  s8 substickY;
+  u8 triggerL;
+  u8 triggerR;
+  u8 analogA;
+  u8 analogB;
+  s8 err;
+} PADStatus;
+
+BOOL PADInit();
+u32 PADRead(PADStatus* status);
+BOOL PADReset(u32 mask);
+BOOL PADRecalibrate(u32 mask);
+void PADClamp(PADStatus* status);
+void PADClampCircle(PADStatus* status);
+void PADControlMotor(s32 chan, u32 cmd);
+void PADSetSpec(u32 spec);
+void PADControlAllMotors(const u32* cmdArr);
+void PADSetAnalogMode(u32 mode);
+PADSamplingCallback PADSetSamplingCallback(PADSamplingCallback);
+
+#ifdef TARGET_PC
+/* New API to facilitate controller interactions */
+typedef struct PADDeadZones {
+  bool emulateTriggers;
+  bool useDeadzones;
+  u16 stickDeadZone;
+  u16 substickDeadZone;
+  u16 leftTriggerActivationZone;
+  u16 rightTriggerActivationZone;
+} PADDeadZones;
+
+typedef u16 PADButton;
+
+typedef struct PADButtonMapping {
+  u32 nativeButton;
+  PADButton padButton;
+} PADButtonMapping;
+
+/* Returns the total number of controllers */
+u32 PADCount();
+/* Returns the controller name for the given index into the controller map */
+const char* PADGetNameForControllerIndex(u32 idx);
+void PADSetPortForIndex(u32 index, s32 port);
+s32 PADGetIndexForPort(u32 port);
+void PADGetVidPid(u32 port, u32* vid, u32* pid);
+void PADClearPort(u32 port);
+const char* PADGetName(u32 port);
+void PADSetButtonMapping(u32 port, PADButtonMapping mapping);
+void PADSetAllButtonMappings(u32 port, PADButtonMapping buttons[12]);
+PADButtonMapping* PADGetButtonMappings(u32 port, u32* buttonCount);
+void PADSerializeMappings();
+PADDeadZones* PADGetDeadZones(u32 port);
+const char* PADGetButtonName(PADButton);
+const char* PADGetNativeButtonName(u32 button);
+/* Returns any pressed native button */
+s32 PADGetNativeButtonPressed(u32 port);
+void PADRestoreDefaultMapping(u32 port);
+void PADBlockInput(bool block);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_PAD

include/dolphin/sipriv.h

@@ -0,0 +1,52 @@
+#ifndef _DOLPHIN_SIPRIV
+#define _DOLPHIN_SIPRIV
+
+#include "dolphin/os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*SICallback)(s32 chan, u32 sr, OSContext* context);
+typedef void (*SITypeAndStatusCallback)(s32 chan, u32 type);
+
+typedef struct SIPacket {
+  s32 chan;
+  void* output;
+  u32 outputBytes;
+  void* input;
+  u32 inputBytes;
+  SICallback callback;
+  OSTime fire;
+} SIPacket;
+
+void SIInit(void);
+u32 SIGetStatus(s32 chan);
+
+BOOL SIBusy(void);
+BOOL SIIsChanBusy(s32 chan);
+
+BOOL SITransfer(s32 chan, void* output, u32 outputBytes, void* input, u32 inputBytes,
+                SICallback callback, OSTime delay);
+u32 SISync(void);
+
+void SISetCommand(s32 chan, u32 command);
+u32 SIGetCommand(s32 chan);
+void SITransferCommands(void);
+u32 SISetXY(u32 x, u32 y);
+u32 SIEnablePolling(u32 poll);
+u32 SIDisablePolling(u32 poll);
+BOOL SIGetResponse(s32 chan, void* data);
+
+BOOL SIRegisterPollingHandler(__OSInterruptHandler handler);
+BOOL SIUnregisterPollingHandler(__OSInterruptHandler handler);
+
+u32 SIGetType(s32 chan);
+u32 SIGetTypeAsync(s32 chan, SITypeAndStatusCallback callback);
+u32 SIDecodeType(u32 type);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_SIPRIV

include/dolphin/thp.h

@@ -0,0 +1,88 @@
+#ifndef _DOLPHIN_THP
+#define _DOLPHIN_THP
+
+#include "dolphin/types.h"
+#include "dolphin/thp/THPAudio.h"
+#include "dolphin/thp/THPVideoDecode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef u8 THPSample;
+typedef s16 THPCoeff;
+typedef f32 THPQuantTab[64];
+
+typedef struct _THPHuffmanTab {
+  u8 quick[32];
+  u8 increment[32];
+  u8* Vij;
+  s32 maxCode[18];
+  s32 valPtr[18];
+  u8 Vij1;
+  u8 pad[11];
+} THPHuffmanTab;
+
+typedef struct _THPComponent {
+  u8 quantizationTableSelector;
+  u8 DCTableSelector;
+  u8 ACTableSelector;
+  THPCoeff predDC;
+} THPComponent;
+
+typedef struct _THPFileInfo {
+  THPQuantTab quantTabs[3];
+  THPHuffmanTab huffmanTabs[4];
+  THPComponent components[3];
+  u16 xPixelSize;
+  u16 yPixelSize;
+  u16 MCUsPerRow;
+  u16 decompressedY;
+  u8* c;
+  u32 currByte;
+  u32 cnt;
+  u8 validHuffmanTabs;
+  u8 RST;
+  u16 nMCU;
+  u16 currMCU;
+  u8* dLC[3];
+} THPFileInfo;
+
+s32 __THPAudioGetNewSample(THPAudioDecodeInfo*);
+void __THPAudioInitialize(THPAudioDecodeInfo*, u8*);
+
+static void __THPSetupBuffers(void);
+static u8 __THPReadFrameHeader(void);
+static u8 __THPReadScaneHeader(void);
+static u8 __THPReadQuantizationTable(void);
+static u8 __THPReadHuffmanTableSpecification(void);
+static void __THPHuffGenerateSizeTable(void);
+static void __THPHuffGenerateCodeTable(void);
+static void __THPHuffGenerateDecoderTables(u8 tabIndex);
+static void __THPRestartDefinition(void);
+static void __THPPrepBitStream(void);
+static void __THPDecompressYUV(void*, void*, void*);
+static void __THPGQRRestore(void);
+static void __THPDecompressiMCURow512x448(void);
+static void __THPDecompressiMCURow640x480(void);
+static void __THPDecompressiMCURowNxN(void);
+static void __THPInverseDCTNoYPos(THPCoeff*, u32);
+static void __THPHuffDecodeDCTCompY(THPFileInfo*, THPCoeff*);
+static void __THPHuffDecodeDCTCompU(THPFileInfo*, THPCoeff*);
+static void __THPHuffDecodeDCTCompV(THPFileInfo*, THPCoeff*);
+
+static const u8 __THPJpegNaturalOrder[80] = {
+    0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, 18, 11, 4,  5,  12, 19, 26, 33,
+    40, 48, 41, 34, 27, 20, 13, 6,  7,  14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54,
+    47, 55, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63};
+
+static const f64 __THPAANScaleFactor[8] = {
+    1.0f, 1.387039845f, 1.306562965f, 1.175875602f, 1.0f, 0.785694958f, 0.541196100f, 0.275899379f,
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_THP

include/dolphin/thp/THPAudio.h

@@ -0,0 +1,38 @@
+#ifndef _DOLPHIN_THPAUDIO
+#define _DOLPHIN_THPAUDIO
+
+#include "dolphin/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct THPAudioRecordHeader {
+  u32 offsetNextChannel;
+  u32 sampleSize;
+  s16 lCoef[8][2];
+  s16 rCoef[8][2];
+  s16 lYn1;
+  s16 lYn2;
+  s16 rYn1;
+  s16 rYn2;
+} THPAudioRecordHeader;
+
+typedef struct THPAudioDecodeInfo {
+  u8* encodeData;
+  u32 offsetNibbles;
+  u8 predictor;
+  u8 scale;
+  s16 yn1;
+  s16 yn2;
+} THPAudioDecodeInfo;
+
+u32 THPAudioDecode(s16* audioBuffer, u8* audioFrame, s32 flag);
+static s32 __THPAudioGetNewSample(THPAudioDecodeInfo* info);
+static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_THPAUDIO

include/dolphin/thp/THPAudioDecode.h

@@ -0,0 +1,29 @@
+#ifndef _THP_THPAUDIODECODE_H
+#define _THP_THPAUDIODECODE_H
+
+#include "Dolphin/os.h"
+#include "THP/THPAudio.h"
+
+static void* AudioDecoderForOnMemory(void* bufPtr);
+static void* AudioDecoder(void* _);
+static void AudioDecode(THPReadBuffer* readBuffer);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+BOOL CreateAudioDecodeThread(OSPriority prio, void* param);
+void AudioDecodeThreadStart();
+void AudioDecodeThreadCancel();
+
+void PushFreeAudioBuffer(void* buf);
+void PushDecodedAudioBuffer(void* buf);
+
+void* PopFreeAudioBuffer();
+void* PopDecodedAudioBuffer(s32 flags);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/dolphin/thp/THPBuffer.h

@@ -0,0 +1,36 @@
+#ifndef _THP_THPBUFFER_H
+#define _THP_THPBUFFER_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Size 0x10
+typedef struct THPTextureSet {
+	u8* mYTexture;    // _00
+	u8* mUTexture;    // _04
+	u8* mVTexture;    // _08
+	s32 mFrameNumber; // _0C
+} THPTextureSet;
+
+// Size 0xC
+typedef struct THPAudioBuffer {
+	s16* mBuffer;     // _00
+	s16* mCurPtr;     // _04
+	u32 mValidSample; // _08
+} THPAudioBuffer;
+
+// Size 0xC
+typedef struct THPReadBuffer {
+	u8* mPtr;         // _00
+	s32 mFrameNumber; // _04
+	BOOL mIsValid;    // _08
+} THPReadBuffer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/dolphin/thp/THPDraw.h

@@ -0,0 +1,21 @@
+#ifndef _THP_THPDRAW_H
+#define _THP_THPDRAW_H
+
+#include "types.h"
+#include "Dolphin/GX/GXTypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // ifdef __cplusplus
+
+void THPGXRestore(void);
+void THPGXYuv2RgbSetup(GXRenderModeObj* obj);
+void THPGXYuv2RgbDraw(u32* yImage, u32* uImage, u32* vImage, s16 x, s16 y, s16 texWidth, s16 texHeight, s16 polyWidth, s16 polyHeight);
+void THPPlayerStop();
+BOOL THPPlayerSetVolume(int, int);
+
+#ifdef __cplusplus
+};
+#endif // ifdef __cplusplus
+
+#endif

include/dolphin/thp/THPFile.h

@@ -0,0 +1,30 @@
+#ifndef _THP_THPFILE_H
+#define _THP_THPFILE_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Size 0x30
+typedef struct THPHeader {
+	char mMagic[4];             // _00
+	u32 mVersion;               // _04
+	u32 mBufferSize;            // _08
+	u32 mAudioMaxSamples;       // _0C
+	f32 mFrameRate;             // _10
+	u32 mNumFrames;             // _14
+	u32 mFirstFrameSize;        // _18
+	u32 mMovieDataSize;         // _1C
+	u32 mCompInfoDataOffsets;   // _20
+	u32 mOffsetDataOffsets;     // _24
+	u32 mMovieDataOffsets;      // _28
+	u32 mFinalFrameDataOffsets; // _2C
+} THPHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/dolphin/thp/THPInfo.h

@@ -0,0 +1,35 @@
+#ifndef _THP_THPINFO_H
+#define _THP_THPINFO_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Size 0xC
+typedef struct THPVideoInfo {
+	u32 mXSize;     // _00
+	u32 mYSize;     // _04
+	u32 mVideoType; // _08
+} THPVideoInfo;
+
+// Size 0x10
+typedef struct THPAudioInfo {
+	u32 mSndChannels;   // _00
+	u32 mSndFrequency;  // _04
+	u32 mSndNumSamples; // _08
+	u32 mSndNumTracks;  // _0C
+} THPAudioInfo;
+
+// Size 0x14
+typedef struct THPFrameCompInfo {
+	u32 mNumComponents; // _00
+	u8 mFrameComp[16];  // _04
+} THPFrameCompInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/dolphin/thp/THPPlayer.h

@@ -0,0 +1,91 @@
+#ifndef _THP_THPPLAYER_H
+#define _THP_THPPLAYER_H
+
+#include "types.h"
+#include "Dolphin/os.h"
+#include "Dolphin/gx.h"
+#include "THP/THPBuffer.h"
+#include "THP/THPFile.h"
+#include "THP/THPInfo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Size: 0x1D0
+typedef struct THPPlayer {
+	DVDFileInfo mFileInfo;            // _00
+	THPHeader mHeader;                // _3C
+	THPFrameCompInfo mCompInfo;       // _6C
+	THPVideoInfo mVideoInfo;          // _80
+	THPAudioInfo mAudioInfo;          // _8C
+	void* mThpWorkArea;               // _9C
+	BOOL mIsOpen;                     // _A0
+	u8 mState;                        // _A4
+	u8 mInternalState;                // _A5
+	u8 mPlayFlag;                     // _A6
+	u8 mAudioExist;                   // _A7
+	s32 mDvdError;                    // _A8
+	s32 mVideoError;                  // _AC
+	BOOL mIsOnMemory;                 // _B0
+	u8* mMovieData;                   // _B4
+	s32 mInitOffset;                  // _B8
+	s32 mInitReadSize;                // _BC
+	s32 mInitReadFrame;               // _C0
+	u32 mCurField;                    // _C4
+	s64 mRetraceCount;                // _C8
+	s32 mPrevCount;                   // _D0
+	s32 mCurCount;                    // _D4
+	s32 mVideoDecodeCount;            // _D8
+	f32 mCurVolume;                   // _DC
+	f32 mTargetVolume;                // _E0
+	f32 mDeltaVolume;                 // _E4
+	s32 mRampCount;                   // _E8
+	s32 mCurAudioTrack;               // _EC
+	s32 mCurVideoNumber;              // _F0
+	s32 mCurAudioNumber;              // _F4
+	THPTextureSet* mDispTextureSet;   // _F8
+	THPAudioBuffer* mPlayAudioBuffer; // _FC
+	THPReadBuffer mReadBuffer[10];    // _100
+	THPTextureSet mTextureSet[3];     // _178
+	THPAudioBuffer mAudioBuffer[3];   // _1A8
+} THPPlayer;
+
+extern THPPlayer ActivePlayer;
+
+BOOL THPPlayerInit(int _);
+void THPPlayerQuit();
+BOOL THPPlayerOpen(const char* fileName, BOOL onMemory);
+BOOL THPPlayerClose();
+BOOL THPPlayerPlay();
+void THPPlayerStop();
+BOOL THPPlayerPause();
+BOOL THPPlayerPrepare(int offset, u8 flag, int audioTrack);
+
+BOOL THPPlayerSetBuffer(u8* data);
+
+u32 THPPlayerCalcNeedMemory();
+
+BOOL THPPlayerGetVideoInfo(void* dst);
+BOOL THPPlayerGetAudioInfo(void* dst);
+// f32 THPPlayerGetFrameRate();
+BOOL THPPlayerSetVolume(int vol, int duration);
+
+int THPPlayerDrawCurrentFrame(GXRenderModeObj* obj, int x, int y, int polyWidth,
+                              int polyHeight); // TODO, parameter names from dwarf info if it exists
+u32 THPPlayerGetTotalFrame();
+u8 THPPlayerGetState();
+
+void THPPlayerDrawDone();
+void THPPlayerPostDrawDone();
+
+// this should go in a dolphin THP header eventually
+BOOL THPInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+void PrepareReady(int msg);
+
+#endif /* _THP_THPPLAYER_H */

include/dolphin/thp/THPRead.h

@@ -0,0 +1,28 @@
+#ifndef _THP_THPREAD_H
+#define _THP_THPREAD_H
+
+#include "dolphin/thp/THPBuffer.h"
+#include "dolphin/os.h"
+
+static void* Reader(void* arg);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // ifdef __cplusplus
+
+BOOL CreateReadThread(OSPriority priority);
+void ReadThreadStart();
+void ReadThreadCancel();
+OSMessage PopReadedBuffer();
+BOOL PushReadedBuffer(OSMessage*);
+OSMessage PopFreeReadBuffer();
+BOOL PushFreeReadBuffer(OSMessage*);
+OSMessage PopReadedBuffer2();
+BOOL PushReadedBuffer2(OSMessage*);
+
+extern u8 gTHPReaderDvdAccess;
+#ifdef __cplusplus
+};
+#endif
+
+#endif

include/dolphin/thp/THPVideoDecode.h

@@ -0,0 +1,31 @@
+#ifndef _DOLPHIN_THPVIDEODECODE
+#define _DOLPHIN_THPVIDEODECODE
+
+#include "dolphin/thp/THPRead.h"
+
+static void* VideoDecoder(void*);
+static void* VideoDecoderForOnMemory(void*);
+static void VideoDecode(THPReadBuffer*);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // ifdef __cplusplus
+s32 THPVideoDecode(void* file, void* tileY, void* tileU, void* tileV, void* work);
+BOOL CreateVideoDecodeThread(OSPriority priority, void* task);
+void VideoDecodeThreadStart();
+void VideoDecodeThreadCancel();
+OSMessage PopFreeTextureSet();
+BOOL PushFreeTextureSet(OSMessage*);
+OSMessage PopDecodedTextureSet(s32 flags);
+BOOL PushDecodedTextureSet(OSMessage*);
+
+extern BOOL VideoDecodeThreadCreated;
+extern OSMessageQueue FreeTextureSetQueue;
+extern OSMessageQueue DecodedTextureSetQueue;
+extern OSThread VideoDecodeThread;
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // _DOLPHIN_THPVIDEODECODE

include/dolphin/types.h

@@ -0,0 +1,90 @@
+#ifndef _DOLPHIN_TYPES
+#define _DOLPHIN_TYPES
+
+#ifdef TARGET_PC
+#include <stdint.h>
+typedef int8_t s8;
+typedef int16_t s16;
+typedef int32_t s32;
+typedef int64_t s64;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+#else
+typedef signed char s8;
+typedef signed short int s16;
+typedef signed long s32;
+typedef signed long long int s64;
+typedef unsigned char u8;
+typedef unsigned short int u16;
+typedef unsigned long u32;
+typedef unsigned long long int u64;
+#endif
+
+typedef volatile u8 vu8;
+typedef volatile u16 vu16;
+typedef volatile u32 vu32;
+typedef volatile u64 vu64;
+
+typedef volatile s8 vs8;
+typedef volatile s16 vs16;
+typedef volatile s32 vs32;
+typedef volatile s64 vs64;
+
+typedef float f32;
+typedef double f64;
+
+typedef volatile f32 vf32;
+typedef volatile f64 vf64;
+
+#if defined(TARGET_PC) && !defined(_WIN32)
+#include <stdbool.h>
+typedef bool BOOL;
+#ifndef FALSE
+#define FALSE false
+#endif
+#ifndef TRUE
+#define TRUE true
+#endif
+#else
+typedef int BOOL;
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+#endif
+
+#ifdef TARGET_PC
+#include <stddef.h>
+#else
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+#endif
+#if !defined(__cplusplus) || __cplusplus < 201103L
+#ifndef nullptr
+#define nullptr NULL
+#endif
+
+#if defined(__MWERKS__)
+#ifndef override
+#define override
+#endif
+#endif
+
+#endif
+
+#ifndef ATTRIBUTE_ALIGN
+#if defined(__MWERKS__) || defined(__GNUC__)
+#define ATTRIBUTE_ALIGN(num) __attribute__((aligned(num)))
+#elif defined(_MSC_VER)
+#define ATTRIBUTE_ALIGN(num)
+#else
+#error unknown compiler
+#endif
+#endif
+
+#endif // _DOLPHIN_TYPES

include/dolphin/vi.h

@@ -0,0 +1,31 @@
+#ifndef _DOLPHIN_VI
+#define _DOLPHIN_VI
+
+#include <dolphin/gx/GXStruct.h>
+#include <dolphin/vifuncs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void VIInit(void);
+void VIConfigure(const GXRenderModeObj* rm);
+void VIFlush(void);
+u32 VIGetTvFormat(void);
+void VISetNextFrameBuffer(void* fb);
+void VIWaitForRetrace(void);
+void VISetBlack(BOOL black);
+
+#ifdef TARGET_PC
+void VISetWindowTitle(const char* title);
+void VISetWindowFullscreen(bool fullscreen);
+bool VIGetWindowFullscreen();
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_VI

include/dolphin/vifuncs.h

@@ -0,0 +1,22 @@
+#ifndef _DOLPHIN_VIFUNCS
+#define _DOLPHIN_VIFUNCS
+
+#include <dolphin/types.h>
+
+#include <dolphin/vitypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+u32 VIGetNextField(void);
+VIRetraceCallback VISetPreRetraceCallback(VIRetraceCallback callback);
+VIRetraceCallback VISetPostRetraceCallback(VIRetraceCallback callback);
+void __VIGetCurrentPosition(s16* x, s16* y);
+u32 VIGetDTVStatus(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_VIFUNCS

include/dolphin/vitypes.h

@@ -0,0 +1,130 @@
+#ifndef _DOLPHIN_VITYPES
+#define _DOLPHIN_VITYPES
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VI_INTERLACE 0
+#define VI_NON_INTERLACE 1
+#define VI_PROGRESSIVE 2
+#define VI_3D 3
+
+#define VI_NTSC 0
+#define VI_PAL 1
+#define VI_MPAL 2
+#define VI_DEBUG 3
+#define VI_DEBUG_PAL 4
+#define VI_EURGB60 5
+#define VI_GCA 6
+
+#define VI_TVMODE(format, interlace) (((format) << 2) + (interlace))
+
+typedef enum {
+  // NTSC
+  VI_TVMODE_NTSC_INT = VI_TVMODE(VI_NTSC, VI_INTERLACE),
+  VI_TVMODE_NTSC_DS = VI_TVMODE(VI_NTSC, VI_NON_INTERLACE),
+  VI_TVMODE_NTSC_PROG = VI_TVMODE(VI_NTSC, VI_PROGRESSIVE),
+  VI_TVMODE_NTSC_3D = VI_TVMODE(VI_NTSC, VI_3D),
+  // PAL
+  VI_TVMODE_PAL_INT = VI_TVMODE(VI_PAL, VI_INTERLACE),
+  VI_TVMODE_PAL_DS = VI_TVMODE(VI_PAL, VI_NON_INTERLACE),
+
+  // MPAL
+  VI_TVMODE_MPAL_INT = VI_TVMODE(VI_MPAL, VI_INTERLACE),
+  VI_TVMODE_MPAL_DS = VI_TVMODE(VI_MPAL, VI_NON_INTERLACE),
+
+  // Debug
+  VI_TVMODE_DEBUG_INT = VI_TVMODE(VI_DEBUG, VI_INTERLACE),
+
+  // Debug PAL
+  VI_TVMODE_DEBUG_PAL_INT = VI_TVMODE(VI_DEBUG_PAL, VI_INTERLACE),
+  VI_TVMODE_DEBUG_PAL_DS = VI_TVMODE(VI_DEBUG_PAL, VI_NON_INTERLACE),
+
+  // EU RGB60
+  VI_TVMODE_EURGB60_INT = VI_TVMODE(VI_EURGB60, VI_INTERLACE),
+  VI_TVMODE_EURGB60_DS = VI_TVMODE(VI_EURGB60, VI_NON_INTERLACE),
+
+  // GCA
+  VI_TVMODE_GCA_INT = VI_TVMODE(VI_GCA, VI_INTERLACE),
+  VI_TVMODE_GCA_DS = VI_TVMODE(VI_GCA, VI_NON_INTERLACE),
+  VI_TVMODE_GCA_PROG = VI_TVMODE(VI_GCA, VI_PROGRESSIVE),
+} VITVMode;
+
+typedef enum {
+  VI_XFBMODE_SF = 0,
+  VI_XFBMODE_DF = 1,
+} VIXFBMode;
+
+typedef void (*VIPositionCallback)(s16 x, s16 y);
+typedef void (*VIRetraceCallback)(u32 retraceCount);
+
+// Structure to use with timing in vi.c (size 0x28).
+typedef struct VITimingInfo {
+  u8 equ;           // _00
+  u16 acv;          // _02
+  u16 prbOdd;       // _04
+  u16 prbEven;      // _06
+  u16 psbOdd;       // _08
+  u16 psbEven;      // _0A
+  u8 bs1;           // _0C
+  u8 bs2;           // _0D
+  u8 bs3;           // _0E
+  u8 bs4;           // _0F
+  u16 be1;          // _10
+  u16 be2;          // _12
+  u16 be3;          // _14
+  u16 be4;          // _16
+  u16 numHalfLines; // _18
+  u16 hlw;          // _1A
+  u8 hsy;           // _1C
+  u8 hcs;           // _1D
+  u8 hce;           // _1E
+  u8 hbe640;        // _1F
+  u16 hbs640;       // _20
+  u8 hbeCCIR656;    // _24
+  u16 hbsCCIR656;   // _26
+} VITimingInfo;
+
+// Structure to use with HorVer in vi.c (size 0x58).
+typedef struct VIPositionInfo {
+  u16 dispPosX;         // _00
+  u16 dispPosY;         // _02
+  u16 dispSizeX;        // _04
+  u16 dispSizeY;        // _06
+  u16 adjDispPosX;      // _08
+  u16 adjDispPosY;      // _0A
+  u16 adjDispSizeY;     // _0C
+  u16 adjPanPosY;       // _0E
+  u16 adjPanSizeY;      // _10
+  u16 fbSizeX;          // _12
+  u16 fbSizeY;          // _14
+  u16 panPosX;          // _16
+  u16 panPosY;          // _18
+  u16 panSizeX;         // _1A
+  u16 panSizeY;         // _1C
+  VIXFBMode xfbMode;    // _20
+  u32 nonInter;         // _24
+  u32 tv;               // _28
+  u8 wordPerLine;       // _2C
+  u8 std;               // _2D
+  u8 wpl;               // _2E
+  u32 bufAddr;          // _30
+  u32 tfbb;             // _34
+  u32 bfbb;             // _38
+  u8 xof;               // _3C
+  BOOL isBlack;         // _40
+  BOOL is3D;            // _44
+  u32 rbufAddr;         // _48
+  u32 rtfbb;            // _4C
+  u32 rbfbb;            // _50
+  VITimingInfo* timing; // _54
+} VIPositionInfo;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DOLPHIN_VITYPES

include/functions.h

@@ -4,11 +4,6 @@
 #include "types.h"
 #include "common_structs.h"
 
-void OSReport(const char * format, ...);
-void* OSAllocFromHeap(int heap, u32 size);
-s32 OSCheckHeap(int heap);
-void DCFlushRangeNoSync(void *addr, u32 size);
-void DCFlushRange(void *addr, u32 size);
 void* HuPrcCreate(void (*), s32, s32, s32);
 void HuPrcSleep(s32, f32);
 void HuPrcVSleep(void);

include/types.h

@@ -1,24 +1,6 @@
 #ifndef _TYPES_H_
 #define _TYPES_H_
 
-#define NULL ((void *)0)
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned long u32;
-typedef unsigned long long u64;
-typedef signed char s8;
-typedef short s16;
-typedef long s32;
-typedef long long s64;
-typedef volatile unsigned char vu8;
-typedef volatile unsigned short vu16;
-typedef volatile unsigned long vu32;
-typedef volatile unsigned long long vu64;
-typedef volatile signed char vs8;
-typedef volatile short vs16;
-typedef volatile long vs32;
-typedef volatile long long vs64;
-typedef float f32;
-typedef double f64;
+#include "dolphin/types.h"
 
-#endif
+#endif

src/REL/_minigameDLL/_minigameDLL.c

@@ -1,5 +1,6 @@
 #include "common.h"
 #include "REL/executor.h"
+#include "dolphin/os.h"
 
 void ModuleProlog(void) {
     OSReport("minigame dll setup\n");

src/game/decode.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "dolphin/os.h"
 
 struct decode_data
 {

src/game/malloc.c

@@ -1,7 +1,7 @@
 #include "common.h"
+#include "dolphin/os.h"
 
-extern int __OSCurrHeap;
-extern int currentHeapHandle;
+extern OSHeapHandle currentHeapHandle;
 
 static u32 HeapSizeTbl[5] = { 0x240000, 0x140000, 0xA80000, 0x580000, 0 };
 static void *HeapTbl[5];

src/game/memory.c

@@ -1,4 +1,5 @@
 #include "common.h"
+#include "dolphin/os.h"
 
 #define DATA_GET_BLOCK(ptr) ((struct memory_block *)(((char *)(ptr))-32))
 #define BLOCK_GET_DATA(block) (((char *)(block))+32)