From 7d4e4c0b34a613dd3c0220475ae4e448197522c1 Mon Sep 17 00:00:00 2001
From: Treeki <treeki@gmail.com>
Date: Sat, 12 Mar 2011 23:17:12 +0100
Subject: initial commit. now I can start playing with stuff!

---
 include/actors.h          |  813 ++++++++++++++++++++++++++++
 include/common.h          |  107 ++++
 include/course.h          |  168 ++++++
 include/event.h           |   16 +
 include/g3dhax.h          |  168 ++++++
 include/game.h            | 1102 ++++++++++++++++++++++++++++++++++++++
 include/rvl/GXBump.h      |   55 ++
 include/rvl/GXCull.h      |   18 +
 include/rvl/GXDispList.h  |   18 +
 include/rvl/GXEnum.h      | 1300 +++++++++++++++++++++++++++++++++++++++++++++
 include/rvl/GXGeometry.h  |   82 +++
 include/rvl/GXLighting.h  |   94 ++++
 include/rvl/GXPixel.h     |   49 ++
 include/rvl/GXStruct.h    |  132 +++++
 include/rvl/GXTev.h       |   92 ++++
 include/rvl/GXTexture.h   |  127 +++++
 include/rvl/GXTransform.h |   71 +++
 include/rvl/GXVert.h      |  222 ++++++++
 include/rvl/OSCache.h     |   61 +++
 include/rvl/PPCWGPipe.h   |   37 ++
 include/rvl/arc.h         |  115 ++++
 include/rvl/mtx.h         |  441 +++++++++++++++
 include/rvl/tpl.h         |  107 ++++
 include/rvl/vifuncs.h     |   48 ++
 include/rvl/vitypes.h     |   79 +++
 include/stage.h           |   63 +++
 include/state.h           |   24 +
 27 files changed, 5609 insertions(+)
 create mode 100755 include/actors.h
 create mode 100755 include/common.h
 create mode 100755 include/course.h
 create mode 100755 include/event.h
 create mode 100644 include/g3dhax.h
 create mode 100755 include/game.h
 create mode 100755 include/rvl/GXBump.h
 create mode 100755 include/rvl/GXCull.h
 create mode 100755 include/rvl/GXDispList.h
 create mode 100755 include/rvl/GXEnum.h
 create mode 100755 include/rvl/GXGeometry.h
 create mode 100755 include/rvl/GXLighting.h
 create mode 100755 include/rvl/GXPixel.h
 create mode 100755 include/rvl/GXStruct.h
 create mode 100755 include/rvl/GXTev.h
 create mode 100755 include/rvl/GXTexture.h
 create mode 100755 include/rvl/GXTransform.h
 create mode 100755 include/rvl/GXVert.h
 create mode 100755 include/rvl/OSCache.h
 create mode 100755 include/rvl/PPCWGPipe.h
 create mode 100755 include/rvl/arc.h
 create mode 100755 include/rvl/mtx.h
 create mode 100755 include/rvl/tpl.h
 create mode 100755 include/rvl/vifuncs.h
 create mode 100755 include/rvl/vitypes.h
 create mode 100755 include/stage.h
 create mode 100755 include/state.h

(limited to 'include')

