Decompile PreRender.c (#319)

* Decompile PreRender.c

* use NON_EQUIVALENT and run format.sh

* Get rid of some magic values

* rename dList/dListp to dListHead/dList

* make func_800C213C NON_MATCHING

* replace more values with SCREEN_WIDTH/SCREEN_HEIGHT

* dList/dListHead with gfxp/gfx

6 files changed, 633 insertions, 38 deletions

diff --git a/src/code/PreRender.c b/src/code/PreRender.c
index 4e335cd50..bc577353d 100644
--- a/src/code/PreRender.c
+++ b/src/code/PreRender.c
@@ -1,42 +1,637 @@
-#include <ultra64.h>
 #include <global.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C0E70.s")
+void PreRender_SetValuesSave(PreRenderContext* this, u32 width, u32 height, void* fbuf, void* zbuf, void* cvg) {
+    this->widthSave = width;
+    this->heightSave = height;
+    this->fbufSave = fbuf;
+    this->cvgSave = cvg;
+    this->zbufSave = zbuf;
+    this->ulxSave = 0;
+    this->ulySave = 0;
+    this->lrxSave = width - 1;
+    this->lrySave = height - 1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C0EA8.s")
+void PreRender_Init(PreRenderContext* this) {
+    bzero(this, sizeof(PreRenderContext));
+    ListAlloc_Init(&this->alloc);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C0ED8.s")
+void PreRender_SetValues(PreRenderContext* this, u32 width, u32 height, void* fbuf, void* zbuf) {
+    this->width = width;
+    this->height = height;
+    this->fbuf = fbuf;
+    this->zbuf = zbuf;
+    this->ulx = 0;
+    this->uly = 0;
+    this->lrx = width - 1;
+    this->lry = height - 1;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C0F08.s")
+void PreRender_Destroy(PreRenderContext* this) {
+    ListAlloc_FreeAll(&this->alloc);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C0F28.s")
+void func_800C0F28(PreRenderContext* this, Gfx** gfxp, void* buf, void* bufSave) {
+    Gfx* gfx;
+    s32 x;
+    s32 x2;
+    s32 add;
+    s32 uls;
+    s32 ult;
+    s32 lrs;
+    s32 lrt;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1258.s")
+    LogUtils_CheckNullPointer("this", this, "../PreRender.c", 215);
+    LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 216);
+    gfx = *gfxp;
+    LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 218);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C170C.s")
+    gDPPipeSync(gfx++);
+    gDPSetOtherMode(gfx++,
+                    G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, bufSave);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1AE8.s")
+    x = this->height;
+    add = 0x1000 / (this->width * 2);
+    uls = 0;
+    x2 = 0;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1B24.s")
+    while (x > 0) {
+        lrs = this->width - 1;
+        if (x < add) {
+            add = x;
+        }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1E9C.s")
+        ult = x2;
+        lrt = (ult + add) - 1;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1F20.s")
+        if (1) {}
+        gDPLoadTextureTile(gfx++, buf, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt,
+                           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);
+        gSPTextureRectangle(gfx++, uls << 2, ult << 2, lrs << 2, lrt << 2, G_TX_RENDERTILE, uls << 5, ult << 5,
+                            4 << 10, 1 << 10);
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C1FA4.s")
+        x -= add;
+        x2 += add;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C20B4.s")
+    gDPPipeSync(gfx++);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
+    *gfxp = gfx;
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C2118.s")
+void func_800C1258(PreRenderContext* this, Gfx** gfxp) {
+    Gfx* gfx;
+    s32 y;
+    s32 y2;
+    s32 add;
+    s32 ult;
+    s32 lrs;
+    s32 lrt;
+    s32 uly;
 
+    LogUtils_CheckNullPointer("this", this, "../PreRender.c", 278);
+    LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 279);
+    gfx = *gfxp;
+    LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 281);
+
+    gDPPipeSync(gfx++);
+    gDPSetOtherMode(gfx++,
+                    G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, this->ulx, this->uly, this->lrx + 1, this->lry + 1);
+
+    y2 = 0;
+    add = 0x1000 / ((this->lrxSave - this->ulxSave + 1) * 2);
+    y = (this->lrySave - this->ulySave) + 1;
+
+    while (y > 0) {
+        if (y < add) {
+            add = y;
+        }
+
+        ult = this->ulySave + y2;
+        uly = this->uly + y2;
+        lrt = (ult + add) - 1;
+
+        if (1) {}
+        gDPLoadTextureTile(gfx++, this->fbufSave, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->widthSave, this->height - 1,
+                           this->ulxSave, ult, this->lrxSave, lrt, 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);
+        gSPTextureRectangle(gfx++, this->ulx << 2, uly << 2, this->lrx << 2, (uly + add - 1) << 2,
+                            G_TX_RENDERTILE, this->ulxSave << 5, ult << 5, 4 << 10, 1 << 10);
+
+        y -= add;
+        y2 += add;
+    }
+
+    gDPPipeSync(gfx++);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
+    *gfxp = gfx;
+}
+
+void func_800C170C(PreRenderContext* this, Gfx** gfxp, void* fbuf, void* fbufSave, u32 r, u32 g, u32 b, u32 a) {
+    Gfx* gfx;
+    s32 x;
+    s32 x2;
+    s32 add;
+    s32 uls;
+    s32 ult;
+    s32 lrs;
+    s32 lrt;
+    s32 unk;
+
+    LogUtils_CheckNullPointer("this", this, "../PreRender.c", 343);
+    LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 344);
+    gfx = *gfxp;
+    LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 346);
+
+    gDPPipeSync(gfx++);
+    gDPSetOtherMode(gfx++,
+                    G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PRIM | G_RM_OPA_SURF | G_RM_OPA_SURF2);
+    gDPSetEnvColor(gfx++, r, g, b, a);
+    gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 0, 0, 0, 1, 0, 0, 0, TEXEL0, 0, 0, 0, 1);
+    gDPSetCombineLERP(gfx++, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, 1, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, 1);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, fbufSave);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
+
+    x2 = 0;
+    x = this->height;
+    add = 0x1000 / (this->width * 2);
+
+    while (x > 0) {
+        lrs = this->width - 1;
+
+        if (x < add) {
+            add = x;
+        }
+
+        uls = 0;
+        ult = x2;
+        lrt = (x2 + add - 1);
+
+        gDPLoadTextureTile(gfx++, fbuf, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs,
+                           lrt, 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);
+        if (1) {}
+        gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrs + 1) << 2, (lrt + 1) << 2, G_TX_RENDERTILE, uls << 5,
+                            ult << 5, 1 << 10, 1 << 10);
+
+        x -= add;
+        x2 += add;
+    }
+
+    gDPPipeSync(gfx++);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
+    *gfxp = gfx;
+}
+
+void func_800C1AE8(PreRenderContext* this, Gfx** gfxp, void* fbuf, void* fbufSave) {
+    func_800C170C(this, gfxp, fbuf, fbufSave, 255, 255, 255, 255);
+}
+
+void func_800C1B24(PreRenderContext* this, Gfx** gfxp, void* fbuf, void* cvgSave) {
+    Gfx* gfx;
+    s32 x;
+    s32 x2;
+    s32 add;
+    s32 uls;
+    s32 ult;
+    s32 lrs;
+    s32 lrt;
+
+    LogUtils_CheckNullPointer("this", this, "../PreRender.c", 422);
+    LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 423);
+    gfx = *gfxp;
+    LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 425);
+
+    gDPPipeSync(gfx++);
+    gDPSetOtherMode(gfx++,
+                    G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PRIM | G_RM_PASS | G_RM_OPA_CI2);
+    gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 0, 0, 0, 0, 0, 0, 0, TEXEL0, 0, 0, 0, 0);
+    gDPSetColorImage(gfx++, G_IM_FMT_I, G_IM_SIZ_8b, this->width, cvgSave);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
+
+    x = this->height;
+    x2 = 0;
+    add = 0x1000 / (this->width * 2);
+
+    while (x > 0) {
+        lrs = this->width - 1;
+        if (x < add) {
+            add = x;
+        }
+        uls = 0;
+        ult = x2;
+        lrt = (x2 + add) - 1;
+
+        gDPLoadTextureTile(gfx++, fbuf, G_IM_FMT_IA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt,
+                           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);
+        if (1) {}
+        gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrs + 1) << 2, (lrt + 1) << 2, G_TX_RENDERTILE, uls << 5,
+                            ult << 5, 1 << 10, 1 << 10);
+
+        x -= add;
+        x2 += add;
+    }
+
+    gDPPipeSync(gfx++);
+    gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
+    *gfxp = gfx;
+}
+
+void func_800C1E9C(PreRenderContext* this, Gfx** gfxp) {
+    LogUtils_CheckNullPointer("this->zbuf_save", this->zbufSave, "../PreRender.c", 481);
+    LogUtils_CheckNullPointer("this->zbuf", this->zbuf, "../PreRender.c", 482);
+
+    if (!this->zbufSave || !this->zbuf) {
+        return;
+    }
+
+    func_800C0F28(this, gfxp, this->zbuf, this->zbufSave);
+}
+
+void func_800C1F20(PreRenderContext* this, Gfx** gfxp) {
+    LogUtils_CheckNullPointer("this->fbuf_save", this->fbufSave, "../PreRender.c", 495);
+    LogUtils_CheckNullPointer("this->fbuf", this->fbuf, "../PreRender.c", 496);
+
+    if (!this->fbufSave || !this->fbuf) {
+        return;
+    }
+
+    func_800C1AE8(this, gfxp, this->fbuf, this->fbufSave);
+}
+
+void func_800C1FA4(PreRenderContext* this, Gfx** gfxp) {
+    Gfx* gfx;
+
+    gfx = *gfxp;
+
+    gDPPipeSync(gfx++);
+    gDPSetBlendColor(gfx++, 255, 255, 255, 8);
+    gDPSetPrimDepth(gfx++, -1, -1);
+    gDPSetOtherMode(gfx++,
+                    G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PRIM | G_RM_VISCVG | G_RM_VISCVG2);
+    gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
+    gDPFillRectangle(gfx++, 0, 0, this->width, this->height);
+    gDPPipeSync(gfx++);
+
+    *gfxp = gfx;
+}
+
+void func_800C20B4(PreRenderContext* this, Gfx** gfxp) {
+    func_800C1FA4(this, gfxp);
+    LogUtils_CheckNullPointer("this->cvg_save", this->cvgSave, "../PreRender.c", 532);
+    if (!this->cvgSave) {
+        return;
+    }
+
+    func_800C1B24(this, gfxp, this->fbuf, this->cvgSave);
+}
+
+void func_800C2118(PreRenderContext* this, Gfx** gfxp) {
+    func_800C0F28(this, gfxp, this->zbufSave, this->zbuf);
+}
+
+#ifdef NON_MATCHING
+// regalloc differences in gDPLoadMultiTile
+void func_800C213C(PreRenderContext* this, Gfx** gfxp) {
+    Gfx* gfx;
+    s32 y;
+    s32 y2;
+    s32 add;
+    s32 uls;
+    s32 ult;
+    s32 lrx;
+    s32 lry;
+
+    if (!this->cvgSave) {
+        return;
+    }
+
+    LogUtils_CheckNullPointer("this", this, "../PreRender.c", 563);
+    LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 564);
+    gfx = *gfxp;
+    LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 566);
+
+    gDPPipeSync(gfx++);
+    gDPSetEnvColor(gfx++, 255, 255, 255, 32);
+    gDPSetOtherMode(gfx++,
+                    G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
+                        G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
+                    G_AC_NONE | G_ZS_PRIM | AA_EN | CVG_DST_CLAMP | ZMODE_OPA | CVG_X_ALPHA |
+                        GBL_c1(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1) |
+                        GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1));
+    gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 1, 0, TEXEL1, ENVIRONMENT, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED);
+
+    y = this->height;
+    add = 4;
+    y2 = 0;
+
+    while (y > 0) {
+        lrx = this->width - 1;
+        if (y < add) {
+            add = y;
+        }
+
+        uls = 0;
+        ult = y2;
+        lry = (y2 + add - 1);
+
+        gDPLoadMultiTile(gfx++, this->fbufSave, 0x0000, G_TX_RENDERTILE, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width,
+                         this->height, uls, ult, lrx, lry, 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);
+        gDPLoadMultiTile(gfx++, this->cvgSave, 0x0160, 1, G_IM_FMT_I, G_IM_SIZ_8b, this->width, this->height, uls,
+                         ult, lrx, lry, 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);
+
+        gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrx + 1) << 2, (lry + 1) << 2, G_TX_RENDERTILE, uls << 5,
+                            ult << 5, 1 << 10, 1 << 10);
+
+        if (1) {}
+        y -= add;
+        y2 += add;
+    }
+
+    gDPPipeSync(gfx++);
+    *gfxp = gfx;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C213C.s")
+#endif
+
+void func_800C24BC(PreRenderContext* this, Gfx** gfxp) {
+    func_800C0F28(this, gfxp, this->fbufSave, this->fbuf);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C24BC.s")
+void func_800C24E0(PreRenderContext* this, Gfx** gfxp) {
+    func_800C1258(this, gfxp);
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C24E0.s")
+#ifdef NON_EQUIVALENT
+void func_800C2500(PreRenderContext* this, s32 x, s32 y) {
 
+    u32 buffA[3 * 8]; // 0x144
+    u32 buffR[3 * 8]; // 0x108
+    u32 buffG[3 * 8]; // 0xCC
+    u32 buffB[3 * 8]; // 0x90
+
+    u32 pxR, pxG, pxB, pxR2, pxG2, pxB2;
+
+    s32 i;
+
+    s32 x1, y1;
+    u32 px;
+    u32 comp;
+
+    u32 unk;
+    u16 pixel;
+
+    /*
+    you have to picture this as a 3x5 rectangle where the middle pixel (index 7) correspond to (x; y)
+      _ _ _ _ _
+    | 0 1 2 3 4 |
+    | 5 6 7 8 9 |
+    | A B C D E |
+      ‾ ‾ ‾ ‾ ‾
+    */
+    for (i = 0; i < 3 * 5; i++) {
+        x1 = (i % 5) + x - 2; // range (-2) - (2)
+        y1 = (i / 5) + x - 1; // range (-1) - (1)
+
+        if (x1 < 0) {
+            x1 = 0;
+        } else if (this->width - 1 < x1) {
+            x1 = this->width - 1;
+        }
+        if (y1 < 0) {
+            y1 = 0;
+        } else if (this->height - 1 < y1) {
+            y1 = this->height - 1;
+        }
+
+        px = this->fbufSave[y1 * this->width + x1];
+        comp = (px << 0) >> 27; // R
+        buffR[i] = (comp << 3) | (comp >> 2);
+        comp = (px << 5) >> 27; // G
+        buffG[i] = (comp << 3) | (comp >> 2);
+        comp = (px << 10) >> 27; // B
+        buffB[i] = (comp << 3) | (comp >> 2);
+        buffA[i] = this->cvgSave[y1 * this->width + x1] >> 5; // A
+    }
+
+    // 7 == buffA[7] ?
+    if (7 == buffA[7]) {
+        osSyncPrintf("Error, should not be in here \n");
+        return;
+    }
+
+    pxR = buffR[7];
+    pxG = buffG[7];
+    pxB = buffB[7];
+
+    for (i = 1; i < 3 * 5; i += 2) {
+        if (7 == buffA[i]) {
+            // R
+            if (pxR < buffR[i]) {
+                if (i != 1 && buffR[1] >= buffR[i] && 7 == buffA[1]) {
+                    pxR = buffR[i];
+                }
+                if (i != 3 && buffR[3] >= buffR[i] && 7 == buffA[3]) {
+                    pxR = buffR[i];
+                }
+                if (i != 5 && buffR[5] >= buffR[i] && 7 == buffA[5]) {
+                    pxR = buffR[i];
+                }
+                if (i != 7 && buffR[7] >= buffR[i] && 7 == buffA[7]) {
+                    pxR = buffR[i];
+                }
+                if (i != 9 && buffR[9] >= buffR[i] && 7 == buffA[9]) {
+                    pxR = buffR[i];
+                }
+                if (i != 11 && buffR[11] >= buffR[i] && 7 == buffA[11]) {
+                    pxR = buffR[i];
+                }
+                if (i != 13 && buffR[13] >= buffR[i] && 7 == buffA[13]) {
+                    pxR = buffR[i];
+                }
+            }
+            // G
+            if (pxG < buffG[i]) {
+                if (i != 1 && buffG[1] >= buffG[i] && 7 == buffA[1]) {
+                    pxG = buffG[i];
+                }
+                if (i != 3 && buffG[3] >= buffG[i] && 7 == buffA[3]) {
+                    pxG = buffG[i];
+                }
+                if (i != 5 && buffG[5] >= buffG[i] && 7 == buffA[5]) {
+                    pxG = buffG[i];
+                }
+                if (i != 7 && buffG[7] >= buffG[i] && 7 == buffA[7]) {
+                    pxG = buffG[i];
+                }
+                if (i != 9 && buffG[9] >= buffG[i] && 7 == buffA[9]) {
+                    pxG = buffG[i];
+                }
+                if (i != 11 && buffG[11] >= buffG[i] && 7 == buffA[11]) {
+                    pxG = buffG[i];
+                }
+                if (i != 13 && buffG[13] >= buffG[i] && 7 == buffA[13]) {
+                    pxG = buffG[i];
+                }
+            }
+            // B
+            if (pxB < buffB[i]) {
+                if (i != 1 && buffB[1] >= buffB[i] && 7 == buffA[1]) {
+                    pxB = buffB[i];
+                }
+                if (i != 3 && buffB[3] >= buffB[i] && 7 == buffA[3]) {
+                    pxB = buffB[i];
+                }
+                if (i != 5 && buffB[5] >= buffB[i] && 7 == buffA[5]) {
+                    pxB = buffB[i];
+                }
+                if (i != 7 && buffB[7] >= buffB[i] && 7 == buffA[7]) {
+                    pxB = buffB[i];
+                }
+                if (i != 9 && buffB[9] >= buffB[i] && 7 == buffA[9]) {
+                    pxB = buffB[i];
+                }
+                if (i != 11 && buffB[11] >= buffB[i] && 7 == buffA[11]) {
+                    pxB = buffB[i];
+                }
+                if (i != 13 && buffB[13] >= buffB[i] && 7 == buffA[13]) {
+                    pxB = buffB[i];
+                }
+            }
+
+            // R
+            if (pxR2 < buffR[i + 1]) {
+                if (i + 1 != 1 && buffR[1] >= buffR[i + 1] && 7 == buffA[1]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 3 && buffR[3] >= buffR[i + 1] && 7 == buffA[3]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 5 && buffR[5] >= buffR[i + 1] && 7 == buffA[5]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 7 && buffR[7] >= buffR[i + 1] && 7 == buffA[7]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 9 && buffR[9] >= buffR[i + 1] && 7 == buffA[9]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 11 && buffR[11] >= buffR[i + 1] && 7 == buffA[11]) {
+                    pxR2 = buffR[i + 1];
+                }
+                if (i + 1 != 13 && buffR[13] >= buffR[i + 1] && 7 == buffA[13]) {
+                    pxR2 = buffR[i + 1];
+                }
+            }
+            // G
+            if (pxG2 < buffG[i + 1]) {
+                if (i + 1 != 1 && buffG[1] >= buffG[i + 1] && 7 == buffA[1]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 3 && buffG[3] >= buffG[i + 1] && 7 == buffA[3]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 5 && buffG[5] >= buffG[i + 1] && 7 == buffA[5]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 7 && buffG[7] >= buffG[i + 1] && 7 == buffA[7]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 9 && buffG[9] >= buffG[i + 1] && 7 == buffA[9]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 11 && buffG[11] >= buffG[i + 1] && 7 == buffA[11]) {
+                    pxG2 = buffG[i + 1];
+                }
+                if (i + 1 != 13 && buffG[13] >= buffG[i + 1] && 7 == buffA[13]) {
+                    pxG2 = buffG[i + 1];
+                }
+            }
+            // B
+            if (pxB2 < buffB[i + 1]) {
+                if (i + 1 != 1 && buffB[1] >= buffB[i + 1] && 7 == buffA[1]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 3 && buffB[3] >= buffB[i + 1] && 7 == buffA[3]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 5 && buffB[5] >= buffB[i + 1] && 7 == buffA[5]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 7 && buffB[7] >= buffB[i + 1] && 7 == buffA[7]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 9 && buffB[9] >= buffB[i + 1] && 7 == buffA[9]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 11 && buffB[11] >= buffB[i + 1] && 7 == buffA[11]) {
+                    pxB2 = buffB[i + 1];
+                }
+                if (i + 1 != 13 && buffB[13] >= buffB[i + 1] && 7 == buffA[13]) {
+                    pxB2 = buffB[i + 1];
+                }
+            }
+        }
+    }
+
+    unk = 7 - buffA[7];
+
+    pixel =
+        (((((((pxR + pxR2) - (buffR[7] << 1)) * unk + 4) >> 3) + buffR[7]) >> 3) << 3) | (pixel & 0xFF07); // RG + 7?
+    pixel = ((((((((pxG + pxG2) - (buffG[7] << 1)) * unk + 4) >> 3) + buffG[7]) >> 3) << 6) & 0x07C0) |
+            (pixel & 0xF83F); // R-BA
+    pixel = ((((((((pxB + pxB2) - (buffB[7] << 1)) * unk + 4) >> 3) + buffB[7]) >> 3) << 1) & 0x003E) |
+            (pixel & 0xFFC1); // RG-A
+    pixel |= 1;
+    this->fbufSave[y * this->width + x] = pixel;
+}
+#else
 #pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C2500.s")
+#endif
 
 #pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C2FE4.s")
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/PreRender/func_800C3770.s")
+void PreRender_Calc(PreRenderContext* this) {
+    s32 x;
+    s32 y;
+
+    if (!this->cvgSave || !this->fbufSave) {
+        return;
+    }
+
+    for (y = 0; y < this->height; y++) {
+        for (x = 0; x < this->width; x++) {
+            s32 a = this->cvgSave[x + y * this->width];
+            a >>= 5;
+            a++;
+            if (a != 8) {
+                func_800C2500(this, x, y);
+            }
+        }
+    }
+
+    if (HREG(80) == 0xF ? HREG(81) : 0) {
+        func_800C2FE4(this);
+    }
+}
diff --git a/src/code/fault.c b/src/code/fault.c
index 38d61ef0f..7520165f4 100644
--- a/src/code/fault.c
+++ b/src/code/fault.c
@@ -907,7 +907,7 @@ void Fault_CommitFB() {
     }
 
     osViSwapBuffer(fb);
-    FaultDrawer_SetDrawerFB(fb, 0x140, 0xf0);
+    FaultDrawer_SetDrawerFB(fb, SCREEN_WIDTH, SCREEN_HEIGHT);
 }
 
 void Fault_ProcessClients(void) {
diff --git a/src/code/fault_drawer.c b/src/code/fault_drawer.c
index 593696173..9a4a81be1 100644
--- a/src/code/fault_drawer.c
+++ b/src/code/fault_drawer.c
@@ -38,8 +38,8 @@ const u32 sFaultDrawerFont[] = {
 // data
 FaultDrawer sFaultDrawerDefault = {
     (u16*)0x803DA800,                   // fb
-    320,                                // w
-    240,                                // h
+    SCREEN_WIDTH,                       // w
+    SCREEN_HEIGHT,                      // h
     16,                                 // yStart
     223,                                // yEnd
     22,                                 // xStart
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index 019c3c239..8835072be 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -3594,7 +3594,7 @@ s32 func_800343CC(GlobalContext* globalCtx, Actor* actor, s16* arg2, f32 arg3, c
 
     func_8002F374(globalCtx, actor, &sp26, &sp24);
 
-    if ((sp26 < 0) || (sp26 > 0x140) || (sp24 < 0) || (sp24 > 0xF0)) {
+    if ((sp26 < 0) || (sp26 > SCREEN_WIDTH) || (sp24 < 0) || (sp24 > SCREEN_HEIGHT)) {
         return 0;
     }
 
@@ -5398,7 +5398,7 @@ s32 func_80037D98(GlobalContext* globalCtx, Actor* actor, s16 arg2, s32* arg3) {
 
     if (0) {} // Necessary to match
 
-    if ((sp2C < 0) || (sp2C > 320) || (sp2A < 0) || (sp2A > 240)) {
+    if ((sp2C < 0) || (sp2C > SCREEN_WIDTH) || (sp2A < 0) || (sp2A > SCREEN_HEIGHT)) {
         return 0;
     }
 
diff --git a/src/code/z_moji.c b/src/code/z_moji.c
index 16649a22d..17886ba8b 100644
--- a/src/code/z_moji.c
+++ b/src/code/z_moji.c
@@ -85,10 +85,10 @@ void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
         switch (arg1[i]) {
             case 9:
                 D_80120120 = (((D_80120120 / 8) / 8) + 1) * 8 * 8;
-                if (D_80120120 >= 320) {
+                if (D_80120120 >= SCREEN_WIDTH) {
                     D_80120120 = 0;
                     D_80120124 += 8;
-                    if (D_80120124 >= 240) {
+                    if (D_80120124 >= SCREEN_HEIGHT) {
                         D_80120124 = 0;
                     }
                 }
@@ -97,7 +97,7 @@ void func_8007BBA8(GraphicsContext* gfxCtx, u8* arg1) {
             case 13:
                 D_80120120 = 0;
                 D_80120124 += 8;
-                if (D_80120124 >= 240) {
+                if (D_80120124 >= SCREEN_HEIGHT) {
                     D_80120124 = 0;
                 }
                 break;
diff --git a/src/code/z_play.c b/src/code/z_play.c
index a3ab3930f..5422448e4 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -156,7 +156,7 @@ void Gameplay_Destroy(GlobalContext* globalCtx) {
     SREG(91) = 0;
     R_PAUSE_MENU_MODE = 0;
 
-    func_800C0F08(&globalCtx->preRenderCtx);
+    PreRender_Destroy(&globalCtx->preRenderCtx);
     Effect_DeleteAll(globalCtx);
     EffectSs_ClearAll(globalCtx);
     CollisionCheck_DestroyContext(globalCtx, &globalCtx->colChkCtx);
@@ -333,9 +333,9 @@ void Gameplay_Init(GlobalContext* globalCtx) {
 
     SREG(91) = -1;
     R_PAUSE_MENU_MODE = 0;
-    func_800C0EA8(&globalCtx->preRenderCtx);
-    func_800C0E70(&globalCtx->preRenderCtx, 0x140, 0xF0, 0, 0, 0);
-    func_800C0ED8(&globalCtx->preRenderCtx, 0x140, 0xF0, 0, 0);
+    PreRender_Init(&globalCtx->preRenderCtx);
+    PreRender_SetValuesSave(&globalCtx->preRenderCtx, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0);
+    PreRender_SetValues(&globalCtx->preRenderCtx, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
     gTrnsnUnkState = 0;
     globalCtx->transitionMode = 0;
     func_8008E6A0(&globalCtx->sub_7B8);
@@ -1158,11 +1158,11 @@ void Gameplay_Draw(GlobalContext* globalCtx) {
             oGfxCtx->polyOpa.p = sp88;
             goto Gameplay_Draw_DrawOverlayElements;
         } else {
-            func_800C0ED8(&globalCtx->preRenderCtx, 0x140, 0xF0, gfxCtx->curFrameBuffer, gZBuffer);
+            PreRender_SetValues(&globalCtx->preRenderCtx, SCREEN_WIDTH, SCREEN_HEIGHT, gfxCtx->curFrameBuffer, gZBuffer);
 
             if (R_PAUSE_MENU_MODE == 2) {
                 MsgEvent_SendNullTask();
-                func_800C3770(&globalCtx->preRenderCtx);
+                PreRender_Calc(&globalCtx->preRenderCtx);
                 R_PAUSE_MENU_MODE = 3;
             } else if (R_PAUSE_MENU_MODE >= 4) {
                 R_PAUSE_MENU_MODE = 0;
@@ -1286,19 +1286,19 @@ void Gameplay_Draw(GlobalContext* globalCtx) {
                 }
 
                 if ((R_PAUSE_MENU_MODE == 1) || (gTrnsnUnkState == 1)) {
-                    Gfx* sp70 = oGfxCtx->overlay.p;
-                    globalCtx->preRenderCtx.unk_10 = gfxCtx->curFrameBuffer;
-                    globalCtx->preRenderCtx.unk_14 = gZBuffer;
+                    Gfx* sp70 = gfxCtx->overlay.p;
+                    globalCtx->preRenderCtx.fbuf = gfxCtx->curFrameBuffer;
+                    globalCtx->preRenderCtx.fbufSave = gZBuffer;
                     func_800C1F20(&globalCtx->preRenderCtx, &sp70);
                     if (R_PAUSE_MENU_MODE == 1) {
-                        globalCtx->preRenderCtx.unk_18 = gfxCtx->curFrameBuffer;
+                        globalCtx->preRenderCtx.cvgSave = gfxCtx->curFrameBuffer;
                         func_800C20B4(&globalCtx->preRenderCtx, &sp70);
                         R_PAUSE_MENU_MODE = 2;
                     } else {
                         gTrnsnUnkState = 2;
                     }
-                    oGfxCtx->overlay.p = sp70;
-                    globalCtx->preRenderCtx.unk_A3 = 2;
+                    gfxCtx->overlay.p = sp70;
+                    globalCtx->unk_121C7 = 2;
                     SREG(33) |= 1;
                 } else {
                 Gameplay_Draw_DrawOverlayElements: