Cleanup `VecSph`: Better Distinguish Between "Spherical" vs. "Geographic" Coordinates (#1407)

* begin geo and sph docs

* cleanup

* cleanup

* cleanup struct

* PR suggestions

* spacing

5 files changed, 521 insertions, 513 deletions

diff --git a/src/code/db_camera.c b/src/code/db_camera.c
index a514f92de..1018ba21c 100644
--- a/src/code/db_camera.c
+++ b/src/code/db_camera.c
@@ -96,17 +96,19 @@ static DbCamera* sDbCamPtr;
 static s16 D_8016110C;
 static DbCameraAnim sDbCamAnim;
 
-Vec3f* DbCamera_AddVecSph(Vec3f* out, Vec3f* in, VecSph* sph) {
-    Vec3f ret;
-    Vec3f vec;
+Vec3f* DbCamera_AddVecGeoToVec3f(Vec3f* dest, Vec3f* a, VecGeo* geo) {
+    Vec3f sum;
+    Vec3f b;
 
-    OLib_VecSphGeoToVec3f(&vec, sph);
+    OLib_VecGeoToVec3f(&b, geo);
 
-    ret.x = in->x + vec.x;
-    ret.y = in->y + vec.y;
-    ret.z = in->z + vec.z;
-    *out = ret;
-    return out;
+    sum.x = a->x + b.x;
+    sum.y = a->y + b.y;
+    sum.z = a->z + b.z;
+
+    *dest = sum;
+
+    return dest;
 }
 
 Vec3f* DbCamera_CalcUpFromPitchYawRoll(Vec3f* dest, s16 pitch, s16 yaw, s16 roll) {
@@ -224,25 +226,28 @@ void DbCamera_Vec3SToF2(Vec3s* in, Vec3f* out) {
 }
 
 void func_800B3F94(PosRot* posRot, Vec3f* vec, Vec3s* out) {
-    VecSph sph;
+    VecGeo geo;
     Vec3f tempVec;
-    OLib_Vec3fDiffToVecSphGeo(&sph, &posRot->pos, vec);
-    sph.yaw -= posRot->rot.y;
-    OLib_VecSphGeoToVec3f(&tempVec, &sph);
+
+    OLib_Vec3fDiffToVecGeo(&geo, &posRot->pos, vec);
+    geo.yaw -= posRot->rot.y;
+    OLib_VecGeoToVec3f(&tempVec, &geo);
     DbCamera_Vec3FToS(&tempVec, out);
 }
 
 void func_800B3FF4(PosRot* posRot, Vec3f* vec, Vec3f* out) {
-    VecSph sph;
+    VecGeo geo;
     Vec3f tempVec;
+
     DbCamera_CopyVec3f(vec, &tempVec);
-    OLib_Vec3fToVecSphGeo(&sph, &tempVec);
-    sph.yaw += posRot->rot.y;
-    DbCamera_AddVecSph(out, &posRot->pos, &sph);
+    OLib_Vec3fToVecGeo(&geo, &tempVec);
+    geo.yaw += posRot->rot.y;
+    DbCamera_AddVecGeoToVec3f(out, &posRot->pos, &geo);
 }
 
 void func_800B404C(PosRot* posRot, Vec3s* vec, Vec3f* out) {
     Vec3f tempVec;
+
     DbCamera_Vec3SToF(vec, &tempVec);
     func_800B3FF4(posRot, &tempVec, out);
 }
@@ -318,7 +323,7 @@ s32 func_800B42C0(DbCamera* dbCamera, Camera* cameraPtr) {
 s32 func_800B4370(DbCamera* dbCamera, s16 idx, Camera* cam) {
     CutsceneCameraPoint* lookAt = &dbCamera->sub.lookAt[idx];
     CutsceneCameraPoint* position = &dbCamera->sub.position[idx];
-    VecSph sph;
+    VecGeo geo;
     Vec3f at;
 
     if (dbCamera->sub.mode != 1) {
@@ -335,10 +340,10 @@ s32 func_800B4370(DbCamera* dbCamera, s16 idx, Camera* cam) {
         }
         dbCamera->at = at;
     }
-    sph.pitch = 0x2000;
-    sph.yaw -= 0x7FFF;
-    sph.r = 250.0f;
-    DbCamera_AddVecSph(&dbCamera->eye, &dbCamera->at, &sph);
+    geo.pitch = 0x2000;
+    geo.yaw -= 0x7FFF;
+    geo.r = 250.0f;
+    DbCamera_AddVecGeoToVec3f(&dbCamera->eye, &dbCamera->at, &geo);
     dbCamera->roll = lookAt->cameraRoll;
     dbCamera->rollDegrees = dbCamera->roll * (360.0f / 256.0f);
     dbCamera->fov = lookAt->viewAngle;
@@ -572,9 +577,9 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
     char sp111;
     char sp110;
     f32 temp_f2_2;
-    VecSph sp104;
-    VecSph spFC;
-    VecSph spF4;
+    VecGeo sp104;
+    VecGeo spFC;
+    VecGeo spF4;
     PosRot* temp_s6;
     UNUSED Vec3f* eye;
     UNUSED Vec3f* at;
@@ -588,7 +593,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
     Vec3f spB8;
     Vec3f spAC;
     s16 spAA;
-    VecSph spA0;
+    VecGeo spA0;
 
     sp90 = &dbCamera->unk_54;
     temp_s6 = &cam->playerPosRot;
@@ -671,9 +676,9 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
     phi_s0 = sp124;
 
     if (!D_80161144) {
-        OLib_Vec3fDiffToVecSphGeo(&sp104, sp7C, sp80);
+        OLib_Vec3fDiffToVecGeo(&sp104, sp7C, sp80);
     } else {
-        OLib_Vec3fDiffToVecSphGeo(&sp104, sp80, sp7C);
+        OLib_Vec3fDiffToVecGeo(&sp104, sp80, sp7C);
     }
 
     if (dbCamera->unk_44 > 100) {
@@ -709,11 +714,11 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
             spFC.r = temp_f2;
             if (!D_80161144) {
                 spFC.yaw = sp104.yaw;
-                DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+                DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
             } else {
                 spFC.pitch = -spFC.pitch;
                 spFC.yaw = sp104.yaw - 0x7FFF;
-                DbCamera_AddVecSph(sp80, sp80, &spFC);
+                DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
             }
             if (dbCamera->unk_40 == 0xB) {
                 dbCamera->unk_44++;
@@ -737,11 +742,11 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
             spFC.r = -temp_f2;
             if (!D_80161144) {
                 spFC.yaw = sp104.yaw;
-                DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+                DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
             } else {
                 spFC.pitch = -spFC.pitch;
                 spFC.yaw = sp104.yaw - 0x7FFF;
-                DbCamera_AddVecSph(sp80, sp80, &spFC);
+                DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
             }
             if (dbCamera->unk_40 == 0xC) {
                 dbCamera->unk_44++;
@@ -760,10 +765,10 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = 0;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.yaw = sp104.yaw - 0x7FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
 
         if (dbCamera->unk_40 == 1) {
@@ -778,10 +783,10 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = 0;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.yaw = sp104.yaw - 0x7FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 2) {
             dbCamera->unk_44++;
@@ -795,9 +800,9 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = 0x3FFF;
         spFC.yaw = sp104.yaw;
         if (!D_80161144) {
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 3) {
             dbCamera->unk_44++;
@@ -811,9 +816,9 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = -0x3FFF;
         spFC.yaw = sp104.yaw;
         if (!D_80161144) {
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 4) {
             dbCamera->unk_44++;
@@ -828,10 +833,10 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = 0;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw + 0x3FFF;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.yaw = sp104.yaw - 0x3FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 5) {
             dbCamera->unk_44++;
@@ -846,10 +851,10 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.pitch = 0;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw - 0x3FFF;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.yaw = sp104.yaw + 0x3FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 6) {
             dbCamera->unk_44++;
@@ -873,11 +878,11 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.r = temp_f2;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.pitch = -spFC.pitch;
             spFC.yaw = sp104.yaw - 0x7FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 0xB) {
             dbCamera->unk_44++;
@@ -902,11 +907,11 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         spFC.r = -temp_f2;
         if (!D_80161144) {
             spFC.yaw = sp104.yaw;
-            DbCamera_AddVecSph(sp7C, sp7C, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp7C, &spFC);
         } else {
             spFC.pitch = -spFC.pitch;
             spFC.yaw = sp104.yaw - 0x7FFF;
-            DbCamera_AddVecSph(sp80, sp80, &spFC);
+            DbCamera_AddVecGeoToVec3f(sp80, sp80, &spFC);
         }
         if (dbCamera->unk_40 == 0xC) {
             dbCamera->unk_44++;
@@ -964,18 +969,18 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         if (!D_80161144) {
             sp104.pitch += (s16)((temp_f0_5 >= 0.0f) ? pitch : -pitch);
             sp104.yaw += (s16)((temp_f2_2 >= 0.0f) ? yaw : -yaw);
-            DbCamera_AddVecSph(sp80, sp7C, &sp104);
+            DbCamera_AddVecGeoToVec3f(sp80, sp7C, &sp104);
             dbCamera->sub.unk_104A.x = -sp104.pitch;
             dbCamera->sub.unk_104A.y = sp104.yaw - 0x7FFF;
         } else {
             sp104.pitch += (s16)((temp_f0_5 >= 0.0f) ? -pitch : pitch);
             sp104.yaw += (s16)((temp_f2_2 >= 0.0f) ? -yaw : yaw);
-            DbCamera_AddVecSph(sp7C, sp80, &sp104);
+            DbCamera_AddVecGeoToVec3f(sp7C, sp80, &sp104);
             dbCamera->sub.unk_104A.x = sp104.pitch;
             dbCamera->sub.unk_104A.y = sp104.yaw;
         }
 
-        OLib_Vec3fDiffToVecSphGeo(&spF4, sp80, sp7C);
+        OLib_Vec3fDiffToVecGeo(&spF4, sp80, sp7C);
         DbCamera_CalcUpFromPitchYawRoll(&dbCamera->unk_1C, spF4.pitch, spF4.yaw,
                                         CAM_DEG_TO_BINANG(dbCamera->rollDegrees));
         if (dbCamera->unk_00 == 1) {
@@ -985,7 +990,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
                 cam->at = *sp7C;
                 spFC = sp104;
                 spFC.r = new_var2;
-                DbCamera_AddVecSph(&cam->eye, &cam->at, &spFC);
+                DbCamera_AddVecGeoToVec3f(&cam->eye, &cam->at, &spFC);
             }
         }
     }
@@ -1370,7 +1375,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
                 func_8006376C(0x1E, 0x19, 2, &sp110);
             } else {
                 if (D_8012CEE0[0]) {}
-                OLib_Vec3fDiffToVecSphGeo(&spFC, sp90, sp7C);
+                OLib_Vec3fDiffToVecGeo(&spFC, sp90, sp7C);
                 spFC.yaw -= cam->playerPosRot.rot.y;
                 func_8006376C(3, 0x16,
                               ((dbCamera->sub.unk_08 == 1) && (dbCamera->sub.unk_0A == 4) && !D_80161144) ? 7
@@ -1383,7 +1388,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
                 func_8006376C(3, 0x18, 3, D_8012D0F8);
                 DbCamera_SetTextValue(spFC.r, &D_8012D0D4[7], 6);
                 func_8006376C(3, 0x19, 3, D_8012D0D4);
-                OLib_Vec3fDiffToVecSphGeo(&spFC, sp90, sp80);
+                OLib_Vec3fDiffToVecGeo(&spFC, sp90, sp80);
                 spFC.yaw -= cam->playerPosRot.rot.y;
                 func_8006376C(0x1E, 0x16,
                               ((dbCamera->sub.unk_08 == 1) && (dbCamera->sub.unk_0A == 4) && D_80161144) ? 7
@@ -1413,7 +1418,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
                         func_800B404C(temp_s6, &(dbCamera->sub.lookAt + i)->pos, &spB8);
                         func_800B404C(temp_s6, &(dbCamera->sub.position + i)->pos, &spAC);
                     }
-                    OLib_Vec3fDiffToVecSphGeo(&spFC, &spAC, &spB8);
+                    OLib_Vec3fDiffToVecGeo(&spFC, &spAC, &spB8);
                     spAA = dbCamera->sub.lookAt[i].cameraRoll * 0xB6;
                     if (i == dbCamera->sub.unkIdx) {
                         DebugDisplay_AddObject(spAC.x, spAC.y, spAC.z, spFC.pitch * -1, spFC.yaw, spAA, .5f, .5f, .5f,
@@ -1481,7 +1486,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
         D_8012D110++;
         D_8012D110 %= 50;
 
-        OLib_Vec3fDiffToVecSphGeo(&spA0, &cam->eye, &cam->at);
+        OLib_Vec3fDiffToVecGeo(&spA0, &cam->eye, &cam->at);
         DebugDisplay_AddObject(dbCamera->at.x, dbCamera->at.y + 1.0f, dbCamera->at.z, 0, 0, 0, 0.02f, 2.0f, 0.02f, 0xFF,
                                0xFF, 0x7F, 0x2D, 0, cam->play->view.gfxCtx);
         DebugDisplay_AddObject(dbCamera->at.x, dbCamera->at.y + 1.0f, dbCamera->at.z, 0, 0, 0, 2.0f, 0.02f, 0.02f, 0x7F,
@@ -1492,7 +1497,7 @@ void DbCamera_Update(DbCamera* dbCamera, Camera* cam) {
                                0x7F, 0x7F, 0x80, 5, cam->play->view.gfxCtx);
         DebugDisplay_AddObject(cam->at.x, cam->at.y, cam->at.z, spA0.pitch * -1, spA0.yaw, 0, 1.5f, 2.0f, 1.0f, 0xFF,
                                0x7F, 0x7F, 0x80, 4, cam->play->view.gfxCtx);
-        OLib_Vec3fDiffToVecSphGeo(&spA0, &cam->eyeNext, &cam->at);
+        OLib_Vec3fDiffToVecGeo(&spA0, &cam->eyeNext, &cam->at);
         DebugDisplay_AddObject(cam->eyeNext.x, cam->eyeNext.y, cam->eyeNext.z, spA0.pitch * -1, spA0.yaw, 0, .5f, .5f,
                                .5f, 0xFF, 0xC0, 0x7F, 0x50, 5, cam->play->view.gfxCtx);
     }
@@ -1845,7 +1850,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
     s16 idx3;
     char sp74[(ARRAY_COUNT(sDbCameraCuts) - 1 + 4) * 2];
     DbCameraCut sp64;
-    VecSph sp5C;
+    VecGeo sp5C;
     s32 (*callbacks[])(char*) = { DbCamera_SaveCallback, DbCamera_LoadCallback, DbCamera_ClearCallback };
 
     func_8006376C(0xE, 5, 0, D_8012CF44); // DEMO CONTROL
@@ -2148,7 +2153,7 @@ s32 DbCamera_UpdateDemoControl(DbCamera* dbCamera, Camera* cam) {
                     Audio_PlaySfxGeneral(NA_SE_SY_GET_RUPY, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale,
                                          &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb);
                 }
-                OLib_Vec3fDiffToVecSphGeo(&sp5C, &dbCamera->eye, &dbCamera->at);
+                OLib_Vec3fDiffToVecGeo(&sp5C, &dbCamera->eye, &dbCamera->at);
                 DbCamera_CalcUpFromPitchYawRoll(&dbCamera->unk_1C, sp5C.pitch, sp5C.yaw,
                                                 CAM_DEG_TO_BINANG(dbCamera->rollDegrees));
                 return 2;
diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index 815be7475..8baf648b0 100644
--- a/src/code/z_camera.c
+++ b/src/code/z_camera.c
@@ -183,16 +183,18 @@ Vec3f* Camera_Vec3sToVec3f(Vec3f* dest, Vec3s* src) {
     return dest;
 }
 
-Vec3f* Camera_Vec3fVecSphGeoAdd(Vec3f* dest, Vec3f* a, VecSph* b) {
-    Vec3f copy;
-    Vec3f vecB;
-    OLib_VecSphGeoToVec3f(&vecB, b);
+Vec3f* Camera_AddVecGeoToVec3f(Vec3f* dest, Vec3f* a, VecGeo* geo) {
+    Vec3f sum;
+    Vec3f b;
 
-    copy.x = a->x + vecB.x;
-    copy.y = a->y + vecB.y;
-    copy.z = a->z + vecB.z;
+    OLib_VecGeoToVec3f(&b, geo);
+
+    sum.x = a->x + b.x;
+    sum.y = a->y + b.y;
+    sum.z = a->z + b.z;
+
+    *dest = sum;
 
-    *dest = copy;
     return dest;
 }
 
@@ -218,11 +220,11 @@ s32 Camera_BGCheckInfo(Camera* camera, Vec3f* from, CamColChk* to) {
     f32 floorPolyY;
     CollisionPoly* floorPoly;
     s32 floorBgId;
-    VecSph fromToOffset;
+    VecGeo fromToOffset;
 
-    OLib_Vec3fDiffToVecSphGeo(&fromToOffset, from, &to->pos);
+    OLib_Vec3fDiffToVecGeo(&fromToOffset, from, &to->pos);
     fromToOffset.r += 8.0f;
-    Camera_Vec3fVecSphGeoAdd(&toPoint, from, &fromToOffset);
+    Camera_AddVecGeoToVec3f(&toPoint, from, &fromToOffset);
 
     if (!BgCheck_CameraLineTest1(colCtx, from, &toPoint, &toNewPos, &to->poly, 1, 1, 1, -1, &to->bgId)) {
         // no poly in path.
@@ -282,11 +284,11 @@ s32 func_80043F94(Camera* camera, Vec3f* from, CamColChk* to) {
     f32 floorY;
     CollisionPoly* floorPoly;
     s32 bgId;
-    VecSph fromToGeo;
+    VecGeo fromToGeo;
 
-    OLib_Vec3fDiffToVecSphGeo(&fromToGeo, from, &to->pos);
+    OLib_Vec3fDiffToVecGeo(&fromToGeo, from, &to->pos);
     fromToGeo.r += 8.0f;
-    Camera_Vec3fVecSphGeoAdd(&toPos, from, &fromToGeo);
+    Camera_AddVecGeoToVec3f(&toPos, from, &fromToGeo);
     if (!BgCheck_CameraLineTest1(colCtx, from, &toPos, &toNewPos, &to->poly, 1, 1, 1, -1, &to->bgId)) {
         OLib_Vec3fDistNormalize(&fromToNorm, from, &to->pos);
         to->norm.x = -fromToNorm.x;
@@ -822,7 +824,7 @@ Vec3f* Camera_BGCheckCorner(Vec3f* dst, Vec3f* linePointA, Vec3f* linePointB, Ca
  * 3 ?
  * 6 if the angle between the polys is greater than 120 degrees
  */
-s32 func_80045508(Camera* camera, VecSph* diffSph, CamColChk* eyeChk, CamColChk* atChk, s16 checkEye) {
+s32 func_80045508(Camera* camera, VecGeo* diffGeo, CamColChk* eyeChk, CamColChk* atChk, s16 checkEye) {
     Vec3f* at = &camera->at;
     Vec3f* eye = &camera->eye;
     Vec3f* eyeNext = &camera->eyeNext;
@@ -841,10 +843,10 @@ s32 func_80045508(Camera* camera, VecSph* diffSph, CamColChk* eyeChk, CamColChk*
         // collision found between at->eye
         atChk->pos = camera->at;
 
-        OLib_Vec3fToVecSphGeo(&eyeChk->sphNorm, &eyeChk->norm);
+        OLib_Vec3fToVecGeo(&eyeChk->geoNorm, &eyeChk->norm);
 
-        if (eyeChk->sphNorm.pitch >= 0x2EE1) {
-            eyeChk->sphNorm.yaw = diffSph->yaw;
+        if (eyeChk->geoNorm.pitch >= 0x2EE1) {
+            eyeChk->geoNorm.yaw = diffGeo->yaw;
         }
 
         eyeAtBgId = Camera_BGCheckInfo(camera, eyeNext, atChk);
@@ -871,10 +873,10 @@ s32 func_80045508(Camera* camera, VecSph* diffSph, CamColChk* eyeChk, CamColChk*
             return 3;
         }
 
-        OLib_Vec3fToVecSphGeo(&atChk->sphNorm, &atChk->norm);
+        OLib_Vec3fToVecGeo(&atChk->geoNorm, &atChk->norm);
 
-        if (atChk->sphNorm.pitch >= 0x2EE1) {
-            atChk->sphNorm.yaw = diffSph->yaw - 0x7FFF;
+        if (atChk->geoNorm.pitch >= 0x2EE1) {
+            atChk->geoNorm.yaw = diffGeo->yaw - 0x7FFF;
         }
 
         if (atEyeBgId != eyeAtBgId) {
@@ -899,18 +901,18 @@ s32 func_80045508(Camera* camera, VecSph* diffSph, CamColChk* eyeChk, CamColChk*
  */
 f32 Camera_CalcSlopeYAdj(Vec3f* floorNorm, s16 playerYRot, s16 eyeAtYaw, f32 adjAmt) {
     f32 tmp;
-    VecSph floorNormSph;
+    VecGeo floorNormGeo;
 
-    OLib_Vec3fToVecSphGeo(&floorNormSph, floorNorm);
+    OLib_Vec3fToVecGeo(&floorNormGeo, floorNorm);
 
-    tmp = Math_CosS(floorNormSph.pitch) * Math_CosS(playerYRot - floorNormSph.yaw);
+    tmp = Math_CosS(floorNormGeo.pitch) * Math_CosS(playerYRot - floorNormGeo.yaw);
     return (fabsf(tmp) * adjAmt) * Math_CosS(playerYRot - eyeAtYaw);
 }
 
 /**
  * Calculates new at vector for the camera pointing in `eyeAtDir`
  */
-s32 Camera_CalcAtDefault(Camera* camera, VecSph* eyeAtDir, f32 extraYOffset, s16 calcSlope) {
+s32 Camera_CalcAtDefault(Camera* camera, VecGeo* eyeAtDir, f32 extraYOffset, s16 calcSlope) {
     Vec3f* at = &camera->at;
     Vec3f posOffsetTarget;
     Vec3f atTarget;
@@ -941,7 +943,7 @@ s32 Camera_CalcAtDefault(Camera* camera, VecSph* eyeAtDir, f32 extraYOffset, s16
     return true;
 }
 
-s32 func_800458D4(Camera* camera, VecSph* eyeAtDir, f32 arg2, f32* arg3, s16 arg4) {
+s32 func_800458D4(Camera* camera, VecGeo* eyeAtDir, f32 arg2, f32* arg3, s16 arg4) {
     f32 phi_f2;
     Vec3f posOffsetTarget;
     Vec3f atTarget;
@@ -983,7 +985,7 @@ s32 func_800458D4(Camera* camera, VecSph* eyeAtDir, f32 arg2, f32* arg3, s16 arg
     return 1;
 }
 
-s32 func_80045B08(Camera* camera, VecSph* eyeAtDir, f32 yExtra, s16 arg3) {
+s32 func_80045B08(Camera* camera, VecGeo* eyeAtDir, f32 yExtra, s16 arg3) {
     f32 phi_f2;
     Vec3f posOffsetTarget;
     Vec3f atTarget;
@@ -1018,7 +1020,7 @@ s32 func_80045B08(Camera* camera, VecSph* eyeAtDir, f32 yExtra, s16 arg3) {
 /**
  * Adjusts the camera's at position for Camera_Parallel1
  */
-s32 Camera_CalcAtForParallel(Camera* camera, VecSph* arg1, f32 yOffset, f32* arg3, s16 arg4) {
+s32 Camera_CalcAtForParallel(Camera* camera, VecGeo* arg1, f32 yOffset, f32* arg3, s16 arg4) {
     Vec3f* at = &camera->at;
     Vec3f posOffsetTarget;
     Vec3f atTarget;
@@ -1088,14 +1090,14 @@ s32 Camera_CalcAtForParallel(Camera* camera, VecSph* arg1, f32 yOffset, f32* arg
 /**
  * Adjusts at position for Camera_Battle1 and Camera_KeepOn1
  */
-s32 Camera_CalcAtForLockOn(Camera* camera, VecSph* eyeAtDir, Vec3f* targetPos, f32 yOffset, f32 distance,
-                           f32* yPosOffset, VecSph* outPlayerToTargetDir, s16 flags) {
+s32 Camera_CalcAtForLockOn(Camera* camera, VecGeo* eyeAtDir, Vec3f* targetPos, f32 yOffset, f32 distance,
+                           f32* yPosOffset, VecGeo* outPlayerToTargetDir, s16 flags) {
     Vec3f* at = &camera->at;
     Vec3f tmpPos0;
     Vec3f tmpPos1;
     Vec3f lookFromOffset;
     Vec3f* floorNorm = &camera->floorNorm;
-    VecSph playerToTargetDir;
+    VecGeo playerToTargetDir;
     PosRot* playerPosRot = &camera->playerPosRot;
     f32 yPosDelta;
     f32 phi_f16;
@@ -1114,7 +1116,7 @@ s32 Camera_CalcAtForLockOn(Camera* camera, VecSph* eyeAtDir, Vec3f* targetPos, f
     // tmpPos1 is player's head
     tmpPos1 = playerPosRot->pos;
     tmpPos1.y += playerHeight;
-    OLib_Vec3fDiffToVecSphGeo(outPlayerToTargetDir, &tmpPos1, targetPos);
+    OLib_Vec3fDiffToVecGeo(outPlayerToTargetDir, &tmpPos1, targetPos);
     playerToTargetDir = *outPlayerToTargetDir;
     if (distance < playerToTargetDir.r) {
         playerToTargetDir.r = playerToTargetDir.r * CAM_DATA_SCALED(OREG(38));
@@ -1132,7 +1134,7 @@ s32 Camera_CalcAtForLockOn(Camera* camera, VecSph* eyeAtDir, Vec3f* targetPos, f
         camera->xzOffsetUpdateRate = camera->yOffsetUpdateRate = .01f;
     }
 
-    OLib_VecSphGeoToVec3f(&lookFromOffset, &playerToTargetDir);
+    OLib_VecGeoToVec3f(&lookFromOffset, &playerToTargetDir);
 
     if (PREG(89)) {
         osSyncPrintf("%f (%f %f %f) %f\n", playerToTargetDir.r / distance, lookFromOffset.x, lookFromOffset.y,
@@ -1190,7 +1192,7 @@ s32 Camera_CalcAtForLockOn(Camera* camera, VecSph* eyeAtDir, Vec3f* targetPos, f
     return 1;
 }
 
-s32 Camera_CalcAtForHorse(Camera* camera, VecSph* eyeAtDir, f32 yOffset, f32* yPosOffset, s16 calcSlope) {
+s32 Camera_CalcAtForHorse(Camera* camera, VecGeo* eyeAtDir, f32 yOffset, f32* yPosOffset, s16 calcSlope) {
     Vec3f* at = &camera->at;
     Vec3f posOffsetTarget;
     Vec3f atTarget;
@@ -1326,7 +1328,7 @@ s16 Camera_CalcDefaultYaw(Camera* camera, s16 cur, s16 target, f32 arg3, f32 acc
     return cur + (s16)(angDelta * velocity * velFactor * yawUpdRate);
 }
 
-void func_80046E20(Camera* camera, VecSph* eyeAdjustment, f32 minDist, f32 arg3, f32* arg4, SwingAnimation* anim) {
+void func_80046E20(Camera* camera, VecGeo* eyeAdjustment, f32 minDist, f32 arg3, f32* arg4, SwingAnimation* anim) {
     static CamColChk atEyeColChk;
     static CamColChk eyeAtColChk;
     static CamColChk newEyeColChk;
@@ -1336,8 +1338,8 @@ void func_80046E20(Camera* camera, VecSph* eyeAdjustment, f32 minDist, f32 arg3,
     Vec3f peekAroundPoint;
     Vec3f* eyeNext = &camera->eyeNext;
     f32 temp_f0;
-    VecSph newEyeAdjustment;
-    VecSph sp40;
+    VecGeo newEyeAdjustment;
+    VecGeo sp40;
 
     temp_v0 = func_80045508(camera, eyeAdjustment, &atEyeColChk, &eyeAtColChk, !anim->unk_18);
 
@@ -1356,17 +1358,17 @@ void func_80046E20(Camera* camera, VecSph* eyeAdjustment, f32 minDist, f32 arg3,
             anim->swingUpdateRate = CAM_DATA_SCALED(OREG(10));
             anim->unk_18 = 1;
             anim->atEyePoly = eyeAtColChk.poly;
-            OLib_Vec3fDiffToVecSphGeo(&newEyeAdjustment, at, &peekAroundPoint);
+            OLib_Vec3fDiffToVecGeo(&newEyeAdjustment, at, &peekAroundPoint);
 
             newEyeAdjustment.r = eyeAdjustment->r;
-            Camera_Vec3fVecSphGeoAdd(eye, at, &newEyeAdjustment);
+            Camera_AddVecGeoToVec3f(eye, at, &newEyeAdjustment);
             newEyeColChk.pos = *eye;
             if (Camera_BGCheckInfo(camera, at, &newEyeColChk) == 0) {
                 // no collision found between at->newEyePos
                 newEyeAdjustment.yaw += (s16)(eyeAdjustment->yaw - newEyeAdjustment.yaw) >> 1;
                 newEyeAdjustment.pitch += (s16)(eyeAdjustment->pitch - newEyeAdjustment.pitch) >> 1;
-                Camera_Vec3fVecSphGeoAdd(eye, at, &newEyeAdjustment);
-                if (atEyeColChk.sphNorm.pitch < 0x2AA8) {
+                Camera_AddVecGeoToVec3f(eye, at, &newEyeAdjustment);
+                if (atEyeColChk.geoNorm.pitch < 0x2AA8) {
                     // ~ 60 degrees
                     anim->unk_16 = newEyeAdjustment.yaw;
                     anim->unk_14 = newEyeAdjustment.pitch;
@@ -1377,9 +1379,9 @@ void func_80046E20(Camera* camera, VecSph* eyeAdjustment, f32 minDist, f32 arg3,
                 peekAroundPoint.x = anim->collisionClosePoint.x - (atEyeColChk.norm.x + eyeAtColChk.norm.x);
                 peekAroundPoint.y = anim->collisionClosePoint.y - (atEyeColChk.norm.y + eyeAtColChk.norm.y);
                 peekAroundPoint.z = anim->collisionClosePoint.z - (atEyeColChk.norm.z + eyeAtColChk.norm.z);
-                OLib_Vec3fDiffToVecSphGeo(&newEyeAdjustment, at, &peekAroundPoint);
+                OLib_Vec3fDiffToVecGeo(&newEyeAdjustment, at, &peekAroundPoint);
                 newEyeAdjustment.r = eyeAdjustment->r;
-                Camera_Vec3fVecSphGeoAdd(eyeNext, at, &newEyeAdjustment);
+                Camera_AddVecGeoToVec3f(eyeNext, at, &newEyeAdjustment);
                 break;
             }
 
@@ -1403,9 +1405,9 @@ void func_80046E20(Camera* camera, VecSph* eyeAdjustment, f32 minDist, f32 arg3,
             anim->atEyePoly = NULL;
             if (temp_f0 < OREG(21)) {
                 sp40.yaw = eyeAdjustment->yaw;
-                sp40.pitch = Math_SinS(atEyeColChk.sphNorm.pitch + 0x3FFF) * 16380.0f;
+                sp40.pitch = Math_SinS(atEyeColChk.geoNorm.pitch + 0x3FFF) * 16380.0f;
                 sp40.r = (OREG(21) - temp_f0) * CAM_DATA_SCALED(OREG(22));
-                Camera_Vec3fVecSphGeoAdd(eye, eye, &sp40);
+                Camera_AddVecGeoToVec3f(eye, eye, &sp40);
             }
             break;
         default:
@@ -1438,9 +1440,9 @@ s32 Camera_Normal1(Camera* camera) {
     Vec3f sp88;
     s16 wiggleAdj;
     s16 t;
-    VecSph eyeAdjustment;
-    VecSph atEyeGeo;
-    VecSph atEyeNextGeo;
+    VecGeo eyeAdjustment;
+    VecGeo atEyeGeo;
+    VecGeo atEyeNextGeo;
     PosRot* playerPosRot = &camera->playerPosRot;
     Normal1ReadOnlyData* roData = &camera->paramData.norm1.roData;
     Normal1ReadWriteData* rwData = &camera->paramData.norm1.rwData;
@@ -1473,8 +1475,8 @@ s32 Camera_Normal1(Camera* camera) {
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
-    OLib_Vec3fDiffToVecSphGeo(&atEyeGeo, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atEyeNextGeo, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atEyeGeo, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atEyeNextGeo, at, eyeNext);
 
     switch (camera->animState) {
         case 20:
@@ -1578,7 +1580,7 @@ s32 Camera_Normal1(Camera* camera) {
         Camera_CalcAtDefault(camera, &atEyeNextGeo, spA0, roData->interfaceFlags & 1);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAdjustment, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeAdjustment, at, eyeNext);
 
     camera->dist = eyeAdjustment.r =
         Camera_ClampDist(camera, eyeAdjustment.r, roData->distMin, roData->distMax, rwData->unk_28);
@@ -1608,7 +1610,7 @@ s32 Camera_Normal1(Camera* camera) {
         eyeAdjustment.pitch = -0x3C8C;
     }
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeAdjustment);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &eyeAdjustment);
     if ((camera->status == CAM_STAT_ACTIVE) && !(roData->interfaceFlags & 0x10)) {
         rwData->swingYawTarget = camera->playerPosRot.rot.y - 0x7FFF;
         if (rwData->startSwingTimer > 0) {
@@ -1636,7 +1638,7 @@ s32 Camera_Normal1(Camera* camera) {
             camera->inputDir.y = atEyeGeo.yaw - 0x7FFF;
             camera->inputDir.z = 0;
         } else {
-            OLib_Vec3fDiffToVecSphGeo(&eyeAdjustment, eye, at);
+            OLib_Vec3fDiffToVecGeo(&eyeAdjustment, eye, at);
             camera->inputDir.x = eyeAdjustment.pitch;
             camera->inputDir.y = eyeAdjustment.yaw;
             camera->inputDir.z = 0;
@@ -1670,11 +1672,11 @@ s32 Camera_Normal2(Camera* camera) {
     s16 phi_a1;
     f32 spA4;
     f32 spA0;
-    VecSph adjSph;
-    VecSph sp90;
-    VecSph sp88;
-    VecSph atToEyeDir;
-    VecSph atToEyeNextDir;
+    VecGeo adjGeo;
+    VecGeo sp90;
+    VecGeo sp88;
+    VecGeo atToEyeDir;
+    VecGeo atToEyeNextDir;
     PosRot* playerPosRot = &camera->playerPosRot;
     Normal2ReadOnlyData* roData = &camera->paramData.norm2.roData;
     Normal2ReadWriteData* rwData = &camera->paramData.norm2.rwData;
@@ -1733,7 +1735,7 @@ s32 Camera_Normal2(Camera* camera) {
                 sp88.pitch = rwData->unk_20;
                 sp88.yaw = rwData->unk_22 + 0x3FFF;
                 sp88.r = 100.0f;
-                OLib_VecSphGeoToVec3f(&rwData->unk_0C, &sp88);
+                OLib_VecGeoToVec3f(&rwData->unk_0C, &sp88);
             }
 
             camera->animState = 1;
@@ -1746,8 +1748,8 @@ s32 Camera_Normal2(Camera* camera) {
             break;
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeDir, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeNextDir, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atToEyeNextDir, at, eyeNext);
 
     camera->speedRatio *= 0.5f;
     spA4 = CAM_DATA_SCALED(OREG(25)) * camera->speedRatio;
@@ -1775,8 +1777,8 @@ s32 Camera_Normal2(Camera* camera) {
 
     rwData->unk_00.y = playerPosRot->pos.y;
 
-    OLib_Vec3fDiffToVecSphGeo(&sp88, &rwData->unk_00, at);
-    OLib_Vec3fDiffToVecSphGeo(&sp90, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&sp88, &rwData->unk_00, at);
+    OLib_Vec3fDiffToVecGeo(&sp90, at, eyeNext);
 
     phi_a1 = (rwData->unk_28 & 2 ? rwData->unk_22 : roData->unk_1C);
     phi_a0 = sp90.yaw - sp88.yaw;
@@ -1784,30 +1786,30 @@ s32 Camera_Normal2(Camera* camera) {
 
         phi_a0 = (phi_a0 < 0 ? -phi_a1 : phi_a1);
         phi_a0 += sp88.yaw;
-        adjSph.yaw =
+        adjGeo.yaw =
             Camera_LERPCeilS(phi_a0, atToEyeDir.yaw, (1.0f / camera->yawUpdateRateInv) * camera->speedRatio, 0xA);
         if (rwData->unk_28 & 1) {
-            adjSph.pitch = Camera_CalcDefaultPitch(camera, atToEyeNextDir.pitch, rwData->unk_20, 0);
+            adjGeo.pitch = Camera_CalcDefaultPitch(camera, atToEyeNextDir.pitch, rwData->unk_20, 0);
         } else {
-            adjSph.pitch = atToEyeDir.pitch;
+            adjGeo.pitch = atToEyeDir.pitch;
         }
     } else {
-        adjSph = sp90;
+        adjGeo = sp90;
     }
 
-    camera->dist = adjSph.r = Camera_ClampDist(camera, sp90.r, roData->unk_04, roData->unk_08, 0);
+    camera->dist = adjGeo.r = Camera_ClampDist(camera, sp90.r, roData->unk_04, roData->unk_08, 0);
 
     if (!(rwData->unk_28 & 1)) {
-        if (adjSph.pitch >= 0xE39) {
-            adjSph.pitch += ((s16)(0xE38 - adjSph.pitch) >> 2);
+        if (adjGeo.pitch >= 0xE39) {
+            adjGeo.pitch += ((s16)(0xE38 - adjGeo.pitch) >> 2);
         }
 
-        if (adjSph.pitch < 0) {
-            adjSph.pitch += ((s16)(-0x38E - adjSph.pitch) >> 2);
+        if (adjGeo.pitch < 0) {
+            adjGeo.pitch += ((s16)(-0x38E - adjGeo.pitch) >> 2);
         }
     }
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &adjSph);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &adjGeo);
 
     if (camera->status == CAM_STAT_ACTIVE) {
         bgChk.pos = *eyeNext;
@@ -1817,9 +1819,9 @@ s32 Camera_Normal2(Camera* camera) {
         } else {
             func_80043F94(camera, at, &bgChk);
             *eye = bgChk.pos;
-            OLib_Vec3fDiffToVecSphGeo(&adjSph, eye, at);
-            camera->inputDir.x = adjSph.pitch;
-            camera->inputDir.y = adjSph.yaw;
+            OLib_Vec3fDiffToVecGeo(&adjGeo, eye, at);
+            camera->inputDir.x = adjGeo.pitch;
+            camera->inputDir.y = adjGeo.yaw;
             camera->inputDir.z = 0;
         }
     }
@@ -1839,9 +1841,9 @@ s32 Camera_Normal3(Camera* camera) {
     f32 sp94;
     f32 sp90;
     f32 sp8C;
-    VecSph sp84;
-    VecSph sp7C;
-    VecSph sp74;
+    VecGeo sp84;
+    VecGeo sp7C;
+    VecGeo sp74;
     PosRot* playerPosRot = &camera->playerPosRot;
     f32 temp_f0;
     f32 temp_f6;
@@ -1870,8 +1872,8 @@ s32 Camera_Normal3(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&sp7C, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&sp74, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&sp7C, at, eye);
+    OLib_Vec3fDiffToVecGeo(&sp74, at, eyeNext);
 
     sUpdateCameraDirection = true;
     sCameraInterfaceFlags = roData->interfaceFlags;
@@ -1926,7 +1928,7 @@ s32 Camera_Normal3(Camera* camera) {
 
     Camera_CalcAtForHorse(camera, &sp74, roData->yOffset, &rwData->unk_20, 1);
     sp90 = (roData->distMax + roData->distMin) * 0.5f;
-    OLib_Vec3fDiffToVecSphGeo(&sp84, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&sp84, at, eyeNext);
     camera->dist = sp84.r = Camera_ClampDist(camera, sp84.r, roData->distMin, roData->distMax, rwData->distTimer);
     if (camera->xzSpeed > 0.001f) {
         sp84.r += (sp90 - sp84.r) * 0.002f;
@@ -1964,7 +1966,7 @@ s32 Camera_Normal3(Camera* camera) {
         rwData->yawTimer--;
     }
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &sp84);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &sp84);
 
     if (camera->status == CAM_STAT_ACTIVE) {
         func_80046E20(camera, &sp84, roData->distMin, roData->yawUpdateSpeed, &sp8C, &rwData->swing);
@@ -1993,9 +1995,9 @@ s32 Camera_Parallel1(Camera* camera) {
     f32 spB8;
     f32 spB4;
     s16 tangle;
-    VecSph spA8;
-    VecSph atToEyeDir;
-    VecSph atToEyeNextDir;
+    VecGeo spA8;
+    VecGeo atToEyeDir;
+    VecGeo atToEyeNextDir;
     PosRot* playerPosRot = &camera->playerPosRot;
     CamColChk sp6C;
     s16 sp6A;
@@ -2029,8 +2031,8 @@ s32 Camera_Parallel1(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeDir, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeNextDir, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atToEyeNextDir, at, eyeNext);
 
     switch (camera->animState) {
         case 0:
@@ -2123,7 +2125,7 @@ s32 Camera_Parallel1(Camera* camera) {
     } else {
         rwData->unk_16 = 0;
         camera->dist = Camera_LERPCeilF(roData->distTarget, camera->dist, 1.0f / camera->rUpdateRateInv, 2.0f);
-        OLib_Vec3fDiffToVecSphGeo(&spA8, at, eyeNext);
+        OLib_Vec3fDiffToVecGeo(&spA8, at, eyeNext);
         spA8.r = camera->dist;
 
         if (roData->interfaceFlags & 0x40) {
@@ -2148,7 +2150,7 @@ s32 Camera_Parallel1(Camera* camera) {
             spA8.pitch = R_CAM_MIN_PITCH_1;
         }
     }
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &spA8);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &spA8);
     if (camera->status == CAM_STAT_ACTIVE) {
         sp6C.pos = *eyeNext;
         if (!camera->play->envCtx.skyboxDisabled || roData->interfaceFlags & 0x10) {
@@ -2157,7 +2159,7 @@ s32 Camera_Parallel1(Camera* camera) {
         } else {
             func_80043F94(camera, at, &sp6C);
             *eye = sp6C.pos;
-            OLib_Vec3fDiffToVecSphGeo(&spA8, eye, at);
+            OLib_Vec3fDiffToVecGeo(&spA8, eye, at);
             camera->inputDir.x = spA8.pitch;
             camera->inputDir.y = spA8.yaw;
             camera->inputDir.z = 0;
@@ -2206,10 +2208,10 @@ s32 Camera_Jump1(Camera* camera) {
     s32 pad2;
     f32 spA4;
     Vec3f newEye;
-    VecSph eyeAtOffset;
-    VecSph eyeNextAtOffset;
-    VecSph eyeDiffSph;
-    VecSph eyeDiffTarget;
+    VecGeo eyeAtOffset;
+    VecGeo eyeNextAtOffset;
+    VecGeo eyeDiffGeo;
+    VecGeo eyeDiffTarget;
     PosRot* playerPosRot = &camera->playerPosRot;
     PosRot playerhead;
     s16 tangle;
@@ -2241,20 +2243,20 @@ s32 Camera_Jump1(Camera* camera) {
     // playerhead never gets used.
     Actor_GetFocus(&playerhead, &camera->player->actor);
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
     if (RELOAD_PARAMS(camera)) {
         rwData->swing.unk_16 = rwData->swing.unk_18 = 0;
         rwData->swing.atEyePoly = NULL;
-        rwData->unk_20.pitch = 0;
-        rwData->unk_20.yaw = 0xC8;
+        rwData->unk_24 = 0;
+        rwData->unk_26 = 200;
         rwData->swing.swingUpdateRateTimer = 0;
         rwData->swing.swingUpdateRate = roData->yawUpateRateTarget;
         rwData->unk_1C = playerPosRot->pos.y - camera->playerPosDelta.y;
-        rwData->unk_20.r = eyeAtOffset.r;
+        rwData->unk_20 = eyeAtOffset.r;
         camera->posOffset.y -= camera->playerPosDelta.y;
         camera->xzOffsetUpdateRate = (1.0f / 10000.0f);
         camera->animState++;
@@ -2282,51 +2284,51 @@ s32 Camera_Jump1(Camera* camera) {
 
     func_800458D4(camera, &eyeNextAtOffset, roData->atYOffset, &rwData->unk_1C, 0);
 
-    eyeDiffSph = eyeAtOffset;
+    eyeDiffGeo = eyeAtOffset;
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeDiffTarget, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeDiffTarget, at, eye);
 
-    eyeDiffSph.r = Camera_LERPCeilF(eyeDiffTarget.r, eyeAtOffset.r, CAM_DATA_SCALED(OREG(29)), 1.0f);
-    eyeDiffSph.pitch = Camera_LERPCeilS(eyeDiffTarget.pitch, eyeAtOffset.pitch, CAM_DATA_SCALED(OREG(29)), 0xA);
+    eyeDiffGeo.r = Camera_LERPCeilF(eyeDiffTarget.r, eyeAtOffset.r, CAM_DATA_SCALED(OREG(29)), 1.0f);
+    eyeDiffGeo.pitch = Camera_LERPCeilS(eyeDiffTarget.pitch, eyeAtOffset.pitch, CAM_DATA_SCALED(OREG(29)), 0xA);
 
     if (rwData->swing.unk_18) {
-        eyeDiffSph.yaw =
+        eyeDiffGeo.yaw =
             Camera_LERPCeilS(rwData->swing.unk_16, eyeNextAtOffset.yaw, 1.0f / camera->yawUpdateRateInv, 0xA);
-        eyeDiffSph.pitch =
+        eyeDiffGeo.pitch =
             Camera_LERPCeilS(rwData->swing.unk_14, eyeNextAtOffset.pitch, 1.0f / camera->yawUpdateRateInv, 0xA);
     } else {
-        eyeDiffSph.yaw =
+        eyeDiffGeo.yaw =
             Camera_CalcDefaultYaw(camera, eyeNextAtOffset.yaw, camera->playerPosRot.rot.y, roData->maxYawUpdate, 0.0f);
     }
 
-    // Clamp the eye->at distance to roData->distMin < eyeDiffSph.r < roData->distMax
-    if (eyeDiffSph.r < roData->distMin) {
-        eyeDiffSph.r = roData->distMin;
-    } else if (eyeDiffSph.r > roData->distMax) {
-        eyeDiffSph.r = roData->distMax;
+    // Clamp the eye->at distance to roData->distMin < eyeDiffGeo.r < roData->distMax
+    if (eyeDiffGeo.r < roData->distMin) {
+        eyeDiffGeo.r = roData->distMin;
+    } else if (eyeDiffGeo.r > roData->distMax) {
+        eyeDiffGeo.r = roData->distMax;
     }
 
     // Clamp the phi rotation at R_CAM_MAX_PITCH AND R_CAM_MIN_PITCH_2
-    if (eyeDiffSph.pitch > R_CAM_MAX_PITCH) {
-        eyeDiffSph.pitch = R_CAM_MAX_PITCH;
-    } else if (eyeDiffSph.pitch < R_CAM_MIN_PITCH_2) {
-        eyeDiffSph.pitch = R_CAM_MIN_PITCH_2;
+    if (eyeDiffGeo.pitch > R_CAM_MAX_PITCH) {
+        eyeDiffGeo.pitch = R_CAM_MAX_PITCH;
+    } else if (eyeDiffGeo.pitch < R_CAM_MIN_PITCH_2) {
+        eyeDiffGeo.pitch = R_CAM_MIN_PITCH_2;
     }
 
-    Camera_Vec3fVecSphGeoAdd(&newEye, at, &eyeDiffSph);
+    Camera_AddVecGeoToVec3f(&newEye, at, &eyeDiffGeo);
     eyeNext->x = newEye.x;
     eyeNext->z = newEye.z;
     eyeNext->y += (newEye.y - eyeNext->y) * CAM_DATA_SCALED(OREG(31));
     if ((camera->status == CAM_STAT_ACTIVE) && !(roData->interfaceFlags & 0x10)) {
-        func_80046E20(camera, &eyeDiffSph, roData->distMin, roData->yawUpateRateTarget, &spA4, &rwData->swing);
+        func_80046E20(camera, &eyeDiffGeo, roData->distMin, roData->yawUpateRateTarget, &spA4, &rwData->swing);
         if (roData->interfaceFlags & 4) {
             camera->inputDir.x = -eyeAtOffset.pitch;
             camera->inputDir.y = eyeAtOffset.yaw - 0x7FFF;
             camera->inputDir.z = 0;
         } else {
-            OLib_Vec3fDiffToVecSphGeo(&eyeDiffSph, eye, at);
-            camera->inputDir.x = eyeDiffSph.pitch;
-            camera->inputDir.y = eyeDiffSph.yaw;
+            OLib_Vec3fDiffToVecGeo(&eyeDiffGeo, eye, at);
+            camera->inputDir.x = eyeDiffGeo.pitch;
+            camera->inputDir.y = eyeDiffGeo.yaw;
             camera->inputDir.z = 0;
         }
         if (rwData->swing.unk_18) {
@@ -2354,10 +2356,10 @@ s32 Camera_Jump2(Camera* camera) {
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f bgChkPos;
     Vec3f floorNorm;
-    VecSph adjAtToEyeDir;
-    VecSph bgChkPara;
-    VecSph atToEyeNextDir;
-    VecSph atToEyeDir;
+    VecGeo adjAtToEyeDir;
+    VecGeo bgChkPara;
+    VecGeo atToEyeNextDir;
+    VecGeo atToEyeDir;
     f32 temp_f14;
     f32 temp_f16;
     f32 sp90;
@@ -2396,8 +2398,8 @@ s32 Camera_Jump2(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeDir, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeNextDir, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atToEyeNextDir, at, eyeNext);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -2444,7 +2446,7 @@ s32 Camera_Jump2(Camera* camera) {
     camera->rUpdateRateInv = OREG(27);
 
     Camera_CalcAtDefault(camera, &atToEyeNextDir, roData->atYOffset, 0);
-    OLib_Vec3fDiffToVecSphGeo(&adjAtToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&adjAtToEyeDir, at, eye);
 
     temp_f16 = roData->minDist;
     sp90 = roData->maxDist + (roData->maxDist * roData->minMaxDistFactor);
@@ -2502,7 +2504,7 @@ s32 Camera_Jump2(Camera* camera) {
         adjAtToEyeDir.pitch = -0x2AF8;
     }
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &adjAtToEyeDir);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &adjAtToEyeDir);
     camBgChk.pos = *eyeNext;
     if (Camera_BGCheckInfo(camera, at, &camBgChk)) {
         // Collision detected between at->eyeNext, Check if collision between
@@ -2511,7 +2513,7 @@ s32 Camera_Jump2(Camera* camera) {
         bgChkPara.r = adjAtToEyeDir.r;
         bgChkPara.pitch = 0;
         bgChkPara.yaw = adjAtToEyeDir.yaw;
-        Camera_Vec3fVecSphGeoAdd(&camBgChk.pos, at, &bgChkPara);
+        Camera_AddVecGeoToVec3f(&camBgChk.pos, at, &bgChkPara);
         if (Camera_BGCheckInfo(camera, at, &camBgChk)) {
             // Collision found between parallel at->eyeNext, set eye position to
             // first collsion point.
@@ -2519,7 +2521,7 @@ s32 Camera_Jump2(Camera* camera) {
         } else {
             // no collision found with the parallel at->eye, animate to be parallel
             adjAtToEyeDir.pitch = Camera_LERPCeilS(0, adjAtToEyeDir.pitch, 0.2f, 0xA);
-            Camera_Vec3fVecSphGeoAdd(eye, at, &adjAtToEyeDir);
+            Camera_AddVecGeoToVec3f(eye, at, &adjAtToEyeDir);
             // useless?
             Camera_BGCheck(camera, at, eye);
         }
@@ -2544,11 +2546,11 @@ s32 Camera_Jump3(Camera* camera) {
     f32 spC0;
     f32 spBC;
     UNUSED Vec3f spB0;
-    VecSph eyeDiffSph;
+    VecGeo eyeDiffGeo;
     PosRot* playerPosRot = &camera->playerPosRot;
     Jump3ReadOnlyData* roData = &camera->paramData.jump3.roData;
-    VecSph eyeAtOffset;
-    VecSph eyeNextAtOffset;
+    VecGeo eyeAtOffset;
+    VecGeo eyeNextAtOffset;
     s32 pad;
     s32 pad2;
     CameraModeValue* values;
@@ -2577,8 +2579,8 @@ s32 Camera_Jump3(Camera* camera) {
         modeSwitch = true;
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
 
     if (RELOAD_PARAMS(camera) || modeSwitch || R_RELOAD_CAM_PARAMS) {
         values = sCameraSettings[camera->setting].cameraModes[rwData->mode].values;
@@ -2651,10 +2653,10 @@ s32 Camera_Jump3(Camera* camera) {
         Camera_LERPCeilF(CAM_DATA_SCALED(OREG(4)), camera->yOffsetUpdateRate, camera->speedRatio * 0.05f, 0.1f);
 
     Camera_CalcAtDefault(camera, &eyeNextAtOffset, roData->yOffset, roData->interfaceFlags);
-    OLib_Vec3fDiffToVecSphGeo(&eyeDiffSph, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeDiffGeo, at, eyeNext);
 
-    camera->dist = eyeDiffSph.r =
-        Camera_ClampDist(camera, eyeDiffSph.r, roData->distMin, roData->distMax, rwData->animTimer);
+    camera->dist = eyeDiffGeo.r =
+        Camera_ClampDist(camera, eyeDiffGeo.r, roData->distMin, roData->distMax, rwData->animTimer);
 
     if (camera->playerGroundY <= playerPosRot->pos.y) {
         phi_f0 = playerPosRot->pos.y - camera->playerGroundY;
@@ -2673,34 +2675,34 @@ s32 Camera_Jump3(Camera* camera) {
         }
     }
     if (rwData->swing.unk_18 != 0) {
-        eyeDiffSph.yaw =
+        eyeDiffGeo.yaw =
             Camera_LERPCeilS(rwData->swing.unk_16, eyeNextAtOffset.yaw, 1.0f / camera->yawUpdateRateInv, 0xA);
-        eyeDiffSph.pitch =
+        eyeDiffGeo.pitch =
             Camera_LERPCeilS(rwData->swing.unk_14, eyeNextAtOffset.pitch, 1.0f / camera->yawUpdateRateInv, 0xA);
     } else {
-        eyeDiffSph.yaw = Camera_CalcDefaultYaw(camera, eyeNextAtOffset.yaw, playerPosRot->rot.y, roData->unk_14, 0.0f);
-        eyeDiffSph.pitch = Camera_CalcDefaultPitch(camera, eyeNextAtOffset.pitch, roData->pitchTarget, 0);
+        eyeDiffGeo.yaw = Camera_CalcDefaultYaw(camera, eyeNextAtOffset.yaw, playerPosRot->rot.y, roData->unk_14, 0.0f);
+        eyeDiffGeo.pitch = Camera_CalcDefaultPitch(camera, eyeNextAtOffset.pitch, roData->pitchTarget, 0);
     }
 
-    if (eyeDiffSph.pitch > R_CAM_MAX_PITCH) {
-        eyeDiffSph.pitch = R_CAM_MAX_PITCH;
+    if (eyeDiffGeo.pitch > R_CAM_MAX_PITCH) {
+        eyeDiffGeo.pitch = R_CAM_MAX_PITCH;
     }
 
-    if (eyeDiffSph.pitch < R_CAM_MIN_PITCH_1) {
-        eyeDiffSph.pitch = R_CAM_MIN_PITCH_1;
+    if (eyeDiffGeo.pitch < R_CAM_MIN_PITCH_1) {
+        eyeDiffGeo.pitch = R_CAM_MIN_PITCH_1;
     }
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeDiffSph);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &eyeDiffGeo);
     if ((camera->status == CAM_STAT_ACTIVE) && !(roData->interfaceFlags & 0x10)) {
-        func_80046E20(camera, &eyeDiffSph, roData->distMin, roData->swingUpdateRate, &spBC, &rwData->swing);
+        func_80046E20(camera, &eyeDiffGeo, roData->distMin, roData->swingUpdateRate, &spBC, &rwData->swing);
         if (roData->interfaceFlags & 4) {
             camera->inputDir.x = -eyeAtOffset.pitch;
             camera->inputDir.y = eyeAtOffset.yaw - 0x7FFF;
             camera->inputDir.z = 0;
         } else {
-            OLib_Vec3fDiffToVecSphGeo(&eyeDiffSph, eye, at);
-            camera->inputDir.x = eyeDiffSph.pitch;
-            camera->inputDir.y = eyeDiffSph.yaw;
+            OLib_Vec3fDiffToVecGeo(&eyeDiffGeo, eye, at);
+            camera->inputDir.x = eyeDiffGeo.pitch;
+            camera->inputDir.y = eyeDiffGeo.yaw;
             camera->inputDir.z = 0;
         }
 
@@ -2748,11 +2750,11 @@ s32 Camera_Battle1(Camera* camera) {
     s32 skipEyeAtCalc;
     f32 distRatio;
     CamColChk spBC;
-    VecSph spB4;
-    VecSph atToTargetDir;
-    VecSph playerToTargetDir;
-    VecSph atToEyeDir;
-    VecSph atToEyeNextDir;
+    VecGeo spB4;
+    VecGeo atToTargetDir;
+    VecGeo playerToTargetDir;
+    VecGeo atToEyeDir;
+    VecGeo atToEyeNextDir;
     PosRot* playerPosRot = &camera->playerPosRot;
     s16 tmpAng1;
     s16 tmpAng2;
@@ -2833,8 +2835,8 @@ s32 Camera_Battle1(Camera* camera) {
     camera->fovUpdateRate =
         Camera_LERPCeilF(CAM_DATA_SCALED(OREG(4)), camera->fovUpdateRate, camera->speedRatio * 0.05f, 0.1f);
     playerHeight += roData->yOffset;
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeDir, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeNextDir, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atToEyeNextDir, at, eyeNext);
     if (camera->target == NULL || camera->target->update == NULL) {
         if (camera->target == NULL) {
             osSyncPrintf(
@@ -2900,10 +2902,10 @@ s32 Camera_Battle1(Camera* camera) {
     tmpAng2 = playerToTargetDir.yaw;
     playerHead = playerPosRot->pos;
     playerHead.y += playerHeight;
-    OLib_Vec3fDiffToVecSphGeo(&playerToTargetDir, &playerHead, &camera->targetPosRot.pos);
+    OLib_Vec3fDiffToVecGeo(&playerToTargetDir, &playerHead, &camera->targetPosRot.pos);
     distRatio = playerToTargetDir.r > distance ? 1 : playerToTargetDir.r / distance;
     targetPos = camera->targetPosRot.pos;
-    OLib_Vec3fDiffToVecSphGeo(&atToTargetDir, at, &targetPos);
+    OLib_Vec3fDiffToVecGeo(&atToTargetDir, at, &targetPos);
     atToTargetDir.r = distance - ((atToTargetDir.r <= distance ? atToTargetDir.r : distance) * 0.5f);
     swingAngle = roData->swingYawInitial + ((roData->swingYawFinal - roData->swingYawInitial) * (1.1f - distRatio));
     spF8 = OREG(13) + swingAngle;
@@ -2914,7 +2916,7 @@ s32 Camera_Battle1(Camera* camera) {
     if (rwData->animTimer != 0) {
         if (rwData->animTimer >= OREG(24)) {
             sp86 = rwData->animTimer - OREG(24);
-            OLib_Vec3fDiffToVecSphGeo(&playerToTargetDir, at, eye);
+            OLib_Vec3fDiffToVecGeo(&playerToTargetDir, at, eye);
             playerToTargetDir.yaw = tmpAng2 - 0x7FFF;
 
             var2 = 1.0f / R_CAM_DEFAULT_ANIM_TIME;
@@ -2960,7 +2962,7 @@ s32 Camera_Battle1(Camera* camera) {
         }
 
         spB4.pitch = Camera_LERPCeilS(tmpAng1, atToEyeNextDir.pitch, rwData->unk_10, 0xA);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &spB4);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &spB4);
         spBC.pos = *eyeNext;
         if (camera->status == CAM_STAT_ACTIVE) {
             if (!camera->play->envCtx.skyboxDisabled || roData->flags & 1) {
@@ -3004,9 +3006,9 @@ s32 Camera_Battle4(Camera* camera) {
     Vec3f* eye = &camera->eye;
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
-    VecSph eyeNextOffset;
-    VecSph eyeAtOffset;
-    VecSph eyeNextAtOffset;
+    VecGeo eyeNextOffset;
+    VecGeo eyeAtOffset;
+    VecGeo eyeNextAtOffset;
     Battle4ReadOnlyData* roData = &camera->paramData.batt4.roData;
     Battle4ReadWriteData* rwData = &camera->paramData.batt4.rwData;
     s32 pad;
@@ -3031,8 +3033,8 @@ s32 Camera_Battle4(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -3064,7 +3066,7 @@ s32 Camera_Battle4(Camera* camera) {
         eyeNextOffset.pitch = Camera_LERPCeilS(roData->pitchTarget, eyeAtOffset.pitch, roData->lerpUpdateRate, 2);
         eyeNextOffset.r = Camera_LERPCeilF(roData->rTarget, eyeAtOffset.r, roData->lerpUpdateRate, 0.001f);
     }
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeNextOffset);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &eyeNextOffset);
     *eye = *eyeNext;
     camera->dist = eyeNextOffset.r;
     camera->fov = Camera_LERPCeilF(roData->fovTarget, camera->fov, roData->lerpUpdateRate, 1.0f);
@@ -3096,11 +3098,11 @@ s32 Camera_KeepOn1(Camera* camera) {
     f32 t2;
     s16 spE2;
     s16 spE0;
-    VecSph spD8;
-    VecSph spD0;
-    VecSph spC8;
-    VecSph spC0;
-    VecSph spB8;
+    VecGeo spD8;
+    VecGeo spD0;
+    VecGeo spC8;
+    VecGeo spC0;
+    VecGeo spB8;
     PosRot* playerPosRot = &camera->playerPosRot;
     CamColChk sp8C;
     s32 sp88;
@@ -3148,8 +3150,8 @@ s32 Camera_KeepOn1(Camera* camera) {
     }
 
     playerHeight += roData->unk_00;
-    OLib_Vec3fDiffToVecSphGeo(&spC0, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&spB8, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&spC0, at, eye);
+    OLib_Vec3fDiffToVecGeo(&spB8, at, eyeNext);
     sCameraInterfaceFlags = roData->interfaceFlags;
     if (RELOAD_PARAMS(camera)) {
         camera->animState++;
@@ -3180,7 +3182,7 @@ s32 Camera_KeepOn1(Camera* camera) {
                 spC8.r = 60.0f;
                 spC8.yaw = camera->playerPosRot.rot.y;
                 spC8.pitch = 0x2EE0;
-                Camera_Vec3fVecSphGeoAdd(&camera->targetPosRot.pos, &sp54.pos, &spC8);
+                Camera_AddVecGeoToVec3f(&camera->targetPosRot.pos, &sp54.pos, &spC8);
             } else {
                 Actor_GetFocus(&camera->targetPosRot, camera->target);
             }
@@ -3211,7 +3213,7 @@ s32 Camera_KeepOn1(Camera* camera) {
                                    sp104, &rwData->unk_08, &spC8, (sp80 ? 0x80 : 0) | roData->interfaceFlags);
             sp114 = playerPosRot->pos;
             sp114.y += playerHeight;
-            OLib_Vec3fDiffToVecSphGeo(&spC8, &sp114, &camera->targetPosRot.pos);
+            OLib_Vec3fDiffToVecGeo(&spC8, &sp114, &camera->targetPosRot.pos);
             sp84 = spC8.r > sp104 ? 1.0f : spC8.r / sp104;
             break;
         default:
@@ -3220,7 +3222,7 @@ s32 Camera_KeepOn1(Camera* camera) {
             rwData->unk_0C = NULL;
             break;
     }
-    OLib_Vec3fDiffToVecSphGeo(&spD8, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&spD8, at, eyeNext);
     if (spD8.r < roData->unk_04) {
         sp104 = roData->unk_04;
         spE8 = OREG(6);
@@ -3235,7 +3237,7 @@ s32 Camera_KeepOn1(Camera* camera) {
     camera->rUpdateRateInv = Camera_LERPCeilF(spE8, camera->rUpdateRateInv, CAM_DATA_SCALED(OREG(25)), 0.1f);
     spD8.r = spE8 = camera->dist = Camera_LERPCeilF(sp104, camera->dist, 1.0f / camera->rUpdateRateInv, 0.2f);
     sp108 = camera->targetPosRot.pos;
-    OLib_Vec3fDiffToVecSphGeo(&spD0, at, &sp108);
+    OLib_Vec3fDiffToVecGeo(&spD0, at, &sp108);
     spD0.r = spE8 - ((spD0.r <= spE8 ? spD0.r : spE8) * 0.5f);
     spEC = roData->unk_0C + ((roData->unk_10 - roData->unk_0C) * (1.1f - sp84));
     spF0 = OREG(13) + spEC;
@@ -3246,7 +3248,7 @@ s32 Camera_KeepOn1(Camera* camera) {
         if (rwData->unk_16 >= OREG(24)) {
             sp82 = rwData->unk_16 - OREG(24);
             spE2 = spC8.yaw;
-            OLib_Vec3fDiffToVecSphGeo(&spC8, at, eye);
+            OLib_Vec3fDiffToVecGeo(&spC8, at, eye);
             spC8.yaw = spE2 - 0x7FFF;
 
             t2 = 1.0f / R_CAM_DEFAULT_ANIM_TIME;
@@ -3289,7 +3291,7 @@ s32 Camera_KeepOn1(Camera* camera) {
         }
 
         spD8.pitch = Camera_LERPCeilS(spE2, spB8.pitch, CAM_DATA_SCALED(OREG(12)), 0xA);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &spD8);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &spD8);
         sp8C.pos = *eyeNext;
         if (camera->status == CAM_STAT_ACTIVE) {
             if (!camera->play->envCtx.skyboxDisabled || roData->interfaceFlags & 1) {
@@ -3333,10 +3335,10 @@ s32 Camera_KeepOn3(Camera* camera) {
     f32 prevTargetPlayerDist;
     f32 swingAngle;
     Actor* colChkActors[2];
-    VecSph targetToPlayerDir;
-    VecSph atToEyeAdj;
-    VecSph atToEyeDir;
-    VecSph atToEyeNextDir;
+    VecGeo targetToPlayerDir;
+    VecGeo atToEyeAdj;
+    VecGeo atToEyeDir;
+    VecGeo atToEyeNextDir;
     s32 i;
     s32 angleCnt;
     s16 sp82;
@@ -3390,13 +3392,13 @@ s32 Camera_KeepOn3(Camera* camera) {
     }
 
     playerHeight += roData->yOffset;
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeDir, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&atToEyeNextDir, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&atToEyeDir, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atToEyeNextDir, at, eyeNext);
     Actor_GetFocus(&camera->targetPosRot, camera->target);
     Actor_GetFocus(&playerPosRot, &camera->player->actor);
     playerHeadPos = camPlayerPosRot->pos;
     playerHeadPos.y += playerHeight;
-    OLib_Vec3fDiffToVecSphGeo(&targetToPlayerDir, &playerHeadPos, &camera->targetPosRot.pos);
+    OLib_Vec3fDiffToVecGeo(&targetToPlayerDir, &playerHeadPos, &camera->targetPosRot.pos);
     sCameraInterfaceFlags = roData->flags;
     if (RELOAD_PARAMS(camera)) {
         colChkActors[0] = camera->target;
@@ -3441,12 +3443,12 @@ s32 Camera_KeepOn3(Camera* camera) {
         sp82 = atToEyeAdj.pitch;
         playerHeadPos = camPlayerPosRot->pos;
         playerHeadPos.y += playerHeight;
-        Camera_Vec3fVecSphGeoAdd(&rwData->atTarget, &playerHeadPos, &targetToPlayerDir);
+        Camera_AddVecGeoToVec3f(&rwData->atTarget, &playerHeadPos, &targetToPlayerDir);
         angleCnt = ARRAY_COUNT(D_8011D3B0);
         i = 0;
         targetToPlayerDir.r = prevTargetPlayerDist;
         atToEyeAdj.r = roData->minDist + (targetToPlayerDir.r * (1 - 0.5f)) - atToEyeNextDir.r + atToEyeNextDir.r;
-        Camera_Vec3fVecSphGeoAdd(&lineChkPointB, &rwData->atTarget, &atToEyeAdj);
+        Camera_AddVecGeoToVec3f(&lineChkPointB, &rwData->atTarget, &atToEyeAdj);
         if (!(roData->flags & 0x80)) {
             while (i < angleCnt) {
                 if (!CollisionCheck_LineOCCheck(camera->play, &camera->play->colChkCtx, &rwData->atTarget,
@@ -3456,16 +3458,16 @@ s32 Camera_KeepOn3(Camera* camera) {
                 }
                 atToEyeAdj.yaw = sp80 + D_8011D3B0[i];
                 atToEyeAdj.pitch = sp82 + D_8011D3CC[i];
-                Camera_Vec3fVecSphGeoAdd(&lineChkPointB, &rwData->atTarget, &atToEyeAdj);
+                Camera_AddVecGeoToVec3f(&lineChkPointB, &rwData->atTarget, &atToEyeAdj);
                 i++;
             }
         }
         osSyncPrintf("camera: talk: BG&collision check %d time(s)\n", i);
         camera->unk_14C &= ~0xC;
         pad = ((rwData->animTimer + 1) * rwData->animTimer) >> 1;
-        rwData->eyeToAtTarget.y = (f32)(s16)(atToEyeAdj.yaw - atToEyeNextDir.yaw) / pad;
-        rwData->eyeToAtTarget.z = (f32)(s16)(atToEyeAdj.pitch - atToEyeNextDir.pitch) / pad;
-        rwData->eyeToAtTarget.x = (atToEyeAdj.r - atToEyeNextDir.r) / pad;
+        rwData->eyeToAtTargetYaw = (f32)(s16)(atToEyeAdj.yaw - atToEyeNextDir.yaw) / pad;
+        rwData->eyeToAtTargetPitch = (f32)(s16)(atToEyeAdj.pitch - atToEyeNextDir.pitch) / pad;
+        rwData->eyeToAtTargetR = (atToEyeAdj.r - atToEyeNextDir.r) / pad;
         return 1;
     }
 
@@ -3475,10 +3477,10 @@ s32 Camera_KeepOn3(Camera* camera) {
         at->z += (rwData->atTarget.z - at->z) / rwData->animTimer;
         // needed to match
         if (!prevTargetPlayerDist) {}
-        atToEyeAdj.r = ((rwData->eyeToAtTarget.x * rwData->animTimer) + atToEyeNextDir.r) + 1.0f;
-        atToEyeAdj.yaw = atToEyeNextDir.yaw + (s16)(rwData->eyeToAtTarget.y * rwData->animTimer);
-        atToEyeAdj.pitch = atToEyeNextDir.pitch + (s16)(rwData->eyeToAtTarget.z * rwData->animTimer);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &atToEyeAdj);
+        atToEyeAdj.r = ((rwData->eyeToAtTargetR * rwData->animTimer) + atToEyeNextDir.r) + 1.0f;
+        atToEyeAdj.yaw = atToEyeNextDir.yaw + (s16)(rwData->eyeToAtTargetYaw * rwData->animTimer);
+        atToEyeAdj.pitch = atToEyeNextDir.pitch + (s16)(rwData->eyeToAtTargetPitch * rwData->animTimer);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &atToEyeAdj);
         *eye = *eyeNext;
         camera->fov = Camera_LERPCeilF(roData->fovTarget, camera->fov, 0.5, 1.0f);
         camera->roll = Camera_LERPCeilS(0, camera->roll, 0.5, 0xA);
@@ -3520,9 +3522,9 @@ s32 Camera_KeepOn4(Camera* camera) {
     f32 t = -0.5f;
     f32 temp_f0_2;
     CollisionPoly* spC0;
-    VecSph spB8;
-    VecSph spB0;
-    VecSph spA8;
+    VecGeo spB8;
+    VecGeo spB0;
+    VecGeo spA8;
     s16* temp_s0 = &camera->data2;
     s16 spA2;
     s16 spA0;
@@ -3668,8 +3670,8 @@ s32 Camera_KeepOn4(Camera* camera) {
 
     sUpdateCameraDirection = 1;
     sCameraInterfaceFlags = roData->unk_1C;
-    OLib_Vec3fDiffToVecSphGeo(&spB0, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&spA8, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&spB0, at, eye);
+    OLib_Vec3fDiffToVecGeo(&spA8, at, eyeNext);
     D_8015BD50 = playerPosRot->pos;
     D_8015BD50.y += playerHeight;
     temp_f0_2 = BgCheck_CameraRaycastDown2(&camera->play->colCtx, &spC0, &i, &D_8015BD50);
@@ -3728,7 +3730,7 @@ s32 Camera_KeepOn4(Camera* camera) {
             spB8.pitch = spA2;
             spB8.yaw = spA0;
             spB8.r = roData->unk_04;
-            Camera_Vec3fVecSphGeoAdd(&D_8015BD70, &D_8015BD50, &spB8);
+            Camera_AddVecGeoToVec3f(&D_8015BD70, &D_8015BD50, &spB8);
             if (!(roData->unk_1C & 1)) {
                 angleCnt = ARRAY_COUNT(D_8011D3B0);
                 for (i = 0; i < angleCnt; i++) {
@@ -3739,7 +3741,7 @@ s32 Camera_KeepOn4(Camera* camera) {
                     }
                     spB8.yaw = D_8011D3B0[i] + spA0;
                     spB8.pitch = D_8011D3CC[i] + spA2;
-                    Camera_Vec3fVecSphGeoAdd(&D_8015BD70, &D_8015BD50, &spB8);
+                    Camera_AddVecGeoToVec3f(&D_8015BD70, &D_8015BD50, &spB8);
                 }
                 osSyncPrintf("camera: item: BG&collision check %d time(s)\n", i);
             }
@@ -3763,7 +3765,7 @@ s32 Camera_KeepOn4(Camera* camera) {
         spB8.r = roData->unk_10;
         spB8.pitch = 0;
         spB8.yaw = playerPosRot->rot.y;
-        Camera_Vec3fVecSphGeoAdd(at, at, &spB8);
+        Camera_AddVecGeoToVec3f(at, at, &spB8);
     }
     camera->atLERPStepScale = 0.0f;
     camera->dist = Camera_LERPCeilF(roData->unk_04, camera->dist, 0.25f, 2.0f);
@@ -3796,7 +3798,7 @@ s32 Camera_KeepOn4(Camera* camera) {
     }
     spB8.yaw = Camera_LERPCeilS(rwData->unk_0C, spA8.yaw, roData->unk_14, 4);
     spB8.pitch = Camera_LERPCeilS(rwData->unk_0E, spA8.pitch, roData->unk_14, 4);
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &spB8);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &spB8);
     *eye = *eyeNext;
     Camera_BGCheck(camera, at, eye);
     camera->fov = Camera_LERPCeilF(roData->unk_18, camera->fov, camera->fovUpdateRate, 1.0f);
@@ -3810,8 +3812,8 @@ s32 Camera_KeepOn0(Camera* camera) {
     Vec3f* eye = &camera->eye;
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f* at = &camera->at;
-    VecSph eyeTargetPosOffset;
-    VecSph eyeAtOffset;
+    VecGeo eyeTargetPosOffset;
+    VecGeo eyeAtOffset;
     KeepOn0ReadOnlyData* roData = &camera->paramData.keep0.roData;
     KeepOn0ReadWriteData* rwData = &camera->paramData.keep0.rwData;
     s32 pad;
@@ -3856,8 +3858,8 @@ s32 Camera_KeepOn0(Camera* camera) {
 
     Actor_GetFocus(&camera->targetPosRot, camera->target);
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, eye, at);
-    OLib_Vec3fDiffToVecSphGeo(&eyeTargetPosOffset, eye, &camera->targetPosRot.pos);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, eye, at);
+    OLib_Vec3fDiffToVecGeo(&eyeTargetPosOffset, eye, &camera->targetPosRot.pos);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -3872,7 +3874,7 @@ s32 Camera_KeepOn0(Camera* camera) {
 
     if (rwData->animTimer != 0) {
         eyeAtOffset.yaw += ((s16)(eyeTargetPosOffset.yaw - eyeAtOffset.yaw) / rwData->animTimer) * roData->yawScale;
-        Camera_Vec3fVecSphGeoAdd(at, eye, &eyeAtOffset);
+        Camera_AddVecGeoToVec3f(at, eye, &eyeAtOffset);
         rwData->animTimer--;
     } else {
         camera->unk_14C |= (0x400 | 0x10);
@@ -3885,8 +3887,8 @@ s32 Camera_Fixed1(Camera* camera) {
     Fixed1ReadOnlyData* roData = &camera->paramData.fixd1.roData;
     Fixed1ReadWriteData* rwData = &camera->paramData.fixd1.rwData;
     s32 pad;
-    VecSph eyeOffset;
-    VecSph eyeAtOffset;
+    VecGeo eyeOffset;
+    VecGeo eyeAtOffset;
     s32 pad2;
     Vec3f adjustedPos;
     BgCamFuncData* bgCamFuncData;
@@ -3929,7 +3931,7 @@ s32 Camera_Fixed1(Camera* camera) {
         }
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, eye, at);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, eye, at);
 
     Camera_LERPCeilVec3f(&rwData->eyePosRotTarget.pos, eye, 0.1f, 0.1f, 0.2f);
     adjustedPos = playerPosRot->pos;
@@ -3940,7 +3942,7 @@ s32 Camera_Fixed1(Camera* camera) {
     eyeOffset.pitch = Camera_LERPCeilS(-rwData->eyePosRotTarget.rot.x, eyeAtOffset.pitch, roData->lerpStep, 5);
     eyeOffset.yaw = Camera_LERPCeilS(rwData->eyePosRotTarget.rot.y, eyeAtOffset.yaw, roData->lerpStep, 5);
 
-    Camera_Vec3fVecSphGeoAdd(at, eye, &eyeOffset);
+    Camera_AddVecGeoToVec3f(at, eye, &eyeOffset);
 
     camera->eyeNext = *eye;
 
@@ -4041,16 +4043,16 @@ s32 Camera_Fixed3(Camera* camera) {
     Vec3f* eye = &camera->eye;
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
-    VecSph atSph;
+    VecGeo atGeo;
     BgCamFuncData* bgCamFuncData;
-    VecSph eyeAtOffset;
+    VecGeo eyeAtOffset;
     Fixed3ReadOnlyData* roData = &camera->paramData.fixd3.roData;
     Fixed3ReadWriteData* rwData = &camera->paramData.fixd3.rwData;
     s32 pad;
 
     bgCamFuncData = (BgCamFuncData*)Camera_GetBgCamFuncData(camera);
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, eye, at);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, eye, at);
 
     if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
         CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
@@ -4092,11 +4094,11 @@ s32 Camera_Fixed3(Camera* camera) {
         sUpdateCameraDirection = false;
     }
 
-    atSph.r = 150.0f;
-    atSph.yaw = rwData->rot.y;
-    atSph.pitch = -rwData->rot.x;
+    atGeo.r = 150.0f;
+    atGeo.yaw = rwData->rot.y;
+    atGeo.pitch = -rwData->rot.x;
 
-    Camera_Vec3fVecSphGeoAdd(at, eye, &atSph);
+    Camera_AddVecGeoToVec3f(at, eye, &atGeo);
     sCameraInterfaceFlags = roData->interfaceFlags;
     rwData->fov = R_CAM_DATA(CAM_DATA_FOV);
     camera->roll = 0;
@@ -4116,8 +4118,8 @@ s32 Camera_Fixed4(Camera* camera) {
     Vec3f playerPosWithCamOffset;
     Vec3f atTarget;
     Vec3f posOffsetTarget;
-    VecSph atEyeNextOffset;
-    VecSph atTargetEyeNextOffset;
+    VecGeo atEyeNextOffset;
+    VecGeo atTargetEyeNextOffset;
     PosRot* playerPosRot = &camera->playerPosRot;
     BgCamFuncData* bgCamFuncData;
     Vec3f* posOffset = &camera->posOffset;
@@ -4170,15 +4172,15 @@ s32 Camera_Fixed4(Camera* camera) {
     playerPosWithCamOffset.z = playerPosRot->pos.z + camera->posOffset.z;
     VEC3F_LERPIMPDST(&atTarget, at, &playerPosWithCamOffset, 0.5f);
 
-    OLib_Vec3fDiffToVecSphGeo(&atEyeNextOffset, eyeNext, at);
-    OLib_Vec3fDiffToVecSphGeo(&atTargetEyeNextOffset, eyeNext, &atTarget);
+    OLib_Vec3fDiffToVecGeo(&atEyeNextOffset, eyeNext, at);
+    OLib_Vec3fDiffToVecGeo(&atTargetEyeNextOffset, eyeNext, &atTarget);
 
     atEyeNextOffset.r += (atTargetEyeNextOffset.r - atEyeNextOffset.r) * rwData->followSpeed;
     atEyeNextOffset.pitch = Camera_LERPCeilS(atTargetEyeNextOffset.pitch, atEyeNextOffset.pitch,
                                              rwData->followSpeed * camera->speedRatio, 0xA);
     atEyeNextOffset.yaw =
         Camera_LERPCeilS(atTargetEyeNextOffset.yaw, atEyeNextOffset.yaw, rwData->followSpeed * camera->speedRatio, 0xA);
-    Camera_Vec3fVecSphGeoAdd(at, eyeNext, &atEyeNextOffset);
+    Camera_AddVecGeoToVec3f(at, eyeNext, &atEyeNextOffset);
     camera->dist = OLib_Vec3fDist(at, eye);
     camera->roll = 0;
     camera->fov = roData->fov;
@@ -4207,9 +4209,9 @@ s32 Camera_Subj3(Camera* camera) {
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f sp98;
     Vec3f sp8C;
-    VecSph sp84;
-    VecSph sp7C;
-    VecSph tsph;
+    VecGeo sp84;
+    VecGeo sp7C;
+    VecGeo tGeo;
     PosRot sp60;
     PosRot* playerPosRot = &camera->playerPosRot;
     f32 sp58;
@@ -4248,8 +4250,8 @@ s32 Camera_Subj3(Camera* camera) {
     sp98 = sp60.pos;
     sp98.y += roData->eyeNextYOffset;
 
-    Camera_Vec3fVecSphGeoAdd(&sp8C, &sp98, &sp84);
-    OLib_Vec3fDiffToVecSphGeo(&sp7C, at, eye);
+    Camera_AddVecGeoToVec3f(&sp8C, &sp98, &sp84);
+    OLib_Vec3fDiffToVecGeo(&sp7C, at, eye);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
     if (RELOAD_PARAMS(camera)) {
@@ -4263,9 +4265,9 @@ s32 Camera_Subj3(Camera* camera) {
         camera->dist = roData->eyeNextDist;
     }
 
-    tsph.r = rwData->r;
-    tsph.yaw = rwData->yaw;
-    tsph.pitch = rwData->pitch;
+    tGeo.r = rwData->r;
+    tGeo.yaw = rwData->yaw;
+    tGeo.pitch = rwData->pitch;
     if (rwData->animTimer != 0) {
         temp_f0_3 = (1.0f / rwData->animTimer);
         pad2 = at;
@@ -4274,15 +4276,15 @@ s32 Camera_Subj3(Camera* camera) {
         at->z = at->z + (sp98.z - pad2->z) * temp_f0_3;
 
         temp_f0_3 = (1.0f / R_CAM_DEFAULT_ANIM_TIME);
-        sp58 = (tsph.r - sp84.r) * temp_f0_3;
-        sp52 = (s16)(tsph.yaw - sp84.yaw) * temp_f0_3;
-        sp50 = (s16)(tsph.pitch - sp84.pitch) * temp_f0_3;
+        sp58 = (tGeo.r - sp84.r) * temp_f0_3;
+        sp52 = (s16)(tGeo.yaw - sp84.yaw) * temp_f0_3;
+        sp50 = (s16)(tGeo.pitch - sp84.pitch) * temp_f0_3;
 
         sp7C.r = Camera_LERPCeilF(sp84.r + (sp58 * rwData->animTimer), sp7C.r, CAM_DATA_SCALED(OREG(28)), 1.0f);
         sp7C.yaw = Camera_LERPCeilS(sp84.yaw + (sp52 * rwData->animTimer), sp7C.yaw, CAM_DATA_SCALED(OREG(28)), 0xA);
         sp7C.pitch =
             Camera_LERPCeilS(sp84.pitch + (sp50 * rwData->animTimer), sp7C.pitch, CAM_DATA_SCALED(OREG(28)), 0xA);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &sp7C);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &sp7C);
 
         *eye = *eyeNext;
         rwData->animTimer--;
@@ -4309,9 +4311,9 @@ s32 Camera_Subj3(Camera* camera) {
         sp7C.r = roData->eyeNextDist;
         sp7C.yaw = sp60.rot.y - 0x7FFF;
         sp7C.pitch = sp60.rot.x;
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &sp7C);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &sp7C);
         sp7C.r = roData->eyeDist;
-        Camera_Vec3fVecSphGeoAdd(eye, at, &sp7C);
+        Camera_AddVecGeoToVec3f(eye, at, &sp7C);
     }
 
     camera->posOffset.x = camera->at.x - playerPosRot->pos.x;
@@ -4348,8 +4350,8 @@ s32 Camera_Subj4(Camera* camera) {
     s16 pad2;
     f32 temp_f16;
     PosRot sp6C;
-    VecSph sp64;
-    VecSph sp5C;
+    VecGeo sp64;
+    VecGeo sp5C;
     s16 temp_a0;
     f32 tx;
     Player* player;
@@ -4375,7 +4377,7 @@ s32 Camera_Subj4(Camera* camera) {
 
     Actor_GetWorldPosShapeRot(&sp6C, &camera->player->actor);
 
-    OLib_Vec3fDiffToVecSphGeo(&sp5C, at, eye);
+    OLib_Vec3fDiffToVecGeo(&sp5C, at, eye);
     sCameraInterfaceFlags = roData->interfaceFlags;
     if (camera->animState == 0) {
         crawlspacePoints = (Vec3s*)Camera_GetBgCamFuncDataUnderPlayer(camera, &crawlspaceNumPoints);
@@ -4410,7 +4412,7 @@ s32 Camera_Subj4(Camera* camera) {
         sp64.r = 10.0f;
         sp64.pitch = 0x238C;
         sp64.yaw = rwData->unk_30;
-        Camera_Vec3fVecSphGeoAdd(&sp8C, &sp6C.pos, &sp64);
+        Camera_AddVecGeoToVec3f(&sp8C, &sp6C.pos, &sp64);
         sp88 = (rwData->unk_32 + 1.0f);
         at->x += (sp8C.x - at->x) / sp88;
         at->y += (sp8C.y - at->y) / sp88;
@@ -4418,7 +4420,7 @@ s32 Camera_Subj4(Camera* camera) {
         sp5C.r -= (sp5C.r / sp88);
         sp5C.yaw = BINANG_LERPIMPINV(sp5C.yaw, (s16)(sp6C.rot.y - 0x7FFF), rwData->unk_32);
         sp5C.pitch = BINANG_LERPIMPINV(sp5C.pitch, sp6C.rot.x, rwData->unk_32);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &sp5C);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &sp5C);
         *eye = *eyeNext;
         rwData->unk_32--;
         return false;
@@ -4435,7 +4437,7 @@ s32 Camera_Subj4(Camera* camera) {
     sp64.yaw = rwData->unk_30;
     sp64.r = 5.0f;
     sp64.pitch = 0x238C;
-    Camera_Vec3fVecSphGeoAdd(&sp98, eyeNext, &sp64);
+    Camera_AddVecGeoToVec3f(&sp98, eyeNext, &sp64);
     rwData->unk_2C += 0xBB8;
     temp_f16 = Math_CosS(rwData->unk_2C);
     eye->x += (sp98.x - eye->x) * fabsf(temp_f16);
@@ -4487,9 +4489,9 @@ s32 Camera_Data3(Camera* camera) {
 s32 Camera_Data4(Camera* camera) {
     s32 pad2[2];
     Data4ReadOnlyData* roData = &camera->paramData.data4.roData;
-    VecSph eyeAtOffset;
-    VecSph atOffset;
-    VecSph eyeNextAtOffset;
+    VecGeo eyeAtOffset;
+    VecGeo atOffset;
+    VecGeo eyeNextAtOffset;
     f32 yNormal;
     s16 fov;
     Vec3f* eyeNext = &camera->eyeNext;
@@ -4536,16 +4538,16 @@ s32 Camera_Data4(Camera* camera) {
         func_80043B60(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
     Camera_CalcAtDefault(camera, &eyeNextAtOffset, roData->yOffset, false);
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, eye, at);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, eye, at);
 
     atOffset.r = eyeAtOffset.r;
     atOffset.yaw = (rwData->flags & 1) ? (CAM_DEG_TO_BINANG(camera->data2) + rwData->eyePosRot.rot.y) : eyeAtOffset.yaw;
     atOffset.pitch =
         (rwData->flags & 2) ? (CAM_DEG_TO_BINANG(camera->data3) + rwData->eyePosRot.rot.x) : eyeAtOffset.pitch;
 
-    Camera_Vec3fVecSphGeoAdd(at, eye, &atOffset);
+    Camera_AddVecGeoToVec3f(at, eye, &atOffset);
 
     lookAt = camera->playerPosRot.pos;
     lookAt.y += playerHeight;
@@ -4567,10 +4569,10 @@ s32 Camera_Unique1(Camera* camera) {
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f playerWaistPos;
     s16 phiTarget;
-    VecSph sp8C;
-    VecSph unk908PlayerPosOffset;
-    VecSph eyeAtOffset;
-    VecSph eyeNextAtOffset;
+    VecGeo sp8C;
+    VecGeo unk908PlayerPosOffset;
+    VecGeo eyeAtOffset;
+    VecGeo eyeNextAtOffset;
     PosRot* playerPosRot = &camera->playerPosRot;
     PosRot playerhead;
     Unique1ReadOnlyData* roData = &camera->paramData.uniq1.roData;
@@ -4600,8 +4602,8 @@ s32 Camera_Unique1(Camera* camera) {
 
     sUpdateCameraDirection = 1;
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -4610,7 +4612,7 @@ s32 Camera_Unique1(Camera* camera) {
         rwData->yawTarget = eyeNextAtOffset.yaw;
         rwData->unk_00 = 0.0f;
         playerWaistPos = camera->player->bodyPartsPos[PLAYER_BODYPART_WAIST];
-        OLib_Vec3fDiffToVecSphGeo(&unk908PlayerPosOffset, &playerPosRot->pos, &playerWaistPos);
+        OLib_Vec3fDiffToVecGeo(&unk908PlayerPosOffset, &playerPosRot->pos, &playerWaistPos);
         rwData->timer = R_CAM_DEFAULT_ANIM_TIME;
         rwData->yawTargetAdj = ABS((s16)(unk908PlayerPosOffset.yaw - eyeAtOffset.yaw)) < 0x3A98
                                    ? 0
@@ -4627,7 +4629,7 @@ s32 Camera_Unique1(Camera* camera) {
     camera->fovUpdateRate = Camera_LERPCeilF(OREG(4) * 0.01f, camera->fovUpdateRate, 0.05f, 0.1f);
 
     Camera_CalcAtDefault(camera, &eyeNextAtOffset, roData->yOffset, 1);
-    OLib_Vec3fDiffToVecSphGeo(&sp8C, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&sp8C, at, eyeNext);
 
     camera->dist = Camera_LERPClampDist(camera, sp8C.r, roData->distMin, roData->distMax);
 
@@ -4647,7 +4649,7 @@ s32 Camera_Unique1(Camera* camera) {
     }
 
     sp8C.yaw = Camera_LERPFloorS(rwData->yawTarget, eyeNextAtOffset.yaw, 0.5f, 0x2710);
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &sp8C);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &sp8C);
     *eye = *eyeNext;
     Camera_BGCheck(camera, at, eye);
     camera->fov = Camera_LERPCeilF(roData->fovTarget, camera->fov, camera->fovUpdateRate, 1.0f);
@@ -4661,8 +4663,8 @@ s32 Camera_Unique2(Camera* camera) {
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f playerPos;
-    VecSph eyeOffset;
-    VecSph eyeAtOffset;
+    VecGeo eyeOffset;
+    VecGeo eyeAtOffset;
     s32 pad;
     f32 lerpRateFactor;
     Unique2ReadOnlyData* roData = &camera->paramData.uniq2.roData;
@@ -4672,7 +4674,7 @@ s32 Camera_Unique2(Camera* camera) {
 
     playerHeight = Player_GetHeight(camera->player);
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
 
     if (RELOAD_PARAMS(camera) || R_RELOAD_CAM_PARAMS) {
         CameraModeValue* values = sCameraSettings[camera->setting].cameraModes[camera->mode].values;
@@ -4712,17 +4714,17 @@ s32 Camera_Unique2(Camera* camera) {
     rwData->unk_00 = F32_LERPIMP(rwData->unk_00, 2.0f, 0.05f); // unused.
 
     if (roData->interfaceFlags & 1) {
-        OLib_Vec3fDiffToVecSphGeo(&eyeOffset, at, eyeNext);
+        OLib_Vec3fDiffToVecGeo(&eyeOffset, at, eyeNext);
         eyeOffset.r = roData->distTarget;
-        Camera_Vec3fVecSphGeoAdd(&playerPos, at, &eyeOffset);
+        Camera_AddVecGeoToVec3f(&playerPos, at, &eyeOffset);
         Camera_LERPCeilVec3f(&playerPos, eye, 0.25f, 0.25f, 0.2f);
     } else if (roData->interfaceFlags & 2) {
         if (OLib_Vec3fDistXZ(at, eyeNext) < roData->distTarget) {
-            OLib_Vec3fDiffToVecSphGeo(&eyeOffset, at, eyeNext);
+            OLib_Vec3fDiffToVecGeo(&eyeOffset, at, eyeNext);
             eyeOffset.yaw = Camera_LERPCeilS(eyeOffset.yaw, eyeAtOffset.yaw, 0.1f, 0xA);
             eyeOffset.r = roData->distTarget;
             eyeOffset.pitch = 0;
-            Camera_Vec3fVecSphGeoAdd(eye, at, &eyeOffset);
+            Camera_AddVecGeoToVec3f(eye, at, &eyeOffset);
             eye->y = eyeNext->y;
         } else {
             Camera_LERPCeilVec3f(eyeNext, eye, 0.25f, 0.25f, 0.2f);
@@ -4738,7 +4740,7 @@ s32 Camera_Unique2(Camera* camera) {
 }
 
 s32 Camera_Unique3(Camera* camera) {
-    VecSph sp60;
+    VecGeo sp60;
     f32 playerHeight;
     DoorParams* doorParams = &camera->paramData.doorParams;
     BgCamFuncData* bgCamFuncData;
@@ -4785,7 +4787,7 @@ s32 Camera_Unique3(Camera* camera) {
             sp60.yaw = bgCamRot.y;
             sp60.pitch = -bgCamRot.x;
 
-            Camera_Vec3fVecSphGeoAdd(at, &camera->eye, &sp60);
+            Camera_AddVecGeoToVec3f(at, &camera->eye, &sp60);
             camera->animState++;
             FALLTHROUGH;
         case 2:
@@ -4829,9 +4831,9 @@ s32 Camera_Unique3(Camera* camera) {
             FALLTHROUGH;
         case 5:
             camera->fov = Camera_LERPCeilF(rwData->initialFov, camera->fov, 0.4f, 0.1f);
-            OLib_Vec3fDiffToVecSphGeo(&sp60, at, &camera->eye);
+            OLib_Vec3fDiffToVecGeo(&sp60, at, &camera->eye);
             sp60.r = Camera_LERPCeilF(100.0f, sp60.r, 0.4f, 0.1f);
-            Camera_Vec3fVecSphGeoAdd(&camera->eyeNext, at, &sp60);
+            Camera_AddVecGeoToVec3f(&camera->eyeNext, at, &sp60);
             camera->eye = camera->eyeNext;
             if (doorParams->timer3-- > 0) {
                 break;
@@ -4862,7 +4864,7 @@ s32 Camera_Unique0(Camera* camera) {
     CameraModeValue* values;
     Player* player;
     Vec3f playerPosWithOffset;
-    VecSph atPlayerOffset;
+    VecGeo atPlayerOffset;
     BgCamFuncData* bgCamFuncData;
     Vec3s bgCamRot;
     PosRot* playerPosRot = &camera->playerPosRot;
@@ -4909,7 +4911,7 @@ s32 Camera_Unique0(Camera* camera) {
         atPlayerOffset.r = OLib_Vec3fDist(&playerPosWithOffset, eye);
         atPlayerOffset.yaw = bgCamRot.y;
         atPlayerOffset.pitch = -bgCamRot.x;
-        OLib_VecSphGeoToVec3f(&rwData->eyeAndDirection.dir, &atPlayerOffset);
+        OLib_VecGeoToVec3f(&rwData->eyeAndDirection.dir, &atPlayerOffset);
         Math3D_LineClosestToPoint(&rwData->eyeAndDirection, &playerPosRot->pos, &camera->at);
         rwData->initalPos = playerPosRot->pos;
         camera->animState++;
@@ -5037,7 +5039,7 @@ s32 Camera_Unique7(Camera* camera) {
     s32 pad;
     Unique7ReadOnlyData* roData = &camera->paramData.uniq7.roData;
     CameraModeValue* values;
-    VecSph playerPosEyeOffset;
+    VecGeo playerPosEyeOffset;
     s16 fov;
     BgCamFuncData* bgCamFuncData;
     UNUSED Vec3s bgCamRot;
@@ -5062,7 +5064,7 @@ s32 Camera_Unique7(Camera* camera) {
     *eye = *eyeNext;
     bgCamRot = bgCamFuncData->rot;
 
-    OLib_Vec3fDiffToVecSphGeo(&playerPosEyeOffset, eye, &playerPosRot->pos);
+    OLib_Vec3fDiffToVecGeo(&playerPosEyeOffset, eye, &playerPosRot->pos);
 
     // fov actually goes unused since it's hard set later on.
     fov = bgCamFuncData->fov;
@@ -5089,7 +5091,7 @@ s32 Camera_Unique7(Camera* camera) {
     // 0x7D0 ~ 10.98 degres.
     rwData->unk_00.x = Camera_LERPFloorS(playerPosEyeOffset.yaw, rwData->unk_00.x, 0.4f, 0x7D0);
     playerPosEyeOffset.pitch = -bgCamFuncData->rot.x * Math_CosS(playerPosEyeOffset.yaw - bgCamFuncData->rot.y);
-    Camera_Vec3fVecSphGeoAdd(at, eye, &playerPosEyeOffset);
+    Camera_AddVecGeoToVec3f(at, eye, &playerPosEyeOffset);
     camera->unk_14C |= 0x400;
     return true;
 }
@@ -5104,9 +5106,9 @@ s32 Camera_Unique9(Camera* camera) {
     Unique9ReadOnlyData* roData = &camera->paramData.uniq9.roData;
     Unique9ReadWriteData* rwData = &camera->paramData.uniq9.rwData;
     f32 invKeyFrameTimer;
-    VecSph eyeNextAtOffset;
-    VecSph scratchSph;
-    VecSph playerTargetOffset;
+    VecGeo eyeNextAtOffset;
+    VecGeo scratchGeo;
+    VecGeo playerTargetOffset;
     s16 action;
     s16 atInitFlags;
     s16 eyeInitFlags;
@@ -5207,17 +5209,17 @@ s32 Camera_Unique9(Camera* camera) {
             Actor_GetFocus(&playerhead, &camera->player->actor);
             playerhead.pos.x = playerPosRot.pos.x;
             playerhead.pos.z = playerPosRot.pos.z;
-            OLib_Vec3fDiffToVecSphGeo(&playerTargetOffset, &targethead.pos, &playerhead.pos);
+            OLib_Vec3fDiffToVecGeo(&playerTargetOffset, &targethead.pos, &playerhead.pos);
             if (atInitFlags & (s16)0x8080) {
-                scratchSph.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.x);
-                scratchSph.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.y);
-                scratchSph.r = rwData->curKeyFrame->atTargetInit.z;
+                scratchGeo.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.x);
+                scratchGeo.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.y);
+                scratchGeo.r = rwData->curKeyFrame->atTargetInit.z;
             } else {
-                OLib_Vec3fToVecSphGeo(&scratchSph, &rwData->curKeyFrame->atTargetInit);
+                OLib_Vec3fToVecGeo(&scratchGeo, &rwData->curKeyFrame->atTargetInit);
             }
-            scratchSph.yaw += playerTargetOffset.yaw;
-            scratchSph.pitch += playerTargetOffset.pitch;
-            Camera_Vec3fVecSphGeoAdd(&rwData->atTarget, &targethead.pos, &scratchSph);
+            scratchGeo.yaw += playerTargetOffset.yaw;
+            scratchGeo.pitch += playerTargetOffset.pitch;
+            Camera_AddVecGeoToVec3f(&rwData->atTarget, &targethead.pos, &scratchGeo);
         } else {
             if (camera->target == NULL) {
                 osSyncPrintf(VT_COL(YELLOW, BLACK) "camera: warning: demo C: actor is not valid\n" VT_RST);
@@ -5247,16 +5249,16 @@ s32 Camera_Unique9(Camera* camera) {
                 }
 
                 if (atInitFlags & (s16)0x8080) {
-                    scratchSph.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.x);
-                    scratchSph.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.y);
-                    scratchSph.r = rwData->curKeyFrame->atTargetInit.z;
+                    scratchGeo.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.x);
+                    scratchGeo.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->atTargetInit.y);
+                    scratchGeo.r = rwData->curKeyFrame->atTargetInit.z;
                 } else {
-                    OLib_Vec3fToVecSphGeo(&scratchSph, &rwData->curKeyFrame->atTargetInit);
+                    OLib_Vec3fToVecGeo(&scratchGeo, &rwData->curKeyFrame->atTargetInit);
                 }
 
-                scratchSph.yaw += atFocusPosRot.rot.y;
-                scratchSph.pitch -= atFocusPosRot.rot.x;
-                Camera_Vec3fVecSphGeoAdd(&rwData->atTarget, &atFocusPosRot.pos, &scratchSph);
+                scratchGeo.yaw += atFocusPosRot.rot.y;
+                scratchGeo.pitch -= atFocusPosRot.rot.x;
+                Camera_AddVecGeoToVec3f(&rwData->atTarget, &atFocusPosRot.pos, &scratchGeo);
             } else {
                 if (camera->target == NULL) {
                     osSyncPrintf(VT_COL(YELLOW, BLACK) "camera: warning: demo C: actor is not valid\n" VT_RST);
@@ -5290,7 +5292,7 @@ s32 Camera_Unique9(Camera* camera) {
             Actor_GetFocus(&playerhead, &camera->player->actor);
             playerhead.pos.x = playerPosRot.pos.x;
             playerhead.pos.z = playerPosRot.pos.z;
-            OLib_Vec3fDiffToVecSphGeo(&playerTargetOffset, &targethead.pos, &playerhead.pos);
+            OLib_Vec3fDiffToVecGeo(&playerTargetOffset, &targethead.pos, &playerhead.pos);
             if (eyeInitFlags == 0x400 || eyeInitFlags == (s16)0x8400) {
                 eyeLookAtPos = targethead.pos;
             } else {
@@ -5298,16 +5300,16 @@ s32 Camera_Unique9(Camera* camera) {
             }
 
             if (eyeInitFlags & (s16)0x8080) {
-                scratchSph.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.x);
-                scratchSph.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
-                scratchSph.r = rwData->curKeyFrame->eyeTargetInit.z;
+                scratchGeo.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.x);
+                scratchGeo.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
+                scratchGeo.r = rwData->curKeyFrame->eyeTargetInit.z;
             } else {
-                OLib_Vec3fToVecSphGeo(&scratchSph, &rwData->curKeyFrame->eyeTargetInit);
+                OLib_Vec3fToVecGeo(&scratchGeo, &rwData->curKeyFrame->eyeTargetInit);
             }
 
-            scratchSph.yaw += playerTargetOffset.yaw;
-            scratchSph.pitch += playerTargetOffset.pitch;
-            Camera_Vec3fVecSphGeoAdd(&rwData->eyeTarget, &eyeLookAtPos, &scratchSph);
+            scratchGeo.yaw += playerTargetOffset.yaw;
+            scratchGeo.pitch += playerTargetOffset.pitch;
+            Camera_AddVecGeoToVec3f(&rwData->eyeTarget, &eyeLookAtPos, &scratchGeo);
         } else {
             if (camera->target == NULL) {
                 osSyncPrintf(VT_COL(YELLOW, BLACK) "camera: warning: demo C: actor is not valid\n" VT_RST);
@@ -5339,16 +5341,16 @@ s32 Camera_Unique9(Camera* camera) {
                 }
 
                 if (eyeInitFlags & (s16)0x8080) {
-                    scratchSph.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.x);
-                    scratchSph.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
-                    scratchSph.r = rwData->curKeyFrame->eyeTargetInit.z;
+                    scratchGeo.pitch = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.x);
+                    scratchGeo.yaw = CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
+                    scratchGeo.r = rwData->curKeyFrame->eyeTargetInit.z;
                 } else {
-                    OLib_Vec3fToVecSphGeo(&scratchSph, &rwData->curKeyFrame->eyeTargetInit);
+                    OLib_Vec3fToVecGeo(&scratchGeo, &rwData->curKeyFrame->eyeTargetInit);
                 }
 
-                scratchSph.yaw += eyeFocusPosRot.rot.y;
-                scratchSph.pitch -= eyeFocusPosRot.rot.x;
-                Camera_Vec3fVecSphGeoAdd(&rwData->eyeTarget, &eyeFocusPosRot.pos, &scratchSph);
+                scratchGeo.yaw += eyeFocusPosRot.rot.y;
+                scratchGeo.pitch -= eyeFocusPosRot.rot.x;
+                Camera_AddVecGeoToVec3f(&rwData->eyeTarget, &eyeFocusPosRot.pos, &scratchGeo);
             } else {
                 if (camera->target == NULL) {
                     osSyncPrintf(VT_COL(YELLOW, BLACK) "camera: warning: demo C: actor is not valid\n" VT_RST);
@@ -5409,16 +5411,16 @@ s32 Camera_Unique9(Camera* camera) {
             camera->roll = rwData->rollTarget;
             break;
         case 1:
-            // linear interpolation of eye/at using the spherical coordinates
-            OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
-            OLib_Vec3fDiffToVecSphGeo(&rwData->atEyeOffsetTarget, &rwData->atTarget, &rwData->eyeTarget);
+            // linear interpolation of eye/at using the geographic coordinates
+            OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
+            OLib_Vec3fDiffToVecGeo(&rwData->atEyeOffsetTarget, &rwData->atTarget, &rwData->eyeTarget);
             invKeyFrameTimer = 1.0f / rwData->keyFrameTimer;
-            scratchSph.r = F32_LERPIMP(eyeNextAtOffset.r, rwData->atEyeOffsetTarget.r, invKeyFrameTimer);
-            scratchSph.pitch = eyeNextAtOffset.pitch +
+            scratchGeo.r = F32_LERPIMP(eyeNextAtOffset.r, rwData->atEyeOffsetTarget.r, invKeyFrameTimer);
+            scratchGeo.pitch = eyeNextAtOffset.pitch +
                                ((s16)(rwData->atEyeOffsetTarget.pitch - eyeNextAtOffset.pitch) * invKeyFrameTimer);
-            scratchSph.yaw =
+            scratchGeo.yaw =
                 eyeNextAtOffset.yaw + ((s16)(rwData->atEyeOffsetTarget.yaw - eyeNextAtOffset.yaw) * invKeyFrameTimer);
-            Camera_Vec3fVecSphGeoAdd(&eyeTarget, at, &scratchSph);
+            Camera_AddVecGeoToVec3f(&eyeTarget, at, &scratchGeo);
             goto setEyeNext;
         case 2:
             // linear interpolation of eye/at using the eyeTarget
@@ -5452,15 +5454,15 @@ s32 Camera_Unique9(Camera* camera) {
             break;
         case 4:
             // linear interpolation of eye/at/fov/roll using the step scale, and spherical coordinates
-            OLib_Vec3fDiffToVecSphGeo(&eyeNextAtOffset, at, eyeNext);
-            OLib_Vec3fDiffToVecSphGeo(&rwData->atEyeOffsetTarget, &rwData->atTarget, &rwData->eyeTarget);
-            scratchSph.r = Camera_LERPCeilF(rwData->atEyeOffsetTarget.r, eyeNextAtOffset.r,
+            OLib_Vec3fDiffToVecGeo(&eyeNextAtOffset, at, eyeNext);
+            OLib_Vec3fDiffToVecGeo(&rwData->atEyeOffsetTarget, &rwData->atTarget, &rwData->eyeTarget);
+            scratchGeo.r = Camera_LERPCeilF(rwData->atEyeOffsetTarget.r, eyeNextAtOffset.r,
                                             rwData->curKeyFrame->lerpStepScale, 0.1f);
-            scratchSph.pitch = Camera_LERPCeilS(rwData->atEyeOffsetTarget.pitch, eyeNextAtOffset.pitch,
+            scratchGeo.pitch = Camera_LERPCeilS(rwData->atEyeOffsetTarget.pitch, eyeNextAtOffset.pitch,
                                                 rwData->curKeyFrame->lerpStepScale, 1);
-            scratchSph.yaw = Camera_LERPCeilS(rwData->atEyeOffsetTarget.yaw, eyeNextAtOffset.yaw,
+            scratchGeo.yaw = Camera_LERPCeilS(rwData->atEyeOffsetTarget.yaw, eyeNextAtOffset.yaw,
                                               rwData->curKeyFrame->lerpStepScale, 1);
-            Camera_Vec3fVecSphGeoAdd(eyeNext, at, &scratchSph);
+            Camera_AddVecGeoToVec3f(eyeNext, at, &scratchGeo);
             goto setAtFOVRoll;
         case 3:
             // linear interplation of eye/at/fov/roll using the step scale using eyeTarget
@@ -5486,26 +5488,26 @@ s32 Camera_Unique9(Camera* camera) {
             camera->at.x = Camera_LERPCeilF(rwData->atTarget.x, camera->at.x, rwData->curKeyFrame->lerpStepScale, 1.0f);
             camera->at.y += camera->playerPosDelta.y * rwData->curKeyFrame->lerpStepScale;
             camera->at.z = Camera_LERPCeilF(rwData->atTarget.z, camera->at.z, rwData->curKeyFrame->lerpStepScale, 1.0f);
-            OLib_Vec3fDiffToVecSphGeo(&scratchSph, at, eyeNext);
-            scratchSph.yaw += CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
+            OLib_Vec3fDiffToVecGeo(&scratchGeo, at, eyeNext);
+            scratchGeo.yaw += CAM_DEG_TO_BINANG(rwData->curKeyFrame->eyeTargetInit.y);
 
             // 3A98 ~ 82.40 degrees
-            if (scratchSph.pitch >= 0x3A99) {
-                scratchSph.pitch = 0x3A98;
+            if (scratchGeo.pitch >= 0x3A99) {
+                scratchGeo.pitch = 0x3A98;
             }
 
-            if (scratchSph.pitch < -0x3A98) {
-                scratchSph.pitch = -0x3A98;
+            if (scratchGeo.pitch < -0x3A98) {
+                scratchGeo.pitch = -0x3A98;
             }
 
-            spB4 = scratchSph.r;
+            spB4 = scratchGeo.r;
             if (1) {}
-            scratchSph.r = !(spB4 < rwData->curKeyFrame->eyeTargetInit.z)
+            scratchGeo.r = !(spB4 < rwData->curKeyFrame->eyeTargetInit.z)
                                ? Camera_LERPCeilF(rwData->curKeyFrame->eyeTargetInit.z, spB4,
                                                   rwData->curKeyFrame->lerpStepScale, 1.0f)
-                               : scratchSph.r;
+                               : scratchGeo.r;
 
-            Camera_Vec3fVecSphGeoAdd(eyeNext, at, &scratchSph);
+            Camera_AddVecGeoToVec3f(eyeNext, at, &scratchGeo);
             camera->fov =
                 Camera_LERPCeilF(F32_LERPIMPINV(camera->fov, rwData->curKeyFrame->fovTargetInit, rwData->keyFrameTimer),
                                  camera->fov, rwData->curKeyFrame->lerpStepScale, 1.0f);
@@ -5603,13 +5605,13 @@ void Camera_Vec3fCopy(Vec3f* src, Vec3f* dst) {
  * Name from AC map: Camera2_CalcPos_Demo
  */
 void Camera_RotateAroundPoint(PosRot* at, Vec3f* pos, Vec3f* dst) {
-    VecSph posSph;
+    VecGeo posGeo;
     Vec3f posCopy;
 
     Camera_Vec3fCopy(pos, &posCopy);
-    OLib_Vec3fToVecSphGeo(&posSph, &posCopy);
-    posSph.yaw += at->rot.y;
-    Camera_Vec3fVecSphGeoAdd(dst, &at->pos, &posSph);
+    OLib_Vec3fToVecGeo(&posGeo, &posCopy);
+    posGeo.yaw += at->rot.y;
+    Camera_AddVecGeoToVec3f(dst, &at->pos, &posGeo);
 }
 
 /**
@@ -5699,9 +5701,9 @@ s32 Camera_Demo3(Camera* camera) {
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
     PosRot* camPlayerPosRot = &camera->playerPosRot;
-    VecSph eyeAtOffset;
-    VecSph eyeOffset;
-    VecSph atOffset;
+    VecGeo eyeAtOffset;
+    VecGeo eyeOffset;
+    VecGeo atOffset;
     Vec3f sp74;
     Vec3f sp68;
     Vec3f sp5C;
@@ -5728,7 +5730,7 @@ s32 Camera_Demo3(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, at, eye);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, at, eye);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -5759,9 +5761,9 @@ s32 Camera_Demo3(Camera* camera) {
             if (Camera_BGCheck(camera, &sp68, &sp74)) {
                 rwData->yawDir = -rwData->yawDir;
             }
-            OLib_Vec3fToVecSphGeo(&atOffset, &D_8011D678[0]);
+            OLib_Vec3fToVecGeo(&atOffset, &D_8011D678[0]);
             atOffset.yaw += camPlayerPosRot->rot.y;
-            Camera_Vec3fVecSphGeoAdd(at, &rwData->initialAt, &atOffset);
+            Camera_AddVecGeoToVec3f(at, &rwData->initialAt, &atOffset);
             eyeOffset.r = D_8011D658[0].r;
             eyeOffset.pitch = D_8011D658[0].pitch;
             eyeOffset.yaw = (D_8011D658[0].yaw * rwData->yawDir) + camPlayerPosRot->rot.y;
@@ -5774,9 +5776,9 @@ s32 Camera_Demo3(Camera* camera) {
             sp5C.y = F32_LERPIMP(D_8011D678[0].y, D_8011D678[1].y, temp_f0);
             sp5C.z = F32_LERPIMP(D_8011D678[0].z, D_8011D678[1].z, temp_f0);
 
-            OLib_Vec3fToVecSphGeo(&atOffset, &sp5C);
+            OLib_Vec3fToVecGeo(&atOffset, &sp5C);
             atOffset.yaw = (atOffset.yaw * rwData->yawDir) + camPlayerPosRot->rot.y;
-            Camera_Vec3fVecSphGeoAdd(at, &rwData->initialAt, &atOffset);
+            Camera_AddVecGeoToVec3f(at, &rwData->initialAt, &atOffset);
 
             atOffset.r = F32_LERPIMP(D_8011D658[0].r, D_8011D658[1].r, temp_f0);
             atOffset.pitch = BINANG_LERPIMP(D_8011D658[0].pitch, D_8011D658[1].pitch, temp_f0);
@@ -5796,9 +5798,9 @@ s32 Camera_Demo3(Camera* camera) {
             sp5C.y += yOffset;
             sp5C.z = F32_LERPIMP(D_8011D678[1].z, D_8011D678[2].z, temp_f0);
 
-            OLib_Vec3fToVecSphGeo(&atOffset, &sp5C);
+            OLib_Vec3fToVecGeo(&atOffset, &sp5C);
             atOffset.yaw = (atOffset.yaw * rwData->yawDir) + camPlayerPosRot->rot.y;
-            Camera_Vec3fVecSphGeoAdd(at, &rwData->initialAt, &atOffset);
+            Camera_AddVecGeoToVec3f(at, &rwData->initialAt, &atOffset);
 
             atOffset.r = F32_LERPIMP(D_8011D658[1].r, D_8011D658[2].r, temp_f0);
             atOffset.pitch = BINANG_LERPIMP(D_8011D658[1].pitch, D_8011D658[2].pitch, temp_f0);
@@ -5817,9 +5819,9 @@ s32 Camera_Demo3(Camera* camera) {
             sp5C.y += yOffset;
             sp5C.z = F32_LERPIMP(D_8011D678[2].z, D_8011D678[3].z, temp_f0);
 
-            OLib_Vec3fToVecSphGeo(&atOffset, &sp5C);
+            OLib_Vec3fToVecGeo(&atOffset, &sp5C);
             atOffset.yaw = (atOffset.yaw * rwData->yawDir) + camPlayerPosRot->rot.y;
-            Camera_Vec3fVecSphGeoAdd(at, &rwData->initialAt, &atOffset);
+            Camera_AddVecGeoToVec3f(at, &rwData->initialAt, &atOffset);
 
             atOffset.r = F32_LERPIMP(D_8011D658[2].r, D_8011D658[3].r, temp_f0);
             atOffset.pitch = BINANG_LERPIMP(D_8011D658[2].pitch, D_8011D658[3].pitch, temp_f0);
@@ -5897,7 +5899,7 @@ s32 Camera_Demo3(Camera* camera) {
         eyeOffset.r = Camera_LERPCeilF(eyeOffset.r, eyeAtOffset.r, rwData->unk_0C, 2.0f);
         eyeOffset.pitch = Camera_LERPCeilS(eyeOffset.pitch, eyeAtOffset.pitch, rwData->unk_0C, 0xA);
         eyeOffset.yaw = Camera_LERPCeilS(eyeOffset.yaw, eyeAtOffset.yaw, rwData->unk_0C, 0xA);
-        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeOffset);
+        Camera_AddVecGeoToVec3f(eyeNext, at, &eyeOffset);
         *eye = *eyeNext;
     }
 
@@ -5919,8 +5921,8 @@ s32 Camera_Demo4(Camera* camera) {
 s32 Camera_Demo5(Camera* camera) {
     f32 eyeTargetDist;
     f32 sp90;
-    VecSph playerTargetGeo;
-    VecSph eyePlayerGeo;
+    VecGeo playerTargetGeo;
+    VecGeo eyePlayerGeo;
     s16 targetScreenPosX;
     s16 targetScreenPosY;
     s32 pad1;
@@ -5944,11 +5946,11 @@ s32 Camera_Demo5(Camera* camera) {
         return true;
     }
     Actor_GetFocus(&camera->targetPosRot, camera->target);
-    OLib_Vec3fDiffToVecSphGeo(&playerTargetGeo, &camera->targetPosRot.pos, &camera->playerPosRot.pos);
+    OLib_Vec3fDiffToVecGeo(&playerTargetGeo, &camera->targetPosRot.pos, &camera->playerPosRot.pos);
     D_8011D3AC = camera->target->category;
     Actor_GetScreenPos(camera->play, camera->target, &targetScreenPosX, &targetScreenPosY);
     eyeTargetDist = OLib_Vec3fDist(&camera->targetPosRot.pos, &camera->eye);
-    OLib_Vec3fDiffToVecSphGeo(&eyePlayerGeo, &playerhead.pos, &camera->eyeNext);
+    OLib_Vec3fDiffToVecGeo(&eyePlayerGeo, &playerhead.pos, &camera->eyeNext);
     sp4A = eyePlayerGeo.yaw - playerTargetGeo.yaw;
     if (camera->target->category == ACTORCAT_PLAYER) {
         // camera is targeting a(the) player actor
@@ -6152,7 +6154,7 @@ s32 Camera_Demo6(Camera* camera) {
     Demo6ReadOnlyData* roData = &camera->paramData.demo6.roData;
     Vec3f* eyeNext = &camera->eyeNext;
     CameraModeValue* values;
-    VecSph eyeOffset;
+    VecGeo eyeOffset;
     Actor* camFocus;
     PosRot focusPosRot;
     s16 stateTimers[4];
@@ -6187,7 +6189,7 @@ s32 Camera_Demo6(Camera* camera) {
             eyeOffset.yaw = Camera_XZAngle(&focusPosRot.pos, &mainCam->playerPosRot.pos) + 0x7D0;
             // -0x3E8 ~5.49 degrees
             eyeOffset.pitch = -0x3E8;
-            Camera_Vec3fVecSphGeoAdd(eyeNext, &camera->at, &eyeOffset);
+            Camera_AddVecGeoToVec3f(eyeNext, &camera->at, &eyeOffset);
             camera->eye = *eyeNext;
             camera->animState++;
             FALLTHROUGH;
@@ -6490,10 +6492,10 @@ s32 Camera_Special5(Camera* camera) {
     s16 pad;
     s16 spA4;
     CamColChk sp7C;
-    VecSph sp74;
-    VecSph sp6C;
-    VecSph sp64;
-    VecSph sp5C;
+    VecGeo sp74;
+    VecGeo sp6C;
+    VecGeo sp64;
+    VecGeo sp5C;
     PosRot* playerPosRot = &camera->playerPosRot;
     Special5ReadOnlyData* roData = &camera->paramData.spec5.roData;
     Special5ReadWriteData* rwData = &camera->paramData.spec5.rwData;
@@ -6520,8 +6522,8 @@ s32 Camera_Special5(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&sp64, at, eye);
-    OLib_Vec3fDiffToVecSphGeo(&sp5C, at, eyeNext);
+    OLib_Vec3fDiffToVecGeo(&sp64, at, eye);
+    OLib_Vec3fDiffToVecGeo(&sp5C, at, eyeNext);
     Actor_GetWorld(&spA8, camera->target);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
@@ -6544,9 +6546,9 @@ s32 Camera_Special5(Camera* camera) {
             sp6C.yaw = playerPosRot->rot.y;
             sp6C.pitch = -playerPosRot->rot.x;
             sp6C.r = 20.0f;
-            Camera_Vec3fVecSphGeoAdd(&sp7C.pos, &spA8.pos, &sp6C);
+            Camera_AddVecGeoToVec3f(&sp7C.pos, &spA8.pos, &sp6C);
             Camera_BGCheckInfo(camera, at, &sp7C);
-            OLib_Vec3fToVecSphGeo(&sp6C, &sp7C.norm);
+            OLib_Vec3fToVecGeo(&sp6C, &sp7C.norm);
             spA4 = playerPosRot->rot.y - sp6C.yaw;
             sp74.r = roData->eyeDist;
             temp_f0_2 = Rand_ZeroOne();
@@ -6554,7 +6556,7 @@ s32 Camera_Special5(Camera* camera) {
                 (s16)(playerPosRot->rot.y - 0x7FFF) + (s16)(spA4 < 0 ? -(s16)(0x1553 + (s16)(temp_f0_2 * 2730.0f))
                                                                      : (s16)(0x1553 + (s16)(temp_f0_2 * 2730.0f)));
             sp74.pitch = roData->pitch;
-            Camera_Vec3fVecSphGeoAdd(eyeNext, &spA8.pos, &sp74);
+            Camera_AddVecGeoToVec3f(eyeNext, &spA8.pos, &sp74);
             *eye = *eyeNext;
             Camera_BGCheck(camera, &spA8.pos, eye);
         }
@@ -6631,12 +6633,12 @@ s32 Camera_Special6(Camera* camera) {
     Vec3f* eye = &camera->eye;
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
-    VecSph atOffset;
+    VecGeo atOffset;
     Vec3f bgCamPos;
     Vec3f eyePosCalc;
     Vec3f eyeAnim;
     Vec3f atAnim;
-    VecSph eyeAtOffset;
+    VecGeo eyeAtOffset;
     PosRot* playerPosRot = &camera->playerPosRot;
     BgCamFuncData* bgCamFuncData;
     Vec3s bgCamRot;
@@ -6658,7 +6660,7 @@ s32 Camera_Special6(Camera* camera) {
         Camera_CopyPREGToModeValues(camera);
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&eyeAtOffset, eye, at);
+    OLib_Vec3fDiffToVecGeo(&eyeAtOffset, eye, at);
 
     bgCamFuncData = (BgCamFuncData*)Camera_GetBgCamFuncData(camera);
     Camera_Vec3sToVec3f(&bgCamPos, &bgCamFuncData->pos);
@@ -6701,7 +6703,7 @@ s32 Camera_Special6(Camera* camera) {
         atOffset.r = 100.0f;
         atOffset.yaw = bgCamRot.y;
         atOffset.pitch = -bgCamRot.x;
-        Camera_Vec3fVecSphGeoAdd(&atAnim, &eyeAnim, &atOffset);
+        Camera_AddVecGeoToVec3f(&atAnim, &eyeAnim, &atOffset);
         timerDivisor = 1.0f / timerF;
         eye->x += (eyeAnim.x - eye->x) * timerDivisor;
         eye->y += (eyeAnim.y - eye->y) * timerDivisor;
@@ -6725,7 +6727,7 @@ s32 Camera_Special6(Camera* camera) {
         atOffset.r = 100.0f;
         atOffset.yaw = bgCamRot.y;
         atOffset.pitch = -bgCamRot.x;
-        Camera_Vec3fVecSphGeoAdd(at, eye, &atOffset);
+        Camera_AddVecGeoToVec3f(at, eye, &atOffset);
     }
     return true;
 }
@@ -6740,8 +6742,8 @@ s32 Camera_Special9(Camera* camera) {
     Vec3f* at = &camera->at;
     Vec3f* eyeNext = &camera->eyeNext;
     Vec3f spAC;
-    VecSph eyeAdjustment;
-    VecSph atEyeOffsetGeo;
+    VecGeo eyeAdjustment;
+    VecGeo atEyeOffsetGeo;
     f32 playerYOffset;
     s32 pad3;
     PosRot* playerPosRot = &camera->playerPosRot;
@@ -6778,7 +6780,7 @@ s32 Camera_Special9(Camera* camera) {
         adjustedPlayerPosRot.rot.x = 0;
     }
 
-    OLib_Vec3fDiffToVecSphGeo(&atEyeOffsetGeo, at, eye);
+    OLib_Vec3fDiffToVecGeo(&atEyeOffsetGeo, at, eye);
 
     sCameraInterfaceFlags = roData->interfaceFlags;
 
@@ -6809,12 +6811,12 @@ s32 Camera_Special9(Camera* camera) {
                     yaw = 0xAAA * ((camera->play->state.frames & 1) ? 1 : -1);
                     eyeAdjustment.yaw = rwData->targetYaw + yaw;
                     eyeAdjustment.r = 200.0f * yNormal;
-                    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeAdjustment);
+                    Camera_AddVecGeoToVec3f(eyeNext, at, &eyeAdjustment);
                     spAC = *eye = *eyeNext;
                     if (Camera_CheckOOB(camera, &spAC, &playerPosRot->pos)) {
                         yaw = -yaw;
                         eyeAdjustment.yaw = rwData->targetYaw + yaw;
-                        Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeAdjustment);
+                        Camera_AddVecGeoToVec3f(eyeNext, at, &eyeAdjustment);
                         *eye = *eyeNext;
                     }
                 }
@@ -6842,7 +6844,7 @@ s32 Camera_Special9(Camera* camera) {
             eyeAdjustment.pitch = Camera_LERPCeilS(0xAAA, atEyeOffsetGeo.pitch, 0.3f, 0xA);
             eyeAdjustment.yaw = Camera_LERPCeilS(rwData->targetYaw, atEyeOffsetGeo.yaw, 0.3f, 0xA);
             eyeAdjustment.r = Camera_LERPCeilF(60.0f, atEyeOffsetGeo.r, 0.3f, 1.0f);
-            Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeAdjustment);
+            Camera_AddVecGeoToVec3f(eyeNext, at, &eyeAdjustment);
             *eye = *eyeNext;
             doorParams->timer3--;
             if (doorParams->timer3 <= 0) {
@@ -7015,7 +7017,7 @@ void Camera_Stub80058140(Camera* camera) {
 
 void Camera_InitPlayerSettings(Camera* camera, Player* player) {
     PosRot playerPosShape;
-    VecSph eyeNextAtOffset;
+    VecGeo eyeNextAtOffset;
     s32 bgId;
     Vec3f floorPos;
     s32 upXZ;
@@ -7043,7 +7045,7 @@ void Camera_InitPlayerSettings(Camera* camera, Player* player) {
     camera->posOffset.y = playerYOffset;
     camera->posOffset.z = 0;
 
-    Camera_Vec3fVecSphGeoAdd(eyeNext, at, &eyeNextAtOffset);
+    Camera_AddVecGeoToVec3f(eyeNext, at, &eyeNextAtOffset);
     *eye = *eyeNext;
     camera->roll = 0;
 
@@ -7440,7 +7442,7 @@ Vec3s Camera_Update(Camera* camera) {
     s32 bgId;
     f32 playerGroundY;
     f32 playerXZSpeed;
-    VecSph eyeAtAngle;
+    VecGeo eyeAtAngle;
     s16 bgCamIndex;
     s16 numQuakesApplied;
     PosRot curPlayerPosRot;
@@ -7546,7 +7548,7 @@ Vec3s Camera_Update(Camera* camera) {
     if (sOOBTimer < 200) {
         sCameraFunctions[sCameraSettings[camera->setting].cameraModes[camera->mode].funcIdx](camera);
     } else if (camera->player != NULL) {
-        OLib_Vec3fDiffToVecSphGeo(&eyeAtAngle, &camera->at, &camera->eye);
+        OLib_Vec3fDiffToVecGeo(&eyeAtAngle, &camera->at, &camera->eye);
         Camera_CalcAtDefault(camera, &eyeAtAngle, 0.0f, 0);
     }
 
@@ -7620,14 +7622,14 @@ Vec3s Camera_Update(Camera* camera) {
         viewEye.y = camera->eye.y + camShake.eyeOffset.y;
         viewEye.z = camera->eye.z + camShake.eyeOffset.z;
 
-        OLib_Vec3fDiffToVecSphGeo(&eyeAtAngle, &viewEye, &viewAt);
+        OLib_Vec3fDiffToVecGeo(&eyeAtAngle, &viewEye, &viewAt);
         Camera_CalcUpFromPitchYawRoll(&viewUp, eyeAtAngle.pitch + camShake.upPitchOffset,
                                       eyeAtAngle.yaw + camShake.upYawOffset, camera->roll);
         viewFov = camera->fov + CAM_BINANG_TO_DEG(camShake.fovOffset);
     } else {
         viewAt = camera->at;
         viewEye = camera->eye;
-        OLib_Vec3fDiffToVecSphGeo(&eyeAtAngle, &viewEye, &viewAt);
+        OLib_Vec3fDiffToVecGeo(&eyeAtAngle, &viewEye, &viewAt);
         Camera_CalcUpFromPitchYawRoll(&viewUp, eyeAtAngle.pitch, eyeAtAngle.yaw, camera->roll);
         viewFov = camera->fov;
     }
diff --git a/src/code/z_olib.c b/src/code/z_olib.c
index 0bfb0d2f2..e89a0b348 100644
--- a/src/code/z_olib.c
+++ b/src/code/z_olib.c
@@ -93,16 +93,16 @@ Vec3f* OLib_VecSphToVec3f(Vec3f* dest, VecSph* sph) {
 }
 
 /**
- * Takes the geographic point `sph` and converts it into a x,y,z position
+ * Takes the geographic point `geo` and converts it into a x,y,z position
  */
-Vec3f* OLib_VecSphGeoToVec3f(Vec3f* dest, VecSph* sph) {
-    VecSph geo;
+Vec3f* OLib_VecGeoToVec3f(Vec3f* dest, VecGeo* geo) {
+    VecSph sph;
 
-    geo.r = sph->r;
-    geo.pitch = 0x3FFF - sph->pitch;
-    geo.yaw = sph->yaw;
+    sph.r = geo->r;
+    sph.pitch = 0x3FFF - geo->pitch;
+    sph.yaw = geo->yaw;
 
-    return OLib_VecSphToVec3f(dest, &geo);
+    return OLib_VecSphToVec3f(dest, &sph);
 }
 
 /**
@@ -110,17 +110,16 @@ Vec3f* OLib_VecSphGeoToVec3f(Vec3f* dest, VecSph* sph) {
  */
 VecSph* OLib_Vec3fToVecSph(VecSph* dest, Vec3f* vec) {
     VecSph sph;
+    f32 distXZSq = SQ(vec->x) + SQ(vec->z);
+    f32 distXZ = sqrtf(distXZSq);
 
-    f32 distSquared = SQ(vec->x) + SQ(vec->z);
-    f32 dist = sqrtf(distSquared);
-
-    if ((dist == 0.0f) && (vec->y == 0.0f)) {
+    if ((distXZ == 0.0f) && (vec->y == 0.0f)) {
         sph.pitch = 0;
     } else {
-        sph.pitch = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(dist, vec->y)));
+        sph.pitch = CAM_DEG_TO_BINANG(RAD_TO_DEG(Math_FAtan2F(distXZ, vec->y)));
     }
 
-    sph.r = sqrtf(SQ(vec->y) + distSquared);
+    sph.r = sqrtf(SQ(vec->y) + distXZSq);
     if ((vec->x == 0.0f) && (vec->z == 0.0f)) {
         sph.yaw = 0;
     } else {
@@ -135,7 +134,7 @@ VecSph* OLib_Vec3fToVecSph(VecSph* dest, Vec3f* vec) {
 /**
  * Takes the point `vec`, and converts it to a geographic coordinate
  */
-VecSph* OLib_Vec3fToVecSphGeo(VecSph* dest, Vec3f* vec) {
+VecGeo* OLib_Vec3fToVecGeo(VecGeo* dest, Vec3f* vec) {
     VecSph sph;
 
     OLib_Vec3fToVecSph(&sph, vec);
@@ -150,26 +149,26 @@ VecSph* OLib_Vec3fToVecSphGeo(VecSph* dest, Vec3f* vec) {
  * Takes the differences of positions `a` and `b`, and converts them to spherical coordinates
  */
 VecSph* OLib_Vec3fDiffToVecSph(VecSph* dest, Vec3f* a, Vec3f* b) {
-    Vec3f sph;
+    Vec3f diff;
 
-    sph.x = b->x - a->x;
-    sph.y = b->y - a->y;
-    sph.z = b->z - a->z;
+    diff.x = b->x - a->x;
+    diff.y = b->y - a->y;
+    diff.z = b->z - a->z;
 
-    return OLib_Vec3fToVecSph(dest, &sph);
+    return OLib_Vec3fToVecSph(dest, &diff);
 }
 
 /**
  * Takes the difference of positions `a` and `b`, and converts them to geographic coordinates
  */
-VecSph* OLib_Vec3fDiffToVecSphGeo(VecSph* dest, Vec3f* a, Vec3f* b) {
-    Vec3f sph;
+VecGeo* OLib_Vec3fDiffToVecGeo(VecGeo* dest, Vec3f* a, Vec3f* b) {
+    Vec3f diff;
 
-    sph.x = b->x - a->x;
-    sph.y = b->y - a->y;
-    sph.z = b->z - a->z;
+    diff.x = b->x - a->x;
+    diff.y = b->y - a->y;
+    diff.z = b->z - a->z;
 
-    return OLib_Vec3fToVecSphGeo(dest, &sph);
+    return OLib_Vec3fToVecGeo(dest, &diff);
 }
 
 /**
diff --git a/src/code/z_onepointdemo.c b/src/code/z_onepointdemo.c
index 9d62b8910..dc3a67531 100644
--- a/src/code/z_onepointdemo.c
+++ b/src/code/z_onepointdemo.c
@@ -9,17 +9,19 @@ static s32 sPrevFrameCs1100 = -4096;
 
 #include "z_onepointdemo_data.inc.c"
 
-void OnePointCutscene_AddVecSphToVec3f(Vec3f* dst, Vec3f* src, VecSph* vecSph) {
-    Vec3f out;
-    Vec3f vec;
+Vec3f* OnePointCutscene_AddVecGeoToVec3f(Vec3f* dest, Vec3f* a, VecGeo* geo) {
+    Vec3f sum;
+    Vec3f b;
 
-    OLib_VecSphGeoToVec3f(&vec, vecSph);
+    OLib_VecGeoToVec3f(&b, geo);
 
-    out.x = src->x + vec.x;
-    out.y = src->y + vec.y;
-    out.z = src->z + vec.z;
-    if (dst) {}
-    *dst = out;
+    sum.x = a->x + b.x;
+    sum.y = a->y + b.y;
+    sum.z = a->z + b.z;
+
+    *dest = sum;
+
+    return dest;
 }
 
 s16 OnePointCutscene_Vec3fYaw(Vec3f* vec1, Vec3f* vec2) {
@@ -62,7 +64,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
     Camera* childCam = play->cameraPtrs[subCam->childCamId];
     Camera* mainCam = play->cameraPtrs[CAM_ID_MAIN];
     Player* player = mainCam->player;
-    VecSph spD0;
+    VecGeo spD0;
     s32 i;
     Vec3f spC0;
     Vec3f spB4;
@@ -95,7 +97,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             D_80120964[0].atTargetInit = play->view.at;
             D_80120964[0].eyeTargetInit = play->view.eye;
             D_80120964[0].fovTargetInit = play->view.fovy;
-            OLib_Vec3fDiffToVecSphGeo(&spD0, &mainCam->at, &mainCam->eye);
+            OLib_Vec3fDiffToVecGeo(&spD0, &mainCam->at, &mainCam->eye);
             D_80120964[1].eyeTargetInit.y = CAM_BINANG_TO_DEG(spD0.yaw);
             D_80120964[1].timerInit = timer - 1;
 
@@ -108,9 +110,9 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             D_801209B4[0].atTargetInit = D_801209B4[1].atTargetInit = play->view.at;
             D_801209B4[0].eyeTargetInit = play->view.eye;
             D_801209B4[0].fovTargetInit = D_801209B4[2].fovTargetInit = play->view.fovy;
-            OLib_Vec3fDiffToVecSphGeo(&spD0, &actor->focus.pos, &mainCam->at);
+            OLib_Vec3fDiffToVecGeo(&spD0, &actor->focus.pos, &mainCam->at);
             spD0.r = mainCam->dist;
-            OnePointCutscene_AddVecSphToVec3f(&D_801209B4[1].eyeTargetInit, &D_801209B4[1].atTargetInit, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&D_801209B4[1].eyeTargetInit, &D_801209B4[1].atTargetInit, &spD0);
             D_801209B4[1].atTargetInit.y += 20.0f;
 
             csInfo->keyFrames = D_801209B4;
@@ -298,7 +300,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spD0.yaw = spA0.rot.y;
             spD0.pitch = 0x3E8;
 
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraChangeSetting(play, subCamId, CAM_SET_FREE2);
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             func_8002DF54(play, NULL, 8);
@@ -309,7 +311,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             }
             break;
         case 2210:
-            OLib_Vec3fDiffToVecSphGeo(&spD0, &player->actor.world.pos, &actor->world.pos);
+            OLib_Vec3fDiffToVecGeo(&spD0, &player->actor.world.pos, &actor->world.pos);
             D_801213B4[0].eyeTargetInit.y = D_801213B4[1].eyeTargetInit.y = D_801213B4[2].eyeTargetInit.y =
                 D_801213B4[2].atTargetInit.y = CAM_BINANG_TO_DEG(spD0.yaw);
             if (Rand_ZeroOne() < 0.0f) {
@@ -521,7 +523,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spD0.r = 250.0f;
             Actor_GetWorld(&spA0, &player->actor);
             spD0.yaw = OnePointCutscene_Vec3fYaw(&spC0, &spA0.pos) - 0x7D0;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraChangeSetting(play, subCamId, CAM_SET_FREE2);
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             Play_CopyCamera(play, CAM_ID_MAIN, subCamId);
@@ -535,7 +537,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spD0.pitch = 0;
             spD0.yaw = spA0.rot.y;
             spD0.r = 150.0f;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraChangeSetting(play, subCamId, CAM_SET_FREE2);
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             subCam->roll = 0;
@@ -549,7 +551,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spD0.r = 300.0f;
             spD0.yaw = spA0.rot.y;
             spD0.pitch = -0xAF0;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraChangeSetting(play, subCamId, CAM_SET_FREE2);
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             subCam->roll = 0;
@@ -578,10 +580,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spC0.x = sp8C.pos.x;
             spC0.y = sp8C.pos.y + 70.0f;
             spC0.z = sp8C.pos.z;
-            OLib_Vec3fDiffToVecSphGeo(&spD0, &spA0.pos, &sp8C.pos);
+            OLib_Vec3fDiffToVecGeo(&spD0, &spA0.pos, &sp8C.pos);
             spD0.pitch = 0x5DC;
             spD0.r = 120.0f;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraSetAtEye(play, CAM_ID_MAIN, &spC0, &spB4);
 
             i = Quake_Request(subCam, QUAKE_TYPE_3);
@@ -596,7 +598,7 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spC0.y += 70.0f;
             spD0.yaw = spA0.rot.y + 0x7FFF;
             spD0.r = 300.0f;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             Play_CameraChangeSetting(play, subCamId, CAM_SET_FREE2);
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             subCam->roll = 0;
@@ -608,10 +610,10 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
             spC0 = spA0.pos;
             func_800C0808(play, subCamId, player, CAM_SET_PIVOT_VERTICAL);
             Actor_GetWorld(&spA0, &player->actor);
-            OLib_Vec3fDiffToVecSphGeo(&spD0, &spC0, &spA0.pos);
+            OLib_Vec3fDiffToVecGeo(&spD0, &spC0, &spA0.pos);
             spD0.yaw += 0x3E8;
             spD0.r = 400.0f;
-            OnePointCutscene_AddVecSphToVec3f(&spB4, &spC0, &spD0);
+            OnePointCutscene_AddVecGeoToVec3f(&spB4, &spC0, &spD0);
             spB4.y = spA0.pos.y + 60.0f;
             Play_CameraSetAtEye(play, subCamId, &spC0, &spB4);
             subCam->roll = 0;
@@ -971,12 +973,12 @@ s32 OnePointCutscene_SetInfo(PlayState* play, s16 subCamId, s16 csId, Actor* act
                     D_801231B4[2].atTargetInit.z = 0.0f;
                 }
                 Actor_GetWorldPosShapeRot(&spA0, &player->actor);
-                OLib_Vec3fDiffToVecSphGeo(&spD0, &spA0.pos, &mainCam->at);
+                OLib_Vec3fDiffToVecGeo(&spD0, &spA0.pos, &mainCam->at);
                 spD0.yaw -= spA0.rot.y;
-                OLib_VecSphGeoToVec3f(&D_801231B4[3].atTargetInit, &spD0);
-                OLib_Vec3fDiffToVecSphGeo(&spD0, &spA0.pos, &mainCam->eye);
+                OLib_VecGeoToVec3f(&D_801231B4[3].atTargetInit, &spD0);
+                OLib_Vec3fDiffToVecGeo(&spD0, &spA0.pos, &mainCam->eye);
                 spD0.yaw -= spA0.rot.y;
-                OLib_VecSphGeoToVec3f(&D_801231B4[3].eyeTargetInit, &spD0);
+                OLib_VecGeoToVec3f(&D_801231B4[3].eyeTargetInit, &spD0);
                 D_801231B4[3].fovTargetInit = mainCam->fov;
                 D_801231B4[3].timerInit = timer - 50;
 
diff --git a/src/code/z_quake.c b/src/code/z_quake.c
index d2538b5dd..0f50b598b 100644
--- a/src/code/z_quake.c
+++ b/src/code/z_quake.c
@@ -22,11 +22,11 @@ QuakeRequest sQuakeRequests[4];
 s16 sQuakeUnused = 1;
 s16 sQuakeRequestCount = 0;
 
-Vec3f* Quake_VecSphGeoAddToVec3f(Vec3f* dst, Vec3f* a, VecSph* sph) {
+Vec3f* Quake_AddVecGeoToVec3f(Vec3f* dst, Vec3f* a, VecGeo* geo) {
     Vec3f vec;
     Vec3f b;
 
-    OLib_VecSphGeoToVec3f(&b, sph);
+    OLib_VecGeoToVec3f(&b, geo);
     vec.x = a->x + b.x;
     vec.y = a->y + b.y;
     vec.z = a->z + b.z;
@@ -40,38 +40,38 @@ void Quake_UpdateShakeInfo(QuakeRequest* req, ShakeInfo* shake, f32 y, f32 x) {
     Vec3f* at = &req->cam->at;
     Vec3f* eye = &req->cam->eye;
     Vec3f offset;
-    VecSph sph;
-    VecSph eyeToAtSph;
+    VecGeo geo;
+    VecGeo eyeToAtGeo;
 
     if (req->isRelativeToScreen) {
         offset.x = 0;
         offset.y = 0;
         offset.z = 0;
-        OLib_Vec3fDiffToVecSphGeo(&eyeToAtSph, eye, at);
+        OLib_Vec3fDiffToVecGeo(&eyeToAtGeo, eye, at);
 
         // y shake
-        sph.r = req->y * y;
+        geo.r = req->y * y;
         // point unit vector up, then add on `req->orientation`
-        sph.pitch = eyeToAtSph.pitch + req->orientation.x + 0x4000;
-        sph.yaw = eyeToAtSph.yaw + req->orientation.y;
+        geo.pitch = eyeToAtGeo.pitch + req->orientation.x + 0x4000;
+        geo.yaw = eyeToAtGeo.yaw + req->orientation.y;
         // apply y shake
-        Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
+        Quake_AddVecGeoToVec3f(&offset, &offset, &geo);
 
         // x shake
-        sph.r = req->x * x;
+        geo.r = req->x * x;
         // point unit vector left, then add on `req->orientation`
-        sph.pitch = eyeToAtSph.pitch + req->orientation.x;
-        sph.yaw = eyeToAtSph.yaw + req->orientation.y + 0x4000;
+        geo.pitch = eyeToAtGeo.pitch + req->orientation.x;
+        geo.yaw = eyeToAtGeo.yaw + req->orientation.y + 0x4000;
         // apply x shake
-        Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
+        Quake_AddVecGeoToVec3f(&offset, &offset, &geo);
     } else {
         offset.x = 0;
         offset.y = req->y * y;
         offset.z = 0;
-        sph.r = req->x * x;
-        sph.pitch = req->orientation.x;
-        sph.yaw = req->orientation.y;
-        Quake_VecSphGeoAddToVec3f(&offset, &offset, &sph);
+        geo.r = req->x * x;
+        geo.pitch = req->orientation.x;
+        geo.yaw = req->orientation.y;
+        Quake_AddVecGeoToVec3f(&offset, &offset, &geo);
     }
 
     shake->atOffset = shake->eyeOffset = offset;