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..221107f14 100644
--- a/extern/ZAPDUtils/Utils/DiskFile.h
+++ b/extern/ZAPDUtils/Utils/DiskFile.h
@@ -81,7 +81,10 @@ class DiskFile
 
 	static void WriteAllText(const fs::path& filePath, const std::string& text)
 	{
-		std::ofstream file(filePath, std::ios::out);
+        if (!std::filesystem::exists(filePath.parent_path())) {
+                std::filesystem::create_directories(filePath.parent_path());
+		}
+        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..a4e500695 100644
--- a/include/libultraship/libultra/abi.h
+++ b/include/libultraship/libultra/abi.h
@@ -7,7 +7,7 @@ typedef unsigned int u32;
 #define A_SPNOOP 0
 #define A_ADPCM 1
 #define A_CLEARBUFF 2
-#define A_UNK3 3
+#define A_UNK3 3f
 #define A_ADDMIXER 4
 #define A_RESAMPLE 5
 #define A_RESAMPLE_ZOH 6
@@ -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,12 +447,12 @@ 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 aAddMixer(pkt, count, dmemi, dmemo, a4)                                                        \
diff --git a/include/libultraship/libultra/gbi.h b/include/libultraship/libultra/gbi.h
index f72898d72..a0a5567d2 100644
--- a/include/libultraship/libultra/gbi.h
+++ b/include/libultraship/libultra/gbi.h
@@ -184,6 +184,9 @@
 // RDP Cmd
 #define G_SETGRAYSCALE 0x39
 #define G_EXTRAGEOMETRYMODE 0x3a
+#define G_COPYFB 0x3b
+#define G_IMAGERECT 0x3c
+#define G_DL_INDEX 0x3d
 #define G_SETINTENSITY 0x40
 
 /*
@@ -343,6 +346,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 +1274,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 +1296,7 @@ typedef struct {
 
 typedef union {
     Light_t l;
+    PointLight_t p;
     long long int force_structure_alignment[2];
 } Light;
 
@@ -1769,11 +1783,13 @@ typedef union {
 #define gsSPDisplayList(dl) gsDma1p(G_DL, dl, 0, G_DL_PUSH)
 #define gsSPDisplayListOTRHash(dl) gsDma1p(G_DL_OTR_HASH, dl, 0, G_DL_PUSH)
 #define gsSPDisplayListOTRFilePath(dl) gsDma1p(G_DL_OTR_FILEPATH, dl, 0, G_DL_PUSH)
+#define gsSPDisplayListIndex(dl) gsDma1p(G_DL_INDEX, dl, 0, G_DL_PUSH)
 
 #define gSPBranchList(pkt, dl) gDma1p(pkt, G_DL, dl, 0, G_DL_NOPUSH)
 #define gsSPBranchList(dl) gsDma1p(G_DL, dl, 0, G_DL_NOPUSH)
 #define gsSPBranchListOTRHash(dl) gsDma1p(G_DL_OTR_HASH, dl, 0, G_DL_NOPUSH)
 #define gsSPBranchListOTRFilePath(dl) gsDma1p(G_DL_OTR_FILEPATH, dl, 0, G_DL_NOPUSH)
+#define gsSPBranchListIndex(dl) gsDma1p(G_DL_INDEX, dl, 0, G_DL_NOPUSH)
 
 #define gSPSprite2DBase(pkt, s) gDma1p(pkt, G_SPRITE2D_BASE, s, sizeof(uSprite), 0)
 #define gsSPSprite2DBase(s) gsDma1p(G_SPRITE2D_BASE, s, sizeof(uSprite), 0)
@@ -2271,9 +2287,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
@@ -2648,6 +2664,26 @@ typedef union {
         _g->words.w1 = 0;                         \
     }
 
+#define gDPCopyFB(pkt, dst, src, once, copiedPtr)                                                                    \
+    {                                                                                                                \
+        Gfx* _g = (Gfx*)(pkt);                                                                                       \
+                                                                                                                     \
+        _g->words.w0 = _SHIFTL(G_COPYFB, 24, 8) | _SHIFTL(dst, 11, 11) | _SHIFTL(src, 0, 11) | _SHIFTL(once, 22, 1); \
+        _g->words.w1 = (uintptr_t)copiedPtr;                                                                         \
+    }
+
+#define gDPImageRectangle(pkt, x0, y0, s0, t0, x1, y1, s1, t1, tile, iw, ih) \
+    {                                                                        \
+        Gfx *_g0 = (Gfx*)(pkt), *_g1 = (Gfx*)(pkt), *_g2 = (Gfx*)(pkt);      \
+                                                                             \
+        _g0->words.w0 = _SHIFTL(G_IMAGERECT, 24, 8) | _SHIFTL((tile), 0, 3); \
+        _g0->words.w1 = _SHIFTL((iw), 16, 16) | _SHIFTL((ih), 0, 16);        \
+        _g1->words.w0 = _SHIFTL((x0), 16, 16) | _SHIFTL((y0), 0, 16);        \
+        _g1->words.w1 = _SHIFTL((s0), 16, 16) | _SHIFTL((t0), 0, 16);        \
+        _g2->words.w0 = _SHIFTL((x1), 16, 16) | _SHIFTL((y1), 0, 16);        \
+        _g2->words.w1 = _SHIFTL((s1), 16, 16) | _SHIFTL((t1), 0, 16);        \
+    }
+
 #define gSPGrayscale(pkt, state)                       \
     {                                                  \
         Gfx* _g = (Gfx*)(pkt);                         \
@@ -2785,6 +2821,8 @@ 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
@@ -4061,4 +4099,4 @@ typedef union {
 
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c9c5753da..ce5a712a6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,8 +1,12 @@
 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)
 option(USE_OPENGLES "Enable GLES3" OFF)
+option(GFX_DEBUG_DISASSEMBLER "Enable libgfxd" OFF)
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
 use_props(${PROJECT_NAME} "${CMAKE_CONFIGURATION_TYPES}" "${DEFAULT_CXX_PROPS}")
@@ -173,7 +177,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
@@ -183,6 +187,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
@@ -190,7 +196,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})
 
@@ -201,6 +207,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})
@@ -247,6 +255,8 @@ 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
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/Font.h
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/Font.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/window/gui/resource/FontFactory.h
@@ -260,6 +270,28 @@ set(Source_Files__Window__Gui
 source_group("window/gui" FILES ${Source_Files__Window__Gui})
 target_sources(libultraship PRIVATE ${Source_Files__Window__Gui})
 
+if (GFX_DEBUG_DISASSEMBLER)
+    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})
+endif()
+
 #=================== Utils ===================
 
 set(Source_Files__Utils
@@ -456,7 +488,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} $<$<BOOL:${GFX_DEBUG_DISASSEMBLER}>:${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
 )
 
@@ -518,7 +550,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()
 
@@ -530,6 +562,7 @@ if (NOT CMAKE_SYSTEM_NAME STREQUAL "CafeOS")
         $<$<CONFIG:Debug>:SPDLOG_ACTIVE_LEVEL=0>
         $<$<NOT:$<CONFIG:Debug>>:SPDLOG_ACTIVE_LEVEL=1>
         $<$<BOOL:${USE_OPENGLES}>:USE_OPENGLES>
+        $<$<BOOL:${GFX_DEBUG_DISASSEMBLER}>:GFX_DEBUG_DISASSEMBLER>
     )
 else ()
     target_compile_definitions(libultraship PRIVATE
diff --git a/src/Context.cpp b/src/Context.cpp
index 960a92bbf..8ba78df0b 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 _WIN32
 #include <tchar.h>
@@ -86,6 +87,7 @@ void Context::Init(const std::vector<std::string>& otrFiles, const std::unordere
     InitConsole();
     InitWindow();
     InitAudio();
+    InitGfxDebugger();
 }
 
 void Context::InitLogging() {
@@ -247,6 +249,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;
@@ -301,6 +311,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 53a48f277..6164d1904 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(std::vector<uint16_t> additionalBitmasks = {});
     void InitCrashHandler();
     void InitAudio();
+    void InitGfxDebugger();
     void InitConsole();
     void InitWindow(std::shared_ptr<GuiWindow> customInputEditorWindow = nullptr);
 
@@ -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/GfxDebugger.cpp b/src/debug/GfxDebugger.cpp
new file mode 100644
index 000000000..4c704cba1
--- /dev/null
+++ b/src/debug/GfxDebugger.cpp
@@ -0,0 +1,54 @@
+#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 std::vector<const Gfx*>& GfxDebugger::GetBreakPoint() const {
+    return mBreakPoint;
+}
+
+void GfxDebugger::SetBreakPoint(const std::vector<const Gfx*>& bp) {
+    mBreakPoint = bp;
+}
+
+void GfxDebugger::RequestDebugging() {
+    mIsDebuggingRequested = true;
+}
+bool GfxDebugger::IsDebugging() const {
+    return mIsDebugging;
+}
+bool GfxDebugger::IsDebuggingRequested() const {
+    return mIsDebuggingRequested;
+}
+
+void GfxDebugger::DebugDisplayList(Gfx* cmds) {
+    mDlist = cmds;
+    mIsDebuggingRequested = false;
+    mIsDebugging = true;
+    mBreakPoint = { cmds };
+}
+
+bool GfxDebugger::HasBreakPoint(const std::vector<const Gfx*>& path) const {
+    if (path.size() != mBreakPoint.size())
+        return false;
+
+    for (size_t i = 0; i < path.size(); i++) {
+        if (path[i] != mBreakPoint[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+} // namespace LUS
diff --git a/src/debug/GfxDebugger.h b/src/debug/GfxDebugger.h
new file mode 100644
index 000000000..c9ef8f3f0
--- /dev/null
+++ b/src/debug/GfxDebugger.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "libultraship/libultra/gbi.h"
+#include <string>
+#include <vector>
+
+namespace LUS {
+
+class GfxDebugger {
+  public:
+    void RequestDebugging();
+    bool IsDebugging() const;
+    bool IsDebuggingRequested() const;
+
+    void DebugDisplayList(Gfx* cmds);
+
+    void ResumeGame();
+
+    const Gfx* GetDisplayList() const;
+
+    const std::vector<const Gfx*>& GetBreakPoint() const;
+
+    bool HasBreakPoint(const std::vector<const Gfx*>& path) const;
+
+    void SetBreakPoint(const std::vector<const Gfx*>& bp);
+
+  private:
+    bool mIsDebugging = false;
+    bool mIsDebuggingRequested = false;
+    Gfx* mDlist = nullptr;
+    std::vector<const Gfx*> mBreakPoint = {};
+};
+
+} // namespace LUS
diff --git a/src/graphic/Fast3D/gfx_direct3d11.cpp b/src/graphic/Fast3D/gfx_direct3d11.cpp
index e0bfd9909..528c43e66 100644
--- a/src/graphic/Fast3D/gfx_direct3d11.cpp
+++ b/src/graphic/Fast3D/gfx_direct3d11.cpp
@@ -966,6 +966,78 @@ void gfx_d3d11_select_texture_fb(int fbID) {
     gfx_d3d11_select_texture(tile, d3d.framebuffers[fbID].texture_id);
 }
 
+void gfx_d3d11_copy_framebuffer(int fb_dst_id, int fb_src_id) {
+    if (fb_src_id >= (int)d3d.framebuffers.size() || fb_dst_id >= (int)d3d.framebuffers.size()) {
+        return;
+    }
+
+    Framebuffer& fb_dst = d3d.framebuffers[fb_dst_id];
+    Framebuffer& fb_src = d3d.framebuffers[fb_src_id];
+
+    TextureData& td_dst = d3d.textures[fb_dst.texture_id];
+    TextureData& td_src = d3d.textures[fb_src.texture_id];
+
+    // Skip copying framebuffers that don't have the same width
+    if (td_src.width != td_dst.width) {
+        return;
+    }
+
+    // Textures are the same size so we can do a direct copy or resolve
+    if (td_src.height == td_dst.height) {
+        if (fb_src.msaa_level <= 1) {
+            d3d.context->CopyResource(td_dst.texture.Get(), td_src.texture.Get());
+        } else {
+            d3d.context->ResolveSubresource(td_dst.texture.Get(), 0, td_src.texture.Get(), 0,
+                                            DXGI_FORMAT_R8G8B8A8_UNORM);
+        }
+        return;
+    }
+
+    D3D11_BOX region;
+    region.left = 0;
+    region.right = td_src.width;
+    region.top = 0;
+    region.bottom = td_src.height;
+    region.front = 0;
+    region.back = 1;
+
+    // Account for source framebuffer having the menu bar open
+    if (td_src.height > td_dst.height) {
+        region.top = td_src.height - td_dst.height;
+    }
+
+    // We can't region copy a multi-sample texture to a single sample texture
+    if (fb_src.msaa_level <= 1) {
+        d3d.context->CopySubresourceRegion(td_dst.texture.Get(), 0, 0, 0, 0, td_src.texture.Get(), 0, &region);
+    } else {
+        // Setup a temporary texture
+        TextureData td_resolved;
+        td_resolved.width = td_src.width;
+        td_resolved.height = td_src.height;
+
+        D3D11_TEXTURE2D_DESC texture_desc;
+        texture_desc.Width = td_src.width;
+        texture_desc.Height = td_src.height;
+        texture_desc.Usage = D3D11_USAGE_DEFAULT;
+        texture_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+        texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        texture_desc.CPUAccessFlags = 0;
+        texture_desc.MiscFlags = 0;
+        texture_desc.ArraySize = 1;
+        texture_desc.MipLevels = 1;
+        texture_desc.SampleDesc.Count = 1;
+        texture_desc.SampleDesc.Quality = 0;
+
+        ThrowIfFailed(d3d.device->CreateTexture2D(&texture_desc, nullptr, td_resolved.texture.GetAddressOf()));
+
+        // Resolve multi-sample to temporary
+        d3d.context->ResolveSubresource(td_resolved.texture.Get(), 0, td_src.texture.Get(), 0,
+                                        DXGI_FORMAT_R8G8B8A8_UNORM);
+        // Then copy the region to the destination
+        d3d.context->CopySubresourceRegion(td_dst.texture.Get(), 0, 0, 0, 0, td_resolved.texture.Get(), 0, &region);
+    }
+}
+
 void gfx_d3d11_set_texture_filter(FilteringMode mode) {
     d3d.current_filter_mode = mode;
     gfx_texture_cache_clear();
@@ -1118,6 +1190,7 @@ struct GfxRenderingAPI gfx_direct3d11_api = { gfx_d3d11_get_name,
                                               gfx_d3d11_create_framebuffer,
                                               gfx_d3d11_update_framebuffer_parameters,
                                               gfx_d3d11_start_draw_to_framebuffer,
+                                              gfx_d3d11_copy_framebuffer,
                                               gfx_d3d11_clear_framebuffer,
                                               gfx_d3d11_resolve_msaa_color_buffer,
                                               gfx_d3d11_get_pixel_depth,
diff --git a/src/graphic/Fast3D/gfx_gx2.cpp b/src/graphic/Fast3D/gfx_gx2.cpp
index 8d0fa4e98..d0934c6a6 100644
--- a/src/graphic/Fast3D/gfx_gx2.cpp
+++ b/src/graphic/Fast3D/gfx_gx2.cpp
@@ -752,6 +752,10 @@ void gfx_gx2_select_texture_fb(int fb) {
     GX2SetPixelSampler(&buffer->sampler, location);
 }
 
+void gfx_gx2_copy_framebuffer(int fb_dst_id, int fb_src_id) {
+    // TODO: Implement framebuffer texture copy
+}
+
 static std::unordered_map<std::pair<float, float>, uint16_t, hash_pair_ff>
 gfx_gx2_get_pixel_depth(int fb_id, const std::set<std::pair<float, float>>& coordinates) {
     struct Framebuffer* buffer = (struct Framebuffer*)fb_id;
@@ -855,6 +859,7 @@ struct GfxRenderingAPI gfx_gx2_api = { gfx_gx2_get_name,
                                        gfx_gx2_create_framebuffer,
                                        gfx_gx2_update_framebuffer_parameters,
                                        gfx_gx2_start_draw_to_framebuffer,
+                                       gfx_gx2_copy_framebuffer,
                                        gfx_gx2_clear_framebuffer,
                                        gfx_gx2_resolve_msaa_color_buffer,
                                        gfx_gx2_get_pixel_depth,
diff --git a/src/graphic/Fast3D/gfx_metal.cpp b/src/graphic/Fast3D/gfx_metal.cpp
index 06461e47a..298e82b0f 100644
--- a/src/graphic/Fast3D/gfx_metal.cpp
+++ b/src/graphic/Fast3D/gfx_metal.cpp
@@ -103,6 +103,8 @@ struct FramebufferMetal {
     struct ShaderProgramMetal* last_shader_program;
     MTL::Texture* last_bound_textures[SHADER_MAX_TEXTURES];
     MTL::SamplerState* last_bound_samplers[SHADER_MAX_TEXTURES];
+    MTL::ScissorRect scissor_rect;
+    MTL::Viewport viewport;
 
     int8_t last_depth_test = -1;
     int8_t last_depth_mask = -1;
@@ -476,30 +478,29 @@ static void gfx_metal_set_zmode_decal(bool zmode_decal) {
 }
 
 static void gfx_metal_set_viewport(int x, int y, int width, int height) {
-    MTL::Viewport viewport;
-    viewport.originX = x;
-    viewport.originY = mctx.render_target_height - y - height;
-    viewport.width = width;
-    viewport.height = height;
-    viewport.znear = 0;
-    viewport.zfar = 1;
-
-    auto current_framebuffer = mctx.framebuffers[mctx.current_framebuffer];
-    current_framebuffer.command_encoder->setViewport(viewport);
+    FramebufferMetal& fb = mctx.framebuffers[mctx.current_framebuffer];
+
+    fb.viewport.originX = x;
+    fb.viewport.originY = mctx.render_target_height - y - height;
+    fb.viewport.width = width;
+    fb.viewport.height = height;
+    fb.viewport.znear = 0;
+    fb.viewport.zfar = 1;
+
+    fb.command_encoder->setViewport(fb.viewport);
 }
 
 static void gfx_metal_set_scissor(int x, int y, int width, int height) {
-    FramebufferMetal fb = mctx.framebuffers[mctx.current_framebuffer];
+    FramebufferMetal& fb = mctx.framebuffers[mctx.current_framebuffer];
     TextureDataMetal tex = mctx.textures[fb.texture_id];
 
-    MTL::ScissorRect rect;
     // clamp to viewport size as metal does not support larger values than viewport size
-    rect.x = std::max(0, std::min<int>(x, tex.width));
-    rect.y = std::max(0, std::min<int>(mctx.render_target_height - y - height, tex.height));
-    rect.width = std::max(0, std::min<int>(x + width, tex.width));
-    rect.height = std::max(0, std::min<int>(height, tex.height));
+    fb.scissor_rect.x = std::max(0, std::min<int>(x, tex.width));
+    fb.scissor_rect.y = std::max(0, std::min<int>(mctx.render_target_height - y - height, tex.height));
+    fb.scissor_rect.width = std::max(0, std::min<int>(x + width, tex.width));
+    fb.scissor_rect.height = std::max(0, std::min<int>(height, tex.height));
 
-    fb.command_encoder->setScissorRect(rect);
+    fb.command_encoder->setScissorRect(fb.scissor_rect);
 }
 
 static void gfx_metal_set_use_alpha(bool use_alpha) {
@@ -658,6 +659,8 @@ void gfx_metal_end_frame(void) {
             fb.last_bound_textures[i] = nullptr;
             fb.last_bound_samplers[i] = nullptr;
         }
+        memset(&fb.viewport, 0, sizeof(MTL::Viewport));
+        memset(&fb.scissor_rect, 0, sizeof(MTL::ScissorRect));
         fb.last_depth_test = -1;
         fb.last_depth_mask = -1;
         fb.last_zmode_decal = -1;
@@ -706,8 +709,7 @@ static void gfx_metal_setup_screen_framebuffer(uint32_t width, uint32_t height)
     MTL::RenderPassDescriptor* render_pass_descriptor = MTL::RenderPassDescriptor::renderPassDescriptor();
     MTL::ClearColor clear_color = MTL::ClearColor::Make(0, 0, 0, 1);
     render_pass_descriptor->colorAttachments()->object(0)->setTexture(tex.texture);
-    render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(msaa_enabled ? MTL::LoadActionLoad
-                                                                                      : MTL::LoadActionClear);
+    render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(MTL::LoadActionLoad);
     render_pass_descriptor->colorAttachments()->object(0)->setStoreAction(MTL::StoreActionStore);
     render_pass_descriptor->colorAttachments()->object(0)->setClearColor(clear_color);
 
@@ -813,14 +815,13 @@ static void gfx_metal_update_framebuffer_parameters(int fb_id, uint32_t width, u
             if (fb_msaa_enabled) {
                 render_pass_descriptor->colorAttachments()->object(0)->setTexture(tex.msaaTexture);
                 render_pass_descriptor->colorAttachments()->object(0)->setResolveTexture(tex.texture);
-                render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(MTL::LoadActionClear);
+                render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(MTL::LoadActionLoad);
                 render_pass_descriptor->colorAttachments()->object(0)->setStoreAction(
-                    MTL::StoreActionMultisampleResolve);
+                    MTL::StoreActionStoreAndMultisampleResolve);
                 render_pass_descriptor->colorAttachments()->object(0)->setClearColor(clear_color);
             } else {
                 render_pass_descriptor->colorAttachments()->object(0)->setTexture(tex.texture);
-                render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(
-                    fb_id == 0 && game_msaa_enabled ? MTL::LoadActionLoad : MTL::LoadActionClear);
+                render_pass_descriptor->colorAttachments()->object(0)->setLoadAction(MTL::LoadActionLoad);
                 render_pass_descriptor->colorAttachments()->object(0)->setStoreAction(MTL::StoreActionStore);
                 render_pass_descriptor->colorAttachments()->object(0)->setClearColor(clear_color);
             }
@@ -1017,6 +1018,70 @@ void gfx_metal_select_texture_fb(int fb_id) {
     gfx_metal_select_texture(tile, mctx.framebuffers[fb_id].texture_id);
 }
 
+void gfx_metal_copy_framebuffer(int fb_dst_id, int fb_src_id) {
+    if (fb_src_id >= (int)mctx.framebuffers.size() || fb_dst_id >= (int)mctx.framebuffers.size()) {
+        return;
+    }
+
+    FramebufferMetal& source_framebuffer = mctx.framebuffers[fb_src_id];
+
+    int source_texture_id = source_framebuffer.texture_id;
+    MTL::Texture* source_texture = mctx.textures[source_texture_id].texture;
+
+    int target_texture_id = mctx.framebuffers[fb_dst_id].texture_id;
+    MTL::Texture* target_texture = mctx.textures[target_texture_id].texture;
+
+    // Skip copying framebuffers that don't have the same width
+    if (source_texture->width() != target_texture->width()) {
+        return;
+    }
+
+    // End the current render encoder
+    source_framebuffer.command_encoder->endEncoding();
+
+    // Create a blit encoder
+    MTL::BlitCommandEncoder* blit_encoder = source_framebuffer.command_buffer->blitCommandEncoder();
+    blit_encoder->setLabel(NS::String::string("Copy Framebuffer Encoder", NS::UTF8StringEncoding));
+
+    MTL::Origin source_origin = MTL::Origin(0, 0, 0);
+    MTL::Origin target_origin = MTL::Origin(0, 0, 0);
+    MTL::Size source_size = MTL::Size(source_texture->width(), source_texture->height(), 1);
+
+    // Account for source framebuffer having the menu bar open
+    if (source_texture->height() > target_texture->height()) {
+        auto diff = source_texture->height() - target_texture->height();
+        source_size.height -= diff;
+        source_origin.y = diff;
+    }
+
+    // Copy the texture over using the origins and size
+    blit_encoder->copyFromTexture(source_texture, 0, 0, source_origin, source_size, target_texture, 0, 0,
+                                  target_origin);
+    blit_encoder->endEncoding();
+
+    // Create a new render encoder back onto the framebuffer
+    source_framebuffer.command_encoder =
+        source_framebuffer.command_buffer->renderCommandEncoder(source_framebuffer.render_pass_descriptor);
+
+    std::string fbce_label = fmt::format("FrameBuffer {} Command Encoder After Copy", fb_src_id);
+    source_framebuffer.command_encoder->setLabel(NS::String::string(fbce_label.c_str(), NS::UTF8StringEncoding));
+    source_framebuffer.command_encoder->setDepthClipMode(MTL::DepthClipModeClamp);
+    source_framebuffer.command_encoder->setViewport(source_framebuffer.viewport);
+    source_framebuffer.command_encoder->setScissorRect(source_framebuffer.scissor_rect);
+
+    // Reset the framebuffer so the encoder is setup again when rendering triangles
+    source_framebuffer.has_bounded_vertex_buffer = false;
+    source_framebuffer.has_bounded_fragment_buffer = false;
+    source_framebuffer.last_shader_program = nullptr;
+    for (int i = 0; i < SHADER_MAX_TEXTURES; i++) {
+        source_framebuffer.last_bound_textures[i] = nullptr;
+        source_framebuffer.last_bound_samplers[i] = nullptr;
+    }
+    source_framebuffer.last_depth_test = -1;
+    source_framebuffer.last_depth_mask = -1;
+    source_framebuffer.last_zmode_decal = -1;
+}
+
 void gfx_metal_set_texture_filter(FilteringMode mode) {
     mctx.current_filter_mode = mode;
     gfx_texture_cache_clear();
@@ -1056,6 +1121,7 @@ struct GfxRenderingAPI gfx_metal_api = { gfx_metal_get_name,
                                          gfx_metal_create_framebuffer,
                                          gfx_metal_update_framebuffer_parameters,
                                          gfx_metal_start_draw_to_framebuffer,
+                                         gfx_metal_copy_framebuffer,
                                          gfx_metal_clear_framebuffer,
                                          gfx_metal_resolve_msaa_color_buffer,
                                          gfx_metal_get_pixel_depth,
diff --git a/src/graphic/Fast3D/gfx_opengl.cpp b/src/graphic/Fast3D/gfx_opengl.cpp
index daea98d71..08679c584 100644
--- a/src/graphic/Fast3D/gfx_opengl.cpp
+++ b/src/graphic/Fast3D/gfx_opengl.cpp
@@ -999,9 +999,15 @@ void gfx_opengl_resolve_msaa_color_buffer(int fb_id_target, int fb_id_source) {
     Framebuffer& fb_src = framebuffers[fb_id_source];
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb_dst.fbo);
     glBindFramebuffer(GL_READ_FRAMEBUFFER, fb_src.fbo);
+
+    // Disabled for blit
+    glDisable(GL_SCISSOR_TEST);
+
     glBlitFramebuffer(0, 0, fb_src.width, fb_src.height, 0, 0, fb_dst.width, fb_dst.height, GL_COLOR_BUFFER_BIT,
                       GL_NEAREST);
     glBindFramebuffer(GL_FRAMEBUFFER, current_framebuffer);
+
+    glEnable(GL_SCISSOR_TEST);
 }
 
 void* gfx_opengl_get_framebuffer_texture_id(int fb_id) {
@@ -1014,6 +1020,78 @@ void gfx_opengl_select_texture_fb(int fb_id) {
     glBindTexture(GL_TEXTURE_2D, framebuffers[fb_id].clrbuf);
 }
 
+void gfx_opengl_copy_framebuffer(int fb_dst_id, int fb_src_id) {
+    if (fb_dst_id >= (int)framebuffers.size() || fb_src_id >= (int)framebuffers.size()) {
+        return;
+    }
+
+    Framebuffer& src = framebuffers[fb_src_id];
+    const Framebuffer& dst = framebuffers[fb_dst_id];
+
+    // Skip copying framebuffers that don't have the same width
+    if (src.width != dst.width) {
+        return;
+    }
+
+    int srcX0, srcY0, srcX1, srcY1;
+    int dstX0, dstY0, dstX1, dstY1;
+
+    dstX0 = dstY0 = 0;
+    dstX1 = dst.width;
+    dstY1 = dst.height;
+
+    srcX0 = 0;
+    srcY0 = 0;
+    srcX1 = src.width;
+    srcY1 = src.height;
+
+    // Account for source framebuffer having the menu bar open
+    if (src.height >= dst.height) {
+        srcY1 -= src.height - dst.height;
+    }
+
+    // flip vertically as openGLs origin is in the bottom left when compared to Fast3D
+    if (src.invert_y != dst.invert_y) {
+        std::swap(dstY0, dstY1);
+    }
+
+    // Disabled for blit
+    glDisable(GL_SCISSOR_TEST);
+
+    // For msaa enabled buffers we can't perform a scaled blit to a simple sample buffer
+    // First do an unscaled blit to main buffer to resolve the sample data
+    if (src.height != dst.height && src.width != dst.width && src.msaa_level > 1) {
+        // Since frambuffer 0 is considered the final single sample resolve for the MSAA buffer,
+        // and is only needed at the end of a frame, we can temporarily use it here without causing issues
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, src.fbo);
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+
+        glBlitFramebuffer(0, 0, src.width, src.height, 0, 0, src.width, src.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+
+        // Switch source buffer to the single sample
+        fb_src_id = 0;
+        src = framebuffers[0];
+    }
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, src.fbo);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dst.fbo);
+
+    // The 0 buffer is a double buffer so we need to choose the back to avoid imgui elements
+    if (fb_src_id == 0) {
+        glReadBuffer(GL_BACK);
+    } else {
+        glReadBuffer(GL_COLOR_ATTACHMENT0);
+    }
+
+    glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+
+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[current_framebuffer].fbo);
+
+    glReadBuffer(GL_BACK);
+
+    glEnable(GL_SCISSOR_TEST);
+}
+
 static std::unordered_map<std::pair<float, float>, uint16_t, hash_pair_ff>
 gfx_opengl_get_pixel_depth(int fb_id, const std::set<std::pair<float, float>>& coordinates) {
     std::unordered_map<std::pair<float, float>, uint16_t, hash_pair_ff> res;
@@ -1118,6 +1196,7 @@ struct GfxRenderingAPI gfx_opengl_api = { gfx_opengl_get_name,
                                           gfx_opengl_create_framebuffer,
                                           gfx_opengl_update_framebuffer_parameters,
                                           gfx_opengl_start_draw_to_framebuffer,
+                                          gfx_opengl_copy_framebuffer,
                                           gfx_opengl_clear_framebuffer,
                                           gfx_opengl_resolve_msaa_color_buffer,
                                           gfx_opengl_get_pixel_depth,
diff --git a/src/graphic/Fast3D/gfx_pc.cpp b/src/graphic/Fast3D/gfx_pc.cpp
index 593db7b3e..9a66ee9f0 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 @@ 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,23 +869,23 @@ 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;
-    uint32_t orig_size_bytes = rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].orig_size_bytes;
-
-    const RawTexMetadata* metadata = &rdp.loaded_texture[rdp.texture_tile[tile].tmem_index].raw_tex_metadata;
+    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;
+    uint32_t orig_size_bytes = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index].orig_size_bytes;
+
+    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, orig_size_bytes };
+        key = { orig_addr, { g_rdp.palettes[0], g_rdp.palettes[1] }, fmt, siz, palette_index, orig_size_bytes };
     } else {
         key = { orig_addr, {}, fmt, siz, palette_index, orig_size_bytes };
     }
@@ -1035,8 +941,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;
@@ -1059,10 +965,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;
@@ -1111,7 +1017,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);
 }
 
@@ -1155,37 +1061,41 @@ 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);
             }
         }
     }
+    g_rsp.lights_changed = true;
 }
 
 static float gfx_adjust_x_for_aspect_ratio(float x) {
@@ -1197,7 +1107,7 @@ static float gfx_adjust_x_for_aspect_ratio(float x) {
 }
 
 static void gfx_adjust_width_height_for_scale(uint32_t& width, uint32_t& height) {
-    width = round(width * RATIO_Y);
+    width = round(width * RATIO_X);
     height = round(height * RATIO_Y);
     if (width == 0) {
         width = 1;
@@ -1211,52 +1121,99 @@ 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];
+
+        float world_pos[3];
+        if (g_rsp.geometry_mode & G_LIGHTING_POSITIONAL) {
+            float(*mtx)[4] = g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1];
+            world_pos[0] = v->ob[0] * mtx[0][0] + v->ob[1] * mtx[1][0] + v->ob[2] * mtx[2][0] + mtx[3][0];
+            world_pos[1] = v->ob[0] * mtx[0][1] + v->ob[1] * mtx[1][1] + v->ob[2] * mtx[2][1] + mtx[3][1];
+            world_pos[2] = v->ob[0] * mtx[0][2] + v->ob[1] * mtx[1][2] + v->ob[2] * mtx[2][2] + mtx[3][2];
+        }
 
         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].l, 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].l.col[0];
+            int g = g_rsp.current_lights[g_rsp.current_num_lights - 1].l.col[1];
+            int b = g_rsp.current_lights[g_rsp.current_num_lights - 1].l.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 /= 127.0f;
+                if ((g_rsp.geometry_mode & G_LIGHTING_POSITIONAL) && (g_rsp.current_lights[i].p.unk3 != 0)) {
+                    // Calculate distance from the light to the vertex
+                    float dist_vec[3] = { g_rsp.current_lights[i].p.pos[0] - world_pos[0],
+                                          g_rsp.current_lights[i].p.pos[1] - world_pos[1],
+                                          g_rsp.current_lights[i].p.pos[2] - world_pos[2] };
+                    float dist_sq =
+                        dist_vec[0] * dist_vec[0] + dist_vec[1] * dist_vec[1] +
+                        dist_vec[2] * dist_vec[2] * 2; // The *2 comes from GLideN64, unsure of why it does it
+                    float dist = sqrt(dist_sq);
+
+                    // Transform distance vector (which acts as a direction light vector) into model's space
+                    float light_model[3];
+                    gfx_transposed_matrix_mul(light_model, dist_vec,
+                                              g_rsp.modelview_matrix_stack[g_rsp.modelview_matrix_stack_size - 1]);
+
+                    // Calculate intensity for each axis using standard formula for intensity
+                    float light_intensity[3];
+                    for (int light_i = 0; light_i < 3; light_i++) {
+                        light_intensity[light_i] = 4.0f * light_model[light_i] / dist_sq;
+                        light_intensity[light_i] = clamp(light_intensity[light_i], -1.0f, 1.0f);
+                    }
+
+                    // Adjust intensity based on surface normal and sum up total
+                    float total_intensity =
+                        light_intensity[0] * vn->n[0] + light_intensity[1] * vn->n[1] + light_intensity[2] * vn->n[2];
+                    total_intensity = clamp(total_intensity, -1.0f, 1.0f);
+
+                    // Attenuate intensity based on attenuation values.
+                    // Example formula found at https://ogldev.org/www/tutorial20/tutorial20.html
+                    // Specific coefficients for MM's microcode sourced from GLideN64
+                    // https://github.com/gonetz/GLideN64/blob/3b43a13a80dfc2eb6357673440b335e54eaa3896/src/gSP.cpp#L636
+                    float distf = floorf(dist);
+                    float attenuation = (distf * g_rsp.current_lights[i].p.unk7 * 2.0f +
+                                         distf * distf * g_rsp.current_lights[i].p.unkE / 8.0f) /
+                                            (float)0xFFFF +
+                                        1.0f;
+                    intensity = total_intensity / attenuation;
+                } else {
+                    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].l.col[0];
+                    g += intensity * g_rsp.current_lights[i].l.col[1];
+                    b += intensity * g_rsp.current_lights[i].l.col[2];
                 }
             }
 
@@ -1264,14 +1221,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;
@@ -1279,7 +1236,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;
@@ -1292,8 +1249,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];
@@ -1328,7 +1285,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;
@@ -1339,7 +1296,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 {
@@ -1354,15 +1311,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;
@@ -1372,7 +1329,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);
@@ -1386,11 +1343,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;
@@ -1407,8 +1364,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();
@@ -1416,39 +1373,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;
@@ -1478,16 +1435,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;
     }
 
@@ -1497,7 +1454,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);
@@ -1506,32 +1463,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;
@@ -1547,8 +1504,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);
@@ -1562,13 +1519,13 @@ 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();
 
                 // Set the same sampler params on the blended texture. Needed for opengl.
-                if (rdp.loaded_texture[i].blended) {
+                if (g_rdp.loaded_texture[i].blended) {
                     gfx_rapi->set_sampler_parameters(SHADER_FIRST_REPLACEMENT_TEXTURE + i, linear_filter, cms, cmt);
                 }
 
@@ -1621,8 +1578,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;
@@ -1638,10 +1595,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;
@@ -1674,17 +1631,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++) {
@@ -1695,31 +1652,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) {
@@ -1736,7 +1693,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:
@@ -1779,13 +1736,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) {
@@ -1804,9 +1761,9 @@ static void gfx_adjust_viewport_or_scissor(XYWidthHeight* area) {
                        (gfx_current_game_window_viewport.y + gfx_current_game_window_viewport.height);
         }
     } else {
-        area->width *= RATIO_Y;
+        area->width *= RATIO_X;
         area->height *= RATIO_Y;
-        area->x *= RATIO_Y;
+        area->x *= RATIO_X;
         area->y = active_fb->second.orig_height - area->y;
         area->y *= RATIO_Y;
     }
@@ -1819,14 +1776,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) {
@@ -1837,8 +1794,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
@@ -1846,9 +1803,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));
             } else if (lightidx < 0) {
-                memcpy(rsp.lookat + offset / 24, data, sizeof(Light_t));
+                memcpy(g_rsp.lookat + offset / 24, data, sizeof(Light_t)); // TODO Light?
             }
             break;
         }
@@ -1857,7 +1814,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
     }
@@ -1867,34 +1824,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) {
@@ -1903,23 +1860,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,
@@ -1935,50 +1894,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;
     }
 }
 
@@ -1989,9 +1946,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;
@@ -2003,44 +1960,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;
@@ -2059,7 +2020,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;
@@ -2069,8 +2030,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);
@@ -2079,36 +2040,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) {
@@ -2140,11 +2101,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) {
@@ -2156,32 +2117,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) {
@@ -2190,18 +2151,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
@@ -2218,10 +2179,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;
@@ -2245,32 +2206,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;
@@ -2296,10 +2257,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;
@@ -2316,28 +2277,74 @@ 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;
+    }
+    g_rdp.first_tile_index = saved_tile;
+    g_rdp.combine_mode = saved_combine_mode;
+}
+
+static void gfx_dp_image_rectangle(int32_t tile, int32_t w, int32_t h, int32_t ulx, int32_t uly, int16_t uls,
+                                   int16_t ult, int32_t lrx, int32_t lry, int16_t lrs, int16_t lrt) {
+
+    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 * 32;
+    ul->v = ult * 32;
+    lr->u = lrs * 32;
+    lr->v = lrt * 32;
+    ll->u = uls * 32;
+    ll->v = lrt * 32;
+    ur->u = lrs * 32;
+    ur->v = ult * 32;
+
+    // ensure we have the correct texture size, format and starting position
+    g_rdp.texture_tile[tile].siz = G_IM_SIZ_8b;
+    g_rdp.texture_tile[tile].fmt = G_IM_FMT_RGBA;
+    g_rdp.texture_tile[tile].cms = 0;
+    g_rdp.texture_tile[tile].cmt = 0;
+    g_rdp.texture_tile[tile].shifts = 0;
+    g_rdp.texture_tile[tile].shiftt = 0;
+    g_rdp.texture_tile[tile].uls = 0;
+    g_rdp.texture_tile[tile].ult = 0;
+    g_rdp.texture_tile[tile].line_size_bytes = w << (g_rdp.texture_tile[tile].siz >> 1);
+
+    auto& loadtex = g_rdp.loaded_texture[g_rdp.texture_tile[tile].tmem_index];
+    loadtex.full_image_line_size_bytes = loadtex.line_size_bytes = g_rdp.texture_tile[tile].line_size_bytes;
+    loadtex.size_bytes = loadtex.orig_size_bytes = loadtex.line_size_bytes * h;
+
+    uint8_t saved_tile = g_rdp.first_tile_index;
+    if (saved_tile != tile) {
+        g_rdp.textures_changed[0] = true;
+        g_rdp.textures_changed[1] = true;
+    }
+    g_rdp.first_tile_index = tile;
+
+    gfx_draw_rectangle(ulx, uly, lrx, lry);
+    if (saved_tile != tile) {
+        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;
 }
 
 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)) {
@@ -2354,39 +2361,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) {
@@ -2443,16 +2450,58 @@ static void gfx_s2dex_bg_copy(uObjBg* bg) {
                              false);
 }
 
+static void gfx_s2dex_bg_1cyc(uObjBg* bg) {
+    uintptr_t data = (uintptr_t)bg->b.imagePtr;
+
+    uint32_t texFlags = 0;
+    RawTexMetadata rawTexMetadata = {};
+
+    if ((bool)gfx_check_image_signature((char*)data)) {
+        std::shared_ptr<LUS::Texture> tex = std::static_pointer_cast<LUS::Texture>(
+            LUS::Context::GetInstance()->GetResourceManager()->LoadResourceProcess((char*)data));
+        texFlags = tex->Flags;
+        rawTexMetadata.width = tex->Width;
+        rawTexMetadata.height = tex->Height;
+        rawTexMetadata.h_byte_scale = tex->HByteScale;
+        rawTexMetadata.v_pixel_scale = tex->VPixelScale;
+        rawTexMetadata.type = tex->Type;
+        rawTexMetadata.resource = tex;
+        data = (uintptr_t) reinterpret_cast<char*>(tex->ImageData);
+    }
+
+    // TODO: Implement bg scaling correctly
+    s16 uls = bg->b.imageX >> 2;
+    s16 lrs = bg->b.imageW >> 2;
+
+    s16 dsdxRect = 1 << 10;
+    s16 ulsRect = bg->b.imageX << 3;
+    // Flip flag only flips horizontally
+    if (bg->b.imageFlip == G_BG_FLAG_FLIPS) {
+        dsdxRect = -dsdxRect;
+        ulsRect = (bg->b.imageW - bg->b.imageX) << 3;
+    }
+
+    gfx_dp_set_texture_image(bg->b.imageFmt, bg->b.imageSiz, bg->b.imageW >> 2, nullptr, texFlags, rawTexMetadata,
+                             (void*)data);
+    gfx_dp_set_tile(bg->b.imageFmt, bg->b.imageSiz, 0, 0, G_TX_LOADTILE, 0, 0, 0, 0, 0, 0, 0);
+    gfx_dp_load_block(G_TX_LOADTILE, 0, 0, (bg->b.imageW * bg->b.imageH >> 4) - 1, 0);
+    gfx_dp_set_tile(bg->b.imageFmt, bg->b.imageSiz, (((lrs - uls) * bg->b.imageSiz) + 7) >> 3, 0, G_TX_RENDERTILE,
+                    bg->b.imagePal, 0, 0, 0, 0, 0, 0);
+    gfx_dp_set_tile_size(G_TX_RENDERTILE, 0, 0, bg->b.imageW, bg->b.imageH);
+
+    gfx_dp_texture_rectangle(bg->b.frameX, bg->b.frameY, bg->b.frameW, bg->b.frameH, G_TX_RENDERTILE, ulsRect,
+                             bg->b.imageY << 3, dsdxRect, 1 << 10, false);
+}
+
 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 (segmentPointers[segNum] != 0) {
-            return (void*)(segmentPointers[segNum] + offset);
+        if (gSegmentPointers[segNum] != 0) {
+            return (void*)(gSegmentPointers[segNum] + offset);
         } else {
             return (void*)w1;
         }
@@ -2466,612 +2515,740 @@ 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();
+}
 
-    Gfx* dListStart = cmd;
-    uint64_t ourHash = -1;
+void GfxExecStack::stop() {
+    while (!cmd_stack.empty())
+        cmd_stack.pop();
+    gfx_path.clear();
+}
 
-    for (;;) {
-        uint32_t opcode = cmd->words.w0 >> 24;
-        // uint32_t opcode = cmd->words.w0 & 0xFF;
+Gfx*& GfxExecStack::currCmd() {
+    return cmd_stack.top();
+}
 
-        // if (markerOn)
-        // printf("OP: %02X\n", opcode);
+void GfxExecStack::openDisp(const char* file, int line) {
+    disp_stack.push_back({ file, line });
+}
+void GfxExecStack::closeDisp() {
+    disp_stack.pop_back();
+}
+const std::vector<GfxExecStack::CodeDisp>& GfxExecStack::getDisp() const {
+    return disp_stack;
+}
 
-        switch (opcode) {
-                // RSP commands:
-            case G_LOAD_UCODE:
-                rsp.fog_mul = 0;
-                rsp.fog_offset = 0;
-                break;
-            case G_MARKER: {
-                cmd++;
+void GfxExecStack::branch(Gfx* caller) {
+    Gfx* old = cmd_stack.top();
+    cmd_stack.pop();
+    cmd_stack.push(nullptr);
+    cmd_stack.push(old);
 
-                ourHash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+    gfx_path.push_back(caller);
+}
 
-#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
+void GfxExecStack::call(Gfx* caller, Gfx* callee) {
+    cmd_stack.push(callee);
+    gfx_path.push_back(caller);
+}
+
+Gfx* GfxExecStack::ret() {
+    Gfx* cmd = cmd_stack.top();
 
-                markerOn = true;
-            } break;
-            case G_INVALTEXCACHE: {
-                uintptr_t texAddr = cmd->words.w1;
+    cmd_stack.pop();
+    if (!gfx_path.empty()) {
+        gfx_path.pop_back();
+    }
+
+    while (cmd_stack.size() > 0 && cmd_stack.top() == nullptr) {
+        cmd_stack.pop();
+        if (!gfx_path.empty()) {
+            gfx_path.pop_back();
+        }
+    }
+    return cmd;
+}
 
-                if (texAddr == 0) {
-                    gfx_texture_cache_clear();
+void gfx_set_framebuffer(int fb, float noise_scale);
+void gfx_reset_framebuffer();
+void gfx_copy_framebuffer(int fb_dst_id, int fb_src_id, bool copyOnce, bool* hasCopiedPtr);
+
+static void gfx_step(GfxExecStack& exec_stack) {
+    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++;
+
+            // ourHash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+
+            {
+                uint64_t hash = ((uint64_t)cmd->words.w0 << 32) + cmd->words.w1;
+                std::string dlName = ResourceGetNameByCrc(hash);
+            }
+
+            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 {
-                    gfx_texture_cache_delete((const uint8_t*)texAddr);
-                }
-            } 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;
+                    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;
-                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();
+            }
+        } 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) {
+                exec_stack.call(cmd0, nDL);
+            } else {
+                if (nDL != nullptr) {
+                    cmd = nDL;
+                    exec_stack.branch(cmd0);
+                    return; // shortcut cmd increment
                 } else {
-                    if (nDL != nullptr) {
-                        cmd = nDL;
-                    } else {
-                        return;
-                    }
-                    --cmd; // increase after break
+                    assert(0 && "???");
+                    // gfx_path.pop_back();
+                    // 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
+            }
+        } 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) {
+                    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
+            }
+        } break;
+        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) {
+                    exec_stack.call(cmd0, gfx);
                 }
-                break;
-            case G_PUSHCD:
-                gfx_push_current_dir((char*)cmd->words.w1);
-                break;
-            case G_BRANCH_Z_OTR: {
+            } else {
+                assert(0 && "????");
+                cmd = (Gfx*)seg_addr(cmd->words.w1);
+                return;
+            }
+            break;
+        case G_DL_INDEX: {
+            // Compute seg addr by converting an index value to a offset value
+            // handling 32 vs 64 bit size differences for Gfx
+            // adding 1 to trigger the segaddr flow
+            uint32_t segNum = cmd->words.w1 >> 24;
+            uint32_t index = cmd->words.w1 & 0x00FFFFFF;
+            uintptr_t segAddr = (segNum << 24) | (index * sizeof(Gfx)) + 1;
+
+            Gfx* subGFX = (Gfx*)seg_addr(segAddr);
+            if (C0(16, 1) == 0) {
                 // Push return address
+                if (subGFX != nullptr) {
+                    exec_stack.call(cmd0, subGFX);
+                }
+            } else {
+                cmd = subGFX;
+                exec_stack.branch(cmd0);
+                return; // shortcut cmd increment
+            }
+        } break;
+        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;
+            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;
 
-                        if (ourHash != (uint64_t)-1) {
-                            auto res = ResourceLoad(ourHash);
-                        }
+                    // if (ourHash != (uint64_t)-1) {
+                    //     auto res = ResourceLoad(ourHash);
+                    // }
 
-                        cmd++;
-                    }
+                    cmd++;
+                }
 
-                    cmd--;
+                cmd--;
 
-                    uint32_t fmt = C0(21, 3);
-                    uint32_t size = C0(19, 2);
-                    uint32_t width = C0(0, 10);
+                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);
-                    }
-                } else {
-                    SPDLOG_ERROR("G_SETTIMG_OTR_HASH: Texture is null");
+                if (tex != NULL) {
+                    gfx_dp_set_texture_image(fmt, size, width, fileName, texFlags, rawTexMetadata, tex);
                 }
-
-                cmd++;
-                break;
+            } else {
+                SPDLOG_ERROR("G_SETTIMG_OTR_HASH: Texture is null");
             }
-            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");
-                }
-                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_SETFB: {
-                gfx_flush();
-                fbActive = 1;
+            break;
+        }
+        case G_SETFB: {
+            gfx_flush();
+
+            if (cmd->words.w1) {
+                gfx_set_framebuffer(cmd->words.w1, 1.0f);
                 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;
+                fbActive = true;
+            } else {
+                gfx_reset_framebuffer();
+                fbActive = false;
+                active_fb = framebuffers.end();
             }
-            case G_SETTIMG_FB: {
-                gfx_flush();
-                gfx_rapi->select_texture_fb(cmd->words.w1);
-                rdp.textures_changed[0] = false;
-                rdp.textures_changed[1] = false;
+            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_COPYFB: {
+            bool* hasCopiedPtr = (bool*)cmd->words.w1;
 
-                // 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;
-            }
-            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;
+            gfx_flush();
+            gfx_copy_framebuffer(C0(11, 11), C0(0, 11), (bool)C0(22, 1), hasCopiedPtr);
+
+            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_IMAGERECT: {
+            int16_t tile, iw, ih;
+            int16_t x0, y0, s0, t0;
+            int16_t x1, y1, s1, t1;
+            tile = C0(0, 3);
+            iw = C1(16, 16);
+            ih = C1(0, 16);
+            ++cmd;
+            x0 = C0(16, 16);
+            y0 = C0(0, 16);
+            s0 = C1(16, 16);
+            t0 = C1(0, 16);
+            ++cmd;
+            x1 = C0(16, 16);
+            y1 = C0(0, 16);
+            s1 = C1(16, 16);
+            t1 = C1(0, 16);
+            gfx_dp_image_rectangle(tile, iw, ih, x0, y0, s0, t0, x1, y1, s1, t1);
+            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_BG_1CYC:
+            gfx_s2dex_bg_1cyc((uObjBg*)cmd->words.w1);
+            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) {
@@ -3099,7 +3276,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) {
@@ -3114,9 +3291,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) {
@@ -3174,6 +3351,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();
 
@@ -3205,10 +3384,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_back(cmd);
+            if (dbg->HasBreakPoint(g_exec_stack.gfx_path)) {
+                break;
+            }
+            g_exec_stack.gfx_path.pop_back();
+        }
+        gfx_step(g_exec_stack);
+    }
     gfx_flush();
     gfxFramebuffer = 0;
     currentDir = std::stack<std::string>();
@@ -3253,7 +3446,7 @@ void gfx_set_maximum_frame_latency(int latency) {
     gfx_wapi->set_maximum_frame_latency(latency);
 }
 
-int gfx_create_framebuffer(uint32_t width, uint32_t height) {
+extern "C" int gfx_create_framebuffer(uint32_t width, uint32_t height) {
     uint32_t orig_width = width, orig_height = height;
     gfx_adjust_width_height_for_scale(width, height);
     int fb = gfx_rapi->create_framebuffer();
@@ -3267,12 +3460,32 @@ void gfx_set_framebuffer(int fb, float noise_scale) {
     gfx_rapi->clear_framebuffer();
 }
 
+void gfx_copy_framebuffer(int fb_dst_id, int fb_src_id, bool copyOnce, bool* hasCopiedPtr) {
+    // Do not copy again if we have already copied before
+    if (copyOnce && hasCopiedPtr != nullptr && *hasCopiedPtr) {
+        return;
+    }
+
+    if (fb_src_id == 0 && gfx_msaa_level > 1) {
+        // read from the framebuffer we've been rendering to
+        fb_src_id = game_framebuffer;
+    }
+
+    gfx_rapi->copy_framebuffer(fb_dst_id, fb_src_id);
+
+    // Set the copied pointer if we have one
+    if (hasCopiedPtr != nullptr) {
+        *hasCopiedPtr = true;
+    }
+}
+
 void gfx_reset_framebuffer() {
     gfx_rapi->start_draw_to_framebuffer(0, (float)gfx_current_dimensions.height / SCREEN_HEIGHT);
+    gfx_rapi->clear_framebuffer();
 }
 
 static void adjust_pixel_depth_coordinates(float& x, float& y) {
-    x = x * RATIO_Y - (SCREEN_WIDTH * RATIO_Y - gfx_current_dimensions.width) / 2;
+    x = x * RATIO_X - (SCREEN_WIDTH * RATIO_X - gfx_current_dimensions.width) / 2;
     y *= RATIO_Y;
     if (!game_renders_to_framebuffer ||
         (gfx_msaa_level > 1 && gfx_current_dimensions.width == gfx_current_game_window_viewport.width &&
diff --git a/src/graphic/Fast3D/gfx_pc.h b/src/graphic/Fast3D/gfx_pc.h
index de14a1b02..e8ac32bda 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
@@ -63,6 +68,135 @@ struct TextureCacheMapIter {
     TextureCacheMap::iterator it;
 };
 
+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)
+    std::vector<const Gfx*> gfx_path = {};
+    struct CodeDisp {
+        const char* file;
+        int line;
+    };
+    // stack for OpenDisp/CloseDisps
+    std::vector<CodeDisp> disp_stack{};
+
+    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 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/graphic/Fast3D/gfx_rendering_api.h b/src/graphic/Fast3D/gfx_rendering_api.h
index a99a9d448..ffebde5f9 100644
--- a/src/graphic/Fast3D/gfx_rendering_api.h
+++ b/src/graphic/Fast3D/gfx_rendering_api.h
@@ -58,6 +58,7 @@ struct GfxRenderingAPI {
                                           bool opengl_invert_y, bool render_target, bool has_depth_buffer,
                                           bool can_extract_depth);
     void (*start_draw_to_framebuffer)(int fb_id, float noise_scale);
+    void (*copy_framebuffer)(int fb_dst_id, int fb_src_id);
     void (*clear_framebuffer)(void);
     void (*resolve_msaa_color_buffer)(int fb_id_target, int fb_id_source);
     std::unordered_map<std::pair<float, float>, uint16_t, hash_pair_ff> (*get_pixel_depth)(
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/type/Texture.h b/src/resource/type/Texture.h
index 8d09bf108..71e0b0cd9 100644
--- a/src/resource/type/Texture.h
+++ b/src/resource/type/Texture.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "resource/Resource.h"
-#include "libultraship/libultra/types.h"
 
 #define TEX_FLAG_LOAD_AS_RAW (1 << 0)
 
diff --git a/src/window/gui/GfxDebuggerWindow.cpp b/src/window/gui/GfxDebuggerWindow.cpp
new file mode 100644
index 000000000..51d043925
--- /dev/null
+++ b/src/window/gui/GfxDebuggerWindow.cpp
@@ -0,0 +1,514 @@
+#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 <graphic/Fast3D/gfx_pc.h>
+#ifdef GFX_DEBUG_DISASSEMBLER
+#include <gfxd.h>
+#endif
+
+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);
+        CASE(G_IMAGERECT);
+        CASE(G_COPYFB);
+        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))
+
+// static int s_dbgcnt = 0;
+void GfxDebuggerWindow::DrawDisasNode(const Gfx* cmd, std::vector<const Gfx*>& 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_back(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_back();
+    };
+
+    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) {
+#ifdef GFX_DEBUG_DISASSEMBLER
+            // Our Gfx uses uinptr_t for words, but libgfxd uses uint32_t,
+            // Copy only the first 32bits of each word into a vector before passing the instructions
+            std::vector<uint32_t> input;
+            for (size_t i = 0; i < size; i++) {
+                input.push_back(cmd[i].words.w0 & 0xFFFFFFFF);
+                input.push_back(cmd[i].words.w1 & 0xFFFFFFFF);
+            }
+
+            gfxd_input_buffer(input.data(), sizeof(uint32_t) * size * 2);
+            gfxd_endian(gfxd_endian_host, 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
+            node_with_text(cmd, fmt::format("{}", opname));
+#endif
+        } 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;
+            }
+
+            case G_IMAGERECT: {
+                node_with_text(cmd0, fmt::format("G_IMAGERECT"));
+                cmd += 3;
+                break;
+            }
+
+            case G_SETTIMG_FB: {
+                node_with_text(cmd0, fmt::format("G_SETTIMG_FB: src {}", cmd->words.w1));
+                cmd++;
+                break;
+            }
+
+            case G_COPYFB: {
+                node_with_text(cmd0, fmt::format("G_COPYFB: src {}, dest {}, new frames only {}", C0(0, 11), C0(11, 11),
+                                                 C0(22, 1)));
+                cmd++;
+                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: __asan_on_error
+
+void GfxDebuggerWindow::DrawDisas() {
+
+    auto dbg = LUS::Context::GetInstance()->GetGfxDebugger();
+    auto dlist = dbg->GetDisplayList();
+    ImGui::Text("dlist: %p", dlist);
+    std::string bp = "";
+    for (auto& gfx : dbg->GetBreakPoint()) {
+        bp += fmt::format("/{}", (const void*)gfx);
+    }
+    ImGui::Text("BreakPoint: %s", bp.c_str());
+
+    bool isNew = !bpEquals(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) {
+                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::Text("Loaded Textures");
+            for (size_t i = 0; i < 2; i++) {
+                auto& tex = g_rdp.loaded_texture[i];
+                // ImGui::Text("%s", fmt::format("{}: {}x{} type={}", i, tex.raw_tex_metadata.width,
+                //                               tex.raw_tex_metadata.height, getTexType(tex.raw_tex_metadata.type))
+                //                       .c_str());
+                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;
+                // ImGui::Text("%s", fmt::format("{}x{} type={}", tex.raw_tex_metadata.width,
+                // tex.raw_tex_metadata.height,
+                //                               getTexType(tex.raw_tex_metadata.type))
+                //                       .c_str());
+
+                // if (isNew && g_rdp.texture_to_load.raw_tex_metadata.resource != nullptr) {
+                //     gui->UnloadTexture(TO_LOAD_TEX);
+                //     gui->LoadGuiTexture(TO_LOAD_TEX, *g_rdp.texture_to_load.raw_tex_metadata.resource,
+                //                         ImVec4{ 1.0f, 1.0f, 1.0f, 1.0f });
+                // }
+
+                // ImGui::Image(gui->GetTextureByName(TO_LOAD_TEX), ImVec2{ 100.0f, 100.0f });
+                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::EndChild();
+
+    ImGui::BeginChild("##Disassembler", ImVec2(0.0f, 0.0f), true);
+    {
+        std::vector<const Gfx*> 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);
+    // const ImVec2 pos = ImGui::GetWindowPos();
+    // const ImVec2 size = ImGui::GetWindowSize();
+
+    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..d1030d8b8
--- /dev/null
+++ b/src/window/gui/GfxDebuggerWindow.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "window/gui/GuiWindow.h"
+#include "libultraship/libultra/gbi.h"
+#include <vector>
+
+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, std::vector<const Gfx*>& gfx_path) const;
+    void DrawDisas();
+
+  private:
+    std::vector<const Gfx*> mLastBreakPoint = {};
+};
+
+} // namespace LUS
diff --git a/src/window/gui/Gui.cpp b/src/window/gui/Gui.cpp
index 85affad02..a4cef5437 100644
--- a/src/window/gui/Gui.cpp
+++ b/src/window/gui/Gui.cpp
@@ -17,6 +17,8 @@
 #include "window/gui/Fonts.h"
 #include "window/gui/resource/GuiTextureFactory.h"
 
+#include "window/gui/GfxDebuggerWindow.h"
+
 #ifdef __WIIU__
 #include <gx2/registers.h> // GX2SetViewport / GX2SetScissor
 
@@ -81,6 +83,7 @@ Gui::Gui(std::shared_ptr<GuiWindow> customInputEditorWindow) : mNeedsConsoleVari
     AddGuiWindow(
         std::make_shared<ControllerReorderingWindow>("gControllerReorderingWindowEnabled", "Controller Reordering"));
     AddGuiWindow(std::make_shared<ConsoleWindow>("gConsoleEnabled", "Console"));
+    AddGuiWindow(std::make_shared<GfxDebuggerWindow>("gGfxDebuggerEnabled", "GfxDebuggerWindow"));
 }
 
 Gui::Gui() : Gui(nullptr) {
@@ -149,6 +152,7 @@ void Gui::Init(GuiWindowInitData windowImpl) {
     GetGuiWindow("Stats")->Init();
     GetGuiWindow("Input Editor")->Init();
     GetGuiWindow("Console")->Init();
+    GetGuiWindow("GfxDebuggerWindow")->Init();
     GetGameOverlay()->Init();
 
     Context::GetInstance()->GetResourceManager()->GetResourceLoader()->RegisterResourceFactory(
@@ -772,32 +776,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);
@@ -806,9 +834,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;
         }
     }
@@ -822,16 +901,32 @@ void Gui::LoadGuiTexture(const std::string& name, const std::string& path, const
 
     GuiTextureMetadata 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)) {
+        GuiTextureMetadata 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 9ebd04fd7..c3dd0ca0f 100644
--- a/src/window/gui/Gui.h
+++ b/src/window/gui/Gui.h
@@ -18,6 +18,7 @@
 #include "window/gui/GuiWindow.h"
 #include "window/gui/GuiMenuBar.h"
 #include "libultraship/libultra/controller.h"
+#include "resource/type/Texture.h"
 #include "window/gui/resource/GuiTexture.h"
 
 namespace LUS {
@@ -78,6 +79,8 @@ class Gui {
     void RemoveGuiWindow(const std::string& name);
     void LoadGuiTexture(const std::string& name, const std::string& path, const ImVec4& tint);
     bool HasTextureByName(const std::string& name);
+    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);
     ImVec2 GetTextureSize(const std::string& name);
     bool SupportsViewports();