diff --git a/CMakeLists.txt b/CMakeLists.txt
index e0b689413..6a3844f17 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,8 +18,8 @@ include(cmake/Utils.cmake)
 if (CMAKE_SYSTEM_NAME STREQUAL "Windows" AND USE_AUTO_VCPKG)
     include(cmake/automate-vcpkg.cmake)
 
-    set(VCPKG_TRIPLET x64-windows-static)
-    set(VCPKG_TARGET_TRIPLET x64-windows-static)
+    set(VCPKG_TRIPLET x86-windows-static)
+    set(VCPKG_TARGET_TRIPLET x86-windows-static)
 
     vcpkg_bootstrap()
     vcpkg_install_packages(zlib bzip2 sdl2 glew)
diff --git a/extern/ZAPDUtils/Utils/BitConverter.h b/extern/ZAPDUtils/Utils/BitConverter.h
index 46845fe36..c90b3dfbd 100644
--- a/extern/ZAPDUtils/Utils/BitConverter.h
+++ b/extern/ZAPDUtils/Utils/BitConverter.h
@@ -193,12 +193,12 @@ class BitConverter
 
 		switch (firstByte) {
 			case 0x37: // v64
-				for (int32_t pos = 0; pos < (romSize / 2); pos++) {
+				for (size_t pos = 0; pos < (romSize / 2); pos++) {
 					((uint16_t*)rom)[pos] = ToUInt16BE(rom, pos * 2);
 				}
 				break;
 			case 0x40: // n64
-				for (int32_t pos = 0; pos < (romSize / 4); pos++) {
+				for (size_t pos = 0; pos < (romSize / 4); pos++) {
 					((uint32_t*)rom)[pos] = ToUInt32BE(rom, pos * 4);
 				}
 				break;
diff --git a/extern/ZAPDUtils/Utils/DiskFile.h b/extern/ZAPDUtils/Utils/DiskFile.h
index 74962a02a..51aefb44a 100644
--- a/extern/ZAPDUtils/Utils/DiskFile.h
+++ b/extern/ZAPDUtils/Utils/DiskFile.h
@@ -81,7 +81,19 @@ class DiskFile
 
 	static void WriteAllText(const fs::path& filePath, const std::string& text)
 	{
+            try {
+                std::filesystem::create_directories(filePath.parent_path().string());
+			} catch (std::filesystem::filesystem_error const& ex) {
+                std::cout << "what():  " << ex.what() << '\n'
+                          << "path1(): " << ex.path1() << '\n'
+                          << "path2(): " << ex.path2() << '\n'
+                          << "code().value():    " << ex.code().value() << '\n'
+                          << "code().message():  " << ex.code().message() << '\n'
+                          << "code().category(): " << ex.code().category().name() << '\n';
+            }
 		std::ofstream file(filePath, std::ios::out);
+		
+            
 		file.write(text.c_str(), text.size());
 	}
 };
diff --git a/include/libultraship/bridge.h b/include/libultraship/bridge.h
index 9d4f6dca7..668e6b63e 100644
--- a/include/libultraship/bridge.h
+++ b/include/libultraship/bridge.h
@@ -7,5 +7,6 @@
 #include "public/bridge/windowbridge.h"
 #include "public/bridge/consolevariablebridge.h"
 #include "public/bridge/crashhandlerbridge.h"
+#include "public/bridge/gfxdebuggerbridge.h"
 
 #endif
diff --git a/include/libultraship/libultra/abi.h b/include/libultraship/libultra/abi.h
index 99d8ddf35..3b0912f72 100644
--- a/include/libultraship/libultra/abi.h
+++ b/include/libultraship/libultra/abi.h
@@ -37,6 +37,7 @@ typedef unsigned int u32;
 #define A_INIT 0x01
 #define A_CONTINUE 0x00
 #define A_LOOP 0x02
+#define A_ADPCM_SHORT 0x04
 #define A_OUT 0x02
 #define A_LEFT 0x02
 #define A_RIGHT 0x00
@@ -446,13 +447,20 @@ typedef short ENVMIX_STATE[40];
         _a->words.w1 = (u32)(addr);                                                                 \
     }
 
-#define aDuplicate(pkt, count, dmemi, dmemo, a4)                                                      \
-    {                                                                                                 \
-        Acmd* _a = (Acmd*)pkt;                                                                        \
-                                                                                                      \
-        _a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | _SHIFTL(count, 16, 8) | _SHIFTL(dmemi, 0, 16)); \
-        _a->words.w1 = _SHIFTL(dmemo, 16, 16) | _SHIFTL(a4, 0, 16);                                   \
+#define aDuplicate(pkt, numCopies, dmemSrc, dmemDest)                                                       \
+    {                                                                                                       \
+        Acmd* _a = (Acmd*)pkt;                                                                              \
+                                                                                                            \
+        _a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | _SHIFTL(numCopies, 16, 8) | _SHIFTL(dmemSrc, 0, 16)); \
+        _a->words.w1 = _SHIFTL(dmemDest, 16, 16) | _SHIFTL(0x80, 0, 16);                                    \
     }
