GFGeometry, GFLight, GFPixel, GFTev, GFTransform (#1180)

configure.py

@@ -952,11 +952,11 @@ config.libs = [
         "progress_category": "sdk",
         "host": False,
         "objects": [
-            Object(NonMatching, "dolphin/gf/GFGeometry.cpp"),
-            Object(NonMatching, "dolphin/gf/GFLight.cpp"),
-            Object(MatchingFor("GZLJ01", "GZLE01", "GZLP01"),    "dolphin/gf/GFPixel.cpp"),
-            Object(NonMatching, "dolphin/gf/GFTev.cpp"),
-            Object(NonMatching, "dolphin/gf/GFTransform.cpp"),
+            Object(Matching, "dolphin/gf/GFGeometry.cpp"),
+            Object(Matching, "dolphin/gf/GFLight.cpp"),
+            Object(Matching, "dolphin/gf/GFPixel.cpp"),
+            Object(Matching, "dolphin/gf/GFTev.cpp"),
+            Object(Matching, "dolphin/gf/GFTransform.cpp"),
         ],
     },
     JSystemLib(

include/dolphin/gf/GF.h

@@ -1,10 +1,47 @@
 #ifndef GF_H
 #define GF_H
 
+#include "dolphin/gd/GDBase.h"
 #include "dolphin/gf/GFGeometry.h" // IWYU pragma: export
 #include "dolphin/gf/GFLight.h" // IWYU pragma: export
 #include "dolphin/gf/GFPixel.h" // IWYU pragma: export
 #include "dolphin/gf/GFTev.h" // IWYU pragma: export
 #include "dolphin/gf/GFTransform.h" // IWYU pragma: export
 
+inline void GFWrite_u8(u8 data) {
+    GXCmd1u8(data);
+}
+
+inline void GFWrite_u16(u16 data) {
+    GXCmd1u16(data);
+}
+
+inline void GFWrite_u32(u32 data) {
+    GXCmd1u32(data);
+}
+
+inline void GFWriteCPCmd(u8 addr, u32 val) {
+    GFWrite_u8(GX_LOAD_CP_REG);
+    GFWrite_u8(addr);
+    GFWrite_u32(val);
+}
+
+inline void GFWriteXFCmd(u16 addr, u32 val) {
+    GFWrite_u8(GX_LOAD_XF_REG);
+    GFWrite_u16(0);
+    GFWrite_u16(addr);
+    GFWrite_u32(val);
+}
+
+inline void GFWriteXFCmdHdr(u16 addr, u8 len) {
+    GFWrite_u8(GX_LOAD_XF_REG);
+    GFWrite_u16(len - 1);
+    GFWrite_u16(addr);
+}
+
+inline void GFWriteBPCmd(u32 x) {
+    GFWrite_u8(GX_LOAD_BP_REG);
+    GFWrite_u32(x);
+}
+
 #endif /* GF_H */

include/dolphin/gf/GFLight.h

@@ -4,6 +4,23 @@
 #include "dolphin/gx/GXEnum.h"
 #include "dolphin/gx/GXStruct.h"
 
+#define XF_LIGHT_ID 0x0600
+#define XF_LIGHT_COLOR_ID 0x0603
+#define XF_LIGHT_ATTN_ID 0x0604
+#define XF_LIGHT_DISTATTN_ID 0x0607
+#define XF_LIGHT_POS_ID 0x060A
+#define XF_LIGHT_SPEC_DIR_ID 0x060A
+#define XF_LIGHT_DIR_ID 0x060D
+
+#define XF_REG_AMBIENT0_ID 0x100A
+#define XF_REG_AMBIENT1_ID 0x100B
+#define XF_REG_MATERIAL0_ID 0x100C
+#define XF_REG_MATERIAL1_ID 0x100D
+#define XF_REG_COLOR0CNTRL_ID 0x100E
+#define XF_REG_COLOR1CNTRL_ID 0x100F
+#define XF_REG_ALPHA0CNTRL_ID 0x1010
+#define XF_REG_ALPHA1CNTRL_ID 0x1011
+
 void GFSetChanMatColor(GXChannelID, GXColor);
 
 #endif /* GFLIGHT_H */

include/dolphin/gf/GFTransform.h

@@ -4,6 +4,36 @@
 #include "dolphin/gx/GXEnum.h"
 #include "dolphin/mtx/mtx.h"
 
+#define CP_MTX_REG_A_ID 0x30
+#define CP_MTX_REG_B_ID 0x40
+
+#define XF_REG_MATRIXINDEX0_ID 0x1018
+#define XF_REG_MATRIXINDEX1_ID 0x1019
+#define XF_REG_PROJECTIONA_ID 0x1020
+#define XF_REG_PROJECTIONB_ID 0x1021
+#define XF_REG_PROJECTIONC_ID 0x1022
+#define XF_REG_PROJECTIOND_ID 0x1023
+#define XF_REG_PROJECTIONE_ID 0x1024
+#define XF_REG_PROJECTIONF_ID 0x1025
+#define XF_REG_PROJECTORTHO_ID 0x1026
+
+#define CP_MTX_REG_A(pn, t0, t1, t2, t3) \
+    ( \
+        (u32)(pn) << 0 | \
+        (u32)(t0) << 6 | \
+        (u32)(t1) << 12 | \
+        (u32)(t2) << 18 | \
+        (u32)(t3) << 24 \
+    )
+
+#define CP_MTX_REG_B(t4, t5, t6, t7) \
+    ( \
+        (u32)(t4) << 0 | \
+        (u32)(t5) << 6 | \
+        (u32)(t6) << 12 | \
+        (u32)(t7) << 18 \
+    )
+
 void GFLoadPosMtxImm(MtxP, u32);
 void GFLoadNrmMtxImm(MtxP, u32);
 void GFSetCurrentMtx(u32, u32, u32, u32, u32, u32, u32, u32, u32);

include/dolphin/gx/GX.h

@@ -103,6 +103,18 @@ volatile PPCWGPipe GXFIFO AT_ADDRESS(GXFIFO_ADDR);
     }
 
 // Direct
+inline void GXCmd1u8(const u8 x) {
+    GXFIFO.u8 = x;
+}
+
+inline void GXCmd1u16(const u16 x) {
+    GXFIFO.u16 = x;
+}
+
+inline void GXCmd1u32(const u32 x) {
+    GXFIFO.u32 = x;
+}
+
 inline void GXPosition2f32(f32 x, f32 z) {
     GXFIFO.f32 = x;
     GXFIFO.f32 = z;
@@ -218,11 +230,6 @@ inline void GXTexCoord1x16(u16 x) {
     GXFIFO.u16 = x;
 }
 
-inline void GFWriteBPCmd(u32 x) {
-    GXFIFO.u8 = GX_CMD_LOAD_BP_REG;
-    GXFIFO.u32 = x;
-}
-
 inline void GXEnd() {}
 
 #define GX_WRITE_U8(ub)     \

src/JSystem/JRenderer/JRenderer.cpp

@@ -6,7 +6,7 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
 #include "JSystem/JRenderer/JRenderer.h"
-#include "dolphin/gx/GX.h"
+#include "dolphin/gf/GF.h"
 #include "JSystem/J3DGraphBase/J3DGD.h"
 
 u8 JRNTexImage1Ids[] = { 0x8c, 0x8d, 0x8e, 0x8f, 0xac, 0xad, 0xae, 0xaf };

src/dolphin/gf/GFGeometry.cpp

@@ -3,18 +3,252 @@
 #include "dolphin/gf/GF.h"
 #include "dolphin/os/OS.h"
 
-void GFSetVtxDescv(GXVtxDescList*) {
-    // NONMATCHING
+void GFSetVtxDescv(GXVtxDescList* attrPtr) {
+    u32 nnorms = 0;
+    u32 ncols = 0;
+    u32 ntexs = 0;
+    u32 pnMtxIdx = GX_NONE;
+    u32 txMtxIdxMask = 0;
+    u32 posn = GX_DIRECT;
+    u32 norm = GX_NONE;
+    u32 col0 = GX_NONE;
+    u32 col1 = GX_NONE;
+    u32 tex0 = GX_NONE;
+    u32 tex1 = GX_NONE;
+    u32 tex2 = GX_NONE;
+    u32 tex3 = GX_NONE;
+    u32 tex4 = GX_NONE;
+    u32 tex5 = GX_NONE;
+    u32 tex6 = GX_NONE;
+    u32 tex7 = GX_NONE;
+
+    for (; attrPtr->attr != GX_VA_NULL; ++attrPtr) {
+        switch (attrPtr->attr) {
+        case GX_VA_PNMTXIDX:
+            pnMtxIdx = attrPtr->type;
+            break;
+        case GX_VA_TEX0MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x1) | (attrPtr->type << 0);
+            break;
+        case GX_VA_TEX1MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x2) | (attrPtr->type << 1);
+            break;
+        case GX_VA_TEX2MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x4) | (attrPtr->type << 2);
+            break;
+        case GX_VA_TEX3MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x8) | (attrPtr->type << 3);
+            break;
+        case GX_VA_TEX4MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x10) | (attrPtr->type << 4);
+            break;
+        case GX_VA_TEX5MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x20) | (attrPtr->type << 5);
+            break;
+        case GX_VA_TEX6MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x40) | (attrPtr->type << 6);
+            break;
+        case GX_VA_TEX7MTXIDX:
+            txMtxIdxMask = (txMtxIdxMask & ~0x80) | (attrPtr->type << 7);
+            break;
+        case GX_VA_POS:
+            posn = attrPtr->type;
+            break;
+        case GX_VA_NRM:
+            if (attrPtr->type != GX_NONE) {
+                norm = attrPtr->type;
+                nnorms = 1;
+            }
+            break;
+        case GX_VA_NBT:
+            if (attrPtr->type != GX_NONE) {
+                norm = attrPtr->type;
+                nnorms = 2;
+            }
+            break;
+        case GX_VA_CLR0:
+            col0 = attrPtr->type;
+            ncols += (col0 != GX_NONE);
+            break;
+        case GX_VA_CLR1:
+            col1 = attrPtr->type;
+            ncols += (col1 != GX_NONE);
+            break;
+        case GX_VA_TEX0:
+            tex0 = attrPtr->type;
+            ntexs += (tex0 != GX_NONE);
+            break;
+        case GX_VA_TEX1:
+            tex1 = attrPtr->type;
+            ntexs += (tex1 != GX_NONE);
+            break;
+        case GX_VA_TEX2:
+            tex2 = attrPtr->type;
+            ntexs += (tex2 != GX_NONE);
+            break;
+        case GX_VA_TEX3:
+            tex3 = attrPtr->type;
+            ntexs += (tex3 != GX_NONE);
+            break;
+        case GX_VA_TEX4:
+            tex4 = attrPtr->type;
+            ntexs += (tex4 != GX_NONE);
+            break;
+        case GX_VA_TEX5:
+            tex5 = attrPtr->type;
+            ntexs += (tex5 != GX_NONE);
+            break;
+        case GX_VA_TEX6:
+            tex6 = attrPtr->type;
+            ntexs += (tex6 != GX_NONE);
+            break;
+        case GX_VA_TEX7:
+            tex7 = attrPtr->type;
+            ntexs += (tex7 != GX_NONE);
+            break;
+        }
+    }
+
+    GFWriteCPCmd(CP_REG_VCD_LO_ID, CP_REG_VCD_LO(pnMtxIdx, txMtxIdxMask, posn, norm, col0, col1));
+    GFWriteCPCmd(CP_REG_VCD_HI_ID, CP_REG_VCD_HI(tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7));
+    GFWriteXFCmd(XF_REG_INVERTEXSPEC_ID, XF_REG_INVTXSPEC(ncols, nnorms, ntexs));
 }
 
