From f818fb5299980e5630d490140b325c228f9776b8 Mon Sep 17 00:00:00 2001
From: Random <28494085+Random0666@users.noreply.github.com>
Date: Sat, 4 Apr 2020 18:12:59 +0200
Subject: Decompile graph.c

- decompile `graph.c` (2 non-matchings left)
- decompile `z_game_dlftbls.c`
- add noop macros in `gbi.h`
---
 src/code/graph.c           | 558 +++++++++++++++++++++++++++++++++++++++++++++
 src/code/z_actor.c         |  90 ++++----
 src/code/z_cheap_proc.c    |   8 +-
 src/code/z_debug.c         |   8 +-
 src/code/z_debug_display.c |   8 +-
 src/code/z_demo.c          |   8 +-
 src/code/z_draw.c          | 104 ++++-----
 src/code/z_eff_blure.c     |   4 +-
 src/code/z_en_a_keep.c     |   4 +-
 src/code/z_en_item00.c     |  16 +-
 src/code/z_game_dlftbls.c  |  26 +++
 src/code/z_lifemeter.c     |   4 +-
 src/code/z_map_mark.c      |   4 +-
 src/code/z_moji.c          |   8 +-
 src/code/z_parameter.c     |  28 +--
 src/code/z_prenmi.c        |   4 +-
 src/code/z_rcp.c           | 190 +++++++--------
 src/code/z_room.c          |  16 +-
 src/code/z_sample.c        |   4 +-
 src/code/z_scene_table.c   | 208 ++++++++---------
 src/code/z_skelanime.c     |  32 +--
 21 files changed, 958 insertions(+), 374 deletions(-)
 create mode 100644 src/code/graph.c
 create mode 100644 src/code/z_game_dlftbls.c

(limited to 'src/code')

diff --git a/src/code/graph.c b/src/code/graph.c
new file mode 100644
index 000000000..a26d9e9f1
--- /dev/null
+++ b/src/code/graph.c
@@ -0,0 +1,558 @@
+#include <global.h>
+#include <ultra64/hardware.h>
+#include <sched.h>
+#include <vt.h>
+#include <PR/os_cont.h>
+
+#define GFXPOOL_HEAD_MAGIC  0x1234
+#define GFXPOOL_TAIL_MAGIC  0x5678
+
+OSTime sGraph_UpdateTime;
+OSTime sGraphSetTaskTime;
+FaultClient sGraphFaultClient;
+CfbInfo sGraphCfbInfos[3];
+FaultClient sGraphUcodeFaultClient;
+
+UcodeInfo D_8012D230[3] = {
+    { 1, D_80155F50 },
+    { 2, NULL },
+    { 3, D_801120C0+0xFB0 }, // D_80113070
+};
+
+UcodeInfo D_8012D248[3] = {
+    { 1, D_80155F50 },
+    { 2, NULL },
+    { 3, D_801120C0+0xFB0 }, // D_80113070
+};
+
+void Graph_FaultClient()
+{
+    void* nextFb;
+    void* newFb;
+
+    nextFb = osViGetNextFramebuffer();
+    newFb = ((u32)SysCfb_GetFbPtr(0) != (u32)nextFb)
+        ? SysCfb_GetFbPtr(0)
+        : SysCfb_GetFbPtr(1);
+    
+    osViSwapBuffer(newFb);
+    Fault_WaitForInput();
+    osViSwapBuffer(nextFb);
+}
+
+void Graph_DisassembleUCode(void* arg0)
+{
+    UcodeDisas disassembler;
+
+    if (HREG(80) == 7 && HREG(81) != 0)
+    {
+        func_800D7F5C(&disassembler);
+        disassembler.enableLog = HREG(83);
+        func_800DAC80(&disassembler, 3, D_8012D230);
+        func_800DAC90(&disassembler, D_80155F50);
+        func_800D8400(&disassembler, arg0);
+        HREG(93) = disassembler.dl_cnt;
+        HREG(84) = disassembler.tri2_cnt * 2 + disassembler.tri1_cnt + (disassembler.quad_cnt * 2) + disassembler.line_cnt;
+        HREG(85) = disassembler.vtx_cnt;
+        HREG(86) = disassembler.spvtx_cnt;
+        HREG(87) = disassembler.tri1_cnt;
+        HREG(88) = disassembler.tri2_cnt;
+        HREG(89) = disassembler.quad_cnt;
+        HREG(90) = disassembler.line_cnt;
+        HREG(91) = disassembler.sync_err;
+        HREG(92) = disassembler.loaducode_cnt;
+        if (HREG(82) == 1 || HREG(82) == 2)
+        {
+            osSyncPrintf("vtx_cnt=%d\n", disassembler.vtx_cnt);
+            osSyncPrintf("spvtx_cnt=%d\n", disassembler.spvtx_cnt);
+            osSyncPrintf("tri1_cnt=%d\n", disassembler.tri1_cnt);
+            osSyncPrintf("tri2_cnt=%d\n", disassembler.tri2_cnt);
+            osSyncPrintf("quad_cnt=%d\n", disassembler.quad_cnt);
+            osSyncPrintf("line_cnt=%d\n", disassembler.line_cnt);
+            osSyncPrintf("sync_err=%d\n", disassembler.sync_err);
+            osSyncPrintf("loaducode_cnt=%d\n", disassembler.loaducode_cnt);
+            osSyncPrintf("dl_depth=%d\n", disassembler.dl_depth);
+            osSyncPrintf("dl_cnt=%d\n", disassembler.dl_cnt);
+        }
+        func_800D7FC4(&disassembler);
+    }
+}
+
+void Graph_UCodeFaultClient(void* arg0)
+{
+    UcodeDisas disassembler;
+
+    func_800D7F5C(&disassembler);
+    disassembler.enableLog = true;
+    func_800DAC80(&disassembler, 3, D_8012D248);
+    func_800DAC90(&disassembler, D_80155F50);
+    func_800D8400(&disassembler, arg0);
+    func_800D7FC4(&disassembler);
+}
+
+void* Graph_InitTHGA(GraphicsContext* gfxCtx)
+{
+    GfxPool* pool;
+
+    pool = &gGfxPools[gfxCtx->gfxPoolIdx & 1];
+
+    pool->headMagic = GFXPOOL_HEAD_MAGIC;
+    pool->tailMagic = GFXPOOL_TAIL_MAGIC;
+    THGA_Ct(&gfxCtx->polyOpa, pool->polyOpaBuffer, sizeof(pool->polyOpaBuffer));
+    THGA_Ct(&gfxCtx->polyXlu, pool->polyXluBuffer, sizeof(pool->polyXluBuffer));
+    THGA_Ct(&gfxCtx->overlay, pool->overlayBuffer, sizeof(pool->overlayBuffer));
+    THGA_Ct(&gfxCtx->work, pool->workBuffer, sizeof(pool->workBuffer));
+
+    gfxCtx->polyOpaBuffer = pool->polyOpaBuffer;
+    gfxCtx->polyXluBuffer = pool->polyXluBuffer;
+    gfxCtx->overlayBuffer = pool->overlayBuffer;
+    gfxCtx->workBuffer = pool->workBuffer;
+
+    gfxCtx->curFrameBuffer = (u16*)SysCfb_GetFbPtr(gfxCtx->fbIdx % 2);
+    gfxCtx->unk_014 = 0;
+}
+
+GameStateOverlay* Graph_GetNextGameState()
+{
+    void* game_init_func;
+
+    game_init_func = func_800C546C();
+    if (game_init_func == TitleSetup_Init) {
+        return &gGameStateOverlayTable[0];
+    }
+    if (game_init_func == func_80801E44) {
+        return &gGameStateOverlayTable[1];
+    }
+    if (game_init_func == Title_Init) {
+        return &gGameStateOverlayTable[2];
+    }
+    if (game_init_func == func_800BCA64) {
+        return &gGameStateOverlayTable[3];
+    }
+    if (game_init_func == Opening_Init) {
+        return &gGameStateOverlayTable[4];
+    }
+    if (game_init_func == func_80811A20) {
+        return &gGameStateOverlayTable[5];
+    }
+    
+    LogUtils_LogThreadId("../graph.c", 696); osSyncPrintf("game_init_func = %08x\n", game_init_func);
+    return NULL;
+}
+
+void Graph_Ct(GraphicsContext* gfxCtx)
+{
+    bzero(gfxCtx, sizeof(GraphicsContext));
+    gfxCtx->gfxPoolIdx = 0;
+    gfxCtx->fbIdx = 0;
+    gfxCtx->viMode = NULL;
+    gfxCtx->viFeatures = gViConfigFeatures;
+    gfxCtx->xScale = gViConfigXScale;
+    gfxCtx->yScale = gViConfigYScale;
+    osCreateMesgQueue(&gfxCtx->queue, gfxCtx->msgBuff, ARRAY_COUNT(gfxCtx->msgBuff));
+    func_800D31F0();
+    Fault_AddClient(&sGraphFaultClient, Graph_FaultClient, 0, 0);
+}
+
+void Graph_Dt(GraphicsContext* gfxCtx)
+{
+    func_800D3210();
+    Fault_RemoveClient(&sGraphFaultClient);
+}
+
+// Close to matching, reordering at the end
+#ifdef NON_MATCHING
+void Graph_TaskSet00(GraphicsContext* gfxCtx)
+{
+    static u32 D_8012D260 = 0;
+    static s32 sGraphCfbInfoIdx = 0;
+
+    OSTimer timer;
+    OSMesg msg;
+    OSMesgQueue* mq;
+    u32 temp;
+    OSTime time;
+    OSTask_t* task;
+    Gfx* gfxArr[3];
+    OSScTask* scTask;
+    CfbInfo* cfb;
+
+    mq = &gfxCtx->queue;
+    task = &gfxCtx->task.list.t;
+    scTask = &gfxCtx->task;
+
+    D_8016A528 = osGetTime() - sGraphSetTaskTime - D_8016A558;
+
+    osSetTimer(&timer, 140625000, 0, mq, 666);
+
+    osRecvMesg(mq, &msg, OS_MESG_BLOCK);
+    osStopTimer(&timer);
+    if (msg == (OSMesg)666)
+    {
+        osSyncPrintf(VT_FGCOL(RED));
+        osSyncPrintf("RCPが帰ってきませんでした。"); // "RCP did not return."
+        osSyncPrintf(VT_RST);
+        LogUtils_LogHexDump(&HW_REG(SP_MEM_ADDR_REG, u32), 0x20);
+        LogUtils_LogHexDump(&DPC_START_REG, 0x20);
+        LogUtils_LogHexDump(gGfxSPTaskYieldBuffer, sizeof(gGfxSPTaskYieldBuffer));
+
+        SREG(6) = -1;
+        if (D_8012D260)
+        {
+            temp = D_8012D260;
+            HREG(80) = 7;
+            HREG(81) = 1;
+            HREG(82) = 2;
+            D_8012D260 = temp;
+            Graph_DisassembleUCode(temp);
+        }
+        Fault_AddHungupAndCrashImpl("RCP is HUNG UP!!", "Oh! MY GOD!!");
+    }
+    osRecvMesg(mq, &msg, OS_MESG_NOBLOCK);
+    D_8012D260 = gfxCtx->workBuffer;
+    if (gfxCtx->callback)
+        gfxCtx->callback(gfxCtx, gfxCtx->callbackParam);
+    
+    time = osGetTime();
+    if (D_8016A550)
+    {
+        D_8016A558 = (D_8016A558 + time) - D_8016A550;
+        D_8016A550 = time;
+    }
+    D_8016A520 = D_8016A558;
+    D_8016A558 = 0;
+    sGraphSetTaskTime = osGetTime();
+
+    task->type = M_GFXTASK;
+    task->flags = OS_SC_DRAM_DLIST;
+    task->ucode_boot = SysUcode_GetUCodeBoot();
+    task->ucode_boot_size = SysUcode_GetUcodeBootSize();
+    task->ucode = SysUcode_GetUcode();
+    task->ucode_data = SysUcode_GetUcodeData();
+    task->ucode_size = 0x1000;
+    task->ucode_data_size = 0x800;
+    task->dram_stack = gGfxSPTaskStack;
+    task->dram_stack_size = sizeof(gGfxSPTaskStack);
+    task->output_buff = gGfxSPTaskOutputBuffer;
+    task->output_buff_size = gGfxSPTaskYieldBuffer; // ??
+    task->data_ptr = gfxCtx->workBuffer;
+
+    Graph_OpenDisp(gfxArr, gfxCtx, "../graph.c", 828);
+    task->data_size = (u32)gfxCtx->work.p - (u32)gfxCtx->workBuffer;
+    Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 830);
+    
+    task->yield_data_ptr = gGfxSPTaskYieldBuffer;
+    task->yield_data_size = sizeof(gGfxSPTaskYieldBuffer);
+
+    scTask->next = NULL;
+    scTask->flags = OS_SC_RCP_MASK | OS_SC_SWAPBUFFER | OS_SC_LAST_TASK;
+    if (SREG(33) & 1)
+    {
+        SREG(33) &= ~1;
+        scTask->flags &= ~OS_SC_SWAPBUFFER;
+        gfxCtx->fbIdx--;
+    }
+
+    scTask->msg = NULL;
+    scTask->msgQ = mq;
+
+    cfb = sGraphCfbInfos + sGraphCfbInfoIdx++; 
+    cfb->fb1 = gfxCtx->curFrameBuffer;
+    cfb->swapbuffer = gfxCtx->curFrameBuffer;
+    cfb->viMode = gfxCtx->viMode;
+    cfb->features = gfxCtx->viFeatures;
+    cfb->xScale = gfxCtx->xScale;
+    cfb->yScale = gfxCtx->yScale;
+    cfb->unk_10 = 0;
+    cfb->updateRate = R_UPDATE_RATE;
+
+    scTask->framebuffer = cfb;
+    sGraphCfbInfoIdx = sGraphCfbInfoIdx % ARRAY_COUNT(sGraphCfbInfos);
+    gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
+
+    osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
+    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+}
+#else
+u32 D_8012D260 = 0;
+u32 sGraphCfbInfoIdx = 0;
+#pragma GLOBAL_ASM("asm/non_matchings/code/graph/Graph_TaskSet00.s")
+#endif
+
+// Very close to matching, stack usage
+#ifdef NON_MATCHING
+void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
+{
+    u32 problem;        // 0xC4 -> 0xD4
+    Gfx* gfxArr[5];     // 0xB0 -> 0xC0
+    Gfx* gfxArr2[9];    // 0x8C -> 0x9C
+    Gfx* gfxArr3[9];    // 0x68 -> 0x78
+    u64 time;
+    GfxPool* pool;      // 0x4C -> 0x6C
+
+    gameState->unk_A0 = 0;
+    Graph_InitTHGA(gfxCtx);
+
+    Graph_OpenDisp(gfxArr, gfxCtx, "../graph.c", 966);
+    gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 開始", 0);
+    gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 開始", 0);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 975);
+    
+    func_800C4A98(gameState); // Game_ReqPadData
+    func_800C4AC8(gameState); // Game_SetGameFrame
+    
+    Graph_OpenDisp(gfxArr2, gfxCtx, "../graph.c", 987);
+    gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 終了", 0);
+    gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 終了", 0);
+    Graph_CloseDisp(gfxArr2, gfxCtx, "../graph.c", 996);
+    
+    Graph_OpenDisp(gfxArr3, gfxCtx, "../graph.c", 999);
+    gSPBranchList(gfxCtx->work.p++, gfxCtx->polyOpaBuffer);
+    gSPBranchList(gfxCtx->polyOpa.p++, gfxCtx->polyXluBuffer);
+    gSPBranchList(gfxCtx->polyXlu.p++, gfxCtx->overlayBuffer);
+    gDPPipeSync(gfxCtx->overlay.p++);
+    gDPFullSync(gfxCtx->overlay.p++);
+    gSPEndDisplayList(gfxCtx->overlay.p++);
+    Graph_CloseDisp(gfxArr3, gfxCtx, "../graph.c", 1028);
+
+    if (HREG(80) == 10 && HREG(93) == 2) {
+        HREG(80) = 7;
+        HREG(81) = -1;
+        HREG(83) = HREG(92);
+    }
+    if (HREG(80) == 7 && HREG(81) != 0) {
+        if (HREG(82) == 3) {
+            Fault_AddClient(&sGraphUcodeFaultClient, Graph_UCodeFaultClient, gfxCtx->workBuffer, "do_count_fault");
+        }
+
+        Graph_DisassembleUCode(gfxCtx->workBuffer);
+
+        if (HREG(82) == 3) {
+            Fault_RemoveClient(&sGraphUcodeFaultClient);
+        }
+
+        if (HREG(81) < 0) {
+            LogUtils_LogHexDump(&HW_REG(SP_MEM_ADDR_REG, u32), 0x20);
+            LogUtils_LogHexDump(&DPC_START_REG, 0x20);
+        }
+
+        if (HREG(81) < 0) {
+            HREG(81) = 0;
+        }
+    }
+
+    problem = false;
+    pool = &gGfxPools[gfxCtx->gfxPoolIdx & 1];
+    if (pool->headMagic != GFXPOOL_HEAD_MAGIC) {
+        // BUG (?) : devs might've forgotten "problem = true;"
+        osSyncPrintf("%c", 7);
+        // Dynamic area head is destroyed
+        osSyncPrintf(VT_COL(RED, WHITE) "ダイナミック領域先頭が破壊されています\n" VT_RST);
+        Fault_AddHungupAndCrash("../graph.c", 1070);
+    }
+    if (pool->tailMagic != GFXPOOL_TAIL_MAGIC) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Dynamic region tail is destroyed
+        osSyncPrintf(VT_COL(RED, WHITE) "ダイナミック領域末尾が破壊されています\n" VT_RST);
+        Fault_AddHungupAndCrash("../graph.c", 1076);
+    }
+    
+    if (THGA_IsCrash(&gfxCtx->polyOpa)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 0 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ0は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+    if (THGA_IsCrash(&gfxCtx->polyXlu)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 1 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ1は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+    if (THGA_IsCrash(&gfxCtx->overlay)) {
+        problem = true;
+        osSyncPrintf("%c", 7);
+        // Zelda 4 is dead
+        osSyncPrintf(VT_COL(RED, WHITE) "ゼルダ4は死んでしまった(graph_alloc is empty)\n" VT_RST);
+    }
+
+    if (!problem) {
+        Graph_TaskSet00(gfxCtx);
+        gfxCtx->gfxPoolIdx++;
+        gfxCtx->fbIdx++;
+    }
+    
+    func_800F3054();
+    time = osGetTime();
+    D_8016A538 = D_8016A568;
+    D_8016A530 = D_8016A560;
+    D_8016A540 = D_8016A580;
+    D_8016A568 = 0;
+    D_8016A560 = 0;
+    D_8016A580 = 0;
+
+    if (sGraph_UpdateTime != 0) {
+        D_8016A548 = time - sGraph_UpdateTime;
+    }
+    sGraph_UpdateTime = time;
+
+    if (D_8012DBC0 && (!~(gameState->input[0].padPressed | ~Z_TRIG)) && (!~(gameState->input[0].raw.pad | ~(L_TRIG | R_TRIG)))) {
+        gSaveContext.game_mode = 0;
+        SET_NEXT_GAMESTATE(gameState, func_80801E44, char[0x240]); // TODO : SelectContext
+        gameState->running = false;
+    }
+
+    if (D_8012DBC0 && PreNmiBuff_IsResetting(gAppNmiBufferPtr) && !gameState->unk_A0) {
+        // To reset mode
+        osSyncPrintf(VT_COL(YELLOW, BLACK) "PRE-NMIによりリセットモードに移行します\n" VT_RST);
+        SET_NEXT_GAMESTATE(gameState, PreNMI_Init, PreNMIContext);
+        gameState->running = false;
+    }
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/graph/Graph_Update.s")
+#endif
+
+void Graph_ThreadEntry(void* arg0)
+{
+    GraphicsContext gfxCtx;
+    GameState* gameState;
+    u32 size;
+    GameStateOverlay* nextOvl;
+    GameStateOverlay* ovl;
+    char faultMsg[0x50];
+    
+    nextOvl = &gGameStateOverlayTable[0];
+
+    // Start graphic thread execution
+    osSyncPrintf("グラフィックスレッド実行開始\n");
+    Graph_Ct(&gfxCtx);
+
+    while(nextOvl)
+    {
+        ovl = nextOvl;
+        Overlay_LoadGameState(ovl);
+
+        size = ovl->instanceSize;
+        // Class size =%d bytes
+        osSyncPrintf("クラスサイズ＝%dバイト\n", size);
+
+        gameState = SystemArena_MallocDebug(size, "../graph.c", 1196);
+        
+        if (!gameState)
+        {
+            // Failure to secure
+            osSyncPrintf("確保失敗\n");
+            
+            sprintf(faultMsg, "CLASS SIZE= %d bytes", size);
+            Fault_AddHungupAndCrashImpl("GAME CLASS MALLOC FAILED", faultMsg);
+        }
+        func_800C5080(gameState, ovl->init, &gfxCtx); //Game_Ct
+
+        while (func_800C547C(gameState)) //Game_IsGameStateRunning
+        {
+            Graph_Update(&gfxCtx, gameState);
+        }
+
+        nextOvl = Graph_GetNextGameState(gameState);
+        func_800C5360(gameState); //Game_Dt
+        SystemArena_FreeDebug(gameState, "../graph.c", 1227);
+        Overlay_FreeGameState(ovl);
+
+    }
+    Graph_Dt(&gfxCtx);
+    // End of graphic thread execution
+    osSyncPrintf("グラフィックスレッド実行終了\n");
+
+}
+
+void* Graph_Alloc(GraphicsContext* gfxCtx, size_t size)
+{
+    TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
+
+    if (HREG(59) == 1)
+    {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size,
+            thga->bufp, thga->p, thga->d);
+    }
+    return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
+}
+
+void* Graph_Alloc2(GraphicsContext* gfxCtx, size_t size)
+{
+    TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
+    
+    if (HREG(59) == 1)
+    {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size,
+            thga->bufp, thga->p, thga->d);
+    }
+    return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
+}
+
+void Graph_OpenDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line)
+{
+    if (HREG(80) == 7 && HREG(82) != 4)
+    {
+        gfxArr[0] = gfxCtx->polyOpa.p;
+        gfxArr[1] = gfxCtx->polyXlu.p;
+        gfxArr[2] = gfxCtx->overlay.p;
+        
+        gDPNoOpOpenDisp(gfxCtx->polyOpa.p++, file, line);
+        gDPNoOpOpenDisp(gfxCtx->polyXlu.p++, file, line);
+        gDPNoOpOpenDisp(gfxCtx->overlay.p++, file, line);
+    }
+}
+
+void Graph_CloseDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line)
+{
+    if (HREG(80) == 7 && HREG(82) != 4)
+    {
+        if (gfxArr[0] + 1 == gfxCtx->polyOpa.p)
+            gfxCtx->polyOpa.p = gfxArr[0];
+        else
+            gDPNoOpCloseDisp(gfxCtx->polyOpa.p++, file, line);
+
+        if (gfxArr[1] + 1 == gfxCtx->polyXlu.p)
+            gfxCtx->polyXlu.p = gfxArr[1];
+        else
+            gDPNoOpCloseDisp(gfxCtx->polyXlu.p++, file, line);
+
+        if (gfxArr[2] + 1 == gfxCtx->overlay.p)
+            gfxCtx->overlay.p = gfxArr[2];
+        else
+            gDPNoOpCloseDisp(gfxCtx->overlay.p++, file, line);
+    }
+}
+
+Gfx* Graph_GfxPlusOne(Gfx* gfx)
+{
+    return gfx+1;
+}
+
+Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst)
+{
+    gSPBranchList(gfx, dst);
+    return dst;
+}
+
+void* Graph_DlistAlloc(Gfx** gfx, u32 size)
+{
+    u8* ptr;
+    Gfx* dst;
+
+    size = ((size + 7) & ~7),
+
+    ptr = *gfx + 1;
+
+    dst = (Gfx*)(ptr + size);
+    gSPBranchList(*gfx, dst);
+
+    *gfx = dst;
+    return ptr;
+}
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 2781bb5ae..72fe340b4 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -21,7 +21,7 @@ void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* global
 
         if (temp1 >= -50.0f && temp1 < 500.0f) {
             gfxCtx = globalCtx->state.gfxCtx;
-            func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
+            Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
 
             gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
 
@@ -52,7 +52,7 @@ void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* global
                       G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
 
-            func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
+            Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
         }
     }
 }