+//#define aDuplicate(pkt, count, dmemi, dmemo, a4)                                                      \
+//    {                                                                                                 \
+//        Acmd* _a = (Acmd*)pkt;                                                                        \
+//                                                                                                      \
+//        _a->words.w0 = (_SHIFTL(A_DUPLICATE, 24, 8) | _SHIFTL(count, 16, 8) | _SHIFTL(dmemi, 0, 16)); \
+//        _a->words.w1 = _SHIFTL(dmemo, 16, 16) | _SHIFTL(a4, 0, 16);                                   \
+//    }
 
 #define aAddMixer(pkt, count, dmemi, dmemo, a4)                                                        \
     {                                                                                                  \
diff --git a/include/libultraship/libultra/gbi.h b/include/libultraship/libultra/gbi.h
index f72898d72..45e124b8b 100644
--- a/include/libultraship/libultra/gbi.h
+++ b/include/libultraship/libultra/gbi.h
@@ -343,6 +343,7 @@
 #define G_TEXTURE_GEN 0x00040000
 #define G_TEXTURE_GEN_LINEAR 0x00080000
 #define G_LOD 0x00100000 /* NOT IMPLEMENTED */
+#define G_LIGHTING_POSITIONAL 0x00400000
 #if (defined(F3DEX_GBI) || defined(F3DLP_GBI))
 #define G_CLIPPING 0x00800000
 #else
@@ -1270,6 +1271,15 @@ typedef struct {
     char pad3;
 } Light_t;
 
+typedef struct {
+    unsigned char col[3];
+    unsigned char unk3;
+    unsigned char colc[3];
+    unsigned char unk7;
+    short pos[3];
+    unsigned char unkE;
+} PointLight_t;
+
 typedef struct {
     unsigned char col[3]; /* ambient light value (rgba) */
     char pad1;
@@ -1283,6 +1293,7 @@ typedef struct {
 
 typedef union {
     Light_t l;
+    PointLight_t p;
     long long int force_structure_alignment[2];
 } Light;
 
@@ -2271,9 +2282,9 @@ typedef union {
 #define gsSPLoadUcode(uc_start, uc_dstart) gsSPLoadUcodeEx((uc_start), (uc_dstart), SP_UCODE_DATA_SIZE)
 
 #define gSPLoadUcodeL(pkt, ucode) \
-    gSPLoadUcode((pkt), OS_K0_TO_PHYSICAL(&##ucode##TextStart), OS_K0_TO_PHYSICAL(&##ucode##DataStart))
+//    gSPLoadUcode((pkt), OS_K0_TO_PHYSICAL(&##ucode##TextStart), OS_K0_TO_PHYSICAL(&##ucode##DataStart))
 #define gsSPLoadUcodeL(ucode) \
-    gsSPLoadUcode(OS_K0_TO_PHYSICAL(&##ucode##TextStart), OS_K0_TO_PHYSICAL(&##ucode##DataStart))
+//    gsSPLoadUcode(OS_K0_TO_PHYSICAL(&##ucode##TextStart), OS_K0_TO_PHYSICAL(&##ucode##DataStart))
 #endif
 
 #ifdef F3DEX_GBI_2
@@ -2785,6 +2796,9 @@ typedef union {
 #define gsDPSetAlphaDither(mode) gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 2, mode)
 #endif
 
+#define gDPSetDither(pkt, mode) gSPSetOtherMode(pkt, G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 4, mode)
+
+
 /* 'blendmask' is not supported anymore.
  * The bits are reserved for future use.
  * Fri May 26 13:45:55 PDT 1995
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index de362932b..9044ed8e0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,6 +1,9 @@
 add_library(libultraship STATIC)
 set_target_properties(libultraship PROPERTIES PREFIX "")
 set_property(TARGET libultraship PROPERTY CXX_STANDARD 20)
+# Need to set C11 for libgfxd (_Alignas)
+set_property(TARGET libultraship PROPERTY C_STANDARD 11)
+
 set(INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../include)
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
@@ -87,7 +90,7 @@ set(Source_Files__Public__Libultra
     ${CMAKE_CURRENT_SOURCE_DIR}/public/libultra/os.h
     ${CMAKE_CURRENT_SOURCE_DIR}/public/libultra/os.cpp
 )
- 
+
 source_group("public/libultra" FILES ${Source_Files__Public__Libultra})
 
 set(Source_Files__Public__Bridge
@@ -97,6 +100,8 @@ set(Source_Files__Public__Bridge
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/windowbridge.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/audiobridge.h
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/audiobridge.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/gfxdebuggerbridge.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/gfxdebuggerbridge.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/controllerbridge.h
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/controllerbridge.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/consolevariablebridge.h
@@ -104,7 +109,7 @@ set(Source_Files__Public__Bridge
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/crashhandlerbridge.h
     ${CMAKE_CURRENT_SOURCE_DIR}/public/bridge/crashhandlerbridge.cpp
 )
- 
+
 source_group("public/bridge" FILES ${Source_Files__Public__Bridge})
 target_sources(libultraship PRIVATE ${Source_Files__Public__Libultra} ${Source_Files__Public__Bridge})
 
@@ -115,6 +120,8 @@ set(Source_Files__Debug
     ${CMAKE_CURRENT_SOURCE_DIR}/debug/CrashHandler.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/debug/Console.h
     ${CMAKE_CURRENT_SOURCE_DIR}/debug/Console.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/debug/GfxDebugger.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/debug/GfxDebugger.h
 )
 
 source_group("debug" FILES ${Source_Files__Debug})
@@ -163,11 +170,35 @@ set(Source_Files__Window__Gui
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/GuiElement.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/GuiMenuBar.h
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/GuiMenuBar.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/GfxDebuggerWindow.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/GfxDebuggerWindow.h
 )
 
 source_group("window/gui" FILES ${Source_Files__Window__Gui})
 target_sources(libultraship PRIVATE ${Source_Files__Window__Gui})
 
+
+set(Header_Files__Libraries__libgfxd
+    "../../ZAPDTR/lib/libgfxd/gbi.h"
+    "../../ZAPDTR/lib/libgfxd/gfxd.h"
+    "../../ZAPDTR/lib/libgfxd/priv.h"
+)
+source_group("Header Files\\Libraries\\libgfxd" FILES ${Header_Files__Libraries__libgfxd})
+
+set(Source_Files__Libraries__libgfxd
+    "../../ZAPDTR/lib/libgfxd/gfxd.c"
+    "../../ZAPDTR/lib/libgfxd/uc.c"
+    "../../ZAPDTR/lib/libgfxd/uc_f3d.c"
+    "../../ZAPDTR/lib/libgfxd/uc_f3db.c"
+    "../../ZAPDTR/lib/libgfxd/uc_f3dex.c"
+    "../../ZAPDTR/lib/libgfxd/uc_f3dex2.c"
+    "../../ZAPDTR/lib/libgfxd/uc_f3dexb.c"
+)
+source_group("Source Files\\Libraries\\libgfxd" FILES ${Source_Files__Libraries__libgfxd})
+
+
+target_sources(libultraship PRIVATE ${Header_Files__Libraries__libgfxd} ${Source_Files__Libraries__libgfxd})
+
 #=================== Utils ===================
 
 set(Source_Files__Utils
@@ -349,7 +380,7 @@ endif()
 #=================== Packages & Includes ===================
 
 target_include_directories(libultraship
-    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../extern ${CMAKE_CURRENT_BINARY_DIR}
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../extern ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/lib/libgfxd
     PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../extern/spdlog/include ${CMAKE_CURRENT_SOURCE_DIR}/../extern/stb
 )
 
@@ -398,7 +429,7 @@ endif()
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     set_target_properties(${PROJECT_NAME} PROPERTIES
-        XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES 
+        XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES
     )
 endif()
 
diff --git a/src/Context.cpp b/src/Context.cpp
index 6140e0458..cb08eb027 100644
--- a/src/Context.cpp
+++ b/src/Context.cpp
@@ -5,6 +5,7 @@
 #include <spdlog/sinks/rotating_file_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include "install_config.h"
+#include "debug/GfxDebugger.h"
 
 #ifdef __APPLE__
 #include "utils/OSXFolderManager.h"
@@ -82,6 +83,7 @@ void Context::Init(const std::vector<std::string>& otrFiles, const std::unordere
     InitConsole();
     InitWindow();
     InitAudio();
+    InitGfxDebugger();
 }
 
 void Context::InitLogging() {
@@ -237,6 +239,14 @@ void Context::InitAudio() {
     GetAudio()->Init();
 }
 
+void Context::InitGfxDebugger() {
+    if (GetGfxDebugger() != nullptr) {
+        return;
+    }
+
+    mGfxDebugger = std::make_shared<GfxDebugger>();
+}
+
 void Context::InitConsole() {
     if (GetConsole() != nullptr) {
         return;
@@ -291,6 +301,10 @@ std::shared_ptr<Audio> Context::GetAudio() {
     return mAudio;
 }
 
+std::shared_ptr<GfxDebugger> Context::GetGfxDebugger() {
+    return mGfxDebugger;
+}
+
 std::string Context::GetConfigFilePath() {
     return mConfigFilePath;
 }
diff --git a/src/Context.h b/src/Context.h
index a7b2d57b8..f1179597e 100644
--- a/src/Context.h
+++ b/src/Context.h
@@ -15,6 +15,7 @@
 #include "debug/Console.h"
 
 namespace LUS {
+class GfxDebugger;
 
 class Context {
   public:
@@ -47,6 +48,7 @@ class Context {
     std::shared_ptr<Window> GetWindow();
     std::shared_ptr<Console> GetConsole();
     std::shared_ptr<Audio> GetAudio();
+    std::shared_ptr<GfxDebugger> GetGfxDebugger();
 
     std::string GetConfigFilePath();
     std::string GetName();
@@ -60,6 +62,7 @@ class Context {
     void InitControlDeck();
     void InitCrashHandler();
     void InitAudio();
+    void InitGfxDebugger();
     void InitConsole();
     void InitWindow();
 
@@ -78,6 +81,7 @@ class Context {
     std::shared_ptr<Window> mWindow;
     std::shared_ptr<Console> mConsole;
     std::shared_ptr<Audio> mAudio;
+    std::shared_ptr<GfxDebugger> mGfxDebugger;
 
     std::string mConfigFilePath;
     std::string mMainPath;
diff --git a/src/debug/CrashHandler.cpp b/src/debug/CrashHandler.cpp
index 47855e53b..287a00630 100644
--- a/src/debug/CrashHandler.cpp
+++ b/src/debug/CrashHandler.cpp
@@ -74,6 +74,7 @@ void CrashHandler::PrintCommon() {
 
 #if (__linux__)
 void CrashHandler::PrintRegisters(ucontext_t* ctx) {
+    #if 0
     char regbuffer[30];
     AppendLine("Registers:");
 #if defined(__x86_64__)
@@ -135,6 +136,7 @@ void CrashHandler::PrintRegisters(ucontext_t* ctx) {
     snprintf(regbuffer, std::size(regbuffer), "EFL: 0x%08lX", ctx->uc_mcontext.gregs[REG_EFL]);
     AppendLine(regbuffer);
 #endif
+    #endif
 }
 
 static void ErrorHandler(int sig, siginfo_t* sigInfo, void* data) {
@@ -215,6 +217,7 @@ static void ShutdownHandler(int sig, siginfo_t* sigInfo, void* data) {
 void CrashHandler::PrintRegisters(CONTEXT* ctx) {
     AppendLine("Registers: ");
     char regBuff[25];
+    #if 0
 #if defined(_M_AMD64)
     sprintf_s(regBuff, std::size(regBuff), "RAX: 0x%016llX", ctx->Rax);
     AppendLine(regBuff);
@@ -294,9 +297,11 @@ void CrashHandler::PrintRegisters(CONTEXT* ctx) {
     sprintf_s(regBuff, std::size(regBuff), "EIP: 0x%08lX", ctx->Eip);
     AppendLine(regBuff);
 #endif
+    #endif
 }
 
 void CrashHandler::PrintStack(CONTEXT* ctx) {
+    #if 0
     BOOL result;
     HANDLE process;
     HANDLE thread;
@@ -387,6 +392,7 @@ void CrashHandler::PrintStack(CONTEXT* ctx) {
     PrintCommon();
     LUS::Context::GetInstance()->GetLogger()->flush();
     spdlog::shutdown();
+    #endif
 }
 
 extern "C" LONG seh_filter(struct _EXCEPTION_POINTERS* ex) {
@@ -409,6 +415,7 @@ extern "C" LONG seh_filter(struct _EXCEPTION_POINTERS* ex) {
 #endif
 
 CrashHandler::CrashHandler() {
+    #if 0
     mOutBuffer = new char[gMaxBufferSize];
 #if defined(__linux__)
     struct sigaction action;
@@ -431,6 +438,7 @@ CrashHandler::CrashHandler() {
 #elif _WIN32
     SetUnhandledExceptionFilter(seh_filter);
 #endif
+    #endif
 }
 
 CrashHandler::CrashHandler(CrashHandlerCallback callback) {
diff --git a/src/debug/GfxDebugger.cpp b/src/debug/GfxDebugger.cpp
new file mode 100644
index 000000000..7dc9cd55f
--- /dev/null
+++ b/src/debug/GfxDebugger.cpp
@@ -0,0 +1,65 @@
+#include "GfxDebugger.h"
+#include <spdlog/fmt/fmt.h>
+
+namespace LUS {
+
+void GfxDebugger::ResumeGame() {
+    mIsDebugging = false;
+    mIsDebuggingRequested = false;
+    mDlist = nullptr;
+}
+
+const Gfx* GfxDebugger::GetDisplayList() const {
+    return mDlist;
+}
+
+const GfxPath& GfxDebugger::GetBreakPoint() const {
+    return mBreakPoint;
+}
+
+void GfxDebugger::SetBreakPoint(const GfxPath& bp) {
+    mBreakPoint = bp;
+}
+
+void GfxDebugger::RequestDebugging() {
+    mIsDebuggingRequested = true;
+}
+
+bool GfxDebugger::IsDebugging() const {
+    return mIsDebugging;
+}
+
+bool GfxDebugger::IsDebuggingRequested() const {
+    return mIsDebuggingRequested;
+}
+
+bool GfxDebugger::HasBreakOnDlist(const std::string& dlistName) {
+    return mBreakOnDLs.contains(dlistName);
+}
+
+void GfxDebugger::AddBreakOnDlist(const std::string& dlistName) {
+    mBreakOnDLs.emplace(dlistName);
+}
+
+void GfxDebugger::RemoveBreakOnDlist(const std::string& dlistName) {
+    if (mBreakOnDLs.contains(dlistName))
+        mBreakOnDLs.erase(dlistName);
+}
+
+const std::set<std::string>& GfxDebugger::GetBreakOnDlists() const {
+    return mBreakOnDLs;
+}
+
+void GfxDebugger::DebugDisplayList(Gfx* cmds) {
+    mDlist = cmds;
+    mIsDebuggingRequested = false;
+    mIsDebugging = true;
+    mBreakPoint = {};
+    mBreakPoint.push(cmds);
+}
+
+bool GfxDebugger::HasBreakPoint(const GfxPath& path) const {
+    return path == mBreakPoint;
+}
+
+} // namespace LUS
diff --git a/src/debug/GfxDebugger.h b/src/debug/GfxDebugger.h
new file mode 100644
index 000000000..c4c3644bc
--- /dev/null
+++ b/src/debug/GfxDebugger.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "libultraship/libultra/gbi.h"
+#include <string>
+#include "graphic/Fast3D/gfx_pc.h"
+#include <set>
+
+namespace LUS {
+
+class GfxDebugger {
+  public:
+    void RequestDebugging();
+    bool IsDebugging() const;
+    bool IsDebuggingRequested() const;
+
+    void DebugDisplayList(Gfx* cmds);
+
+    void ResumeGame();
+
+    const Gfx* GetDisplayList() const;
+
+    const GfxPath& GetBreakPoint() const;
+
+    bool HasBreakPoint(const GfxPath& path) const;
+
+    void SetBreakPoint(const GfxPath& bp);
+
+    bool HasBreakOnDlist(const std::string& dlistName);
+    void AddBreakOnDlist(const std::string& dlistName);
+    void RemoveBreakOnDlist(const std::string& dlistName);
+    const std::set<std::string>& GetBreakOnDlists() const;
+
+  private:
+    bool mIsDebugging = false;
+    bool mIsDebuggingRequested = false;
+    Gfx* mDlist = nullptr;
+    GfxPath mBreakPoint = {};
+    std::set<std::string> mBreakOnDLs = {};
+};
+
+} // namespace LUS
diff --git a/src/graphic/Fast3D/gfx_pc.cpp b/src/graphic/Fast3D/gfx_pc.cpp
index 537f5923d..71ee6913a 100644
--- a/src/graphic/Fast3D/gfx_pc.cpp
+++ b/src/graphic/Fast3D/gfx_pc.cpp
@@ -33,11 +33,13 @@
 #include "log/luslog.h"
 #include "window/gui/Gui.h"
 #include "resource/GameVersions.h"
-#include "resource/Resource.h"
 #include "resource/ResourceManager.h"
-#include "resource/type/Texture.h"
 #include "utils/Utils.h"
 #include "libultraship/libultraship.h"
+#include "libultraship/bridge.h"
+#include "debug/GfxDebugger.h"
+
+#include <spdlog/fmt/fmt.h>
 
 uintptr_t gfxFramebuffer;
 std::stack<std::string> currentDir;
@@ -62,24 +64,8 @@ using namespace std;
 #define RATIO_X (gfx_current_dimensions.width / (2.0f * HALF_SCREEN_WIDTH))
 #define RATIO_Y (gfx_current_dimensions.height / (2.0f * HALF_SCREEN_HEIGHT))
 
-#define MAX_BUFFERED 256
-// #define MAX_LIGHTS 2
-#define MAX_LIGHTS 32
-#define MAX_VERTICES 64
-
 #define TEXTURE_CACHE_MAX_SIZE 500
 
-struct RGBA {
-    uint8_t r, g, b, a;
-};
-
-struct LoadedVertex {
-    float x, y, z, w;
-    float u, v;
-    struct RGBA color;
-    uint8_t clip_rej;
-};
-
 static struct {
     TextureCacheMap map;
     list<TextureCacheMapIter> lru;
@@ -99,87 +85,8 @@ static map<ColorCombinerKey, struct ColorCombiner>::iterator prev_combiner = col
 
 static uint8_t* tex_upload_buffer = nullptr;
 
-static struct RSP {
-    float modelview_matrix_stack[11][4][4];
-    uint8_t modelview_matrix_stack_size;
-
-    float MP_matrix[4][4];
-    float P_matrix[4][4];
-
-    Light_t lookat[2];
-    Light_t current_lights[MAX_LIGHTS + 1];
-    float current_lights_coeffs[MAX_LIGHTS][3];
-    float current_lookat_coeffs[2][3]; // lookat_x, lookat_y
-    uint8_t current_num_lights;        // includes ambient light
-    bool lights_changed;
-
-    uint32_t geometry_mode;
-    int16_t fog_mul, fog_offset;
-
-    uint32_t extra_geometry_mode;
-
-    struct {
-        // U0.16
-        uint16_t s, t;
-    } texture_scaling_factor;
-
-    struct LoadedVertex loaded_vertices[MAX_VERTICES + 4];
-} rsp;
-
-struct RawTexMetadata {
-    uint16_t width, height;
-    float h_byte_scale = 1, v_pixel_scale = 1;
-    std::shared_ptr<LUS::Texture> resource;
-    LUS::TextureType type;
-};
-
-static struct RDP {
-    const uint8_t* palettes[2];
-    struct {
-        const uint8_t* addr;
-        uint8_t siz;
-        uint32_t width;
-        uint32_t tex_flags;
-        struct RawTexMetadata raw_tex_metadata;
-    } texture_to_load;
-    struct {
-        const uint8_t* addr;
-        uint32_t orig_size_bytes;
-        uint32_t size_bytes;
-        uint32_t full_image_line_size_bytes;
-        uint32_t line_size_bytes;
-        uint32_t tex_flags;
-        struct RawTexMetadata raw_tex_metadata;
-        bool masked;
-        bool blended;
-    } loaded_texture[2];
-    struct {
-        uint8_t fmt;
-        uint8_t siz;
-        uint8_t cms, cmt;
-        uint8_t shifts, shiftt;
-        uint16_t uls, ult, lrs, lrt; // U10.2
-        uint16_t tmem;               // 0-511, in 64-bit word units
-        uint32_t line_size_bytes;
-        uint8_t palette;
-        uint8_t tmem_index; // 0 or 1 for offset 0 kB or offset 2 kB, respectively
-    } texture_tile[8];
-    bool textures_changed[2];
-
-    uint8_t first_tile_index;
-
-    uint32_t other_mode_l, other_mode_h;
-    uint64_t combine_mode;
-    bool grayscale;
-
-    uint8_t prim_lod_fraction;
-    struct RGBA env_color, prim_color, fog_color, fill_color, grayscale_color;
-    struct XYWidthHeight viewport, scissor;
-    bool viewport_or_scissor_changed;
-    void* z_buf_address;
-    void* color_image_address;
-} rdp;
-
+RSP g_rsp;
+RDP g_rdp;
 static struct RenderingState {
     uint8_t depth_test_and_mask; // 1: depth test, 2: depth mask
     bool decal_mode;
@@ -216,7 +123,7 @@ static struct GfxWindowManagerAPI* gfx_wapi;
 static struct GfxRenderingAPI* gfx_rapi;
 
 static int markerOn;
-static uintptr_t segmentPointers[16];
+uintptr_t gSegmentPointers[16];
 
 struct FBInfo {
     uint32_t orig_width, orig_height;
@@ -249,15 +156,6 @@ static std::string GetPathWithoutFileName(char* filePath) {
     return filePath;
 }
 
-static char* GetPathWithCurrentDir(char* filePath) {
-    static char fullPath[4096]; // OTRTODO: This is probably a bad idea...
-    if (filePath[0] == '>') {
-        sprintf(fullPath, "%s/%s", currentDir.top().c_str(), &filePath[1]);
-        return fullPath;
-    } else
-        return filePath;
-}
-
 static void gfx_flush(void) {
     if (buf_vbo_len > 0) {
         gfx_rapi->draw_triangles(buf_vbo, buf_vbo_len, buf_vbo_num_tris);
@@ -591,16 +489,16 @@ static void gfx_texture_cache_delete(const uint8_t* orig_addr) {
 }
 
 static void import_texture_rgba16(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     // SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes / 2; i++) {
@@ -615,43 +513,43 @@ static void import_texture_rgba16(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = a ? 255 : 0;
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes / 2;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_rgba32(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
-    uint32_t height = (size_bytes / 2) / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes / 2;
+    uint32_t height = (size_bytes / 2) / g_rdp.texture_tile[tile].line_size_bytes;
     gfx_rapi->upload_texture(addr, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, addr, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, addr, width, height);
 }
 
 static void import_texture_ia4(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes * 2; i++) {
@@ -668,24 +566,24 @@ static void import_texture_ia4(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = alpha ? 255 : 0;
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes * 2;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes * 2;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_ia8(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes; i++) {
@@ -700,24 +598,24 @@ static void import_texture_ia8(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = SCALE_4_8(alpha);
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_ia16(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes / 2; i++) {
@@ -732,24 +630,24 @@ static void import_texture_ia16(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = alpha;
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes / 2;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_i4(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     // SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes * 2; i++) {
@@ -766,24 +664,24 @@ static void import_texture_i4(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = SCALE_4_8(a);
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes * 2;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes * 2;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_i8(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
     // SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes; i++) {
@@ -798,26 +696,34 @@ static void import_texture_i8(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = a;
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes;
-    uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes;
+    uint32_t height = size_bytes / g_rdp.texture_tile[tile].line_size_bytes;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_ci4(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
-    uint32_t pal_idx = rdp.texture_tile[tile].palette;                           // 0-15
-    const uint8_t* palette = rdp.palettes[pal_idx / 8] + (pal_idx % 8) * 16 * 2; // 16 pixel entries, 16 bits each
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
+    uint32_t pal_idx = g_rdp.texture_tile[tile].palette; // 0-15
+
+    uint8_t* palette = nullptr;
+    // const uint8_t* palette = g_rdp.palettes[pal_idx / 8] + (pal_idx % 8) * 16 * 2; // 16 pixel entries, 16 bits each
+
+    if (pal_idx > 7)
+        palette = (uint8_t*)g_rdp.palettes[pal_idx / 8]; // 16 pixel entries, 16 bits each
+    else
+        palette = (uint8_t*)(g_rdp.palettes[pal_idx / 8] + (pal_idx % 8) * 16 * 2);
+
     SUPPORT_CHECK(full_image_line_size_bytes == line_size_bytes);
 
     for (uint32_t i = 0; i < size_bytes * 2; i++) {
@@ -834,7 +740,7 @@ static void import_texture_ci4(int tile, bool importReplacement) {
         tex_upload_buffer[4 * i + 3] = a ? 255 : 0;
     }
 
-    uint32_t result_line_size = rdp.texture_tile[tile].line_size_bytes;
+    uint32_t result_line_size = g_rdp.texture_tile[tile].line_size_bytes;
     if (metadata->h_byte_scale != 1) {
         result_line_size *= metadata->h_byte_scale;
     }
@@ -846,22 +752,22 @@ static void import_texture_ci4(int tile, bool importReplacement) {
 }
 
 static void import_texture_ci8(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
-    uint32_t size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
+    uint32_t size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
 
     for (uint32_t i = 0, j = 0; i < size_bytes; j += full_image_line_size_bytes - line_size_bytes) {
         for (uint32_t k = 0; k < line_size_bytes; i++, k++, j++) {
             uint8_t idx = addr[j];
-            uint16_t col16 = (rdp.palettes[idx / 128][(idx % 128) * 2] << 8) |
-                             rdp.palettes[idx / 128][(idx % 128) * 2 + 1]; // Big endian load
+            uint16_t col16 = (g_rdp.palettes[idx / 128][(idx % 128) * 2] << 8) |
+                             g_rdp.palettes[idx / 128][(idx % 128) * 2 + 1]; // Big endian load
             uint8_t a = col16 & 1;
             uint8_t r = col16 >> 11;
             uint8_t g = (col16 >> 6) & 0x1f;
@@ -873,7 +779,7 @@ static void import_texture_ci8(int tile, bool importReplacement) {
         }
     }
 
-    uint32_t result_line_size = rdp.texture_tile[tile].line_size_bytes;
+    uint32_t result_line_size = g_rdp.texture_tile[tile].line_size_bytes;
     if (metadata->h_byte_scale != 1) {
         result_line_size *= metadata->h_byte_scale;
     }
@@ -882,16 +788,16 @@ static void import_texture_ci8(int tile, bool importReplacement) {
     uint32_t height = size_bytes / result_line_size;
 
     gfx_rapi->upload_texture(tex_upload_buffer, width, height);
-    // DumpTexture(rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
+    // DumpTexture(g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture_raw(int tile, bool importReplacement) {
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr;
+            : g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr;
 
     uint16_t width = metadata->width;
     uint16_t height = metadata->height;
@@ -910,11 +816,11 @@ static void import_texture_raw(int tile, bool importReplacement) {
             break;
     }
 
-    uint32_t num_loaded_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes;
-    uint32_t num_originally_loaded_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes;
+    uint32_t num_loaded_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes;
+    uint32_t num_originally_loaded_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes;
 
-    uint32_t result_orig_line_size = rdp.texture_tile[tile].line_size_bytes;
-    switch (rdp.texture_tile[tile].siz) {
+    uint32_t result_orig_line_size = g_rdp.texture_tile[tile].line_size_bytes;
+    switch (g_rdp.texture_tile[tile].siz) {
         case G_IM_SIZ_32b:
             result_orig_line_size *= 2;
             break;
@@ -930,8 +836,8 @@ static void import_texture_raw(int tile, bool importReplacement) {
     }
 
     uint32_t full_image_line_size_bytes =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
-    uint32_t line_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes;
+    uint32_t line_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes;
 
     // Get the resource's true image size
     uint32_t resource_image_size_bytes = resource->ImageDataSize;
@@ -963,22 +869,22 @@ static void import_texture_raw(int tile, bool importReplacement) {
 }
 
 static void import_texture(int i, int tile, bool importReplacement) {
-    uint8_t fmt = rdp.texture_tile[tile].fmt;
-    uint8_t siz = rdp.texture_tile[tile].siz;
-    uint32_t texFlags = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].tex_flags;
-    uint32_t tmem_index = rdp.texture_tile[tile].tmem_index;
-    uint8_t palette_index = rdp.texture_tile[tile].palette;
+    uint8_t fmt = g_rdp.texture_tile[tile].fmt;
+    uint8_t siz = g_rdp.texture_tile[tile].siz;
+    uint32_t texFlags = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].tex_flags;
+    uint32_t tmem_index = g_rdp.texture_tile[tile].tmem_index;
+    uint8_t palette_index = g_rdp.texture_tile[tile].palette;
 
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    const RawTexMetadata* metadata = &g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
     const uint8_t* orig_addr =
         importReplacement && (metadata->resource != nullptr)
             ? masked_textures.find(gfx_get_base_texture_path(metadata->resource->GetInitData()->Path))
                   ->second.replacementData
-            : rdp.loaded_texture[tmem_index].addr;
+            : g_rdp.loaded_texture[tmem_index].addr;
 
     TextureCacheKey key;
     if (fmt == G_IM_FMT_CI) {
-        key = { orig_addr, { rdp.palettes[0], rdp.palettes[1] }, fmt, siz, palette_index };
+        key = { orig_addr, { g_rdp.palettes[0], g_rdp.palettes[1] }, fmt, siz, palette_index };
     } else {
         key = { orig_addr, {}, fmt, siz, palette_index };
     }
@@ -1034,8 +940,8 @@ static void import_texture(int i, int tile, bool importReplacement) {
 }
 
 static void import_texture_mask(int i, int tile) {
-    uint32_t tmem_index = rdp.texture_tile[tile].tmem_index;
-    RawTexMetadata metadata = rdp.loaded_texture[tmem_index].raw_tex_metadata;
+    uint32_t tmem_index = g_rdp.texture_tile[tile].tmem_index;
+    RawTexMetadata metadata = g_rdp.loaded_texture[tmem_index].raw_tex_metadata;
 
     if (metadata.resource == nullptr) {
         return;
@@ -1058,10 +964,10 @@ static void import_texture_mask(int i, int tile) {
         return;
     }
 
-    uint32_t width = rdp.texture_tile[tile].line_size_bytes;
-    uint32_t height =
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes / rdp.texture_tile[tile].line_size_bytes;
-    switch (rdp.texture_tile[tile].siz) {
+    uint32_t width = g_rdp.texture_tile[tile].line_size_bytes;
+    uint32_t height = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes /
+                      g_rdp.texture_tile[tile].line_size_bytes;
+    switch (g_rdp.texture_tile[tile].siz) {
         case G_IM_SIZ_4b:
             width *= 2;
             break;
@@ -1110,7 +1016,7 @@ static void gfx_transposed_matrix_mul(float res[3], const float a[3], const floa
 static void calculate_normal_dir(const Light_t* light, float coeffs[3]) {
     float light_dir[3] = { light->dir[0] / 127.0f, light->dir[1] / 127.0f, light->dir[2] / 127.0f };
 
-    gfx_transposed_matrix_mul(coeffs, light_dir, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]);
+    gfx_transposed_matrix_mul(coeffs, light_dir, g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1]);
     gfx_normalize_vector(coeffs);
 }
 
@@ -1154,34 +1060,37 @@ static void gfx_sp_matrix(uint8_t parameters, const int32_t* addr) {
 
     if (parameters & G_MTX_PROJECTION) {
         if (parameters & G_MTX_LOAD) {
-            memcpy(rsp.P_matrix, matrix, sizeof(matrix));
+            memcpy(g_rsp.P_matrix, matrix, sizeof(matrix));
         } else {
-            gfx_matrix_mul(rsp.P_matrix, matrix, rsp.P_matrix);
+            gfx_matrix_mul(g_rsp.P_matrix, matrix, g_rsp.P_matrix);
         }
     } else { // G_MTX_MODELVIEW
-        if ((parameters & G_MTX_PUSH) && rsp.modelview_matrix_stack_size < 11) {
-            ++rsp.modelview_matrix_stack_size;
-            memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1],
-                   rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 2], sizeof(matrix));
+        if ((parameters & G_MTX_PUSH) && g_rsp.modelview_matrix_stack_size < 11) {
+            ++g_rsp.modelview_matrix_stack_size;
+            memcpy(g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1],
+                   g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 2], sizeof(matrix));
         }
         if (parameters & G_MTX_LOAD) {
-            memcpy(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix, sizeof(matrix));
+            if (g_rsp.modelview_matrix_stack_size == 0)
+                ++g_rsp.modelview_matrix_stack_size;
+            memcpy(g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1], matrix, sizeof(matrix));
         } else {
-            gfx_matrix_mul(rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], matrix,
-                           rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1]);
+            gfx_matrix_mul(g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1], matrix,
+                           g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1]);
         }
-        rsp.lights_changed = 1;
+        g_rsp.lights_changed = 1;
     }
-    gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1], rsp.P_matrix);
+    gfx_matrix_mul(g_rsp.MP_matrix, g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1],
+                   g_rsp.P_matrix);
 }
 
 static void gfx_sp_pop_matrix(uint32_t count) {
     while (count--) {
-        if (rsp.modelview_matrix_stack_size > 0) {
-            --rsp.modelview_matrix_stack_size;
-            if (rsp.modelview_matrix_stack_size > 0) {
-                gfx_matrix_mul(rsp.MP_matrix, rsp.modelview_matrix_stack[rsp.modelview_matrix_stack_size - 1],
-                               rsp.P_matrix);
+        if (g_rsp.modelview_matrix_stack_size > 0) {
+            --g_rsp.modelview_matrix_stack_size;
+            if (g_rsp.modelview_matrix_stack_size > 0) {
+                gfx_matrix_mul(g_rsp.MP_matrix, g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1],
+                               g_rsp.P_matrix);
             }
         }
     }
@@ -1210,52 +1119,52 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
     for (size_t i = 0; i < n_vertices; i++, dest_index++) {
         const Vtx_t* v = &vertices[i].v;
         const Vtx_tn* vn = &vertices[i].n;
-        struct LoadedVertex* d = &rsp.loaded_vertices[dest_index];
+        struct LoadedVertex* d = &g_rsp.loaded_vertices[dest_index];
 
         if (v == NULL) {
             return;
         }
 
-        float x = v->ob[0] * rsp.MP_matrix[0][0] + v->ob[1] * rsp.MP_matrix[1][0] + v->ob[2] * rsp.MP_matrix[2][0] +
-                  rsp.MP_matrix[3][0];
-        float y = v->ob[0] * rsp.MP_matrix[0][1] + v->ob[1] * rsp.MP_matrix[1][1] + v->ob[2] * rsp.MP_matrix[2][1] +
-                  rsp.MP_matrix[3][1];
-        float z = v->ob[0] * rsp.MP_matrix[0][2] + v->ob[1] * rsp.MP_matrix[1][2] + v->ob[2] * rsp.MP_matrix[2][2] +
-                  rsp.MP_matrix[3][2];
-        float w = v->ob[0] * rsp.MP_matrix[0][3] + v->ob[1] * rsp.MP_matrix[1][3] + v->ob[2] * rsp.MP_matrix[2][3] +
-                  rsp.MP_matrix[3][3];
+        float x = v->ob[0] * g_rsp.MP_matrix[0][0] + v->ob[1] * g_rsp.MP_matrix[1][0] +
+                  v->ob[2] * g_rsp.MP_matrix[2][0] + g_rsp.MP_matrix[3][0];
+        float y = v->ob[0] * g_rsp.MP_matrix[0][1] + v->ob[1] * g_rsp.MP_matrix[1][1] +
+                  v->ob[2] * g_rsp.MP_matrix[2][1] + g_rsp.MP_matrix[3][1];
+        float z = v->ob[0] * g_rsp.MP_matrix[0][2] + v->ob[1] * g_rsp.MP_matrix[1][2] +
+                  v->ob[2] * g_rsp.MP_matrix[2][2] + g_rsp.MP_matrix[3][2];
+        float w = v->ob[0] * g_rsp.MP_matrix[0][3] + v->ob[1] * g_rsp.MP_matrix[1][3] +
+                  v->ob[2] * g_rsp.MP_matrix[2][3] + g_rsp.MP_matrix[3][3];
 
         x = gfx_adjust_x_for_aspect_ratio(x);
 
-        short U = v->tc[0] * rsp.texture_scaling_factor.s >> 16;
-        short V = v->tc[1] * rsp.texture_scaling_factor.t >> 16;
+        short U = v->tc[0] * g_rsp.texture_scaling_factor.s >> 16;
+        short V = v->tc[1] * g_rsp.texture_scaling_factor.t >> 16;
 
-        if (rsp.geometry_mode & G_LIGHTING) {
-            if (rsp.lights_changed) {
-                for (int i = 0; i < rsp.current_num_lights - 1; i++) {
-                    calculate_normal_dir(&rsp.current_lights[i], rsp.current_lights_coeffs[i]);
+        if (g_rsp.geometry_mode & G_LIGHTING) {
+            if (g_rsp.lights_changed) {
+                for (int i = 0; i < g_rsp.current_num_lights - 1; i++) {
+                    calculate_normal_dir(&g_rsp.current_lights[i], g_rsp.current_lights_coeffs[i]);
                 }
                 /*static const Light_t lookat_x = {{0, 0, 0}, 0, {0, 0, 0}, 0, {127, 0, 0}, 0};
                 static const Light_t lookat_y = {{0, 0, 0}, 0, {0, 0, 0}, 0, {0, 127, 0}, 0};*/
-                calculate_normal_dir(&rsp.lookat[0], rsp.current_lookat_coeffs[0]);
-                calculate_normal_dir(&rsp.lookat[1], rsp.current_lookat_coeffs[1]);
-                rsp.lights_changed = false;
+                calculate_normal_dir(&g_rsp.lookat[0], g_rsp.current_lookat_coeffs[0]);
+                calculate_normal_dir(&g_rsp.lookat[1], g_rsp.current_lookat_coeffs[1]);
+                g_rsp.lights_changed = false;
             }
 
-            int r = rsp.current_lights[rsp.current_num_lights - 1].col[0];
-            int g = rsp.current_lights[rsp.current_num_lights - 1].col[1];
-            int b = rsp.current_lights[rsp.current_num_lights - 1].col[2];
+            int r = g_rsp.current_lights[g_rsp.current_num_lights - 1].col[0];
+            int g = g_rsp.current_lights[g_rsp.current_num_lights - 1].col[1];
+            int b = g_rsp.current_lights[g_rsp.current_num_lights - 1].col[2];
 
-            for (int i = 0; i < rsp.current_num_lights - 1; i++) {
+            for (int i = 0; i < g_rsp.current_num_lights - 1; i++) {
                 float intensity = 0;
-                intensity += vn->n[0] * rsp.current_lights_coeffs[i][0];
-                intensity += vn->n[1] * rsp.current_lights_coeffs[i][1];
-                intensity += vn->n[2] * rsp.current_lights_coeffs[i][2];
+                intensity += vn->n[0] * g_rsp.current_lights_coeffs[i][0];
+                intensity += vn->n[1] * g_rsp.current_lights_coeffs[i][1];
+                intensity += vn->n[2] * g_rsp.current_lights_coeffs[i][2];
                 intensity /= 127.0f;
                 if (intensity > 0.0f) {
-                    r += intensity * rsp.current_lights[i].col[0];
-                    g += intensity * rsp.current_lights[i].col[1];
-                    b += intensity * rsp.current_lights[i].col[2];
+                    r += intensity * g_rsp.current_lights[i].col[0];
+                    g += intensity * g_rsp.current_lights[i].col[1];
+                    b += intensity * g_rsp.current_lights[i].col[2];
                 }
             }
 
@@ -1263,14 +1172,14 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
             d->color.g = g > 255 ? 255 : g;
             d->color.b = b > 255 ? 255 : b;
 
-            if (rsp.geometry_mode & G_TEXTURE_GEN) {
+            if (g_rsp.geometry_mode & G_TEXTURE_GEN) {
                 float dotx = 0, doty = 0;
-                dotx += vn->n[0] * rsp.current_lookat_coeffs[0][0];
-                dotx += vn->n[1] * rsp.current_lookat_coeffs[0][1];
-                dotx += vn->n[2] * rsp.current_lookat_coeffs[0][2];
-                doty += vn->n[0] * rsp.current_lookat_coeffs[1][0];
-                doty += vn->n[1] * rsp.current_lookat_coeffs[1][1];
-                doty += vn->n[2] * rsp.current_lookat_coeffs[1][2];
+                dotx += vn->n[0] * g_rsp.current_lookat_coeffs[0][0];
+                dotx += vn->n[1] * g_rsp.current_lookat_coeffs[0][1];
+                dotx += vn->n[2] * g_rsp.current_lookat_coeffs[0][2];
+                doty += vn->n[0] * g_rsp.current_lookat_coeffs[1][0];
+                doty += vn->n[1] * g_rsp.current_lookat_coeffs[1][1];
+                doty += vn->n[2] * g_rsp.current_lookat_coeffs[1][2];
 
                 dotx /= 127.0f;
                 doty /= 127.0f;
@@ -1278,7 +1187,7 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
                 dotx = LUS::Math::clamp(dotx, -1.0f, 1.0f);
                 doty = LUS::Math::clamp(doty, -1.0f, 1.0f);
 
-                if (rsp.geometry_mode & G_TEXTURE_GEN_LINEAR) {
+                if (g_rsp.geometry_mode & G_TEXTURE_GEN_LINEAR) {
                     // Not sure exactly what formula we should use to get accurate values
                     /*dotx = (2.906921f * dotx * dotx + 1.36114f) * dotx;
                     doty = (2.906921f * doty * doty + 1.36114f) * doty;
@@ -1291,8 +1200,8 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
                     doty = (doty + 1.0f) / 4.0f;
                 }
 
-                U = (int32_t)(dotx * rsp.texture_scaling_factor.s);
-                V = (int32_t)(doty * rsp.texture_scaling_factor.t);
+                U = (int32_t)(dotx * g_rsp.texture_scaling_factor.s);
+                V = (int32_t)(doty * g_rsp.texture_scaling_factor.t);
             }
         } else {
             d->color.r = v->cn[0];
@@ -1327,7 +1236,7 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
         d->z = z;
         d->w = w;
 
-        if (rsp.geometry_mode & G_FOG) {
+        if (g_rsp.geometry_mode & G_FOG) {
             if (fabsf(w) < 0.001f) {
                 // To avoid division by zero
                 w = 0.001f;
@@ -1338,7 +1247,7 @@ static void gfx_sp_vertex(size_t n_vertices, size_t dest_index, const Vtx* verti
                 winv = std::numeric_limits<int16_t>::max();
             }
 
-            float fog_z = z * winv * rsp.fog_mul + rsp.fog_offset;
+            float fog_z = z * winv * g_rsp.fog_mul + g_rsp.fog_offset;
             fog_z = LUS::Math::clamp(fog_z, 0.0f, 255.0f);
             d->color.a = fog_z; // Use alpha variable to store fog factor
         } else {
@@ -1353,15 +1262,15 @@ static void gfx_sp_modify_vertex(uint16_t vtx_idx, uint8_t where, uint32_t val)
     int16_t s = (int16_t)(val >> 16);
     int16_t t = (int16_t)val;
 
-    struct LoadedVertex* v = &rsp.loaded_vertices[vtx_idx];
+    struct LoadedVertex* v = &g_rsp.loaded_vertices[vtx_idx];
     v->u = s;
     v->v = t;
 }
 
 static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bool is_rect) {
-    struct LoadedVertex* v1 = &rsp.loaded_vertices[vtx1_idx];
-    struct LoadedVertex* v2 = &rsp.loaded_vertices[vtx2_idx];
-    struct LoadedVertex* v3 = &rsp.loaded_vertices[vtx3_idx];
+    struct LoadedVertex* v1 = &g_rsp.loaded_vertices[vtx1_idx];
+    struct LoadedVertex* v2 = &g_rsp.loaded_vertices[vtx2_idx];
+    struct LoadedVertex* v3 = &g_rsp.loaded_vertices[vtx3_idx];
     struct LoadedVertex* v_arr[3] = { v1, v2, v3 };
 
     // if (rand()%2) return;
@@ -1371,7 +1280,7 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
         return;
     }
 
-    if ((rsp.geometry_mode & G_CULL_BOTH) != 0) {
+    if ((g_rsp.geometry_mode & G_CULL_BOTH) != 0) {
         float dx1 = v1->x / (v1->w) - v2->x / (v2->w);
         float dy1 = v1->y / (v1->w) - v2->y / (v2->w);
         float dx2 = v3->x / (v3->w) - v2->x / (v2->w);
@@ -1385,11 +1294,11 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
         }
 
         // If inverted culling is requested, negate the cross
-        if ((rsp.extra_geometry_mode & G_EX_INVERT_CULLING) == 1) {
+        if ((g_rsp.extra_geometry_mode & G_EX_INVERT_CULLING) == 1) {
             cross = -cross;
         }
 
-        switch (rsp.geometry_mode & G_CULL_BOTH) {
+        switch (g_rsp.geometry_mode & G_CULL_BOTH) {
             case G_CULL_FRONT:
                 if (cross <= 0) {
                     return;
@@ -1406,8 +1315,8 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
         }
     }
 
-    bool depth_test = (rsp.geometry_mode & G_ZBUFFER) == G_ZBUFFER;
-    bool depth_mask = (rdp.other_mode_l & Z_UPD) == Z_UPD;
+    bool depth_test = (g_rsp.geometry_mode & G_ZBUFFER) == G_ZBUFFER;
+    bool depth_mask = (g_rdp.other_mode_l & Z_UPD) == Z_UPD;
     uint8_t depth_test_and_mask = (depth_test ? 1 : 0) | (depth_mask ? 2 : 0);
     if (depth_test_and_mask != rendering_state.depth_test_and_mask) {
         gfx_flush();
@@ -1415,39 +1324,39 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
         rendering_state.depth_test_and_mask = depth_test_and_mask;
     }
 
-    bool zmode_decal = (rdp.other_mode_l & ZMODE_DEC) == ZMODE_DEC;
+    bool zmode_decal = (g_rdp.other_mode_l & ZMODE_DEC) == ZMODE_DEC;
     if (zmode_decal != rendering_state.decal_mode) {
         gfx_flush();
         gfx_rapi->set_zmode_decal(zmode_decal);
         rendering_state.decal_mode = zmode_decal;
     }
 
-    if (rdp.viewport_or_scissor_changed) {
-        if (memcmp(&rdp.viewport, &rendering_state.viewport, sizeof(rdp.viewport)) != 0) {
+    if (g_rdp.viewport_or_scissor_changed) {
+        if (memcmp(&g_rdp.viewport, &rendering_state.viewport, sizeof(g_rdp.viewport)) != 0) {
             gfx_flush();
-            gfx_rapi->set_viewport(rdp.viewport.x, rdp.viewport.y, rdp.viewport.width, rdp.viewport.height);
-            rendering_state.viewport = rdp.viewport;
+            gfx_rapi->set_viewport(g_rdp.viewport.x, g_rdp.viewport.y, g_rdp.viewport.width, g_rdp.viewport.height);
+            rendering_state.viewport = g_rdp.viewport;
         }
-        if (memcmp(&rdp.scissor, &rendering_state.scissor, sizeof(rdp.scissor)) != 0) {
+        if (memcmp(&g_rdp.scissor, &rendering_state.scissor, sizeof(g_rdp.scissor)) != 0) {
             gfx_flush();
-            gfx_rapi->set_scissor(rdp.scissor.x, rdp.scissor.y, rdp.scissor.width, rdp.scissor.height);
-            rendering_state.scissor = rdp.scissor;
+            gfx_rapi->set_scissor(g_rdp.scissor.x, g_rdp.scissor.y, g_rdp.scissor.width, g_rdp.scissor.height);
+            rendering_state.scissor = g_rdp.scissor;
         }
-        rdp.viewport_or_scissor_changed = false;
+        g_rdp.viewport_or_scissor_changed = false;
     }
 
-    uint64_t cc_id = rdp.combine_mode;
+    uint64_t cc_id = g_rdp.combine_mode;
     uint64_t cc_options = 0;
-    bool use_alpha =
-        (rdp.other_mode_l & (3 << 20)) == (G_BL_CLR_MEM << 20) && (rdp.other_mode_l & (3 << 16)) == (G_BL_1MA << 16);
-    bool use_fog = (rdp.other_mode_l >> 30) == G_BL_CLR_FOG;
-    bool texture_edge = (rdp.other_mode_l & CVG_X_ALPHA) == CVG_X_ALPHA;
-    bool use_noise = (rdp.other_mode_l & (3U << G_MDSFT_ALPHACOMPARE)) == G_AC_DITHER;
-    bool use_2cyc = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_2CYCLE;
-    bool alpha_threshold = (rdp.other_mode_l & (3U << G_MDSFT_ALPHACOMPARE)) == G_AC_THRESHOLD;
+    bool use_alpha = (g_rdp.other_mode_l & (3 << 20)) == (G_BL_CLR_MEM << 20) &&
+                     (g_rdp.other_mode_l & (3 << 16)) == (G_BL_1MA << 16);
+    bool use_fog = (g_rdp.other_mode_l >> 30) == G_BL_CLR_FOG;
+    bool texture_edge = (g_rdp.other_mode_l & CVG_X_ALPHA) == CVG_X_ALPHA;
+    bool use_noise = (g_rdp.other_mode_l & (3U << G_MDSFT_ALPHACOMPARE)) == G_AC_DITHER;
+    bool use_2cyc = (g_rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_2CYCLE;
+    bool alpha_threshold = (g_rdp.other_mode_l & (3U << G_MDSFT_ALPHACOMPARE)) == G_AC_THRESHOLD;
     bool invisible =
-        (rdp.other_mode_l & (3 << 24)) == (G_BL_0 << 24) && (rdp.other_mode_l & (3 << 20)) == (G_BL_CLR_MEM << 20);
-    bool use_grayscale = rdp.grayscale;
+        (g_rdp.other_mode_l & (3 << 24)) == (G_BL_0 << 24) && (g_rdp.other_mode_l & (3 << 20)) == (G_BL_CLR_MEM << 20);
+    bool use_grayscale = g_rdp.grayscale;
 
     if (texture_edge) {
         use_alpha = true;
@@ -1477,16 +1386,16 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
     if (use_grayscale) {
         cc_options |= (uint64_t)SHADER_OPT_GRAYSCALE;
     }
-    if (rdp.loaded_texture[0].masked) {
+    if (g_rdp.loaded_texture[0].masked) {
         cc_options |= (uint64_t)SHADER_OPT_TEXEL0_MASK;
     }
-    if (rdp.loaded_texture[1].masked) {
+    if (g_rdp.loaded_texture[1].masked) {
         cc_options |= (uint64_t)SHADER_OPT_TEXEL1_MASK;
     }
-    if (rdp.loaded_texture[0].blended) {
+    if (g_rdp.loaded_texture[0].blended) {
         cc_options |= (uint64_t)SHADER_OPT_TEXEL0_BLEND;
     }
-    if (rdp.loaded_texture[1].blended) {
+    if (g_rdp.loaded_texture[1].blended) {
         cc_options |= (uint64_t)SHADER_OPT_TEXEL1_BLEND;
     }
 
@@ -1496,7 +1405,7 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
     }
 
     ColorCombinerKey key;
-    key.combine_mode = rdp.combine_mode;
+    key.combine_mode = g_rdp.combine_mode;
     key.options = cc_options;
 
     ColorCombiner* comb = gfx_lookup_or_create_color_combiner(key);
@@ -1505,32 +1414,32 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
     uint32_t tex_width[2], tex_height[2], tex_width2[2], tex_height2[2];
 
     for (int i = 0; i < 2; i++) {
-        uint32_t tile = rdp.first_tile_index + i;
+        uint32_t tile = g_rdp.first_tile_index + i;
         if (comb->used_textures[i]) {
-            if (rdp.textures_changed[i]) {
+            if (g_rdp.textures_changed[i]) {
                 gfx_flush();
                 import_texture(i, tile, false);
-                if (rdp.loaded_texture[i].masked) {
+                if (g_rdp.loaded_texture[i].masked) {
                     import_texture_mask(SHADER_FIRST_MASK_TEXTURE + i, tile);
                 }
-                if (rdp.loaded_texture[i].blended) {
+                if (g_rdp.loaded_texture[i].blended) {
                     import_texture(SHADER_FIRST_REPLACEMENT_TEXTURE + i, tile, true);
                 }
-                rdp.textures_changed[i] = false;
+                g_rdp.textures_changed[i] = false;
             }
 
-            uint8_t cms = rdp.texture_tile[tile].cms;
-            uint8_t cmt = rdp.texture_tile[tile].cmt;
+            uint8_t cms = g_rdp.texture_tile[tile].cms;
+            uint8_t cmt = g_rdp.texture_tile[tile].cmt;
 
-            uint32_t tex_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes;
-            uint32_t line_size = rdp.texture_tile[tile].line_size_bytes;
+            uint32_t tex_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes;
+            uint32_t line_size = g_rdp.texture_tile[tile].line_size_bytes;
 
             if (line_size == 0) {
                 line_size = 1;
             }
 
             tex_height[i] = tex_size_bytes / line_size;
-            switch (rdp.texture_tile[tile].siz) {
+            switch (g_rdp.texture_tile[tile].siz) {
                 case G_IM_SIZ_4b:
                     line_size <<= 1;
                     break;
@@ -1546,8 +1455,8 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
             }
             tex_width[i] = line_size;
 
-            tex_width2[i] = (rdp.texture_tile[tile].lrs - rdp.texture_tile[tile].uls + 4) / 4;
-            tex_height2[i] = (rdp.texture_tile[tile].lrt - rdp.texture_tile[tile].ult + 4) / 4;
+            tex_width2[i] = (g_rdp.texture_tile[tile].lrs - g_rdp.texture_tile[tile].uls + 4) / 4;
+            tex_height2[i] = (g_rdp.texture_tile[tile].lrt - g_rdp.texture_tile[tile].ult + 4) / 4;
 
             uint32_t tex_width1 = tex_width[i] << (cms & G_TX_MIRROR);
             uint32_t tex_height1 = tex_height[i] << (cmt & G_TX_MIRROR);
@@ -1561,7 +1470,7 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
                 cmt &= ~G_TX_CLAMP;
             }
 
-            bool linear_filter = (rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT;
+            bool linear_filter = (g_rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT;
             if (linear_filter != rendering_state.textures[i]->second.linear_filter ||
                 cms != rendering_state.textures[i]->second.cms || cmt != rendering_state.textures[i]->second.cmt) {
                 gfx_flush();
@@ -1614,8 +1523,8 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
             float u = v_arr[i]->u / 32.0f;
             float v = v_arr[i]->v / 32.0f;
 
-            int shifts = rdp.texture_tile[rdp.first_tile_index + t].shifts;
-            int shiftt = rdp.texture_tile[rdp.first_tile_index + t].shiftt;
+            int shifts = g_rdp.texture_tile[g_rdp.first_tile_index + t].shifts;
+            int shiftt = g_rdp.texture_tile[g_rdp.first_tile_index + t].shiftt;
             if (shifts != 0) {
                 if (shifts <= 10) {
                     u /= 1 << shifts;
@@ -1631,10 +1540,10 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
                 }
             }
 
-            u -= rdp.texture_tile[rdp.first_tile_index + t].uls / 4.0f;
-            v -= rdp.texture_tile[rdp.first_tile_index + t].ult / 4.0f;
+            u -= g_rdp.texture_tile[g_rdp.first_tile_index + t].uls / 4.0f;
+            v -= g_rdp.texture_tile[g_rdp.first_tile_index + t].ult / 4.0f;
 
-            if ((rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT) {
+            if ((g_rdp.other_mode_h & (3U << G_MDSFT_TEXTFILT)) != G_TF_POINT) {
                 // Linear filter adds 0.5f to the coordinates
                 if (!is_rect) {
                     u += 0.5f;
@@ -1667,17 +1576,17 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
         }
 
         if (use_fog) {
-            buf_vbo[buf_vbo_len++] = rdp.fog_color.r / 255.0f;
-            buf_vbo[buf_vbo_len++] = rdp.fog_color.g / 255.0f;
-            buf_vbo[buf_vbo_len++] = rdp.fog_color.b / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.fog_color.r / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.fog_color.g / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.fog_color.b / 255.0f;
             buf_vbo[buf_vbo_len++] = v_arr[i]->color.a / 255.0f; // fog factor (not alpha)
         }
 
         if (use_grayscale) {
-            buf_vbo[buf_vbo_len++] = rdp.grayscale_color.r / 255.0f;
-            buf_vbo[buf_vbo_len++] = rdp.grayscale_color.g / 255.0f;
-            buf_vbo[buf_vbo_len++] = rdp.grayscale_color.b / 255.0f;
-            buf_vbo[buf_vbo_len++] = rdp.grayscale_color.a / 255.0f; // lerp interpolation factor (not alpha)
+            buf_vbo[buf_vbo_len++] = g_rdp.grayscale_color.r / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.grayscale_color.g / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.grayscale_color.b / 255.0f;
+            buf_vbo[buf_vbo_len++] = g_rdp.grayscale_color.a / 255.0f; // lerp interpolation factor (not alpha)
         }
 
         for (int j = 0; j < num_inputs; j++) {
@@ -1688,31 +1597,31 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
                         // Note: CCMUX constants and ACMUX constants used here have same value, which is why this works
                         // (except LOD fraction).
                     case G_CCMUX_PRIMITIVE:
-                        color = &rdp.prim_color;
+                        color = &g_rdp.prim_color;
                         break;
                     case G_CCMUX_SHADE:
                         color = &v_arr[i]->color;
                         break;
                     case G_CCMUX_ENVIRONMENT:
-                        color = &rdp.env_color;
+                        color = &g_rdp.env_color;
                         break;
                     case G_CCMUX_PRIMITIVE_ALPHA: {
-                        tmp.r = tmp.g = tmp.b = rdp.prim_color.a;
+                        tmp.r = tmp.g = tmp.b = g_rdp.prim_color.a;
                         color = &tmp;
                         break;
                     }
                     case G_CCMUX_ENV_ALPHA: {
-                        tmp.r = tmp.g = tmp.b = rdp.env_color.a;
+                        tmp.r = tmp.g = tmp.b = g_rdp.env_color.a;
                         color = &tmp;
                         break;
                     }
                     case G_CCMUX_PRIM_LOD_FRAC: {
-                        tmp.r = tmp.g = tmp.b = rdp.prim_lod_fraction;
+                        tmp.r = tmp.g = tmp.b = g_rdp.prim_lod_fraction;
                         color = &tmp;
                         break;
                     }
                     case G_CCMUX_LOD_FRACTION: {
-                        if (rdp.other_mode_l & G_TL_LOD) {
+                        if (g_rdp.other_mode_l & G_TL_LOD) {
                             // "Hack" that works for Bowser - Peach painting
                             float distance_frac = (v1->w - 3000.0f) / 3000.0f;
                             if (distance_frac < 0.0f) {
@@ -1729,7 +1638,7 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
                         break;
                     }
                     case G_ACMUX_PRIM_LOD_FRAC:
-                        tmp.a = rdp.prim_lod_fraction;
+                        tmp.a = g_rdp.prim_lod_fraction;
                         color = &tmp;
                         break;
                     default:
@@ -1772,13 +1681,13 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
 }
 
 static void gfx_sp_geometry_mode(uint32_t clear, uint32_t set) {
-    rsp.geometry_mode &= ~clear;
-    rsp.geometry_mode |= set;
+    g_rsp.geometry_mode &= ~clear;
+    g_rsp.geometry_mode |= set;
 }
 
 static void gfx_sp_extra_geometry_mode(uint32_t clear, uint32_t set) {
-    rsp.extra_geometry_mode &= ~clear;
-    rsp.extra_geometry_mode |= set;
+    g_rsp.extra_geometry_mode &= ~clear;
+    g_rsp.extra_geometry_mode |= set;
 }
 
 static void gfx_adjust_viewport_or_scissor(XYWidthHeight* area) {
@@ -1812,14 +1721,14 @@ static void gfx_calc_and_set_viewport(const Vp_t* viewport) {
     float x = (viewport->vtrans[0] / 4.0f) - width / 2.0f;
     float y = ((viewport->vtrans[1] / 4.0f) + height / 2.0f);
 
-    rdp.viewport.x = x;
-    rdp.viewport.y = y;
-    rdp.viewport.width = width;
-    rdp.viewport.height = height;
+    g_rdp.viewport.x = x;
+    g_rdp.viewport.y = y;
+    g_rdp.viewport.width = width;
+    g_rdp.viewport.height = height;
 
-    gfx_adjust_viewport_or_scissor(&rdp.viewport);
+    gfx_adjust_viewport_or_scissor(&g_rdp.viewport);
 
-    rdp.viewport_or_scissor_changed = true;
+    g_rdp.viewport_or_scissor_changed = true;
 }
 
 static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) {
@@ -1830,8 +1739,8 @@ static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) {
 #if 0
         case G_MV_LOOKATY:
         case G_MV_LOOKATX:
-            memcpy(rsp.current_lookat + (index - G_MV_LOOKATY) / 2, data, sizeof(Light_t));
-            //rsp.lights_changed = 1;
+            memcpy(g_rsp.current_lookat + (index - G_MV_LOOKATY) / 2, data, sizeof(Light_t));
+            //g_rsp.lights_changed = 1;
             break;
 #endif
 #ifdef F3DEX_GBI_2
@@ -1839,9 +1748,9 @@ static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) {
             int lightidx = offset / 24 - 2;
             if (lightidx >= 0 && lightidx <= MAX_LIGHTS) { // skip lookat
                 // NOTE: reads out of bounds if it is an ambient light
-                memcpy(rsp.current_lights + lightidx, data, sizeof(Light_t));
+                memcpy(g_rsp.current_lights + lightidx, data, sizeof(Light_t));
             } else if (lightidx < 0) {
-                memcpy(rsp.lookat + offset / 24, data, sizeof(Light_t));
+                memcpy(g_rsp.lookat + offset / 24, data, sizeof(Light_t));
             }
             break;
         }
@@ -1850,7 +1759,7 @@ static void gfx_sp_movemem(uint8_t index, uint8_t offset, const void* data) {
         case G_MV_L1:
         case G_MV_L2:
             // NOTE: reads out of bounds if it is an ambient light
-            memcpy(rsp.current_lights + (index - G_MV_L0) / 2, data, sizeof(Light_t));
+            memcpy(g_rsp.current_lights + (index - G_MV_L0) / 2, data, sizeof(Light_t));
             break;
 #endif
     }
@@ -1860,34 +1769,34 @@ static void gfx_sp_moveword(uint8_t index, uint16_t offset, uintptr_t data) {
     switch (index) {
         case G_MW_NUMLIGHT:
 #ifdef F3DEX_GBI_2
-            rsp.current_num_lights = data / 24 + 1; // add ambient light
+            g_rsp.current_num_lights = data / 24 + 1; // add ambient light
 #else
             // Ambient light is included
             // The 31th bit is a flag that lights should be recalculated
-            rsp.current_num_lights = (data - 0x80000000U) / 32;
+            g_rsp.current_num_lights = (data - 0x80000000U) / 32;
 #endif
-            rsp.lights_changed = 1;
+            g_rsp.lights_changed = 1;
             break;
         case G_MW_FOG:
-            rsp.fog_mul = (int16_t)(data >> 16);
-            rsp.fog_offset = (int16_t)data;
+            g_rsp.fog_mul = (int16_t)(data >> 16);
+            g_rsp.fog_offset = (int16_t)data;
             break;
         case G_MW_SEGMENT:
             int segNumber = offset / 4;
-            segmentPointers[segNumber] = data;
+            gSegmentPointers[segNumber] = data;
             break;
     }
 }
 
 static void gfx_sp_texture(uint16_t sc, uint16_t tc, uint8_t level, uint8_t tile, uint8_t on) {
-    rsp.texture_scaling_factor.s = sc;
-    rsp.texture_scaling_factor.t = tc;
-    if (rdp.first_tile_index != tile) {
-        rdp.textures_changed[0] = true;
-        rdp.textures_changed[1] = true;
+    g_rsp.texture_scaling_factor.s = sc;
+    g_rsp.texture_scaling_factor.t = tc;
+    if (g_rdp.first_tile_index != tile) {
+        g_rdp.textures_changed[0] = true;
+        g_rdp.textures_changed[1] = true;
     }
 
-    rdp.first_tile_index = tile;
+    g_rdp.first_tile_index = tile;
 }
 
 static void gfx_dp_set_scissor(uint32_t mode, uint32_t ulx, uint32_t uly, uint32_t lrx, uint32_t lry) {
@@ -1896,23 +1805,25 @@ static void gfx_dp_set_scissor(uint32_t mode, uint32_t ulx, uint32_t uly, uint32
     float width = (lrx - ulx) / 4.0f;
     float height = (lry - uly) / 4.0f;
 
-    rdp.scissor.x = x;
-    rdp.scissor.y = y;
-    rdp.scissor.width = width;
-    rdp.scissor.height = height;
+    g_rdp.scissor.x = x;
+    g_rdp.scissor.y = y;
+    g_rdp.scissor.width = width;
+    g_rdp.scissor.height = height;
 
-    gfx_adjust_viewport_or_scissor(&rdp.scissor);
+    gfx_adjust_viewport_or_scissor(&g_rdp.scissor);
 
-    rdp.viewport_or_scissor_changed = true;
+    g_rdp.viewport_or_scissor_changed = true;
 }
 
 static void gfx_dp_set_texture_image(uint32_t format, uint32_t size, uint32_t width, const char* texPath,
                                      uint32_t texFlags, RawTexMetadata rawTexMetdata, const void* addr) {
-    rdp.texture_to_load.addr = (const uint8_t*)addr;
-    rdp.texture_to_load.siz = size;
-    rdp.texture_to_load.width = width;
-    rdp.texture_to_load.tex_flags = texFlags;
-    rdp.texture_to_load.raw_tex_metadata = rawTexMetdata;
+    // fprintf(stderr, "gfx_dp_set_texture_image: %s (width=%d; size=0x%X)\n",
+    //         rawTexMetdata.resource ? rawTexMetdata.resource->GetInitData()->Path.c_str() : nullptr, width, size);
+    g_rdp.texture_to_load.addr = (const uint8_t*)addr;
+    g_rdp.texture_to_load.siz = size;
+    g_rdp.texture_to_load.width = width;
+    g_rdp.texture_to_load.tex_flags = texFlags;
+    g_rdp.texture_to_load.raw_tex_metadata = rawTexMetdata;
 }
 
 static void gfx_dp_set_tile(uint8_t fmt, uint32_t siz, uint32_t line, uint32_t tmem, uint8_t tile, uint32_t palette,
@@ -1928,50 +1839,48 @@ static void gfx_dp_set_tile(uint8_t fmt, uint32_t siz, uint32_t line, uint32_t t
         cmt = G_TX_CLAMP;
     }
 
-    rdp.texture_tile[tile].palette = palette; // palette should set upper 4 bits of color index in 4b mode
-    rdp.texture_tile[tile].fmt = fmt;
-    rdp.texture_tile[tile].siz = siz;
-    rdp.texture_tile[tile].cms = cms;
-    rdp.texture_tile[tile].cmt = cmt;
-    rdp.texture_tile[tile].shifts = shifts;
-    rdp.texture_tile[tile].shiftt = shiftt;
-    rdp.texture_tile[tile].line_size_bytes = line * 8;
+    g_rdp.texture_tile[tile].palette = palette; // palette should set upper 4 bits of color index in 4b mode
+    g_rdp.texture_tile[tile].fmt = fmt;
+    g_rdp.texture_tile[tile].siz = siz;
+    g_rdp.texture_tile[tile].cms = cms;
+    g_rdp.texture_tile[tile].cmt = cmt;
+    g_rdp.texture_tile[tile].shifts = shifts;
+    g_rdp.texture_tile[tile].shiftt = shiftt;
+    g_rdp.texture_tile[tile].line_size_bytes = line * 8;
 
-    if (rdp.texture_tile[tile].line_size_bytes > 15000) {
-        int bp = 0;
-    }
+    g_rdp.texture_tile[tile].tmem = tmem;
+    // g_rdp.texture_tile[tile].tmem_index = tmem / 256; // tmem is the 64-bit word offset, so 256 words means 2 kB
 
-    rdp.texture_tile[tile].tmem = tmem;
-    // rdp.texture_tile[tile].tmem_index = tmem / 256; // tmem is the 64-bit word offset, so 256 words means 2 kB
-    rdp.texture_tile[tile].tmem_index =
+    g_rdp.texture_tile[tile].tmem_index =
         tmem != 0; // assume one texture is loaded at address 0 and another texture at any other address
-    rdp.textures_changed[0] = true;
-    rdp.textures_changed[1] = true;
+
+    g_rdp.textures_changed[0] = true;
+    g_rdp.textures_changed[1] = true;
 }
 
 static void gfx_dp_set_tile_size(uint8_t tile, uint16_t uls, uint16_t ult, uint16_t lrs, uint16_t lrt) {
-    rdp.texture_tile[tile].uls = uls;
-    rdp.texture_tile[tile].ult = ult;
-    rdp.texture_tile[tile].lrs = lrs;
-    rdp.texture_tile[tile].lrt = lrt;
-    rdp.textures_changed[0] = true;
-    rdp.textures_changed[1] = true;
+    g_rdp.texture_tile[tile].uls = uls;
+    g_rdp.texture_tile[tile].ult = ult;
+    g_rdp.texture_tile[tile].lrs = lrs;
+    g_rdp.texture_tile[tile].lrt = lrt;
+    g_rdp.textures_changed[0] = true;
+    g_rdp.textures_changed[1] = true;
 }
 
 static void gfx_dp_load_tlut(uint8_t tile, uint32_t high_index) {
     SUPPORT_CHECK(tile == G_TX_LOADTILE);
-    SUPPORT_CHECK(rdp.texture_to_load.siz == G_IM_SIZ_16b);
-
-    SUPPORT_CHECK((rdp.texture_tile[tile].tmem == 256 && (high_index <= 127 || high_index == 255)) ||
-                  (rdp.texture_tile[tile].tmem == 384 && high_index == 127));
+    SUPPORT_CHECK(g_rdp.texture_to_load.siz == G_IM_SIZ_16b);
+    // BENTODO
+    // SUPPORT_CHECK((g_rdp.texture_tile[tile].tmem == 256 && (high_index <= 127 || high_index == 255)) ||
+    //              (g_rdp.texture_tile[tile].tmem == 384 && high_index == 127));
 
-    if (rdp.texture_tile[tile].tmem == 256) {
-        rdp.palettes[0] = rdp.texture_to_load.addr;
+    if (g_rdp.texture_tile[tile].tmem == 256) {
+        g_rdp.palettes[0] = g_rdp.texture_to_load.addr;
         if (high_index == 255) {
-            rdp.palettes[1] = rdp.texture_to_load.addr + 2 * 128;
+            g_rdp.palettes[1] = g_rdp.texture_to_load.addr + 2 * 128;
         }
     } else {
-        rdp.palettes[1] = rdp.texture_to_load.addr;
+        g_rdp.palettes[1] = g_rdp.texture_to_load.addr;
     }
 }
 
@@ -1982,9 +1891,9 @@ static void gfx_dp_load_block(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t
 
     // The lrs field rather seems to be number of pixels to load
     uint32_t word_size_shift = 0;
-    switch (rdp.texture_to_load.siz) {
+    switch (g_rdp.texture_to_load.siz) {
         case G_IM_SIZ_4b:
-            word_size_shift = 0; // Or -1? It's unused in SM64 anyway.
+            word_size_shift = -1;
             break;
         case G_IM_SIZ_8b:
             word_size_shift = 0;
@@ -1996,44 +1905,48 @@ static void gfx_dp_load_block(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t
             word_size_shift = 2;
             break;
     }
-    uint32_t orig_size_bytes = (lrs + 1) << word_size_shift;
+    uint32_t orig_size_bytes =
+        word_size_shift > 0 ? (lrs + 1) << word_size_shift : (lrs + 1) >> (-(int64_t)word_size_shift);
     uint32_t size_bytes = orig_size_bytes;
-    if (rdp.texture_to_load.raw_tex_metadata.h_byte_scale != 1 ||
-        rdp.texture_to_load.raw_tex_metadata.v_pixel_scale != 1) {
-        size_bytes *= rdp.texture_to_load.raw_tex_metadata.h_byte_scale;
-        size_bytes *= rdp.texture_to_load.raw_tex_metadata.v_pixel_scale;
-    }
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes = orig_size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes = size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes = size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes = size_bytes;
+    if (g_rdp.texture_to_load.raw_tex_metadata.h_byte_scale != 1 ||
+        g_rdp.texture_to_load.raw_tex_metadata.v_pixel_scale != 1) {
+        size_bytes *= g_rdp.texture_to_load.raw_tex_metadata.h_byte_scale;
+        size_bytes *= g_rdp.texture_to_load.raw_tex_metadata.v_pixel_scale;
+    }
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes = orig_size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes = size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes = size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes = size_bytes;
     // assert(size_bytes <= 4096 && "bug: too big texture");
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].tex_flags = rdp.texture_to_load.tex_flags;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata = rdp.texture_to_load.raw_tex_metadata;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr = rdp.texture_to_load.addr;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].tex_flags = g_rdp.texture_to_load.tex_flags;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata = g_rdp.texture_to_load.raw_tex_metadata;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr = g_rdp.texture_to_load.addr;
+    // fprintf(stderr, "gfx_dp_load_block: line_size = 0x%x; orig = 0x%x; bpp=%d; lrs=%d\n", size_bytes,
+    // orig_size_bytes,
+    //         g_rdp.texture_to_load.siz, lrs);
 
     const std::string& texPath =
-        rdp.texture_to_load.raw_tex_metadata.resource != nullptr
-            ? gfx_get_base_texture_path(rdp.texture_to_load.raw_tex_metadata.resource->GetInitData()->Path)
+        g_rdp.texture_to_load.raw_tex_metadata.resource != nullptr
+            ? gfx_get_base_texture_path(g_rdp.texture_to_load.raw_tex_metadata.resource->GetInitData()->Path)
             : "";
     auto maskedTextureIter = masked_textures.find(texPath);
     if (maskedTextureIter != masked_textures.end()) {
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].masked = true;
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].blended =
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].masked = true;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].blended =
             maskedTextureIter->second.replacementData != nullptr;
     } else {
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].masked = false;
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].blended = false;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].masked = false;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].blended = false;
     }
 
-    rdp.textures_changed[rdp.texture_tile[tile].tmem_index] = true;
+    g_rdp.textures_changed[g_rdp.texture_tile[tile].tmem_index] = true;
 }
 
 static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t lrs, uint32_t lrt) {
     SUPPORT_CHECK(tile == G_TX_LOADTILE);
 
     uint32_t word_size_shift = 0;
-    switch (rdp.texture_to_load.siz) {
+    switch (g_rdp.texture_to_load.siz) {
         case G_IM_SIZ_4b:
             word_size_shift = 0;
             break;
@@ -2052,7 +1965,7 @@ static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t
     uint32_t offset_y = ult >> G_TEXTURE_IMAGE_FRAC;
     uint32_t tile_width = ((lrs - uls) >> G_TEXTURE_IMAGE_FRAC) + 1;
     uint32_t tile_height = ((lrt - ult) >> G_TEXTURE_IMAGE_FRAC) + 1;
-    uint32_t full_image_width = rdp.texture_to_load.width + 1;
+    uint32_t full_image_width = g_rdp.texture_to_load.width + 1;
 
     uint32_t offset_x_in_bytes = offset_x << word_size_shift;
     uint32_t tile_line_size_bytes = tile_width << word_size_shift;
@@ -2062,8 +1975,8 @@ static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t
     uint32_t size_bytes = orig_size_bytes;
     uint32_t start_offset_bytes = full_image_line_size_bytes * offset_y + offset_x_in_bytes;
 
-    float h_byte_scale = rdp.texture_to_load.raw_tex_metadata.h_byte_scale;
-    float v_pixel_scale = rdp.texture_to_load.raw_tex_metadata.v_pixel_scale;
+    float h_byte_scale = g_rdp.texture_to_load.raw_tex_metadata.h_byte_scale;
+    float v_pixel_scale = g_rdp.texture_to_load.raw_tex_metadata.v_pixel_scale;
 
     if (h_byte_scale != 1 || v_pixel_scale != 1) {
         start_offset_bytes = h_byte_scale * (v_pixel_scale * offset_y * full_image_line_size_bytes + offset_x_in_bytes);
@@ -2072,36 +1985,36 @@ static void gfx_dp_load_tile(uint8_t tile, uint32_t uls, uint32_t ult, uint32_t
         tile_line_size_bytes *= h_byte_scale;
     }
 
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes = orig_size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].size_bytes = size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes = full_image_line_size_bytes;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].line_size_bytes = tile_line_size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes = orig_size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].size_bytes = size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].full_image_line_size_bytes = full_image_line_size_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].line_size_bytes = tile_line_size_bytes;
 
     //    assert(size_bytes <= 4096 && "bug: too big texture");
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].tex_flags = rdp.texture_to_load.tex_flags;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata = rdp.texture_to_load.raw_tex_metadata;
-    rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].addr = rdp.texture_to_load.addr + start_offset_bytes;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].tex_flags = g_rdp.texture_to_load.tex_flags;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].raw_tex_metadata = g_rdp.texture_to_load.raw_tex_metadata;
+    g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].addr = g_rdp.texture_to_load.addr + start_offset_bytes;
 
     const std::string& texPath =
-        rdp.texture_to_load.raw_tex_metadata.resource != nullptr
-            ? gfx_get_base_texture_path(rdp.texture_to_load.raw_tex_metadata.resource->GetInitData()->Path)
+        g_rdp.texture_to_load.raw_tex_metadata.resource != nullptr
+            ? gfx_get_base_texture_path(g_rdp.texture_to_load.raw_tex_metadata.resource->GetInitData()->Path)
             : "";
     auto maskedTextureIter = masked_textures.find(texPath);
     if (maskedTextureIter != masked_textures.end()) {
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].masked = true;
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].blended =
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].masked = true;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].blended =
             maskedTextureIter->second.replacementData != nullptr;
     } else {
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].masked = false;
-        rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].blended = false;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].masked = false;
+        g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].blended = false;
     }
 
-    rdp.texture_tile[tile].uls = uls;
-    rdp.texture_tile[tile].ult = ult;
-    rdp.texture_tile[tile].lrs = lrs;
-    rdp.texture_tile[tile].lrt = lrt;
+    g_rdp.texture_tile[tile].uls = uls;
+    g_rdp.texture_tile[tile].ult = ult;
+    g_rdp.texture_tile[tile].lrs = lrs;
+    g_rdp.texture_tile[tile].lrt = lrt;
 
-    rdp.textures_changed[rdp.texture_tile[tile].tmem_index] = true;
+    g_rdp.textures_changed[g_rdp.texture_tile[tile].tmem_index] = true;
 }
 
 /*static uint8_t color_comb_component(uint32_t v) {
@@ -2133,11 +2046,11 @@ static inline uint32_t color_comb(uint32_t a, uint32_t b, uint32_t c, uint32_t d
 }
 
 static void gfx_dp_set_combine_mode(uint32_t rgb, uint32_t alpha) {
-    rdp.combine_mode = rgb | (alpha << 12);
+    g_rdp.combine_mode = rgb | (alpha << 12);
 }*/
 
 static void gfx_dp_set_combine_mode(uint32_t rgb, uint32_t alpha, uint32_t rgb_cyc2, uint32_t alpha_cyc2) {
-    rdp.combine_mode = rgb | (alpha << 16) | ((uint64_t)rgb_cyc2 << 28) | ((uint64_t)alpha_cyc2 << 44);
+    g_rdp.combine_mode = rgb | (alpha << 16) | ((uint64_t)rgb_cyc2 << 28) | ((uint64_t)alpha_cyc2 << 44);
 }
 
 static inline uint32_t color_comb(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
@@ -2149,32 +2062,32 @@ static inline uint32_t alpha_comb(uint32_t a, uint32_t b, uint32_t c, uint32_t d
 }
 
 static void gfx_dp_set_grayscale_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
-    rdp.grayscale_color.r = r;
-    rdp.grayscale_color.g = g;
-    rdp.grayscale_color.b = b;
-    rdp.grayscale_color.a = a;
+    g_rdp.grayscale_color.r = r;
+    g_rdp.grayscale_color.g = g;
+    g_rdp.grayscale_color.b = b;
+    g_rdp.grayscale_color.a = a;
 }
 
 static void gfx_dp_set_env_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
-    rdp.env_color.r = r;
-    rdp.env_color.g = g;
-    rdp.env_color.b = b;
-    rdp.env_color.a = a;
+    g_rdp.env_color.r = r;
+    g_rdp.env_color.g = g;
+    g_rdp.env_color.b = b;
+    g_rdp.env_color.a = a;
 }
 
 static void gfx_dp_set_prim_color(uint8_t m, uint8_t l, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
-    rdp.prim_lod_fraction = l;
-    rdp.prim_color.r = r;
-    rdp.prim_color.g = g;
-    rdp.prim_color.b = b;
-    rdp.prim_color.a = a;
+    g_rdp.prim_lod_fraction = l;
+    g_rdp.prim_color.r = r;
+    g_rdp.prim_color.g = g;
+    g_rdp.prim_color.b = b;
+    g_rdp.prim_color.a = a;
 }
 
 static void gfx_dp_set_fog_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
-    rdp.fog_color.r = r;
-    rdp.fog_color.g = g;
-    rdp.fog_color.b = b;
-    rdp.fog_color.a = a;
+    g_rdp.fog_color.r = r;
+    g_rdp.fog_color.g = g;
+    g_rdp.fog_color.b = b;
+    g_rdp.fog_color.a = a;
 }
 
 static void gfx_dp_set_fill_color(uint32_t packed_color) {
@@ -2183,18 +2096,18 @@ static void gfx_dp_set_fill_color(uint32_t packed_color) {
     uint32_t g = (col16 >> 6) & 0x1f;
     uint32_t b = (col16 >> 1) & 0x1f;
     uint32_t a = col16 & 1;
-    rdp.fill_color.r = SCALE_5_8(r);
-    rdp.fill_color.g = SCALE_5_8(g);
-    rdp.fill_color.b = SCALE_5_8(b);
-    rdp.fill_color.a = a * 255;
+    g_rdp.fill_color.r = SCALE_5_8(r);
+    g_rdp.fill_color.g = SCALE_5_8(g);
+    g_rdp.fill_color.b = SCALE_5_8(b);
+    g_rdp.fill_color.a = a * 255;
 }
 
 static void gfx_draw_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) {
-    uint32_t saved_other_mode_h = rdp.other_mode_h;
-    uint32_t cycle_type = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE));
+    uint32_t saved_other_mode_h = g_rdp.other_mode_h;
+    uint32_t cycle_type = (g_rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE));
 
     if (cycle_type == G_CYC_COPY) {
-        rdp.other_mode_h = (rdp.other_mode_h & ~(3U << G_MDSFT_TEXTFILT)) | G_TF_POINT;
+        g_rdp.other_mode_h = (g_rdp.other_mode_h & ~(3U << G_MDSFT_TEXTFILT)) | G_TF_POINT;
     }
 
     // U10.2 coordinates
@@ -2211,10 +2124,10 @@ static void gfx_draw_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lr
     ulxf = gfx_adjust_x_for_aspect_ratio(ulxf);
     lrxf = gfx_adjust_x_for_aspect_ratio(lrxf);
 
-    struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0];
-    struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1];
-    struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2];
-    struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3];
+    struct LoadedVertex* ul = &g_rsp.loaded_vertices[MAX_VERTICES + 0];
+    struct LoadedVertex* ll = &g_rsp.loaded_vertices[MAX_VERTICES + 1];
+    struct LoadedVertex* lr = &g_rsp.loaded_vertices[MAX_VERTICES + 2];
+    struct LoadedVertex* ur = &g_rsp.loaded_vertices[MAX_VERTICES + 3];
 
     ul->x = ulxf;
     ul->y = ulyf;
@@ -2238,32 +2151,32 @@ static void gfx_draw_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lr
 
     // The coordinates for texture rectangle shall bypass the viewport setting
     struct XYWidthHeight default_viewport = { 0, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT };
-    struct XYWidthHeight viewport_saved = rdp.viewport;
-    uint32_t geometry_mode_saved = rsp.geometry_mode;
+    struct XYWidthHeight viewport_saved = g_rdp.viewport;
+    uint32_t geometry_mode_saved = g_rsp.geometry_mode;
 
     gfx_adjust_viewport_or_scissor(&default_viewport);
 
-    rdp.viewport = default_viewport;
-    rdp.viewport_or_scissor_changed = true;
-    rsp.geometry_mode = 0;
+    g_rdp.viewport = default_viewport;
+    g_rdp.viewport_or_scissor_changed = true;
+    g_rsp.geometry_mode = 0;
 
     gfx_sp_tri1(MAX_VERTICES + 0, MAX_VERTICES + 1, MAX_VERTICES + 3, true);
     gfx_sp_tri1(MAX_VERTICES + 1, MAX_VERTICES + 2, MAX_VERTICES + 3, true);
 
-    rsp.geometry_mode = geometry_mode_saved;
-    rdp.viewport = viewport_saved;
-    rdp.viewport_or_scissor_changed = true;
+    g_rsp.geometry_mode = geometry_mode_saved;
+    g_rdp.viewport = viewport_saved;
+    g_rdp.viewport_or_scissor_changed = true;
 
     if (cycle_type == G_CYC_COPY) {
-        rdp.other_mode_h = saved_other_mode_h;
+        g_rdp.other_mode_h = saved_other_mode_h;
     }
 }
 
 static void gfx_dp_texture_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry, uint8_t tile, int16_t uls,
                                      int16_t ult, int16_t dsdx, int16_t dtdy, bool flip) {
     // printf("render %d at %d\n", tile, lrx);
-    uint64_t saved_combine_mode = rdp.combine_mode;
-    if ((rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_COPY) {
+    uint64_t saved_combine_mode = g_rdp.combine_mode;
+    if ((g_rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE)) == G_CYC_COPY) {
         // Per RDP Command Summary Set Tile's shift s and this dsdx should be set to 4 texels
         // Divide by 4 to get 1 instead
         dsdx >>= 2;
@@ -2289,10 +2202,10 @@ static void gfx_dp_texture_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int3
     float lrs = ((uls << 7) + dsdx * width) >> 7;
     float lrt = ((ult << 7) + dtdy * height) >> 7;
 
-    struct LoadedVertex* ul = &rsp.loaded_vertices[MAX_VERTICES + 0];
-    struct LoadedVertex* ll = &rsp.loaded_vertices[MAX_VERTICES + 1];
-    struct LoadedVertex* lr = &rsp.loaded_vertices[MAX_VERTICES + 2];
-    struct LoadedVertex* ur = &rsp.loaded_vertices[MAX_VERTICES + 3];
+    struct LoadedVertex* ul = &g_rsp.loaded_vertices[MAX_VERTICES + 0];
+    struct LoadedVertex* ll = &g_rsp.loaded_vertices[MAX_VERTICES + 1];
+    struct LoadedVertex* lr = &g_rsp.loaded_vertices[MAX_VERTICES + 2];
+    struct LoadedVertex* ur = &g_rsp.loaded_vertices[MAX_VERTICES + 3];
     ul->u = uls;
     ul->v = ult;
     lr->u = lrs;
@@ -2309,28 +2222,28 @@ static void gfx_dp_texture_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int3
         ur->v = lrt;
     }
 
-    uint8_t saved_tile = rdp.first_tile_index;
+    uint8_t saved_tile = g_rdp.first_tile_index;
     if (saved_tile != tile) {
-        rdp.textures_changed[0] = true;
-        rdp.textures_changed[1] = true;
+        g_rdp.textures_changed[0] = true;
+        g_rdp.textures_changed[1] = true;
     }
-    rdp.first_tile_index = tile;
+    g_rdp.first_tile_index = tile;
 
     gfx_draw_rectangle(ulx, uly, lrx, lry);
     if (saved_tile != tile) {
-        rdp.textures_changed[0] = true;
-        rdp.textures_changed[1] = true;
+        g_rdp.textures_changed[0] = true;
+        g_rdp.textures_changed[1] = true;
     }
-    rdp.first_tile_index = saved_tile;
-    rdp.combine_mode = saved_combine_mode;
+    g_rdp.first_tile_index = saved_tile;
+    g_rdp.combine_mode = saved_combine_mode;
 }
 
 static void gfx_dp_fill_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t lry) {
-    if (rdp.color_image_address == rdp.z_buf_address) {
+    if (g_rdp.color_image_address == g_rdp.z_buf_address) {
         // Don't clear Z buffer here since we already did it with glClear
         return;
     }
-    uint32_t mode = (rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE));
+    uint32_t mode = (g_rdp.other_mode_h & (3U << G_MDSFT_CYCLETYPE));
 
     // OTRTODO: This is a bit of a hack for widescreen screen fades, but it'll work for now...
     if (ulx == 0 && uly == 0 && lrx == (319 * 4) && lry == (239 * 4)) {
@@ -2347,39 +2260,39 @@ static void gfx_dp_fill_rectangle(int32_t ulx, int32_t uly, int32_t lrx, int32_t
     }
 
     for (int i = MAX_VERTICES; i < MAX_VERTICES + 4; i++) {
-        struct LoadedVertex* v = &rsp.loaded_vertices[i];
-        v->color = rdp.fill_color;
+        struct LoadedVertex* v = &g_rsp.loaded_vertices[i];
+        v->color = g_rdp.fill_color;
     }
 
-    uint64_t saved_combine_mode = rdp.combine_mode;
+    uint64_t saved_combine_mode = g_rdp.combine_mode;
 
     if (mode == G_CYC_FILL) {
         gfx_dp_set_combine_mode(color_comb(0, 0, 0, G_CCMUX_SHADE), alpha_comb(0, 0, 0, G_ACMUX_SHADE), 0, 0);
     }
 
     gfx_draw_rectangle(ulx, uly, lrx, lry);
-    rdp.combine_mode = saved_combine_mode;
+    g_rdp.combine_mode = saved_combine_mode;
 }
 
 static void gfx_dp_set_z_image(void* z_buf_address) {
-    rdp.z_buf_address = z_buf_address;
+    g_rdp.z_buf_address = z_buf_address;
 }
 
 static void gfx_dp_set_color_image(uint32_t format, uint32_t size, uint32_t width, void* address) {
-    rdp.color_image_address = address;
+    g_rdp.color_image_address = address;
 }
 
 static void gfx_sp_set_other_mode(uint32_t shift, uint32_t num_bits, uint64_t mode) {
     uint64_t mask = (((uint64_t)1 << num_bits) - 1) << shift;
-    uint64_t om = rdp.other_mode_l | ((uint64_t)rdp.other_mode_h << 32);
+    uint64_t om = g_rdp.other_mode_l | ((uint64_t)g_rdp.other_mode_h << 32);
     om = (om & ~mask) | mode;
-    rdp.other_mode_l = (uint32_t)om;
-    rdp.other_mode_h = (uint32_t)(om >> 32);
+    g_rdp.other_mode_l = (uint32_t)om;
+    g_rdp.other_mode_h = (uint32_t)(om >> 32);
 }
 
 static void gfx_dp_set_other_mode(uint32_t h, uint32_t l) {
-    rdp.other_mode_h = h;
-    rdp.other_mode_l = l;
+    g_rdp.other_mode_h = h;
+    g_rdp.other_mode_l = l;
 }
 
 static void gfx_s2dex_bg_copy(uObjBg* bg) {
@@ -2442,10 +2355,9 @@ static inline void* seg_addr(uintptr_t w1) {
         uint32_t segNum = (w1 >> 24);
 
         uint32_t offset = w1 & 0x00FFFFFE;
-        // offset = 0; // Cursed Malon bug
 
-        if (segmentPointers[segNum] != 0) {
-            return (void*)(segmentPointers[segNum] + offset);
+        if (gSegmentPointers[segNum] != 0) {
+            return (void*)(gSegmentPointers[segNum] + offset);
         } else {
             return (void*)w1;
         }
@@ -2459,612 +2371,725 @@ static inline void* seg_addr(uintptr_t w1) {
 
 uintptr_t clearMtx;
 
-static void gfx_run_dl(Gfx* cmd) {
-    // puts("dl");
-    int dummy = 0;
-    char dlName[128];
-    const char* fileName;
+void GfxExecStack::start(Gfx* dlist) {
+    while (!cmd_stack.empty())
+        cmd_stack.pop();
+    gfx_path.clear();
+    cmd_stack.push(dlist);
+    disp_stack.clear();
+    start_dlist = dlist;
+}
+
+void GfxExecStack::stop() {
+    while (!cmd_stack.empty())
+        cmd_stack.pop();
+    gfx_path.clear();
+}
 
-    Gfx* dListStart = cmd;
-    uint64_t ourHash = -1;
+Gfx*& GfxExecStack::currCmd() {
+    return cmd_stack.top();
+}
 
-    for (;;) {
-        uint32_t opcode = cmd->words.w0 >> 24;
-        // uint32_t opcode = cmd->words.w0 & 0xFF;
+void GfxExecStack::openDisp(const char* file, int line) {
+    disp_stack.push_back({ file, line });
+}
 
-        // if (markerOn)
-        // printf("OP: %02X\n", opcode);
+void GfxExecStack::closeDisp() {
+    disp_stack.pop_back();
+}
 
-        switch (opcode) {
-                // RSP commands:
-            case G_LOAD_UCODE:
-                rsp.fog_mul = 0;
-                rsp.fog_offset = 0;
-                break;
-            case G_MARKER: {
-                cmd++;
+const std::vector<GfxExecStack::CodeDisp>& GfxExecStack::getDisp() const {
+    return disp_stack;
+}
 
-                ourHash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+void GfxExecStack::branch(Gfx* caller) {
+    Gfx* old = cmd_stack.top();
+    cmd_stack.pop();
+    cmd_stack.push(nullptr);
+    cmd_stack.push(old);
 
-#if _DEBUG
-                // uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
-                // ResourceMgr_GetNameByCRC(hash, dlName);
-                // lusprintf(__FILE__, __LINE__, 6, "G_MARKER: %s\n", dlName);
-#endif
+    gfx_path.push(caller);
+}
 
-                markerOn = true;
-            } break;
-            case G_INVALTEXCACHE: {
-                uintptr_t texAddr = cmd->words.w1;
+void GfxExecStack::call(Gfx* caller, Gfx* callee) {
+    cmd_stack.push(callee);
+    gfx_path.push(caller);
+}
 
-                if (texAddr == 0) {
-                    gfx_texture_cache_clear();
-                } else {
-                    gfx_texture_cache_delete((const uint8_t*)texAddr);
+Gfx* GfxExecStack::ret() {
+    Gfx* cmd = cmd_stack.top();
+
+    cmd_stack.pop();
+
+    if (!gfx_path.empty()) {
+        gfx_path.pop();
+    }
+
+    while (cmd_stack.size() > 0 && cmd_stack.top() == nullptr) {
+        cmd_stack.pop();
+        gfx_path.pop();
+    }
+    return cmd;
+}
+
+bool GfxPath::operator==(const GfxPath& other) const {
+    if (path.size() != other.path.size())
+        return false;
+
+    for (size_t i = 0; i < path.size(); i++) {
+        if (path[i] != other.path[i])
+            return false;
+    }
+
+    return true;
+}
+
+void GfxPath::push(const Gfx* cmd) {
+    path.push_back(cmd);
+}
+
+void GfxPath::pop() {
+    assert(!path.empty());
+    path.pop_back();
+}
+
+void GfxPath::clear() {
+    path.clear();
+}
+
+bool GfxPath::empty() const {
+    return path.empty();
+}
+
+std::string GfxPath::string() const {
+    std::string bp = "";
+    for (auto& gfx : path) {
+        bp += fmt::format("/{}", (const void*)gfx);
+    }
+    return bp;
+}
+
+static void gfx_step(GfxExecStack& exec_stack) {
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+    auto& cmd = exec_stack.currCmd();
+    auto cmd0 = cmd;
+    uint32_t opcode = cmd->words.w0 >> 24;
+
+    // if (markerOn)
+    // printf("OP: %016X\n", cmd0->force_structure_alignment);
+
+    switch (opcode) {
+            // RSP commands:
+        case G_LOAD_UCODE:
+            g_rsp.fog_mul = 0;
+            g_rsp.fog_offset = 0;
+            break;
+        case G_MARKER: {
+            cmd++;
+
+            {
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                std::string dlName = ResourceGetNameByCrc(hash);
+                if (!GfxDebuggerIsDebugging() && dbg->HasBreakOnDlist(dlName)) {
+                    GfxDebuggerRequestDebugging();
+                    exec_stack.stop();
+                    return;
                 }
-            } break;
-            case G_NOOP:
-                break;
-            case G_MTX: {
-                uintptr_t mtxAddr = cmd->words.w1;
-
-                if (mtxAddr == SEG_ADDR(0, 0x12DB20) || // GC MQ D
-                    mtxAddr == SEG_ADDR(0, 0x12DB40) || // GC NMQ D
-                    mtxAddr == SEG_ADDR(0, 0xFBC20) ||  // GC PAL
-                    mtxAddr == SEG_ADDR(0, 0xFBC01) ||  // GC MQ PAL
-                    mtxAddr == SEG_ADDR(0, 0xFCD00) ||  // PAL1.0
-                    mtxAddr == SEG_ADDR(0, 0xFCD40)     // PAL1.1
-                ) {
-                    mtxAddr = clearMtx;
+            }
+
+            markerOn = true;
+        } break;
+        case G_INVALTEXCACHE: {
+            uintptr_t texAddr = cmd->words.w1;
+
+            if (texAddr == 0) {
+                gfx_texture_cache_clear();
+            } else {
+                gfx_texture_cache_delete((const uint8_t*)texAddr);
+            }
+        } break;
+        case G_NOOP: {
+            const char* filename = (const char*)cmd->words.w1;
+            uint32_t p = C0(16, 8);
+            uint32_t l = C0(0, 16);
+            if (p == 7) {
+                exec_stack.openDisp(filename, l);
+            } else if (p == 8) {
+                if (exec_stack.disp_stack.size() == 0) {
+                    SPDLOG_WARN("CLOSE_DISPS without matching open {}:{}", p, l);
+                } else {
+                    exec_stack.closeDisp();
                 }
+            }
+        } break;
+        case G_MTX: {
+            uintptr_t mtxAddr = cmd->words.w1;
+
+            if (mtxAddr == SEG_ADDR(0, 0x12DB20) || // GC MQ D
+                mtxAddr == SEG_ADDR(0, 0x12DB40) || // GC NMQ D
+                mtxAddr == SEG_ADDR(0, 0xFBC20) ||  // GC PAL
+                mtxAddr == SEG_ADDR(0, 0xFBC01) ||  // GC MQ PAL
+                mtxAddr == SEG_ADDR(0, 0xFCD00) ||  // PAL1.0
+                mtxAddr == SEG_ADDR(0, 0xFCD40)     // PAL1.1
+            ) {
+                mtxAddr = clearMtx;
+            }
 
 #ifdef F3DEX_GBI_2
-                gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, (const int32_t*)seg_addr(mtxAddr));
+            gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, (const int32_t*)seg_addr(mtxAddr));
 #else
-                gfx_sp_matrix(C0(16, 8), (const int32_t*)seg_addr(cmd->words.w1));
+            gfx_sp_matrix(C0(16, 8), (const int32_t*)seg_addr(cmd->words.w1));
 #endif
-                break;
-            }
-            case G_MTX_OTR: {
-                cmd++;
+            break;
+        }
+        case G_MTX_OTR: {
+            cmd++;
 
-                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+            uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
 
-                int32_t* mtx = (int32_t*)ResourceGetDataByCrc(hash);
+            int32_t* mtx = (int32_t*)ResourceGetDataByCrc(hash);
 
 #ifdef F3DEX_GBI_2
-                if (mtx != NULL) {
-                    cmd--;
-                    gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, mtx);
-                    cmd++;
-                }
+            if (mtx != NULL) {
+                cmd--;
+                gfx_sp_matrix(C0(0, 8) ^ G_MTX_PUSH, mtx);
+                cmd++;
+            }
 #else
-                gfx_sp_matrix(C0(16, 8), (const int32_t*)seg_addr(cmd->words.w1));
+            gfx_sp_matrix(C0(16, 8), (const int32_t*)seg_addr(cmd->words.w1));
 #endif
-                break;
-            }
-            case (uint8_t)G_POPMTX:
+            break;
+        }
+        case (uint8_t)G_POPMTX:
 #ifdef F3DEX_GBI_2
-                gfx_sp_pop_matrix(cmd->words.w1 / 64);
+            gfx_sp_pop_matrix(cmd->words.w1 / 64);
 #else
-                gfx_sp_pop_matrix(1);
+            gfx_sp_pop_matrix(1);
 #endif
-                break;
-            case G_MOVEMEM:
+            break;
+        case G_MOVEMEM:
 #ifdef F3DEX_GBI_2
-                gfx_sp_movemem(C0(0, 8), C0(8, 8) * 8, seg_addr(cmd->words.w1));
+            gfx_sp_movemem(C0(0, 8), C0(8, 8) * 8, seg_addr(cmd->words.w1));
 #else
-                gfx_sp_movemem(C0(16, 8), 0, seg_addr(cmd->words.w1));
+            gfx_sp_movemem(C0(16, 8), 0, seg_addr(cmd->words.w1));
 #endif
-                break;
-            case (uint8_t)G_MOVEWORD:
+            break;
+        case (uint8_t)G_MOVEWORD:
 #ifdef F3DEX_GBI_2
-                gfx_sp_moveword(C0(16, 8), C0(0, 16), cmd->words.w1);
+            gfx_sp_moveword(C0(16, 8), C0(0, 16), cmd->words.w1);
 #else
-                gfx_sp_moveword(C0(0, 8), C0(8, 16), cmd->words.w1);
+            gfx_sp_moveword(C0(0, 8), C0(8, 16), cmd->words.w1);
 #endif
-                break;
-            case (uint8_t)G_TEXTURE:
+            break;
+        case (uint8_t)G_TEXTURE:
 #ifdef F3DEX_GBI_2
-                gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(1, 7));
+            gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(1, 7));
 #else
-                gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(0, 8));
+            gfx_sp_texture(C1(16, 16), C1(0, 16), C0(11, 3), C0(8, 3), C0(0, 8));
 #endif
-                break;
-            case G_VTX:
+            break;
+        case G_VTX:
 #ifdef F3DEX_GBI_2
-                gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), (const Vtx*)seg_addr(cmd->words.w1));
+            gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), (const Vtx*)seg_addr(cmd->words.w1));
 #elif defined(F3DEX_GBI) || defined(F3DLP_GBI)
-                gfx_sp_vertex(C0(10, 6), C0(16, 8) / 2, seg_addr(cmd->words.w1));
+            gfx_sp_vertex(C0(10, 6), C0(16, 8) / 2, seg_addr(cmd->words.w1));
 #else
-                gfx_sp_vertex((C0(0, 16)) / sizeof(Vtx), C0(16, 4), seg_addr(cmd->words.w1));
+            gfx_sp_vertex((C0(0, 16)) / sizeof(Vtx), C0(16, 4), seg_addr(cmd->words.w1));
 #endif
-                break;
-            case G_VTX_OTR_HASH: {
-                // Offset added to the start of the vertices
-                uintptr_t offset = cmd->words.w1;
-                // This is a two-part display list command, so increment the instruction pointer so we can get the CRC64
-                // hash from the second
+            break;
+        case G_VTX_OTR_HASH: {
+            // Offset added to the start of the vertices
+            uintptr_t offset = cmd->words.w1;
+            // This is a two-part display list command, so increment the instruction pointer so we can get the CRC64
+            // hash from the second
+            cmd++;
+            uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+
+            // We need to know if the offset is a cached pointer or not. An offset greater than one million is not a
+            // real offset, so it must be a real pointer
+            if (offset > 0xFFFFF) {
+                cmd--;
+                gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), (Vtx*)offset);
                 cmd++;
-                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
-
-                // We need to know if the offset is a cached pointer or not. An offset greater than one million is not a
-                // real offset, so it must be a real pointer
-                if (offset > 0xFFFFF) {
-                    cmd--;
-                    gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), (Vtx*)offset);
-                    cmd++;
-                } else {
-                    Vtx* vtx = (Vtx*)ResourceGetDataByCrc(hash);
+            } else {
+                Vtx* vtx = (Vtx*)ResourceGetDataByCrc(hash);
 
-                    if (vtx != NULL) {
-                        vtx = (Vtx*)((char*)vtx + offset);
+                if (vtx != NULL) {
+                    vtx = (Vtx*)((char*)vtx + offset);
 
-                        cmd--;
+                    cmd--;
 
-                        if (ourHash != (uint64_t)-1) {
-                            auto res = ResourceLoad(ourHash);
-                        }
+                    // if (ourHash != (uint64_t)-1) {
+                    //     auto res = ResourceLoad(ourHash);
+                    // }
 
-                        cmd->words.w1 = (uintptr_t)vtx;
+                    // TODO: WTF??
+                    cmd->words.w1 = (uintptr_t)vtx;
 
-                        gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), vtx);
-                        cmd++;
-                    }
+                    gfx_sp_vertex(C0(12, 8), C0(1, 7) - C0(12, 8), vtx);
+                    cmd++;
                 }
-            } break;
-            case G_VTX_OTR_FILEPATH: {
-                char* fileName = (char*)cmd->words.w1;
+            }
+        } break;
+        case G_VTX_OTR_FILEPATH: {
+            char* fileName = (char*)cmd->words.w1;
+            cmd++;
+            int vtxCnt = cmd->words.w0;
+            int vtxIdxOff = cmd->words.w1 >> 16;
+            int vtxDataOff = cmd->words.w1 & 0xFFFF;
+            Vtx* vtx = (Vtx*)ResourceGetDataByName((const char*)fileName);
+            vtx += vtxDataOff;
+            cmd--;
+
+            gfx_sp_vertex(vtxCnt, vtxIdxOff, vtx);
+        } break;
+        case G_DL_OTR_FILEPATH: {
+            char* fileName = (char*)cmd->words.w1;
+            Gfx* nDL = (Gfx*)ResourceGetDataByName((const char*)fileName);
+
+            if (C0(16, 1) == 0 && nDL != nullptr) {
                 cmd++;
-                int vtxCnt = cmd->words.w0;
-                int vtxIdxOff = cmd->words.w1 >> 16;
-                int vtxDataOff = cmd->words.w1 & 0xFFFF;
-                Vtx* vtx = (Vtx*)ResourceGetDataByName((const char*)fileName);
-                vtx += vtxDataOff;
-                cmd--;
-
-                gfx_sp_vertex(vtxCnt, vtxIdxOff, vtx);
-            } break;
-            case G_DL_OTR_FILEPATH: {
-                fileName = (char*)cmd->words.w1;
-                Gfx* nDL = (Gfx*)ResourceGetDataByName((const char*)fileName);
-
-                if (C0(16, 1) == 0 && nDL != nullptr) {
-                    // Push return address
-                    currentDir.push((char*)fileName);
-                    gfx_run_dl(nDL);
-                    currentDir.pop();
+                exec_stack.call(cmd0, nDL);
+            } else {
+                if (nDL != nullptr) {
+                    cmd = nDL;
+                    exec_stack.branch(cmd0);
                 } else {
-                    if (nDL != nullptr) {
-                        cmd = nDL;
-                    } else {
-                        return;
-                    }
-                    --cmd; // increase after break
+                    assert(0 && "???");
+                    // gfx_path.pop();
+                    // cmd = cmd_stack.top();
+                    // cmd_stack.pop();
                 }
-            } break;
-            case G_MODIFYVTX:
-                gfx_sp_modify_vertex(C0(1, 15), C0(16, 8), cmd->words.w1);
-                break;
-            case G_DL:
-                if (C0(16, 1) == 0) {
-                    // Push return address
-                    Gfx* subGFX = (Gfx*)seg_addr(cmd->words.w1);
-
-                    if (subGFX != nullptr) {
-                        gfx_run_dl(subGFX);
-                    }
-                } else {
-                    cmd = (Gfx*)seg_addr(cmd->words.w1);
-                    --cmd; // increase after break
+            }
+            return; // shortcut cmd increment
+        } break;
+        case G_MODIFYVTX:
+            gfx_sp_modify_vertex(C0(1, 15), C0(16, 8), cmd->words.w1);
+            break;
+        case G_DL: {
+            Gfx* subGFX = (Gfx*)seg_addr(cmd->words.w1);
+            if (C0(16, 1) == 0) {
+                // Push return address
+                if (subGFX != nullptr) {
+                    cmd++;
+                    exec_stack.call(cmd0, subGFX);
                 }
-                break;
-            case G_DL_OTR_HASH:
-                if (C0(16, 1) == 0) {
-                    // Push return address
+            } else {
+                cmd = subGFX;
+                exec_stack.branch(cmd0);
+            }
+            return; // shortcut cmd increment
+        }
+        case G_DL_OTR_HASH:
+            if (C0(16, 1) == 0) {
+                // Push return address
 
-                    cmd++;
+                cmd++;
 
-                    uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
 
 #if _DEBUG
-                    // char fileName[4096];
-                    // ResourceMgr_GetNameByCRC(hash, fileName);
+                // char fileName[4096];
+                // ResourceMgr_GetNameByCRC(hash, fileName);
 
-                    // printf("G_DL_OTR: %s\n", fileName);
+                // printf("G_DL_OTR: %s\n", fileName);
 #endif
 
-                    Gfx* gfx = (Gfx*)ResourceGetDataByCrc(hash);
+                Gfx* gfx = (Gfx*)ResourceGetDataByCrc(hash);
 
-                    if (gfx != 0) {
-                        gfx_run_dl(gfx);
-                    }
-                } else {
-                    cmd = (Gfx*)seg_addr(cmd->words.w1);
+                if (gfx != 0) {
+                    cmd++;
+                    exec_stack.call(cmd0, gfx);
                 }
-                break;
-            case G_PUSHCD:
-                gfx_push_current_dir((char*)cmd->words.w1);
-                break;
-            case G_BRANCH_Z_OTR: {
-                // Push return address
+            } else {
+                assert(0 && "????");
+                cmd = (Gfx*)seg_addr(cmd->words.w1);
+            }
+            return;
+        case G_PUSHCD:
+            gfx_push_current_dir((char*)cmd->words.w1);
+            break;
+        case G_BRANCH_Z_OTR: {
+            // Push return address
 
-                uint8_t vbidx = cmd->words.w0 & 0x00000FFF;
-                uint32_t zval = cmd->words.w1;
+            uint8_t vbidx = cmd->words.w0 & 0x00000FFF;
+            uint32_t zval = cmd->words.w1;
 
-                cmd++;
+            cmd++;
 
-                if (rsp.loaded_vertices[vbidx].z <= zval) {
+            if (g_rsp.loaded_vertices[vbidx].z <= zval) {
 
-                    uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
 
 #if _DEBUG
-                    // char fileName[4096];
-                    // ResourceMgr_GetNameByCRC(hash, fileName);
+                // char fileName[4096];
+                // ResourceMgr_GetNameByCRC(hash, fileName);
 
-                    // printf("G_BRANCH_Z_OTR: %s\n", fileName);
+                // printf("G_BRANCH_Z_OTR: %s\n", fileName);
 #endif
 
-                    Gfx* gfx = (Gfx*)ResourceGetDataByCrc(hash);
+                Gfx* gfx = (Gfx*)ResourceGetDataByCrc(hash);
 
-                    if (gfx != 0) {
-                        cmd = gfx;
-                        --cmd; // increase after break
-                    }
+                if (gfx != 0) {
+                    cmd = gfx;
+                    return;
                 }
-            } break;
-            case (uint8_t)G_ENDDL:
+            }
+        } break;
+        case (uint8_t)G_ENDDL:
 
-                // if (markerOn)
-                // printf("END DL ON MARKER\n");
+            // if (markerOn)
+            // printf("END DL ON MARKER\n");
 
-                markerOn = false;
-                return;
+            markerOn = false;
+            cmd = exec_stack.ret();
+            return;
 #ifdef F3DEX_GBI_2
-            case G_GEOMETRYMODE:
-                gfx_sp_geometry_mode(~C0(0, 24), cmd->words.w1);
-                break;
+        case G_GEOMETRYMODE:
+            gfx_sp_geometry_mode(~C0(0, 24), cmd->words.w1);
+            break;
 #else
-            case (uint8_t)G_SETGEOMETRYMODE:
-                gfx_sp_geometry_mode(0, cmd->words.w1);
-                break;
-            case (uint8_t)G_CLEARGEOMETRYMODE:
-                gfx_sp_geometry_mode(cmd->words.w1, 0);
-                break;
+        case (uint8_t)G_SETGEOMETRYMODE:
+            gfx_sp_geometry_mode(0, cmd->words.w1);
+            break;
+        case (uint8_t)G_CLEARGEOMETRYMODE:
+            gfx_sp_geometry_mode(cmd->words.w1, 0);
+            break;
 #endif
-            case (uint8_t)G_TRI1_OTR: {
-                int v00 = cmd->words.w0 & 0x0000FFFF;
-                int v01 = cmd->words.w1 >> 16;
-                int v02 = cmd->words.w1 & 0x0000FFFF;
-                gfx_sp_tri1(v00, v01, v02, false);
-            } break;
-            case (uint8_t)G_TRI1:
+        case (uint8_t)G_TRI1_OTR: {
+            int v00 = cmd->words.w0 & 0x0000FFFF;
+            int v01 = cmd->words.w1 >> 16;
+            int v02 = cmd->words.w1 & 0x0000FFFF;
+            gfx_sp_tri1(v00, v01, v02, false);
+        } break;
+        case (uint8_t)G_TRI1:
 #ifdef F3DEX_GBI_2
-                gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2, false);
+            gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2, false);
 #elif defined(F3DEX_GBI) || defined(F3DLP_GBI)
-                gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2, false);
+            gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2, false);
 #else
