Rename many functions, structs, and variables to match the oot decomp. Some things have not been renamed as their respective files have not been decompiled yet.

15 files changed, 379 insertions, 379 deletions

diff --git a/src/code/code_0x800A5AC0.c b/src/code/code_0x800A5AC0.c
index ddb632d0f..5a4532e33 100644
--- a/src/code/code_0x800A5AC0.c
+++ b/src/code/code_0x800A5AC0.c
@@ -5,17 +5,17 @@
 
 void EnAObj_Init(ActorEnAObj* this, GlobalContext* ctxt) {
     ActorEnAObj* s0 = (ActorEnAObj*)this;
-    s0->base.textId = ((s0->base.variable >> 8) & 0xFF) | 0x300;
-    s0->base.variable = (s0->base.variable & 0xFF) - 9;
-    Lib_ApplyActorInitVars((Actor*)s0, (ActorInitVar*)&enAObjInitVar);
-    Actor_SetDrawParams(&s0->base.drawParams, 0, (actor_post_draw_func)func_800B3FC0, 12);
+    s0->base.textId = ((s0->base.params >> 8) & 0xFF) | 0x300;
+    s0->base.params = (s0->base.params & 0xFF) - 9;
+    Actor_ProcessInitChain((Actor*)s0, (ActorInitVar*)&enAObjInitVar);
+    Actor_SetDrawParams(&s0->base.shape, 0, (actor_shadow_draw_func)func_800B3FC0, 12);
     Collision_InitCylinder(ctxt, &s0->collision, (Actor*)s0, &enAObjCylinderInit);
     Collision_CylinderMoveToActor((Actor*)s0, &s0->collision);
-    s0->base.unkA0.unk16 = 255;
+    s0->base.unkA0.mass = 255;
     s0->update = (actor_func)EnAObj_Update1;
 }
 
