Update lus (#16)

* Updates

.gitignore

@@ -28,6 +28,7 @@
 *.out
 *.app
 *.hex
+*.otr
 
 # Debug files
 *.dSYM/
@@ -55,7 +56,7 @@ xml/*
 
 # Torch
 include/assets/*
-tools/torch/*
+torch/*
 debug/*
 /debug/*
 

.gitmodules

@@ -10,9 +10,9 @@
 [submodule "doxygen-awesome-css"]
 	path = doxygen-awesome-css
 	url = https://github.com/jothepro/doxygen-awesome-css.git
-[submodule "tools/torch"]
+[submodule "torch"]
-	path = tools/torch
+	path = torch
-	url = https://github.com/HarbourMasters/torch
+	url = https://github.com/HarbourMasters/Torch
 [submodule "libultraship"]
 	path = libultraship
-	url = https://github.com/KiritoDv/libultraship/
+	url = https://github.com/Kenix3/libultraship

CMakeLists.txt

@@ -538,3 +538,21 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang|AppleClang")
         )
   endif()
 endif()
+
+include(ExternalProject)
+ExternalProject_Add(Torch
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/torch
+    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/torch
+)
+
+ExternalProject_Get_Property(Torch install_dir)
+set(TORCH_EXECUTABLE ${install_dir}/torch/build/x64/Debug/torch)
+
+add_custom_target(
+    ExtractAssets
+    DEPENDS Torch
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    COMMAND ${TORCH_EXECUTABLE} pack assets ship.otr
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/spaghetti.otr" "${CMAKE_BINARY_DIR}/spaghetti.otr"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/ship.otr" "${CMAKE_BINARY_DIR}/ship.otr"
+)

config.yml

@@ -7,7 +7,7 @@
     enums: 
       - include/defines.h
     output:
-      binary: mkcube.otr
+      binary: spaghetti.otr
       headers: include/assets
       code: assets/code
   metadata: [yamls/courses]

course_metadata/D_0D009418.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// choco mountain
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// bowser's castle
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// banshee boardwalk
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// yoshi valley
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// frappe snowland
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// koopa troopa beach
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// royal raceway
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// luigi raceway
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// moo moo farm
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// toad's turnpike
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// kalimari desert
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// sherbet land
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// rainbow road
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// wario stadium
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// block fort
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// skyscraper
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// double deck
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// d.k.'s jungle parkway
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// big donut
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// null
+{ 0.0f, 0.0f, 0.0f, 0.0f, },

course_metadata/D_0D009568.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// choco mountain
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// bowser's castle
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// banshee boardwalk
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// yoshi valley
+{ 3.75f, 4.5833334f, 4.5833334f, 4.5833334f, },
+// frappe snowland
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// koopa troopa beach
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// royal raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// luigi raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// moo moo farm
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// toad's turnpike
+{ 4.1666665f, 5.5833334f, 6.1666665f, 6.75f, },
+// kalimari desert
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// sherbet land
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// rainbow road
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// wario stadium
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// block fort
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// skyscraper
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// double deck
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// d.k.'s jungle parkway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// big donut
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// null
+{ 0.0f, 0.0f, 0.0f, 0.0f, },

course_metadata/D_0D0096B8.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// choco mountain
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// bowser's castle
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// banshee boardwalk
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// yoshi valley
+{ 3.3333332f, 3.3333332f, 3.3333332f, 3.3333332f, },
+// frappe snowland
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// koopa troopa beach
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// royal raceway
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// luigi raceway
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// moo moo farm
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// toad's turnpike
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// kalimari desert
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// sherbet land
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// rainbow road
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// wario stadium
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// block fort
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// skyscraper
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// double deck
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// d.k.'s jungle parkway
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// big donut
+{ 3.3333332f, 3.9166667f, 4.5f, 5.0833334f, },
+// null
+{ 0.0f, 0.0f, 0.0f, 0.0f, },

course_metadata/D_0D009808.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// choco mountain
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// bowser's castle
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// banshee boardwalk
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// yoshi valley
+{ 2.9166667f, 3.75f, 3.75f, 3.75f, },
+// frappe snowland
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// koopa troopa beach
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// royal raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// luigi raceway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// moo moo farm
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// toad's turnpike
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// kalimari desert
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// sherbet land
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// rainbow road
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// wario stadium
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// block fort
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// skyscraper
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// double deck
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// d.k.'s jungle parkway
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// big donut
+{ 3.75f, 5.1666665f, 5.75f, 6.3333334f, },
+// null
+{ 0.0f, 0.0f, 0.0f, 0.0f, },

course_metadata/D_800DCBB4.inc.c

@@ -0,0 +1 @@
+D_800DCB34, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, D_800DCAF4, 

course_metadata/gBombKartSpawns.inc.c

@@ -0,0 +1,189 @@
+{ // mario raceway
+{ 40, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 3, 0.8333333, 0, 0, 0, 0 },
+{ 265, 3, 0.8333333, 0, 0, 0, 0 },
+{ 285, 1, 0.8333333, 0, 0, 0, 0 },
+{ 420, 1, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // choco mountain
+{ 140, 3, 0.8333333, 0, 0, 0, 0 },
+{ 165, 1, 0.8333333, 0, 0, 0, 0 },
+{ 330, 3, 0.8333333, 0, 0, 0, 0 },
+{ 550, 1, 0.8333333, 0, 0, 0, 0 },
+{ 595, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // bowser's castle
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 150, 1, 0.8333333, 0, 0, 0, 0 },
+{ 200, 3, 0.8333333, 0, 0, 0, 0 },
+{ 260, 1, 0.8333333, 0, 0, 0, 0 },
+{ 435, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // banshee boardwalk
+{ 110, 3, 0.8333333, 0, 0, 0, 0 },
+{ 190, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 475, 1, 0.8333333, 0, 0, 0, 0 },
+{ 610, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // yoshi valley
+{ 0, 0, 0.8333333, -1533, -682, -103, 0 },
+{ 10, 0, 0.8333333, -1565, -619, -109, 0 },
+{ 20, 0, 0.8333333, -1529, -579, -109, 0 },
+{ 30, 0, 0.8333333, -1588, -534, -106, 0 },
+{ 40, 0, 0.8333333, -1598, -207, -105, 0 },
+{ 50, 0, 0.8333333, -1646, -147, -93, 0 },
+{ 60, 0, 0.8333333, -2532, -445, -90, 0 },
+},
+{ // frappe snowland
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 290, 1, 0.8333333, 0, 0, 0, 0 },
+{ 350, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // koopa troopa beach
+{ 60, 1, 0.8333333, 0, 0, 0, 0 },
+{ 120, 1, 0.8333333, 0, 0, 0, 0 },
+{ 200, 3, 0.8333333, 0, 0, 0, 0 },
+{ 280, 1, 0.8333333, 0, 0, 0, 0 },
+{ 435, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // royal raceway
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 3, 0.8333333, 0, 0, 0, 0 },
+{ 296, 3, 0.8333333, 0, 0, 0, 0 },
+{ 400, 1, 0.8333333, 0, 0, 0, 0 },
+{ 746, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // luigi raceway
+{ 50, 1, 0.8333333, 0, 0, 0, 0 },
+{ 200, 3, 0.8333333, 0, 0, 0, 0 },
+{ 305, 1, 0.8333333, 0, 0, 0, 0 },
+{ 440, 3, 0.8333333, 0, 0, 0, 0 },
+{ 515, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // moo moo farm
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 140, 3, 0.8333333, 0, 0, 0, 0 },
+{ 225, 3, 0.8333333, 0, 0, 0, 0 },
+{ 316, 3, 0.8333333, 0, 0, 0, 0 },
+{ 434, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // toad's turnpike
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 200, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // kalimari desert
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 138, 1, 0.8333333, 0, 0, 0, 0 },
+{ 280, 3, 0.8333333, 0, 0, 0, 0 },
+{ 404, 1, 0.8333333, 0, 0, 0, 0 },
+{ 510, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // sherbet land
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 200, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // rainbow road
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 200, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // wario stadium
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 200, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // block fort
+{ 20, 0, 1.0, 0, 0, 0, 0 },
+{ 40, 0, 1.0, 0, 0, 0, 0 },
+{ 60, 0, 1.0, 0, 0, 0, 0 },
+{ 80, 0, 1.0, 0, 0, 0, 0 },
+{ 100, 0, 1.0, 0, 0, 0, 0 },
+{ 120, 0, 1.0, 0, 0, 0, 0 },
+{ 140, 0, 1.0, 0, 0, 0, 0 },
+},
+{ // skyscraper
+{ 20, 0, 1.0, 0, 0, 0, 0 },
+{ 40, 0, 1.0, 0, 0, 0, 0 },
+{ 60, 0, 1.0, 0, 0, 0, 0 },
+{ 80, 0, 1.0, 0, 0, 0, 0 },
+{ 100, 0, 1.0, 0, 0, 0, 0 },
+{ 120, 0, 1.0, 0, 0, 0, 0 },
+{ 140, 0, 1.0, 0, 0, 0, 0 },
+},
+{ // double deck
+{ 20, 0, 1.0, 0, 0, 0, 0 },
+{ 40, 0, 1.0, 0, 0, 0, 0 },
+{ 60, 0, 1.0, 0, 0, 0, 0 },
+{ 80, 0, 1.0, 0, 0, 0, 0 },
+{ 100, 0, 1.0, 0, 0, 0, 0 },
+{ 120, 0, 1.0, 0, 0, 0, 0 },
+{ 140, 0, 1.0, 0, 0, 0, 0 },
+},
+{ // d.k.'s jungle parkway
+{ 50, 3, 0.8333333, 0, 0, 0, 0 },
+{ 100, 1, 0.8333333, 0, 0, 0, 0 },
+{ 150, 3, 0.8333333, 0, 0, 0, 0 },
+{ 190, 1, 0.8333333, 0, 0, 0, 0 },
+{ 250, 3, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+{ 0, 0, 0.8333333, 0, 0, 0, 0 },
+},
+{ // big donut
+{ 20, 0, 1.0, 0, 0, 0, 0 },
+{ 40, 0, 1.0, 0, 0, 0, 0 },
+{ 60, 0, 1.0, 0, 0, 0, 0 },
+{ 80, 0, 1.0, 0, 0, 0, 0 },
+{ 100, 0, 1.0, 0, 0, 0, 0 },
+{ 120, 0, 1.0, 0, 0, 0, 0 },
+{ 140, 0, 1.0, 0, 0, 0, 0 },
+},
+{ // null
+{ 3, 5, 1.25, 0, 0, 0, 0 },
+{ 40, 0, 1.0, 0, 0, 0, 0 },
+{ 60, 0, 1.0, 0, 0, 0, 0 },
+{ 80, 0, 1.0, 0, 0, 0, 0 },
+{ 100, 0, 1.0, 0, 0, 0, 0 },
+{ 120, 0, 1.0, 0, 0, 0, 0 },
+{ 140, 0, 1.0, 0, 0, 0, 0 },
+},

course_metadata/gCPUSteeringSensitivity.inc.c

@@ -0,0 +1 @@
+48, 53, 53, 53, 53, 53, 53, 53, 48, 48, 40, 53, 53, 38, 53, 53, 53, 53, 53, 40, 53, 0

course_metadata/gCourseDebugNames.inc.c

@@ -0,0 +1 @@
+"m circuit", "mountain", "castle", "ghost", "maze", "snow", "beach", "p circuit", "l circuit", "farm", "highway", "desert", "sherbet", "rainbow", "stadium", "block", "skyscraper", "deck", "jungle", "doughnut", 

course_metadata/gCourseNames.inc.c

@@ -0,0 +1 @@
+"mario raceway", "choco mountain", "bowser's castle", "banshee boardwalk", "yoshi valley", "frappe snowland", "koopa troopa beach", "royal raceway", "luigi raceway", "moo moo farm", "toad's turnpike", "kalimari desert", "sherbet land", "rainbow road", "wario stadium", "block fort", "skyscraper", "double deck", "d.k.'s jungle parkway", "big donut", 

course_metadata/gCoursePathSizes.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 600, 1, 1, 1, 1, {0, 0, 0}},
+// choco mountain
+{ 700, 1, 1, 1, 1, {0, 0, 0}},
+// bowser's castle
+{ 780, 1, 1, 1, 1, {0, 0, 0}},
+// banshee boardwalk
+{ 750, 1, 1, 1, 1, {0, 0, 0}},
+// yoshi valley
+{ 690, 680, 690, 800, 1, {0, 0, 0}},
+// frappe snowland
+{ 750, 1, 1, 1, 1, {0, 0, 0}},
+// koopa troopa beach
+{ 700, 1, 1, 1, 1, {0, 0, 0}},
+// royal raceway
+{ 1000, 1, 1, 1, 1, {0, 0, 0}},
+// luigi raceway
+{ 730, 1, 1, 1, 1, {0, 0, 0}},
+// moo moo farm
+{ 560, 1, 1, 1, 1, {0, 0, 0}},
+// toad's turnpike
+{ 1000, 1, 1, 1, 1, {0, 0, 0}},
+// kalimari desert
+{ 700, 1, 1, 1, 550, {0, 0, 0}},
+// sherbet land
+{ 700, 1, 1, 1, 1, {0, 0, 0}},
+// rainbow road
+{ 1900, 1, 1, 1, 1, {0, 0, 0}},
+// wario stadium
+{ 1600, 1, 1, 1, 1, {0, 0, 0}},
+// block fort
+{ 1, 1, 1, 1, 1, {0, 0, 0}},
+// skyscraper
+{ 1, 1, 1, 1, 1, {0, 0, 0}},
+// double deck
+{ 1, 1, 1, 1, 1, {0, 0, 0}},
+// d.k.'s jungle parkway
+{ 880, 1, 1, 1, 500, {0, 0, 0}},
+// big donut
+{ 1, 1, 1, 1, 1, {0, 0, 0}},
+// null
+{ 500, 500, 500, 500, 1, {0, 0, 0}},

course_metadata/gCoursePathTable.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ d_course_mario_raceway_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// choco mountain
+{ d_course_choco_mountain_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// bowser's castle
+{ d_course_bowsers_castle_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// banshee boardwalk
+{ d_course_banshee_boardwalk_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// yoshi valley
+{ d_course_yoshi_valley_track_waypoints, d_course_yoshi_valley_track_waypoints_2, d_course_yoshi_valley_track_waypoints_3, d_course_yoshi_valley_track_waypoints_4, },
+// frappe snowland
+{ d_course_frappe_snowland_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// koopa troopa beach
+{ d_course_koopa_troopa_beach_track_waypoints, d_course_koopa_troopa_beach_track_waypoints_2, &nullPath, &nullPath, },
+// royal raceway
+{ d_course_royal_raceway_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// luigi raceway
+{ d_course_luigi_raceway_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// moo moo farm
+{ d_course_moo_moo_farm_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// toad's turnpike
+{ d_course_toads_turnpike_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// kalimari desert
+{ d_course_kalimari_desert_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// sherbet land
+{ d_course_sherbet_land_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// rainbow road
+{ d_course_rainbow_road_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// wario stadium
+{ d_course_wario_stadium_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// block fort
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// skyscraper
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// double deck
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// d.k.'s jungle parkway
+{ d_course_dks_jungle_parkway_track_waypoints, &nullPath, &nullPath, &nullPath, },
+// big donut
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// null
+{ &nullPath, &nullPath, &nullPath, &nullPath, },

course_metadata/gCoursePathTableUnknown.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ d_course_mario_raceway_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// choco mountain
+{ d_course_choco_mountain_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// bowser's castle
+{ d_course_bowsers_castle_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// banshee boardwalk
+{ d_course_banshee_boardwalk_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// yoshi valley
+{ d_course_yoshi_valley_unknown_waypoints, d_course_yoshi_valley_unknown_waypoints_2, d_course_yoshi_valley_unknown_waypoints_3, d_course_yoshi_valley_unknown_waypoints_4, },
+// frappe snowland
+{ d_course_frappe_snowland_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// koopa troopa beach
+{ d_course_koopa_troopa_beach_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// royal raceway
+{ d_course_royal_raceway_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// luigi raceway
+{ d_course_luigi_raceway_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// moo moo farm
+{ d_course_moo_moo_farm_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// toad's turnpike
+{ d_course_toads_turnpike_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// kalimari desert
+{ d_course_kalimari_desert_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// sherbet land
+{ d_course_sherbet_land_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// rainbow road
+{ d_course_rainbow_road_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// wario stadium
+{ d_course_wario_stadium_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// block fort
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// skyscraper
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// double deck
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// d.k.'s jungle parkway
+{ d_course_dks_jungle_parkway_unknown_waypoints, &nullPath, &nullPath, &nullPath, },
+// big donut
+{ &nullPath, &nullPath, &nullPath, &nullPath, },
+// null
+{ podium_ceremony_path, podium_ceremony_path_2, podium_ceremony_path_3, podium_ceremony_path_4, },

course_metadata/gCupSelectionByCourseId.inc.c

@@ -0,0 +1 @@
+FLOWER_CUP, FLOWER_CUP, STAR_CUP, SPECIAL_CUP, SPECIAL_CUP, FLOWER_CUP, MUSHROOM_CUP, STAR_CUP, MUSHROOM_CUP, MUSHROOM_CUP, FLOWER_CUP, MUSHROOM_CUP, STAR_CUP, SPECIAL_CUP, STAR_CUP, BATTLE_CUP, BATTLE_CUP, BATTLE_CUP, SPECIAL_CUP, BATTLE_CUP, 

course_metadata/gKartAIBehaviourLUT.inc.c

@@ -0,0 +1 @@
+D_0D008F28, D_0D008F80, D_0D008FB8, D_0D009058, D_0D0090B8, D_0D0090F8, D_0D009158, D_0D009188, D_0D0091E8, D_0D009210, D_0D009238, D_0D009260, D_0D009280, D_0D0092C8, D_0D009310, D_0D008F18, D_0D008F18, D_0D008F18, D_0D0093C0, D_0D008F18, D_0D008F18, 0

course_metadata/gKartAICourseMaximumSeparation.inc.c

@@ -0,0 +1 @@
+50.0f, 35.0f, 35.0f, 40.0f, 35.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, 50.0f, -1.0f, -1.0f, -1.0f, 40.0f, -1.0f, 40.0f, 

course_metadata/gKartAICourseMinimumSeparation.inc.c

@@ -0,0 +1 @@
+0.3f, 0.3f, 0.2f, 0.4f, 0.0f, 0.3f, 0.5f, 0.4f, 0.7f, 0.5f, 0.5f, 0.3f, 0.3f, 0.4f, 0.6f, 0.1f, 0.5f, 0.5f, 0.1f, 0.5f, 0.5f, 

course_metadata/gPerCupIndexByCourseId.inc.c

@@ -0,0 +1 @@
+3, 2, 3, 2, 1, 1, 2, 2, 0, 1, 0, 3, 1, 3, 0, 1, 3, 2, 0, 0, 

course_metadata/sCourseLengths.inc.c

@@ -0,0 +1 @@
+"567m", "687m", "777m", "747m", "772m", "734m", "691m", "1025m", "717m", "527m", "1036m", "753m", "756m", "2000m", "1591m", "", "", "", "893m", "", 

course_metadata/sSkyColors.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 128, 4280, 6136, 216, 7144, 32248, },
+// choco mountain
+{ 255, 255, 255, 255, 255, 255, },
+// bowser's castle
+{ 48, 1544, 49528, 0, 0, 0, },
+// banshee boardwalk
+{ 0, 0, 0, 0, 0, 0, },
+// yoshi valley
+{ 113, 70, 255, 255, 184, 99, },
+// frappe snowland
+{ 28, 11, 90, 0, 99, 164, },
+// koopa troopa beach
+{ 48, 1688, 54136, 216, 7144, 32248, },
+// royal raceway
+{ 238, 144, 255, 255, 224, 240, },
+// luigi raceway
+{ 128, 4280, 6136, 216, 7144, 32248, },
+// moo moo farm
+{ 0, 18, 255, 197, 211, 255, },
+// toad's turnpike
+{ 0, 2, 94, 209, 65, 23, },
+// kalimari desert
+{ 195, 231, 255, 255, 192, 0, },
+// sherbet land
+{ 128, 4280, 6136, 216, 7144, 32248, },
+// rainbow road
+{ 0, 0, 0, 0, 0, 0, },
+// wario stadium
+{ 20, 30, 56, 40, 60, 110, },
+// block fort
+{ 128, 4280, 6136, 216, 7144, 32248, },
+// skyscraper
+{ 0, 0, 0, 0, 0, 0, },
+// double deck
+{ 113, 70, 255, 255, 184, 99, },
+// d.k.'s jungle parkway
+{ 255, 174, 0, 255, 229, 124, },
+// big donut
+{ 0, 0, 0, 0, 0, 0, },
+// null
+{ 238, 144, 255, 255, 224, 240, },

course_metadata/sSkyColors2.inc.c

@@ -0,0 +1,42 @@
+// mario raceway
+{ 0, 0, 0, 0, 0, 0, },
+// choco mountain
+{ 255, 255, 255, 255, 255, 255, },
+// bowser's castle
+{ 0, 0, 0, 0, 0, 0, },
+// banshee boardwalk
+{ 0, 0, 0, 0, 0, 0, },
+// yoshi valley
+{ 95, 40, 15, 0, 0, 0, },
+// frappe snowland
+{ 0, 99, 164, 0, 0, 0, },
+// koopa troopa beach
+{ 48, 1688, 54136, 0, 0, 0, },
+// royal raceway
+{ 255, 224, 240, 0, 0, 0, },
+// luigi raceway
+{ 216, 7144, 32248, 0, 0, 0, },
+// moo moo farm
+{ 255, 184, 99, 0, 0, 0, },
+// toad's turnpike
+{ 209, 65, 23, 0, 0, 0, },
+// kalimari desert
+{ 255, 192, 0, 0, 0, 0, },
+// sherbet land
+{ 216, 7144, 32248, 128, 4280, 6136, },
+// rainbow road
+{ 0, 0, 0, 0, 0, 0, },
+// wario stadium
+{ 0, 0, 0, 0, 0, 0, },
+// block fort
+{ 216, 7144, 32248, 0, 0, 0, },
+// skyscraper
+{ 0, 0, 0, 0, 0, 0, },
+// double deck
+{ 255, 224, 240, 0, 0, 0, },
+// d.k.'s jungle parkway
+{ 22, 145, 22, 0, 0, 0, },
+// big donut
+{ 0, 0, 0, 0, 0, 0, },
+// null
+{ 255, 224, 240, 0, 0, 0, },

courses/all_course_offsets.h

@@ -8,7 +8,7 @@ extern Gfx *bowsers_castle_dls[];
 extern Gfx *choco_mountain_dls[];
 extern Gfx *kalimari_desert_dls[];
 extern Gfx *luigi_raceway_dls[];
-extern Gfx *mario_raceway_dls[];
+extern const char *mario_raceway_dls[];
 extern Gfx *moo_moo_farm_dls[];
 extern Gfx *royal_raceway_dls[];
 extern Gfx *sherbet_land_dls[];

courses/courseTable.h

@@ -32,7 +32,6 @@ extern u8 _mario_raceway_vertexSegmentRomEnd[];
 extern u8 _course_mario_raceway_offsetsSegmentRomStart[];
 extern u8 _course_mario_raceway_offsetsSegmentRomEnd[];
 extern u8 d_course_mario_raceway_packed[];
-extern u32 mario_raceway_textures[];
 
 extern u8 _course_choco_mountain_dl_mio0SegmentRomStart[];
 extern u8 _course_choco_mountain_dl_mio0SegmentRomEnd[];

courses/mario_raceway/course_offsets.c

@@ -36,7 +36,7 @@ const course_texture mario_raceway_textures[] = {
     {0x00000000,                     0x0000, 0x0000, 0x0},
 };
 
-const Gfx *mario_raceway_dls[] = {
+const char *mario_raceway_dls[] = {
     d_course_mario_raceway_dl_0,
     d_course_mario_raceway_dl_1D0,
     d_course_mario_raceway_dl_E8,

include/common_structs.h

@@ -372,7 +372,7 @@ typedef struct {
     /* 0x023C */ f32 unk_23C;
     /* 0x0240 */ s32 unk_240;
     /* 0x0244 */ u16 animFrameSelector[4]; // [0] Active texture group
-    /* 0x024C */ u16 animGroupSelector[4];
+    /* 0x024C */ u16 animGroupSelector[4]; // Based on screen
     /* 0x0254 */ u16 characterId;
     /* 0x0256 */ u16 unk_256;
     /* 0x0258 */ UnkPlayerStruct258 unk_258[40];

include/course.h

@@ -10,7 +10,7 @@
 */
 
 typedef struct {
-    Gfx *addr;
+    uintptr_t addr;
     u8 surfaceType;
     u8 sectionId;
     u16 flags;

include/defines.h

@@ -42,8 +42,8 @@
   #define DEBUG_MODE 1
   #define DEBUG_MENU 2
 #else
-  #define DEBUG_MODE 0
+  #define DEBUG_MODE 1
-  #define DEBUG_MENU 1
+  #define DEBUG_MENU 2
 #endif
 
 #define HOLD_ALL_DPAD_AND_C_BUTTONS (U_JPAD | L_JPAD | R_JPAD | D_JPAD | U_CBUTTONS | L_CBUTTONS | R_CBUTTONS | D_CBUTTONS)

include/mk64.h

@@ -97,7 +97,7 @@ enum SURFACE_TYPE {
     /* 0xFF */ RAMP // Koopa Troopa beach
 };
 
-#define GFX_GET_OPCODE(var) ((uintptr_t)((var) & 0xFF000000))
+#define GFX_GET_OPCODE(var) ((uint32_t)((var) & 0xFF000000))
 
 // Pointer casting is technically UB, and avoiding it gets rid of endian issues
 // as well as a nice side effect.

libultraship

@@ -1 +1 @@
-Subproject commit 3018f1e75516ab00aa6cc5e183d007d9d0c8a139
+Subproject commit c7974d6a25853d65b44905df728a0e0249636947

src/buffers/buffers.c

@@ -4,8 +4,10 @@
 #include "buffers.h"
 
 ALIGNED8 union_D_802BFB80 D_802BFB80;
+// [nothing][screen][player]
 ALIGNED8 struct_D_802DFB80 D_802DFB80[2][2][8];
 #ifdef AVOID_UB
+// [buffer][screen][player] Buffer might be two separate buffers or something?
 ALIGNED8 struct_D_802F1F80 D_802F1F80[2][4][8];
 #else
 ALIGNED8 u16 D_802F1F80[2][4][0x100 * 8];

src/code_800029B0.c

@@ -311,7 +311,7 @@ void func_80003040(void) {
         case COURSE_MARIO_RACEWAY:
             struct ActorSpawnData *a_d_course_mario_raceway_tree_spawns = (struct ActorSpawnData *) LOAD_ASSET(d_course_mario_raceway_tree_spawns);
             dma_textures(gTextureTrees1, 0x35B, 0x800);
-            spawn_foliage(a_d_course_mario_raceway_tree_spawns);
+            //spawn_foliage(a_d_course_mario_raceway_tree_spawns);
             break;
         case COURSE_BOWSER_CASTLE:
             // d_course_bowsers_castle_packed_dl_1350

src/code_80005FD0.c

@@ -3477,6 +3477,7 @@ void func_8000F628(void) {
         if (gCurrentCourseId < (NUM_COURSES - 1)) {
             func_8000B95C(i, 0, 0);
         }
+        //! todo: @BUG this doesn't seem right. This variable is metadata.
         D_80163028[i] = *(f32 *) LOAD_ASSET(&D_0D009418[gCurrentCourseId][gCCSelection]);
         D_801630E8[i] = 0;
         D_80163100[i] = 0;

src/code_80057C60.c

@@ -344,8 +344,7 @@ s16 D_8018CF18;
 Player *D_8018CF1C;
 s16 D_8018CF20;
 UNUSED s32 D_8018CF24;
-Player *D_8018CF28[4];
+Player *D_8018CF28[8];
-UNUSED s32 D_8018CF38[4];
 s16 D_8018CF48;
 s16 D_8018CF50[8];
 s16 D_8018CF60;

src/code_8006E9C0.c

@@ -567,7 +567,7 @@ void func_8006FA94(void) {
     D_8018D17C = D_8018D18C;
     D_8018D174 = D_8018D18C;
     player = gPlayerOne;
-    for (var_a0 = 0; var_a0 < 8; var_a0++) {
+    for (var_a0 = 0; var_a0 < NUM_PLAYERS; var_a0++) {
         D_8018D0F0[var_a0] = D_8018D050[var_a0] = -32.0f;
         D_8018CE10[var_a0].unk_04[0] = D_8018CE10[var_a0].unk_04[1] = D_8018CE10[var_a0].unk_04[2] = 0.0f;
         D_8018CF50[var_a0] = var_a0;

src/code_80091750.c

@@ -396,24 +396,24 @@ char *gCupNames[] = {
 
 // Displays at beginning of course
 char *gCourseNames[] = {
-    #include "assets/course_metadata/gCourseNames.inc.c"
+    #include "course_metadata/gCourseNames.inc.c"
 };
 
 char *gCourseNamesDup[] = {
-    #include "assets/course_metadata/gCourseNames.inc.c"
+    #include "course_metadata/gCourseNames.inc.c"
 };
 
 char *gCourseNamesDup2[] = {
-    #include "assets/course_metadata/gCourseNames.inc.c"
+    #include "course_metadata/gCourseNames.inc.c"
 };
 
 // Used in debug menu at splash screen
 char *gDebugCourseNames[] = {
-    #include "assets/course_metadata/gCourseDebugNames.inc.c"
+    #include "course_metadata/gCourseDebugNames.inc.c"
 };
 
 const s8 gPerCupIndexByCourseId[] = {
-    #include "assets/course_metadata/gPerCupIndexByCourseId.inc.c"
+    #include "course_metadata/gPerCupIndexByCourseId.inc.c"
 };
 
 // @todo Increase this array for more than eight players
@@ -421,7 +421,7 @@ const s8 D_800EFD64[] = { 0, 1, 4, 3, 5, 6, 2, 7 };
 
 // Maps course IDs (as defined in the COURSES enum) to the cup they belong to
 s8 gCupSelectionByCourseId[] = {
-    #include "assets/course_metadata/gCupSelectionByCourseId.inc.c"
+    #include "course_metadata/gCupSelectionByCourseId.inc.c"
 };
 
 char *D_800E7678[] = {
@@ -557,7 +557,7 @@ char D_800E77B4[] = "a BUTTON*SEE DATA  B BUTTON*EXIT";
 char D_800E77D8[] = "distance";
 
 char *sCourseLengths[] = {
-    #include "assets/course_metadata/sCourseLengths.inc.c"
+    #include "course_metadata/sCourseLengths.inc.c"
 };
 
 char *D_800E7834[] = {
@@ -2404,7 +2404,6 @@ void func_800942D0(void) {
     s32 var_s2;
     s32 thing;
     test = &gGfxPool->mtxObject[0];
-    Gfx * a_D_02007F60 = LOAD_ASSET(D_02007F60);
     gSPMatrix(gDisplayListHead++, &gGfxPool->mtxScreen, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
     gSPMatrix(gDisplayListHead++, &gGfxPool->mtxLookAt[0], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
     guRotate(test, D_8018EDC8, 1.0f, 0.0f, 0.0f);
@@ -2415,7 +2414,7 @@ void func_800942D0(void) {
     gSPMatrix(gDisplayListHead++, test++, G_MTX_PUSH   | G_MTX_MUL | G_MTX_MODELVIEW);
     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
     gDPSetEnvColor(gDisplayListHead++, 0x00, 0x00, 0x00, 0x00);
-    gSPDisplayList(gDisplayListHead++, a_D_02007F60);
+    gSPDisplayList(gDisplayListHead++, D_02007F60);
     gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
     if (D_800E8530 > 0) {
         var_f26 = D_800E8534;
@@ -2890,6 +2889,7 @@ func_80095BD0_label2:
     return func_800959F8(displayListHead, var_a1);
 }
 
+// Player select menu character border
 Gfx *func_80095E10(Gfx *displayListHead, s8 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6, s32 arg7, s32 arg8, s32 arg9, u8 *argA, u32 argB, u32 argC) {
     u32 var_a1_2 = arg4;
     u32 var_s3 = arg5;
@@ -3333,6 +3333,7 @@ Gfx *func_80097AE4(Gfx *displayListHead, s8 fmt, s32 arg2, s32 arg3, u8 *arg4, s
     return displayListHead;
 }
 
+// Render player characters at player select menu
 Gfx *func_80097E58(Gfx *displayListHead, s8 fmt, u32 arg2, u32 arg3, u32 arg4, u32 arg5, s32 arg6, s32 arg7, u8 *someTexture, u32 arg9, u32 argA, s32 width) {
     u32 ult;
     u32 temp;
@@ -3361,12 +3362,14 @@ Gfx *func_80097E58(Gfx *displayListHead, s8 fmt, u32 arg2, u32 arg3, u32 arg4, u
         }
         temp_v1 = ((32 * lrs) << 10) / (lrs * (32 - width));
 
+        // Renders the left side
         gDPLoadTextureTile(displayListHead++, someTexture, fmt, G_IM_SIZ_16b, arg9, argA, temp, ult, temp + lrs, ult + var_s2, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
-        gSPTextureRectangle(displayListHead++, (arg6 + lrs * width / 32) << 2, arg7 << 2, (arg6 + lrs) << 2, (arg7 + var_s2) << 2, 0, 0, (ult << 5) & 0xFFFF, temp_v1, 1024);
+        gSPTextureRectangle(displayListHead++, (arg6 + lrs * (width) / 32) << 2, arg7 << 2, (((arg6) + lrs) << 2), (((arg7) + var_s2) << 2), 0, 0, (ult << 5) & 0xFFFF, temp_v1, 1024);
         arg6 += lrs;
         temp_v1 = ((32 * spDC) << 10) / (spDC * (32 - width));
+        // Renders the right side
         gDPLoadTextureTile(displayListHead++, someTexture, fmt, G_IM_SIZ_16b, arg9, argA, temp + lrs, ult, temp + arg9, ult + var_s2, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, 5, 5, G_TX_NOLOD, G_TX_NOLOD);
-        gSPTextureRectangle(displayListHead++, arg6 << 2, arg7 << 2, (arg6 + spDC * (32 - width) / 32) << 2, (arg7 + var_s2) << 2, 0, (lrs << 5) & 0xFFFF, (ult << 5) & 0xFFFF, temp_v1, 1024);
+        gSPTextureRectangle(displayListHead++, arg6 << 2, arg7 << 2, ((arg6 + spDC * (32 - (width)) / 32) << 2), (((arg7) + var_s2) << 2), 0,  (1+lrs << 5) & 0xFFFF, (ult << 5) & 0xFFFF, temp_v1, 1024);
         arg6 = arg6Copy;
         arg7 += temp2;
     }
@@ -3872,6 +3875,7 @@ void func_80099AEC(void) {
             //osPiStartDma(&sp68, 0, 0, (uintptr_t)&_textures_0aSegmentRomStart[SEGMENT_OFFSET(temp_s2->textureData)], D_8018D9B4 + sp60*4, size, &gDmaMesgQueue);
         }
         //mio0decode(D_8018D9B4, (u8*)&D_8018D9B0[D_8018E118[var_s1->unk_4].offset]);
+        //u16 *asset = LOAD_ASSET(var_s1->texture->textureData);
         memcpy(&D_8018D9B0[D_8018E118[var_s1->unk_4].offset], var_s1->texture->textureData, var_s1->texture->width * var_s1->texture->height * 2);
 
         var_s1->texture = NULL;
@@ -3895,6 +3899,7 @@ void func_80099AEC(void) {
             //osPiStartDma(&sp68, 0, 0, (uintptr_t)&_textures_0aSegmentRomStart[SEGMENT_OFFSET(temp_s2->textureData)], D_8018D9B4, size, &gDmaMesgQueue);
         }
         //mio0decode(D_8018D9B4 + sp60*4, (u8*)&D_8018D9B0[D_8018E118[var_s1->unk_4].offset]);
+        //u16 *asseta = LOAD_ASSET(var_s1->texture->textureData);
         memcpy(&D_8018D9B0[D_8018E118[var_s1->unk_4].offset], var_s1->texture->textureData, var_s1->texture->width * var_s1->texture->height * 2);
         var_s1->texture = NULL;
         var_s1++;

src/data/path_spawn_metadata.c

@@ -5,33 +5,33 @@
 
 // @warning Array contains an extra zero element at the end.
 KartAIBehaviour *gKartAIBehaviourLUT[] = {
-    #include "assets/course_metadata/gKartAIBehaviourLUT.inc.c"
+    #include "course_metadata/gKartAIBehaviourLUT.inc.c"
 
 };
 
 TrackWaypoint nullPath = { 0x8000, 0x0000, 0x0000, 0x0000 };
 
 TrackWaypoint *gCoursePathTable[][4] = {
-    #include "assets/course_metadata/gCoursePathTableUnknown.inc.c"
+    #include "course_metadata/gCoursePathTableUnknown.inc.c"
 };
 
 TrackWaypoint *gCoursePathTable2[][4] = {
-    #include "assets/course_metadata/gCoursePathTable.inc.c"
+    #include "course_metadata/gCoursePathTable.inc.c"
 };
 
 // @warning Array contains an extra zero element at the end.
 s16 gKartAISteeringSensitivity[] = {
-    #include "assets/course_metadata/gCPUSteeringSensitivity.inc.c"
+    #include "course_metadata/gCPUSteeringSensitivity.inc.c"
 };
 
 // Possibly maximum cpu separation
 f32 gKartAICourseMaximumSeparation[] = {
-    #include "assets/course_metadata/gKartAICourseMaximumSeparation.inc.c"
+    #include "course_metadata/gKartAICourseMaximumSeparation.inc.c"
 };
 
 // Possibly minimum cpu separation
 f32 gKartAICourseMinimumSeparation[] = {
-    #include "assets/course_metadata/gKartAICourseMinimumSeparation.inc.c"
+    #include "course_metadata/gKartAICourseMinimumSeparation.inc.c"
 };
 
 // I think the types for D_800DCAF4, D_800DCB34, and D_800DCBB4 are all
@@ -58,15 +58,15 @@ s16 D_800DCB34[] = {
 };
 
 s16 *D_800DCBB4[] = {
-    #include "assets/course_metadata/D_800DCBB4.inc.c"
+    #include "course_metadata/D_800DCBB4.inc.c"
 };
 
 BombKartSpawn gBombKartSpawns[][NUM_BOMB_KARTS_MAX] = {
-    #include "assets/course_metadata/gBombKartSpawns.inc.c"
+    #include "course_metadata/gBombKartSpawns.inc.c"
 };
 
 struct _struct_gCoursePathSizes_0x10 gCoursePathSizes[] = {
-    #include "assets/course_metadata/gCoursePathSizes.inc.c"
+    #include "course_metadata/gCoursePathSizes.inc.c"
 };
 
 s32 D_800DDB20 = 0x00000000;

src/kart_dma.c

@@ -13,6 +13,7 @@
 #include <assets/bowser_kart.h>
 #include <assets/wario_kart.h>
 #include <assets/donkeykong_kart.h>
+#include "render_player.h"
 
 // Seemingly the largest compressed size for a frame for a given character
 // They seem slightly oversized too, either an alignemnt or safety thing
@@ -1697,16 +1698,21 @@ u8 *gKartPalettes[] = {
  *
  * @param player
  * @param playerId Player ID.
- * @param arg2 Rom buffer index appears to always be 0-3. Sometimes subtracted by 2.
+ * @param screenId Rom buffer index appears to always be 0-3. Sometimes subtracted by 2.
- * @param arg3 Second buffer index appears to always be 0-3.
+ * @param screenId2 Second buffer index appears to always be 0-3.
- * @param arg4 First buffer index always zero.
+ * @param zero First buffer index always zero.
  **/
-void load_kart_texture(Player *player, s8 playerId, s8 arg2, s8 arg3, s8 arg4) {
+void load_kart_texture(Player *player, s8 playerId, s8 screenId, s8 screenId2, s8 zero) {
     s32 temp = player->effects;
+    u8 *texture;
+    u8 *asset;
+    size_t size = 0;
     if (((temp & 0x80) == 0x80) || ((temp & 0x40) == 0x40) || ((temp & 0x80000) == 0x80000) || ((temp & 0x800000) == 0x800000) || ((temp & 0x20000) == 0x20000) || ((player->unk_044 & 0x800) != 0)) {
-        if (player->animFrameSelector[arg2] != 0) {
+        if (player->animFrameSelector[screenId] != 0) {
-            osInvalDCache(&D_802DFB80[arg4][arg3][playerId], D_800DDEB0[player->characterId]);
+            osInvalDCache(&D_802DFB80[zero][screenId2][playerId], D_800DDEB0[player->characterId]);
 
+
+            texture = gKartTextureTable1[player->characterId][player->animGroupSelector[screenId]][player->animFrameSelector[screenId]];
             // osPiStartDma(
             //     &gDmaIoMesg,
             //     OS_MESG_PRI_NORMAL, OS_READ,
@@ -1717,10 +1723,16 @@ void load_kart_texture(Player *player, s8 playerId, s8 arg2, s8 arg3, s8 arg4) {
             //     D_800DDEB0[player->characterId],
             //     &gDmaMesgQueue
             // );
+            printf("T1 kart %s\n", texture);
 
-            osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+            //return gKartTextureTable1[player->characterId][player->animGroupSelector[screenId]][player->animFrameSelector[screenId]];
+            size = ResourceGetTexSizeByName(texture);
+            asset = (u8 *) LOAD_ASSET(texture);
+            memcpy(&D_802BFB80.arraySize8[zero][screenId2][playerId], asset, size);
+
+            //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
         } else {
-            osInvalDCache(&D_802DFB80[arg4][arg3][playerId], D_800DDEB0[player->characterId]);
+            osInvalDCache(&D_802DFB80[zero][screenId2][playerId], D_800DDEB0[player->characterId]);
 
             // osPiStartDma(
             //     &gDmaIoMesg,
@@ -1734,10 +1746,15 @@ void load_kart_texture(Player *player, s8 playerId, s8 arg2, s8 arg3, s8 arg4) {
             //     &gDmaMesgQueue
             // );
 
-            osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+            texture = gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]][player->animFrameSelector[screenId]];
+            size = ResourceGetTexSizeByName(texture);
+            printf("T0 kart %s\n",texture);
+            asset = (u8 *) LOAD_ASSET(texture);
+            memcpy(&D_802BFB80.arraySize8[zero][screenId2][playerId], asset, size);
+            //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
         }
     } else if (((temp & 0x400) == 0x400) || ((temp & 0x01000000) == 0x01000000) || ((temp & 0x02000000) == 0x02000000) || ((temp & 0x10000) == 0x10000)) {
-        osInvalDCache(&D_802DFB80[arg4][arg3][playerId], 0x780U);
+        osInvalDCache(&D_802DFB80[zero][screenId2][playerId], 0x780U);
         // player->unk_0A8 >> 8 converts an 8.8 fixed-point animation frame to a whole number.
         // osPiStartDma(
         //     &gDmaIoMesg,
@@ -1750,10 +1767,15 @@ void load_kart_texture(Player *player, s8 playerId, s8 arg2, s8 arg3, s8 arg4) {
         //     0x900,
         //     &gDmaMesgQueue
         // );
+        texture = gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
+        printf("Tum Kart %s\n",texture);
+        size = ResourceGetTexSizeByName(texture);
+        asset = (u8 *) LOAD_ASSET(texture);
+        memcpy(&D_802BFB80.arraySize8[zero][screenId2][playerId], asset, size);
 
         osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     } else {
-        osInvalDCache(&D_802DFB80[arg4][arg3][playerId], D_800DDEB0[player->characterId]);
+        osInvalDCache(&D_802DFB80[zero][screenId2][playerId], D_800DDEB0[player->characterId]);
 
         // osPiStartDma(
         //     &gDmaIoMesg,
@@ -1767,12 +1789,21 @@ void load_kart_texture(Player *player, s8 playerId, s8 arg2, s8 arg3, s8 arg4) {
         //     &gDmaMesgQueue
         // );
 
-        osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+        texture = gKartTextureTable0[player->characterId][player->animGroupSelector[screenId]][player->animFrameSelector[screenId]];
+        printf("T0 kart 2 %s\n", texture);
+        size = ResourceGetTexSizeByName(texture);
+        asset = (u8 *) LOAD_ASSET(texture);
+        memcpy(&D_802BFB80.arraySize8[zero][screenId2][playerId], asset, size);
+
+        //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     }
 }
 
-void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4) {
+void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4, size_t i) {
     s32 temp = player->effects;
+    u8 *asset;
+    u8 *texture;
+    size_t size;
 
     if (((temp & 0x80) == 0x80) || ((temp & 0x40) == 0x40) || ((temp & 0x80000) == 0x80000) || ((temp & 0x800000) == 0x800000) || ((temp & 0x20000) == 0x20000) || ((player->unk_044 & 0x800) != 0))
     {
@@ -1790,6 +1821,14 @@ void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4) {
             //     D_800DDEB0[player->characterId],
             //     &gDmaMesgQueue
             // );
+
+            texture = gKartTextureTable1[player->characterId][player->animGroupSelector[arg2]][player->animFrameSelector[arg2]];
+            printf("T1 kart 2 %s\n", texture);
+            size = ResourceGetTexSizeByName(texture);
+            asset = (u8 *) LOAD_ASSET(texture);
+            memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array, 
+            asset, size);
+
         } else {
             osInvalDCache(&D_802DFB80[arg4][arg3][arg1], D_800DDEB0[player->characterId]);
 
@@ -1804,6 +1843,11 @@ void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4) {
             //     D_800DDEB0[player->characterId],
             //     &gDmaMesgQueue
             // );
+            texture = gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]][player->animFrameSelector[arg2]];
+            printf("T0 kart 3 %s\n", texture);
+            size = ResourceGetTexSizeByName(texture);
+            asset = (u8 *) LOAD_ASSET(texture);
+            memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array, asset, size);
         }
     } else if (((temp & 0x400) == 0x400) || ((temp & 0x01000000) == 0x01000000) ||
         ((temp & 0x02000000) == 0x02000000) || ((temp & 0x10000) == 0x10000))
@@ -1821,6 +1865,11 @@ void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4) {
         //     0x900,
         //     &gDmaMesgQueue
         // );
+        texture = gKartTextureTumbles[player->characterId][player->unk_0A8 >> 8];
+        printf("Tum kart 2 %s\n", texture);
+        size = ResourceGetTexSizeByName(texture);
+        asset = (u8 *) LOAD_ASSET(texture);
+        memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array, asset, size);
     } else {
         osInvalDCache(&D_802DFB80[arg4][arg3][arg1], D_800DDEB0[player->characterId]);
 
@@ -1835,14 +1884,21 @@ void func_80027560(Player *player, s8 arg1, s8 arg2, s8 arg3, s8 arg4) {
         //     D_800DDEB0[player->characterId],
         //     &gDmaMesgQueue
         // );
+        texture = gKartTextureTable0[player->characterId][player->animGroupSelector[arg2]][player->animFrameSelector[arg2]];
+        printf("T0 kart 4 %s 0x%llX\n", texture, &D_802DFB80[arg4][arg3][arg1]);
+        size = ResourceGetTexSizeByName(texture);
+        asset = (u8 *) LOAD_ASSET(texture);
+        memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array, asset, size);
     }
 }
 
-void load_kart_palette(Player *player, s8 playerId, s8 arg2, s8 arg3) {
+void load_kart_palette(Player *player, s8 playerId, s8 screenId, s8 buffer) {
+    u8 *asset;
+    size_t size;
 #ifdef AVOID_UB
-    struct_D_802F1F80 *temp_s0 = &D_802F1F80[arg3][arg2][playerId];
+    struct_D_802F1F80 *temp_s0 = &D_802F1F80[buffer][screenId][playerId];
 #else
-    struct_D_802F1F80 *temp_s0 = (struct_D_802F1F80 *) &D_802F1F80[arg3][arg2][playerId * 0x100];
+    struct_D_802F1F80 *temp_s0 = (struct_D_802F1F80 *) &D_802F1F80[buffer][screenId][playerId * 0x100];
 #endif
     switch(gActiveScreenMode) {
         case SCREEN_MODE_1P:
@@ -1862,7 +1918,11 @@ void load_kart_palette(Player *player, s8 playerId, s8 arg2, s8 arg3) {
             //     &gDmaMesgQueue
             // );
 
-            osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+            size = ResourceGetTexSizeByName(gKartPalettes[player->characterId]);
+            asset = (u8 *) LOAD_ASSET(gKartPalettes[player->characterId]);
+            memcpy(temp_s0, asset, size);
+
+            //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
             break;
         case SCREEN_MODE_3P_4P_SPLITSCREEN: // Code identical to above
             osInvalDCache(temp_s0, sizeof(struct_D_802F1F80));
@@ -1879,12 +1939,16 @@ void load_kart_palette(Player *player, s8 playerId, s8 arg2, s8 arg3) {
             //     &gDmaMesgQueue
             // );
 
-            osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+            size = ResourceGetTexSizeByName(gKartPalettes[player->characterId]);
+            asset = (u8 *) LOAD_ASSET(gKartPalettes[player->characterId]);
+            memcpy(temp_s0, asset, size);
+
+            //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
             break;
     }
 }
 
-void func_80027BDC(UNUSED Player *player, s32 arg1, void *vAddr, u16 size) {
+void func_80027BDC(UNUSED Player *player, u8 *arg1, void *vAddr, u16 size) {
     osInvalDCache(vAddr, size);
 
     // osPiStartDma(
@@ -1897,10 +1961,13 @@ void func_80027BDC(UNUSED Player *player, s32 arg1, void *vAddr, u16 size) {
     //     &gDmaMesgQueue
     // );
 
-    osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+    // u8 *asset = (u8 *) LOAD_ASSET(arg1);
+    //     memcpy(vAddr, asset, size);
+
+    //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
 }
 
-void func_80027C74(UNUSED Player *player, s32 arg1, void *vAddr, u16 size) {
+void func_80027C74(UNUSED Player *player, u8 *texture, void *vAddr, u16 size) {
     osInvalDCache(vAddr, size);
 
     // osPiStartDma(
@@ -1912,4 +1979,7 @@ void func_80027C74(UNUSED Player *player, s32 arg1, void *vAddr, u16 size) {
     //     size,
     //     &gDmaMesgQueue
     // );
+    // size_t textureSize = ResourceGetTexSizeByName(texture);
+    // printf("test %s\n",texture);
+    //     memcpy(vAddr, texture, textureSize);
 }

src/kart_dma.h

@@ -7,10 +7,10 @@
 /* Function Prototypes */
 
 void load_kart_texture(Player*, s8, s8, s8, s8);
-void func_80027560(Player*, s8, s8, s8, s8);
+void func_80027560(Player*, s8, s8, s8, s8, size_t);
 void load_kart_palette(Player*, s8, s8, s8);
-void func_80027BDC(Player*, s32, void*, u16);
+void func_80027BDC(Player*, u8*, void*, u16);
-void func_80027C74(Player*, s32, void*, u16);
+void func_80027C74(Player*, u8*, void*, u16);
 
 /* This is where I'd put my static data, if I had any */
 

src/menus.c

@@ -59,7 +59,7 @@ s8 D_8018EE0C;
 struct_8018EE10_entry D_8018EE10[2];
 
 /** Data **/
-s32 gMenuSelection = LOGO_INTRO_MENU;
+s32 gMenuSelection = START_MENU;
 s32 D_800E86A4 = 0;
 s8 gCharacterSelections[4] = { MARIO, LUIGI, YOSHI, TOAD };
 

src/player_controller.c

@@ -360,24 +360,24 @@ s32 get_player_index_for_player(Player *player) {
     return index;
 }
 
-void func_80027DA8(Player *arg0, s8 arg1) {
+void func_80027DA8(Player *player, s8 playerId) {
     if (D_8015F890 != 1) {
-        if ((arg0->type & 0x10) != 0x10) {
+        if ((player->type & 0x10) != 0x10) {
-            if (((D_8018D168 == 1) && ((arg0->type & 0x4000) == 0x4000)) && ((arg0->type & 0x100) != 0x100)) {
+            if (((D_8018D168 == 1) && ((player->type & 0x4000) == 0x4000)) && ((player->type & 0x100) != 0x100)) {
-                func_800C94A4(arg1);
+                func_800C94A4(playerId);
-                arg0->type |= 0x10;
+                player->type |= 0x10;
-            } else if ((arg0->type & 0x2000) == 0) {
+            } else if ((player->type & 0x2000) == 0) {
-                func_800C9A88(arg1);
+                func_800C9A88(playerId);
-                arg0->type |= 0x10;
+                player->type |= 0x10;
             }
         }
-    } else if ((arg0->type & 0x10) != 0x10) {
+    } else if ((player->type & 0x10) != 0x10) {
-        if ((D_8018D168 == 1) && (arg0 == gPlayerOne)) {
+        if ((D_8018D168 == 1) && (player == gPlayerOne)) {
-            func_800C94A4(arg1);
+            func_800C94A4(playerId);
-            arg0->type |= 0x10;
+            player->type |= 0x10;
-        } else if ((arg0->type & 0x2000) == 0) {
+        } else if ((player->type & 0x2000) == 0) {
-            func_800C9A88(arg1);
+            func_800C9A88(playerId);
-            arg0->type |= 0x10;
+            player->type |= 0x10;
         }
     }
 }
@@ -618,7 +618,7 @@ void func_80027EDC(Player *player, s8 playerId) {
     }
 }
 
-void func_80028864(Player *player, Camera *camera, s8 arg2, s8 arg3) {
+void func_80028864(Player *player, Camera *camera, s8 playerId, s8 screenId) {
     u16 sp1E;
 
     if (!(player->type & PLAYER_START_SEQUENCE)) {
@@ -648,7 +648,7 @@ void func_80028864(Player *player, Camera *camera, s8 arg2, s8 arg3) {
             ((player->unk_0CA & 2) != 0) ||
             (player->unk_0CA & 8) ||
             //! @todo make a proper match
-            ((*(D_801633F8 + (arg2))) == ((s16) 1U))) {
+            ((*(D_801633F8 + (playerId))) == ((s16) 1U))) {
                 player->effects &= ~0x1000;
                 if (((player->effects & 0x80) == 0x80) ||
                     ((player->effects & 0x40) == 0x40) ||
@@ -660,18 +660,18 @@ void func_80028864(Player *player, Camera *camera, s8 arg2, s8 arg3) {
                     ((player->effects & HIT_BY_ITEM_EFFECT) == HIT_BY_ITEM_EFFECT) ||
                     ((player->effects & 0x20000) == 0x20000) ||
                     (player->unk_044 & 0x800)) {
-                        func_8002E594(player, camera, arg3, arg2);
+                        func_8002E594(player, camera, screenId, playerId);
                 } else {
-                    func_8002D268(player, camera, arg3, arg2);
+                    func_8002D268(player, camera, screenId, playerId);
                 }
         } else {
-            control_kart_ai_movement(player, camera, arg3, arg2);
+            control_kart_ai_movement(player, camera, screenId, playerId);
         }
     } else if ((player->type & PLAYER_STAGING) == PLAYER_STAGING) {
-        func_8002D028(player, arg2);
+        func_8002D028(player, playerId);
-        func_8002F730(player, camera, arg3, arg2);
+        func_8002F730(player, camera, screenId, playerId);
     } else if (player->type & 0x80) {
-        func_8002D268(player, camera, arg3, arg2);
+        func_8002D268(player, camera, screenId, playerId);
     } else {
         if ((player->type & PLAYER_HUMAN) != PLAYER_HUMAN) {
             player->currentSpeed = 50.0f;
@@ -680,7 +680,7 @@ void func_80028864(Player *player, Camera *camera, s8 arg2, s8 arg3) {
     }
 }
 
-void func_80028C44(Player *player, Camera *camera, s8 arg2, s8 arg3) {
+void func_80028C44(Player *player, Camera *camera, s8 playerId, s8 screenId) {
     if ((player->type & PLAYER_START_SEQUENCE) == 0) {
         player->effects &= ~0x1000;
         if (((player->effects & 0x80) == 0x80) ||
@@ -693,16 +693,16 @@ void func_80028C44(Player *player, Camera *camera, s8 arg2, s8 arg3) {
             ((player->effects & HIT_BY_ITEM_EFFECT) == HIT_BY_ITEM_EFFECT) ||
             ((player->effects & 0x20000) == 0x20000) ||
             ((player->unk_044 & 0x800) != 0)) {
-                func_8002E594(player, camera, arg3, arg2);
+                func_8002E594(player, camera, screenId, playerId);
         } else {
-			func_8002D268(player, camera, arg3, arg2);
+			func_8002D268(player, camera, screenId, playerId);
 		}
     } else {
 		player->effects &= -9;
 	}
 }
 
-void func_80028D3C(Player *player, Camera *camera, s8 arg2, s8 arg3) {
+void func_80028D3C(Player *player, Camera *camera, s8 playerId, s8 screenId) {
    if ((((player->type & PLAYER_START_SEQUENCE) == 0)
         && (D_800DC510 != 5))
         || (player->unk_0CA & 2) != 0
@@ -720,37 +720,37 @@ void func_80028D3C(Player *player, Camera *camera, s8 arg2, s8 arg3) {
                 ((player->effects & HIT_BY_ITEM_EFFECT) == HIT_BY_ITEM_EFFECT) ||
                 ((player->effects & 0x20000) == 0x20000) ||
                 ((player->unk_044 & 0x800) != 0)) {
-                    func_8002E594(player, camera, arg3, arg2);
+                    func_8002E594(player, camera, screenId, playerId);
             } else {
-                func_8002D268(player, camera, arg3, arg2);
+                func_8002D268(player, camera, screenId, playerId);
             }
     } else {
         player->effects = player->effects & ~8;
     }
 }
 
-void func_80028E70(Player *player, Camera *camera, s8 arg2, s8 arg3)  {
+void func_80028E70(Player *player, Camera *camera, s8 playerId, s8 screenId)  {
     if ((player->type & PLAYER_EXISTS) == PLAYER_EXISTS) {
         switch (gGamestate) {
             case ENDING:
                 if (!(player->type & PLAYER_START_SEQUENCE)) {
-                    func_80038C6C(player, camera, arg3, arg2);
+                    func_80038C6C(player, camera, screenId, playerId);
                 } else {
                     player->effects &= ~8;
                 }
                 break;
             default:
-                func_80027DA8(player, arg2);
+                func_80027DA8(player, playerId);
                 switch (gModeSelection) {
                     case TIME_TRIALS:
                     case VERSUS:
-                        func_80028C44(player, camera, arg2, arg3);
+                        func_80028C44(player, camera, playerId, screenId);
                         break;
                     case BATTLE:
-                        func_80028D3C(player, camera, arg2, arg3);
+                        func_80028D3C(player, camera, playerId, screenId);
                         break;
                     default:
-                        func_80028864(player, camera, arg2, arg3);
+                        func_80028864(player, camera, playerId, screenId);
                         break;
                 }
                 break;
@@ -810,37 +810,37 @@ void func_800291F8(void) {
 
 }
 
-void func_80029200(Player *player, s8 arg1) {
+void func_80029200(Player *player, s8 screenId) {
     if ((s32) player->slopeAccel < -0x71B) {
-        player->animGroupSelector[arg1] = 0;
+        player->animGroupSelector[screenId] = 0;
     }
     if (((s32) player->slopeAccel < -0x4F9) && ((s32) player->slopeAccel >= -0x71B)) {
-        player->animGroupSelector[arg1] = 1;
+        player->animGroupSelector[screenId] = 1;
     }
     if ((player->slopeAccel < -0x221) && (player->slopeAccel >= -0x4F9)) {
-        player->animGroupSelector[arg1] = 2;
+        player->animGroupSelector[screenId] = 2;
     }
     if ((player->slopeAccel < -0x16B) && (player->slopeAccel >= -0x221)) {
-        player->animGroupSelector[arg1] = 3;
+        player->animGroupSelector[screenId] = 3;
     }
     if ((player->slopeAccel < 0x16C) && (player->slopeAccel >= -0x16B)) {
-        player->animGroupSelector[arg1] = 4;
+        player->animGroupSelector[screenId] = 4;
     }
     if ((player->slopeAccel >= 0x16C) && (player->slopeAccel < 0x222)) {
-        player->animGroupSelector[arg1] = 5;
+        player->animGroupSelector[screenId] = 5;
     }
     if ((player->slopeAccel >= 0x222) && (player->slopeAccel < 0x4FA)) {
-        player->animGroupSelector[arg1] = 6;
+        player->animGroupSelector[screenId] = 6;
     }
     if ((player->slopeAccel >= 0x4FA) && (player->slopeAccel < 0x71C)) {
-        player->animGroupSelector[arg1] = 7;
+        player->animGroupSelector[screenId] = 7;
     }
     if (player->slopeAccel >= 0x71C) {
-        player->animGroupSelector[arg1] = 8;
+        player->animGroupSelector[screenId] = 8;
     }
 }
 
-void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
+void func_8002934C(Player *player, Camera *camera, s8 screenId, s8 playerId) {
     UNUSED s32 pad[2];
     f32 temp_f0;
     f32 temp_f2;
@@ -852,45 +852,45 @@ void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
     s32 var_t0;
     u16 var_a0;
 
-    player->unk_048[arg2] = atan2s(player->pos[0] - camera->pos[0], player->pos[2] - camera->pos[2]);
+    player->unk_048[screenId] = atan2s(player->pos[0] - camera->pos[0], player->pos[2] - camera->pos[2]);
-    player->animFrameSelector[arg2] = (u16) ( (((player->unk_048[arg2]) + player->rotation[1] + player->unk_0C0))) / 128;
+    player->animFrameSelector[screenId] = (u16) ( (((player->unk_048[screenId]) + player->rotation[1] + player->unk_0C0))) / 128;
 
     temp_f2 = (gCharacterSize[player->characterId] * 18.0f) * player->size;
     temp_f0 = player->unk_230 - player->unk_23C;
     if ((player->effects & 8) != 8) {
         if ((player->effects & LIGHTNING_EFFECT) == LIGHTNING_EFFECT) {
-            player->unk_0CC[arg2] = (s16) ((s32) (((f64) func_802B7C40(temp_f0 / temp_f2)) * 1.6));
+            player->unk_0CC[screenId] = (s16) ((s32) (((f64) func_802B7C40(temp_f0 / temp_f2)) * 1.6));
         } else {
-            player->unk_0CC[arg2] = func_802B7C40(temp_f0 / temp_f2) * 2;
+            player->unk_0CC[screenId] = func_802B7C40(temp_f0 / temp_f2) * 2;
         }
     }
     if ((player->effects & HIT_EFFECT) == HIT_EFFECT) {
-        player->unk_0CC[arg2] = (s16) ((s32) player->unk_D9C);
+        player->unk_0CC[screenId] = (s16) ((s32) player->unk_D9C);
     }
     if ((player->effects & 8) != 8) {
         temp_f0 = player->unk_1F8 - player->unk_1FC;
-        player->unk_0D4[arg2] = (((func_802B7C40(temp_f0 / temp_f2)) * 0.9));
+        player->unk_0D4[screenId] = (((func_802B7C40(temp_f0 / temp_f2)) * 0.9));
     }
     else {
-        if (((player->animFrameSelector[arg2]) >= 0) && ((player->animFrameSelector[arg2]) < 0x101)) {
+        if (((player->animFrameSelector[screenId]) >= 0) && ((player->animFrameSelector[screenId]) < 0x101)) {
             var_f0 = player->copy_rotation_y - player->pos[1];
         } else {
             var_f0 = player->pos[1] - player->copy_rotation_y;
         }
-        player->unk_0D4[arg2] = (s16) ((s32) (((f64) func_802B7C40(var_f0 / temp_f2)) * 0.5));
+        player->unk_0D4[screenId] = (s16) ((s32) (((f64) func_802B7C40(var_f0 / temp_f2)) * 0.5));
     }
     if ((player->effects & HIT_EFFECT) == HIT_EFFECT) {
-        player->unk_0D4[arg2] = (s16) ((s32) player->unk_D9C);
+        player->unk_0D4[screenId] = (s16) ((s32) player->unk_D9C);
     }
-    func_80029200(player, arg2);
+    func_80029200(player, screenId);
-    temp_a0 = ((player->unk_048[arg2] + player->rotation[1]) + player->unk_0C0);
+    temp_a0 = ((player->unk_048[screenId] + player->rotation[1]) + player->unk_0C0);
-    temp_a0 = (s16) player->unk_0D4[arg2] * sins((u16) temp_a0) + player->unk_0CC[arg2] * coss((u16) temp_a0);
+    temp_a0 = (s16) player->unk_0D4[screenId] * sins((u16) temp_a0) + player->unk_0CC[screenId] * coss((u16) temp_a0);
-    move_s16_towards(&player->unk_050[arg2], temp_a0, 0.5f);
+    move_s16_towards(&player->unk_050[screenId], temp_a0, 0.5f);
-    var_a0 = player->animFrameSelector[arg2];
+    var_a0 = player->animFrameSelector[screenId];
-    player->unk_002 = player->unk_002 & (~(4 << (arg2 * 4)));
+    player->unk_002 = player->unk_002 & (~(4 << (screenId * 4)));
     if (var_a0 >= 0x101) {
         var_a0 = 0x201 - var_a0;
-        player->unk_002 |= (4 << (arg2 * 4));
+        player->unk_002 |= (4 << (screenId * 4));
     }
     if (((player->effects & 0x80) != 0x80)
         && ((player->effects & 0x40) != 0x40)
@@ -913,13 +913,13 @@ void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
     if (((player->effects & 0x80000) == 0x80000)
         || ((player->effects & 0x800000) == 0x800000)
         || (player->unk_044 & 0x800)) {
-        player->unk_050[arg2] = 0;
+        player->unk_050[screenId] = 0;
     }
     if (((player->effects & 8) == 8)
         && ((player->unk_0CA & 2) == 2)) {
-        player->unk_050[arg2] = 0;
+        player->unk_050[screenId] = 0;
     }
-    var_a0 = (player->unk_048[arg2] + player->rotation[1] + player->unk_0C0);
+    var_a0 = (player->unk_048[screenId] + player->rotation[1] + player->unk_0C0);
     if (((player->effects & 0x80) == 0x80)
         || ((player->effects & 0x40) == 0x40)
         || ((player->effects & 0x80000) == 0x80000)
@@ -941,9 +941,9 @@ void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
         }
         var_a0 /= var_a1;
     }
-    player->animFrameSelector[arg2] = var_a0 + var_t0;
+    player->animFrameSelector[screenId] = var_a0 + var_t0;
-    if ((player->animFrameSelector[arg2]) >= 0x23) {
+    if ((player->animFrameSelector[screenId]) >= 0x23) {
-        player->animFrameSelector[arg2] = 0x22;
+        player->animFrameSelector[screenId] = 0x22;
     }
     if ((player->effects & 0x80)
         || (player->effects & 0x40)
@@ -952,18 +952,18 @@ void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
         || (player->effects & 0x20000)
         || (player->unk_044 & 0x800)) {
 
-        if ((player->animFrameSelector[arg2]) >= 0x14) {
+        if ((player->animFrameSelector[screenId]) >= 0x14) {
-            player->animFrameSelector[arg2] = 0;
+            player->animFrameSelector[screenId] = 0;
         }
     }
-    if ((player->animGroupSelector[arg2]) >= 9) {
+    if ((player->animGroupSelector[screenId]) >= 9) {
-        player->animGroupSelector[arg2] = 4;
+        player->animGroupSelector[screenId] = 4;
     }
     if (((player->effects & 0x80000) == 0x80000)
         || ((player->effects & 0x800000) == 0x800000)
         ||  (player->unk_044 & 0x800)) {
 
-        player->animGroupSelector[arg2] = 4;
+        player->animGroupSelector[screenId] = 4;
     }
     if (((player->effects & 0x400) == 0x400)
         || ((player->effects & 0x01000000) == 0x01000000)
@@ -972,27 +972,27 @@ void func_8002934C(Player *player, Camera *camera, s8 arg2, s8 playerId) {
         || (player->effects & 0x80)
         || (player->effects & 0x40)) {
 
-        player->unk_002 |= 1 << (arg2 * 4);
+        player->unk_002 |= 1 << (screenId * 4);
-        D_80165190[arg2][playerId] = 1;
+        D_80165190[screenId][playerId] = 1;
 
         if ((player->effects & 0x80) || (player->effects & 0x40)) {
-            if ((player->animFrameSelector[arg2] == D_801650D0[arg2][playerId])
+            if ((player->animFrameSelector[screenId] == D_801650D0[screenId][playerId])
-                && (player->animGroupSelector[arg2] == D_80165110[arg2][playerId])) {
+                && (player->animGroupSelector[screenId] == D_80165110[screenId][playerId])) {
-                player->unk_002 &= ~(1 << (arg2 * 4));
+                player->unk_002 &= ~(1 << (screenId * 4));
-                D_80165190[arg2][playerId] = 1;
+                D_80165190[screenId][playerId] = 1;
             }
-        } else if (((player->unk_0A8) >> 8) == D_80165150[arg2][playerId] >> 8) {
+        } else if (((player->unk_0A8) >> 8) == D_80165150[screenId][playerId] >> 8) {
-            player->unk_002 &= ~(1 << (arg2 * 4));
+            player->unk_002 &= ~(1 << (screenId * 4));
         }
     } else {
-        player->unk_002 |= 1 << (arg2 * 4);
+        player->unk_002 |= 1 << (screenId * 4);
-        if (((player->animFrameSelector[arg2] == D_801650D0[arg2][playerId]) && (player->animGroupSelector[arg2] == D_80165110[arg2][playerId])) && ((D_80165190[arg2][playerId]) == 0)) {
+        if (((player->animFrameSelector[screenId] == D_801650D0[screenId][playerId]) && (player->animGroupSelector[screenId] == D_80165110[screenId][playerId])) && ((D_80165190[screenId][playerId]) == 0)) {
-            player->unk_002 &= ~(1 << (arg2 * 4));
+            player->unk_002 &= ~(1 << (screenId * 4));
         }
     }
-    temp_a0_2 = D_801650D0[arg2][playerId] - player->animFrameSelector[arg2];
+    temp_a0_2 = D_801650D0[screenId][playerId] - player->animFrameSelector[screenId];
     if ((temp_a0_2 >= 0x14) || (temp_a0_2 < (-0x13))) {
-        player->unk_002 |= 1 << (arg2 * 4);
+        player->unk_002 |= 1 << (screenId * 4);
     }
 }
 
@@ -1516,7 +1516,7 @@ void func_8002B218(Player *player) {
     }
 }
 
-void apply_sound_effect(Player *player, s8 playerId, UNUSED s8 arg2) {
+void apply_sound_effect(Player *player, s8 playerId, UNUSED s8 screenId) {
     if ((player->soundEffects & 2) == 2) {
         apply_hit_by_item_sound_effect(player, playerId);
     }
@@ -1573,7 +1573,7 @@ void apply_sound_effect(Player *player, s8 playerId, UNUSED s8 arg2) {
     }
 }
 
-void func_8002B5C0(Player *player, UNUSED s8 playerId, UNUSED s8 arg2) {
+void func_8002B5C0(Player *player, UNUSED s8 playerId, UNUSED s8 screenId) {
     if (((player->unk_0CA & 8) != 0) || ((player->unk_0CA & 2) != 0)) {
         player->soundEffects &= 0xFE1D0478;
     }
@@ -1627,12 +1627,12 @@ void func_8002B5C0(Player *player, UNUSED s8 playerId, UNUSED s8 arg2) {
     }
 }
 
-void func_8002B830(Player *player, s8 playerId, s8 arg2) {
+void func_8002B830(Player *player, s8 playerId, s8 screenId) {
     if (player->soundEffects != 0) {
-        func_8002B5C0(player, playerId, arg2);
+        func_8002B5C0(player, playerId, screenId);
     }
     if (player->soundEffects != 0) {
-        apply_sound_effect(player, playerId, arg2);
+        apply_sound_effect(player, playerId, screenId);
     }
     if ((player->unk_044 & 0x400) != 0) {
         func_800911B4(player, playerId);
@@ -2199,7 +2199,7 @@ void func_8002D028(Player *player, s8 arg1) {
     }
 }
 
-void func_8002D268(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
+void func_8002D268(Player *player, UNUSED Camera *camera, s8 screenId, s8 playerId)
 {
     Vec3f sp184 = {0.0, 0.0, 1.0};
     Vec3f sp178 = {0.0, 0.0, 0.0};
@@ -2234,11 +2234,11 @@ void func_8002D268(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         func_8002A79C(player, playerId);
     }
-    func_8002B830(player, playerId, arg2);
+    func_8002B830(player, playerId, screenId);
     if (((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) && ((player->type & PLAYER_INVISIBLE_OR_BOMB) != PLAYER_INVISIBLE_OR_BOMB)) {
         func_8002BF4C(player, playerId);
     }
-    apply_effect(player, playerId, arg2);
+    apply_effect(player, playerId, screenId);
     if (((player->effects & 0x20000000) == 0x20000000) && (player->unk_228 >= 0x64)) {
         sp7C = 2;
     }
@@ -2288,7 +2288,7 @@ void func_8002D268(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
     mtxf_translate_vec3f_mat3(sp178, player->orientationMatrix);
     spB4 += sp178[0];
     spAC += sp178[2];
-    func_8002C7E4(player, playerId, arg2);
+    func_8002C7E4(player, playerId, screenId);
     sp184[2] = func_80030150(player, playerId);
     mtxf_translate_vec3f_mat3(sp184, player->orientationMatrix);
     sp98[0] = player->velocity[0];
@@ -2461,7 +2461,7 @@ void func_8002D268(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
     }
     player->pos[1] = spF8;
     if ((player->type & PLAYER_HUMAN) && (!(player->type & PLAYER_KART_AI))) {
-        func_8002BB9C(player, &spFC, &spF4, arg2, playerId, sp98);
+        func_8002BB9C(player, &spFC, &spF4, screenId, playerId, sp98);
     }
     player->unk_064[0] = sp178[0];
     player->unk_064[2] = sp178[2];
@@ -2509,7 +2509,7 @@ void func_8002E4C4(Player *player) {
     player->velocity[1] = 0.0f;
 }
 
-void func_8002E594(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId) {
+void func_8002E594(Player *player, UNUSED Camera *camera, s8 screenId, s8 playerId) {
     Vec3f spEC = {0.0f, 0.0f, 1.0f};
     Vec3f spE0 = {0.0f, 0.0f, 0.0f};
     Vec3f spD4 = {0.0f, 0.0f, 0.0f};
@@ -2531,7 +2531,7 @@ void func_8002E594(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
     Vec3f sp54;
     Vec3f sp48;
     s16 sp46;
-    func_8002B830(player, playerId, arg2);
+    func_8002B830(player, playerId, screenId);
     if ((((((((player->effects & 0x80) == 0x80)
         || ((player->effects & 0x40) == 0x40))
         || ((player->effects & 0x4000) == 0x4000))
@@ -2543,7 +2543,7 @@ void func_8002E594(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
     } else {
         sp46 = 0;
     }
-    apply_effect(player, playerId, arg2);
+    apply_effect(player, playerId, screenId);
     func_8002AB70(player);
     func_8002FCA8(player, playerId);
     if ((((player->effects & 0x80) == 0x80)
@@ -2557,7 +2557,7 @@ void func_8002E594(Player *player, UNUSED Camera *camera, s8 arg2, s8 playerId)
         sp7C = -1 * player->kartGravity;
         sp78 = -1 * player->unk_064[2];
     }
-    func_8002C7E4(player, playerId, arg2);
+    func_8002C7E4(player, playerId, screenId);
     if (sp46 == 1) {
         calculate_orientation_matrix(player->orientationMatrix, player->unk_058, player->unk_05C, player->unk_060, (s16) ((s32) player->rotation[1]));
         calculate_orientation_matrix(player->unk_150, player->unk_058, player->unk_05C, player->unk_060, (s16) ((s32) player->unk_0AE));
@@ -2827,7 +2827,7 @@ void control_kart_ai_movement(Player *player, UNUSED Camera *camera, s8 arg2, s8
     }
 }
 
-void func_8002F730(Player *player, UNUSED Camera *camera, UNUSED s8 arg2, s8 arg3) {
+void func_8002F730(Player *player, UNUSED Camera *camera, UNUSED s8 screenId, s8 playerId) {
     Vec3f spF4 = {0.0f, 0.0f, 1.0f};
     Vec3f spE8 = {0.0f, 0.0f, 0.0f};
     UNUSED Vec3f spDC = {0.0f, 0.0f, 0.0f};
@@ -2853,7 +2853,7 @@ void func_8002F730(Player *player, UNUSED Camera *camera, UNUSED s8 arg2, s8 arg
     func_80037BB4(player, spD0);
     sp84 = player->unk_064[0] * 0;
     sp7C = player->unk_064[2] * 0;
-    spF4[2] = func_80030150(player, arg3);
+    spF4[2] = func_80030150(player, playerId);
 
     mtxf_translate_vec3f_mat3(spF4, player->orientationMatrix);
 
@@ -2898,7 +2898,7 @@ void func_8002F730(Player *player, UNUSED Camera *camera, UNUSED s8 arg2, s8 arg
     } else {
         func_8002A194(player, spCC, spC8, spC4);
     }
-    func_8002AE38(player, arg3, spC0, spB8, spCC, spC4);
+    func_8002AE38(player, playerId, spC0, spB8, spCC, spC4);
     sqrt = (sp68[0] * sp68[0]) + (sp68[1] * sp68[1]) + (sp68[2] * sp68[2]);
     player->unk_22C = player->unk_094;
     player->unk_094 = sqrtf(sqrt);
@@ -2918,9 +2918,9 @@ void func_8002F730(Player *player, UNUSED Camera *camera, UNUSED s8 arg2, s8 arg
     player->velocity[1] = sp68[1];
     player->velocity[2] = sp68[2];
 
-    D_80165070[arg3][0] = sp68[0];
+    D_80165070[playerId][0] = sp68[0];
-    D_80165070[arg3][1] = sp68[1];
+    D_80165070[playerId][1] = sp68[1];
-    D_80165070[arg3][2] = sp68[2];
+    D_80165070[playerId][2] = sp68[2];
 
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         if (gKartTopSpeedTable[player->characterId] < player->unk_094) {

src/port/Engine.cpp

@@ -8,6 +8,7 @@
 #include "resource/importers/Vec3fFactory.h"
 #include "resource/importers/Vec3sFactory.h"
 #include "resource/importers/KartAIFactory.h"
+#include "resource/importers/CourseVtxFactory.h"
 #include "resource/importers/TrackSectionsFactory.h"
 #include "resource/importers/TrackWaypointFactory.h"
 #include "resource/importers/ActorSpawnDataFactory.h"
@@ -25,7 +26,6 @@ float gInterpolationStep = 0.0f;
 #include <DisplayListFactory.h>
 #include <TextureFactory.h>
 #include <MatrixFactory.h>
-#include <ArrayFactory.h>
 #include <BlobFactory.h>
 #include <VertexFactory.h>
 }
@@ -34,11 +34,11 @@ GameEngine* GameEngine::Instance;
 
 GameEngine::GameEngine() {
     std::vector<std::string> OTRFiles;
-    if (const std::string cube_path = Ship::Context::GetPathRelativeToAppDirectory("mkcube.otr"); std::filesystem::exists(cube_path)) {
+    if (const std::string spaghetti_path = Ship::Context::GetPathRelativeToAppDirectory("spaghetti.otr"); std::filesystem::exists(spaghetti_path)) {
-        OTRFiles.push_back(cube_path);
+        OTRFiles.push_back(spaghetti_path);
     }
-    if (const std::string sm64_otr_path = Ship::Context::GetPathRelativeToAppBundle("sm64.otr"); std::filesystem::exists(sm64_otr_path)) {
+    if (const std::string ship_otr_path = Ship::Context::GetPathRelativeToAppBundle("ship.otr"); std::filesystem::exists(ship_otr_path)) {
-        OTRFiles.push_back(sm64_otr_path);
+        OTRFiles.push_back(ship_otr_path);
     }
     if (const std::string patches_path = Ship::Context::GetPathRelativeToAppDirectory("mods"); !patches_path.empty() && std::filesystem::exists(patches_path)) {
         if (std::filesystem::is_directory(patches_path)) {
@@ -52,6 +52,10 @@ GameEngine::GameEngine() {
 
     this->context = Ship::Context::CreateInstance("Spaghettify", "skart64", "spaghettify.cfg.json", OTRFiles, {}, 3);
 
+    auto wnd = std::dynamic_pointer_cast<Fast::Fast3dWindow>(Ship::Context::GetInstance()->GetWindow());
+
+    wnd->SetRendererUCode(ucode_f3dex);
+
     auto loader = context->GetResourceManager()->GetResourceLoader();
     loader->RegisterResourceFactory(std::make_shared<SF64::ResourceFactoryBinaryVec3fV0>(), RESOURCE_FORMAT_BINARY, "Vec3f", static_cast<uint32_t>(SF64::ResourceType::Vec3f), 0);
     loader->RegisterResourceFactory(std::make_shared<SF64::ResourceFactoryBinaryVec3sV0>(), RESOURCE_FORMAT_BINARY, "Vec3s", static_cast<uint32_t>(SF64::ResourceType::Vec3s), 0);
@@ -61,9 +65,9 @@ GameEngine::GameEngine() {
     loader->RegisterResourceFactory(std::make_shared<LUS::ResourceFactoryBinaryVertexV0>(), RESOURCE_FORMAT_BINARY, "Vertex", static_cast<uint32_t>(LUS::ResourceType::Vertex), 0);
     loader->RegisterResourceFactory(std::make_shared<LUS::ResourceFactoryBinaryDisplayListV0>(), RESOURCE_FORMAT_BINARY, "DisplayList", static_cast<uint32_t>(LUS::ResourceType::DisplayList), 0);
     loader->RegisterResourceFactory(std::make_shared<LUS::ResourceFactoryBinaryMatrixV0>(), RESOURCE_FORMAT_BINARY, "Matrix", static_cast<uint32_t>(LUS::ResourceType::Matrix), 0);
-    loader->RegisterResourceFactory(std::make_shared<LUS::ResourceFactoryBinaryArrayV0>(), RESOURCE_FORMAT_BINARY, "Array", static_cast<uint32_t>(LUS::ResourceType::Array), 0);
     loader->RegisterResourceFactory(std::make_shared<LUS::ResourceFactoryBinaryBlobV0>(), RESOURCE_FORMAT_BINARY, "Blob", static_cast<uint32_t>(LUS::ResourceType::Blob), 0);
     loader->RegisterResourceFactory(std::make_shared<MK64::ResourceFactoryBinaryKartAIV0>(), RESOURCE_FORMAT_BINARY, "KartAI", static_cast<uint32_t>(MK64::ResourceType::KartAI), 0);
+    loader->RegisterResourceFactory(std::make_shared<MK64::ResourceFactoryBinaryCourseVtxV0>(), RESOURCE_FORMAT_BINARY, "CourseVtx", static_cast<uint32_t>(MK64::ResourceType::CourseVertex), 0);
     loader->RegisterResourceFactory(std::make_shared<MK64::ResourceFactoryBinaryTrackSectionsV0>(), RESOURCE_FORMAT_BINARY, "TrackSections", static_cast<uint32_t>(MK64::ResourceType::TrackSection), 0);
     loader->RegisterResourceFactory(std::make_shared<MK64::ResourceFactoryBinaryTrackWaypointsV0>(), RESOURCE_FORMAT_BINARY, "Waypoints", static_cast<uint32_t>(MK64::ResourceType::Waypoints), 0);
     loader->RegisterResourceFactory(std::make_shared<MK64::ResourceFactoryBinaryActorSpawnDataV0>(), RESOURCE_FORMAT_BINARY, "SpawnData", static_cast<uint32_t>(MK64::ResourceType::SpawnData), 0);

src/port/GBIMiddleware.cpp

@@ -2,7 +2,6 @@
 
 #include "Engine.h"
 #include "DisplayList.h"
-#include "Array.h"
 
 extern "C" int GameEngine_OTRSigCheck(const char* data);
 
@@ -13,9 +12,6 @@ extern "C" void gSPDisplayList(Gfx* pkt, Gfx* dl) {
         auto resource = Ship::Context::GetInstance()->GetResourceManager()->LoadResource(imgData);
         auto res = std::static_pointer_cast<LUS::DisplayList>(resource);
         dl = &res->Instructions[0];
-        dl->words.trace.file = imgData;
-        dl->words.trace.idx = 0;
-        dl->words.trace.valid = true;
     }
 
     __gSPDisplayList(pkt, dl);
@@ -41,9 +37,6 @@ extern "C" void gSPInvalidateTexCache(Gfx* pkt, uintptr_t texAddr) {
             case LUS::ResourceType::DisplayList:
                 texAddr = reinterpret_cast<uintptr_t>(&std::static_pointer_cast<LUS::DisplayList>(res)->Instructions[0]);
                 break;
-            case LUS::ResourceType::Array:
-                texAddr = reinterpret_cast<uintptr_t>(std::static_pointer_cast<LUS::Array>(res)->Vertices.data());
-                break;
             default:
                 texAddr = reinterpret_cast<uintptr_t>(res->GetRawPointer());
                 break;

src/port/resource/importers/CourseVtxFactory.cpp

@@ -0,0 +1,35 @@
+#include "CourseVtxFactory.h"
+#include "../type/CourseVtx.h"
+#include "spdlog/spdlog.h"
+#include "libultraship/libultra/gbi.h"
+
+namespace MK64 {
+    std::shared_ptr<Ship::IResource> ResourceFactoryBinaryCourseVtxV0::ReadResource(std::shared_ptr<Ship::File> file) {
+        if (!FileHasValidFormatAndReader(file)) {
+            return nullptr;
+        }
+
+        auto cvtx = std::make_shared<CourseVtxClass>(file->InitData);
+        auto reader = std::get<std::shared_ptr<Ship::BinaryReader>>(file->Reader);
+
+        uint32_t count = reader->ReadUInt32();
+        cvtx->CourseVtxList.reserve(count);
+
+        for (uint32_t i = 0; i < count; i++) {
+            CourseVtxData data;
+            data.ob[0] = reader->ReadInt16();
+            data.ob[1] = reader->ReadInt16();
+            data.ob[2] = reader->ReadInt16();
+            data.tc[0] = reader->ReadInt16();
+            data.tc[1] = reader->ReadInt16();
+            data.ca[0] = reader->ReadUByte();
+            data.ca[1] = reader->ReadUByte();
+            data.ca[2] = reader->ReadUByte();
+            data.ca[3] = reader->ReadUByte();
+
+            cvtx->CourseVtxList.push_back(data);
+        }
+
+        return cvtx;
+    }
+}

src/port/resource/importers/CourseVtxFactory.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Resource.h"
+#include "ResourceFactoryBinary.h"
+
+namespace MK64 {
+class ResourceFactoryBinaryCourseVtxV0 : public Ship::ResourceFactoryBinary {
+  public:
+    std::shared_ptr<Ship::IResource> ReadResource(std::shared_ptr<Ship::File> file) override;
+};
+
+} // namespace LUS

src/port/resource/type/CourseVtx.cpp

@@ -0,0 +1,15 @@
+#include "CourseVtx.h"
+#include "libultraship/libultra/gbi.h"
+
+namespace MK64 {
+CourseVtxClass::CourseVtxClass() : Resource(std::shared_ptr<Ship::ResourceInitData>()) {
+}
+
+CourseVtxData* CourseVtxClass::GetPointer() {
+    return CourseVtxList.data();
+}
+
+size_t CourseVtxClass::GetPointerSize() {
+    return CourseVtxList.size() * sizeof(CourseVtxData);
+}
+} // namespace LUS

src/port/resource/type/CourseVtx.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "resource/Resource.h"
+#include <vector>
+#include <libultra/gbi.h>
+
+typedef struct {
+    s16 ob[3];    /* x, y, z */
+    s16 tc[2];    /* texture coord */
+    s8  ca[4];    /* color & alpha */
+} CourseVtxData;
+
+namespace MK64 {
+class CourseVtxClass : public Ship::Resource<CourseVtxData> {
+  public:
+    using Resource::Resource;
+
+    CourseVtxClass();
+
+    CourseVtxData* GetPointer() override;
+    size_t GetPointerSize() override;
+
+    std::vector<CourseVtxData> CourseVtxList;
+};
+} // namespace LUS

src/port/resource/type/TrackSections.h

@@ -5,7 +5,7 @@
 #include <libultra/gbi.h>
 
 typedef struct {
-    uintptr_t addr;
+    uint32_t addr;
     uint8_t surfaceType;
     uint8_t sectionId;
     uint16_t flags;

src/port/ui/ImguiUI.cpp

@@ -188,7 +188,8 @@ void DrawSettingsMenu(){
         { // FPS Slider
             const int minFps = 30;
             static int maxFps;
-            if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend() == Ship::WindowBackend::DX11) {
+            if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend()
+                == Ship::WindowBackend::FAST3D_DXGI_DX11) {
                 maxFps = 360;
             } else {
                 maxFps = Ship::Context::GetInstance()->GetWindow()->GetCurrentRefreshRate();
@@ -255,13 +256,15 @@ void DrawSettingsMenu(){
             CVarSetInteger("gInterpolationFPS", currentFps);
             Ship::Context::GetInstance()->GetWindow()->GetGui()->SaveConsoleVariablesOnNextTick();
         #else
-            bool matchingRefreshRate =
+            bool matchingRefreshRate = CVarGetInteger("gMatchRefreshRate", 0)
-                CVarGetInteger("gMatchRefreshRate", 0) && Ship::Context::GetInstance()->GetWindow()->GetWindowBackend() != Ship::WindowBackend::DX11;
+                                       && Ship::Context::GetInstance()->GetWindow()->GetWindowBackend()
+                                              != Ship::WindowBackend::FAST3D_DXGI_DX11;
             UIWidgets::CVarSliderInt((currentFps == 20) ? "FPS: Original (20)" : "FPS: %d", "gInterpolationFPS", minFps, maxFps, 1, {
                 .disabled = matchingRefreshRate
             });
         #endif
-            if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend() == Ship::WindowBackend::DX11) {
+            if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend()
+                == Ship::WindowBackend::FAST3D_DXGI_DX11) {
                 UIWidgets::Tooltip(
                     "Uses Matrix Interpolation to create extra frames, resulting in smoother graphics. This is purely "
                     "visual and does not impact game logic, execution of glitches etc.\n\n"
@@ -275,7 +278,8 @@ void DrawSettingsMenu(){
             }
         } // END FPS Slider
 
-        if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend() == Ship::WindowBackend::DX11) {
+        if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend()
+            == Ship::WindowBackend::FAST3D_DXGI_DX11) {
             UIWidgets::Spacer(0);
             if (ImGui::Button("Match Refresh Rate")) {
                 int hz = Ship::Context::GetInstance()->GetWindow()->GetCurrentRefreshRate();
@@ -290,7 +294,8 @@ void DrawSettingsMenu(){
 
         UIWidgets::Tooltip("Matches interpolation value to the current game's window refresh rate");
 
-        if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend() == Ship::WindowBackend::DX11) {
+        if (Ship::Context::GetInstance()->GetWindow()->GetWindowBackend()
+            == Ship::WindowBackend::FAST3D_DXGI_DX11) {
             UIWidgets::PaddedEnhancementSliderInt(CVarGetInteger("gExtraLatencyThreshold", 80) == 0 ? "Jitter fix: Off" : "Jitter fix: >= %d FPS",
                                                   "##ExtraLatencyThreshold", "gExtraLatencyThreshold", 0, 360, "", 80, true, true, false);
             UIWidgets::Tooltip("When Interpolation FPS setting is at least this threshold, add one frame of input lag (e.g. 16.6 ms for 60 FPS) in order to avoid jitter. This setting allows the CPU to work on one frame while GPU works on the previous frame.\nThis setting should be used when your computer is too slow to do CPU + GPU work in time.");
@@ -300,17 +305,17 @@ void DrawSettingsMenu(){
 
 
         static std::unordered_map<Ship::WindowBackend, const char*> windowBackendNames = {
-                { Ship::WindowBackend::DX11, "DirectX" },
+                { Ship::WindowBackend::FAST3D_DXGI_DX11, "DirectX" },
-                { Ship::WindowBackend::SDL_OPENGL, "OpenGL"},
+                { Ship::WindowBackend::FAST3D_SDL_OPENGL, "OpenGL" },
-                { Ship::WindowBackend::SDL_METAL, "Metal" },
+                { Ship::WindowBackend::FAST3D_SDL_METAL, "Metal" },
-                { Ship::WindowBackend::GX2, "GX2"}
         };
 
         ImGui::Text("Renderer API (Needs reload)");
         Ship::WindowBackend runningWindowBackend = Ship::Context::GetInstance()->GetWindow()->GetWindowBackend();
         Ship::WindowBackend configWindowBackend;
         int configWindowBackendId = Ship::Context::GetInstance()->GetConfig()->GetInt("Window.Backend.Id", -1);
-        if (configWindowBackendId != -1 && configWindowBackendId < static_cast<int>(Ship::WindowBackend::BACKEND_COUNT)) {
+        if (configWindowBackendId != -1
+            && configWindowBackendId < static_cast<int>(Ship::WindowBackend::WINDOW_BACKEND_COUNT)) {
             configWindowBackend = static_cast<Ship::WindowBackend>(configWindowBackendId);
         } else {
             configWindowBackend = runningWindowBackend;

src/racing/actors.c

@@ -333,16 +333,16 @@ void func_80297340(Camera *arg0) {
         if (D_800DC5BC != 0) {
 
             gDPSetFogColor(gDisplayListHead++, D_801625EC, D_801625F4, D_801625F0, 0xFF);
-            gSPDisplayList(gDisplayListHead++, &D_0D001C20);
+            gSPDisplayList(gDisplayListHead++, D_0D001C20);
         } else {
-            gSPDisplayList(gDisplayListHead++, &D_0D001B90);
+            gSPDisplayList(gDisplayListHead++, D_0D001B90);
         }
     } else if (D_800DC5BC != 0) {
 
         gDPSetFogColor(gDisplayListHead++, D_801625EC, D_801625F4, D_801625F0, 0xFF);
-        gSPDisplayList(gDisplayListHead++, &D_0D001C88);
+        gSPDisplayList(gDisplayListHead++, D_0D001C88);
     } else {
-        gSPDisplayList(gDisplayListHead++, &D_0D001BD8);
+        gSPDisplayList(gDisplayListHead++, D_0D001BD8);
     }
 }
 
@@ -747,32 +747,32 @@ void func_8029AC18(Camera *camera, Mat4 arg1, struct Actor *arg2) {
     arg1[3][2] = arg2->pos[2];
 
     if (render_set_position(arg1, 0) != 0) {
-        gSPDisplayList(gDisplayListHead++, &D_0D001750);
+        gSPDisplayList(gDisplayListHead++, D_0D001750);
 
         switch (arg2->state) {
         case 0:
-            gSPDisplayList(gDisplayListHead++, &D_0D001780);
+            gSPDisplayList(gDisplayListHead++, D_0D001780);
             break;
         case 1:
-            gSPDisplayList(gDisplayListHead++, &D_0D001798);
+            gSPDisplayList(gDisplayListHead++, D_0D001798);
             break;
         case 2:
-            gSPDisplayList(gDisplayListHead++, &D_0D0017B0);
+            gSPDisplayList(gDisplayListHead++, D_0D0017B0);
             break;
         case 3:
-            gSPDisplayList(gDisplayListHead++, &D_0D0017C8);
+            gSPDisplayList(gDisplayListHead++, D_0D0017C8);
             break;
         case 4:
-            gSPDisplayList(gDisplayListHead++, &D_0D0017E0);
+            gSPDisplayList(gDisplayListHead++, D_0D0017E0);
             break;
         case 5:
-            gSPDisplayList(gDisplayListHead++, &D_0D0017F8);
+            gSPDisplayList(gDisplayListHead++, D_0D0017F8);
             break;
         case 6:
-            gSPDisplayList(gDisplayListHead++, &D_0D001810);
+            gSPDisplayList(gDisplayListHead++, D_0D001810);
             break;
         case 7:
-            gSPDisplayList(gDisplayListHead++, &D_0D001828);
+            gSPDisplayList(gDisplayListHead++, D_0D001828);
             break;
         }
     }
@@ -1028,16 +1028,16 @@ void spawn_course_actors(void) {
         struct ActorSpawnData *a_d_course_mario_raceway_piranha_plant_spawns = (struct ActorSpawnData *) LOAD_ASSET(d_course_mario_raceway_piranha_plant_spawns);
         struct ActorSpawnData *a_d_course_mario_raceway_item_box_spawns = (struct ActorSpawnData *) LOAD_ASSET(d_course_mario_raceway_item_box_spawns);
 
-        spawn_foliage(a_d_course_mario_raceway_tree_spawns);
+        //spawn_foliage(a_d_course_mario_raceway_tree_spawns);
-        spawn_piranha_plants(a_d_course_mario_raceway_piranha_plant_spawns);
+        //spawn_piranha_plants(a_d_course_mario_raceway_piranha_plant_spawns);
-        spawn_all_item_boxes(a_d_course_mario_raceway_item_box_spawns);
+        //spawn_all_item_boxes(a_d_course_mario_raceway_item_box_spawns);
-        vec3f_set(position, 150.0f, 40.0f, -1300.0f);
+        // vec3f_set(position, 150.0f, 40.0f, -1300.0f);
-        position[0] *= gCourseDirection;
+        // position[0] *= gCourseDirection;
-        add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
+        // add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
-        vec3f_set(position, 2520.0f, 0.0f, 1240.0f);
+        // vec3f_set(position, 2520.0f, 0.0f, 1240.0f);
-        position[0] *= gCourseDirection;
+        // position[0] *= gCourseDirection;
-        actor = &gActorList[add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN)];
+        // actor = &gActorList[add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN)];
-        actor->flags |= 0x4000;
+        // actor->flags |= 0x4000;
         break;
     case COURSE_CHOCO_MOUNTAIN:
         spawn_all_item_boxes(d_course_choco_mountain_item_box_spawns);

src/racing/collision.c

@@ -9,6 +9,7 @@
 #include "collision.h"
 #include "math_util.h"
 #include "code_800029B0.h"
+#include <assert.h>
 
 // Used to delete the choco mountain guard rail
 void nullify_displaylist(uintptr_t addr) {
@@ -1547,6 +1548,11 @@ void func_802AE434(Vtx *vtx1, Vtx *vtx2, Vtx *vtx3, s8 surfaceType, u16 sectionI
     s16 y3;
     s16 z3;
 
+    // printf("mesh index: %d ", D_8015F588);
+    // printf("sectionId: 0x%X ", sectionId);
+    // printf("surfaceType: 0x%X ", surfaceType);
+    
+
     /* Unused variables placed around doubles for dramatic effect */
     UNUSED s32 pad2[7];
 
@@ -1676,6 +1682,11 @@ void func_802AE434(Vtx *vtx1, Vtx *vtx2, Vtx *vtx3, s8 surfaceType, u16 sectionI
         gCourseMaxZ = maxZ;
     }
 
+    // printf("X 0x%X\n ", normalX);
+    // printf("Y 0x%X\n ", normalY);
+    // printf("Z 0x%X\n ", normalZ);
+    // printf("dist 0x%X\n\n", distance);
+
     tile->height = normalX;
     tile->gravity = normalY;
     tile->rotation = normalZ;
@@ -1747,6 +1758,17 @@ void set_vtx_from_tri2(u32 triangle1, u32 triangle2, s8 surfaceType, u16 section
     u32 vert5 = ( ( triangle2 & 0x0000FF00 ) >>  8 ) / 2;
     u32 vert6 = (   triangle2 & 0x000000FF )         / 2;
 
+    // printf("tr1: 0x%X \n", triangle1);
+    // printf("tr2: 0x%X \n", triangle2);
+
+    // printf("\nv1 0x%X ", vert1);
+    // printf("v2 0x%X ", vert2);
+    // printf("v3 0x%X ", vert3);
+    // printf("v4 0x%X ", vert4);
+    // printf("v5 0x%X ", vert5);
+    // printf("v6 0x%X\n", vert6);
+
+
     Vtx *vtx1 = vtxBuffer[vert1];
     Vtx *vtx2 = vtxBuffer[vert2];
     Vtx *vtx3 = vtxBuffer[vert3];
@@ -1791,6 +1813,10 @@ void set_vtx_buffer(uintptr_t addr, u32 numVertices, u32 bufferIndex) {
     u32 i;
     Vtx *vtx = (Vtx *) addr;
     for (i = 0; i < numVertices; i++) {
+        //printf("VTX: 0x%llX",vtx);
+        if (vtx == 0) {
+           assert(false);
+        }
         vtxBuffer[bufferIndex] = vtx;
         vtx++;
         bufferIndex++;
@@ -1977,6 +2003,7 @@ void set_vertex_data_with_default_section_id(Gfx *gfx, s8 surfaceType) {
 }
 
 extern u32 D_8015F58C;
+u32 numTimes = 0;
 
 /**
  * Recursive search and set for vertex data
@@ -1986,6 +2013,7 @@ void find_and_set_vertex_data(Gfx *addr, s8 surfaceType, u16 sectionId) {
     uintptr_t lo;
     uintptr_t hi;
     s32 i;
+    numTimes++;
     //printf("Initial\n");
     //printf("ptr 0x%llX\n", &addr);
     //printf("w0 0x%llX\n", addr->words.w0);
@@ -2009,20 +2037,20 @@ void find_and_set_vertex_data(Gfx *addr, s8 surfaceType, u16 sectionId) {
         
         //  printf("ptr 0x%llX\n", &addr);
         //  printf("op 0x%llX\n", opcode);
-        //  printf("w0 0x%X\n", lo);
+        //   printf("w0 0x%llX\n", lo);
-        //  printf("w1 0x%X\n", hi);
+        //   printf("w1 0x%llX\n", hi);
 
         if (opcode == (G_DL << 24)) {
             // G_DL's hi contains an addr to another DL.
-            Gfx *dl = segmented_gfx_to_virtual(hi);
+            //Gfx *dl = segmented_gfx_to_virtual(hi);
-            // printf("DL: 0x%llX\n", &dl);
+            // printf("DL: 0x%llX ", hi);
-            //     printf("  w0 0x%X\n", dl->words.w0);
+            //     printf("  w0 0x%llX", lo);
-            //     printf("  w1 0x%X\n", dl->words.w1);
+            //     printf("  w1 0x%llX\n", hi);
 
-            find_and_set_vertex_data((Gfx *) (dl), surfaceType, sectionId);
+            find_and_set_vertex_data((Gfx *) (hi), surfaceType, sectionId);
 
         } else if (opcode == (G_VTX << 24)) {
-            set_vtx_buffer(segmented_gfx_to_virtual(hi), (lo >> 10) & 0x3F, ((lo >> 16) & 0xFF) >> 1);
+            set_vtx_buffer((hi), (lo >> 10) & 0x3F, ((lo >> 16) & 0xFF) >> 1);
 
         } else if (opcode == (G_TRI1 << 24)) {
             D_8015F58C += 1;
@@ -2030,6 +2058,7 @@ void find_and_set_vertex_data(Gfx *addr, s8 surfaceType, u16 sectionId) {
 
         } else if (opcode == (G_TRI2 << 24)) {
             D_8015F58C += 2;
+
             set_vtx_from_tri2(lo, hi, surfaceType, sectionId);
 
         } else if (opcode == (G_QUAD << 24)) {

src/racing/memory.c

@@ -2,6 +2,7 @@
 #include <libultra/types.h>
 #include <align_asset_macro.h>
 #include <macros.h>
+#include <string.h>
 #include <common_structs.h>
 #include <segments.h>
 #include <decode.h>
@@ -15,7 +16,9 @@
 #include "defines.h"
 #include <assets/mario_raceway_displaylists.h>
 #include <assets/mario_raceway_vertices.h>
+#include <assets/mario_raceway_data.h>
 #include <assert.h>
+#include <course_offsets.h>
 
 s32 sGfxSeekPosition;
 s32 sPackedSeekPosition;
@@ -95,17 +98,44 @@ void *segmented_to_virtual(const void *addr) {
     return (void *) ((gSegmentTable[segment] + offset));
 }
 
+
 void *segment_offset_to_virtual(uint32_t segment, uint32_t offset) {
     return (void *) (gSegmentTable[segment] + ( (offset / 8) * sizeof(Gfx) ) );
 }
 
+void *segment_vtx_to_virtual(size_t offset) {
+    printf("seg_vtx_to_virt: 0x%llX to 0x%llX\n", offset, (gSegmentTable[0x04] + offset));
+
+    return (void *) (gSegmentTable[0x04] + (offset));
+}
+
+void *segmented_texture_to_virtual(size_t offset) {
+    printf("seg_texture_to_virt: 0x%llX to 0x%llX\n", offset, (gSegmentTable[0x05] + offset));
+
+    return (void *) (gSegmentTable[0x05] + (offset));
+}
+
+void *segmented_uintptr_t_to_virtual(uintptr_t addr) {
+    uint32_t newAddr = (uint32_t) addr;
+    size_t segment = (uintptr_t) newAddr >> 24;
+    size_t offset = (uintptr_t) newAddr & 0x00FFFFFF;
+
+    uint32_t numCommands = offset / 8;
+    offset = numCommands * sizeof(Gfx);
+
+    printf("seg_gfx_to_virt: 0x%llX to 0x%llX\n", newAddr, (gSegmentTable[segment] + offset));
+
+    return (void *) ((gSegmentTable[segment] + offset));
+}
+
 void *segmented_gfx_to_virtual(const void *addr) {
     size_t segment = (uintptr_t) addr >> 24;
     size_t offset = (uintptr_t) addr & 0x00FFFFFF;
 
-    offset = (offset / 8) * sizeof(Gfx);
+    uint32_t numCommands = offset / 8;
+    offset = numCommands * sizeof(Gfx);
 
-    printf("seg_gfx_to_virt: 0x%llX\n",addr);
+    printf("seg_gfx_to_virt: 0x%llX to 0x%llX\n", addr, (gSegmentTable[segment] + offset));
 
     return (void *) ((gSegmentTable[segment] + offset));
 }
@@ -143,7 +173,7 @@ void initialize_memory_pool() {
 /**
  * @brief Allocates memory and adjusts gFreeMemorySize.
 */
-void *allocate_memory(uintptr_t size) {
+void *allocate_memory(size_t size) {
     uintptr_t freeSpace;
 
     size = ALIGN16(size);
@@ -437,19 +467,22 @@ UNUSED u8 *func_802A841C(u8* arg0, s32 arg1, s32 arg2) {
 }
 
 u8 *dma_textures(u8 texture[], size_t arg1, size_t arg2) {
-    // u8 *temp_v0;
+    u8 *temp_v0;
-    // void *temp_a0;
+    void *temp_a0;
 
-    // temp_v0 = (u8 *) gNextFreeMemoryAddress;
+    u8* tex = (u8 *) LOAD_ASSET(texture);
-    // temp_a0 = temp_v0 + arg2;
+
-    // arg1 = ALIGN16(arg1);
+    temp_v0 = (u8 *) gNextFreeMemoryAddress;
-    // arg2 = ALIGN16(arg2);
+    temp_a0 = temp_v0 + arg2;
+    arg1 = ALIGN16(arg1);
+    arg2 = ALIGN16(arg2);
     //osInvalDCache((void *) temp_a0, arg1);
     // osPiStartDma(&gDmaIoMesg, 0, 0, (uintptr_t) &_other_texturesSegmentRomStart[SEGMENT_OFFSET(texture)], (void *)temp_a0, arg1, &gDmaMesgQueue);
     // osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, (int) 1);
     // mio0decode((u8 *) temp_a0, temp_v0);
-    // gNextFreeMemoryAddress += arg2;
+    memcpy(temp_v0, tex, arg2);
-    return texture;
+    gNextFreeMemoryAddress += arg2;
+    return temp_v0;
 }
 
 uintptr_t MIO0_0F(u8 *arg0, uintptr_t arg1, uintptr_t arg2) {
@@ -550,13 +583,13 @@ void unpack_displaylist(Gfx *arg0, u8 *args, UNUSED s8 opcode) {
     uintptr_t temp_t7 = ((args[sPackedSeekPosition++]) << 8 | temp_v0) * 8;
     arg0[sGfxSeekPosition].words.w0 = 0x06000000;
     // Segment seven addr
-    arg0[sGfxSeekPosition].words.w1 = 0x07000000 + temp_t7;
+    arg0[sGfxSeekPosition].words.w1 = segment_offset_to_virtual(0x07, temp_t7); // (0x07000000 + temp_t7); // (gSegmentTable[segment] + ( (offset / 8) * sizeof(Gfx) ) );
     sGfxSeekPosition++;
 }
 
 // end displaylist
 void unpack_end_displaylist(Gfx *arg0, UNUSED u8 *arg1, UNUSED s8 arg2) {
-    arg0[sGfxSeekPosition].words.w0 = G_ENDDL << 24;
+    arg0[sGfxSeekPosition].words.w0 = (uintptr_t)(uint8_t)G_ENDDL << 24;
     arg0[sGfxSeekPosition].words.w1 = 0;
     sGfxSeekPosition++;
 }
@@ -731,7 +764,7 @@ void unpack_tile_sync(Gfx *gfx, u8 *args, s8 opcode) {
     gfx[sGfxSeekPosition].words.w1 = tileSync->words.w1;
     sGfxSeekPosition++;
 
-    lo = (G_SETTILE << 24) | (fmt << 21) | (siz << 19) | (line << 9) | tmem;
+    lo = ((uintptr_t)(uint8_t)G_SETTILE << 24) | (fmt << 21) | (siz << 19) | (line << 9) | tmem;
     hi = ((cmt) << 18) | ((maskt) << 14) | ((cms) << 8) | ((masks) << 4);
 
     gfx[sGfxSeekPosition].words.w0 = lo;
@@ -741,7 +774,7 @@ void unpack_tile_sync(Gfx *gfx, u8 *args, s8 opcode) {
     lrs = (width - 1) << 2;
     lrt = (height - 1) << 2;
 
-    lo = (G_SETTILESIZE << 24);
+    lo = ((uintptr_t)(uint8_t)G_SETTILESIZE << 24);
     hi = (lrs << 12) | lrt;
 
     gfx[sGfxSeekPosition].words.w0 = lo;
@@ -764,6 +797,7 @@ void unpack_tile_load_sync(Gfx *gfx, u8 *args, s8 opcode) {
     uintptr_t siz;
     uintptr_t tmem;
     uintptr_t tile;
+    size_t offset;
 
     switch (opcode) {
         case 32:
@@ -803,7 +837,8 @@ void unpack_tile_load_sync(Gfx *gfx, u8 *args, s8 opcode) {
     // Waa?
     var = args[sPackedSeekPosition];
     // Generates a texture address.
-    addr = SEGMENT_ADDR(0x05, args[sPackedSeekPosition++] << 11);
+    offset = args[sPackedSeekPosition++] << 11;
+    addr = SEGMENT_ADDR(0x05, offset);
     sPackedSeekPosition++;
     arg = args[sPackedSeekPosition++];
     siz = G_IM_SIZ_16b;
@@ -812,16 +847,16 @@ void unpack_tile_load_sync(Gfx *gfx, u8 *args, s8 opcode) {
 
     // Generate gfx
 
-    lo = (G_SETTIMG << 24) | (fmt << 21) | (siz << 19);
+    lo = ((uintptr_t)(uint8_t)G_SETTIMG << 24) | (fmt << 21) | (siz << 19);
     gfx[sGfxSeekPosition].words.w0 = lo;
-    gfx[sGfxSeekPosition].words.w1 = addr;
+    gfx[sGfxSeekPosition].words.w1 = segmented_texture_to_virtual(offset);
     sGfxSeekPosition++;
 
     gfx[sGfxSeekPosition].words.w0 = tileSync->words.w0;
     gfx[sGfxSeekPosition].words.w1 = tileSync->words.w1;
     sGfxSeekPosition++;
 
-    lo = (G_SETTILE << 24) | (fmt << 21) | (siz << 19) | tmem;
+    lo = ((uintptr_t)(uint8_t)G_SETTILE << 24) | (fmt << 21) | (siz << 19) | tmem;
     hi = tile << 24;
 
     gfx[sGfxSeekPosition].words.w0 = lo;
@@ -832,7 +867,7 @@ void unpack_tile_load_sync(Gfx *gfx, u8 *args, s8 opcode) {
     gfx[sGfxSeekPosition].words.w1 = loadSync->words.w1;
     sGfxSeekPosition++;
 
-    lo = G_LOADBLOCK << 24;
+    lo = (uintptr_t)(uint8_t)G_LOADBLOCK << 24;
     hi = (tile << 24) | (MIN((width * height) - 1, 0x7FF) << 12) | CALC_DXT(width, G_IM_SIZ_16b_BYTES);
 
     gfx[sGfxSeekPosition].words.w0 = lo;
@@ -842,6 +877,7 @@ void unpack_tile_load_sync(Gfx *gfx, u8 *args, s8 opcode) {
 
 void unpack_texture_on(Gfx *arg0, UNUSED u8 *args, UNUSED s8 arg2) {
     Gfx macro[] = { gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON) };
+
     arg0[sGfxSeekPosition].words.w0 = macro->words.w0;
     arg0[sGfxSeekPosition].words.w1 = macro->words.w1;
     sGfxSeekPosition++;
@@ -867,8 +903,8 @@ void unpack_vtx1(Gfx *gfx, u8 *args, UNUSED s8 arg2) {
     temp = args[sPackedSeekPosition++];
     temp_t7_2 = temp & 0x3F;
 
-    gfx[sGfxSeekPosition].words.w0 = (G_VTX << 24) | (temp_t7_2 * 2 << 16) | (((temp_t7 << 10) + ((0x10 * temp_t7) - 1)));
+    gfx[sGfxSeekPosition].words.w0 = ((uintptr_t)(uint8_t)G_VTX << 24) | (temp_t7_2 * 2 << 16) | (((temp_t7 << 10) + ((0x10 * temp_t7) - 1)));
-    gfx[sGfxSeekPosition].words.w1 = 0x04000000 + temp2;
+    gfx[sGfxSeekPosition].words.w1 = (uintptr_t) segment_vtx_to_virtual(temp2);
     sGfxSeekPosition++;
 }
 
@@ -882,8 +918,8 @@ void unpack_vtx2(Gfx *gfx, u8 *args, s8 arg2) {
 
     temp_t9 = arg2 - 50;
 
-    gfx[sGfxSeekPosition].words.w0 = (G_VTX << 24) | ((temp_t9 << 10) + (((temp_t9) * 0x10) - 1));
+    gfx[sGfxSeekPosition].words.w0 = ((uintptr_t)(uint8_t)G_VTX << 24) | ((temp_t9 << 10) + (((temp_t9) * 0x10) - 1));
-    gfx[sGfxSeekPosition].words.w1 = 0x4000000 + temp_v2;
+    gfx[sGfxSeekPosition].words.w1 = (uintptr_t) segment_vtx_to_virtual(temp_v2);
     sGfxSeekPosition++;
 }
 
@@ -908,7 +944,7 @@ void unpack_triangle(Gfx *gfx, u8 *args, UNUSED s8 arg2) {
         phi_a2 |= (temp_v0 & 3) * 8;
         phi_a3 = (temp_v0 >> 2) & 0x1F;
     }
-    gfx[sGfxSeekPosition].words.w0 = (G_TRI1 << 24);
+    gfx[sGfxSeekPosition].words.w0 = ((uintptr_t)(uint8_t)G_TRI1 << 24);
     gfx[sGfxSeekPosition].words.w1 = ((phi_a0 * 2) << 16) | ((phi_a2 * 2) << 8) | (phi_a3 * 2);
     sGfxSeekPosition++;
 }
@@ -954,7 +990,7 @@ void unpack_quadrangle(Gfx *gfx, u8 *args, UNUSED s8 arg2) {
         phi_a2 = (temp_v0 >> 2) & 0x1F;
     }
     gfx[sGfxSeekPosition].words.w0 =
-        (G_TRI2 << 24) | ((phi_a0 * 2) << 16) | ((phi_a3 * 2) << 8) | (phi_t0 * 2);
+        ((uintptr_t)(uint8_t)G_TRI2 << 24) | ((phi_a0 * 2) << 16) | ((phi_a3 * 2) << 8) | (phi_t0 * 2);
     gfx[sGfxSeekPosition].words.w1 = ((phi_t2 * 2) << 16) | ((phi_t1 * 2) << 8) | (phi_a2 * 2);
     sGfxSeekPosition++;
 }
@@ -987,7 +1023,7 @@ void unpack_spline_3D(Gfx *gfx, u8 *arg1, UNUSED s8 arg2) {
         temp_v0 = arg1[sPackedSeekPosition++];
         phi_a0 |= (temp_v0 & 0xF) * 2;
     }
-    gfx[sGfxSeekPosition].words.w0 = (G_LINE3D << 24);
+    gfx[sGfxSeekPosition].words.w0 = ((uintptr_t)(uint8_t)G_LINE3D << 24);
     gfx[sGfxSeekPosition].words.w1 =
         ((phi_a0 * 2) << 24) | ((phi_t0 * 2) << 16) | ((phi_a3 * 2) << 8) | (phi_a2 * 2);
     sGfxSeekPosition++;
@@ -1027,6 +1063,7 @@ void displaylist_unpack(Gfx *gfx, u8 *data, uintptr_t arg2) {
 
     while(true) {
 
+
         // Seek to the next byte
         opcode = packed_dl[sPackedSeekPosition++];
 
@@ -1367,6 +1404,14 @@ void *decompress_segments(u8 *start, u8 *end) {
     return (void *)freeSpace;
 }
 
+extern const course_texture mario_raceway_textures[30];
+
+/* To help verify if ptrs are pointing within segments see gfx_pc.cpp gfx_step() */
+uintptr_t vtxSegEnd;
+uintptr_t dlSegEnd;
+uintptr_t texSegEnd; size_t texSegSize;
+Gfx *testaaa;
+
 /**
  * @brief Loads & DMAs course data. Vtx, textures, displaylists, etc.
  * @param courseId
@@ -1374,37 +1419,45 @@ void *decompress_segments(u8 *start, u8 *end) {
 void load_course(s32 courseId) {
     printf("Loading Course Data\n");
 
-    // Extract packed DLs
+    testaaa = (Gfx *) LOAD_ASSET(d_course_mario_raceway_dl_0);
-    u8 *packed = (u8 *) LOAD_ASSET(d_course_mario_raceway_packed_dls);
-    Gfx *gfx = (Gfx *) allocate_memory(sizeof(Gfx) * 3366); // Size of unpacked DLs
-    displaylist_unpack(gfx, packed, 0);
-
-    gSegmentTable[7] = &gfx[0];
 
     // Convert course vtx to vtx
     CourseVtx *cvtx = (CourseVtx *) LOAD_ASSET(d_course_mario_raceway_vertex);
     Vtx *vtx = (Vtx *) allocate_memory(sizeof(Vtx) * 5757);
-    func_802A86A8(cvtx, vtx, 5757);
     gSegmentTable[4] = &vtx[0];
+    func_802A86A8(cvtx, vtx, 5757);
+    vtxSegEnd = &vtx[5757];
 
+    // Load and allocate memory for course textures
+    course_texture *asset = mario_raceway_textures;
+    u8 *freeMemory = NULL;
+    u8 *texture = NULL;
+    size_t size = 0;
+    texSegSize = 0;
+    while (asset->addr) {
+        size = ResourceGetTexSizeByName(asset->addr);
+        freeMemory = (u8 *) allocate_memory(size);
 
+        texture = (u8 *) LOAD_ASSET(asset->addr);
+        if (texture) {
+            if (asset == &mario_raceway_textures[0]) {
+                gSegmentTable[5] = &freeMemory[0];
+            }
+            memcpy(freeMemory, texture, size);
+            texSegSize += size;
+            // printf("Texture Addr: 0x%llX, size 0x%X\n", &freeMemory[0], size);
+        }
+        asset++;
+    }
 
+    texSegEnd = &((u8 *)gSegmentTable[5])[texSegSize];
 
-//    __gSPSegment(gDisplayListHead++, 7, &gfx);
+    // Extract packed DLs
+    u8 *packed = (u8 *) LOAD_ASSET(d_course_mario_raceway_packed_dls);
+    Gfx *gfx = (Gfx *) allocate_memory(sizeof(Gfx) * 3367); // Size of unpacked DLs
+    gSegmentTable[7] = &gfx[0];
+    displaylist_unpack(gfx, packed, 0);
+    dlSegEnd = &gfx[3367];
 
 
-    //printf("Course Data Loaded!\n");
-
-    // Future implementation for Extra mode and course stretching.
-
-    // if (gIsMirrorMode) {
-    //     for (size_t i = 0; i < sizeof(vtx); i++) {
-    //         dest->v.ob[0] = -courseVtx->ob[0];
-    //     }
-    // }
-
-    // if (vtxStretchY != 1.0f) {
-    //     dest->v.ob[1] *= vtxStretchY;
-    // }
-
 }

src/racing/memory.h

@@ -46,11 +46,14 @@ uintptr_t set_segment_base_addr(s32, void*);
 void *get_segment_base_addr(s32);
 void *segmented_to_virtual(const void *);
 void *segment_offset_to_virtual(uint32_t, uint32_t);
+void *segment_vtx_to_virtual(size_t offset);
+void *segmented_texture_to_virtual(size_t offset);
+void *segmented_uintptr_t_to_virtual(uintptr_t);
 void *segmented_gfx_to_virtual(const void *);
 void  move_segment_table_to_dmem(void);
 void  initialize_memory_pool(void);
 void *decompress_segments(u8*, u8*);
-void *allocate_memory(uintptr_t);
+void *allocate_memory(size_t);
 void *load_data(uintptr_t, uintptr_t);
 void  func_802A7D54(s32, s32);
 

src/racing/render_courses.c

@@ -20,6 +20,7 @@
 #include "courses/all_course_packed.h"
 #include "courses/all_course_offsets.h"
 #include <assets/mario_raceway_data.h>
+#include <assets/mario_raceway_displaylists.h>
 
 s16 D_802B87B0 = 995;
 s16 D_802B87B4 = 1000;
@@ -47,12 +48,12 @@ s32 func_80290C20(Camera *camera) {
 }
 
 void parse_course_displaylists(TrackSections *addr) {
-    TrackSections *first = addr;
+    TrackSections *first = &addr[0];
-    TrackSections *section = addr;
+    TrackSections *section = &addr[0];
 
-    while (addr->addr != 0) {
+    while (section->addr != 0) {
-        section->addr = segmented_gfx_to_virtual(addr->addr);
+        printf("SECTION ADDR: 0x%X\n", section->addr);
-        addr++;
+        section->addr = segmented_uintptr_t_to_virtual(section->addr);
         section++;
     }
     section = first;
@@ -83,16 +84,15 @@ void parse_course_displaylists(TrackSections *addr) {
 
 extern u32 isFlycam;
 
-void load_surface_map(Gfx *addr[], struct UnkStruct_800DC5EC *arg1) {
+void load_surface_map(const char* addr[], struct UnkStruct_800DC5EC *arg1) {
     Player *player = arg1->player;
     Camera *camera = arg1->camera;
-    //! @todo Should be Gfx*
-    Gfx **gfx = &addr;
     s16 var_a3;
     s16 temp_v1;
     s16 sp1E;
     s16 temp_v0_3;
     u16 rot;
+    //printf("--------Loading Collision Mesh--------\n");
     if (gIsMirrorMode) {
         rot = (u16) camera->rot[1];
         if (rot < 0x2000) {
@@ -126,6 +126,7 @@ void load_surface_map(Gfx *addr[], struct UnkStruct_800DC5EC *arg1) {
     arg1->playerDirection = var_a3;
 
     if (D_80152300[camera - camera1] == 1) {
+                printf("LOGIC\n");
         sp1E = func_802ABD40(camera->unk_54.unk3A);
         temp_v0_3 = func_802ABD40(player->unk_110.unk3A);
         temp_v1 = sp1E - temp_v0_3;
@@ -180,6 +181,7 @@ void load_surface_map(Gfx *addr[], struct UnkStruct_800DC5EC *arg1) {
             }
         }
     } else {
+                printf("ELSE\n");
         temp_v1 = func_802ABD40(camera->unk_54.unk3A);
         if (camera->unk_54.unk3C[2] > 30.0f) {
             temp_v1 = arg1->pathCounter;
@@ -191,7 +193,11 @@ void load_surface_map(Gfx *addr[], struct UnkStruct_800DC5EC *arg1) {
     arg1->pathCounter = temp_v1;
     temp_v1 = ((temp_v1 - 1) * 4) + var_a3;
 
-    gSPDisplayList(gDisplayListHead++, (Gfx *)&gfx[temp_v1]);
+    printf("----Collision DL Call----\n");
+    //printf("temp_v1: %d\n", temp_v1);
+    //printf("Call: %s\n", addr[temp_v1]);
+    gSPDisplayList(gDisplayListHead++, addr[0]);
+    printf("--------Collision Mesh Loaded--------\n");
 }
 
 void func_80291198(void) {
@@ -618,7 +624,8 @@ void render_mario_raceway(struct UnkStruct_800DC5EC *arg0) {
     // d_course_mario_raceway_packed_dl_14A0
     gSPDisplayList(gDisplayListHead++, ((uintptr_t) segmented_gfx_to_virtual(0x070014A0)));
     printf("LOADING SURFACE MAP\n");
-    load_surface_map(&mario_raceway_dls, arg0);
+    load_surface_map(mario_raceway_dls, arg0);
+    printf("SURFACE MAP LOADED\n");
     gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA);
     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
     gSPClearGeometryMode(gDisplayListHead++, G_CULL_BACK);
@@ -631,7 +638,7 @@ void render_mario_raceway(struct UnkStruct_800DC5EC *arg0) {
     gSPDisplayList(gDisplayListHead++, ((uintptr_t) segmented_gfx_to_virtual(0x070000E0)));
     // d_course_mario_raceway_packed_dl_160
     gSPDisplayList(gDisplayListHead++, ((uintptr_t) segmented_gfx_to_virtual(0x07000160)));
-    printf("SURFACE MAP LOADED\n");
+    printf("RENDERED COURSE\n");
 }
 
 void render_choco_mountain(struct UnkStruct_800DC5EC *arg0) {

src/racing/render_courses.h

@@ -7,7 +7,7 @@
 void func_8029122C(struct UnkStruct_800DC5EC*, s32);
 s32  func_80290C20(Camera*);
 void parse_course_displaylists(uintptr_t);
-void load_surface_map(Gfx*, struct UnkStruct_800DC5EC*);
+void load_surface_map(const char*[], struct UnkStruct_800DC5EC*);
 void func_80291198(void);
 void func_802911C4(void);
 void render_mario_raceway(struct UnkStruct_800DC5EC*);

src/racing/skybox_and_splitscreen.c

@@ -321,7 +321,7 @@ UNUSED Gfx D_802B8A90[] = {
 };
 
 struct Skybox sSkyColors[] = {
-    #include "assets/course_metadata/sSkyColors.inc.c"
+    #include "course_metadata/sSkyColors.inc.c"
 
 };
 
@@ -350,7 +350,7 @@ struct Skybox sSkyColors[] = {
 // };
 
 struct Skybox sSkyColors2[] = {
-    #include "assets/course_metadata/sSkyColors2.inc.c"
+    #include "course_metadata/sSkyColors2.inc.c"
 };
 
 void func_802A450C(Vtx *skybox) {

src/render_objects.c

@@ -46,7 +46,7 @@ void func_800431B0(Vec3f pos, Vec3su orientation, f32 scale, Vtx *vtx) {
 
 void func_80043220(Vec3f pos, Vec3su orientation, f32 scale, Gfx *gfx) {
     rsp_set_matrix_transformation(pos, orientation, scale);
-    gSPDisplayList(gDisplayListHead++, &D_0D0077A0);
+    gSPDisplayList(gDisplayListHead++, D_0D0077A0);
     gSPDisplayList(gDisplayListHead++, gfx);
 }
 
@@ -227,16 +227,16 @@ void load_texture_block_i8_nomirror(u8 *texture, s32 width, s32 height) {
 void func_80044924(u8 *texture, s32 width, s32 height) {
     // This macro ought to be equivalent to the block of macros below but it doesn't match
     // See comment above the `gDPLoadBlock` macro
-    // gDPLoadTextureBlock_4b(gDisplayListHead++, texture, G_IM_FMT_I, width, height, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
+    gDPLoadTextureBlock_4b(gDisplayListHead++, texture, G_IM_FMT_I, width, height, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
 
-    gDPSetTextureImage(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, texture);
+    // gDPSetTextureImage(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, texture);
-    gDPSetTile(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, G_TX_RENDERTILE, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD);
+    // gDPSetTile(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, G_TX_RENDERTILE, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD);
-    gDPLoadSync(gDisplayListHead++);
+    // gDPLoadSync(gDisplayListHead++);
-    // The last argument to this macro really should be `CALC_DXT_4b(width)` but that creates a massive diff
+    // // The last argument to this macro really should be `CALC_DXT_4b(width)` but that creates a massive diff
-    gDPLoadBlock(gDisplayListHead++, G_TX_LOADTILE, 0, 0, (((width * height) + 3) >> 2) - 1, ((width / 16) + 2047) / (width / 16));
+    // gDPLoadBlock(gDisplayListHead++, G_TX_LOADTILE, 0, 0, (((width * height) + 3) >> 2) - 1, ((width / 16) + 2047) / (width / 16));
-    gDPPipeSync(gDisplayListHead++);
+    // gDPPipeSync(gDisplayListHead++);
-    gDPSetTile(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_4b, (((width >> 1) + 7) >> 3), G_TX_RENDERTILE, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD);
+    // gDPSetTile(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_4b, (((width >> 1) + 7) >> 3), G_TX_RENDERTILE, G_TX_RENDERTILE, 0, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOLOD);
-    gDPSetTileSize(gDisplayListHead++, G_TX_RENDERTILE, 0, 0, (width-1) << G_TEXTURE_IMAGE_FRAC, (height-1) << G_TEXTURE_IMAGE_FRAC);
+    // gDPSetTileSize(gDisplayListHead++, G_TX_RENDERTILE, 0, 0, (width-1) << G_TEXTURE_IMAGE_FRAC, (height-1) << G_TEXTURE_IMAGE_FRAC);
 }
 
 UNUSED void func_80044AB8(u8 *texture, s32 width, s32 height) {
@@ -3795,7 +3795,7 @@ void func_80054D00(s32 objectIndex, s32 cameraId) {
             D_80183E80[0] = (s16) gObjectList[objectIndex].orientation[0];
             D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
             D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
-            func_80048130(gObjectList[objectIndex].pos, (u16 *) D_80183E80, gObjectList[objectIndex].sizeScaling, (u8 *) gObjectList[objectIndex].activeTLUT, gObjectList[objectIndex].activeTexture, D_0D0062B0, 0x00000020, 0x00000040, 0x00000020, 0x00000040, 5);
+            func_80048130(gObjectList[objectIndex].pos, (u16 *) D_80183E80, gObjectList[objectIndex].sizeScaling, (u8 *) gObjectList[objectIndex].activeTLUT, gObjectList[objectIndex].activeTexture, LOAD_ASSET(D_0D0062B0), 0x00000020, 0x00000040, 0x00000020, 0x00000040, 5);
         }
     }
 }

src/render_player.c

@@ -57,7 +57,7 @@ u16 gPlayerBlueEffect[8];
 u16 gPlayerCyanEffect[8];
 u16 gPlayerMagentaEffect[8];
 u16 gPlayerYellowEffect[8];
-//if it's also a color effect like before
+// If it's also a colour effect like before
 UNUSED u16 gPlayerWhiteEffect[8];
 s32 D_80164B80[296];
 s16 D_80165020[40];
@@ -81,7 +81,7 @@ void func_8001F980(s32 *arg0, s32 *arg1) {
     *arg1 = 0;
 }
 
-void func_8001F9E4(Player *player, Camera *camera, s8 arg2) {
+void func_8001F9E4(Player *player, Camera *camera, s8 screenId) {
     UNUSED s32 pad;
     s32 sp30;
     s32 sp2C;
@@ -90,14 +90,14 @@ void func_8001F9E4(Player *player, Camera *camera, s8 arg2) {
     get_player_index_for_player(player);
     func_8001F980(&sp30, &sp2C);
 
-    player->unk_002 &= ~(2 << (arg2 * 4));
+    player->unk_002 &= ~(2 << (screenId * 4));
-    player->unk_002 &= ~(8 << (arg2 * 4));
+    player->unk_002 &= ~(8 << (screenId * 4));
 
     if (check_player_camera_collision(player, camera, (f32) (D_80165578 + sp30), (f32) (D_8016557A + sp2C)) == 1) {
-        player->unk_002 |= 2 << (arg2 * 4);
+        player->unk_002 |= 2 << (screenId * 4);
     }
     if (check_player_camera_collision(player, camera, (f32) D_80165580, (f32) D_80165582) == 1) {
-        player->unk_002 |= 8 << (arg2 * 4);
+        player->unk_002 |= 8 << (screenId * 4);
     }
 }
 
@@ -179,7 +179,7 @@ u16 func_8001FD78(Player *player, f32 posX, UNUSED f32 arg2, f32 posZ) {
     return ret;
 }
 
-void init_render_player(Player *player, Camera *camera, s8 playerId, s8 playerRenderId) {
+void init_render_player(Player *player, Camera *camera, s8 playerId, s8 screenId) {
     UNUSED s32 pad[4];
     s32 sp4C;
     s32 sp48;
@@ -188,64 +188,64 @@ void init_render_player(Player *player, Camera *camera, s8 playerId, s8 playerRe
     s32 temp_v0_2;
 
     if ((player->type & PLAYER_EXISTS) == PLAYER_EXISTS) {
-        func_8001F9E4(player, camera, playerRenderId);
+        func_8001F9E4(player, camera, screenId);
-        temp_v0 = 2 << (playerRenderId << 2);
+        temp_v0 = 2 << (screenId << 2);
         if (temp_v0 == (player->unk_002 & temp_v0)) {
             if (!(player->type & PLAYER_START_SEQUENCE)) {
-                func_8002934C(player, camera, playerRenderId, playerId);
+                func_8002934C(player, camera, screenId, playerId);
             } else {
-                func_8002934C(player, camera, playerRenderId, playerId);
+                func_8002934C(player, camera, screenId, playerId);
                 player->slopeAccel = 0;
                 player->unk_206 = 0;
-                player->unk_050[playerRenderId] = 0;
+                player->unk_050[screenId] = 0;
             }
         }
         func_8001F980(&sp4C, &sp48);
-        temp_v0_2 = 1 << (playerRenderId << 2);
+        temp_v0_2 = 1 << (screenId << 2);
         if ((temp_v0 == (player->unk_002 & temp_v0)) && (temp_v0_2 == (player->unk_002 & temp_v0_2))) {
             if ((check_player_camera_collision(player, camera, D_80165570 + sp4C, D_80165572 + sp48) == 1) & 0xFFFF) {
                 D_80164AB0[gPlayersToRenderCount] = (s16) playerId;
-                D_80164AC0[gPlayersToRenderCount] = (s16) playerRenderId;
+                D_80164AC0[gPlayersToRenderCount] = (s16) screenId;
                 D_80164AD0[gPlayersToRenderCount] = player;
                 gPlayersToRenderCount += 1;
-                D_80165190[playerRenderId][playerId] = 0;
+                D_80165190[screenId][playerId] = 0;
-                D_801650D0[playerRenderId][playerId] = player->animFrameSelector[playerRenderId];
+                D_801650D0[screenId][playerId] = player->animFrameSelector[screenId];
-                D_80165110[playerRenderId][playerId] = player->animGroupSelector[playerRenderId];
+                D_80165110[screenId][playerId] = player->animGroupSelector[screenId];
-                D_80165150[playerRenderId][playerId] = player->unk_0A8;
+                D_80165150[screenId][playerId] = player->unk_0A8;
-                D_801651D0[playerRenderId][playerId] += 1;
+                D_801651D0[screenId][playerId] += 1;
-                if (D_801651D0[playerRenderId][playerId] == 2) {
+                if (D_801651D0[screenId][playerId] == 2) {
-                    D_801651D0[playerRenderId][playerId] = 0;
+                    D_801651D0[screenId][playerId] = 0;
                 }
             } else {
                 if ((check_player_camera_collision(player, camera, D_80165574 + sp4C, D_80165576) == 1) & 0xFFFF) {
-                    if ((sRenderingFramebuffer == gRenderingFramebufferByPlayer[playerId]) || ((D_801650D0[playerRenderId][playerId] - player->animFrameSelector[playerRenderId]) > 0x13) || ((D_801650D0[playerRenderId][playerId] - player->animFrameSelector[playerRenderId]) < -0x13) || (D_80165190[playerRenderId][playerId] == (s16) 1U)) {
+                    if ((sRenderingFramebuffer == gRenderingFramebufferByPlayer[playerId]) || ((D_801650D0[screenId][playerId] - player->animFrameSelector[screenId]) > 0x13) || ((D_801650D0[screenId][playerId] - player->animFrameSelector[screenId]) < -0x13) || (D_80165190[screenId][playerId] == (s16) 1U)) {
                         D_80164AB0[gPlayersToRenderCount] = (s16) playerId;
-                        D_80164AC0[gPlayersToRenderCount] = (s16) playerRenderId;
+                        D_80164AC0[gPlayersToRenderCount] = (s16) screenId;
                         D_80164AD0[gPlayersToRenderCount] = player;
                         gPlayersToRenderCount += 1;
-                        D_801650D0[playerRenderId][playerId] = player->animFrameSelector[playerRenderId];
+                        D_801650D0[screenId][playerId] = player->animFrameSelector[screenId];
-                        D_80165110[playerRenderId][playerId] = player->animGroupSelector[playerRenderId];
+                        D_80165110[screenId][playerId] = player->animGroupSelector[screenId];
-                        D_80165150[playerRenderId][playerId] = player->unk_0A8;
+                        D_80165150[screenId][playerId] = player->unk_0A8;
-                        D_80165190[playerRenderId][playerId] = 0;
+                        D_80165190[screenId][playerId] = 0;
-                        D_801651D0[playerRenderId][playerId] += 1;
+                        D_801651D0[screenId][playerId] += 1;
-                        if (D_801651D0[playerRenderId][playerId] == 2) {
+                        if (D_801651D0[screenId][playerId] == 2) {
-                            D_801651D0[playerRenderId][playerId] = 0;
+                            D_801651D0[screenId][playerId] = 0;
                         }
                     }
                 } else {
                     if ((
-                        (D_801650D0[playerRenderId][playerId] - player->animFrameSelector[playerRenderId]) > 0x13) || ((D_801650D0[playerRenderId][playerId] - player->animFrameSelector[playerRenderId]) < -0x13) || (D_80165190[playerRenderId][playerId] == (s16) 1U)) {
+                        (D_801650D0[screenId][playerId] - player->animFrameSelector[screenId]) > 0x13) || ((D_801650D0[screenId][playerId] - player->animFrameSelector[screenId]) < -0x13) || (D_80165190[screenId][playerId] == (s16) 1U)) {
                         D_80164AB0[gPlayersToRenderCount] = (s16) playerId;
-                        D_80164AC0[gPlayersToRenderCount] = (s16) playerRenderId;
+                        D_80164AC0[gPlayersToRenderCount] = (s16) screenId;
                         D_80164AD0[gPlayersToRenderCount] = player;
                         gPlayersToRenderCount += 1;
-                        D_801650D0[playerRenderId][playerId] = (s16) player->animFrameSelector[playerRenderId];
+                        D_801650D0[screenId][playerId] = (s16) player->animFrameSelector[screenId];
-                        D_80165110[playerRenderId][playerId] = player->animGroupSelector[playerRenderId];
+                        D_80165110[screenId][playerId] = player->animGroupSelector[screenId];
-                        D_80165150[playerRenderId][playerId] = player->unk_0A8;
+                        D_80165150[screenId][playerId] = player->unk_0A8;
-                        D_80165190[playerRenderId][playerId] = 0;
+                        D_80165190[screenId][playerId] = 0;
-                        D_801651D0[playerRenderId][playerId] += 1;
+                        D_801651D0[screenId][playerId] += 1;
-                        if (D_801651D0[playerRenderId][playerId] == 2) {
+                        if (D_801651D0[screenId][playerId] == 2) {
-                            D_801651D0[playerRenderId][playerId] = 0;
+                            D_801651D0[screenId][playerId] = 0;
                         }
                     }
                 }
@@ -257,7 +257,7 @@ void init_render_player(Player *player, Camera *camera, s8 playerId, s8 playerRe
 void func_80020524(void) {
     s16 i;
 
-    func_80027560(D_80164AD0[0], D_80164AB0[0], D_80164AC0[0], D_80164AC0[0], D_801651D0[D_80164AC0[0]][D_80164AB0[0]]);
+    func_80027560(D_80164AD0[0], D_80164AB0[0], D_80164AC0[0], D_80164AC0[0], D_801651D0[D_80164AC0[0]][D_80164AB0[0]], 0);
     func_8006E5AC(gPlayerOneCopy, 0, 0);
     func_8006E5AC(gPlayerTwo,     1, 0);
     func_8006E5AC(gPlayerThree,   2, 0);
@@ -272,21 +272,32 @@ void func_80020524(void) {
 
     for (i = 1; i < gPlayersToRenderCount; i++) {
 
-            func_80027560(D_80164AD0[i], D_80164AB0[i], D_80164AC0[i], D_80164AC0[i], D_801651D0[D_80164AC0[i]][D_80164AB0[i]]);
+            func_80027560(D_80164AD0[i], D_80164AB0[i], D_80164AC0[i], D_80164AC0[i], D_801651D0[D_80164AC0[i]][D_80164AB0[i]], i);
 
-            mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].unk_00,
+        //size_t textureSize = ResourceGetSizeByName(texture);
-                       D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array);
+        //printf("test %s\n",texture);
-            osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+       // memcpy(vAddr, texture, textureSize);
+
+            //mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].unk_00,
+//                       D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array);
+
+            // memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].pixel_index_array,
+            //     D_802DFB80[D_801651D0[D_80164AC0[i - 1]][D_80164AB0[i - 1]]][D_80164AC0[i - 1]][D_80164AB0[i - 1]].unk_00, 0x1000);
+
+            //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     }
 
-    mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00,
+    //mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00,
-               D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array);
+    //           D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array);
+
+    // memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array, 
+    //     D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00, 0x1000);
+
 }
 
 void func_8002088C(void) {
     s16 var_s0;
 
-    func_80027560(D_80164AD0[0], D_80164AB0[0], D_80164AC0[0], D_80164AC0[0], D_801651D0[D_80164AC0[0]][D_80164AB0[0]]);
     func_8006E634(gPlayerOneCopy, 0, 1);
     func_8006E634(gPlayerTwo,     1, 1);
     func_8006E634(gPlayerThree,   2, 1);
@@ -299,51 +310,59 @@ void func_8002088C(void) {
     }
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
-        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0], D_80164AC0[var_s0], D_80164AC0[var_s0], D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]]);
+        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0], D_80164AC0[var_s0], D_80164AC0[var_s0], D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]], var_s0);
-        mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].unk_00,
+        //mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].unk_00,
-                   D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].pixel_index_array);
+         //          D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].pixel_index_array);
-        osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+        
+        // memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].pixel_index_array,
+        //     D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]].unk_00, 0x1000);
+        
+        //osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     }
-    mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00,
+    //func_80027560(D_80164AD0[0], D_80164AB0[0], D_80164AC0[0], D_80164AC0[0], D_801651D0[D_80164AC0[0]][D_80164AB0[0]], 0);
-               D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array);
+
+    //mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00,
+    //           D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array);
+    // memcpy(&D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].pixel_index_array,
+    //     D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]].unk_00, 0x1000);
 }
 
 void func_80020BF4(void) {
     s16 var_s0;
 
-    func_80027560(D_80164AD0[0], D_80164AB0[0] + 4, D_80164AC0[0], D_80164AC0[0] - 2, D_801651D0[D_80164AC0[0]][D_80164AB0[0]]);
     func_8006E6BC(gPlayerOneCopy, 0, 2);
     func_8006E6BC(gPlayerTwo,     1, 2);
     func_8006E6BC(gPlayerThree,   2, 2);
     func_8006E6BC(gPlayerFour,    3, 2);
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
-        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0] + 4, D_80164AC0[var_s0], D_80164AC0[var_s0] - 2, D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]]);
+        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0] + 4, D_80164AC0[var_s0], D_80164AC0[var_s0] - 2, D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]], var_s0);
-        mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].unk_00,
+        // mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].unk_00,
-                   D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].pixel_index_array);
+        //            D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].pixel_index_array);
-        osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+        // osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     }
-    mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].unk_00,
+    //func_80027560(D_80164AD0[0], D_80164AB0[0] + 4, D_80164AC0[0], D_80164AC0[0] - 2, D_801651D0[D_80164AC0[0]][D_80164AB0[0]], 0);
-               D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].pixel_index_array);
+    // mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].unk_00,
+    //            D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].pixel_index_array);
 }
 
 void func_80020F1C(void) {
     s16 var_s0;
 
-    func_80027560(D_80164AD0[0], D_80164AB0[0] + 4, D_80164AC0[0], D_80164AC0[0] - 2, D_801651D0[D_80164AC0[0]][D_80164AB0[0]]);
     func_8006E744(gPlayerOneCopy, 0, 3);
     func_8006E744(gPlayerTwo,     1, 3);
     func_8006E744(gPlayerThree,   2, 3);
     func_8006E744(gPlayerFour,    3, 3);
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
-        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0] + 4, D_80164AC0[var_s0], D_80164AC0[var_s0] - 2, D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]]);
+        func_80027560(D_80164AD0[var_s0], D_80164AB0[var_s0] + 4, D_80164AC0[var_s0], D_80164AC0[var_s0] - 2, D_801651D0[D_80164AC0[var_s0]][D_80164AB0[var_s0]], var_s0);
-        mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].unk_00,
+        // mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].unk_00,
-                   D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].pixel_index_array);
+        //            D_802BFB80.arraySize8[D_801651D0[D_80164AC0[var_s0 - 1]][D_80164AB0[var_s0 - 1]]][D_80164AC0[var_s0 - 1] - 2][D_80164AB0[var_s0 - 1] + 4].pixel_index_array);
-        osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+        // osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     }
-    mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].unk_00,
+    //func_80027560(D_80164AD0[0], D_80164AB0[0] + 4, D_80164AC0[0], D_80164AC0[0] - 2, D_801651D0[D_80164AC0[0]][D_80164AB0[0]], 0);
-               D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].pixel_index_array);
+    // mio0decode((u8*) D_802DFB80[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].unk_00,
+    //            D_802BFB80.arraySize8[D_801651D0[D_80164AC0[gPlayersToRenderCount-1]][D_80164AB0[gPlayersToRenderCount-1]]][D_80164AC0[gPlayersToRenderCount-1] - 2][D_80164AB0[gPlayersToRenderCount-1] + 4].pixel_index_array);
 }
 
 void try_render_player(Player *player, s8 playerId, s8 arg2) {
@@ -351,7 +370,7 @@ void try_render_player(Player *player, s8 playerId, s8 arg2) {
     if (((player->type & PLAYER_EXISTS) == PLAYER_EXISTS)
     && ((player->type & PLAYER_UNKNOWN_0x40) == 0)) {
         if ((player->unk_002 & 2 << (arg2 * 4)) == 2 << (arg2 * 4)) {
-            player_render(player, playerId, arg2);
+            render_player(player, playerId, arg2);
         }
     }
 }
@@ -1665,40 +1684,40 @@ void player_ice_reflection_render(Player *player, s8 playerId, s8 arg2, s8 arg3)
     gMatrixEffectCount += 1;
 }
 
-void player_render(Player *player, s8 playerId, s8 arg2) {
+void render_player(Player *player, s8 playerId, s8 screenId) {
     UNUSED s32 pad[2];
     s32 temp_t1;
     s32 var_v1;
     OSMesg *sp34;
 
-    func_80026B4C(player, playerId, arg2, D_801651D0[arg2][playerId]);
+    func_80026B4C(player, playerId, screenId, D_801651D0[screenId][playerId]);
-    if (!(player->unk_002 & (4 << (arg2 * 4)))) {
+    if (!(player->unk_002 & (4 << (screenId * 4)))) {
         var_v1 = 0;
     } else {
         var_v1 = 8;
     }
-    func_80023BF0(player, playerId, arg2, var_v1);
+    func_80023BF0(player, playerId, screenId, var_v1);
-    temp_t1 = 8 << (arg2 * 4);
+    temp_t1 = 8 << (screenId * 4);
     if ((temp_t1 == (player->unk_002 & temp_t1)) && (player->unk_110.unk3C[2] <= 50.0f) && (player->surfaceType != ICE)) {
         if ((player->effects & BOO_EFFECT) == BOO_EFFECT) {
-            if (playerId == arg2) {
+            if (playerId == screenId) {
-                render_player_shadow(player, playerId, arg2);
+                render_player_shadow(player, playerId, screenId);
             }
         } else {
-            render_player_shadow(player, playerId, arg2);
+            render_player_shadow(player, playerId, screenId);
         }
     }
     if ((player->type & PLAYER_INVISIBLE_OR_BOMB) != PLAYER_INVISIBLE_OR_BOMB) {
-        kart_render(player, playerId, arg2, var_v1);
+        kart_render(player, playerId, screenId, var_v1);
     } else {
-        ghost_render(player, playerId, arg2, var_v1);
+        ghost_render(player, playerId, screenId, var_v1);
     }
     osRecvMesg(&gDmaMesgQueue, (OSMesg *) &sp34, OS_MESG_BLOCK);
     if ((temp_t1 == (player->unk_002 & temp_t1)) && (player->surfaceType == ICE) && ((player->unk_0CA & 1) != 1) && (player->unk_110.unk3C[2] <= 30.0f)) {
-        player_ice_reflection_render(player, playerId, arg2, var_v1);
+        player_ice_reflection_render(player, playerId, screenId, var_v1);
     }
     if (player->boostPower >= 2.0f) {
-        func_80025DE8(player, playerId, arg2, var_v1);
+        func_80025DE8(player, playerId, screenId, var_v1);
     }
 }
 
@@ -1731,27 +1750,30 @@ void func_80026A48(Player *player, s8 arg1) {
 #define D_802F1F80_WHEEL(a, b, c) &D_802F1F80[a][b][(c * 0x100) + 0xC0]
 #endif
 
-void func_80026B4C(Player *player, s8 playerId, s8 arg2, s8 arg3) {
+void func_80026B4C(Player *player, s8 playerId, s8 screenId, s8 arg3) {
-    s16 temp_t0 = D_801650D0[arg2][playerId];
+    s16 temp_t0 = D_801650D0[screenId][playerId];
-    s16 temp_t1 = D_80165110[arg2][playerId];
+    s16 temp_t1 = D_80165110[screenId][playerId];
     s16 temp_t2 = player->unk_240;
     s16 temp_num = 0x40; // setting this as a variable gets rid of regalloc
 
+    u8 *wheel0 = LOAD_ASSET(D_800DDE34[player->characterId][temp_t1]);
+    u8 *wheel1 = LOAD_ASSET(D_800DDE54[player->characterId][temp_t1]);
+
     if (((player->effects & 0x4000) == 0x4000) && ((player->type & PLAYER_START_SEQUENCE) == 0)) {
         if (((player->effects & 0x80) != 0x80) && ((player->effects & 0x40) != 0x40)
          && ((player->effects & 0x20000) != 0x20000) && ((player->effects & 0x80000) != 0x80000)
          && ((player->effects & 0x800000) != 0x800000) && ((player->unk_044 & 0x800) == 0)) {
 
             if (temp_t0 <= 20) {
-                func_80027C74(player, (s32) (D_800DDE34[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel0 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             } else {
-                func_80027C74(player, (s32) (D_800DDE54[player->characterId][temp_t1] + (temp_t0 - 21) * (temp_num * 4) + ((temp_t2 >> 8) * 0x40) + 0x600), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel1 + (temp_t0 - 21) * (temp_num * 4) + ((temp_t2 >> 8) * 0x40) + 0x600), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             }
         } else {
             if (temp_t0 == 0) {
-                func_80027C74(player, (s32) (D_800DDE34[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel0 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             } else {
-                func_80027C74(player, (s32) (D_800DDE54[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel1 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             }
         }
     } else {
@@ -1760,15 +1782,15 @@ void func_80026B4C(Player *player, s8 playerId, s8 arg2, s8 arg3) {
          && ((player->effects & 0x20000) != 0x20000) && ((player->unk_044 & 0x800) == 0)) {
 
             if (temp_t0 <= 20) {
-                func_80027C74(player, (s32) (D_800DDE34[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel0 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             } else {
-                func_80027C74(player, (s32) (D_800DDE54[player->characterId][temp_t1] + (temp_t0 - 21) * (temp_num * 4) + ((temp_t2 >> 8) * 0x40) + 0x600), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel1 + (temp_t0 - 21) * (temp_num * 4) + ((temp_t2 >> 8) * 0x40) + 0x600), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             }
         } else {
             if (temp_t0 == 0) {
-                func_80027C74(player, (s32) (D_800DDE34[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel0 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             } else {
-                func_80027C74(player, (s32) (D_800DDE54[player->characterId][temp_t1] + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, arg2, playerId), 0x80);
+                func_80027C74(player, (uintptr_t*) (wheel1 + (temp_t0 * temp_num * 4) + ((temp_t2 >> 8) * 0x40)), D_802F1F80_WHEEL(arg3, screenId, playerId), 0x80);
             }
         }
     }

src/render_player.h

@@ -58,7 +58,7 @@ void kart_render(Player*, s8, s8, s8);
 void ghost_render(Player*, s8, s8, s8);
 void func_80025DE8(Player*, s8, s8, s8);
 void player_ice_reflection_render(Player*, s8, s8, s8);
-void player_render(Player*, s8, s8);
+void render_player(Player*, s8, s8);
 void func_80026A48(Player*, s8);
 void func_80026B4C(Player*, s8, s8, s8);
 void func_80030A34(Player*);

src/spawn_players.c

@@ -1071,29 +1071,31 @@ void func_8003CD78(void) {
     func_8003BE30();
 }
 
-void func_8003CD98(Player *player, Camera *camera, s8 playerId, s8 arg3) {
+void func_8003CD98(Player *player, Camera *camera, s8 playerId, s8 screenId) {
     if (player->type & PLAYER_EXISTS) {
-        if (arg3 == 0) {
+        if (screenId == 0) {
-            func_8002D268(player, camera, arg3, playerId);
+            func_8002D268(player, camera, screenId, playerId);
         }
-        func_8002934C(player, camera, arg3, playerId);
+        func_8002934C(player, camera, screenId, playerId);
-        if ((arg3 == 0) || (arg3 == 1)) {
+        if ((screenId == 0) || (screenId == 1)) {
-            load_kart_palette(player, playerId, arg3, 0);
+            load_kart_palette(player, playerId, screenId, 0);
-            load_kart_palette(player, playerId, arg3, 1);
+            load_kart_palette(player, playerId, screenId, 1);
-            load_kart_texture(player, playerId, arg3, arg3, 0);
+            load_kart_texture(player, playerId, screenId, screenId, 0);
-            mio0decode((u8 *) &D_802DFB80[0][arg3][playerId], (u8 *) &D_802BFB80.arraySize8[0][arg3][playerId]);
+            //mio0decode((u8 *) &D_802DFB80[0][arg3][playerId], (u8 *) &D_802BFB80.arraySize8[0][arg3][playerId]);
+            //memcpy(&D_802BFB80.arraySize8[0][screenId][playerId], &D_802DFB80[0][screenId][playerId], 0x1000);
         } else {
-            load_kart_palette(player, playerId, arg3, 0);
+            load_kart_palette(player, playerId, screenId, 0);
-            load_kart_palette(player, playerId, arg3, 1);
+            load_kart_palette(player, playerId, screenId, 1);
-            load_kart_texture(player, (s8) (playerId + 4), arg3, (s8) (arg3 - 2), 0);
+            load_kart_texture(player, (s8) (playerId + 4), screenId, (s8) (screenId - 2), 0);
-            mio0decode((u8 *) &D_802DFB80[0][arg3 - 2][playerId + 4], (u8 *) &D_802BFB80.arraySize8[0][arg3 - 2][playerId + 4]);
+            //mio0decode((u8 *) &D_802DFB80[0][arg3 - 2][playerId + 4], (u8 *) &D_802BFB80.arraySize8[0][arg3 - 2][playerId + 4]);
+            //memcpy(&D_802BFB80.arraySize8[0][screenId - 2][playerId + 4], &D_802DFB80[0][screenId - 2][playerId + 4], 0x1000);
         }
 
-        D_801650D0[arg3][playerId] = player->animFrameSelector[arg3];
+        D_801650D0[screenId][playerId] = player->animFrameSelector[screenId];
-        D_80165110[arg3][playerId] = player->animGroupSelector[arg3];
+        D_80165110[screenId][playerId] = player->animGroupSelector[screenId];
-        D_80165150[arg3][playerId] = player->unk_0A8;
+        D_80165150[screenId][playerId] = player->unk_0A8;
-        D_801651D0[arg3][playerId] = 0;
+        D_801651D0[screenId][playerId] = 0;
-        player_render(player, playerId, arg3);
+        render_player(player, playerId, screenId);
     }
 }
 

tools/torch

@@ -1 +1 @@
-Subproject commit 45e6853e315933d57a0e7213a2d5590fb74f628a
+Subproject commit 76e90b4ddc9c215132c39ebf8433d5f88813b368

torch

@@ -0,0 +1 @@
+Subproject commit 6b1f46c81d0cff15f141820fa351d1874cca9f05

yamls/us/common_data.yml

@@ -47,7 +47,6 @@ common_tlut_finish_line_banner:
   type: texture
   ctype: u16
   offset: 0x0
-  size: 0x200
   width: 16
   height: 16
   format: RGBA16

yamls/us/data_segment2.yml

@@ -1,4 +1,7 @@
 :config:
+  external_files:
+    - "yamls/us\\startup_logo.yml"
+    - "yamls/us\\common_data.yml"
   segments:
     - [0x02, 0x12AAE0]
     - [0x0D, 0x132B50]

yamls/us/mario_raceway_data.yml

@@ -1,6 +1,7 @@
 :config:
   segments:
     - [0x06, 0x8284D0]
+    - [0x07, 0x800000]
   header:
     code:
       - '#include <libultraship.h>'
@@ -8,287 +9,352 @@
       - '#include <libultraship.h>'
       - '#include <libultra/gbi.h>'
       - '#include <align_asset_macro.h>'
-d_course_mario_raceway_vertex:
+    references_packed_displaylists: true
-  symbol: d_course_mario_raceway_data
-  type: blob
-  size: 0x13AD6
-  offset: 0x0
 d_course_mario_raceway_dl_0:
   symbol: d_course_mario_raceway_dl_0
   type: gfx
   offset: 0x0
+  otr_mode: index
 d_course_mario_raceway_dl_E8:
   symbol: d_course_mario_raceway_dl_E8
   type: gfx
   offset: 0xE8
+  otr_mode: index
 d_course_mario_raceway_dl_1D0:
   symbol: d_course_mario_raceway_dl_1D0
   type: gfx
   offset: 0x1D0
+  otr_mode: index
 d_course_mario_raceway_dl_2C8:
   symbol: d_course_mario_raceway_dl_2C8
   type: gfx
   offset: 0x2C8
+  otr_mode: index
 d_course_mario_raceway_dl_3A8:
   symbol: d_course_mario_raceway_dl_3A8
   type: gfx
   offset: 0x3A8
+  otr_mode: index
 d_course_mario_raceway_dl_478:
   symbol: d_course_mario_raceway_dl_478
   type: gfx
   offset: 0x478
+  otr_mode: index
 d_course_mario_raceway_dl_568:
   symbol: d_course_mario_raceway_dl_568
   type: gfx
   offset: 0x568
+  otr_mode: index
 d_course_mario_raceway_dl_668:
   symbol: d_course_mario_raceway_dl_668
   type: gfx
   offset: 0x668
+  otr_mode: index
 d_course_mario_raceway_dl_750:
   symbol: d_course_mario_raceway_dl_750
   type: gfx
   offset: 0x750
+  otr_mode: index
 d_course_mario_raceway_dl_828:
   symbol: d_course_mario_raceway_dl_828
   type: gfx
   offset: 0x828
+  otr_mode: index
 d_course_mario_raceway_dl_928:
   symbol: d_course_mario_raceway_dl_928
   type: gfx
   offset: 0x928
+  otr_mode: index
 d_course_mario_raceway_dl_A00:
   symbol: d_course_mario_raceway_dl_A00
   type: gfx
   offset: 0xA00
+  otr_mode: index
 d_course_mario_raceway_dl_B08:
   symbol: d_course_mario_raceway_dl_B08
   type: gfx
   offset: 0xB08
+  otr_mode: index
 d_course_mario_raceway_dl_C20:
   symbol: d_course_mario_raceway_dl_C20
   type: gfx
   offset: 0xC20
+  otr_mode: index
 d_course_mario_raceway_dl_DC8:
   symbol: d_course_mario_raceway_dl_DC8
   type: gfx
   offset: 0xDC8
+  otr_mode: index
 d_course_mario_raceway_dl_F60:
   symbol: d_course_mario_raceway_dl_F60
   type: gfx
   offset: 0xF60
+  otr_mode: index
 d_course_mario_raceway_dl_10A8:
   symbol: d_course_mario_raceway_dl_10A8
   type: gfx
   offset: 0x10A8
+  otr_mode: index
 d_course_mario_raceway_dl_1210:
   symbol: d_course_mario_raceway_dl_1210
   type: gfx
   offset: 0x1210
+  otr_mode: index
 d_course_mario_raceway_dl_1408:
   symbol: d_course_mario_raceway_dl_1408
   type: gfx
   offset: 0x1408
+  otr_mode: index
 d_course_mario_raceway_dl_15C8:
   symbol: d_course_mario_raceway_dl_15C8
   type: gfx
   offset: 0x15C8
+  otr_mode: index
 d_course_mario_raceway_dl_1740:
   symbol: d_course_mario_raceway_dl_1740
   type: gfx
   offset: 0x1740
+  otr_mode: index
 d_course_mario_raceway_dl_1850:
   symbol: d_course_mario_raceway_dl_1850
   type: gfx
   offset: 0x1850
+  otr_mode: index
 d_course_mario_raceway_dl_1A30:
   symbol: d_course_mario_raceway_dl_1A30
   type: gfx
   offset: 0x1A30
+  otr_mode: index
 d_course_mario_raceway_dl_1B70:
   symbol: d_course_mario_raceway_dl_1B70
   type: gfx
   offset: 0x1B70
+  otr_mode: index
 d_course_mario_raceway_dl_1CF8:
   symbol: d_course_mario_raceway_dl_1CF8
   type: gfx
   offset: 0x1CF8
+  otr_mode: index
 d_course_mario_raceway_dl_1DE0:
   symbol: d_course_mario_raceway_dl_1DE0
   type: gfx
   offset: 0x1DE0
+  otr_mode: index
 d_course_mario_raceway_dl_1F68:
   symbol: d_course_mario_raceway_dl_1F68
   type: gfx
   offset: 0x1F68
+  otr_mode: index
 d_course_mario_raceway_dl_20A0:
   symbol: d_course_mario_raceway_dl_20A0
   type: gfx
   offset: 0x20A0
+  otr_mode: index
 d_course_mario_raceway_dl_21E8:
   symbol: d_course_mario_raceway_dl_21E8
   type: gfx
   offset: 0x21E8
+  otr_mode: index
 d_course_mario_raceway_dl_22E0:
   symbol: d_course_mario_raceway_dl_22E0
   type: gfx
   offset: 0x22E0
+  otr_mode: index
 d_course_mario_raceway_dl_2418:
   symbol: d_course_mario_raceway_dl_2418
   type: gfx
   offset: 0x2418
+  otr_mode: index
 d_course_mario_raceway_dl_2558:
   symbol: d_course_mario_raceway_dl_2558
   type: gfx
   offset: 0x2558
+  otr_mode: index
 d_course_mario_raceway_dl_2680:
   symbol: d_course_mario_raceway_dl_2680
   type: gfx
   offset: 0x2680
+  otr_mode: index
 d_course_mario_raceway_dl_2790:
   symbol: d_course_mario_raceway_dl_2790
   type: gfx
   offset: 0x2790
+  otr_mode: index
 d_course_mario_raceway_dl_28B0:
   symbol: d_course_mario_raceway_dl_28B0
   type: gfx
   offset: 0x28B0
+  otr_mode: index
 d_course_mario_raceway_dl_2A10:
   symbol: d_course_mario_raceway_dl_2A10
   type: gfx
   offset: 0x2A10
+  otr_mode: index
 d_course_mario_raceway_dl_2B40:
   symbol: d_course_mario_raceway_dl_2B40
   type: gfx
   offset: 0x2B40
+  otr_mode: index
 d_course_mario_raceway_dl_2C98:
   symbol: d_course_mario_raceway_dl_2C98
   type: gfx
   offset: 0x2C98
+  otr_mode: index
 d_course_mario_raceway_dl_2DC0:
   symbol: d_course_mario_raceway_dl_2DC0
   type: gfx
   offset: 0x2DC0
+  otr_mode: index
 d_course_mario_raceway_dl_2EF8:
   symbol: d_course_mario_raceway_dl_2EF8
   type: gfx
   offset: 0x2EF8
+  otr_mode: index
 d_course_mario_raceway_dl_3038:
   symbol: d_course_mario_raceway_dl_3038
   type: gfx
   offset: 0x3038
+  otr_mode: index
 d_course_mario_raceway_dl_31F0:
   symbol: d_course_mario_raceway_dl_31F0
   type: gfx
   offset: 0x31F0
+  otr_mode: index
 d_course_mario_raceway_dl_32D8:
   symbol: d_course_mario_raceway_dl_32D8
   type: gfx
   offset: 0x32D8
+  otr_mode: index
 d_course_mario_raceway_dl_3458:
   symbol: d_course_mario_raceway_dl_3458
   type: gfx
   offset: 0x3458
+  otr_mode: index
 d_course_mario_raceway_dl_35D0:
   symbol: d_course_mario_raceway_dl_35D0
   type: gfx
   offset: 0x35D0
+  otr_mode: index
 d_course_mario_raceway_dl_3748:
   symbol: d_course_mario_raceway_dl_3748
   type: gfx
   offset: 0x3748
+  otr_mode: index
 d_course_mario_raceway_dl_3830:
   symbol: d_course_mario_raceway_dl_3830
   type: gfx
   offset: 0x3830
+  otr_mode: index
 d_course_mario_raceway_dl_3960:
   symbol: d_course_mario_raceway_dl_3960
   type: gfx
   offset: 0x3960
+  otr_mode: index
 d_course_mario_raceway_dl_3AA0:
   symbol: d_course_mario_raceway_dl_3AA0
   type: gfx
   offset: 0x3AA0
+  otr_mode: index
 d_course_mario_raceway_dl_3C08:
   symbol: d_course_mario_raceway_dl_3C08
   type: gfx
   offset: 0x3C08
+  otr_mode: index
 d_course_mario_raceway_dl_3D68:
   symbol: d_course_mario_raceway_dl_3D68
   type: gfx
   offset: 0x3D68
+  otr_mode: index
 d_course_mario_raceway_dl_3EB8:
   symbol: d_course_mario_raceway_dl_3EB8
   type: gfx
   offset: 0x3EB8
+  otr_mode: index
 d_course_mario_raceway_dl_4038:
   symbol: d_course_mario_raceway_dl_4038
   type: gfx
   offset: 0x4038
+  otr_mode: index
 d_course_mario_raceway_dl_4150:
   symbol: d_course_mario_raceway_dl_4150
   type: gfx
   offset: 0x4150
+  otr_mode: index
 d_course_mario_raceway_dl_42A0:
   symbol: d_course_mario_raceway_dl_42A0
   type: gfx
   offset: 0x42A0
+  otr_mode: index
 d_course_mario_raceway_dl_43D8:
   symbol: d_course_mario_raceway_dl_43D8
   type: gfx
   offset: 0x43D8
+  otr_mode: index
 d_course_mario_raceway_dl_44F8:
   symbol: d_course_mario_raceway_dl_44F8
   type: gfx
   offset: 0x44F8
+  otr_mode: index
 d_course_mario_raceway_dl_4610:
   symbol: d_course_mario_raceway_dl_4610
   type: gfx
   offset: 0x4610
+  otr_mode: index
 d_course_mario_raceway_dl_4738:
   symbol: d_course_mario_raceway_dl_4738
   type: gfx
   offset: 0x4738
+  otr_mode: index
 d_course_mario_raceway_dl_4840:
   symbol: d_course_mario_raceway_dl_4840
   type: gfx
   offset: 0x4840
+  otr_mode: index
 d_course_mario_raceway_dl_4910:
   symbol: d_course_mario_raceway_dl_4910
   type: gfx
   offset: 0x4910
+  otr_mode: index
 d_course_mario_raceway_dl_4A60:
   symbol: d_course_mario_raceway_dl_4A60
   type: gfx
   offset: 0x4A60
+  otr_mode: index
 d_course_mario_raceway_dl_4B78:
   symbol: d_course_mario_raceway_dl_4B78
   type: gfx
   offset: 0x4B78
+  otr_mode: index
 d_course_mario_raceway_dl_4CD8:
   symbol: d_course_mario_raceway_dl_4CD8
   type: gfx
   offset: 0x4CD8
+  otr_mode: index
 d_course_mario_raceway_dl_4DC8:
   symbol: d_course_mario_raceway_dl_4DC8
   type: gfx
   offset: 0x4DC8
+  otr_mode: index
 d_course_mario_raceway_dl_4ED0:
   symbol: d_course_mario_raceway_dl_4ED0
   type: gfx
   offset: 0x4ED0
+  otr_mode: index
 d_course_mario_raceway_dl_4FF0:
   symbol: d_course_mario_raceway_dl_4FF0
   type: gfx
   offset: 0x4FF0
+  otr_mode: index
 d_course_mario_raceway_dl_5150:
   symbol: d_course_mario_raceway_dl_5150
   type: gfx
   offset: 0x5150
+  otr_mode: index
 d_course_mario_raceway_dl_5228:
   symbol: d_course_mario_raceway_dl_5228
   type: gfx
   offset: 0x5228
+  otr_mode: index
 d_course_mario_raceway_unknown_waypoints:
   symbol: d_course_mario_raceway_unknown_waypoints
   offset: 0x5568
@@ -316,6 +382,7 @@ d_course_mario_raceway_dl_piranha_plant:
   symbol: d_course_mario_raceway_dl_piranha_plant
   type: gfx
   offset: 0x6990
+  otr_mode: index
 d_course_mario_raceway_tree_model:
   symbol: d_course_mario_raceway_tree_model
   type: vtx
@@ -325,6 +392,7 @@ d_course_mario_raceway_dl_tree:
   symbol: d_course_mario_raceway_dl_tree
   type: gfx
   offset: 0x6A68
+  otr_mode: index
 d_course_mario_sign_model:
   symbol: d_course_mario_sign_model
   type: vtx
@@ -380,34 +448,42 @@ d_course_mario_raceway_dl_9068:
   symbol: d_course_mario_raceway_dl_9068
   type: gfx
   offset: 0x9068
+  otr_mode: index
 d_course_mario_raceway_dl_90B0:
   symbol: d_course_mario_raceway_dl_90B0
   type: gfx
   offset: 0x90B0
+  otr_mode: index
 d_course_mario_raceway_dl_90C0:
   symbol: d_course_mario_raceway_dl_90C0
   type: gfx
   offset: 0x90C0
+  otr_mode: index
 d_course_mario_raceway_dl_9190:
   symbol: d_course_mario_raceway_dl_9190
   type: gfx
   offset: 0x9190
+  otr_mode: index
 d_course_mario_raceway_dl_9250:
   symbol: d_course_mario_raceway_dl_9250
   type: gfx
   offset: 0x9250
+  otr_mode: index
 d_course_mario_raceway_dl_9310:
   symbol: d_course_mario_raceway_dl_9310
   type: gfx
   offset: 0x9310
+  otr_mode: index
 d_course_mario_raceway_dl_sign:
   symbol: d_course_mario_raceway_dl_sign
   type: gfx
   offset: 0x9330
+  otr_mode: index
 d_course_mario_raceway_dl_9348:
   symbol: d_course_mario_raceway_dl_9348
   type: gfx
   offset: 0x9348
+  otr_mode: index
 d_course_mario_raceway_item_box_spawns:
   symbol: d_course_mario_raceway_item_box_spawns
   type: mk64:spawn_data

yamls/us/mario_raceway_vertices.yml

@@ -1,7 +1,6 @@
 :config:
   segments:
     - [0x0F, 0x88FA10]
-  no_compression: true
   header:
     code:
       - '#include <libultraship.h>'
@@ -11,6 +10,6 @@
       - '#include <align_asset_macro.h>'
 d_course_mario_raceway_vertex:
   symbol: d_course_mario_raceway_vertex
-  type: blob
+  type: mk64:course_vtx
-  size: 0x13AD6
+  count: 5757
   offset: 0x0