-                gfx_sp_tri1(C1(16, 8) / 10, C1(8, 8) / 10, C1(0, 8) / 10, false);
+            gfx_sp_tri1(C1(16, 8) / 10, C1(8, 8) / 10, C1(0, 8) / 10, false);
 #endif
-                break;
+            break;
 #ifdef F3DEX_GBI_2
-            case G_QUAD: {
-                [[fallthrough]];
-            }
+        case G_QUAD: {
+            [[fallthrough]];
+        }
 #endif
 #if defined(F3DEX_GBI) || defined(F3DLP_GBI)
-            case (uint8_t)G_TRI2:
-                gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2, false);
-                gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2, false);
-                break;
+        case (uint8_t)G_TRI2:
+            gfx_sp_tri1(C0(16, 8) / 2, C0(8, 8) / 2, C0(0, 8) / 2, false);
+            gfx_sp_tri1(C1(16, 8) / 2, C1(8, 8) / 2, C1(0, 8) / 2, false);
+            break;
 #endif
-            case (uint8_t)G_SETOTHERMODE_L:
+        case (uint8_t)G_SETOTHERMODE_L:
 #ifdef F3DEX_GBI_2
-                gfx_sp_set_other_mode(31 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, cmd->words.w1);
+            gfx_sp_set_other_mode(31 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, cmd->words.w1);
 #else
