Misc cleanup 13 (#1189)

* FaultAddrConv Functions

* Invisible Ruppe macros

* skybox

* Z64 header defines

* ActorId

* remove i from KaleidoManager_FaultAddrConv

* size_t and parens

6 files changed, 73 insertions, 75 deletions

diff --git a/src/code/graph.c b/src/code/graph.c
index be865ee61..4bf322878 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -90,21 +90,21 @@ GameStateOverlay* Graph_GetNextGameState(GameState* gameState) {
     return NULL;
 }
 
-void* Graph_FaultAddrConvFunc(void* address, void* param) {
+void* Graph_FaultAddrConv(void* address, void* param) {
     uintptr_t addr = address;
     GameStateOverlay* gameStateOvl = &gGameStateOverlayTable[0];
-    uintptr_t ramConv;
+    size_t ramConv;
     void* ramStart;
-    uintptr_t diff;
+    size_t diff;
     s32 i;
 
-    for (i = 0; i < graphNumGameStates; i++, gameStateOvl++) {
+    for (i = 0; i < gGraphNumGameStates; i++, gameStateOvl++) {
         diff = VRAM_PTR_SIZE(gameStateOvl);
         ramStart = gameStateOvl->loadedRamAddr;
         ramConv = (uintptr_t)gameStateOvl->vramStart - (uintptr_t)ramStart;
 
         if (ramStart != NULL) {
-            if (addr >= (uintptr_t)ramStart && addr < (uintptr_t)ramStart + diff) {
+            if ((addr >= (uintptr_t)ramStart) && (addr < (uintptr_t)ramStart + diff)) {
                 return addr + ramConv;
             }
         }
@@ -122,7 +122,7 @@ void Graph_Init(GraphicsContext* gfxCtx) {
     gfxCtx->yScale = gViConfigYScale;
     osCreateMesgQueue(&gfxCtx->queue, gfxCtx->msgBuff, ARRAY_COUNT(gfxCtx->msgBuff));
     Fault_AddClient(&sGraphFaultClient, Graph_FaultClient, NULL, NULL);
-    Fault_AddAddrConvClient(&sGraphFaultAddrConvClient, Graph_FaultAddrConvFunc, NULL);
+    Fault_AddAddrConvClient(&sGraphFaultAddrConvClient, Graph_FaultAddrConv, NULL);
 }
 
 void Graph_Destroy(GraphicsContext* gfxCtx) {
diff --git a/src/code/z_actor_dlftbls.c b/src/code/z_actor_dlftbls.c
index 5d7f30ea8..1008cceab 100644
--- a/src/code/z_actor_dlftbls.c
+++ b/src/code/z_actor_dlftbls.c
@@ -38,45 +38,44 @@ ActorOverlay gActorOverlayTable[] = {
 
 ActorId gMaxActorId = 0;
 
-FaultClient D_801ED930;
-FaultAddrConvClient D_801ED940;
+FaultClient sActorOverlayTableFaultClient;
+FaultAddrConvClient sActorOverlayTableFaultAddrConvClient;
 
-void ActorOverlayTable_FaultPrint(void* arg0, void* arg1) {
+void ActorOverlayTable_FaultClient(void* arg0, void* arg1) {
     ActorOverlay* overlayEntry;
     u32 overlaySize;
-    ActorId i;
+    ActorId actorId;
 
     FaultDrawer_SetCharPad(-2, 0);
 
     FaultDrawer_Printf("actor_dlftbls %u\n", gMaxActorId);
     FaultDrawer_Printf("No. RamStart- RamEnd cn  Name\n");
 
-    for (i = 0, overlayEntry = &gActorOverlayTable[0]; i < gMaxActorId; i++, overlayEntry++) {
+    for (actorId = 0, overlayEntry = &gActorOverlayTable[0]; actorId < gMaxActorId; actorId++, overlayEntry++) {
         overlaySize = VRAM_PTR_SIZE(overlayEntry);
         if (overlayEntry->loadedRamAddr != NULL) {
-            FaultDrawer_Printf("%3d %08x-%08x %3d %s\n", i, overlayEntry->loadedRamAddr,
+            FaultDrawer_Printf("%3d %08x-%08x %3d %s\n", actorId, overlayEntry->loadedRamAddr,
                                (u32)overlayEntry->loadedRamAddr + overlaySize, overlayEntry->numLoaded, "");
         }
     }
 }
 
-void* ActorOverlayTable_FaultAddrConv(void* arg0, void* arg1) {
-    u8* ptr = arg0;
-    ActorOverlay* overlayEntry = &gActorOverlayTable[0];
-    ActorId i;
-    u8* ramStart;
-    u8* ramEnd;
-    size_t size;
-    u32 offset;
-
-    for (i = 0; i < gMaxActorId; i++, overlayEntry++) {
-        size = VRAM_PTR_SIZE(overlayEntry);
-        ramStart = overlayEntry->loadedRamAddr;
-        ramEnd = ramStart + size;
-        offset = (u8*)overlayEntry->vramStart - ramStart;
+void* ActorOverlayTable_FaultAddrConv(void* address, void* param) {
+    uintptr_t addr = address;
+    ActorOverlay* actorOvl = &gActorOverlayTable[0];
+    size_t ramConv;
+    void* ramStart;
+    size_t diff;
+    ActorId actorId;
+
+    for (actorId = 0; actorId < gMaxActorId; actorId++, actorOvl++) {
+        diff = VRAM_PTR_SIZE(actorOvl);
+        ramStart = actorOvl->loadedRamAddr;
+        ramConv = (uintptr_t)actorOvl->vramStart - (uintptr_t)ramStart;
+
         if (ramStart != NULL) {
-            if (ptr >= ramStart && ptr < ramEnd) {
-                return ptr + offset;
+            if ((addr >= (uintptr_t)ramStart) && (addr < (uintptr_t)ramStart + diff)) {
+                return addr + ramConv;
             }
         }
     }
@@ -85,12 +84,12 @@ void* ActorOverlayTable_FaultAddrConv(void* arg0, void* arg1) {
 
 void ActorOverlayTable_Init(void) {
     gMaxActorId = ACTOR_ID_MAX;
-    Fault_AddClient(&D_801ED930, &ActorOverlayTable_FaultPrint, NULL, NULL);
-    Fault_AddAddrConvClient(&D_801ED940, &ActorOverlayTable_FaultAddrConv, NULL);
+    Fault_AddClient(&sActorOverlayTableFaultClient, ActorOverlayTable_FaultClient, NULL, NULL);
+    Fault_AddAddrConvClient(&sActorOverlayTableFaultAddrConvClient, ActorOverlayTable_FaultAddrConv, NULL);
 }
 
 void ActorOverlayTable_Cleanup(void) {
-    Fault_RemoveClient(&D_801ED930);
-    Fault_RemoveAddrConvClient(&D_801ED940);
+    Fault_RemoveClient(&sActorOverlayTableFaultClient);
+    Fault_RemoveAddrConvClient(&sActorOverlayTableFaultAddrConvClient);
     gMaxActorId = 0;
 }
diff --git a/src/code/z_game_dlftbls.c b/src/code/z_game_dlftbls.c
index 11d390a28..1b82705f5 100644
--- a/src/code/z_game_dlftbls.c
+++ b/src/code/z_game_dlftbls.c
@@ -24,4 +24,4 @@ GameStateOverlay gGameStateOverlayTable[] = {
     GAMESTATE_OVERLAY(daytelop, DayTelop_Init, DayTelop_Destroy, sizeof(DayTelopState)),
 };
 
-s32 graphNumGameStates = ARRAY_COUNT(gGameStateOverlayTable);
+s32 gGraphNumGameStates = ARRAY_COUNT(gGameStateOverlayTable);
diff --git a/src/code/z_kaleido_manager.c b/src/code/z_kaleido_manager.c
index 48e8e2ad6..3771de9c0 100644
--- a/src/code/z_kaleido_manager.c
+++ b/src/code/z_kaleido_manager.c
@@ -14,24 +14,23 @@ KaleidoMgrOverlay gKaleidoMgrOverlayTable[] = {
 
 void* sKaleidoAreaPtr = NULL;
 KaleidoMgrOverlay* gKaleidoMgrCurOvl = NULL;
-FaultAddrConvClient sKaleidoAreaFaultClient;
-
-void* KaleidoManager_FaultAddrConvFunc(void* address, void* param) {
-    u8* ptr = address;
-    KaleidoMgrOverlay* ovl = &gKaleidoMgrCurOvl[0];
-    u8* ramStart;
-    u8* ramEnd;
-    size_t size;
-    uintptr_t offset;
-
-    if (ovl != NULL) {
-        size = VRAM_PTR_SIZE(ovl);
-        ramStart = ovl->loadedRamAddr;
-        ramEnd = ramStart + size;
-        offset = (u8*)ovl->vramStart - ramStart;
+FaultAddrConvClient sKaleidoMgrFaultAddrConvClient;
+
+void* KaleidoManager_FaultAddrConv(void* address, void* param) {
+    uintptr_t addr = address;
+    KaleidoMgrOverlay* kaleidoMgrOvl = gKaleidoMgrCurOvl;
+    size_t ramConv;
+    void* ramStart;
+    size_t diff;
+
+    if (kaleidoMgrOvl != NULL) {
+        diff = VRAM_PTR_SIZE(kaleidoMgrOvl);
+        ramStart = kaleidoMgrOvl->loadedRamAddr;
+        ramConv = (uintptr_t)kaleidoMgrOvl->vramStart - (uintptr_t)ramStart;
+
         if (ramStart != NULL) {
-            if (ptr >= ramStart && ptr < ramEnd) {
-                return ptr + offset;
+            if ((addr >= (uintptr_t)ramStart) && (addr < (uintptr_t)ramStart + diff)) {
+                return addr + ramConv;
             }
         }
     }
@@ -68,11 +67,11 @@ void KaleidoManager_Init(PlayState* play) {
 
     sKaleidoAreaPtr = THA_AllocEndAlign16(&play->state.heap, largestSize);
     gKaleidoMgrCurOvl = NULL;
-    Fault_AddAddrConvClient(&sKaleidoAreaFaultClient, KaleidoManager_FaultAddrConvFunc, NULL);
+    Fault_AddAddrConvClient(&sKaleidoMgrFaultAddrConvClient, KaleidoManager_FaultAddrConv, NULL);
 }
 
 void KaleidoManager_Destroy() {
-    Fault_RemoveAddrConvClient(&sKaleidoAreaFaultClient);
+    Fault_RemoveAddrConvClient(&sKaleidoMgrFaultAddrConvClient);
 
     if (gKaleidoMgrCurOvl != NULL) {
         KaleidoManager_ClearOvl(gKaleidoMgrCurOvl);
diff --git a/src/code/z_vr_box.c b/src/code/z_vr_box.c
index 2797fee3c..4d44de0f9 100644
--- a/src/code/z_vr_box.c
+++ b/src/code/z_vr_box.c
@@ -188,7 +188,7 @@ void Skybox_Setup(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyboxId)
     size_t size;
     void* segment;
 
-    skyboxCtx->rotZ = 0.0f;
+    skyboxCtx->rot.z = 0.0f;
 
     switch (skyboxId) {
         case SKYBOX_NORMAL_SKY:
@@ -210,17 +210,17 @@ void Skybox_Setup(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyboxId)
             segment = (void*)ALIGN8((uintptr_t)segment + size);
             DmaMgr_SendRequest0(skyboxCtx->paletteStaticSegment, SEGMENT_ROM_START(d2_fine_pal_static), size);
 
-            skyboxCtx->primR = 145;
-            skyboxCtx->primG = 120;
-            skyboxCtx->primB = 155;
+            skyboxCtx->prim.r = 145;
+            skyboxCtx->prim.g = 120;
+            skyboxCtx->prim.b = 155;
 
-            skyboxCtx->envR = 40;
-            skyboxCtx->envG = 0;
-            skyboxCtx->envB = 40;
+            skyboxCtx->env.r = 40;
+            skyboxCtx->env.g = 0;
+            skyboxCtx->env.b = 40;
 
             // Inverted Stone Tower Temple and Inverted Stone Tower
             if ((play->sceneId == SCENE_F41) || (play->sceneId == SCENE_INISIE_R)) {
-                skyboxCtx->rotZ = 3.15f;
+                skyboxCtx->rot.z = 3.15f;
             }
             break;
 
@@ -289,7 +289,7 @@ void func_80143324(PlayState* play, SkyboxContext* skyboxCtx, s16 skyboxId) {
 
 void Skybox_Init(GameState* gameState, SkyboxContext* skyboxCtx, s16 skyboxId) {
     skyboxCtx->skyboxShouldDraw = false;
-    skyboxCtx->rotX = skyboxCtx->rotY = skyboxCtx->rotZ = 0.0f;
+    skyboxCtx->rot.x = skyboxCtx->rot.y = skyboxCtx->rot.z = 0.0f;
 
     Skybox_Setup(gameState, skyboxCtx, skyboxId);
 
diff --git a/src/code/z_vr_box_draw.c b/src/code/z_vr_box_draw.c
index 2569f81fa..489f596e5 100644
--- a/src/code/z_vr_box_draw.c
+++ b/src/code/z_vr_box_draw.c
@@ -5,19 +5,19 @@ Mtx* sSkyboxDrawMatrix;
 Mtx* Skybox_UpdateMatrix(SkyboxContext* skyboxCtx, f32 x, f32 y, f32 z) {
     Matrix_Translate(x, y, z, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
-    Matrix_RotateXFApply(skyboxCtx->rotX);
-    Matrix_RotateYF(skyboxCtx->rotY, MTXMODE_APPLY);
-    Matrix_RotateZF(skyboxCtx->rotZ, MTXMODE_APPLY);
+    Matrix_RotateXFApply(skyboxCtx->rot.x);
+    Matrix_RotateYF(skyboxCtx->rot.y, MTXMODE_APPLY);
+    Matrix_RotateZF(skyboxCtx->rot.z, MTXMODE_APPLY);
     return Matrix_ToMtx(sSkyboxDrawMatrix);
 }
 
 void Skybox_SetColors(SkyboxContext* skyboxCtx, u8 primR, u8 primG, u8 primB, u8 envR, u8 envG, u8 envB) {
-    skyboxCtx->primR = primR;
-    skyboxCtx->primG = primG;
-    skyboxCtx->primB = primB;
-    skyboxCtx->envR = envR;
-    skyboxCtx->envG = envG;
-    skyboxCtx->envB = envB;
+    skyboxCtx->prim.r = primR;
+    skyboxCtx->prim.g = primG;
+    skyboxCtx->prim.b = primB;
+    skyboxCtx->env.r = envR;
+    skyboxCtx->env.g = envG;
+    skyboxCtx->env.b = envB;
 }
 
 void Skybox_Draw(SkyboxContext* skyboxCtx, GraphicsContext* gfxCtx, s16 skyboxId, s16 blend, f32 x, f32 y, f32 z) {
@@ -32,9 +32,9 @@ void Skybox_Draw(SkyboxContext* skyboxCtx, GraphicsContext* gfxCtx, s16 skyboxId
 
     Matrix_Translate(x, y, z, MTXMODE_NEW);
     Matrix_Scale(1.0f, 1.0f, 1.0f, MTXMODE_APPLY);
-    Matrix_RotateXFApply(skyboxCtx->rotX);
-    Matrix_RotateYF(skyboxCtx->rotY, MTXMODE_APPLY);
-    Matrix_RotateZF(skyboxCtx->rotZ, MTXMODE_APPLY);
+    Matrix_RotateXFApply(skyboxCtx->rot.x);
+    Matrix_RotateYF(skyboxCtx->rot.y, MTXMODE_APPLY);
+    Matrix_RotateZF(skyboxCtx->rot.z, MTXMODE_APPLY);
     Matrix_ToMtx(sSkyboxDrawMatrix);
 
     gSPMatrix(POLY_OPA_DISP++, sSkyboxDrawMatrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
@@ -45,8 +45,8 @@ void Skybox_Draw(SkyboxContext* skyboxCtx, GraphicsContext* gfxCtx, s16 skyboxId
     gDPSetTextureConvert(POLY_OPA_DISP++, G_TC_FILT);
     gDPSetCombineLERP(POLY_OPA_DISP++, TEXEL1, TEXEL0, PRIMITIVE_ALPHA, TEXEL0, TEXEL1, TEXEL0, PRIMITIVE, TEXEL0,
                       PRIMITIVE, ENVIRONMENT, COMBINED, ENVIRONMENT, 0, 0, 0, COMBINED);
-    gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, skyboxCtx->primR, skyboxCtx->primG, skyboxCtx->primB, blend);
-    gDPSetEnvColor(POLY_OPA_DISP++, skyboxCtx->envR, skyboxCtx->envG, skyboxCtx->envB, 0);
+    gDPSetPrimColor(POLY_OPA_DISP++, 0, 0, skyboxCtx->prim.r, skyboxCtx->prim.g, skyboxCtx->prim.b, blend);
+    gDPSetEnvColor(POLY_OPA_DISP++, skyboxCtx->env.r, skyboxCtx->env.g, skyboxCtx->env.b, 0);
 
     gSPDisplayList(POLY_OPA_DISP++, &skyboxCtx->dListBuf[0]);
     gSPDisplayList(POLY_OPA_DISP++, &skyboxCtx->dListBuf[2]);