@@ -76,7 +76,7 @@ void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
     f32 sp58;
     Gfx* gfxArr[7];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
 
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0,
                     (u32)(((arg3 * 0.00005f) > 1.0f ? 1.0f : (arg3 * 0.00005f)) * arg4) & 0xFF);
@@ -92,7 +92,7 @@ void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04048180);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
 }
 
 #ifdef NON_MATCHING
@@ -139,7 +139,7 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
         temp_s6 -= 2;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
+        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
 
         gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
         actor->shape.unk_15 = 0;
@@ -209,7 +209,7 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
             actor->shape.unk_15 = ((spE0[0] + temp_f0) < (spE0[1] - temp_f0)) ? 2 : 1;
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
     }
 }
 #else
@@ -331,7 +331,7 @@ void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
 
     actor = targetCtx->targetedActor;
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2029);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2029);
 
     if (targetCtx->unk_48 != 0) {
         player = PLAYER;
@@ -431,7 +431,7 @@ void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
         gSPDisplayList(gfxCtx->polyXlu.p++, &D_0400CB70);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_8002C124.s")
@@ -746,7 +746,7 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
         sp38 = spCC * 2;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
+        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
 
         spB0 = spCC * spC8 * gSaveContext.language;
         spC8 = (spCC * spC8 > 0x1000) ? 0x1000 / spCC : spC8;
@@ -777,7 +777,7 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
                                 G_TX_RENDERTILE, 0, 0, 1024, 1024);
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
     }
 }
 
@@ -1333,9 +1333,9 @@ Hilite* func_8002EABC(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContex
     Hilite* hilite;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 4306);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 4306);
     gfxCtx->polyOpa.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyOpa.p, &hilite);
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 4313);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 4313);
 
     return hilite;
 }
@@ -1344,9 +1344,9 @@ Hilite* func_8002EB44(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContex
     Hilite* hilite;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 4332);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 4332);
     gfxCtx->polyXlu.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyXlu.p, &hilite);
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 4339);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 4339);
 
     return hilite;
 }
@@ -1375,13 +1375,13 @@ void func_8002EBCC(Actor* actor, GlobalContext* globalCtx, s32 flag) {
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
+        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyOpa.p++, 0x07, displayList);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
     }
 }
 
@@ -1404,13 +1404,13 @@ void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag) {
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
+        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyXlu.p++, 0x07, displayList);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
     }
 }
 
@@ -1830,7 +1830,7 @@ void func_8002FBAC(GlobalContext* globalCtx) {
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
 
     if (gSaveContext.respawn[RESPAWN_MODE_TOP].data != 0) {
         if (LINK_IS_ADULT) {
@@ -1962,7 +1962,7 @@ void func_8002FBAC(GlobalContext* globalCtx) {
         Lights_InitType0PositionalLight(&D_8015BC00, lightPos.x, lightPos.y, lightPos.z, 0xFF, 0xFF, 0xFF,
                                         500.0f * spD4);
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
     }
 }
 #else
@@ -2198,7 +2198,7 @@ void Actor_Draw(GlobalContext* globalCtx, Actor* actor) {
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
 
     lightMapper = Lights_CreateMapper(&globalCtx->lightCtx, globalCtx->state.gfxCtx);
 
@@ -2253,7 +2253,7 @@ void Actor_Draw(GlobalContext* globalCtx, Actor* actor) {
         actor->shape.shadowDrawFunc(actor, lightMapper, globalCtx);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
 
     Fault_RemoveClient(&faultClient);
 }
@@ -2275,7 +2275,7 @@ void func_80030ED8(Actor* actor) {
 void func_80030FA8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 6161);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 6161);
 
     gDPLoadTextureBlock(gfxCtx->polyXlu.p++, &D_0401E370, G_IM_FMT_I, G_IM_SIZ_8b, 64, 64, 0, G_TX_MIRROR | G_TX_CLAMP,
                         G_TX_MIRROR | G_TX_CLAMP, 6, 6, G_TX_NOLOD, G_TX_NOLOD);
@@ -2284,7 +2284,7 @@ void func_80030FA8(GraphicsContext* gfxCtx) {
     gSPTextureRectangle(gfxCtx->polyXlu.p++, 0, 0, 1280, 960, G_TX_RENDERTILE, 2240, 1600, 576, 597);
     gDPPipeSync(gfxCtx->polyXlu.p++);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 6183);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 6183);
 }
 
 void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invisibleActors) {
@@ -2295,10 +2295,10 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_actor.c", 6197);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 6197);
 
     // Translates to: "MAGIC LENS START"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ START", 0, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ START", 0);
 
     gDPPipeSync(gfxCtx->polyXlu.p++);
 
@@ -2326,21 +2326,21 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
     func_80030FA8(gfxCtx);
 
     // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY START"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示 START", nbInvisibleActors, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示 START", nbInvisibleActors);
 
     invisibleActor = &invisibleActors[0];
     for (i = 0; i < nbInvisibleActors; i++) {
         // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示", i, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示", i);
         Actor_Draw(globalCtx, *(invisibleActor++));
     }
 
     // Translates to: "MAGIC LENS INVISIBLE ACTOR DISPLAY END"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ 見えないＡcｔｏｒ表示 END", nbInvisibleActors, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ 見えないＡcｔｏｒ表示 END", nbInvisibleActors);
 
     if (globalCtx->roomCtx.curRoom.showInvisActors != 0) {
         // Translates to: "BLUE SPECTACLES (EXTERIOR)"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "青い眼鏡(外側)", 0, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "青い眼鏡(外側)", 0);
 
         gDPPipeSync(gfxCtx->polyXlu.p++);
 
@@ -2354,13 +2354,13 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
         func_80030FA8(gfxCtx);
 
         // Translates to: "BLUE SPECTACLES (EXTERIOR)"
-        gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "青い眼鏡(外側)", 1, 2);
+        gDPNoOpString(gfxCtx->polyOpa.p++, "青い眼鏡(外側)", 1);
     }
 
     // Translates to: "MAGIC LENS END"
-    gDma1p(gfxCtx->polyOpa.p++, G_NOOP, "魔法のメガネ END", 0, 2);
+    gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ END", 0);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_actor.c", 6284);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 6284);
 }
 
 s32 func_800314B0(GlobalContext* globalCtx, Actor* actor) {
@@ -2396,7 +2396,7 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
     gfxCtx = globalCtx->state.gfxCtx;
     invisibleActorCounter = 0;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
 
     actorListEntry = &actorCtx->actorList[0];
 
@@ -2406,8 +2406,8 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
             overlayEntry = actor->overlayEntry;
             actorName = overlayEntry->name != NULL ? overlayEntry->name : "";
 
-            gDma1p(gfxCtx->polyOpa.p++, G_NOOP, actorName, i, 2);
-            gDma1p(gfxCtx->polyXlu.p++, G_NOOP, actorName, i, 2);
+            gDPNoOpString(gfxCtx->polyOpa.p++, actorName, i);
+            gDPNoOpString(gfxCtx->polyXlu.p++, actorName, i);
 
             HREG(66) = i;
 
@@ -2485,7 +2485,7 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
         func_8005D62C(globalCtx, &globalCtx->sub_11E60);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
 }
 
 void func_80031A28(GlobalContext* globalCtx, ActorContext* actorCtx) {
@@ -3485,7 +3485,7 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
 
     if (0) {} // Necessary to match
 
@@ -3512,7 +3512,7 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04049210);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
 }
 
 void func_80033DB8(GlobalContext* globalCtx, s16 arg1, s16 arg2) {
@@ -3578,7 +3578,7 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2) {
     var = entry->unk_10;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
 
     Matrix_Translate(0.0f, entry->unk_08, 500.0f, MTXMODE_APPLY);
     Matrix_Get(&spB0);
@@ -3615,7 +3615,7 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, entry->unk_18);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
 }
 
 void func_8003424C(GlobalContext* globalCtx, Vec3f* arg1) {
@@ -3889,7 +3889,7 @@ void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
@@ -3901,7 +3901,7 @@ void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     gfxCtx->polyOpa.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
                                           skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyOpa.p);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
 }
 
 void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_LimbUpdateMatrix2 unkFunc1,
@@ -3909,7 +3909,7 @@ void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
 
     func_80093D84(globalCtx->state.gfxCtx);
 
@@ -3920,7 +3920,7 @@ void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     gfxCtx->polyXlu.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
                                           skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyXlu.p);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
 }
 
 s16 func_80034DD4(Actor* actor, GlobalContext* globalCtx, s16 arg2, f32 arg3) {
diff --git a/src/code/z_cheap_proc.c b/src/code/z_cheap_proc.c
index 7e5bbb275..740120df8 100644
--- a/src/code/z_cheap_proc.c
+++ b/src/code/z_cheap_proc.c
@@ -5,26 +5,26 @@ void Gfx_DrawDListOpa(GlobalContext* globalCtx, u32 dlist) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 216),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
 }
 
 void Gfx_DrawDListXlu(GlobalContext* globalCtx, u32 dlist) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 230),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
 }
diff --git a/src/code/z_debug.c b/src/code/z_debug.c
index e5bc9199f..a4febc4c7 100644
--- a/src/code/z_debug.c
+++ b/src/code/z_debug.c
@@ -223,10 +223,10 @@ void func_80063D7C(GraphicsContext* gfxCtx) {
     void* unk[2];
     Gfx* dlFrame[4]; // stores state of GfxCtx next ptrs
 
-    func_800C6AC4(&dlFrame, gfxCtx, "../z_debug.c", 628);
+    Graph_OpenDisp(&dlFrame, gfxCtx, "../z_debug.c", 628);
     GfxPrint_Ctor(&gfxPrint);
     sp78 = gfxCtx->polyOpa.p;
-    tempRet = func_800C6C20(gfxCtx->polyOpa.p);
+    tempRet = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
     gSPDisplayList(gfxCtx->overlay.p++, tempRet);
     GfxPrint_Open(&gfxPrint, tempRet);
 
@@ -241,9 +241,9 @@ void func_80063D7C(GraphicsContext* gfxCtx) {
     D_8011E0B0 = 0;
     sp7C = GfxPrint_Close(&gfxPrint);
     gSPEndDisplayList(sp7C++);
-    func_800C6C28(sp78, sp7C);
+    Graph_BranchDlist(sp78, sp7C);
     gfxCtx->polyOpa.p = sp7C;
     if (0) {}
-    func_800C6B54(&dlFrame, gfxCtx, "../z_debug.c", 664);
+    Graph_CloseDisp(&dlFrame, gfxCtx, "../z_debug.c", 664);
     GfxPrint_Dtor(&gfxPrint);
 }
diff --git a/src/code/z_debug_display.c b/src/code/z_debug_display.c
index e96ccdc2f..82765d9f6 100644
--- a/src/code/z_debug_display.c
+++ b/src/code/z_debug_display.c
@@ -74,7 +74,7 @@ static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, Glo
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
 
     func_80094678(globalCtx->state.gfxCtx);
 
@@ -92,14 +92,14 @@ static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, Glo
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_04004298);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
 }
 
 static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
     func_8009435C(globalCtx->state.gfxCtx);
 
     gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, dispObj->color.r, dispObj->color.g, dispObj->color.b, dispObj->color.a);
@@ -113,5 +113,5 @@ static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, Global
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
 }
diff --git a/src/code/z_demo.c b/src/code/z_demo.c
index 436dbfc15..8cdd7e8f6 100644
--- a/src/code/z_demo.c
+++ b/src/code/z_demo.c
@@ -1876,17 +1876,17 @@ void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
 
         if (BREG(0) != 0) {
             gfxCtx = globalCtx->state.gfxCtx;
-            func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
+            Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
 
             prevDisplayList = gfxCtx->polyOpa.p;
-            displayList = func_800C6C20(gfxCtx->polyOpa.p);
+            displayList = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
             gSPDisplayList(gfxCtx->overlay.p++, displayList);
             Cutscene_DrawDebugInfo(globalCtx, &displayList, csCtx);
             gSPEndDisplayList(displayList++);
-            func_800C6C28(prevDisplayList, displayList);
+            Graph_BranchDlist(prevDisplayList, displayList);
             gfxCtx->polyOpa.p = displayList;
 
-            func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
+            Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
         }
 
         csCtx->frames++;
diff --git a/src/code/z_draw.c b/src/code/z_draw.c
index cb737b55c..187b4226e 100644
--- a/src/code/z_draw.c
+++ b/src/code/z_draw.c
@@ -171,35 +171,35 @@ static void func_800694E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 556);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 556);
 
     func_80093BA8(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 560),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 565);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 565);
 }
 
 static void func_800695C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 572);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 572);
 
     gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 5);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 576),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 581);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 581);
 }
 
 static void func_8006969C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 588);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 588);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 592),
@@ -219,14 +219,14 @@ static void func_8006969C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 621);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 621);
 }
 
 static void func_80069880(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 628);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 628);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 632),
@@ -249,14 +249,14 @@ static void func_80069880(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 663);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 663);
 }
 
 static void func_80069AC8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 670);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 670);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 674),
@@ -278,14 +278,14 @@ static void func_80069AC8(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 704);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 704);
 }
 
 static void func_80069CF0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 712);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 712);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -302,14 +302,14 @@ static void func_80069CF0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 735);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 735);
 }
 
 static void func_80069EB0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 742);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 742);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 746),
@@ -325,14 +325,14 @@ static void func_80069EB0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 765);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 765);
 }
 
 static void func_8006A060(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 772);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 772);
 
     func_80093BA8(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 776),
@@ -340,14 +340,14 @@ static void func_8006A060(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 783);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 783);
 }
 
 static void func_8006A158(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 811);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 811);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 815),
@@ -359,14 +359,14 @@ static void func_8006A158(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 827);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 827);
 }
 
 static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 834);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 834);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -386,14 +386,14 @@ static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[5]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 861);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 861);
 }
 
 static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 868);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 868);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -404,14 +404,14 @@ static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 883);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 883);
 }
 
 static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 890);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 890);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -422,14 +422,14 @@ static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 906);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 906);
 }
 
 static void func_8006A73C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 913);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 913);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -440,14 +440,14 @@ static void func_8006A73C(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 929);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 929);
 }
 
 static void func_8006A88C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 936);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 936);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -458,28 +458,28 @@ static void func_8006A88C(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 952);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 952);
 }
 
 static void func_8006A9CC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 959);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 959);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 963),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 968);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 968);
 }
 
 static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 975);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 975);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 979),
@@ -491,27 +491,27 @@ static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 991);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 991);
 }
 
 static void func_8006ABEC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 998);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 998);
     func_80093D84(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1002),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
 }
 
 static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1019),
@@ -524,14 +524,14 @@ static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
 }
 
 static void func_8006AE40(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1043),
@@ -544,14 +544,14 @@ static void func_8006AE40(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
 }
 
 static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -564,14 +564,14 @@ static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
 }
 
 static void func_8006B124(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1092),
@@ -581,14 +581,14 @@ static void func_8006B124(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[3]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
 }
 
 static void func_8006B24C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1112),
@@ -602,14 +602,14 @@ static void func_8006B24C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
 }
 
 static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
 
     Matrix_Scale(0.7f, 0.7f, 0.7f, MTXMODE_APPLY);
 
@@ -625,14 +625,14 @@ static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
 }
 
 static void func_8006B54C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -646,14 +646,14 @@ static void func_8006B54C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
 }
 
 static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1192),
@@ -668,7 +668,7 @@ static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
 }
 
 static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
@@ -676,7 +676,7 @@ static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1218),
@@ -690,5 +690,5 @@ static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[6]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[7]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
 }
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index 8861a309a..4b91bba40 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -12,11 +12,11 @@
 void func_80020F60(u32 unused, GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, D_80135180, 809);
+    Graph_OpenDisp(gfxArr, gfxCtx, D_80135180, 809);
 
     gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 0x26);
 