-                gfx_sp_set_other_mode(C0(8, 8), C0(0, 8), cmd->words.w1);
+            gfx_sp_set_other_mode(C0(8, 8), C0(0, 8), cmd->words.w1);
 #endif
-                break;
-            case (uint8_t)G_SETOTHERMODE_H:
+            break;
+        case (uint8_t)G_SETOTHERMODE_H:
 #ifdef F3DEX_GBI_2
-                gfx_sp_set_other_mode(63 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, (uint64_t)cmd->words.w1 << 32);
+            gfx_sp_set_other_mode(63 - C0(8, 8) - C0(0, 8), C0(0, 8) + 1, (uint64_t)cmd->words.w1 << 32);
 #else
-                gfx_sp_set_other_mode(C0(8, 8) + 32, C0(0, 8), (uint64_t)cmd->words.w1 << 32);
+            gfx_sp_set_other_mode(C0(8, 8) + 32, C0(0, 8), (uint64_t)cmd->words.w1 << 32);
 #endif
-                break;
+            break;
 
-            // RDP Commands:
-            case G_SETTIMG: {
-                uintptr_t i = (uintptr_t)seg_addr(cmd->words.w1);
-
-                char* imgData = (char*)i;
-                uint32_t texFlags = 0;
-                RawTexMetadata rawTexMetdata = {};
-
-                if ((i & 1) != 1) {
-                    if (gfx_check_image_signature(imgData) == 1) {
-                        std::shared_ptr<LUS::Texture> tex = std::static_pointer_cast<LUS::Texture>(
-                            LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(imgData));
-
-                        i = (uintptr_t) reinterpret_cast<char*>(tex->ImageData);
-                        texFlags = tex->Flags;
-                        rawTexMetdata.width = tex->Width;
-                        rawTexMetdata.height = tex->Height;
-                        rawTexMetdata.h_byte_scale = tex->HByteScale;
-                        rawTexMetdata.v_pixel_scale = tex->VPixelScale;
-                        rawTexMetdata.type = tex->Type;
-                        rawTexMetdata.resource = tex;
-                    }
+        // RDP Commands:
+        case G_SETTIMG: {
+            uintptr_t i = (uintptr_t)seg_addr(cmd->words.w1);
+
+            char* imgData = (char*)i;
+            uint32_t texFlags = 0;
+            RawTexMetadata rawTexMetdata = {};
+
+            if ((i & 1) != 1) {
+                if (gfx_check_image_signature(imgData) == 1) {
+                    std::shared_ptr<LUS::Texture> tex = std::static_pointer_cast<LUS::Texture>(
+                        LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(imgData));
+
+                    i = (uintptr_t) reinterpret_cast<char*>(tex->ImageData);
+                    texFlags = tex->Flags;
+                    rawTexMetdata.width = tex->Width;
+                    rawTexMetdata.height = tex->Height;
+                    rawTexMetdata.h_byte_scale = tex->HByteScale;
+                    rawTexMetdata.v_pixel_scale = tex->VPixelScale;
+                    rawTexMetdata.type = tex->Type;
+                    rawTexMetdata.resource = tex;
                 }
-
-                gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), imgData, texFlags, rawTexMetdata, (void*)i);
-                break;
             }
-            case G_SETTIMG_OTR_HASH: {
-                uintptr_t addr = cmd->words.w1;
-                cmd++;
-                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + (uint64_t)cmd->words.w1;
-
-                fileName = ResourceGetNameByCrc(hash);
-                uint32_t texFlags = 0;
-                RawTexMetadata rawTexMetadata = {};
-
-                std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
-                    LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(ResourceGetNameByCrc(hash)));
-                if (texture != nullptr) {
-                    texFlags = texture->Flags;
-                    rawTexMetadata.width = texture->Width;
-                    rawTexMetadata.height = texture->Height;
-                    rawTexMetadata.h_byte_scale = texture->HByteScale;
-                    rawTexMetadata.v_pixel_scale = texture->VPixelScale;
-                    rawTexMetadata.type = texture->Type;
-                    rawTexMetadata.resource = texture;
-
-#if _DEBUG && 0
-                    tex = reinterpret_cast<char*>(texture->imageData);
-                    ResourceMgr_GetNameByCRC(hash, fileName);
-                    printf("G_SETTIMG_OTR_HASH: %s, %08X\n", fileName, hash);
-#else
-                    char* tex = NULL;
-#endif
-
-                    // OTRTODO: We have disabled caching for now to fix a texture corruption issue with HD texture
-                    // support. In doing so, there is a potential performance hit since we are not caching lookups. We
-                    // need to do proper profiling to see whether or not it is worth it to keep the caching system.
-
-                    tex = reinterpret_cast<char*>(texture->ImageData);
-
-                    if (tex != nullptr) {
-                        cmd--;
-                        uintptr_t oldData = cmd->words.w1;
-                        cmd->words.w1 = (uintptr_t)tex;
-
-                        if (ourHash != (uint64_t)-1) {
-                            auto res = ResourceLoad(ourHash);
-                        }
-
-                        cmd++;
-                    }
 
+            gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), imgData, texFlags, rawTexMetdata, (void*)i);
+            break;
+        }
+        case G_SETTIMG_OTR_HASH: {
+            uintptr_t addr = cmd->words.w1;
+            cmd++;
+            uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + (uint64_t)cmd->words.w1;
+
+            const char* fileName = ResourceGetNameByCrc(hash);
+            uint32_t texFlags = 0;
+            RawTexMetadata rawTexMetadata = {};
+
+            std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
+                LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(ResourceGetNameByCrc(hash)));
+            if (texture != nullptr) {
+                texFlags = texture->Flags;
+                rawTexMetadata.width = texture->Width;
+                rawTexMetadata.height = texture->Height;
+                rawTexMetadata.h_byte_scale = texture->HByteScale;
+                rawTexMetadata.v_pixel_scale = texture->VPixelScale;
+                rawTexMetadata.type = texture->Type;
+                rawTexMetadata.resource = texture;
+
+                // #if _DEBUG && 0
+                // tex = reinterpret_cast<char*>(texture->imageData);
+                // ResourceMgr_GetNameByCRC(hash, fileName);
+                // fprintf(stderr, "G_SETTIMG_OTR_HASH: %s (%dx%d) size=0x%x, %08X\n", fileName, texture->Width,
+                //         texture->Height, texture->ImageDataSize, hash);
+                // #else
+                char* tex = NULL;
+                // #endif
+
+                // OTRTODO: We have disabled caching for now to fix a texture corruption issue with HD texture
+                // support. In doing so, there is a potential performance hit since we are not caching lookups. We
+                // need to do proper profiling to see whether or not it is worth it to keep the caching system.
+
+                tex = reinterpret_cast<char*>(texture->ImageData);
+
+                if (tex != nullptr) {
                     cmd--;
+                    uintptr_t oldData = cmd->words.w1;
+                    // TODO: wtf??
+                    cmd->words.w1 = (uintptr_t)tex;
 
-                    uint32_t fmt = C0(21, 3);
-                    uint32_t size = C0(19, 2);
-                    uint32_t width = C0(0, 10);
+                    // if (ourHash != (uint64_t)-1) {
+                    //     auto res = ResourceLoad(ourHash);
+                    // }
 
-                    if (tex != NULL) {
-                        gfx_dp_set_texture_image(fmt, size, width, fileName, texFlags, rawTexMetadata, tex);
-                    }
-                } else {
-                    SPDLOG_ERROR("G_SETTIMG_OTR_HASH: Texture is null");
+                    cmd++;
                 }
 
-                cmd++;
-                break;
-            }
-            case G_SETTIMG_OTR_FILEPATH: {
-                fileName = (char*)cmd->words.w1;
-
-                uint32_t texFlags = 0;
-                RawTexMetadata rawTexMetadata = {};
-
-                std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
-                    LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(fileName));
-                if (texture != nullptr) {
-                    texFlags = texture->Flags;
-                    rawTexMetadata.width = texture->Width;
-                    rawTexMetadata.height = texture->Height;
-                    rawTexMetadata.h_byte_scale = texture->HByteScale;
-                    rawTexMetadata.v_pixel_scale = texture->VPixelScale;
-                    rawTexMetadata.type = texture->Type;
-                    rawTexMetadata.resource = texture;
-
-                    uint32_t fmt = C0(21, 3);
-                    uint32_t size = C0(19, 2);
-                    uint32_t width = C0(0, 10);
-
-                    gfx_dp_set_texture_image(fmt, size, width, fileName, texFlags, rawTexMetadata,
-                                             reinterpret_cast<char*>(texture->ImageData));
-                } else {
-                    SPDLOG_ERROR("G_SETTIMG_OTR_FILEPATH: Texture is null");
+                cmd--;
+
+                uint32_t fmt = C0(21, 3);
+                uint32_t size = C0(19, 2);
+                uint32_t width = C0(0, 10);
+
+                if (tex != NULL) {
+                    gfx_dp_set_texture_image(fmt, size, width, fileName, texFlags, rawTexMetadata, tex);
                 }
-                break;
-            }
-            case G_SETFB: {
-                gfx_flush();
-                fbActive = 1;
-                active_fb = framebuffers.find(cmd->words.w1);
-                gfx_rapi->start_draw_to_framebuffer(active_fb->first, (float)active_fb->second.applied_height /
-                                                                          active_fb->second.orig_height);
-                gfx_rapi->clear_framebuffer();
-                break;
-            }
-            case G_RESETFB: {
-                gfx_flush();
-                fbActive = 0;
-                gfx_rapi->start_draw_to_framebuffer(game_renders_to_framebuffer ? game_framebuffer : 0,
-                                                    (float)gfx_current_dimensions.height / SCREEN_HEIGHT);
-                break;
+            } else {
+                SPDLOG_ERROR("G_SETTIMG_OTR_HASH: Texture is null");
             }