diff --git a/include/actors.h b/include/actors.h
new file mode 100755
index 0000000..f1ebe4c
--- /dev/null
+++ b/include/actors.h
@@ -0,0 +1,813 @@
+#ifndef __KAMEK_ACTORS_H
+#define __KAMEK_ACTORS_H
+
+#include <common.h>
+
+enum Actors {
+	BOOT = 0,
+	AUTO_SELECT = 1,
+	SELECT = 2,
+	WORLD_MAP = 3,
+	WORLD_9_DEMO = 4,
+	STAGE = 5,
+	RESTART_CRSIN = 6,
+	CRSIN = 7,
+	MOVIE = 8,
+	GAMEOVER = 9,
+	GAME_SETUP = 10,
+	MULTI_PLAY_COURSE_SELECT = 11,
+	CURSOR = 12,
+	PLAYER = 13,
+	YOSHI = 14,
+	WM_TEST = 15,
+	WM_TEST2 = 16,
+	BG_GM = 17,
+	CAMERA = 18,
+	YOSHI_FIRE = 19,
+	SLOW_QUICK_TAG = 20,
+	TORIDE_KOKOOPA_DEMO = 21,
+	BOSS_KAMECK_DEMO = 22,
+	BOSS_KOOPA_DEMO = 23,
+	CASTLE_KOKOOPA_DEMO_1ST = 24,
+	CASTLE_KOKOOPA_DEMO_2ND = 25,
+	BOSS_KOOPA_JR_DEMO = 26,
+	KOOPA_SHIP_FOR_CASTLE_DEMO = 27,
+	KOOPA_JR_FOR_CASTLE_DEMO = 28,
+	PEACH_FOR_CASTLE_DEMO = 29,
+	KAMECK_FOR_CASTLE_DEMO = 30,
+	LEMMY_FOOTHOLD = 31,
+	LEMMY_FOOTHOLD_MAIN = 32,
+	CASTLE_BOSS_DOOR = 33,
+	CASTLE_BOSS_KEY = 34,
+	AC_BATTLE_GAME = 35,
+	AC_BATTLE_KINOPIO = 36,
+	AC_BATTLE_ITEM = 37,
+	AC_ENDING_MAIN = 38,
+	AC_BLOCK_WIND_TAG = 39,
+	AC_GROUPID = 40,
+	KAWANAGARE = 41,
+	RIVER_PAIPO = 42,
+	RIVER_ITEM = 43,
+	RIVER_COIN = 44,
+	RIVER_STARCOIN = 45,
+	RIVER_LIFT = 46,
+	RIVER_BARREL = 47,
+	RIVER_PUKU = 48,
+	RIVER_PAKKUN = 49,
+	RIVER_MGR = 50,
+	EN_KURIBO = 51,
+	EN_PATA_KURIBO = 52,
+	EN_MAME_KURIBO = 53,
+	EN_NOKONOKO = 54,
+	EN_PATAPATA = 55,
+	EN_MET = 56,
+	EN_TOGEZO = 57,
+	EN_SAKASA_TOGEZO = 58,
+	EN_BLOCK = 59,
+	EN_ITEM = 60,
+	EN_STAR_COIN = 61,
+	EN_STAR_COIN_LINE = 62,
+	EN_STAR_COIN_VOLT = 63,
+	AC_FLAGON = 64,
+	AC_4SWICHAND = 65,
+	AC_4SWICHOR = 66,
+	AC_RANDSWICH = 67,
+	AC_CHNGESWICH = 68,
+	AC_IFSWICH = 69,
+	AC_RNSWICH = 70,
+	EN_BKBLOCK = 71,
+	EN_HNSWICH = 72,
+	EN_PSWICH = 73,
+	EN_QSWICH = 74,
+	EN_BOSS_KOOPA_SWITCH = 75,
+	EN_BOSS_KOOPA_BIG_SWITCH = 76,
+	EN_BLSWICH = 77,
+	EN_BLPSWICH = 78,
+	EN_BLQSWICH = 79,
+	EN_BUBBLE = 80,
+	EN_DOSUN = 81,
+	EN_BIGDOSUN = 82,
+	EN_JUGEM = 83,
+	EN_JUGEM_COIN = 84,
+	EN_EATJUGEM = 85,
+	EN_JUGEM_BODY = 86,
+	EN_TOGEMET = 87,
+	EN_FIREBAR = 88,
+	EN_TOGETEKKYU = 89,
+	EN_BIG_TOGETEKKYU = 90,
+	EN_UP_DOKAN_PAKKUN = 91,
+	EN_DOWN_DOKAN_PAKKUN = 92,
+	EN_RIGHT_DOKAN_PAKKUN = 93,
+	EN_LEFT_DOKAN_PAKKUN = 94,
+	EN_UP_DOKAN_FPAKKUN = 95,
+	EN_DOWN_DOKAN_FPAKKUN = 96,
+	EN_RIGHT_DOKAN_FPAKKUN = 97,
+	EN_LEFT_DOKAN_FPAKKUN = 98,
+	EN_JIMEN_PAKKUN = 99,
+	EN_JIMEN_BIG_PAKKUN = 100,
+	EN_JIMEN_FPAKKUN = 101,
+	EN_JIMEN_BIG_FPAKKUN = 102,
+	EN_WALK_PAKKUN = 103,
+	ICEBALL = 104,
+	PL_FIREBALL = 105,
+	PAKKUN_FIREBALL = 106,
+	BROS_FIREBALL = 107,
+	BOOMERANG = 108,
+	EN_HELPOS = 109,
+	EN_FIREBROS = 110,
+	EN_BOOMERANGBROS = 111,
+	EN_HAMMERBROS = 112,
+	EN_ICEBROS = 113,
+	EN_LIFT_HAMMERBROS = 114,
+	HAMMER = 115,
+	EN_HIMANBROS = 116,
+	MEGA_HAMMER = 117,
+	BROS_ICEBALL = 118,
+	EN_BOYON = 119,
+	EN_REMOCON_TORIMOCHI = 120,
+	TAG_WIND = 121,
+	TAG_THUNDER = 122,
+	TAG_WATER = 123,
+	EN_AUTOSCR = 124,
+	OBJ_GRASS = 125,
+	EN_ENV = 126,
+	EN_KILLER = 127,
+	EN_SEARCH_KILLER = 128,
+	EN_MAGNUM_KILLER = 129,
+	EN_SEARCH_MAGNUM_KILLER = 130,
+	EN_BASABASA = 131,
+	WAKI_PARABOM = 132,
+	EN_BOMHEI = 133,
+	EN_PARA_BOMHEI = 134,
+	EN_MECHA_KOOPA = 135,
+	EN_MOUSE = 136,
+	EN_GHOST_JUGEM = 137,
+	DOKAN_WAKIDASHI = 138,
+	EN_CRASHER = 139,
+	AC_WAKILIFT = 140,
+	EN_BIRIKYU = 141,
+	EN_LINE_BIRIKYU = 142,
+	EN_BIRIKYU_MAKER = 143,
+	EN_CHOROBON = 144,
+	EN_SANBO = 145,
+	EN_SANBO_PARTS = 146,
+	EN_SANBO_EL = 147,
+	EN_GURUGURU = 148,
+	EN_GESSO = 149,
+	EN_BARAMAKI_GESSO = 150,
+	EN_GOALPOLE = 151,
+	EN_GESSO_CHILD = 152,
+	BARNAR_MGR = 153,
+	EN_SYNCRO_BARNAR = 154,
+	EN_BARNAR = 155,
+	EN_LARGE_BARNAR = 156,
+	EN_PUKUPUKU_PARENT = 157,
+	AC_TEAM_PUKUPUKU = 158,
+	EN_PUKUPUKU = 159,
+	EN_TOGEPUKU = 160,
+	EN_MIDDLE_PUKU = 161,
+	EN_PUKUCOIN = 162,
+	EN_KARON = 163,
+	EN_BIGKARON = 164,
+	EN_KARON_HEAD = 165,
+	EN_REVERSE = 166,
+	EN_WAKI_JUGEM = 167,
+	EN_WIRE_TURN = 168,
+	EN_BIG_WIRE_TURN = 169,
+	EN_NET_NOKONOKO_LR = 170,
+	EN_NET_NOKONOKO_UD = 171,
+	BIGHANA_MGR = 172,
+	HANA_MOUNTAIN = 173,
+	EN_HANACHAN = 174,
+	EN_BIG_HANACHAN = 175,
+	EN_TERESA = 176,
+	EN_BIG_TERESA = 177,
+	EN_CROW = 178,
+	EN_BIGPILE_UNDER = 179,
+	EN_BIGPILE_UPPER = 180,
+	EN_BIGPILE_RIGHT = 181,
+	EN_BIGPILE_LEFT = 182,
+	EN_SUPER_BIGPILE_RIGHT = 183,
+	EN_SUPER_BIGPILE_LEFT = 184,
+	EN_GOKUBUTO_BIGPILE_UNDER = 185,
+	EN_GOKUBUTO_BIGPILE_UPPER = 186,
+	EN_MORTON_BIGPILE = 187,
+	EN_YAJIRUSHI = 188,
+	EN_WANWAN = 189,
+	EN_WANWAN_PILE = 190,
+	EN_JUMPPUKU = 191,
+	EN_IGAPUKU = 192,
+	EN_WAKI_IGAPUKU = 193,
+	EN_FIRESNAKE = 194,
+	EN_BOSS_KAMECK = 195,
+	EN_SLIP_PENGUIN = 196,
+	WAKI_SLIP_PENGUIN2 = 197,
+	EN_SLIP_PENGUIN2 = 198,
+	SLIP_PENGUIN2_GLASSES = 199,
+	EN_IGA_KURIBO = 200,
+	EN_WATERSTREAM = 201,
+	AWA = 202,
+	DUMMY_DOOR_PARENT = 203,
+	DUMMY_DOOR_CHILD = 204,
+	DUMMY_DOOR = 205,
+	NOBORIBOU_OBAKE = 206,
+	UNTEI_ROPE = 207,
+	REMO_DOOR = 208,
+	REMO_SLIDE_DOOR = 209,
+	BRANCH = 210,
+	BG_CENTER = 211,
+	KAMECK_MAGIC = 212,
+	SINKDOKAN_UP = 213,
+	SINKDOKAN_DOWN = 214,
+	SINKDOKAN_LEFT = 215,
+	SINKDOKAN_RIGHT = 216,
+	FLYDOKAN_UP = 217,
+	FLYDOKAN_DOWN = 218,
+	FLYDOKAN_LEFT = 219,
+	FLYDOKAN_RIGHT = 220,
+	EN_HATENA_BALLOON = 221,
+	EN_ONEWAY_GATE = 222,
+	EN_PATABLOCK = 223,
+	EN_KERONPA = 224,
+	KERONPA_FIRE = 225,
+	AC_NEXTGOTO_BLOCK = 226,
+	EN_BAKUBAKU = 227,
+	EN_DOOR = 228,
+	EN_SWITCHDOOR = 229,
+	EN_OBAKEDOOR = 230,
+	EN_TORIDEDOOR = 231,
+	EN_CASTLEDOOR = 232,
+	EN_KOOPADOOR = 233,
+	AC_REVERSEBLOCK = 234,
+	CHUKAN_POINT = 235,
+	EN_MAX_UE_LEFT = 236,
+	EN_MAX_UE_RIGHT = 237,
+	EN_MAX_UE2_LEFT = 238,
+	EN_MAX_UE2_RIGHT = 239,
+	EN_ZOOM = 240,
+	EN_BOSS_LARRY = 241,
+	EN_BOSS_WENDY = 242,
+	EN_BOSS_IGGY = 243,
+	EN_BOSS_LEMMY = 244,
+	EN_BOSS_MORTON = 245,
+	EN_BOSS_ROY = 246,
+	EN_BOSS_LUDWIG = 247,
+	EN_BOSS_CASTLE_LARRY = 248,
+	EN_BOSS_CASTLE_ROY = 249,
+	EN_BOSS_CASTLE_WENDY = 250,
+	EN_BOSS_CASTLE_IGGY = 251,
+	CASTLE_LEMMY_BALL = 252,
+	EN_BOSS_CASTLE_LEMMY = 253,
+	EN_BOSS_CASTLE_MORTON = 254,
+	OBJ_LUDWIG = 255,
+	EN_BOSS_CASTLE_LUDWIG = 256,
+	EN_BOSS_KOOPA = 257,
+	EN_BOSS_KOOPA_DEMO_KAMECK = 258,
+	EN_BOSS_KOOPA_DEMO_PEACH = 259,
+	AC_WAKI_KOOPA_FIRE = 260,
+	KOOPA_FIRE = 261,
+	LARRY_FIRE = 262,
+	KOKOOPA_RING = 263,
+	KOKOOPA_BALL = 264,
+	KOKOOPA_THREEWAY_BLITZ = 265,
+	LEMMY_BALL = 266,
+	CASTLE_LEMMY_THROW_BALL = 267,
+	OBJ_IGGY_SLED = 268,
+	OBJ_IGGY_WANWAN = 269,
+	OBJ_MORTON = 270,
+	OBJ_ROY = 271,
+	OBJ_LARRY = 272,
+	OBJ_WENDY = 273,
+	AC_BOSS_KOOPA_SCAFFOLD = 274,
+	AC_BOSS_KOOPA_RUBBLE = 275,
+	AC_BOSS_KOOPA_BG_EFFECT = 276,
+	CASTLE_LUDWIG_BLITZ = 277,
+	CASTLE_LUDWIG_BLITZ_MGR = 278,
+	WAKI_KOKOOPA_FIRE = 279,
+	FALL_FIRE = 280,
+	WAKI_FIRE = 281,
+	FIRE_BLITZ = 282,
+	KOKOOPA_SEARCH_FIRE = 283,
+	EN_UNIZOO = 284,
+	EN_UNIRA = 285,
+	EN_KANIBO = 286,
+	EN_KANITAMA = 287,
+	EN_KOPONE = 288,
+	EN_AKOYA = 289,
+	EN_MIDDLE_KURIBO = 290,
+	EN_LARGE_KURIBO = 291,
+	EN_BEANS_KURIBO = 292,
+	AC_STRONGBOX = 293,
+	EN_REMOCON_CANNON = 294,
+	WAKI_TOGETEKKYU = 295,
+	JR_CLOWN_A = 296,
+	JR_CLOWN_B = 297,
+	JR_CLOWN_C = 298,
+	JR_CLOWN_FOR_PLAYER = 299,
+	FLOOR_JR_A = 300,
+	FLOOR_JR_B = 301,
+	FLOOR_JR_C = 302,
+	FLOOR_JR_C_MGR = 303,
+	BOMB_JR_C = 304,
+	EN_BOSS_KOOPA_JR_A = 305,
+	EN_BOSS_KOOPA_JR_B = 306,
+	EN_BOSS_KOOPA_JR_C = 307,
+	JR_FIRE = 308,
+	JR_FLOOR_FIRE = 309,
+	JR_FLOOR_FIRE_MGR = 310,
+	JR_CLOWN_FOR_JR_C_DEMO = 311,
+	KAMECK_FOR_AIRSHIP_DEMO = 312,
+	PEACH_FOR_AIRSHIP_DEMO = 313,
+	KOOPA_SHIP_FOR_AIRSHIP_DEMO = 314,
+	EN_EATCOIN = 315,
+	AC_WAKI_KILLER = 316,
+	WAKI_KERONPA = 317,
+	AC_WAKI_PUKUPUKU = 318,
+	BELT_NEEDLE = 319,
+	INTERMITTENT = 320,
+	MIST_INTERMITTENT = 321,
+	YOGAN_INTERMITTENT = 322,
+	EN_IBARAMUSHI = 323,
+	WAKI_ANKOH = 324,
+	EN_CHOCHIN_ANKOH = 325,
+	EN_MISTMAN = 326,
+	EN_TESTMAN = 327,
+	EN_CLOUD = 328,
+	AC_ITEM_KEY = 329,
+	AC_YOSHI_EGG = 330,
+	EN_WATERPAIPO = 331,
+	EN_WATERPAKKUN = 332,
+	FOO_BALL = 333,
+	MT_HANACHAN = 334,
+	EN_LR_STOP_UP = 335,
+	EN_LR_STOP_DW = 336,
+	EN_ROT_PAKKUN = 337,
+	EN_POLTER = 338,
+	EN_ICICLE = 339,
+	WALLINSECT_MGR = 340,
+	EN_WALLINSECT = 341,
+	EN_LANDBARREL = 342,
+	EN_IWAO = 343,
+	IWAO_ROCK = 344,
+	KAZAN_MGR = 345,
+	KAZAN_ROCK = 346,
+	EN_CANNON_BULLET = 347,
+	EN_CHOROPU = 348,
+	EN_MANHOLE_CHOROPU = 349,
+	CHOROPOO_SHADOW = 350,
+	MINI_GAME_BALLOON = 351,
+	MINI_GAME_BALLOON_STICK = 352,
+	EN_JELLY_FISH = 353,
+	MINI_GAME_WIRE_MESH = 354,
+	MINI_GAME_GUN_BATTERY_MGR = 355,
+	MINI_GAME_GUN_BATTERY_MGR_OBJ = 356,
+	MINI_GAME_WIRE_MESH_MGR = 357,
+	MINI_GAME_WIRE_MESH_MGR_OBJ = 358,
+	PEACH_CASTLE_SEQUENCE_MGR = 359,
+	PEACH_CASTLE_SEQUENCE_MGR_OBJ = 360,
+	PEACH_CASTLE_BLOCK = 361,
+	MINI_GAME_KINOPIO = 362,
+	AC_KANBAN_ARROW = 363,
+	AC_WATER_BUBBLE = 364,
+	EN_BUBBLE_CONTROL = 365,
+	AC_WAKI_WOODBOX = 366,
+	AC_AUTOSCROOL_SWICH = 367,
+	AC_ROTATION_GHOST_PARENT = 368,
+	EN_ROTATION_GHOST = 369,
+	SHIP_WINDOW = 370,
+	EN_MADOPU = 371,
+	SPANA = 372,
+	EN_GABON = 373,
+	GABON_ROCK = 374,
+	MANHOLE = 375,
+	BGM_INTERLOCKING_DUMMY_BLOCK = 376,
+	BGM_INTERLOCKING_DUMMY_BLOCK_MGR = 377,
+	EN_KING_KILLER = 378,
+	EN_WATER_BUBBLE_BULLET = 379,
+	EN_FRUIT = 380,
+	OBJ_SPARKS = 381,
+	OBJ_SNOW = 382,
+	TAG_SCROLL = 383,
+	AC_BLOCK_GROUP = 384,
+	AC_BLOCK_ONEUP = 385,
+	AC_BLOCK_COIN = 386,
+	AC_WAKI_SEARCH_MAGKILLER = 387,
+	EN_TOBIPUKU = 388,
+	AC_WAKI_TOBIPUKU = 389,
+	NEEDLE_FOR_KOOPA_JR_B = 390,
+	TOP_BG_FOR_CASTLE_LUDWIG = 391,
+	MIDDLE_BG_FOR_CASTLE_LUDWIG = 392,
+	BOTTOM_BG_FOR_CASTLE_LUDWIG = 393,
+	MD_ACTOR = 394,
+	MD_CAMERA = 395,
+	EN_CLOUDLT = 396,
+	UNIT_RAIL = 397,
+	UNIT_CHIKUWA = 398,
+	OBJ_SEAWEED = 399,
+	TAG_ENVSOUND = 400,
+	EN_COIN = 401,
+	EN_COIN_JUGEM = 402,
+	EN_COIN_JUMP = 403,
+	EN_COIN_FLOOR = 404,
+	EN_COIN_VOLT = 405,
+	EN_COIN_WIND = 406,
+	EN_BLUE_COIN = 407,
+	EN_COIN_WATER = 408,
+	EN_REDCOIN = 409,
+	EN_GREENCOIN = 410,
+	ICE_ACTOR = 411,
+	AC_LIGHT_BLOCK = 412,
+	AC_PROP_BLOCK = 413,
+	ENEMY_ICE = 414,
+	PLAYER_ICE = 415,
+	SLIDE_BLOCK = 416,
+	POW_BLOCK = 417,
+	BLOCK_TARU = 418,
+	OBJ_CENTER = 419,
+	OBJ_CENTER2 = 420,
+	EN_LIFT_ROTATION_FULL = 421,
+	LIFT_ROTATION_FULL_CHIKA = 422,
+	LIFT_ROTATION_FULL_KINOKO = 423,
+	LIFT_ROTATION_FULL_COLOR = 424,
+	CAGE_BLOCK = 425,
+	LIFT_ZEN_HAMMER = 426,
+	LIFT_ZEN_SUISYA = 427,
+	LIFT_ZEN_KAITEN_KANAAMI = 428,
+	MOUSE_HOLE = 429,
+	KATAMUKIYUKA = 430,
+	LIFT_TORIDE_ROLL = 431,
+	AC_LIFT_RIDE_HMOVE = 432,
+	AC_LIFT_OBJBG_VMOVE = 433,
+	AC_LIFT_OBJBG_HMOVE = 434,
+	AC_LIFT_OBJBG_HMOVE_BIG = 435,
+	EN_OBJ_POL = 436,
+	EN_OBJ_POL_TORIDE = 437,
+	EN_OBJ_POL_NEEDLE_L = 438,
+	EN_OBJ_POL_NEEDLE_R = 439,
+	EN_OBJ_POL_NEEDLE_LR = 440,
+	EN_OBJ_POL_NEEDLE_U = 441,
+	EN_OBJ_POL_NEEDLE_D = 442,
+	EN_OBJ_POL_NEEDLE_UD = 443,
+	LIFT_ZEN_TOGE = 444,
+	LIFT_ZEN_SHIRO_YOGAN = 445,
+	LIFT_ZEN_KAIHEI = 446,
+	LIFT_DOKAN = 447,
+	EN_PAIR_OBJ_PARENT = 448,
+	EN_PAIR_OBJ_CHILD = 449,
+	LIFT_ZEN_SHIRO = 450,
+	EN_PAIR_OBJ_CHILD_TORIDE = 451,
+	WAKI_ICE_ASHIBA = 452,
+	WAKI_ICE_ASHIBA_WATER = 453,
+	ICE_ASHIBA = 454,
+	ICE_ASHIBA_WATER = 455,
+	ICE_ASHIBA_RAIL = 456,
+	AC_LIFT_RIDE_VMOVE = 457,
+	AC_LIFT_SEESAW = 458,
+	AC_LIFT_FALL = 459,
+	AC_LIFT_REMOCON_SEESAW = 460,
+	EN_LIFT_WHEEL = 461,
+	AC_LIFT_BALANCE = 462,
+	AC_LIFT_REMOCON_BALANCE_CLINCH = 463,
+	AC_LIFT_REMOCON_BALANCE = 464,
+	AC_LIFT_REMOCON_XLINE = 465,
+	EN_LIFT_REMOCON_TRPLN = 466,
+	EN_TRPLN_WALL = 467,
+	EN_CHIKUWA_BLOCK = 468,
+	EN_CLIFF_CHIKUWA_BLOCK = 469,
+	EN_KILLER_HOUDAI = 470,
+	EN_MAGNUM_KILLER_HOUDAI = 471,
+	AC_WAKILIFT_STEP = 472,
+	AC_LINE_LIFT = 473,
+	LINE_SPIN_LIFT = 474,
+	PALM_TREE = 475,
+	NICE_BOAT = 476,
+	LINE_KINOKO_BLOCK = 477,
+	LADDER = 478,
+	TARZAN_TSUTA = 479,
+	TARZAN_IVY = 480,
+	EN_LIFT_ROTATION_HALF = 481,
+	LIFT_HURIKO_CENTER = 482,
+	LIFT_HURIKO = 483,
+	AC_LIFT_RIDEMOVE = 484,
+	EN_LIFT_BURANKO = 485,
+	AC_LIFT_WATERWHEEL = 486,
+	EN_RAIL_POLYGON = 487,
+	EN_RAIL_POLY_ICE = 488,
+	EN_RAIL_POLY_PARENT = 489,
+	EN_RAIL_POLY_CHILD = 490,
+	FREEFALL = 491,
+	EN_GURA_ROCK = 492,
+	EN_GURA_YUKA = 493,
+	EN_KAITEN_HOUDAI = 494,
+	EN_REDRING = 495,
+	EN_BARREL = 496,
+	EN_JUMPDAI = 497,
+	EN_BIG_HNSWICH = 498,
+	EN_BIGBLOCK = 499,
+	EN_SNAKEBLOCK = 500,
+	EN_MARUTA = 501,
+	OBJ_KAMECK = 502,
+	AC_LIFT_SPINROTATION = 503,
+	AC_LIFT_SPINROTATION_SYNC = 504,
+	EN_RULETBLOCK = 505,
+	AC_LIFT_SCALES = 506,
+	AC_LIFT_SCALES_STEP = 507,
+	EN_TARZANROPE = 508,
+	AC_LIFT_BOSS_REMOCON_SEESAW = 509,
+	AC_CHENGE_BLOCK = 510,
+	EN_FIXATION_ICICLE = 511,
+	EN_OBJ_HATENA_BLOCK = 512,
+	EN_OBJ_HATENAB_BLOCK = 513,
+	EN_OBJ_RENGA_BLOCK = 514,
+	EN_OBJ_CLEAR_BLOCK = 515,
+	AC_OBJ_CLEAR_BLOCK = 516,
+	EN_HATENA_BLOCK_LINE = 517,
+	EN_RENGA_BLOCK_LINE = 518,
+	EN_BLOCK_HATENA_WATER = 519,
+	EN_BLOCK_SOROBAN = 520,
+	EN_BLOCK_STAFFROLL = 521,
+	ELASTIC_KINOKO_PARENT = 522,
+	ELASTIC_KINOKO = 523,
+	EN_WHITE_BLOCK = 524,
+	MANTA_MGR = 525,
+	MANTA_MGR2 = 526,
+	MANTA = 527,
+	AC_LIFT_SLIDE_KINOKO = 528,
+	EN_ROTATION_BLOCK = 529,
+	EN_COIN_ANGLE = 530,
+	ROT_DOKAN = 531,
+	EN_BLOCK_HATENA_ANGLE = 532,
+	EN_BLOCK_RENGA_ANGLE = 533,
+	AC_WIRE_CIRCLE = 534,
+	AC_WIRE_REMOCON = 535,
+	AC_LIFT_ICE_SPRING = 536,
+	ICELUMP = 537,
+	ICECUBE = 538,
+	EN_WOODBOX = 539,
+	EN_PATAMET = 540,
+	EN_BIG_PATAMET = 541,
+	NUT = 542,
+	EN_BIG_MET = 543,
+	EN_GAKE_NOKO = 544,
+	AC_DOKAN_CANNON = 545,
+	AC_SHIP_CANNON = 546,
+	AC_ROT_CANNON = 547,
+	AC_ROT_DOKAN_CANNON = 548,
+	ROT_BARNAR = 549,
+	CIRCLE_RIGHT = 550,
+	BLOCK_LIGHT = 551,
+	HAND_RIGHT = 552,
+	EN_BIG_ICICLE = 553,
+	AC_WATER_BUBBLE_PARENT = 554,
+	AC_WATER_BUBBLE_CANNON = 555,
+	EN_KILLER_HOUDAI_SLIDE = 556,
+	EN_BLACK_PAKKUN = 557,
+	TORCHILIGHT = 558,
+	EN_BLOCK_CLOUD = 559,
+	AC_WIRE_MOVE = 560,
+	OBJ_FRUITTREE = 561,
+	EN_BOUNCE_BALL = 562,
+	EN_BLOCK_HATENA_PLAYER = 563,
+	EN_BLOCK_RENGA_PLAYER = 564,
+	AC_FREEZER = 565,
+	AC_WIRE_FOOTHOLD = 566,
+	EN_ITEM_IVY = 567,
+	TARZAN_ROPE = 568,
+	CANNON_PIPE = 569,
+	KINOKO_LIFT_PARENT = 570,
+	KINOKO_LIFT = 571,
+	OBJ_SPIN_PARENT = 572,
+	OBJ_SPIN_CHILD = 573,
+	OBJ_SPIN_ASHIBA = 574,
+	SPIN_WIRE = 575,
+	WARP_CANNON = 576,
+	OBJ_KINOKO = 577,
+	ZOOM_PIPE = 578,
+	ZOOM_PIPE_DOWN = 579,
+	OBJ_PIPE_UP = 580,
+	OBJ_PIPE_UP_NG = 581,
+	OBJ_PIPE_DOWN = 582,
+	OBJ_PIPE_RIGHT = 583,
+	OBJ_PIPE_LEFT = 584,
+	LIFT_DOWN_ON = 585,
+	OBJ_MOVE_ON_GHOST = 586,
+	LIFT_DOWN_ON_NORMAL = 587,
+	LIFT_RIDE_OFF = 588,
+	LINE_TRAIN = 589,
+	REMO_LINE_LIFT = 590,
+	WATER_LIFT = 591,
+	AC_NICE_COIN = 592,
+	AC_NICE_COIN_REGULAR = 593,
+	EN_BLOCK_HELP = 594,
+	FAR_BG = 595,
+	AC_BG_WATER = 596,
+	AC_BG_LAVA = 597,
+	AC_BG_POISON = 598,
+	AC_BG_SAND = 599,
+	AC_BG_CLOUD = 600,
+	AC_BG_MOYA = 601,
+	AC_WATERALL_RAIL = 602,
+	EN_BLUR = 603,
+	MASK = 604,
+	DTEST = 605,
+	AC_WATER_MOVE = 606,
+	AC_WATER_MOVE_REGULAR = 607,
+	AC_WATER_XINFINITE_MOVE = 608,
+	AC_FLOOR_GYRATION = 609,
+	AC_FLOOR_HOLE_DOKAN = 610,
+	AC_FLOOR_DOKAN_EIGHT = 611,
+	AC_GEAR_GYRATION = 612,
+	AC_SHIP_GEAR = 613,
+	AC_BIGSHELL = 614,
+	EN_BOSS_KOOPA_DEMO_CAGE = 615,
+	AC_STAND = 616,
+	AC_HOUSE_LIGHT = 617,
+	AC_LIGHT_WATER = 618,
+	AC_COPYRIGHT = 619,
+	WII_STRAP = 620,
+	WM_CS_SEQ_MNG = 621,
+	WORLD_CAMERA = 622,
+	WM_MAP = 623,
+	WM_IBARA = 624,
+	WM_ANTLION_MNG = 625,
+	WM_CASTLE = 626,
+	WM_TOWER = 627,
+	WM_PEACH_CASTLE = 628,
+	WM_KILLER = 629,
+	WM_KILLERBULLET = 630,
+	WM_SINKSHIP = 631,
+	WM_SWITCH = 632,
+	WM_START = 633,
+	WM_KINOKO_BASE = 634,
+	WM_KINOKO_RED = 635,
+	WM_KINOKO_1UP = 636,
+	WM_KINOKO_STAR = 637,
+	WM_COURSE = 638,
+	WM_STOP = 639,
+	WM_TORIDE = 640,
+	WM_GHOST = 641,
+	WM_DOKAN = 642,
+	WM_CANNON = 643,
+	WM_KOOPASHIP = 644,
+	WM_BOSS_BASE = 645,
+	WM_BOSS_LARRY = 646,
+	WM_BOSS_ROY = 647,
+	WM_BOSS_WENDY = 648,
+	WM_BOSS_IGGY = 649,
+	WM_BOSS_LEMMY = 650,
+	WM_BOSS_MORTON = 651,
+	WM_BOSS_LUDWIG = 652,
+	WM_BOSS_KAMECK = 653,
+	WM_ANTLION = 654,
+	WM_KURIBO = 655,
+	WM_PUKU = 656,
+	WM_PAKKUN = 657,
+	WM_BROS = 658,
+	WM_JUGEM = 659,
+	WM_PLAYER = 660,
+	WM_SUBPLAYER = 661,
+	WM_NOTE = 662,
+	WM_TREASURESHIP = 663,
+	WM_DIRECTOR = 664,
+	WM_GRID = 665,
+	WM_ISLAND = 666,
+	WM_ITEM = 667,
+	WM_CS_W3_PALM = 668,
+	WM_SURRENDER = 669,
+	WM_KOOPA_CASTLE = 670,
+	WM_ANCHOR = 671,
+	WM_PAKKUNHEAD = 672,
+	WM_CLOUD = 673,
+	WM_SMALLCLOUD = 674,
+	WM_KOOPAJR = 675,
+	WM_PEACH = 676,
+	WM_BOARD = 677,
+	WM_BUBBLE = 678,
+	WM_KINOBALLOON = 679,
+	WM_SANDPILLAR = 680,
+	WM_YOGANPILLAR = 681,
+	WM_KINOPIO = 682,
+	WM_DANCE_PAKKUN = 683,
+	WM_DOKANROUTE = 684,
+	WM_HANACHAN = 685,
+	WM_TOGEZO = 686,
+	WM_MANTA = 687,
+	WM_TERESA = 688,
+	WORLD_SELECT = 689,
+	WORLD_SELECT_GUIDE = 690,
+	COLLECTION_COIN_BASE = 691,
+	COLLECTION_COIN = 692,
+	COURSE_SELECT_MENU = 693,
+	NUMBER_OF_PEOPLE_CHANGE = 694,
+	STOCK_ITEM = 695,
+	STOCK_ITEM_SHADOW = 696,
+	EASY_PAIRING = 697,
+	WM_2D_PLAYER = 698,
+	EVENT_OPENING_TITLE = 699,
+	SELECT_PLAYER = 700,
+	MULTI_COURSE_SELECT = 701,
+	TIME_UP = 702,
+	COURSE_TIME_UP = 703,
+	YES_NO_WINDOW = 704,
+	COURSE_SELECT_MANAGER = 705,
+	FUKIDASHI_MANAGER = 706,
+	SMALL_SCORE_MANAGER = 707,
+	GAMEDISPLAY = 708,
+	OTASUKE_INFO = 709,
+	PAUSEWINDOW = 710,
+	RESULT = 711,
+	POINT_RESULT_MULTI = 712,
+	POINT_RESULT_DATE_FILE = 713,
+	POINT_RESULT_DATE_FILE_FREE = 714,
+	GOAL_MANAGER = 715,
+	COURSE_CLEAR = 716,
+	OTEHON_CLEAR = 717,
+	INFO_WINDOW = 718,
+	SELECT_CURSOR = 719,
+	WARNING_MANAGER = 720,
+	SEQUENCE_BG = 721,
+	GAME_OVER = 722,
+	MODE_SELECT = 723,
+	DATE_FILE = 724,
+	FILE_SELECT = 725,
+	CONTINUE = 726,
+	MINI_GAME_CANNON = 727,
+	MINI_GAME_WIRE = 728,
+	MODEL_PLAY_MANAGER = 729,
+	MODEL_PLAY_BASE = 730,
+	MODEL_PLAY_DATE = 731,
+	MODEL_PLAY_ARROW = 732,
+	MODEL_PLAY_GUIDE = 733,
+	MESSAGE_WINDOW = 734,
+	CHARACTER_CHANGE_SELECT_BASE = 735,
+	CHARACTER_CHANGE_SELECT_CONTENTS = 736,
+	CHARACTER_CHANGE_SELECT_ARROW = 737,
+	CHARACTER_CHANGE_INDICATOR = 738,
+	MULTI_COURSE_SELECT_CONTENTS = 739,
+	COLLECTION_COIN_DATE = 740,
+	CONTROLLER_INFORMATION = 741,
+	DRAW_GAME = 742,
+	STAFF_CREDIT_SCORE = 743,
+	THE_END = 744,
+	DEMO_MESSAGE = 745,
+	LETTER_WINDOW = 746,
+	DUMMY_ACTOR = 747,
+	LASTACTOR_STAGE = 748,
+	LASTACTOR = 749
+};
+
+struct Actor {
+	int field_0x00;
+	unsigned int settings;
+	short type;
+	int field_0x0A;
+	char field_0x0E;
+	char field_0x0F;
+	tree_node node;
+	int field_0x24;
+	int field_0x28;
+	void *field_0x2C;
+	short field_0x30;
+	short field_0x32;
+	int field_0x34;
+	int field_0x38;
+	void *field_0x3C;
+	short field_0x40;
+	short field_0x42;
+	int field_0x44;
+	int field_0x48;
+	void *field_0x4C;
+	int field_0x50;
+	int field_0x54;
+	int field_0x58;
+	void *vtable;
+	int field_0x64;
+	int field_0x68;
+	char *class_name;
+	int field_0x70;
+	int field_0x74;
+	void *field_0x78;
+	int field_0x7C;
+	int field_0x80;
+	int field_0x84;
+	int field_0x88;
+	int field_0x8C;
+	int field_0x90;
+	int field_0x94;
+	int field_0x98;
+	int field_0x9C;
+	int field_0xA0;
+	int field_0xA4;
+	int field_0xA8;
+	VEC3 position;
+	// more goes here eventually...
+};
+
+Actor *CreateActor(Actors type, u32 settings, VEC3 *pos, void *rot, char layer);
+Actor *GetActorParent(Actor *ac);
+char *GetActorName(Actors type);
+
+Actor *FindActorByID(int id);
+Actor *FindActorByType(Actors type, Actor *startFrom);
+
+#endif
diff --git a/include/common.h b/include/common.h
new file mode 100755
index 0000000..b8bce80
--- /dev/null
+++ b/include/common.h
@@ -0,0 +1,107 @@
+#ifndef __KAMEK_COMMON_H
+#define __KAMEK_COMMON_H
+
+
+#define GEKKO
+
+/* Common Number Types */
+typedef signed long long s64;
+typedef signed int s32;
+typedef signed short s16;
+typedef signed char s8;
+
+typedef unsigned long long u64;
+typedef unsigned int u32;
+typedef unsigned short u16;
+typedef unsigned char u8;
+
+typedef float f32;
+typedef double f64;
+
+typedef unsigned long ulong;
+typedef unsigned int uint;
+typedef unsigned short ushort;
+typedef unsigned char uchar;
+
+typedef char* Ptr; // DUMB
+
+typedef int BOOL;
+#define TRUE 1
+#define FALSE 0
+
+#define NULL 0
+
+/* Structures */
+typedef f32 Mtx[3][4];
+typedef f32 (*MtxPtr)[4];
+typedef f32 Mtx44[4][4];
+typedef f32 (*Mtx44Ptr)[4];
+typedef f32 ROMtx[4][3];
+typedef f32 (*ROMtxPtr)[3];
+
+typedef struct { f32 x, y; } VEC2, Vec2, *Vec2Ptr, Point2d, *Point2dPtr;
+typedef struct { f32 x, y, z; } VEC3, 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;
+
+#include "rvl/mtx.h"
+
+
+inline void *operator new(unsigned long size, void *ptr) { return ptr; }
+
+
+
+struct tree_node {
+	tree_node *parent, *child, *prev_sibling, *next_sibling;
+	void *obj;
+};
+
+/* Virtual Function Helpers */
+//#define VF_BEGIN(type, obj, id, vtable_offset) \
+//	{ type __VFUNC = (((u32)(obj))+(vtable_offset));
+#define VF_BEGIN(type, obj, id, vtable_offset) \
+	{ type __VFUNC = ((type*)(*((void**)(((u32)(obj))+(vtable_offset)))))[(id)];
+
+#define VF_CALL __VFUNC
+
+#define VF_END }
+
+
+
+
+/* Common Functions */
+
+void OSReport(const char *format, ...);
+int sprintf(char *buffer, const char *format, ...);
+int snprintf(char *buffer, int buff_size, const char *format, ...);
+char *strcat(const char *destination, const char *source);
+void *memset(void *ptr, int value, unsigned int num);
+
+void *AllocFromGameHeap1(u32 size);
+void FreeFromGameHeap1(void *block);
+
+/* Archive */
+/*#ifdef REGION_PAL
+	#define ARC_TABLE ((*((void**)0x8042A318))+4)
+	#define RAW_ARC_TABLE (*((void**)0x8042A318))
+#endif
+
+#ifdef REGION_NTSC
+	#define ARC_TABLE ((*((void**)0x8042A038))+4)
+	#define RAW_ARC_TABLE (*((void**)0x8042A038))
+#endif
+
+char *RetrieveFileFromArc(void *table, char *name, char *path);
+char *RetrieveFileFromArcAlt(void *table, char *name, char *path);*/
+
+extern void *ArchiveHeap; // PAL 0x8042A72C, NTSC 0x8042A44C
+
+
+#ifdef __MWERKS__
+	#define InfiniteLoop for (;;) { asm { nop } }
+#else
+	#define InfiniteLoop for (;;) { asm("nop"); }
+#endif
+
+
+#endif
diff --git a/include/course.h b/include/course.h
new file mode 100755
index 0000000..6fa0f55
--- /dev/null
+++ b/include/course.h
@@ -0,0 +1,168 @@
+#ifndef __KAMEK_COURSE_H
+#define __KAMEK_COURSE_H
+
+#include <common.h>
+
+struct BGDatObject_t {
+	s16 objType;
+	s16 x;
+	s16 y;
+	s16 width;
+	s16 height;
+};
+
+struct Block1 {
+	char tileset0[32];
+	char tileset1[32];
+	char tileset2[32];
+	char tileset3[32];
+};
+
+#define COURSE_FLAG_WRAP 1
+
+struct Block2 {
+	u64 defaultEvents;
+	s16 courseFlags;
+	s16 timeLimit;
+	u8 unk1;
+	u8 unk2;
+	u8 unk3;
+	u8 unk4;
+	u8 startEntrance;
+	u8 unk5;
+	u8 unk6;
+	u8 unk7;
+};
+
+struct Block3 {
+	s32 yBoundNormalTop;
+	s32 yBoundNormalBottom;
+	s32 yBoundSpecialTop;
+	s32 yBoundSpecialBottom;
+	u16 entryID;
+	u16 lockToBottom;
+	u32 unknown;
+};
+
+struct Block4 {
+	u16 unk1;
+	u16 unk2;
+	u16 unk3;
+	u16 unk4;
+};
+
+struct BGSettings {
+	u16 entryID;
+	u16 xScrollRate;
+	u16 yScrollRate;
+	u16 yPosOffset;
+	u16 xPosOffset;
+	u16 fileID1;
+	u16 fileID2;
+	u16 fileID3;
+	u16 unk1;
+	u16 scale;
+	u32 unk2;
+};
+
+#define ENTRANCE_FLAG_NO_ENTRY 0x80
+#define ENTRANCE_FLAG_CONNECTED_PIPE 8
+#define ENTRANCE_FLAG_LINK_TO_FORWARD 4
+#define ENTRANCE_FLAG_CONNECTED_REVERSE 1
+
+struct Block7 {
+	s16 xPos;
+	s16 yPos;
+	s16 cameraXPos;
+	s16 cameraYPos;
+	u8 entryID;
+	u8 destArea;
+	u8 destEntrance;
+	u8 type;
+	u8 unk1;
+	u8 zoneID;
+	u8 layerID;
+	u8 pathID;
+	u16 flags;
+	u16 unk2;
+};
+
+struct Block8 {
+	u16 type;
+	s16 xPos;
+	s16 yPos;
+	u16 eventIDs;
+	u32 settings;
+	u8 zoneID;
+	u8 layerID;
+	u16 unused;
+};
+
+struct Block9 {
+	u16 type;
+	u16 unused;
+};
+
+struct Block10 {
+	s16 xPos;
+	s16 yPos;
+	s16 xSize;
+	s16 ySize;
+	s16 objShading;
+	s16 bgShading;
+	u8 zoneID;
+	u8 boundingID;
+	u8 scrollMode;
+	u8 zoomMode;
+	u8 unk1;
+	u8 lightMode;
+	u8 fgID;
+	u8 bgID;
+	u8 unk2;
+	u8 unk3;
+	u8 music;
+	u8 audioModifier;
+};
+
+struct Block11 {
+	s16 xPos;
+	s16 yPos;
+	s16 xSize;
+	s16 ySize;
+	u8 entryID;
+	u8 unused[3];
+};
+
+struct Block12 {
+	u32 unk1;
+	u32 unk2;
+	u32 unk3;
+	u8 unk4;
+	u8 scrollMode;
+	u8 zoomMode;
+	u8 unk5;
+	u16 unk6;
+	u8 eventID;
+	u8 unk7;
+};
+
+#define PATH_FLAG_LOOP 2
+
+struct Block13 {
+	u8 pathID;
+	u8 unknown;
+	u16 startNode;
+	u16 nodeCount;
+	u16 flags;
+};
+
+struct Block14 {
+	u16 xPos;
+	u16 yPos;
+	float speed;
+	float accel;
+	short unk1;
+	short unk2;
+};
+
+#endif
diff --git a/include/event.h b/include/event.h
new file mode 100755
index 0000000..c0c1c99
--- /dev/null
+++ b/include/event.h
@@ -0,0 +1,16 @@
+#ifndef __KAMEK_EVENT_H
+#define __KAMEK_EVENT_H
+
+#include <common.h>
+
+#ifdef REGION_PAL
+	#define EVENT_TABLE (*((void**)0x8042A358))
+#endif
+
+#ifdef REGION_NTSC
+	// ...
+#endif
+
+void TriggerEventFlag(void *eventstruct, u8 event, u8 delay, u8 method, s32 unk3, u8 expiry, s32 unk5);
+
+#endif
diff --git a/include/g3dhax.h b/include/g3dhax.h
new file mode 100644
index 0000000..c3aeaef
--- /dev/null
+++ b/include/g3dhax.h
@@ -0,0 +1,168 @@
+// nw4r::g3d wrapper
+
+namespace nw4r {
+namespace g3d {
+
+class ResName {
+public:
+	const char *name;
+
+	ResName(const char *p = NULL) {
+		name = p;
+	}
+};
+
+class ResFile {
+public:
+	void * /*ResFileData*/ data;
+
+	ResFile(void *p = NULL) {
+		data = p;
+	}
+
+	void Init();
+	bool CheckRevision() const;
+
+	void * /*ResMdl*/ GetResMdl(const char *str) const;
+	void * /*ResPltt*/ GetResPltt(const ResName n) const;
+	void * /*ResTex*/ GetResTex(const char *str) const;
+	void * /*ResTex*/ GetResTex(const ResName n) const;
+	void * /*ResTex*/ GetResTex(u32 idx) const;
+	void * /*ResAnmChr*/ GetResAnmChr(const char *str) const;
+	void * /*ResAnmVis*/ GetResAnmVis(const char *str) const;
+	void * /*ResAnmClr*/ GetResAnmClr(const char *str) const;
+	void * /*ResAnmTexPat*/ GetResAnmTexPat(const char *str) const;
+	void * /*ResAnmTexSrt*/ GetResAnmTexSrt(const char *str) const;
+	void * /*ResAnmScn*/ GetResAnmScn(const char *str) const;
+
+	bool Bind(ResFile rhs);
+};
+
+void *__ScnMdlSimple__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResMdl*/ mdl,
+	int nView = 1);
+
+
+void *__ScnMdl__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResMdl*/ mdl,
+	u32 bufferOption,
+	int nView = 1);
+
+
+void *__AnmObjChrRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmChr*/ resAnm,
+	void * /*ResMdl*/ resMdl,
+	bool bHasCache);
+
+
+void *__AnmObjVisRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmVis*/ resAnm,
+	void * /*ResMdl*/ resMdl);
+
+
+void *__AnmObjTexPatRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmTexPat*/ resAnm,
+	void * /*ResMdl*/ resMdl,
+	bool bHasCache);
+
+
+void *__AnmObjTexSrtRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmTexSrt*/ resAnm,
+	void * /*ResMdl*/ resMdl,
+	bool bHasCache);
+
+
+void *__AnmObjMatClrRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmMatClr*/ resAnm,
+	void * /*ResMdl*/ resMdl,
+	bool bHasCache);
+
+
+void *__AnmObjShpRes__Construct(
+	void * /*MEMAllocator*/ pHeap,
+	u32 *pSize,
+	void * /*ResAnmShp*/ resAnm,
+	void * /*ResMdl*/ resMdl,
+	bool bHasCache);
+
+
+
+bool InsertIntoScene(void *scnObj); // 80164F90
+
+extern void *g3dMemAllocator; // 8042A6A8
+
+inline void *ConstructScnMdlSimple(void *mdl, int nView = 1) {
+	return __ScnMdlSimple__Construct(g3dMemAllocator, 0, mdl, nView);
+}
+
+inline void *ConstructScnMdl(void *mdl, u32 bufferOption, int nView = 1) {
+	return __ScnMdl__Construct(g3dMemAllocator, 0, mdl, bufferOption, nView);
+}
+
+
+
+}
+}
+
+
+class mHeapAllocator_c { // Actually that weird subclass. INCOMPLETE!!
+public:
+	char data1[0x10];
+
+	mHeapAllocator_c();
+	virtual ~mHeapAllocator_c();
+	virtual void *alloc(u32 size);
+	virtual void free(void *block);
+
+	bool link(s32 size, void *heap, const char *name, int align);
+	u32 unlink();
+
+	char data2[8];
+};
+
+namespace m3d {
+
+	class mdl_c {
+	public:
+		mdl_c();
+		virtual ~mdl_c();
+
+		virtual void _vf0C();
+		virtual void _vf10();
+		virtual bool scheduleForDrawing();
+		virtual void bindAnim(void *anim, float boo);
+		virtual void _vf1C();
+
+		bool setup(void *model, void *allocator, u32 bufferOption, int nView, u32 *size);
+		void oneSetupType();
+		void sub_80064BF0();
+
+		void setDrawMatrix(const Mtx matrix);
+
+		char data[0x3C];
+	};
+};
+
+
+
+void SetupTextures_Player(m3d::mdl_c *model, int sceneID); // 800B3E50
+void SetupTextures_Map(m3d::mdl_c *model, int sceneID); // 800B3F50
+void SetupTextures_Boss(m3d::mdl_c *model, int sceneID); // 800B4050
+void SetupTextures_Enemy(m3d::mdl_c *model, int sceneID); // 800B4170
+void SetupTextures_MapObj(m3d::mdl_c *model, int sceneID); // 800B42B0
+void SetupTextures_Item(m3d::mdl_c *model, int sceneID); // 800B43D0
+
diff --git a/include/game.h b/include/game.h
new file mode 100755
index 0000000..cb567f3
--- /dev/null
+++ b/include/game.h
@@ -0,0 +1,1102 @@
+#ifndef __KAMEK_GAME_H
+#define __KAMEK_GAME_H
+
+#include <common.h>
+#include <rvl/mtx.h>
+#include <rvl/GXEnum.h>
+#include <rvl/vifuncs.h>
+
+
+extern "C" {
+int strlen(const char *str);
+
+float atan(float x);
+float atan2(float y, float x);
+
+float cos(float x);
+float sin(float x);
+}
+
+bool DVD_Start();
+bool DVD_End();
+bool DVD_StillLoading(void *dvdclass2);
+void DVD_LoadFile(void *dvdclass, char *folder, char *file, void *callbackData);
+void DVD_FreeFile(void *dvdclass2, char *file);
+
+extern void *DVDClass;
+
+inline void *GetDVDClass() {
+	return DVDClass;
+}
+
+inline void *GetDVDClass2() {
+	return (void*)(((u32)GetDVDClass())+4);
+}
+
+void *DVD_GetFile(void *dvdclass2, const char *arc, const char *file);
+
+
+extern int Player_Active[4];
+extern int Player_ID[4];
+extern int Player_Powerup[4];
+extern int Player_Flags[4];
+extern int Player_Lives[4];
+extern int Player_Coins[4];
+
+struct StartLevelInfo {
+	int maybeUnused;
+	unsigned char unk1; // 0x04
+	unsigned char unk2; // 0x05
+	unsigned char unk3; // 0x06
+	unsigned char unk4; // 0x07
+	unsigned int purpose; // 0x08
+	unsigned char world1; // 0x0C
+	unsigned char level1; // 0x0D
+	unsigned char world2; // 0x0E
+	unsigned char level2; // 0x0F
+};
+
+extern void *GameMgr;
+inline void *GetGameMgr() {
+	return GameMgr;
+}
+
+bool QueryPlayerAvailability(int id);
+void DoStartLevel(void *gameMgr, StartLevelInfo *sl);
+void SetSomeConditionShit(int world, int level, unsigned int bits);
+
+bool IsWideScreen();
+
+#define GAMEMGR_GET_AFC(gmgr) (*((bool*)(((u32)(gmgr))+0xAFC)))
+
+
+#define COND_COIN1 1
+#define COND_COIN2 2
+#define COND_COIN3 4
+#define COND_NORMAL 0x10
+#define COND_SECRET 0x20
+#define COND_SGNORMAL 0x80
+#define COND_SGSECRET 0x100
+
+class SaveFirstBlock {
+public:
+	char titleID[4];			// 0x00
+	u8 field_00;				// 0x04
+	u8 field_01;				// 0x05
+	u8 current_file;			// 0x06
+	u8 field_03;				// 0x07
+	u16 freemode_fav[10][0x2A];	// 0x08
+	u16 coinbtl_fav[10][0x2A];	// 0x350
+	u16 bitfield;				// 0x698
+	u16 field_69A;				// 0x69A
+	u32 checksum;				// 0x69C
+};
+
+class SaveBlock {
+public:
+	u8 field_00;				// 0x00
+	u8 field_01;				// 0x01
+	u8 bitfield;				// 0x02
+	u8 current_world;			// 0x03
+	u8 field_04;				// 0x04
+	u8 current_path_node;		// 0x05
+	u8 field_06;				// 0x06
+	u8 switch_on;				// 0x07
+	u8 field_08;				// 0x08
+	u8 powerups_available[7];	// 0x09
+	u8 toad_level_idx[10];		// 0x10
+	u8 player_continues[4];		// 0x1A
+	u8 player_coins[4];			// 0x1E
+	u8 player_lives[4];			// 0x22
+	u8 player_flags[4];			// 0x26
+	u8 player_type[4];			// 0x2A
+	u8 player_powerup[4];		// 0x2E
+	u8 worlds_available[10];	// 0x32
+	u32 ambush_countdown[10];	// 0x3C
+	u16 field_64;				// 0x64
+	u16 credits_hiscore;		// 0x66
+	u16 score;					// 0x68
+	u32 completions[10][0x2A];	// 0x6C
+	u8 hint_movie_bought[70];	// 0x6FC
+	u8 toad_location[10];		// 0x742
+	u8 field_74C[10][4];		// 0x74C
+	u8 field_774[10][4];		// 0x774
+	u8 field_79C[10][4];		// 0x79C
+	u8 death_counts[10][0x2A];	// 0x7C4
+	u8 death_count_3_4_switch;	// 0x968
+	u8 pad[0x13];				// 0x969
+	u32 checksum;				// 0x97C
+
+	u32 GetLevelCondition(int world, int level);
+	bool CheckLevelCondition(int world, int level, int cond);
+	bool CheckIfCoinCollected(int world, int level, int num);
+};
+
+class SaveFile {
+public:
+	u32 field_00;
+	u32 field_04;
+	u32 field_08;
+	u32 field_0C;
+	u32 field_10;
+	u32 field_14;
+	u32 field_18;
+	u32 field_1C;
+
+	// Real Savefile starts here
+	SaveFirstBlock header;
+	SaveBlock blocks[3];
+	SaveBlock quickSave[3];
+
+	SaveBlock *GetBlock(int id);
+	SaveBlock *GetQSBlock(int id);
+
+	bool CheckIfWriting(); // 0x800E0540
+};
+
+class SaveHandler {
+public:
+	u8 unknown[0x70];
+	u32 CurrentState;
+	u32 CurrentError;
+	u32 field_7C;
+};
+
+extern SaveFile *SaveFileInstance;
+extern SaveHandler *SaveHandlerInstance;
+
+inline SaveFile *GetSaveFile() {
+	return SaveFileInstance;
+}
+
+inline SaveHandler *GetSaveHandler() {
+	return SaveHandlerInstance;
+}
+
+#define WPAD_DOWN	0x0001 // Actually Left, but rotated
+#define WPAD_UP		0x0002 // Actually Right, but rotated
+#define WPAD_RIGHT	0x0004 // Actually Down, but rotated
+#define WPAD_LEFT	0x0008 // Actually Up, but rotated
+#define WPAD_PLUS	0x0010
+#define WPAD_TWO	0x0100
+#define WPAD_ONE	0x0200
+#define WPAD_B		0x0400
+#define WPAD_A		0x0800
+#define WPAD_MINUS	0x1000
+#define WPAD_HOME	0x8000
+
+struct RemoconMngClass {
+	void *vtable;
+	void *controllers[4];
+};
+
+/*
+ * Ok, here's how the remocon/wiimote shit works:
+ * Remocon is a NSMB-specific class, it handles the different control methods
+ * and D-pad directions and such automatically.
+ *
+ * Wiimote is a generic class (part of EGG) -- well it's not actually called
+ * that, but who cares. It handles different types of controllers. Only
+ * query it if whatever you're accessing is control type dependent.
+ */
+
+extern RemoconMngClass *RemoconMng;
+extern int ActiveWiimoteID;
+extern void *ActiveWiimote;
+
+inline RemoconMngClass *GetRemoconMng() {
+	return RemoconMng;
+}
+
+inline int GetActiveWiimoteID() {
+	return ActiveWiimoteID;
+}
+
+inline void *GetActiveRemocon() {
+	return GetRemoconMng()->controllers[GetActiveWiimoteID()];
+}
+
+inline void *GetActiveWiimote() {
+	return ActiveWiimote;
+}
+
+inline unsigned int Remocon_GetButtons(void *self) {
+	return *((unsigned int*)((u32)self+0x18));
+}
+
+inline unsigned int Remocon_GetPressed(void *self) {
+	return *((unsigned int*)((u32)self+0x1C));
+}
+
+typedef bool (*__Wiimote_TestButtons_type)(void*, unsigned int);
+inline bool Wiimote_TestButtons(void *self, unsigned int btns) {
+	VF_BEGIN(__Wiimote_TestButtons_type, self, 8, 0)
+		return VF_CALL(self, btns);
+	VF_END;
+}
+
+int SearchForIndexOfPlayerID(int id);
+
+bool CheckIfContinueShouldBeActivated();
+
+bool CheckIfMenuShouldBeCancelledForSpecifiedWiimote(int num);
+
+void StartTitleScreenStage(bool realDemo, int sceneParam);
+
+bool CheckIfWeCantDoStuff();
+
+u32 QueryGlobal5758(u32 check);
+
+void SaveGame(void *classDoesntMatter, bool isQuick);
+
+#include <actors.h>
+void *CreateParentedObject(short classID, void *parent, int settings, char something);
+void *CreateChildObject(short classID, void *parent, int settings, int unk1, int unk2);
+
+
+#define WIPE_FADE 0
+#define WIPE_CIRCLE 1
+#define WIPE_BOWSER 2
+#define WIPE_WAVY 3
+#define WIPE_MARIO 4
+#define WIPE_CIRCLE_s 5
+
+void ActivateWipe(int type);
+
+typedef void (*ScreenDrawFunc)();
+
+extern ScreenDrawFunc *CurrentDrawFunc;
+void WorldMapDrawFunc();
+void GameSetupDrawFunc();
+
+void GameSetup__LoadScene(void *self); // 0x80919560
+void FreeScene(int id);
+
+void WpadShit(int unk); // 0x8016F780
+
+void *BgTexMng__LoadAnimTile(void *self, int tileset, short tile, char *name, char *delays, char reverse); // 0x80087B60
+
+extern void *GameHeaps[];
+
+
+
+namespace nw4r {
+
+namespace ut {
+	// this isn't 100% accurate because it doesn't use templates
+	// or detail::LinkListImpl, but oh well
+	// I don't need the methods anyway.
+
+	class LinkListNode {
+		LinkListNode *next;
+		LinkListNode *prev;
+	};
+
+	class LinkList {
+		int count;
+		LinkListNode initialNode;
+	};
+
+	class Color : public GXColor { };
+
+	class Rect {
+		f32 left;
+		f32 top;
+		f32 right;
+		f32 bottom;
+	};
+
+	template <class T>
+	class TagProcessorBase { };
+}
+
+namespace lyt {
+	class Pane; // forward declaration
+	class DrawInfo;
+
+	class AnimTransform; // I'll do these later
+	class AnimResource;
+	class AnimationLink;
+	class ResourceAccessor;
+	class GroupContainer;
+
+	class Layout {
+	public:
+		Layout();
+		virtual ~Layout();
+
+		virtual bool Build(const void *data, ResourceAccessor *resAcc);
+
+		virtual AnimTransform *CreateAnimTransform();
+		virtual AnimTransform *CreateAnimTransform(const void *data, ResourceAccessor *resAcc);
+		virtual AnimTransform *CreateAnimTransform(const AnimResource &res, ResourceAccessor *resAcc);
+
+		virtual void BindAnimation(AnimTransform *anim);
+		virtual void UnbindAnimation(AnimTransform *anim);
+		virtual void UnbindAllAnimation();
+		virtual bool BindAnimationAuto(const AnimResource &res, ResourceAccessor *resAcc);
+
+		virtual void SetAnimationEnable(AnimTransform *anim, bool unk);
+
+		virtual void CalculateMtx(const DrawInfo &info);
+
+		virtual void/*?*/ Draw(const DrawInfo &info);
+		virtual void/*?*/ Animate(ulong flag);
+
+		virtual void/*?*/ SetTagProcessor(ut::TagProcessorBase<wchar_t> *tagProc);
+
+		ut::LinkList animations;
+
+		Pane *rootPane;
+		GroupContainer *groupContainer;
+
+		float width;
+		float height;
+	};
+
+
+	class DrawInfo {
+	public:
+		DrawInfo();
+		virtual ~DrawInfo();
+
+		Mtx matrix;
+		float left;
+		float top;
+		float right;
+		float bottom;
+		float scaleX;
+		float scaleY;
+		float alpha;
+		u8 _50; // this is actually a bitfield. todo: investigate how CW handles bitfields, and so on
+	};
+
+
+	class Material {
+	public:
+		// ...
+	};
+
+	class Pane {
+	public:
+		//Pane(nw4r::lyt::res::Pane const *); // todo: this struct
+		Pane(void *);
+		~Pane();
+
+		virtual void *GetRuntimeTypeInfo() const;
+		virtual void CalculateMtx(const DrawInfo &info);
+
+		virtual void Draw(const DrawInfo &info);
+		virtual void DrawSelf(const DrawInfo &info);
+		virtual void Animate(ulong flag);
+		virtual void AnimateSelf(ulong flag);
+
+		virtual ut::Color GetVtxColor(ulong id) const;
+		virtual void SetVtxColor(ulong id, ut::Color color);
+		virtual uchar GetColorElement(ulong id) const;
+		virtual void SetColorElement(ulong id, uchar value);
+		virtual uchar GetVtxColorElement(ulong id) const;
+		virtual void SetVtxColorElement(ulong id, uchar value);
+
+		virtual Pane *FindPaneByName(const char *name, bool recursive);
+		virtual Material *FindMaterialByName(const char *name, bool recursive);
+
+		virtual void/*?*/ BindAnimation(AnimTransform *anim, bool unk1, bool unk2);
+		virtual void UnbindAnimation(AnimTransform *anim, bool unk);
+		virtual void UnbindAllAnimation(bool unk);
+		virtual void UnbindAnimationSelf(AnimTransform *anim);
+
+		virtual ut::LinkListNode *FindAnimationLinkSelf(AnimTransform *anim);
+		virtual ut::LinkListNode *FindAnimationLinkSelf(const AnimResource &anim);
+
+		virtual void SetAnimationEnable(AnimTransform *anim, bool unk1, bool unk2);
+		virtual void SetAnimationEnable(const AnimResource &anim, bool unk1, bool unk2);
+
+		virtual ulong GetMaterialNum() const;
+		virtual Material *GetMaterial() const;
+		virtual Material *GetMaterial(ulong id) const;
+
+		virtual void LoadMtx(const DrawInfo &info);
+
+		void AppendChild(Pane *child);
+
+		ut::Rect GetPaneRect(const DrawInfo &info) const;
+
+		ut::LinkListNode *AddAnimationLink(AnimationLink *link);
+
+		Vec2 GetVtxPos() const;
+
+
+		ut::LinkListNode parentLink;
+		Pane *parent;
+
+		ut::LinkList children;
+		ut::LinkList animations;
+
+		Material *material;
+
+		Vec trans;
+		Vec rotate;
+		Vec2 scale;
+		Vec2 size;
+
+		Mtx calcMtx;
+		Mtx effectiveMtx;
+
+		float _B4;
+
+		u8 alpha;
+		u8 effectiveAlpha;
+		u8 origin;
+		u8 flag;
+
+		char name[0x14];
+		char userdata[8];
+
+		u8 _D5;
+		u8 paneIsOwnedBySomeoneElse;
+		u8 _D7;
+	};
+}
+
+
+
+namespace g3d {
+struct CameraData
+{
+enum Flag
+    {
+FLAG_CAMERA_LOOKAT          = 0x00000001,
+FLAG_CAMERA_ROTATE = 0x00000002,
+FLAG_CAMERA_AIM    = 0x00000004,
+MASK_CAMERA        = 0x00000007,
+
+FLAG_CMTX_VALID    = 0x00000008,
+
+FLAG_PROJ_FLUSTUM  = 0x00000010,
+FLAG_PROJ_PERSP    = 0x00000020,
+FLAG_PROJ_ORTHO    = 0x00000040,
+MASK_PROJ          = 0x00000070,
+
+FLAG_PMTX_VALID             = 0x00000080,
+
+FLAG_VIEWPORT_JITTER_ABOVE  = 0x00000100
+    };
+
+Mtx  cameraMtx;
+Mtx44  projMtx;
+
+u32 flags;
+
+VEC3   cameraPos;
+VEC3   cameraUp;
+VEC3   cameraTarget;
+VEC3   cameraRotate;
+f32    cameraTwist;
+
+GXProjectionType    projType;
+f32                 projFovy;
+f32                 projAspect;
+f32                 projNear;
+f32                 projFar;
+f32                 projTop;
+f32                 projBottom;
+f32                 projLeft;
+f32                 projRight;
+
+f32                 lightScaleS;
+f32                 lightScaleT;
+f32                 lightTransS;
+f32                 lightTransT;
+
+VEC2   viewportOrigin;
+VEC2   viewportSize;
+f32    viewportNear;
+f32    viewportFar;
+
+u32    scissorX;
+u32    scissorY;
+u32    scissorWidth;
+u32    scissorHeight;
+
+s32    scissorOffsetX;
+s32    scissorOffsetY;
+};
+
+/* Correct camera
+cameraMtx:
+1.0 0.0 0.0 -0.0
+0.0 1.0 0.0 -0.0
+0.0 0.0 1.0 -6000.0
+
+projMtx:
+0.002345 0.000000  0.000000 -1.000000
+0.000000 0.004386  0.000000 -1.000000
+0.000000 0.000000 -0.000005 -0.500000
+0.000000 0.000000  0.000000  1.000000
+
+flags: 000000C9 : FLAG_CAMERA_LOOKAT | FLAG_CMTX_VALID | FLAG_PROJ_ORTHO | FLAG_PMTX_VALID
+
+cameraPos: {0, 0, 15}
+cameraUp: {0, 1, 0}
+cameraTarget: {0, 0, 0}
+cameraRotate: {0, 0, 0}
+cameraTwist: 0
+
+projType: 1
+projFovy: 60
+projAspect: 1.333333
+projNear: -100000
+projFar: 100000
+projTop: 456
+projBottom: 0
+projLeft: 0
+projRight: 853
+
+lightScaleS: 0.5
+lightScaleT: 0.5
+lightTransS: 0.5
+lightTransT: 0.5
+
+viewportOrigin: {0,0}
+viewportSize: {640,456}
+viewportNear: 0
+viewportFar: 1
+
+scissorX: 0
+scissorY: 0
+scissorWidth: 0x280
+scissorHeight: 0x1C8
+
+scissorOffsetX: 0
+scissorOffsetY: 0
+*/
+
+class Camera {
+public:
+	enum PostureType { POSTURE_LOOKAT, POSTURE_ROTATE, POSTURE_AIM };
+	struct PostureInfo
+	{
+	PostureType tp;
+	VEC3   cameraUp;
+	VEC3   cameraTarget;
+	VEC3   cameraRotate;
+	f32         cameraTwist;
+	};
+private:
+	CameraData *data;
+public:
+	Camera(CameraData *pCamera);
+	void Init();
+	void Init(u16 efbWidth, u16 efbHeight, u16 xfbWidth, u16 xfbHeight, u16 viWidth, u16 viHeight);
+	//void SetPosition(f32 x, f32 y, f32 z);
+	void SetPosition(const VEC3 &pos);
+	//void GetPosition(f32 *px, f32 *py, f32 *pz) const;
+	void GetPosition(VEC3 *pPos) const;
+	void SetPosture(const PostureInfo &info);
+	//void GetPosture(PostureInfo *info) const;
+	void SetCameraMtxDirectly(const Mtx &mtx);
+	void GetCameraMtx(Mtx *pMtx) const;
+	void SetOrtho(f32 top, f32 bottom, f32 left, f32 right, f32 near, f32 far);
+	//void SetFrustum(f32 top, f32 bottom, f32 left, f32 right, f32 near, f32 far);
+	void SetPerspective(f32 fovy, f32 aspect, f32 near, f32 far);
+	void SetProjectionMtxDirectly(const Mtx44 *pMtx);
+	void GetProjectionMtx(Mtx44 *pMtx) const;
+	//GXProjectionType GetProjectionType() const;
+	void SetScissor(u32 xOrigin, u32 yOrigin, u32 width, u32 height);
+	void SetScissorBoxOffset(s32 xOffset, s32 yOffset);
+	//void GetScissor(u32 *xOrigin, u32 *yOrigin, u32 *width, u32 *height);
+	void SetViewport(f32 xOrigin, f32 yOrigin, f32 width, f32 height);
+	//void SetViewport(f32 xOrigin, f32 yOrigin, f32 width, f32 height, f32 near, f32 far);
+	void SetViewportZRange(f32 near, f32 far);
+	void SetViewportJitter(u32 field);
+	//void SetViewportJitter(f32 xOrigin, f32 yOrigin, f32 width, f32 height, f32 near, f32 far, u32 field);
+	void GetViewport(f32 *xOrigin, f32 *yOrigin, f32 *width, f32 *height, f32 *near, f32 *far) const;
+	void GXSetViewport() const;
+	void GXSetProjection() const;
+	void GXSetScissor() const;
+	void GXSetScissorBoxOffset() const;
+};
+
+namespace G3DState {
+	GXRenderModeObj *GetRenderModeObj();
+}
+}
+}
+
+
+nw4r::g3d::CameraData *GetCameraByID(int id);
+
+int GetCurrentCameraID(); // 80164C80
+void SetCurrentCameraID(int id); // 80164C90
+
+void LinkScene(int id); // 80164D50
+void UnlinkScene(int id); // 80164CD0
+
+void SceneCalcWorld(int sceneID); // 80164E10
+void SceneCameraStuff(int sceneID); // 80164EA0
+
+void CalcMaterial(); // 80164E90
+void DrawOpa(); // 80164F70
+void DrawXlu(); // 80164F80
+
+bool ChangeAlphaUpdate(bool enable); // 802D3270
+
+void DoSpecialDrawing1(); // 8006CAE0
+void DoSpecialDrawing2(); // 8006CB40
+
+void SetupLYTDrawing(); // 80163360
+void ClearLayoutDrawList(); // 801632B0
+
+void DrawAllLayoutsBeforeX(int x); // 80163440
+void DrawAllLayoutsAfterX(int x); // 801634D0
+void DrawAllLayoutsAfterXandBeforeY(int x, int y); // 80163560
+
+void RenderEffects(int v1, int v2); // 80093F10
+
+void RemoveAllFromScnRoot(); // 80164FB0
+void Reset3DState(); // 80165000
+
+extern "C" void GXDrawDone(); // 801C4FE0
+
+
+
+namespace m2d {
+	class Base_c /*: public nw4r::ut::Link what's this? */ {
+		u32 _00;
+		u32 _04;
+
+		Base_c();
+		virtual ~Base_c();
+		virtual void _vf0C();
+
+		u8 _0C;
+	};
+
+	class Simple_c : public Base_c {
+		nw4r::lyt::Layout layout;
+		nw4r::lyt::DrawInfo drawInfo;
+
+		u32 _84;
+		float _88;
+		float _8C;
+		float _90;
+		u32 _94;
+
+		Simple_c();
+		~Simple_c();
+
+		void _vf0C();
+		virtual void _vf10();
+		virtual void _vf14();
+	};
+}
+
+
+
+namespace EGG {
+	class Frustum {
+		GXProjectionType projType;
+		int isCentered;
+		float width;
+		float height;
+		float fovy;
+		float dunno;
+		float near;
+		float far;
+		float center_x_maybe;
+		float center_y_maybe;
+		float x_direction;
+		float unk2;
+		float unk3;
+		short some_flag_bit;
+
+
+		// isCentered might actually be isNotCentered, dunno
+		Frustum(GXProjectionType projType, Vec2 size, bool isCentered, float near, float far); // 802C6D20
+		Frustum(Frustum &f); // 802C6D90
+		virtual ~Frustum(); // 802C75F0
+
+		virtual void loadDirectly(); // 802C7050
+		virtual void loadIntoCamera(nw4r::g3d::Camera cam); // 802C7070
+
+		void setOrtho(float top, float bottom, float left, float right, float near, float far); // 802C6DD0
+
+		void setFovy(float newFovy); // 802C6F60
+
+		void getCenterPointsBasedOnPos(float x, float y, float *destX, float *destY); // 802C6FD0
+
+		// no idea what this does
+		float getSomethingForPerspective(float blah); // 802C7020
+
+
+	protected:
+		// not all of these might be protected, dunno
+
+		void copyAllFields(Frustum &f); // 802C6EE0
+
+		void saveSomething(float f1, float f2, float f3, float f4); // 802C70C0
+		void loadSomething(float *f1, float *f2, float *f3, float *f4); // 802C70E0
+
+		void loadPerspective(); // 802C7110
+		void loadOrtho(); // 802C7140
+
+		void setCameraPerspective(nw4r::g3d::Camera cam); // 802C7170
+		void setCameraOrtho(nw4r::g3d::Camera cam); // 802C71E0
+
+		void getPerspectiveProjMtx(Mtx44 *mtx); // 802C7250
+		void getPerspectiveProjv(float *ptr); // 802C72E0
+		void getOrthoProjv(float *ptr); // 802C73A0
+
+		void getOrthoVars(float *top, float *bottom, float *left, float *right); // 802C7480
+	};
+}
+
+
+
+
+struct LinkListEntry {
+	LinkListEntry *prev;
+	LinkListEntry *next;
+	void *owned_obj;
+};
+
+
+struct LinkList {
+	LinkListEntry *first;
+	LinkListEntry *last;
+	// PTMF goes here, but I don't know how to represent it
+};
+
+
+struct OrderedLinkListEntry : LinkListEntry {
+	u16 order;
+	u16 _;
+};
+
+
+struct TreeNode {
+	TreeNode *parent;
+	TreeNode *child;
+	TreeNode *prev;
+	TreeNode *next;
+	void *owned_obj;
+};
+
+
+struct Tree {
+	TreeNode *firstNode;
+	// PTMF goes here, but I don't know how to represent it
+};
+
+
+typedef bool (*ChainedFunc)(void*);
+
+struct FunctionChain {
+	ChainedFunc *functions;
+	u16 count;
+	u16 current;
+};
+
+
+class fBase_c {
+public:
+	u32 id;
+	u32 settings;
+	u16 name;
+	u8 _A;
+	u8 _B;
+	u8 _C;
+	u8 _D;
+	u8 base_type;
+	u8 _F;
+	TreeNode link_connect;
+	OrderedLinkListEntry link_execute;
+	OrderedLinkListEntry link_draw;
+	LinkListEntry link_IDlookup;
+	u32 _50;
+	u32 _54;
+	u32 _58;
+	u32 heap;
+
+	fBase_c();
+
+	virtual int onCreate();
+	virtual int beforeCreate();
+	virtual int afterCreate();
+
+	virtual int onDelete();
+	virtual int beforeDelete();
+	virtual int afterDelete();
+
+	virtual int onExecute();
+	virtual int beforeExecute();
+	virtual int afterExecute();
+
+	virtual int onDraw();
+	virtual int beforeDraw();
+	virtual int afterDraw();
+
+	virtual void willBeDeleted();
+
+	virtual bool moreHeapShit(u32 size, void *parentHeap);
+	virtual bool createHeap(u32 size, void *parentHeap);
+	virtual void heapCreated();
+
+	virtual ~fBase_c();
+
+	void Delete();
+
+	fBase_c *GetParent();
+	fBase_c *GetChild();
+	fBase_c *GetNext();
+};
+
+class dBase_c : public fBase_c {
+public:
+	u32 _64;
+	const char *explanation_string;
+	const char *name_string;
+
+	dBase_c();
+
+	int beforeCreate();
+	int afterCreate();
+	int beforeDelete();
+	int afterDelete();
+	int beforeExecute();
+	int afterExecute();
+	int beforeDraw();
+	int afterDraw();
+
+	~dBase_c();
+
+	virtual const char *GetExplanationString();
+};
+
+class dScene_c : public dBase_c {
+public:
+	FunctionChain *funcChain;
+
+	dScene_c();
+
+	int beforeCreate();
+	int afterCreate();
+	int beforeDelete();
+	int afterDelete();
+	int beforeExecute();
+	int afterExecute();
+	int beforeDraw();
+	int afterDraw();
+
+	~dScene_c();
+};
+
+class dActor_c : public dBase_c {
+public:
+	LinkListEntry link_actor;
+	Mtx matrix;
+	Vec pos;
+	Vec last_pos;
+	Vec pos_delta;
+	Vec _D0;
+	Vec scale;
+	Vec speed;
+	Vec max_speed;
+	S16Vec rot;
+	S16Vec _106;
+	u32 _10C;
+	u32 _110;
+	float y_speed_inc;
+	u32 _118;
+	float x_speed_inc;
+	u32 _120;
+	bool visible;
+
+	dActor_c();
+
+	virtual void specialDraw1();
+	virtual void specialDraw2();
+	virtual int _vf58();
+	virtual void _vf5C();
+
+	~dActor_c();
+};
+
+
+
+class dPlayerModelBase_c {
+	// dunno what's public and what's private here
+	// don't really care
+public:
+	dPlayerModelBase_c(u8 player_id);		// 800D5420
+	virtual ~dPlayerModelBase_c();			// 800D55D0
+
+	char allocator[28]; // actually a mHeapAllocatorSubclass but I don't have that
+	u32 _20;
+	u32 _24;
+	char someAnimation[2][0x38]; // actually PlayerAnim's
+	char yetAnotherAnimation[40]; // actually m3d::banm_c afaics -- is it even 40 bytes?
+	Vec someVector[2]; // maybe not an array
+	Vec headOffs;
+	Vec scale;
+	u8 player_id_1;
+	u8 player_id_2;
+	u8 powerup_id;
+	u8 powerup_tex;
+	int current_anim;
+	int last_anim_maybe;
+	u32 _15C;
+	int someFlags;
+	u32 _164;
+	u32 _168; // related to jump_strings
+	u32 _16C;
+	u32 _170;
+	u32 _174;
+	u8 _178;
+	char padding[3]; // not needed?
+	u32 model_visibility_flags_maybe;
+	u32 mode_maybe;
+	float _184;
+	float _188;
+	u32 _18C;
+	char someArray[6][12]; // some unknown class/struct
+	char _1D8[0x24];
+	short _1FC;
+	short _1FE;
+	short _200;
+	char padding_[2]; // not needed?
+	u32 _204;
+	u32 _208;
+
+	virtual int _vf0C();						// 800D6DA0
+	virtual void prepare();					// 800D5720
+	virtual void finaliseModel();				// 800D5740
+	virtual void update();						// 800D5750
+	virtual void update3DStuff();				// 800D5760
+	virtual void _vf20();						// 800D6D90
+	virtual void draw();						// 800D5C70
+	virtual int getCurrentModel();				// 800D5870
+	virtual int getCurrentResFile();			// 800D62D0
+	virtual void setPowerup(u8 powerup_id);	// 800D5730
+	virtual void setPowerupTexture();			// 800D5CC0
+	virtual void _vf38();						// 800D6D80
+	virtual void _vf3C();						// 800BD750
+	virtual void _vf40();						// 800D6D70
+	virtual void _vf44();						// 800D6D60
+	virtual void _vf48();						// 800BD740
+	virtual void _vf4C();						// 800BD730
+	virtual void getModelMatrix(u32 unk, MtxPtr dest);	// 800D5820
+	virtual int _vf54();						// 80318D0C
+	virtual bool _vf58(int type, char *buf, bool unk); // 800D6930
+	virtual void startAnimation(int id, float frame, float unk, float updateRate);	// 800D5EC0
+	virtual int _vf60();						// 800D6920
+	virtual void _vf64(int id, float unk1, float unk2, float unk3); // 800D62F0
+	virtual void _vf68(int id, float unk);		// 800D63E0
+	virtual void _vf6C();						// 800D62E0
+	virtual void _vf70();						// 800D6690
+	virtual void _vf74();						// 800D66A0
+	virtual void _vf78();						// 800D66B0
+	virtual void SomethingRelatedToPenguinAnims();	// 800D66C0
+	virtual void _vf80();						// 800D6A20
+	virtual void _vf84(float frame);			// 800D5D00
+	virtual void _vf88(float frame);			// 800D5D70
+	virtual void _vf8C(float updateRate);		// 800D5D80
+	virtual void setUpdateRateForAnim1(float updateRate);	// 800D5DF0
+	virtual void _vf94();						// 800D6D40
+	virtual int _vf98();						// 800D6D30
+	virtual void _vf9C();						// 800D6D20
+	virtual int _vfA0();						// 800D6D10
+	virtual void _vfA4();						// 800D6D00
+	virtual int _vfA8();						// 800D6CF0
+	virtual void _vfAC(bool blah);						// 800BD720
+
+	// I won't even bother with non-virtual functions....
+};
+
+
+class dPlayerModelHandler_c {
+public:
+	dPlayerModelHandler_c(u8 player_id);	// 800D6DB0
+	virtual ~dPlayerModelHandler_c();		// 800D6EF0
+
+	dPlayerModelBase_c *mdlClass;	// might be dPlayerModel_c ?
+
+	int loadModel(u8 player_id, int powerup_id, int unk);	// 800D6EE0
+	void update();											// 800D6F80
+	void setMatrix(Mtx matrix);								// 800D6FA0
+	void setSRT(Vec position, S16Vec rotation, Vec scale);	// 800D7030
+	void callVF20();										// 800D70F0
+	void draw();											// 800D7110
+
+private:
+	int hasMatrix;	// might be bool ?
+
+	void allocPlayerClass(u8 player_id);					// 800D6E00
+};
+
+
+class mTexture_c {
+public:
+	mTexture_c();	// 802C0D20
+	mTexture_c(u16 width, u16 height, GXTexFmt format);	// 802C0D70
+
+	// vtable is at 80350450
+	virtual ~mTexture_c();	// 802C0DB0
+	virtual void setFlagTo1();	// 802C0E20
+
+	void setImageBuffer(void *buffer);	// 802C0E30
+	void load(GXTexMapID id);			// 802C0E50
+	void makeTexObj(GXTexObj *obj);		// 802C0E90
+	void flushDC();						// 802C0F10
+
+	void makeRadialGradient();			// 802C0F60 parameters unknown yet
+	void makeLinearGradient(int type, char size, u16 startPos, u16 endPos,
+			GXColor begin, GXColor end, bool startAtCenter);	// 802C1120
+	// "type" should be enum once I figure it out
+	// reverse might not be accurate
+
+	void allocateBuffer(/* EGG::Heap */void *heap = 0);	// 802C14D0
+
+	void plotPixel(u16 x, u16 y, GXColor pixel);	// 802C1570
+
+
+	u16 width;
+	u16 height;
+	u8 flags;
+	u8 format;
+	u8 wrapS;
+	u8 wrapT;
+	u8 minFilter;
+	u8 magFilter;
+
+private:
+	void *buffer;
+	void *myBuffer;
+};
+
+
+class dDvdLoader_c {
+public:
+	dDvdLoader_c();				// 8008F140
+	virtual ~dDvdLoader_c();	// 8008F170
+
+	void *load(const char *filename, u8 unk = 0);	// 8008F1B0
+
+	bool close();	// 8008F2B0 -- Frees command, DON'T USE THIS unless you free the buffer yourself
+	bool unload();	// 8008F310 -- Frees command and buffer, USE THIS
+
+	int size;
+	void *command;	// really mDvd_toMainRam_c
+	void *heap;		// really EGG::Heap
+	void *buffer;
+
+private:
+	virtual void freeBuffer();	// 8008F380
+	void freeCommand();			// 8008F3F0
+};
+
+
+
+#endif
+
diff --git a/include/rvl/GXBump.h b/include/rvl/GXBump.h
new file mode 100755
index 0000000..56cbbd9
--- /dev/null
+++ b/include/rvl/GXBump.h
@@ -0,0 +1,55 @@
+#ifndef __GXBUMP_H__
+#define __GXBUMP_H__
+
+//******************************************************************************
+//
+//  Graphics Library Indirect Texture (Bump) functions.
+//  
+//******************************************************************************
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//------------------------------------------------------------------------------
+// Bump (indirect texture functions).
+//------------------------------------------------------------------------------
+extern void GXSetNumIndStages (u8 nIndStages);
+extern void GXSetIndTexOrder (GXIndTexStageID ind_stage, GXTexCoordID tex_coord,
+			      GXTexMapID tex_map);
+extern void GXSetIndTexCoordScale (GXIndTexStageID ind_state, 
+				   GXIndTexScale scale_s, GXIndTexScale scale_t);
+extern void GXSetIndTexMtx (GXIndTexMtxID mtx_sel, const f32 offset[2][3], s8 scale_exp);
+extern 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);
+
+//------------------------------------------------------------------------------
+// Convenience functions
+//------------------------------------------------------------------------------
+extern void GXSetTevDirect (GXTevStageID tev_stage);
+extern void GXSetTevIndWarp (GXTevStageID tev_stage, GXIndTexStageID ind_stage,
+			     GXBool signed_offset, GXBool replace_mode,
+			     GXIndTexMtxID matrix_sel);
+extern void GXSetTevIndTile (GXTevStageID tev_stage, GXIndTexStageID ind_stage,
+			     u16 tilesize_s, u16 tilesize_t, 
+			     u16 tilespacing_s, u16 tilespacing_t, 
+			     GXIndTexFormat format, GXIndTexMtxID matrix_sel,
+			     GXIndTexBiasSel bias_sel, GXIndTexAlphaSel alpha_sel);
+extern void GXSetTevIndBumpST (GXTevStageID tev_stage, GXIndTexStageID ind_stage, 
+			       GXIndTexMtxID matrix_sel);
+extern void GXSetTevIndBumpXYZ (GXTevStageID tev_stage, GXIndTexStageID ind_stage, 
+			       GXIndTexMtxID matrix_sel);
+extern void GXSetTevIndRepeat (GXTevStageID tev_stage);
+
+//------------------------------------------------------------------------------
+extern void __GXSetIndirectMask ( u32 mask );
+
+//------------------------------------------------------------------------------
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXBUMP_H__
diff --git a/include/rvl/GXCull.h b/include/rvl/GXCull.h
new file mode 100755
index 0000000..3584439
--- /dev/null
+++ b/include/rvl/GXCull.h
@@ -0,0 +1,18 @@
+#ifndef __GXCULL_H__
+#define __GXCULL_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 // __GXCULL_H__
diff --git a/include/rvl/GXDispList.h b/include/rvl/GXDispList.h
new file mode 100755
index 0000000..5246525
--- /dev/null
+++ b/include/rvl/GXDispList.h
@@ -0,0 +1,18 @@
+#ifndef __GXDISPLIST_H__
+#define __GXDISPLIST_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 // __GXDISPLIST_H__
diff --git a/include/rvl/GXEnum.h b/include/rvl/GXEnum.h
new file mode 100755
index 0000000..6f75a0f
--- /dev/null
+++ b/include/rvl/GXEnum.h
@@ -0,0 +1,1300 @@
+#ifndef __GXENUM_H__
+#define __GXENUM_H__
+
+/********************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/********************************/
+typedef u8 GXBool;
+
+/********************************/
+#define GX_TRUE        ((GXBool)1)
+#define GX_FALSE       ((GXBool)0)
+#define GX_ENABLE      ((GXBool)1)
+#define GX_DISABLE     ((GXBool)0)
+
+/********************************/
+typedef enum _GXAttr
+{
+    GX_VA_PNMTXIDX = 0,    // position/normal matrix index
+    GX_VA_TEX0MTXIDX,      // texture 0 matrix index
+    GX_VA_TEX1MTXIDX,      // texture 1 matrix index
+    GX_VA_TEX2MTXIDX,      // texture 2 matrix index
+    GX_VA_TEX3MTXIDX,      // texture 3 matrix index
+    GX_VA_TEX4MTXIDX,      // texture 4 matrix index
+    GX_VA_TEX5MTXIDX,      // texture 5 matrix index
+    GX_VA_TEX6MTXIDX,      // texture 6 matrix index
+    GX_VA_TEX7MTXIDX,      // texture 7 matrix index
+    GX_VA_POS      = 9,    // position
+    GX_VA_NRM,             // normal
+    GX_VA_CLR0,            // color 0
+    GX_VA_CLR1,            // color 1
+    GX_VA_TEX0,            // input texture coordinate 0
+    GX_VA_TEX1,            // input texture coordinate 1
+    GX_VA_TEX2,            // input texture coordinate 2
+    GX_VA_TEX3,            // input texture coordinate 3
+    GX_VA_TEX4,            // input texture coordinate 4
+    GX_VA_TEX5,            // input texture coordinate 5
+    GX_VA_TEX6,            // input texture coordinate 6
+    GX_VA_TEX7,            // input texture coordinate 7
+
+    GX_POS_MTX_ARRAY,      // position matrix array pointer
+    GX_NRM_MTX_ARRAY,      // normal matrix array pointer
+    GX_TEX_MTX_ARRAY,      // texture matrix array pointer
+    GX_LIGHT_ARRAY,        // light parameter array pointer
+    GX_VA_NBT,             // normal, bi-normal, tangent 
+    GX_VA_MAX_ATTR,        // maximum number of vertex attributes
+
+    GX_VA_NULL     = 0xff  // NULL attribute (to mark end of lists)
+
+} GXAttr;
+
+#define GX_MAX_VTXDESC              GX_VA_MAX_ATTR
+#define GX_MAX_VTXDESCLIST_SZ       (GX_MAX_VTXDESC+1)    // +1 for GX_VA_NULL
+
+#define GX_MAX_VTXATTRFMT           GX_VA_MAX_ATTR
+#define GX_MAX_VTXATTRFMTLIST_SZ    (GX_MAX_VTXATTRFMT+1) // +1 for GX_VA_NULL
+
+#define GX_MAX_VTXARRAY             16
+
+/********************************/
+typedef enum _GXVtxFmt
+{
+    GX_VTXFMT0 = 0,
+    GX_VTXFMT1,
+    GX_VTXFMT2,
+    GX_VTXFMT3,
+    GX_VTXFMT4,
+    GX_VTXFMT5,
+    GX_VTXFMT6,
+    GX_VTXFMT7,
+    GX_MAX_VTXFMT
+
+} GXVtxFmt;
+
+#define GX_MAX_VTXFMT               GX_MAX_VTXFMT
+
+/********************************/
+typedef enum _GXAttrType
+{
+    GX_NONE    = 0,
+    GX_DIRECT,
+    GX_INDEX8,
+    GX_INDEX16
+
+} GXAttrType;
+
+/********************************/
+typedef enum _GXTexCoordID
+{
+    GX_TEXCOORD0 = 0x0,    	// generated texture coordinate 0
+    GX_TEXCOORD1, 		// generated texture coordinate 1
+    GX_TEXCOORD2, 		// generated texture coordinate 2
+    GX_TEXCOORD3, 		// generated texture coordinate 3
+    GX_TEXCOORD4, 		// generated texture coordinate 4
+    GX_TEXCOORD5, 		// generated texture coordinate 5
+    GX_TEXCOORD6, 		// generated texture coordinate 6
+    GX_TEXCOORD7, 		// generated texture coordinate 7
+    GX_MAX_TEXCOORD = 8,
+    GX_TEXCOORD_NULL = 0xff
+
+} GXTexCoordID;
+
+#define GX_MAX_TEXCOORDGEN          GX_MAX_TEXCOORD
+
+/********************************/
+typedef enum _GXTexGenType
+{
+    GX_TG_MTX3x4 = 0,
+    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 _GXTexGenSrc
+{
+    GX_TG_POS = 0,
+    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
+
+} GXTexGenSrc;
+
+/********************************/
+typedef enum _GXCompCnt
+{
+#if ( GX_REV == 1 )
+    GX_POS_XY    = 0,
+    GX_POS_XYZ   = 1,
+    GX_NRM_XYZ   = 0,
+    GX_NRM_NBT   = 1, // not really used, just to make api consistent
+    GX_CLR_RGB   = 0,
+    GX_CLR_RGBA  = 1,
+    GX_TEX_S     = 0,
+    GX_TEX_ST    = 1
+
+#else // ( GX_REV >= 2 )
+    GX_POS_XY    = 0,
+    GX_POS_XYZ   = 1,
+    GX_NRM_XYZ   = 0,
+    GX_NRM_NBT   = 1, // one index per NBT
+    GX_NRM_NBT3  = 2, // one index per each of N/B/T
+    GX_CLR_RGB   = 0,
+    GX_CLR_RGBA  = 1,
+    GX_TEX_S     = 0,
+    GX_TEX_ST    = 1
+
+#endif
+} 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 _GXChannelID
+{
+    GX_COLOR0,
+    GX_COLOR1,
+    GX_ALPHA0,
+    GX_ALPHA1,
+    GX_COLOR0A0,          // Color 0 + Alpha 0
+    GX_COLOR1A1,          // Color 1 + Alpha 1
+	GX_COLOR_ZERO,        // RGBA = 0
+	GX_ALPHA_BUMP,        // bump alpha 0-248, RGB=0
+	GX_ALPHA_BUMPN,       // normalized bump alpha, 0-255, RGB=0
+    GX_COLOR_NULL = 0xff
+
+} GXChannelID;
+
+/********************************/
+typedef enum _GXColorSrc
+{
+    GX_SRC_REG = 0,
+    GX_SRC_VTX
+
+} GXColorSrc;
+
+/********************************/
+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 = 0x000
+} GXLightID;
+
+/********************************/
+typedef enum _GXDiffuseFn
+{
+    GX_DF_NONE = 0,
+    GX_DF_SIGN,
+    GX_DF_CLAMP
+
+} GXDiffuseFn;
+
+/********************************/
+typedef enum _GXAttnFn
+{
+    GX_AF_SPEC = 0,    // use specular attenuation
+    GX_AF_SPOT = 1,    // use distance/spotlight attenuation
+    GX_AF_NONE         // attenuation is off
+
+} GXAttnFn;
+
+/********************************/
+typedef enum _GXSpotFn
+{
+    GX_SP_OFF = 0,
+    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 = 0,
+    GX_DA_GENTLE,
+    GX_DA_MEDIUM,
+    GX_DA_STEEP
+} GXDistAttnFn;
+
+/********************************/
+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;
+
+/********************************/
+#if ( GX_REV != 1 ) // Revision 2 or greater only
+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;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+typedef enum _GXTexMtxType
+{
+    GX_MTX3x4 = 0,
+    GX_MTX2x4
+
+} GXTexMtxType;
+
+/********************************/
+typedef enum _GXPrimitive
+{
+    GX_POINTS        = 0xb8,
+    GX_LINES         = 0xa8,
+    GX_LINESTRIP     = 0xb0,
+    GX_TRIANGLES     = 0x90,
+    GX_TRIANGLESTRIP = 0x98,
+    GX_TRIANGLEFAN   = 0xa0,
+    GX_QUADS         = 0x80
+
+} GXPrimitive;
+
+/********************************/
+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 _GXCullMode
+{
+    GX_CULL_NONE,
+    GX_CULL_FRONT,
+    GX_CULL_BACK,
+    GX_CULL_ALL
+
+} GXCullMode;
+
+/********************************/
+typedef enum _GXClipMode
+{
+    // Note: these are (by design) backwards of typical enable/disables!
+    GX_CLIP_ENABLE = 0,
+    GX_CLIP_DISABLE = 1
+
+} GXClipMode;
+
+/********************************/
+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 _GXCITexFmt
+{
+    GX_TF_C4    = 0x8,
+    GX_TF_C8    = 0x9,
+    GX_TF_C14X2 = 0xa
+
+} GXCITexFmt;
+
+/********************************/
+typedef enum _GXTexFmt
+{
+#if ( GX_REV == 1 )
+    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_TF_A8     = (0x20 | GX_TF_I8), 
+    GX_TF_Z8     = (0x10 | GX_TF_I8),
+    GX_TF_Z16    = (0x10 | GX_TF_IA8),
+    GX_TF_Z24X8  = (0x10 | GX_TF_RGBA8)
+
+#else // ( GX_REV >= 2 )
+
+#define _GX_TF_CTF     0x20 /* copy-texture-format only */
+#define _GX_TF_ZTF     0x10 /* Z-texture-format */
+
+    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 // to keep compatibility
+#endif
+} GXTexFmt;
+
+/********************************/
+typedef enum _GXTlutFmt
+{
+    GX_TL_IA8    = 0x0,
+    GX_TL_RGB565 = 0x1,
+    GX_TL_RGB5A3 = 0x2,
+    GX_MAX_TLUTFMT
+
+} GXTlutFmt;
+
+/********************************/
+typedef enum _GXTlutSize
+{
+    GX_TLUT_16 = 1,	// number of 16 entry blocks.
+    GX_TLUT_32 = 2,
+    GX_TLUT_64 = 4,
+    GX_TLUT_128 = 8,
+    GX_TLUT_256 = 16,
+    GX_TLUT_512 = 32,
+    GX_TLUT_1K = 64,
+    GX_TLUT_2K = 128,
+    GX_TLUT_4K = 256,
+    GX_TLUT_8K = 512,
+    GX_TLUT_16K = 1024
+
+} GXTlutSize;
+
+/********************************/
+typedef enum _GXTlut
+{
+    // default 256-entry TLUTs
+    GX_TLUT0 = 0,
+    GX_TLUT1,
+    GX_TLUT2,
+    GX_TLUT3,
+    GX_TLUT4,
+    GX_TLUT5,
+    GX_TLUT6,
+    GX_TLUT7,
+    GX_TLUT8,
+    GX_TLUT9,
+    GX_TLUT10,
+    GX_TLUT11,
+    GX_TLUT12,
+    GX_TLUT13,
+    GX_TLUT14,
+    GX_TLUT15,
+    GX_BIGTLUT0,
+    GX_BIGTLUT1,
+    GX_BIGTLUT2,
+    GX_BIGTLUT3
+
+} GXTlut;
+
+/********************************/
+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	// mask  : disables texture look up
+
+} GXTexMapID;
+
+#define GX_MAX_TEXMAPS      GX_MAX_TEXMAP
+
+/********************************/
+typedef enum _GXTexCacheSize
+{
+    GX_TEXCACHE_32K,
+    GX_TEXCACHE_128K,
+    GX_TEXCACHE_512K,
+    GX_TEXCACHE_NONE
+
+} GXTexCacheSize;
+
+/********************************/
+typedef enum _GXIndTexFormat
+{
+    GX_ITF_8,		// 8 bit texture offsets.
+    GX_ITF_5,		// 5 bit texture offsets.
+    GX_ITF_4,		// 4 bit texture offsets.
+    GX_ITF_3,		// 3 bit texture offsets.
+    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,		// no wrapping
+    GX_ITW_256,		// wrap 256
+    GX_ITW_128,		// wrap 128
+    GX_ITW_64, 		// wrap 64
+    GX_ITW_32, 		// wrap 32
+    GX_ITW_16, 		// wrap 16
+    GX_ITW_0, 		// wrap 0
+    GX_MAX_ITWRAP
+
+} GXIndTexWrap;
+
+/********************************/
+typedef enum _GXIndTexScale
+{
+    GX_ITS_1,		// Scale by 1.
+    GX_ITS_2,		// Scale by 1/2.
+    GX_ITS_4,		// Scale by 1/4.
+    GX_ITS_8,		// Scale by 1/8.
+    GX_ITS_16,		// Scale by 1/16.
+    GX_ITS_32,		// Scale by 1/32.
+    GX_ITS_64,		// Scale by 1/64.
+    GX_ITS_128,		// Scale by 1/128.
+    GX_ITS_256,		// Scale by 1/256.
+    GX_MAX_ITSCALE
+
+} GXIndTexScale;
+
+/********************************/
+typedef enum _GXIndTexStageID
+{
+    GX_INDTEXSTAGE0,	// Indirect Texture Stage Names.
+    GX_INDTEXSTAGE1,
+    GX_INDTEXSTAGE2,
+    GX_INDTEXSTAGE3,
+    GX_MAX_INDTEXSTAGE
+
+} GXIndTexStageID;
+
+/********************************/
+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;
+
+#define GX_MAX_TEVSTAGES            GX_MAX_TEVSTAGE
+
+/********************************/
+typedef enum _GXTevRegID
+{
+    GX_TEVPREV = 0,
+    GX_TEVREG0,
+    GX_TEVREG1,
+    GX_TEVREG2,
+    GX_MAX_TEVREG
+
+} GXTevRegID;
+
+/********************************/
+typedef enum _GXTevOp
+{
+#if ( GX_REV == 1 )
+    GX_TEV_ADD,
+    GX_TEV_SUB
+
+#else // ( GX_REV >= 2 )
+    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, // for alpha channel
+    GX_TEV_COMP_A8_EQ = GX_TEV_COMP_RGB8_EQ  // for alpha channel
+
+#endif
+} GXTevOp;
+
+/********************************/
+typedef enum _GXTevColorArg
+{
+#if ( GX_REV == 1 )
+    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_QUARTER,
+    GX_CC_ZERO,
+
+    GX_CC_TEXRRR,
+    GX_CC_TEXGGG,
+    GX_CC_TEXBBB
+
+#else // ( GX_REV >= 2 )
+    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
+
+#ifndef GX_NO_LEGACY_HW1
+    ,             // separator needed only in this case
+
+    GX_CC_TEXRRR, // obsolete
+    GX_CC_TEXGGG, // obsolete
+    GX_CC_TEXBBB, // obsolete
+
+    GX_CC_QUARTER = GX_CC_KONST // obsolete, to keep compatibility
+#endif
+
+#endif
+} GXTevColorArg;
+
+/********************************/
+typedef enum _GXTevAlphaArg
+{
+#if ( GX_REV == 1 )
+    GX_CA_APREV,
+    GX_CA_A0,
+    GX_CA_A1,
+    GX_CA_A2,
+    GX_CA_TEXA,
+    GX_CA_RASA,
+    GX_CA_ONE,
+    GX_CA_ZERO
+
+#else // ( GX_REV >= 2 )
+    GX_CA_APREV,
+    GX_CA_A0,
+    GX_CA_A1,
+    GX_CA_A2,
+    GX_CA_TEXA,
+    GX_CA_RASA,
+    GX_CA_KONST,
+    GX_CA_ZERO
+
+#ifndef GX_NO_LEGACY_HW1
+    ,                       // separator needed only in this case
+
+    GX_CA_ONE = GX_CA_KONST // obsolete, to keep compatibility
+#endif
+
+#endif
+} GXTevAlphaArg;
+
+/********************************/
+typedef enum _GXTevBias
+{
+    GX_TB_ZERO,
+    GX_TB_ADDHALF,
+    GX_TB_SUBHALF,
+    GX_MAX_TEVBIAS
+
+} GXTevBias;
+
+/********************************/
+typedef enum _GXTevClampMode
+{
+    GX_TC_LINEAR,
+    GX_TC_GE,
+    GX_TC_EQ,
+    GX_TC_LE,
+    GX_MAX_TEVCLAMPMODE
+
+} GXTevClampMode;
+
+/********************************/
+#if ( GX_REV != 1 ) // GX Revision 2 or later only
+typedef enum _GXTevKColorID
+{
+    GX_KCOLOR0 = 0,
+    GX_KCOLOR1,
+    GX_KCOLOR2,
+    GX_KCOLOR3,
+    GX_MAX_KCOLOR
+
+} GXTevKColorID;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+#if ( GX_REV != 1 ) // GX Revision 2 or later only
+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;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+#if ( GX_REV != 1 ) // GX Revision 2 or later only
+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;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+#if ( GX_REV != 1 ) // GX Revision 2 or later only
+typedef enum _GXTevSwapSel
+{
+    GX_TEV_SWAP0 = 0,
+    GX_TEV_SWAP1,
+    GX_TEV_SWAP2,
+    GX_TEV_SWAP3,
+    GX_MAX_TEVSWAP
+
+} GXTevSwapSel;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+#if ( GX_REV != 1 ) // GX Revision 2 or later only
+typedef enum _GXTevColorChan
+{
+    GX_CH_RED = 0,
+    GX_CH_GREEN,
+    GX_CH_BLUE,
+    GX_CH_ALPHA
+
+} GXTevColorChan;
+#endif // ( GX_REV != 1 )
+
+/********************************/
+typedef enum _GXAlphaOp
+{
+    GX_AOP_AND,
+    GX_AOP_OR,
+    GX_AOP_XOR,
+    GX_AOP_XNOR,
+    GX_MAX_ALPHAOP
+
+} GXAlphaOp;
+
+/********************************/
+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 _GXFogType
+{
+    GX_FOG_NONE		     = 0x00,
+
+    GX_FOG_PERSP_LIN     = 0x02,
+    GX_FOG_PERSP_EXP     = 0x04,
+    GX_FOG_PERSP_EXP2    = 0x05,
+    GX_FOG_PERSP_REVEXP  = 0x06,
+    GX_FOG_PERSP_REVEXP2 = 0x07,
+
+    GX_FOG_ORTHO_LIN     = 0x0A,
+    GX_FOG_ORTHO_EXP     = 0x0C,
+    GX_FOG_ORTHO_EXP2    = 0x0D,
+    GX_FOG_ORTHO_REVEXP  = 0x0E,
+    GX_FOG_ORTHO_REVEXP2 = 0x0F,
+
+    // For compatibility with former versions
+    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 _GXBlendMode
+{
+#if ( GX_REV == 1 )
+    GX_BM_NONE,
+    GX_BM_BLEND,
+    GX_BM_LOGIC,
+    GX_MAX_BLENDMODE
+
+#else // ( GX_REV >= 2 )
+    GX_BM_NONE,
+    GX_BM_BLEND,
+    GX_BM_LOGIC,
+    GX_BM_SUBTRACT,
+    GX_MAX_BLENDMODE
+
+#endif
+} 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 _GXCompare
+{
+    GX_NEVER,
+    GX_LESS,
+    GX_EQUAL,
+    GX_LEQUAL,
+    GX_GREATER,
+    GX_NEQUAL,
+    GX_GEQUAL,
+    GX_ALWAYS
+
+} GXCompare;
+
+/********************************/
+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 _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 _GXZFmt16
+{
+    GX_ZC_LINEAR,
+    GX_ZC_NEAR,
+    GX_ZC_MID,
+    GX_ZC_FAR
+
+} GXZFmt16;
+
+/********************************/
+typedef enum _GXTevMode
+{
+    GX_MODULATE,
+    GX_DECAL,
+    GX_BLEND,
+    GX_REPLACE,
+    GX_PASSCLR
+
+} GXTevMode;
+
+/********************************/
+typedef enum _GXGamma
+{
+    GX_GM_1_0,
+    GX_GM_1_7,
+    GX_GM_2_2
+
+} GXGamma;
+
+/********************************/
+typedef enum _GXProjectionType
+{
+    GX_PERSPECTIVE,
+    GX_ORTHOGRAPHIC
+
+} GXProjectionType;
+
+
+/********************************/
+typedef enum _GXEvent
+{
+    GX_VCACHE_MISS_ALL,
+    GX_VCACHE_MISS_POS,
+    GX_VCACHE_MISS_NRM
+
+} GXEvent;
+
+/********************************/
+typedef enum _GXFBClamp
+{
+    GX_CLAMP_NONE,
+    GX_CLAMP_TOP,
+    GX_CLAMP_BOTTOM
+
+} GXFBClamp;
+
+/********************************/
+typedef enum _GXAnisotropy
+{
+    GX_ANISO_1,
+    GX_ANISO_2,
+    GX_ANISO_4,
+    GX_MAX_ANISOTROPY
+
+} GXAnisotropy;
+
+/********************************/
+typedef enum _GXZTexOp
+{
+    GX_ZT_DISABLE,
+    GX_ZT_ADD,
+    GX_ZT_REPLACE,
+    GX_MAX_ZTEXOP
+
+} GXZTexOp;
+
+/********************************/
+typedef enum _GXAlphaReadMode
+{
+    GX_READ_00,
+    GX_READ_FF,
+    GX_READ_NONE
+
+} GXAlphaReadMode;
+
+/********************************/
+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 _GXCopyMode
+{
+    GX_COPY_PROGRESSIVE = 0,
+    GX_COPY_INTLC_EVEN  = 2,
+    GX_COPY_INTLC_ODD   = 3
+
+} GXCopyMode;
+
+/********************************/
+typedef enum _GXMiscToken
+{
+    GX_MT_XF_FLUSH           = 1,
+    GX_MT_DL_SAVE_CONTEXT    = 2,
+    GX_MT_ABORT_WAIT_COPYOUT = 3, 
+    GX_MT_NULL               = 0
+
+} GXMiscToken;
+
+/********************************/
+typedef enum _GXXFFlushVal
+{
+    GX_XF_FLUSH_NONE  = 0,
+    GX_XF_FLUSH_SAFE  = 8
+
+} GXXFFlushVal;
+
+/********************************/
+// Compile-time checks to ensure that enumerations are compiled
+// as 32-bit integers.  If your build breaks at this line,
+// please ensure that you enable the "enumerations are integers"
+// option for the compiler.
+
+#define GXCTASSERT(cond)  int GXCTASSERT( int assertion_failed[ (cond) != 0 ] )
+
+GXCTASSERT(sizeof(GXAttrType) == sizeof(u32));
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXENUM_H__
diff --git a/include/rvl/GXGeometry.h b/include/rvl/GXGeometry.h
new file mode 100755
index 0000000..b85a4f0
--- /dev/null
+++ b/include/rvl/GXGeometry.h
@@ -0,0 +1,82 @@
+#ifndef __GXGEOMETRY_H__
+#define __GXGEOMETRY_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+#include "rvl/GXStruct.h"
+
+void GXSetVtxDesc           ( GXAttr attr, GXAttrType type );
+void GXSetVtxDescv          ( const GXVtxDescList *attrPtr );
+void GXClearVtxDesc         ( void );
+
+void GXSetVtxAttrFmt( 
+    GXVtxFmt       vtxfmt, 
+    GXAttr         attr, 
+    GXCompCnt      cnt, 
+    GXCompType     type, 
+    u8             frac );
+
+void GXSetVtxAttrFmtv       ( GXVtxFmt vtxfmt, const GXVtxAttrFmtList *list );
+void GXSetArray             ( GXAttr attr, const void *base_ptr, u8 stride );
+void GXBegin                ( GXPrimitive type, GXVtxFmt vtxfmt, u16 nverts );
+
+#if defined(EMU) || defined(WIN32)
+void GXEnd                  ( void );
+#else // !EMU
+static inline void GXEnd           ( void )
+{
+#ifdef _DEBUG
+    extern GXBool __GXinBegin;
+    if (!__GXinBegin)
+        OSPanic(__FILE__, __LINE__, "GXEnd: called without a GXBegin");
+    __GXinBegin = GX_FALSE;
+#endif
+}
+#endif // EMU
+
+#if ( GX_REV != 1 ) // GX revision 2 or later only
+void GXSetTexCoordGen2(
+    GXTexCoordID     dst_coord,
+    GXTexGenType     func,
+    GXTexGenSrc      src_param,
+    u32              mtx,
+    GXBool           normalize,
+    u32              postmtx );
+#endif // ( GX_REV != 1 )
+
+#if ( GX_REV == 1 || defined(EMU) ) // GX revision 1 or emulator
+void GXSetTexCoordGen( 
+    GXTexCoordID     dst_coord,
+    GXTexGenType     func,
+    GXTexGenSrc      src_param,
+    u32              mtx );
+#else // GX revision 2 or later and real hardware
+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);
+}
+#endif // ( GX_REV == 1 || defined(EMU) )
+
+
+void GXSetNumTexGens        ( u8 nTexGens );
+
+void GXInvalidateVtxCache   ( void );
+void GXSetLineWidth         ( u8 width, GXTexOffset texOffsets );
+void GXSetPointSize         ( u8 pointSize, GXTexOffset texOffsets );
+void GXEnableTexOffsets	    ( GXTexCoordID coord, GXBool line_enable, 
+			      GXBool point_enable );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXGEOMETRY_H__
diff --git a/include/rvl/GXLighting.h b/include/rvl/GXLighting.h
new file mode 100755
index 0000000..26139b9
--- /dev/null
+++ b/include/rvl/GXLighting.h
@@ -0,0 +1,94 @@
+#ifndef __GXLIGHTING_H__
+#define __GXLIGHTING_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+#include "rvl/GXStruct.h"
+
+/*---------------------------------------------------------------------------*/
+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 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 GXInitLightColor 	( GXLightObj* lt_obj, GXColor color );
+void GXLoadLightObjImm 	( const GXLightObj* lt_obj, GXLightID light );
+void GXLoadLightObjIndx	( u32 lt_obj_indx, GXLightID light );
+void GXSetChanAmbColor 	( GXChannelID chan, GXColor amb_color );
+void GXSetChanMatColor	( GXChannelID chan, GXColor mat_color );
+void GXSetNumChans      ( u8 nChans );
+
+void GXInitLightDir 	( GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz );
+
+// New functions to set light direction and half-angle.
+void GXInitSpecularDir 	( GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz );
+void GXInitSpecularDirHA(
+        GXLightObj* lt_obj,
+        f32         nx,
+        f32         ny,
+        f32         nz,
+        f32         hx,
+        f32         hy,
+        f32         hz );
+
+void GXSetChanCtrl(
+        GXChannelID   chan,
+        GXBool        enable,
+        GXColorSrc    amb_src,
+        GXColorSrc    mat_src,
+        u32           light_mask,
+        GXDiffuseFn   diff_fn,
+        GXAttnFn      attn_fn );
+
+/*---------------------------------------------------------------------------*/
+// Convenient Macros
+
+#define GXInitLightPosv(lo,vec) \
+    (GXInitLightPos((lo), *(f32*)(vec), *((f32*)(vec)+1), *((f32*)(vec)+2)))
+
+#define GXInitLightDirv(lo,vec) \
+    (GXInitLightDir((lo), *(f32*)(vec), *((f32*)(vec)+1), *((f32*)(vec)+2)))
+
+#define GXInitSpecularDirv(lo,vec) \
+    (GXInitSpecularDir((lo), *(f32*)(vec), *((f32*)(vec)+1), *((f32*)(vec)+2)))
+
+#define GXInitSpecularDirHAv(lo,vec0,vec1) \
+    (GXInitSpecularDirHA((lo), \
+    *(f32*)(vec0), *((f32*)(vec0)+1), *((f32*)(vec0)+2), \
+    *(f32*)(vec1), *((f32*)(vec1)+1), *((f32*)(vec1)+2)))
+
+#define GXInitLightShininess(lobj, shininess) \
+    (GXInitLightAttn(lobj, 0.0F, 0.0F, 1.0F,  \
+                    (shininess)/2.0F, 0.0F,   \
+                    1.0F-(shininess)/2.0F ))
+
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXLIGHTING_H__
diff --git a/include/rvl/GXPixel.h b/include/rvl/GXPixel.h
new file mode 100755
index 0000000..ddacc88
--- /dev/null
+++ b/include/rvl/GXPixel.h
@@ -0,0 +1,49 @@
+#ifndef __GXPIXEL_H__
+#define __GXPIXEL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+#include "rvl/GXEnum.h"
+#include "rvl/GXStruct.h"
+
+/*---------------------------------------------------------------------------*/
+void GXSetFog(	GXFogType	type,
+		f32		startz,
+		f32		endz,
+		f32		nearz,
+		f32		farz,
+		GXColor		color );
+
+void GXSetFogColor( GXColor color );
+
+void GXInitFogAdjTable( GXFogAdjTable* table, u16 width, const f32 projmtx[4][4] );
+
+void GXSetFogRangeAdj( GXBool enable, u16 center, const GXFogAdjTable* table );
+
+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 );
+void GXSetFieldMask( GXBool odd_mask, GXBool even_mask );
+void GXSetFieldMode( GXBool field_mode, GXBool half_aspect_ratio );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif // __GXPIXEL_H__
+
+#endif
diff --git a/include/rvl/GXStruct.h b/include/rvl/GXStruct.h
new file mode 100755
index 0000000..2b58a98
--- /dev/null
+++ b/include/rvl/GXStruct.h
@@ -0,0 +1,132 @@
+#ifndef __GXSTRUCT_H__
+#define __GXSTRUCT_H__
+
+/********************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/********************************/
+#include "rvl/vitypes.h"
+
+/*---------------------------------------------------------------------------*/
+
+#ifdef __MWERKS__
+#pragma warn_padding    off
+#endif // __MWERKS__
+
+/*---------------------------------------------------------------------------*/
+
+/********************************/
+typedef struct _GXColor
+{
+    u8  r,
+        g, 
+        b, 
+        a;
+
+} GXColor;
+
+typedef struct _GXColorS10
+{
+    s16    r, g, b, a; // s10-bit components for Tev constant color
+} GXColorS10;
+
+/********************************/
+typedef struct _GXTexObj
+{
+#ifdef EMU
+    u32 dummy[16]; // emulator version
+#else
+    u32 dummy[8];  // real hardware version
+#endif    
+} GXTexObj;
+
+/********************************/
+typedef struct _GXTlutObj
+{
+    u32 dummy[3];
+    
+} GXTlutObj;
+
+/********************************/
+typedef struct _GXLightObj
+{
+    u32 dummy[16];
+    
+} GXLightObj;
+
+/********************************/
+typedef struct _GXVtxAttrFmtList
+{
+    GXAttr        attr;
+    GXCompCnt     cnt;
+    GXCompType    type;
+    u8            frac;
+    
+} GXVtxAttrFmtList;
+
+/********************************/
+typedef struct _GXTexRegion
+{
+#ifdef EMU
+    u32 dummy[8]; // emulator version
+#else
+    u32 dummy[4]; // real hardware version
+#endif
+} GXTexRegion;
+
+/********************************/
+typedef struct _GXTlutRegion
+{
+    u32 dummy[4];
+    
+} GXTlutRegion;
+
+/********************************/
+typedef struct _GXVtxDescList
+{
+    GXAttr        attr;
+    GXAttrType    type;
+    
+} GXVtxDescList;
+
+/********************************/
+typedef struct _GXRenderModeObj
+{
+    VITVMode          viTVmode;
+    u16               fbWidth;   // no xscale from efb to xfb
+    u16               efbHeight; // embedded frame buffer
+    u16               xfbHeight; // external frame buffer, may yscale efb
+    u16               viXOrigin;
+    u16               viYOrigin;
+    u16               viWidth;
+    u16               viHeight;
+    VIXFBMode         xFBmode;   // whether single-field or double-field in 
+                                 // XFB.
+    u8                field_rendering;    // rendering fields or frames?
+    u8                aa;                 // anti-aliasing on?
+    u8                sample_pattern[12][2]; // aa sample pattern
+    u8                vfilter[7];         // vertical filter coefficients
+} GXRenderModeObj;
+
+/********************************/
+typedef struct _GXFogAdjTable
+{
+    u16			r[10];
+} GXFogAdjTable;
+
+/********************************/
+
+/*---------------------------------------------------------------------------*/
+
+#ifdef __MWERKS__
+#pragma warn_padding    reset
+#endif // __MWERKS__
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/rvl/GXTev.h b/include/rvl/GXTev.h
new file mode 100755
index 0000000..1cecafc
--- /dev/null
+++ b/include/rvl/GXTev.h
@@ -0,0 +1,92 @@
+#ifndef __GXTEV_H__
+#define __GXTEV_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+#include "rvl/GXStruct.h"
+
+/*---------------------------------------------------------------------------*/
+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 );
+
+// Feature available in GX chip revision 1 only
+// Revision 2 version is defined, but only prints error msg
+void GXSetTevClampMode ( GXTevStageID stage, GXTevClampMode mode );
+
+void GXSetAlphaCompare(
+    GXCompare       comp0,
+    u8              ref0,
+    GXAlphaOp       op,
+    GXCompare       comp1,
+    u8              ref1 );
+
+void GXSetTevOrder(
+    GXTevStageID    stage, 
+    GXTexCoordID    coord,
+    GXTexMapID      map,
+    GXChannelID     color );
+
+void GXSetZTexture ( GXZTexOp op, GXTexFmt fmt, u32 bias );
+void GXSetNumTevStages( u8 nStages );
+
+#if ( GX_REV != 1 )
+// Features available in GX chip revision 2 or later only
+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 );
+
+#endif // ( GX_REV != 1 )
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXTEV_H__
diff --git a/include/rvl/GXTexture.h b/include/rvl/GXTexture.h
new file mode 100755
index 0000000..b51f6d5
--- /dev/null
+++ b/include/rvl/GXTexture.h
@@ -0,0 +1,127 @@
+#ifndef __GXTEXTURE_H__
+#define __GXTEXTURE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef GXTexRegion*  (*GXTexRegionCallback) (const GXTexObj* t_obj, GXTexMapID id);
+typedef GXTlutRegion* (*GXTlutRegionCallback)(u32 idx);
+
+/*---------------------------------------------------------------------------*/
+void GXInitTexObj(
+         GXTexObj*      obj,
+         void*          image_ptr,
+         u16            width,
+         u16            height,
+         GXTexFmt       format,
+         GXTexWrapMode  wrap_s,
+         GXTexWrapMode  wrap_t,
+         GXBool         mipmap);
+
+void GXInitTexObjCI(
+         GXTexObj*      obj,
+         void*          image_ptr,
+         u16            width,
+         u16            height,
+         GXCITexFmt     format,
+         GXTexWrapMode  wrap_s,
+         GXTexWrapMode  wrap_t,
+         GXBool         mipmap,
+         u32            tlut_name);
+
+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  GXInitTexObjData     ( GXTexObj* obj, void* image_ptr );
+void  GXInitTexObjWrapMode ( GXTexObj* obj, GXTexWrapMode s, GXTexWrapMode t );
+void  GXInitTexObjTlut     ( GXTexObj* obj, u32 tlut_name );
+void  GXInitTexObjFilter   ( GXTexObj* obj, GXTexFilter min_filt, GXTexFilter mag_filt );
+void  GXInitTexObjMaxLOD   ( GXTexObj* obj, f32 max_lod );
+void  GXInitTexObjMinLOD   ( GXTexObj* obj, f32 min_lod );
+void  GXInitTexObjLODBias  ( GXTexObj* obj, f32 lod_bias );
+void  GXInitTexObjBiasClamp( GXTexObj* obj, GXBool bias_clamp );
+void  GXInitTexObjEdgeLOD  ( GXTexObj* obj, GXBool do_edge_lod );
+void  GXInitTexObjMaxAniso ( GXTexObj* obj, GXAnisotropy max_aniso );
+
+
+void  GXInitTexObjUserData ( GXTexObj* obj, void* user_data );
+void* GXGetTexObjUserData  ( const GXTexObj* obj );
+
+void  GXLoadTexObj         ( const GXTexObj* obj, GXTexMapID id );
+
+u32   GXGetTexBufferSize(
+          u16           width,
+          u16           height,
+          u32           format,
+          GXBool        mipmap,
+          u8            max_lod );
+
+void GXInitTlutObj(
+         GXTlutObj* tlut_obj,
+         void*      lut,
+         GXTlutFmt  fmt,
+         u16        n_entries );
+
+void GXLoadTlut             ( const GXTlutObj* tlut_obj, u32 tlut_name );
+
+void GXInitTexCacheRegion(
+         GXTexRegion*      region,
+         GXBool            is_32b_mipmap,
+         u32               tmem_even,
+         GXTexCacheSize    size_even,
+         u32               tmem_odd,
+         GXTexCacheSize    size_odd );
+
+void GXInitTexPreLoadRegion(
+         GXTexRegion*      region,
+         u32               tmem_even,
+         u32               size_even,
+         u32               tmem_odd,
+         u32               size_odd );
+
+void GXInitTlutRegion(
+         GXTlutRegion*     region,
+         u32               tmem_addr,
+         GXTlutSize        tlut_size );
+
+void GXInvalidateTexRegion  ( const GXTexRegion* region );
+void GXInvalidateTexAll     ( void );
+void GXPreLoadEntireTexture ( const GXTexObj* tex_obj, const GXTexRegion* region );
+
+GXTexRegionCallback  GXSetTexRegionCallback ( GXTexRegionCallback f );
+GXTlutRegionCallback GXSetTlutRegionCallback( GXTlutRegionCallback f );
+
+void GXLoadTexObjPreLoaded(
+         const GXTexObj*    obj, 
+         const GXTexRegion* region, 
+         GXTexMapID         id );
+
+void GXSetTexCoordScaleManually(GXTexCoordID coord,
+                                GXBool enable,
+                                u16 ss, u16 ts);
+
+void GXSetTexCoordCylWrap(GXTexCoordID coord,
+                          GXBool s_enable,
+                          GXBool t_enable);
+
+void GXSetTexCoordBias(GXTexCoordID coord,
+                       GXBool s_enable,
+                       GXBool t_enable);
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXTEXTURE_H__
diff --git a/include/rvl/GXTransform.h b/include/rvl/GXTransform.h
new file mode 100755
index 0000000..15c508a
--- /dev/null
+++ b/include/rvl/GXTransform.h
@@ -0,0 +1,71 @@
+#ifndef __GXTRANSFORM_H__
+#define __GXTRANSFORM_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+#define GX_PROJECTION_SZ  7
+#define GX_VIEWPORT_SZ    6
+
+/*---------------------------------------------------------------------------*/
+void GXSetProjection ( const f32 mtx[4][4], GXProjectionType type );
+void GXSetProjectionv ( const f32 *ptr );
+void GXLoadPosMtxImm ( const f32 mtx[3][4], u32 id );
+void GXLoadPosMtxIndx ( u16 mtx_indx, u32 id );
+void GXLoadNrmMtxImm ( const f32 mtx[3][4], u32 id );
+void GXLoadNrmMtxImm3x3 ( const f32 mtx[3][3], u32 id );
+void GXLoadNrmMtxIndx3x3 ( u16 mtx_indx, u32 id );
+void GXSetCurrentMtx ( u32 id );
+void GXLoadTexMtxImm ( const f32 mtx[][4], u32 id, GXTexMtxType type );
+void GXLoadTexMtxIndx ( u16 mtx_indx, u32 id, GXTexMtxType type );
+
+void GXProject ( 
+	f32  x,          // model coordinates
+	f32  y,
+	f32  z,
+	const f32  mtx[3][4],  // model-view matrix
+	const f32* pm,         // projection matrix, as returned by GXGetProjectionv
+	const f32* vp,         // viewport, as returned by GXGetViewportv
+	f32* sx,         // screen coordinates
+	f32* sy,
+	f32* sz );
+
+void GXSetViewport(
+         f32 left, 
+         f32 top, 
+         f32 wd, 
+         f32 ht, 
+         f32 nearz, 
+         f32 farz );
+
+static inline void GXSetViewportv( const f32 *vp )
+{   // Note: doesn't check for NULL ptr
+    GXSetViewport(vp[0], vp[1], vp[2], vp[3], vp[4], vp[5]);
+}
+
+void GXSetViewportJitter(
+         f32 left, 
+         f32 top, 
+         f32 wd, 
+         f32 ht, 
+         f32 nearz, 
+         f32 farz,
+	 u32 field );
+
+void GXSetZScaleOffset  ( f32 scale, f32 offset );
+
+#if ( GX_REV != 1 )
+void GXSetScissorBoxOffset( s32 x_off, s32 y_off );
+#endif
+
+void GXSetClipMode( GXClipMode mode );
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __GXTRANSFORM_H__
diff --git a/include/rvl/GXVert.h b/include/rvl/GXVert.h
new file mode 100755
index 0000000..8564563
--- /dev/null
+++ b/include/rvl/GXVert.h
@@ -0,0 +1,222 @@
+#ifndef __GXVERT_H__
+#define __GXVERT_H__
+
+#ifdef WIN32
+#include <win32/win32.h>
+#endif
+
+// NOTE:  This file closely mirrors GXVert.c.
+//        Don't change this file without considering that one too,
+//        and vice-versa.
+
+/********************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*>*******************************(*)*******************************<*/
+#ifndef EMU // real hardware
+/*---------------------------------------------*
+ * Write gather pipe for GFXFifo               *
+ *---------------------------------------------*/
+#ifndef MINNOW
+#define   GXFIFO_ADDR   0xCC008000
+#else // MINNOW
+#define   GXFIFO_ADDR   0x1C008000
+#endif// MINNOW
+
+// SN-Phil: removed 'extern', added AT_ADDRESS
+//volatile PPCWGPipe GXWGFifo AT_ADDRESS(GXFIFO_ADDR) ;
+extern volatile PPCWGPipe GXWGFifo;
+
+#endif // !EMU
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------*
+ * GXVertex functions                          *
+ *---------------------------------------------*/
+//-------------------------------
+// Define gfx function templates
+//-------------------------------
+//
+// Templates syntax:
+//  __GXCDEF (function_prefix, num_of_components, component_type)
+//  __GXCDEFX(function_name, num_of_comps, src_comp_type, dest_comp_type)
+//
+#define __GXCDEF(prfx,n,t)  __GXCDEF##n(prfx##n##t,t,t)
+#define __GXCDEFX(func,n,t) __GXCDEF##n(func,t,t)
+
+#ifdef _DEBUG
+
+// 1 component
+#define __GXCDEF1(func,ts,td) \
+    void func(const ts x);
+
+// 2 components
+#define __GXCDEF2(func,ts,td) \
+    void func(const ts x, const ts y);
+
+// 3 components
+#define __GXCDEF3(func,ts,td) \
+    void func(const ts x, const ts y, const ts z);
+
+// 4 components
+#define __GXCDEF4(func,ts,td) \
+    void func(const ts x, const ts y, const ts z, const ts w);
+
+
+#else // ifdef _DEBUG
+/*---------------------------------------------*
+ * For real hardware                           *
+ *---------------------------------------------*/
+#ifndef EMU
+
+// 1 component
+#define __GXCDEF1(func,ts,td) \
+    static inline void func(const ts x) \
+    {                         \
+        GXWGFifo._##td = (td) x; \
+        return;               \
+    }
+
+// 2 components
+#define __GXCDEF2(func,ts,td) \
+    static inline void func(const ts x, const ts y) \
+    {                         \
+        GXWGFifo._##td = (td) x; \
+        GXWGFifo._##td = (td) y; \
+        return;               \
+    }
+
+// 3 components
+#define __GXCDEF3(func,ts,td) \
+    static inline void func(const ts x, const ts y, const ts z) \
+    {                         \
+        GXWGFifo._##td = (td) x; \
+        GXWGFifo._##td = (td) y; \
+        GXWGFifo._##td = (td) z; \
+        return;               \
+    }
+
+// 4 components
+#define __GXCDEF4(func,ts,td) \
+    static inline void func(const ts x, const ts y, const ts z, const ts w) \
+    {                         \
+        GXWGFifo._##td = (td) x; \
+        GXWGFifo._##td = (td) y; \
+        GXWGFifo._##td = (td) z; \
+        GXWGFifo._##td = (td) w; \
+        return;               \
+    }
+
+#endif // ifndef EMU
+
+#endif // ifdef _DEBUG else
+
+//---------------------------
+// Generate inline functions
+//---------------------------
+//---- GXCmd[n][t] ----
+__GXCDEF( GXCmd, 1, u8  )
+__GXCDEF( GXCmd, 1, u16 )
+__GXCDEF( GXCmd, 1, u32 )
+
+//---- GXParam[n][t] ----
+__GXCDEF( GXParam, 1, u8  )
+__GXCDEF( GXParam, 1, u16 )
+__GXCDEF( GXParam, 1, u32 )
+__GXCDEF( GXParam, 1, s8  )
+__GXCDEF( GXParam, 1, s16 )
+__GXCDEF( GXParam, 1, s32 )
+__GXCDEF( GXParam, 1, f32 )
+__GXCDEF( GXParam, 3, f32 ) // for light
+__GXCDEF( GXParam, 4, f32 ) // for matrix
+
+//---- GXPosition[n][t] ----
+  // for GX_POS_XYZ
+__GXCDEF( GXPosition, 3, f32 )
+__GXCDEF( GXPosition, 3, u8  )
+__GXCDEF( GXPosition, 3, s8  )
+__GXCDEF( GXPosition, 3, u16 )
+__GXCDEF( GXPosition, 3, s16 )
+  // for GX_POS_XY
+__GXCDEF( GXPosition, 2, f32 )
+__GXCDEF( GXPosition, 2, u8  )
+__GXCDEF( GXPosition, 2, s8  )
+__GXCDEF( GXPosition, 2, u16 )
+__GXCDEF( GXPosition, 2, s16 )
+  // for Index
+__GXCDEFX( GXPosition1x16, 1, u16 )
+__GXCDEFX( GXPosition1x8,  1, u8  )
+
+//---- GXNormal[n][t] ----
+  // for GX_NRM or GX_NBT
+__GXCDEF( GXNormal, 3, f32 )
+__GXCDEF( GXNormal, 3, s16 )
+__GXCDEF( GXNormal, 3, s8  )
+  // for Index
+__GXCDEFX( GXNormal1x16, 1, u16 )
+__GXCDEFX( GXNormal1x8,  1, u8  )
+
+//---- GXColor[n][t] ----
+  // for GX_CLR_RGBA8 or RGBX8
+__GXCDEF( GXColor, 4, u8  )
+__GXCDEF( GXColor, 1, u32 )
+  // for GX_CLR_RGBA6 or RGB8
+__GXCDEF( GXColor, 3, u8  )
+  // for GX_CLR_RGBA4 or RGB565
+__GXCDEF( GXColor, 1, u16 )
+  // for Index
+__GXCDEFX( GXColor1x16, 1, u16 )
+__GXCDEFX( GXColor1x8,  1, u8  )
+
+//---- GXTexCoord[n][t] ----
+  // for GX_TEX_ST
+__GXCDEF( GXTexCoord, 2, f32 )
+__GXCDEF( GXTexCoord, 2, s16 )
+__GXCDEF( GXTexCoord, 2, u16 )
+__GXCDEF( GXTexCoord, 2, s8  )
+__GXCDEF( GXTexCoord, 2, u8  )
+  // for GX_TEX_S
+__GXCDEF( GXTexCoord, 1, f32 )
+__GXCDEF( GXTexCoord, 1, s16 )
+__GXCDEF( GXTexCoord, 1, u16 )
+__GXCDEF( GXTexCoord, 1, s8  )
+__GXCDEF( GXTexCoord, 1, u8  )
+  // for Index
+__GXCDEFX( GXTexCoord1x16, 1, u16 )
+__GXCDEFX( GXTexCoord1x8,  1, u8  )
+
+//---- GXMatrixIndex* ----
+// GXMatrixIndex1u8
+__GXCDEF( GXMatrixIndex, 1, u8 )
+#define GXMatrixIndex1x8    GXMatrixIndex1u8
+
+//------------------------
+// Undefine all templates
+//------------------------
+#undef  __GXCDEF
+#undef  __GXCDEFX
+#undef  __GXCDEF1
+#undef  __GXCDEF2
+#undef  __GXCDEF3
+#undef  __GXCDEF4
+
+/*---------------------------------------------------------------------------*/
+// Packing macro for a several color format
+#define	GXPackedRGB565(r,g,b)   \
+	((u16)((((r)&0xf8)<<8)|(((g)&0xfc)<<3)|(((b)&0xf8)>>3)))
+#define	GXPackedRGBA4(r,g,b,a)  \
+	((u16)((((r)&0xf0)<<8)|(((g)&0xf0)<<4)|(((b)&0xf0)   )|(((a)&0xf0)>>4)))
+#define	GXPackedRGB5A3(r,g,b,a) \
+	((u16)((a)>=224 ? \
+	((((r)&0xf8)<<7)|(((g)&0xf8)<<2)|(((b)&0xf8)>>3)|(1<<15)): \
+	((((r)&0xf0)<<4)|(((g)&0xf0)   )|(((b)&0xf0)>>4)|(((a)&0xe0)<<7))))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __GXVERT_H__
+
diff --git a/include/rvl/OSCache.h b/include/rvl/OSCache.h
new file mode 100755
index 0000000..0957139
--- /dev/null
+++ b/include/rvl/OSCache.h
@@ -0,0 +1,61 @@
+/*
+    This header file defines the most common high level cache operations.
+    For finer grain control over the caches, use OSDC.h, OSIC.h, and OSLC.h
+    for data cache, instruction cache, and locked cache routines respectively.
+ */
+
+#ifndef __OSCACHE_H__
+#define __OSCACHE_H__
+
+/*#include <revolution/types.h>
+#include <revolution/os/OSDC.h>
+#include <revolution/os/OSIC.h>
+#include <revolution/os/OSL2.h>
+#include <revolution/os/OSLC.h>*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*
+    L1 Data Cache Operations
+ *---------------------------------------------------------------------------*/
+
+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 );
+
+/*---------------------------------------------------------------------------*
+    L1 Instruction Cache Operations
+ *---------------------------------------------------------------------------*/
+
+void ICInvalidateRange  ( void* addr, u32 nBytes );
+
+/*---------------------------------------------------------------------------*
+    Locked Cache Operations
+ *---------------------------------------------------------------------------*/
+// 0xEnnn nnnn addresses will be mapped in by LCEnable (DBAT3 will be used)
+#define LC_BASE_PREFIX  0xE000
+#define LC_BASE         (LC_BASE_PREFIX << 16)
+
+void LCEnable           ( void );
+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 );
+
+#define LCGetBase()     ((void*)LC_BASE)
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __OSCACHE_H__
diff --git a/include/rvl/PPCWGPipe.h b/include/rvl/PPCWGPipe.h
new file mode 100755
index 0000000..1354a93
--- /dev/null
+++ b/include/rvl/PPCWGPipe.h
@@ -0,0 +1,37 @@
+#ifndef __PPCWGPIPE_H__
+#define __PPCWGPIPE_H__
+
+#ifdef  __cplusplus
+extern  "C" {
+#endif
+
+/*---------------------------------------------------------------------------*
+    PPC Write Gather Pipe
+
+    Write Gather Pipe is defined as:
+        PPCWGPipe wgpipe : <Write Gathered Address>;
+
+    Then, used as:
+        wgpipe.u8  = 0xff;
+        wgpipe.s16 = -5;
+        wgpipe.f32 = 0.10f;
+ *---------------------------------------------------------------------------*/
+typedef union uPPCWGPipe
+{
+    u8  _u8;
+    u16 _u16;
+    u32 _u32;
+    u64 _u64;
+    s8  _s8;
+    s16 _s16;
+    s32 _s32;
+    s64 _s64;
+    f32 _f32;
+    f64 _f64;
+} PPCWGPipe;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  //__PPCWGPIPE_H__
diff --git a/include/rvl/arc.h b/include/rvl/arc.h
new file mode 100755
index 0000000..94d5d5b
--- /dev/null
+++ b/include/rvl/arc.h
@@ -0,0 +1,115 @@
+#ifndef __ARC_H__
+#define __ARC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    unsigned int    magic;
+    int             fstStart;
+    int             fstSize;
+    int             fileStart;
+    int             reserve[4];
+    
+} ARCHeader;
+
+#define DARCH_MAGIC         0x55aa382d
+
+typedef struct
+{
+    void*       archiveStartAddr;
+    void*       FSTStart;
+    void*       fileStart;
+    u32         entryNum;
+    char*       FSTStringStart;
+    u32         FSTLength;
+    u32         currDir;
+    
+} ARCHandle;
+
+typedef struct
+{
+    ARCHandle*  handle;
+    u32         startOffset;
+    u32         length;
+
+} ARCFileInfo;
+
+typedef struct
+{
+    ARCHandle*  handle;
+    u32         entryNum;
+    u32         location;
+    u32         next;
+} ARCDir;
+
+typedef struct 
+{
+    ARCHandle*  handle;
+    u32         entryNum;
+    BOOL        isDir;
+    char*       name;
+} ARCDirEntry;
+
+
+BOOL  ARCInitHandle(void* arcStart, ARCHandle* handle);
+BOOL  ARCOpen(ARCHandle* handle, const char* fileName, ARCFileInfo* af);
+BOOL  ARCFastOpen(ARCHandle* handle, s32 entrynum, ARCFileInfo* af);
+s32   ARCConvertPathToEntrynum(ARCHandle* handle, const char* pathPtr);
+void* ARCGetStartAddrInMem(ARCFileInfo* af);
+u32   ARCGetStartOffset(ARCFileInfo* af);
+u32   ARCGetLength(ARCFileInfo* af);
+BOOL  ARCClose(ARCFileInfo* af);
+
+BOOL  ARCChangeDir(ARCHandle* handle, const char* dirName);
+BOOL  ARCGetCurrentDir(ARCHandle* handle, char* path, u32 maxlen);
+
+BOOL  ARCOpenDir(ARCHandle* handle, const char* dirName, ARCDir* dir);
+BOOL  ARCReadDir(ARCDir* dir, ARCDirEntry* dirent);
+BOOL  ARCCloseDir(ARCDir* dir);
+
+/*---------------------------------------------------------------------------*
+  Name:         ARCTellDir
+
+  Description:  Returns the current location associated with the directory
+
+  Arguments:    dir         Pre-opened ARCDir* structure
+
+  Returns:      current location
+ *---------------------------------------------------------------------------*/
+#define ARCTellDir(dir)             ((dir)->location)
+
+/*---------------------------------------------------------------------------*
+  Name:         ARCSeekDir
+
+  Description:  Sets the position of the next ARCReadDir on the directory
+
+  Arguments:    dir         Pre-opened ARCDir* structure
+                loc         location to set
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+#define ARCSeekDir(dir, loc)        ((dir)->location = loc)
+
+/*---------------------------------------------------------------------------*
+  Name:         ARCRewindDir
+
+  Description:  Resets the position of the directory to the beginning
+
+  Arguments:    dir         Pre-opened ARCDir* structure
+
+  Returns:      None
+ *---------------------------------------------------------------------------*/
+#define ARCRewindDir(dir)           ((dir)->location = (dir)->entryNum + 1)
+
+#define ARCGetDirEntryName(dirent)  ((dirent)->name)
+#define ARCDirEntryIsDir(dirent)    ((dirent)->isDir)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // __ARC_H__
diff --git a/include/rvl/mtx.h b/include/rvl/mtx.h
new file mode 100755
index 0000000..3bb804e
--- /dev/null
+++ b/include/rvl/mtx.h
@@ -0,0 +1,441 @@
+#ifndef __MTX_H__
+#define __MTX_H__
+
+
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*
+    Default function binding configuration
+ *---------------------------------------------------------------------------*/
+// [Binding Rule]
+//
+// "MTX_USE_PS" -> When this flag is specified, it uses PS* (Paired-Single
+//                 assembler code) functions for non-prefixed function calls.
+// "MTX_USE_C " -> When this flag is specified, it uses C_* (C code) functions
+//                 for non-prefixed function calls.
+//
+// If both are specified, it will be treated as MTX_USE_PS.
+// If nothing is specified, NDEBUG build refers PS* functions and
+// DEBUG build uses C_* functions.
+
+// For non-Gekko HW (e.g. emulator)
+#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
+
+/*---------------------------------------------------------------------------*
+    Macro definitions
+ *---------------------------------------------------------------------------*/
+
+// MtxPtr offset to access next Mtx of an array
+#define MTX_PTR_OFFSET      3
+
+// Mtx44Ptr offset to access next Mtx44 of an array
+#define MTX44_PTR_OFFSET    4   
+
+
+// matrix stack
+typedef struct				    
+{            
+
+    u32    numMtx;
+    MtxPtr stackBase;
+    MtxPtr stackPtr;
+	
+} MtxStack, *MtxStackPtr;
+
+ 
+// degree <--> radian conversion macros
+#define MTXDegToRad(a)   ( (a) *  0.01745329252f )
+#define MTXRadToDeg(a)   ( (a) * 57.29577951f )
+
+
+// Matrix-element-referencing macro.
+// Insulates user from changes from row-major to column-major and vice-versa.
+// Fully documents which index is row, which index is column.
+// XXX this version will change once matrices are transposed.
+
+#define MTXRowCol(m,r,c) ((m)[(r)][(c)])
+
+
+/*---------------------------------------------------------------------------*
+    GENERAL MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// C version
+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 );
+
+// PS assembler version
+#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
+
+// Bindings
+#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 // MTX_USE_C
+#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
+
+
+/*---------------------------------------------------------------------------*
+    MATRIX-VECTOR SECTION
+ *---------------------------------------------------------------------------*/
+// C version
+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 );
+
+// PS assembler version
+#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
+
+// Bindings
+#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
+
+
+/*---------------------------------------------------------------------------*
+    MODEL MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// C version
+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 );
+
+// PS assembler version
+#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
+
+// Bindings
+#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
+
+
+// Obsolete. Don't use this if possible.
+#define MTXRotAxis              MTXRotAxisDeg
+
+
+/*---------------------------------------------------------------------------*
+    VIEW MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// C version only so far
+void    C_MTXLookAt         ( Mtx            m, 
+                              const Point3d *camPos, 
+                              const Vec     *camUp, 
+                              const Point3d *target );
+
+// Bindings
+#define MTXLookAt               C_MTXLookAt
+
+
+/*---------------------------------------------------------------------------*
+    PROJECTION MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// C version only so far
+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 );
+
+// Bindings
+#define MTXFrustum              C_MTXFrustum
+#define MTXPerspective          C_MTXPerspective
+#define MTXOrtho                C_MTXOrtho
+
+
+/*---------------------------------------------------------------------------*
+    TEXTURE PROJECTION MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// C version only so far
+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 );
+
+// Bindings
+#define MTXLightFrustum         C_MTXLightFrustum
+#define MTXLightPerspective     C_MTXLightPerspective
+#define MTXLightOrtho           C_MTXLightOrtho
+
+
+/*---------------------------------------------------------------------------*
+    VECTOR   SECTION
+ *---------------------------------------------------------------------------*/
+// C version
+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 );
+
+// PS assembler version
+#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
+
+// Bindings
+#ifdef MTX_USE_PS
+#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
+
+
+/*---------------------------------------------------------------------------*
+    QUATERNION SECTION
+ *---------------------------------------------------------------------------*/
+// C version
+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 );
+
+
+// PS assembler version
+#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
+
+
+// Bindings
+#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
+
+
+/*---------------------------------------------------------------------------*
+    SPECIAL PURPOSE MATRIX SECTION
+ *---------------------------------------------------------------------------*/
+// Only PS assembler versions are available
+#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
+
+
+/*---------------------------------------------------------------------------*
+    MATRIX STACK SECTION
+ *---------------------------------------------------------------------------*/
+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 );
+
+
+// macro to create a matrix stack.
+// the macro exposes the  use of OSAlloc() for
+// ease of replacement if desired.
+#define MTXAllocStack( sPtr, numMtx ) (  ((MtxStackPtr)(sPtr))->stackBase = (MtxPtr)OSAlloc( ( (numMtx) * sizeof(Mtx) ) )  )
+ 
+// macro to free a matrix stack
+#define MTXFreeStack( sPtr )    (  OSFree( (void*)( ((MtxStackPtr)(sPtr))->stackBase ) )  )
+ 
+
+/*---------------------------------------------------------------------------*/
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __MTX_H__
+
+/*===========================================================================*/
+
diff --git a/include/rvl/tpl.h b/include/rvl/tpl.h
new file mode 100755
index 0000000..9e68fac
--- /dev/null
+++ b/include/rvl/tpl.h
@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------*
+  This TPL library provides a simple interface for TPL files, which used
+  to be the texture data format for the character pipeline in the Nintendo GameCube
+  software development kit.
+  This file also contains wrapper definitions for the conventional TEX API in
+  the new library.
+ *---------------------------------------------------------------------------*/
+
+#ifndef TPL_H
+#define TPL_H
+
+/*---------------------------------------------------------------------------*/
+#include "rvl/GXTexture.h"
+
+// Macros for conventional character pipeline functions
+#ifdef  COMPATIBLE_OLD_TEXPALETTE
+
+#define TEXPalettePtr       TPLPalettePtr
+#define TEXDescriptorPtr    TPLDescriptorPtr
+#define TEXGetPalette       TPLGetPalette
+#define TEXReleasePalette   TPLReleasePalette
+#define TEXGet              TPLGet
+
+#define TEXGetGXTexObjFromPalette   TPLGetGXTexObjFromPalette
+#define TEXGetGXTexObjFromPaletteCI TPLGetGXTexObjFromPaletteCI
+
+#endif
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*
+    Structure definitions
+ *---------------------------------------------------------------------------*/
+typedef struct
+{
+    u16             numEntries;
+    u8              unpacked;
+    u8              pad8;
+
+    GXTlutFmt       format;
+    Ptr             data;
+
+} TPLClutHeader, *TPLClutHeaderPtr;
+
+/*---------------------------------------------------------------------------*/
+typedef struct
+{
+    u16             height;
+    u16             width;
+
+    u32             format;
+    Ptr             data;
+
+    GXTexWrapMode   wrapS;
+    GXTexWrapMode   wrapT;
+
+    GXTexFilter     minFilter;
+    GXTexFilter     magFilter;
+
+    float           LODBias;
+
+    u8              edgeLODEnable;
+    u8              minLOD;
+    u8              maxLOD;
+    u8              unpacked;
+
+} TPLHeader, *TPLHeaderPtr;
+
+/*---------------------------------------------------------------------------*/
+typedef struct
+{
+    TPLHeaderPtr        textureHeader;
+    TPLClutHeaderPtr    CLUTHeader;
+
+} TPLDescriptor, *TPLDescriptorPtr;
+
+/*---------------------------------------------------------------------------*/
+typedef struct
+{
+    u32                 versionNumber;
+
+    u32                 numDescriptors;
+    TPLDescriptorPtr    descriptorArray;
+
+} TPLPalette, *TPLPalettePtr;
+
+/*---------------------------------------------------------------------------*
+    Function prototypes
+ *---------------------------------------------------------------------------*/
+void                TPLBind         ( TPLPalettePtr pal );
+TPLDescriptorPtr    TPLGet          ( TPLPalettePtr pal, u32 id );
+
+void TPLGetGXTexObjFromPalette      ( TPLPalettePtr pal, GXTexObj *to, u32 id );
+void TPLGetGXTexObjFromPaletteCI    ( TPLPalettePtr pal, GXTexObj *to,
+                                      GXTlutObj *tlo, GXTlut tluts, u32 id );
+
+
+
+/*---------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/rvl/vifuncs.h b/include/rvl/vifuncs.h
new file mode 100755
index 0000000..fab95b4
--- /dev/null
+++ b/include/rvl/vifuncs.h
@@ -0,0 +1,48 @@
+#ifndef __VIFUNCS_H
+#define __VIFUNCS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "rvl/vitypes.h"
+#include "rvl/GXStruct.h"     // for GXRenderModeObj structure
+
+
+#define VIPadFrameBufferWidth(width)     ((u16)(((u16)(width) + 15) & ~15))
+
+void VIInit                  ( void );
+void VIFlush                 ( void );
+void VIWaitForRetrace        ( void );
+
+void VIConfigure             ( const GXRenderModeObj* rm );
+void VIConfigurePan          ( u16 PanPosX, u16 PanPosY,
+                               u16 PanSizeX, u16 PanSizeY );
+void VISetNextFrameBuffer    ( void *fb );
+
+void *VIGetNextFrameBuffer   ( void );
+void *VIGetCurrentFrameBuffer( void );
+
+VIRetraceCallback VISetPreRetraceCallback  (VIRetraceCallback callback);
+VIRetraceCallback VISetPostRetraceCallback (VIRetraceCallback callback);
+
+void VISetBlack              ( bool black );
+u32  VIGetRetraceCount       ( void );
+u32  VIGetNextField          ( void );
+u32  VIGetCurrentLine        ( void );
+u32  VIGetTvFormat           ( void );
+u32  VIGetScanMode           ( void );
+
+u32  VIGetDTVStatus          ( void );
+
+// For test of switch to Progressive from Interlace
+void  VISetVSyncTimingTest ( void );
+u32   VIGetVSyncTimingTest ( void );
+
+
+/********************************/
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/rvl/vitypes.h b/include/rvl/vitypes.h
new file mode 100755
index 0000000..506a4f4
--- /dev/null
+++ b/include/rvl/vitypes.h
@@ -0,0 +1,79 @@
+#ifndef __VITYPES_H
+#define __VITYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VI_DISPLAY_PIX_SZ           2
+
+#define VI_INTERLACE                0
+#define VI_NON_INTERLACE            1
+#define VI_PROGRESSIVE              2
+// 3 is reserved
+
+#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
+// 6,7,8,9 are reserved
+
+#define VI_TVMODE(FMT, INT)   ( ((FMT) << 2) + (INT) )
+
+typedef enum
+{
+    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_PAL_INT       = VI_TVMODE(VI_PAL,         VI_INTERLACE),
+    VI_TVMODE_PAL_DS        = VI_TVMODE(VI_PAL,         VI_NON_INTERLACE),
+
+    
+    VI_TVMODE_EURGB60_INT   = VI_TVMODE(VI_EURGB60,     VI_INTERLACE),
+    VI_TVMODE_EURGB60_DS    = VI_TVMODE(VI_EURGB60,     VI_NON_INTERLACE),
+    VI_TVMODE_EURGB60_PROG  = VI_TVMODE(VI_EURGB60,     VI_PROGRESSIVE),
+    
+    VI_TVMODE_MPAL_INT      = VI_TVMODE(VI_MPAL,        VI_INTERLACE),
+    VI_TVMODE_MPAL_DS       = VI_TVMODE(VI_MPAL,        VI_NON_INTERLACE),
+    VI_TVMODE_MPAL_PROG     = VI_TVMODE(VI_MPAL,        VI_PROGRESSIVE),
+    
+    VI_TVMODE_DEBUG_INT     = VI_TVMODE(VI_DEBUG,       VI_INTERLACE),
+
+    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)
+} VITVMode;
+    
+typedef enum
+{
+    VI_XFBMODE_SF = 0,
+    VI_XFBMODE_DF
+} VIXFBMode;
+
+
+#define VI_FIELD_ABOVE              1
+#define VI_FIELD_BELOW              0
+
+// Maximum screen space
+#define VI_MAX_WIDTH_NTSC           720
+#define VI_MAX_HEIGHT_NTSC          480
+
+#define VI_MAX_WIDTH_PAL            720
+#define VI_MAX_HEIGHT_PAL           574
+
+#define VI_MAX_WIDTH_MPAL           720
+#define VI_MAX_HEIGHT_MPAL          480
+
+#define VI_MAX_WIDTH_EURGB60        VI_MAX_WIDTH_NTSC
+#define VI_MAX_HEIGHT_EURGB60       VI_MAX_HEIGHT_NTSC
+
+
+typedef void (*VIRetraceCallback)(u32 retraceCount);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/stage.h b/include/stage.h
new file mode 100755
index 0000000..c89c7dc
--- /dev/null
+++ b/include/stage.h
@@ -0,0 +1,63 @@
+#ifndef __KAMEK_STAGE_H
+#define __KAMEK_STAGE_H
+
+#include <common.h>
+#include <course.h>
+
+#define STAGE_01		0
+#define STAGE_02		1
+#define STAGE_03		2
+#define STAGE_04		3
+#define STAGE_05		4
+#define STAGE_06		5
+#define STAGE_07		6
+#define STAGE_08		7
+#define STAGE_09		8
+#define STAGE_10		9
+#define STAGE_11		10
+#define STAGE_12		11
+#define STAGE_13		12
+#define STAGE_14		13
+#define STAGE_15		14
+#define STAGE_16		15
+#define STAGE_17		16
+#define STAGE_18		17
+#define STAGE_19		18
+#define STAGE_COIN		19
+#define STAGE_GHOST		20
+#define STAGE_TOWER1	21
+#define STAGE_TOWER2	22
+#define STAGE_CASTLE1	23
+#define STAGE_CASTLE2	24
+#define STAGE_TOAD1		25
+#define STAGE_TOAD2		26
+#define STAGE_TOAD3		27
+#define STAGE_TOAD4		28
+#define STAGE_ENEMY1	32
+#define STAGE_ENEMY2	33
+#define STAGE_ENEMY3	34
+#define STAGE_WARP		35
+#define STAGE_DOOMSHIP	37
+#define STAGE_HOME		38
+#define STAGE_TITLE		39
+#define STAGE_PEACH		40
+#define STAGE_STAFFROLL	41
+
+enum StageGroup {
+	Normal = 0,
+	Ghost = 1,
+	Tower = 2,
+	Castle = 3,
+	Toad = 4,
+	Enemy = 5,
+	Warp = 6,
+	Level37 = 7,
+	Doomship = 8,
+	Home = 9,
+	Peach = 10,
+	Invalid = 11
+};
+
+
+
+#endif
diff --git a/include/state.h b/include/state.h
new file mode 100755
index 0000000..b22308f
--- /dev/null
+++ b/include/state.h
@@ -0,0 +1,24 @@
+#ifndef __KAMEK_STATE_H
+#define __KAMEK_STATE_H
+
+#include <common.h>
+
+#ifdef REGION_PAL
+	#define SAVED_STATE_TABLE (*((ObjState**)(0x8042A210)))
+#endif
+
+#ifdef REGION_NTSC
+	#define SAVED_STATE_TABLE (*((ObjState**)(0x80429F30)))
+#endif
+
+struct ObjState {
+	s16 area;
+	s16 x;
+	s16 y;
+	s16 value;
+};
+
+s16 RestoreObjectState(ObjState *table, s16 area, float objX, float objY);
+s32 StoreObjectState(ObjState *table, s16 area, s16 value, float objX, float objY);
+
+#endif
-- 
cgit v1.2.3