-    func_800C6B54(gfxArr, gfxCtx, D_80135194, 813);
+    Graph_CloseDisp(gfxArr, gfxCtx, D_80135194, 813);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80020FC0.s")
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index 85cc0e9c2..5a23dedfc 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -333,7 +333,7 @@ void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
@@ -349,5 +349,5 @@ void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, D_80115484[type]);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
 }
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index 348e983ba..22bf17b0e 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -769,7 +769,7 @@ void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 iconNb;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
@@ -789,7 +789,7 @@ void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04042440);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
 }
 
 /**
@@ -802,7 +802,7 @@ void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
 
     iconNb = this->actor.params - 3;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
 
     gfxCtx->polyOpa.p = func_800BC8A0(globalCtx, gfxCtx->polyOpa.p);
 
@@ -820,7 +820,7 @@ void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_0403F070);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
 }
 
 /**
@@ -830,7 +830,7 @@ void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
@@ -844,7 +844,7 @@ void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403BCD8);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
 }
 
 /**
@@ -854,7 +854,7 @@ void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
 
     func_80093D84(globalCtx->state.gfxCtx);
     func_8002ED80(&this->actor, globalCtx, 0);
@@ -862,7 +862,7 @@ void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403B030);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
 }
 
 /**
diff --git a/src/code/z_game_dlftbls.c b/src/code/z_game_dlftbls.c
new file mode 100644
index 000000000..99fa15069
--- /dev/null
+++ b/src/code/z_game_dlftbls.c
@@ -0,0 +1,26 @@
+#include <global.h>
+
+#define GAMESTATE_OVERLAY(name, init, destroy, size)                              \
+    {                                                                       \
+        NULL,                                                               \
+        (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, \
+        _ovl_##name##SegmentStart, _ovl_##name##SegmentEnd,                 \
+        0, init, destroy, 0, 0, 0, size                                     \
+    }
+#define GAMESTATE_OVERLAY_INTERNAL(init, destroy, size)                     \
+    {                                                                       \
+        NULL,                                                               \
+        0, 0,                                                               \
+        NULL, NULL,                                                         \
+        0, init, destroy, 0, 0, 0, size                                     \
+    }
+
+GameStateOverlay gGameStateOverlayTable[] =
+{
+    GAMESTATE_OVERLAY_INTERNAL(TitleSetup_Init, TitleSetup_Destroy, sizeof(GameState)),
+    GAMESTATE_OVERLAY(select, func_80801E44, func_80801E0C, 0x240), // TODO : sizeof(SelectContext)
+    GAMESTATE_OVERLAY(title, Title_Init, Title_Destroy, sizeof(TitleContext)),
+    GAMESTATE_OVERLAY_INTERNAL(func_800BCA64, func_800BC8EC, sizeof(GlobalContext)),
+    GAMESTATE_OVERLAY(opening, Opening_Init, Opening_Destroy, sizeof(OpeningContext)),
+    GAMESTATE_OVERLAY(file_choose, func_80811A20, func_80811A18, 0x1CAE0),
+};
\ No newline at end of file
diff --git a/src/code/z_lifemeter.c b/src/code/z_lifemeter.c
index 27050cf24..ea70e8ece 100644
--- a/src/code/z_lifemeter.c
+++ b/src/code/z_lifemeter.c
@@ -208,7 +208,7 @@ void Interface_DrawHealth(GlobalContext* globalCtx) {
     s32 ddHeartCountMinusOne = gSaveContext.defense_hearts - 1;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_lifemeter.c", 353);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_lifemeter.c", 353);
 
     if (!(gSaveContext.health % 0x10)) {
         fullHeartCount--;
@@ -379,7 +379,7 @@ void Interface_DrawHealth(GlobalContext* globalCtx) {
         }
     }
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_lifemeter.c", 606);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_lifemeter.c", 606);
 }
 
 u32 Health_IsCritical(void);
diff --git a/src/code/z_map_mark.c b/src/code/z_map_mark.c
index 2c9343591..31fd73964 100644
--- a/src/code/z_map_mark.c
+++ b/src/code/z_map_mark.c
@@ -101,7 +101,7 @@ void MapMark_Draw(GlobalContext* globalCtx) {
     mapMarkData = &sLoadedMarkDataTable[dungeonId][interfaceCtx->roomNum][0];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
 
     while (1) {
         if (mapMarkData->markType == -1) {
@@ -134,7 +134,7 @@ void MapMark_Draw(GlobalContext* globalCtx) {
         mapMarkData++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
 }
 
 void MapMark_DrawConditionally(GlobalContext* globalCtx) {
diff --git a/src/code/z_moji.c b/src/code/z_moji.c
index 05a7a282c..c9568b33f 100644
--- a/src/code/z_moji.c
+++ b/src/code/z_moji.c
@@ -39,7 +39,7 @@ void func_8007B934(s32 arg0, s32 arg1) {
 void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1) {
     Gfx* gfxArr[7];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_moji.c", 86);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_moji.c", 86);
 
     if ((u32)gLetterTLUT & 0xF) {
         osSyncPrintf("moji_tlut --> %X\n", gLetterTLUT);
@@ -54,14 +54,14 @@ void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1) {
                         (D_80120124 + 8) << 2, G_TX_RENDERTILE, (u16)(arg1 & 4) * 64, (u16)(arg1 >> 3) * 256, 1024,
                         1024);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_moji.c", 123);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_moji.c", 123);
 }
 
 void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
     s32 i;
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_moji.c", 137);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_moji.c", 137);
 
     if ((u32)gFontFF & 0xF) {
         osSyncPrintf("font_ff --> %X\n", gFontFF);
@@ -108,5 +108,5 @@ void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
         }
     }
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_moji.c", 181);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_moji.c", 181);
 }
diff --git a/src/code/z_parameter.c b/src/code/z_parameter.c
index 73b02a892..bd1cc13e0 100644
--- a/src/code/z_parameter.c
+++ b/src/code/z_parameter.c
@@ -2585,7 +2585,7 @@ void Interface_DrawMagicBar(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
 
     if (gSaveContext.magic_level != 0) {
         if (gSaveContext.health_capacity > 0xA0) {
@@ -2660,7 +2660,7 @@ void Interface_DrawMagicBar(GlobalContext* globalCtx) {
         }
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
 }
 
 void func_80088AA0(s16 arg0) {
@@ -2702,7 +2702,7 @@ void func_80088B34(s16 arg0) {
 void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_parameter.c", 2820);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_parameter.c", 2820);
 
     gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, texture);
     gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
@@ -2716,7 +2716,7 @@ void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture) {
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_parameter.c", 2829);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_parameter.c", 2829);
 }
 
 u8* sCUpLabelTextures[] = { D_02002FC0, D_02002FC0, D_02002FC0 };
@@ -2737,7 +2737,7 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx) {
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
 
     // B Button Color & Texture
     // Also loads the Item Button Texture reused by other buttons afterwards
@@ -2881,7 +2881,7 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx) {
         }
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
 }
 #else
 void Interface_DrawItemButtons(GlobalContext* globalCtx);
@@ -2893,7 +2893,7 @@ void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
 
     gDPLoadTextureBlock(gfxCtx->overlay.p++, texture, G_IM_FMT_RGBA, G_IM_SIZ_32b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
                         G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
@@ -2903,7 +2903,7 @@ void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16
                         (R_ITEM_ICON_Y(button) + R_ITEM_ICON_WIDTH(button)) << 2, G_TX_RENDERTILE, 0, 0,
                         R_ITEM_ICON_DD(button) * 2, R_ITEM_ICON_DD(button) * 2);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
 }
 
 void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
@@ -2914,7 +2914,7 @@ void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
     Gfx* gfxArr[3];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
 
     item = gSaveContext.equips.button_items[button];
 
@@ -2964,7 +2964,7 @@ void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
                                            R_ITEM_AMMO_Y(button), 8, 8, 1024, 1024);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
 }
 
 void Interface_DrawActionButton(GlobalContext* globalCtx) {
@@ -2973,7 +2973,7 @@ void Interface_DrawActionButton(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
 
     Matrix_Translate(0.0f, 0.0f, XREG(18) / 10.0f, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
@@ -2991,7 +2991,7 @@ void Interface_DrawActionButton(GlobalContext* globalCtx) {
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
 }
 
 void Interface_InitVertices(GlobalContext* globalCtx) {
@@ -3153,7 +3153,7 @@ void Interface_Draw(GlobalContext* globalCtx) {
     s32 pad;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
 
     gSPSegment(gfxCtx->overlay.p++, 0x02, interfaceCtx->parameterSegment);
     gSPSegment(gfxCtx->overlay.p++, 0x07, interfaceCtx->do_actionSegment);
@@ -3968,7 +3968,7 @@ void Interface_Draw(GlobalContext* globalCtx) {
         gDPFillRectangle(gfxCtx->overlay.p++, 0, 0, gScreenWidth - 1, gScreenHeight - 1);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
 }
 #else
 s16 D_8015FFE0;
diff --git a/src/code/z_prenmi.c b/src/code/z_prenmi.c
index a44fa7214..f29816dc1 100644
--- a/src/code/z_prenmi.c
+++ b/src/code/z_prenmi.c
@@ -30,7 +30,7 @@ void PreNMI_Draw(PreNMIContext* prenmiCtx) {
 
     osSyncPrintf(VT_COL(YELLOW, BLACK) "prenmi_draw\n" VT_RST);
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_prenmi.c", 96);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_prenmi.c", 96);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
     func_80095248(gfxCtx, 0, 0, 0);
@@ -39,7 +39,7 @@ void PreNMI_Draw(PreNMIContext* prenmiCtx) {
                     (GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1) << 16) | GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1));
     gDPFillRectangle(gfxCtx->polyOpa.p++, 0, prenmiCtx->timer + 100, SCREEN_WIDTH - 1, prenmiCtx->timer + 100);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_prenmi.c", 112);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_prenmi.c", 112);
 }
 
 void PreNMI_Main(PreNMIContext* prenmiCtx) {
diff --git a/src/code/z_rcp.c b/src/code/z_rcp.c
index 9df3b257d..e3b71a460 100644
--- a/src/code/z_rcp.c
+++ b/src/code/z_rcp.c
@@ -891,101 +891,101 @@ Gfx* func_80093808(Gfx* gfx) {
 void func_80093848(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1293);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1293);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3A]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1297);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1297);
 }
 
 void func_800938B4(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1309);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1309);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x39]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1313);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1313);
 }
 
 void func_80093920(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1325);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1325);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x32]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1329);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1329);
 }
 
 void func_8009398C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1341);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1341);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x33]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1345);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1345);
 }
 
 void func_800939F8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1357);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1357);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x34]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1361);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1361);
 }
 
 void func_80093A64(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1373);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1373);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x35]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1377);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1377);
 }
 
 void func_80093AD0(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1389);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1389);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x36]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1393);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1393);
 }
 
 void func_80093B3C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1405);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1405);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x37]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1409);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1409);
 }
 
 void func_80093BA8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1421);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1421);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1A]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1425);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1425);
 }
 
 void func_80093C14(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1439);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1439);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1443);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1443);
 }
 
 void func_80093C80(GlobalContext* globalCtx) {
@@ -996,62 +996,62 @@ void func_80093C80(GlobalContext* globalCtx) {
     func_80093D18(gfxCtx);
 
     if (globalCtx->roomCtx.curRoom.unk_03 == 3) {
-        func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1460);
+        Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1460);
 
         gDPSetColorDither(gfxCtx->polyOpa.p++, G_CD_DISABLE);
 
-        func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1462);
+        Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1462);
     }
 }
 
 void func_80093D18(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1475);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1475);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x19]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1479);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1479);
 }
 
 void func_80093D84(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1491);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1491);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1495);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1495);
 }
 
 void func_80093DF0(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1507);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1507);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1F]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1511);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1511);
 }
 
 void func_80093E5C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1523);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1523);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x20]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1527);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1527);
 }
 
 void func_80093EC8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1539);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1539);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x21]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1543);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1543);
 }
 
 Gfx* func_80093F34(Gfx* gfx) {
@@ -1067,41 +1067,41 @@ Gfx* func_80093F58(Gfx* gfx) {
 void func_80093F7C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1569);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1569);
 
     gfxCtx->polyOpa.p = func_80093F58(gfxCtx->polyOpa.p);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1573);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1573);
 }
 
 void func_80093FD8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1585);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1585);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x23]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1589);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1589);
 }
 
 void func_80094044(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1601);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1601);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2C]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1605);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1605);
 }
 
 void func_800940B0(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1617);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1617);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x24]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1621);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1621);
 }
 
 Gfx* func_8009411C(Gfx* gfx) {
@@ -1112,81 +1112,81 @@ Gfx* func_8009411C(Gfx* gfx) {
 void func_80094140(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1640);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1640);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1C]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1644);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1644);
 }
 
 void func_800941AC(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1651);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1651);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2B]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1655);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1655);
 }
 
 void func_80094218(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1670);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1670);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2D]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1674);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1674);
 }
 
 void func_80094284(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1681);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1681);
 
     gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2E]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1685);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1685);
 }
 
 void func_800942F0(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1700);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1700);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x26]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1704);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1704);
 }
 
 void func_8009435C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1722);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1722);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x04]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1726);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1726);
 }
 
 void func_800943C8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1758);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1758);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x25]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1762);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1762);
 }
 
 void func_80094434(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1775);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1775);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x02]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1779);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1779);
 }
 
 Gfx* func_800944A0(Gfx* gfx) {
@@ -1197,21 +1197,21 @@ Gfx* func_800944A0(Gfx* gfx) {
 void func_800944C4(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1799);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1799);
 
     gfxCtx->polyOpa.p = func_800944A0(gfxCtx->polyOpa.p);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1801);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1801);
 }
 
 void func_80094520(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1809);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1809);
 
     gfxCtx->overlay.p = func_800944A0(gfxCtx->overlay.p);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1811);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1811);
 }
 
 void func_8009457C(Gfx** gfxp) {
@@ -1223,31 +1223,31 @@ void func_8009457C(Gfx** gfxp) {
 void func_800945A0(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1837);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1837);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x28]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1841);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1841);
 }
 
 void func_8009460C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1853);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1853);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x29]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1857);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1857);
 }
 
 void func_80094678(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1869);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1869);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2F]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1873);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1873);
 }
 
 Gfx* func_800946E4(Gfx* gfx) {
@@ -1309,82 +1309,82 @@ Gfx* func_80094968(Gfx* gfx) {
 void func_800949A8(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1953);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1953);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2A]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1957);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1957);
 }
 
 void func_80094A14(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1964);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1964);
 
     gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2A]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1968);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1968);
 }
 
 void func_80094A80(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 1992);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1992);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x30]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 1996);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1996);
 }
 
 void func_80094AEC(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2008);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2008);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x31]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2012);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2012);
 }
 
 void func_80094B58(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2024);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2024);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x1B]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2028);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2028);
 }
 
 void func_80094BC4(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2040);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2040);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3C]);
     gDPSetColorDither(gfxCtx->polyXlu.p++, G_CD_DISABLE);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2043);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2043);
 }
 
 void func_80094C50(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2056);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2056);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3D]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2058);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2058);
 }
 
 void func_80094CBC(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2086);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2086);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x38]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2090);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2090);
 }
 
 void func_80094D28(Gfx** gfxp) {
@@ -1396,17 +1396,17 @@ void func_80094D28(Gfx** gfxp) {
 void func_80094D4C(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2112);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2112);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3B]);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2116);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2116);
 }
 
 #ifdef NON_MATCHING
 // regalloc differences
 void Gfx_BranchTexScroll(Gfx** gfxp, u32 x, u32 y, s32 width, s32 height) {
-    Gfx* displayList = func_800C6C3C(gfxp, 3 * sizeof(Gfx));
+    Gfx* displayList = Graph_DlistAlloc(gfxp, 3 * sizeof(Gfx));
 
     gDPTileSync(displayList);
     gDPSetTileSize(displayList + 1, 0, x, y, (x + ((width - 1) << 2)), (y + ((height - 1) << 2)));
@@ -1487,7 +1487,7 @@ void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
     Gfx* gfxArr[5];
     s32 ret;
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2386);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2386);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
     gSPDisplayList(gfxCtx->polyXlu.p++, sFillSetupDL);
@@ -1499,10 +1499,10 @@ void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
     gDPSetScissorFrac(gfxCtx->overlay.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
                       (s32)gScreenHeight * 4.0f);
 
-    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
-    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
-    gDPSetColorImage(gfxCtx->polyXlu.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
-    gDPSetColorImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->polyXlu.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
+    gDPSetColorImage(gfxCtx->overlay.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
 
     gDPSetDepthImage(gfxCtx->polyOpa.p++, gZBuffer);
     gDPSetDepthImage(gfxCtx->polyXlu.p++, gZBuffer);
@@ -1559,7 +1559,7 @@ void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
         gDPFillRectangle(gfxCtx->polyOpa.p++, 0, ret, gScreenWidth - 1, gScreenHeight - ret - 1);
         gDPPipeSync(gfxCtx->polyOpa.p++);
 
-        gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
+        gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
         gDPSetCycleType(gfxCtx->polyOpa.p++, G_CYC_FILL);
         gDPSetRenderMode(gfxCtx->polyOpa.p++, G_RM_NOOP, G_RM_NOOP2);
         gDPSetFillColor(gfxCtx->polyOpa.p++, (GPACK_RGBA5551(r, g, b, 1) << 16) | GPACK_RGBA5551(r, g, b, 1));
@@ -1577,19 +1577,19 @@ void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
         }
     }
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2497);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2497);
 }
 
 void func_80095974(GraphicsContext* gfxCtx) {
     Gfx* gfxArr[5];
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_rcp.c", 2503);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2503);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
     gDPSetScissorFrac(gfxCtx->polyOpa.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
                       (s32)gScreenHeight * 4.0f);
     gDPSetDepthImage(gfxCtx->polyOpa.p++, gZBuffer);
-    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->unk_2DC);
+    gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_rcp.c", 2513);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2513);
 }
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 77eb17522..ac4e829c5 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -41,7 +41,7 @@ void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 193);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 193);
 
     if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
@@ -71,7 +71,7 @@ void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags) {
         polygonDlist++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 239);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 239);
 }
 
 #define SHAPE_SORT_MAX 64
@@ -110,7 +110,7 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
     spB0 = NULL;
     spB4 = NULL;
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 287);
+    Graph_OpenDisp(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 287);
 
     if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
@@ -222,7 +222,7 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
 
     iREG(88) = sp9C - 1;
 
-    func_800C6B54(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 430);
+    Graph_CloseDisp(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 430);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80095D04.s")
@@ -353,7 +353,7 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 628);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 628);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     polygon1 = &room->mesh->polygon1;
@@ -399,7 +399,7 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags) {
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 691);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 691);
 }
 
 typedef struct {
@@ -459,7 +459,7 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 752);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 752);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     sp98 = (camera->unk_142 ^ 25) == 0;
@@ -505,7 +505,7 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags) {
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 819);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 819);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80096B6C.s")
diff --git a/src/code/z_sample.c b/src/code/z_sample.c
index 3a7ca5885..5c9d7d6ce 100644
--- a/src/code/z_sample.c
+++ b/src/code/z_sample.c
@@ -18,7 +18,7 @@ void Sample_Draw(SampleContext* this) {
     Gfx* gfxArr[4];
     Mtx* mtx;
 
-    func_800C6AC4(gfxArr, gfxCtx, "../z_sample.c", 62);
+    Graph_OpenDisp(gfxArr, gfxCtx, "../z_sample.c", 62);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
     gSPSegment(gfxCtx->polyOpa.p++, 0x01, this->staticSegment);
@@ -41,7 +41,7 @@ void Sample_Draw(SampleContext* this) {
                       PRIMITIVE);
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0xFF, 0xFF, 0x00, 0x00);
 
-    func_800C6B54(gfxArr, gfxCtx, "../z_sample.c", 111);
+    Graph_CloseDisp(gfxArr, gfxCtx, "../z_sample.c", 111);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/Sample_Draw.s")
diff --git a/src/code/z_scene_table.c b/src/code/z_scene_table.c
index 4ecf34556..a4ff5a224 100644
--- a/src/code/z_scene_table.c
+++ b/src/code/z_scene_table.c
@@ -684,12 +684,12 @@ void func_80099550(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     Gfx* gfxArr[4];
 
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
 }
 
 u32 D_8012A2F8[] = { 0x0200BA18, 0x0200CA18 };
@@ -703,7 +703,7 @@ void func_800995DC(GlobalContext* globalCtx) {
     gameplayFrames = globalCtx->gameplayFrames;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
                Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128,
@@ -716,7 +716,7 @@ void func_800995DC(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A2F8[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
 }
 
 // Scene Draw Config 28
@@ -726,7 +726,7 @@ void func_80099760(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -736,7 +736,7 @@ void func_80099760(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
 }
 
 u32 D_8012A300[] = { 0x02012378, 0x02013378 };
@@ -753,7 +753,7 @@ void func_80099878(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A300[gSaveContext.night_flag]));
@@ -782,7 +782,7 @@ void func_80099878(GlobalContext* globalCtx) {
     gDPSetEnvColor(displayListHead++, 0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
 }
 
 // Scene Draw Config 30
@@ -795,7 +795,7 @@ void func_80099BD8(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 18 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
 
     temp = globalCtx->unk_11D30[0] / 255.0f;
 
@@ -839,7 +839,7 @@ void func_80099BD8(GlobalContext* globalCtx) {
     gDPSetEnvColor(displayListHead++, 0, 0, 0, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
 
     if (gSaveContext.scene_setup_index == 5) {
         D_8015FCF0 = 1;
@@ -859,7 +859,7 @@ void func_8009A45C(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -884,7 +884,7 @@ void func_8009A45C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
 }
 
 // Scene Draw Config 32
@@ -894,7 +894,7 @@ void func_8009A798(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -916,7 +916,7 @@ void func_8009A798(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
 }
 
 // Scene Draw Config 33
@@ -926,7 +926,7 @@ void func_8009A9DC(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -942,7 +942,7 @@ void func_8009A9DC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
 }
 
 // Scene Draw Config 48
@@ -952,7 +952,7 @@ void func_8009AB98(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 256, 16));
@@ -963,7 +963,7 @@ void func_8009AB98(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
 }
 
 // Scene Draw Config 39
@@ -973,7 +973,7 @@ void func_8009ACA8(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -987,7 +987,7 @@ void func_8009ACA8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
 }
 
 // Scene Draw Config 24
@@ -997,7 +997,7 @@ void func_8009AE30(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
@@ -1017,7 +1017,7 @@ void func_8009AE30(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
 }
 
 u32 D_8012A328[] = { 0x0200BD20, 0x0200B920 };
@@ -1029,7 +1029,7 @@ void func_8009AFE0(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
@@ -1039,7 +1039,7 @@ void func_8009AFE0(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A328[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
 }
 
 u32 D_8012A330[] = { 0x02014C30, 0x02015830 };
@@ -1053,7 +1053,7 @@ void func_8009B0FC(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
 
     if (1) {} // Necessary to match
 
@@ -1116,7 +1116,7 @@ void func_8009B0FC(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
 }
 
 // Scene Draw Config 29
@@ -1126,7 +1126,7 @@ void func_8009B86C(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1138,7 +1138,7 @@ void func_8009B86C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x91);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
 }
 
 // Scene Draw Config 34
@@ -1148,7 +1148,7 @@ void func_8009B9BC(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 4, 16));
@@ -1156,7 +1156,7 @@ void func_8009B9BC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
 }
 
 // Scene Draw Config 35
@@ -1166,7 +1166,7 @@ void func_8009BAA4(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1184,7 +1184,7 @@ void func_8009BAA4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
 }
 
 // Scene Draw Config 36
@@ -1199,7 +1199,7 @@ void func_8009BC44(GlobalContext* globalCtx) {
     sp83 = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
@@ -1226,7 +1226,7 @@ void func_8009BC44(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp83, sp83, sp83, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
 }
 
 // Screen Shake for Ganon's Tower Collapse
@@ -1266,7 +1266,7 @@ void func_8009C0AC(GlobalContext* globalCtx) {
     sp7B = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1289,7 +1289,7 @@ void func_8009C0AC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp7B, sp7B, sp7B, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
 
     if (Flags_GetSwitch(globalCtx, 0x37)) {
         if ((globalCtx->sceneNum == SCENE_GANON_DEMO) || (globalCtx->sceneNum == SCENE_GANON_FINAL) ||
@@ -1310,7 +1310,7 @@ void func_8009C3EC(GlobalContext* globalCtx) {
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A338[gSaveContext.night_flag]));
@@ -1329,7 +1329,7 @@ void func_8009C3EC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
 }
 
 // Scene Draw Config 42
@@ -1339,7 +1339,7 @@ void func_8009C608(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1360,7 +1360,7 @@ void func_8009C608(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
 }
 
 // Scene Draw Config 43
@@ -1370,7 +1370,7 @@ void func_8009C8B8(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1387,7 +1387,7 @@ void func_8009C8B8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
 }
 
 // Scene Draw Config 47
@@ -1397,7 +1397,7 @@ void func_8009CAC0(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1410,7 +1410,7 @@ void func_8009CAC0(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
 }
 
 u32 D_8012A340[] = { 0x0200F8C0, 0x020100C0 };
@@ -1424,7 +1424,7 @@ void func_8009CC00(GlobalContext* globalCtx) {
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A340[gSaveContext.night_flag]));
@@ -1443,7 +1443,7 @@ void func_8009CC00(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
 }
 
 Gfx* Gfx_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1, s32 tile2,
@@ -1472,7 +1472,7 @@ void func_8009CF84(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1487,7 +1487,7 @@ void func_8009CF84(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
 }
 
 // Scene Draw Config 41
@@ -1497,7 +1497,7 @@ void func_8009D0E8(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1515,7 +1515,7 @@ void func_8009D0E8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
 }
 
 u32 D_8012A348[] = { 0x02005210, 0x02005010 };
@@ -1527,7 +1527,7 @@ void func_8009D31C(GlobalContext* globalCtx) {
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A348[gSaveContext.night_flag]));
 
@@ -1537,7 +1537,7 @@ void func_8009D31C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
 }
 
 u32 D_8012A350[] = { 0x02006550, 0x02003550 };
@@ -1550,7 +1550,7 @@ void func_8009D438(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
 
     if (LINK_IS_ADULT) {
         var = 1;
@@ -1567,7 +1567,7 @@ void func_8009D438(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
 }
 
 // Scene Draw Config 46
@@ -1577,7 +1577,7 @@ void func_8009D5B4(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1592,7 +1592,7 @@ void func_8009D5B4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
 }
 
 u32 D_8012A360[] = { 0x02014D90, 0x02014590 };
@@ -1606,7 +1606,7 @@ void func_8009D758(GlobalContext* globalCtx) {
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A360[gSaveContext.night_flag]));
@@ -1625,7 +1625,7 @@ void func_8009D758(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
 }
 
 u32 D_8012A368[] = { 0x02018920, 0x02018020 };
@@ -1637,11 +1637,11 @@ void func_8009D974(GlobalContext* globalCtx) {
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A368[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
 }
 
 // Scene Draw Config 1
@@ -1654,7 +1654,7 @@ void func_8009DA30(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1690,7 +1690,7 @@ void func_8009DA30(GlobalContext* globalCtx) {
         gSPEndDisplayList(displayListHead);
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
 }
 
 u32 D_8012A370[] = { 0x02015B50, 0x02016B50 };
@@ -1702,7 +1702,7 @@ void func_8009DD5C(GlobalContext* globalCtx) {
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A370[gSaveContext.night_flag]));
 
@@ -1712,7 +1712,7 @@ void func_8009DD5C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
 }
 
 // Scene Draw Config 3
@@ -1722,7 +1722,7 @@ void func_8009DE78(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1741,7 +1741,7 @@ void func_8009DE78(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
 }
 
 // Scene Draw Config 4
@@ -1759,7 +1759,7 @@ void func_8009E0B8(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
@@ -1798,7 +1798,7 @@ void func_8009E0B8(GlobalContext* globalCtx) {
                Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16, 1, 0,
                                 (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
 }
 
 // Scene Draw Config 5
@@ -1808,7 +1808,7 @@ void func_8009E54C(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
 
     if ((gSaveContext.scene_setup_index > 3) || (LINK_IS_ADULT && !(gSaveContext.event_chk_inf[6] & 0x200))) {
         globalCtx->unk_11D30[0] = 87;
@@ -1825,7 +1825,7 @@ void func_8009E54C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0xFF, 0xFF, 0xFF, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
 }
 
 u32 D_8012A378[] = { 0x02008F98, 0x02008FD8 };
@@ -1838,7 +1838,7 @@ void func_8009E730(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
 
     gameplayFrames = globalCtx->gameplayFrames;
     var = 127 - (gameplayFrames * 1) % 128;
@@ -1855,7 +1855,7 @@ void func_8009E730(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
 }
 
 // Scene Draw Config 7
@@ -1865,7 +1865,7 @@ void func_8009E8C0(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1883,7 +1883,7 @@ void func_8009E8C0(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
 }
 
 // Scene Draw Config 8
@@ -1893,7 +1893,7 @@ void func_8009EAD8(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1921,7 +1921,7 @@ void func_8009EAD8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
 }
 
 // Scene Draw Config 9
@@ -1933,7 +1933,7 @@ void func_8009EE44(GlobalContext* globalCtx) {
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1957,7 +1957,7 @@ void func_8009EE44(GlobalContext* globalCtx) {
         globalCtx->unk_11D30[1]++;
     }
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
 }
 
 // Scene Draw Config 10
@@ -1967,7 +1967,7 @@ void func_8009F074(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1979,7 +1979,7 @@ void func_8009F074(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
 }
 
 u32 D_8012A380[] = { 0x02009678, 0x0200DE78 };
@@ -1991,11 +1991,11 @@ void func_8009F1B4(GlobalContext* globalCtx) {
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A380[gSaveContext.night_flag]));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
 }
 
 // Scene Draw Config 12
@@ -2005,7 +2005,7 @@ void func_8009F270(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2021,7 +2021,7 @@ void func_8009F270(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
 }
 
 // Scene Draw Config 13
@@ -2031,7 +2031,7 @@ void func_8009F40C(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -2047,7 +2047,7 @@ void func_8009F40C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
 }
 
 // Scene Draw Config 14
@@ -2059,7 +2059,7 @@ void func_8009F5D4(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, displayListHead);
 
@@ -2087,7 +2087,7 @@ void func_8009F5D4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
 }
 
 // Scene Draw Config 15
@@ -2102,7 +2102,7 @@ void func_8009F7D4(GlobalContext* globalCtx) {
     sp6E = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
 
     gameplayFrames = globalCtx->gameplayFrames;
     sp6F = (sp6F >> 1) + 192;
@@ -2118,7 +2118,7 @@ void func_8009F7D4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
 }
 
 u32 D_8012A388[] = { 0x02009808, 0x02008FC8 };
@@ -2130,7 +2130,7 @@ void func_8009F9D0(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2147,7 +2147,7 @@ void func_8009F9D0(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
 }
 
 u32 D_8012A390[] = { 0x020081E0, 0x0200FBE0 };
@@ -2159,7 +2159,7 @@ void func_8009FB74(GlobalContext* globalCtx) {
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A390[gSaveContext.night_flag]));
 
@@ -2169,7 +2169,7 @@ void func_8009FB74(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
 }
 
 // Scene Draw Config 18
@@ -2179,7 +2179,7 @@ void func_8009FC90(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2196,7 +2196,7 @@ void func_8009FC90(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x40);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
 }
 
 f32 D_8012A398 = 0.0f;
@@ -2213,7 +2213,7 @@ void func_8009FE58(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
 
     gameplayFrames = globalCtx->gameplayFrames;
     if (globalCtx->sceneNum == SCENE_BDAN) {
@@ -2278,7 +2278,7 @@ void func_8009FE58(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0D, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_scene_table.c", 7809));
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
 }
 #else
 s16 D_8012A39C = 538;
@@ -2294,7 +2294,7 @@ void func_800A0334(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -2313,7 +2313,7 @@ void func_800A0334(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
 }
 
 // Scene Draw Config 52
@@ -2333,7 +2333,7 @@ void func_800A059C(GlobalContext* globalCtx) {
     Gfx* gfxArr[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
+    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2347,7 +2347,7 @@ void func_800A059C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
+    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
 }
 
 void (*sSceneDrawHandlers[])(GlobalContext*) = {
@@ -2384,14 +2384,14 @@ void Scene_Draw(GlobalContext* globalCtx) {
         }
 
         gfxCtx = globalCtx->state.gfxCtx;
-        func_800C6AC4(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
+        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
 
         if (HREG(81) == 1) {
             gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
             gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
         }
 
-        func_800C6B54(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
+        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
 
         if (HREG(82) == 1) {
             sSceneDrawHandlers[globalCtx->sceneConfig](globalCtx);
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index 05f23531c..cc78b7c74 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -39,7 +39,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* sk
     Gfx* gfx[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 773);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 773);
     Matrix_Push();
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
     limbIndex++;
@@ -80,7 +80,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* sk
                               appendDlistFunc, actor, dListIndex);
     }
 
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 821);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 821);
 }
 
 /*
@@ -104,7 +104,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* acto
         return;
     }
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 849);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 849);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
@@ -133,7 +133,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* acto
     }
 
     Matrix_Pull();
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 894);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 894);
 }
 
 /*
@@ -169,10 +169,10 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton*
         if (dList[1] != NULL) {
             Matrix_ToMtx(*mtx, "../z_skelanime.c", 945);
             gfxCtx = globalCtx->state.gfxCtx;
-            func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 946);
+            Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 946);
             gSPMatrix(gfxCtx->polyOpa.p++, *mtx, G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
-            func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 949);
+            Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 949);
             (*mtx)++;
         } else if (dList[0] != NULL) {
             Matrix_ToMtx(*mtx, "../z_skelanime.c", 954);
@@ -221,7 +221,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* ac
         return;
     }
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1000);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1000);
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
     Matrix_Push();
 
@@ -258,7 +258,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* ac
 
     Matrix_Pull();
 
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1053);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1053);
 }
 
 /*
@@ -276,7 +276,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skele
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1076);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1076);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
@@ -316,7 +316,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skele
                            appendDlistFunc, actor);
     }
 
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1121);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1121);
 }
 
 void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable,
@@ -338,7 +338,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDr
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1148);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1148);
     Matrix_Push();
     rootLimb = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
 
@@ -369,7 +369,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDr
 
     Matrix_Pull();
 
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1190);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1190);
 }
 
 void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
@@ -383,7 +383,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* ske
     Gfx* gfx[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1214);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1214);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
@@ -426,7 +426,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* ske
                              appendDlistFunc, actor, limbMatricies);
     }
 
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1265);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1265);
 }
 
 void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable, s32 dListCount,
@@ -452,7 +452,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actor
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    func_800C6AC4(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1294);
+    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1294);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
 
@@ -494,7 +494,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actor
     }
 
     Matrix_Pull();
-    func_800C6B54(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1347);
+    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1347);
 }
 
 /*
-- 
cgit v1.2.3


From fed29c029c2d545f1491e71e5193ff0f0e660c6d Mon Sep 17 00:00:00 2001
From: Random <28494085+Random0666@users.noreply.github.com>
Date: Sat, 4 Apr 2020 18:38:05 +0200
Subject: Run format.sh

---
 src/code/graph.c          | 188 +++++++++++++++++++---------------------------
 src/code/z_game_dlftbls.c |  24 ++----
 2 files changed, 87 insertions(+), 125 deletions(-)

(limited to 'src/code')

diff --git a/src/code/graph.c b/src/code/graph.c
index a26d9e9f1..997bcd443 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -4,8 +4,8 @@
 #include <vt.h>
 #include <PR/os_cont.h>
 
-#define GFXPOOL_HEAD_MAGIC  0x1234
-#define GFXPOOL_TAIL_MAGIC  0x5678
+#define GFXPOOL_HEAD_MAGIC 0x1234
+#define GFXPOOL_TAIL_MAGIC 0x5678
 
 OSTime sGraph_UpdateTime;
 OSTime sGraphSetTaskTime;
@@ -14,45 +14,37 @@ CfbInfo sGraphCfbInfos[3];
 FaultClient sGraphUcodeFaultClient;
 
 UcodeInfo D_8012D230[3] = {
-    { 1, D_80155F50 },
-    { 2, NULL },
-    { 3, D_801120C0+0xFB0 }, // D_80113070
+    { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
 };
 
 UcodeInfo D_8012D248[3] = {
-    { 1, D_80155F50 },
-    { 2, NULL },
-    { 3, D_801120C0+0xFB0 }, // D_80113070
+    { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
 };
 
-void Graph_FaultClient()
-{
+void Graph_FaultClient() {
     void* nextFb;
     void* newFb;
 
     nextFb = osViGetNextFramebuffer();
-    newFb = ((u32)SysCfb_GetFbPtr(0) != (u32)nextFb)
-        ? SysCfb_GetFbPtr(0)
-        : SysCfb_GetFbPtr(1);
-    
+    newFb = ((u32)SysCfb_GetFbPtr(0) != (u32)nextFb) ? SysCfb_GetFbPtr(0) : SysCfb_GetFbPtr(1);
+
     osViSwapBuffer(newFb);
     Fault_WaitForInput();
     osViSwapBuffer(nextFb);
 }
 
-void Graph_DisassembleUCode(void* arg0)
-{
+void Graph_DisassembleUCode(void* arg0) {
     UcodeDisas disassembler;
 
-    if (HREG(80) == 7 && HREG(81) != 0)
-    {
+    if (HREG(80) == 7 && HREG(81) != 0) {
         func_800D7F5C(&disassembler);
         disassembler.enableLog = HREG(83);
         func_800DAC80(&disassembler, 3, D_8012D230);
         func_800DAC90(&disassembler, D_80155F50);
         func_800D8400(&disassembler, arg0);
         HREG(93) = disassembler.dl_cnt;
-        HREG(84) = disassembler.tri2_cnt * 2 + disassembler.tri1_cnt + (disassembler.quad_cnt * 2) + disassembler.line_cnt;
+        HREG(84) =
+            disassembler.tri2_cnt * 2 + disassembler.tri1_cnt + (disassembler.quad_cnt * 2) + disassembler.line_cnt;
         HREG(85) = disassembler.vtx_cnt;
         HREG(86) = disassembler.spvtx_cnt;
         HREG(87) = disassembler.tri1_cnt;
@@ -61,8 +53,7 @@ void Graph_DisassembleUCode(void* arg0)
         HREG(90) = disassembler.line_cnt;
         HREG(91) = disassembler.sync_err;
         HREG(92) = disassembler.loaducode_cnt;
-        if (HREG(82) == 1 || HREG(82) == 2)
-        {
+        if (HREG(82) == 1 || HREG(82) == 2) {
             osSyncPrintf("vtx_cnt=%d\n", disassembler.vtx_cnt);
             osSyncPrintf("spvtx_cnt=%d\n", disassembler.spvtx_cnt);
             osSyncPrintf("tri1_cnt=%d\n", disassembler.tri1_cnt);
@@ -78,8 +69,7 @@ void Graph_DisassembleUCode(void* arg0)
     }
 }
 
-void Graph_UCodeFaultClient(void* arg0)
-{
+void Graph_UCodeFaultClient(void* arg0) {
     UcodeDisas disassembler;
 
     func_800D7F5C(&disassembler);
@@ -90,8 +80,7 @@ void Graph_UCodeFaultClient(void* arg0)
     func_800D7FC4(&disassembler);
 }
 
-void* Graph_InitTHGA(GraphicsContext* gfxCtx)
-{
+void* Graph_InitTHGA(GraphicsContext* gfxCtx) {
     GfxPool* pool;
 
     pool = &gGfxPools[gfxCtx->gfxPoolIdx & 1];
@@ -112,8 +101,7 @@ void* Graph_InitTHGA(GraphicsContext* gfxCtx)
     gfxCtx->unk_014 = 0;
 }
 
-GameStateOverlay* Graph_GetNextGameState()
-{
+GameStateOverlay* Graph_GetNextGameState() {
     void* game_init_func;
 
     game_init_func = func_800C546C();
@@ -135,13 +123,13 @@ GameStateOverlay* Graph_GetNextGameState()
     if (game_init_func == func_80811A20) {
         return &gGameStateOverlayTable[5];
     }
-    
-    LogUtils_LogThreadId("../graph.c", 696); osSyncPrintf("game_init_func = %08x\n", game_init_func);
+
+    LogUtils_LogThreadId("../graph.c", 696);
+    osSyncPrintf("game_init_func = %08x\n", game_init_func);
     return NULL;
 }
 
-void Graph_Ct(GraphicsContext* gfxCtx)
-{
+void Graph_Ct(GraphicsContext* gfxCtx) {
     bzero(gfxCtx, sizeof(GraphicsContext));
     gfxCtx->gfxPoolIdx = 0;
     gfxCtx->fbIdx = 0;
@@ -154,16 +142,14 @@ void Graph_Ct(GraphicsContext* gfxCtx)
     Fault_AddClient(&sGraphFaultClient, Graph_FaultClient, 0, 0);
 }
 
-void Graph_Dt(GraphicsContext* gfxCtx)
-{
+void Graph_Dt(GraphicsContext* gfxCtx) {
     func_800D3210();
     Fault_RemoveClient(&sGraphFaultClient);
 }
 
 // Close to matching, reordering at the end
 #ifdef NON_MATCHING
-void Graph_TaskSet00(GraphicsContext* gfxCtx)
-{
+void Graph_TaskSet00(GraphicsContext* gfxCtx) {
     static u32 D_8012D260 = 0;
     static s32 sGraphCfbInfoIdx = 0;
 
@@ -187,8 +173,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx)
 
     osRecvMesg(mq, &msg, OS_MESG_BLOCK);
     osStopTimer(&timer);
-    if (msg == (OSMesg)666)
-    {
+    if (msg == (OSMesg)666) {
         osSyncPrintf(VT_FGCOL(RED));
         osSyncPrintf("RCPが帰ってきませんでした。"); // "RCP did not return."
         osSyncPrintf(VT_RST);
@@ -197,8 +182,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx)
         LogUtils_LogHexDump(gGfxSPTaskYieldBuffer, sizeof(gGfxSPTaskYieldBuffer));
 
         SREG(6) = -1;
-        if (D_8012D260)
-        {
+        if (D_8012D260) {
             temp = D_8012D260;
             HREG(80) = 7;
             HREG(81) = 1;
@@ -210,12 +194,12 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx)
     }
     osRecvMesg(mq, &msg, OS_MESG_NOBLOCK);
     D_8012D260 = gfxCtx->workBuffer;
-    if (gfxCtx->callback)
+    if (gfxCtx->callback) {
         gfxCtx->callback(gfxCtx, gfxCtx->callbackParam);
-    
+    }
+
     time = osGetTime();
-    if (D_8016A550)
-    {
+    if (D_8016A550) {
         D_8016A558 = (D_8016A558 + time) - D_8016A550;
         D_8016A550 = time;
     }
@@ -240,14 +224,13 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx)
     Graph_OpenDisp(gfxArr, gfxCtx, "../graph.c", 828);
     task->data_size = (u32)gfxCtx->work.p - (u32)gfxCtx->workBuffer;
     Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 830);
-    
+
     task->yield_data_ptr = gGfxSPTaskYieldBuffer;
     task->yield_data_size = sizeof(gGfxSPTaskYieldBuffer);
 
     scTask->next = NULL;
     scTask->flags = OS_SC_RCP_MASK | OS_SC_SWAPBUFFER | OS_SC_LAST_TASK;
-    if (SREG(33) & 1)
-    {
+    if (SREG(33) & 1) {
         SREG(33) &= ~1;
         scTask->flags &= ~OS_SC_SWAPBUFFER;
         gfxCtx->fbIdx--;
@@ -256,7 +239,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx)
     scTask->msg = NULL;
     scTask->msgQ = mq;
 
-    cfb = sGraphCfbInfos + sGraphCfbInfoIdx++; 
+    cfb = sGraphCfbInfos + sGraphCfbInfoIdx++;
     cfb->fb1 = gfxCtx->curFrameBuffer;
     cfb->swapbuffer = gfxCtx->curFrameBuffer;
     cfb->viMode = gfxCtx->viMode;
@@ -281,14 +264,13 @@ u32 sGraphCfbInfoIdx = 0;
 
 // Very close to matching, stack usage
 #ifdef NON_MATCHING
-void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
-{
-    u32 problem;        // 0xC4 -> 0xD4
-    Gfx* gfxArr[5];     // 0xB0 -> 0xC0
-    Gfx* gfxArr2[9];    // 0x8C -> 0x9C
-    Gfx* gfxArr3[9];    // 0x68 -> 0x78
+void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
+    u32 problem;     // 0xC4 -> 0xD4
+    Gfx* gfxArr[5];  // 0xB0 -> 0xC0
+    Gfx* gfxArr2[9]; // 0x8C -> 0x9C
+    Gfx* gfxArr3[9]; // 0x68 -> 0x78
     u64 time;
-    GfxPool* pool;      // 0x4C -> 0x6C
+    GfxPool* pool; // 0x4C -> 0x6C
 
     gameState->unk_A0 = 0;
     Graph_InitTHGA(gfxCtx);
@@ -299,17 +281,17 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
     gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 開始", 0);
     gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 開始", 0);
     Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 975);
-    
+
     func_800C4A98(gameState); // Game_ReqPadData
     func_800C4AC8(gameState); // Game_SetGameFrame
-    
+
     Graph_OpenDisp(gfxArr2, gfxCtx, "../graph.c", 987);
     gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 終了", 0);
     gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 終了", 0);
     gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 終了", 0);
     gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 終了", 0);
     Graph_CloseDisp(gfxArr2, gfxCtx, "../graph.c", 996);
-    
+
     Graph_OpenDisp(gfxArr3, gfxCtx, "../graph.c", 999);
     gSPBranchList(gfxCtx->work.p++, gfxCtx->polyOpaBuffer);
     gSPBranchList(gfxCtx->polyOpa.p++, gfxCtx->polyXluBuffer);
@@ -361,7 +343,7 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
         osSyncPrintf(VT_COL(RED, WHITE) "ダイナミック領域末尾が破壊されています\n" VT_RST);
         Fault_AddHungupAndCrash("../graph.c", 1076);
     }
-    
+
     if (THGA_IsCrash(&gfxCtx->polyOpa)) {
         problem = true;
         osSyncPrintf("%c", 7);
@@ -386,7 +368,7 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
         gfxCtx->gfxPoolIdx++;
         gfxCtx->fbIdx++;
     }
-    
+
     func_800F3054();
     time = osGetTime();
     D_8016A538 = D_8016A568;
@@ -401,7 +383,8 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
     }
     sGraph_UpdateTime = time;
 
-    if (D_8012DBC0 && (!~(gameState->input[0].padPressed | ~Z_TRIG)) && (!~(gameState->input[0].raw.pad | ~(L_TRIG | R_TRIG)))) {
+    if (D_8012DBC0 && (!~(gameState->input[0].padPressed | ~Z_TRIG)) &&
+        (!~(gameState->input[0].raw.pad | ~(L_TRIG | R_TRIG)))) {
         gSaveContext.game_mode = 0;
         SET_NEXT_GAMESTATE(gameState, func_80801E44, char[0x240]); // TODO : SelectContext
         gameState->running = false;
@@ -418,23 +401,21 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState)
 #pragma GLOBAL_ASM("asm/non_matchings/code/graph/Graph_Update.s")
 #endif
 
-void Graph_ThreadEntry(void* arg0)
-{
+void Graph_ThreadEntry(void* arg0) {
     GraphicsContext gfxCtx;
     GameState* gameState;
     u32 size;
     GameStateOverlay* nextOvl;
     GameStateOverlay* ovl;
     char faultMsg[0x50];
-    
+
     nextOvl = &gGameStateOverlayTable[0];
 
     // Start graphic thread execution
     osSyncPrintf("グラフィックスレッド実行開始\n");
     Graph_Ct(&gfxCtx);
 
-    while(nextOvl)
-    {
+    while (nextOvl) {
         ovl = nextOvl;
         Overlay_LoadGameState(ovl);
 
@@ -443,106 +424,95 @@ void Graph_ThreadEntry(void* arg0)
         osSyncPrintf("クラスサイズ＝%dバイト\n", size);
 
         gameState = SystemArena_MallocDebug(size, "../graph.c", 1196);
-        
-        if (!gameState)
-        {
+
+        if (!gameState) {
             // Failure to secure
             osSyncPrintf("確保失敗\n");
-            
+
             sprintf(faultMsg, "CLASS SIZE= %d bytes", size);
             Fault_AddHungupAndCrashImpl("GAME CLASS MALLOC FAILED", faultMsg);
         }
-        func_800C5080(gameState, ovl->init, &gfxCtx); //Game_Ct
+        func_800C5080(gameState, ovl->init, &gfxCtx); // Game_Ct
 
-        while (func_800C547C(gameState)) //Game_IsGameStateRunning
+        while (func_800C547C(gameState)) // Game_IsGameStateRunning
         {
             Graph_Update(&gfxCtx, gameState);
         }
 
         nextOvl = Graph_GetNextGameState(gameState);
-        func_800C5360(gameState); //Game_Dt
+        func_800C5360(gameState); // Game_Dt
         SystemArena_FreeDebug(gameState, "../graph.c", 1227);
         Overlay_FreeGameState(ovl);
-
     }
     Graph_Dt(&gfxCtx);
     // End of graphic thread execution
     osSyncPrintf("グラフィックスレッド実行終了\n");
-
 }
 
-void* Graph_Alloc(GraphicsContext* gfxCtx, size_t size)
-{
+void* Graph_Alloc(GraphicsContext* gfxCtx, size_t size) {
     TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
 
-    if (HREG(59) == 1)
-    {
-        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size,
-            thga->bufp, thga->p, thga->d);
+    if (HREG(59) == 1) {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size, thga->bufp,
+                     thga->p, thga->d);
     }
     return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
 }
 
-void* Graph_Alloc2(GraphicsContext* gfxCtx, size_t size)
-{
+void* Graph_Alloc2(GraphicsContext* gfxCtx, size_t size) {
     TwoHeadGfxArena* thga = &gfxCtx->polyOpa;
-    
-    if (HREG(59) == 1)
-    {
-        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size,
-            thga->bufp, thga->p, thga->d);
+
+    if (HREG(59) == 1) {
+        osSyncPrintf("graph_alloc siz=%d thga size=%08x bufp=%08x head=%08x tail=%08x\n", size, thga->size, thga->bufp,
+                     thga->p, thga->d);
     }
     return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
 }
 
-void Graph_OpenDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line)
-{
-    if (HREG(80) == 7 && HREG(82) != 4)
-    {
+void Graph_OpenDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line) {
+    if (HREG(80) == 7 && HREG(82) != 4) {
         gfxArr[0] = gfxCtx->polyOpa.p;
         gfxArr[1] = gfxCtx->polyXlu.p;
         gfxArr[2] = gfxCtx->overlay.p;
-        
+
         gDPNoOpOpenDisp(gfxCtx->polyOpa.p++, file, line);
         gDPNoOpOpenDisp(gfxCtx->polyXlu.p++, file, line);
         gDPNoOpOpenDisp(gfxCtx->overlay.p++, file, line);
     }
 }
 
-void Graph_CloseDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line)
-{
-    if (HREG(80) == 7 && HREG(82) != 4)
-    {
-        if (gfxArr[0] + 1 == gfxCtx->polyOpa.p)
+void Graph_CloseDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line) {
+    if (HREG(80) == 7 && HREG(82) != 4) {
+        if (gfxArr[0] + 1 == gfxCtx->polyOpa.p) {
             gfxCtx->polyOpa.p = gfxArr[0];
-        else
+        } else {
             gDPNoOpCloseDisp(gfxCtx->polyOpa.p++, file, line);
+        }
 
-        if (gfxArr[1] + 1 == gfxCtx->polyXlu.p)
+        if (gfxArr[1] + 1 == gfxCtx->polyXlu.p) {
             gfxCtx->polyXlu.p = gfxArr[1];
-        else
+        } else {
             gDPNoOpCloseDisp(gfxCtx->polyXlu.p++, file, line);
+        }
 
-        if (gfxArr[2] + 1 == gfxCtx->overlay.p)
+        if (gfxArr[2] + 1 == gfxCtx->overlay.p) {
             gfxCtx->overlay.p = gfxArr[2];
-        else
+        } else {
             gDPNoOpCloseDisp(gfxCtx->overlay.p++, file, line);
+        }
     }
 }
 
-Gfx* Graph_GfxPlusOne(Gfx* gfx)
-{
-    return gfx+1;
+Gfx* Graph_GfxPlusOne(Gfx* gfx) {
+    return gfx + 1;
 }
 
-Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst)
-{
+Gfx* Graph_BranchDlist(Gfx* gfx, Gfx* dst) {
     gSPBranchList(gfx, dst);
     return dst;
 }
 
-void* Graph_DlistAlloc(Gfx** gfx, u32 size)
-{
+void* Graph_DlistAlloc(Gfx** gfx, u32 size) {
     u8* ptr;
     Gfx* dst;
 
diff --git a/src/code/z_game_dlftbls.c b/src/code/z_game_dlftbls.c
index 99fa15069..025cdda6d 100644
--- a/src/code/z_game_dlftbls.c
+++ b/src/code/z_game_dlftbls.c
@@ -1,26 +1,18 @@
 #include <global.h>
 
-#define GAMESTATE_OVERLAY(name, init, destroy, size)                              \
-    {                                                                       \
-        NULL,                                                               \
-        (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, \
-        _ovl_##name##SegmentStart, _ovl_##name##SegmentEnd,                 \
-        0, init, destroy, 0, 0, 0, size                                     \
-    }
-#define GAMESTATE_OVERLAY_INTERNAL(init, destroy, size)                     \
-    {                                                                       \
-        NULL,                                                               \
-        0, 0,                                                               \
-        NULL, NULL,                                                         \
-        0, init, destroy, 0, 0, 0, size                                     \
+#define GAMESTATE_OVERLAY(name, init, destroy, size)                                                         \
+    {                                                                                                        \
+        NULL, (u32)_ovl_##name##SegmentRomStart, (u32)_ovl_##name##SegmentRomEnd, _ovl_##name##SegmentStart, \
+            _ovl_##name##SegmentEnd, 0, init, destroy, 0, 0, 0, size                                         \
     }
+#define GAMESTATE_OVERLAY_INTERNAL(init, destroy, size) \
+    { NULL, 0, 0, NULL, NULL, 0, init, destroy, 0, 0, 0, size }
 
-GameStateOverlay gGameStateOverlayTable[] =
-{
+GameStateOverlay gGameStateOverlayTable[] = {
     GAMESTATE_OVERLAY_INTERNAL(TitleSetup_Init, TitleSetup_Destroy, sizeof(GameState)),
     GAMESTATE_OVERLAY(select, func_80801E44, func_80801E0C, 0x240), // TODO : sizeof(SelectContext)
     GAMESTATE_OVERLAY(title, Title_Init, Title_Destroy, sizeof(TitleContext)),
     GAMESTATE_OVERLAY_INTERNAL(func_800BCA64, func_800BC8EC, sizeof(GlobalContext)),
     GAMESTATE_OVERLAY(opening, Opening_Init, Opening_Destroy, sizeof(OpeningContext)),
     GAMESTATE_OVERLAY(file_choose, func_80811A20, func_80811A18, 0x1CAE0),
-};
\ No newline at end of file
+};
-- 
cgit v1.2.3


From 168d90b6b0a5dcd8b76a2a7bb2525453f9df1e45 Mon Sep 17 00:00:00 2001
From: Random <28494085+Random0666@users.noreply.github.com>
Date: Sat, 4 Apr 2020 19:28:53 +0200
Subject: Add log macros

- Add log macros required to match `Graph_GetNextGameState`
---
 src/code/graph.c                |  3 +--
 src/code/padmgr.c               |  3 +--
 src/code/z_elf_message.c        |  8 ++++----
 src/code/z_kaleido_scope_call.c | 14 +++++---------
 src/code/z_room.c               |  4 ++--
 src/code/z_skelanime.c          | 12 ++++--------
 6 files changed, 17 insertions(+), 27 deletions(-)

(limited to 'src/code')

diff --git a/src/code/graph.c b/src/code/graph.c
index 997bcd443..e29453bf2 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -124,8 +124,7 @@ GameStateOverlay* Graph_GetNextGameState() {
         return &gGameStateOverlayTable[5];
     }
 
-    LogUtils_LogThreadId("../graph.c", 696);
-    osSyncPrintf("game_init_func = %08x\n", game_init_func);
+    LOG_ADDRESS("game_init_func", game_init_func, "../graph.c", 696);
     return NULL;
 }
 
diff --git a/src/code/padmgr.c b/src/code/padmgr.c
index 5cc539dbf..8860c2980 100644
--- a/src/code/padmgr.c
+++ b/src/code/padmgr.c
@@ -143,8 +143,7 @@ void func_800C740C(PadMgr* padmgr) {
             } else if (var4 == 11) {
                 padmgr->unk_2AE[var3] = 2;
             } else if (var4 == 4) {
-                LogUtils_LogThreadId("../padmgr.c", 282);
-                osSyncPrintf("++errcnt = %d\n", ++D_8012D284);
+                LOG_VALUE("++errcnt", ++D_8012D284, "../padmgr.c", 282);
                 osSyncPrintf(VT_FGCOL(YELLOW));
                 osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "コントローラパックの通信エラー");
                 osSyncPrintf(VT_RST);
diff --git a/src/code/z_elf_message.c b/src/code/z_elf_message.c
index 3828c6823..272efdf7a 100644
--- a/src/code/z_elf_message.c
+++ b/src/code/z_elf_message.c
@@ -47,8 +47,8 @@ u32 ElfMessage_CheckCondition(ElfMessage* msg) {
             }
     }
 
-    LogUtils_LogThreadId("../z_elf_message.c", 156);
-    osSyncPrintf("\"企画外 条件\" = %s\n", "企画外 条件"); // "Unplanned conditions"
+    // "Unplanned conditions"
+    LOG_STRING("\"企画外 条件\"", "企画外 条件", "../z_elf_message.c", 156);
     __assert("0", "../z_elf_message.c", 157);
 
     return false;
@@ -138,8 +138,8 @@ u16 ElfMessage_GetTextFromMsgs(ElfMessage* msg) {
             case 0xE0:
                 return msg->byte2 | 0x100;
             default:
-                LogUtils_LogThreadId("../z_elf_message.c", 281);
-                osSyncPrintf("\"企画外 条件\" = %s\n", "企画外 条件"); // "Unplanned conditions"
+                // "Unplanned conditions"
+                LOG_STRING("\"企画外 条件\"", "企画外 条件", "../z_elf_message.c", 281);
                 __assert("0", "../z_elf_message.c", 282);
         }
         msg++;
diff --git a/src/code/z_kaleido_scope_call.c b/src/code/z_kaleido_scope_call.c
index 3366c932d..60928cc61 100644
--- a/src/code/z_kaleido_scope_call.c
+++ b/src/code/z_kaleido_scope_call.c
@@ -30,15 +30,11 @@ void KaleidoScopeCall_Init(GlobalContext* globalCtx) {
     osSyncPrintf("カレイド・スコープ入れ替え コンストラクト \n");
     sKaleidoScopeUpdateFunc = KaleidoManager_GetRamAddr(func_80826CB4);
     sKaleidoScopeDrawFunc = KaleidoManager_GetRamAddr(func_808262B8);
-    // Note : the line numbers suggests there was a macro (see logutils.c)
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 98);
-    osSyncPrintf("kaleido_scope_move = %08x\n", func_80826CB4);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 99);
-    osSyncPrintf("kaleido_scope_move_func = %08x\n", sKaleidoScopeUpdateFunc);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 100);
-    osSyncPrintf("kaleido_scope_draw = %08x\n", func_808262B8);
-    LogUtils_LogThreadId("../z_kaleido_scope_call.c", 101);
-    osSyncPrintf("kaleido_scope_draw_func = %08x\n", sKaleidoScopeDrawFunc);
+
+    LOG_ADDRESS("kaleido_scope_move", func_80826CB4, "../z_kaleido_scope_call.c", 98);
+    LOG_ADDRESS("kaleido_scope_move_func", sKaleidoScopeUpdateFunc, "../z_kaleido_scope_call.c", 99);
+    LOG_ADDRESS("kaleido_scope_draw", func_808262B8, "../z_kaleido_scope_call.c", 100);
+    LOG_ADDRESS("kaleido_scope_draw_func", sKaleidoScopeDrawFunc, "../z_kaleido_scope_call.c", 101);
     func_8006ECF4(globalCtx);
 }
 
diff --git a/src/code/z_room.c b/src/code/z_room.c
index ac4e829c5..1cd9984a2 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -558,8 +558,8 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx) {
         j = 0;
         roomList = globalCtx->roomList;
         transitionActor = &globalCtx->transitionActorList[0];
-        LogUtils_LogThreadId("../z_room.c", 912);
-        osSyncPrintf("game_play->room_rom_address.num = %d\n", globalCtx->nbRooms);
+        LOG_VALUE("game_play->room_rom_address.num", globalCtx->nbRooms, "../z_room.c", 912);
+
         for (j = 0; j < globalCtx->nbTransitionActors; j++) {
             frontRoom = transitionActor->frontRoom;
             backRoom = transitionActor->backRoom;
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index cc78b7c74..0dccdd5cb 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -520,14 +520,10 @@ void SkelAnime_AnimateFrame(AnimationHeader* animationSeg, s32 currentFrame, s32
     for (i = 0; i < limbCount; i++, dst++, index++) {
         if ((dst == NULL) || (index == NULL) || (frameRotationValueTable == NULL) || (rotationValueTable == NULL)) {
             if (1) {} // Necessary to match.
-            LogUtils_LogThreadId("../z_skelanime.c", 1392);
-            osSyncPrintf("out = %08x\n", dst);
-            LogUtils_LogThreadId("../z_skelanime.c", 1393);
-            osSyncPrintf("ref_tbl = %08x\n", index);
-            LogUtils_LogThreadId("../z_skelanime.c", 1394);
-            osSyncPrintf("frame_tbl = %08x\n", frameRotationValueTable);
-            LogUtils_LogThreadId("../z_skelanime.c", 1395);
-            osSyncPrintf("tbl = %08x\n", rotationValueTable);
+            LOG_ADDRESS("out", dst, "../z_skelanime.c", 1392);
+            LOG_ADDRESS("ref_tbl", index, "../z_skelanime.c", 1393);
+            LOG_ADDRESS("frame_tbl", frameRotationValueTable, "../z_skelanime.c", 1394);
+            LOG_ADDRESS("tbl", rotationValueTable, "../z_skelanime.c", 1395);
         }
 
         dst->x = index->x >= limit ? frameRotationValueTable[index->x] : rotationValueTable[index->x];
-- 
cgit v1.2.3


From 02eaaa20390c394e1b368184001d3422497a5dbc Mon Sep 17 00:00:00 2001
From: Random <28494085+Random0666@users.noreply.github.com>
Date: Sun, 5 Apr 2020 12:32:08 +0200
Subject: Fixes in PR #50

- Rename "sGraph_UpdateTime" to "sGraphUpdateTime"
- Rename "Graph_Ct"/"Graph_Dt" to "Graph_Init"/"Graph_Destroy"
- Change the LOG_STRING macro
- Rename "LOG_VALUE" to "LOG_NUM"
- Fix brace style
- Rename "UcodeInfo"/"UcodeDisas" to "UCodeInfo"/"UCodeDisas"
- Fix field names in "UCodeDisas"
- Fix typo in "GraphicsContext"
- Change the size of unknown fields in "GraphicsContext" to hex
- Rename "game_init_func" to "gameStateInitFunc"
---
 src/code/graph.c         | 83 ++++++++++++++++++++++++------------------------
 src/code/padmgr.c        |  2 +-
 src/code/z_elf_message.c |  4 +--
 src/code/z_room.c        |  2 +-
 4 files changed, 45 insertions(+), 46 deletions(-)

(limited to 'src/code')

diff --git a/src/code/graph.c b/src/code/graph.c
index e29453bf2..c6d8a6d61 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -7,17 +7,17 @@
 #define GFXPOOL_HEAD_MAGIC 0x1234
 #define GFXPOOL_TAIL_MAGIC 0x5678
 
-OSTime sGraph_UpdateTime;
+OSTime sGraphUpdateTime;
 OSTime sGraphSetTaskTime;
 FaultClient sGraphFaultClient;
 CfbInfo sGraphCfbInfos[3];
 FaultClient sGraphUcodeFaultClient;
 
-UcodeInfo D_8012D230[3] = {
+UCodeInfo D_8012D230[3] = {
     { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
 };
 
-UcodeInfo D_8012D248[3] = {
+UCodeInfo D_8012D248[3] = {
     { 1, D_80155F50 }, { 2, NULL }, { 3, D_801120C0 + 0xFB0 }, // D_80113070
 };
 
@@ -34,7 +34,7 @@ void Graph_FaultClient() {
 }
 
 void Graph_DisassembleUCode(void* arg0) {
-    UcodeDisas disassembler;
+    UCodeDisas disassembler;
 
     if (HREG(80) == 7 && HREG(81) != 0) {
         func_800D7F5C(&disassembler);
@@ -42,35 +42,34 @@ void Graph_DisassembleUCode(void* arg0) {
         func_800DAC80(&disassembler, 3, D_8012D230);
         func_800DAC90(&disassembler, D_80155F50);
         func_800D8400(&disassembler, arg0);
-        HREG(93) = disassembler.dl_cnt;
-        HREG(84) =
-            disassembler.tri2_cnt * 2 + disassembler.tri1_cnt + (disassembler.quad_cnt * 2) + disassembler.line_cnt;
-        HREG(85) = disassembler.vtx_cnt;
-        HREG(86) = disassembler.spvtx_cnt;
-        HREG(87) = disassembler.tri1_cnt;
-        HREG(88) = disassembler.tri2_cnt;
-        HREG(89) = disassembler.quad_cnt;
-        HREG(90) = disassembler.line_cnt;
-        HREG(91) = disassembler.sync_err;
-        HREG(92) = disassembler.loaducode_cnt;
+        HREG(93) = disassembler.dlCnt;
+        HREG(84) = disassembler.tri2Cnt * 2 + disassembler.tri1Cnt + (disassembler.quadCnt * 2) + disassembler.lineCnt;
+        HREG(85) = disassembler.vtxCnt;
+        HREG(86) = disassembler.spvtxCnt;
+        HREG(87) = disassembler.tri1Cnt;
+        HREG(88) = disassembler.tri2Cnt;
+        HREG(89) = disassembler.quadCnt;
+        HREG(90) = disassembler.lineCnt;
+        HREG(91) = disassembler.syncErr;
+        HREG(92) = disassembler.loaducodeCnt;
         if (HREG(82) == 1 || HREG(82) == 2) {
-            osSyncPrintf("vtx_cnt=%d\n", disassembler.vtx_cnt);
-            osSyncPrintf("spvtx_cnt=%d\n", disassembler.spvtx_cnt);
-            osSyncPrintf("tri1_cnt=%d\n", disassembler.tri1_cnt);
-            osSyncPrintf("tri2_cnt=%d\n", disassembler.tri2_cnt);
-            osSyncPrintf("quad_cnt=%d\n", disassembler.quad_cnt);
-            osSyncPrintf("line_cnt=%d\n", disassembler.line_cnt);
-            osSyncPrintf("sync_err=%d\n", disassembler.sync_err);
-            osSyncPrintf("loaducode_cnt=%d\n", disassembler.loaducode_cnt);
-            osSyncPrintf("dl_depth=%d\n", disassembler.dl_depth);
-            osSyncPrintf("dl_cnt=%d\n", disassembler.dl_cnt);
+            osSyncPrintf("vtx_cnt=%d\n", disassembler.vtxCnt);
+            osSyncPrintf("spvtx_cnt=%d\n", disassembler.spvtxCnt);
+            osSyncPrintf("tri1_cnt=%d\n", disassembler.tri1Cnt);
+            osSyncPrintf("tri2_cnt=%d\n", disassembler.tri2Cnt);
+            osSyncPrintf("quad_cnt=%d\n", disassembler.quadCnt);
+            osSyncPrintf("line_cnt=%d\n", disassembler.lineCnt);
+            osSyncPrintf("sync_err=%d\n", disassembler.syncErr);
+            osSyncPrintf("loaducode_cnt=%d\n", disassembler.loaducodeCnt);
+            osSyncPrintf("dl_depth=%d\n", disassembler.dlDepth);
+            osSyncPrintf("dl_cnt=%d\n", disassembler.dlCnt);
         }
         func_800D7FC4(&disassembler);
     }
 }
 
 void Graph_UCodeFaultClient(void* arg0) {
-    UcodeDisas disassembler;
+    UCodeDisas disassembler;
 
     func_800D7F5C(&disassembler);
     disassembler.enableLog = true;
@@ -102,33 +101,33 @@ void* Graph_InitTHGA(GraphicsContext* gfxCtx) {
 }
 
 GameStateOverlay* Graph_GetNextGameState() {
-    void* game_init_func;
+    void* gameStateInitFunc;
 
-    game_init_func = func_800C546C();
-    if (game_init_func == TitleSetup_Init) {
+    gameStateInitFunc = func_800C546C();
+    if (gameStateInitFunc == TitleSetup_Init) {
         return &gGameStateOverlayTable[0];
     }
-    if (game_init_func == func_80801E44) {
+    if (gameStateInitFunc == func_80801E44) {
         return &gGameStateOverlayTable[1];
     }
-    if (game_init_func == Title_Init) {
+    if (gameStateInitFunc == Title_Init) {
         return &gGameStateOverlayTable[2];
     }
-    if (game_init_func == func_800BCA64) {
+    if (gameStateInitFunc == func_800BCA64) {
         return &gGameStateOverlayTable[3];
     }
-    if (game_init_func == Opening_Init) {
+    if (gameStateInitFunc == Opening_Init) {
         return &gGameStateOverlayTable[4];
     }
-    if (game_init_func == func_80811A20) {
+    if (gameStateInitFunc == func_80811A20) {
         return &gGameStateOverlayTable[5];
     }
 
-    LOG_ADDRESS("game_init_func", game_init_func, "../graph.c", 696);
+    LOG_ADDRESS("game_init_func", gameStateInitFunc, "../graph.c", 696);
     return NULL;
 }
 
-void Graph_Ct(GraphicsContext* gfxCtx) {
+void Graph_Init(GraphicsContext* gfxCtx) {
     bzero(gfxCtx, sizeof(GraphicsContext));
     gfxCtx->gfxPoolIdx = 0;
     gfxCtx->fbIdx = 0;
@@ -141,7 +140,7 @@ void Graph_Ct(GraphicsContext* gfxCtx) {
     Fault_AddClient(&sGraphFaultClient, Graph_FaultClient, 0, 0);
 }
 
-void Graph_Dt(GraphicsContext* gfxCtx) {
+void Graph_Destroy(GraphicsContext* gfxCtx) {
     func_800D3210();
     Fault_RemoveClient(&sGraphFaultClient);
 }
@@ -377,10 +376,10 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
     D_8016A560 = 0;
     D_8016A580 = 0;
 
-    if (sGraph_UpdateTime != 0) {
-        D_8016A548 = time - sGraph_UpdateTime;
+    if (sGraphUpdateTime != 0) {
+        D_8016A548 = time - sGraphUpdateTime;
     }
-    sGraph_UpdateTime = time;
+    sGraphUpdateTime = time;
 
     if (D_8012DBC0 && (!~(gameState->input[0].padPressed | ~Z_TRIG)) &&
         (!~(gameState->input[0].raw.pad | ~(L_TRIG | R_TRIG)))) {
@@ -412,7 +411,7 @@ void Graph_ThreadEntry(void* arg0) {
 
     // Start graphic thread execution
     osSyncPrintf("グラフィックスレッド実行開始\n");
-    Graph_Ct(&gfxCtx);
+    Graph_Init(&gfxCtx);
 
     while (nextOvl) {
         ovl = nextOvl;
@@ -443,7 +442,7 @@ void Graph_ThreadEntry(void* arg0) {
         SystemArena_FreeDebug(gameState, "../graph.c", 1227);
         Overlay_FreeGameState(ovl);
     }
-    Graph_Dt(&gfxCtx);
+    Graph_Destroy(&gfxCtx);
     // End of graphic thread execution
     osSyncPrintf("グラフィックスレッド実行終了\n");
 }
diff --git a/src/code/padmgr.c b/src/code/padmgr.c
index 8860c2980..dc3e9c472 100644
--- a/src/code/padmgr.c
+++ b/src/code/padmgr.c
@@ -143,7 +143,7 @@ void func_800C740C(PadMgr* padmgr) {
             } else if (var4 == 11) {
                 padmgr->unk_2AE[var3] = 2;
             } else if (var4 == 4) {
-                LOG_VALUE("++errcnt", ++D_8012D284, "../padmgr.c", 282);
+                LOG_NUM("++errcnt", ++D_8012D284, "../padmgr.c", 282);
                 osSyncPrintf(VT_FGCOL(YELLOW));
                 osSyncPrintf("padmgr: %dコン: %s\n", var3 + 1, "コントローラパックの通信エラー");
                 osSyncPrintf(VT_RST);
diff --git a/src/code/z_elf_message.c b/src/code/z_elf_message.c
index 272efdf7a..ad7ae66c6 100644
--- a/src/code/z_elf_message.c
+++ b/src/code/z_elf_message.c
@@ -48,7 +48,7 @@ u32 ElfMessage_CheckCondition(ElfMessage* msg) {
     }
 
     // "Unplanned conditions"
-    LOG_STRING("\"企画外 条件\"", "企画外 条件", "../z_elf_message.c", 156);
+    LOG_STRING("企画外 条件", "../z_elf_message.c", 156);
     __assert("0", "../z_elf_message.c", 157);
 
     return false;
@@ -139,7 +139,7 @@ u16 ElfMessage_GetTextFromMsgs(ElfMessage* msg) {
                 return msg->byte2 | 0x100;
             default:
                 // "Unplanned conditions"
-                LOG_STRING("\"企画外 条件\"", "企画外 条件", "../z_elf_message.c", 281);
+                LOG_STRING("企画外 条件", "../z_elf_message.c", 281);
                 __assert("0", "../z_elf_message.c", 282);
         }
         msg++;
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 1cd9984a2..ad476f357 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -558,7 +558,7 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx) {
         j = 0;
         roomList = globalCtx->roomList;
         transitionActor = &globalCtx->transitionActorList[0];
-        LOG_VALUE("game_play->room_rom_address.num", globalCtx->nbRooms, "../z_room.c", 912);
+        LOG_NUM("game_play->room_rom_address.num", globalCtx->nbRooms, "../z_room.c", 912);
 
         for (j = 0; j < globalCtx->nbTransitionActors; j++) {
             frontRoom = transitionActor->frontRoom;
-- 
cgit v1.2.3


From 43acba22a94c4e90a237dda5a3376c099633cbda Mon Sep 17 00:00:00 2001
From: Random <28494085+Random0666@users.noreply.github.com>
Date: Sun, 5 Apr 2020 19:29:30 +0200
Subject: Fixes in PR #50 (3)

- Rename Graph_OpenDisp/Graph_CloseDisp to Graph_OpenDisps/Graph_CloseDisps
- Rename gfxArr to dispRefs
---
 src/code/graph.c           |  46 +++----
 src/code/z_actor.c         | 108 ++++++++--------
 src/code/z_cheap_proc.c    |  12 +-
 src/code/z_debug.c         |   6 +-
 src/code/z_debug_display.c |  12 +-
 src/code/z_demo.c          |   6 +-
 src/code/z_draw.c          | 156 +++++++++++------------
 src/code/z_eff_blure.c     |   6 +-
 src/code/z_en_a_keep.c     |   6 +-
 src/code/z_en_item00.c     |  24 ++--
 src/code/z_lifemeter.c     |   6 +-
 src/code/z_map_mark.c      |   6 +-
 src/code/z_moji.c          |  12 +-
 src/code/z_parameter.c     |  42 +++---
 src/code/z_prenmi.c        |   6 +-
 src/code/z_rcp.c           | 264 +++++++++++++++++++-------------------
 src/code/z_room.c          |  24 ++--
 src/code/z_sample.c        |   6 +-
 src/code/z_scene_table.c   | 312 ++++++++++++++++++++++-----------------------
 src/code/z_skelanime.c     |  48 +++----
 20 files changed, 554 insertions(+), 554 deletions(-)

(limited to 'src/code')

diff --git a/src/code/graph.c b/src/code/graph.c
index c6d8a6d61..fb3d80e06 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -157,7 +157,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
     u32 temp;
     OSTime time;
     OSTask_t* task;
-    Gfx* gfxArr[3];
+    Gfx* dispRefs[3];
     OSScTask* scTask;
     CfbInfo* cfb;
 
@@ -219,9 +219,9 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
     task->output_buff_size = gGfxSPTaskYieldBuffer; // ??
     task->data_ptr = gfxCtx->workBuffer;
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../graph.c", 828);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../graph.c", 828);
     task->data_size = (u32)gfxCtx->work.p - (u32)gfxCtx->workBuffer;
-    Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 830);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../graph.c", 830);
 
     task->yield_data_ptr = gGfxSPTaskYieldBuffer;
     task->yield_data_size = sizeof(gGfxSPTaskYieldBuffer);
@@ -264,40 +264,40 @@ u32 sGraphCfbInfoIdx = 0;
 #ifdef NON_MATCHING
 void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
     u32 problem;     // 0xC4 -> 0xD4
-    Gfx* gfxArr[5];  // 0xB0 -> 0xC0
-    Gfx* gfxArr2[9]; // 0x8C -> 0x9C
-    Gfx* gfxArr3[9]; // 0x68 -> 0x78
+    Gfx* dispRefs[5];  // 0xB0 -> 0xC0
+    Gfx* dispRefs2[9]; // 0x8C -> 0x9C
+    Gfx* dispRefs3[9]; // 0x68 -> 0x78
     u64 time;
     GfxPool* pool; // 0x4C -> 0x6C
 
     gameState->unk_A0 = 0;
     Graph_InitTHGA(gfxCtx);
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../graph.c", 966);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../graph.c", 966);
     gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 開始", 0);
     gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 開始", 0);
     gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 開始", 0);
     gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 開始", 0);
-    Graph_CloseDisp(gfxArr, gfxCtx, "../graph.c", 975);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../graph.c", 975);
 
     func_800C4A98(gameState); // Game_ReqPadData
     func_800C4AC8(gameState); // Game_SetGameFrame
 
-    Graph_OpenDisp(gfxArr2, gfxCtx, "../graph.c", 987);
+    Graph_OpenDisps(dispRefs2, gfxCtx, "../graph.c", 987);
     gDPNoOpString(gfxCtx->work.p++, "WORK_DISP 終了", 0);
     gDPNoOpString(gfxCtx->polyOpa.p++, "POLY_OPA_DISP 終了", 0);
     gDPNoOpString(gfxCtx->polyXlu.p++, "POLY_XLU_DISP 終了", 0);
     gDPNoOpString(gfxCtx->overlay.p++, "OVERLAY_DISP 終了", 0);
-    Graph_CloseDisp(gfxArr2, gfxCtx, "../graph.c", 996);
+    Graph_CloseDisps(dispRefs2, gfxCtx, "../graph.c", 996);
 
-    Graph_OpenDisp(gfxArr3, gfxCtx, "../graph.c", 999);
+    Graph_OpenDisps(dispRefs3, gfxCtx, "../graph.c", 999);
     gSPBranchList(gfxCtx->work.p++, gfxCtx->polyOpaBuffer);
     gSPBranchList(gfxCtx->polyOpa.p++, gfxCtx->polyXluBuffer);
     gSPBranchList(gfxCtx->polyXlu.p++, gfxCtx->overlayBuffer);
     gDPPipeSync(gfxCtx->overlay.p++);
     gDPFullSync(gfxCtx->overlay.p++);
     gSPEndDisplayList(gfxCtx->overlay.p++);
-    Graph_CloseDisp(gfxArr3, gfxCtx, "../graph.c", 1028);
+    Graph_CloseDisps(dispRefs3, gfxCtx, "../graph.c", 1028);
 
     if (HREG(80) == 10 && HREG(93) == 2) {
         HREG(80) = 7;
@@ -467,11 +467,11 @@ void* Graph_Alloc2(GraphicsContext* gfxCtx, size_t size) {
     return THGA_AllocEnd(&gfxCtx->polyOpa, ALIGN16(size));
 }
 
-void Graph_OpenDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line) {
+void Graph_OpenDisps(Gfx** dispRefs, GraphicsContext* gfxCtx, const char* file, s32 line) {
     if (HREG(80) == 7 && HREG(82) != 4) {
-        gfxArr[0] = gfxCtx->polyOpa.p;
-        gfxArr[1] = gfxCtx->polyXlu.p;
-        gfxArr[2] = gfxCtx->overlay.p;
+        dispRefs[0] = gfxCtx->polyOpa.p;
+        dispRefs[1] = gfxCtx->polyXlu.p;
+        dispRefs[2] = gfxCtx->overlay.p;
 
         gDPNoOpOpenDisp(gfxCtx->polyOpa.p++, file, line);
         gDPNoOpOpenDisp(gfxCtx->polyXlu.p++, file, line);
@@ -479,22 +479,22 @@ void Graph_OpenDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32
     }
 }
 
-void Graph_CloseDisp(Gfx** gfxArr, GraphicsContext* gfxCtx, const char* file, s32 line) {
+void Graph_CloseDisps(Gfx** dispRefs, GraphicsContext* gfxCtx, const char* file, s32 line) {
     if (HREG(80) == 7 && HREG(82) != 4) {
-        if (gfxArr[0] + 1 == gfxCtx->polyOpa.p) {
-            gfxCtx->polyOpa.p = gfxArr[0];
+        if (dispRefs[0] + 1 == gfxCtx->polyOpa.p) {
+            gfxCtx->polyOpa.p = dispRefs[0];
         } else {
             gDPNoOpCloseDisp(gfxCtx->polyOpa.p++, file, line);
         }
 
-        if (gfxArr[1] + 1 == gfxCtx->polyXlu.p) {
-            gfxCtx->polyXlu.p = gfxArr[1];
+        if (dispRefs[1] + 1 == gfxCtx->polyXlu.p) {
+            gfxCtx->polyXlu.p = dispRefs[1];
         } else {
             gDPNoOpCloseDisp(gfxCtx->polyXlu.p++, file, line);
         }
 
-        if (gfxArr[2] + 1 == gfxCtx->overlay.p) {
-            gfxCtx->overlay.p = gfxArr[2];
+        if (dispRefs[2] + 1 == gfxCtx->overlay.p) {
+            gfxCtx->overlay.p = dispRefs[2];
         } else {
             gDPNoOpCloseDisp(gfxCtx->overlay.p++, file, line);
         }
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 72fe340b4..4b95dfe3a 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -14,14 +14,14 @@ void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* global
     f32 temp2;
     MtxF sp60;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (actor->floorPoly != NULL) {
         temp1 = actor->posRot.pos.y - actor->unk_80;
 
         if (temp1 >= -50.0f && temp1 < 500.0f) {
             gfxCtx = globalCtx->state.gfxCtx;
-            Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1553);
 
             gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
 
@@ -52,7 +52,7 @@ void func_8002B200(Actor* actor, LightMapper* lightMapper, GlobalContext* global
                       G_MTX_MODELVIEW | G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
 
-            Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1594);
         }
     }
 }
@@ -74,9 +74,9 @@ void ActorShadow_DrawFunc_Squiggly(Actor* actor, LightMapper* lightMapper, Globa
 void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3, f32 arg4, f32 arg5, f32 arg6) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     f32 sp58;
-    Gfx* gfxArr[7];
+    Gfx* dispRefs[7];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1661);
 
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0, 0, 0,
                     (u32)(((arg3 * 0.00005f) > 1.0f ? 1.0f : (arg3 * 0.00005f)) * arg4) & 0xFF);
@@ -92,7 +92,7 @@ void func_8002B66C(GlobalContext* globalCtx, Light* light, MtxF* arg2, s32 arg3,
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04048180);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1693);
 }
 
 #ifdef NON_MATCHING
@@ -103,7 +103,7 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
     f32 spE0[2];
     s32 i;
     f32* spAC;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     f32 temp_10;
     u8 temp_14;
     f32 temp_f0;
@@ -139,7 +139,7 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
         temp_s6 -= 2;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1741);
 
         gfxCtx->polyOpa.p = Gfx_CallSetupDL(gfxCtx->polyOpa.p, 0x2C);
         actor->shape.unk_15 = 0;
@@ -209,7 +209,7 @@ void ActorShadow_DrawFunc_Teardrop(Actor* actor, LightMapper* lightMapper, Globa
             actor->shape.unk_15 = ((spE0[0] + temp_f0) < (spE0[1] - temp_f0)) ? 2 : 1;
         }
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 1831);
     }
 }
 #else
@@ -316,7 +316,7 @@ void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
     Actor* actor;
     Player* player;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     TargetContextEntry* entry;
     s16 spCE;
     f32 temp1;
@@ -331,7 +331,7 @@ void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
 
     actor = targetCtx->targetedActor;
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2029);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2029);
 
     if (targetCtx->unk_48 != 0) {
         player = PLAYER;
@@ -431,7 +431,7 @@ void func_8002C124(TargetContext* targetCtx, GlobalContext* globalCtx) {
         gSPDisplayList(gfxCtx->polyXlu.p++, &D_0400CB70);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2158);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_actor/func_8002C124.s")
@@ -736,7 +736,7 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
     s32 spB4;
     s32 spB0;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (titleCtx->unk_C != 0) {
         spCC = titleCtx->unk_8;
@@ -746,7 +746,7 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
         sp38 = spCC * 2;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2824);
 
         spB0 = spCC * spC8 * gSaveContext.language;
         spC8 = (spCC * spC8 > 0x1000) ? 0x1000 / spCC : spC8;
@@ -777,7 +777,7 @@ void TitleCard_Draw(GlobalContext* globalCtx, TitleCardContext* titleCtx) {
                                 G_TX_RENDERTILE, 0, 0, 1024, 1024);
         }
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 2880);
     }
 }
 
@@ -1331,22 +1331,22 @@ Gfx* func_8002E830(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext*
 
 Hilite* func_8002EABC(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx) {
     Hilite* hilite;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 4306);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 4306);
     gfxCtx->polyOpa.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyOpa.p, &hilite);
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 4313);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 4313);
 
     return hilite;
 }
 
 Hilite* func_8002EB44(Vec3f* object, Vec3f* eye, Vec3f* lightDir, GraphicsContext* gfxCtx) {
     Hilite* hilite;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 4332);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 4332);
     gfxCtx->polyXlu.p = func_8002E830(object, eye, lightDir, gfxCtx, gfxCtx->polyXlu.p, &hilite);
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 4339);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 4339);
 
     return hilite;
 }
@@ -1357,7 +1357,7 @@ void func_8002EBCC(Actor* actor, GlobalContext* globalCtx, s32 flag) {
     Gfx* displayListHead;
     Gfx* displayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     lightDir.x = globalCtx->unk_10A4E;
     lightDir.y = globalCtx->unk_10A4F;
@@ -1375,13 +1375,13 @@ void func_8002EBCC(Actor* actor, GlobalContext* globalCtx, s32 flag) {
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4384);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyOpa.p++, 0x07, displayList);
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4394);
     }
 }
 
@@ -1391,7 +1391,7 @@ void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag) {
     Gfx* displayListHead;
     Gfx* displayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     lightDir.x = globalCtx->unk_10A4E;
     lightDir.y = globalCtx->unk_10A4F;
@@ -1404,13 +1404,13 @@ void func_8002ED80(Actor* actor, GlobalContext* globalCtx, s32 flag) {
         displayListHead = displayList;
 
         gfxCtx = globalCtx->state.gfxCtx;
-        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4429);
 
         gDPSetHilite1Tile(displayListHead++, 1, hilite, 0x10, 0x10);
         gSPEndDisplayList(displayListHead);
         gSPSegment(gfxCtx->polyXlu.p++, 0x07, displayList);
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 4439);
     }
 }
 
@@ -1807,7 +1807,7 @@ Color_RGB8 D_80116064 = { 0x64, 0xC8, 0x00 };
 // this also doesn't generate a few useless struct copies
 void func_8002FBAC(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[6];
+    Gfx* dispRefs[6];
     Vec3f lightPos;
     f32 spD8;
     f32 spD4;
@@ -1830,7 +1830,7 @@ void func_8002FBAC(GlobalContext* globalCtx) {
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 5308);
 
     if (gSaveContext.respawn[RESPAWN_MODE_TOP].data != 0) {
         if (LINK_IS_ADULT) {
@@ -1962,7 +1962,7 @@ void func_8002FBAC(GlobalContext* globalCtx) {
         Lights_InitType0PositionalLight(&D_8015BC00, lightPos.x, lightPos.y, lightPos.z, 0xFF, 0xFF, 0xFF,
                                         500.0f * spD4);
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 5474);
     }
 }
 #else
@@ -2192,13 +2192,13 @@ void Actor_Draw(GlobalContext* globalCtx, Actor* actor) {
     LightMapper* lightMapper;
     GraphicsContext* gfxCtx;
     Camera* camera;
-    Gfx* gfxArr[3];
+    Gfx* dispRefs[3];
 
     Fault_AddClient(&faultClient, Actor_FaultPrint, actor, "Actor_draw");
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6035);
 
     lightMapper = Lights_CreateMapper(&globalCtx->lightCtx, globalCtx->state.gfxCtx);
 
@@ -2253,7 +2253,7 @@ void Actor_Draw(GlobalContext* globalCtx, Actor* actor) {
         actor->shape.shadowDrawFunc(actor, lightMapper, globalCtx);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6119);
 
     Fault_RemoveClient(&faultClient);
 }
@@ -2273,9 +2273,9 @@ void func_80030ED8(Actor* actor) {
 }
 
 void func_80030FA8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 6161);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 6161);
 
     gDPLoadTextureBlock(gfxCtx->polyXlu.p++, &D_0401E370, G_IM_FMT_I, G_IM_SIZ_8b, 64, 64, 0, G_TX_MIRROR | G_TX_CLAMP,
                         G_TX_MIRROR | G_TX_CLAMP, 6, 6, G_TX_NOLOD, G_TX_NOLOD);
@@ -2284,18 +2284,18 @@ void func_80030FA8(GraphicsContext* gfxCtx) {
     gSPTextureRectangle(gfxCtx->polyXlu.p++, 0, 0, 1280, 960, G_TX_RENDERTILE, 2240, 1600, 576, 597);
     gDPPipeSync(gfxCtx->polyXlu.p++);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 6183);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 6183);
 }
 
 void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invisibleActors) {
     Actor** invisibleActor;
     GraphicsContext* gfxCtx;
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_actor.c", 6197);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_actor.c", 6197);
 
     // Translates to: "MAGIC LENS START"
     gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ START", 0);
@@ -2360,7 +2360,7 @@ void func_8003115C(GlobalContext* globalCtx, s32 nbInvisibleActors, Actor** invi
     // Translates to: "MAGIC LENS END"
     gDPNoOpString(gfxCtx->polyOpa.p++, "魔法のメガネ END", 0);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_actor.c", 6284);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_actor.c", 6284);
 }
 
 s32 func_800314B0(GlobalContext* globalCtx, Actor* actor) {
@@ -2388,7 +2388,7 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
     ActorListEntry* actorListEntry;
     GraphicsContext* gfxCtx;
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
     Actor* actor;
     ActorOverlay* overlayEntry;
     char* actorName;
@@ -2396,7 +2396,7 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
     gfxCtx = globalCtx->state.gfxCtx;
     invisibleActorCounter = 0;
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6336);
 
     actorListEntry = &actorCtx->actorList[0];
 
@@ -2485,7 +2485,7 @@ void func_800315AC(GlobalContext* globalCtx, ActorContext* actorCtx) {
         func_8005D62C(globalCtx, &globalCtx->sub_11E60);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 6563);
 }
 
 void func_80031A28(GlobalContext* globalCtx, ActorContext* actorCtx) {
@@ -3483,9 +3483,9 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
     Vec3f sp50;
     CollisionPoly* sp4C;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8120);
 
     if (0) {} // Necessary to match
 
@@ -3512,7 +3512,7 @@ void func_80033C30(Vec3f* arg0, Vec3f* arg1, u8 alpha, GlobalContext* globalCtx)
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04049210);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8155);
 }
 
 void func_80033DB8(GlobalContext* globalCtx, s16 arg1, s16 arg2) {
@@ -3572,13 +3572,13 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2) {
     f32 temp2;
     f32 temp3;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     entry = &D_801160DC[arg2];
     var = entry->unk_10;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8265);
 
     Matrix_Translate(0.0f, entry->unk_08, 500.0f, MTXMODE_APPLY);
     Matrix_Get(&spB0);
@@ -3615,7 +3615,7 @@ void func_80033F54(GlobalContext* globalCtx, s32 arg1, s32 arg2) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, entry->unk_18);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8319);
 }
 
 void func_8003424C(GlobalContext* globalCtx, Vec3f* arg1) {
@@ -3887,9 +3887,9 @@ Gfx* func_80034B54(GraphicsContext* gfxCtx) {
 void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_LimbUpdateMatrix2 unkFunc1,
                    SkelAnime_LimbAppendDlist2 unkFunc2, Actor* actor, s16 alpha) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8831);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
@@ -3901,15 +3901,15 @@ void func_80034BA0(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     gfxCtx->polyOpa.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
                                           skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyOpa.p);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8860);
 }
 
 void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_LimbUpdateMatrix2 unkFunc1,
                    SkelAnime_LimbAppendDlist2 unkFunc2, Actor* actor, s16 alpha) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8876);
 
     func_80093D84(globalCtx->state.gfxCtx);
 
@@ -3920,7 +3920,7 @@ void func_80034CC4(GlobalContext* globalCtx, SkelAnime* skelAnime, SkelAnime_Lim
     gfxCtx->polyXlu.p = SkelAnime_DrawSV2(globalCtx, skelAnime->skeleton, skelAnime->actorDrawTbl,
                                           skelAnime->dListCount, unkFunc1, unkFunc2, actor, gfxCtx->polyXlu.p);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_actor.c", 8904);
 }
 
 s16 func_80034DD4(Actor* actor, GlobalContext* globalCtx, s16 arg2, f32 arg3) {
diff --git a/src/code/z_cheap_proc.c b/src/code/z_cheap_proc.c
index 740120df8..3b83d1b71 100644
--- a/src/code/z_cheap_proc.c
+++ b/src/code/z_cheap_proc.c
@@ -3,28 +3,28 @@
 
 void Gfx_DrawDListOpa(GlobalContext* globalCtx, u32 dlist) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 214);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 216),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, dlist);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 219);
 }
 
 void Gfx_DrawDListXlu(GlobalContext* globalCtx, u32 dlist) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 228);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_cheap_proc.c", 230),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_cheap_proc.c", 233);
 }
diff --git a/src/code/z_debug.c b/src/code/z_debug.c
index a4febc4c7..adda7974b 100644
--- a/src/code/z_debug.c
+++ b/src/code/z_debug.c
@@ -221,9 +221,9 @@ void func_80063D7C(GraphicsContext* gfxCtx) {
     void* unk2[6];
     GfxPrint gfxPrint;
     void* unk[2];
-    Gfx* dlFrame[4]; // stores state of GfxCtx next ptrs
+    Gfx* dispRefs[4]; // stores state of GfxCtx next ptrs
 
-    Graph_OpenDisp(&dlFrame, gfxCtx, "../z_debug.c", 628);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_debug.c", 628);
     GfxPrint_Ctor(&gfxPrint);
     sp78 = gfxCtx->polyOpa.p;
     tempRet = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
@@ -244,6 +244,6 @@ void func_80063D7C(GraphicsContext* gfxCtx) {
     Graph_BranchDlist(sp78, sp7C);
     gfxCtx->polyOpa.p = sp7C;
     if (0) {}
-    Graph_CloseDisp(&dlFrame, gfxCtx, "../z_debug.c", 664);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_debug.c", 664);
     GfxPrint_Dtor(&gfxPrint);
 }
diff --git a/src/code/z_debug_display.c b/src/code/z_debug_display.c
index 82765d9f6..914d70c89 100644
--- a/src/code/z_debug_display.c
+++ b/src/code/z_debug_display.c
@@ -72,9 +72,9 @@ void DebugDisplay_DrawObjects(GlobalContext* globalCtx) {
 
 static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 169);
 
     func_80094678(globalCtx->state.gfxCtx);
 
@@ -92,14 +92,14 @@ static void DebugDisplay_DrawSpriteI8(DebugDispObject* dispObj, u32 texture, Glo
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_04004298);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 192);
 }
 
 static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 211);
     func_8009435C(globalCtx->state.gfxCtx);
 
     gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, dispObj->color.r, dispObj->color.g, dispObj->color.b, dispObj->color.a);
@@ -113,5 +113,5 @@ static void DebugDisplay_DrawPolygon(DebugDispObject* dispObj, u32 dlist, Global
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, dlist);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_debug_display.c", 231);
 }
diff --git a/src/code/z_demo.c b/src/code/z_demo.c
index 8cdd7e8f6..c2cad2206 100644
--- a/src/code/z_demo.c
+++ b/src/code/z_demo.c
@@ -1867,7 +1867,7 @@ void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
     Gfx* displayList;
     Gfx* prevDisplayList;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (0) {} // Necessary to match
 
@@ -1876,7 +1876,7 @@ void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
 
         if (BREG(0) != 0) {
             gfxCtx = globalCtx->state.gfxCtx;
-            Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_demo.c", 4101);
 
             prevDisplayList = gfxCtx->polyOpa.p;
             displayList = Graph_GfxPlusOne(gfxCtx->polyOpa.p);
@@ -1886,7 +1886,7 @@ void func_80068C3C(GlobalContext* globalCtx, CutsceneContext* csCtx) {
             Graph_BranchDlist(prevDisplayList, displayList);
             gfxCtx->polyOpa.p = displayList;
 
-            Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_demo.c", 4108);
         }
 
         csCtx->frames++;
diff --git a/src/code/z_draw.c b/src/code/z_draw.c
index 187b4226e..ce07d2b36 100644
--- a/src/code/z_draw.c
+++ b/src/code/z_draw.c
@@ -169,37 +169,37 @@ void func_800694A0(GlobalContext* globalCtx, s16 drawId) {
 
 static void func_800694E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 556);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 556);
 
     func_80093BA8(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 560),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 565);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 565);
 }
 
 static void func_800695C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 572);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 572);
 
     gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 5);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 576),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 581);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 581);
 }
 
 static void func_8006969C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 588);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 588);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 592),
@@ -219,14 +219,14 @@ static void func_8006969C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     Matrix_Pull();
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 621);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 621);
 }
 
 static void func_80069880(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 628);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 628);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 632),
@@ -249,14 +249,14 @@ static void func_80069880(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 663);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 663);
 }
 
 static void func_80069AC8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 670);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 670);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 674),
@@ -278,14 +278,14 @@ static void func_80069AC8(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
     Matrix_Pull();
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 704);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 704);
 }
 
 static void func_80069CF0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 712);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 712);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -302,14 +302,14 @@ static void func_80069CF0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 735);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 735);
 }
 
 static void func_80069EB0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 742);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 742);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 746),
@@ -325,14 +325,14 @@ static void func_80069EB0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 765);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 765);
 }
 
 static void func_8006A060(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 772);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 772);
 
     func_80093BA8(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 776),
@@ -340,14 +340,14 @@ static void func_8006A060(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[1]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 783);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 783);
 }
 
 static void func_8006A158(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 811);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 811);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 815),
@@ -359,14 +359,14 @@ static void func_8006A158(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 827);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 827);
 }
 
 static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 834);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 834);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -386,14 +386,14 @@ static void func_8006A2A0(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[5]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 861);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 861);
 }
 
 static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 868);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 868);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -404,14 +404,14 @@ static void func_8006A4B0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 883);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 883);
 }
 
 static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 890);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 890);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -422,14 +422,14 @@ static void func_8006A5F0(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 906);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 906);
 }
 
 static void func_8006A73C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 913);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 913);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -440,14 +440,14 @@ static void func_8006A73C(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 929);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 929);
 }
 
 static void func_8006A88C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 936);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 936);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -458,28 +458,28 @@ static void func_8006A88C(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 952);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 952);
 }
 
 static void func_8006A9CC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 959);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 959);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 963),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 968);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 968);
 }
 
 static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 975);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 975);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 979),
@@ -491,27 +491,27 @@ static void func_8006AAA8(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 991);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 991);
 }
 
 static void func_8006ABEC(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 998);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 998);
     func_80093D84(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyXlu.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1002),
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1008);
 }
 
 static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1015);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1019),
@@ -524,14 +524,14 @@ static void func_8006ACE4(GlobalContext* globalCtx, s16 drawId) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1032);
 }
 
 static void func_8006AE40(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1039);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1043),
@@ -544,14 +544,14 @@ static void func_8006AE40(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1056);
 }
 
 static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1063);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -564,14 +564,14 @@ static void func_8006AF9C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1081);
 }
 
 static void func_8006B124(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1088);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1092),
@@ -581,14 +581,14 @@ static void func_8006B124(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[2]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[3]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1100);
 }
 
 static void func_8006B24C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1108);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1112),
@@ -602,14 +602,14 @@ static void func_8006B24C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1126);
 }
 
 static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1133);
 
     Matrix_Scale(0.7f, 0.7f, 0.7f, MTXMODE_APPLY);
 
@@ -625,14 +625,14 @@ static void func_8006B3C0(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[2]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1154);
 }
 
 static void func_8006B54C(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1162);
 
     func_80093D84(globalCtx->state.gfxCtx);
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -646,14 +646,14 @@ static void func_8006B54C(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[1]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[0]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1181);
 }
 
 static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1188);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1192),
@@ -668,15 +668,15 @@ static void func_8006B6E4(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[3]);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDrawItemTable[drawId].dlists[4]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1207);
 }
 
 static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
     u32 pad;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1214);
 
     func_80093D18(globalCtx->state.gfxCtx);
     gSPMatrix(gfxCtx->polyOpa.p++, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_draw.c", 1218),
@@ -690,5 +690,5 @@ static void func_8006B870(GlobalContext* globalCtx, s16 drawId) {
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[6]);
     gSPDisplayList(gfxCtx->polyOpa.p++, sDrawItemTable[drawId].dlists[7]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_draw.c", 1230);
 }
diff --git a/src/code/z_eff_blure.c b/src/code/z_eff_blure.c
index 4b91bba40..21f2bc75a 100644
--- a/src/code/z_eff_blure.c
+++ b/src/code/z_eff_blure.c
@@ -10,13 +10,13 @@
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80020A50.s")
 
 void func_80020F60(u32 unused, GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, D_80135180, 809);
+    Graph_OpenDisps(dispRefs, gfxCtx, D_80135180, 809);
 
     gfxCtx->polyXlu.p = Gfx_CallSetupDL(gfxCtx->polyXlu.p, 0x26);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, D_80135194, 813);
+    Graph_CloseDisps(dispRefs, gfxCtx, D_80135194, 813);
 }
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_eff_blure/func_80020FC0.s")
diff --git a/src/code/z_en_a_keep.c b/src/code/z_en_a_keep.c
index 5a23dedfc..84107e8a4 100644
--- a/src/code/z_en_a_keep.c
+++ b/src/code/z_en_a_keep.c
@@ -331,9 +331,9 @@ void En_A_Obj_Update(ActorEnAObj* this, GlobalContext* globalCtx) {
 void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
     s32 type = this->actor.params;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 701);
 
     func_80093D18(globalCtx->state.gfxCtx);
 
@@ -349,5 +349,5 @@ void En_A_Obj_Draw(ActorEnAObj* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, D_80115484[type]);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_a_keep.c", 715);
 }
diff --git a/src/code/z_en_item00.c b/src/code/z_en_item00.c
index 22bf17b0e..7d71802bb 100644
--- a/src/code/z_en_item00.c
+++ b/src/code/z_en_item00.c
@@ -767,9 +767,9 @@ void En_Item00_Draw(ActorEnItem00* this, GlobalContext* globalCtx) {
 void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
     s32 iconNb;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1546);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
@@ -789,7 +789,7 @@ void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_04042440);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1568);
 }
 
 /**
@@ -798,11 +798,11 @@ void func_8001EF30(ActorEnItem00* this, GlobalContext* globalCtx) {
 void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
     s32 iconNb;
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     iconNb = this->actor.params - 3;
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1594);
 
     gfxCtx->polyOpa.p = func_800BC8A0(globalCtx, gfxCtx->polyOpa.p);
 
@@ -820,7 +820,7 @@ void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyOpa.p++, &D_0403F070);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1611);
 }
 
 /**
@@ -828,9 +828,9 @@ void func_8001F080(ActorEnItem00* this, GlobalContext* globalCtx) {
  */
 void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1623);
 
     func_80093D18(globalCtx->state.gfxCtx);
     func_8002EBCC(&this->actor, globalCtx, 0);