-void EnAObj_Fini(ActorEnAObj* this, GlobalContext* ctxt) {
+void EnAObj_Destroy(ActorEnAObj* this, GlobalContext* ctxt) {
     ColCylinder* a2 = &this->collision;
     Collision_FiniCylinder(ctxt, a2);
 }
@@ -26,9 +26,9 @@ void EnAObj_Update1(ActorEnAObj* this, GlobalContext* ctxt) {
     if (func_800B84D0((Actor*)this, ctxt) != 0) {
         this->update = (actor_func)EnAObj_Update2;
     } else {
-        v0 = this->base.yawToLink - this->base.drawParams.rot.y;
+        v0 = this->base.rotTowardsLinkY - this->base.shape.rot.y;
         v1 = (v0 < 0)? -v0 : v0;
-        if ((v1 < 10240) || ((this->base.variable == 1) && (v1 > 22528))) {
+        if ((v1 < 10240) || ((this->base.params == 1) && (v1 > 22528))) {
             func_800B863C((Actor*)this, ctxt);
         }
     }
@@ -40,12 +40,12 @@ void EnAObj_Update2(ActorEnAObj* this, GlobalContext* ctxt) {
     }
 }
 
-void EnAObj_Main(ActorEnAObj* this, GlobalContext* ctxt) {
+void EnAObj_Update(ActorEnAObj* this, GlobalContext* ctxt) {
     (this->update)((Actor*)this, (GlobalContext*)ctxt);
     Actor_SetHeight((Actor*)this, 45.0f);
-    Collision_AddOT(ctxt, &ctxt->collisionContext, (ColCommon*)&this->collision);
+    Collision_AddOT(ctxt, &ctxt->colCheckCtx, (ColCommon*)&this->collision);
 }
 
 void EnAObj_Draw(ActorEnAObj* this, GlobalContext* ctxt) {
-    func_800BDFC0(ctxt, enAObjDisplayLists[this->base.variable]);
+    func_800BDFC0(ctxt, enAObjDisplayLists[this->base.params]);
 }
diff --git a/src/code/code_0x800BF9A0.c b/src/code/code_0x800BF9A0.c
index 31294e559..754717be5 100644
--- a/src/code/code_0x800BF9A0.c
+++ b/src/code/code_0x800BF9A0.c
@@ -3,7 +3,7 @@
 
 void func_800BF9A0(s32 a0, s32 a1) {
     s32 i;
-    ActorOverlayTableEntry* s0;
+    ActorOverlay* s0;
     s32 v1;
 
     func_8008439C(-2, 0);
@@ -11,27 +11,27 @@ void func_800BF9A0(s32 a0, s32 a1) {
     func_800847CC(D_801DCBC4);
 
     for (i = 0, s0 = &actorOverlayTable[0]; i < D_801B4610; i++, s0++) {
-        v1 = s0->vramEnd - s0->vramStart;
-        if (s0->ramAddr == 0) continue;
-        func_800847CC(D_801DCBE4, i, s0->ramAddr, s0->ramAddr + v1, s0->clients, &D_801DCBFC);
+        v1 = (u32)s0->vramEnd - (u32)s0->vramStart;
+        if (s0->loadedRamAddr == NULL) continue;
+        func_800847CC(D_801DCBE4, i, s0->loadedRamAddr, (u32)s0->loadedRamAddr + v1, s0->nbLoaded, &D_801DCBFC);
     }
 }
 
 s32 func_800BFA78(s32 a0, s32 a1) {
     s32 i;
-    ActorOverlayTableEntry* v0 = &actorOverlayTable[0];
+    ActorOverlay* v0 = &actorOverlayTable[0];
     s32 t1;
     s32 a2;
     s32 a0_2 = a0;
 
     for (i = 0; i < D_801B4610; i++, v0++) {
-        t1 = v0->vramStart - v0->ramAddr;
-        a2 = v0->vramEnd - v0->vramStart;
+        t1 = (u32)v0->vramStart - (u32)v0->loadedRamAddr;
+        a2 = (u32)v0->vramEnd - (u32)v0->vramStart;
 
-        if (v0->ramAddr == 0) continue;
-        if (a0_2 < v0->ramAddr) continue;
+        if (v0->loadedRamAddr == NULL) continue;
+        if (a0_2 < (u32)v0->loadedRamAddr) continue;
 
-        if (a0_2 < (v0->ramAddr + a2)) {
+        if (a0_2 < ((u32)v0->loadedRamAddr + a2)) {
             return a0_2 + t1;
         }
     }
diff --git a/src/code/code_0x800CAAD0.c b/src/code/code_0x800CAAD0.c
index 65db86620..e4a9f4683 100644
--- a/src/code/code_0x800CAAD0.c
+++ b/src/code/code_0x800CAAD0.c
@@ -5,38 +5,38 @@
 // Perhaps it is called something like z_bgcheck_attach.c
 // The functions will use the BgCheck2 prefix for now.
 
-void BgCheck2_UpdateActorPosition(BgCheckContext* bgCtxt, s32 index, Actor* actor) {
+void BgCheck2_UpdateActorPosition(CollisionContext* bgCtxt, s32 index, Actor* actor) {
     z_Matrix prevMatrix;
     z_Matrix prevMatrixInv;
     z_Matrix currMatrix;
-    Vector3f newPos;
-    Vector3f posWithInv;
+    Vec3f newPos;
+    Vec3f posWithInv;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) return;
 
     Matrix_MakeTranslationRotationYXZScale(&prevMatrix,
-        bgCtxt->dyna.actorMeshes[index].prevParams.scale.x,
-        bgCtxt->dyna.actorMeshes[index].prevParams.scale.y,
-        bgCtxt->dyna.actorMeshes[index].prevParams.scale.z,
-        bgCtxt->dyna.actorMeshes[index].prevParams.rotation.x,
-        bgCtxt->dyna.actorMeshes[index].prevParams.rotation.y,
-        bgCtxt->dyna.actorMeshes[index].prevParams.rotation.z,
-        bgCtxt->dyna.actorMeshes[index].prevParams.pos.x,
-        bgCtxt->dyna.actorMeshes[index].prevParams.pos.y,
-        bgCtxt->dyna.actorMeshes[index].prevParams.pos.z);
+        bgCtxt->dyna.actorMeshArr[index].prevParams.scale.x,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.scale.y,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.scale.z,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.rotation.x,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.rotation.y,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.rotation.z,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.pos.x,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.pos.y,
+        bgCtxt->dyna.actorMeshArr[index].prevParams.pos.z);
 
     if (Matrix_Invert(&prevMatrix, &prevMatrixInv) == 2) return;
 
     Matrix_MakeTranslationRotationYXZScale(&currMatrix,
-        bgCtxt->dyna.actorMeshes[index].currParams.scale.x,
-        bgCtxt->dyna.actorMeshes[index].currParams.scale.y,
-        bgCtxt->dyna.actorMeshes[index].currParams.scale.z,
-        bgCtxt->dyna.actorMeshes[index].currParams.rotation.x,
-        bgCtxt->dyna.actorMeshes[index].currParams.rotation.y,
-        bgCtxt->dyna.actorMeshes[index].currParams.rotation.z,
-        bgCtxt->dyna.actorMeshes[index].currParams.pos.x,
-        bgCtxt->dyna.actorMeshes[index].currParams.pos.y,
-        bgCtxt->dyna.actorMeshes[index].currParams.pos.z);
+        bgCtxt->dyna.actorMeshArr[index].currParams.scale.x,
+        bgCtxt->dyna.actorMeshArr[index].currParams.scale.y,
+        bgCtxt->dyna.actorMeshArr[index].currParams.scale.z,
+        bgCtxt->dyna.actorMeshArr[index].currParams.rotation.x,
+        bgCtxt->dyna.actorMeshArr[index].currParams.rotation.y,
+        bgCtxt->dyna.actorMeshArr[index].currParams.rotation.z,
+        bgCtxt->dyna.actorMeshArr[index].currParams.pos.x,
+        bgCtxt->dyna.actorMeshArr[index].currParams.pos.y,
+        bgCtxt->dyna.actorMeshArr[index].currParams.pos.z);
 
     Matrix_MultiplyByVectorXYZ(&prevMatrixInv, &actor->currPosRot.pos, &posWithInv);
     Matrix_MultiplyByVectorXYZ(&currMatrix, &posWithInv, &newPos);
@@ -44,23 +44,23 @@ void BgCheck2_UpdateActorPosition(BgCheckContext* bgCtxt, s32 index, Actor* acto
     actor->currPosRot.pos = newPos;
 }
 
-void BgCheck2_UpdateActorYRotation(BgCheckContext* bgCtxt, s32 index, Actor* actor) {
+void BgCheck2_UpdateActorYRotation(CollisionContext* bgCtxt, s32 index, Actor* actor) {
     s16 angleChange;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) return;
 
-    angleChange = bgCtxt->dyna.actorMeshes[index].currParams.rotation.y - bgCtxt->dyna.actorMeshes[index].prevParams.rotation.y;
+    angleChange = bgCtxt->dyna.actorMeshArr[index].currParams.rotation.y - bgCtxt->dyna.actorMeshArr[index].prevParams.rotation.y;
 
     if (actor->id == 0) {
         ((ActorPlayer*)actor)->unkAD4 += angleChange;
     }
 
-    actor->drawParams.rot.y += angleChange;
+    actor->shape.rot.y += angleChange;
     actor->currPosRot.rot.y += angleChange;
 }
 
-void BgCheck2_AttachToMesh(BgCheckContext* bgCtxt, Actor* actor, s32 index) {
-    BgActor *meshActor;
+void BgCheck2_AttachToMesh(CollisionContext* bgCtxt, Actor* actor, s32 index) {
+    DynaPolyActor *meshActor;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) return;
 
@@ -77,13 +77,13 @@ void BgCheck2_AttachToMesh(BgCheckContext* bgCtxt, Actor* actor, s32 index) {
     }
 }
 
-u32 BgCheck2_UpdateActorAttachedToMesh(BgCheckContext* bgCtxt, s32 index, Actor* actor) {
+u32 BgCheck2_UpdateActorAttachedToMesh(CollisionContext* bgCtxt, s32 index, Actor* actor) {
     u32 wasUpdated = 0;
-    BgActor *meshActor;
+    DynaPolyActor *meshActor;
 
     if (BgCheck_IsActorMeshIndexValid(index) == 0) return 0;
 
-    if (((bgCtxt->dyna.meshParams[index] & 2) != 0) || ((bgCtxt->dyna.meshParams[index] & 1) == 0)) return 0;
+    if (((bgCtxt->dyna.flags[index] & 2) != 0) || ((bgCtxt->dyna.flags[index] & 1) == 0)) return 0;
 
     meshActor = BgCheck_GetActorOfMesh(bgCtxt,index);
 
diff --git a/src/code/code_0x800CAE10.c b/src/code/code_0x800CAE10.c
index e53b4f6f8..0bad5fce7 100644
--- a/src/code/code_0x800CAE10.c
+++ b/src/code/code_0x800CAE10.c
@@ -1,98 +1,98 @@
 #include <ultra64.h>
 #include <global.h>
 
-void BcCheck3_BgActorInit(BgActor* actor, UNK_TYPE4 param_2) {
-    actor->bgActorId = -1;
+void BcCheck3_BgActorInit(DynaPolyActor* actor, UNK_TYPE4 param_2) {
+    actor->dynaPolyId = -1;
     actor->unk148 = 0;
     actor->unk14C = 0;
     actor->unk154 = param_2;
-    actor->bgFlags = 0;
+    actor->dynaFlags = 0;
 }
 
-void BgCheck3_LoadMesh(GlobalContext* ctxt, BgActor* actor, BgMeshHeader* meshHeader) {
+void BgCheck3_LoadMesh(GlobalContext* ctxt, DynaPolyActor* actor, BgMeshHeader* meshHeader) {
     BgMeshHeader* header;
 
     header = NULL;
     BgCheck_RelocateMeshHeader(meshHeader, &header);
-    actor->bgActorId = BgCheck_AddActorMesh(ctxt, &ctxt->bgCheckContext.dyna, actor, header);
+    actor->dynaPolyId = BgCheck_AddActorMesh(ctxt, &ctxt->colCtx.dyna, actor, header);
 }
 
-void BgCheck3_ResetFlags(BgActor* actor) {
-    actor->bgFlags = 0;
+void BgCheck3_ResetFlags(DynaPolyActor* actor) {
+    actor->dynaFlags = 0;
 }
 
-void func_800CAE88(BgActor* actor) {
-    actor->bgFlags |= 1;
+void func_800CAE88(DynaPolyActor* actor) {
+    actor->dynaFlags |= 1;
 }
 
-void func_800CAE9C(BgActor* actor) {
-    actor->bgFlags |= 2;
+void func_800CAE9C(DynaPolyActor* actor) {
+    actor->dynaFlags |= 2;
 }
 
-void func_800CAEB0(BgCheckContext* bgCtxt, s32 index) {
-    BgActor* actor;
+void func_800CAEB0(CollisionContext* bgCtxt, s32 index) {
+    DynaPolyActor* actor;
 
     actor = BgCheck_GetActorOfMesh(bgCtxt, index);
-    if (actor != (BgActor *)0x0) {
+    if (actor != (DynaPolyActor *)0x0) {
         func_800CAE9C(actor);
     }
 }
 
-void func_800CAEE0(BgActor* actor) {
-    actor->bgFlags |= 4;
+void func_800CAEE0(DynaPolyActor* actor) {
+    actor->dynaFlags |= 4;
 }
 
-void func_800CAEF4(BgCheckContext* bgCtxt, s32 index) {
-    BgActor* actor;
+void func_800CAEF4(CollisionContext* bgCtxt, s32 index) {
+    DynaPolyActor* actor;
 
     actor = BgCheck_GetActorOfMesh(bgCtxt, index);
-    if (actor != (BgActor *)0x0) {
+    if (actor != (DynaPolyActor *)0x0) {
         func_800CAEE0(actor);
     }
 }
 
-void func_800CAF24(BgActor* actor) {
-    actor->bgFlags |= 8;
+void func_800CAF24(DynaPolyActor* actor) {
+    actor->dynaFlags |= 8;
 }
 
-void func_800CAF38(BgActor* actor) {
-    actor->bgFlags |= 0x10;
+void func_800CAF38(DynaPolyActor* actor) {
+    actor->dynaFlags |= 0x10;
 }
 
-s32 func_800CAF4C(BgActor* actor) {
-    if (actor->bgFlags & 1) {
+s32 func_800CAF4C(DynaPolyActor* actor) {
+    if (actor->dynaFlags & 1) {
         return 1;
     } else {
         return 0;
     }
 }
 
-s32 func_800CAF70(BgActor* actor) {
-    if (actor->bgFlags & 2) {
+s32 func_800CAF70(DynaPolyActor* actor) {
+    if (actor->dynaFlags & 2) {
         return 1;
     } else {
         return 0;
     }
 }
 
-s32 func_800CAF94(BgActor* actor) {
-    if (actor->bgFlags & 4) {
+s32 func_800CAF94(DynaPolyActor* actor) {
+    if (actor->dynaFlags & 4) {
         return 1;
     } else {
         return 0;
     }
 }
 
-s32 func_800CAFB8(BgActor* actor) {
-    if (actor->bgFlags & 8) {
+s32 func_800CAFB8(DynaPolyActor* actor) {
+    if (actor->dynaFlags & 8) {
         return 1;
     } else {
         return 0;
     }
 }
 
-s32 func_800CAFDC(BgActor* actor) {
-    if (actor->bgFlags & 0x10) {
+s32 func_800CAFDC(DynaPolyActor* actor) {
+    if (actor->dynaFlags & 0x10) {
         return 1;
     } else {
         return 0;
diff --git a/src/code/code_0x800E8EA0.c b/src/code/code_0x800E8EA0.c
index 5beb6f8dc..146fb9790 100644
--- a/src/code/code_0x800E8EA0.c
+++ b/src/code/code_0x800E8EA0.c
@@ -18,26 +18,26 @@ s32 nop_800E8EEC(UNK_TYPE4 param_1) {
 
 void nop_800E8EFC(UNK_TYPE4 param_1) {}
 
-s32 func_800E8F08(Vector3s* param_1, Vector3s* param_2) {
-  Lib_ScaleMaxMin_s(&param_1->y, 0, 6, 6200, 100);
-  Lib_ScaleMaxMin_s(&param_1->x, 0, 6, 6200, 100);
-  Lib_ScaleMaxMin_s(&param_2->y, 0, 6, 6200, 100);
-  Lib_ScaleMaxMin_s(&param_2->x, 0, 6, 6200, 100);
+s32 func_800E8F08(Vec3s* param_1, Vec3s* param_2) {
+  Math_SmoothScaleMaxMinS(&param_1->y, 0, 6, 6200, 100);
+  Math_SmoothScaleMaxMinS(&param_1->x, 0, 6, 6200, 100);
+  Math_SmoothScaleMaxMinS(&param_2->y, 0, 6, 6200, 100);
+  Math_SmoothScaleMaxMinS(&param_2->x, 0, 6, 6200, 100);
   return 1;
 }
 
-s32 func_800E8FA4(Actor* actor, Vector3f* param_2, Vector3s* param_3, Vector3s* param_4) {
+s32 func_800E8FA4(Actor* actor, Vec3f* param_2, Vec3s* param_3, Vec3s* param_4) {
     s16 targetPitch;
     s16 targetYaw;
     s16 yawDiffFromTarget;
 
-    targetPitch = Lib_PitchVec3f(&actor->topPosRot.pos,param_2);
-    targetYaw = Lib_YawVec3f(&actor->topPosRot.pos,param_2) - actor->currPosRot.rot.y;
+    targetPitch = Math_Vec3f_Pitch(&actor->topPosRot.pos,param_2);
+    targetYaw = Math_Vec3f_Yaw(&actor->topPosRot.pos,param_2) - actor->currPosRot.rot.y;
 
-    Lib_ScaleMaxMin_s(&param_3->x, targetPitch, 6, 2000, 1);
+    Math_SmoothScaleMaxMinS(&param_3->x, targetPitch, 6, 2000, 1);
     param_3->x = (param_3->x < -6000)? -6000 : ((6000 < param_3->x)? 6000 : param_3->x);
 
-    yawDiffFromTarget = Lib_ScaleMaxMin_s(&param_3->y, targetYaw, 6, 2000, 1);
+    yawDiffFromTarget = Math_SmoothScaleMaxMinS(&param_3->y, targetYaw, 6, 2000, 1);
     param_3->y = (param_3->y < -8000)? -8000 : ((8000 < param_3->y)? 8000 : param_3->y);
 
     if (yawDiffFromTarget != 0) {
@@ -46,23 +46,23 @@ s32 func_800E8FA4(Actor* actor, Vector3f* param_2, Vector3s* param_3, Vector3s*
         }
     }
 
-    Lib_ScaleMaxMin_s(&param_4->y, targetYaw - param_3->y, 4, 2000, 1);
+    Math_SmoothScaleMaxMinS(&param_4->y, targetYaw - param_3->y, 4, 2000, 1);
     param_4->y = (param_4->y < -12000)? -12000 : ((12000 < param_4->y)? 12000 : param_4->y);
 
     return 1;
 }
 
-s32 func_800E9138(GlobalContext* ctxt, Actor* actor, Vector3s* param_3, Vector3s* param_4, f32 param_5) {
+s32 func_800E9138(GlobalContext* ctxt, Actor* actor, Vec3s* param_3, Vec3s* param_4, f32 param_5) {
     s16 sVar3;
     Actor *player;
-    Vector3f local_14;
+    Vec3f local_14;
 
-    player = (ctxt->actorContext).actorTypeLists[2].head;
+    player = (ctxt->actorCtx).actorList[2].first;
     actor->topPosRot.pos = actor->currPosRot.pos;
     actor->topPosRot.pos.y += param_5;
 
-    if (((ctxt->cutsceneContext).state == 0) && (D_801D0D50 == 0)) {
-        sVar3 = actor->yawToLink - actor->drawParams.rot.y;
+    if (((ctxt->csCtx).state == 0) && (D_801D0D50 == 0)) {
+        sVar3 = actor->rotTowardsLinkY - actor->shape.rot.y;
         // TODO is this shifting because of a missing cast?
         if (0x42ff < (sVar3 < 0? ((-sVar3 << 0x10) >> 0x10) : ((sVar3 << 0x10) >> 0x10))) {
             func_800E8F08(param_3,param_4);
@@ -70,7 +70,7 @@ s32 func_800E9138(GlobalContext* ctxt, Actor* actor, Vector3s* param_3, Vector3s
         }
     }
 
-    if (((ctxt->cutsceneContext).state != 0) || (D_801D0D50 != 0)) {
+    if (((ctxt->csCtx).state != 0) || (D_801D0D50 != 0)) {
         local_14 = ctxt->view.eye;
     } else {
         local_14 = player->topPosRot.pos;
@@ -80,16 +80,16 @@ s32 func_800E9138(GlobalContext* ctxt, Actor* actor, Vector3s* param_3, Vector3s
 
     return 1;
 }
-s32 func_800E9250(GlobalContext* ctxt, Actor* actor, Vector3s* param_3, Vector3s* param_4, Vector3f param_5) {
+s32 func_800E9250(GlobalContext* ctxt, Actor* actor, Vec3s* param_3, Vec3s* param_4, Vec3f param_5) {
     s16 sVar3;
     Actor *player;
-    Vector3f local_14;
+    Vec3f local_14;
 
-    player = (ctxt->actorContext).actorTypeLists[2].head;
+    player = (ctxt->actorCtx).actorList[2].first;
     actor->topPosRot.pos = param_5;
 
-    if (((ctxt->cutsceneContext).state == 0) && (D_801D0D50 == 0)) {
-        sVar3 = actor->yawToLink - actor->drawParams.rot.y;
+    if (((ctxt->csCtx).state == 0) && (D_801D0D50 == 0)) {
+        sVar3 = actor->rotTowardsLinkY - actor->shape.rot.y;
         // TODO is this shifting because of a missing cast?
         if (0x42ff < (sVar3 < 0? ((-sVar3 << 0x10) >> 0x10) : ((sVar3 << 0x10) >> 0x10))) {
             func_800E8F08(param_3,param_4);
@@ -97,7 +97,7 @@ s32 func_800E9250(GlobalContext* ctxt, Actor* actor, Vector3s* param_3, Vector3s
         }
     }
 
-    if (((ctxt->cutsceneContext).state != 0) || (D_801D0D50 != 0)) {
+    if (((ctxt->csCtx).state != 0) || (D_801D0D50 != 0)) {
         local_14 = ctxt->view.eye;
     } else {
         local_14 = player->topPosRot.pos;
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index ed67183fa..32620752d 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -5,9 +5,9 @@
 
 GLOBAL_ASM("asm/non_matchings/z_actor//Actor_PrintLists.asm")
 
-void Actor_SetDrawParams(ActorDrawParams* iParm1, f32 yDisplacement, actor_post_draw_func func, f32 scale) {
+void Actor_SetDrawParams(ActorShape* iParm1, f32 yDisplacement, actor_shadow_draw_func func, f32 scale) {
     iParm1->yDisplacement = yDisplacement;
-    iParm1->postDrawFunc = func;
+    iParm1->shadowDrawFunc = func;
     iParm1->scale = scale;
     iParm1->alphaScale = 255;
 }
@@ -58,73 +58,73 @@ GLOBAL_ASM("asm/non_matchings/z_actor//func_800B5814.asm")
 
 u32 Actor_GetSwitchFlag(GlobalContext* ctxt, s32 flag) {
     if (flag >= 0 && flag < 0x80) {
-        return ctxt->actorContext.switchFlags[(flag & -0x20) >> 5] & (1 << (flag & 0x1F));
+        return ctxt->actorCtx.switchFlags[(flag & -0x20) >> 5] & (1 << (flag & 0x1F));
     }
     return 0;
 }
 
 void Actor_SetSwitchFlag(GlobalContext* ctxt, s32 flag){
     if (flag >= 0 && flag < 0x80) {
-        ctxt->actorContext.switchFlags[(flag & -0x20) >> 5] |= 1 << (flag & 0x1F);
+        ctxt->actorCtx.switchFlags[(flag & -0x20) >> 5] |= 1 << (flag & 0x1F);
     }
 }
 
 void Actor_UnsetSwitchFlag(GlobalContext* ctxt, s32 flag) {
     if (flag >= 0 && flag < 0x80) {
-        ctxt->actorContext.switchFlags[(flag & -0x20) >> 5] &= ~(1 << (flag & 0x1F));
+        ctxt->actorCtx.switchFlags[(flag & -0x20) >> 5] &= ~(1 << (flag & 0x1F));
     }
 }
 
 u32 Actor_GetChestFlag(GlobalContext* ctxt, u32 flag) {
-    return ctxt->actorContext.chestFlags & (1 << flag);
+    return ctxt->actorCtx.chestFlags & (1 << flag);
 }
 
 void Actor_SetChestFlag(GlobalContext* ctxt, u32 flag) {
-    ctxt->actorContext.chestFlags |= (1 << flag);
+    ctxt->actorCtx.chestFlags |= (1 << flag);
 }
 
 void Actor_SetAllChestFlag(GlobalContext* ctxt, u32 flag) {
-    ctxt->actorContext.chestFlags = flag;
+    ctxt->actorCtx.chestFlags = flag;
 }
 
 u32 Actor_GetAllChestFlag(GlobalContext* ctxt) {
-    return ctxt->actorContext.chestFlags;
+    return ctxt->actorCtx.chestFlags;
 }
 
 u32 Actor_GetRoomCleared(GlobalContext* ctxt, u32 roomNumber) {
-    return ctxt->actorContext.clearedRooms & (1 << roomNumber);
+    return ctxt->actorCtx.clearedRooms & (1 << roomNumber);
 }
 
 void Actor_SetRoomCleared(GlobalContext* ctxt, u32 roomNumber) {
-    ctxt->actorContext.clearedRooms |= (1 << roomNumber);
+    ctxt->actorCtx.clearedRooms |= (1 << roomNumber);
 }
 
 void Actor_UnsetRoomCleared(GlobalContext* ctxt, u32 roomNumber) {
-    ctxt->actorContext.clearedRooms &= ~(1 << roomNumber);
+    ctxt->actorCtx.clearedRooms &= ~(1 << roomNumber);
 }
 
 u32 Actor_GetRoomClearedTemp(GlobalContext* ctxt, u32 roomNumber) {
-    return ctxt->actorContext.clearedRoomsTemp & (1 << roomNumber);
+    return ctxt->actorCtx.clearedRoomsTemp & (1 << roomNumber);
 }
 
 void Actor_SetRoomClearedTemp(GlobalContext* ctxt, u32 roomNumber) {
-    ctxt->actorContext.clearedRoomsTemp |= (1 << roomNumber);
+    ctxt->actorCtx.clearedRoomsTemp |= (1 << roomNumber);
 }
 
 void Actor_UnsetRoomClearedTemp(GlobalContext* ctxt, u32 roomNumber) {
-    ctxt->actorContext.clearedRoomsTemp &= ~(1 << roomNumber);
+    ctxt->actorCtx.clearedRoomsTemp &= ~(1 << roomNumber);
 }
 
 u32 Actor_GetCollectibleFlag(GlobalContext* ctxt, s32 index) {
     if (index > 0 && index < 0x80) {
-        return ctxt->actorContext.collectibleFlags[(index & -0x20) >> 5] & (1 << (index & 0x1F));
+        return ctxt->actorCtx.collectibleFlags[(index & -0x20) >> 5] & (1 << (index & 0x1F));
     }
     return 0;
 }
 
 void Actor_SetCollectibleFlag(GlobalContext* ctxt, s32 index) {
     if (index > 0 && index < 0x80) {
-        ctxt->actorContext.collectibleFlags[(index & -0x20) >> 5] |= 1 << (index & 0x1F);
+        ctxt->actorCtx.collectibleFlags[(index & -0x20) >> 5] |= 1 << (index & 0x1F);
     }
 }
 
@@ -181,7 +181,7 @@ GLOBAL_ASM("asm/non_matchings/z_actor//func_800B6680.asm")
 
 void Actor_MarkForDeath(Actor* actor) {
     actor->draw = NULL;
-    actor->main = NULL;
+    actor->update = NULL;
     actor->flags &= ~0x1;
 }
 
@@ -199,11 +199,11 @@ void Actor_SetHeight(Actor* actor, f32 height) {
 }
 
 void Actor_SetRotationFromDrawRotation(Actor* actor) {
-    actor->currPosRot.rot = actor->drawParams.rot;
+    actor->currPosRot.rot = actor->shape.rot;
 }
 
 void Actor_InitDrawRotation(Actor* actor) {
-    actor->drawParams.rot = actor->currPosRot.rot;
+    actor->shape.rot = actor->currPosRot.rot;
 }
 
 void Actor_SetScale(Actor* actor, f32 scale) {
@@ -213,7 +213,7 @@ void Actor_SetScale(Actor* actor, f32 scale) {
 }
 
 void Actor_SetObjectSegment(GlobalContext* ctxt, Actor* actor) {
-    gRspSegmentPhysAddrs[6] = (u32) ctxt->sceneContext.objects[actor->objectIndex].vramAddr + 0x80000000;
+    gRspSegmentPhysAddrs[6] = (u32) ctxt->sceneContext.objects[actor->objBankIndex].vramAddr + 0x80000000;
 }
 
 #ifdef NON_MATCHING
@@ -221,11 +221,11 @@ void Actor_InitToDefaultValues(Actor* actor, GlobalContext* ctxt) {
     Actor_InitCurrPosition(actor);
     Actor_InitDrawRotation(actor);
     Actor_SetHeight(actor, 0);
-    Lib_CopyVec3f(&actor->lastPos, &actor->currPosRot.pos);
+    Math_Vec3f_Copy(&actor->lastPos, &actor->currPosRot.pos);
     Actor_SetScale(actor, 0.01);
     actor->unk1F = 3;
     actor->minYVelocity = -20.0f;
-    
+
     actor->meshAttachedTo = 0x32;
 
     actor->sqrdDistToLink = D_801DCA54;
@@ -236,8 +236,8 @@ void Actor_InitToDefaultValues(Actor* actor, GlobalContext* ctxt) {
 
     actor->naviMsgId = 255;
 
-    Actor_SetDrawParams(&actor->drawParams, 0, 0, 0);
-    if (Scene_IsObjectLoaded(&ctxt->sceneContext, actor->objectIndex) != 0) {
+    Actor_Setshape(&actor->shape, 0, 0, 0);
+    if (Scene_IsObjectLoaded(&ctxt->sceneContext, actor->objBankIndex) != 0) {
         Actor_SetObjectSegment(ctxt, actor);
         actor->init(actor, ctxt);
         actor->init = NULL;
@@ -249,9 +249,9 @@ GLOBAL_ASM("asm/non_matchings/z_actor//Actor_InitToDefaultValues.asm")
 
 void Actor_FiniActor(Actor* actor, GlobalContext* ctxt) {
     if (actor->init == NULL) {
-        if (actor->fini != NULL) {
-            actor->fini(actor, ctxt);
-            actor->fini = NULL;
+        if (actor->destroy != NULL) {
+            actor->destroy(actor, ctxt);
+            actor->destroy = NULL;
         }
     }
 }
@@ -272,9 +272,9 @@ GLOBAL_ASM("asm/non_matchings/z_actor//Actor_ApplyMovement.asm")
 
 #ifdef NON_MATCHING
 void Actor_SetVelocityYRotationAndGravity(Actor* actor) {
-    actor->velocity.x = actor->speed * Lib_sin(actor->currPosRot.rot.x);
+    actor->velocity.x = actor->speedXZ * Math_Sins(actor->currPosRot.rot.x);
     actor->velocity.y = actor->velocity.y + actor->gravity;
-    actor->velocity.z = actor->speed * Lib_cos(actor->currPosRot.rot.x);
+    actor->velocity.z = actor->speedXZ * Math_Coss(actor->currPosRot.rot.x);
 
     if (actor->velocity.y < actor->minYVelocity) {
         actor->velocity.y = actor->minYVelocity;
@@ -290,10 +290,10 @@ void Actor_SetVelocityAndMoveYRotationAndGravity(Actor* actor) {
 }
 
 void Actor_SetVelocityXYRotation(Actor* actor) {
-    f32 velX =  Lib_cos(actor->currPosRot.rot.x) * actor->speed;
-    actor->velocity.x = Lib_sin(actor->currPosRot.rot.y) * velX;
-    actor->velocity.y = Lib_sin(actor->currPosRot.rot.x) * actor->speed;
-    actor->velocity.z = Lib_cos(actor->currPosRot.rot.y) * velX;
+    f32 velX =  Math_Coss(actor->currPosRot.rot.x) * actor->speedXZ;
+    actor->velocity.x = Math_Sins(actor->currPosRot.rot.y) * velX;
+    actor->velocity.y = Math_Sins(actor->currPosRot.rot.x) * actor->speedXZ;
+    actor->velocity.z = Math_Coss(actor->currPosRot.rot.y) * velX;
 }
 
 void Actor_SetVelocityAndMoveXYRotation(Actor* actor) {
@@ -302,10 +302,10 @@ void Actor_SetVelocityAndMoveXYRotation(Actor* actor) {
 }
 
 void Actor_SetVelocityXYRotationReverse(Actor* actor) {
-    f32 velX =  Lib_cos(-actor->currPosRot.rot.x) * actor->speed;
-    actor->velocity.x = Lib_sin(actor->currPosRot.rot.y) * velX;
-    actor->velocity.y = Lib_sin(-actor->currPosRot.rot.x) * actor->speed;
-    actor->velocity.z = Lib_cos(actor->currPosRot.rot.y) * velX;
+    f32 velX =  Math_Coss(-actor->currPosRot.rot.x) * actor->speedXZ;
+    actor->velocity.x = Math_Sins(actor->currPosRot.rot.y) * velX;
+    actor->velocity.y = Math_Sins(-actor->currPosRot.rot.x) * actor->speedXZ;
+    actor->velocity.z = Math_Coss(actor->currPosRot.rot.y) * velX;
 }
 
 void Actor_SetVelocityAndMoveXYRotationReverse(Actor* actor) {
@@ -318,52 +318,52 @@ GLOBAL_ASM("asm/non_matchings/z_actor//func_800B6C04.asm")
 GLOBAL_ASM("asm/non_matchings/z_actor//func_800B6C58.asm")
 
 s16 Actor_YawBetweenActors(Actor* from, Actor* to) {
-    return Lib_YawVec3f(&from->currPosRot.pos, &to->currPosRot.pos);
+    return Math_Vec3f_Yaw(&from->currPosRot.pos, &to->currPosRot.pos);
 }
 
 s16 Actor_YawBetweenActorsTop(Actor* from, Actor* to) {
-    return Lib_YawVec3f(&from->topPosRot.pos, &to->topPosRot.pos);
+    return Math_Vec3f_Yaw(&from->topPosRot.pos, &to->topPosRot.pos);
 }
 
-s16 Actor_YawToPoint(Actor* actor, Vector3f* point) {
-    return Lib_YawVec3f(&actor->currPosRot.pos, point);
+s16 Actor_YawToPoint(Actor* actor, Vec3f* point) {
+    return Math_Vec3f_Yaw(&actor->currPosRot.pos, point);
 }
 
 s16 Actor_PitchBetweenActors(Actor* from, Actor* to) {
-    return Lib_PitchVec3f(&from->currPosRot.pos, &to->currPosRot.pos);
+    return Math_Vec3f_Pitch(&from->currPosRot.pos, &to->currPosRot.pos);
 }
 
 s16 Actor_PitchBetweenActorsTop(Actor* from, Actor* to) {
-    return Lib_PitchVec3f(&from->topPosRot.pos, &to->topPosRot.pos);
+    return Math_Vec3f_Pitch(&from->topPosRot.pos, &to->topPosRot.pos);
 }
 
-s16 Actor_PitchToPoint(Actor* actor, Vector3f* point) {
-    return Lib_PitchVec3f(&actor->currPosRot.pos, point);
+s16 Actor_PitchToPoint(Actor* actor, Vec3f* point) {
+    return Math_Vec3f_Pitch(&actor->currPosRot.pos, point);
 }
 
 f32 Actor_DistanceBetweenActors(Actor* actor1, Actor* actor2) {
-    return Lib_DistanceVec3f(&actor1->currPosRot.pos, &actor2->currPosRot.pos);
+    return Math_Vec3f_DistXYZ(&actor1->currPosRot.pos, &actor2->currPosRot.pos);
 }
 
-f32 Actor_DistanceToPoint(Actor* actor, Vector3f* point) {
-    return Lib_DistanceVec3f(&actor->currPosRot.pos, point);
+f32 Actor_DistanceToPoint(Actor* actor, Vec3f* point) {
+    return Math_Vec3f_DistXYZ(&actor->currPosRot.pos, point);
 }
 
 f32 Actor_XZDistanceBetweenActors(Actor* actor1, Actor* actor2) {
-    return Lib_DistanceXZVec3f(&actor1->currPosRot.pos, &actor2->currPosRot.pos);
+    return Math_Vec3f_DistXZ(&actor1->currPosRot.pos, &actor2->currPosRot.pos);
 }
 
-f32 Actor_XZDistanceToPoint(Actor* actor, Vector3f* point) {
-    return Lib_DistanceXZVec3f(&actor->currPosRot.pos, point);
+f32 Actor_XZDistanceToPoint(Actor* actor, Vec3f* point) {
+    return Math_Vec3f_DistXZ(&actor->currPosRot.pos, point);
 }
 
 #ifdef NON_MATCHING
-void Actor_CalcOffsetOrientedToDrawRotation(Actor* actor, Vector3f* offset, Vector3f* point) {
+void Actor_CalcOffsetOrientedToDrawRotation(Actor* actor, Vec3f* offset, Vec3f* point) {
     f32 cos_rot_x;
     f32 sin_rot_x;
 
-    cos_rot_x = Lib_cos(actor->drawParams.rot.x);
-    sin_rot_x = Lib_sin(actor->drawParams.rot.x);
+    cos_rot_x = Math_Coss(actor->shape.rot.x);
+    sin_rot_x = Math_Sins(actor->shape.rot.x);
     offset->x = (point->x - actor->currPosRot.pos.x * cos_rot_x) - (point->z - actor->currPosRot.pos.z * sin_rot_x);
     offset->y = point->y - actor->currPosRot.pos.y;
     offset->z = (point->z - actor->currPosRot.pos.z * cos_rot_x) + (point->x - actor->currPosRot.pos.x * sin_rot_x);
@@ -553,8 +553,8 @@ GLOBAL_ASM("asm/non_matchings/z_actor//Actor_DrawActor.asm")
 GLOBAL_ASM("asm/non_matchings/z_actor//func_800B9D1C.asm")
 
 void Actor_DrawAllSetup(GlobalContext* ctxt) {
-    ctxt->actorContext.undrawnActorCount = 0;
-    ctxt->actorContext.unkB = 0;
+    ctxt->actorCtx.undrawnActorCount = 0;
+    ctxt->actorCtx.unkB = 0;
 }
 
 GLOBAL_ASM("asm/non_matchings/z_actor//Actor_RecordUndrawnActor.asm")
@@ -581,20 +581,20 @@ GLOBAL_ASM("asm/non_matchings/z_actor//Actor_InsertIntoTypeList.asm")
 
 GLOBAL_ASM("asm/non_matchings/z_actor//Actor_RemoveFromTypeList.asm")
 
-void Actor_FreeOverlay(ActorOverlayTableEntry* entry) {
-    u32 ramAddr;
+void Actor_FreeOverlay(ActorOverlay* entry) {
+    void* ramAddr;
 
-    if (entry->clients == 0) {
-        ramAddr = entry->ramAddr;
-        if (ramAddr != 0) {
+    if (entry->nbLoaded == 0) {
+        ramAddr = entry->loadedRamAddr;
+        if (ramAddr != NULL) {
             //Bit 1 - always loaded
-            if ((entry->flags & 2) == 0) {
+            if ((entry->allocType & 2) == 0) {
                 //Bit 0 - don't alloc memory
-                if ((entry->flags & 1) != 0) {
-                    entry->ramAddr = 0;
+                if ((entry->allocType & 1) != 0) {
+                    entry->loadedRamAddr = NULL;
                 } else {
                     zelda_free(ramAddr);
-                    entry->ramAddr = 0;
+                    entry->loadedRamAddr = NULL;
                 }
             }
         }
diff --git a/src/code/z_bgcheck.c b/src/code/z_bgcheck.c
index b1cc1019e..31f90636f 100644
--- a/src/code/z_bgcheck.c
+++ b/src/code/z_bgcheck.c
@@ -32,7 +32,7 @@ void BgCheck_PolygonLinkedListInit(GlobalContext* ctxt, BgPolygonLinkedList* lis
 }
 
 void BgCheck_PolygonLinkedListAlloc(GlobalContext* ctxt, BgPolygonLinkedList* list, u32 numNodes) {
-    list->nodes = (BgPolygonLinkedListNode*)GameStateHeap_AllocFromEndAligned(&ctxt->common.heap, numNodes << 2, 0xfffffffe);
+    list->nodes = (BgPolygonLinkedListNode*)GameStateHeap_AllocFromEndAligned(&ctxt->state.heap, numNodes << 2, 0xfffffffe);
     list->maxNodes = numNodes;
     list->nextFreeNode = 0;
 }
@@ -52,13 +52,13 @@ u16 BgCheck_AllocPolygonLinkedListNode(BgPolygonLinkedList* list) {
     return index;
 }
 
-void BgCheck_CreateVec3fFromVertex(BgVertex* vertex, Vector3f* vector) {
+void BgCheck_CreateVec3fFromVertex(BgVertex* vertex, Vec3f* vector) {
     vector->x = vertex->pos.x;
     vector->y = vertex->pos.y;
     vector->z = vertex->pos.z;
 }
 
-void BgCheck_CreateVertexFromVec3f(BgVertex* vertex, Vector3f* vector) {
+void BgCheck_CreateVertexFromVec3f(BgVertex* vertex, Vec3f* vector) {
     vertex->pos.x = vector->x;
     vertex->pos.y = vector->y;
     vertex->pos.z = vector->z;
diff --git a/src/code/z_eff_footmark.c b/src/code/z_eff_footmark.c
index 22fa62f7d..bb7c83813 100644
--- a/src/code/z_eff_footmark.c
+++ b/src/code/z_eff_footmark.c
@@ -19,7 +19,7 @@ void EffFootmark_Init(GlobalContext* ctxt) {
     }
 }
 
-void EffFootmark_Add(GlobalContext* ctxt, z_Matrix* displayMatrix, Actor* actor, u8 id, Vector3f* location, u16 size, u8 red, u8 green, u8 blue, u16 alpha, u16 alphaChange, u16 fadeoutDelay) {
+void EffFootmark_Add(GlobalContext* ctxt, z_Matrix* displayMatrix, Actor* actor, u8 id, Vec3f* location, u16 size, u8 red, u8 green, u8 blue, u16 alpha, u16 alphaChange, u16 fadeoutDelay) {
     s32 i;
     EffFootmark* footmark;
     EffFootmark* destination = NULL;
@@ -100,22 +100,22 @@ void EffFootmark_Update(GlobalContext* ctxt) {
 void EffFootmark_Draw(GlobalContext* ctxt) {
     EffFootmark* footmark;
     s32 i;
-    GraphicsContext *gCtxt = ctxt->common.gCtxt;
+    GraphicsContext *gfxCtx = ctxt->state.gfxCtx;
 
-    func_8012C448(ctxt->common.gCtxt);
+    func_8012C448(ctxt->state.gfxCtx);
 
-    gSPDisplayList(gCtxt->polyXlu.append++, D_801BC240);
+    gSPDisplayList(gfxCtx->polyXlu.p++, D_801BC240);
 
     for (footmark = ctxt->footmarks, i = 0; i < 100; i++, footmark++) {
         if (footmark->actor != NULL) {
             SysMatrix_SetCurrentState(&footmark->displayMatrix);
             SysMatrix_InsertScale(footmark->size * 0.00390625f * 0.7f, 1, footmark->size * 0.00390625f, 1);
 
-            gSPMatrix(gCtxt->polyXlu.append++, SysMatrix_AppendStateToPolyOpaDisp(ctxt->common.gCtxt), G_MTX_NOPUSH | G_MTX_LOAD);
+            gSPMatrix(gfxCtx->polyXlu.p++, SysMatrix_AppendStateToPolyOpaDisp(ctxt->state.gfxCtx), G_MTX_NOPUSH | G_MTX_LOAD);
 
-            gDPSetPrimColor(gCtxt->polyXlu.append++, 0, 0, footmark->red, footmark->green, footmark->blue, footmark->alpha >> 8);
+            gDPSetPrimColor(gfxCtx->polyXlu.p++, 0, 0, footmark->red, footmark->green, footmark->blue, footmark->alpha >> 8);
 
-            gSPDisplayList(gCtxt->polyXlu.append++, D_801BC288);
+            gSPDisplayList(gfxCtx->polyXlu.p++, D_801BC288);
         }
     }
 }
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index 96e933715..866248de3 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -4,14 +4,14 @@
 void EffectSS_Init(GlobalContext* ctxt, s32 numEntries) {
     u32 i;
     LoadedParticleEntry* iter;
-    ParticleOverlayTableEntry* iter2;
+    ParticleOverlay* iter2;
 
-    EffectSS2Info.data_table = (LoadedParticleEntry*)GameStateHeap_AllocFromEnd(&ctxt->common.heap, numEntries * sizeof(LoadedParticleEntry));
+    EffectSS2Info.data_table = (LoadedParticleEntry*)GameStateHeap_AllocFromEnd(&ctxt->state.heap, numEntries * sizeof(LoadedParticleEntry));
     EffectSS2Info.searchIndex = 0;
     EffectSS2Info.size = numEntries;
 
     for (iter = EffectSS2Info.data_table; iter < EffectSS2Info.data_table + EffectSS2Info.size; iter++) {
-        EffectSS_ResetLoadedParticleEntry(iter);
+        EffectSS_ResetEntry(iter);
     }
 
     for (i = 0, iter2 = particleOverlayTable; i != 0x27; i++) {
@@ -19,10 +19,10 @@ void EffectSS_Init(GlobalContext* ctxt, s32 numEntries) {
     }
 }
 
-void EffectSS_Fini(GlobalContext* ctxt) {
+void EffectSS_Clear(GlobalContext* ctxt) {
     u32 i;
     LoadedParticleEntry* iter;
-    ParticleOverlayTableEntry* iter2;
+    ParticleOverlay* iter2;
     void* addr;
 
     EffectSS2Info.data_table = NULL;
@@ -57,10 +57,10 @@ void EffectSS_Delete(LoadedParticleEntry* a0) {
         func_801A72CC((UNK_PTR)&a0->unk2C);
     }
 
-    EffectSS_ResetLoadedParticleEntry(a0);
+    EffectSS_ResetEntry(a0);
 }
 
-void EffectSS_ResetLoadedParticleEntry(LoadedParticleEntry* particle) {
+void EffectSS_ResetEntry(LoadedParticleEntry* particle) {
     u32 i;
 
     particle->type = 0x27;
@@ -164,7 +164,7 @@ void EffectSS_LoadParticle(GlobalContext* ctxt, u32 type, u32 priority, void* in
     u32 initRet;
     u32 overlaySize;
     ParticleOverlayInfo* overlayInfo;
-    ParticleOverlayTableEntry* entry = &particleOverlayTable[type];
+    ParticleOverlay* entry = &particleOverlayTable[type];
 
     if (EffectSS_FindFreeSpace(priority, &index) != 0) {
         return;
@@ -203,7 +203,7 @@ void EffectSS_LoadParticle(GlobalContext* ctxt, u32 type, u32 priority, void* in
         initRet = (*overlayInfo->init)(ctxt, index, &EffectSS2Info.data_table[index], initData);
 
         if (initRet == 0) {
-            EffectSS_ResetLoadedParticleEntry(&EffectSS2Info.data_table[index]);
+            EffectSS_ResetEntry(&EffectSS2Info.data_table[index]);
         }
     }
 }
@@ -256,9 +256,9 @@ void EffectSS_DrawAllParticles(GlobalContext* ctxt) {
     LightMapper* s0;
     s32 i;
 
-    s0 = Lights_CreateMapper(&ctxt->lightsContext, ctxt->common.gCtxt);
-    Lights_MapLights(s0, ctxt->lightsContext.lightsHead, 0, ctxt);
-    Lights_UploadLights(s0, ctxt->common.gCtxt);
+    s0 = Lights_CreateMapper(&ctxt->lightCtx, ctxt->state.gfxCtx);
+    Lights_MapLights(s0, ctxt->lightCtx.lightsHead, 0, ctxt);
+    Lights_UploadLights(s0, ctxt->state.gfxCtx);
 
     for (i = 0; i < EffectSS2Info.size; i++) {
         if (EffectSS2Info.data_table[i].life > -1) {
diff --git a/src/code/z_kanfont.c b/src/code/z_kanfont.c
index 93a31c097..c8c8621b7 100644
--- a/src/code/z_kanfont.c
+++ b/src/code/z_kanfont.c
@@ -4,13 +4,13 @@
 void Kanfont_Nop800F4F40(GlobalContext* ctxt, UNK_TYPE param_2, UNK_TYPE param_3) {}
 
 void Kanfont_LoadAsciiChar(GlobalContext* ctxt, u8 character, s32 iParm3) {
-    Dmamgr_SendRequestAndWait((u32)ctxt->msgContext.font.unk0[(ctxt->msgContext).unk11EF0] + iParm3,
+    DmaMgr_SendRequest0((u32)ctxt->msgCtx.font.unk0[(ctxt->msgCtx).unk11EF0] + iParm3,
         (u32)&nes_font_static_vrom_start + character * 0x80 - 0x1000,
         0x80);
 }
 
 void Kanfont_LoadMessageBoxEnd(Font* font, u16 type) {
-    Dmamgr_SendRequestAndWait((u32)font->unk7800, type * 0x80 + (u32)&message_static_vrom_start + 0x5000, 0x80);
+    DmaMgr_SendRequest0((u32)font->unk7800, type * 0x80 + (u32)&message_static_vrom_start + 0x5000, 0x80);
 }
 
 void Kanfont_LoadOrderedFont(Font* font) {
@@ -24,7 +24,7 @@ void Kanfont_LoadOrderedFont(Font* font) {
         if (kanfontOrdering[codePointIndex] == 0) {
             loadOffset = 0;
         }
-        Dmamgr_SendRequestAndWait(writeLocation, (u32)&nes_font_static_vrom_start + loadOffset, 0x80);
+        DmaMgr_SendRequest0(writeLocation, (u32)&nes_font_static_vrom_start + loadOffset, 0x80);
         if (kanfontOrdering[codePointIndex] == 140) break;
         codePointIndex++;
     }
diff --git a/src/code/z_lib.c b/src/code/z_lib.c
index 55b040c0b..b30941ae5 100644
--- a/src/code/z_lib.c
+++ b/src/code/z_lib.c
@@ -12,7 +12,7 @@ void* Lib_bcopy(void* dest, void* src, size_t n) {
 }
 
 #ifdef NON_MATCHING
-void* Lib_memset(u8* a0, u32 a1, u32 a2) {
+void* Lib_MemSet(u8* a0, u32 a1, u32 a2) {
     u8* v0;
 
     // XXX: realloc is messed up
@@ -29,14 +29,14 @@ void* Lib_memset(u8* a0, u32 a1, u32 a2) {
     return a0;
 }
 #else
-GLOBAL_ASM("./asm/non_matchings/z_lib/Lib_memset.asm")
+GLOBAL_ASM("./asm/non_matchings/z_lib/Lib_MemSet.asm")
 #endif
 
-f32 Lib_cos(s16 angle) {
+f32 Math_Coss(s16 angle) {
     return coss(angle) * D_801DDA80;
 }
 
-f32 Lib_sin(s16 angle) {
+f32 Math_Sins(s16 angle) {
     return sins(angle) * D_801DDA84;
 }
 
@@ -216,15 +216,15 @@ void func_800FF3A0(void) {
 GLOBAL_ASM("./asm/non_matchings/z_lib/func_800FF3A0.asm")
 #endif
 
-s16 Lib_rand_s(s16 base, s16 range) {
+s16 Math_Rand_S16Offset(s16 base, s16 range) {
     return (s16)(randZeroOne() * range) + base;
 }
 
-s16 Lib_randestride_s(s16 base, s16 stride, s16 range) {
+s16 Math_Rand_S16OffsetStride(s16 base, s16 stride, s16 range) {
     return (s16)(randZeroOne() * range) * stride + base;
 }
 
-void Lib_CopyVec3f(Vector3f* dest, Vector3f* src) {
+void Math_Vec3f_Copy(Vec3f* dest, Vec3f* src) {
     f32 x = src->x;
     f32 y = src->y;
     f32 z = src->z;
@@ -234,7 +234,7 @@ void Lib_CopyVec3f(Vector3f* dest, Vector3f* src) {
     dest->z = z;
 }
 
-void Lib_CopyVec3s(Vector3s* dest, Vector3s* src) {
+void Math_Vec3s_Copy(Vec3s* dest, Vec3s* src) {
     s16 x = src->x;
     s16 y = src->y;
     s16 z = src->z;
@@ -244,7 +244,7 @@ void Lib_CopyVec3s(Vector3s* dest, Vector3s* src) {
     dest->z = z;
 }
 
-void Lib_ToVec3f(Vector3f* dest, Vector3s* src) {
+void Math_Vec3s_ToVec3f(Vec3f* dest, Vec3s* src) {
     f32 x = src->x;
     f32 y = src->y;
     f32 z = src->z;
@@ -254,7 +254,7 @@ void Lib_ToVec3f(Vector3f* dest, Vector3s* src) {
     dest->z = z;
 }
 
-void Lib_ToVec3s(Vector3s* dest, Vector3f* src) {
+void Math_Vec3f_ToVec3s(Vec3s* dest, Vec3f* src) {
     f32 x = src->x;
     f32 y = src->y;
     f32 z = src->z;
@@ -264,56 +264,56 @@ void Lib_ToVec3s(Vector3s* dest, Vector3f* src) {
     dest->z = z;
 }
 
-void Lib_AddVec3f(Vector3f* l, Vector3f* r, Vector3f* dest) {
+void Math_Vec3f_Sum(Vec3f* l, Vec3f* r, Vec3f* dest) {
     dest->x = l->x + r->x;
     dest->y = l->y + r->y;
     dest->z = l->z + r->z;
 }
 
-void Lib_SubVec3f(Vector3f* l, Vector3f* r, Vector3f* dest) {
+void Math_Vec3f_Diff(Vec3f* l, Vec3f* r, Vec3f* dest) {
     dest->x = l->x - r->x;
     dest->y = l->y - r->y;
     dest->z = l->z - r->z;
 }
 
-void Lib_SubVec3sToVec3f(Vector3f* dest, Vector3s* l, Vector3s* r) {
+void Math_Vec3s_DiffToVec3f(Vec3f* dest, Vec3s* l, Vec3s* r) {
     dest->x = l->x - r->x;
     dest->y = l->y - r->y;
     dest->z = l->z - r->z;
 }
 
-void Lib_ScaleInPlaceVec3f(Vector3f* vec, f32 scale) {
+void Math_Vec3f_Scale(Vec3f* vec, f32 scale) {
     vec->x *= scale;
     vec->y *= scale;
     vec->z *= scale;
 }
 
-void Lib_ScaleVec3f(Vector3f* vec, f32 scale, Vector3f* dest) {
+void Math_Vec3f_ScaleAndStore(Vec3f* vec, f32 scale, Vec3f* dest) {
     dest->x = vec->x * scale;
     dest->y = vec->y * scale;
     dest->z = vec->z * scale;
 }
 
-void Lib_LerpVec3f(Vector3f* a, Vector3f* b, f32 t, Vector3f* dest) {
+void Math_Vec3f_Lerp(Vec3f* a, Vec3f* b, f32 t, Vec3f* dest) {
     dest->x = (b->x - a->x) * t + a->x;
     dest->y = (b->y - a->y) * t + a->y;
     dest->z = (b->z - a->z) * t + a->z;
 }
 
-void Lib_AddScaledVec3f(Vector3f* a, Vector3f* b, f32 scale, Vector3f* dest) {
+void Math_Vec3f_SumScaled(Vec3f* a, Vec3f* b, f32 scale, Vec3f* dest) {
     dest->x = b->x * scale + a->x;
     dest->y = b->y * scale + a->y;
     dest->z = b->z * scale + a->z;
 }
 
-void Lib_ModifyRandScaled(Vector3f* orig, f32 scale, Vector3f* dest) {
+void Math_Vec3f_ModifyRand(Vec3f* orig, f32 scale, Vec3f* dest) {
     dest->x = randPlusMinusPoint5Scaled(scale) + orig->x;
     dest->y = randPlusMinusPoint5Scaled(scale) + orig->y;
     dest->z = randPlusMinusPoint5Scaled(scale) + orig->z;
 }
 
-void Lib_ScaledNormalizedDifferenceVec3f(Vector3f* a, Vector3f* b, f32 scale, Vector3f* dest) {
-    f32 f0 = Lib_DistanceAndDifferenceVec3f(a, b, dest);
+void Math_Vec3f_DistXYZAndStoreNormalizedDiff(Vec3f* a, Vec3f* b, f32 scale, Vec3f* dest) {
+    f32 f0 = Math_Vec3f_DistXYZAndStoreDiff(a, b, dest);
     f32 f2;
 
     if (f0 == 0) {
@@ -327,34 +327,34 @@ void Lib_ScaledNormalizedDifferenceVec3f(Vector3f* a, Vector3f* b, f32 scale, Ve
     dest->z *= f2;
 }
 
-f32 Lib_DistanceVec3f(Vector3f* a, Vector3f* b) {
-    Vector3f sp1C;
-    Lib_SubVec3f(b, a, &sp1C);
+f32 Math_Vec3f_DistXYZ(Vec3f* a, Vec3f* b) {
+    Vec3f sp1C;
+    Math_Vec3f_Diff(b, a, &sp1C);
     return sqrtf((sp1C.x * sp1C.x) + (sp1C.y * sp1C.y) + (sp1C.z * sp1C.z));
 }
 
-f32 Lib_DistanceAndDifferenceVec3f(Vector3f* a, Vector3f* b, Vector3f* difference) {
-    Lib_SubVec3f(b, a, difference);
+f32 Math_Vec3f_DistXYZAndStoreDiff(Vec3f* a, Vec3f* b, Vec3f* difference) {
+    Math_Vec3f_Diff(b, a, difference);
     return sqrtf((difference->x * difference->x) + (difference->y * difference->y) + (difference->z * difference->z));
 }
 
-f32 Lib_DistanceXZVec3f(Vector3f* a, Vector3f* b) {
+f32 Math_Vec3f_DistXZ(Vec3f* a, Vec3f* b) {
     f32 dx = b->x - a->x;
     f32 dz = b->z - a->z;
     return sqrtf((dx * dx) + (dz * dz));
 }
 
-f32 Lib_DistanceAndDifferenceXZVec3f(Vector3f* a, Vector3f* b, f32* xDiff, f32* zDiff) {
+f32 Math_Vec3f_DistXZAndStore(Vec3f* a, Vec3f* b, f32* xDiff, f32* zDiff) {
     *xDiff = b->x - a->x;
     *zDiff = b->z - a->z;
     return sqrtf((*xDiff * *xDiff) + (*zDiff * *zDiff));
 }
 
 #ifdef NON_MATCHING
-void Lib_PushAwayXZVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproach) {
+void Math_Vec3f_PushAwayXZ(Vec3f* start, Vec3f* pusher, f32 distanceToApproach) {
     f32 sp24;
     f32 sp20;
-    f32 f0 = Lib_DistanceAndDifferenceXZVec3f(pusher, start, &sp24, &sp20);
+    f32 f0 = Math_Vec3f_DistXZAndStore(pusher, start, &sp24, &sp20);
     f32 f2 = f0 - distanceToApproach;
 
     if ((f0 >= distanceToApproach) && (f2 != 0)) {
@@ -367,63 +367,63 @@ void Lib_PushAwayXZVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproa
     start->z = pusher->z + sp20 * f2;
 }
 #else
-GLOBAL_ASM("./asm/non_matchings/z_lib/Lib_PushAwayXZVec3f.asm")
+GLOBAL_ASM("./asm/non_matchings/z_lib/Math_Vec3f_PushAwayXZ.asm")
 #endif
 
-f32 Lib_DistanceYVec3f(Vector3f* a, Vector3f* b) {
+f32 Math_Vec3f_DiffY(Vec3f* a, Vec3f* b) {
     return b->y - a->y;
 }
 
-s16 Lib_YawVec3f(Vector3f* from, Vector3f* to) {
+s16 Math_Vec3f_Yaw(Vec3f* from, Vec3f* to) {
     f32 f14 = to->x - from->x;
     f32 f12 = to->z - from->z;
     return atans_flip(f12, f14);
 }
 
-s16 Lib_PitchVec3f(Vector3f* from, Vector3f* to) {
-    return atans_flip(Lib_DistanceXZVec3f(from, to), from->y - to->y);
+s16 Math_Vec3f_Pitch(Vec3f* from, Vec3f* to) {
+    return atans_flip(Math_Vec3f_DistXZ(from, to), from->y - to->y);
 }
 
-void Lib_ApplyActorInitVars(Actor* actor, ActorInitVar* init) {
+void Actor_ProcessInitChain(Actor* actor, ActorInitVar* init) {
     do {
         actorInitVarFuncs[init->type]((u8*)actor, init);
     } while ((init++)->cont);
 }
 
-void Lib_ApplyActorInitVarByte1(u8* actor, ActorInitVar* init) {
+void IChain_Apply_u8(u8* actor, ActorInitVar* init) {
     *(u8*)(actor + init->offset) = (u8)(init->value);
 }
 
-void Lib_ApplyActorInitVarByte2(u8* actor, ActorInitVar* init) {
+void IChain_Apply_s8(u8* actor, ActorInitVar* init) {
     *(u8*)(actor + init->offset) = (u8)(init->value);
 }
 
-void Lib_ApplyActorInitVarShort1(u8* actor, ActorInitVar* init) {
+void IChain_Apply_u16(u8* actor, ActorInitVar* init) {
     *(u16*)(actor + init->offset) = (u16)(init->value);
 }
 
-void Lib_ApplyActorInitVarShort2(u8* actor, ActorInitVar* init) {
+void IChain_Apply_s16(u8* actor, ActorInitVar* init) {
     *(u16*)(actor + init->offset) = (u16)(init->value);
 }
 
-void Lib_ApplyActorInitVarWord1(u8* actor, ActorInitVar* init) {
+void IChain_Apply_u32(u8* actor, ActorInitVar* init) {
     *(u32*)(actor + init->offset) = (u32)(init->value);
 }
 
-void Lib_ApplyActorInitVarWord2(u8* actor, ActorInitVar* init) {
+void IChain_Apply_s32(u8* actor, ActorInitVar* init) {
     *(u32*)(actor + init->offset) = (u32)(init->value);
 }
 
-void Lib_ApplyActorInitVarFloat(u8* actor, ActorInitVar* init) {
+void IChain_Apply_f32(u8* actor, ActorInitVar* init) {
     *(f32*)(actor + init->offset) = (f32)(init->value);
 }
 
-void Lib_ApplyActorInitVarFloat1000th(u8* actor, ActorInitVar* init) {
+void IChain_Apply_f32div1000(u8* actor, ActorInitVar* init) {
     *(f32*)(actor + init->offset) = (f32)(init->value) / 1000;
 }
 
-void Lib_ApplyActorInitVarVector3f(u8* actor, ActorInitVar* init) {
-    Vector3f* v0 = (Vector3f*)(actor + init->offset);
+void IChain_Apply_Vec3f(u8* actor, ActorInitVar* init) {
+    Vec3f* v0 = (Vec3f*)(actor + init->offset);
     f32 f0 = (f32)(init->value);
 
     v0->z = f0;
@@ -431,8 +431,8 @@ void Lib_ApplyActorInitVarVector3f(u8* actor, ActorInitVar* init) {
     v0->x = f0;
 }
 
-void Lib_ApplyActorInitVarVector3f1000th(u8* actor, ActorInitVar* init) {
-    Vector3f* v0 = (Vector3f*)(actor + init->offset);
+void IChain_Apply_Vec3fdiv1000(u8* actor, ActorInitVar* init) {
+    Vec3f* v0 = (Vec3f*)(actor + init->offset);
     f32 f0 = (f32)(init->value) / 1000;
 
     v0->z = f0;
@@ -440,8 +440,8 @@ void Lib_ApplyActorInitVarVector3f1000th(u8* actor, ActorInitVar* init) {
     v0->x = f0;
 }
 
-void Lib_ApplyActorInitVarVector3s(u8* actor, ActorInitVar* init) {
-    Vector3s* v0 = (Vector3s*)(actor + init->offset);
+void IChain_Apply_Vec3s(u8* actor, ActorInitVar* init) {
+    Vec3s* v0 = (Vec3s*)(actor + init->offset);
     s16 v1 = (s16)(init->value);
 
     v0->z = v1;
@@ -449,7 +449,7 @@ void Lib_ApplyActorInitVarVector3s(u8* actor, ActorInitVar* init) {
     v0->x = v1;
 }
 
-f32 func_800FFCD8(f32* a0, f32 a1, f32 a2, f32 a3, f32 a4) {
+f32 Math_SmoothScaleMaxMinF(f32* a0, f32 a1, f32 a2, f32 a3, f32 a4) {
     f32 f0;
 
     if (*a0 != a1) {
@@ -489,7 +489,7 @@ f32 func_800FFCD8(f32* a0, f32 a1, f32 a2, f32 a3, f32 a4) {
     return fabsf(a1 - *a0);
 }
 
-void Lib_ScaleMax_f(f32* start, f32 target, f32 scale, f32 maxStep) {
+void Math_SmoothScaleMaxF(f32* start, f32 target, f32 scale, f32 maxStep) {
     f32 f2;
 
     if (*start != target) {
@@ -505,7 +505,7 @@ void Lib_ScaleMax_f(f32* start, f32 target, f32 scale, f32 maxStep) {
     }
 }
 
-void Lib_Scale_f(f32* start, f32 scale, f32 maxStep) {
+void Math_SmoothDownscaleMaxF(f32* start, f32 scale, f32 maxStep) {
   f32 f0 = *start * scale;
 
   if (maxStep < f0) {
@@ -518,14 +518,14 @@ void Lib_Scale_f(f32* start, f32 scale, f32 maxStep) {
 }
 
 #ifdef NON_MATCHING
-s32 Lib_ScaleMaxMin_s(s16* start, s16 target, s16 scale, s16 maxStep, s16 minStep) {
+s32 Math_SmoothScaleMaxMinS(s16* start, s16 target, s16 scale, s16 maxStep, s16 minStep) {
 
 }
 #else
-GLOBAL_ASM("./asm/non_matchings/z_lib/Lib_ScaleMaxMin_s.asm")
+GLOBAL_ASM("./asm/non_matchings/z_lib/Math_SmoothScaleMaxMinS.asm")
 #endif
 
-void Lib_ScaleMax_s(s16* start, s16 target, s16 scale, s16 maxStep) {
+void Math_SmoothScaleMaxS(s16* start, s16 target, s16 scale, s16 maxStep) {
     s16 v0 = target - *start;
     v0 /= scale;
 
@@ -542,7 +542,7 @@ void Lib_ScaleMax_s(s16* start, s16 target, s16 scale, s16 maxStep) {
     *start += v0;
 }
 
-void Lib_CopyColor(ColorRGBA8* dst, ColorRGBA8* src) {
+void Color_RGBA8_Copy(ColorRGBA8* dst, ColorRGBA8* src) {
     dst->red = src->red;
     dst->green = src->green;
     dst->blue = src->blue;
@@ -561,12 +561,12 @@ void func_801000F4(s32 a0, u16 a1) {
     func_8019F1C0(a0, a1);
 }
 
-void Lib_TranslateAndRotateYVec3f(Vector3f* translation, s16 rotation, Vector3f* src, Vector3f* dst) {
+void Lib_TranslateAndRotateYVec3f(Vec3f* translation, s16 rotation, Vec3f* src, Vec3f* dst) {
     f32 sp1C;
     f32 f0;
 
-    sp1C = Lib_cos(rotation);
-    f0 = Lib_sin(rotation);
+    sp1C = Math_Coss(rotation);
+    f0 = Math_Sins(rotation);
     dst->x = translation->x + (src->x * sp1C + src->z * f0);
     dst->y = translation->y + src->y;
     dst->z = translation->z + (src->z * sp1C - src->x * f0);
@@ -583,12 +583,12 @@ void Lib_LerpRGB(RGB* a, RGB* b, f32 t, RGB* dst) {
 GLOBAL_ASM("./asm/non_matchings/z_lib/Lib_LerpRGB.asm")
 #endif
 
-f32 Lib_PushAwayVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproach) {
-    Vector3f sp24;
+f32 Lib_PushAwayVec3f(Vec3f* start, Vec3f* pusher, f32 distanceToApproach) {
+    Vec3f sp24;
     f32 f2;
     f32 f0;
 
-    Lib_SubVec3f(pusher, start, &sp24);
+    Math_Vec3f_Diff(pusher, start, &sp24);
     f0 = Math3D_Length(&sp24);
     if (distanceToApproach < f0) {
         f2 = distanceToApproach / f0;
@@ -597,7 +597,7 @@ f32 Lib_PushAwayVec3f(Vector3f* start, Vector3f* pusher, f32 distanceToApproach)
         start->y = start->y + f2 * sp24.y;
         start->z = start->z + f2 * sp24.z;
     } else {
-        Lib_CopyVec3f(start, pusher);
+        Math_Vec3f_Copy(start, pusher);
         f0 = 0;
     }
 
diff --git a/src/code/z_lights.c b/src/code/z_lights.c
index be530cb36..57bc3b0a8 100644
--- a/src/code/z_lights.c
+++ b/src/code/z_lights.c
@@ -60,18 +60,18 @@ void Lights_UploadLights(LightMapper* mapper, GraphicsContext* gCtxt) {
     Light* l;
     s32 i;
 
-    gSPNumLights(gCtxt->polyOpa.append++, mapper->numLights);
-    gSPNumLights(gCtxt->polyXlu.append++, mapper->numLights);
+    gSPNumLights(gCtxt->polyOpa.p++, mapper->numLights);
+    gSPNumLights(gCtxt->polyXlu.p++, mapper->numLights);
 
     l = &mapper->lights.l[0];
 
     for (i = 0; i < mapper->numLights;) {
-        gSPLight(gCtxt->polyOpa.append++, l, ++i);
-        gSPLight(gCtxt->polyXlu.append++, l++, i);
+        gSPLight(gCtxt->polyOpa.p++, l, ++i);
+        gSPLight(gCtxt->polyXlu.p++, l++, i);
     }
 
-    gSPLight(gCtxt->polyOpa.append++, &mapper->lights.a, ++i);
-    gSPLight(gCtxt->polyXlu.append++, &mapper->lights.a, i);
+    gSPLight(gCtxt->polyOpa.p++, &mapper->lights.a, ++i);
+    gSPLight(gCtxt->polyXlu.p++, &mapper->lights.a, i);
 }
 #else
 GLOBAL_ASM("asm/non_matchings/z_lights/Lights_UploadLights.asm")
@@ -86,7 +86,7 @@ Light* Lights_MapperGetNextFreeSlot(LightMapper* mapper) {
 
 // XXX regalloc, some reorderings
 #ifdef NON_MATCHING
-void Lights_MapPositionalWithReference(LightMapper* mapper, LightInfoPositionalParams* params, Vector3f* pos) {
+void Lights_MapPositionalWithReference(LightMapper* mapper, LightInfoPositionalParams* params, Vec3f* pos) {
     f32 xDiff;
     f32 yDiff;
     f32 zDiff;
@@ -138,8 +138,8 @@ GLOBAL_ASM("asm/non_matchings/z_lights/Lights_MapPositionalWithReference.asm")
 void Lights_MapPositional(LightMapper* mapper, LightInfoPositionalParams* params, GlobalContext* ctxt) {
     Light* light;
     f32 radiusF = params->radius;
-    Vector3f posF;
-    Vector3f adjustedPos;
+    Vec3f posF;
+    Vec3f adjustedPos;
     u32 pad;
     if (radiusF > 0) {
         posF.x = params->posX;
@@ -196,7 +196,7 @@ void Lights_MapDirectional(LightMapper* mapper, LightInfoDirectionalParams* para
     }
 }
 
-void Lights_MapLights(LightMapper* mapper, z_Light* lights, Vector3f* refPos, GlobalContext* ctxt) {
+void Lights_MapLights(LightMapper* mapper, z_Light* lights, Vec3f* refPos, GlobalContext* ctxt) {
     if (lights != NULL) {
         if ((refPos == NULL) && (mapper->enablePosLights == 1)) {
             do {
@@ -318,8 +318,8 @@ LightMapper* func_801026E8(GraphicsContext* gCtxt, u8 ambientRed, u8 ambientGree
     s32 i;
 
     // TODO allocation should be a macro
-    mapper = (LightMapper *)((int)gCtxt->polyOpa.appendEnd - sizeof(LightMapper));
-    gCtxt->polyOpa.appendEnd = (void*)mapper;
+    mapper = (LightMapper *)((int)gCtxt->polyOpa.d - sizeof(LightMapper));
+    gCtxt->polyOpa.d = (void*)mapper;
 
     mapper->lights.a.l.col[0] = mapper->lights.a.l.colc[0] = ambientRed;
     mapper->lights.a.l.col[1] = mapper->lights.a.l.colc[1] = ambientGreen;
@@ -345,8 +345,8 @@ LightMapper* Lights_MapperAllocateAndInit(GraphicsContext* gCtxt, u8 red, u8 gre
     LightMapper* mapper;
 
     // TODO allocation should be a macro
-    mapper = (LightMapper *)((int)gCtxt->polyOpa.appendEnd - sizeof(LightMapper));
-    gCtxt->polyOpa.appendEnd = (void*)mapper;
+    mapper = (LightMapper *)((int)gCtxt->polyOpa.d - sizeof(LightMapper));
+    gCtxt->polyOpa.d = (void*)mapper;
 
     mapper->lights.a.l.col[0] = red;
     mapper->lights.a.l.colc[0] = red;
@@ -365,8 +365,8 @@ LightMapper* Lights_MapperAllocateAndInit(GraphicsContext* gCtxt, u8 red, u8 gre
 void func_80102880(GlobalContext* ctxt) {
     z_Light* light = ctxt->lightsContext.lightsHead;
     LightInfoPositionalParams* params;
-    Vector3f local_14;
-    Vector3f local_20;
+    Vec3f local_14;
+    Vec3f local_20;
     f32 local_24;
     f32 fVar4;
     s32 s2;
@@ -411,7 +411,7 @@ void func_80102A64(GlobalContext* ctxt) {
 
     if (light != NULL) {
         gCtxt = ctxt->common.gCtxt;
-        dl = func_8012C7FC(gCtxt->polyXlu.append);
+        dl = func_8012C7FC(gCtxt->polyXlu.p);
 
         gSPSetOtherMode(dl++, G_SETOTHERMODE_H, 4, 4, 0x00000080); //! This doesn't resolve to any of the macros in gdi.h
 
@@ -440,7 +440,7 @@ void func_80102A64(GlobalContext* ctxt) {
             light = light->next;
         } while (light != NULL);
 
-        gCtxt->polyXlu.append = dl;
+        gCtxt->polyXlu.p = dl;
     }
 }
 #else
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 4499ffa95..1087a02e0 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -9,33 +9,33 @@ void Room_DrawType0Mesh(GlobalContext* ctxt, Room* room, u32 flags) {
     RoomMeshType0* mesh;
     s32 i;
     RoomMeshType0Params* meshParams;
-    GraphicsContext* gCtxt;
+    GraphicsContext* gfxCtx;
     UNK_TYPE4 pad;
 
-    gCtxt = ctxt->common.gCtxt;
+    gfxCtx = ctxt->state.gfxCtx;
     if (flags & 1) {
         func_800BCBF4(&D_801C1D10, ctxt);
-        gSPSegment(gCtxt->polyOpa.append++, 0x03, room->vramAddr);
+        gSPSegment(gfxCtx->polyOpa.p++, 0x03, room->segment);
         func_8012C268(ctxt);
-        gSPMatrix(gCtxt->polyOpa.append++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
+        gSPMatrix(gfxCtx->polyOpa.p++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
     if (flags & 2) {
         func_800BCC68(&D_801C1D10, ctxt);
-        gSPSegment(gCtxt->polyXlu.append++, 0x03, room->vramAddr);
-        func_8012C2DC(ctxt->common.gCtxt);
-        gSPMatrix(gCtxt->polyXlu.append++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
+        gSPSegment(gfxCtx->polyXlu.p++, 0x03, room->segment);
+        func_8012C2DC(ctxt->state.gfxCtx);
+        gSPMatrix(gfxCtx->polyXlu.p++, &D_801D1DE0, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
     mesh = &room->mesh->type0;
     meshParams = (RoomMeshType0Params*)Lib_PtrSegToVirt(mesh->paramsStart);
     for (i = 0; i < mesh->count; i++) {
         if ((flags & 1) && (meshParams->opaqueDl != NULL)) {
-            gSPDisplayList(gCtxt->polyOpa.append++, meshParams->opaqueDl);
+            gSPDisplayList(gfxCtx->polyOpa.p++, meshParams->opaqueDl);
         }
 
         if ((flags & 2) && (meshParams->translucentDl != NULL)) {
-            gSPDisplayList(gCtxt->polyXlu.append++, meshParams->translucentDl);
+            gSPDisplayList(gfxCtx->polyXlu.p++, meshParams->translucentDl);
         }
 
         meshParams++;
@@ -63,8 +63,8 @@ void Room_DrawType1Mesh(GlobalContext* ctxt, Room* room, u32 flags) {
 
 void Room_Init(GlobalContext* ctxt, RoomContext* roomCtxt) {
     s32 i;
-    roomCtxt->currRoom.index = -1;
-    roomCtxt->currRoom.vramAddr = 0;
+    roomCtxt->currRoom.num = -1;
+    roomCtxt->currRoom.segment = NULL;
     roomCtxt->unk78 = 1;
     roomCtxt->unk79 = 0;
     for (i = 0; i < 3; i++) {
@@ -81,16 +81,16 @@ s32 Room_StartRoomTransition(GlobalContext* ctxt, RoomContext* roomCtxt, s32 ind
     // XXX: this should use a branch-likely
     if (roomCtxt->unk31 == 0) {
         roomCtxt->prevRoom = roomCtxt->currRoom;
-        roomCtxt->currRoom.index = index;
-        roomCtxt->currRoom.vramAddr = NULL;
+        roomCtxt->currRoom.num = index;
+        roomCtxt->currRoom.segment = NULL;
         roomCtxt->unk31 = 1;
 
         size = ctxt->roomAddrs[index].vromEnd - ctxt->roomAddrs[index].vromStart;
         roomCtxt->activeRoomVram = ((s32)roomCtxt->roomMemPages[roomCtxt->activeMemPage] - (size + 8) * roomCtxt->activeMemPage + 8) & 0xfffffff0;
 
-        osCreateMesgQueue(&roomCtxt->roomDmaCallback, roomCtxt->roomDmaCallbackMsg, 1);
-        Dmamgr_SendRequest(&roomCtxt->dmaReq, roomCtxt->activeRoomVram, ctxt->roomAddrs[index].vromStart, size,
-                      0, &roomCtxt->roomDmaCallback, NULL);
+        osCreateMesgQueue(&roomCtxt->loadQueue, roomCtxt->loadMsg, 1);
+        DmaMgr_SendRequestImpl(&roomCtxt->dmaRequest, roomCtxt->activeRoomVram, ctxt->roomAddrs[index].vromStart, size,
+                      0, &roomCtxt->loadQueue, NULL);
         roomCtxt->activeMemPage ^= 1;
 
         return 1;
@@ -105,17 +105,17 @@ GLOBAL_ASM("asm/non_matchings/z_room/Room_StartRoomTransition.asm")
 s32 Room_HandleLoadCallbacks(GlobalContext* ctxt, RoomContext* roomCtxt) {
     if (roomCtxt->unk31 == 1)
     {
-        if (!osRecvMesg(&roomCtxt->roomDmaCallback, NULL, OS_MESG_NOBLOCK))
+        if (!osRecvMesg(&roomCtxt->loadQueue, NULL, OS_MESG_NOBLOCK))
         {
             roomCtxt->unk31 = 0;
-            roomCtxt->currRoom.vramAddr = (void*)(roomCtxt->activeRoomVram);
+            roomCtxt->currRoom.segment = (void*)(roomCtxt->activeRoomVram);
             gRspSegmentPhysAddrs[3] = roomCtxt->activeRoomVram + 0x80000000;
 
-            Scene_ProcessHeader(ctxt, (SceneCmd*)roomCtxt->currRoom.vramAddr);
-            func_80123140(ctxt, (ActorPlayer*)ctxt->actorContext.actorTypeLists[2].head);
-            Actor_SpawnTransitionActors(ctxt, &ctxt->actorContext);
+            Scene_ProcessHeader(ctxt, (SceneCmd*)roomCtxt->currRoom.segment);
+            func_80123140(ctxt, (ActorPlayer*)ctxt->actorCtx.actorList[2].first);
+            Actor_SpawnTransitionActors(ctxt, &ctxt->actorCtx);
 
-            if (((ctxt->currentScene != 0x13) || (roomCtxt->currRoom.index != 1)) && (ctxt->currentScene != 0x56)) {
+            if (((ctxt->sceneNum != 0x13) || (roomCtxt->currRoom.num != 1)) && (ctxt->sceneNum != 0x56)) {
                 ctxt->kankyoContext.unkC3 = 0xff;
                 ctxt->kankyoContext.unkE0 = 0;
             }
@@ -132,20 +132,20 @@ s32 Room_HandleLoadCallbacks(GlobalContext* ctxt, RoomContext* roomCtxt) {
 }
 
 void Room_Draw(GlobalContext* ctxt, Room* room, u32 flags) {
-    if (room->vramAddr != NULL) {
-        gRspSegmentPhysAddrs[3] = (u32)room->vramAddr + 0x80000000;
-        roomDrawFuncs[room->mesh->type0.type](ctxt,room,flags);
+    if (room->segment != NULL) {
+        gRspSegmentPhysAddrs[3] = (u32)room->segment + 0x80000000;
+        roomDrawFuncs[room->mesh->type0.type](ctxt, room, flags);
     }
     return;
 }
 
 void func_8012EBF8(GlobalContext* ctxt, RoomContext* roomCtxt){
-    roomCtxt->prevRoom.index = -1;
-    roomCtxt->prevRoom.vramAddr = NULL;
-    func_800BA798(ctxt, &ctxt->actorContext);
-    Actor_SpawnTransitionActors(ctxt, &ctxt->actorContext);
-    if (-1 < roomCtxt->currRoom.index) {
-        func_8010A33C(ctxt, roomCtxt->currRoom.index);
+    roomCtxt->prevRoom.num = -1;
+    roomCtxt->prevRoom.segment = NULL;
+    func_800BA798(ctxt, &ctxt->actorCtx);
+    Actor_SpawnTransitionActors(ctxt, &ctxt->actorCtx);
+    if (-1 < roomCtxt->currRoom.num) {
+        func_8010A33C(ctxt, roomCtxt->currRoom.num);
         func_8010A2DC(ctxt);
     }
     func_801A3CD8(ctxt->roomContext.currRoom.unk4);
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index a43adc304..ee25cc4af 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -65,8 +65,8 @@ void Scene_HeaderCommand01(GlobalContext* ctxt, SceneCmd* entry) {
     temp_a2 = ctxt;
     temp_a2->sceneNumActorsToLoad = (u16) entry->base.unk1;
     ctxt = temp_a2;
-    ctxt->sceneActorList = (ActorEntry*)Lib_PtrSegToVirt((void*)entry->base.unk4);
-    ctxt->actorContext.unkC = (u16)0;
+    ctxt->setupActorList = (ActorEntry*)Lib_PtrSegToVirt((void*)entry->base.unk4);
+    ctxt->actorCtx.unkC = (u16)0;
 }
 
 // Scene Command 0x02: Cutscene Camera List
@@ -93,18 +93,18 @@ void Scene_HeaderCommand03(GlobalContext* ctxt, SceneCmd* entry) {
         temp_s0->waterboxes = (BgWaterBox*)Lib_PtrSegToVirt(temp_s0->waterboxes);
     }
 
-    BgCheck_Init(&ctxt->bgCheckContext, ctxt, temp_s0);
+    BgCheck_Init(&ctxt->colCtx, ctxt, temp_s0);
 }
 
 // Scene Command 0x04: Room List
 void Scene_HeaderCommand04(GlobalContext* ctxt, SceneCmd* entry) {
     ctxt->numRooms = (u8) entry->base.unk1;
-    ctxt->roomAddrs = (RoomFileLocation*)Lib_PtrSegToVirt((void*)entry->base.unk4);
+    ctxt->roomList = (RoomFileLocation*)Lib_PtrSegToVirt((void*)entry->base.unk4);
 }
 
 // Scene Command 0x06: Entrance List
 void Scene_HeaderCommand06(GlobalContext* ctxt, SceneCmd* entry) {
-    ctxt->entranceList = (EntranceEntry*)Lib_PtrSegToVirt((void*)entry->base.unk4);
+    ctxt->setupEntranceList = (EntranceEntry*)Lib_PtrSegToVirt((void*)entry->base.unk4);
 }
 
 // Scene Command 0x07: Special Files
@@ -130,7 +130,7 @@ void Scene_HeaderCommand08(GlobalContext* ctxt, SceneCmd* entry) {
     ctxt->roomContext.currRoom.unk3 = entry->base.unk1;
     ctxt->roomContext.currRoom.unk2 = entry->base.unk4 & 0xFF;
     ctxt->roomContext.currRoom.unk5 = (entry->base.unk4 >> 8) & 1;
-    ctxt->msgContext.unk12044 = (entry->base.unk4 >> 0xa) & 1;
+    ctxt->msgCtx.unk12044 = (entry->base.unk4 >> 0xa) & 1;
     ctxt->roomContext.currRoom.enablePosLights = (entry->base.unk4 >> 0xb) & 1;
     ctxt->kankyoContext.unkE2 = (entry->base.unk4 >> 0xc) & 1;
 }
@@ -177,7 +177,7 @@ GLOBAL_ASM("./asm/non_matchings/z_scene/Scene_HeaderCommand18.asm")
 
 // Scene Command 0x17: Cutscene Data
 void Scene_HeaderCommand17(GlobalContext* ctxt, SceneCmd* entry) {
-    ctxt->cutsceneContext.cutsceneCount = (u8)entry->base.unk1;
+    ctxt->csCtx.cutsceneCount = (u8)entry->base.unk1;
     ctxt->cutsceneList = (CutsceneEntry*)Lib_PtrSegToVirt((void*)entry->base.unk4);
 }
 
diff --git a/src/code/z_scene_proc.c b/src/code/z_scene_proc.c
index 9b0f98ddb..bfe3f3860 100644
--- a/src/code/z_scene_proc.c
+++ b/src/code/z_scene_proc.c
@@ -6,14 +6,14 @@ void SceneProc_DrawCurrentSceneAnimatedTextures(GlobalContext* ctxt) {
 }
 
 void SceneProc_DrawSceneConfig0(GlobalContext* ctxt) {
-    GraphicsContext* gCtxt = ctxt->common.gCtxt;
+    GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
 
-    gSPDisplayList(gCtxt->polyOpa.append++, gSceneProcDefaultDl);
-    gSPDisplayList(gCtxt->polyXlu.append++, gSceneProcDefaultDl);
+    gSPDisplayList(gfxCtx->polyOpa.p++, gSceneProcDefaultDl);
+    gSPDisplayList(gfxCtx->polyXlu.p++, gSceneProcDefaultDl);
 }
 
 Gfx* SceneProc_SetTile1Layer(GlobalContext* ctxt, ScrollingTextureParams* params) {
-    return Rcp_GenerateSetTileSizeDl((ctxt->common).gCtxt,
+    return Rcp_GenerateSetTileSizeDl((ctxt->state).gfxCtx,
                                      params->xStep * gSceneProcStep,
                                      -(params->yStep * gSceneProcStep),
                                      params->width,
@@ -24,19 +24,19 @@ void SceneProc_DrawType0Texture(GlobalContext* ctxt, u32 segment, ScrollingTextu
     Gfx* dl = SceneProc_SetTile1Layer(ctxt, params);
 
     {
-        GraphicsContext* gCtxt = ctxt->common.gCtxt;
+        GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
         if (gSceneProcFlags & 1) {
-            gSPSegment(gCtxt->polyOpa.append++, segment, dl);
+            gSPSegment(gfxCtx->polyOpa.p++, segment, dl);
         }
 
         if (gSceneProcFlags & 2) {
-            gSPSegment(gCtxt->polyXlu.append++, segment, dl);
+            gSPSegment(gfxCtx->polyXlu.p++, segment, dl);
         }
     }
 }
 
 Gfx* SceneProc_SetTile2Layers(GlobalContext* ctxt, ScrollingTextureParams* params) {
-    return Rcp_GenerateSetTileSize2Dl((ctxt->common).gCtxt,
+    return Rcp_GenerateSetTileSize2Dl((ctxt->state).gfxCtx,
                                       0,
                                       params[0].xStep * gSceneProcStep,
                                       -(params[0].yStep * gSceneProcStep),
@@ -53,13 +53,13 @@ void SceneProc_DrawType1Texture(GlobalContext* ctxt, u32 segment, ScrollingTextu
     Gfx* dl = SceneProc_SetTile2Layers(ctxt, params);
 
     {
-        GraphicsContext* gCtxt = ctxt->common.gCtxt;
+        GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
         if (gSceneProcFlags & 1) {
-            gSPSegment(gCtxt->polyOpa.append++, segment, dl);
+            gSPSegment(gfxCtx->polyOpa.p++, segment, dl);
         }
 
         if (gSceneProcFlags & 2) {
-            gSPSegment(gCtxt->polyXlu.append++, segment, dl);
+            gSPSegment(gfxCtx->polyXlu.p++, segment, dl);
         }
     }
 }
@@ -67,22 +67,22 @@ void SceneProc_DrawType1Texture(GlobalContext* ctxt, u32 segment, ScrollingTextu
 #ifdef NON_MATCHING
 // Slight ordering differences at the beginning
 void SceneProc_DrawFlashingTexture(GlobalContext* ctxt, u32 segment, FlashingTexturePrimColor* primColor, RGBA8* envColor) {
-    GraphicsContext* gCtxt;
+    GraphicsContext* gfxCtx;
     Gfx* dl;
 
     {
-        Gfx* _g = (Gfx*)ctxt->common.gCtxt->polyOpa.appendEnd - 4;
+        Gfx* _g = (Gfx*)ctxt->state.gfxCtx->polyOpa.d - 4;
         dl = _g;
-        ctxt->common.gCtxt->polyOpa.appendEnd = _g;
+        ctxt->state.gfxCtx->polyOpa.d = _g;
     }
 
-    gCtxt = ctxt->common.gCtxt;
+    gfxCtx = ctxt->state.gfxCtx;
     if (gSceneProcFlags & 1) {
-        gSPSegment(gCtxt->polyOpa.append++, segment, dl);
+        gSPSegment(gfxCtx->polyOpa.p++, segment, dl);
     }
 
     if (gSceneProcFlags & 2) {
-        gSPSegment(gCtxt->polyXlu.append++, segment, dl);
+        gSPSegment(gfxCtx->polyXlu.p++, segment, dl);
     }
 
     gDPSetPrimColor(dl++,
@@ -207,7 +207,7 @@ void SceneProc_DrawType5Texture(GlobalContext* ctxt, u32 segment, CyclingTexture
     u8* offsets;
     Gfx** dls;
     Gfx* dl;
-    GraphicsContext* gCtxt;
+    GraphicsContext* gfxCtx;
     s32 step;
 
     dls = (Gfx**)Lib_PtrSegToVirt(params->textureDls);
@@ -215,13 +215,13 @@ void SceneProc_DrawType5Texture(GlobalContext* ctxt, u32 segment, CyclingTexture
     step = gSceneProcStep % params->cycleLength;
     dl = (Gfx*)Lib_PtrSegToVirt(dls[offsets[step]]);
 
-    gCtxt = ctxt->common.gCtxt;
+    gfxCtx = ctxt->state.gfxCtx;
     if (gSceneProcFlags & 1) {
-        gSPSegment(gCtxt->polyOpa.append++, segment, dl);
+        gSPSegment(gfxCtx->polyOpa.p++, segment, dl);
     }
 
     if (gSceneProcFlags & 2) {
-        gSPSegment(gCtxt->polyXlu.append++, segment, dl);
+        gSPSegment(gfxCtx->polyXlu.p++, segment, dl);
     }
 }
 
@@ -299,37 +299,37 @@ void SceneProc_DrawSceneConfig1(GlobalContext* ctxt) {
 #ifdef NON_MATCHING
 // This function still needs a lot of work
 void SceneProc_DrawSceneConfig3(GlobalContext* ctxt) {
-    GraphicsContext* gCtxt = ctxt->common.gCtxt;
+    GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
     u32 frames = ctxt->unk18840;
 
     if (0);
 
-    gSPSegment(gCtxt->polyXlu.append++, 8,
-               Rcp_GenerateSetTileSizeDl(ctxt->common.gCtxt, 0, frames & 0x3f, 0x100, 0x10));
-    gSPSegment(gCtxt->polyXlu.append++, 9,
-               Rcp_GenerateSetTileSize2Dl(ctxt->common.gCtxt,
+    gSPSegment(gfxCtx->polyXlu.p++, 8,
+               Rcp_GenerateSetTileSizeDl(ctxt->state.gfxCtx, 0, frames & 0x3f, 0x100, 0x10));
+    gSPSegment(gfxCtx->polyXlu.p++, 9,
+               Rcp_GenerateSetTileSize2Dl(ctxt->state.gfxCtx,
                                           0, 0x7F - (frames & 0x7F), frames & 0x7F, 0x20, 0x20,
                                           1, frames & 0x7F, frames & 0x7F, 0x20, 0x20));
-    gSPSegment(gCtxt->polyOpa.append++, 10,
-               Rcp_GenerateSetTileSize2Dl(ctxt->common.gCtxt,
+    gSPSegment(gfxCtx->polyOpa.p++, 10,
+               Rcp_GenerateSetTileSize2Dl(ctxt->state.gfxCtx,
                                           0, 0, 0, 0x20, 0x20,
                                           1, 0, 0x7F - (frames & 0x7F), 0x20, 0x20));
-    gSPSegment(gCtxt->polyOpa.append++, 11,
-               Rcp_GenerateSetTileSizeDl(ctxt->common.gCtxt, 0, frames & 0x7F, 0x20, 0x20));
-    gSPSegment(gCtxt->polyXlu.append++, 12,
-               Rcp_GenerateSetTileSize2Dl(ctxt->common.gCtxt,
+    gSPSegment(gfxCtx->polyOpa.p++, 11,
+               Rcp_GenerateSetTileSizeDl(ctxt->state.gfxCtx, 0, frames & 0x7F, 0x20, 0x20));
+    gSPSegment(gfxCtx->polyXlu.p++, 12,
+               Rcp_GenerateSetTileSize2Dl(ctxt->state.gfxCtx,
                                           0, 0, frames * 0x32 & 0x7Ff, 8, 0x200,
                                           1, 0, frames * 0x3c & 0x7Ff, 8, 0x200));
-    gSPSegment(gCtxt->polyOpa.append++, 13,
-               Rcp_GenerateSetTileSize2Dl(ctxt->common.gCtxt,
+    gSPSegment(gfxCtx->polyOpa.p++, 13,
+               Rcp_GenerateSetTileSize2Dl(ctxt->state.gfxCtx,
                                           0, 0, 0, 0x20, 0x40,
                                           1, 0, frames & 0x7F, 0x20, 0x20));
 
-    gDPPipeSync(gCtxt->polyXlu.append++);
-    gDPSetEnvColor(gCtxt->polyXlu.append++, 0x80, 0x80, 0x80, 0x80);
+    gDPPipeSync(gfxCtx->polyXlu.p++);
+    gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 
-    gDPPipeSync(gCtxt->polyOpa.append++);
-    gDPSetEnvColor(gCtxt->polyOpa.append++, 0x80, 0x80, 0x80, 0x80);
+    gDPPipeSync(gfxCtx->polyOpa.p++);
+    gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 }
 #else
 GLOBAL_ASM("./asm/non_matchings/z_scene_proc/SceneProc_DrawSceneConfig3.asm")
@@ -337,22 +337,22 @@ GLOBAL_ASM("./asm/non_matchings/z_scene_proc/SceneProc_DrawSceneConfig3.asm")
 
 void SceneProc_DrawSceneConfig4(GlobalContext* ctxt) {
     u32 frames;
-    GraphicsContext* gCtxt = ctxt->common.gCtxt;
+    GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
     u32 frames2;
 
     frames = ctxt->unk18840;
     frames2 = frames * 1;
 
-    gSPSegment(gCtxt->polyXlu.append++, 8,
-               Rcp_GenerateSetTileSize2Dl(ctxt->common.gCtxt,
+    gSPSegment(gfxCtx->polyXlu.p++, 8,
+               Rcp_GenerateSetTileSize2Dl(ctxt->state.gfxCtx,
                                           0, 0x7F - (frames & 0x7F), frames2 & 0x7F, 0x20, 0x20,
                                           1, (frames & 0x7F), frames2 & 0x7F, 0x20, 0x20));
 
-    gDPPipeSync(gCtxt->polyOpa.append++);
-    gDPSetEnvColor(gCtxt->polyOpa.append++, 0x80, 0x80, 0x80, 0x80);
+    gDPPipeSync(gfxCtx->polyOpa.p++);
+    gDPSetEnvColor(gfxCtx->polyOpa.p++, 0x80, 0x80, 0x80, 0x80);
 
-    gDPPipeSync(gCtxt->polyXlu.append++);
-    gDPSetEnvColor(gCtxt->polyXlu.append++, 0x80, 0x80, 0x80, 0x80);
+    gDPPipeSync(gfxCtx->polyXlu.p++);
+    gDPSetEnvColor(gfxCtx->polyXlu.p++, 0x80, 0x80, 0x80, 0x80);
 }
 
 void SceneProc_DrawSceneConfig2(GlobalContext* ctxt){}
@@ -361,13 +361,13 @@ void func_80131DF0(GlobalContext* ctxt, u32 param_2, u32 flags) {
     Gfx* dl = D_801C3C50[param_2];
 
     {
-        GraphicsContext* gCtxt = ctxt->common.gCtxt;
+        GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
         if (flags & 1) {
-            gSPSegment(gCtxt->polyOpa.append++, 12, dl);
+            gSPSegment(gfxCtx->polyOpa.p++, 12, dl);
         }
 
         if (flags & 2) {
-            gSPSegment(gCtxt->polyXlu.append++, 12, dl);
+            gSPSegment(gfxCtx->polyXlu.p++, 12, dl);
         }
     }
 }
@@ -376,13 +376,13 @@ void func_80131E58(GlobalContext* ctxt, u32 param_2, u32 flags) {
     Gfx* dl = D_801C3C80[param_2];
 
     {
-        GraphicsContext* gCtxt = ctxt->common.gCtxt;
+        GraphicsContext* gfxCtx = ctxt->state.gfxCtx;
         if (flags & 1) {
-            gSPSegment(gCtxt->polyOpa.append++, 12, dl);
+            gSPSegment(gfxCtx->polyOpa.p++, 12, dl);
         }
 
         if (flags & 2) {
-            gSPSegment(gCtxt->polyXlu.append++, 12, dl);
+            gSPSegment(gfxCtx->polyXlu.p++, 12, dl);
         }
     }
 }
@@ -390,7 +390,7 @@ void func_80131E58(GlobalContext* ctxt, u32 param_2, u32 flags) {
 void SceneProc_DrawSceneConfig5(GlobalContext* ctxt) {
     u32 dlIndex;
     u32 alpha;
-    GraphicsContext* gCtxt;
+    GraphicsContext* gfxCtx;
 
     if (ctxt->roomContext.unk7A[0] != 0) {
         dlIndex = 1;
@@ -403,7 +403,7 @@ void SceneProc_DrawSceneConfig5(GlobalContext* ctxt) {
     if (alpha == 0) {
         ctxt->roomContext.unk78 = 0;
     } else {
-        gCtxt = ctxt->common.gCtxt;
+        gfxCtx = ctxt->state.gfxCtx;
 
         ctxt->roomContext.unk78 = 1;
 
@@ -411,8 +411,8 @@ void SceneProc_DrawSceneConfig5(GlobalContext* ctxt) {
 
         func_80131DF0(ctxt, dlIndex, 3);
 
-        gDPSetEnvColor(gCtxt->polyOpa.append++, 0xFF, 0xFF, 0xFF, alpha);
-        gDPSetEnvColor(gCtxt->polyXlu.append++, 0xFF, 0xFF, 0xFF, alpha);
+        gDPSetEnvColor(gfxCtx->polyOpa.p++, 0xFF, 0xFF, 0xFF, alpha);
+        gDPSetEnvColor(gfxCtx->polyXlu.p++, 0xFF, 0xFF, 0xFF, alpha);
     }
 }
 
@@ -425,7 +425,7 @@ void SceneProc_DrawSceneConfig6(GlobalContext* ctxt) {
     Gfx* dlHead;
     u32 pad1;
     u32 pad2;
-    GraphicsContext* gCtxt;
+    GraphicsContext* gfxCtx;
     u32 pad3;
     u32 pad4;
     u32 pad5;
@@ -436,20 +436,20 @@ void SceneProc_DrawSceneConfig6(GlobalContext* ctxt) {
         Actor_GetSwitchFlag(ctxt,0x34) &&
         Actor_GetSwitchFlag(ctxt,0x35) &&
         Actor_GetSwitchFlag(ctxt,0x36)) {
-        func_800C3C00(&ctxt->bgCheckContext, 1);
+        func_800C3C00(&ctxt->colCtx, 1);
     } else {
-        func_800C3C14(&ctxt->bgCheckContext, 1);
+        func_800C3C14(&ctxt->colCtx, 1);
     }
 
     {
-        dl = (Gfx*)ctxt->common.gCtxt->polyOpa.appendEnd - 18;
+        dl = (Gfx*)ctxt->state.gfxCtx->polyOpa.d - 18;
         //dl = _g;
-        ctxt->common.gCtxt->polyOpa.appendEnd = dl;
+        ctxt->state.gfxCtx->polyOpa.d = dl;
     }
 
     SceneProc_DrawAllSceneAnimatedTextures(ctxt, ctxt->sceneTextureAnimations);
 
-    gCtxt = ctxt->common.gCtxt;
+    gfxCtx = ctxt->state.gfxCtx;
     dlHead = dl;
     for (i = 0; i < 9; i++, dlHead += 2) {
         u32 lodFrac = 0;
@@ -516,6 +516,6 @@ void SceneProc_DrawSceneConfig6(GlobalContext* ctxt) {
         gDPSetPrimColor(dlHead, 0, lodFrac, 0xFF, 0xFF, 0xFF, 0xFF);
     }
 
-    gSPSegment(gCtxt->polyOpa.append++, 6, dl);
-    gSPSegment(gCtxt->polyXlu.append++, 6, dl);
+    gSPSegment(gfxCtx->polyOpa.p++, 6, dl);
+    gSPSegment(gfxCtx->polyXlu.p++, 6, dl);
 }