-void GFSetVtxAttrFmtv(GXVtxFmt, GXVtxAttrFmtList*) {
-    // NONMATCHING
+void GFSetVtxAttrFmtv(GXVtxFmt vtxfmt, GXVtxAttrFmtList* list) {
+    u32 posCnt = GX_POS_XYZ;
+    u32 posType = GX_F32;
+    u32 posFrac = 0;
+
+    u32 nrmCnt = GX_NRM_XYZ;
+    u32 nrmType = GX_F32;
+    u32 nrmIdx3 = 0;
+
+    u32 c0Cnt = GX_CLR_RGBA;
+    u32 c0Type = GX_RGBA8;
+
+    u32 c1Cnt = GX_CLR_RGBA;
+    u32 c1Type = GX_RGBA8;
+
+    u32 tx0Cnt = GX_TEX_ST;
+    u32 tx0Type = GX_F32;
+    u32 tx0Frac = 0;
+
+    u32 tx1Cnt = GX_TEX_ST;
+    u32 tx1Type = GX_F32;
+    u32 tx1Frac = 0;
+
+    u32 tx2Cnt = GX_TEX_ST;
+    u32 tx2Type = GX_F32;
+    u32 tx2Frac = 0;
+
+    u32 tx3Cnt = GX_TEX_ST;
+    u32 tx3Type = GX_F32;
+    u32 tx3Frac = 0;
+
+    u32 tx4Cnt = GX_TEX_ST;
+    u32 tx4Type = GX_F32;
+    u32 tx4Frac = 0;
+
+    u32 tx5Cnt = GX_TEX_ST;
+    u32 tx5Type = GX_F32;
+    u32 tx5Frac = 0;
+
+    u32 tx6Cnt = GX_TEX_ST;
+    u32 tx6Type = GX_F32;
+    u32 tx6Frac = 0;
+
+    u32 tx7Cnt = GX_TEX_ST;
+    u32 tx7Type = GX_F32;
+    u32 tx7Frac = 0;
+
+    for (; list->attr != GX_VA_NULL; ++list) {
+        switch (list->attr) {
+            case GX_VA_POS:
+                posCnt = list->cnt;
+                posType = list->type;
+                posFrac = list->frac;
+                break;
+            case GX_VA_NRM:
+            case GX_VA_NBT:
+                nrmType = list->type;
+                if (list->cnt == GX_NRM_NBT3) {
+                    nrmCnt = GX_NRM_NBT;
+                    nrmIdx3 = 1;
+                } else {
+                    nrmCnt = list->cnt;
+                    nrmIdx3 = 0;
+                }
+                break;
+            case GX_VA_CLR0:
+                c0Cnt = list->cnt;
+                c0Type = list->type;
+                break;
+            case GX_VA_CLR1:
+                c1Cnt = list->cnt;
+                c1Type = list->type;
+                break;
+            case GX_VA_TEX0:
+                tx0Cnt = list->cnt;
+                tx0Type = list->type;
+                tx0Frac = list->frac;
+                break;
+            case GX_VA_TEX1:
+                tx1Cnt = list->cnt;
+                tx1Type = list->type;
+                tx1Frac = list->frac;
+                break;
+            case GX_VA_TEX2:
+                tx2Cnt = list->cnt;
+                tx2Type = list->type;
+                tx2Frac = list->frac;
+                break;
+            case GX_VA_TEX3:
+                tx3Cnt = list->cnt;
+                tx3Type = list->type;
+                tx3Frac = list->frac;
+                break;
+            case GX_VA_TEX4:
+                tx4Cnt = list->cnt;
+                tx4Type = list->type;
+                tx4Frac = list->frac;
+                break;
+            case GX_VA_TEX5:
+                tx5Cnt = list->cnt;
+                tx5Type = list->type;
+                tx5Frac = list->frac;
+                break;
+            case GX_VA_TEX6:
+                tx6Cnt = list->cnt;
+                tx6Type = list->type;
+                tx6Frac = list->frac;
+                break;
+            case GX_VA_TEX7:
+                tx7Cnt = list->cnt;
+                tx7Type = list->type;
+                tx7Frac = list->frac;
+        }
+    }
+
+    GFWriteCPCmd(vtxfmt + CP_REG_VAT_GRP0_ID, CP_REG_VAT_GRP0(posCnt, posType, posFrac, nrmCnt, nrmType, c0Cnt, c0Type, c1Cnt, c1Type, tx0Cnt, tx0Type, tx0Frac, 1, nrmIdx3));
+    GFWriteCPCmd(vtxfmt + CP_REG_VAT_GRP1_ID, CP_REG_VAT_GRP1(tx1Cnt, tx1Type, tx1Frac, tx2Cnt, tx2Type, tx2Frac, tx3Cnt, tx3Type, tx3Frac, tx4Cnt, tx4Type, 1));
+    GFWriteCPCmd(vtxfmt + CP_REG_VAT_GRP2_ID, CP_REG_VAT_GRP2(tx4Frac, tx5Cnt, tx5Type, tx5Frac, tx6Cnt, tx6Type, tx6Frac, tx7Cnt, tx7Type, tx7Frac));
 }
 
-void GFSetArray(GXAttr, void*, u8) {
-    // NONMATCHING
+void GFSetArray(GXAttr attr, void* base_ptr, u8 stride) {
+    s32 cpAttr;
+    if (attr == GX_VA_NBT) {
+        cpAttr = GX_VA_TEX0MTXIDX;
+    } else {
+        cpAttr = attr - GX_VA_POS;
+    }
+
+    GFWriteCPCmd(cpAttr + CP_REG_ARRAYBASE_ID, OSCachedToPhysical(base_ptr));
+    GFWriteCPCmd(cpAttr + CP_REG_ARRAYSTRIDE_ID, stride);
 }
 
-void GFSetCullMode(GXCullMode) {
-    // NONMATCHING
+void GFSetCullMode(GXCullMode mode) {
+    static u8 cm2hw[4] = {0, 2, 1, 3};
+
+    GFWriteBPCmd(0xFE00C000);
+    GFWriteBPCmd(cm2hw[mode] << 14);
 }

src/dolphin/gf/GFLight.cpp

@@ -3,6 +3,6 @@
 #include "dolphin/gf/GF.h"
 #include "dolphin/os/OS.h"
 
-void GFSetChanMatColor(GXChannelID, GXColor) {
-    // NONMATCHING
+void GFSetChanMatColor(GXChannelID chan, GXColor color) {
+    GFWriteXFCmd((chan & 1) + XF_REG_MATERIAL0_ID, color.r << 24 | color.g << 16 | color.b << 8 | color.a);
 }

src/dolphin/gf/GFPixel.cpp

@@ -70,3 +70,7 @@ void GFSetBlendModeEtc(GXBlendMode type, GXBlendFactor src_factor,
         0x41
     ));
 }
+
+void GFSetDstAlpha(u8 enable, u8 alpha) {
+    GFWriteBPCmd(BP_DST_ALPHA(alpha, enable, 0x42));
+}

src/dolphin/gf/GFTev.cpp

@@ -2,8 +2,17 @@
 #include "dolphin/gd/GDGeometry.h"
 #include "dolphin/gf/GF.h"
 
-void GFSetTevColor(GXTevRegID, GXColor) {
-    // NONMATCHING
+void GFSetTevColor(GXTevRegID reg, GXColor color) {
+    u32 regRA;
+    u32 regBG;
+
+    regRA = BP_TEV_COLOR_REG_RA(color.r, color.a, 0, 0xE0 + reg * 2);
+    regBG = BP_TEV_COLOR_REG_BG(color.b, color.g, 0, 0xE1 + reg * 2);
+
+    GFWriteBPCmd(regRA);
+    GFWriteBPCmd(regBG);
+    GFWriteBPCmd(regBG);
+    GFWriteBPCmd(regBG);
 }
 
 void GFSetTevColorS10(GXTevRegID reg, GXColorS10 color) {
@@ -19,6 +28,6 @@ void GFSetTevColorS10(GXTevRegID reg, GXColorS10 color) {
     GFWriteBPCmd(regBG);
 }
 
-void GFSetAlphaCompare(GXCompare, u8, GXAlphaOp, GXCompare, u8) {
-    // NONMATCHING
+void GFSetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1) {
+    GFWriteBPCmd(BP_ALPHA_COMPARE(ref0, ref1, comp0, comp1, op, 0xF3));
 }

src/dolphin/gf/GFTransform.cpp

@@ -2,14 +2,45 @@
 #include "dolphin/gd/GDGeometry.h"
 #include "dolphin/gf/GF.h"
 
-void GFLoadPosMtxImm(MtxP, u32) {
-    // NONMATCHING
+void GFLoadPosMtxImm(MtxP mtx, u32 id) {
+    GFWriteXFCmdHdr(4 * id, 12);
+    GFWrite_f32(mtx[0][0]);
+    GFWrite_f32(mtx[0][1]);
+    GFWrite_f32(mtx[0][2]);
+    GFWrite_f32(mtx[0][3]);
+    GFWrite_f32(mtx[1][0]);
+    GFWrite_f32(mtx[1][1]);
+    GFWrite_f32(mtx[1][2]);
+    GFWrite_f32(mtx[1][3]);
+    GFWrite_f32(mtx[2][0]);
+    GFWrite_f32(mtx[2][1]);
+    GFWrite_f32(mtx[2][2]);
+    GFWrite_f32(mtx[2][3]);
 }
 
-void GFLoadNrmMtxImm(MtxP, u32) {
-    // NONMATCHING
+void GFLoadNrmMtxImm(MtxP mtx, u32 id) {
+    GFWriteXFCmdHdr(id * 3 + 0x400, 9);
+    GFWrite_f32(mtx[0][0]);
+    GFWrite_f32(mtx[0][1]);
+    GFWrite_f32(mtx[0][2]);
+    GFWrite_f32(mtx[1][0]);
+    GFWrite_f32(mtx[1][1]);
+    GFWrite_f32(mtx[1][2]);
+    GFWrite_f32(mtx[2][0]);
+    GFWrite_f32(mtx[2][1]);
+    GFWrite_f32(mtx[2][2]);
 }
 
-void GFSetCurrentMtx(u32, u32, u32, u32, u32, u32, u32, u32, u32) {
-    // NONMATCHING
+void GFSetCurrentMtx(u32 pn, u32 t0, u32 t1, u32 t2, u32 t3, u32 t4, u32 t5, u32 t6, u32 t7) {
+    u32 regA;
+    u32 regB;
+
+    regA = CP_MTX_REG_A(pn, t0, t1, t2, t3);
+    regB = CP_MTX_REG_B(t4, t5, t6, t7);
+
+    GFWriteCPCmd(CP_MTX_REG_A_ID, regA);
+    GFWriteCPCmd(CP_MTX_REG_B_ID, regB);
+    GFWriteXFCmdHdr(XF_REG_MATRIXINDEX0_ID, 2);
+    GFWrite_u32(regA);
+    GFWrite_u32(regB);
 }

src/dolphin/gx/GXInit.c

@@ -173,12 +173,12 @@ GXFifoObj* GXInit(void* base, u32 size) {
 
         val1 = (val2 / 2048) | 0x69000400;
 
-        GFWriteBPCmd(val1);
+        GX_WRITE_RAS_REG(val1);
 
         __GXFlushTextureState();
 
         val1 = (val2 / 4224) | 0x46000200;
-        GFWriteBPCmd(val1);
+        GX_WRITE_RAS_REG(val1);
     }
 
     for (i = 0; i < GX_MAX_TEXMAP; i++) {
@@ -210,11 +210,11 @@ GXFifoObj* GXInit(void* base, u32 size) {
     GXFIFO.u32 = 0x1006;
     GXFIFO.u32 = 0;
 
-    GFWriteBPCmd(0x23000000);
+    GX_WRITE_RAS_REG(0x23000000);
 
-    GFWriteBPCmd(0x24000000);
+    GX_WRITE_RAS_REG(0x24000000);
 
-    GFWriteBPCmd(0x67000000);
+    GX_WRITE_RAS_REG(0x67000000);
 
     __GXSetTmemConfig(2);
     __GXInitGX();

src/dolphin/gx/GXMisc.c

@@ -77,7 +77,7 @@ static GXBool DrawDone;
 void GXSetDrawDone(void) {
     u8 padding[8];
     BOOL restore = OSDisableInterrupts();
-    GFWriteBPCmd(0x45000002);
+    GX_WRITE_RAS_REG(0x45000002);
     GXFlush();
     DrawDone = 0;
     OSRestoreInterrupts(restore);

src/dolphin/gx/GXPerf.c

@@ -36,7 +36,7 @@ void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
     case GX_PERF0_TRIANGLES_0CLR:
     case GX_PERF0_TRIANGLES_1CLR:
     case GX_PERF0_TRIANGLES_2CLR:
-        GFWriteBPCmd(0x23000000);
+        GX_WRITE_RAS_REG(0x23000000);
         break;
 
     case GX_PERF0_QUAD_0CVG:
@@ -46,7 +46,7 @@ void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
     case GX_PERF0_QUAD_3CVG:
     case GX_PERF0_QUAD_4CVG:
     case GX_PERF0_AVG_QUAD_CNT:
-        GFWriteBPCmd(0x24000000);
+        GX_WRITE_RAS_REG(0x24000000);
         break;
 
     case GX_PERF0_NONE:
@@ -64,7 +64,7 @@ void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
     case GX_PERF1_TC_CHECK7_8:
     case GX_PERF1_TC_MISS:
     case GX_PERF1_CLOCKS:
-        GFWriteBPCmd(0x67000000);
+        GX_WRITE_RAS_REG(0x67000000);
         break;
 
     case GX_PERF1_VC_ELEMQ_FULL:
@@ -157,74 +157,74 @@ void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
         break;
 
     case GX_PERF0_TRIANGLES:
-        GFWriteBPCmd(0x2300AE7F);
+        GX_WRITE_RAS_REG(0x2300AE7F);
         break;
     case GX_PERF0_TRIANGLES_CULLED:
-        GFWriteBPCmd(0x23008E7F);
+        GX_WRITE_RAS_REG(0x23008E7F);
         break;
     case GX_PERF0_TRIANGLES_PASSED:
-        GFWriteBPCmd(0x23009E7F);
+        GX_WRITE_RAS_REG(0x23009E7F);
         break;
     case GX_PERF0_TRIANGLES_SCISSORED:
-        GFWriteBPCmd(0x23001E7F);
+        GX_WRITE_RAS_REG(0x23001E7F);
         break;
     case GX_PERF0_TRIANGLES_0TEX:
-        GFWriteBPCmd(0x2300AC3F);
+        GX_WRITE_RAS_REG(0x2300AC3F);
         break;
     case GX_PERF0_TRIANGLES_1TEX:
-        GFWriteBPCmd(0x2300AC7F);
+        GX_WRITE_RAS_REG(0x2300AC7F);
         break;
     case GX_PERF0_TRIANGLES_2TEX:
-        GFWriteBPCmd(0x2300ACBF);
+        GX_WRITE_RAS_REG(0x2300ACBF);
         break;
     case GX_PERF0_TRIANGLES_3TEX:
-        GFWriteBPCmd(0x2300ACFF);
+        GX_WRITE_RAS_REG(0x2300ACFF);
         break;
     case GX_PERF0_TRIANGLES_4TEX:
-        GFWriteBPCmd(0x2300AD3F);
+        GX_WRITE_RAS_REG(0x2300AD3F);
         break;
     case GX_PERF0_TRIANGLES_5TEX:
-        GFWriteBPCmd(0x2300AD7F);
+        GX_WRITE_RAS_REG(0x2300AD7F);
         break;
     case GX_PERF0_TRIANGLES_6TEX:
-        GFWriteBPCmd(0x2300ADBF);
+        GX_WRITE_RAS_REG(0x2300ADBF);
         break;
     case GX_PERF0_TRIANGLES_7TEX:
-        GFWriteBPCmd(0x2300ADFF);
+        GX_WRITE_RAS_REG(0x2300ADFF);
         break;
     case GX_PERF0_TRIANGLES_8TEX:
-        GFWriteBPCmd(0x2300AE3F);
+        GX_WRITE_RAS_REG(0x2300AE3F);
         break;
     case GX_PERF0_TRIANGLES_0CLR:
-        GFWriteBPCmd(0x2300A27F);
+        GX_WRITE_RAS_REG(0x2300A27F);
         break;
     case GX_PERF0_TRIANGLES_1CLR:
-        GFWriteBPCmd(0x2300A67F);
+        GX_WRITE_RAS_REG(0x2300A67F);
         break;
     case GX_PERF0_TRIANGLES_2CLR:
-        GFWriteBPCmd(0x2300AA7F);
+        GX_WRITE_RAS_REG(0x2300AA7F);
         break;
 
     case GX_PERF0_QUAD_0CVG:
-        GFWriteBPCmd(0x2402C0C6);
+        GX_WRITE_RAS_REG(0x2402C0C6);
         break;
     case GX_PERF0_QUAD_NON0CVG:
-        GFWriteBPCmd(0x2402C16B);
+        GX_WRITE_RAS_REG(0x2402C16B);
         break;
     case GX_PERF0_QUAD_1CVG:
-        GFWriteBPCmd(0x2402C0E7);
+        GX_WRITE_RAS_REG(0x2402C0E7);
         break;
     case GX_PERF0_QUAD_2CVG:
-        GFWriteBPCmd(0x2402C108);
+        GX_WRITE_RAS_REG(0x2402C108);
         break;
     case GX_PERF0_QUAD_3CVG:
-        GFWriteBPCmd(0x2402C129);
+        GX_WRITE_RAS_REG(0x2402C129);
         break;
     case GX_PERF0_QUAD_4CVG:
-        GFWriteBPCmd(0x2402C14A);
+        GX_WRITE_RAS_REG(0x2402C14A);
         break;
     case GX_PERF0_AVG_QUAD_CNT:
-        GFWriteBPCmd(0x2402C1AD);
+        GX_WRITE_RAS_REG(0x2402C1AD);
         break;
 
     case GX_PERF0_NONE:
@@ -235,34 +235,34 @@ void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
 
     switch (gx->perf1) {
     case GX_PERF1_TEXELS:
-        GFWriteBPCmd(0x67000042);
+        GX_WRITE_RAS_REG(0x67000042);
         break;
     case GX_PERF1_TX_IDLE:
-        GFWriteBPCmd(0x67000084);
+        GX_WRITE_RAS_REG(0x67000084);
         break;
     case GX_PERF1_TX_REGS:
-        GFWriteBPCmd(0x67000063);
+        GX_WRITE_RAS_REG(0x67000063);
         break;
     case GX_PERF1_TX_MEMSTALL:
-        GFWriteBPCmd(0x67000129);
+        GX_WRITE_RAS_REG(0x67000129);
         break;
     case GX_PERF1_TC_MISS:
-        GFWriteBPCmd(0x67000252);
+        GX_WRITE_RAS_REG(0x67000252);
         break;
     case GX_PERF1_CLOCKS:
-        GFWriteBPCmd(0x67000021);
+        GX_WRITE_RAS_REG(0x67000021);
         break;
     case GX_PERF1_TC_CHECK1_2:
-        GFWriteBPCmd(0x6700014B);
+        GX_WRITE_RAS_REG(0x6700014B);
         break;
     case GX_PERF1_TC_CHECK3_4:
-        GFWriteBPCmd(0x6700018D);
+        GX_WRITE_RAS_REG(0x6700018D);
         break;
     case GX_PERF1_TC_CHECK5_6:
-        GFWriteBPCmd(0x670001CF);
+        GX_WRITE_RAS_REG(0x670001CF);
         break;
     case GX_PERF1_TC_CHECK7_8:
-        GFWriteBPCmd(0x67000211);
+        GX_WRITE_RAS_REG(0x67000211);
         break;
 
     case GX_PERF1_VC_ELEMQ_FULL:

src/dolphin/gx/GXTev.c

@@ -50,14 +50,14 @@ void GXSetTevOp(GXTevStageID stage, GXTevMode mode) {
     tevReg = gx->tevc[stage];
     tevReg = (*color & ~0xFF000000) | (tevReg & 0xFF000000);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
 
     gx->tevc[stage] = tevReg;
 
     tevReg = gx->teva[stage];
     tevReg = (*alpha & ~0xFF00000F) | (tevReg & 0xFF00000F);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
 
     gx->teva[stage] = tevReg;
 
@@ -75,7 +75,7 @@ void GXSetTevColorIn(GXTevStageID stage, GXTevColorArg a, GXTevColorArg b, GXTev
     SET_REG_FIELD(tevReg, 4, 4, 2);
     SET_REG_FIELD(tevReg, 4, 0, 2);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
 
     gx->tevc[stage] = tevReg;
     gx->bpSentNot = GX_FALSE;
@@ -92,7 +92,7 @@ void GXSetTevAlphaIn(GXTevStageID stage, GXTevAlphaArg a, GXTevAlphaArg b, GXTev
     SET_REG_FIELD(tevReg, 3, 7, 2);
     SET_REG_FIELD(tevReg, 3, 4, 2);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
 
     gx->teva[stage] = tevReg;
     gx->bpSentNot = GX_FALSE;
@@ -116,7 +116,7 @@ void GXSetTevColorOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale
     SET_REG_FIELD(tevReg, 1, 19, 2);
     SET_REG_FIELD(tevReg, 2, 22, 2);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
     gx->tevc[stage] = tevReg;
     gx->bpSentNot = GX_FALSE;
 }
@@ -139,7 +139,7 @@ void GXSetTevAlphaOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale
     SET_REG_FIELD(tevReg, 1, 19, 2);
     SET_REG_FIELD(tevReg, 2, 22, 2);
 
-    GFWriteBPCmd(tevReg);
+    GX_WRITE_RAS_REG(tevReg);
     gx->teva[stage] = tevReg;
     gx->bpSentNot = GX_FALSE;
 }