@@ -844,7 +844,7 @@ void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403BCD8);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1647);
 }
 
 /**
@@ -852,9 +852,9 @@ void func_8001F1F4(ActorEnItem00* this, GlobalContext* globalCtx) {
  */
 void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1658);
 
     func_80093D84(globalCtx->state.gfxCtx);
     func_8002ED80(&this->actor, globalCtx, 0);
@@ -862,7 +862,7 @@ void func_8001F334(ActorEnItem00* this, GlobalContext* globalCtx) {
               G_MTX_MODELVIEW | G_MTX_LOAD);
     gSPDisplayList(gfxCtx->polyXlu.p++, &D_0403B030);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_en_item00.c", 1673);
 }
 
 /**
diff --git a/src/code/z_lifemeter.c b/src/code/z_lifemeter.c
index ea70e8ece..cd430e55a 100644
--- a/src/code/z_lifemeter.c
+++ b/src/code/z_lifemeter.c
@@ -206,9 +206,9 @@ void Interface_DrawHealth(GlobalContext* globalCtx) {
     s32 curCombineModeSet = 0;
     u8* curBgImgLoaded = NULL;
     s32 ddHeartCountMinusOne = gSaveContext.defense_hearts - 1;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_lifemeter.c", 353);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_lifemeter.c", 353);
 
     if (!(gSaveContext.health % 0x10)) {
         fullHeartCount--;
@@ -379,7 +379,7 @@ void Interface_DrawHealth(GlobalContext* globalCtx) {
         }
     }
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_lifemeter.c", 606);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_lifemeter.c", 606);
 }
 
 u32 Health_IsCritical(void);
diff --git a/src/code/z_map_mark.c b/src/code/z_map_mark.c
index 31fd73964..698715ffe 100644
--- a/src/code/z_map_mark.c
+++ b/src/code/z_map_mark.c
@@ -86,7 +86,7 @@ void MapMark_Draw(GlobalContext* globalCtx) {
     s32 rectLeft;
     s32 rectTop;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     dungeonId = gSaveContext.dungeon_index;
     interfaceCtx = &globalCtx->interfaceCtx;
@@ -101,7 +101,7 @@ void MapMark_Draw(GlobalContext* globalCtx) {
     mapMarkData = &sLoadedMarkDataTable[dungeonId][interfaceCtx->roomNum][0];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_map_mark.c", 303);
 
     while (1) {
         if (mapMarkData->markType == -1) {
@@ -134,7 +134,7 @@ void MapMark_Draw(GlobalContext* globalCtx) {
         mapMarkData++;
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_map_mark.c", 339);
 }
 
 void MapMark_DrawConditionally(GlobalContext* globalCtx) {
diff --git a/src/code/z_moji.c b/src/code/z_moji.c
index c9568b33f..d6966544f 100644
--- a/src/code/z_moji.c
+++ b/src/code/z_moji.c
@@ -37,9 +37,9 @@ void func_8007B934(s32 arg0, s32 arg1) {
 }
 
 void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1) {
-    Gfx* gfxArr[7];
+    Gfx* dispRefs[7];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_moji.c", 86);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_moji.c", 86);
 
     if ((u32)gLetterTLUT & 0xF) {
         osSyncPrintf("moji_tlut --> %X\n", gLetterTLUT);
@@ -54,14 +54,14 @@ void func_8007B9A4(GraphicsContext* gfxCtx, u8 arg1) {
                         (D_80120124 + 8) << 2, G_TX_RENDERTILE, (u16)(arg1 & 4) * 64, (u16)(arg1 >> 3) * 256, 1024,
                         1024);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_moji.c", 123);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_moji.c", 123);
 }
 
 void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
     s32 i;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_moji.c", 137);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_moji.c", 137);
 
     if ((u32)gFontFF & 0xF) {
         osSyncPrintf("font_ff --> %X\n", gFontFF);
@@ -108,5 +108,5 @@ void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
         }
     }
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_moji.c", 181);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_moji.c", 181);
 }
diff --git a/src/code/z_parameter.c b/src/code/z_parameter.c
index bd1cc13e0..d0e69f5bc 100644
--- a/src/code/z_parameter.c
+++ b/src/code/z_parameter.c
@@ -2582,10 +2582,10 @@ void Interface_DrawMagicBar(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     s16 magicBarY;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2650);
 
     if (gSaveContext.magic_level != 0) {
         if (gSaveContext.health_capacity > 0xA0) {
@@ -2660,7 +2660,7 @@ void Interface_DrawMagicBar(GlobalContext* globalCtx) {
         }
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2731);
 }
 
 void func_80088AA0(s16 arg0) {
@@ -2700,9 +2700,9 @@ void func_80088B34(s16 arg0) {
 }
 
 void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_parameter.c", 2820);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_parameter.c", 2820);
 
     gDPSetTextureImage(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, texture);
     gDPSetTile(gfxCtx->overlay.p++, G_IM_FMT_IA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_NOMIRROR | G_TX_WRAP,
@@ -2716,7 +2716,7 @@ void Interface_DrawActionLabel(GraphicsContext* gfxCtx, void* texture) {
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_parameter.c", 2829);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_parameter.c", 2829);
 }
 
 u8* sCUpLabelTextures[] = { D_02002FC0, D_02002FC0, D_02002FC0 };
@@ -2733,11 +2733,11 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx) {
     s16 cUpAlpha;
     s32 pad;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 2900);
 
     // B Button Color & Texture
     // Also loads the Item Button Texture reused by other buttons afterwards
@@ -2881,7 +2881,7 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx) {
         }
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3071);
 }
 #else
 void Interface_DrawItemButtons(GlobalContext* globalCtx);
@@ -2890,10 +2890,10 @@ void Interface_DrawItemButtons(GlobalContext* globalCtx);
 
 void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16 button) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3079);
 
     gDPLoadTextureBlock(gfxCtx->overlay.p++, texture, G_IM_FMT_RGBA, G_IM_SIZ_32b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
                         G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
@@ -2903,7 +2903,7 @@ void Interface_DrawItemIconTexture(GlobalContext* globalCtx, void* texture, s16
                         (R_ITEM_ICON_Y(button) + R_ITEM_ICON_WIDTH(button)) << 2, G_TX_RENDERTILE, 0, 0,
                         R_ITEM_ICON_DD(button) * 2, R_ITEM_ICON_DD(button) * 2);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3094);
 }
 
 void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
@@ -2911,10 +2911,10 @@ void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
     s16 ammo;
     GraphicsContext* gfxCtx;
     s16 i;
-    Gfx* gfxArr[3];
+    Gfx* dispRefs[3];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3105);
 
     item = gSaveContext.equips.button_items[button];
 
@@ -2964,16 +2964,16 @@ void Interface_DrawAmmoCount(GlobalContext* globalCtx, s16 button, s16 alpha) {
                                            R_ITEM_AMMO_Y(button), 8, 8, 1024, 1024);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3158);
 }
 
 void Interface_DrawActionButton(GlobalContext* globalCtx) {
     InterfaceContext* interfaceCtx = &globalCtx->interfaceCtx;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3172);
 
     Matrix_Translate(0.0f, 0.0f, XREG(18) / 10.0f, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
@@ -2991,7 +2991,7 @@ void Interface_DrawActionButton(GlobalContext* globalCtx) {
 
     gSP1Quadrangle(gfxCtx->overlay.p++, 0, 2, 3, 1, 0);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3187);
 }
 
 void Interface_InitVertices(GlobalContext* globalCtx) {
@@ -3149,11 +3149,11 @@ void Interface_Draw(GlobalContext* globalCtx) {
     s16 phi_s0;
     s16 sp274;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 3405);
 
     gSPSegment(gfxCtx->overlay.p++, 0x02, interfaceCtx->parameterSegment);
     gSPSegment(gfxCtx->overlay.p++, 0x07, interfaceCtx->do_actionSegment);
@@ -3968,7 +3968,7 @@ void Interface_Draw(GlobalContext* globalCtx) {
         gDPFillRectangle(gfxCtx->overlay.p++, 0, 0, gScreenWidth - 1, gScreenHeight - 1);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_parameter.c", 4269);
 }
 #else
 s16 D_8015FFE0;
diff --git a/src/code/z_prenmi.c b/src/code/z_prenmi.c
index f29816dc1..286c6328f 100644
--- a/src/code/z_prenmi.c
+++ b/src/code/z_prenmi.c
@@ -26,11 +26,11 @@ void PreNMI_Update(PreNMIContext* prenmiCtx) {
 
 void PreNMI_Draw(PreNMIContext* prenmiCtx) {
     GraphicsContext* gfxCtx = prenmiCtx->state.gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
     osSyncPrintf(VT_COL(YELLOW, BLACK) "prenmi_draw\n" VT_RST);
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_prenmi.c", 96);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_prenmi.c", 96);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
     func_80095248(gfxCtx, 0, 0, 0);
@@ -39,7 +39,7 @@ void PreNMI_Draw(PreNMIContext* prenmiCtx) {
                     (GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1) << 16) | GPACK_RGBA5551(0xFF, 0xFF, 0xFF, 1));
     gDPFillRectangle(gfxCtx->polyOpa.p++, 0, prenmiCtx->timer + 100, SCREEN_WIDTH - 1, prenmiCtx->timer + 100);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_prenmi.c", 112);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_prenmi.c", 112);
 }
 
 void PreNMI_Main(PreNMIContext* prenmiCtx) {
diff --git a/src/code/z_rcp.c b/src/code/z_rcp.c
index e3b71a460..6472f300f 100644
--- a/src/code/z_rcp.c
+++ b/src/code/z_rcp.c
@@ -889,169 +889,169 @@ Gfx* func_80093808(Gfx* gfx) {
 }
 
 void func_80093848(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1293);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1293);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3A]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1297);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1297);
 }
 
 void func_800938B4(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1309);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1309);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x39]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1313);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1313);
 }
 
 void func_80093920(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1325);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1325);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x32]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1329);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1329);
 }
 
 void func_8009398C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1341);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1341);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x33]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1345);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1345);
 }
 
 void func_800939F8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1357);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1357);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x34]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1361);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1361);
 }
 
 void func_80093A64(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1373);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1373);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x35]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1377);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1377);
 }
 
 void func_80093AD0(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1389);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1389);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x36]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1393);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1393);
 }
 
 void func_80093B3C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1405);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1405);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x37]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1409);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1409);
 }
 
 void func_80093BA8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1421);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1421);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1A]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1425);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1425);
 }
 
 void func_80093C14(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1439);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1439);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1443);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1443);
 }
 
 void func_80093C80(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
     gfxCtx = globalCtx->state.gfxCtx;
     func_80093D18(gfxCtx);
 
     if (globalCtx->roomCtx.curRoom.unk_03 == 3) {
-        Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1460);
+        Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1460);
 
         gDPSetColorDither(gfxCtx->polyOpa.p++, G_CD_DISABLE);
 
-        Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1462);
+        Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1462);
     }
 }
 
 void func_80093D18(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1475);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1475);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x19]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1479);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1479);
 }
 
 void func_80093D84(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1491);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1491);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x19]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1495);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1495);
 }
 
 void func_80093DF0(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1507);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1507);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1F]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1511);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1511);
 }
 
 void func_80093E5C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1523);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1523);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x20]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1527);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1527);
 }
 
 void func_80093EC8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1539);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1539);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x21]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1543);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1543);
 }
 
 Gfx* func_80093F34(Gfx* gfx) {
@@ -1065,43 +1065,43 @@ Gfx* func_80093F58(Gfx* gfx) {
 }
 
 void func_80093F7C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1569);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1569);
 
     gfxCtx->polyOpa.p = func_80093F58(gfxCtx->polyOpa.p);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1573);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1573);
 }
 
 void func_80093FD8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1585);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1585);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x23]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1589);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1589);
 }
 
 void func_80094044(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1601);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1601);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2C]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1605);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1605);
 }
 
 void func_800940B0(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1617);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1617);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x24]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1621);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1621);
 }
 
 Gfx* func_8009411C(Gfx* gfx) {
@@ -1110,83 +1110,83 @@ Gfx* func_8009411C(Gfx* gfx) {
 }
 
 void func_80094140(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1640);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1640);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x1C]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1644);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1644);
 }
 
 void func_800941AC(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1651);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1651);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2B]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1655);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1655);
 }
 
 void func_80094218(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1670);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1670);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2D]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1674);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1674);
 }
 
 void func_80094284(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1681);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1681);
 
     gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2E]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1685);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1685);
 }
 
 void func_800942F0(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1700);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1700);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x26]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1704);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1704);
 }
 
 void func_8009435C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1722);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1722);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x04]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1726);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1726);
 }
 
 void func_800943C8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1758);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1758);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x25]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1762);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1762);
 }
 
 void func_80094434(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1775);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1775);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x02]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1779);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1779);
 }
 
 Gfx* func_800944A0(Gfx* gfx) {
@@ -1195,23 +1195,23 @@ Gfx* func_800944A0(Gfx* gfx) {
 }
 
 void func_800944C4(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1799);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1799);
 
     gfxCtx->polyOpa.p = func_800944A0(gfxCtx->polyOpa.p);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1801);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1801);
 }
 
 void func_80094520(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1809);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1809);
 
     gfxCtx->overlay.p = func_800944A0(gfxCtx->overlay.p);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1811);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1811);
 }
 
 void func_8009457C(Gfx** gfxp) {
@@ -1221,33 +1221,33 @@ void func_8009457C(Gfx** gfxp) {
 }
 
 void func_800945A0(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1837);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1837);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x28]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1841);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1841);
 }
 
 void func_8009460C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1853);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1853);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x29]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1857);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1857);
 }
 
 void func_80094678(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1869);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1869);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x2F]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1873);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1873);
 }
 
 Gfx* func_800946E4(Gfx* gfx) {
@@ -1307,84 +1307,84 @@ Gfx* func_80094968(Gfx* gfx) {
 }
 
 void func_800949A8(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1953);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1953);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x2A]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1957);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1957);
 }
 
 void func_80094A14(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1964);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1964);
 
     gSPDisplayList(gfxCtx->overlay.p++, &sSetupDL[6 * 0x2A]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1968);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1968);
 }
 
 void func_80094A80(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 1992);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 1992);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x30]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 1996);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 1996);
 }
 
 void func_80094AEC(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2008);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2008);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x31]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2012);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2012);
 }
 
 void func_80094B58(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2024);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2024);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x1B]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2028);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2028);
 }
 
 void func_80094BC4(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2040);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2040);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3C]);
     gDPSetColorDither(gfxCtx->polyXlu.p++, G_CD_DISABLE);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2043);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2043);
 }
 
 void func_80094C50(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2056);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2056);
 
     gSPDisplayList(gfxCtx->polyXlu.p++, &sSetupDL[6 * 0x3D]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2058);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2058);
 }
 
 void func_80094CBC(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2086);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2086);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x38]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2090);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2090);
 }
 
 void func_80094D28(Gfx** gfxp) {
@@ -1394,13 +1394,13 @@ void func_80094D28(Gfx** gfxp) {
 }
 
 void func_80094D4C(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2112);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2112);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, &sSetupDL[6 * 0x3B]);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2116);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2116);
 }
 
 #ifdef NON_MATCHING
@@ -1484,10 +1484,10 @@ Gfx* Gfx_EnvColor(GraphicsContext* gfxCtx, s32 r, s32 g, s32 b, s32 a) {
 }
 
 void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
     s32 ret;
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2386);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2386);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
     gSPDisplayList(gfxCtx->polyXlu.p++, sFillSetupDL);
@@ -1577,13 +1577,13 @@ void func_80095248(GraphicsContext* gfxCtx, u8 r, u8 g, u8 b) {
         }
     }
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2497);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2497);
 }
 
 void func_80095974(GraphicsContext* gfxCtx) {
-    Gfx* gfxArr[5];
+    Gfx* dispRefs[5];
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_rcp.c", 2503);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_rcp.c", 2503);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sFillSetupDL);
     gDPSetScissorFrac(gfxCtx->polyOpa.p++, G_SC_NON_INTERLACE, 0, 0, (s32)gScreenWidth * 4.0f,
@@ -1591,5 +1591,5 @@ void func_80095974(GraphicsContext* gfxCtx) {
     gDPSetDepthImage(gfxCtx->polyOpa.p++, gZBuffer);
     gDPSetColorImage(gfxCtx->polyOpa.p++, G_IM_FMT_RGBA, G_IM_SIZ_16b, gScreenWidth, gfxCtx->curFrameBuffer);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_rcp.c", 2513);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_rcp.c", 2513);
 }
diff --git a/src/code/z_room.c b/src/code/z_room.c
index ad476f357..3990b11a1 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -38,10 +38,10 @@ void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags) {
     PolygonType0* polygon0;
     PolygonDlist* polygonDlist;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 193);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 193);
 
     if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
@@ -71,7 +71,7 @@ void func_80095AB4(GlobalContext* globalCtx, Room* room, u32 flags) {
         polygonDlist++;
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 239);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 239);
 }
 
 #define SHAPE_SORT_MAX 64
@@ -105,12 +105,12 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
     f32 temp_f0;
     f32 temp_f2;
     GraphicsContext* gfxCtx;
-    Gfx* sp5C[4];
+    Gfx* dispRefs[4];
 
     spB0 = NULL;
     spB4 = NULL;
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 287);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 287);
 
     if (flags & 1) {
         func_800342EC(&D_801270A0, globalCtx);
@@ -222,7 +222,7 @@ void func_80095D04(GlobalContext* globalCtx, Room* room, u32 flags) {
 
     iREG(88) = sp9C - 1;
 
-    Graph_CloseDisp(sp5C, globalCtx->state.gfxCtx, "../z_room.c", 430);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 430);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80095D04.s")
@@ -350,10 +350,10 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags) {
     u32 sp94;
     u32 sp90;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 628);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 628);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     polygon1 = &room->mesh->polygon1;
@@ -399,7 +399,7 @@ void func_80096680(GlobalContext* globalCtx, Room* room, u32 flags) {
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 691);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 691);
 }
 
 typedef struct {
@@ -456,10 +456,10 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags) {
     u32 sp90;
     u32 sp8C;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 752);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 752);
 
     camera = globalCtx->cameraCtx.activeCameraPtrs[globalCtx->cameraCtx.unk_5C0];
     sp98 = (camera->unk_142 ^ 25) == 0;
@@ -505,7 +505,7 @@ void func_80096B6C(GlobalContext* globalCtx, Room* room, u32 flags) {
         gSPDisplayList(gfxCtx->polyXlu.p++, polygonDlist->xlu);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_room.c", 819);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_room.c", 819);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_room/func_80096B6C.s")
diff --git a/src/code/z_sample.c b/src/code/z_sample.c
index 5c9d7d6ce..fa995e06e 100644
--- a/src/code/z_sample.c
+++ b/src/code/z_sample.c
@@ -15,10 +15,10 @@ void Sample_Draw(SampleContext* this) {
     u32 pad;
     GraphicsContext* gfxCtx = this->state.gfxCtx;
     View* view = &this->view;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     Mtx* mtx;
 
-    Graph_OpenDisp(gfxArr, gfxCtx, "../z_sample.c", 62);
+    Graph_OpenDisps(dispRefs, gfxCtx, "../z_sample.c", 62);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x00, NULL);
     gSPSegment(gfxCtx->polyOpa.p++, 0x01, this->staticSegment);
@@ -41,7 +41,7 @@ void Sample_Draw(SampleContext* this) {
                       PRIMITIVE);
     gDPSetPrimColor(gfxCtx->polyOpa.p++, 0, 0, 0xFF, 0xFF, 0x00, 0x00);
 
-    Graph_CloseDisp(gfxArr, gfxCtx, "../z_sample.c", 111);
+    Graph_CloseDisps(dispRefs, gfxCtx, "../z_sample.c", 111);
 }
 #else
 #pragma GLOBAL_ASM("asm/non_matchings/code/z_sample/Sample_Draw.s")
diff --git a/src/code/z_scene_table.c b/src/code/z_scene_table.c
index a4ff5a224..f4893ac56 100644
--- a/src/code/z_scene_table.c
+++ b/src/code/z_scene_table.c
@@ -682,14 +682,14 @@ void func_800994A0(GlobalContext* globalCtx) {
 // Scene Draw Config 0
 void func_80099550(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx = globalCtx->state.gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4725);
 
     gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
     gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4735);
 }
 
 u32 D_8012A2F8[] = { 0x0200BA18, 0x0200CA18 };
@@ -698,12 +698,12 @@ u32 D_8012A2F8[] = { 0x0200BA18, 0x0200CA18 };
 void func_800995DC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gameplayFrames = globalCtx->gameplayFrames;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4763);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
                Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 127 - (gameplayFrames % 128), (gameplayFrames * 1) % 128,
@@ -716,17 +716,17 @@ void func_800995DC(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A2F8[gSaveContext.night_flag]));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4783);
 }
 
 // Scene Draw Config 28
 void func_80099760(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4845);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -736,7 +736,7 @@ void func_80099760(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4859);
 }
 
 u32 D_8012A300[] = { 0x02012378, 0x02013378 };
@@ -748,12 +748,12 @@ void func_80099878(GlobalContext* globalCtx) {
     s32 pad;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4905);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A300[gSaveContext.night_flag]));
@@ -782,7 +782,7 @@ void func_80099878(GlobalContext* globalCtx) {
     gDPSetEnvColor(displayListHead++, 0xFF, 0xFF, 0xFF, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 4956);
 }
 
 // Scene Draw Config 30
@@ -790,12 +790,12 @@ void func_80099BD8(GlobalContext* globalCtx) {
     f32 temp;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 18 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5069);
 
     temp = globalCtx->unk_11D30[0] / 255.0f;
 
@@ -839,7 +839,7 @@ void func_80099BD8(GlobalContext* globalCtx) {
     gDPSetEnvColor(displayListHead++, 0, 0, 0, globalCtx->unk_11D30[1]);
     gSPEndDisplayList(displayListHead);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5145);
 
     if (gSaveContext.scene_setup_index == 5) {
         D_8015FCF0 = 1;
@@ -856,10 +856,10 @@ void func_80099BD8(GlobalContext* globalCtx) {
 void func_8009A45C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5171);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -884,17 +884,17 @@ void func_8009A45C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5212);
 }
 
 // Scene Draw Config 32
 void func_8009A798(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5226);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -916,17 +916,17 @@ void func_8009A798(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5264);
 }
 
 // Scene Draw Config 33
 void func_8009A9DC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5278);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -942,17 +942,17 @@ void func_8009A9DC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5301);
 }
 
 // Scene Draw Config 48
 void func_8009AB98(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5317);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 256, 16));
@@ -963,17 +963,17 @@ void func_8009AB98(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5330);
 }
 
 // Scene Draw Config 39
 void func_8009ACA8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5346);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -987,17 +987,17 @@ void func_8009ACA8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5367);
 }
 
 // Scene Draw Config 24
 void func_8009AE30(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5384);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
@@ -1017,7 +1017,7 @@ void func_8009AE30(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5416);
 }
 
 u32 D_8012A328[] = { 0x0200BD20, 0x0200B920 };
@@ -1026,10 +1026,10 @@ u32 D_8012A328[] = { 0x0200BD20, 0x0200B920 };
 void func_8009AFE0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5490);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x09,
@@ -1039,7 +1039,7 @@ void func_8009AFE0(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A328[gSaveContext.night_flag]));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5507);
 }
 
 u32 D_8012A330[] = { 0x02014C30, 0x02015830 };
@@ -1050,10 +1050,10 @@ void func_8009B0FC(GlobalContext* globalCtx) {
     s32 spB0;
     s32 spAC;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5535);
 
     if (1) {} // Necessary to match
 
@@ -1116,17 +1116,17 @@ void func_8009B0FC(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5644);
 }
 
 // Scene Draw Config 29
 void func_8009B86C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5791);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1138,17 +1138,17 @@ void func_8009B86C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x91);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5808);
 }
 
 // Scene Draw Config 34
 void func_8009B9BC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5822);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, Gfx_TexScroll(globalCtx->state.gfxCtx, 0, gameplayFrames % 64, 4, 16));
@@ -1156,17 +1156,17 @@ void func_8009B9BC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5836);
 }
 
 // Scene Draw Config 35
 void func_8009BAA4(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5850);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1184,7 +1184,7 @@ void func_8009BAA4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5876);
 }
 
 // Scene Draw Config 36
@@ -1192,14 +1192,14 @@ void func_8009BC44(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s8 sp83;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (1) {} // Necessary to match
 
     sp83 = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5894);
 
     gameplayFrames = globalCtx->gameplayFrames;
 
@@ -1226,7 +1226,7 @@ void func_8009BC44(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp83, sp83, sp83, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5930);
 }
 
 // Screen Shake for Ganon's Tower Collapse
@@ -1259,14 +1259,14 @@ void func_8009C0AC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     s8 sp7B;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (1) {} // Necessary to match
 
     sp7B = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 5968);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1289,7 +1289,7 @@ void func_8009C0AC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, sp7B, sp7B, sp7B, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6004);
 
     if (Flags_GetSwitch(globalCtx, 0x37)) {
         if ((globalCtx->sceneNum == SCENE_GANON_DEMO) || (globalCtx->sceneNum == SCENE_GANON_FINAL) ||
@@ -1305,12 +1305,12 @@ u32 D_8012A338[] = { 0x0200FAC0, 0x0200F8C0 };
 void func_8009C3EC(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6042);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A338[gSaveContext.night_flag]));
@@ -1329,17 +1329,17 @@ void func_8009C3EC(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6076);
 }
 
 // Scene Draw Config 42
 void func_8009C608(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6151);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1360,17 +1360,17 @@ void func_8009C608(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6187);
 }
 
 // Scene Draw Config 43
 void func_8009C8B8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6201);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1387,17 +1387,17 @@ void func_8009C8B8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6232);
 }
 
 // Scene Draw Config 47
 void func_8009CAC0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6249);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1410,7 +1410,7 @@ void func_8009CAC0(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6264);
 }
 
 u32 D_8012A340[] = { 0x0200F8C0, 0x020100C0 };
@@ -1419,12 +1419,12 @@ u32 D_8012A340[] = { 0x0200F8C0, 0x020100C0 };
 void func_8009CC00(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6290);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A340[gSaveContext.night_flag]));
@@ -1443,7 +1443,7 @@ void func_8009CC00(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6320);
 }
 
 Gfx* Gfx_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y1, s32 width1, s32 height1, s32 tile2,
@@ -1469,10 +1469,10 @@ Gfx* Gfx_TwoTexScrollPrimColor(GraphicsContext* gfxCtx, s32 tile1, u32 x1, u32 y
 void func_8009CF84(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6433);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1487,17 +1487,17 @@ void func_8009CF84(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6449);
 }
 
 // Scene Draw Config 41
 void func_8009D0E8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6463);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1515,7 +1515,7 @@ void func_8009D0E8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6491);
 }
 
 u32 D_8012A348[] = { 0x02005210, 0x02005010 };
@@ -1523,11 +1523,11 @@ u32 D_8012A348[] = { 0x02005210, 0x02005010 };
 // Scene Draw Config 44
 void func_8009D31C(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6515);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A348[gSaveContext.night_flag]));
 
@@ -1537,7 +1537,7 @@ void func_8009D31C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6528);
 }
 
 u32 D_8012A350[] = { 0x02006550, 0x02003550 };
@@ -1547,10 +1547,10 @@ u32 D_8012A358[] = { 0x02002350, 0x02001350 };
 void func_8009D438(GlobalContext* globalCtx) {
     s32 var;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6560);
 
     if (LINK_IS_ADULT) {
         var = 1;
@@ -1567,17 +1567,17 @@ void func_8009D438(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6581);
 }
 
 // Scene Draw Config 46
 void func_8009D5B4(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6595);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1592,7 +1592,7 @@ void func_8009D5B4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6615);
 }
 
 u32 D_8012A360[] = { 0x02014D90, 0x02014590 };
@@ -1601,12 +1601,12 @@ u32 D_8012A360[] = { 0x02014D90, 0x02014590 };
 void func_8009D758(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6640);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A360[gSaveContext.night_flag]));
@@ -1625,7 +1625,7 @@ void func_8009D758(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6671);
 }
 
 u32 D_8012A368[] = { 0x02018920, 0x02018020 };
@@ -1633,15 +1633,15 @@ u32 D_8012A368[] = { 0x02018920, 0x02018020 };
 // Scene Draw Config 25
 void func_8009D974(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6752);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A368[gSaveContext.night_flag]));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6762);
 }
 
 // Scene Draw Config 1
@@ -1649,12 +1649,12 @@ void func_8009DA30(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6814);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1690,7 +1690,7 @@ void func_8009DA30(GlobalContext* globalCtx) {
         gSPEndDisplayList(displayListHead);
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6866);
 }
 
 u32 D_8012A370[] = { 0x02015B50, 0x02016B50 };
@@ -1698,11 +1698,11 @@ u32 D_8012A370[] = { 0x02015B50, 0x02016B50 };
 // Scene Draw Config 2
 void func_8009DD5C(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6890);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A370[gSaveContext.night_flag]));
 
@@ -1712,17 +1712,17 @@ void func_8009DD5C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6903);
 }
 
 // Scene Draw Config 3
 void func_8009DE78(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6917);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1741,7 +1741,7 @@ void func_8009DE78(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6948);
 }
 
 // Scene Draw Config 4
@@ -1751,7 +1751,7 @@ void func_8009E0B8(GlobalContext* globalCtx) {
     u16 spA0;
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     spA3 = 128;
     spA0 = 500;
@@ -1759,7 +1759,7 @@ void func_8009E0B8(GlobalContext* globalCtx) {
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 6 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 6965);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x09,
@@ -1798,17 +1798,17 @@ void func_8009E0B8(GlobalContext* globalCtx) {
                Gfx_TwoTexScroll(globalCtx->state.gfxCtx, 0, 0, (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16, 1, 0,
                                 (s16)(-globalCtx->unk_11D30[0] * 0.02f), 32, 16));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7044);
 }
 
 // Scene Draw Config 5
 void func_8009E54C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7058);
 
     if ((gSaveContext.scene_setup_index > 3) || (LINK_IS_ADULT && !(gSaveContext.event_chk_inf[6] & 0x200))) {
         globalCtx->unk_11D30[0] = 87;
@@ -1825,7 +1825,7 @@ void func_8009E54C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyOpa.p++);
     gDPSetEnvColor(gfxCtx->polyOpa.p++, 0xFF, 0xFF, 0xFF, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7097);
 }
 
 u32 D_8012A378[] = { 0x02008F98, 0x02008FD8 };
@@ -1835,10 +1835,10 @@ void func_8009E730(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     u32 var;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7123);
 
     gameplayFrames = globalCtx->gameplayFrames;
     var = 127 - (gameplayFrames * 1) % 128;
@@ -1855,17 +1855,17 @@ void func_8009E730(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7147);
 }
 
 // Scene Draw Config 7
 void func_8009E8C0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7161);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1883,17 +1883,17 @@ void func_8009E8C0(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7192);
 }
 
 // Scene Draw Config 8
 void func_8009EAD8(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7206);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1921,19 +1921,19 @@ void func_8009EAD8(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7260);
 }
 
 // Scene Draw Config 9
 void func_8009EE44(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (0) {} // Necessary to match
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7274);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -1957,17 +1957,17 @@ void func_8009EE44(GlobalContext* globalCtx) {
         globalCtx->unk_11D30[1]++;
     }
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7309);
 }
 
 // Scene Draw Config 10
 void func_8009F074(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7323);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -1979,7 +1979,7 @@ void func_8009F074(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7339);
 }
 
 u32 D_8012A380[] = { 0x02009678, 0x0200DE78 };
@@ -1987,25 +1987,25 @@ u32 D_8012A380[] = { 0x02009678, 0x0200DE78 };
 // Scene Draw Config 11
 void func_8009F1B4(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7363);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A380[gSaveContext.night_flag]));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7371);
 }
 
 // Scene Draw Config 12
 void func_8009F270(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7385);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2021,17 +2021,17 @@ void func_8009F270(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7409);
 }
 
 // Scene Draw Config 13
 void func_8009F40C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7423);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -2047,19 +2047,19 @@ void func_8009F40C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7443);
 }
 
 // Scene Draw Config 14
 void func_8009F5D4(GlobalContext* globalCtx) {
     Gfx* displayListHead;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     displayListHead = Graph_Alloc(globalCtx->state.gfxCtx, 3 * sizeof(Gfx));
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7461);
 
     gSPSegment(gfxCtx->polyXlu.p++, 0x08, displayListHead);
 
@@ -2087,7 +2087,7 @@ void func_8009F5D4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7495);
 }
 
 // Scene Draw Config 15
@@ -2096,13 +2096,13 @@ void func_8009F7D4(GlobalContext* globalCtx) {
     s8 sp6E;
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     sp6F = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
     sp6E = coss((globalCtx->gameplayFrames * 1500) & 0xFFFF) >> 8;
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7512);
 
     gameplayFrames = globalCtx->gameplayFrames;
     sp6F = (sp6F >> 1) + 192;
@@ -2118,7 +2118,7 @@ void func_8009F7D4(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7530);
 }
 
 u32 D_8012A388[] = { 0x02009808, 0x02008FC8 };
@@ -2127,10 +2127,10 @@ u32 D_8012A388[] = { 0x02009808, 0x02008FC8 };
 void func_8009F9D0(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7555);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2147,7 +2147,7 @@ void func_8009F9D0(GlobalContext* globalCtx) {
 
     { s32 pad[2]; } // Necessary to match stack usage
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7578);
 }
 
 u32 D_8012A390[] = { 0x020081E0, 0x0200FBE0 };
@@ -2155,11 +2155,11 @@ u32 D_8012A390[] = { 0x020081E0, 0x0200FBE0 };
 // Scene Draw Config 17
 void func_8009FB74(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
     s32 pad[2];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7602);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x08, SEGMENTED_TO_VIRTUAL(D_8012A390[gSaveContext.night_flag]));
 
@@ -2169,17 +2169,17 @@ void func_8009FB74(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7615);
 }
 
 // Scene Draw Config 18
 void func_8009FC90(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7630);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2196,7 +2196,7 @@ void func_8009FC90(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x40);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7653);
 }
 
 f32 D_8012A398 = 0.0f;
@@ -2210,10 +2210,10 @@ void func_8009FE58(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     f32 temp;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7712);
 
     gameplayFrames = globalCtx->gameplayFrames;
     if (globalCtx->sceneNum == SCENE_BDAN) {
@@ -2278,7 +2278,7 @@ void func_8009FE58(GlobalContext* globalCtx) {
 
     gSPSegment(gfxCtx->polyOpa.p++, 0x0D, Matrix_NewMtx(globalCtx->state.gfxCtx, "../z_scene_table.c", 7809));
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7811);
 }
 #else
 s16 D_8012A39C = 538;
@@ -2291,10 +2291,10 @@ void func_8009FE58(GlobalContext* globalCtx);
 void func_800A0334(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7825);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyXlu.p++, 0x08,
@@ -2313,7 +2313,7 @@ void func_800A0334(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7852);
 }
 
 // Scene Draw Config 52
@@ -2330,10 +2330,10 @@ void func_800A057C(GlobalContext* globalCtx) {
 void func_800A059C(GlobalContext* globalCtx) {
     u32 gameplayFrames;
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7893);
 
     gameplayFrames = globalCtx->gameplayFrames;
     gSPSegment(gfxCtx->polyOpa.p++, 0x08,
@@ -2347,7 +2347,7 @@ void func_800A059C(GlobalContext* globalCtx) {
     gDPPipeSync(gfxCtx->polyXlu.p++);
     gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 7910);
 }
 
 void (*sSceneDrawHandlers[])(GlobalContext*) = {
@@ -2363,7 +2363,7 @@ void (*sSceneDrawHandlers[])(GlobalContext*) = {
 
 void Scene_Draw(GlobalContext* globalCtx) {
     GraphicsContext* gfxCtx;
-    Gfx* gfxArr[4];
+    Gfx* dispRefs[4];
 
     if (HREG(80) == 0x11) {
         if (HREG(95) != 0x11) {
@@ -2384,14 +2384,14 @@ void Scene_Draw(GlobalContext* globalCtx) {
         }
 
         gfxCtx = globalCtx->state.gfxCtx;
-        Graph_OpenDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
+        Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 8104);
 
         if (HREG(81) == 1) {
             gSPDisplayList(gfxCtx->polyOpa.p++, sDefaultDisplayList);
             gSPDisplayList(gfxCtx->polyXlu.p++, sDefaultDisplayList);
         }
 
-        Graph_CloseDisp(gfxArr, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
+        Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_scene_table.c", 8109);
 
         if (HREG(82) == 1) {
             sSceneDrawHandlers[globalCtx->sceneConfig](globalCtx);
diff --git a/src/code/z_skelanime.c b/src/code/z_skelanime.c
index 0dccdd5cb..099fa122e 100644
--- a/src/code/z_skelanime.c
+++ b/src/code/z_skelanime.c
@@ -36,10 +36,10 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* sk
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 773);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 773);
     Matrix_Push();
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
     limbIndex++;
@@ -80,7 +80,7 @@ void SkelAnime_LodDrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* sk
                               appendDlistFunc, actor, dListIndex);
     }
 
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 821);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 821);
 }
 
 /*
@@ -95,7 +95,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* acto
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     if (skeleton == NULL) {
         osSyncPrintf(VT_FGCOL(RED));
@@ -104,7 +104,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* acto
         return;
     }
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 849);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 849);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
@@ -133,7 +133,7 @@ void SkelAnime_LodDraw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* acto
     }
 
     Matrix_Pull();
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 894);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 894);
 }
 
 /*
@@ -148,7 +148,7 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton*
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     Matrix_Push();
 
@@ -169,10 +169,10 @@ void SkelAnime_LodDrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton*
         if (dList[1] != NULL) {
             Matrix_ToMtx(*mtx, "../z_skelanime.c", 945);
             gfxCtx = globalCtx->state.gfxCtx;
-            Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 946);
+            Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 946);
             gSPMatrix(gfxCtx->polyOpa.p++, *mtx, G_MTX_LOAD);
             gSPDisplayList(gfxCtx->polyOpa.p++, dList[1]);
-            Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 949);
+            Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 949);
             (*mtx)++;
         } else if (dList[0] != NULL) {
             Matrix_ToMtx(*mtx, "../z_skelanime.c", 954);
@@ -210,7 +210,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* ac
     Vec3s rot;
     Mtx* mtx;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     mtx = Graph_Alloc(globalCtx->state.gfxCtx, dListCount * sizeof(Mtx));
 
@@ -221,7 +221,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* ac
         return;
     }
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1000);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1000);
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
     Matrix_Push();
 
@@ -258,7 +258,7 @@ void SkelAnime_LodDrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* ac
 
     Matrix_Pull();
 
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1053);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1053);
 }
 
 /*
@@ -272,11 +272,11 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skele
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1076);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1076);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
@@ -316,7 +316,7 @@ void SkelAnime_DrawLimb(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skele
                            appendDlistFunc, actor);
     }
 
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1121);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1121);
 }
 
 void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable,
@@ -327,7 +327,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDr
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     if (skeleton == NULL) {
         osSyncPrintf(VT_FGCOL(RED));
@@ -338,7 +338,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDr
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1148);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1148);
     Matrix_Push();
     rootLimb = SEGMENTED_TO_VIRTUAL(skeleton->limbs[0]);
 
@@ -369,7 +369,7 @@ void SkelAnime_Draw(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDr
 
     Matrix_Pull();
 
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1190);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1190);
 }
 
 void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* skeleton, Vec3s* actorDrawTable,
@@ -380,10 +380,10 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* ske
     Vec3f pos;
     Vec3s rot;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     gfxCtx = globalCtx->state.gfxCtx;
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1214);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1214);
     Matrix_Push();
 
     limbEntry = SEGMENTED_TO_VIRTUAL(skeleton->limbs[limbIndex]);
@@ -426,7 +426,7 @@ void SkelAnime_DrawLimbSV(GlobalContext* globalCtx, s32 limbIndex, Skeleton* ske
                              appendDlistFunc, actor, limbMatricies);
     }
 
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1265);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1265);
 }
 
 void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actorDrawTable, s32 dListCount,
@@ -439,7 +439,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actor
     Vec3s rot;
     Mtx* mtx;
     GraphicsContext* gfxCtx;
-    Gfx* gfx[4];
+    Gfx* dispRefs[4];
 
     mtx = Graph_Alloc(globalCtx->state.gfxCtx, dListCount * sizeof(Mtx));
 
@@ -452,7 +452,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actor
 
     gfxCtx = globalCtx->state.gfxCtx;
 
-    Graph_OpenDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1294);
+    Graph_OpenDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1294);
 
     gSPSegment(gfxCtx->polyOpa.p++, 0xD, mtx);
 
@@ -494,7 +494,7 @@ void SkelAnime_DrawSV(GlobalContext* globalCtx, Skeleton* skeleton, Vec3s* actor
     }
 
     Matrix_Pull();
-    Graph_CloseDisp(gfx, globalCtx->state.gfxCtx, "../z_skelanime.c", 1347);
+    Graph_CloseDisps(dispRefs, globalCtx->state.gfxCtx, "../z_skelanime.c", 1347);
 }
 
 /*
-- 
cgit v1.2.3