-            case G_SETTIMG_FB: {
-                gfx_flush();
-                gfx_rapi->select_texture_fb(cmd->words.w1);
-                rdp.textures_changed[0] = false;
-                rdp.textures_changed[1] = false;
 
-                // if (texPtr != NULL)
-                // gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), texPtr);
-                break;
-            }
-            case G_SETGRAYSCALE: {
-                rdp.grayscale = cmd->words.w1;
-                break;
+            cmd++;
+            break;
+        }
+        case G_SETTIMG_OTR_FILEPATH: {
+            const char* fileName = (char*)cmd->words.w1;
+
+            uint32_t texFlags = 0;
+            RawTexMetadata rawTexMetadata = {};
+
+            std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
+                LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(fileName));
+            if (texture != nullptr) {
+                texFlags = texture->Flags;
+                rawTexMetadata.width = texture->Width;
+                rawTexMetadata.height = texture->Height;
+                rawTexMetadata.h_byte_scale = texture->HByteScale;
+                rawTexMetadata.v_pixel_scale = texture->VPixelScale;
+                rawTexMetadata.type = texture->Type;
+                rawTexMetadata.resource = texture;
+
+                uint32_t fmt = C0(21, 3);
+                uint32_t size = C0(19, 2);
+                uint32_t width = C0(0, 10);
+
+                gfx_dp_set_texture_image(fmt, size, width, fileName, texFlags, rawTexMetadata,
+                                         reinterpret_cast<char*>(texture->ImageData));
+            } else {
+                SPDLOG_ERROR("G_SETTIMG_OTR_FILEPATH: Texture is null");
             }
-            case G_LOADBLOCK:
-                gfx_dp_load_block(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
-                break;
-            case G_LOADTILE:
-                gfx_dp_load_tile(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
-                break;
-            case G_SETTILE:
-                gfx_dp_set_tile(C0(21, 3), C0(19, 2), C0(9, 9), C0(0, 9), C1(24, 3), C1(20, 4), C1(18, 2), C1(14, 4),
-                                C1(10, 4), C1(8, 2), C1(4, 4), C1(0, 4));
-                break;
-            case G_SETTILESIZE:
-                gfx_dp_set_tile_size(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
-                break;
-            case G_LOADTLUT:
-                gfx_dp_load_tlut(C1(24, 3), C1(14, 10));
-                break;
-            case G_SETENVCOLOR:
-                gfx_dp_set_env_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
-                break;
-            case G_SETPRIMCOLOR:
-                gfx_dp_set_prim_color(C0(8, 8), C0(0, 8), C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
-                break;
-            case G_SETFOGCOLOR:
-                gfx_dp_set_fog_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
-                break;
-            case G_SETFILLCOLOR:
-                gfx_dp_set_fill_color(cmd->words.w1);
-                break;
-            case G_SETINTENSITY:
-                gfx_dp_set_grayscale_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
-                break;
-            case G_SETCOMBINE:
-                gfx_dp_set_combine_mode(color_comb(C0(20, 4), C1(28, 4), C0(15, 5), C1(15, 3)),
-                                        alpha_comb(C0(12, 3), C1(12, 3), C0(9, 3), C1(9, 3)),
-                                        color_comb(C0(5, 4), C1(24, 4), C0(0, 5), C1(6, 3)),
-                                        alpha_comb(C1(21, 3), C1(3, 3), C1(18, 3), C1(0, 3)));
-                break;
-            // G_SETPRIMCOLOR, G_CCMUX_PRIMITIVE, G_ACMUX_PRIMITIVE, is used by Goddard
-            // G_CCMUX_TEXEL1, LOD_FRACTION is used in Bowser room 1
-            case G_TEXRECT:
-            case G_TEXRECTFLIP: {
-                int32_t lrx, lry, tile, ulx, uly;
-                uint32_t uls, ult, dsdx, dtdy;
+            break;
+        }
+        case G_SETFB: {
+            gfx_flush();
+            fbActive = 1;
+            active_fb = framebuffers.find(cmd->words.w1);
+            gfx_rapi->start_draw_to_framebuffer(active_fb->first, (float)active_fb->second.applied_height /
+                                                                      active_fb->second.orig_height);
+            gfx_rapi->clear_framebuffer();
+            break;
+        }
+        case G_RESETFB: {
+            gfx_flush();
+            fbActive = 0;
+            gfx_rapi->start_draw_to_framebuffer(game_renders_to_framebuffer ? game_framebuffer : 0,
+                                                (float)gfx_current_dimensions.height / SCREEN_HEIGHT);
+            break;
+        }
+        case G_SETTIMG_FB: {
+            gfx_flush();
+            gfx_rapi->select_texture_fb(cmd->words.w1);
+            g_rdp.textures_changed[0] = false;
+            g_rdp.textures_changed[1] = false;
+
+            // if (texPtr != NULL)
+            // gfx_dp_set_texture_image(C0(21, 3), C0(19, 2), C0(0, 10), texPtr);
+            break;
+        }
+        case G_SETGRAYSCALE: {
+            g_rdp.grayscale = cmd->words.w1;
+            break;
+        }
+        case G_LOADBLOCK:
+            gfx_dp_load_block(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
+            break;
+        case G_LOADTILE:
+            gfx_dp_load_tile(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
+            break;
+        case G_SETTILE:
+            gfx_dp_set_tile(C0(21, 3), C0(19, 2), C0(9, 9), C0(0, 9), C1(24, 3), C1(20, 4), C1(18, 2), C1(14, 4),
+                            C1(10, 4), C1(8, 2), C1(4, 4), C1(0, 4));
+            break;
+        case G_SETTILESIZE:
+            gfx_dp_set_tile_size(C1(24, 3), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
+            break;
+        case G_LOADTLUT:
+            gfx_dp_load_tlut(C1(24, 3), C1(14, 10));
+            break;
+        case G_SETENVCOLOR:
+            gfx_dp_set_env_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
+            break;
+        case G_SETPRIMCOLOR:
+            gfx_dp_set_prim_color(C0(8, 8), C0(0, 8), C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
+            break;
+        case G_SETFOGCOLOR:
+            gfx_dp_set_fog_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
+            break;
+        case G_SETFILLCOLOR:
+            gfx_dp_set_fill_color(cmd->words.w1);
+            break;
+        case G_SETINTENSITY:
+            gfx_dp_set_grayscale_color(C1(24, 8), C1(16, 8), C1(8, 8), C1(0, 8));
+            break;
+        case G_SETCOMBINE:
+            gfx_dp_set_combine_mode(color_comb(C0(20, 4), C1(28, 4), C0(15, 5), C1(15, 3)),
+                                    alpha_comb(C0(12, 3), C1(12, 3), C0(9, 3), C1(9, 3)),
+                                    color_comb(C0(5, 4), C1(24, 4), C0(0, 5), C1(6, 3)),
+                                    alpha_comb(C1(21, 3), C1(3, 3), C1(18, 3), C1(0, 3)));
+            break;
+        // G_SETPRIMCOLOR, G_CCMUX_PRIMITIVE, G_ACMUX_PRIMITIVE, is used by Goddard
+        // G_CCMUX_TEXEL1, LOD_FRACTION is used in Bowser room 1
+        case G_TEXRECT:
+        case G_TEXRECTFLIP: {
+            int32_t lrx, lry, tile, ulx, uly;
+            uint32_t uls, ult, dsdx, dtdy;
 #ifdef F3DEX_GBI_2E
-                lrx = (int32_t)(C0(0, 24) << 8) >> 8;
-                lry = (int32_t)(C1(0, 24) << 8) >> 8;
-                tile = C1(24, 3);
-                ++cmd;
-                ulx = (int32_t)(C0(0, 24) << 8) >> 8;
-                uly = (int32_t)(C1(0, 24) << 8) >> 8;
-                ++cmd;
-                uls = C0(16, 16);
-                ult = C0(0, 16);
-                dsdx = C1(16, 16);
-                dtdy = C1(0, 16);
+            lrx = (int32_t)(C0(0, 24) << 8) >> 8;
+            lry = (int32_t)(C1(0, 24) << 8) >> 8;
+            tile = C1(24, 3);
+            ++cmd;
+            ulx = (int32_t)(C0(0, 24) << 8) >> 8;
+            uly = (int32_t)(C1(0, 24) << 8) >> 8;
+            ++cmd;
+            uls = C0(16, 16);
+            ult = C0(0, 16);
+            dsdx = C1(16, 16);
+            dtdy = C1(0, 16);
 #else
-                lrx = C0(12, 12);
-                lry = C0(0, 12);
-                tile = C1(24, 3);
-                ulx = C1(12, 12);
-                uly = C1(0, 12);
-                ++cmd;
-                uls = C1(16, 16);
-                ult = C1(0, 16);
-                ++cmd;
-                dsdx = C1(16, 16);
-                dtdy = C1(0, 16);
+            lrx = C0(12, 12);
+            lry = C0(0, 12);
+            tile = C1(24, 3);
+            ulx = C1(12, 12);
+            uly = C1(0, 12);
+            ++cmd;
+            uls = C1(16, 16);
+            ult = C1(0, 16);
+            ++cmd;
+            dsdx = C1(16, 16);
+            dtdy = C1(0, 16);
 #endif
-                gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, opcode == G_TEXRECTFLIP);
-                break;
-            }
-            case G_TEXRECT_WIDE: {
-                int32_t lrx, lry, tile, ulx, uly;
-                uint32_t uls, ult, dsdx, dtdy;
-                lrx = static_cast<int32_t>((C0(0, 24) << 8)) >> 8;
-                lry = static_cast<int32_t>((C1(0, 24) << 8)) >> 8;
-                tile = C1(24, 3);
-                ++cmd;
-                ulx = static_cast<int32_t>((C0(0, 24) << 8)) >> 8;
-                uly = static_cast<int32_t>((C1(0, 24) << 8)) >> 8;
-                ++cmd;
-                uls = C0(16, 16);
-                ult = C0(0, 16);
-                dsdx = C1(16, 16);
-                dtdy = C1(0, 16);
-                gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, opcode == G_TEXRECTFLIP);
-                break;
-            }
-            case G_FILLRECT:
+            gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, opcode == G_TEXRECTFLIP);
+            break;
+        }
+        case G_TEXRECT_WIDE: {
+            int32_t lrx, lry, tile, ulx, uly;
+            uint32_t uls, ult, dsdx, dtdy;
+            lrx = static_cast<int32_t>((C0(0, 24) << 8)) >> 8;
+            lry = static_cast<int32_t>((C1(0, 24) << 8)) >> 8;
+            tile = C1(24, 3);
+            ++cmd;
+            ulx = static_cast<int32_t>((C0(0, 24) << 8)) >> 8;
+            uly = static_cast<int32_t>((C1(0, 24) << 8)) >> 8;
+            ++cmd;
+            uls = C0(16, 16);
+            ult = C0(0, 16);
+            dsdx = C1(16, 16);
+            dtdy = C1(0, 16);
+            gfx_dp_texture_rectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy, opcode == G_TEXRECTFLIP);
+            break;
+        }
+        case G_FILLRECT:
 #ifdef F3DEX_GBI_2E
-            {
-                int32_t lrx, lry, ulx, uly;
-                lrx = (int32_t)(C0(0, 24) << 8) >> 8;
-                lry = (int32_t)(C1(0, 24) << 8) >> 8;
-                ++cmd;
-                ulx = (int32_t)(C0(0, 24) << 8) >> 8;
-                uly = (int32_t)(C1(0, 24) << 8) >> 8;
-                gfx_dp_fill_rectangle(ulx, uly, lrx, lry);
-                break;
-            }
+        {
+            int32_t lrx, lry, ulx, uly;
+            lrx = (int32_t)(C0(0, 24) << 8) >> 8;
+            lry = (int32_t)(C1(0, 24) << 8) >> 8;
+            ++cmd;
+            ulx = (int32_t)(C0(0, 24) << 8) >> 8;
+            uly = (int32_t)(C1(0, 24) << 8) >> 8;
+            gfx_dp_fill_rectangle(ulx, uly, lrx, lry);
+            break;
+        }
 #else
-                gfx_dp_fill_rectangle(C1(12, 12), C1(0, 12), C0(12, 12), C0(0, 12));
-                break;
-            case G_FILLWIDERECT: {
-                int32_t lrx, lry, ulx, uly;
-                lrx = (int32_t)(C0(0, 24) << 8) >> 8;
-                lry = (int32_t)(C1(0, 24) << 8) >> 8;
-                ++cmd;
-                ulx = (int32_t)(C0(0, 24) << 8) >> 8;
-                uly = (int32_t)(C1(0, 24) << 8) >> 8;
-                gfx_dp_fill_rectangle(ulx, uly, lrx, lry);
-                break;
-            }
+            gfx_dp_fill_rectangle(C1(12, 12), C1(0, 12), C0(12, 12), C0(0, 12));
+            break;
+        case G_FILLWIDERECT: {
+            int32_t lrx, lry, ulx, uly;
+            lrx = (int32_t)(C0(0, 24) << 8) >> 8;
+            lry = (int32_t)(C1(0, 24) << 8) >> 8;
+            ++cmd;
+            ulx = (int32_t)(C0(0, 24) << 8) >> 8;
+            uly = (int32_t)(C1(0, 24) << 8) >> 8;
+            gfx_dp_fill_rectangle(ulx, uly, lrx, lry);
+            break;
+        }
 #endif
-            case G_SETSCISSOR:
-                gfx_dp_set_scissor(C1(24, 2), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
-                break;
-            case G_SETZIMG:
-                gfx_dp_set_z_image(seg_addr(cmd->words.w1));
-                break;
-            case G_SETCIMG:
-                gfx_dp_set_color_image(C0(21, 3), C0(19, 2), C0(0, 11), seg_addr(cmd->words.w1));
-                break;
-            case G_RDPSETOTHERMODE:
-                gfx_dp_set_other_mode(C0(0, 24), cmd->words.w1);
-                break;
-                // S2DEX
-            case G_BG_COPY:
-                if (!markerOn) {
-                    gfx_s2dex_bg_copy((uObjBg*)cmd->words.w1); // not seg_addr here it seems
-                }
+        case G_SETSCISSOR:
+            gfx_dp_set_scissor(C1(24, 2), C0(12, 12), C0(0, 12), C1(12, 12), C1(0, 12));
+            break;
+        case G_SETZIMG:
+            gfx_dp_set_z_image(seg_addr(cmd->words.w1));
+            break;
+        case G_SETCIMG:
+            gfx_dp_set_color_image(C0(21, 3), C0(19, 2), C0(0, 11), seg_addr(cmd->words.w1));
+            break;
+        case G_RDPSETOTHERMODE:
+            gfx_dp_set_other_mode(C0(0, 24), cmd->words.w1);
+            break;
+            // S2DEX
+        case G_BG_COPY:
+            if (!markerOn) {
+                gfx_s2dex_bg_copy((uObjBg*)cmd->words.w1); // not seg_addr here it seems
+            }
 
-                break;
-            case G_EXTRAGEOMETRYMODE:
-                gfx_sp_extra_geometry_mode(~C0(0, 24), cmd->words.w1);
-                break;
-        }
-        ++cmd;
+            break;
+        case G_EXTRAGEOMETRYMODE:
+            gfx_sp_extra_geometry_mode(~C0(0, 24), cmd->words.w1);
+            break;
     }
+    ++cmd;
 }
 
 static void gfx_sp_reset() {
-    rsp.modelview_matrix_stack_size = 1;
-    rsp.current_num_lights = 2;
-    rsp.lights_changed = true;
+    g_rsp.modelview_matrix_stack_size = 1;
+    g_rsp.current_num_lights = 2;
+    g_rsp.lights_changed = true;
 }
 
 void gfx_get_dimensions(uint32_t* width, uint32_t* height, int32_t* posX, int32_t* posY) {
@@ -3092,7 +3117,7 @@ void gfx_init(struct GfxWindowManagerAPI* wapi, struct GfxRenderingAPI* rapi, co
     game_framebuffer_msaa_resolved = gfx_rapi->create_framebuffer();
 
     for (int i = 0; i < 16; i++) {
-        segmentPointers[i] = 0;
+        gSegmentPointers[i] = 0;
     }
 
     if (tex_upload_buffer == nullptr) {
@@ -3107,9 +3132,9 @@ void gfx_destroy(void) {
 
     // Texture cache and loaded textures store references to Resources which need to be unreferenced.
     gfx_texture_cache_clear();
-    rdp.texture_to_load.raw_tex_metadata.resource = nullptr;
-    rdp.loaded_texture[0].raw_tex_metadata.resource = nullptr;
-    rdp.loaded_texture[1].raw_tex_metadata.resource = nullptr;
+    g_rdp.texture_to_load.raw_tex_metadata.resource = nullptr;
+    g_rdp.loaded_texture[0].raw_tex_metadata.resource = nullptr;
+    g_rdp.loaded_texture[1].raw_tex_metadata.resource = nullptr;
 }
 
 struct GfxRenderingAPI* gfx_get_current_rendering_api(void) {
@@ -3167,6 +3192,8 @@ void gfx_start_frame(void) {
     fbActive = 0;
 }
 
+GfxExecStack g_exec_stack = {};
+
 void gfx_run(Gfx* commands, const std::unordered_map<Mtx*, MtxF>& mtx_replacements) {
     gfx_sp_reset();
 
@@ -3198,10 +3225,24 @@ void gfx_run(Gfx* commands, const std::unordered_map<Mtx*, MtxF>& mtx_replacemen
     gfx_rapi->start_draw_to_framebuffer(game_renders_to_framebuffer ? game_framebuffer : 0,
                                         (float)gfx_current_dimensions.height / SCREEN_HEIGHT);
     gfx_rapi->clear_framebuffer();
-    rdp.viewport_or_scissor_changed = true;
+    g_rdp.viewport_or_scissor_changed = true;
     rendering_state.viewport = {};
     rendering_state.scissor = {};
-    gfx_run_dl(commands);
+
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+    g_exec_stack.start(commands);
+    while (!g_exec_stack.cmd_stack.empty()) {
+        auto cmd = g_exec_stack.cmd_stack.top();
+
+        if (GfxDebuggerIsDebugging()) {
+            g_exec_stack.gfx_path.push(cmd);
+            if (dbg->HasBreakPoint(g_exec_stack.gfx_path)) {
+                break;
+            }
+            g_exec_stack.gfx_path.pop();
+        }
+        gfx_step(g_exec_stack);
+    }
     gfx_flush();
     gfxFramebuffer = 0;
     currentDir = std::stack<std::string>();
diff --git a/src/graphic/Fast3D/gfx_pc.h b/src/graphic/Fast3D/gfx_pc.h
index 8080a965c..bea331494 100644
--- a/src/graphic/Fast3D/gfx_pc.h
+++ b/src/graphic/Fast3D/gfx_pc.h
@@ -7,10 +7,15 @@
 #include <unordered_map>
 #include <list>
 #include <cstddef>
+#include <vector>
+#include <stack>
 
 #include "libultraship/libultra/gbi.h"
 #include "libultraship/libultra/types.h"
 
+#include "resource/type/Texture.h"
+#include "resource/Resource.h"
+
 // TODO figure out why changing these to 640x480 makes the game only render in a quarter of the window
 #define SCREEN_WIDTH 320
 #define SCREEN_HEIGHT 240
@@ -62,6 +67,148 @@ struct TextureCacheMapIter {
     TextureCacheMap::iterator it;
 };
 
+struct GfxPath {
+    std::vector<const Gfx*> path = {};
+
+    bool operator==(const GfxPath& other) const;
+
+    void push(const Gfx* cmd);
+    void pop();
+    void clear();
+    bool empty() const;
+    std::string string() const;
+};
+
+struct GfxExecStack {
+    // This is a dlist stack used to handle dlist calls.
+    std::stack<Gfx*> cmd_stack = {};
+    // This is also a dlist stack but a std::vector is used to make it possible
+    // to iterate on the elements.
+    // The purpose of this is to identify an instruction at a poin in time
+    // which would not be possible with just a Gfx* because a dlist can be called multiple times
+    // what we do instead is store the call path that leads to the instruction (including branches)
+    GfxPath gfx_path = {};
+    struct CodeDisp {
+        const char* file;
+        int line;
+    };
+    // stack for OpenDisp/CloseDisps
+    std::vector<CodeDisp> disp_stack;
+    Gfx* start_dlist;
+
+    void start(Gfx* dlist);
+    void stop();
+    Gfx*& currCmd();
+    void openDisp(const char* file, int line);
+    void closeDisp();
+    const std::vector<CodeDisp>& getDisp() const;
+    void branch(Gfx* caller);
+    void call(Gfx* caller, Gfx* callee);
+    Gfx* ret();
+};
+
+struct RGBA {
+    uint8_t r, g, b, a;
+};
+
+struct LoadedVertex {
+    float x, y, z, w;
+    float u, v;
+    struct RGBA color;
+    uint8_t clip_rej;
+};
+
+struct RawTexMetadata {
+    uint16_t width, height;
+    float h_byte_scale = 1, v_pixel_scale = 1;
+    std::shared_ptr<LUS::Texture> resource;
+    LUS::TextureType type;
+};
+
+#define MAX_BUFFERED 256
+// #define MAX_LIGHTS 2
+#define MAX_LIGHTS 32
+#define MAX_VERTICES 64
+
+struct RSP {
+    float modelview_matrix_stack[11][4][4];
+    uint8_t modelview_matrix_stack_size;
+
+    float MP_matrix[4][4];
+    float P_matrix[4][4];
+
+    Light_t lookat[2];
+    Light_t current_lights[MAX_LIGHTS + 1];
+    float current_lights_coeffs[MAX_LIGHTS][3];
+    float current_lookat_coeffs[2][3]; // lookat_x, lookat_y
+    uint8_t current_num_lights;        // includes ambient light
+    bool lights_changed;
+
+    uint32_t geometry_mode;
+    int16_t fog_mul, fog_offset;
+
+    uint32_t extra_geometry_mode;
+
+    struct {
+        // U0.16
+        uint16_t s, t;
+    } texture_scaling_factor;
+
+    struct LoadedVertex loaded_vertices[MAX_VERTICES + 4];
+};
+
+struct RDP {
+    const uint8_t* palettes[2];
+    struct {
+        const uint8_t* addr;
+        uint8_t siz;
+        uint32_t width;
+        uint32_t tex_flags;
+        struct RawTexMetadata raw_tex_metadata;
+    } texture_to_load;
+    struct {
+        const uint8_t* addr;
+        uint32_t orig_size_bytes;
+        uint32_t size_bytes;
+        uint32_t full_image_line_size_bytes;
+        uint32_t line_size_bytes;
+        uint32_t tex_flags;
+        struct RawTexMetadata raw_tex_metadata;
+        bool masked;
+        bool blended;
+    } loaded_texture[2];
+    struct {
+        uint8_t fmt;
+        uint8_t siz;
+        uint8_t cms, cmt;
+        uint8_t shifts, shiftt;
+        uint16_t uls, ult, lrs, lrt; // U10.2
+        uint16_t tmem;               // 0-511, in 64-bit word units
+        uint32_t line_size_bytes;
+        uint8_t palette;
+        uint8_t tmem_index; // 0 or 1 for offset 0 kB or offset 2 kB, respectively
+    } texture_tile[8];
+    bool textures_changed[2];
+
+    uint8_t first_tile_index;
+
+    uint32_t other_mode_l, other_mode_h;
+    uint64_t combine_mode;
+    bool grayscale;
+
+    uint8_t prim_lod_fraction;
+    struct RGBA env_color, prim_color, fog_color, fill_color, grayscale_color;
+    struct XYWidthHeight viewport, scissor;
+    bool viewport_or_scissor_changed;
+    void* z_buf_address;
+    void* color_image_address;
+};
+
+extern RDP g_rdp;
+extern RSP g_rsp;
+
+extern GfxExecStack g_exec_stack;
+
 extern "C" {
 
 extern struct GfxDimensions gfx_current_window_dimensions; // The dimensions of the window
diff --git a/src/public/bridge/gfxdebuggerbridge.cpp b/src/public/bridge/gfxdebuggerbridge.cpp
new file mode 100644
index 000000000..386449d34
--- /dev/null
+++ b/src/public/bridge/gfxdebuggerbridge.cpp
@@ -0,0 +1,16 @@
+#include "gfxdebuggerbridge.h"
+#include "Context.h"
+#include "debug/GfxDebugger.h"
+
+void GfxDebuggerRequestDebugging(void) {
+    LUS::Context::GetInstance()->GetGfxDebugger()->RequestDebugging();
+}
+bool GfxDebuggerIsDebugging(void) {
+    return LUS::Context::GetInstance()->GetGfxDebugger()->IsDebugging();
+}
+bool GfxDebuggerIsDebuggingRequested(void) {
+    return LUS::Context::GetInstance()->GetGfxDebugger()->IsDebuggingRequested();
+}
+void GfxDebuggerDebugDisplayList(void* cmds) {
+    LUS::Context::GetInstance()->GetGfxDebugger()->DebugDisplayList((Gfx*)cmds);
+}
diff --git a/src/public/bridge/gfxdebuggerbridge.h b/src/public/bridge/gfxdebuggerbridge.h
new file mode 100644
index 000000000..dc8488051
--- /dev/null
+++ b/src/public/bridge/gfxdebuggerbridge.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#ifndef GFXDEBUGGER_H
+#define GFXDEBUGGER_H
+
+#include "stdint.h"
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void GfxDebuggerRequestDebugging(void);
+bool GfxDebuggerIsDebugging(void);
+bool GfxDebuggerIsDebuggingRequested(void);
+void GfxDebuggerDebugDisplayList(void* cmds);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
diff --git a/src/resource/ResourceManager.cpp b/src/resource/ResourceManager.cpp
index 8c705f1cf..4aca2900f 100644
--- a/src/resource/ResourceManager.cpp
+++ b/src/resource/ResourceManager.cpp
@@ -59,7 +59,11 @@ bool ResourceManager::DidLoadSuccessfully() {
 }
 
 std::shared_ptr<File> ResourceManager::LoadFileProcess(const std::string& filePath) {
+    if (filePath == "objects/gameplay_keep/gPlayerAnim_link_normal_wait_free") {
+        int bp = 5;
+    }
     auto file = mArchive->LoadFile(filePath, true);
+    
     if (file != nullptr) {
         SPDLOG_TRACE("Loaded File {} on ResourceManager", file->Path);
     } else {
@@ -70,6 +74,9 @@ std::shared_ptr<File> ResourceManager::LoadFileProcess(const std::string& filePa
 
 std::shared_ptr<IResource> ResourceManager::LoadResourceProcess(const std::string& filePath, bool loadExact) {
     // Check for and remove the OTR signature
+    if (filePath == "misc/link_animation/gPlayerAnim_link_normal_wait_free_Data") {
+        int bp = 5;
+    }
     if (OtrSignatureCheck(filePath.c_str())) {
         const auto newFilePath = filePath.substr(7);
         return LoadResourceProcess(newFilePath);
@@ -163,6 +170,9 @@ std::shared_ptr<File> ResourceManager::LoadFile(const std::string& filePath) {
 
 std::shared_future<std::shared_ptr<IResource>> ResourceManager::LoadResourceAsync(const std::string& filePath,
                                                                                   bool loadExact, bool priority) {
+    if (filePath == "misc/link_animation/gPlayerAnim_link_normal_wait_free_Data") {
+        int bp = 5;
+    }
     // Check for and remove the OTR signature
     if (OtrSignatureCheck(filePath.c_str())) {
         auto newFilePath = filePath.substr(7);
@@ -187,7 +197,7 @@ std::shared_future<std::shared_ptr<IResource>> ResourceManager::LoadResourceAsyn
 }
 
 std::shared_ptr<IResource> ResourceManager::LoadResource(const std::string& filePath, bool loadExact) {
-    auto resource = LoadResourceAsync(filePath, loadExact, true).get();
+    auto resource = LoadResourceProcess(filePath, true); // LoadResourceAsync(filePath, loadExact, true).get();
     if (resource == nullptr) {
         SPDLOG_ERROR("Failed to load resource file at path {}", filePath);
     }
diff --git a/src/resource/ResourceType.h b/src/resource/ResourceType.h
index cc0512a86..d10ebc140 100644
--- a/src/resource/ResourceType.h
+++ b/src/resource/ResourceType.h
@@ -25,11 +25,15 @@ enum class ResourceType {
     SOH_Path = 0x4F505448,            // OPTH
     SOH_Cutscene = 0x4F435654,        // OCUT
     SOH_Text = 0x4F545854,            // OTXT
+    SOH_TextMM = 0x4F54584D,          // OTXM
     SOH_Audio = 0x4F415544,           // OAUD
     SOH_AudioSample = 0x4F534D50,     // OSMP
     SOH_AudioSoundFont = 0x4F534654,  // OSFT
     SOH_AudioSequence = 0x4F534551,   // OSEQ
     SOH_Background = 0x4F424749,      // OBGI
     SOH_SceneCommand = 0x4F52434D,    // ORCM
+
+    //LUS of Two
+    TSH_TexAnim = 0x4F54414E,         //OTAN
 };
 } // namespace LUS
diff --git a/src/window/gui/GfxDebuggerWindow.cpp b/src/window/gui/GfxDebuggerWindow.cpp
new file mode 100644
index 000000000..3eed43ebd
--- /dev/null
+++ b/src/window/gui/GfxDebuggerWindow.cpp
@@ -0,0 +1,691 @@
+#include "GfxDebuggerWindow.h"
+#include <ImGui/imgui.h>
+#include <spdlog/spdlog.h>
+#include "Context.h"
+#include "debug/GfxDebugger.h"
+#include <stack>
+#include <spdlog/fmt/fmt.h>
+#include "libultraship/bridge.h"
+#include <gfxd.h>
+
+extern uintptr_t gSegmentPointers[16];
+
+namespace LUS {
+
+GfxDebuggerWindow::~GfxDebuggerWindow() {
+}
+
+void GfxDebuggerWindow::InitElement() {
+}
+
+void GfxDebuggerWindow::UpdateElement() {
+}
+
+static const char* GetOpName(uint32_t op) {
+    switch (op) {
+#define CASE(x) \
+    case x:     \
+        return #x
+
+        CASE(G_RDPHALF_1);
+        CASE(G_RDPHALF_2);
+        CASE(G_RDPPIPESYNC);
+        CASE(G_RDPFULLSYNC);
+        CASE(G_RDPLOADSYNC);
+        CASE(G_LOAD_UCODE);
+        CASE(G_MARKER);
+        CASE(G_INVALTEXCACHE);
+        CASE(G_NOOP);
+        CASE(G_MTX);
+        CASE(G_MTX_OTR);
+        CASE(G_POPMTX);
+        CASE(G_MOVEMEM);
+        CASE(G_MOVEWORD);
+        CASE(G_TEXTURE);
+        CASE(G_VTX);
+        CASE(G_VTX_OTR_HASH);
+        CASE(G_VTX_OTR_FILEPATH);
+        CASE(G_DL_OTR_FILEPATH);
+        CASE(G_MODIFYVTX);
+        CASE(G_DL);
+        CASE(G_DL_OTR_HASH);
+        CASE(G_PUSHCD);
+        CASE(G_BRANCH_Z_OTR);
+        CASE(G_ENDDL);
+        CASE(G_GEOMETRYMODE);
+        // CASE(G_SETGEOMETRYMODE);
+        // CASE(G_CLEARGEOMETRYMODE);
+        CASE(G_TRI1_OTR);
+        CASE(G_TRI1);
+        CASE(G_QUAD);
+        CASE(G_TRI2);
+        CASE(G_SETOTHERMODE_L);
+        CASE(G_SETOTHERMODE_H);
+        CASE(G_SETTIMG);
+        CASE(G_SETTIMG_OTR_HASH);
+        CASE(G_SETTIMG_OTR_FILEPATH);
+        CASE(G_SETFB);
+        CASE(G_RESETFB);
+        CASE(G_SETTIMG_FB);
+        CASE(G_SETGRAYSCALE);
+        CASE(G_LOADBLOCK);
+        CASE(G_LOADTILE);
+        CASE(G_SETTILE);
+        CASE(G_SETTILESIZE);
+        CASE(G_LOADTLUT);
+        CASE(G_SETENVCOLOR);
+        CASE(G_SETPRIMCOLOR);
+        CASE(G_SETFOGCOLOR);
+        CASE(G_SETFILLCOLOR);
+        CASE(G_SETINTENSITY);
+        CASE(G_SETCOMBINE);
+        CASE(G_TEXRECT);
+        CASE(G_TEXRECTFLIP);
+        CASE(G_TEXRECT_WIDE);
+        CASE(G_FILLRECT);
+        CASE(G_FILLWIDERECT);
+        CASE(G_SETSCISSOR);
+        CASE(G_SETZIMG);
+        CASE(G_SETCIMG);
+        CASE(G_RDPSETOTHERMODE);
+        // CASE(G_BG_COPY);
+        CASE(G_EXTRAGEOMETRYMODE);
+        CASE(G_SETBLENDCOLOR);
+        CASE(G_RDPTILESYNC);
+        CASE(G_SPNOOP);
+        CASE(G_CULLDL);
+        default:
+            return nullptr;
+            // return "UNKNOWN";
+#undef CASE
+    }
+}
+
+static inline void* seg_addr(uintptr_t w1) {
+    // Segmented?
+    if (w1 & 1) {
+        uint32_t segNum = (w1 >> 24);
+
+        uint32_t offset = w1 & 0x00FFFFFE;
+        // offset = 0; // Cursed Malon bug
+
+        if (gSegmentPointers[segNum] != 0) {
+            return (void*)(gSegmentPointers[segNum] + offset);
+        } else {
+            return (void*)w1;
+        }
+    } else {
+        return (void*)w1;
+    }
+}
+
+#define C0(pos, width) ((cmd->words.w0 >> (pos)) & ((1U << width) - 1))
+#define C1(pos, width) ((cmd->words.w1 >> (pos)) & ((1U << width) - 1))
+
+void GfxDebuggerWindow::DrawDisasNode(const Gfx* cmd, GfxPath& gfx_path) const {
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+
+    auto node_with_text = [dbg, this, &gfx_path](const Gfx* cmd, const std::string& text,
+                                                 const Gfx* sub = nullptr) mutable {
+        ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
+
+        gfx_path.push(cmd);
+        if (dbg->HasBreakPoint(gfx_path))
+            flags |= ImGuiTreeNodeFlags_Selected;
+        if (sub == nullptr)
+            flags |= ImGuiTreeNodeFlags_Leaf;
+
+        bool open = ImGui::TreeNodeEx((const void*)cmd, flags, "%p: %s", cmd, text.c_str());
+        if (ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
+            dbg->SetBreakPoint(gfx_path);
+        }
+        if (open) {
+            if (sub) {
+                DrawDisasNode(sub, gfx_path);
+            }
+            ImGui::TreePop();
+        }
+        gfx_path.pop();
+    };
+
+    auto simple_node = [dbg, node_with_text](const Gfx* cmd, uint32_t opcode) mutable {
+        const char* opname = GetOpName(opcode);
+        size_t size = 1;
+        if (opcode == G_TEXRECT)
+            size = 3;
+        if (opname) {
+            gfxd_input_buffer(cmd, sizeof(uint64_t) * size);
+            gfxd_endian(gfxd_endian_little, sizeof(uint32_t));
+            char buff[256] = { 0 };
+            gfxd_output_buffer(buff, sizeof(buff));
+            gfxd_enable(gfxd_emit_dec_color);
+            gfxd_target(gfxd_f3dex2);
+            gfxd_execute();
+
+            node_with_text(cmd, fmt::format("{}", buff));
+        } else {
+            uint32_t opcode = cmd->words.w0 >> 24;
+            node_with_text(cmd, fmt::format("UNK: 0x{:X}", opcode));
+        }
+    };
+
+    while (true) {
+        uint32_t opcode = cmd->words.w0 >> 24;
+        const Gfx* cmd0 = cmd;
+        switch (opcode) {
+
+            case G_NOOP: {
+                const char* filename = (const char*)cmd->words.w1;
+                uint32_t p = C0(16, 8);
+                uint32_t l = C0(0, 16);
+
+                if (p == 7) {
+                    node_with_text(cmd0, fmt::format("gDPNoOpOpenDisp(): {}:{}", filename, l));
+                } else if (p == 8) {
+                    node_with_text(cmd0, fmt::format("gDPNoOpCloseDisp() {}:{}", filename, l));
+                } else {
+                    node_with_text(cmd0, fmt::format("G_NOOP: {}", p));
+                }
+
+                cmd++;
+                break;
+            }
+
+            case G_MARKER: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* dlName = ResourceGetNameByCrc(hash);
+                if (!dlName)
+                    dlName = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_MARKER: {}", dlName));
+                cmd++;
+                break;
+            }
+
+            case G_DL_OTR_HASH: {
+
+                if (C0(16, 1) == 0) {
+                    cmd++;
+                    uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                    const char* dlName = ResourceGetNameByCrc(hash);
+                    if (!dlName)
+                        dlName = "UNKNOWN";
+
+                    Gfx* subGfx = (Gfx*)ResourceGetDataByCrc(hash);
+                    // node_with_text(cmd0, fmt::format("G_DL_OTR_HASH: {}", "UNKOWN"), subGfx);
+                    node_with_text(cmd0, fmt::format("G_DL_OTR_HASH: {}", dlName), subGfx);
+                    cmd++;
+                } else {
+                    assert(0 && "Invalid in gfx_pc????");
+                }
+                break;
+            }
+
+            case G_SETTIMG_OTR_HASH: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* name = ResourceGetNameByCrc(hash);
+                if (!name)
+                    name = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_SETTIMG_OTR_HASH: {}", name));
+
+                // std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
+                //     LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(ResourceGetNameByCrc(hash)));
+                cmd++;
+                break;
+            }
+
+            case G_VTX_OTR_HASH: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* name = ResourceGetNameByCrc(hash);
+                if (!name)
+                    name = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_VTX_OTR_HASH: {}", name));
+
+                // Vtx* vtx = (Vtx*)ResourceGetDataByCrc(hash);
+                cmd++;
+                break;
+            };
+
+            case G_DL: {
+                Gfx* subGFX = (Gfx*)seg_addr(cmd->words.w1);
+                if (C0(16, 1) == 0) {
+                    node_with_text(cmd0, fmt::format("G_DL: 0x{:x} -> {}", cmd->words.w1, (void*)subGFX), subGFX);
+                    cmd++;
+                } else {
+                    node_with_text(cmd0, fmt::format("G_DL (branch): 0x{:x} -> {}", cmd->words.w1, (void*)subGFX),
+                                   subGFX);
+                    return;
+                }
+                break;
+            }
+
+            case G_ENDDL: {
+                simple_node(cmd, opcode);
+                return;
+            }
+
+            case G_TEXRECT: {
+                simple_node(cmd, opcode);
+                cmd += 3;
+                break;
+            }
+
+            default: {
+                simple_node(cmd, opcode);
+                cmd++;
+                break;
+            }
+        }
+    }
+}
+
+static const char* getTexType(LUS::TextureType type) {
+    switch (type) {
+
+        case LUS::TextureType::RGBA32bpp:
+            return "RGBA32";
+        case LUS::TextureType::RGBA16bpp:
+            return "RGBA16";
+        case LUS::TextureType::Palette4bpp:
+            return "CI4";
+        case LUS::TextureType::Palette8bpp:
+            return "CI8";
+        case LUS::TextureType::Grayscale4bpp:
+            return "I4";
+        case LUS::TextureType::Grayscale8bpp:
+            return "I8";
+        case LUS::TextureType::GrayscaleAlpha4bpp:
+            return "IA4";
+        case LUS::TextureType::GrayscaleAlpha8bpp:
+            return "IA8";
+        case LUS::TextureType::GrayscaleAlpha16bpp:
+            return "IA16";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+static bool bpEquals(const std::vector<const Gfx*>& x, const std::vector<const Gfx*>& y) {
+    if (x.size() != y.size())
+        return false;
+
+    for (size_t i = 0; i < x.size(); i++) {
+        if (x[i] != y[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// TODO: cleanup
+static void disasCrash(FILE* f, size_t level, const Gfx* cmd, GfxPath& gfx_path) {
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+
+    auto node_with_text = [f, dbg, level, &gfx_path](const Gfx* cmd, const std::string& text,
+                                                     const Gfx* sub = nullptr) mutable {
+        ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_OpenOnArrow;
+
+        bool crash_here = gfx_path == g_exec_stack.gfx_path && cmd == g_exec_stack.currCmd();
+        if (crash_here) {
+            fmt::print(f, "*****************************************************CRASH**********************************"
+                          "*************************\n");
+        }
+
+        gfx_path.push(cmd);
+
+        for (size_t i = 0; i < level; i++) {
+            fmt::print(f, "    ");
+        }
+        fmt::print(f, "{}: {}\n", (const void*)cmd, text);
+        fflush(f);
+
+        if (sub) {
+            disasCrash(f, level + 1, sub, gfx_path);
+        }
+        gfx_path.pop();
+    };
+
+    auto simple_node = [dbg, node_with_text](const Gfx* cmd, uint32_t opcode) mutable {
+        const char* opname = GetOpName(opcode);
+        size_t size = 1;
+        if (opcode == G_TEXRECT)
+            size = 3;
+        if (opname) {
+            gfxd_input_buffer(cmd, sizeof(uint64_t) * size);
+            gfxd_endian(gfxd_endian_little, sizeof(uint32_t));
+            char buff[256] = { 0 };
+            gfxd_output_buffer(buff, sizeof(buff));
+            gfxd_enable(gfxd_emit_dec_color);
+            gfxd_target(gfxd_f3dex2);
+            gfxd_execute();
+
+            node_with_text(cmd, fmt::format("{}", buff));
+        } else {
+            uint32_t opcode = cmd->words.w0 >> 24;
+            node_with_text(cmd, fmt::format("UNK: 0x{:X}", opcode));
+        }
+    };
+
+    while (true) {
+        uint32_t opcode = cmd->words.w0 >> 24;
+        const Gfx* cmd0 = cmd;
+        switch (opcode) {
+
+            case G_NOOP: {
+                const char* filename = (const char*)cmd->words.w1;
+                uint32_t p = C0(16, 8);
+                uint32_t l = C0(0, 16);
+
+                if (p == 7) {
+                    node_with_text(cmd0, fmt::format("gDPNoOpOpenDisp(): {}:{}", filename, l));
+                } else if (p == 8) {
+                    node_with_text(cmd0, fmt::format("gDPNoOpCloseDisp() {}:{}", filename, l));
+                } else {
+                    node_with_text(cmd0, fmt::format("G_NOOP: {}", p));
+                }
+
+                cmd++;
+                break;
+            }
+
+            case G_MARKER: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* dlName = ResourceGetNameByCrc(hash);
+                if (!dlName)
+                    dlName = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_MARKER: {}", dlName));
+                cmd++;
+                break;
+            }
+
+            case G_DL_OTR_HASH: {
+
+                if (C0(16, 1) == 0) {
+                    cmd++;
+                    uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                    const char* dlName = ResourceGetNameByCrc(hash);
+                    if (!dlName)
+                        dlName = "UNKNOWN";
+
+                    Gfx* subGfx = (Gfx*)ResourceGetDataByCrc(hash);
+                    // node_with_text(cmd0, fmt::format("G_DL_OTR_HASH: {}", "UNKOWN"), subGfx);
+                    node_with_text(cmd0, fmt::format("G_DL_OTR_HASH: {}", dlName), subGfx);
+                    cmd++;
+                } else {
+                    assert(0 && "Invalid in gfx_pc????");
+                }
+                break;
+            }
+
+            case G_SETTIMG_OTR_HASH: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* name = ResourceGetNameByCrc(hash);
+                if (!name)
+                    name = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_SETTIMG_OTR_HASH: {}", name));
+
+                // std::shared_ptr<LUS::Texture> texture = std::static_pointer_cast<LUS::Texture>(
+                //     LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess(ResourceGetNameByCrc(hash)));
+                cmd++;
+                break;
+            }
+
+            case G_VTX_OTR_HASH: {
+                cmd++;
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                const char* name = ResourceGetNameByCrc(hash);
+                if (!name)
+                    name = "UNKNOWN";
+
+                node_with_text(cmd0, fmt::format("G_VTX_OTR_HASH: {}", name));
+
+                // Vtx* vtx = (Vtx*)ResourceGetDataByCrc(hash);
+                cmd++;
+                break;
+            };
+
+            case G_DL: {
+                Gfx* subGFX = (Gfx*)seg_addr(cmd->words.w1);
+                if (C0(16, 1) == 0) {
+                    node_with_text(cmd0, fmt::format("G_DL: 0x{:x} -> {}", cmd->words.w1, (void*)subGFX), subGFX);
+                    cmd++;
+                } else {
+                    node_with_text(cmd0, fmt::format("G_DL (branch): 0x{:x} -> {}", cmd->words.w1, (void*)subGFX),
+                                   subGFX);
+                    return;
+                }
+                break;
+            }
+
+            case G_ENDDL: {
+                simple_node(cmd, opcode);
+                return;
+            }
+
+            case G_TEXRECT: {
+                simple_node(cmd, opcode);
+                cmd += 3;
+                break;
+            }
+
+            default: {
+                simple_node(cmd, opcode);
+                cmd++;
+                break;
+            }
+        }
+    }
+}
+
+extern "C" void __asan_on_error() {
+    if (g_exec_stack.cmd_stack.empty())
+        return;
+
+    GfxPath gfx_path = {};
+    FILE* x = fopen("dlist.crash", "w+");
+    disasCrash(x, 0, g_exec_stack.start_dlist, gfx_path);
+    fclose(x);
+}
+
+void GfxDebuggerWindow::DrawDisas() {
+
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+    auto dlist = dbg->GetDisplayList();
+    ImGui::Text("dlist: %p", dlist);
+    ImGui::Text("BreakPoint: %s", dbg->GetBreakPoint().string().c_str());
+
+    bool isNew = mLastBreakPoint != dbg->GetBreakPoint();
+    if (isNew) {
+        mLastBreakPoint = dbg->GetBreakPoint();
+        // fprintf(stderr, "NEW BREAKPOINT %s\n", bp.c_str());
+    }
+
+    std::string TO_LOAD_TEX = "GfxDebuggerWindowTextureToLoad";
+
+    const Gfx* cmd = dlist;
+    auto gui = LUS::Context::GetInstance()->GetWindow()->GetGui();
+
+    ImGui::BeginChild("###State", ImVec2(0.0f, 200.0f), true);
+    {
+        ImGui::BeginGroup();
+        {
+            ImGui::Text("Disp Stack");
+            ImGui::BeginChild("### Disp Stack", ImVec2(400.0f, 0.0f), true, ImGuiWindowFlags_HorizontalScrollbar);
+            for (auto& disp : g_exec_stack.disp_stack) {
+                ImGui::Text("%s", fmt::format("{}:{}", disp.file, disp.line).c_str());
+            }
+            ImGui::EndChild();
+        }
+        ImGui::EndGroup();
+        ImGui::SameLine();
+
+        ImGui::BeginGroup();
+        {
+            ImGui::Text("Tiles");
+            ImGui::BeginChild("### Tile", ImVec2(400.0f, 0.0f), true);
+            // for (size_t i = 0; i < 8; i++) {
+            //     auto& tile = g_rdp.texture_tile[i];
+            //     ImGui::Text(
+            //         "%s", fmt::format("{}: fmt={}; siz={}; cms={}; cmt={};", i, tile.fmt, tile.siz, tile.cms,
+            //         tile.cmt)
+            //                   .c_str());
+            // }
+
+            auto draw_img = [isNew, &gui](std::optional<std::string> prefix, const std::string& name,
+                                          const RawTexMetadata& metadata) {
+                ImGui::BeginGroup();
+                if (prefix) {
+                    ImGui::Text("%s: %dx%d; type=%s", prefix->c_str(), metadata.width, metadata.height,
+                                getTexType(metadata.type));
+                } else {
+                    ImGui::Text("%dx%d; type=%s", metadata.width, metadata.height, getTexType(metadata.type));
+                }
+
+                if (isNew && metadata.resource != nullptr) {
+                    gui->UnloadTexture(name);
+                    gui->LoadGuiTexture(name, *metadata.resource, ImVec4{ 1.0f, 1.0f, 1.0f, 1.0f });
+                }
+
+                ImGui::Image(gui->GetTextureByName(name), ImVec2{ 100.0f, 100.0f });
+                ImGui::EndGroup();
+            };
+
+            ImGui::Text("Loaded Textures");
+            for (size_t i = 0; i < 2; i++) {
+                auto& tex = g_rdp.loaded_texture[i];
+                if (i != 0) {
+                    ImGui::SameLine();
+                }
+                draw_img(std::to_string(i), fmt::format("GfxDebuggerWindowLoadedTexture{}", i), tex.raw_tex_metadata);
+            }
+            ImGui::Text("Texture To Load");
+            {
+                auto& tex = g_rdp.texture_to_load;
+                draw_img(std::nullopt, TO_LOAD_TEX, tex.raw_tex_metadata);
+            }
+            ImGui::EndChild();
+        }
+        ImGui::EndGroup();
+
+        ImGui::SameLine();
+
+        ImGui::BeginGroup();
+        {
+            auto showColor = [](const char* text, RGBA c) {
+                float cf[] = { c.r / 255.0f, c.g / 255.0f, c.b / 255.0f, c.a / 255.0f };
+                ImGui::ColorEdit3(text, cf, ImGuiColorEditFlags_NoInputs);
+            };
+
+            showColor("Env Color", g_rdp.env_color);
+            showColor("Prim Color", g_rdp.prim_color);
+            showColor("Fog Color", g_rdp.fog_color);
+            showColor("Fill Color", g_rdp.fill_color);
+            showColor("Grayscale Color", g_rdp.grayscale_color);
+        }
+        ImGui::EndGroup();
+
+        ImGui::SameLine();
+
+        ImGui::BeginGroup();
+        {
+            ImGui::Text("Breakpoints");
+            ImGui::BeginChild("### Breakpoints", ImVec2(400.0f, 0.0f), true, ImGuiWindowFlags_HorizontalScrollbar);
+
+            if (ImGui::BeginPopupContextWindow("Context Menu")) {
+                ImGui::BeginGroup();
+                {
+                    ImGui::InputText("Name", mPopupInpuBuf, sizeof(mPopupInpuBuf));
+                    if (ImGui::MenuItem("Add")) {
+                        fmt::print("{}\n", mPopupInpuBuf);
+                        dbg->AddBreakOnDlist(mPopupInpuBuf);
+                        mPopupInpuBuf[0] = 0;
+                    }
+                }
+                ImGui::EndGroup();
+                ImGui::EndPopup();
+            }
+            if (ImGui::IsItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
+                ImGui::OpenPopup("Context Menu");
+            }
+
+            std::string toAdd = "";
+            std::string toRemove = "";
+
+            for (auto& dlist : dbg->GetBreakOnDlists()) {
+                ImGui::MenuItem(dlist.c_str());
+
+                if (ImGui::BeginPopupContextItem()) {
+                    ImGui::BeginGroup();
+                    {
+                        ImGui::InputText("Name", mPopupInpuBuf, sizeof(mPopupInpuBuf));
+                        if (ImGui::MenuItem("Add")) {
+                            fmt::print("Add {}\n", mPopupInpuBuf);
+                            toAdd = mPopupInpuBuf;
+                            mPopupInpuBuf[0] = 0;
+                        }
+                    }
+                    ImGui::EndGroup();
+                    ImGui::Separator();
+                    if (ImGui::MenuItem("Delete")) {
+                        fmt::print("Delete {}\n", dlist);
+                        toRemove = dlist;
+                    }
+                    ImGui::EndPopup();
+                }
+            }
+
+            if (!toRemove.empty())
+                dbg->RemoveBreakOnDlist(toRemove);
+            if (!toAdd.empty())
+                dbg->AddBreakOnDlist(toAdd);
+
+            ImGui::EndChild();
+        }
+        ImGui::EndGroup();
+    }
+    ImGui::EndChild();
+
+    ImGui::BeginChild("##Disassembler", ImVec2(0.0f, 0.0f), true, ImGuiWindowFlags_HorizontalScrollbar);
+    {
+        GfxPath gfx_path = {};
+        DrawDisasNode(dlist, gfx_path);
+    }
+    ImGui::EndChild();
+}
+
+void GfxDebuggerWindow::DrawElement() {
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+
+    ImGui::SetNextWindowSize(ImVec2(520, 600), ImGuiCond_FirstUseEver);
+    ImGui::Begin("GFX Debugger", &mIsVisible, ImGuiWindowFlags_NoFocusOnAppearing);
+
+    if (!dbg->IsDebugging()) {
+        if (ImGui::Button("Debug")) {
+            dbg->RequestDebugging();
+        }
+    } else {
+        bool resumed = false;
+        if (ImGui::Button("Resume Game")) {
+            dbg->ResumeGame();
+            resumed = true;
+        }
+
+        if (!resumed) {
+            DrawDisas();
+        }
+    }
+
+    ImGui::End();
+}
+
+} // namespace LUS
diff --git a/src/window/gui/GfxDebuggerWindow.h b/src/window/gui/GfxDebuggerWindow.h
new file mode 100644
index 000000000..d7c58c9f0
--- /dev/null
+++ b/src/window/gui/GfxDebuggerWindow.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "window/gui/GuiWindow.h"
+#include "libultraship/libultra/gbi.h"
+#include <vector>
+#include <graphic/Fast3D/gfx_pc.h>
+
+namespace LUS {
+
+class GfxDebuggerWindow : public GuiWindow {
+  public:
+    using GuiWindow::GuiWindow;
+    ~GfxDebuggerWindow();
+
+  protected:
+    void InitElement() override;
+    void UpdateElement() override;
+    void DrawElement() override;
+
+  private:
+    void DrawDisasNode(const Gfx* cmd, GfxPath& gfx_path) const;
+    void DrawDisas();
+
+  private:
+    GfxPath mLastBreakPoint = {};
+    char mPopupInpuBuf[256] = { 0 };
+};
+
+} // namespace LUS
diff --git a/src/window/gui/Gui.cpp b/src/window/gui/Gui.cpp
index 8ca8fd8c0..8d45e87a5 100644
--- a/src/window/gui/Gui.cpp
+++ b/src/window/gui/Gui.cpp
@@ -16,6 +16,8 @@
 #include <stb/stb_image.h>
 #include "window/gui/Fonts.h"
 
+#include "window/gui/GfxDebuggerWindow.h"
+
 #ifdef __WIIU__
 #include <gx2/registers.h> // GX2SetViewport / GX2SetScissor
 
@@ -69,6 +71,7 @@ Gui::Gui() : mNeedsConsoleVariableSave(false) {
     AddGuiWindow(std::make_shared<StatsWindow>("gStatsEnabled", "Stats"));
     AddGuiWindow(std::make_shared<InputEditorWindow>("gControllerConfigurationEnabled", "Input Editor"));
     AddGuiWindow(std::make_shared<ConsoleWindow>("gConsoleEnabled", "Console"));
+    AddGuiWindow(std::make_shared<GfxDebuggerWindow>("gGfxDebuggerEnabled", "GfxDebuggerWindow"));
 }
 
 Gui::~Gui() {
@@ -128,6 +131,7 @@ void Gui::Init(GuiWindowInitData windowImpl) {
     GetGuiWindow("Stats")->Init();
     GetGuiWindow("Input Editor")->Init();
     GetGuiWindow("Console")->Init();
+    GetGuiWindow("GfxDebuggerWindow")->Init();
     GetGameOverlay()->Init();
 
     ImGuiWMInit();
@@ -722,32 +726,56 @@ std::shared_ptr<GuiWindow> Gui::GetGuiWindow(const std::string& name) {
     }
 }
 
-void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const ImVec4& tint) {
+void Gui::LoadGuiTexture(const std::string& name, const LUS::Texture& res, const ImVec4& tint) {
     GfxRenderingAPI* api = gfx_get_current_rendering_api();
-    const auto res =
-        static_cast<LUS::Texture*>(Context::GetInstance()->GetResourceManager()->LoadResource(path, true).get());
-
     std::vector<uint8_t> texBuffer;
-    texBuffer.reserve(res->Width * res->Height * 4);
+    texBuffer.reserve(res.Width * res.Height * 4);
 
     // For HD textures we need to load the buffer raw (similar to inside gfx_pp)
-    if ((res->Flags & TEX_FLAG_LOAD_AS_RAW) != 0) {
+    if ((res.Flags & TEX_FLAG_LOAD_AS_RAW) != 0) {
         // Raw loading doesn't support TLUT textures
-        if (res->Type == LUS::TextureType::Palette4bpp || res->Type == LUS::TextureType::Palette8bpp) {
+        if (res.Type == LUS::TextureType::Palette4bpp || res.Type == LUS::TextureType::Palette8bpp) {
             // TODO convert other image types
-            SPDLOG_WARN("ImGui::ResourceLoad: Attempting to load unsupported image type %s", path.c_str());
+            SPDLOG_WARN("ImGui::ResourceLoad: Attempting to load unsupported image type");
             return;
         }
 
-        texBuffer.assign(res->ImageData, res->ImageData + (res->Width * res->Height * 4));
+        texBuffer.assign(res.ImageData, res.ImageData + (res.Width * res.Height * 4));
     } else {
-        switch (res->Type) {
+        switch (res.Type) {
             case LUS::TextureType::RGBA32bpp:
-                texBuffer.assign(res->ImageData, res->ImageData + (res->Width * res->Height * 4));
+                texBuffer.assign(res.ImageData, res.ImageData + (res.Width * res.Height * 4));
+                break;
+            case LUS::TextureType::RGBA16bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i++) {
+                    uint8_t b1 = res.ImageData[i * 2 + 0];
+                    uint8_t b2 = res.ImageData[i * 2 + 1];
+                    uint8_t r = (b1 >> 3) * 0xFF / 0x1F;
+                    uint8_t g = (((b1 & 7) << 2) | (b2 >> 6)) * 0xFF / 0x1F;
+                    uint8_t b = ((b2 >> 1) & 0x1F) * 0xFF / 0x1F;
+                    uint8_t a = 0xFF * (b2 & 1);
+                    texBuffer.push_back(r);
+                    texBuffer.push_back(g);
+                    texBuffer.push_back(b);
+                    texBuffer.push_back(a);
+                }
                 break;
-            case LUS::TextureType::GrayscaleAlpha8bpp:
-                for (int32_t i = 0; i < res->Width * res->Height; i++) {
-                    uint8_t ia = res->ImageData[i];
+            }
+            case LUS::TextureType::GrayscaleAlpha16bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i++) {
+                    uint8_t color = res.ImageData[i * 2 + 0];
+                    uint8_t alpha = res.ImageData[i * 2 + 1];
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(alpha);
+                }
+                break;
+                break;
+            }
+            case LUS::TextureType::GrayscaleAlpha8bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i++) {
+                    uint8_t ia = res.ImageData[i];
                     uint8_t color = ((ia >> 4) & 0xF) * 255 / 15;
                     uint8_t alpha = (ia & 0xF) * 255 / 15;
                     texBuffer.push_back(color);
@@ -756,9 +784,60 @@ void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const
                     texBuffer.push_back(alpha);
                 }
                 break;
+            }
+            case LUS::TextureType::GrayscaleAlpha4bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i += 2) {
+                    uint8_t b = res.ImageData[i / 2];
+
+                    uint8_t ia4 = b >> 4;
+                    uint8_t color = ((ia4 >> 1) & 0xF) * 255 / 0b111;
+                    uint8_t alpha = (ia4 & 1) * 255;
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(alpha);
+
+                    ia4 = b & 0xF;
+                    color = ((ia4 >> 1) & 0xF) * 255 / 0b111;
+                    alpha = (ia4 & 1) * 255;
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(color);
+                    texBuffer.push_back(alpha);
+                }
+                break;
+            }
+            case LUS::TextureType::Grayscale8bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i++) {
+                    uint8_t ia = res.ImageData[i];
+                    texBuffer.push_back(ia);
+                    texBuffer.push_back(ia);
+                    texBuffer.push_back(ia);
+                    texBuffer.push_back(0xFF);
+                }
+                break;
+            }
+            case LUS::TextureType::Grayscale4bpp: {
+                for (int32_t i = 0; i < res.Width * res.Height; i += 2) {
+                    uint8_t b = res.ImageData[i / 2];
+
+                    uint8_t ia4 = ((b >> 4) * 0xFF) / 0b1111;
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(0xFF);
+
+                    ia4 = ((b & 0xF) * 0xFF) / 0b1111;
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(ia4);
+                    texBuffer.push_back(0xFF);
+                }
+                break;
+            }
             default:
                 // TODO convert other image types
-                SPDLOG_WARN("ImGui::ResourceLoad: Attempting to load unsupported image type %s", path.c_str());
+                SPDLOG_WARN("ImGui::ResourceLoad: Attempting to load unsupported image type");
                 return;
         }
     }
@@ -772,16 +851,32 @@ void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const
 
     GuiTexture asset;
     asset.RendererTextureId = api->new_texture();
-    asset.Width = res->Width;
-    asset.Height = res->Height;
+    asset.Width = res.Width;
+    asset.Height = res.Height;
 
     api->select_texture(0, asset.RendererTextureId);
     api->set_sampler_parameters(0, false, 0, 0);
-    api->upload_texture(texBuffer.data(), res->Width, res->Height);
+    api->upload_texture(texBuffer.data(), res.Width, res.Height);
 
     mGuiTextures[name] = asset;
 }
 
+void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const ImVec4& tint) {
+    const auto res =
+        static_cast<LUS::Texture*>(Context::GetInstance()->GetResourceManager()->LoadResource(path, true).get());
+
+    LoadGuiTexture(name, *res, tint);
+}
+
+void Gui::UnloadTexture(const std::string& name) {
+    if (mGuiTextures.contains(name)) {
+        GuiTexture tex = mGuiTextures[name];
+        GfxRenderingAPI* api = gfx_get_current_rendering_api();
+        api->delete_texture(tex.RendererTextureId);
+        mGuiTextures.erase(name);
+    }
+}
+
 std::shared_ptr<GameOverlay> Gui::GetGameOverlay() {
     return mGameOverlay;
 }
diff --git a/src/window/gui/Gui.h b/src/window/gui/Gui.h
index 1f03c1b80..cd675a2b7 100644
--- a/src/window/gui/Gui.h
+++ b/src/window/gui/Gui.h
@@ -17,6 +17,7 @@
 #include "window/gui/GuiWindow.h"
 #include "window/gui/GuiMenuBar.h"
 #include "libultraship/libultra/controller.h"
+#include "resource/type/Texture.h"
 
 namespace LUS {
 
@@ -74,6 +75,8 @@ class Gui {
     void RemoveGuiWindow(std::shared_ptr<GuiWindow> guiWindow);
     void RemoveGuiWindow(const std::string& name);
     void LoadGuiTexture(const std::string& name, const std::string& path, const ImVec4& tint);
+    void LoadGuiTexture(const std::string& name, const LUS::Texture& tex, const ImVec4& tint);
+    void UnloadTexture(const std::string& name);
     ImTextureID GetTextureByName(const std::string& name);
     bool SupportsViewports();
     std::shared_ptr<GuiWindow> GetGuiWindow(const std::string& name);