diff --git a/include/common_structs.h b/include/common_structs.h
index b5efa387a..7bab26f8e 100644
--- a/include/common_structs.h
+++ b/include/common_structs.h
@@ -7,12 +7,27 @@
 #include <ultra64.h>
 #endif
 
-typedef f32 Vec3f[3];
-typedef f32 Vec4f[4];
+typedef struct Vec4f {
+    /* 0x0 */ f32 x;
+    /* 0x4 */ f32 y;
+    /* 0x8 */ f32 z;
+    /* 0xC */ f32 w;
+} Vec4f; // size = 0x10
+
+typedef struct {
+    /* 0x0 */ f32 x;
+    /* 0x4 */ f32 y;
+    /* 0x8 */ f32 z;
+} Vec3f; // size = 0xC
+
+typedef struct {
+    /* 0x0 */ s16 x;
+    /* 0x2 */ s16 y;
+    /* 0x4 */ s16 z;
+} Vec3s; // size = 0x6;
 
 typedef s32 Vec3iu[3];
 
-typedef s16 Vec3s[3];
 typedef u16 Vec3su[3];
 typedef s16 Vec4s[4];
 
diff --git a/src/actors/banana/render.inc.c b/src/actors/banana/render.inc.c
index e33938bd2..7e9b41eca 100644
--- a/src/actors/banana/render.inc.c
+++ b/src/actors/banana/render.inc.c
@@ -15,7 +15,7 @@ void render_actor_banana(Camera* camera, UNUSED Mat4 arg1, struct BananaActor* b
     Vec3s sp7C;
     Mat4 sp3C;
 
-    f32 temp = is_within_render_distance(camera->pos, banana->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
+    f32 temp = is_within_render_distance(camera->pos, banana->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
                                          490000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp = MAX(temp, 0.0f);
@@ -25,11 +25,11 @@ void render_actor_banana(Camera* camera, UNUSED Mat4 arg1, struct BananaActor* b
         return;
     }
 
-    if ((banana->pos[1] > gCourseMaxY + 800.0f)) {
+    if ((banana->pos.y > gCourseMaxY + 800.0f)) {
         actor_not_rendered(camera, (struct Actor*) banana);
         return;
     }
-    if (banana->pos[1] < (gCourseMinY - 800.0f)) {
+    if (banana->pos.y < (gCourseMinY - 800.0f)) {
         actor_not_rendered(camera, (struct Actor*) banana);
         return;
     }
diff --git a/src/actors/banana/update.inc.c b/src/actors/banana/update.inc.c
index cd7b70078..def009af0 100644
--- a/src/actors/banana/update.inc.c
+++ b/src/actors/banana/update.inc.c
@@ -31,24 +31,24 @@ void update_actor_banana(struct BananaActor* banana) {
     player = &gPlayers[banana->playerId];
     switch (banana->state) {
         case HELD_BANANA:
-            temp_f2 = player->pos[0] - banana->pos[0];
-            temp_f14 = player->pos[1] - banana->pos[1];
-            temp_f16 = player->pos[2] - banana->pos[2];
+            temp_f2 = player->pos.x - banana->pos.x;
+            temp_f14 = player->pos.y - banana->pos.y;
+            temp_f16 = player->pos.z - banana->pos.z;
             temp_f12 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16)) / 10.0f;
             if (temp_f12 == 0.0f) {
-                banana->pos[0] = player->pos[0] + 0.2f;
-                banana->pos[1] = player->pos[1] + 0.2f;
-                banana->pos[2] = player->pos[2] + 0.2f;
+                banana->pos.x = player->pos.x + 0.2f;
+                banana->pos.y = player->pos.y + 0.2f;
+                banana->pos.z = player->pos.z + 0.2f;
             } else {
                 temp_f2 /= temp_f12;
                 temp_f14 /= temp_f12;
                 temp_f16 /= temp_f12;
-                banana->pos[0] = player->pos[0] - temp_f2;
-                banana->pos[1] = player->pos[1] - temp_f14 - 2.0f;
-                banana->pos[2] = player->pos[2] - temp_f16;
+                banana->pos.x = player->pos.x - temp_f2;
+                banana->pos.y = player->pos.y - temp_f14 - 2.0f;
+                banana->pos.z = player->pos.z - temp_f16;
             }
-            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
-                                     banana->pos[2]);
+            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
+                                     banana->pos.z);
             func_802B4E30((struct Actor*) banana);
             if ((player->type & PLAYER_HUMAN) != 0) {
                 if (gDemoMode) {
@@ -73,13 +73,13 @@ void update_actor_banana(struct BananaActor* banana) {
                         }
                         vec3f_set(someVelocity, 0, pad3, temp_f0);
                         func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
-                        banana->velocity[0] = someVelocity[0];
-                        banana->velocity[1] = someVelocity[1];
-                        banana->velocity[2] = someVelocity[2];
+                        banana->velocity.x = someVelocity[0];
+                        banana->velocity.y = someVelocity[1];
+                        banana->velocity.z = someVelocity[2];
                     } else {
-                        banana->velocity[0] = 0;
-                        banana->velocity[1] = 1.5f;
-                        banana->velocity[2] = 0;
+                        banana->velocity.x = 0;
+                        banana->velocity.y = 1.5f;
+                        banana->velocity.z = 0;
                     }
                 }
             }
@@ -91,27 +91,27 @@ void update_actor_banana(struct BananaActor* banana) {
                     banana->flags &= ~0x1000;
                 }
             }
-            banana->pos[0] += banana->velocity[0];
-            banana->pos[2] += banana->velocity[2];
-            if (banana->velocity[1] > -1.0f) {
-                banana->velocity[1] -= 0.15f;
+            banana->pos.x += banana->velocity.x;
+            banana->pos.z += banana->velocity.z;
+            if (banana->velocity.y > -1.0f) {
+                banana->velocity.y -= 0.15f;
             }
-            banana->pos[1] += banana->velocity[1];
-            if ((banana->pos[2] < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < banana->pos[2]) ||
-                (banana->pos[0] < (f32) gCourseMinX) || ((f32) gCourseMaxX < banana->pos[0]) ||
-                (banana->pos[1] < (f32) gCourseMinY)) {
+            banana->pos.y += banana->velocity.y;
+            if ((banana->pos.z < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < banana->pos.z) ||
+                (banana->pos.x < (f32) gCourseMinX) || ((f32) gCourseMaxX < banana->pos.x) ||
+                (banana->pos.y < (f32) gCourseMinY)) {
                 destroy_destructable_actor((struct Actor*) banana);
             } else {
-                check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
-                                         banana->pos[2]);
+                check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
+                                         banana->pos.z);
                 banana->unk30.unk34 = 1;
                 if ((banana->unk30.unk34 != 0) && (banana->unk30.surfaceDistance[2] < 0.0f)) {
                     someOtherVelocity[0] = -banana->unk30.orientationVector[0];
                     someOtherVelocity[1] = -banana->unk30.orientationVector[1];
                     someOtherVelocity[2] = -banana->unk30.orientationVector[2];
-                    banana->pos[0] += someOtherVelocity[0] * banana->unk30.surfaceDistance[2];
-                    banana->pos[1] += someOtherVelocity[1] * banana->unk30.surfaceDistance[2];
-                    banana->pos[2] += someOtherVelocity[2] * banana->unk30.surfaceDistance[2];
+                    banana->pos.x += someOtherVelocity[0] * banana->unk30.surfaceDistance[2];
+                    banana->pos.y += someOtherVelocity[1] * banana->unk30.surfaceDistance[2];
+                    banana->pos.z += someOtherVelocity[2] * banana->unk30.surfaceDistance[2];
                     banana->flags &= ~0x1000;
                     banana->state = 4;
                 }
@@ -122,61 +122,61 @@ void update_actor_banana(struct BananaActor* banana) {
             someVelocity[1] = 0.0f;
             someVelocity[2] = -5.0f;
             func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
-            unkX = player->pos[0] + someVelocity[0];
-            unkY = player->pos[1] + someVelocity[1];
-            unkZ = player->pos[2] + someVelocity[2];
-            temp_f2 = unkX - banana->pos[0];
-            temp_f14 = unkY - banana->pos[1];
-            temp_f16 = unkZ - banana->pos[2];
+            unkX = player->pos.x + someVelocity[0];
+            unkY = player->pos.y + someVelocity[1];
+            unkZ = player->pos.z + someVelocity[2];
+            temp_f2 = unkX - banana->pos.x;
+            temp_f14 = unkY - banana->pos.y;
+            temp_f16 = unkZ - banana->pos.z;
             temp_f0 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16));
             if (temp_f0 == 0.0f) {
-                banana->pos[0] = player->pos[0] + 0.2f;
-                banana->pos[1] = player->pos[1] + 0.2f;
-                banana->pos[2] = player->pos[2] + 0.2f;
+                banana->pos.x = player->pos.x + 0.2f;
+                banana->pos.y = player->pos.y + 0.2f;
+                banana->pos.z = player->pos.z + 0.2f;
             } else {
                 temp_f2 /= temp_f0;
                 temp_f14 /= temp_f0;
                 temp_f16 /= temp_f0;
-                banana->pos[0] = someVelocity[0] + (unkX - temp_f2);
-                banana->pos[1] = unkY - temp_f14 - 2.0f;
-                banana->pos[2] = unkZ - temp_f16;
+                banana->pos.x = someVelocity[0] + (unkX - temp_f2);
+                banana->pos.y = unkY - temp_f14 - 2.0f;
+                banana->pos.z = unkZ - temp_f16;
             }
-            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
-                                     banana->pos[2]);
+            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
+                                     banana->pos.z);
             func_802B4E30((struct Actor*) banana);
             break;
         case BANANA_BUNCH_BANANA:
             elderBanana = (struct BananaActor*) GET_ACTOR(banana->elderIndex);
-            temp_f2 = elderBanana->pos[0] - banana->pos[0];
-            temp_f14 = elderBanana->pos[1] - banana->pos[1];
-            temp_f16 = elderBanana->pos[2] - banana->pos[2];
+            temp_f2 = elderBanana->pos.x - banana->pos.x;
+            temp_f14 = elderBanana->pos.y - banana->pos.y;
+            temp_f16 = elderBanana->pos.z - banana->pos.z;
             temp_f12 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16)) / 5.0f;
             if (temp_f12 == 0.0f) {
-                banana->pos[0] = elderBanana->pos[0] + 0.2f;
-                banana->pos[1] = elderBanana->pos[1] + 0.2f;
-                banana->pos[2] = elderBanana->pos[2] + 0.2f;
+                banana->pos.x = elderBanana->pos.x + 0.2f;
+                banana->pos.y = elderBanana->pos.y + 0.2f;
+                banana->pos.z = elderBanana->pos.z + 0.2f;
             } else {
                 temp_f2 /= temp_f12;
                 temp_f14 /= temp_f12;
                 temp_f16 /= temp_f12;
-                banana->pos[0] = elderBanana->pos[0] - temp_f2;
-                banana->pos[1] = elderBanana->pos[1] - temp_f14 - 2.0f;
-                banana->pos[2] = elderBanana->pos[2] - temp_f16;
+                banana->pos.x = elderBanana->pos.x - temp_f2;
+                banana->pos.y = elderBanana->pos.y - temp_f14 - 2.0f;
+                banana->pos.z = elderBanana->pos.z - temp_f16;
             }
-            var_f8 = banana->pos[2];
-            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
-                                     banana->pos[2]);
+            var_f8 = banana->pos.z;
+            check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
+                                     banana->pos.z);
             func_802B4E30((struct Actor*) banana);
             break;
         case DESTROYED_BANANA:
-            banana->velocity[1] -= 0.3f;
-            if (banana->velocity[1] < -5.0f) {
-                banana->velocity[1] = -5.0f;
+            banana->velocity.y -= 0.3f;
+            if (banana->velocity.y < -5.0f) {
+                banana->velocity.y = -5.0f;
             }
-            banana->pos[1] += banana->velocity[1];
-            banana->rot[0] += 0x16C;
-            banana->rot[1] -= 0x5B0;
-            banana->rot[2] += 0x38E;
+            banana->pos.y += banana->velocity.y;
+            banana->rot.x += 0x16C;
+            banana->rot.y -= 0x5B0;
+            banana->rot.z += 0x38E;
             banana->unk_04 -= 1;
             if (banana->unk_04 == 0) {
                 destroy_actor((struct Actor*) banana);
diff --git a/src/actors/blue_and_red_shells/update.inc.c b/src/actors/blue_and_red_shells/update.inc.c
index 277ec2075..3ae65e218 100644
--- a/src/actors/blue_and_red_shells/update.inc.c
+++ b/src/actors/blue_and_red_shells/update.inc.c
@@ -39,18 +39,18 @@ void func_802B3B44(struct ShellActor* shell) {
         nextWaypoint -= D_80164430;
     }
 
-    temp_f20 = temp_f2 - shell->pos[0];
-    temp_f22 = temp_f12 - shell->pos[1];
-    temp_f24 = temp_f28 - shell->pos[2];
+    temp_f20 = temp_f2 - shell->pos.x;
+    temp_f22 = temp_f12 - shell->pos.y;
+    temp_f24 = temp_f28 - shell->pos.z;
     temp_f0 = (temp_f20 * temp_f20) + (temp_f22 * temp_f22) + (temp_f24 * temp_f24);
     if (temp_f0 > 400.0f) {
         temp_f18_3 = D_80164490[nextWaypoint].posX;
         temp_f16_3 = D_80164490[nextWaypoint].posY;
         temp_f26 = D_80164490[nextWaypoint].posZ;
 
-        temp_f12_0 = temp_f18_3 - shell->pos[0];
-        temp_f12_1 = temp_f16_3 - shell->pos[1];
-        temp_f12_2 = temp_f26 - shell->pos[2];
+        temp_f12_0 = temp_f18_3 - shell->pos.x;
+        temp_f12_1 = temp_f16_3 - shell->pos.y;
+        temp_f12_2 = temp_f26 - shell->pos.z;
 
         temp_f0_3 = (temp_f12_0 * temp_f12_0) + (temp_f12_1 * temp_f12_1) + (temp_f12_2 * temp_f12_2);
         if (temp_f0_3 < temp_f0) {
@@ -61,9 +61,9 @@ void func_802B3B44(struct ShellActor* shell) {
             temp_f22 /= temp_f0_2;
             temp_f24 /= temp_f0_2;
 
-            temp_f12_3 = shell->velocity[0];
-            temp_f14_2 = shell->velocity[1];
-            temp_f16_2 = shell->velocity[2];
+            temp_f12_3 = shell->velocity.x;
+            temp_f14_2 = shell->velocity.y;
+            temp_f16_2 = shell->velocity.z;
 
             temp_f12_3 += temp_f20;
             temp_f14_2 += temp_f22;
@@ -75,39 +75,39 @@ void func_802B3B44(struct ShellActor* shell) {
                 temp_f14_2 /= temp_f0;
                 temp_f16_2 /= temp_f0;
             }
-            shell->velocity[0] = temp_f12_3;
-            shell->velocity[1] = temp_f14_2;
-            shell->velocity[2] = temp_f16_2;
+            shell->velocity.x = temp_f12_3;
+            shell->velocity.y = temp_f14_2;
+            shell->velocity.z = temp_f16_2;
 
-            origPos[0] = shell->pos[0];
-            origPos[1] = shell->pos[1];
-            origPos[2] = shell->pos[2];
+            origPos[0] = shell->pos.x;
+            origPos[1] = shell->pos.y;
+            origPos[2] = shell->pos.z;
 
-            shell->pos[0] += temp_f12_3;
-            shell->pos[1] += temp_f14_2;
-            shell->pos[2] += temp_f16_2;
-            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
+            shell->pos.x += temp_f12_3;
+            shell->pos.y += temp_f14_2;
+            shell->pos.z += temp_f16_2;
+            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
                                     origPos[1], origPos[2]);
             func_802B4E30((struct Actor*) shell);
         }
     } else {
         if (temp_f0 > 5.0f) {
-            shell->pos[0] = temp_f2;
-            shell->pos[1] = shell->boundingBoxSize + temp_f12;
-            shell->pos[2] = temp_f28;
+            shell->pos.x = temp_f2;
+            shell->pos.y = shell->boundingBoxSize + temp_f12;
+            shell->pos.z = temp_f28;
             shell->pathIndex = nextWaypoint;
         } else {
             temp_f18_3 = D_80164490[nextWaypoint].posX;
             temp_f16_3 = D_80164490[nextWaypoint].posY;
             temp_f26 = D_80164490[nextWaypoint].posZ;
 
-            shell->pos[0] = (temp_f2 + temp_f18_3) * 0.5f;
-            shell->pos[1] = ((temp_f12 + temp_f16_3) * 0.5f) + shell->boundingBoxSize;
-            shell->pos[2] = (temp_f28 + temp_f26) * 0.5f;
+            shell->pos.x = (temp_f2 + temp_f18_3) * 0.5f;
+            shell->pos.y = ((temp_f12 + temp_f16_3) * 0.5f) + shell->boundingBoxSize;
+            shell->pos.z = (temp_f28 + temp_f26) * 0.5f;
 
-            shell->velocity[0] = (temp_f18_3 - temp_f2) * 0.5f;
-            shell->velocity[1] = (temp_f16_3 - temp_f12) * 0.5f;
-            shell->velocity[2] = (temp_f26 - temp_f28) * 0.5f;
+            shell->velocity.x = (temp_f18_3 - temp_f2) * 0.5f;
+            shell->velocity.y = (temp_f16_3 - temp_f12) * 0.5f;
+            shell->velocity.z = (temp_f26 - temp_f28) * 0.5f;
         }
     }
 }
@@ -118,10 +118,10 @@ void func_802B3E7C(struct ShellActor* shell, Player* player) {
     f32 xz_dist;
     Vec3f newPosition;
 
-    x_velocity = player->pos[0];
-    x_velocity -= shell->pos[0];
-    z_velocity = player->pos[2];
-    z_velocity -= shell->pos[2];
+    x_velocity = player->pos.x;
+    x_velocity -= shell->pos.x;
+    z_velocity = player->pos.z;
+    z_velocity -= shell->pos.z;
     xz_dist = sqrtf((x_velocity * x_velocity) + (z_velocity * z_velocity)) / 8;
     if (xz_dist == 0.0f) {
         x_velocity = 0.0f;
@@ -131,20 +131,20 @@ void func_802B3E7C(struct ShellActor* shell, Player* player) {
         z_velocity /= xz_dist;
     }
 
-    newPosition[0] = shell->pos[0];
-    newPosition[1] = shell->pos[1];
-    newPosition[2] = shell->pos[2];
-    shell->pos[0] += x_velocity;
-    shell->pos[1] -= 2.0f;
-    shell->pos[2] += z_velocity;
-    shell->velocity[0] = x_velocity;
-    shell->velocity[1] = -2.0f;
-    shell->velocity[2] = z_velocity;
+    newPosition[0] = shell->pos.x;
+    newPosition[1] = shell->pos.y;
+    newPosition[2] = shell->pos.z;
+    shell->pos.x += x_velocity;
+    shell->pos.y -= 2.0f;
+    shell->pos.z += z_velocity;
+    shell->velocity.x = x_velocity;
+    shell->velocity.y = -2.0f;
+    shell->velocity.z = z_velocity;
 
     if (player->effects & BOO_EFFECT) {
         destroy_destructable_actor((struct Actor*) shell);
     } else {
-        actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], newPosition[0],
+        actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, newPosition[0],
                                 newPosition[1], newPosition[2]);
         func_802B4E30((struct Actor*) shell);
         func_802B4104(shell);
@@ -234,9 +234,9 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
     UNUSED f32 pad17;
     Vec3f origPos;
 
-    pad1 = shell->pos[0];
-    pad0 = shell->pos[2];
-    pad2 = shell->pos[1];
+    pad1 = shell->pos.x;
+    pad0 = shell->pos.z;
+    pad2 = shell->pos.y;
     pad13 = shell->type;
     if ((pad0 < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < pad0) || (pad1 < (f32) gCourseMinX) ||
         ((f32) gCourseMaxX < pad1) || (pad2 < (f32) gCourseMinY)) {
@@ -252,16 +252,16 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
             somePosVel[1] = player->boundingBoxSize;
             somePosVel[2] = -(player->boundingBoxSize + shell->boundingBoxSize + 2.0f);
             mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-            shell->pos[0] = player->pos[0] + somePosVel[0];
-            pad7 = player->pos[1] - somePosVel[1];
-            shell->pos[2] = player->pos[2] + somePosVel[2];
-            height = calculate_surface_height(shell->pos[0], pad7, shell->pos[2], player->collision.meshIndexZX);
+            shell->pos.x = player->pos.x + somePosVel[0];
+            pad7 = player->pos.y - somePosVel[1];
+            shell->pos.z = player->pos.z + somePosVel[2];
+            height = calculate_surface_height(shell->pos.x, pad7, shell->pos.z, player->collision.meshIndexZX);
             temp_f2 = pad7 - height;
 
             if ((temp_f2 < 5.0f) && (temp_f2 > -5.0f)) {
-                shell->pos[1] = shell->boundingBoxSize + height;
+                shell->pos.y = shell->boundingBoxSize + height;
             } else {
-                shell->pos[1] = pad7;
+                shell->pos.y = pad7;
             }
 
             if ((player->type & PLAYER_HUMAN) != 0) {
@@ -325,17 +325,17 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
                 somePosVel[1] = 0.0f;
                 somePosVel[2] = height;
                 func_802B64C4(somePosVel, (s16) (player->rotation[1] + player->unk_0C0));
-                shell->velocity[0] = somePosVel[0];
-                shell->velocity[1] = somePosVel[1];
-                shell->velocity[2] = somePosVel[2];
+                shell->velocity.x = somePosVel[0];
+                shell->velocity.y = somePosVel[1];
+                shell->velocity.z = somePosVel[2];
             } else {
                 somePosVel[0] = sins(shell->rotAngle) * 8.0f;
                 somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
                 somePosVel[2] = coss(shell->rotAngle) * 8.0f;
                 mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-                shell->pos[0] = player->pos[0] + somePosVel[0];
-                shell->pos[1] = player->pos[1] + somePosVel[1];
-                shell->pos[2] = player->pos[2] + somePosVel[2];
+                shell->pos.x = player->pos.x + somePosVel[0];
+                shell->pos.y = player->pos.y + somePosVel[1];
+                shell->pos.z = player->pos.z + somePosVel[2];
             }
             break;
         case MOVING_SHELL:
@@ -357,7 +357,7 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
                     shell->targetPlayer = func_802B3FD0(player, shell);
                     if (shell->targetPlayer < 0) {
                         shell->flags = 0x8000;
-                        shell->velocity[1] = 3.0f;
+                        shell->velocity.y = 3.0f;
                         shell->pathIndex = 0;
                         shell->someTimer = 0x003C;
                         shell->state = DESTROYED_SHELL;
@@ -389,17 +389,17 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
                     }
                 }
             }
-            shell->velocity[1] -= 0.5;
-            if (shell->velocity[1] < -2.0f) {
-                shell->velocity[1] = -2.0f;
+            shell->velocity.y -= 0.5;
+            if (shell->velocity.y < -2.0f) {
+                shell->velocity.y = -2.0f;
             }
-            origPos[0] = shell->pos[0];
-            origPos[1] = shell->pos[1];
-            origPos[2] = shell->pos[2];
-            shell->pos[0] += shell->velocity[0];
-            shell->pos[1] += shell->velocity[1];
-            shell->pos[2] += shell->velocity[2];
-            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
+            origPos[0] = shell->pos.x;
+            origPos[1] = shell->pos.y;
+            origPos[2] = shell->pos.z;
+            shell->pos.x += shell->velocity.x;
+            shell->pos.y += shell->velocity.y;
+            shell->pos.z += shell->velocity.z;
+            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
                                     origPos[1], origPos[2]);
             func_802B4E30((struct Actor*) shell);
             func_802B4104(shell);
@@ -420,10 +420,10 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
         case GREEN_SHELL_HIT_A_RACER:
             func_802B3B44(shell);
             player = &gPlayers[shell->targetPlayer];
-            height = player->pos[0];
-            height -= shell->pos[0];
-            temp_f2 = player->pos[2];
-            temp_f2 -= shell->pos[2];
+            height = player->pos.x;
+            height -= shell->pos.x;
+            temp_f2 = player->pos.z;
+            temp_f2 -= shell->pos.z;
             if (((height * height) + (temp_f2 * temp_f2)) < 40000.0f) {
                 shell->state = RED_SHELL_LOCK_ON;
             }
@@ -439,25 +439,25 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
                 somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
                 somePosVel[2] = coss(shell->rotAngle) * 8.0f;
                 mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-                origPos[0] = shell->pos[0];
-                origPos[1] = shell->pos[1];
-                origPos[2] = shell->pos[2];
-                shell->pos[0] = player->pos[0] + somePosVel[0];
-                shell->pos[1] = player->pos[1] + somePosVel[1];
-                shell->pos[2] = player->pos[2] + somePosVel[2];
-                actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
+                origPos[0] = shell->pos.x;
+                origPos[1] = shell->pos.y;
+                origPos[2] = shell->pos.z;
+                shell->pos.x = player->pos.x + somePosVel[0];
+                shell->pos.y = player->pos.y + somePosVel[1];
+                shell->pos.z = player->pos.z + somePosVel[2];
+                actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
                                         origPos[1], origPos[2]);
                 func_802B4E30((struct Actor*) shell);
             }
             break;
         case DESTROYED_SHELL:
-            shell->velocity[1] -= 0.3f;
-            if (shell->velocity[1] < -5.0f) {
-                shell->velocity[1] = -5.0f;
+            shell->velocity.y -= 0.3f;
+            if (shell->velocity.y < -5.0f) {
+                shell->velocity.y = -5.0f;
             }
             shell->rotAngle += 0x5B0;
             shell->someTimer -= 1;
-            shell->pos[1] += shell->velocity[1];
+            shell->pos.y += shell->velocity.y;
             if (shell->someTimer == 0) {
                 destroy_actor((struct Actor*) shell);
             }
@@ -466,10 +466,10 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
             func_802B3B44(shell);
             shell->targetPlayer = gPlayerPositionLUT[0];
             player = &gPlayers[gPlayerPositionLUT[0]];
-            height = player->pos[0];
-            height -= shell->pos[0];
-            temp_f2 = player->pos[2];
-            temp_f2 -= shell->pos[2];
+            height = player->pos.x;
+            height -= shell->pos.x;
+            temp_f2 = player->pos.z;
+            temp_f2 -= shell->pos.z;
             if (((height * height) + (temp_f2 * temp_f2)) < 40000.0f) {
                 shell->state = BLUE_SHELL_TARGET_ELIMINATED;
             }
diff --git a/src/actors/box_truck/render.inc.c b/src/actors/box_truck/render.inc.c
index c53c13abc..590e03f31 100644
--- a/src/actors/box_truck/render.inc.c
+++ b/src/actors/box_truck/render.inc.c
@@ -17,7 +17,7 @@ void render_actor_box_truck(Camera* arg0, struct Actor* arg1) {
     Mat4 spD8;
     UNUSED s32 pad2[32];
     f32 temp_f0 =
-        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
+        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
     }
diff --git a/src/actors/car/render.inc.c b/src/actors/car/render.inc.c
index 0eb8d03b8..3e95cf73a 100644
--- a/src/actors/car/render.inc.c
+++ b/src/actors/car/render.inc.c
@@ -16,7 +16,7 @@ void render_actor_car(Camera* arg0, struct Actor* arg1) {
     Mat4 spC8;
     UNUSED s32 pad2[32];
     f32 temp_f0 =
-        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
+        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
     }
diff --git a/src/actors/cow/render.inc.c b/src/actors/cow/render.inc.c
index e55154c03..687e8ba66 100644
--- a/src/actors/cow/render.inc.c
+++ b/src/actors/cow/render.inc.c
@@ -13,15 +13,15 @@
  * @param arg2
  */
 void render_actor_cow(Camera* camera, Mat4 arg1, struct Actor* arg2) {
-    if (is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
+    if (is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
                                   4000000.0f) < 0 &&
         CVarGetInteger("gNoCulling", 0) == 0) {
         return;
     }
 
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         switch (arg2->state) {
diff --git a/src/actors/fake_item_box/render.inc.c b/src/actors/fake_item_box/render.inc.c
index 3292b64e2..40b808117 100644
--- a/src/actors/fake_item_box/render.inc.c
+++ b/src/actors/fake_item_box/render.inc.c
@@ -28,24 +28,24 @@ void render_actor_fake_item_box(Camera* camera, struct FakeItemBox* fakeItemBox)
     // @port: Tag the transform.
     FrameInterpolation_RecordOpenChild("Fake Item Box", TAG_ITEM_ADDR(fakeItemBox));
 
-    if (is_within_render_distance(camera->pos, fakeItemBox->pos, camera->rot[1], 2500.0f, gCameraZoom[camera - camera1],
+    if (is_within_render_distance(camera->pos, fakeItemBox->pos, camera->rot.y, 2500.0f, gCameraZoom[camera - camera1],
                                   1000000.0f) < 0 &&
         CVarGetInteger("gNoCulling", 0) == 0) {
         actor_not_rendered(camera, (struct Actor*) fakeItemBox);
         return;
     }
-    if (((f32) gCourseMaxY + 800.0f) < fakeItemBox->pos[1]) {
+    if (((f32) gCourseMaxY + 800.0f) < fakeItemBox->pos.y) {
         actor_not_rendered(camera, (struct Actor*) fakeItemBox);
         return;
     }
-    if (fakeItemBox->pos[1] < ((f32) gCourseMinY - 800.0f)) {
+    if (fakeItemBox->pos.y < ((f32) gCourseMinY - 800.0f)) {
         actor_not_rendered(camera, (struct Actor*) fakeItemBox);
         return;
     }
 
     actor_rendered(camera, (struct Actor*) fakeItemBox);
     someRot[0] = 0;
-    someRot[1] = fakeItemBox->rot[1];
+    someRot[1] = fakeItemBox->rot.y;
     someRot[2] = 0;
     mtxf_pos_rotation_xyz(someMatrix2, fakeItemBox->pos, someRot);
     mtxf_scale(someMatrix2, fakeItemBox->sizeScaling);
@@ -65,13 +65,13 @@ void render_actor_fake_item_box(Camera* camera, struct FakeItemBox* fakeItemBox)
 
         gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
         gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIA, G_CC_MODULATEIA);
-        if ((fakeItemBox->rot[1] < 0xAA1) && (fakeItemBox->rot[1] > 0)) {
+        if ((fakeItemBox->rot.y < 0xAA1) && (fakeItemBox->rot.y > 0)) {
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-        } else if ((fakeItemBox->rot[1] >= 0x6AA5) && (fakeItemBox->rot[1] < 0x754E)) {
+        } else if ((fakeItemBox->rot.y >= 0x6AA5) && (fakeItemBox->rot.y < 0x754E)) {
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-        } else if ((fakeItemBox->rot[1] >= 0x38E1) && (fakeItemBox->rot[1] < 0x438A)) {
+        } else if ((fakeItemBox->rot.y >= 0x38E1) && (fakeItemBox->rot.y < 0x438A)) {
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-        } else if ((fakeItemBox->rot[1] >= 0xC711) && (fakeItemBox->rot[1] < 0xD1BA)) {
+        } else if ((fakeItemBox->rot.y >= 0xC711) && (fakeItemBox->rot.y < 0xD1BA)) {
             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
         } else {
             gDPSetBlendMask(gDisplayListHead++, 0xFF);
diff --git a/src/actors/fake_item_box/update.inc.c b/src/actors/fake_item_box/update.inc.c
index efb834a80..cee7663cf 100644
--- a/src/actors/fake_item_box/update.inc.c
+++ b/src/actors/fake_item_box/update.inc.c
@@ -21,23 +21,23 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
     switch (fake_item_box->state) {
         case 0:
             fake_item_box->boundingBoxSize = fake_item_box->sizeScaling * 5.5f;
-            fake_item_box->rot[0] -= 0xB6;
-            fake_item_box->rot[1] += 0x16C;
-            fake_item_box->rot[2] -= 0xB6;
+            fake_item_box->rot.x -= 0xB6;
+            fake_item_box->rot.y += 0x16C;
+            fake_item_box->rot.z -= 0xB6;
 
-            temp_f14 = temp_v0_4->pos[0] - fake_item_box->pos[0];
-            temp_f16 = temp_v0_4->pos[1] - fake_item_box->pos[1];
-            temp_f18 = temp_v0_4->pos[2] - fake_item_box->pos[2];
+            temp_f14 = temp_v0_4->pos.x - fake_item_box->pos.x;
+            temp_f16 = temp_v0_4->pos.y - fake_item_box->pos.y;
+            temp_f18 = temp_v0_4->pos.z - fake_item_box->pos.z;
 
             temp_f2_2 = sqrtf((temp_f14 * temp_f14) + (temp_f16 * temp_f16) + (temp_f18 * temp_f18)) / 10.0f;
             temp_f14 /= temp_f2_2;
             temp_f16 /= temp_f2_2;
             temp_f18 /= temp_f2_2;
-            fake_item_box->pos[0] = temp_v0_4->pos[0] - temp_f14;
-            fake_item_box->pos[1] = (temp_v0_4->pos[1] - temp_f16) - 1.0f;
-            fake_item_box->pos[2] = temp_v0_4->pos[2] - temp_f18;
-            check_bounding_collision(&fake_item_box->unk30, fake_item_box->boundingBoxSize, fake_item_box->pos[0],
-                                     fake_item_box->pos[1], fake_item_box->pos[2]);
+            fake_item_box->pos.x = temp_v0_4->pos.x - temp_f14;
+            fake_item_box->pos.y = (temp_v0_4->pos.y - temp_f16) - 1.0f;
+            fake_item_box->pos.z = temp_v0_4->pos.z - temp_f18;
+            check_bounding_collision(&fake_item_box->unk30, fake_item_box->boundingBoxSize, fake_item_box->pos.x,
+                                     fake_item_box->pos.y, fake_item_box->pos.z);
             func_802B4E30((struct Actor*) fake_item_box);
             temp_v1_3 = &gControllers[temp_v1];
             if ((temp_v0_4->type & 0x4000) != 0) {
@@ -58,10 +58,10 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
             }
 
             fake_item_box->boundingBoxSize = fake_item_box->sizeScaling * 5.5f;
-            if (fake_item_box->targetY <= fake_item_box->pos[1]) {
-                fake_item_box->pos[1] = fake_item_box->targetY;
+            if (fake_item_box->targetY <= fake_item_box->pos.y) {
+                fake_item_box->pos.y = fake_item_box->targetY;
             } else {
-                fake_item_box->pos[1] += 0.2f;
+                fake_item_box->pos.y += 0.2f;
             }
             if ((fake_item_box->flags & 0x1000) != 0) {
                 if ((fake_item_box->someTimer <= 0) || (fake_item_box->someTimer >= 0x12D)) {
@@ -71,9 +71,9 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
                     fake_item_box->someTimer--;
                 }
             }
-            fake_item_box->rot[0] -= 0xB6;
-            fake_item_box->rot[1] += 0x16C;
-            fake_item_box->rot[2] -= 0xB6;
+            fake_item_box->rot.x -= 0xB6;
+            fake_item_box->rot.y += 0x16C;
+            fake_item_box->rot.z -= 0xB6;
             break;
 
         case 2:
@@ -81,9 +81,9 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
                 destroy_actor((struct Actor*) fake_item_box);
             } else {
                 fake_item_box->someTimer++;
-                fake_item_box->rot[0] += 0x444;
-                fake_item_box->rot[1] -= 0x2D8;
-                fake_item_box->rot[2] += 0x16C;
+                fake_item_box->rot.x += 0x444;
+                fake_item_box->rot.y -= 0x2D8;
+                fake_item_box->rot.z += 0x16C;
             }
             break;
         default:
diff --git a/src/actors/falling_rock/render.inc.c b/src/actors/falling_rock/render.inc.c
index 9d50fd41c..09dd3f83e 100644
--- a/src/actors/falling_rock/render.inc.c
+++ b/src/actors/falling_rock/render.inc.c
@@ -24,7 +24,7 @@ void render_actor_falling_rock(Camera* camera, struct FallingRock* rock) {
         return;
     }
 
-    height = is_within_render_distance(camera->pos, rock->pos, camera->rot[1], 400.0f, gCameraZoom[camera - camera1],
+    height = is_within_render_distance(camera->pos, rock->pos, camera->rot.y, 400.0f, gCameraZoom[camera - camera1],
                                        4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
@@ -38,9 +38,9 @@ void render_actor_falling_rock(Camera* camera, struct FallingRock* rock) {
     if (height < 250000.0f) {
 
         if (rock->unk30.unk34 == 1) {
-            sp8C[0] = rock->pos[0];
-            sp8C[2] = rock->pos[2];
-            height = calculate_surface_height(sp8C[0], rock->pos[1], sp8C[2], rock->unk30.meshIndexZX);
+            sp8C[0] = rock->pos.x;
+            sp8C[2] = rock->pos.z;
+            height = calculate_surface_height(sp8C[0], rock->pos.y, sp8C[2], rock->unk30.meshIndexZX);
             sp98[0] = 0;
             sp98[1] = 0;
             sp98[2] = 0;
diff --git a/src/actors/falling_rock/update.inc.c b/src/actors/falling_rock/update.inc.c
index b700a4226..424b558c6 100644
--- a/src/actors/falling_rock/update.inc.c
+++ b/src/actors/falling_rock/update.inc.c
@@ -16,9 +16,9 @@ void func_8029CF0C(struct ActorSpawnData* spawnData, struct FallingRock* rock) {
     temp_v0 += rock->unk_06;
 #endif
     rock->respawnTimer = sp24[rock->unk_06]; // * 2
-    rock->pos[0] = (f32) temp_v0[rock->unk_06].pos[0] * gCourseDirection;
-    rock->pos[1] = (f32) temp_v0[rock->unk_06].pos[1] + 10.0f;
-    rock->pos[2] = (f32) temp_v0[rock->unk_06].pos[2];
+    rock->pos.x = (f32) temp_v0[rock->unk_06].pos.x * gCourseDirection;
+    rock->pos.y = (f32) temp_v0[rock->unk_06].pos.y + 10.0f;
+    rock->pos.z = (f32) temp_v0[rock->unk_06].pos.z;
     vec3f_set(rock->velocity, 0, 0, 0);
     vec3s_set(rock->rot, 0, 0, 0);
 }
@@ -46,10 +46,10 @@ void spawn_falling_rocks(struct ActorSpawnData* spawnData) {
     Vec3s startingRot;
     s16 temp;
 
-    while (temp_s0->pos[0] != -0x8000) {
-        startingPos[0] = temp_s0->pos[0] * gCourseDirection;
-        startingPos[1] = temp_s0->pos[1] + 10.0f;
-        startingPos[2] = temp_s0->pos[2];
+    while (temp_s0->pos.x != -0x8000) {
+        startingPos[0] = temp_s0->pos.x * gCourseDirection;
+        startingPos[1] = temp_s0->pos.y + 10.0f;
+        startingPos[2] = temp_s0->pos.z;
         vec3f_set(startingVelocity, 0, 0, 0);
         vec3s_set(startingRot, 0, 0, 0);
         temp = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_FALLING_ROCK);
@@ -76,46 +76,46 @@ void update_actor_falling_rocks(struct FallingRock* rock) {
         rock->respawnTimer -= 1;
         return;
     }
-    if (rock->pos[1] < CM_GetWaterLevel(rock->pos, NULL)) {
+    if (rock->pos.y < CM_GetWaterLevel(rock->pos, NULL)) {
         func_8029CF0C(sRockSpawnData, rock);
     }
-    rock->rot[0] += (s16) ((rock->velocity[2] * 5461.0f) / 20.0f);
-    rock->rot[2] += (s16) ((rock->velocity[0] * 5461.0f) / 20.0f);
-    rock->velocity[1] -= 0.1;
-    if (rock->velocity[1] < (-2.0f)) {
-        rock->velocity[1] = -2.0f;
+    rock->rot.x += (s16) ((rock->velocity.z * 5461.0f) / 20.0f);
+    rock->rot.z += (s16) ((rock->velocity.x * 5461.0f) / 20.0f);
+    rock->velocity.y -= 0.1;
+    if (rock->velocity.y < (-2.0f)) {
+        rock->velocity.y = -2.0f;
     }
-    rock->pos[0] += rock->velocity[0];
-    rock->pos[1] += rock->velocity[1];
-    rock->pos[2] += rock->velocity[2];
-    pad1 = rock->velocity[1];
-    check_bounding_collision(&rock->unk30, 10.0f, rock->pos[0], rock->pos[1], rock->pos[2]);
+    rock->pos.x += rock->velocity.x;
+    rock->pos.y += rock->velocity.y;
+    rock->pos.z += rock->velocity.z;
+    pad1 = rock->velocity.y;
+    check_bounding_collision(&rock->unk30, 10.0f, rock->pos.x, rock->pos.y, rock->pos.z);
     pad0 = rock->unk30.surfaceDistance[2];
     if (pad0 < 0.0f) {
         unkVec[0] = -rock->unk30.orientationVector[0];
         unkVec[1] = -rock->unk30.orientationVector[1];
         unkVec[2] = -rock->unk30.orientationVector[2];
-        rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[2];
-        rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[2];
-        rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[2];
+        rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[2];
+        rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[2];
+        rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[2];
         adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
-        rock->velocity[1] = -1.2f * pad1;
+        rock->velocity.y = -1.2f * pad1;
         func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
     }
     pad0 = rock->unk30.surfaceDistance[0];
     if (pad0 < 0.0f) {
         unkVec[1] = -rock->unk30.unk48[1];
         if (unkVec[1] == 0.0f) {
-            rock->velocity[1] *= -1.2f;
+            rock->velocity.y *= -1.2f;
             return;
         } else {
             unkVec[0] = -rock->unk30.unk48[0];
             unkVec[2] = -rock->unk30.unk48[2];
-            rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[0];
-            rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[0];
-            rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[0];
+            rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[0];
+            rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[0];
+            rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[0];
             adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
-            rock->velocity[1] = -1.2f * pad1;
+            rock->velocity.y = -1.2f * pad1;
             func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
         }
     }
@@ -123,16 +123,16 @@ void update_actor_falling_rocks(struct FallingRock* rock) {
     if (pad0 < 0.0f) {
         unkVec[1] = -rock->unk30.unk54[1];
         if (unkVec[1] == 0.0f) {
-            rock->velocity[1] *= -1.2f;
+            rock->velocity.y *= -1.2f;
         } else {
             unkVec[0] = -rock->unk30.unk54[0];
             unkVec[2] = -rock->unk30.unk54[2];
-            rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[1];
-            rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[1];
-            rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[1];
-            pad1 = rock->velocity[1];
+            rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[1];
+            rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[1];
+            rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[1];
+            pad1 = rock->velocity.y;
             adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
-            rock->velocity[1] = -1.2f * pad1;
+            rock->velocity.y = -1.2f * pad1;
             func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
         }
     }
diff --git a/src/actors/green_shell/update.inc.c b/src/actors/green_shell/update.inc.c
index 8499bddc4..04f8e2d95 100644
--- a/src/actors/green_shell/update.inc.c
+++ b/src/actors/green_shell/update.inc.c
@@ -29,9 +29,9 @@ void update_actor_green_shell(struct ShellActor* shell) {
     UNUSED f32 pad7;
     UNUSED f32 pad8;
 
-    height = shell->pos[0];
-    y = shell->pos[1];
-    z = shell->pos[2];
+    height = shell->pos.x;
+    y = shell->pos.y;
+    z = shell->pos.z;
     if ((z < gCourseMinZ) || (gCourseMaxZ < z) || (height < gCourseMinX) || (gCourseMaxX < height) ||
         (y < gCourseMinY)) {
         destroy_destructable_actor((struct Actor*) shell);
@@ -45,15 +45,15 @@ void update_actor_green_shell(struct ShellActor* shell) {
             somePosVel[1] = player->boundingBoxSize;
             somePosVel[2] = -(player->boundingBoxSize + shell->boundingBoxSize + 2.0f);
             mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-            shell->pos[0] = player->pos[0] + somePosVel[0];
-            pad2 = player->pos[1] - somePosVel[1];
-            shell->pos[2] = player->pos[2] + somePosVel[2];
-            height = calculate_surface_height(shell->pos[0], pad2, shell->pos[2], player->collision.meshIndexZX);
+            shell->pos.x = player->pos.x + somePosVel[0];
+            pad2 = player->pos.y - somePosVel[1];
+            shell->pos.z = player->pos.z + somePosVel[2];
+            height = calculate_surface_height(shell->pos.x, pad2, shell->pos.z, player->collision.meshIndexZX);
             z = pad2 - height;
             if ((z < 5.0f) && (z > -5.0f)) {
-                shell->pos[1] = shell->boundingBoxSize + height;
+                shell->pos.y = shell->boundingBoxSize + height;
             } else {
-                shell->pos[1] = pad2;
+                shell->pos.y = pad2;
             }
             if ((player->type & PLAYER_HUMAN) != 0) {
                 controller = &gControllers[shell->playerId];
@@ -68,9 +68,9 @@ void update_actor_green_shell(struct ShellActor* shell) {
                         somePosVel[1] = 0.0f;
                         somePosVel[2] = -var_f2;
                         func_802B64C4(somePosVel, player->rotation[1] + player->unk_0C0);
-                        shell->velocity[0] = somePosVel[0];
-                        shell->velocity[1] = somePosVel[1];
-                        shell->velocity[2] = somePosVel[2];
+                        shell->velocity.x = somePosVel[0];
+                        shell->velocity.y = somePosVel[1];
+                        shell->velocity.z = somePosVel[2];
                         shell->state = 2;
                         func_800C9060(shell->playerId, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x04));
                         func_800C90F4(shell->playerId,
@@ -120,17 +120,17 @@ void update_actor_green_shell(struct ShellActor* shell) {
                 somePosVel[1] = 0.0f;
                 somePosVel[2] = var_f2;
                 func_802B64C4(somePosVel, player->rotation[1] + player->unk_0C0);
-                shell->velocity[0] = somePosVel[0];
-                shell->velocity[1] = somePosVel[1];
-                shell->velocity[2] = somePosVel[2];
+                shell->velocity.x = somePosVel[0];
+                shell->velocity.y = somePosVel[1];
+                shell->velocity.z = somePosVel[2];
             } else {
                 somePosVel[0] = sins(shell->rotAngle) * 6.0f;
                 somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
                 somePosVel[2] = coss(shell->rotAngle) * 6.0f;
                 mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-                shell->pos[0] = player->pos[0] + somePosVel[0];
-                shell->pos[1] = player->pos[1] + somePosVel[1];
-                shell->pos[2] = player->pos[2] + somePosVel[2];
+                shell->pos.x = player->pos.x + somePosVel[0];
+                shell->pos.y = player->pos.y + somePosVel[1];
+                shell->pos.z = player->pos.z + somePosVel[2];
             }
             break;
         case MOVING_SHELL:
@@ -140,17 +140,17 @@ void update_actor_green_shell(struct ShellActor* shell) {
                     shell->flags &= ~0x1000;
                 }
             }
-            shell->velocity[1] -= 0.5f;
-            if (shell->velocity[1] < -2.0f) {
-                shell->velocity[1] = -2.0f;
+            shell->velocity.y -= 0.5f;
+            if (shell->velocity.y < -2.0f) {
+                shell->velocity.y = -2.0f;
             }
-            somePos2[0] = shell->pos[0];
-            somePos2[1] = shell->pos[1];
-            somePos2[2] = shell->pos[2];
-            shell->pos[0] += shell->velocity[0];
-            shell->pos[1] += shell->velocity[1];
-            shell->pos[2] += shell->velocity[2];
-            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], somePos2[0],
+            somePos2[0] = shell->pos.x;
+            somePos2[1] = shell->pos.y;
+            somePos2[2] = shell->pos.z;
+            shell->pos.x += shell->velocity.x;
+            shell->pos.y += shell->velocity.y;
+            shell->pos.z += shell->velocity.z;
+            actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, somePos2[0],
                                     somePos2[1], somePos2[2]);
             func_802B4E30((struct Actor*) shell);
             if ((shell->unk30.surfaceDistance[0] < 0.0f) || (shell->unk30.surfaceDistance[1] < 0.0f)) {
@@ -170,26 +170,26 @@ void update_actor_green_shell(struct ShellActor* shell) {
                 somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
                 somePosVel[2] = coss(shell->rotAngle) * 8.0f;
                 mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
-                somePos2[0] = shell->pos[0];
-                somePos2[1] = shell->pos[1];
-                somePos2[2] = shell->pos[2];
-                shell->pos[0] = player->pos[0] + somePosVel[0];
-                shell->pos[1] = player->pos[1] + somePosVel[1];
-                shell->pos[2] = player->pos[2] + somePosVel[2];
-                actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], somePos2[0],
+                somePos2[0] = shell->pos.x;
+                somePos2[1] = shell->pos.y;
+                somePos2[2] = shell->pos.z;
+                shell->pos.x = player->pos.x + somePosVel[0];
+                shell->pos.y = player->pos.y + somePosVel[1];
+                shell->pos.z = player->pos.z + somePosVel[2];
+                actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, somePos2[0],
                                         somePos2[1], somePos2[2]);
                 func_802B4E30((struct Actor*) shell);
             }
             break;
         case GREEN_SHELL_HIT_A_RACER:
             // Somehow, this fake match affects stack management up in case 2
-            shell->velocity[1] -= (0, 0.3f);
-            if (shell->velocity[1] < -5.0f) {
-                shell->velocity[1] = -5.0f;
+            shell->velocity.y -= (0, 0.3f);
+            if (shell->velocity.y < -5.0f) {
+                shell->velocity.y = -5.0f;
             }
             shell->rotAngle += 0x5B0;
             shell->someTimer -= 1;
-            shell->pos[1] += shell->velocity[1];
+            shell->pos.y += shell->velocity.y;
             if (shell->someTimer == 0) {
                 destroy_actor((struct Actor*) shell);
             }
diff --git a/src/actors/item_box/render.inc.c b/src/actors/item_box/render.inc.c
index 12cc17497..372870966 100644
--- a/src/actors/item_box/render.inc.c
+++ b/src/actors/item_box/render.inc.c
@@ -30,7 +30,7 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
     // @port: Tag the transform.
     FrameInterpolation_RecordOpenChild("ItemBox", TAG_ITEM_ADDR(item_box));
 
-    temp_f0 = is_within_render_distance(camera->pos, item_box->pos, camera->rot[1], 0.0f, gCameraZoom[camera - camera1],
+    temp_f0 = is_within_render_distance(camera->pos, item_box->pos, camera->rot.y, 0.0f, gCameraZoom[camera - camera1],
                                         4000000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = CLAMP(temp_f0, 0.0f, 600000.0f);
@@ -38,11 +38,11 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
     if (!(temp_f0 < 0.0f) && !(600000.0f < temp_f0)) {
         if ((item_box->state == 2) && (temp_f0 < 100000.0f)) {
             someRot[0] = 0;
-            someRot[1] = item_box->rot[1];
+            someRot[1] = item_box->rot.y;
             someRot[2] = 0;
-            someVec2[0] = item_box->pos[0];
+            someVec2[0] = item_box->pos.x;
             someVec2[1] = item_box->resetDistance + 2.0f;
-            someVec2[2] = item_box->pos[2];
+            someVec2[2] = item_box->pos.z;
 
             mtxf_pos_rotation_xyz(someMatrix1, someVec2, someRot);
 
@@ -52,8 +52,8 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
 
             gSPDisplayList(gDisplayListHead++, D_0D002EE8);
 
-            someRot[1] = item_box->rot[1] * 2;
-            someVec2[1] = item_box->pos[1];
+            someRot[1] = item_box->rot.y * 2;
+            someVec2[1] = item_box->pos.y;
 
             mtxf_pos_rotation_xyz(someMatrix1, someVec2, someRot);
 
@@ -82,13 +82,13 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
 
             gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
             gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIA, G_CC_MODULATEIA);
-            // if ((item_box->rot[1] < 0xAA1) && (item_box->rot[1] > 0)) {
+            // if ((item_box->rot.y < 0xAA1) && (item_box->rot.y > 0)) {
             //     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-            // } else if ((item_box->rot[1] >= 0x6AA5) && (item_box->rot[1] < 0x754E)) {
+            // } else if ((item_box->rot.y >= 0x6AA5) && (item_box->rot.y < 0x754E)) {
             //     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-            // } else if ((item_box->rot[1] >= 0x38E1) && (item_box->rot[1] < 0x438A)) {
+            // } else if ((item_box->rot.y >= 0x38E1) && (item_box->rot.y < 0x438A)) {
             //     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
-            // } else if ((item_box->rot[1] >= 0xC711) && (item_box->rot[1] < 0xD1BA)) {
+            // } else if ((item_box->rot.y >= 0xC711) && (item_box->rot.y < 0xD1BA)) {
             //     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
             // } else {
             gDPSetBlendMask(gDisplayListHead++, 0xFF);
diff --git a/src/actors/item_box/update.inc.c b/src/actors/item_box/update.inc.c
index 47513ef8a..17a4e162f 100644
--- a/src/actors/item_box/update.inc.c
+++ b/src/actors/item_box/update.inc.c
@@ -10,9 +10,9 @@
 void update_actor_item_box_hot_air_balloon(struct ItemBox* itemBox) {
     switch (itemBox->state) {
         case 5:
-            itemBox->rot[0] += 0xB6;
-            itemBox->rot[1] -= 0x16C;
-            itemBox->rot[2] += 0xB6;
+            itemBox->rot.x += 0xB6;
+            itemBox->rot.y -= 0x16C;
+            itemBox->rot.z += 0xB6;
             break;
         case 3:
             if (itemBox->someTimer == 0x14) {
@@ -20,9 +20,9 @@ void update_actor_item_box_hot_air_balloon(struct ItemBox* itemBox) {
                 itemBox->flags = -0x4000;
             } else {
                 itemBox->someTimer++;
-                itemBox->rot[0] += 0x444;
-                itemBox->rot[1] -= 0x2D8;
-                itemBox->rot[2] += 0x16C;
+                itemBox->rot.x += 0x444;
+                itemBox->rot.y -= 0x2D8;
+                itemBox->rot.z += 0x16C;
             }
             break;
     }
@@ -39,29 +39,29 @@ void update_actor_item_box(struct ItemBox* itemBox) {
             itemBox->state = 1;
             break;
         case 1:
-            if ((itemBox->pos[1] - itemBox->origY) < 8.66f) {
-                itemBox->pos[1] += 0.45f;
+            if ((itemBox->pos.y - itemBox->origY) < 8.66f) {
+                itemBox->pos.y += 0.45f;
             } else {
-                itemBox->pos[1] = itemBox->origY + 8.66f;
+                itemBox->pos.y = itemBox->origY + 8.66f;
                 itemBox->state = 2;
                 itemBox->flags = 0xC000;
             }
             break;
         case 2:
-            itemBox->rot[0] += 0xB6;
-            itemBox->rot[1] -= 0x16C;
-            itemBox->rot[2] += 0xB6;
+            itemBox->rot.x += 0xB6;
+            itemBox->rot.y -= 0x16C;
+            itemBox->rot.z += 0xB6;
             break;
         case 3:
             if (itemBox->someTimer == 20) {
                 itemBox->state = 0;
-                itemBox->pos[1] = itemBox->resetDistance - 20.0f;
+                itemBox->pos.y = itemBox->resetDistance - 20.0f;
                 itemBox->flags = 0xC000;
             } else {
                 itemBox->someTimer++;
-                itemBox->rot[0] += 0x444;
-                itemBox->rot[1] -= 0x2D8;
-                itemBox->rot[2] += 0x16C;
+                itemBox->rot.x += 0x444;
+                itemBox->rot.y -= 0x2D8;
+                itemBox->rot.z += 0x16C;
             }
             break;
     }
diff --git a/src/actors/kiwano_fruit/render.inc.c b/src/actors/kiwano_fruit/render.inc.c
index 0ecfacf29..cf0a2a551 100644
--- a/src/actors/kiwano_fruit/render.inc.c
+++ b/src/actors/kiwano_fruit/render.inc.c
@@ -20,18 +20,18 @@ void render_actor_kiwano_fruit(UNUSED Camera* camera, Mat4 arg1, struct Actor* a
         return;
     }
 
-    arg1[3][0] = actor->pos[0];
-    arg1[3][1] = actor->pos[1];
-    arg1[3][2] = actor->pos[2];
+    arg1[3][0] = actor->pos.x;
+    arg1[3][1] = actor->pos.y;
+    arg1[3][2] = actor->pos.z;
 
     maxObjectsReached = render_set_position(arg1, 0) == 0;
     if (maxObjectsReached) {
         return;
     }
 
-    // Animate actor by creating an index from rot[0]. Divide by texture size to get whole number 0-2.
+    // Animate actor by creating an index from rot.x. Divide by texture size to get whole number 0-2.
     // All three animated textures need to be the same size for this to work.
-    size_t idx = (actor->rot[0] << 0xA) / ResourceGetTexSizeByName(gTextureDksJungleParkwayKiwanoFruit1);
+    size_t idx = (actor->rot.x << 0xA) / ResourceGetTexSizeByName(gTextureDksJungleParkwayKiwanoFruit1);
     switch(idx) {
         case 0:
             addr = gTextureDksJungleParkwayKiwanoFruit1;
@@ -44,7 +44,7 @@ void render_actor_kiwano_fruit(UNUSED Camera* camera, Mat4 arg1, struct Actor* a
             break;
     }
 
-    //addr = segmented_texture_to_virtual((actor->rot[0] << 0xA) + 0x03009000);
+    //addr = segmented_texture_to_virtual((actor->rot.x << 0xA) + 0x03009000);
     gDPLoadTextureBlock(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(addr), G_IM_FMT_CI, G_IM_SIZ_8b, 32, 32, 0,
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
                         G_TX_NOLOD);
diff --git a/src/actors/kiwano_fruit/update.inc.c b/src/actors/kiwano_fruit/update.inc.c
index a4e6b029d..8110a3516 100644
--- a/src/actors/kiwano_fruit/update.inc.c
+++ b/src/actors/kiwano_fruit/update.inc.c
@@ -28,34 +28,34 @@ void update_actor_kiwano_fruit(struct KiwanoFruit* fruit) {
                 return;
             }
             fruit->state = 1;
-            fruit->velocity[0] = 80.0f;
+            fruit->velocity.x = 80.0f;
         case 1:
             nearestWaypoint = gNearestWaypointByPlayerId[(u16) (player - gPlayerOne)];
-            temp_f2 = player->pos[0] - D_80164490[nearestWaypoint].posX;
-            temp_f16 = player->pos[1] - D_80164490[nearestWaypoint].posY;
-            temp_f14 = player->pos[2] - D_80164490[nearestWaypoint].posZ;
-            temp_f12 = fruit->velocity[0] / sqrtf((temp_f2 * temp_f2) + (temp_f16 * temp_f16) + (temp_f14 * temp_f14));
+            temp_f2 = player->pos.x - D_80164490[nearestWaypoint].posX;
+            temp_f16 = player->pos.y - D_80164490[nearestWaypoint].posY;
+            temp_f14 = player->pos.z - D_80164490[nearestWaypoint].posZ;
+            temp_f12 = fruit->velocity.x / sqrtf((temp_f2 * temp_f2) + (temp_f16 * temp_f16) + (temp_f14 * temp_f14));
             temp_f2 *= temp_f12;
             temp_f16 *= temp_f12;
             temp_f14 *= temp_f12;
-            fruit->pos[0] = player->pos[0] + temp_f2;
-            fruit->pos[1] = player->pos[1] + temp_f16;
-            fruit->pos[2] = player->pos[2] + temp_f14;
-            fruit->velocity[0] -= 2.0f;
-            if (fruit->velocity[0] <= 0.0f) {
+            fruit->pos.x = player->pos.x + temp_f2;
+            fruit->pos.y = player->pos.y + temp_f16;
+            fruit->pos.z = player->pos.z + temp_f14;
+            fruit->velocity.x -= 2.0f;
+            if (fruit->velocity.x <= 0.0f) {
                 fruit->state = 2;
                 fruit->bonkTimer = 30.0f;
-                fruit->velocity[0] = 0.0f;
-                fruit->velocity[1] = 2.3f;
-                fruit->velocity[2] = 0.0f;
+                fruit->velocity.x = 0.0f;
+                fruit->velocity.y = 2.3f;
+                fruit->velocity.z = 0.0f;
                 if ((player->effects & STAR_EFFECT) != 0) {
                     func_800C9060(player - gPlayerOne, SOUND_ARG_LOAD(0x19, 0x00, 0xA0, 0x52));
                 } else {
                     player->effects |= 0x8000;
-                    player->pos[0] -= temp_f2 * 4.0f;
-                    player->pos[2] -= temp_f14 * 4.0f;
-                    player->velocity[0] -= temp_f2 * 0.7f;
-                    player->velocity[2] -= temp_f14 * 0.7f;
+                    player->pos.x -= temp_f2 * 4.0f;
+                    player->pos.z -= temp_f14 * 4.0f;
+                    player->velocity.x -= temp_f2 * 0.7f;
+                    player->velocity.z -= temp_f14 * 0.7f;
                     func_800C9060(player - gPlayerOne, SOUND_ARG_LOAD(0x19, 0x00, 0x70, 0x18));
                     if (gModeSelection != GRAND_PRIX) {
                         D_80162DF8 = 1;
@@ -64,10 +64,10 @@ void update_actor_kiwano_fruit(struct KiwanoFruit* fruit) {
             }
             break;
         case 2:
-            fruit->velocity[1] -= 0.3f;
-            fruit->pos[0] += fruit->velocity[0];
-            fruit->pos[1] += fruit->velocity[1];
-            fruit->pos[2] += fruit->velocity[2];
+            fruit->velocity.y -= 0.3f;
+            fruit->pos.x += fruit->velocity.x;
+            fruit->pos.y += fruit->velocity.y;
+            fruit->pos.z += fruit->velocity.z;
             fruit->bonkTimer -= 1.0f;
             if (fruit->bonkTimer < 0.0f) {
                 fruit->state = 0;
diff --git a/src/actors/mario_sign/render.inc.c b/src/actors/mario_sign/render.inc.c
index 0bf10bf88..81ff85fc6 100644
--- a/src/actors/mario_sign/render.inc.c
+++ b/src/actors/mario_sign/render.inc.c
@@ -19,7 +19,7 @@ void render_actor_mario_sign(Camera* arg0, UNUSED Mat4 arg1, struct Actor* arg2)
         return;
     }
 
-    unk = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 16000000.0f);
+    unk = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 16000000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         unk = MAX(unk, 0.0f);
     }
diff --git a/src/actors/mario_sign/update.inc.c b/src/actors/mario_sign/update.inc.c
index 6a061eddd..cc27793a5 100644
--- a/src/actors/mario_sign/update.inc.c
+++ b/src/actors/mario_sign/update.inc.c
@@ -8,13 +8,13 @@
 void update_actor_mario_sign(struct Actor* arg0) {
     if ((arg0->flags & 0x800) == 0) {
         if ((arg0->flags & 0x400) != 0) {
-            arg0->pos[1] += 4.0f;
-            if (arg0->pos[1] > 800.0f) {
+            arg0->pos.y += 4.0f;
+            if (arg0->pos.y > 800.0f) {
                 arg0->flags |= 0x800;
-                arg0->rot[1] += 1820;
+                arg0->rot.y += 1820;
             }
         } else {
-            arg0->rot[1] += 182;
+            arg0->rot.y += 182;
         }
     }
 }
diff --git a/src/actors/paddle_boat/render.inc.c b/src/actors/paddle_boat/render.inc.c
index 26d65f160..f0e77d0a4 100644
--- a/src/actors/paddle_boat/render.inc.c
+++ b/src/actors/paddle_boat/render.inc.c
@@ -29,7 +29,7 @@ void render_actor_paddle_boat(Camera* arg0, struct PaddleWheelBoat* boat, UNUSED
         return;
     }
 
-    temp = is_within_render_distance(arg0->pos, boat->pos, arg0->rot[1], 90000.0f, gCameraZoom[arg0 - camera1],
+    temp = is_within_render_distance(arg0->pos, boat->pos, arg0->rot.y, 90000.0f, gCameraZoom[arg0 - camera1],
                                      9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
diff --git a/src/actors/palm_tree/render.inc.c b/src/actors/palm_tree/render.inc.c
index 064e0fe13..8c595f6f8 100644
--- a/src/actors/palm_tree/render.inc.c
+++ b/src/actors/palm_tree/render.inc.c
@@ -21,7 +21,7 @@ void render_actor_palm_tree(Camera* arg0, UNUSED Mat4 arg1, struct PalmTree* arg
     }
 
     temp_f0 =
-        is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0.0f, gCameraZoom[arg0 - camera1], 4000000.0f);
+        is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0.0f, gCameraZoom[arg0 - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
diff --git a/src/actors/piranha_plant/render.inc.c b/src/actors/piranha_plant/render.inc.c
index 23d018d1b..cdec7497b 100644
--- a/src/actors/piranha_plant/render.inc.c
+++ b/src/actors/piranha_plant/render.inc.c
@@ -25,7 +25,7 @@ void render_actor_piranha_plant(Camera* arg0, Mat4 arg1, struct PiranhaPlant* ar
         return;
     }
 
-    temp_f0 = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 1000000.0f);
+    temp_f0 = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 1000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -49,9 +49,9 @@ void render_actor_piranha_plant(Camera* arg0, Mat4 arg1, struct PiranhaPlant* ar
         }
         return;
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
     maxObjectsReached = render_set_position(arg1, 0) == 0;
     if (maxObjectsReached) {
         return;
diff --git a/src/actors/piranha_plant/update.inc.c b/src/actors/piranha_plant/update.inc.c
index 3091bb072..61a58da85 100644
--- a/src/actors/piranha_plant/update.inc.c
+++ b/src/actors/piranha_plant/update.inc.c
@@ -9,8 +9,8 @@
 void update_actor_piranha_plant(struct PiranhaPlant* arg0) {
     if ((arg0->flags & 0x800) == 0) {
         if ((arg0->flags & 0x400) != 0) {
-            arg0->pos[1] += 4.0f;
-            if (arg0->pos[1] > 800.0f) {
+            arg0->pos.y += 4.0f;
+            if (arg0->pos.y > 800.0f) {
                 arg0->flags |= 0x800;
             }
         } else {
diff --git a/src/actors/railroad_crossing/render.inc.c b/src/actors/railroad_crossing/render.inc.c
index 10ca253f0..393b4ec4a 100644
--- a/src/actors/railroad_crossing/render.inc.c
+++ b/src/actors/railroad_crossing/render.inc.c
@@ -13,7 +13,7 @@
 void render_actor_railroad_crossing(Camera* arg0, struct RailroadCrossing* rr_crossing) {
     UNUSED Vec3s sp80 = { 0, 0, 0 };
     Mat4 sp40;
-    f32 unk = is_within_render_distance(arg0->pos, rr_crossing->pos, arg0->rot[1], 0.0f, gCameraZoom[arg0 - camera1],
+    f32 unk = is_within_render_distance(arg0->pos, rr_crossing->pos, arg0->rot.y, 0.0f, gCameraZoom[arg0 - camera1],
                                         4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
diff --git a/src/actors/school_bus/render.inc.c b/src/actors/school_bus/render.inc.c
index 5deeb1c9d..3b72f60f2 100644
--- a/src/actors/school_bus/render.inc.c
+++ b/src/actors/school_bus/render.inc.c
@@ -18,7 +18,7 @@ void render_actor_school_bus(Camera* arg0, struct Actor* arg1) {
     f32 temp_f0;
 
     temp_f0 =
-        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
+        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
diff --git a/src/actors/tanker_truck/render.inc.c b/src/actors/tanker_truck/render.inc.c
index 8a3177969..af0f033a0 100644
--- a/src/actors/tanker_truck/render.inc.c
+++ b/src/actors/tanker_truck/render.inc.c
@@ -14,7 +14,7 @@ void render_actor_tanker_truck(Camera* camera, struct Actor* arg1) {
     UNUSED s32 pad[6];
     Mat4 spC8;
     UNUSED s32 pad2[32];
-    f32 temp_f0 = is_within_render_distance(camera->pos, arg1->pos, camera->rot[1], 2500.0f,
+    f32 temp_f0 = is_within_render_distance(camera->pos, arg1->pos, camera->rot.y, 2500.0f,
                                             gCameraZoom[camera - camera1], 9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
diff --git a/src/actors/train/render.inc.c b/src/actors/train/render.inc.c
index 825aa4cd9..fef198f73 100644
--- a/src/actors/train/render.inc.c
+++ b/src/actors/train/render.inc.c
@@ -19,7 +19,7 @@ void render_actor_train_engine(Camera* camera, struct TrainCar* actor) {
     Mat4 objectMtx;
     Mat4 resultMtx;
 
-    f32 distance = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 2500.0f,
+    f32 distance = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 2500.0f,
                                              gCameraZoom[camera - camera1], 9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
@@ -174,7 +174,7 @@ void render_actor_train_tender(Camera* camera, struct TrainCar* actor) {
     Mat4 spE0;
     Mat4 spA0;
 
-    f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 625.0f,
+    f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 625.0f,
                                             gCameraZoom[camera - camera1], 9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
@@ -267,7 +267,7 @@ void render_actor_train_passenger_car(Camera* camera, struct TrainCar* actor) {
     Mat4 spE0;
     Mat4 spA0;
 
-    f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 2025.0f,
+    f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 2025.0f,
                                             gCameraZoom[camera - camera1], 9000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
diff --git a/src/actors/trees/render.inc.c b/src/actors/trees/render.inc.c
index cb54275c6..07a030126 100644
--- a/src/actors/trees/render.inc.c
+++ b/src/actors/trees/render.inc.c
@@ -21,7 +21,7 @@ void render_actor_tree_mario_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
         return;
     }
 
-    temp_f0 = is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
+    temp_f0 = is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
                                         16000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
@@ -35,9 +35,9 @@ void render_actor_tree_mario_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 3.0f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -61,7 +61,7 @@ void render_actor_tree_yoshi_valley(Camera* camera, Mat4 arg1, struct Actor* arg
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -74,9 +74,9 @@ void render_actor_tree_yoshi_valley(Camera* camera, Mat4 arg1, struct Actor* arg
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -100,7 +100,7 @@ void render_actor_tree_royal_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -113,9 +113,9 @@ void render_actor_tree_royal_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -139,7 +139,7 @@ void render_actor_tree_moo_moo_farm(Camera* camera, Mat4 arg1, struct Actor* arg
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 6250000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 6250000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -152,9 +152,9 @@ void render_actor_tree_moo_moo_farm(Camera* camera, Mat4 arg1, struct Actor* arg
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 600.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 5.0f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -172,7 +172,7 @@ void func_80299864(Camera* camera, Mat4 arg1, struct Actor* arg2) {
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -185,9 +185,9 @@ void func_80299864(Camera* camera, Mat4 arg1, struct Actor* arg2) {
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -224,7 +224,7 @@ void render_actor_tree_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -237,9 +237,9 @@ void render_actor_tree_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -263,7 +263,7 @@ void render_actor_bush_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 640000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 640000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -276,9 +276,9 @@ void render_actor_bush_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
@@ -302,7 +302,7 @@ void render_actor_tree_frappe_snowland(Camera* camera, Mat4 arg1, struct Actor*
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -315,9 +315,9 @@ void render_actor_tree_frappe_snowland(Camera* camera, Mat4 arg1, struct Actor*
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, d_course_frappe_snowland_dl_tree);
@@ -340,7 +340,7 @@ void render_actor_tree_cactus1_kalimari_desert(Camera* camera, Mat4 arg1, struct
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -353,9 +353,9 @@ void render_actor_tree_cactus1_kalimari_desert(Camera* camera, Mat4 arg1, struct
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 1.0f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus1);
@@ -378,7 +378,7 @@ void render_actor_tree_cactus2_kalimari_desert(Camera* camera, Mat4 arg1, struct
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -391,9 +391,9 @@ void render_actor_tree_cactus2_kalimari_desert(Camera* camera, Mat4 arg1, struct
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 1.0f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus2);
@@ -416,7 +416,7 @@ void render_actor_tree_cactus3_kalimari_desert(Camera* camera, Mat4 arg1, struct
     }
 
     temp_f0 =
-        is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
+        is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = MAX(temp_f0, 0.0f);
@@ -429,9 +429,9 @@ void render_actor_tree_cactus3_kalimari_desert(Camera* camera, Mat4 arg1, struct
     if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
         func_8029794C(arg2->pos, arg2->rot, 0.80000001f);
     }
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1];
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus3);
diff --git a/src/actors/wario_sign/render.inc.c b/src/actors/wario_sign/render.inc.c
index 3658b7efb..2d1bfd297 100644
--- a/src/actors/wario_sign/render.inc.c
+++ b/src/actors/wario_sign/render.inc.c
@@ -13,7 +13,7 @@
 void render_actor_wario_sign(Camera* arg0, struct Actor* arg1) {
     Mat4 sp38;
     f32 unk =
-        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 16000000.0f);
+        is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 16000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         unk = MAX(unk, 0.0f);
diff --git a/src/actors/wario_sign/update.inc.c b/src/actors/wario_sign/update.inc.c
index 645b79774..bd2aca37d 100644
--- a/src/actors/wario_sign/update.inc.c
+++ b/src/actors/wario_sign/update.inc.c
@@ -7,5 +7,5 @@
  * @param arg0
  */
 void update_actor_wario_sign(struct Actor* arg0) {
-    arg0->rot[1] += 0xB6;
+    arg0->rot.y += 0xB6;
 }
diff --git a/src/actors/yoshi_egg/render.inc.c b/src/actors/yoshi_egg/render.inc.c
index f39524aa3..7f23cdd7b 100644
--- a/src/actors/yoshi_egg/render.inc.c
+++ b/src/actors/yoshi_egg/render.inc.c
@@ -20,7 +20,7 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
     f32 temp_f0;
 
     if (gGamestate != CREDITS_SEQUENCE) {
-        temp_f0 = is_within_render_distance(arg0->pos, egg->pos, arg0->rot[1], 200.0f, gCameraZoom[arg0 - camera1],
+        temp_f0 = is_within_render_distance(arg0->pos, egg->pos, arg0->rot.y, 200.0f, gCameraZoom[arg0 - camera1],
                                             16000000.0f);
 
         if (CVarGetInteger("gNoCulling", 0) == 1) {
@@ -43,9 +43,9 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
     gSPSetGeometryMode(gDisplayListHead++, G_SHADING_SMOOTH);
     if ((arg3 > 12) && (arg3 < 20)) {
         if (temp_f0 < 640000.0f) {
-            sp54[0] = egg->pos[0];
+            sp54[0] = egg->pos.x;
             sp54[1] = 3.0f;
-            sp54[2] = egg->pos[2];
+            sp54[2] = egg->pos.z;
             func_802976D8(sp5C);
             func_8029794C(sp54, sp5C, 10.0f);
         }
@@ -64,9 +64,9 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
         gSPDisplayList(gDisplayListHead++, d_course_yoshi_valley_dl_16D70);
         FrameInterpolation_RecordMatrixPop(sp60);
     } else {
-        arg1[3][0] = egg->pos[0];
-        arg1[3][1] = egg->pos[1];
-        arg1[3][2] = egg->pos[2];
+        arg1[3][0] = egg->pos.x;
+        arg1[3][1] = egg->pos.y;
+        arg1[3][2] = egg->pos.z;
 
         FrameInterpolation_RecordMatrixPush(arg1);
 
diff --git a/src/actors/yoshi_egg/update.inc.c b/src/actors/yoshi_egg/update.inc.c
index 87c217a2d..94459bd4c 100644
--- a/src/actors/yoshi_egg/update.inc.c
+++ b/src/actors/yoshi_egg/update.inc.c
@@ -7,16 +7,16 @@
  */
 void update_actor_yoshi_egg(struct YoshiValleyEgg* egg) {
     egg->pathRot += 0x5B;
-    egg->pos[0] = egg->pathCenter[0] + (sins(egg->pathRot) * egg->pathRadius);
-    egg->pos[2] = egg->pathCenter[2] + (coss(egg->pathRot) * egg->pathRadius);
+    egg->pos.x = egg->pathCenter[0] + (sins(egg->pathRot) * egg->pathRadius);
+    egg->pos.z = egg->pathCenter[2] + (coss(egg->pathRot) * egg->pathRadius);
     if ((egg->flags & 0x400) != 0) {
         egg->pathCenter[1] -= 0.12;
         if (egg->pathCenter[1] < -3.0f) {
             egg->pathCenter[1] = -3.0f;
         }
-        egg->pos[1] += egg->pathCenter[1];
-        if (egg->pos[1] < 0.0f) {
-            egg->pos[1] = 0.0f;
+        egg->pos.y += egg->pathCenter[1];
+        if (egg->pos.y < 0.0f) {
+            egg->pos.y = 0.0f;
             egg->pathCenter[1] = 0.0f;
             egg->flags &= ~(1 << 10);
         }
diff --git a/src/animation.c b/src/animation.c
index ed290ef7a..c53b63352 100644
--- a/src/animation.c
+++ b/src/animation.c
@@ -63,9 +63,9 @@ void mtxf_translate_rotate2(Mat4 dest, Vec3f pos, Vec3s angle) {
     dest[2][2] = cx * cy;
     dest[2][3] = 0.0f;
 
-    dest[3][0] = pos[0];
-    dest[3][1] = pos[1];
-    dest[3][2] = pos[2];
+    dest[3][0] = pos.x;
+    dest[3][1] = pos.y;
+    dest[3][2] = pos.z;
     dest[3][3] = 1.0f;
 }
 
diff --git a/src/audio/external.c b/src/audio/external.c
index 97a2ce7f3..3a9be93da 100644
--- a/src/audio/external.c
+++ b/src/audio/external.c
@@ -318,7 +318,7 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
             sp3C = (func_800C1480(arg0, arg1) * *temp_s0->unk14) * D_80192C48[arg0].current;
             sp3B = func_800C15D0(arg0, arg1, arg2);
             sp34 = func_800C1934(arg0, arg1) * *temp_s0->unk10;
-            sp33 = func_800C16E8(*temp_s0->unk00[0], *temp_s0->unk08, temp_s0->cameraId);
+            sp33 = func_800C16E8(*temp_s0->unk00.x, *temp_s0->unk08, temp_s0->cameraId);
             break;
     }
     temp_s0_2 = &D_8018EF18[arg2];
@@ -340,7 +340,7 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
     }
 }
 
-struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32* arg3, u8 arg4, u32 soundBits) {
+struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, Vec3f velocity, f32* arg3, u8 arg4, u32 soundBits) {
     struct Unk_8018EFD8* temp_a1;
     struct Unk_8018EFD8* temp_v1;
     u8 temp_t7;
@@ -355,14 +355,14 @@ struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32*
         D_8018FB91 = why1;
         D_8018FB90 = D_8018EFD8[D_8018FB90].next;
         D_8018EFD8[D_8018FB90].prev = 0xFF;
-        D_8018EFD8[why1].posX = &position[0];
-        D_8018EFD8[why1].posY = &position[1];
-        D_8018EFD8[why1].posZ = &position[2];
+        D_8018EFD8[why1].posX = &position.x;
+        D_8018EFD8[why1].posY = &position.y;
+        D_8018EFD8[why1].posZ = &position.z;
         D_8018EFD8[why1].next = 0xFF;
-        D_8018EFD8[why1].velX = &velocity[0];
-        D_8018EFD8[why1].velY = &velocity[1];
-        D_8018EFD8[why1].velZ = &velocity[2];
-        D_8018EFD8[why1].unk18[1] = 0.0f;
+        D_8018EFD8[why1].velX = &velocity.x;
+        D_8018EFD8[why1].velY = &velocity.y;
+        D_8018EFD8[why1].velZ = &velocity.z;
+        D_8018EFD8[why1].unk18.y = 0.0f;
         D_8018EFD8[why1].unk24 = arg3;
         D_8018EFD8[why1].cameraId = arg4;
         D_8018EFD8[why1].unk30 = arg0;
@@ -376,10 +376,10 @@ void func_800C1DA4(Camera* arg0, Vec3s rot, struct Unk_8018EFD8* arg2) {
     f32 x;
     f32 y;
 
-    x = arg0->pos[0] - *arg2->posX;
-    y = arg0->pos[2] - *arg2->posZ;
-    arg2->unk18[0] = func_800416D8(x, y, rot[1]);
-    arg2->unk18[2] = func_80041724(x, y, rot[1]);
+    x = arg0->pos.x - *arg2->posX;
+    y = arg0->pos.z - *arg2->posZ;
+    arg2->unk18.x = func_800416D8(x, y, rot.y);
+    arg2->unk18.z = func_80041724(x, y, rot.y);
 }
 
 void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
@@ -393,11 +393,11 @@ void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
     f32 thing1;
     f32 temp_f2;
 
-    x = (*arg2->posX) - camera->pos[0];
-    y = (*arg2->posZ) - camera->pos[2];
+    x = (*arg2->posX) - camera->pos.x;
+    y = (*arg2->posZ) - camera->pos.z;
 
-    sp44 = (*arg2->velX) - velocity[0];
-    temp_f6 = (*arg2->velZ) - velocity[2];
+    sp44 = (*arg2->velX) - velocity.x;
+    temp_f6 = (*arg2->velZ) - velocity.z;
 
     thing0 = x + sp44;
     thing1 = y + temp_f6;
@@ -414,7 +414,7 @@ void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
     }
 
     if ((*arg2->unk24) != 0.0f) {
-        arg2->unk2C *= (((*arg2->unk24) / D_800EA06C[arg2->unk30].unk00[1]) + D_800EA06C[arg2->unk30].unk00[0]) +
+        arg2->unk2C *= (((*arg2->unk24) / D_800EA06C[arg2->unk30].unk00.y) + D_800EA06C[arg2->unk30].unk00.x) +
                        D_800E9F34[arg2->unk30];
     }
 }
@@ -427,16 +427,16 @@ void func_800C1F8C(void) {
 
     var_a1 = D_800EA1C0 + 1;
     for (var_s1 = 0; var_s1 < var_a1; var_s1++) {
-        gVelocityCamera[var_s1][0] = gCopyCamera[var_s1]->pos[0] - gCameraLastPos[var_s1][0];
-        gVelocityCamera[var_s1][2] = gCopyCamera[var_s1]->pos[2] - gCameraLastPos[var_s1][2];
-        gCameraLastPos[var_s1][0] = gCopyCamera[var_s1]->pos[0];
-        gCameraLastPos[var_s1][2] = gCopyCamera[var_s1]->pos[2];
+        gVelocityCamera[var_s1].x = gCopyCamera[var_s1]->pos.x - gCameraLastPos[var_s1].x;
+        gVelocityCamera[var_s1].z = gCopyCamera[var_s1]->pos.z - gCameraLastPos[var_s1].z;
+        gCameraLastPos[var_s1].x = gCopyCamera[var_s1]->pos.x;
+        gCameraLastPos[var_s1].z = gCopyCamera[var_s1]->pos.z;
     }
 
     var_a1 = 0;
     var_s1 = D_8018EFD8[0].next;
     while (var_s1 != 0xFF) {
-        if (D_8018EFD8[var_s1].unk18[1] == 100000.0f) {
+        if (D_8018EFD8[var_s1].unk18.y == 100000.0f) {
             if (D_8018FB91 == var_s1) {
                 D_8018FB91 = D_8018EFD8[var_s1].prev;
             } else {
@@ -452,7 +452,7 @@ void func_800C1F8C(void) {
             // Why? Why would you do it this way? For what possible reason?
             camera = &gCopyCamera[cameraId];
             func_800C1DA4(*camera, (*camera)->rot, &D_8018EFD8[var_s1]);
-            if (D_800EA1C8 != D_8018EFD8[var_s1].velX) {
+            if (&D_800EA1C8 != D_8018EFD8[var_s1].velX) {
                 func_800C1E2C(*camera, gVelocityCamera[0], &D_8018EFD8[var_s1]);
             }
             var_a1 = var_s1;
@@ -468,7 +468,7 @@ Vec3f* func_800C21E8(Vec3f pos, u32 soundBits) {
     u8 it; // iterator
     Vec3f* ret;
     // Only here to force a match
-    UNUSED f32* thing = pos;
+    UNUSED f32* thing = &pos;
     struct Unk_8018EFD8* temp_a1;
 
     ret = 0;
@@ -477,10 +477,10 @@ Vec3f* func_800C21E8(Vec3f pos, u32 soundBits) {
         temp_a1 = &D_8018EFD8[it];
         // It doesn't matter what you set var_v0 to here actually
         it = D_8018EFD8[0].next;
-        if ((pos == temp_a1->posX) && (soundBits == temp_a1->soundBits)) {
+        if ((&pos == temp_a1->posX) && (soundBits == temp_a1->soundBits)) {
             // I suspect all this weirdness here is a result of someone not knowing the 'break' keyword
             it = 0xFF;
-            if (temp_a1->unk18[1] != 100000.0f) {
+            if (temp_a1->unk18.y != 100000.0f) {
                 ret = &temp_a1->unk18;
             } else {
                 goto test;
@@ -575,12 +575,12 @@ void func_800C2474(void) {
     for (var_v0 = 0; var_v0 < 4; var_v0++) {
         D_800E9DB4[var_v0] = 0;
         D_800E9DF4[var_v0] = 0; // This is an f32 FYI, but 0.0f doesn't match right :)
-        gVelocityCamera[var_v0][0] = 0.0f;
-        gVelocityCamera[var_v0][1] = 0.0f;
-        gVelocityCamera[var_v0][2] = 0.0f;
-        gCameraLastPos[var_v0][0] = 0.0f;
-        gCameraLastPos[var_v0][1] = 0.0f;
-        gCameraLastPos[var_v0][2] = 0.0f;
+        gVelocityCamera[var_v0].x = 0.0f;
+        gVelocityCamera[var_v0].y = 0.0f;
+        gVelocityCamera[var_v0].z = 0.0f;
+        gCameraLastPos[var_v0].x = 0.0f;
+        gCameraLastPos[var_v0].y = 0.0f;
+        gCameraLastPos[var_v0].z = 0.0f;
         D_800EA0EC[var_v0] = 0;
         D_800E9EA4[var_v0] = 0;
         D_800E9F7C[var_v0].unk_14 = 0;
@@ -1237,8 +1237,8 @@ void func_800C41CC(u8 arg0, struct SoundCharacteristics* arg1) {
         }
         if (found) {
             sound->soundBits = 0;
-            if (*sound->position != D_800EA1C8) {
-                (*sound->position)[1] = 100000.0f;
+            if (sound->position != &D_800EA1C8) {
+                sound->position.y = 100000.0f;
             }
         }
     }
@@ -1307,9 +1307,9 @@ void func_800C4398(void) {
     }
     if ((sSoundBanks[bank][sSoundBankFreeListFront[bank]].next != 0xFF) && (soundIndex != 0)) {
         soundIndex = sSoundBankFreeListFront[bank];
-        sSoundBanks[bank][soundIndex].unk00 = &(*var_a2->position)[0];
-        sSoundBanks[bank][soundIndex].unk04 = &(*var_a2->position)[1];
-        sSoundBanks[bank][soundIndex].unk08 = &(*var_a2->position)[2];
+        sSoundBanks[bank][soundIndex].unk00 = &(*var_a2->position).x;
+        sSoundBanks[bank][soundIndex].unk04 = &(*var_a2->position).y;
+        sSoundBanks[bank][soundIndex].unk08 = &(*var_a2->position).z;
         sSoundBanks[bank][soundIndex].cameraId = var_a2->cameraId;
         sSoundBanks[bank][soundIndex].unk10 = var_a2->unk0C;
         sSoundBanks[bank][soundIndex].unk14 = var_a2->unk10;
@@ -1324,8 +1324,8 @@ void func_800C4398(void) {
         sSoundBanks[bank][sSoundBankFreeListFront[bank]].prev = 0xFF;
         sSoundBanks[bank][soundIndex].next = 0xFF;
     } else if (sSoundBanks[bank][sSoundBankFreeListFront[bank]].next == 0xFF) {
-        if (D_800EA1C8 != *var_a2->position) {
-            (*var_a2->position)[1] = 100000.0f;
+        if (&D_800EA1C8 != var_a2->position) {
+            (*var_a2->position).y = 100000.0f;
         }
     }
 }
@@ -1336,7 +1336,7 @@ GLOBAL_ASM("asm/non_matchings/audio/external/func_800C4398.s")
 void delete_sound_from_bank(u8 bankId, u8 soundId) {
     UNUSED s32 stackPadding;
     struct SoundCharacteristics* temp = &sSoundBanks[bankId][soundId];
-    if (*temp->unk00 != D_800EA1C8) {
+    if (temp->unk00->x != D_800EA1C8.x) {
         *temp->unk04 = 100000.0f;
     }
     if (temp->soundBits & 0x80000) {
@@ -1393,10 +1393,10 @@ void func_800C4888(u8 bankId) {
         if (temp_t2->freshness == 0) {
             delete_sound_from_bank(bankId, soundIndex);
         } else if (temp_t2->soundStatus != 0) {
-            if (D_800EA1C8 == *temp_t2->unk00) {
+            if (D_800EA1C8.x == temp_t2->unk00->x) {
                 temp_t2->distance = 0.0f;
             } else {
-                temp_t2->distance = ((*temp_t2->unk00)[0] * (*temp_t2->unk00)[0]) + (*temp_t2->unk08 * *temp_t2->unk08);
+                temp_t2->distance = (temp_t2->unk00->x * temp_t2->unk00->x) + (*temp_t2->unk08 * *temp_t2->unk08);
             }
             requestedPriority = ((u32) (temp_t2->soundBits & 0xFF00) >> 8) & 0xFF;
             if (temp_t2->soundBits & 0x100000) {
@@ -1581,7 +1581,7 @@ void func_800C5384(u8 arg0, Vec3f* arg1) {
     next = sSoundBanks[arg0][0].next;
 
     while (next != 0xff) {
-        if (*arg1 == *sSoundBanks[arg0][next].unk00) {
+        if (arg1->x == sSoundBanks[arg0][next].unk00->x) {
             if (sSoundBanks[arg0][next].soundStatus >= 3) {
                 func_800CBBE8((0x06020000 | ((sSoundBanks[arg0][next].unk2C & 0xff) << 8)), 0);
             }
@@ -2789,7 +2789,7 @@ void func_800C8AE4(void) {
 }
 
 void func_800C8C7C(u8 arg0) {
-    D_800EA06C[arg0].unk00[2] = (1.0f - D_800E9F54[arg0]) - D_800EA130[arg0];
+    D_800EA06C[arg0].unk00.z = (1.0f - D_800E9F54[arg0]) - D_800EA130[arg0];
 }
 
 void func_800C8CCC() {
@@ -2913,7 +2913,7 @@ void func_800C92CC(u8 playerId, u32 soundBits) {
 
     if ((D_800EA108 == 0) && (D_800EA0F0 == 0) && ((s32) D_800EA1C0 < 2)) {
         for (var_s0 = 0; var_s0 < D_800EA1C0 + 1; var_s0++) {
-            temp_v0 = func_800C1C88(playerId, gPlayers[playerId].pos, gPlayers[playerId].velocity, D_800EA1C8,
+            temp_v0 = func_800C1C88(playerId, gPlayers[playerId].pos, gPlayers[playerId].velocity, &D_800EA1C8,
                                     (u8) var_s0, soundBits);
             if (temp_v0 != NULL) {
                 temp_v0->unk34 = 170.0f;
@@ -3072,26 +3072,26 @@ void func_800C9A88(u8 playerId) {
                 switch (gPlayers[playerId].characterId) {
                     case 0:
                     case 1:
-                        D_800EA06C[playerId].unk00[0] = 0.35f;
-                        D_800EA06C[playerId].unk00[1] = 1568.9796f;
+                        D_800EA06C[playerId].unk00.x = 0.35f;
+                        D_800EA06C[playerId].unk00.y = 1568.9796f;
                         break;
                     case 2:
                     case 6:
-                        D_800EA06C[playerId].unk00[0] = 0.6f;
-                        D_800EA06C[playerId].unk00[1] = 1478.4615f;
+                        D_800EA06C[playerId].unk00.x = 0.6f;
+                        D_800EA06C[playerId].unk00.y = 1478.4615f;
                         break;
                     case 3:
-                        D_800EA06C[playerId].unk00[0] = 0.6f;
-                        D_800EA06C[playerId].unk00[1] = 1747.2728f;
+                        D_800EA06C[playerId].unk00.x = 0.6f;
+                        D_800EA06C[playerId].unk00.y = 1747.2728f;
                         break;
                     case 4:
-                        D_800EA06C[playerId].unk00[0] = 0.2f;
-                        D_800EA06C[playerId].unk00[1] = 2135.5557f;
+                        D_800EA06C[playerId].unk00.x = 0.2f;
+                        D_800EA06C[playerId].unk00.y = 2135.5557f;
                         break;
                     case 5:
                     case 7:
-                        D_800EA06C[playerId].unk00[0] = 0.4f;
-                        D_800EA06C[playerId].unk00[1] = 1922.0f;
+                        D_800EA06C[playerId].unk00.x = 0.4f;
+                        D_800EA06C[playerId].unk00.y = 1922.0f;
                 }
                 if (D_800EA1C0 < 2) {
                     for (var_s0 = 0; var_s0 < D_800EA1C0 + 1; var_s0++) {
@@ -3101,7 +3101,7 @@ void func_800C9A88(u8 playerId) {
                         if (temp_v0_6 != NULL) {
                             temp_v0_6->unk34 = 40.0f;
                             play_sound(soundBits, &temp_v0_6->unk18, var_s0, &temp_v0_6->unk2C,
-                                       &D_800EA06C[playerId].unk00[2], &D_800EA06C[playerId].unk0C);
+                                       &D_800EA06C[playerId].unk00.z, &D_800EA06C[playerId].unk0C);
                         }
                     }
                 }
diff --git a/src/camera.c b/src/camera.c
index 07003f07d..854c1b23c 100644
--- a/src/camera.c
+++ b/src/camera.c
@@ -70,13 +70,13 @@ void camera_init(f32 posX, f32 posY, f32 posZ, UNUSED s16 rot, u32 arg4, s32 cam
         case 9:
         case 10:
             D_80164A89 = 0;
-            camera->pos[0] = posX;
-            camera->pos[1] = posY;
-            camera->pos[2] = posZ;
+            camera->pos.x = posX;
+            camera->pos.y = posY;
+            camera->pos.z = posZ;
             camera->someBitFlags = 0;
-            camera->lookAt[0] = 0.0f;
-            camera->lookAt[2] = 150.0f;
-            camera->lookAt[1] = posY - 3.0;
+            camera->lookAt.x = 0.0f;
+            camera->lookAt.z = 150.0f;
+            camera->lookAt.y = posY - 3.0;
             camera->up[0] = 0.0f;
             camera->up[1] = 1.0f;
             camera->up[2] = 0.0f;
@@ -237,9 +237,9 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
     sp5C[0] = camera->unk_3C[0];
     sp5C[1] = camera->unk_3C[1];
     sp5C[2] = camera->unk_3C[2];
-    arg2[0] = camera->lookAt[0];
-    arg2[1] = camera->lookAt[1];
-    arg2[2] = camera->lookAt[2];
+    arg2[0] = camera->lookAt.x;
+    arg2[1] = camera->lookAt.y;
+    arg2[2] = camera->lookAt.z;
     calculate_orientation_matrix(sp74, 0, 1, 0, -0x00008000);
     mtxf_translate_vec3f_mat3(sp5C, sp74);
     if (GetCourse() == GetToadsTurnpike()) {
@@ -249,9 +249,9 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
     }
     temp_f16 = D_80165230[7] + sp5C[2];
     temp_f18 = sp5C[1] + (temp_s2->posY + D_80164A30);
-    arg2[0] += (var_f14 - camera->lookAt[0]) * 1;
-    arg2[1] += (temp_f18 - camera->lookAt[1]) * 1;
-    arg2[2] += (temp_f16 - camera->lookAt[2]) * 1;
+    arg2[0] += (var_f14 - camera->lookAt.x) * 1;
+    arg2[1] += (temp_f18 - camera->lookAt.y) * 1;
+    arg2[2] += (temp_f16 - camera->lookAt.z) * 1;
     mtxf_translate_vec3f_mat3(sp68, sp74);
     if (GetCourse() == GetToadsTurnpike()) {
         var_f14 = sp68[0];
@@ -261,11 +261,11 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
     temp_f16 = D_80165230[7] + sp68[2];
     temp_f18 = sp68[1] + (temp_s2->posY + D_80164A30 + 6.0f);
     move_f32_towards(&D_80164A30, 0, 0.02f);
-    posX = camera->pos[0];
+    posX = camera->pos.x;
     *arg3 = ((var_f14 - posX) * 1) + posX;
-    posY = camera->pos[1];
+    posY = camera->pos.y;
     *arg4 = ((temp_f18 - posY) * 1) + posY;
-    posZ = camera->pos[2];
+    posZ = camera->pos.z;
     *arg5 = ((temp_f16 - posZ) * 1) + posZ;
 }
 
@@ -366,45 +366,45 @@ void func_8001CCEC(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
     sp84[0] = camera->unk_3C[0];
     sp84[1] = camera->unk_3C[1] + (player->unk_DB4.unk1E * 0.85) + temp_f12;
     sp84[2] = camera->unk_3C[2] + temp_f0 - D_80164A90[index];
-    arg2[0] = camera->lookAt[0];
-    arg2[1] = camera->lookAt[1];
-    arg2[2] = camera->lookAt[2];
+    arg2[0] = camera->lookAt.x;
+    arg2[1] = camera->lookAt.y;
+    arg2[2] = camera->lookAt.z;
     if ((player->effects & 0x01000000) == 0x01000000) {
         sp84[2] /= 3.0f;
     }
     calculate_orientation_matrix(sp9C, 0, 1, 0, arg7);
     mtxf_translate_vec3f_mat3(sp84, sp9C);
 
-    x = player->pos[0] + sp84[0];
-    z = player->pos[2] + sp84[2];
-    y = player->pos[1] + sp84[1];
+    x = player->pos.x + sp84[0];
+    z = player->pos.z + sp84[2];
+    y = player->pos.y + sp84[1];
 
-    arg2[0] += (x - camera->lookAt[0]) * D_80164A78[index];
-    arg2[2] += ((z - camera->lookAt[2]) * D_80164A78[index]);
+    arg2[0] += (x - camera->lookAt.x) * D_80164A78[index];
+    arg2[2] += ((z - camera->lookAt.z) * D_80164A78[index]);
 
     if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
-        arg2[1] += ((y - camera->lookAt[1]) * 0.02);
+        arg2[1] += ((y - camera->lookAt.y) * 0.02);
     } else {
-        arg2[1] += ((y - camera->lookAt[1]) * 0.5);
+        arg2[1] += ((y - camera->lookAt.y) * 0.5);
     }
     mtxf_translate_vec3f_mat3(sp90, sp9C);
-    x = player->pos[0] + sp90[0];
-    z = player->pos[2] + sp90[2];
+    x = player->pos.x + sp90[0];
+    z = player->pos.z + sp90[2];
     if ((player->effects & 0x01000000) != 0x01000000) {
-        var_f0 = player->pos[1] + sp90[1];
+        var_f0 = player->pos.y + sp90[1];
         // permute
         y = var_f0;
     } else {
         y = player->unk_074 + player->boundingBoxSize + sp90[1];
     }
 
-    *arg3 = camera->pos[0] + ((x - camera->pos[0]) * D_80164A78[index]);
-    *arg5 = camera->pos[2] + ((z - camera->pos[2]) * D_80164A78[index]);
+    *arg3 = camera->pos.x + ((x - camera->pos.x) * D_80164A78[index]);
+    *arg5 = camera->pos.z + ((z - camera->pos.z) * D_80164A78[index]);
 
     if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
-        *arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.01));
+        *arg4 = camera->pos.y + (((y - camera->pos.y) * 0.01));
     } else {
-        *arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.15));
+        *arg4 = camera->pos.y + (((y - camera->pos.y) * 0.15));
     }
 
     if ((player->unk_0DE & 1) != 0) {
@@ -437,20 +437,20 @@ void func_8001D53C(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
     sp5C[0] = camera->unk_3C[0];
     sp5C[1] = camera->unk_3C[1] + camera->unk_A0;
     sp5C[2] = camera->unk_3C[2];
-    arg2[0] = camera->lookAt[0];
-    arg2[1] = camera->lookAt[1];
-    arg2[2] = camera->lookAt[2];
+    arg2[0] = camera->lookAt.x;
+    arg2[1] = camera->lookAt.y;
+    arg2[2] = camera->lookAt.z;
     calculate_orientation_matrix(sp74, 0.0f, 1.0f, 0.0f, arg6);
     mtxf_translate_vec3f_mat3(sp5C, sp74);
-    stackPadding0 = player->pos[0] + sp5C[0];
-    stackPadding2 = player->pos[2] + sp5C[2];
-    stackPadding1 = player->pos[1] + sp5C[1];
-    arg2[0] += (stackPadding0 - camera->lookAt[0]) * 1;
-    arg2[2] += (stackPadding2 - camera->lookAt[2]) * 1;
-    arg2[1] += (stackPadding1 - camera->lookAt[1]) * 1;
+    stackPadding0 = player->pos.x + sp5C[0];
+    stackPadding2 = player->pos.z + sp5C[2];
+    stackPadding1 = player->pos.y + sp5C[1];
+    arg2[0] += (stackPadding0 - camera->lookAt.x) * 1;
+    arg2[2] += (stackPadding2 - camera->lookAt.z) * 1;
+    arg2[1] += (stackPadding1 - camera->lookAt.y) * 1;
     mtxf_translate_vec3f_mat3(sp68, sp74);
-    stackPadding0 = player->pos[0] + sp68[0];
-    stackPadding2 = player->pos[2] + sp68[2];
+    stackPadding0 = player->pos.x + sp68[0];
+    stackPadding2 = player->pos.z + sp68[2];
     stackPadding1 = sp68[1] + (player->unk_074 + 1.5);
     if ((player->unk_0CA & 1) == 1) {
         stackPadding1 = sp68[1] + (thing + 10.0f);
@@ -479,28 +479,28 @@ void func_8001D794(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
     sp54[1] = camera->unk_3C[1];
     sp54[2] = camera->unk_3C[2];
 
-    arg2[0] = camera->lookAt[0];
-    arg2[1] = camera->lookAt[1];
-    arg2[2] = camera->lookAt[2];
+    arg2[0] = camera->lookAt.x;
+    arg2[1] = camera->lookAt.y;
+    arg2[2] = camera->lookAt.z;
 
     calculate_orientation_matrix(sp6C, 0, 1, 0, arg6);
     mtxf_translate_vec3f_mat3(sp54, sp6C);
 
-    test1 = player->pos[0] + sp54[0];
-    test3 = player->pos[2] + sp54[2];
-    test2 = player->pos[1] + sp54[1];
-    arg2[0] += (test1 - camera->lookAt[0]) * 1;
-    arg2[1] += (test2 - camera->lookAt[1]) * 1;
-    arg2[2] += (test3 - camera->lookAt[2]) * 1;
+    test1 = player->pos.x + sp54[0];
+    test3 = player->pos.z + sp54[2];
+    test2 = player->pos.y + sp54[1];
+    arg2[0] += (test1 - camera->lookAt.x) * 1;
+    arg2[1] += (test2 - camera->lookAt.y) * 1;
+    arg2[2] += (test3 - camera->lookAt.z) * 1;
 
     mtxf_translate_vec3f_mat3(sp60, sp6C);
 
-    test1 = player->pos[0] + sp60[0];
-    test3 = player->pos[2] + sp60[2];
-    test2 = player->pos[1] + sp60[1];
-    *arg3 = camera->pos[0] + ((test1 - camera->pos[0]) * 1);
-    *arg4 = camera->pos[1] + ((test2 - camera->pos[1]) * 1);
-    *arg5 = camera->pos[2] + ((test3 - camera->pos[2]) * 1);
+    test1 = player->pos.x + sp60[0];
+    test3 = player->pos.z + sp60[2];
+    test2 = player->pos.y + sp60[1];
+    *arg3 = camera->pos.x + ((test1 - camera->pos.x) * 1);
+    *arg4 = camera->pos.y + ((test2 - camera->pos.y) * 1);
+    *arg5 = camera->pos.z + ((test3 - camera->pos.z) * 1);
 }
 
 void func_8001D944(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* arg4, f32* arg5, UNUSED s32* arg6,
@@ -586,45 +586,45 @@ void func_8001D944(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
     sp84[0] = camera->unk_3C[0];
     sp84[1] = camera->unk_3C[1] + (player->unk_DB4.unk1E * 0.85) + temp_f12;
     sp84[2] = camera->unk_3C[2] + temp_f0 - D_80164A90[index];
-    arg2[0] = camera->lookAt[0];
-    arg2[1] = camera->lookAt[1];
-    arg2[2] = camera->lookAt[2];
+    arg2[0] = camera->lookAt.x;
+    arg2[1] = camera->lookAt.y;
+    arg2[2] = camera->lookAt.z;
     if ((player->effects & 0x01000000) == 0x01000000) {
         sp84[2] /= 3.0f;
     }
     calculate_orientation_matrix(sp9C, 0, 1, 0, arg7);
     mtxf_translate_vec3f_mat3(sp84, sp9C);
 
-    x = player->pos[0] + sp84[0];
-    z = player->pos[2] + sp84[2];
-    y = player->pos[1] + sp84[1];
+    x = player->pos.x + sp84[0];
+    z = player->pos.z + sp84[2];
+    y = player->pos.y + sp84[1];
 
-    arg2[0] += (x - camera->lookAt[0]) * D_80164A78[index];
-    arg2[2] += ((z - camera->lookAt[2]) * D_80164A78[index]);
+    arg2[0] += (x - camera->lookAt.x) * D_80164A78[index];
+    arg2[2] += ((z - camera->lookAt.z) * D_80164A78[index]);
 
     if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
-        arg2[1] += ((y - camera->lookAt[1]) * 0.02);
+        arg2[1] += ((y - camera->lookAt.y) * 0.02);
     } else {
-        arg2[1] += ((y - camera->lookAt[1]) * 0.5);
+        arg2[1] += ((y - camera->lookAt.y) * 0.5);
     }
     mtxf_translate_vec3f_mat3(sp90, sp9C);
-    x = player->pos[0] + sp90[0];
-    z = player->pos[2] + sp90[2];
+    x = player->pos.x + sp90[0];
+    z = player->pos.z + sp90[2];
     if ((player->effects & 0x01000000) != 0x01000000) {
-        var_f0 = player->pos[1] + sp90[1];
+        var_f0 = player->pos.y + sp90[1];
         // permute
         y = var_f0;
     } else {
         y = player->unk_074 + player->boundingBoxSize + sp90[1];
     }
 
-    *arg3 = camera->pos[0] + ((x - camera->pos[0]) * D_80164A78[index]);
-    *arg5 = camera->pos[2] + ((z - camera->pos[2]) * D_80164A78[index]);
+    *arg3 = camera->pos.x + ((x - camera->pos.x) * D_80164A78[index]);
+    *arg5 = camera->pos.z + ((z - camera->pos.z) * D_80164A78[index]);
 
     if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
-        *arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.01));
+        *arg4 = camera->pos.y + (((y - camera->pos.y) * 0.01));
     } else {
-        *arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.15));
+        *arg4 = camera->pos.y + (((y - camera->pos.y) * 0.15));
     }
 
     if ((player->unk_0DE & 1) != 0) {
@@ -678,18 +678,18 @@ void func_8001E0C4(Camera* camera, Player* player, s8 arg2) {
     if ((temp_t7 == 0) && ((camera->someBitFlags & 2) != 2)) {
         camera->unk_AC = camera->unk_2C;
     }
-    camera->lookAt[0] = sp60[0];
-    camera->lookAt[1] = sp60[1];
-    camera->lookAt[2] = sp60[2];
-    camera->pos[0] = sp74;
-    camera->pos[1] = sp70;
-    camera->pos[2] = sp6C;
-    temp_f12 = camera->lookAt[0] - camera->pos[0];
-    sp80 = camera->lookAt[1] - camera->pos[1];
-    temp_f14 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(temp_f12, temp_f14);
-    camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp80);
-    camera->rot[2] = 0;
+    camera->lookAt.x = sp60[0];
+    camera->lookAt.y = sp60[1];
+    camera->lookAt.z = sp60[2];
+    camera->pos.x = sp74;
+    camera->pos.y = sp70;
+    camera->pos.z = sp6C;
+    temp_f12 = camera->lookAt.x - camera->pos.x;
+    sp80 = camera->lookAt.y - camera->pos.y;
+    temp_f14 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(temp_f12, temp_f14);
+    camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp80);
+    camera->rot.z = 0;
 }
 
 // This function has a few stack variables.
@@ -767,21 +767,21 @@ void func_8001E45C(Camera* camera, Player* player, s8 arg2) {
     camera->someBitFlags &= 0xFFFB;
     check_bounding_collision(&camera->collision, temp, sp84, sp80, sp7C);
 
-    camera->pos[0] = sp84;
-    camera->pos[1] = sp80;
-    camera->pos[2] = sp7C;
+    camera->pos.x = sp84;
+    camera->pos.y = sp80;
+    camera->pos.z = sp7C;
 
-    camera->lookAt[0] = sp64[0];
-    camera->lookAt[1] = sp64[1];
-    camera->lookAt[2] = sp64[2];
+    camera->lookAt.x = sp64[0];
+    camera->lookAt.y = sp64[1];
+    camera->lookAt.z = sp64[2];
 
-    temp_f12 = camera->lookAt[0] - camera->pos[0];
-    sp90 = camera->lookAt[1] - camera->pos[1];
-    temp_f14 = camera->lookAt[2] - camera->pos[2];
+    temp_f12 = camera->lookAt.x - camera->pos.x;
+    sp90 = camera->lookAt.y - camera->pos.y;
+    temp_f14 = camera->lookAt.z - camera->pos.z;
 
-    camera->rot[1] = atan2s(temp_f12, temp_f14);
-    camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
-    camera->rot[2] = 0;
+    camera->rot.y = atan2s(temp_f12, temp_f14);
+    camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
+    camera->rot.z = 0;
 }
 
 void func_8001E8E8(Camera* camera, Player* player, s8 arg2) {
@@ -801,18 +801,18 @@ void func_8001E8E8(Camera* camera, Player* player, s8 arg2) {
     camera->unk_2C = player->rotation[1];
     func_8001D53C(player, camera, sp5C, &sp7C, &sp78, &sp74, (s16) (s32) player->rotation[1], (s16) (s32) arg2);
     check_bounding_collision(&camera->collision, 5.0f, sp7C, sp78, sp74);
-    camera->lookAt[0] = sp5C[0];
-    camera->lookAt[1] = sp5C[1];
-    camera->lookAt[2] = sp5C[2];
-    camera->pos[0] = sp7C;
-    camera->pos[1] = sp78;
-    camera->pos[2] = sp74;
-    temp_f12 = camera->lookAt[0] - camera->pos[0];
-    sp88 = camera->lookAt[1] - camera->pos[1];
-    temp_f14 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(temp_f12, temp_f14);
-    camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp88);
-    camera->rot[2] = 0;
+    camera->lookAt.x = sp5C[0];
+    camera->lookAt.y = sp5C[1];
+    camera->lookAt.z = sp5C[2];
+    camera->pos.x = sp7C;
+    camera->pos.y = sp78;
+    camera->pos.z = sp74;
+    temp_f12 = camera->lookAt.x - camera->pos.x;
+    sp88 = camera->lookAt.y - camera->pos.y;
+    temp_f14 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(temp_f12, temp_f14);
+    camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp88);
+    camera->rot.z = 0;
 }
 
 void func_8001EA0C(Camera* camera, Player* player, s8 arg2) {
@@ -890,21 +890,21 @@ void func_8001EA0C(Camera* camera, Player* player, s8 arg2) {
     camera->someBitFlags &= 0xFFFB;
     check_bounding_collision(&camera->collision, temp, sp84, sp80, sp7C);
 
-    camera->pos[0] = sp84;
-    camera->pos[1] = sp80;
-    camera->pos[2] = sp7C;
+    camera->pos.x = sp84;
+    camera->pos.y = sp80;
+    camera->pos.z = sp7C;
 
-    camera->lookAt[0] = sp64[0];
-    camera->lookAt[1] = sp64[1];
-    camera->lookAt[2] = sp64[2];
+    camera->lookAt.x = sp64[0];
+    camera->lookAt.y = sp64[1];
+    camera->lookAt.z = sp64[2];
 
-    temp_f12 = camera->lookAt[0] - camera->pos[0];
-    sp90 = camera->lookAt[1] - camera->pos[1];
-    temp_f14 = camera->lookAt[2] - camera->pos[2];
+    temp_f12 = camera->lookAt.x - camera->pos.x;
+    sp90 = camera->lookAt.y - camera->pos.y;
+    temp_f14 = camera->lookAt.z - camera->pos.z;
 
-    camera->rot[1] = atan2s(temp_f12, temp_f14);
-    camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
-    camera->rot[2] = 0;
+    camera->rot.y = atan2s(temp_f12, temp_f14);
+    camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
+    camera->rot.z = 0;
 }
 
 void func_8001EE98(Player* player, Camera* camera, s8 index) {
@@ -1160,7 +1160,7 @@ void func_8001F87C(s32 cameraId) {
                 if ((playerIndex == 7) && (D_80164A2C == 0x0000003C)) {
                     D_80164A28 = 2;
                     D_80152300[id] = 1;
-                    cameras[id].rot[1] = gPlayerOne[playerIndex].rotation[1];
+                    cameras[id].rot.y = gPlayerOne[playerIndex].rotation[1];
                     cameras[id].unk_2C = gPlayerOne[playerIndex].rotation[1];
                 }
             }
diff --git a/src/code_80005FD0.c b/src/code_80005FD0.c
index 6263883f2..03b9d5b0e 100644
--- a/src/code_80005FD0.c
+++ b/src/code_80005FD0.c
@@ -644,8 +644,8 @@ s32 set_vehicle_render_distance_flags(Vec3f vehiclePos, f32 renderDistance, s32
         // Checks distance from each player.
         for (i = 0; i < gPlayerCount; i++, player++) {
             if (((player->type & PLAYER_HUMAN) != 0) && ((player->type & PLAYER_KART_AI) == 0)) {
-                playerX = player->pos[0];
-                playerZ = player->pos[2];
+                playerX = player->pos.x;
+                playerZ = player->pos.z;
 
                 // Is player within render distance
                 if (((playerX - renderDistance) < x) && ((playerX + renderDistance) > x) &&
@@ -661,8 +661,8 @@ s32 set_vehicle_render_distance_flags(Vec3f vehiclePos, f32 renderDistance, s32
     } else { // Demo cinematic uses the camera to check render distance
         camera = camera1;
         for (i = 0; i < numScreens; i++, camera++) {
-            playerX = camera->pos[0];
-            playerZ = camera->pos[2];
+            playerX = camera->pos.x;
+            playerZ = camera->pos.z;
             if (((playerX - renderDistance) < x) && (x < (playerX + renderDistance)) &&
                 ((playerZ - renderDistance) < z) && (z < (playerZ + renderDistance))) {
                 flag |= (RENDER_VEHICLE << i);
@@ -1027,8 +1027,8 @@ void func_80007FA4(s32 arg0, Player* player, f32 arg2) {
     f32 temp_f2;
     s32 test;
 
-    temp_f0 = D_80163418[arg0] - player->pos[0];
-    temp_f2 = D_80163438[arg0] - player->pos[2];
+    temp_f0 = D_80163418[arg0] - player->pos.x;
+    temp_f2 = D_80163438[arg0] - player->pos.z;
     temp_f12 = (temp_f0 * temp_f0) + (temp_f2 * temp_f2);
     if (arg0 == 3) {
         if ((temp_f12 < 25.0f) && (D_80163410[arg0] < 5)) {
@@ -1081,8 +1081,8 @@ void func_80008424(s32 playerId, f32 arg1, Player* player) {
         } else if ((bStopAICrossing[playerId] == 1) && !(player->effects & (STAR_EFFECT | BOO_EFFECT))) {
             decelerate_ai_player(player, 10.0f);
             if (player->currentSpeed == 0.0) {
-                player->velocity[0] = 0.0f;
-                player->velocity[2] = 0.0f;
+                player->velocity.x = 0.0f;
+                player->velocity.z = 0.0f;
             }
         } else {
             var_f0 = 3.3333333f;
@@ -1325,9 +1325,9 @@ s32 func_80008E58(s32 payerId, s32 pathIndex) {
     UNUSED s32 stackPadding;
 
     player = &gPlayers[payerId];
-    posX = player->pos[0];
-    posY = player->pos[1];
-    posZ = player->pos[2];
+    posX = player->pos.x;
+    posY = player->pos.y;
+    posZ = player->pos.z;
     stackPadding = pathIndex;
     trackSectionId = get_track_section_id(player->collision.meshIndexZX);
     D_80163318[payerId] = trackSectionId;
@@ -1394,9 +1394,9 @@ void func_800090F0(s32 playerId, Player* player) {
     f32 posZ;
     UNUSED f32 pad[2];
 
-    posX = player->pos[0];
-    posY = player->pos[1];
-    posZ = player->pos[2];
+    posX = player->pos.x;
+    posY = player->pos.y;
+    posZ = player->pos.z;
     if (D_80163490[playerId] == 1) {
         D_80163448 = func_80008E58(playerId, random_int(4U));
         sSomeNearestWaypoint = func_8000CD24(posX, posY, posZ, 0, player, playerId, D_80163448);
@@ -1435,9 +1435,9 @@ void func_8000929C(s32 playerId, Player* player) {
     s16 var_t0;
     UNUSED s32 stackPadding1;
 
-    tempPos0 = player->pos[0];
-    tempPos1 = player->pos[1];
-    tempPos2 = player->pos[2];
+    tempPos0 = player->pos.x;
+    tempPos1 = player->pos.y;
+    tempPos2 = player->pos.z;
     D_801630E2 = 0;
     D_80163240[playerId] = 0;
     sSomeNearestWaypoint =
@@ -1648,17 +1648,17 @@ void func_80009B60(s32 playerId) {
             return;
         }
         D_801633E0[playerId] = 0;
-        if (player->pos[0] < gCourseMinX) {
+        if (player->pos.x < gCourseMinX) {
             D_801633E0[playerId] = 1;
         }
-        if (gCourseMaxX < player->pos[0]) {
+        if (gCourseMaxX < player->pos.x) {
             D_801633E0[playerId] = 2;
         }
-        if (player->pos[2] < gCourseMinZ) {
+        if (player->pos.z < gCourseMinZ) {
             D_801633E0[playerId] = 3;
         }
         // MISMATCH3
-        if (gCourseMaxZ < player->pos[2]) {
+        if (gCourseMaxZ < player->pos.z) {
             D_801633E0[playerId] = 4;
         }
         if (!(player->unk_0CA & 2) && !(player->unk_0CA & 8)) {
@@ -1725,7 +1725,7 @@ void func_80009B60(s32 playerId) {
                     set_player_height(player);
                 }
                 if (D_801631E0[playerId] == 1) {
-                    player->pos[1] = D_80164510[playerId];
+                    player->pos.y = D_80164510[playerId];
                 }
                 D_801631F8[playerId] = D_801631E0[playerId];
 
@@ -1763,8 +1763,8 @@ void func_80009B60(s32 playerId) {
                     //check_ai_crossing_distance(playerId);
                     func_8000D3B8(playerId);
                     func_8000D438(playerId, D_801630E0);
-                    temp_f0 = D_80162FA0[0] - player->pos[0];
-                    temp_f2 = D_80162FA0[2] - player->pos[2];
+                    temp_f0 = D_80162FA0[0] - player->pos.x;
+                    temp_f2 = D_80162FA0[2] - player->pos.z;
                     if (!(player->effects & 0x80) && !(player->effects & 0x40) && !(player->effects & 0x800)) {
                         if (((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) > 6400.0f) {
                             if (D_80163448 == 0) {
@@ -2153,7 +2153,7 @@ void func_8000B95C(s32 playerId, u16 waypointIndex, s32 pathIndex) {
     if (CM_GetProps()->AIMaximumSeparation >= 0.0f) {
         if ((gPlayers[playerId].type & 0x8000) != 0) {
             D_80163068[playerId] =
-                func_8000B874(gPlayers[playerId].pos[0], gPlayers[playerId].pos[2], waypointIndex, pathIndex);
+                func_8000B874(gPlayers[playerId].pos.x, gPlayers[playerId].pos.z, waypointIndex, pathIndex);
         }
     }
 }
@@ -2513,9 +2513,9 @@ s16 func_8000CD24(f32 posX, f32 posY, f32 posZ, s16 waypointIndex, Player* playe
         if (D_801631E0[playerId] == 1) {
             if (player->unk_0CA & 1) {
                 temp_v1 = &D_80164550[pathIndex][waypointIndex];
-                player->pos[0] = (f32) temp_v1->posX;
-                player->pos[1] = (f32) temp_v1->posY;
-                player->pos[2] = (f32) temp_v1->posZ;
+                player->pos.x = (f32) temp_v1->posX;
+                player->pos.y = (f32) temp_v1->posY;
+                player->pos.z = (f32) temp_v1->posZ;
                 player->unk_0CA &= ~0x0001;
                 return waypointIndex;
             }
@@ -2531,9 +2531,9 @@ s16 func_8000CD24(f32 posX, f32 posY, f32 posZ, s16 waypointIndex, Player* playe
                     newWaypoint =
                         find_closest_waypoint_track_section(posX, posY, posZ, D_80163318[playerId], &pathIndex);
                     temp_v1 = &D_80164550[pathIndex][newWaypoint];
-                    player->pos[0] = (f32) temp_v1->posX;
-                    player->pos[1] = (f32) temp_v1->posY;
-                    player->pos[2] = (f32) temp_v1->posZ;
+                    player->pos.x = (f32) temp_v1->posX;
+                    player->pos.y = (f32) temp_v1->posY;
+                    player->pos.z = (f32) temp_v1->posZ;
                 }
             } else {
                 newWaypoint = find_closest_waypoint_with_previous_waypoint(posX, posY, posZ, waypointIndex, pathIndex);
@@ -2543,9 +2543,9 @@ s16 func_8000CD24(f32 posX, f32 posY, f32 posZ, s16 waypointIndex, Player* playe
                     posX = (f32) temp_v1->posX;
                     posY = (f32) temp_v1->posY;
                     posZ = (f32) temp_v1->posZ;
-                    player->pos[0] = posX;
-                    player->pos[1] = posY;
-                    player->pos[2] = posZ;
+                    player->pos.x = posX;
+                    player->pos.y = posY;
+                    player->pos.z = posZ;
                     check_bounding_collision(&player->collision, 10.0f, posX, posY, posZ);
                     D_80163318[playerId] = get_track_section_id(player->collision.meshIndexZX);
                 }
@@ -2734,12 +2734,12 @@ s16 func_8000D6D0(Vec3f position, s16* waypointIndex, f32 speed, f32 arg3, s16 p
     TrackWaypoint* path;
 
     path = D_80164550[pathIndex];
-    oldPos[0] = position[0];
-    oldPos[1] = position[1];
-    oldPos[2] = position[2];
-    oldPosX = position[0];
-    oldPosY = position[1];
-    oldPosZ = position[2];
+    oldPos[0] = position.x;
+    oldPos[1] = position.y;
+    oldPos[2] = position.z;
+    oldPosX = position.x;
+    oldPosY = position.y;
+    oldPosZ = position.z;
     temp_v0 = func_8000D2B4(oldPosX, oldPosY, oldPosZ, *waypointIndex, (s32) pathIndex);
     *waypointIndex = temp_v0;
     temp_v1 = temp_v0 + arg5;
@@ -2767,9 +2767,9 @@ s16 func_8000D6D0(Vec3f position, s16* waypointIndex, f32 speed, f32 arg3, s16 p
         var_f12 = oldPosY;
         var_f14 = oldPosZ;
     }
-    position[0] = var_f2;
-    position[1] = var_f12;
-    position[2] = var_f14;
+    position.x = var_f2;
+    position.y = var_f12;
+    position.z = var_f14;
     return get_angle_between_waypoints(oldPos, position);
 }
 
@@ -2800,13 +2800,13 @@ s16 func_8000D940(Vec3f pos, s16* waypointIndex, f32 speed, f32 arg3, s16 pathIn
     s32 waypointCount;
     Vec3f sp54;
 
-    sp54[0] = pos[0];
-    sp54[1] = pos[1];
-    sp54[2] = pos[2];
+    sp54[0] = pos.x;
+    sp54[1] = pos.y;
+    sp54[2] = pos.z;
     waypointCount = gWaypointCountByPathIndex[pathIndex];
-    temp_f20 = pos[0];
-    temp_f22 = pos[1];
-    temp_f24 = pos[2];
+    temp_f20 = pos.x;
+    temp_f22 = pos.y;
+    temp_f24 = pos.z;
     temp_v0 = func_8000D2B4(temp_f20, temp_f22, temp_f24, *waypointIndex, (s32) pathIndex);
     *waypointIndex = temp_v0;
     waypoint1 = ((temp_v0 + waypointCount) - 3) % waypointCount;
@@ -2833,9 +2833,9 @@ s16 func_8000D940(Vec3f pos, s16* waypointIndex, f32 speed, f32 arg3, s16 pathIn
         var_f12 = temp_f22;
         var_f14 = temp_f24;
     }
-    pos[0] = var_f2;
-    pos[1] = var_f12;
-    pos[2] = var_f14;
+    pos.x = var_f2;
+    pos.y = var_f12;
+    pos.z = var_f14;
     return get_angle_between_waypoints(sp54, pos);
 }
 
@@ -2866,12 +2866,12 @@ s16 update_vehicle_following_waypoint(Vec3f pos, s16* waypointIndex, f32 speed)
     Path2D* temp_a2;
     Vec3f sp38;
 
-    origXPos = pos[0];
-    origYPos = pos[1];
-    origZPos = pos[2];
-    sp38[0] = pos[0];
-    sp38[1] = pos[1];
-    sp38[2] = pos[2];
+    origXPos = pos.x;
+    origYPos = pos.y;
+    origZPos = pos.z;
+    sp38[0] = pos.x;
+    sp38[1] = pos.y;
+    sp38[2] = pos.z;
     newWaypointIndex = find_closest_vehicles_waypoint(origXPos, origYPos, origZPos, *waypointIndex);
     *waypointIndex = newWaypointIndex;
     farWaypoint1 = (newWaypointIndex + 3) % gVehicle2DWaypointLength;
@@ -2890,9 +2890,9 @@ s16 update_vehicle_following_waypoint(Vec3f pos, s16* waypointIndex, f32 speed)
         newX = origXPos;
         newZ = origZPos;
     }
-    pos[0] = newX;
-    pos[1] = origYPos;
-    pos[2] = newZ;
+    pos.x = newX;
+    pos.y = origYPos;
+    pos.z = newZ;
     return get_angle_between_waypoints(sp38, pos);
 }
 
@@ -3028,9 +3028,9 @@ void func_8000DF8C(s32 bombKartId) {
             if (GetCourse() == GetPodiumCeremony()) {
                 if (D_8016347E == 1) {
                     var_v0 = gPlayerFour;
-                    temp_f0 = var_f22 - var_v0->pos[0];
-                    temp_f2 = var_f20 - var_v0->pos[1];
-                    temp_f12 = var_f24 - var_v0->pos[2];
+                    temp_f0 = var_f22 - var_v0->pos.x;
+                    temp_f2 = var_f20 - var_v0->pos.y;
+                    temp_f12 = var_f24 - var_v0->pos.z;
                     if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
                         var_s1 = 0;
                         sp7E = 4;
@@ -3043,9 +3043,9 @@ void func_8000DF8C(s32 bombKartId) {
                 for (var_a0 = 0; var_a0 < gPlayerCount; var_a0++) {
                     var_v0 = &gPlayers[var_a0];
                     if (!(var_v0->effects & 0x80000000)) {
-                        temp_f0 = var_f22 - var_v0->pos[0];
-                        temp_f2 = var_f20 - var_v0->pos[1];
-                        temp_f12 = var_f24 - var_v0->pos[2];
+                        temp_f0 = var_f22 - var_v0->pos.x;
+                        temp_f2 = var_f20 - var_v0->pos.y;
+                        temp_f12 = var_f24 - var_v0->pos.z;
                         if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
                             sp7E = 4;
                             var_s1 = 0;
@@ -3514,7 +3514,7 @@ void func_8000F628(void) {
         D_801633C8[i] = 0;
         D_801633F8[i] = 0;
         D_80163318[i] = 0;
-        D_80163450[i] = player->pos[2];
+        D_80163450[i] = player->pos.z;
         D_80163380[i] = 6;
         if (gPlayers[i].type & PLAYER_HUMAN) {
             D_80163330[i] = 3;
@@ -4335,8 +4335,8 @@ void spawn_vehicle_on_road(Vec3f position, Vec3s rotation, Vec3f velocity, s32 w
     UNUSED f32 pad;
     f32 origZPos;
 
-    origXPos = position[0];
-    origZPos = position[2];
+    origXPos = position.x;
+    origZPos = position.z;
     if (D_8016347A == 0) {
         func_8000D6D0(position, (s16*) &waypointIndex, speed,
                       someMultiplierTheSequel, 0, 3);
@@ -4350,20 +4350,20 @@ void spawn_vehicle_on_road(Vec3f position, Vec3s rotation, Vec3f velocity, s32 w
         rotation[1] = 0;
         rotation[2] = 0;
     }
-    velocity[0] = position[0] - origXPos;
-    velocity[2] = position[2] - origZPos;
+    velocity.x = position.x - origXPos;
+    velocity.z = position.z - origZPos;
 }
 
 void set_vehicle_pos_waypoint(TrainCarStuff* trainCar, Path2D* posXZ, u16 waypoint) {
-    trainCar->position[0] = (f32) posXZ->x;
-    trainCar->position[1] = (f32) D_80162EB0;
-    trainCar->position[2] = (f32) posXZ->z;
+    trainCar->position.x = (f32) posXZ->x;
+    trainCar->position.y = (f32) D_80162EB0;
+    trainCar->position.z = (f32) posXZ->z;
     trainCar->actorIndex = -1;
     trainCar->waypointIndex = waypoint;
     trainCar->isActive = 0;
-    trainCar->velocity[0] = 0.0f;
-    trainCar->velocity[1] = 0.0f;
-    trainCar->velocity[2] = 0.0f;
+    trainCar->velocity.x = 0.0f;
+    trainCar->velocity.y = 0.0f;
+    trainCar->velocity.z = 0.0f;
 }
 
 /**
@@ -4446,16 +4446,16 @@ void sync_train_components(TrainCarStuff* trainCar, s16 orientationY) {
     struct TrainCar* trainCarActor;
 
     trainCarActor = (struct TrainCar*) GET_ACTOR(trainCar->actorIndex);
-    trainCarActor->pos[0] = trainCar->position[0];
-    trainCarActor->pos[1] = trainCar->position[1];
-    trainCarActor->pos[2] = trainCar->position[2];
+    trainCarActor->pos.x = trainCar->position.x;
+    trainCarActor->pos.y = trainCar->position.y;
+    trainCarActor->pos.z = trainCar->position.z;
     if (gIsMirrorMode != 0) {
-        trainCarActor->rot[1] = -orientationY;
+        trainCarActor->rot.y = -orientationY;
     } else {
-        trainCarActor->rot[1] = orientationY;
+        trainCarActor->rot.y = orientationY;
     }
-    trainCarActor->velocity[0] = trainCar->velocity[0];
-    trainCarActor->velocity[2] = trainCar->velocity[2];
+    trainCarActor->velocity.x = trainCar->velocity.x;
+    trainCarActor->velocity.z = trainCar->velocity.z;
 }
 
 void update_vehicle_trains(void) {
@@ -4474,14 +4474,14 @@ void update_vehicle_trains(void) {
     for (i = 0; i < NUM_TRAINS; i++) {
         oldWaypointIndex = (u16) gTrainList[i].locomotive.waypointIndex;
 
-        temp_f20 = gTrainList[i].locomotive.position[0];
-        temp_f22 = gTrainList[i].locomotive.position[2];
+        temp_f20 = gTrainList[i].locomotive.position.x;
+        temp_f22 = gTrainList[i].locomotive.position.z;
 
         orientationYUpdate = update_vehicle_following_waypoint(
             gTrainList[i].locomotive.position, (s16*) &gTrainList[i].locomotive.waypointIndex, gTrainList[i].speed);
 
-        gTrainList[i].locomotive.velocity[0] = gTrainList[i].locomotive.position[0] - temp_f20;
-        gTrainList[i].locomotive.velocity[2] = gTrainList[i].locomotive.position[2] - temp_f22;
+        gTrainList[i].locomotive.velocity.x = gTrainList[i].locomotive.position.x - temp_f20;
+        gTrainList[i].locomotive.velocity.z = gTrainList[i].locomotive.position.z - temp_f22;
 
         sync_train_components(&gTrainList[i].locomotive, orientationYUpdate);
 
@@ -4499,9 +4499,9 @@ void update_vehicle_trains(void) {
             gTrainList[i].locomotive.position, TRAIN_SMOKE_RENDER_DISTANCE, gTrainList[i].someFlags);
         // Renders locomotive smoke on all screens if any player is within range.
         if ((((s16) gTrainSmokeTimer % 5) == 0) && (gTrainList[i].someFlags != 0)) {
-            smokePos[0] = gTrainList[i].locomotive.position[0];
-            smokePos[1] = (f32) ((f64) gTrainList[i].locomotive.position[1] + 65.0);
-            smokePos[2] = (f32) ((f64) gTrainList[i].locomotive.position[2] + 25.0);
+            smokePos[0] = gTrainList[i].locomotive.position.x;
+            smokePos[1] = (f32) ((f64) gTrainList[i].locomotive.position.y + 65.0);
+            smokePos[2] = (f32) ((f64) gTrainList[i].locomotive.position.z + 25.0);
             adjust_position_by_angle(smokePos, gTrainList[i].locomotive.position, orientationYUpdate);
             spawn_train_smoke(i, smokePos, 1.1f);
         }
@@ -4509,25 +4509,25 @@ void update_vehicle_trains(void) {
         car = &gTrainList[i].tender;
 
         if (car->isActive == 1) {
-            temp_f20 = car->position[0];
-            temp_f22 = car->position[2];
+            temp_f20 = car->position.x;
+            temp_f22 = car->position.z;
             orientationYUpdate =
                 update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, gTrainList[i].speed);
-            car->velocity[0] = car->position[0] - temp_f20;
-            car->velocity[2] = car->position[2] - temp_f22;
+            car->velocity.x = car->position.x - temp_f20;
+            car->velocity.z = car->position.z - temp_f22;
             sync_train_components(car, orientationYUpdate);
         }
 
         for (j = 0; j < gTrainList[i].numCarriages; j++) {
             car = &gTrainList[i].passengerCars[j];
             if (car->isActive == 1) {
-                temp_f20 = car->position[0];
-                temp_f22 = car->position[2];
+                temp_f20 = car->position.x;
+                temp_f22 = car->position.z;
 
                 orientationYUpdate =
                     update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, gTrainList[i].speed);
-                car->velocity[0] = car->position[0] - temp_f20;
-                car->velocity[2] = car->position[2] - temp_f22;
+                car->velocity.x = car->position.x - temp_f20;
+                car->velocity.z = car->position.z - temp_f22;
                 sync_train_components(car, orientationYUpdate);
             }
         }
@@ -4545,22 +4545,22 @@ void func_80012DC0(s32 playerId, Player* player) {
 
     if (D_801631E0[playerId] != 1) {
         if (!(player->effects & 0x01000000)) {
-            playerPosX = player->pos[0];
-            playerPosZ = player->pos[2];
+            playerPosX = player->pos.x;
+            playerPosZ = player->pos.z;
             for (trainIndex = 0; trainIndex < NUM_TRAINS; trainIndex++) {
                 trainCar = &gTrainList[trainIndex].locomotive;
-                x_dist = playerPosX - trainCar->position[0];
-                z_dist = playerPosZ - trainCar->position[2];
+                x_dist = playerPosX - trainCar->position.x;
+                z_dist = playerPosZ - trainCar->position.z;
                 if ((x_dist > -100.0) && (x_dist < 100.0)) {
                     if ((z_dist > -100.0) && (z_dist < 100.0)) {
-                        if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                          trainCar->velocity[2], 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                        if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                          trainCar->velocity.z, 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                             player->soundEffects |= REVERSE_SOUND_EFFECT;
                         }
                         trainCar = &gTrainList[trainIndex].tender;
                         if (trainCar->isActive == 1) {
-                            if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                              trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                            if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                              trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                                 player->soundEffects |= REVERSE_SOUND_EFFECT;
                             }
                         }
@@ -4570,13 +4570,13 @@ void func_80012DC0(s32 playerId, Player* player) {
                 for (passengerCarIndex = 0; passengerCarIndex < gTrainList[trainIndex].numCarriages;
                      passengerCarIndex++) {
                     trainCar = &gTrainList[trainIndex].passengerCars[passengerCarIndex];
-                    x_dist = playerPosX - trainCar->position[0];
-                    z_dist = playerPosZ - trainCar->position[2];
+                    x_dist = playerPosX - trainCar->position.x;
+                    z_dist = playerPosZ - trainCar->position.z;
                     if (trainCar->isActive == 1) {
                         if ((x_dist > -100.0) && (x_dist < 100.0)) {
                             if ((z_dist > -100.0) && (z_dist < 100.0)) {
-                                if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                                  trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                                if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                                  trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                                     player->soundEffects |= REVERSE_SOUND_EFFECT;
                                 }
                             }
@@ -4656,9 +4656,9 @@ void init_vehicles_ferry(void) {
         temp = i * 0xB4;
         paddleBoat = &gPaddleBoats[i];
         temp_a2 = &gVehicle2DWaypoint[temp];
-        paddleBoat->position[0] = temp_a2->x;
-        paddleBoat->position[1] = D_80162EB2;
-        paddleBoat->position[2] = temp_a2->z;
+        paddleBoat->position.x = temp_a2->x;
+        paddleBoat->position.y = D_80162EB2;
+        paddleBoat->position.z = temp_a2->z;
         paddleBoat->waypointIndex = i * 0xB4;
         paddleBoat->actorIndex = -1;
 
@@ -4667,9 +4667,9 @@ void init_vehicles_ferry(void) {
         } else {
             paddleBoat->isActive = 1;
         }
-        paddleBoat->velocity[0] = 0.0f;
-        paddleBoat->velocity[1] = 0.0f;
-        paddleBoat->velocity[2] = 0.0f;
+        paddleBoat->velocity.x = 0.0f;
+        paddleBoat->velocity.y = 0.0f;
+        paddleBoat->velocity.z = 0.0f;
         paddleBoat->speed = 1.6666666f;
         paddleBoat->rotY = 0;
     }
@@ -4696,22 +4696,22 @@ void update_vehicle_paddle_boats(void) {
     for (i = 0; i < NUM_ACTIVE_PADDLE_BOATS; i++) {
         paddleBoat = &gPaddleBoats[i];
         if (paddleBoat->isActive == 1) {
-            temp_f26 = paddleBoat->position[0];
-            temp_f28 = paddleBoat->position[1];
-            temp_f30 = paddleBoat->position[2];
+            temp_f26 = paddleBoat->position.x;
+            temp_f28 = paddleBoat->position.y;
+            temp_f30 = paddleBoat->position.z;
             update_vehicle_following_waypoint(paddleBoat->position, (s16*) &paddleBoat->waypointIndex,
                                               paddleBoat->speed);
             paddleBoat->someFlags = set_vehicle_render_distance_flags(paddleBoat->position, BOAT_SMOKE_RENDER_DISTANCE,
                                                                       paddleBoat->someFlags);
             if ((((s16) gFerrySmokeTimer % 10) == 0) && (paddleBoat->someFlags != 0)) {
-                smokePos[0] = (f32) ((f64) paddleBoat->position[0] - 30.0);
-                smokePos[1] = (f32) ((f64) paddleBoat->position[1] + 180.0);
-                smokePos[2] = (f32) ((f64) paddleBoat->position[2] + 45.0);
+                smokePos[0] = (f32) ((f64) paddleBoat->position.x - 30.0);
+                smokePos[1] = (f32) ((f64) paddleBoat->position.y + 180.0);
+                smokePos[2] = (f32) ((f64) paddleBoat->position.z + 45.0);
                 adjust_position_by_angle(smokePos, paddleBoat->position, paddleBoat->rotY);
                 spawn_ferry_smoke(i, smokePos, 1.1f);
-                smokePos[0] = (f32) ((f64) paddleBoat->position[0] + 30.0);
-                smokePos[1] = (f32) ((f64) paddleBoat->position[1] + 180.0);
-                smokePos[2] = (f32) ((f64) paddleBoat->position[2] + 45.0);
+                smokePos[0] = (f32) ((f64) paddleBoat->position.x + 30.0);
+                smokePos[1] = (f32) ((f64) paddleBoat->position.y + 180.0);
+                smokePos[2] = (f32) ((f64) paddleBoat->position.z + 45.0);
                 adjust_position_by_angle(smokePos, paddleBoat->position, paddleBoat->rotY);
                 spawn_ferry_smoke(i, smokePos, 1.1f);
             }
@@ -4759,21 +4759,21 @@ void update_vehicle_paddle_boats(void) {
             } else if (temp < 0) {
                 paddleBoat->rotY -= var_v1;
             }
-            paddleBoat->velocity[0] = paddleBoat->position[0] - temp_f26;
-            paddleBoat->velocity[1] = paddleBoat->position[1] - temp_f28;
-            paddleBoat->velocity[2] = paddleBoat->position[2] - temp_f30;
+            paddleBoat->velocity.x = paddleBoat->position.x - temp_f26;
+            paddleBoat->velocity.y = paddleBoat->position.y - temp_f28;
+            paddleBoat->velocity.z = paddleBoat->position.z - temp_f30;
             paddleBoatActor = GET_ACTOR(paddleBoat->actorIndex);
-            paddleBoatActor->pos[0] = paddleBoat->position[0];
-            paddleBoatActor->pos[1] = paddleBoat->position[1];
-            paddleBoatActor->pos[2] = paddleBoat->position[2];
+            paddleBoatActor->pos.x = paddleBoat->position.x;
+            paddleBoatActor->pos.y = paddleBoat->position.y;
+            paddleBoatActor->pos.z = paddleBoat->position.z;
             if (gIsMirrorMode != 0) {
-                paddleBoatActor->rot[1] = -paddleBoat->rotY;
+                paddleBoatActor->rot.y = -paddleBoat->rotY;
             } else {
-                paddleBoatActor->rot[1] = paddleBoat->rotY;
+                paddleBoatActor->rot.y = paddleBoat->rotY;
             }
-            paddleBoatActor->velocity[0] = paddleBoat->velocity[0];
-            paddleBoatActor->velocity[1] = paddleBoat->velocity[1];
-            paddleBoatActor->velocity[2] = paddleBoat->velocity[2];
+            paddleBoatActor->velocity.x = paddleBoat->velocity.x;
+            paddleBoatActor->velocity.y = paddleBoat->velocity.y;
+            paddleBoatActor->velocity.z = paddleBoat->velocity.z;
         }
     }
 }
@@ -4789,19 +4789,19 @@ void func_80013854(Player* player) {
     f32 playerY;
 
     if (!((player->effects & 0x01000000)) && (!(player->effects & HIT_BY_ITEM_EFFECT))) {
-        playerX = player->pos[0];
-        playerY = player->pos[1];
-        playerZ = player->pos[2];
+        playerX = player->pos.x;
+        playerY = player->pos.y;
+        playerZ = player->pos.z;
         for (someIndex = 0; someIndex < NUM_ACTIVE_PADDLE_BOATS; someIndex++) {
             tempPaddleWheelBoat = &gPaddleBoats[someIndex];
             if (tempPaddleWheelBoat->isActive == 1) {
-                x_diff = playerX - tempPaddleWheelBoat->position[0];
-                y_diff = playerY - tempPaddleWheelBoat->position[1];
-                z_diff = playerZ - tempPaddleWheelBoat->position[2];
+                x_diff = playerX - tempPaddleWheelBoat->position.x;
+                y_diff = playerY - tempPaddleWheelBoat->position.y;
+                z_diff = playerZ - tempPaddleWheelBoat->position.z;
                 if ((x_diff > -300.0) && (x_diff < 300.0)) {
                     if ((z_diff > -300.0) && (z_diff < 300.0)) {
-                        if ((func_80006018(tempPaddleWheelBoat->position[0], tempPaddleWheelBoat->position[2],
-                                           tempPaddleWheelBoat->velocity[0], tempPaddleWheelBoat->velocity[2], 200.0f,
+                        if ((func_80006018(tempPaddleWheelBoat->position.x, tempPaddleWheelBoat->position.z,
+                                           tempPaddleWheelBoat->velocity.x, tempPaddleWheelBoat->velocity.z, 200.0f,
                                            60.0f, playerX, playerZ) == 1) &&
                             (y_diff < 60.0)) {
                             player->soundEffects |= 0x80000;
@@ -4824,15 +4824,15 @@ void initialize_toads_turnpike_vehicle(f32 speedA, f32 speedB, s32 numVehicles,
         waypointOffset = (((i * numWaypoints) / numVehicles) + arg3) % numWaypoints;
         veh = &vehicleList[i];
         temp_v0 = &waypointList[waypointOffset];
-        veh->position[0] = (f32) temp_v0->posX;
-        veh->position[1] = (f32) temp_v0->posY;
-        veh->position[2] = (f32) temp_v0->posZ;
+        veh->position.x = (f32) temp_v0->posX;
+        veh->position.y = (f32) temp_v0->posY;
+        veh->position.z = (f32) temp_v0->posZ;
         veh->actorIndex = -1;
         veh->waypointIndex = waypointOffset;
         veh->unused = 0;
-        veh->velocity[0] = 0.0f;
-        veh->velocity[1] = 0.0f;
-        veh->velocity[2] = 0.0f;
+        veh->velocity.x = 0.0f;
+        veh->velocity.y = 0.0f;
+        veh->velocity.z = 0.0f;
         veh->someFlags = 0;
         veh->someFlagsTheSequel = 0;
         if (gModeSelection == TIME_TRIALS) {
@@ -4905,9 +4905,9 @@ void update_vehicle_follow_waypoint(VehicleStuff* vehicle) {
     Vec3f sp34;
     struct Actor* vehicleActor;
 
-    sp5C = vehicle->position[0];
-    sp58 = vehicle->position[1];
-    sp54 = vehicle->position[2];
+    sp5C = vehicle->position.x;
+    sp58 = vehicle->position.y;
+    sp54 = vehicle->position.z;
     sp40[0] = sp58;
     sp40[1] = 0.0f;
     sp40[2] = 0.0f;
@@ -4932,30 +4932,30 @@ void update_vehicle_follow_waypoint(VehicleStuff* vehicle) {
                                vehicle->someMultiplierTheSequel, 0);
     }
     adjust_angle(&vehicle->rotation[1], var_a1, 100);
-    temp_f0_3 = vehicle->position[0] - sp5C;
-    temp_f2_2 = vehicle->position[2] - sp54;
-    sp34[0] = vehicle->position[1];
+    temp_f0_3 = vehicle->position.x - sp5C;
+    temp_f2_2 = vehicle->position.z - sp54;
+    sp34[0] = vehicle->position.y;
     sp34[1] = 0.0f;
     sp34[2] = sqrtf((temp_f0_3 * temp_f0_3) + (temp_f2_2 * temp_f2_2));
     thing = get_angle_between_two_vectors(sp40, sp34);
     adjust_angle(&vehicle->rotation[0], -thing, 100);
-    vehicle->velocity[0] = vehicle->position[0] - sp5C;
-    vehicle->velocity[1] = vehicle->position[1] - sp58;
-    vehicle->velocity[2] = vehicle->position[2] - sp54;
+    vehicle->velocity.x = vehicle->position.x - sp5C;
+    vehicle->velocity.y = vehicle->position.y - sp58;
+    vehicle->velocity.z = vehicle->position.z - sp54;
     vehicleActor = GET_ACTOR(vehicle->actorIndex);
-    vehicleActor->pos[0] = vehicle->position[0];
-    vehicleActor->pos[1] = vehicle->position[1];
-    vehicleActor->pos[2] = vehicle->position[2];
-    vehicleActor->rot[0] = vehicle->rotation[0];
+    vehicleActor->pos.x = vehicle->position.x;
+    vehicleActor->pos.y = vehicle->position.y;
+    vehicleActor->pos.z = vehicle->position.z;
+    vehicleActor->rot.x = vehicle->rotation[0];
     if (gIsMirrorMode != 0) {
-        vehicleActor->rot[1] = -vehicle->rotation[1];
+        vehicleActor->rot.y = -vehicle->rotation[1];
     } else {
-        vehicleActor->rot[1] = vehicle->rotation[1];
+        vehicleActor->rot.y = vehicle->rotation[1];
     }
-    vehicleActor->rot[2] = vehicle->rotation[2];
-    vehicleActor->velocity[0] = vehicle->velocity[0];
-    vehicleActor->velocity[1] = vehicle->velocity[1];
-    vehicleActor->velocity[2] = vehicle->velocity[2];
+    vehicleActor->rot.z = vehicle->rotation[2];
+    vehicleActor->velocity.x = vehicle->velocity.x;
+    vehicleActor->velocity.y = vehicle->velocity.y;
+    vehicleActor->velocity.z = vehicle->velocity.z;
 }
 
 void func_80013F7C(s32 playerId, Player* player, VehicleStuff* vehicle, f32 arg3, f32 arg4, s32 arg5, u32 soundBits) {
@@ -4972,21 +4972,21 @@ void func_80013F7C(s32 playerId, Player* player, VehicleStuff* vehicle, f32 arg3
     if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
         !(player->effects & 0x01000000)) {
 
-        spC4 = player->pos[0];
-        spC0 = player->pos[1];
-        spBC = player->pos[2];
+        spC4 = player->pos.x;
+        spC0 = player->pos.y;
+        spBC = player->pos.z;
 
         for (i = 0; i < arg5; i++) {
-            temp_f12 = spC4 - vehicle->position[0];
-            temp_f22 = spC0 - vehicle->position[1];
-            temp_f14 = spBC - vehicle->position[2];
+            temp_f12 = spC4 - vehicle->position.x;
+            temp_f22 = spC0 - vehicle->position.y;
+            temp_f14 = spBC - vehicle->position.z;
 
             if (((temp_f12) > -100.0) && ((temp_f12) < 100.0)) {
                 if ((temp_f22 > -20.0) && (temp_f22 < 20.0)) {
 
                     if (((temp_f14) > -100.0) && ((temp_f14) < 100.0)) {
-                        if (func_80006018(vehicle->position[0], vehicle->position[2], vehicle->velocity[0],
-                                          vehicle->velocity[2], arg3, arg4, spC4, spBC) == (s32) 1) {
+                        if (func_80006018(vehicle->position.x, vehicle->position.z, vehicle->velocity.x,
+                                          vehicle->velocity.z, arg3, arg4, spC4, spBC) == (s32) 1) {
                             player->soundEffects |= REVERSE_SOUND_EFFECT;
                         }
                     }
@@ -5399,9 +5399,9 @@ void calculate_camera_up_vector(Camera* camera, s32 cameraIndex) {
         camera->up[2] = 0.0f;
         camera->up[1] = 1.0f;
     } else {
-        xdiff = camera->lookAt[0] - camera->pos[0];
-        ydiff = camera->lookAt[1] - camera->pos[1];
-        zdiff = camera->lookAt[2] - camera->pos[2];
+        xdiff = camera->lookAt.x - camera->pos.x;
+        ydiff = camera->lookAt.y - camera->pos.y;
+        zdiff = camera->lookAt.z - camera->pos.z;
         distance = sqrtf((xdiff * xdiff) + (ydiff * ydiff) + (zdiff * zdiff));
         xnorm = xdiff / distance;
         ynorm = ydiff / distance;
@@ -5463,18 +5463,18 @@ void func_80015390(Camera* camera, UNUSED Player* player, UNUSED s32 arg2) {
     }
     func_8001D794(temp_s1, camera, sp64, &sp84, &sp80, &sp7C, camera->unk_2C);
     check_bounding_collision(&camera->collision, 10.0f, sp84, sp80, sp7C);
-    camera->lookAt[0] = sp64[0];
-    camera->lookAt[1] = sp64[1];
-    camera->lookAt[2] = sp64[2];
-    camera->pos[0] = sp84;
-    camera->pos[1] = sp80;
-    camera->pos[2] = sp7C;
-    temp_f12 = camera->lookAt[0] - camera->pos[0];
-    sp90 = camera->lookAt[1] - camera->pos[1];
-    temp_f14 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(temp_f12, temp_f14);
-    camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
-    camera->rot[2] = 0;
+    camera->lookAt.x = sp64[0];
+    camera->lookAt.y = sp64[1];
+    camera->lookAt.z = sp64[2];
+    camera->pos.x = sp84;
+    camera->pos.y = sp80;
+    camera->pos.z = sp7C;
+    temp_f12 = camera->lookAt.x - camera->pos.x;
+    sp90 = camera->lookAt.y - camera->pos.y;
+    temp_f14 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(temp_f12, temp_f14);
+    camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
+    camera->rot.z = 0;
 }
 
 void func_80015544(s32 playerId, f32 arg1, s32 cameraId, s32 pathIndex) {
@@ -5502,9 +5502,9 @@ void func_80015544(s32 playerId, f32 arg1, s32 cameraId, s32 pathIndex) {
         D_80164618[cameraId] = (f32) (temp_f12 + 10.0);
     }
     D_80164648[cameraId] = 0.0f;
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_8001577C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s32 cameraId) {
@@ -5526,7 +5526,7 @@ void func_8001577C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s3
     player = gPlayerOne;
     player += playerId;
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     playerWaypoint = gNearestWaypointByPlayerId[playerId];
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 0x0032U, 0x000FU, gWaypointCountByPathIndex[pathIndex]) <= 0) {
@@ -5548,19 +5548,19 @@ void func_8001577C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s3
         }
     }
 alable:
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    xdiff = camera->lookAt[0] - camera->pos[0];
-    ydiff = camera->lookAt[1] - camera->pos[1];
-    zdiff = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff, zdiff);
-    camera->rot[0] = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
-    camera->rot[2] = 0;
+    xdiff = camera->lookAt.x - camera->pos.x;
+    ydiff = camera->lookAt.y - camera->pos.y;
+    zdiff = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff, zdiff);
+    camera->rot.x = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
+    camera->rot.z = 0;
 }
 
 void func_80015A9C(s32 playerId, f32 arg1, s32 cameraId, s16 pathIndex) {
@@ -5582,9 +5582,9 @@ void func_80015A9C(s32 playerId, f32 arg1, s32 cameraId, s16 pathIndex) {
         D_80164648[cameraId] = 0.0f;
     }
 
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_80015C94(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2, s32 cameraId) {
@@ -5617,7 +5617,7 @@ void func_80015C94(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
     D_80163238 = playerId;
     pathIndex = gPathIndexByPlayerId[playerId];
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     playerWaypoint = gNearestWaypointByPlayerId[playerId];
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 0x0032U, 0x000FU, gWaypointCountByPathIndex[pathIndex]) <= 0) {
@@ -5649,27 +5649,27 @@ void func_80015C94(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
         midY = D_80164618[cameraId];
         midZ = D_80164638[cameraId];
     }
-    camera->pos[0] = midX;
-    camera->pos[2] = midZ;
+    camera->pos.x = midX;
+    camera->pos.z = midZ;
     temp_f2_2 = spawn_actor_on_surface(midX, (midY + 30.0), midZ);
     if ((temp_f2_2 < (midY - 20.0)) || (temp_f2_2 >= 3000.0)) {
-        camera->pos[1] = midY + 10.0;
+        camera->pos.y = midY + 10.0;
     } else {
-        camera->pos[1] = temp_f2_2 + 8.0;
+        camera->pos.y = temp_f2_2 + 8.0;
     }
     D_801645F8[cameraId] = midX;
     D_80164618[cameraId] = midY;
     D_80164638[cameraId] = midZ;
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    xdiff2 = camera->lookAt[0] - camera->pos[0];
-    ydiff2 = camera->lookAt[1] - camera->pos[1];
-    zdiff2 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff2, zdiff2);
-    camera->rot[0] = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
-    camera->rot[2] = 0;
+    xdiff2 = camera->lookAt.x - camera->pos.x;
+    ydiff2 = camera->lookAt.y - camera->pos.y;
+    zdiff2 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff2, zdiff2);
+    camera->rot.x = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
+    camera->rot.z = 0;
 }
 
 void func_800162CC(s32 playerId, f32 arg1, s32 cameraId, s16 pathIndex) {
@@ -5689,9 +5689,9 @@ void func_800162CC(s32 playerId, f32 arg1, s32 cameraId, s16 pathIndex) {
     D_80164658[cameraId] = gPlayers[playerId].unk_094;
     D_80164648[cameraId] = gPlayers[playerId].unk_094;
 
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_80016494(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2, s32 cameraId) {
@@ -5726,7 +5726,7 @@ void func_80016494(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
     pathIndex = gPathIndexByPlayerId[playerId];
     player += playerId;
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     temp_f2_5 = (D_80163068[playerId] - D_80164688[cameraId]);
     temp_f2_5 *= temp_f2_5;
     playerWaypoint = gNearestWaypointByPlayerId[playerId];
@@ -5777,27 +5777,27 @@ void func_80016494(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
         midY = D_80164618[cameraId];
         midZ = D_80164638[cameraId];
     }
-    camera->pos[0] = midX;
-    camera->pos[2] = midZ;
+    camera->pos.x = midX;
+    camera->pos.z = midZ;
     temp_f2_5 = spawn_actor_on_surface(midX, midY + 30.0, midZ);
     if ((temp_f2_5 < (midY - 20.0)) || (temp_f2_5 >= 3000.0)) {
-        camera->pos[1] = midY + 10.0;
+        camera->pos.y = midY + 10.0;
     } else {
-        camera->pos[1] = temp_f2_5 + 10.0;
+        camera->pos.y = temp_f2_5 + 10.0;
     }
     D_801645F8[cameraId] = midX;
     D_80164618[cameraId] = midY;
     D_80164638[cameraId] = midZ;
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    xdiff2 = camera->lookAt[0] - camera->pos[0];
-    ydiff2 = camera->lookAt[1] - camera->pos[1];
-    zdiff2 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff2, zdiff2);
-    camera->rot[0] = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
-    camera->rot[2] = 0;
+    xdiff2 = camera->lookAt.x - camera->pos.x;
+    ydiff2 = camera->lookAt.y - camera->pos.y;
+    zdiff2 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff2, zdiff2);
+    camera->rot.x = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
+    camera->rot.z = 0;
 }
 
 void func_80016C3C(UNUSED s32 playerId, UNUSED f32 arg1, s32 cameraId) {
@@ -5845,12 +5845,12 @@ void func_80016C3C(UNUSED s32 playerId, UNUSED f32 arg1, s32 cameraId) {
     sp54 = (path[0][sp48].posY + path[0][sp44].posY) * 0.5f;
     camera = cameras;
     camera += cameraId;
-    camera->lookAt[0] = temp_f2;
-    camera->lookAt[2] = temp_f12;
-    camera->lookAt[1] = sp54 + 8.0;
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->lookAt.x = temp_f2;
+    camera->lookAt.z = temp_f12;
+    camera->lookAt.y = sp54 + 8.0;
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32 cameraId);
@@ -5891,12 +5891,12 @@ void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32
     sp58 = gWaypointCountByPathIndex[pathIndex];
     D_80163238 = playerId;
     sp56 = gNearestWaypointByCameraId[cameraId];
-    gNearestWaypointByCameraId[cameraId] = func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+    gNearestWaypointByCameraId[cameraId] = func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     // if (GetCourse() == GetYoshiValley()) {
     if (gCurrentCourseId == 4) {
         if ((sp56 != gNearestWaypointByCameraId[cameraId]) && (gNearestWaypointByCameraId[cameraId] == 1)) {
             pathIndex = (D_80163DD8[cameraId] = random_int(4U));
-            gNearestWaypointByCameraId[cameraId] = func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+            gNearestWaypointByCameraId[cameraId] = func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
         }
     }
 
@@ -5941,27 +5941,27 @@ void func_80017054(Camera* camera, UNUSED Player* player, UNUSED s32 index, s32
     }
 
     if (((diffX > (-10000.0))) && ((diffX < 10000.0))) {
-        camera->pos[0] = diffX;
-        camera->pos[2] = diffZ;
+        camera->pos.x = diffX;
+        camera->pos.z = diffZ;
     }
 
-    //camera->pos[0] = camX;
-    camera->pos[1] = diffY + 10.0; // Set camera 10 points above the ground
+    //camera->pos.x = camX;
+    camera->pos.y = diffY + 10.0; // Set camera 10 points above the ground
     
     if (1) { } if (1) { } if (1) { } if (1) { } if (1) { }
     D_801645F8[cameraId] = diffX;
     D_80164638[cameraId] = diffZ;
     D_80164618[cameraId] = camY;
-    camera->lookAt[0] = lookAtX;
-    camera->lookAt[1] = lookAtY + 8.0;
-    camera->lookAt[2] = lookAtZ;
+    camera->lookAt.x = lookAtX;
+    camera->lookAt.y = lookAtY + 8.0;
+    camera->lookAt.z = lookAtZ;
     func_80014D30(cameraId, pathIndex);
-    diffX2 = camera->lookAt[0] - camera->pos[0];
-    diffY2 = camera->lookAt[1] - camera->pos[1];
-    diffZ2 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(diffX2, diffZ2);
-    camera->rot[0] = atan2s(sqrtf((diffX2 * diffX2) + (diffZ2 * diffZ2)), diffY2);
-    camera->rot[2] = 0;
+    diffX2 = camera->lookAt.x - camera->pos.x;
+    diffY2 = camera->lookAt.y - camera->pos.y;
+    diffZ2 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(diffX2, diffZ2);
+    camera->rot.x = atan2s(sqrtf((diffX2 * diffX2) + (diffZ2 * diffZ2)), diffY2);
+    camera->rot.z = 0;
 }
 #else
 GLOBAL_ASM("asm/non_matchings/code_80005FD0/func_80017054.s")
@@ -5984,9 +5984,9 @@ void func_80017720(s32 playerId, UNUSED f32 arg1, s32 cameraId, s16 pathIndex) {
     D_80164658[cameraId] = gPlayers[playerId].unk_094;
     D_80164648[cameraId] = gPlayers[playerId].unk_094;
 
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_800178F4(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2, s32 cameraId) {
@@ -6023,7 +6023,7 @@ void func_800178F4(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
     player += playerId;
     waypointCount = gWaypointCountByPathIndex[pathIndex];
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     playerWaypoint = (gNearestWaypointByPlayerId[playerId] + 3) % waypointCount;
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 0x000DU, 1U, waypointCount) <= 0) {
@@ -6064,22 +6064,22 @@ void func_800178F4(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
         midY = D_80164618[cameraId];
         midZ = D_80164638[cameraId];
     }
-    camera->pos[0] = midX;
-    camera->pos[2] = midZ;
-    camera->pos[1] = midY + 10.0;
+    camera->pos.x = midX;
+    camera->pos.z = midZ;
+    camera->pos.y = midY + 10.0;
     D_801645F8[cameraId] = midX;
     D_80164618[cameraId] = midY;
     D_80164638[cameraId] = midZ;
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    xdiff2 = camera->lookAt[0] - camera->pos[0];
-    ydiff2 = camera->lookAt[1] - camera->pos[1];
-    zdiff2 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff2, zdiff2);
-    camera->rot[0] = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
-    camera->rot[2] = 0;
+    xdiff2 = camera->lookAt.x - camera->pos.x;
+    ydiff2 = camera->lookAt.y - camera->pos.y;
+    zdiff2 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff2, zdiff2);
+    camera->rot.x = atan2s(sqrtf((xdiff2 * xdiff2) + (zdiff2 * zdiff2)), ydiff2);
+    camera->rot.z = 0;
 }
 
 void func_80017F10(s32 playerId, UNUSED f32 arg1, s32 cameraId, s16 pathIndex) {
@@ -6099,9 +6099,9 @@ void func_80017F10(s32 playerId, UNUSED f32 arg1, s32 cameraId, s16 pathIndex) {
     D_80164658[cameraId] = gPlayers[playerId].unk_094;
     D_80164648[cameraId] = gPlayers[playerId].unk_094;
 
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_800180F0(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2, s32 cameraId) {
@@ -6138,7 +6138,7 @@ void func_800180F0(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
     waypointCount = gWaypointCountByPathIndex[pathIndex];
     player += playerId;
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     playerWaypoint = ((gNearestWaypointByPlayerId[playerId] + waypointCount) - 2) % waypointCount;
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 1U, 0x000AU, waypointCount) <= 0) {
@@ -6179,22 +6179,22 @@ void func_800180F0(Camera* camera, UNUSED Player* unusedPlayer, UNUSED s32 arg2,
         midY = D_80164618[cameraId];
         midZ = D_80164638[cameraId];
     }
-    camera->pos[0] = midX;
-    camera->pos[2] = midZ;
-    camera->pos[1] = player->pos[1] + 10.0;
+    camera->pos.x = midX;
+    camera->pos.z = midZ;
+    camera->pos.y = player->pos.y + 10.0;
     D_801645F8[cameraId] = midX;
     D_80164618[cameraId] = midY;
     D_80164638[cameraId] = midZ;
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    sp94 = camera->lookAt[0] - camera->pos[0];
-    sp90 = camera->lookAt[1] - camera->pos[1];
-    sp8C = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(sp94, sp8C);
-    camera->rot[0] = atan2s(sqrtf((sp94 * sp94) + (sp8C * sp8C)), sp90);
-    camera->rot[2] = 0;
+    sp94 = camera->lookAt.x - camera->pos.x;
+    sp90 = camera->lookAt.y - camera->pos.y;
+    sp8C = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(sp94, sp8C);
+    camera->rot.x = atan2s(sqrtf((sp94 * sp94) + (sp8C * sp8C)), sp90);
+    camera->rot.z = 0;
 }
 
 void func_80018718(s32 playerId, UNUSED f32 arg1, s32 cameraId, s16 pathIndex) {
@@ -6213,9 +6213,9 @@ void func_80018718(s32 playerId, UNUSED f32 arg1, s32 cameraId, s16 pathIndex) {
     D_80164658[cameraId] = gPlayers[playerId].unk_094;
     D_80164648[cameraId] = gPlayers[playerId].unk_094;
     D_8016448C = 1;
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_800188F4(Camera* camera, UNUSED Player* unusePlayer, UNUSED s32 arg2, s32 cameraId) {
@@ -6281,7 +6281,7 @@ void func_800188F4(Camera* camera, UNUSED Player* unusePlayer, UNUSED s32 arg2,
     D_80163238 = playerId;
     player += playerId;
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], pathIndex);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], pathIndex);
     playerWaypoint = gNearestWaypointByPlayerId[playerId];
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 0x000FU, 0x000FU, waypointCount) <= 0) {
@@ -6309,27 +6309,27 @@ void func_800188F4(Camera* camera, UNUSED Player* unusePlayer, UNUSED s32 arg2,
         midY = D_80164618[cameraId];
         midZ = D_80164638[cameraId];
     }
-    camera->pos[0] = midX;
-    camera->pos[2] = midZ;
+    camera->pos.x = midX;
+    camera->pos.z = midZ;
     temp_f2_4 = spawn_actor_on_surface(midX, midY + 30.0, midZ);
     if ((temp_f2_4 < (midY - 20.0)) || (temp_f2_4 >= 3000.0)) {
-        camera->pos[1] = midY + 10.0;
+        camera->pos.y = midY + 10.0;
     } else {
-        camera->pos[1] = temp_f2_4 + 8.0;
+        camera->pos.y = temp_f2_4 + 8.0;
     }
     D_801645F8[cameraId] = midX;
     D_80164618[cameraId] = midY;
     D_80164638[cameraId] = midZ;
-    camera->lookAt[0] = player->pos[0];
-    camera->lookAt[1] = player->pos[1] + 6.0;
-    camera->lookAt[2] = player->pos[2];
+    camera->lookAt.x = player->pos.x;
+    camera->lookAt.y = player->pos.y + 6.0;
+    camera->lookAt.z = player->pos.z;
     func_80014D30(cameraId, pathIndex);
-    spAC = camera->lookAt[0] - camera->pos[0];
-    spA8 = camera->lookAt[1] - camera->pos[1];
-    spA4 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(spAC, spA4);
-    camera->rot[0] = atan2s(sqrtf((spAC * spAC) + (spA4 * spA4)), spA8);
-    camera->rot[2] = 0;
+    spAC = camera->lookAt.x - camera->pos.x;
+    spA8 = camera->lookAt.y - camera->pos.y;
+    spA4 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(spAC, spA4);
+    camera->rot.x = atan2s(sqrtf((spAC * spAC) + (spA4 * spA4)), spA8);
+    camera->rot.z = 0;
 }
 
 void func_80019118(s32 playerId, f32 arg1, s32 cameraId, UNUSED s16 pathIndex) {
@@ -6355,9 +6355,9 @@ void func_80019118(s32 playerId, f32 arg1, s32 cameraId, UNUSED s16 pathIndex) {
         D_80164618[cameraId] = (f32) (temp_f12 + 10.0);
     }
     D_80164648[cameraId] = 0.0f;
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
 }
 
 void func_8001933C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s32 cameraId) {
@@ -6381,7 +6381,7 @@ void func_8001933C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s3
     player += playerId;
     waypointCount = gWaypointCountByPathIndex[pathIndex];
     gNearestWaypointByCameraId[cameraId] =
-        func_8000D33C(camera->pos[0], camera->pos[1], camera->pos[2], gNearestWaypointByCameraId[cameraId], 0);
+        func_8000D33C(camera->pos.x, camera->pos.y, camera->pos.z, gNearestWaypointByCameraId[cameraId], 0);
     playerWaypoint = gNearestWaypointByPlayerId[playerId];
     cameraWaypoint = gNearestWaypointByCameraId[cameraId];
     if (func_80007BF8(playerWaypoint, cameraWaypoint, 0x0032U, 0x0014U, waypointCount) <= 0) {
@@ -6393,20 +6393,20 @@ void func_8001933C(Camera* camera, UNUSED Player* playerArg, UNUSED s32 arg2, s3
             func_8001A348(cameraId, -1.0f, 0x0000000C);
         }
     }
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
     waypoint = &D_80164550[pathIndex][cameraWaypoint];
-    camera->lookAt[0] = (player->pos[0] * 0.8) + (0.2 * waypoint->posX);
-    camera->lookAt[1] = (player->pos[1] * 0.8) + (0.2 * waypoint->posY);
-    camera->lookAt[2] = (player->pos[2] * 0.8) + (0.2 * waypoint->posZ);
+    camera->lookAt.x = (player->pos.x * 0.8) + (0.2 * waypoint->posX);
+    camera->lookAt.y = (player->pos.y * 0.8) + (0.2 * waypoint->posY);
+    camera->lookAt.z = (player->pos.z * 0.8) + (0.2 * waypoint->posZ);
     func_80014D30(cameraId, pathIndex);
-    xdiff = camera->lookAt[0] - camera->pos[0];
-    ydiff = camera->lookAt[1] - camera->pos[1];
-    zdiff = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff, zdiff);
-    camera->rot[0] = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
-    camera->rot[2] = 0;
+    xdiff = camera->lookAt.x - camera->pos.x;
+    ydiff = camera->lookAt.y - camera->pos.y;
+    zdiff = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff, zdiff);
+    camera->rot.x = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
+    camera->rot.z = 0;
 }
 
 void func_8001968C(void) {
@@ -6435,20 +6435,20 @@ void func_80019760(Camera* camera, UNUSED Player* player, UNUSED s32 arg2, s32 c
     f32 zdiff;
     TrackWaypoint* temp_v1;
 
-    camera->pos[0] = D_801645F8[cameraId];
-    camera->pos[1] = D_80164618[cameraId];
-    camera->pos[2] = D_80164638[cameraId];
+    camera->pos.x = D_801645F8[cameraId];
+    camera->pos.y = D_80164618[cameraId];
+    camera->pos.z = D_80164638[cameraId];
     temp_v1 = &(*D_80164550)[gNearestWaypointByCameraId[cameraId]];
-    camera->lookAt[0] = (f32) temp_v1->posX;
-    camera->lookAt[1] = (f32) temp_v1->posY;
-    camera->lookAt[2] = (f32) temp_v1->posZ;
+    camera->lookAt.x = (f32) temp_v1->posX;
+    camera->lookAt.y = (f32) temp_v1->posY;
+    camera->lookAt.z = (f32) temp_v1->posZ;
     func_80014D30(cameraId, 0);
-    xdiff = camera->lookAt[0] - camera->pos[0];
-    ydiff = camera->lookAt[1] - camera->pos[1];
-    zdiff = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(xdiff, zdiff);
-    camera->rot[0] = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
-    camera->rot[2] = 0;
+    xdiff = camera->lookAt.x - camera->pos.x;
+    ydiff = camera->lookAt.y - camera->pos.y;
+    zdiff = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(xdiff, zdiff);
+    camera->rot.x = atan2s(sqrtf((xdiff * xdiff) + (zdiff * zdiff)), ydiff);
+    camera->rot.z = 0;
 }
 
 void func_80019890(s32 playerId, s32 cameraId) {
@@ -6511,7 +6511,7 @@ void func_80019890(s32 playerId, s32 cameraId) {
             break;
     }
     gNearestWaypointByCameraId[cameraId] =
-        func_8000BD94(camera->pos[0], camera->pos[1], camera->pos[2], (s32) pathIndex);
+        func_8000BD94(camera->pos.x, camera->pos.y, camera->pos.z, (s32) pathIndex);
     if ((s16) D_80164680[cameraId] == 9) {
         D_80163DD8[cameraId] = (s32) pathIndex;
     }
@@ -6790,11 +6790,11 @@ void func_8001A588(UNUSED u16* localD_80152300, Camera* camera, Player* player,
     }
     func_80019FB4(cameraIndex);
 
-    if ((s32) (camera->pos[0] * 10.0) == (s32) ((f64) camera->lookAt[0] * 10.0)) {
+    if ((s32) (camera->pos.x * 10.0) == (s32) ((f64) camera->lookAt.x * 10.0)) {
 
-        if ((s32) (camera->pos[2] * 10.0) == (s32) ((f64) camera->lookAt[2] * 10.0)) {
-            camera->pos[0] = (f32) (camera->pos[0] + 100.0);
-            camera->pos[2] = (f32) (camera->pos[2] + 100.0);
+        if ((s32) (camera->pos.z * 10.0) == (s32) ((f64) camera->lookAt.z * 10.0)) {
+            camera->pos.x = (f32) (camera->pos.x + 100.0);
+            camera->pos.z = (f32) (camera->pos.z + 100.0);
         }
     }
     if ((gModeSelection != BATTLE) && (D_80164680[cameraIndex] == -1) && (player->type & 0x800) &&
@@ -7065,12 +7065,12 @@ void kart_ai_use_item_strategy(s32 playerId) {
                     if (playerId != banana->playerId) {}
                 } else {
                     banana->state = 1;
-                    banana->velocity[0] = 0.0f;
-                    banana->velocity[1] = 0.0f;
-                    banana->velocity[2] = 0.0f;
+                    banana->velocity.x = 0.0f;
+                    banana->velocity.y = 0.0f;
+                    banana->velocity.z = 0.0f;
                     if (D_801631E0[playerId] == ((u16) 1)) {
-                        banana->pos[1] = spawn_actor_on_surface(player->pos[0], (f32) (((f64) player->pos[1]) + 30.0),
-                                                                player->pos[2]) +
+                        banana->pos.y = spawn_actor_on_surface(player->pos.x, (f32) (((f64) player->pos.y) + 30.0),
+                                                                player->pos.z) +
                                          (banana->boundingBoxSize + 1.0f);
                     }
                 }
@@ -7091,10 +7091,10 @@ void kart_ai_use_item_strategy(s32 playerId) {
                     waypoint = &D_80164550[gPathIndexByPlayerId[0]]
                                           [(gNearestWaypointByPlayerId[D_80163478] + 0x1E) %
                                            gWaypointCountByPathIndex[gPathIndexByPlayerId[D_80163478]]];
-                    banana->velocity[0] = (waypoint->posX - player->pos[0]) / 20.0;
-                    banana->velocity[1] = ((waypoint->posY - player->pos[1]) / 20.0) + 4.0;
-                    banana->velocity[2] = (waypoint->posZ - player->pos[2]) / 20.0;
-                    banana->pos[1] = player->pos[1];
+                    banana->velocity.x = (waypoint->posX - player->pos.x) / 20.0;
+                    banana->velocity.y = ((waypoint->posY - player->pos.y) / 20.0) + 4.0;
+                    banana->velocity.z = (waypoint->posZ - player->pos.z) / 20.0;
+                    banana->pos.y = player->pos.y;
                     func_800C92CC(playerId, SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x09));
                     func_800C98B8(player->pos, player->velocity, SOUND_ARG_LOAD(0x19, 0x01, 0x80, 0x14));
                 } else {
@@ -7111,10 +7111,10 @@ void kart_ai_use_item_strategy(s32 playerId) {
                     temp_s0->unk_04 = 0;
                     player->soundEffects &= ~0x00040000;
                 } else {
-                    banana->velocity[1] -= 0.4;
-                    banana->pos[0] += banana->velocity[0];
-                    banana->pos[1] += banana->velocity[1];
-                    banana->pos[2] += banana->velocity[2];
+                    banana->velocity.y -= 0.4;
+                    banana->pos.x += banana->velocity.x;
+                    banana->pos.y += banana->velocity.y;
+                    banana->pos.z += banana->velocity.z;
                     if (temp_s0->unk_04 >= 0x15) {
                         temp_s0->unk_00 = 0x0024;
                     }
@@ -7128,11 +7128,11 @@ void kart_ai_use_item_strategy(s32 playerId) {
                     if (playerId != banana->playerId) {}
                 } else {
                     banana->state = 1;
-                    banana->velocity[0] = 0.0f;
-                    banana->velocity[1] = 0.0f;
-                    banana->velocity[2] = 0.0f;
-                    banana->pos[1] =
-                        spawn_actor_on_surface(banana->pos[0], (f32) (((f64) banana->pos[1]) + 30.0), banana->pos[2]) +
+                    banana->velocity.x = 0.0f;
+                    banana->velocity.y = 0.0f;
+                    banana->velocity.z = 0.0f;
+                    banana->pos.y =
+                        spawn_actor_on_surface(banana->pos.x, (f32) (((f64) banana->pos.y) + 30.0), banana->pos.z) +
                         (banana->boundingBoxSize + 1.0f);
                 }
                 player->soundEffects &= ~0x00040000;
@@ -7159,7 +7159,7 @@ void kart_ai_use_item_strategy(s32 playerId) {
             case 5:
                 actor = GET_ACTOR(temp_s0->actorIndex);
                 if ((((!(actor->flags & 0x8000)) || (actor->type != 7)) || (actor->state != 0)) ||
-                    (playerId != actor->rot[2])) {
+                    (playerId != actor->rot.z)) {
                     temp_s0->unk_00 = 0;
                     temp_s0->unk_04 = 0;
                 } else if (temp_s0->unk_0E < temp_s0->unk_04) {
@@ -7171,7 +7171,7 @@ void kart_ai_use_item_strategy(s32 playerId) {
             case 6:
                 actor = GET_ACTOR(temp_s0->actorIndex);
                 if ((((!(actor->flags & 0x8000)) || (actor->type != 7)) || (actor->state != 0)) ||
-                    (playerId != actor->rot[2])) {
+                    (playerId != actor->rot.z)) {
                     temp_s0->unk_00 = 0;
                     temp_s0->unk_04 = 0;
                 } else {
@@ -7345,12 +7345,12 @@ void kart_ai_use_item_strategy(s32 playerId) {
                 if ((((!(fakeItemBox->flags & 0x8000)) || (fakeItemBox->type != 0x000D)) ||
                      (fakeItemBox->state != 0)) ||
                     (playerId != ((s32) fakeItemBox->playerId))) {
-                    if (playerId != fakeItemBox->rot[0]) {}
+                    if (playerId != fakeItemBox->rot.x) {}
                 } else {
                     func_802A1064(fakeItemBox);
                     if (D_801631E0[playerId] == 1) {
-                        fakeItemBox->pos[1] = spawn_actor_on_surface(fakeItemBox->pos[0], fakeItemBox->pos[1] + 30.0,
-                                                                     fakeItemBox->pos[2]) +
+                        fakeItemBox->pos.y = spawn_actor_on_surface(fakeItemBox->pos.x, fakeItemBox->pos.y + 30.0,
+                                                                     fakeItemBox->pos.z) +
                                               fakeItemBox->boundingBoxSize;
                     }
                 }
@@ -7486,10 +7486,10 @@ void func_8001BE78(void) {
                 break;
         }
         temp_s0 = &D_80164550[i][gNearestWaypointByPlayerId[i]];
-        temp_s1->pos[0] = (f32) temp_s0->posX;
-        temp_s1->pos[1] =
+        temp_s1->pos.x = (f32) temp_s0->posX;
+        temp_s1->pos.y =
             spawn_actor_on_surface((f32) temp_s0->posX, 2000.0f, (f32) temp_s0->posZ) + temp_s1->boundingBoxSize;
-        temp_s1->pos[2] = (f32) temp_s0->posZ;
+        temp_s1->pos.z = (f32) temp_s0->posZ;
         temp_s1->rotation[1] = (s16) *D_80164590[i];
         func_8003680C(temp_s1, 0);
         temp_s1++;
@@ -7547,8 +7547,8 @@ void func_8001C14C(void) {
         player = &gPlayerOne[var_s1];
         func_80009B60(var_s1);
         if (!(player->type & 0x2000)) {
-            temp_f0 = D_80163418[var_s1] - player->pos[0];
-            temp_f2 = D_80163438[var_s1] - player->pos[2];
+            temp_f0 = D_80163418[var_s1] - player->pos.x;
+            temp_f2 = D_80163438[var_s1] - player->pos.z;
             if ((f64) ((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) < 1.0) {
                 if (var_s1 != 3) {
                     if (1) {}
diff --git a/src/code_80057C60.c b/src/code_80057C60.c
index 840ea88c4..761d2198b 100644
--- a/src/code_80057C60.c
+++ b/src/code_80057C60.c
@@ -1182,9 +1182,9 @@ void func_80059820(s32 playerId) {
     D_8018CF1C = &gPlayerOne[playerId];
     D_8018CF14 = &camera1[playerId];
     temp_v0 = &playerHUD[playerId];
-    temp_v0->posXInt = (s32) D_8018CF1C->pos[0];
-    temp_v0->posYInt = (s32) D_8018CF1C->pos[1];
-    temp_v0->posZInt = (s32) D_8018CF1C->pos[2];
+    temp_v0->posXInt = (s32) D_8018CF1C->pos.x;
+    temp_v0->posYInt = (s32) D_8018CF1C->pos.y;
+    temp_v0->posZInt = (s32) D_8018CF1C->pos.z;
 }
 
 void randomize_seed_from_controller(s32 arg0) {
@@ -2843,12 +2843,12 @@ void func_8005D898(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
     s32 temp_lo;
 
     if (player->unk_0C0 >= 0) {
-        func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_LEFT].pos[0],
-                      player->tyres[BACK_LEFT].baseHeight + 2.0f, player->tyres[BACK_LEFT].pos[2],
+        func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_LEFT].pos.x,
+                      player->tyres[BACK_LEFT].baseHeight + 2.0f, player->tyres[BACK_LEFT].pos.z,
                       player->tyres[BACK_LEFT].surfaceType, 1);
     } else {
-        func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_RIGHT].pos[0],
-                      player->tyres[BACK_RIGHT].baseHeight + 2.0f, player->tyres[BACK_RIGHT].pos[2],
+        func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_RIGHT].pos.x,
+                      player->tyres[BACK_RIGHT].baseHeight + 2.0f, player->tyres[BACK_RIGHT].pos.z,
                       player->tyres[BACK_RIGHT].surfaceType, 0);
     }
 
@@ -2907,16 +2907,16 @@ void func_8005DAF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     surfaceType = 0x000000FF;
     temp_v0 = random_int(test);
     if ((temp_v0 == 0) || (temp_v0 == 4)) {
-        var_f2 = player->tyres[BACK_LEFT].pos[0];
+        var_f2 = player->tyres[BACK_LEFT].pos.x;
         var_f12 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
-        var_f14 = player->tyres[BACK_LEFT].pos[2];
+        var_f14 = player->tyres[BACK_LEFT].pos.z;
         var_t3 = 1;
         surfaceType = player->tyres[BACK_LEFT].surfaceType;
     }
     if ((temp_v0 == 2) || (temp_v0 == 6)) {
-        var_f2 = player->tyres[BACK_RIGHT].pos[0];
+        var_f2 = player->tyres[BACK_RIGHT].pos.x;
         var_f12 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
-        var_f14 = player->tyres[BACK_RIGHT].pos[2];
+        var_f14 = player->tyres[BACK_RIGHT].pos.z;
         var_t3 = 0;
         surfaceType = player->tyres[BACK_RIGHT].surfaceType;
     }
@@ -3131,18 +3131,18 @@ void func_8005EA94(Player* player, s16 arg1, s32 arg2, s8 arg3, UNUSED s8 arg4)
     temp_v0 = random_int(test);
     if ((temp_v0 == 0) || (temp_v0 == 8)) {
         if ((D_801652A0[arg3] - player->tyres[BACK_LEFT].baseHeight) >= 3.5) {
-            var_f2 = player->tyres[BACK_LEFT].pos[0];
+            var_f2 = player->tyres[BACK_LEFT].pos.x;
             var_f12 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
-            var_f14 = player->tyres[BACK_LEFT].pos[2];
+            var_f14 = player->tyres[BACK_LEFT].pos.z;
             var_t1 = 1;
             var_t0 = 0;
         }
     }
     if ((temp_v0 == 2) || (temp_v0 == 6)) {
         if ((D_801652A0[arg3] - player->tyres[BACK_RIGHT].baseHeight) >= 3.5) {
-            var_f2 = player->tyres[BACK_RIGHT].pos[0];
+            var_f2 = player->tyres[BACK_RIGHT].pos.x;
             var_f12 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
-            var_f14 = player->tyres[BACK_RIGHT].pos[2];
+            var_f14 = player->tyres[BACK_RIGHT].pos.z;
             var_t1 = 0;
             var_t0 = 0;
         }
@@ -3175,16 +3175,16 @@ void func_8005ED48(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     surfaceType = 0x000000FF;
     temp_v0 = random_int(test);
     if ((temp_v0 == 2) || (temp_v0 == 4)) {
-        var_f0 = player->tyres[BACK_LEFT].pos[0];
+        var_f0 = player->tyres[BACK_LEFT].pos.x;
         var_f2 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
-        var_f12 = player->tyres[BACK_LEFT].pos[2];
+        var_f12 = player->tyres[BACK_LEFT].pos.z;
         var_t3 = 1;
         surfaceType = player->tyres[BACK_LEFT].surfaceType;
     }
     if ((temp_v0 == 0) || (temp_v0 == 6)) {
-        var_f0 = player->tyres[BACK_RIGHT].pos[0];
+        var_f0 = player->tyres[BACK_RIGHT].pos.x;
         var_f2 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
-        var_f12 = player->tyres[BACK_RIGHT].pos[2];
+        var_f12 = player->tyres[BACK_RIGHT].pos.z;
         var_t3 = 0;
         surfaceType = player->tyres[BACK_RIGHT].surfaceType;
     }
@@ -3376,15 +3376,15 @@ void func_8005F90C(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
 
     var_t1 = 0;
     if ((player->effects & 0x80) == 0x80) {
-        var_f0 = player->pos[0];
-        var_f2 = player->pos[1] - player->boundingBoxSize;
-        var_f12 = player->pos[2];
+        var_f0 = player->pos.x;
+        var_f2 = player->pos.y - player->boundingBoxSize;
+        var_f12 = player->pos.z;
         var_t1 = 1;
         surfaceType = player->tyres[BACK_LEFT].surfaceType;
     } else {
-        var_f0 = player->pos[0];
-        var_f2 = player->pos[1] - player->boundingBoxSize;
-        var_f12 = player->pos[2];
+        var_f0 = player->pos.x;
+        var_f2 = player->pos.y - player->boundingBoxSize;
+        var_f12 = player->pos.z;
         surfaceType = player->tyres[BACK_RIGHT].surfaceType;
     }
 
@@ -3572,15 +3572,15 @@ void func_80060504(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     temp_v0 = random_int(var_v0);
     if ((temp_v0 == 1) || (temp_v0 == 2) || (temp_v0 == 3)) {
         if ((arg1 == 0) && ((player->unk_258[arg2].unk_01E > 0) || (player->unk_258[arg2].unk_01C == 0))) {
-            sp4C = player->pos[1] - 2.5;
-            sp48 = player->pos[2];
-            sp50 = player->pos[0];
+            sp4C = player->pos.y - 2.5;
+            sp48 = player->pos.z;
+            sp50 = player->pos.x;
             func_8005D794(player, &player->unk_258[arg1], sp50, sp4C, sp48, 0, 0);
             func_8005D7D8(&player->unk_258[arg1], 1, 0.5f);
         } else if (player->unk_258[arg2].unk_01E > 0) {
-            sp4C = player->pos[1] - 2.5;
-            sp48 = player->pos[2];
-            sp50 = player->pos[0];
+            sp4C = player->pos.y - 2.5;
+            sp48 = player->pos.z;
+            sp50 = player->pos.x;
             func_8005D794(player, &player->unk_258[arg1], sp50, sp4C, sp48, 0, 0);
             func_8005D7D8(&player->unk_258[arg1], 1, 0.5f);
         }
@@ -3613,9 +3613,9 @@ void func_80060504(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     }
     func_80062B18(&sp50, &sp4C, &sp48, 0.0f, 4.5f, (player->unk_258[arg1].unk_01E * var_f0) + -5.5, -thing2,
                   -player->unk_206 * 2);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + sp50;
-    sp4C = sp4C + (player->pos[1] - player->boundingBoxSize);
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + sp48;
+    player->unk_258[arg1].unk_000[0] = player->pos.x + sp50;
+    sp4C = sp4C + (player->pos.y - player->boundingBoxSize);
+    player->unk_258[arg1].unk_000[2] = player->pos.z + sp48;
     player->unk_258[arg1].unk_000[1] = player->unk_258[arg1].unk_024 + sp4C;
     player->unk_258[arg1].unk_010 = 0;
 }
@@ -3626,14 +3626,14 @@ void func_800608E0(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
     f32 sp4C;
     f32 sp48;
 
-    var_f0 = 8.0f - (D_801652A0[arg3] - player->pos[1]);
+    var_f0 = 8.0f - (D_801652A0[arg3] - player->pos.y);
     if ((f64) var_f0 <= 0.0) {
         var_f0 = 0.0f;
     }
-    sp4C = (D_801652A0[arg3] - player->pos[1]) - 3.0f;
+    sp4C = (D_801652A0[arg3] - player->pos.y) - 3.0f;
     if ((player->unk_0DE & 1) && (GetCourse() != GetKoopaTroopaBeach())) {
         var_f0 = 2.5f;
-        sp4C = (f32) ((f64) (D_801652A0[arg3] - player->pos[1]) + 0.1);
+        sp4C = (f32) ((f64) (D_801652A0[arg3] - player->pos.y) + 0.1);
     }
     func_8005D794(player, &player->unk_258[arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
     func_8005D7D8(&player->unk_258[arg1], 3, var_f0);
@@ -3645,9 +3645,9 @@ void func_800608E0(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
     func_80062B18(&sp50, &sp4C, &sp48, 0.0f, sp4C,
                   ((-player->unk_258[arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 10.0f) + -4.0f,
                   -player->unk_258[arg1].unk_020, -player->unk_206 * 2);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + sp50;
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + sp48;
-    player->unk_258[arg1].unk_000[1] = player->pos[1] + sp4C;
+    player->unk_258[arg1].unk_000[0] = player->pos.x + sp50;
+    player->unk_258[arg1].unk_000[2] = player->pos.z + sp48;
+    player->unk_258[arg1].unk_000[1] = player->pos.y + sp4C;
 }
 
 void func_80060B14(Player* player, s16 arg1, s32 arg2, s8 arg3, s8 arg4) {
@@ -3684,18 +3684,18 @@ void func_80060BCC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
         func_8005D794(player, &player->unk_258[arg1 + 10], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
         func_8005D7D8(&player->unk_258[arg1 + 10], 0x0B, 0.4f);
         func_8005D800(&player->unk_258[arg1 + 10], 0x00FFFFFF, 0x00FF);
-        player->unk_258[arg1 + 10].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -1.8);
-        player->unk_258[arg1 + 10].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -1.8);
-        player->unk_258[arg1 + 10].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
+        player->unk_258[arg1 + 10].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -1.8);
+        player->unk_258[arg1 + 10].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -1.8);
+        player->unk_258[arg1 + 10].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
         player->unk_258[arg1 + 10].unk_018 = sp44 + 1.0f;
         player->unk_258[arg1 + 10].unk_00C = (sp48 + 2.0f) / 10.0f;
     } else if (player->unk_258[arg2 + 10].unk_01E > 0) {
         func_8005D794(player, &player->unk_258[arg1 + 10], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
         func_8005D7D8(&player->unk_258[arg1 + 10], 0x0B, 0.4f);
         func_8005D800(&player->unk_258[arg1 + 10], 0x00FFFFFF, 0x00FF);
-        player->unk_258[arg1 + 10].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -1.8);
-        player->unk_258[arg1 + 10].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -1.8);
-        player->unk_258[arg1 + 10].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
+        player->unk_258[arg1 + 10].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -1.8);
+        player->unk_258[arg1 + 10].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -1.8);
+        player->unk_258[arg1 + 10].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
         player->unk_258[arg1 + 10].unk_018 = sp44 + 1.0f;
         player->unk_258[arg1 + 10].unk_00C = (sp48 + 2.0f) / 10.0f;
     }
@@ -3711,8 +3711,8 @@ void func_80060F50(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
         func_8005D800(&player->unk_258[arg1], 0xFFFFFF, 0xFF);
     }
 
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + (coss(player->unk_258[arg1].unk_020) * -5.8);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + (sins(player->unk_258[arg1].unk_020) * -5.8);
+    player->unk_258[arg1].unk_000[2] = player->pos.z + (coss(player->unk_258[arg1].unk_020) * -5.8);
+    player->unk_258[arg1].unk_000[0] = player->pos.x + (sins(player->unk_258[arg1].unk_020) * -5.8);
     player->unk_258[arg1].unk_000[1] = D_801652A0[arg3];
     player->unk_0DE &= ~0x0008;
 }
@@ -3733,9 +3733,9 @@ void func_80061130(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
     func_8005D7D8(&player->unk_258[arg1], 7, 0.6f);
     func_8005D800(&player->unk_258[arg1], 0xFFFFFF, 0xD0);
 
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + (coss(player->unk_258[arg1].unk_020) * 6.0f);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + (sins(player->unk_258[arg1].unk_020) * 6.0f);
-    player->unk_258[arg1].unk_000[1] = player->pos[1] - 5.0f;
+    player->unk_258[arg1].unk_000[2] = player->pos.z + (coss(player->unk_258[arg1].unk_020) * 6.0f);
+    player->unk_258[arg1].unk_000[0] = player->pos.x + (sins(player->unk_258[arg1].unk_020) * 6.0f);
+    player->unk_258[arg1].unk_000[1] = player->pos.y - 5.0f;
     player->unk_258[arg1].unk_040 = 0;
     player->unk_258[arg1].unk_024 = 0.0f;
 }
@@ -3756,15 +3756,15 @@ void func_800612F8(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
 
     for (var_s2 = 0; var_s2 < 10; var_s2++) {
         player->unk_258[0x1E + var_s2].unk_01C = 1;
-        player->unk_258[0x1E + var_s2].unk_028 = player->pos[1] + 5.0f;
+        player->unk_258[0x1E + var_s2].unk_028 = player->pos.y + 5.0f;
         player->unk_258[0x1E + var_s2].unk_020 = (0x1C70 * var_s2) - player->rotation[1];
         player->unk_258[0x1E + var_s2].unk_024 = (random_int(0x0064U) / 100.0f) + 1.5;
         player->unk_258[0x1E + var_s2].unk_03A = 0;
         player->unk_258[0x1E + var_s2].unk_012 = 1;
         player->unk_258[0x1E + var_s2].unk_01E = 0;
         player->unk_258[0x1E + var_s2].unk_03E = 0x00FF;
-        player->unk_258[0x1E + var_s2].unk_000[2] = player->pos[2];
-        player->unk_258[0x1E + var_s2].unk_000[0] = player->pos[0];
+        player->unk_258[0x1E + var_s2].unk_000[2] = player->pos.z;
+        player->unk_258[0x1E + var_s2].unk_000[0] = player->pos.x;
     }
     player->unk_046 &= ~0x0008;
 }
@@ -3774,7 +3774,7 @@ void func_80061430(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
 
     for (var_s2 = 0; var_s2 < 7; var_s2++) {
         player->unk_258[0x1E + var_s2].unk_01C = 1;
-        player->unk_258[0x1E + var_s2].unk_028 = player->pos[1] - 4.0f;
+        player->unk_258[0x1E + var_s2].unk_028 = player->pos.y - 4.0f;
         player->unk_258[0x1E + var_s2].unk_020 = (0x1C70 * var_s2) - player->rotation[1];
         // ???
         player->unk_258[0x1E + var_s2].unk_024 = (random_int(0x0064U) / 100.0f) + 1.9;
@@ -3783,8 +3783,8 @@ void func_80061430(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
         player->unk_258[0x1E + var_s2].unk_012 = 9;
         player->unk_258[0x1E + var_s2].unk_01E = 0;
         player->unk_258[0x1E + var_s2].unk_03E = 0x00FF;
-        player->unk_258[0x1E + var_s2].unk_000[2] = player->pos[2];
-        player->unk_258[0x1E + var_s2].unk_000[0] = player->pos[0];
+        player->unk_258[0x1E + var_s2].unk_000[2] = player->pos.z;
+        player->unk_258[0x1E + var_s2].unk_000[0] = player->pos.x;
     }
     player->unk_044 &= ~0x1000;
 }
@@ -3798,14 +3798,14 @@ void func_800615AC(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
 
     if (random_int(3U) == 2.0f) {
         player->unk_258[0x1E + arg1].unk_01C = 1;
-        player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0];
-        player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2];
+        player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x;
+        player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z;
         player->unk_258[0x1E + arg1].unk_020 = -player->rotation[1] + sp28[arg1];
         player->unk_258[0x1E + arg1].unk_018 = random_int(1U) + 2.0f;
         temp_f0 = random_int(4U);
         temp_f0 -= test;
         player->unk_258[0x1E + arg1].unk_014 = temp_f0;
-        player->unk_258[0x1E + arg1].unk_000[1] = player->pos[1] + temp_f0;
+        player->unk_258[0x1E + arg1].unk_000[1] = player->pos.y + temp_f0;
         player->unk_258[0x1E + arg1].unk_00C = 0.15f;
         player->unk_258[0x1E + arg1].unk_012 = 5;
         player->unk_258[0x1E + arg1].unk_01E = 0;
@@ -3840,9 +3840,9 @@ void func_80061754(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3, U
         player->unk_258[0x1E + arg1].unk_03A += temp_s1;
         player->unk_258[0x1E + arg1].unk_03C += temp_s1;
     }
-    player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -5.0f);
-    player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -5.0f);
-    player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
+    player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -5.0f);
+    player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -5.0f);
+    player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
     player->unk_258[0x1E + arg1].unk_018 = sp44 + 1.0f;
     player->unk_258[0x1E + arg1].unk_00C = sp48 + 1.0f;
 }
@@ -3870,17 +3870,17 @@ void func_80061A34(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
         func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
         func_8005D7D8(&player->unk_258[0x1E + arg1], 7, 1.0f);
         func_8005D800(&player->unk_258[0x1E + arg1], 0x00FFFFFF, 0x00FF);
-        player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -2.0);
-        player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -2.0);
-        player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
+        player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -2.0);
+        player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -2.0);
+        player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
         player->unk_258[0x1E + arg1].unk_00C = (sp48 + 2.0f) / 10.0f;
     } else if (player->unk_258[0x1E + arg2].unk_01E > 0) {
         func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
         func_8005D7D8(&player->unk_258[0x1E + arg1], 7, 1.0f);
         func_8005D800(&player->unk_258[0x1E + arg1], 0x00FFFFFF, 0x00FF);
-        player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -2.0);
-        player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -2.0);
-        player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + (f32) sp4C + 2.0f;
+        player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -2.0);
+        player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -2.0);
+        player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + (f32) sp4C + 2.0f;
         player->unk_258[0x1E + arg1].unk_00C = (sp48 + 2.0f) / 10.0f;
     }
 }
@@ -3894,9 +3894,9 @@ void func_80061D4C(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
 
     if (random_int(3U) == 2.0f) {
         player->unk_258[0x1E + arg1].unk_01C = 1;
-        player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0];
-        player->unk_258[0x1E + arg1].unk_000[1] = player->pos[1] + 2.0f;
-        player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2];
+        player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x;
+        player->unk_258[0x1E + arg1].unk_000[1] = player->pos.y + 2.0f;
+        player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z;
         player->unk_258[0x1E + arg1].unk_020 = -player->rotation[1] + sp20[arg1];
         player->unk_258[0x1E + arg1].unk_018 = random_int(3U) + 2.0f;
         player->unk_258[0x1E + arg1].unk_014 = random_int(4U);
@@ -3921,12 +3921,12 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     if (temp_v1 == 1) {
         var_t1 = 1;
         var_t0 = 0;
-        var_f2 = player->pos[1];
+        var_f2 = player->pos.y;
     }
     if (temp_v1 == 0) {
         var_t1 = 0;
         var_t0 = 0;
-        var_f2 = player->pos[1];
+        var_f2 = player->pos.y;
     }
     if (var_t0 == 0) {
         if ((arg1 == 0) &&
@@ -3941,10 +3941,10 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
                 player->unk_258[0x1E + arg1].unk_020 -= 0x888;
             }
             player->unk_258[0x1E + arg1].unk_000[2] =
-                player->pos[2] +
+                player->pos.z +
                 (coss(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
             player->unk_258[0x1E + arg1].unk_000[0] =
-                player->pos[0] +
+                player->pos.x +
                 (sins(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
         } else if (player->unk_258[0x1E + arg2].unk_01E > 0) {
             func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, var_f2, 0.0f, (s8) var_t0, (s8) var_t1);
@@ -3957,10 +3957,10 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
                 player->unk_258[0x1E + arg1].unk_020 -= 0x888;
             }
             player->unk_258[0x1E + arg1].unk_000[2] =
-                player->pos[2] +
+                player->pos.z +
                 (coss(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
             player->unk_258[0x1E + arg1].unk_000[0] =
-                player->pos[0] +
+                player->pos.x +
                 (sins(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
         }
     }
@@ -3979,7 +3979,7 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
     if (temp_v1 == 1) {
         phi_t1 = 1;
         phi_t0 = 0;
-        phi_f2 = player->pos[1];
+        phi_f2 = player->pos.y;
     }
 
     if (temp_v1 == 0) {
@@ -3987,7 +3987,7 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
         if (1) {
             phi_t0 = 0;
         }
-        phi_f2 = player->pos[1];
+        phi_f2 = player->pos.y;
     }
 
     if (phi_t0 == 0) {
@@ -4004,10 +4004,10 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
             }
 
             player->unk_258[30 + arg1].unk_000[2] =
-                player->pos[2] +
+                player->pos.z +
                 (coss((player->unk_258[30 + arg1].unk_020 - player->rotation[1]) - player->unk_0C0) * 5.0f);
             player->unk_258[30 + arg1].unk_000[0] =
-                player->pos[0] +
+                player->pos.x +
                 (sins((player->unk_258[30 + arg1].unk_020 - player->rotation[1]) - player->unk_0C0) * 5.0f);
             return;
         }
@@ -4026,10 +4026,10 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
 
             new_var = new_var2;
             new_var->unk_258[30 + arg1].unk_000[2] =
-                new_var->pos[2] +
+                new_var->pos.z +
                 (coss((new_var->unk_258[30 + arg1].unk_020 - new_var->rotation[1]) - new_var->unk_0C0) * 5.0f);
             new_var->unk_258[30 + arg1].unk_000[0] =
-                new_var->pos[0] +
+                new_var->pos.x +
                 (sins((new_var->unk_258[30 + arg1].unk_020 - new_var->rotation[1]) - new_var->unk_0C0) * 5.0f);
         }
     }
@@ -4038,8 +4038,8 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
 void func_80062484(Player* player, UnkPlayerStruct258* arg1, s32 arg2) {
     arg1->unk_01C = 1;
     arg1->unk_000[1] = player->unk_074 + 1.0f;
-    arg1->unk_000[2] = player->pos[2];
-    arg1->unk_000[0] = player->pos[0];
+    arg1->unk_000[2] = player->pos.z;
+    arg1->unk_000[0] = player->pos.x;
     arg1->unk_020 = (arg2 * 0x1998) - player->rotation[1];
     arg1->unk_012 = 4;
     arg1->unk_01E = 0;
@@ -4175,9 +4175,9 @@ void func_80062A18(Player* player, s8 arg1, UNUSED s8 arg2, s8 arg3) {
     player->unk_258[20 + arg3].unk_01E = 1;
     player->unk_258[20 + arg3].unk_020 = 0;
     player->unk_0B6 &= ~0x0080;
-    player->unk_258[20 + arg3].unk_000[2] = player->pos[2];
-    player->unk_258[20 + arg3].unk_000[0] = player->pos[0];
-    player->unk_258[20 + arg3].unk_000[1] = (player->pos[1] + 4.0f);
+    player->unk_258[20 + arg3].unk_000[2] = player->pos.z;
+    player->unk_258[20 + arg3].unk_000[0] = player->pos.x;
+    player->unk_258[20 + arg3].unk_000[1] = (player->pos.y + 4.0f);
 }
 
 void func_80062AA8(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
@@ -4185,43 +4185,30 @@ void func_80062AA8(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
     player->unk_258[20 + arg3].unk_012 = 5;
     player->unk_258[20 + arg3].unk_00C = 0.1f;
     player->unk_258[20 + arg3].unk_01E = 0;
-    player->unk_258[20 + arg3].unk_000[1] = (player->pos[1] + player->boundingBoxSize) - 2.5;
+    player->unk_258[20 + arg3].unk_000[1] = (player->pos.y + player->boundingBoxSize) - 2.5;
 }
 
-void func_80062B18(f32* arg0, f32* arg1, f32* arg2, f32 arg3, f32 arg4, f32 arg5, u16 arg6, u16 arg7) {
-    UNUSED f32 pad;
-    f32 sp30;
-    f32 sp2C;
-    f32 sp28;
-    f32 temp_f20;
+void func_80062B18(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY, f32 inZ, u16 theta, u16 phi) {
+    FrameInterpolation_RecordMatrixMultKart(outX, outY, outZ, inX, inY, inZ, theta, phi);
+    f32 sinTheta = sins(theta);
+    f32 cosTheta = coss(theta);
+    f32 sinPhi   = sins(phi);
+    f32 cosPhi   = coss(phi);
 
-    //  Apply the matrix multiplication:
-    //  Matrix is the Jacobian for cartesian to spherical coordinates?
-    //  Get the change in r, theta, and phi for a change in x, y, z?
-    //
-    // | arg0 |     | cos(arg6)*cos(arg7)  cos(arg6)*sin(arg7)   -sin(arg6) |     | arg3 |
-    // |      |     |                                                       |     |      |
-    // | arg1 |  =  | -sin(arg7)           cos(arg7)                 0      |  X  | arg4 |
-    // |      |     |                                                       |     |      |
-    // | arg2 |     | sin(arg6)*cos(arg7)  sin(arg6)*sin(arg7)    cos(arg6) |     | arg5 |
-    //
-    sp28 = sins(arg7);
-    sp2C = coss(arg6);
-    sp30 = coss(arg7);
-    temp_f20 = coss(arg6);
-    //    = arg3 * cos(arg6) * cos(arg7) + arg4 * cos(arg6) * sin(arg7) - arg5 * sin(arg6)
-    *arg0 = (((arg3 * temp_f20) * sp30) + (arg4 * sp2C) * sp28) - (sins(arg6) * arg5);
+    // Project onto spherical basis vectors:
+    // outX corresponds to radial component
+    *outX = (inX * cosTheta * cosPhi) +
+            (inY * cosTheta * sinPhi) -
+            (inZ * sinTheta);
 
-    temp_f20 = sins(arg7);
-    //    = -arg3 * sin(arg7) + arg4 * cos(arg7)
-    *arg1 = (coss(arg7) * arg4) - (arg3 * temp_f20);
+    // outY corresponds to azimuthal component
+    *outY = (-inX * sinPhi) +
+            (inY * cosPhi);
 
-    sp28 = sins(arg7);
-    sp2C = sins(arg6);
-    sp30 = coss(arg7);
-    temp_f20 = sins(arg6);
-    //    = arg3 * sin(arg6) * cos(arg7) + arg4 * sin(arg6) * sin(arg7) + arg5 * cos(arg6)
-    *arg2 = (coss(arg6) * arg5) + (((arg3 * temp_f20) * sp30) + ((arg4 * sp2C) * sp28));
+    // outZ corresponds to polar (vertical) component
+    *outZ = (inX * sinTheta * cosPhi) +
+            (inY * sinTheta * sinPhi) +
+            (inZ * cosTheta);
 }
 
 void func_80062C74(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
@@ -4273,9 +4260,9 @@ void func_80062C74(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
     }
     func_80062B18(&sp40, &sp38, &sp3C, 0.0f, sp48[player->characterId], (player->unk_258[arg1].unk_01E * var_f6) + -5.5,
                   -thing, -player->unk_206 * 2);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + sp40;
-    sp38 = (player->pos[1] - player->boundingBoxSize) + sp38;
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + sp3C;
+    player->unk_258[arg1].unk_000[0] = player->pos.x + sp40;
+    sp38 = (player->pos.y - player->boundingBoxSize) + sp38;
+    player->unk_258[arg1].unk_000[2] = player->pos.z + sp3C;
     player->unk_258[arg1].unk_000[1] = player->unk_258[arg1].unk_024 + sp38;
 }
 
@@ -4303,8 +4290,8 @@ void func_80062F98(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
 
 void func_800630C0(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
     ++player->unk_258[arg1].unk_01E;
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + coss(player->unk_258[arg1].unk_020) * -5.8;
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + sins(player->unk_258[arg1].unk_020) * -5.8;
+    player->unk_258[arg1].unk_000[2] = player->pos.z + coss(player->unk_258[arg1].unk_020) * -5.8;
+    player->unk_258[arg1].unk_000[0] = player->pos.x + sins(player->unk_258[arg1].unk_020) * -5.8;
     player->unk_258[arg1].unk_000[1] = D_801652A0[arg2];
     if (player->unk_258[arg1].unk_01E == 15) {
         player->unk_258[arg1].unk_01C = 0;
@@ -4347,10 +4334,10 @@ void func_80063268(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 
     player->unk_258[arg1].unk_024 += 0.25;
     player->unk_258[arg1].unk_000[2] =
-        player->pos[2] + (coss((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
+        player->pos.z + (coss((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
     player->unk_258[arg1].unk_000[0] =
-        player->pos[0] + (sins((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
-    player->unk_258[arg1].unk_000[1] = ((player->pos[1] - 5.0f) + player->unk_258[arg1].unk_024);
+        player->pos.x + (sins((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
+    player->unk_258[arg1].unk_000[1] = ((player->pos.y - 5.0f) + player->unk_258[arg1].unk_024);
     ++player->unk_258[arg1].unk_01E;
     player->unk_258[arg1].unk_00C += 0.05;
     player->unk_258[arg1].unk_03E -= 5;
@@ -4369,17 +4356,17 @@ void func_80063268(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 void func_80063408(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     if (player->unk_258[10 + arg1].unk_010 == 1) {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_LEFT].pos[2] +
+            player->tyres[BACK_LEFT].pos.z +
             (player->unk_258[10 + arg1].unk_01E * -7) * coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_LEFT].pos[0] +
+            player->tyres[BACK_LEFT].pos.x +
             (player->unk_258[10 + arg1].unk_01E * -7) * sins(player->unk_258[10 + arg1].unk_020);
     } else {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_RIGHT].pos[2] +
+            player->tyres[BACK_RIGHT].pos.z +
             (player->unk_258[10 + arg1].unk_01E * -7) * coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_RIGHT].pos[0] +
+            player->tyres[BACK_RIGHT].pos.x +
             (player->unk_258[10 + arg1].unk_01E * -7) * sins(player->unk_258[10 + arg1].unk_020);
     }
 
@@ -4417,15 +4404,15 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
             func_80062B18(&sp44, &sp40, &sp3C, -2.0f, 0.0f,
                           (-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16,
                           -player->unk_258[10 + arg1].unk_020, 2 * -player->unk_206);
-            player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_LEFT].pos[0] + sp44;
-            player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_LEFT].pos[2] + sp3C;
+            player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_LEFT].pos.x + sp44;
+            player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_LEFT].pos.z + sp3C;
         } else {
             player->unk_258[10 + arg1].unk_000[2] =
-                player->tyres[BACK_LEFT].pos[2] +
+                player->tyres[BACK_LEFT].pos.z +
                 ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
                     coss(player->unk_258[10 + arg1].unk_020);
             player->unk_258[10 + arg1].unk_000[0] =
-                player->tyres[BACK_LEFT].pos[0] +
+                player->tyres[BACK_LEFT].pos.x +
                 ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
                     sins(player->unk_258[10 + arg1].unk_020);
         }
@@ -4433,15 +4420,15 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
         func_80062B18(&sp44, &sp40, &sp3C, 2.0f, 0.0f,
                       (-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16,
                       -player->unk_258[10 + arg1].unk_020, 2 * -player->unk_206);
-        player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_RIGHT].pos[0] + sp44;
-        player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_RIGHT].pos[2] + sp3C;
+        player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_RIGHT].pos.x + sp44;
+        player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_RIGHT].pos.z + sp3C;
     } else {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_RIGHT].pos[2] +
+            player->tyres[BACK_RIGHT].pos.z +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
                 coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_RIGHT].pos[0] +
+            player->tyres[BACK_RIGHT].pos.x +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
                 sins(player->unk_258[10 + arg1].unk_020);
     }
@@ -4480,17 +4467,17 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 void func_800639DC(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     if (player->unk_258[10 + arg1].unk_010 == 1) {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_LEFT].pos[2] +
+            player->tyres[BACK_LEFT].pos.z +
             (-1.8f * player->unk_258[10 + arg1].unk_01E) * coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_LEFT].pos[0] +
+            player->tyres[BACK_LEFT].pos.x +
             (-1.8f * player->unk_258[10 + arg1].unk_01E) * sins(player->unk_258[10 + arg1].unk_020);
     } else {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_RIGHT].pos[2] +
+            player->tyres[BACK_RIGHT].pos.z +
             (-1.8f * player->unk_258[10 + arg1].unk_01E) * coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_RIGHT].pos[0] +
+            player->tyres[BACK_RIGHT].pos.x +
             (-1.8f * player->unk_258[10 + arg1].unk_01E) * sins(player->unk_258[10 + arg1].unk_020);
     }
     ++player->unk_258[10 + arg1].unk_01E;
@@ -4523,17 +4510,17 @@ void func_800639DC(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 void func_80063BD4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     if (player->unk_258[10 + arg1].unk_010 == 1) {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_LEFT].pos[2] +
+            player->tyres[BACK_LEFT].pos.z +
             (-2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_LEFT].pos[0] +
+            player->tyres[BACK_LEFT].pos.x +
             (-2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
     } else {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_RIGHT].pos[2] +
+            player->tyres[BACK_RIGHT].pos.z +
             (-2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_RIGHT].pos[0] +
+            player->tyres[BACK_RIGHT].pos.x +
             (-2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
     }
 
@@ -4552,20 +4539,20 @@ void func_80063BD4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 void func_80063D58(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     if (player->unk_258[10 + arg1].unk_010 == 1) {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_LEFT].pos[2] +
+            player->tyres[BACK_LEFT].pos.z +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
                 coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_LEFT].pos[0] +
+            player->tyres[BACK_LEFT].pos.x +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
                 sins(player->unk_258[10 + arg1].unk_020);
     } else {
         player->unk_258[10 + arg1].unk_000[2] =
-            player->tyres[BACK_RIGHT].pos[2] +
+            player->tyres[BACK_RIGHT].pos.z +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
                 coss(player->unk_258[10 + arg1].unk_020);
         player->unk_258[10 + arg1].unk_000[0] =
-            player->tyres[BACK_RIGHT].pos[0] +
+            player->tyres[BACK_RIGHT].pos.x +
             ((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
                 sins(player->unk_258[10 + arg1].unk_020);
     }
@@ -4604,9 +4591,9 @@ void func_80063FBC(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
                       -5.5 - (player->unk_258[10 + arg1].unk_01E * (((player->unk_094 / 18.0f) * 216.0f) / 15.0f)),
                       -player->unk_258[10 + arg1].unk_020, 0);
     }
-    player->unk_258[10 + arg1].unk_000[0] = player->pos[0] + sp3C;
-    player->unk_258[10 + arg1].unk_000[2] = player->pos[2] + sp38;
-    player->unk_258[10 + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp34;
+    player->unk_258[10 + arg1].unk_000[0] = player->pos.x + sp3C;
+    player->unk_258[10 + arg1].unk_000[2] = player->pos.z + sp38;
+    player->unk_258[10 + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp34;
     player->unk_258[10 + arg1].unk_01E++;
     if (player->unk_258[10 + arg1].unk_01E == 6) {
         player->unk_258[10 + arg1].unk_01C = 0;
@@ -4620,19 +4607,19 @@ void func_80064184(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
     f32 sp40;
     f32 sp3C;
 
-    sp40 = D_801652A0[arg2] - player->pos[1] - 3.0f;
+    sp40 = D_801652A0[arg2] - player->pos.y - 3.0f;
     if (((player->unk_0DE & 1) != 0) && (GetCourse() != GetKoopaTroopaBeach())) {
-        sp40 = D_801652A0[arg2] - player->pos[1] + 0.1;
+        sp40 = D_801652A0[arg2] - player->pos.y + 0.1;
     }
 
     func_80062B18(&sp44, &sp40, &sp3C, 0.0f, sp40,
                   -4.0f + ((-player->unk_258[arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 10.0f),
                   -player->unk_258[arg1].unk_020, 2 * -player->unk_206);
-    player->unk_258[arg1].unk_000[0] = player->pos[0] + sp44;
-    player->unk_258[arg1].unk_000[2] = player->pos[2] + sp3C;
-    player->unk_258[arg1].unk_000[1] = player->pos[1] + sp40;
+    player->unk_258[arg1].unk_000[0] = player->pos.x + sp44;
+    player->unk_258[arg1].unk_000[2] = player->pos.z + sp3C;
+    player->unk_258[arg1].unk_000[1] = player->pos.y + sp40;
     ++player->unk_258[arg1].unk_01E;
-    if ((player->unk_258[arg1].unk_01E == 12) || (D_801652A0[arg2] <= (player->pos[1] - player->boundingBoxSize))) {
+    if ((player->unk_258[arg1].unk_01E == 12) || (D_801652A0[arg2] <= (player->pos.y - player->boundingBoxSize))) {
         player->unk_258[arg1].unk_01C = 0;
         player->unk_258[arg1].unk_01E = 0;
         player->unk_258[arg1].unk_012 = 0;
@@ -4651,9 +4638,9 @@ void func_80064184(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
 
 void func_800643A8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     player->unk_258[10 + arg1].unk_000[2] =
-        player->pos[2] + (-1.2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
+        player->pos.z + (-1.2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
     player->unk_258[10 + arg1].unk_000[0] =
-        player->pos[0] + (-1.2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
+        player->pos.x + (-1.2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
     player->unk_258[10 + arg1].unk_000[1] = player->unk_258[10 + arg1].unk_000[1] + 0.5;
 
     ++player->unk_258[10 + arg1].unk_01E;
@@ -4682,9 +4669,9 @@ void func_800644E8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     thing2 = player->unk_258[30 + arg1].unk_024;
     thing = player->unk_258[30 + arg1].unk_01E;
     player->unk_258[30 + arg1].unk_000[2] =
-        player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
+        player->pos.z + (coss(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
     player->unk_258[30 + arg1].unk_000[0] =
-        player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
+        player->pos.x + (sins(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
     player->unk_258[30 + arg1].unk_01E++;
     player->unk_258[30 + arg1].unk_000[1] =
         player->unk_258[30 + arg1].unk_028 + (f32) ((thing * thing2) - (0.2 * (thing * thing)));
@@ -4710,9 +4697,9 @@ void func_80064664(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     temp_v1 = player->unk_258[30 + arg1].unk_01E;
     temp_f4 = player->unk_258[30 + arg1].unk_024;
     player->unk_258[30 + arg1].unk_000[2] =
-        player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
+        player->pos.z + (coss(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
     player->unk_258[30 + arg1].unk_000[0] =
-        player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
+        player->pos.x + (sins(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
     player->unk_258[30 + arg1].unk_01E++;
     player->unk_258[30 + arg1].unk_000[1] =
         player->unk_258[30 + arg1].unk_028 + (f32) ((temp_v1 * temp_f4) - (0.1 * (temp_v1 * temp_v1)));
@@ -4733,9 +4720,9 @@ void func_800647C8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 
     ++player->unk_258[30 + arg1].unk_01E;
     player->unk_258[30 + arg1].unk_000[2] =
-        player->pos[2] + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * coss(player->unk_258[30 + arg1].unk_020));
+        player->pos.z + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * coss(player->unk_258[30 + arg1].unk_020));
     player->unk_258[30 + arg1].unk_000[0] =
-        player->pos[0] + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * sins(player->unk_258[30 + arg1].unk_020));
+        player->pos.x + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * sins(player->unk_258[30 + arg1].unk_020));
     player->unk_258[30 + arg1].unk_000[1] = (player->unk_074 + 2.0f);
 
     if (player->unk_258[30 + arg1].unk_01E == 14) {
@@ -4786,7 +4773,7 @@ void func_800649F4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
         player->unk_21C + (((-temp) * player->unk_258[30 + arg1].unk_01E) * coss(player->unk_258[30 + arg1].unk_020));
     player->unk_258[30 + arg1].unk_000[0] =
         player->unk_218 + (((-temp) * player->unk_258[30 + arg1].unk_01E) * sins(player->unk_258[30 + arg1].unk_020));
-    player->unk_258[30 + arg1].unk_000[1] = player->pos[1] + player->unk_258[30 + arg1].unk_014;
+    player->unk_258[30 + arg1].unk_000[1] = player->pos.y + player->unk_258[30 + arg1].unk_014;
     player->unk_258[30 + arg1].unk_00C += 0.04;
 
     ++player->unk_258[30 + arg1].unk_01E;
@@ -4809,9 +4796,9 @@ void func_80064B30(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     temp = player->unk_258[30 + arg1].unk_018 * 1.2;
 
     player->unk_258[30 + arg1].unk_000[2] =
-        (player->pos[2] + (-temp * player->unk_258[30 + arg1].unk_01E) * (coss(player->unk_258[30 + arg1].unk_020)));
+        (player->pos.z + (-temp * player->unk_258[30 + arg1].unk_01E) * (coss(player->unk_258[30 + arg1].unk_020)));
     player->unk_258[30 + arg1].unk_000[0] =
-        (player->pos[0] + (-temp * player->unk_258[30 + arg1].unk_01E) * (sins(player->unk_258[30 + arg1].unk_020)));
+        (player->pos.x + (-temp * player->unk_258[30 + arg1].unk_01E) * (sins(player->unk_258[30 + arg1].unk_020)));
     player->unk_258[30 + arg1].unk_000[1] += 0.1;
 
     ++player->unk_258[30 + arg1].unk_01E;
@@ -4839,10 +4826,10 @@ void func_80064C74(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
     }
 
     player->unk_258[30 + arg1].unk_000[2] =
-        player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
+        player->pos.z + (coss(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
     player->unk_258[30 + arg1].unk_000[0] =
-        player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
-    player->unk_258[30 + arg1].unk_000[1] = player->pos[1] - 1.0f;
+        player->pos.x + (sins(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
+    player->unk_258[30 + arg1].unk_000[1] = player->pos.y - 1.0f;
     player->unk_258[30 + arg1].unk_00C += 0.4;
     ++player->unk_258[30 + arg1].unk_01E;
 
@@ -4861,7 +4848,7 @@ void func_80064C74(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
 
 void func_80064DEC(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
 
-    player->unk_258[20 + arg3].unk_000[1] = player->pos[1];
+    player->unk_258[20 + arg3].unk_000[1] = player->pos.y;
     ++player->unk_258[20 + arg3].unk_01E;
 
     if (player->unk_258[20 + arg3].unk_01E == 9) {
@@ -4928,9 +4915,9 @@ void func_80065030(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
 }
 
 void func_800650FC(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
-    player->unk_258[20 + arg3].unk_000[2] = (f32) player->pos[2];
-    player->unk_258[20 + arg3].unk_000[0] = (f32) player->pos[0];
-    player->unk_258[20 + arg3].unk_000[1] = (f32) (player->pos[1] + 4.0f);
+    player->unk_258[20 + arg3].unk_000[2] = (f32) player->pos.z;
+    player->unk_258[20 + arg3].unk_000[0] = (f32) player->pos.x;
+    player->unk_258[20 + arg3].unk_000[1] = (f32) (player->pos.y + 4.0f);
     if ((player->effects & 0x80) == 0x80) {
         player->unk_258[20 + arg3].unk_020 += 4732;
     } else {
@@ -5327,14 +5314,14 @@ void func_80066BAC(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
     if ((player->unk_258[arg2].unk_01C == 1) && (player->unk_258[arg2].unk_038 != 0x00FF)) {
 
         if (player->collision.surfaceDistance[2] >= 300.0f) {
-            spDC[1] = player->pos[1] + 5.0f;
+            spDC[1] = player->pos.y + 5.0f;
         } else {
-            spDC[1] = player->pos[1] - 3.0f;
+            spDC[1] = player->pos.y - 3.0f;
         }
-        spDC[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
-        spDC[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
+        spDC[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
+        spDC[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
         if (player->collision.surfaceDistance[2] >= 300.0f) {
-            spD4[0] = cameras[arg3].rot[0] - 0x4000;
+            spD4[0] = cameras[arg3].rot.x - 0x4000;
         } else {
             spD4[0] = 0;
         }
@@ -5492,9 +5479,9 @@ void func_80067D3C(Player* player, s8 arg1, u8* texture, s8 arg3, f32 arg4, s32
         sp74[0] = 0;
         sp74[1] = player->unk_048[arg1];
         sp74[2] = 0;
-        sp7C[0] = player->pos[0] + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
-        sp7C[1] = player->pos[1] + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
-        sp7C[2] = player->pos[2] + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
+        sp7C[0] = player->pos.x + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
+        sp7C[1] = player->pos.y + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
+        sp7C[2] = player->pos.z + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
         func_800652D4(sp7C, sp74, player->unk_258[20 + arg3].unk_00C * player->size);
         gSPDisplayList(gDisplayListHead++, D_0D008DB8);
         gDPLoadTextureBlock(gDisplayListHead++, texture, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
@@ -5520,9 +5507,9 @@ void func_8006801C(Player* player, s8 arg1, u8* texture, s8 arg3, f32 arg4, s32
         sp74[0] = 0;
         sp74[1] = player->unk_048[arg1];
         sp74[2] = 0;
-        sp7C[0] = player->pos[0] + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
-        sp7C[1] = player->pos[1] + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
-        sp7C[2] = player->pos[2] + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
+        sp7C[0] = player->pos.x + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
+        sp7C[1] = player->pos.y + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
+        sp7C[2] = player->pos.z + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
         func_800652D4(sp7C, sp74, player->unk_258[20 + arg3].unk_00C * player->size * 0.8);
         gSPDisplayList(gDisplayListHead++, D_0D008DB8);
         gDPLoadTextureBlock(gDisplayListHead++, texture, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
@@ -5541,8 +5528,8 @@ void func_80068310(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
 
     if (player->unk_258[20 + arg4].unk_01C == 1) {
         sp9C[1] = player->unk_258[20 + arg4].unk_000[1];
-        sp9C[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
-        sp9C[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
+        sp9C[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
+        sp9C[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
         sp94[0] = 0;
         sp94[1] = player->unk_048[arg3];
         sp94[2] = 0;
@@ -5570,9 +5557,9 @@ void func_80068724(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
     Vec3s sp7C;
 
     if (player->unk_258[20 + arg4].unk_01C == 1) {
-        sp84[1] = player->pos[1] - 3.0f;
-        sp84[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
-        sp84[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
+        sp84[1] = player->pos.y - 3.0f;
+        sp84[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
+        sp84[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
         sp7C[0] = 0;
         sp7C[1] = player->unk_048[arg3];
         sp7C[2] = 0;
@@ -5598,15 +5585,15 @@ void func_80068AA4(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
     Vec3f sp64;
     Vec3s sp5C;
 
-    sp64[1] = player->pos[1];
-    sp64[2] = player->pos[2];
-    sp64[0] = player->pos[0];
+    sp64[1] = player->pos.y;
+    sp64[2] = player->pos.z;
+    sp64[0] = player->pos.x;
 
     if ((player->unk_258[20 + arg4].unk_01C == 1) && (player->animFrameSelector[arg3] < 0xD)) {
         if (gTickVisuals) {
-            sp64[1] = player->pos[1] - 3.0f;
-            sp64[2] = player->pos[2] + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * coss(player->unk_048[arg3]));
-            sp64[0] = player->pos[0] + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * sins(player->unk_048[arg3]));
+            sp64[1] = player->pos.y - 3.0f;
+            sp64[2] = player->pos.z + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * coss(player->unk_048[arg3]));
+            sp64[0] = player->pos.x + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * sins(player->unk_048[arg3]));
         }
         sp5C[0] = 0;
         sp5C[1] = player->unk_048[arg3];
@@ -5630,9 +5617,9 @@ void func_80068DA0(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
     Vec3s sp94;
 
     if ((player->unk_258[20 + arg4].unk_01C == 1) && ((s32) player->animFrameSelector[arg3] < 0xD)) {
-        sp9C[1] = (player->pos[1] - 3.0f) + player->unk_258[20 + arg4].unk_000[1];
-        sp9C[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
-        sp9C[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
+        sp9C[1] = (player->pos.y - 3.0f) + player->unk_258[20 + arg4].unk_000[1];
+        sp9C[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
+        sp9C[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
         sp94[0] = 0;
         sp94[1] = player->unk_048[arg3];
         sp94[2] = 0;
@@ -5915,9 +5902,9 @@ void func_8006A50C(Player* player, f32 arg1, f32 arg2, s8 arg3, s8 arg4, s16 arg
     D_8018D830[arg3][arg4] = 1;
     D_8018D620[arg3][arg4] = -player->rotation[1] - player->unk_0C0;
     func_80062B18(&someX, &someY, &someZ, arg1, 4.0f, arg2 + -3.8, -player->rotation[1], 0);
-    D_8018D4D0[arg3][arg4] = player->pos[0] + someX;
-    D_8018D590[arg3][arg4] = player->pos[2] + someZ;
-    D_8018D530[arg3][arg4] = (player->pos[1] - player->boundingBoxSize) + someY;
+    D_8018D4D0[arg3][arg4] = player->pos.x + someX;
+    D_8018D590[arg3][arg4] = player->pos.z + someZ;
+    D_8018D530[arg3][arg4] = (player->pos.y - player->boundingBoxSize) + someY;
     gPlayerBalloonStatus[arg3][arg4] |= 1;
     D_8018D860[arg3][arg4] = arg5;
     D_8018D890[arg3][arg4] = 0;
@@ -5994,9 +5981,9 @@ void func_8006A7C0(Player* player, f32 arg1, f32 arg2, s8 arg3, s8 arg4) {
     func_80062B18(&someX, &someY, &someZ, arg1, sp80[player->characterId] - D_8018D710[arg3][arg4],
                   arg2 + -3.2 + (sp6C * 1), -D_8018D620[arg3][arg4], -player->unk_206 * 2);
     if ((gPlayerBalloonStatus[arg3][arg4] & 2) != 2) {
-        D_8018D530[arg3][arg4] = (player->pos[1] - player->boundingBoxSize) + someY;
-        D_8018D4D0[arg3][arg4] = player->pos[0] + someX;
-        D_8018D590[arg3][arg4] = player->pos[2] + someZ;
+        D_8018D530[arg3][arg4] = (player->pos.y - player->boundingBoxSize) + someY;
+        D_8018D4D0[arg3][arg4] = player->pos.x + someX;
+        D_8018D590[arg3][arg4] = player->pos.z + someZ;
         D_8018D8D0[arg3][arg4] = 0;
     } else {
         D_8018D530[arg3][arg4] += 0.2;
@@ -6045,8 +6032,8 @@ void render_battle_balloon(Player* player, s8 arg1, s16 arg2, s8 arg3) {
         var_f20 = 0.3f;
     } else {
         // wut?
-        xdiff = (var_f20 = player->pos[0] - cameras[arg3].pos[0]);
-        zdiff = player->pos[2] - cameras[arg3].pos[2];
+        xdiff = (var_f20 = player->pos.x - cameras[arg3].pos.x);
+        zdiff = player->pos.z - cameras[arg3].pos.z;
         if (gActiveScreenMode != 3) {
             var_f20 = sqrtf((xdiff * xdiff) + (zdiff * zdiff)) / 300.0f;
         } else {
@@ -6189,7 +6176,7 @@ void render_balloon(Vec3f arg0, f32 arg1, s16 arg2, s16 arg3) {
     spFC[1] = arg0[1];
     spFC[2] = arg0[2];
     spF4[0] = 0;
-    spF4[1] = camera1->rot[1];
+    spF4[1] = camera1->rot.y;
     spF4[2] = arg2;
     mtxf_translate_rotate(mtx, spFC, spF4);
     mtxf_scale2(mtx, arg1);
@@ -6234,7 +6221,7 @@ void func_8006C0C8(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
     sp4C[1] = arg0[1];
     sp4C[2] = arg0[2];
     sp44[0] = 0;
-    sp44[1] = camera1->rot[1];
+    sp44[1] = camera1->rot.y;
     sp44[2] = 0;
     func_800652D4(sp4C, sp44, arg1);
     gSPDisplayList(gDisplayListHead++, D_0D008DB8);
@@ -6263,7 +6250,7 @@ void func_8006C294(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
     sp5C[1] = arg0[1];
     sp5C[2] = arg0[2];
     sp54[0] = 0;
-    sp54[1] = camera1->rot[1];
+    sp54[1] = camera1->rot.y;
     sp54[2] = 0;
     func_800652D4(sp5C, sp54, arg1);
     gSPDisplayList(gDisplayListHead++, D_0D008D58);
@@ -6290,7 +6277,7 @@ void func_8006C4D4(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha, s16 arg4) {
     sp4C[1] = arg0[1];
     sp4C[2] = arg0[2];
     sp44[0] = 0;
-    sp44[1] = camera1->rot[1];
+    sp44[1] = camera1->rot.y;
     sp44[2] = 0;
     func_800652D4(sp4C, sp44, arg1);
     gSPDisplayList(gDisplayListHead++, D_0D008DB8);
diff --git a/src/code_8006E9C0.c b/src/code_8006E9C0.c
index d74346d00..ebdcb0259 100644
--- a/src/code_8006E9C0.c
+++ b/src/code_8006E9C0.c
@@ -671,16 +671,16 @@ void init_course_object(void) {
     //         // Handle the big statue's fire breath
     //         objectId = indexObjectList2[0];
     //         init_object(objectId, 0);
-    //         gObjectList[objectId].pos[0] = -68.0 * xOrientation;
-    //         gObjectList[objectId].pos[1] = 80.0f;
-    //         gObjectList[objectId].pos[2] = -1840.0f;
+    //         gObjectList[objectId].pos.x = -68.0 * xOrientation;
+    //         gObjectList[objectId].pos.y = 80.0f;
+    //         gObjectList[objectId].pos.z = -1840.0f;
     //         // Handle the smaller statues' fire breath
     //         for (i = 0; i < NUM_FIRE_BREATHS; i++) {
     //             objectId = indexObjectList3[i];
     //             init_object(objectId, 0);
-    //             gObjectList[objectId].pos[0] = gFireBreathsSpawns[i][0] * xOrientation;
-    //             gObjectList[objectId].pos[1] = gFireBreathsSpawns[i][1];
-    //             gObjectList[objectId].pos[2] = gFireBreathsSpawns[i][2];
+    //             gObjectList[objectId].pos.x = gFireBreathsSpawns[i][0] * xOrientation;
+    //             gObjectList[objectId].pos.y = gFireBreathsSpawns[i][1];
+    //             gObjectList[objectId].pos.z = gFireBreathsSpawns[i][2];
     //             gObjectList[objectId].direction_angle[1] = 0;
     //             if (i % 2U) {
     //                 gObjectList[objectId].direction_angle[1] += 0x8000;
@@ -710,11 +710,11 @@ void init_course_object(void) {
     //             for (i = 0; i < NUM_HEDGEHOGS; i++) {
     //                 objectId = indexObjectList2[i];
     //                 init_object(objectId, 0);
-    //                 gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] =
-    //                     gHedgehogSpawns[i].pos[0] * xOrientation;
-    //                 gObjectList[objectId].pos[1] = gObjectList[objectId].surfaceHeight =
-    //                     gHedgehogSpawns[i].pos[1] + 6.0;
-    //                 gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = gHedgehogSpawns[i].pos[2];
+    //                 gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] =
+    //                     gHedgehogSpawns[i].pos.x * xOrientation;
+    //                 gObjectList[objectId].pos.y = gObjectList[objectId].surfaceHeight =
+    //                     gHedgehogSpawns[i].pos.y + 6.0;
+    //                 gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = gHedgehogSpawns[i].pos.z;
     //                 gObjectList[objectId].unk_0D5 = gHedgehogSpawns[i].unk_06;
     //                 gObjectList[objectId].unk_09C = gHedgehogPatrolPoints[i][0] * xOrientation;
     //                 gObjectList[objectId].unk_09E = gHedgehogPatrolPoints[i][2];
@@ -729,14 +729,14 @@ void init_course_object(void) {
     //             for (i = 0; i < NUM_SNOWMEN; i++) {
     //                 objectId = indexObjectList2[i];
     //                 init_object(objectId, 0);
-    //                 gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos[0] * xOrientation;
-    //                 gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos[1] + 5.0 + 3.0;
-    //                 gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos[2];
+    //                 gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos.x * xOrientation;
+    //                 gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos.y + 5.0 + 3.0;
+    //                 gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos.z;
     //                 objectId = indexObjectList1[i];
     //                 init_object(objectId, 0);
-    //                 gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos[0] * xOrientation;
-    //                 gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos[1] + 3.0;
-    //                 gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos[2];
+    //                 gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos.x * xOrientation;
+    //                 gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos.y + 3.0;
+    //                 gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos.z;
     //                 gObjectList[objectId].unk_0D5 = gSnowmanSpawns[i].unk_6;
     //             }
     //         }
@@ -746,11 +746,11 @@ void init_course_object(void) {
     //             for (i = 0; i < NUM_CRABS; i++) {
     //                 objectId = indexObjectList1[i];
     //                 init_object(objectId, 0);
-    //                 gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] =
+    //                 gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] =
     //                     gCrabSpawns[i].startX * xOrientation;
     //                 gObjectList[objectId].unk_01C[0] = gCrabSpawns[i].patrolX * xOrientation;
 
-    //                 gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = gCrabSpawns[i].startZ;
+    //                 gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = gCrabSpawns[i].startZ;
     //                 gObjectList[objectId].unk_01C[2] = gCrabSpawns[i].patrolZ;
     //             }
     //         }
@@ -834,8 +834,8 @@ void init_course_object(void) {
     //                 find_unused_obj_index(&gObjectParticle1[i]);
     //                 objectId = gObjectParticle1[i];
     //                 init_object(objectId, 0);
-    //                 gObjectList[objectId].pos[0] = gMoleSpawns.asVec3sList[i][0] * xOrientation;
-    //                 gObjectList[objectId].pos[2] = gMoleSpawns.asVec3sList[i][2];
+    //                 gObjectList[objectId].pos.x = gMoleSpawns.asVec3sList[i][0] * xOrientation;
+    //                 gObjectList[objectId].pos.z = gMoleSpawns.asVec3sList[i][2];
     //                 func_800887C0(objectId);
     //                 gObjectList[objectId].sizeScaling = 0.7f;
     //             }
diff --git a/src/code_80086E70.c b/src/code_80086E70.c
index 89f51308a..dca2a10b5 100644
--- a/src/code_80086E70.c
+++ b/src/code_80086E70.c
@@ -118,20 +118,20 @@ UNUSED void func_80087258(s32 objectIndex, UNUSED s32 arg1, f32 arg2) {
 }
 
 UNUSED s32 get_angle_between_player_object(s32 objectIndex, Player* player) {
-    return get_angle_between_xy(player->pos[0], gObjectList[objectIndex].pos[0], player->pos[2],
-                                gObjectList[objectIndex].pos[2]);
+    return get_angle_between_xy(player->pos.x, gObjectList[objectIndex].pos.x, player->pos.z,
+                                gObjectList[objectIndex].pos.z);
 }
 
 s32 angle_between_object_camera(s32 objectIndex, Camera* camera) {
-    return atan2s(gObjectList[objectIndex].pos[0] - camera->pos[0], gObjectList[objectIndex].pos[2] - camera->pos[2]);
+    return atan2s(gObjectList[objectIndex].pos.x - camera->pos.x, gObjectList[objectIndex].pos.z - camera->pos.z);
 }
 
 u16 get_x_direction_angle(s32 objectIndex) {
-    return -atan2s(gObjectList[objectIndex].velocity[1], gObjectList[objectIndex].velocity[2]);
+    return -atan2s(gObjectList[objectIndex].velocity.y, gObjectList[objectIndex].velocity.z);
 }
 
 s32 get_y_direction_angle(s32 objectIndex) {
-    return atan2s(gObjectList[objectIndex].velocity[0], gObjectList[objectIndex].velocity[2]);
+    return atan2s(gObjectList[objectIndex].velocity.x, gObjectList[objectIndex].velocity.z);
 }
 
 UNUSED void func_800873A4(s32 objectIndex) {
@@ -145,24 +145,24 @@ void func_800873F4(s32 objectIndex) {
 }
 
 UNUSED void func_80087444(s32 objectIndex) {
-    gObjectList[objectIndex].velocity[0] =
+    gObjectList[objectIndex].velocity.x =
         gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1]);
 }
 
 UNUSED void func_8008748C(s32 objectIndex) {
-    gObjectList[objectIndex].velocity[1] =
+    gObjectList[objectIndex].velocity.y =
         gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[0]);
 }
 
 UNUSED void func_800874D4(s32 objectIndex) {
-    gObjectList[objectIndex].velocity[2] =
+    gObjectList[objectIndex].velocity.z =
         gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1]);
 }
 
 void func_8008751C(s32 objectIndex) {
-    gObjectList[objectIndex].velocity[0] =
+    gObjectList[objectIndex].velocity.x =
         gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1]);
-    gObjectList[objectIndex].velocity[2] =
+    gObjectList[objectIndex].velocity.z =
         gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1]);
 }
 
@@ -170,19 +170,19 @@ void func_8008757C(s32 objectIndex) {
     f32 sp24;
 
     sp24 = coss(gObjectList[objectIndex].direction_angle[0]);
-    gObjectList[objectIndex].velocity[0] =
+    gObjectList[objectIndex].velocity.x =
         (gObjectList[objectIndex].unk_034 * sp24) * sins(gObjectList[objectIndex].direction_angle[1]);
-    gObjectList[objectIndex].velocity[1] =
+    gObjectList[objectIndex].velocity.y =
         -gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[0]);
     sp24 = coss(gObjectList[objectIndex].direction_angle[0]);
-    gObjectList[objectIndex].velocity[2] =
+    gObjectList[objectIndex].velocity.z =
         (gObjectList[objectIndex].unk_034 * sp24) * coss(gObjectList[objectIndex].direction_angle[1]);
 }
 
 void func_80087620(s32 objectIndex) {
-    gObjectList[objectIndex].velocity[0] =
+    gObjectList[objectIndex].velocity.x =
         gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1] + 0x8000);
-    gObjectList[objectIndex].velocity[2] =
+    gObjectList[objectIndex].velocity.z =
         gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1] + 0x8000);
 }
 
@@ -194,26 +194,26 @@ void func_800876A0(s32 objectIndex) {
 }
 
 void object_add_velocity_offset_xyz(s32 objectIndex) {
-    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
-    gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity[1];
-    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
+    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
+    gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity.y;
+    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
 }
 
 void object_add_velocity_offset_xz(s32 objectIndex) {
-    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
-    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
+    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
+    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
 }
 
 UNUSED void object_add_velocity_offset_x(s32 objectIndex) {
-    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
+    gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
 }
 
 void object_add_velocity_offset_y(s32 objectIndex) {
-    gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity[1];
+    gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity.y;
 }
 
 UNUSED void object_add_velocity_offset_z(s32 objectIndex) {
-    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
+    gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
 }
 
 void func_8008781C(s32 arg0) {
@@ -301,10 +301,10 @@ s32 func_80087B84(s32 objectIndex, f32 arg1, f32 arg2) {
     sp24 = 0;
     if (is_obj_index_flag_status_inactive(objectIndex, 8) != false) {
         set_object_flag(objectIndex, 8);
-        gObjectList[objectIndex].velocity[1] = -arg1;
+        gObjectList[objectIndex].velocity.y = -arg1;
     }
     object_add_velocity_offset_y(objectIndex);
-    if (gObjectList[objectIndex].pos[1] <= arg2) {
+    if (gObjectList[objectIndex].pos.y <= arg2) {
         clear_object_flag(objectIndex, 8);
         func_80086FD4(objectIndex);
         sp24 = 1;
@@ -318,7 +318,7 @@ s32 func_80087C48(s32 objectIndex, f32 arg1, f32 arg2, s32 arg3) {
     sp24 = 0;
     if (is_obj_index_flag_status_inactive(objectIndex, 8) != false) {
         set_object_flag(objectIndex, 8);
-        gObjectList[objectIndex].velocity[1] = arg1;
+        gObjectList[objectIndex].velocity.y = arg1;
         gObjectList[objectIndex].unk_0B0 = (s16) arg3;
     }
     gObjectList[objectIndex].unk_0B0--;
@@ -327,7 +327,7 @@ s32 func_80087C48(s32 objectIndex, f32 arg1, f32 arg2, s32 arg3) {
         func_80086FD4(objectIndex);
         sp24 = 1;
     } else {
-        gObjectList[objectIndex].velocity[1] -= arg2;
+        gObjectList[objectIndex].velocity.y -= arg2;
         object_add_velocity_offset_y(objectIndex);
     }
     return sp24;
@@ -339,9 +339,9 @@ s32 func_80087D24(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
     sp24 = 0;
     if (is_obj_index_flag_status_inactive(objectIndex, 8) != 0) {
         set_object_flag(objectIndex, 8);
-        gObjectList[objectIndex].velocity[1] = arg1;
+        gObjectList[objectIndex].velocity.y = arg1;
     }
-    gObjectList[objectIndex].velocity[1] -= arg2;
+    gObjectList[objectIndex].velocity.y -= arg2;
     object_add_velocity_offset_y(objectIndex);
     if (gObjectList[objectIndex].offset[1] <= arg3) {
         clear_object_flag(objectIndex, 8);
@@ -363,7 +363,7 @@ bool func_80087E08(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4, s32
         gObjectList[objectIndex].offset[1] = 0.0f;
         gObjectList[objectIndex].offset[0] = 0.0f;
         gObjectList[objectIndex].unk_034 = arg3;
-        gObjectList[objectIndex].velocity[1] = arg1;
+        gObjectList[objectIndex].velocity.y = arg1;
         gObjectList[objectIndex].direction_angle[1] = arg4;
         func_8008751C(objectIndex);
         gObjectList[objectIndex].unk_0B0 = arg5;
@@ -374,7 +374,7 @@ bool func_80087E08(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4, s32
         func_80086FD4(objectIndex);
         sp2C = true;
     } else {
-        gObjectList[objectIndex].velocity[1] -= arg2;
+        gObjectList[objectIndex].velocity.y -= arg2;
         object_add_velocity_offset_xyz(objectIndex);
     }
     return sp2C;
@@ -391,7 +391,7 @@ UNUSED s32 func_80087F14(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4
         gObjectList[objectIndex].offset[1] = 0.0f;
         gObjectList[objectIndex].offset[0] = 0.0f;
         gObjectList[objectIndex].unk_034 = arg3;
-        gObjectList[objectIndex].velocity[1] = arg1;
+        gObjectList[objectIndex].velocity.y = arg1;
         gObjectList[objectIndex].direction_angle[1] = arg4;
         func_8008751C(objectIndex);
         gObjectList[objectIndex].unk_0B0 = gVBlankTimer;
@@ -401,7 +401,7 @@ UNUSED s32 func_80087F14(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4
         func_80086FD4(objectIndex);
         sp2C = 1;
     } else {
-        gObjectList[objectIndex].velocity[1] -= arg2;
+        gObjectList[objectIndex].velocity.y -= arg2;
         object_add_velocity_offset_xyz(objectIndex);
     }
     return sp2C;
@@ -416,8 +416,8 @@ void func_80088038(s32 objectIndex, f32 arg1, u16 arg2) {
     gObjectList[objectIndex].unk_0C4 += arg2;
     gObjectList[objectIndex].offset[0] = sins(gObjectList[objectIndex].unk_0C4) * arg1;
     gObjectList[objectIndex].offset[2] = coss(gObjectList[objectIndex].unk_0C4) * arg1;
-    gObjectList[objectIndex].velocity[0] = gObjectList[objectIndex].offset[0] - temp_f4;
-    gObjectList[objectIndex].velocity[2] = gObjectList[objectIndex].offset[2] - sp20;
+    gObjectList[objectIndex].velocity.x = gObjectList[objectIndex].offset[0] - temp_f4;
+    gObjectList[objectIndex].velocity.z = gObjectList[objectIndex].offset[2] - sp20;
 }
 
 UNUSED void func_800880DC(void) {
@@ -428,9 +428,9 @@ void func_800880E4(s32 objectIndex) {
     s32 someIndex;
     phi_v0 = gObjectList[objectIndex].controlPoints;
     for (someIndex = 0; someIndex < 2; someIndex++, phi_v0++) {
-        D_80165760[someIndex] = phi_v0->pos[0];
-        D_80165770[someIndex] = phi_v0->pos[1];
-        D_80165780[someIndex] = phi_v0->pos[2];
+        D_80165760[someIndex] = phi_v0->pos.x;
+        D_80165770[someIndex] = phi_v0->pos.y;
+        D_80165780[someIndex] = phi_v0->pos.z;
     }
 }
 
@@ -464,9 +464,9 @@ void func_80088228(s32 objectIndex) {
     but for some unholy reason that doesn't match
     */
     object->unk_084[8] = *((s16*) object->controlPoints - 1);
-    object->offset[0] = object->controlPoints[0].pos[0];
-    object->offset[1] = object->controlPoints[0].pos[1];
-    object->offset[2] = object->controlPoints[0].pos[2];
+    object->offset[0] = object->controlPoints[0].pos.x;
+    object->offset[1] = object->controlPoints[0].pos.y;
+    object->offset[2] = object->controlPoints[0].pos.z;
     func_80086FD4(objectIndex);
 }
 
@@ -528,14 +528,14 @@ s32 func_8008847C(s32 objectIndex) {
     sp2C = 0;
     clear_object_flag(objectIndex, 0x00800000);
     if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
-        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
-                                 gObjectList[objectIndex].pos[2]);
+        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
+                                 gObjectList[objectIndex].pos.z);
         if (D_8018C3B0.unk34 == 1) {
             sp2C = 1;
             set_object_flag(objectIndex, 0x00800000);
         }
         gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
-            gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
+            gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
     }
     return sp2C;
 }
@@ -546,14 +546,14 @@ s32 func_80088538(s32 objectIndex) {
     sp2C = 0;
     clear_object_flag(objectIndex, 0x00800000);
     if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
-        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
-                                 gObjectList[objectIndex].pos[2]);
+        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
+                                 gObjectList[objectIndex].pos.z);
         if (D_8018C3B0.unk34 == 1) {
             sp2C = 1;
             set_object_flag(objectIndex, 0x00800000);
         }
         gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
-            gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
+            gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
         gObjectList[objectIndex].unk_0B8[0] =
             atan2s(D_8018C3B0.orientationVector[2], D_8018C3B0.orientationVector[1]) + 0x4000;
         gObjectList[objectIndex].unk_0B8[2] = atan2s(D_8018C3B0.orientationVector[0], D_8018C3B0.orientationVector[1]);
@@ -567,14 +567,14 @@ s32 func_8008861C(s32 objectIndex) {
     sp2C = 0;
     clear_object_flag(objectIndex, 0x00800000);
     if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
-        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
-                                 gObjectList[objectIndex].pos[2]);
+        check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
+                                 gObjectList[objectIndex].pos.z);
         if (D_8018C3B0.unk34 == 1) {
             sp2C = 1;
             set_object_flag(objectIndex, 0x00800000);
         }
         gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
-            gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
+            gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
         gObjectList[objectIndex].unk_01C[0] = D_8018C3B0.orientationVector[0];
         gObjectList[objectIndex].unk_01C[1] = D_8018C3B0.orientationVector[1];
         gObjectList[objectIndex].unk_01C[2] = D_8018C3B0.orientationVector[2];
@@ -583,12 +583,12 @@ s32 func_8008861C(s32 objectIndex) {
 }
 
 void func_800886F4(s32 objectIndex) {
-    check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
-                             gObjectList[objectIndex].pos[2]);
+    check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
+                             gObjectList[objectIndex].pos.z);
     if (D_8018C3B0.unk34 == 1) {
         set_object_flag(objectIndex, 0x00800000);
         gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
-            gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
+            gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
         gObjectList[objectIndex].unk_0B8[0] =
             atan2s(D_8018C3B0.orientationVector[2], D_8018C3B0.orientationVector[1]) + 0x4000;
         gObjectList[objectIndex].unk_0B8[2] = atan2s(D_8018C3B0.orientationVector[0], D_8018C3B0.orientationVector[1]);
@@ -598,15 +598,15 @@ void func_800886F4(s32 objectIndex) {
 }
 
 void func_800887C0(s32 objectIndex) {
-    check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
-                             gObjectList[objectIndex].pos[2]);
+    check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
+                             gObjectList[objectIndex].pos.z);
     if (D_8018C3B0.unk34 == 1) {
         set_object_flag(objectIndex, 0x00800000);
         gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
-            gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
-        gObjectList[objectIndex].velocity[0] = D_8018C3B0.orientationVector[0];
-        gObjectList[objectIndex].velocity[1] = D_8018C3B0.orientationVector[1];
-        gObjectList[objectIndex].velocity[2] = D_8018C3B0.orientationVector[2];
+            gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
+        gObjectList[objectIndex].velocity.x = D_8018C3B0.orientationVector[0];
+        gObjectList[objectIndex].velocity.y = D_8018C3B0.orientationVector[1];
+        gObjectList[objectIndex].velocity.z = D_8018C3B0.orientationVector[2];
         return;
     }
     clear_object_flag(objectIndex, 0x00800000);
@@ -623,8 +623,8 @@ UNUSED s32 get_horizontal_distance_to_player(s32 objectIndex, Player* player) {
     s32 x;
     s32 y;
 
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.z - player->pos.z;
     return (x * x) + (y * y);
 }
 
@@ -640,9 +640,9 @@ UNUSED s32 get_distance_to_player(s32 objectIndex, Player* player) {
     s32 z;
     s32 y;
 
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[1] - player->pos[1];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.y - player->pos.y;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     return (x * x) + (y * y) + (z * z);
 }
 
@@ -657,8 +657,8 @@ u32 get_horizontal_distance_to_camera(s32 objectIndex, Camera* camera) {
     s32 x;
     s32 y;
 
-    x = gObjectList[objectIndex].pos[0] - camera->pos[0];
-    y = gObjectList[objectIndex].pos[2] - camera->pos[2];
+    x = gObjectList[objectIndex].pos.x - camera->pos.x;
+    y = gObjectList[objectIndex].pos.z - camera->pos.z;
     return (x * x) + (y * y);
 }
 
@@ -674,9 +674,9 @@ UNUSED s32 get_distance_to_camera(s32 objectIndex, Camera* camera) {
     s32 z;
     s32 y;
 
-    x = gObjectList[objectIndex].pos[0] - camera->pos[0];
-    y = gObjectList[objectIndex].pos[1] - camera->pos[1];
-    z = gObjectList[objectIndex].pos[2] - camera->pos[2];
+    x = gObjectList[objectIndex].pos.x - camera->pos.x;
+    y = gObjectList[objectIndex].pos.y - camera->pos.y;
+    z = gObjectList[objectIndex].pos.z - camera->pos.z;
     return (x * x) + (y * y) + (z * z);
 }
 
@@ -695,8 +695,8 @@ bool is_within_horizontal_distance_of_player(s32 objectIndex, Player* player, f3
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.z - player->pos.z;
     if (((x * x) + (y * y)) <= (distance * distance)) {
         var_v1 = true;
     }
@@ -720,8 +720,8 @@ bool is_in_bounds_to_player(s32 objectIndex, Player* player, f32 distance_min, f
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     distance = (x * x) + (z * z);
     if (((distance_min * distance_min) <= distance) && (distance <= (distance_max * distance_max))) {
         var_v1 = true;
@@ -745,9 +745,9 @@ bool is_within_distance_to_player(s32 objectIndex, Player* player, f32 distance)
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[1] - player->pos[1];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.y - player->pos.y;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
         var_v1 = true;
     }
@@ -769,8 +769,8 @@ bool is_within_horizontal_distance_to_camera(s32 objectIndex, Camera* camera, f3
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - camera->pos[0];
-    y = gObjectList[objectIndex].pos[2] - camera->pos[2];
+    x = gObjectList[objectIndex].pos.x - camera->pos.x;
+    y = gObjectList[objectIndex].pos.z - camera->pos.z;
     if (((x * x) + (y * y)) <= (distance * distance)) {
         var_v1 = true;
     }
@@ -793,8 +793,8 @@ UNUSED bool is_within_bounds_to_camera(s32 objectIndex, Camera* camera, f32 dist
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - camera->pos[0];
-    z = gObjectList[objectIndex].pos[2] - camera->pos[2];
+    x = gObjectList[objectIndex].pos.x - camera->pos.x;
+    z = gObjectList[objectIndex].pos.z - camera->pos.z;
     distance = (x * x) + (z * z);
     if (((distance_min * distance_min) <= distance) && (distance <= (distance_max * distance_max))) {
         var_v1 = true;
@@ -817,9 +817,9 @@ UNUSED bool is_within_distance_to_camera(s32 objectIndex, Camera* camera, f32 di
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - camera->pos[0];
-    y = gObjectList[objectIndex].pos[1] - camera->pos[1];
-    z = gObjectList[objectIndex].pos[2] - camera->pos[2];
+    x = gObjectList[objectIndex].pos.x - camera->pos.x;
+    y = gObjectList[objectIndex].pos.y - camera->pos.y;
+    z = gObjectList[objectIndex].pos.z - camera->pos.z;
     if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
         var_v1 = true;
     }
@@ -841,8 +841,8 @@ bool has_collided_horizontally_with_player(s32 objectIndex, Player* player) {
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
     if (((x * x) + (z * z)) <= (distance * distance)) {
         var_v1 = true;
@@ -866,9 +866,9 @@ bool has_collided_with_player(s32 objectIndex, Player* player) {
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[1] - player->pos[1];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.y - player->pos.y;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
     if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
         var_v1 = true;
@@ -889,7 +889,7 @@ UNUSED bool has_collided_with_player_1d(s32 objectIndex, Player* player, f32 dis
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[1] - player->pos[1];
+    x = gObjectList[objectIndex].pos.y - player->pos.y;
     if ((x * x) <= (distance * distance)) {
         var_v1 = true;
     }
@@ -913,9 +913,9 @@ bool has_collided_with_player_and_within_height(s32 objectIndex, Player* player,
     bool var_v1;
 
     var_v1 = false;
-    x = gObjectList[objectIndex].pos[0] - player->pos[0];
-    y = gObjectList[objectIndex].pos[1] - player->pos[1];
-    z = gObjectList[objectIndex].pos[2] - player->pos[2];
+    x = gObjectList[objectIndex].pos.x - player->pos.x;
+    y = gObjectList[objectIndex].pos.y - player->pos.y;
+    z = gObjectList[objectIndex].pos.z - player->pos.z;
     distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
     // abs(y)
     if (y < 0.0f) {
@@ -930,7 +930,7 @@ bool has_collided_with_player_and_within_height(s32 objectIndex, Player* player,
 f32 func_80088F54(s32 objectIndex, Player* player) {
     f32 distance;
 
-    distance = gObjectList[objectIndex].pos[1] - player->unk_074;
+    distance = gObjectList[objectIndex].pos.y - player->unk_074;
     // abs(distance)
     if (distance < 0.0f) {
         distance = -distance;
@@ -942,7 +942,7 @@ UNUSED bool func_80088F94(s32 objectIndex, Player* player, f32 arg2) {
     f32 distance;
     bool var_v1;
 
-    distance = gObjectList[objectIndex].pos[1] - player->unk_074;
+    distance = gObjectList[objectIndex].pos.y - player->unk_074;
     var_v1 = false;
     // abs(distance)
     if (distance < 0.0f) {
@@ -957,8 +957,8 @@ UNUSED bool func_80088F94(s32 objectIndex, Player* player, f32 arg2) {
 void func_80088FF0(Player* player) {
     player->unk_08C = 0.0f;
     player->currentSpeed = 0.0f;
-    player->velocity[0] = 0.0f;
-    player->velocity[2] = 0.0f;
+    player->velocity.x = 0.0f;
+    player->velocity.z = 0.0f;
 }
 
 UNUSED void func_8008900C(Player* player) {
@@ -1045,17 +1045,17 @@ f32 func_8008933C(Player* player, s32 objectIndex, f32 arg2, f32 arg3) {
         player->unk_046 |= 2;
         player->effects |= 0x8000;
         temp_v1->unk_18[6] = 4;
-        something = (player->pos[0] - object->pos[0]) * object->velocity[0];
+        something = (player->pos.x - object->pos.x) * object->velocity.x;
         if (something >= 0.0f) {
-            temp_v1->unk_04[0] = (-player->velocity[0] * arg2) + (object->velocity[0] * arg3);
+            temp_v1->unk_04[0] = (-player->velocity.x * arg2) + (object->velocity.x * arg3);
         } else {
-            temp_v1->unk_04[0] = -player->velocity[0] * arg2;
+            temp_v1->unk_04[0] = -player->velocity.x * arg2;
         }
-        something = (player->pos[2] - object->pos[2]) * object->velocity[2];
+        something = (player->pos.z - object->pos.z) * object->velocity.z;
         if (something >= 0.0f) {
-            temp_v1->unk_04[2] = (-player->velocity[2] * arg2) + (object->velocity[2] * arg3);
+            temp_v1->unk_04[2] = (-player->velocity.z * arg2) + (object->velocity.z * arg3);
         } else {
-            temp_v1->unk_04[2] = -player->velocity[2] * arg2;
+            temp_v1->unk_04[2] = -player->velocity.z * arg2;
         }
         var_f2 = (temp_v1->unk_04[0] * temp_v1->unk_04[0]) + (temp_v1->unk_04[2] * temp_v1->unk_04[2]);
     }
@@ -1260,7 +1260,7 @@ s32 func_8008A060(s32 objectIndex, Camera* camera, u16 arg2) {
     s32 var_v1;
 
     var_v1 = 0;
-    temp_t3 = (((u16) camera->rot[1] - gObjectList[objectIndex].direction_angle[1]) + (arg2 >> 1));
+    temp_t3 = (((u16) camera->rot.y - gObjectList[objectIndex].direction_angle[1]) + (arg2 >> 1));
 
     //! @warning Always true
     if ((temp_t3 >= 0) && (arg2 >= temp_t3)) {
@@ -1276,9 +1276,9 @@ s32 func_8008A0B4(s32 objectIndex, Player* player, Camera* camera, u16 arg3) {
     s32 var_t0;
 
     var_t0 = 0;
-    x_diff = gObjectList[objectIndex].pos[0] - player->pos[0];
-    z_diff = gObjectList[objectIndex].pos[2] - player->pos[2];
-    temp_t3 = ((u16) camera->rot[1] - atan2s(x_diff, z_diff)) + (arg3 >> 1);
+    x_diff = gObjectList[objectIndex].pos.x - player->pos.x;
+    z_diff = gObjectList[objectIndex].pos.z - player->pos.z;
+    temp_t3 = ((u16) camera->rot.y - atan2s(x_diff, z_diff)) + (arg3 >> 1);
     if ((temp_t3 >= 0) && (arg3 >= temp_t3)) {
         var_t0 = 1;
     }
@@ -1294,10 +1294,10 @@ bool is_object_visible_on_camera(s32 objectIndex, Camera* camera, u16 angle) {
     }
 
     var_t0 = false;
-    temp_t2 = (get_angle_between_xy(camera->pos[0], gObjectList[objectIndex].pos[0], camera->pos[2],
-                                    gObjectList[objectIndex].pos[2]) +
+    temp_t2 = (get_angle_between_xy(camera->pos.x, gObjectList[objectIndex].pos.x, camera->pos.z,
+                                    gObjectList[objectIndex].pos.z) +
                ((s32) angle / 2)) -
-              camera->rot[1];
+              camera->rot.y;
     if ((temp_t2 >= 0) && (angle >= temp_t2)) {
         var_t0 = true;
     }
@@ -1463,9 +1463,9 @@ void func_8008A920(s32 objectIndex) {
     SplineControlPoint* temp_v0;
 
     temp_v0 = gObjectList[objectIndex].controlPoints;
-    gObjectList[objectIndex].velocity[0] = (f32) (temp_v0[1].pos[0] - temp_v0[0].pos[0]) / (f32) temp_v0[0].velocity;
-    gObjectList[objectIndex].velocity[1] = (f32) (temp_v0[1].pos[1] - temp_v0[0].pos[1]) / (f32) temp_v0[0].velocity;
-    gObjectList[objectIndex].velocity[2] = (f32) (temp_v0[1].pos[2] - temp_v0[0].pos[2]) / (f32) temp_v0[0].velocity;
+    gObjectList[objectIndex].velocity.x = (f32) (temp_v0[1].pos.x - temp_v0[0].pos.x) / (f32) temp_v0[0].velocity;
+    gObjectList[objectIndex].velocity.y = (f32) (temp_v0[1].pos.y - temp_v0[0].pos.y) / (f32) temp_v0[0].velocity;
+    gObjectList[objectIndex].velocity.z = (f32) (temp_v0[1].pos.z - temp_v0[0].pos.z) / (f32) temp_v0[0].velocity;
 }
 
 void func_8008A9B8(s32 objectIndex) {
@@ -1491,9 +1491,9 @@ void func_8008AA3C(s32 objectIndex) {
     but for some unholy reason that doesn't match
     */
     object->unk_084[8] = *((s16*) object->controlPoints - 1);
-    object->offset[0] = object->controlPoints[0].pos[0];
-    object->offset[1] = object->controlPoints[0].pos[1];
-    object->offset[2] = object->controlPoints[0].pos[2];
+    object->offset[0] = object->controlPoints[0].pos.x;
+    object->offset[1] = object->controlPoints[0].pos.y;
+    object->offset[2] = object->controlPoints[0].pos.z;
     object->unk_09A = (s16) (10000 / object->controlPoints[0].velocity);
     func_8008A920(objectIndex);
     func_80086FD4(objectIndex);
@@ -1504,9 +1504,9 @@ void func_8008AB10(s32 objectIndex) {
     Object* object;
 
     object = &gObjectList[objectIndex];
-    object->offset[0] += object->velocity[0];
-    object->offset[1] += object->velocity[1];
-    object->offset[2] += object->velocity[2];
+    object->offset[0] += object->velocity.x;
+    object->offset[1] += object->velocity.y;
+    object->offset[2] += object->velocity.z;
     object->animationTimer += (u16) object->unk_09A;
     if (object->animationTimer >= 0x2710) {
         object->unk_084[9] = (u16) object->unk_084[9] + 1;
@@ -1595,11 +1595,11 @@ void func_8008AE9C(s32 objectIndex) {
     Object* object;
 
     object = &gObjectList[objectIndex];
-    object->velocity[0] = (D_80183DC8[0] * D_80165760[0]) + (D_80183DC8[1] * D_80165760[1]) +
+    object->velocity.x = (D_80183DC8[0] * D_80165760[0]) + (D_80183DC8[1] * D_80165760[1]) +
                           (D_80183DC8[2] * D_80165760[2]) + (D_80183DC8[3] * D_80165760[3]);
-    object->velocity[1] = (D_80183DC8[0] * D_80165770[0]) + (D_80183DC8[1] * D_80165770[1]) +
+    object->velocity.y = (D_80183DC8[0] * D_80165770[0]) + (D_80183DC8[1] * D_80165770[1]) +
                           (D_80183DC8[2] * D_80165770[2]) + (D_80183DC8[3] * D_80165770[3]);
-    object->velocity[2] = (D_80183DC8[0] * D_80165780[0]) + (D_80183DC8[1] * D_80165780[1]) +
+    object->velocity.z = (D_80183DC8[0] * D_80165780[0]) + (D_80183DC8[1] * D_80165780[1]) +
                           (D_80183DC8[2] * D_80165780[2]) + (D_80183DC8[3] * D_80165780[3]);
 }
 
@@ -1656,9 +1656,9 @@ void func_8008B1D4(s32 objectIndex) {
 
     test = gObjectList[objectIndex].controlPoints;
     for (someIndex = 0; someIndex < 4; someIndex++) {
-        D_80165760[someIndex] = test->pos[0];
-        D_80165770[someIndex] = test->pos[1];
-        D_80165780[someIndex] = test->pos[2];
+        D_80165760[someIndex] = test->pos.x;
+        D_80165770[someIndex] = test->pos.y;
+        D_80165780[someIndex] = test->pos.z;
         test++;
     }
 }
@@ -1683,9 +1683,9 @@ void func_8008B284(s32 objectIndex) {
         sp0 = 0;
     }
     for (someIndex = 0; someIndex < 4; someIndex++) {
-        D_80165760[someIndex] = test->pos[0];
-        D_80165770[someIndex] = test->pos[1];
-        D_80165780[someIndex] = test->pos[2];
+        D_80165760[someIndex] = test->pos.x;
+        D_80165770[someIndex] = test->pos.y;
+        D_80165780[someIndex] = test->pos.z;
         if (sp0 == someIndex) {
             // Reset back to start of the spline path
             test = gObjectList[objectIndex].spline->controlPoints;
@@ -1823,9 +1823,9 @@ void set_obj_origin_offset(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
 void func_8008B844(s32 objectIndex) {
     f32 temp_f0 = gObjectList[objectIndex].origin_pos[0];
 
-    gObjectList[objectIndex].pos[0] = gObjectList[objectIndex].offset[0] + temp_f0;
-    gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].offset[1] + temp_f0;
-    gObjectList[objectIndex].pos[2] = gObjectList[objectIndex].offset[2] + temp_f0;
+    gObjectList[objectIndex].pos.x = gObjectList[objectIndex].offset[0] + temp_f0;
+    gObjectList[objectIndex].pos.y = gObjectList[objectIndex].offset[1] + temp_f0;
+    gObjectList[objectIndex].pos.z = gObjectList[objectIndex].offset[2] + temp_f0;
 }
 
 void set_obj_direction_angle(s32 objectIndex, u16 arg1, u16 arg2, u16 arg3) {
@@ -1841,9 +1841,9 @@ void set_obj_orientation(s32 objectIndex, u16 arg1, u16 arg2, u16 arg3) {
 }
 
 void set_obj_velocity(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
-    gObjectList[objectIndex].velocity[0] = arg1;
-    gObjectList[objectIndex].velocity[1] = arg2;
-    gObjectList[objectIndex].velocity[2] = arg3;
+    gObjectList[objectIndex].velocity.x = arg1;
+    gObjectList[objectIndex].velocity.y = arg2;
+    gObjectList[objectIndex].velocity.z = arg3;
 }
 
 void func_8008B928(s32 objectIndex, s16 arg1, s16 arg2, s16 arg3, SplineData* spline) {
@@ -1854,11 +1854,11 @@ void func_8008B928(s32 objectIndex, s16 arg1, s16 arg2, s16 arg3, SplineData* sp
     object->origin_pos[1] = (f32) arg2;
     object->spline = spline;
     object->origin_pos[2] = (f32) arg3;
-    object->velocity[0] = (f32) (spline->controlPoints[1].pos[0] - spline->controlPoints[0].pos[0]);
-    object->velocity[1] = (f32) (spline->controlPoints[1].pos[1] - spline->controlPoints[0].pos[1]);
-    object->velocity[2] = (f32) (spline->controlPoints[1].pos[2] - spline->controlPoints[0].pos[2]);
+    object->velocity.x = (f32) (spline->controlPoints[1].pos.x - spline->controlPoints[0].pos.x);
+    object->velocity.y = (f32) (spline->controlPoints[1].pos.y - spline->controlPoints[0].pos.y);
+    object->velocity.z = (f32) (spline->controlPoints[1].pos.z - spline->controlPoints[0].pos.z);
     object->direction_angle[1] = get_y_direction_angle(objectIndex);
-    object->velocity[2] = func_800416D8(object->velocity[2], object->velocity[0], -object->direction_angle[1]);
+    object->velocity.z = func_800416D8(object->velocity.z, object->velocity.x, -object->direction_angle[1]);
     object->direction_angle[0] = get_x_direction_angle(objectIndex);
 }
 
@@ -1917,8 +1917,8 @@ void object_origin_pos_randomize_around_xyz(s32 objectIndex, s16 x, s16 y, s16 z
 }
 
 void object_origin_pos_around_player_one(s32 objectIndex, s16 dist, u16 angle) {
-    gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos[0] + (sins(angle) * dist);
-    gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos[2] + (coss(angle) * dist);
+    gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos.x + (sins(angle) * dist);
+    gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos.z + (coss(angle) * dist);
 }
 
 UNUSED void func_8008BEA4(s32 objectIndex, u16 arg1, u16 arg2) {
@@ -1926,31 +1926,31 @@ UNUSED void func_8008BEA4(s32 objectIndex, u16 arg1, u16 arg2) {
     u16 thing2;
 
     thing = random_int(arg1);
-    thing2 = camera1->rot[1] + random_int(arg2) - ((s32) arg2 / 2);
+    thing2 = camera1->rot.y + random_int(arg2) - ((s32) arg2 / 2);
     object_origin_pos_around_player_one(objectIndex, thing, thing2);
 }
 
 void object_calculate_new_pos_offset(s32 objectIndex) {
-    gObjectList[objectIndex].pos[0] = gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0];
-    gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
-    gObjectList[objectIndex].pos[2] = gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2];
+    gObjectList[objectIndex].pos.x = gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0];
+    gObjectList[objectIndex].pos.y = gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
+    gObjectList[objectIndex].pos.z = gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2];
 }
 
 void func_8008BF64(s32 objectIndex) {
     Object* object;
 
     object = &gObjectList[objectIndex];
-    D_80183E40[0] = object->pos[0];
-    D_80183E40[1] = object->pos[1];
-    D_80183E40[2] = object->pos[2];
+    D_80183E40[0] = object->pos.x;
+    D_80183E40[1] = object->pos.y;
+    D_80183E40[2] = object->pos.z;
     D_80183E80[0] = object->direction_angle[0];
     D_80183E80[1] = object->direction_angle[1];
     D_80183E80[2] = object->direction_angle[2];
 }
 
 void func_8008BFC0(s32 objectIndex) {
-    gObjectList[objectIndex].unk_09C = gObjectList[objectIndex].pos[0];
-    gObjectList[objectIndex].unk_09E = gObjectList[objectIndex].pos[1];
+    gObjectList[objectIndex].unk_09C = gObjectList[objectIndex].pos.x;
+    gObjectList[objectIndex].unk_09E = gObjectList[objectIndex].pos.y;
 }
 
 void func_8008BFFC(s32 objectIndex) {
diff --git a/src/code_80091440.c b/src/code_80091440.c
index 2b8b49aff..bd8d905cf 100644
--- a/src/code_80091440.c
+++ b/src/code_80091440.c
@@ -43,18 +43,18 @@ UNUSED void func_800914E0(void) {
     }
     tempData = sp48 + D_80152308;
 
-    camera->pos[0] = (f32) (tempData->pos[0] + 10);
-    camera->pos[1] = (f32) (tempData->pos[1] + 7);
-    camera->pos[2] = (f32) (tempData->pos[2] - 20);
-    camera->lookAt[0] = gPlayerOneCopy->pos[0];
+    camera->pos.x = (f32) (tempData->pos.x + 10);
+    camera->pos.y = (f32) (tempData->pos.y + 7);
+    camera->pos.z = (f32) (tempData->pos.z - 20);
+    camera->lookAt.x = gPlayerOneCopy->pos.x;
 
-    camera->lookAt[1] = gPlayerOneCopy->pos[1];
-    camera->lookAt[2] = gPlayerOneCopy->pos[2];
-    check_bounding_collision(&camera->collision, 20.0f, camera->pos[0], camera->pos[1], camera->pos[2]);
-    sp38 = camera->lookAt[0] - camera->pos[0];
-    sp34 = camera->lookAt[1] - camera->pos[1];
-    sp30 = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(sp38, sp30);
-    camera->rot[0] = atan2s(sqrtf((sp38 * sp38) + (sp30 * sp30)), sp34);
-    camera->rot[2] = 0;
+    camera->lookAt.y = gPlayerOneCopy->pos.y;
+    camera->lookAt.z = gPlayerOneCopy->pos.z;
+    check_bounding_collision(&camera->collision, 20.0f, camera->pos.x, camera->pos.y, camera->pos.z);
+    sp38 = camera->lookAt.x - camera->pos.x;
+    sp34 = camera->lookAt.y - camera->pos.y;
+    sp30 = camera->lookAt.z - camera->pos.z;
+    camera->rot.y = atan2s(sp38, sp30);
+    camera->rot.x = atan2s(sqrtf((sp38 * sp38) + (sp30 * sp30)), sp34);
+    camera->rot.z = 0;
 }
diff --git a/src/debug/debug.inc.c b/src/debug/debug.inc.c
index 983afea95..d84e6d590 100644
--- a/src/debug/debug.inc.c
+++ b/src/debug/debug.inc.c
@@ -14,9 +14,9 @@ variableWatchAttributes gMainVariableWatchList[] = {
     { "Global Timer: ", &gGlobalTimer, sizeof(gGlobalTimer), DISPLAY_DECIMAL_NUMBER | DISPLAY_SIGNED_NUMBER, 0, 0 },
     { "Actors: ", &gNumActors, sizeof(gNumActors), DISPLAY_DECIMAL_NUMBER, 0, 0 },
     { "Player Type: ", &gPlayers[0].type, sizeof(gPlayerOne->type), DISPLAY_HEXIDECIMAL_NUMBER, 0, 0 },
-    { "X ", &gPlayers[0].pos[0], sizeof(gPlayerOne->pos[0]), DISPLAY_FLOAT_NUMBER, 0, 0 },
-    { "Y ", &gPlayers[0].pos[1], sizeof(gPlayerOne->pos[1]), DISPLAY_FLOAT_NUMBER, 0, 0 },
-    { "Z ", &gPlayers[0].pos[2], sizeof(gPlayerOne->pos[2]), DISPLAY_FLOAT_NUMBER, 0, 0 },
+    { "X ", &gPlayers[0].pos.x, sizeof(gPlayerOne->pos.x), DISPLAY_FLOAT_NUMBER, 0, 0 },
+    { "Y ", &gPlayers[0].pos.y, sizeof(gPlayerOne->pos.y), DISPLAY_FLOAT_NUMBER, 0, 0 },
+    { "Z ", &gPlayers[0].pos.z, sizeof(gPlayerOne->pos.z), DISPLAY_FLOAT_NUMBER, 0, 0 },
     { "Torque 9C: ", &gPlayers[0].currentSpeed, sizeof(gPlayerOne->currentSpeed), DISPLAY_FLOAT_NUMBER, 0, 0 },
     { "Top Speed 214: ", &gPlayers[0].topSpeed, sizeof(gPlayerOne->topSpeed), DISPLAY_FLOAT_NUMBER, 0, 0 },
     { "Accel Offset C4: ", &gPlayers[0].slopeAccel, sizeof(gPlayerOne->slopeAccel), DISPLAY_SIGNED_NUMBER, 0, 0 },
diff --git a/src/effects.c b/src/effects.c
index 06e476117..99c1e1469 100644
--- a/src/effects.c
+++ b/src/effects.c
@@ -762,7 +762,7 @@ void apply_hit_effect(Player* player, s8 arg1) {
             break;
         case 1:
             player->unk_DB4.unk10 = 4.5f;
-            player->pos[1] += 0.13;
+            player->pos.y += 0.13;
             ++player->unk_238;
 
             if ((player->unk_046 & 0x80) != 0) {
@@ -799,7 +799,7 @@ void apply_hit_effect(Player* player, s8 arg1) {
             }
 
             player->unk_DB4.unk10 = 4.5f;
-            player->pos[1] -= 0.085;
+            player->pos.y -= 0.085;
 
             if ((player->effects & 8) != 8) {
                 D_8018D990[arg1] = 3;
@@ -940,8 +940,8 @@ void func_8008E4A4(Player* player, s8 arg1) {
     player->unk_042 += 0xAAA;
     player->unk_08C = 0.0f;
     player->currentSpeed = 0.0f;
-    player->velocity[0] = 0.0f;
-    player->velocity[2] = 0.0f;
+    player->velocity.x = 0.0f;
+    player->velocity.z = 0.0f;
     player->effects &= ~0xC0;
 
     if ((player->effects & 8) != 8) {
@@ -1837,18 +1837,18 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
                         player->unk_0C8 = 0x003C;
                     }
                 } else {
-                    move_f32_towards(&player->pos[1], D_801652A0[playerId] + 100.0f, 0.012f);
+                    move_f32_towards(&player->pos.y, D_801652A0[playerId] + 100.0f, 0.012f);
                     move_s16_towards(&player->unk_0CC[arg2], 0, 0.2f);
-                    if ((D_801652A0[playerId] + 40.0f) <= player->pos[1]) {
+                    if ((D_801652A0[playerId] + 40.0f) <= player->pos.y) {
                         player->unk_222 = 1;
                         player->unk_0CA |= 4;
                         player->unk_0C6 = 0x00FF;
                     }
                 }
             } else if ((player->unk_0CA & 2) == 2) {
-                move_f32_towards(&player->pos[1], player->unk_074 + 100.0f, 0.025f);
+                move_f32_towards(&player->pos.y, player->unk_074 + 100.0f, 0.025f);
                 move_s16_towards(&player->unk_0CC[arg2], 0, 0.2f);
-                if ((player->unk_074 + 40.0f) <= player->pos[1]) {
+                if ((player->unk_074 + 40.0f) <= player->pos.y) {
                     player->unk_222 = 1;
                     player->unk_0CA |= 4;
                     player->unk_0C6 = 0x00FF;
@@ -1863,7 +1863,7 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
                 func_8009E088(playerId, 0xA);
             }
             if ((player->unk_0CA & 1) == 1) {
-                move_f32_towards(&player->pos[1], D_801652A0[playerId] + 40.0f, 0.02f);
+                move_f32_towards(&player->pos.y, D_801652A0[playerId] + 40.0f, 0.02f);
                 player->unk_0C6 -= 8;
                 if (player->unk_0C6 < 9) {
                     player->unk_0C6 = 0;
@@ -1871,7 +1871,7 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
                     player->unk_0CA &= ~0x0001;
                 }
             } else {
-                move_f32_towards(&player->pos[1], player->oldPos[1] + 40.0f, 0.02f);
+                move_f32_towards(&player->pos.y, player->oldPos[1] + 40.0f, 0.02f);
                 player->unk_0C6 -= 8;
                 if (player->unk_0C6 < 9) {
                     player->unk_0C6 = 0;
@@ -1884,9 +1884,9 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
             func_80090178(player, playerId, sp44, sp38);
             // Fakematch found by Verti, who knows what's going on here
             player->rotation[1] = (u16) -get_angle_between_two_vectors(sp44, sp38) & 0xFFFF;
-            player->pos[0] = sp44[0];
-            player->pos[1] = sp44[1] + 40.0f;
-            player->pos[2] = sp44[2];
+            player->pos.x = sp44[0];
+            player->pos.y = sp44[1] + 40.0f;
+            player->pos.z = sp44[2];
             player->unk_222 = 3;
             break;
         case 3:
@@ -1895,11 +1895,11 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
                 func_8009E020(playerId, 0x14);
             }
             func_80090178(player, playerId, sp44, sp38);
-            player->pos[0] = sp44[0];
-            player->pos[1] = sp44[1] + 40.0f;
-            player->pos[2] = sp44[2];
-            player->pos[2] = player->pos[2] + coss((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
-            player->pos[0] = player->pos[0] + sins((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
+            player->pos.x = sp44[0];
+            player->pos.y = sp44[1] + 40.0f;
+            player->pos.z = sp44[2];
+            player->pos.z = player->pos.z + coss((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
+            player->pos.x = player->pos.x + sins((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
             player->unk_0C6 += 8;
             if (player->unk_0C6 >= 0xF0) {
                 player->unk_0C6 = 0x00FF;
@@ -1910,16 +1910,16 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
             break;
         case 4:
             if ((player->unk_0C8 == 0x0096) || (player->unk_0C8 == 0x00C8) || (player->unk_0C8 == 0x00FA)) {
-                player->pos[2] = player->pos[2] + coss(-player->rotation[1]) * -10.0f;
-                player->pos[0] = player->pos[0] + sins(-player->rotation[1]) * -10.0f;
+                player->pos.z = player->pos.z + coss(-player->rotation[1]) * -10.0f;
+                player->pos.x = player->pos.x + sins(-player->rotation[1]) * -10.0f;
             }
             if (player->unk_0C8 == 0x00FC) {
                 waypoint = D_80164550[0];
-                player->pos[0] = waypoint->posX;
-                player->pos[1] = waypoint->posY;
-                player->pos[2] = waypoint->posZ;
+                player->pos.x = waypoint->posX;
+                player->pos.y = waypoint->posY;
+                player->pos.z = waypoint->posZ;
             }
-            move_f32_towards(&player->pos[1], (player->unk_074 + player->boundingBoxSize) - 2.0f, 0.04f);
+            move_f32_towards(&player->pos.y, (player->unk_074 + player->boundingBoxSize) - 2.0f, 0.04f);
             player->unk_0C8++;
             if (((player->effects & 8) != 8) || (player->effects & 0x8000)) {
                 player->unk_0CA &= ~0x1000;
@@ -2062,8 +2062,8 @@ void func_80091298(Player* player, s8 arg1) {
             player->unk_0B2 = 0;
         }
         if (player->unk_0B2 == 0) {
-            if ((player->pos[1] - (player->boundingBoxSize + 1.0f)) <= spC[arg1]) {
-                player->pos[1] = (f32) ((f64) (spC[arg1] + player->boundingBoxSize) + 1.08);
+            if ((player->pos.y - (player->boundingBoxSize + 1.0f)) <= spC[arg1]) {
+                player->pos.y = (f32) ((f64) (spC[arg1] + player->boundingBoxSize) + 1.08);
                 player->unk_DB4.unk18 = 0;
                 player->unk_0A8 = 0;
                 player->unk_07C = 0;
diff --git a/src/ending/camera_junk.c b/src/ending/camera_junk.c
index 7edb587a7..954263545 100644
--- a/src/ending/camera_junk.c
+++ b/src/ending/camera_junk.c
@@ -17,25 +17,25 @@ void update_camera_podium_ceremony(void) {
     camera = &cameras[0];
     func_80283648(camera);
 
-    x_dist = camera->lookAt[0] - camera->pos[0];
-    y_dist = camera->lookAt[1] - camera->pos[1];
-    z_dist = camera->lookAt[2] - camera->pos[2];
-    camera->rot[1] = atan2s(x_dist, z_dist);
-    camera->rot[0] = atan2s(sqrtf((x_dist * x_dist) + (z_dist * z_dist)), y_dist);
-    camera->rot[2] = 0;
+    x_dist = camera->lookAt.x - camera->pos.x;
+    y_dist = camera->lookAt.y - camera->pos.y;
+    z_dist = camera->lookAt.z - camera->pos.z;
+    camera->rot.x = atan2s(x_dist, z_dist);
+    camera->rot.y = atan2s(sqrtf((x_dist * x_dist) + (z_dist * z_dist)), y_dist);
+    camera->rot.z = 0;
 }
 
 // GP podium ceremony camera settings?
 void init_camera_podium_ceremony(void) {
-    cameras[0].pos[0] = -3133.0f;
-    cameras[0].pos[1] = 19.0f;
-    cameras[0].pos[2] = -467.0f;
-    cameras[0].lookAt[0] = -3478.0f;
-    cameras[0].lookAt[1] = 21.0f;
-    cameras[0].lookAt[2] = -528.0f;
-    cameras[0].up[0] = 0.0f;
-    cameras[0].up[1] = 1.0f;
-    cameras[0].up[2] = 0.0f;
+    cameras[0].pos.x = -3133.0f;
+    cameras[0].pos.y = 19.0f;
+    cameras[0].pos.z = -467.0f;
+    cameras[0].lookAt.x = -3478.0f;
+    cameras[0].lookAt.y = 21.0f;
+    cameras[0].lookAt.z = -528.0f;
+    cameras[0].up.x = 0.0f;
+    cameras[0].up.y = 1.0f;
+    cameras[0].up.z = 0.0f;
     gCameraZoom[0] = 40.0f;
     gScreenAspect = 1.33333333f;
     D_80150150 = 3.0f;
diff --git a/src/ending/ceremony_and_credits.c b/src/ending/ceremony_and_credits.c
index fd8b2405c..fc092abe7 100644
--- a/src/ending/ceremony_and_credits.c
+++ b/src/ending/ceremony_and_credits.c
@@ -427,8 +427,8 @@ void func_80282F44(s32 arg0, CinematicCamera* arg1, Camera* camera) {
     Vec3f pos;
     Vec3f lookat;
 
-    vec3f_set_dupe(pos, camera->pos[0], camera->pos[1], camera->pos[2]);
-    vec3f_set_dupe(lookat, camera->lookAt[0], camera->lookAt[1], camera->lookAt[2]);
+    vec3f_set_dupe(pos, camera->pos.x, camera->pos.y, camera->pos.z);
+    vec3f_set_dupe(lookat, camera->lookAt.x, camera->lookAt.y, camera->lookAt.z);
     if ((arg0 == 0) || (arg0 == 1)) {
         if ((arg1->unk48[0] != 0) || (arg1->unk48[1] != 0)) {
             calculate_distance_angle_y_and_angle_y_to_xz(pos, lookat, &distance, &angleCam[0], &angleCam[1]);
@@ -441,9 +441,9 @@ void func_80282F44(s32 arg0, CinematicCamera* arg1, Camera* camera) {
                 arg1->unk4E[arg0] = 0;
             }
         }
-        camera->lookAt[0] = lookat[0];
-        camera->lookAt[1] = lookat[1];
-        camera->lookAt[2] = lookat[2];
+        camera->lookAt.x = lookat[0];
+        camera->lookAt.y = lookat[1];
+        camera->lookAt.z = lookat[2];
     }
 }
 
@@ -627,8 +627,8 @@ s32 func_80283648(Camera* camera) {
         vec3f_copy_return_dupe(camera->pos, cinematicCamera->lookAt);
         vec3f_copy_return_dupe(camera->lookAt, cinematicCamera->pos);
         if ((gGamestate == CREDITS_SEQUENCE) && (gIsMirrorMode != 0)) {
-            camera->pos[0] = -camera->pos[0];
-            camera->lookAt[0] = -camera->lookAt[0];
+            camera->pos.x = -camera->pos.x;
+            camera->lookAt.x = -camera->lookAt.x;
         }
     }
     func_80282F44(0, cinematicCamera, camera);
@@ -947,9 +947,9 @@ void copy_player_two_in_camera(CinematicCamera* camera) {
 }
 
 void lerp_player_two_in_camera(CinematicCamera* camera) {
-    f32_lerp(&camera->pos[0], gPlayerTwo->pos[0], 0.12f);
-    f32_lerp(&camera->pos[1], gPlayerTwo->pos[1], 0.12f);
-    f32_lerp(&camera->pos[2], gPlayerTwo->pos[2], 0.12f);
+    f32_lerp(&camera->pos.x, gPlayerTwo->pos.x, 0.12f);
+    f32_lerp(&camera->pos.y, gPlayerTwo->pos.y, 0.12f);
+    f32_lerp(&camera->pos.z, gPlayerTwo->pos.z, 0.12f);
 }
 
 void func_80283F6C(CinematicCamera* camera) {
@@ -963,9 +963,9 @@ void copy_player_three_in_camera(CinematicCamera* camera) {
 }
 
 void lerp_player_three_in_camera(CinematicCamera* camera) {
-    f32_lerp(&camera->pos[0], gPlayerThree->pos[0], 0.12f);
-    f32_lerp(&camera->pos[1], gPlayerThree->pos[1], 0.12f);
-    f32_lerp(&camera->pos[2], gPlayerThree->pos[2], 0.12f);
+    f32_lerp(&camera->pos.x, gPlayerThree->pos.x, 0.12f);
+    f32_lerp(&camera->pos.y, gPlayerThree->pos.y, 0.12f);
+    f32_lerp(&camera->pos.z, gPlayerThree->pos.z, 0.12f);
 }
 
 void func_80284068(CinematicCamera* camera) {
@@ -999,8 +999,8 @@ void func_80284184(CinematicCamera* camera) {
     f32 trophy;
 
     if (gTrophyIndex != NULL) {
-        trophy = ((gObjectList[gTrophyIndex].pos[1] - camera->lookAt[1]) * 0.9f) + camera->lookAt[1];
-        f32_lerp(&camera->pos[1], trophy, 0.5);
+        trophy = ((gObjectList[gTrophyIndex].pos.y - camera->lookAt.y) * 0.9f) + camera->lookAt.y;
+        f32_lerp(&camera->pos.y, trophy, 0.5);
     }
 }
 
@@ -1039,16 +1039,16 @@ void func_80284308(CinematicCamera* camera) {
 
     ply = *(sp30[0] + D_802874D8.unk1D);
 
-    x = ply->pos[0] - gPlayerOne->pos[0];
-    y = ply->pos[1] - gPlayerOne->pos[1];
-    z = ply->pos[2] - gPlayerOne->pos[2];
+    x = ply->pos.x - gPlayerOne->pos.x;
+    y = ply->pos.y - gPlayerOne->pos.y;
+    z = ply->pos.z - gPlayerOne->pos.z;
 
-    camera->lookAt[0] += x;
-    camera->lookAt[2] += z;
-    camera->pos[0] += x;
-    camera->pos[2] += z;
-    camera->lookAt[1] += y;
-    camera->pos[1] += y;
+    camera->lookAt.x += x;
+    camera->lookAt.z += z;
+    camera->pos.x += x;
+    camera->pos.z += z;
+    camera->lookAt.y += y;
+    camera->pos.y += y;
 }
 
 struct struct_80282C40 D_80285A10[] = {
@@ -1225,12 +1225,12 @@ void func_802846E4(CinematicCamera* camera) {
 
     move_cinematic_camera_along_spline(camera, (struct struct_80286A04*) D_80285CB0,
                                        (struct struct_80286A04*) D_80285CE0, 0);
-    camera->lookAt[0] += (gPlayerFour->pos[0] - -2796.0f); // <-- rodata
-    camera->lookAt[1] += (gPlayerFour->pos[1] - -29.0f);
-    camera->lookAt[2] += (gPlayerFour->pos[2] - -97.0f);
-    camera->pos[0] += (gPlayerFour->pos[0] - -2796.0f);
-    camera->pos[1] += (gPlayerFour->pos[1] - -29.0f);
-    camera->pos[2] += (gPlayerFour->pos[2] - -97.0f);
+    camera->lookAt.x += (gPlayerFour->pos.x - -2796.0f); // <-- rodata
+    camera->lookAt.y += (gPlayerFour->pos.y - -29.0f);
+    camera->lookAt.z += (gPlayerFour->pos.z - -97.0f);
+    camera->pos.x += (gPlayerFour->pos.x - -2796.0f);
+    camera->pos.y += (gPlayerFour->pos.y - -29.0f);
+    camera->pos.z += (gPlayerFour->pos.z - -97.0f);
 }
 
 struct Cutscene D_80285D58[] = {
diff --git a/src/ending/code_80280000.c b/src/ending/code_80280000.c
index be1706ed5..533b9d991 100644
--- a/src/ending/code_80280000.c
+++ b/src/ending/code_80280000.c
@@ -61,8 +61,8 @@ void func_80280038(void) {
     gSPPerspNormalize(gDisplayListHead++, perspNorm);
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxPersp[0]),
               G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
-    guLookAt(&gGfxPool->mtxLookAt[0], camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0],
-             camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
+    guLookAt(&gGfxPool->mtxLookAt[0], camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x,
+             camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxLookAt[0]),
               G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
     gCurrentCourseId = gCreditsCourseId;
@@ -110,12 +110,12 @@ void credits_loop(void) {
 
         D_802874FC = 0;
         func_80283648(camera);
-        temp_f12 = camera->lookAt[0] - camera->pos[0];
-        temp = camera->lookAt[1] - camera->pos[1];
-        temp_f14 = camera->lookAt[2] - camera->pos[2];
-        camera->rot[1] = atan2s(temp_f12, temp_f14);
-        camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), temp);
-        camera->rot[2] = 0;
+        temp_f12 = camera->lookAt.x - camera->pos.x;
+        temp = camera->lookAt.y - camera->pos.y;
+        temp_f14 = camera->lookAt.z - camera->pos.z;
+        camera->rot.y = atan2s(temp_f12, temp_f14);
+        camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), temp);
+        camera->rot.z = 0;
         if (D_802874A0 != 0) {
             D_800DC5E4++;
         } else {
@@ -168,12 +168,12 @@ void load_credits(void) {
     D_800DC5BC = 0;
     D_800DC5C8 = 0;
     gCollisionMesh = (CollisionTriangle*) gNextFreeMemoryAddress;
-    camera->pos[0] = 1400.0f;
-    camera->pos[1] = 300.0f;
-    camera->pos[2] = 1400.0f;
-    camera->lookAt[0] = 0.0f;
-    camera->lookAt[1] = 0.0f;
-    camera->lookAt[2] = 0.0f;
+    camera->pos.x = 1400.0f;
+    camera->pos.y = 300.0f;
+    camera->pos.z = 1400.0f;
+    camera->lookAt.x = 0.0f;
+    camera->lookAt.y = 0.0f;
+    camera->lookAt.z = 0.0f;
     camera->up[0] = 0.0f;
     camera->up[1] = 1.0f;
     camera->up[2] = 0.0f;
diff --git a/src/ending/code_80281C40.c b/src/ending/code_80281C40.c
index 18507f23b..97418d3ea 100644
--- a/src/ending/code_80281C40.c
+++ b/src/ending/code_80281C40.c
@@ -77,8 +77,8 @@ void func_80281D00(void) {
     gSPPerspNormalize(gDisplayListHead++, perspNorm);
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxPersp[0]),
               G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
-    guLookAt((Mtx*) &gGfxPool->mtxLookAt[0], camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0],
-             camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
+    guLookAt((Mtx*) &gGfxPool->mtxLookAt[0], camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x,
+             camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxLookAt[0]),
               G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
     mtxf_identity(matrix);
diff --git a/src/ending/podium_ceremony_actors.c b/src/ending/podium_ceremony_actors.c
index 1e3911287..60e9386ae 100644
--- a/src/ending/podium_ceremony_actors.c
+++ b/src/ending/podium_ceremony_actors.c
@@ -83,9 +83,9 @@ void func_80280650(void) {
 void set_initial_position(CeremonyActor* actor) {
     ActorInitParams* params = actor->initParams;
 
-    actor->pos[0] = params->unk2[0];
-    actor->pos[1] = params->unk2[1];
-    actor->pos[2] = params->unk2[2];
+    actor->pos.x = params->unk2[0];
+    actor->pos.y = params->unk2[1];
+    actor->pos.z = params->unk2[2];
 
     // Place value in the high bits of s16.
     // Example: 85, 0b01010101 -> 0b0101010100000000
@@ -174,7 +174,7 @@ void func_80280884(void) {
 
 void balloon_update(CeremonyActor* actor) {
     render_balloon(actor->pos, 1.0f, actor->unk2E, actor->unk2C);
-    actor->pos[1] += 0.8f;
+    actor->pos.y += 0.8f;
     actor->unk2E = sins(actor->unk30) * actor->unk34;
     actor->unk30 += actor->unk32;
     actor->timer++;
@@ -194,14 +194,14 @@ void balloon_update(CeremonyActor* actor) {
  */
 void firework_cone_update_and_spawn_burst(Firework* cone) {
     if (cone->unk44 < 30) {
-        cone->pos[1] += 2.5f;
-        cone->pos[0] += random_who_knows(0.2f);
-        cone->pos[2] += random_who_knows(0.2f);
+        cone->pos.y += 2.5f;
+        cone->pos.x += random_who_knows(0.2f);
+        cone->pos.z += random_who_knows(0.2f);
     } else if (cone->unk2C == 4) {
         Firework* burst = (Firework*) new_actor(&initCone);
-        burst->pos[0] = cone->pos[0];
-        burst->pos[1] = cone->pos[1];
-        burst->pos[2] = cone->pos[2];
+        burst->pos.x = cone->pos.x;
+        burst->pos.y = cone->pos.y;
+        burst->pos.z = cone->pos.z;
         burst->unk30 = fireworkConeColour[cone->unk48];
         burst->unk3C = 0xFF;
         burst->unk40 = -0x11;
@@ -243,7 +243,7 @@ void render_fireworks(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
     sp4C[1] = arg0[1];
     sp4C[2] = arg0[2];
     sp44[0] = 0;
-    sp44[1] = camera1->rot[1];
+    sp44[1] = camera1->rot.y;
     sp44[2] = 0;
     func_80280A28(sp4C, sp44, arg1);
     gSPDisplayList(gDisplayListHead++, D_0D008DB8);
@@ -264,9 +264,9 @@ void firework_update(Firework* actor) {
     Vec3f pos;
     if (actor->unk44 < 30) {
         for (i = 0; i < 10; i++) {
-            pos[0] = actor->pos[0];
-            pos[1] = actor->pos[1] - i * 2;
-            pos[2] = actor->pos[2];
+            pos.x = actor->pos.x;
+            pos.y = actor->pos.y - i * 2;
+            pos.z = actor->pos.z;
             render_fireworks(pos, ((10 - i) / 10.0f) * 2, fireworkColour[actor->unk48],
                              (((((30 - actor->unk44) * 100)) / 30.0f)));
         }
@@ -322,9 +322,9 @@ void spawn_balloons(s32 arg0, s32 arg1, s32 arg2) {
     for (i = 0; i < 100; i++) {
         CeremonyActor* balloon;
         balloon = new_actor(&initBalloon);
-        balloon->pos[0] = random_who_knows(200.0f) + arg0;
-        balloon->pos[1] = random_who_knows(380.0f) + arg1;
-        balloon->pos[2] = random_who_knows(600.0f) + arg2;
+        balloon->pos.x = random_who_knows(200.0f) + arg0;
+        balloon->pos.y = random_who_knows(380.0f) + arg1;
+        balloon->pos.z = random_who_knows(600.0f) + arg2;
         balloon->unk2C = (s16) (s32) (random_float_between_0_and_1() * 7.0f);
         balloon->unk30 = random_u16_credits();
         balloon->unk32 = (s16) (s32) (random_who_knows(400.0f) + 900.0f);
@@ -349,9 +349,9 @@ void spawn_firework_cone(s32 arg0, s32 arg1, s32 arg2) {
     if (((f32) random_float_between_0_and_1() * (D_802874B0[7] + 0xD)) < 1.0f) {
         Firework* cone;
         cone = (Firework*) new_actor(&initBurst);
-        cone->pos[0] = random_who_knows(0.0f) + arg0;
-        cone->pos[1] = random_who_knows((f32) (D_802874B0[11] + 100)) + (f32) arg1;
-        cone->pos[2] = random_who_knows((f32) (D_802874B0[12] + 700)) + (f32) arg2;
+        cone->pos.x = random_who_knows(0.0f) + arg0;
+        cone->pos.y = random_who_knows((f32) (D_802874B0[11] + 100)) + (f32) arg1;
+        cone->pos.z = random_who_knows((f32) (D_802874B0[12] + 700)) + (f32) arg2;
 
         num = 1.1f;
 
@@ -377,12 +377,12 @@ void spawn_timer(void) {
     Camera* camera = &cameras[0];
     f32 lookAtY;
 
-    guLookAtF(D_80287500, camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0], camera->lookAt[1],
-              camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
+    guLookAtF(D_80287500, camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x, camera->lookAt.y,
+              camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
     if (D_802874D8.unk1D < 3) {
         if (D_802874D8.actorTimer < 300) {
-            lookAtY = camera->lookAt[1];
-            spawn_firework_cone(-0xE0E, (s32) (((lookAtY - camera->pos[1]) * 1.5f) + lookAtY), -0x258);
+            lookAtY = camera->lookAt.y;
+            spawn_firework_cone(-0xE0E, (s32) (((lookAtY - camera->pos.y) * 1.5f) + lookAtY), -0x258);
         }
         if (D_802874D8.actorTimer == 120) {
             spawn_balloons(-0xC6C, (s32) ((f32) D_802874B0[10] + 210.0f), -0x1EF);
diff --git a/src/engine/PlayerBombKart.cpp b/src/engine/PlayerBombKart.cpp
index 9ab3b74e1..cb448f3d1 100644
--- a/src/engine/PlayerBombKart.cpp
+++ b/src/engine/PlayerBombKart.cpp
@@ -14,9 +14,9 @@ extern "C" {
 void PlayerBombKart::Draw(size_t playerId, s32 cameraId) { // render_player_bomb_kart
     Player* player = &gPlayerOne[playerId];
     if (state != PlayerBombKartState::DISABLED) {
-        pos.x = player->pos[0];
-        pos.y = player->pos[1] - 2.0;
-        pos.z = player->pos[2];
+        pos.x = player->pos.x;
+        pos.y = player->pos.y - 2.0;
+        pos.z = player->pos.z;
         surfaceHeight = player->unk_074;
         PlayerBombKart::func_800563DC(cameraId, _primAlpha);
         PlayerBombKart::func_8005669C(_primAlpha);
diff --git a/src/engine/TrainCrossing.cpp b/src/engine/TrainCrossing.cpp
index 8dce6984b..0b1f9b632 100644
--- a/src/engine/TrainCrossing.cpp
+++ b/src/engine/TrainCrossing.cpp
@@ -15,9 +15,9 @@ extern "C" {
 }
 
 TrainCrossing::TrainCrossing(Vec3f position, u32 waypointMin, u32 waypointMax, f32 approachRadius, f32 exitRadius) {
-    Position[0] = position[0] * xOrientation;
-    Position[1] = position[1];
-    Position[2] = position[2];
+    Position[0] = position.x * xOrientation;
+    Position[1] = position.y;
+    Position[2] = position.z;
     ApproachRadius = approachRadius;
     ExitRadius = exitRadius;
     WaypointMin = waypointMin;
diff --git a/src/engine/actors/BowserStatue.cpp b/src/engine/actors/BowserStatue.cpp
index c680c4c25..e1d4dd083 100644
--- a/src/engine/actors/BowserStatue.cpp
+++ b/src/engine/actors/BowserStatue.cpp
@@ -30,9 +30,9 @@ void ABowserStatue::Tick() {
 void ABowserStatue::Draw(Camera *camera) {
     Mat4 mtx;
     Vec3f pos;
-    pos[0] = Pos.x + 76;
-    pos[1] = Pos.y;
-    pos[2] = Pos.z + 1846;
+    pos.x = Pos.x + 76;
+    pos.y = Pos.y;
+    pos.z = Pos.z + 1846;
     gSPSetGeometryMode(gDisplayListHead++, G_SHADING_SMOOTH);
     gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
 
diff --git a/src/engine/actors/Finishline.cpp b/src/engine/actors/Finishline.cpp
index 0680e60bd..b066c5f5b 100644
--- a/src/engine/actors/Finishline.cpp
+++ b/src/engine/actors/Finishline.cpp
@@ -60,7 +60,7 @@ void AFinishline::Draw(Camera *camera) {
         return;
     }
 
-    if (temp < camera->pos[2]) {
+    if (temp < camera->pos.z) {
         if (D_800DC5BC != 0) {
 
             gDPSetFogColor(gDisplayListHead++, D_801625EC, D_801625F4, D_801625F0, 0xFF);
diff --git a/src/engine/actors/MarioSign.cpp b/src/engine/actors/MarioSign.cpp
index f39e4f69b..186721672 100644
--- a/src/engine/actors/MarioSign.cpp
+++ b/src/engine/actors/MarioSign.cpp
@@ -41,7 +41,7 @@ void AMarioSign::Draw(Camera *camera) {
         return;
     }
 
-    unk = is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 16000000.0f);
+    unk = is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 16000000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         unk = MAX(unk, 0.0f);
     }
diff --git a/src/engine/actors/Tree.cpp b/src/engine/actors/Tree.cpp
index faffd0798..83366f7fd 100644
--- a/src/engine/actors/Tree.cpp
+++ b/src/engine/actors/Tree.cpp
@@ -11,9 +11,9 @@ extern "C" {
 
 ATree::ATree(Vec3f pos, Gfx* displaylist, f32 drawDistance, f32 minDrawDistance, const char* tlut = nullptr) {
     Name = "Tree";
-    Pos[0] = pos[0];
-    Pos[1] = pos[1];
-    Pos[2] = pos[2];
+    Pos[0] = pos.x;
+    Pos[1] = pos.y;
+    Pos[2] = pos.z;
 
     Displaylist = displaylist;
     Tlut = tlut;
@@ -37,7 +37,7 @@ void ATree::Draw(Camera* camera) {
         return;
     }
 
-    dist = is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
+    dist = is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
                                         DrawDistance);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
diff --git a/src/engine/actors/WarioSign.cpp b/src/engine/actors/WarioSign.cpp
index 0e83e114f..da83bad6b 100644
--- a/src/engine/actors/WarioSign.cpp
+++ b/src/engine/actors/WarioSign.cpp
@@ -25,7 +25,7 @@ void AWarioSign::Tick() {
 void AWarioSign::Draw(Camera *camera) {
     Mat4 sp38;
     f32 unk =
-        is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 16000000.0f);
+        is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 16000000.0f);
 
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         unk = MAX(unk, 0.0f);
diff --git a/src/engine/courses/BansheeBoardwalk.cpp b/src/engine/courses/BansheeBoardwalk.cpp
index 51049fb8d..6ad317d55 100644
--- a/src/engine/courses/BansheeBoardwalk.cpp
+++ b/src/engine/courses/BansheeBoardwalk.cpp
@@ -298,13 +298,13 @@ void BansheeBoardwalk::Render(struct UnkStruct_800DC5EC* arg0) {
     // d_course_banshee_boardwalk_packed_dl_540
     gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(reinterpret_cast<void*>(0x07000540)));
 
-    if (camera->pos[1] < -20.0f) {
+    if (camera->pos.y < -20.0f) {
         // d_course_banshee_boardwalk_packed_dl_6310
         gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(reinterpret_cast<void*>(0x07006310)));
     }
-    spA8[0] = camera->pos[0];
+    spA8[0] = camera->pos.x;
     spA8[1] = -82.0f;
-    spA8[2] = camera->pos[2];
+    spA8[2] = camera->pos.z;
     mtxf_translate(spCC, spA8);
     render_set_position(spCC, 0);
 
diff --git a/src/engine/courses/BowsersCastle.cpp b/src/engine/courses/BowsersCastle.cpp
index 22b6cbe78..cbd584690 100644
--- a/src/engine/courses/BowsersCastle.cpp
+++ b/src/engine/courses/BowsersCastle.cpp
@@ -243,16 +243,16 @@ void BowsersCastle::InitCourseObjects() {
     // Handle the big statue's fire breath
     objectId = indexObjectList2[0];
     init_object(objectId, 0);
-    gObjectList[objectId].pos[0] = -68.0 * xOrientation;
-    gObjectList[objectId].pos[1] = 80.0f;
-    gObjectList[objectId].pos[2] = -1840.0f;
+    gObjectList[objectId].pos.x = -68.0 * xOrientation;
+    gObjectList[objectId].pos.y = 80.0f;
+    gObjectList[objectId].pos.z = -1840.0f;
     // Handle the smaller statues' fire breath
     for (i = 0; i < NUM_FIRE_BREATHS; i++) {
         objectId = indexObjectList3[i];
         init_object(objectId, 0);
-        gObjectList[objectId].pos[0] = gFireBreathsSpawns[i][0] * xOrientation;
-        gObjectList[objectId].pos[1] = gFireBreathsSpawns[i][1];
-        gObjectList[objectId].pos[2] = gFireBreathsSpawns[i][2];
+        gObjectList[objectId].pos.x = gFireBreathsSpawns[i][0] * xOrientation;
+        gObjectList[objectId].pos.y = gFireBreathsSpawns[i][1];
+        gObjectList[objectId].pos.z = gFireBreathsSpawns[i][2];
         gObjectList[objectId].direction_angle[1] = 0;
         if (i % 2U) {
             gObjectList[objectId].direction_angle[1] += 0x8000;
diff --git a/src/engine/courses/KalimariDesert.cpp b/src/engine/courses/KalimariDesert.cpp
index 8f4c3e893..06b5bed4d 100644
--- a/src/engine/courses/KalimariDesert.cpp
+++ b/src/engine/courses/KalimariDesert.cpp
@@ -160,12 +160,12 @@ void KalimariDesert::BeginPlay() {
         uintptr_t* crossing2 = (uintptr_t*) gWorldInstance.AddCrossing(crossingPos2, 176, 182, 900.0f, 650.0f);
 
         vec3f_set(position, -1680.0f, 2.0f, 35.0f);
-        position[0] *= gCourseDirection;
+        position.x *= gCourseDirection;
         rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
                                                                                 ACTOR_RAILROAD_CROSSING));
         rrxing->crossingTrigger = crossing2;
         vec3f_set(position, -1600.0f, 2.0f, 35.0f);
-        position[0] *= gCourseDirection;
+        position.x *= gCourseDirection;
         rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
                                                                                 ACTOR_RAILROAD_CROSSING));
         rrxing->crossingTrigger = crossing2;
@@ -173,12 +173,12 @@ void KalimariDesert::BeginPlay() {
         // Original game forgot to put gCourseDirection to face the crossing the right direction in extra mode
         vec3s_set(rotation, 0, -0x2000 * gCourseDirection, 0);
         vec3f_set(position, -2459.0f, 2.0f, 2263.0f);
-        position[0] *= gCourseDirection;
+        position.x *= gCourseDirection;
         rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
                                                                                 ACTOR_RAILROAD_CROSSING));
         rrxing->crossingTrigger = crossing1;
         vec3f_set(position, -2467.0f, 2.0f, 2375.0f);
-        position[0] *= gCourseDirection;
+        position.x *= gCourseDirection;
         rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
                                                                                 ACTOR_RAILROAD_CROSSING));
         rrxing->crossingTrigger = crossing1;
diff --git a/src/engine/courses/MarioRaceway.cpp b/src/engine/courses/MarioRaceway.cpp
index 50af0d890..fc7b545f3 100644
--- a/src/engine/courses/MarioRaceway.cpp
+++ b/src/engine/courses/MarioRaceway.cpp
@@ -194,10 +194,10 @@ void MarioRaceway::BeginPlay() {
     spawn_piranha_plants((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_mario_raceway_piranha_plant_spawns));
     spawn_all_item_boxes((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_mario_raceway_item_box_spawns));
     vec3f_set(position, 150.0f, 40.0f, -1300.0f);
-    position[0] *= gCourseDirection;
+    position.x *= gCourseDirection;
     add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
     vec3f_set(position, 2520.0f, 0.0f, 1240.0f);
-    position[0] *= gCourseDirection;
+    position.x *= gCourseDirection;
     add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
 
     if (gModeSelection == VERSUS) {
diff --git a/src/engine/courses/SherbetLand.cpp b/src/engine/courses/SherbetLand.cpp
index 7eb7e958c..922973317 100644
--- a/src/engine/courses/SherbetLand.cpp
+++ b/src/engine/courses/SherbetLand.cpp
@@ -258,7 +258,7 @@ void SherbetLand::DrawWater(struct UnkStruct_800DC5EC* screen, uint16_t pathCoun
     render_course_segments(sherbet_land_dls_2, screen);
 
     gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE);
-    if ((func_80290C20(screen->camera) == 1) && (get_water_level(screen->player) < screen->player->pos[1])) {
+    if ((func_80290C20(screen->camera) == 1) && (get_water_level(screen->player) < screen->player->pos.y)) {
         gSPSetGeometryMode(gDisplayListHead++, G_ZBUFFER);
         gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE);
         gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
diff --git a/src/engine/courses/TestCourse.cpp b/src/engine/courses/TestCourse.cpp
index eebaee17a..5d1c0c1b7 100644
--- a/src/engine/courses/TestCourse.cpp
+++ b/src/engine/courses/TestCourse.cpp
@@ -256,7 +256,7 @@ void TestCourse::BeginPlay() {
     Vec3f crossingPos = {0, 2, 0};
     uintptr_t* crossing1 = (uintptr_t*) gWorldInstance.AddCrossing(crossingPos, 0, 2, 900.0f, 650.0f);
 
-    position[0] *= gCourseDirection;
+    position.x *= gCourseDirection;
     rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
                                                                             ACTOR_RAILROAD_CROSSING));
     rrxing->crossingTrigger = crossing1;
diff --git a/src/engine/courses/YoshiValley.cpp b/src/engine/courses/YoshiValley.cpp
index 5fbcbea69..010e2b62f 100644
--- a/src/engine/courses/YoshiValley.cpp
+++ b/src/engine/courses/YoshiValley.cpp
@@ -151,7 +151,7 @@ void YoshiValley::BeginPlay() {
     spawn_foliage((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_yoshi_valley_tree_spawn));
     spawn_all_item_boxes((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_yoshi_valley_item_box_spawns));
     vec3f_set(position, -2300.0f, 0.0f, 634.0f);
-    position[0] *= gCourseDirection;
+    position.x *= gCourseDirection;
     add_actor_to_empty_slot(position, rotation, velocity, ACTOR_YOSHI_EGG);
 
     if (gGamestate != CREDITS_SEQUENCE) {
@@ -241,7 +241,7 @@ void YoshiValley::CreditsSpawnActors() {
     Vec3s rotation = { 0, 0, 0 };
 
     vec3f_set(position, -2300.0f, 0.0f, 634.0f);
-    position[0] *= gCourseDirection;
+    position.x *= gCourseDirection;
     add_actor_to_empty_slot(position, rotation, velocity, ACTOR_YOSHI_EGG);
 }
 
diff --git a/src/engine/editor/EditorMath.cpp b/src/engine/editor/EditorMath.cpp
index 44923e08e..2801bda2e 100644
--- a/src/engine/editor/EditorMath.cpp
+++ b/src/engine/editor/EditorMath.cpp
@@ -68,7 +68,7 @@ FVector ScreenRayTrace() {
         FVector4 rayEye = MultiplyMatrixVector(inversePerspMtx, (float*)&rayClip.x);
 
         Mat4 lookAtMtx;
-        guLookAtF(lookAtMtx, camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0], camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
+        guLookAtF(lookAtMtx, camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x, camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
         Mat4 inverseViewMtx;
         if (InverseMatrix((float*)&lookAtMtx, (float*)&inverseViewMtx[0][0]) != 2) {
             rayEye.w = 0;
@@ -411,10 +411,10 @@ void SetRotatorFromDirection(FVector direction, IRotator* rot) {
 }
 
 FVector GetPositionAheadOfCamera(f32 dist) {
-    FVector pos = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
+    FVector pos = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
 
-    f32 pitch = (cameras[0].rot[2] / 65535.0f) * 360.0f;
-    f32 yaw = (cameras[0].rot[1] / 65535.0f) * 360.0f;
+    f32 pitch = (cameras[0].rot.z / 65535.0f) * 360.0f;
+    f32 yaw = (cameras[0].rot.y / 65535.0f) * 360.0f;
 
     // Convert degrees to radians
     pitch = pitch * M_PI / 180.0f;
diff --git a/src/engine/editor/EditorMath.h b/src/engine/editor/EditorMath.h
index d5d75fe13..f45fcdd42 100644
--- a/src/engine/editor/EditorMath.h
+++ b/src/engine/editor/EditorMath.h
@@ -29,9 +29,9 @@ struct Triangle {
  * 
  * @return FVector ray direction
  * 
- * ray.x = camera->pos[0] + direction.x * length;
- * ray.y = camera->pos[1] + direction.y * length;
- * ray.z = camera->pos[2] + direction.z * length;
+ * ray.x = camera->pos.x + direction.x * length;
+ * ray.y = camera->pos.y + direction.y * length;
+ * ray.z = camera->pos.z + direction.z * length;
  */
 bool IsInGameScreen();
 FVector ScreenRayTrace();
diff --git a/src/engine/editor/Gizmo.cpp b/src/engine/editor/Gizmo.cpp
index 4987242f0..697a04550 100644
--- a/src/engine/editor/Gizmo.cpp
+++ b/src/engine/editor/Gizmo.cpp
@@ -118,31 +118,31 @@ void Gizmo::Translate() {
 
     if (Enabled) {
         length = sqrt(
-            pow(_selected->Pos->x - cameras[0].pos[0], 2) +
-            pow(_selected->Pos->y - cameras[0].pos[1], 2) +
-            pow(_selected->Pos->z - cameras[0].pos[2], 2)
+            pow(_selected->Pos->x - cameras[0].pos.x, 2) +
+            pow(_selected->Pos->y - cameras[0].pos.y, 2) +
+            pow(_selected->Pos->z - cameras[0].pos.z, 2)
         );
 
         switch(SelectedHandle) {
             case GizmoHandle::All_Axis:
-                _selected->Pos->x = (cameras[0].pos[0] + _ray.x * PickDistance) + _cursorOffset.x;
-                _selected->Pos->y = (cameras[0].pos[1] + _ray.y * PickDistance) + _cursorOffset.y;
-                _selected->Pos->z = (cameras[0].pos[2] + _ray.z * PickDistance) + _cursorOffset.z;
+                _selected->Pos->x = (cameras[0].pos.x + _ray.x * PickDistance) + _cursorOffset.x;
+                _selected->Pos->y = (cameras[0].pos.y + _ray.y * PickDistance) + _cursorOffset.y;
+                _selected->Pos->z = (cameras[0].pos.z + _ray.z * PickDistance) + _cursorOffset.z;
                 if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
                     _selected->Pos->y = SnapToSurface(_selected->Pos);
                 }
                 break;
             case GizmoHandle::X_Axis:
-                _selected->Pos->x = (cameras[0].pos[0] + _ray.x * length) + _cursorOffset.x;
+                _selected->Pos->x = (cameras[0].pos.x + _ray.x * length) + _cursorOffset.x;
                 if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
                     _selected->Pos->y = SnapToSurface(_selected->Pos);
                 }
                 break;
             case GizmoHandle::Y_Axis:
-                _selected->Pos->y = (cameras[0].pos[1] + _ray.y * length) + _cursorOffset.y;
+                _selected->Pos->y = (cameras[0].pos.y + _ray.y * length) + _cursorOffset.y;
                 break;
             case GizmoHandle::Z_Axis:
-                _selected->Pos->z = (cameras[0].pos[2] + _ray.z * length) + _cursorOffset.z;
+                _selected->Pos->z = (cameras[0].pos.z + _ray.z * length) + _cursorOffset.z;
                 if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
                     _selected->Pos->y = SnapToSurface(_selected->Pos);
                 }
@@ -180,7 +180,7 @@ f32 Gizmo::SnapToSurface(FVector* pos) {
 }
 
 void Gizmo::Rotate() {
-    FVector cam = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
+    FVector cam = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
 
     if (_selected == nullptr || _selected->Rot == nullptr) {
         return;
@@ -214,7 +214,7 @@ void Gizmo::Rotate() {
 }
 
 void Gizmo::Scale() {
-    FVector cam = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
+    FVector cam = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
     if (_selected == nullptr || _selected->Scale == nullptr) {
         return;
     }
@@ -320,7 +320,7 @@ void Gizmo::DrawHandles() {
         Editor_MatrixIdentity(CenterMtx);
 
         // Calculate camera-to-object distance
-        FVector cameraDir = FVector(Pos.x - cameras[0].pos[0], Pos.y - cameras[0].pos[1], Pos.z - cameras[0].pos[2]);
+        FVector cameraDir = FVector(Pos.x - cameras[0].pos.x, Pos.y - cameras[0].pos.y, Pos.z - cameras[0].pos.z);
         cameraDir = cameraDir.Normalize();
 
         IRotator centerRot;
diff --git a/src/engine/editor/Light.cpp b/src/engine/editor/Light.cpp
index 594383bd3..0b930fa7d 100644
--- a/src/engine/editor/Light.cpp
+++ b/src/engine/editor/Light.cpp
@@ -61,7 +61,7 @@ size_t LightObject::NumLights = 0;
 
 
         // Calculate camera-to-object distance
-        FVector cameraDir = FVector(LightPos.x - cameras[0].pos[0], LightPos.y - cameras[0].pos[1], LightPos.z - cameras[0].pos[2]);
+        FVector cameraDir = FVector(LightPos.x - cameras[0].pos.x, LightPos.y - cameras[0].pos.y, LightPos.z - cameras[0].pos.z);
         cameraDir = cameraDir.Normalize();
 
         IRotator centerRot;
diff --git a/src/engine/editor/ObjectPicker.cpp b/src/engine/editor/ObjectPicker.cpp
index 9cfeed5f8..0bd3a6d97 100644
--- a/src/engine/editor/ObjectPicker.cpp
+++ b/src/engine/editor/ObjectPicker.cpp
@@ -34,7 +34,7 @@ void ObjectPicker::Tick() {
 
 void ObjectPicker::SelectObject(std::vector<GameObject*> objects) {
     Ray ray;
-    ray.Origin = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
+    ray.Origin = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
 
     // This allows selection of objects in the scene explorer.
     // Otherwise this would still run when selecting buttons in editor windows.
@@ -56,7 +56,7 @@ void ObjectPicker::SelectObject(std::vector<GameObject*> objects) {
 
 void ObjectPicker::DragHandle() {
     Ray ray;
-    ray.Origin = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
+    ray.Origin = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
     ray.Direction = ScreenRayTrace();
 
     // Skip if a drag is already in progress
@@ -136,9 +136,9 @@ void ObjectPicker::Draw() {
         FVector scale = FVector(0.1, 0.1, 0.1);
         FVector ray = ScreenRayTrace();
 
-        float x = (cameras[0].pos[0] + ray.x * 800);
-        float y = (cameras[0].pos[1] + ray.y * 800);
-        float z = (cameras[0].pos[2] + ray.z * 800);
+        float x = (cameras[0].pos.x + ray.x * 800);
+        float y = (cameras[0].pos.y + ray.y * 800);
+        float z = (cameras[0].pos.z + ray.z * 800);
 
         ApplyMatrixTransformations((float(*)[4])&CursorMtx, FVector(x, y, z), rot, scale);
         Editor_AddMatrix((float(*)[4])&CursorMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
diff --git a/src/engine/objects/Bat.cpp b/src/engine/objects/Bat.cpp
index 764476064..84f51146e 100644
--- a/src/engine/objects/Bat.cpp
+++ b/src/engine/objects/Bat.cpp
@@ -120,7 +120,7 @@ void OBat::Draw(s32 cameraId) {
 
             if ((gObjectList[objectIndex].state >= 2) && (gMatrixHudCount < 0x2EF)) {
                 D_80183E80[1] =
-                    func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], temp_s7->pos);
+                    func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, temp_s7->pos);
                 func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
                               (Vtx*)D_0D0062B0);
             }
@@ -135,7 +135,7 @@ void OBat::Draw(s32 cameraId) {
 
             if ((gObjectList[objectIndex].state >= 2) && (gMatrixHudCount < 0x2EF)) {
                 D_80183E80[1] =
-                    func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], temp_s7->pos);
+                    func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, temp_s7->pos);
                 func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
                               (Vtx*)D_0D0062B0);
             }
@@ -179,18 +179,18 @@ void OBat::func_8007D8D4(s32 objectIndex, s32 arg1) {
             }
             if (arg1 == 1) {
                 if (gIsMirrorMode != 0) {
-                    if (gObjectList[objectIndex].pos[0] >= 2540.0) {
+                    if (gObjectList[objectIndex].pos.x >= 2540.0) {
                         func_80072428(objectIndex);
                     }
-                } else if (gObjectList[objectIndex].pos[0] <= -2540.0) {
+                } else if (gObjectList[objectIndex].pos.x <= -2540.0) {
                     func_80072428(objectIndex);
                 }
             } else if (gIsMirrorMode != 0) {
-                if (gObjectList[objectIndex].pos[0] >= 2150.0) {
+                if (gObjectList[objectIndex].pos.x >= 2150.0) {
                     func_80072428(objectIndex);
                 }
             } else {
-                if (gObjectList[objectIndex].pos[0] <= -2150.0) {
+                if (gObjectList[objectIndex].pos.x <= -2150.0) {
                     func_80072428(objectIndex);
                 }
             }
diff --git a/src/engine/objects/BombKart.cpp b/src/engine/objects/BombKart.cpp
index 53b4a4262..ef48d967a 100644
--- a/src/engine/objects/BombKart.cpp
+++ b/src/engine/objects/BombKart.cpp
@@ -131,9 +131,9 @@ void OBombKart::Tick() {
             if (GetCourse() == GetPodiumCeremony()) {
                 if (D_8016347E == 1) {
                     player = gPlayerFour;
-                    temp_f0 = newPos[0] - player->pos[0];
-                    temp_f2 = newPos[2] - player->pos[1];
-                    temp_f12 = newPos[2] - player->pos[2];
+                    temp_f0 = newPos[0] - player->pos.x;
+                    temp_f2 = newPos[2] - player->pos.y;
+                    temp_f12 = newPos[2] - player->pos.z;
                     if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
                         circleTimer = 0;
                         state = States::EXPLODE;
@@ -146,9 +146,9 @@ void OBombKart::Tick() {
                 for (size_t i = 0; i < gPlayerCount; i++) {
                     player = &gPlayers[i];
                     if (!(player->effects & 0x80000000)) {
-                        temp_f0 = newPos[0] - player->pos[0];
-                        temp_f2 = newPos[1] - player->pos[1];
-                        temp_f12 = newPos[2] - player->pos[2];
+                        temp_f0 = newPos[0] - player->pos.x;
+                        temp_f2 = newPos[1] - player->pos.y;
+                        temp_f12 = newPos[2] - player->pos.z;
                         if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
                             state = States::EXPLODE;
                             circleTimer = 0;
@@ -334,9 +334,9 @@ void OBombKart::Draw(s32 cameraId) {
             if (object->state != 0) {
                 s32 primAlpha = object->primAlpha;
                 Player* player = &gPlayerOne[playerId];
-                object->pos[0] = player->pos[0];
-                object->pos[1] = player->pos[1] - 2.0;
-                object->pos[2] = player->pos[2];
+                object->pos.x = player->pos.x;
+                object->pos.y = player->pos.y - 2.0;
+                object->pos.z = player->pos.z;
                 object->surfaceHeight = player->unk_074;
                 func_800563DC(_objectIndex, cameraId, primAlpha);
                 func_8005669C(_objectIndex, cameraId, primAlpha);
@@ -370,9 +370,9 @@ void OBombKart::Draw(s32 cameraId) {
     // huh???
     s32 state = State;
     if (State != States::DISABLED) {
-        gObjectList[_objectIndex].pos[0] = Pos[0];
-        gObjectList[_objectIndex].pos[1] = Pos[1];
-        gObjectList[_objectIndex].pos[2] = Pos[2];
+        gObjectList[_objectIndex].pos.x = Pos[0];
+        gObjectList[_objectIndex].pos.y = Pos[1];
+        gObjectList[_objectIndex].pos.z = Pos[2];
         s32 temp_s4 = func_8008A364(_objectIndex, cameraId, 0x31C4U, 0x000001F4);
         if (is_obj_flag_status_active(_objectIndex, VISIBLE) != 0) {
             set_object_flag(_objectIndex, 0x00200000);
@@ -441,7 +441,7 @@ void OBombKart::Waypoint(s32 screenId) {
 Player* OBombKart::FindTarget() {
     for (size_t i = 0; i < NUM_PLAYERS; i++) {
         if (gPlayers[i].type & PLAYER_HUMAN) {
-            if (is_within_distance_2d(Pos[0], Pos[2], gPlayers[i].pos[0], gPlayers[i].pos[2], 500)) {
+            if (is_within_distance_2d(Pos[0], Pos[2], gPlayers[i].pos.x, gPlayers[i].pos.z, 500)) {
                 return &gPlayers[i];
             }
         }
@@ -456,9 +456,9 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
 
     // Calculate the directional vector toward the player
     Vec3f direction;
-    direction[0] = player->pos[0] - pos[0];
-    direction[1] = player->pos[1] - pos[1];
-    direction[2] = player->pos[2] - pos[2];
+    direction[0] = player->pos.x - pos.x;
+    direction[1] = player->pos.y - pos.y;
+    direction[2] = player->pos.z - pos.z;
 
     // Calculate the distance in the XZ plane
     f32 xz_dist = sqrtf((direction[0] * direction[0]) + (direction[2] * direction[2]));
@@ -466,18 +466,18 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
     // Reset distance
     if (xz_dist > 700.0f) {
         _target = NULL;
-        pos[0] = _spawnPos[0];
-        pos[1] = _spawnPos[1];
-        pos[2] = _spawnPos[2];
+        pos.x = _spawnPos[0];
+        pos.y = _spawnPos[1];
+        pos.z = _spawnPos[2];
         return;
     }
 
     // Break off the chase if player has boo item
     if (player->effects & BOO_EFFECT) {
         _target = NULL;
-        pos[0] = _spawnPos[0];
-        pos[1] = _spawnPos[1];
-        pos[2] = _spawnPos[2];
+        pos.x = _spawnPos[0];
+        pos.y = _spawnPos[1];
+        pos.z = _spawnPos[2];
         return;
     }
 
@@ -488,20 +488,20 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
         direction[2] /= xz_dist;
 
         // Scale the movement by a fixed step size
-        pos[0] += direction[0] * speed;
-        pos[2] += direction[2] * speed;
+        pos.x += direction[0] * speed;
+        pos.z += direction[2] * speed;
     }
 
     Vec3f newPosition;
-    newPosition[0] = pos[0];
-    newPosition[1] = pos[1];
-    newPosition[2] = pos[2];
+    newPosition[0] = pos.x;
+    newPosition[1] = pos.y;
+    newPosition[2] = pos.z;
 
-    newPosition[1] = calculate_surface_height(pos[0], 2000.0f, pos[2], _Collision.meshIndexZX) + 3.5f;
+    newPosition[1] = calculate_surface_height(pos.x, 2000.0f, pos.z, _Collision.meshIndexZX) + 3.5f;
 
-    pos[0] = newPosition[0];
-    pos[1] = newPosition[1];
-    pos[2] = newPosition[2];
+    pos.x = newPosition[0];
+    pos.y = newPosition[1];
+    pos.z = newPosition[2];
 
-    check_bounding_collision(&_Collision, 10.0f, pos[0], pos[1], pos[2]);
+    check_bounding_collision(&_Collision, 10.0f, pos.x, pos.y, pos.z);
 }
\ No newline at end of file
diff --git a/src/engine/objects/Boos.cpp b/src/engine/objects/Boos.cpp
index 5bdbd41cf..7723b225a 100644
--- a/src/engine/objects/Boos.cpp
+++ b/src/engine/objects/Boos.cpp
@@ -61,11 +61,11 @@ void OBoos::Tick() {
             func_8008B78C(objectIndex);
             player = &gPlayerOne[object->unk_0D1];
             camera = &camera1[object->unk_0D1];
-            temp_t4 = (0x8000 - camera->rot[1]);
-            object->pos[0] = player->pos[0] + (coss(temp_t4) * (object->origin_pos[0] + object->offset[0])) -
+            temp_t4 = (0x8000 - camera->rot.y);
+            object->pos.x = player->pos.x + (coss(temp_t4) * (object->origin_pos[0] + object->offset[0])) -
                              (sins(temp_t4) * (object->origin_pos[2] + object->offset[2]));
-            object->pos[1] = 6.5 + player->unk_074 + object->origin_pos[1] + object->offset[1];
-            object->pos[2] = player->pos[2] + (sins(temp_t4) * (object->origin_pos[0] + object->offset[0])) +
+            object->pos.y = 6.5 + player->unk_074 + object->origin_pos[1] + object->offset[1];
+            object->pos.z = player->pos.z + (sins(temp_t4) * (object->origin_pos[0] + object->offset[0])) +
                              (coss(temp_t4) * (object->origin_pos[2] + object->offset[2]));
             OBoos::func_8007C550(objectIndex);
             if (is_obj_flag_status_active(objectIndex, 0x00000080) != 0) {
@@ -101,7 +101,7 @@ void OBoos::func_800523B8(s32 objectIndex, s32 arg1, u32 arg2) {
     Camera* camera = &camera1[arg1];
 
     object = &gObjectList[objectIndex];
-    object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+    object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
     func_800484BC(object->pos, object->orientation, object->sizeScaling, object->primAlpha, (u8*) object->activeTLUT,
                   (u8*)object->activeTexture, object->vertex, 0x00000030, 0x00000028, 0x00000030, 0x00000028);
     if ((is_obj_flag_status_active(objectIndex, 0x00000020) != 0) && (arg2 < 0x15F91U)) {
@@ -140,9 +140,9 @@ void OBoos::func_8007C5B4(s32 objectIndex) {
 
     init_texture_object(objectIndex, (u8*)d_course_banshee_boardwalk_boo_tlut, gTextureGhosts, 48, 40);
     object = &gObjectList[objectIndex];
-    object->pos[0] = 0.0f;
-    object->pos[1] = 0.0f;
-    object->pos[2] = 0.0f;
+    object->pos.x = 0.0f;
+    object->pos.y = 0.0f;
+    object->pos.z = 0.0f;
     set_object_flag(objectIndex, 0x00000020);
     object_next_state(objectIndex);
     object->primAlpha = 0;
@@ -204,7 +204,7 @@ void OBoos::func_8007C4A4(s32 objectIndex) {
 void OBoos::func_8007C550(s32 objectIndex) {
     gObjectList[objectIndex].direction_angle[1] =
         func_800417B4(gObjectList[objectIndex].direction_angle[1],
-                      atan2s(gObjectList[objectIndex].velocity[0], gObjectList[objectIndex].velocity[2]));
+                      atan2s(gObjectList[objectIndex].velocity.x, gObjectList[objectIndex].velocity.z));
     OBoos::func_8007C4A4(objectIndex);
 }
 
diff --git a/src/engine/objects/ChainChomp.cpp b/src/engine/objects/ChainChomp.cpp
index 695df1e8a..35363c592 100644
--- a/src/engine/objects/ChainChomp.cpp
+++ b/src/engine/objects/ChainChomp.cpp
@@ -58,12 +58,12 @@ void OChainChomp::func_80055AB8(s32 objectIndex, s32 cameraId) {
     camera = &camera1[cameraId];
     if (gObjectList[objectIndex].state >= 2) {
         if (is_obj_flag_status_active(objectIndex, 0x00100000) != 0) {
-            D_80183E40[0] = gObjectList[objectIndex].pos[0];
-            D_80183E40[1] = gObjectList[objectIndex].pos[1] + 16.0;
-            D_80183E40[2] = gObjectList[objectIndex].pos[2];
+            D_80183E40[0] = gObjectList[objectIndex].pos.x;
+            D_80183E40[1] = gObjectList[objectIndex].pos.y + 16.0;
+            D_80183E40[2] = gObjectList[objectIndex].pos.z;
             D_80183E80[0] = 0;
             D_80183E80[1] =
-                func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+                func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             D_80183E80[2] = 0x8000;
             func_800468E0(D_80183E40, D_80183E80, 0.54f, (u8*)d_course_rainbow_road_sphere, (Vtx*)D_0D0062B0, 0x00000020,
                           0x00000040, 0x00000020, 0x00000040, 5);
diff --git a/src/engine/objects/CheepCheep.cpp b/src/engine/objects/CheepCheep.cpp
index 5b4157c61..53ed51103 100644
--- a/src/engine/objects/CheepCheep.cpp
+++ b/src/engine/objects/CheepCheep.cpp
@@ -94,12 +94,12 @@ void OCheepCheep::func_8007BBBC(s32 objectIndex) {
             } else {
                 func_80087E08(objectIndex, 18.0f, 0.7f, 25.0f, (s16) 0x00005800, 0x0000012C);
             }
-            if (object->velocity[2] < 0.0f) {
-                var_f14 = -object->velocity[2];
+            if (object->velocity.z < 0.0f) {
+                var_f14 = -object->velocity.z;
             } else {
-                var_f14 = object->velocity[2];
+                var_f14 = object->velocity.z;
             }
-            object->direction_angle[0] = func_80041658(object->velocity[1], var_f14);
+            object->direction_angle[0] = func_80041658(object->velocity.y, var_f14);
             set_and_run_timer_object(objectIndex, 0x00000046);
             break;
         case 3:
@@ -180,10 +180,10 @@ void OCheepCheep::func_8007BFB0(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            object->velocity[1] = -0.2f;
+            object->velocity.y = -0.2f;
             if ((f64) object->offset[1] <= 0.0) {
                 object->offset[1] = 0.0f;
-                object->velocity[1] = 0.0f;
+                object->velocity.y = 0.0f;
                 func_80086F60(objectIndex);
             }
             break;
diff --git a/src/engine/objects/Crab.cpp b/src/engine/objects/Crab.cpp
index 82d2b9330..0e6d7b83d 100644
--- a/src/engine/objects/Crab.cpp
+++ b/src/engine/objects/Crab.cpp
@@ -36,8 +36,8 @@ OCrab::OCrab(const FVector2D& start, const FVector2D& end) {
     find_unused_obj_index(&_objectIndex);
 
     init_object(_objectIndex, 0);
-    gObjectList[_objectIndex].pos[0] = gObjectList[_objectIndex].origin_pos[0] = start.x * xOrientation;
-    gObjectList[_objectIndex].pos[2] = gObjectList[_objectIndex].origin_pos[2] = start.z;
+    gObjectList[_objectIndex].pos.x = gObjectList[_objectIndex].origin_pos[0] = start.x * xOrientation;
+    gObjectList[_objectIndex].pos.z = gObjectList[_objectIndex].origin_pos[2] = start.z;
 
     gObjectList[_objectIndex].unk_01C[0] = end.x * xOrientation;
     gObjectList[_objectIndex].unk_01C[2] = end.z;
@@ -63,7 +63,7 @@ void OCrab::Draw(s32 cameraId) {
         camera = &camera1[cameraId];
         func_8004A6EC(objectIndex, 0.5f);
         gObjectList[objectIndex].orientation[1] =
-            func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+            func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
         draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation,
                            gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT,
                            (uint8_t*)gObjectList[objectIndex].activeTexture, vtx, 64, 64,
@@ -82,7 +82,7 @@ void OCrab::DrawModel(s32 cameraId) {
         if (gObjectList[objectIndex].state >= 2) {
             camera = &camera1[cameraId];
             func_8004A6EC(objectIndex, 0.5f);
-            gObjectList[objectIndex].orientation[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+            gObjectList[objectIndex].orientation[1] = func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation, gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT, (u8*)gObjectList[objectIndex].activeTexture, (Vtx*)common_vtx_hedgehog, 0x00000040, 0x00000040, 0x00000040, 0x00000020);
         }
     }
@@ -163,7 +163,7 @@ void OCrab::func_80082C30(s32 objectIndex) {
     object_calculate_new_pos_offset(objectIndex);
     if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
         func_80088538(objectIndex);
-        gObjectList[objectIndex].pos[1] = (f32) (gObjectList[objectIndex].surfaceHeight + 2.5);
+        gObjectList[objectIndex].pos.y = (f32) (gObjectList[objectIndex].surfaceHeight + 2.5);
     }
 }
 
diff --git a/src/engine/objects/GrandPrixBalloons.cpp b/src/engine/objects/GrandPrixBalloons.cpp
index eb6b311de..0d165d20b 100644
--- a/src/engine/objects/GrandPrixBalloons.cpp
+++ b/src/engine/objects/GrandPrixBalloons.cpp
@@ -172,9 +172,9 @@ void OGrandPrixBalloons::func_80074924(s32 objectIndex) {
 
     set_obj_origin_offset(objectIndex, 0, 0, 0);
     if (gPlayerCount == 1) {
-        object->velocity[1] = (f32) (((f64) (f32) (sp2C % 4) * 0.25) + 0.8);
+        object->velocity.y = (f32) (((f64) (f32) (sp2C % 4) * 0.25) + 0.8);
     } else {
-        object->velocity[1] = (f32) (((f64) (f32) (sp2C % 3) * 0.2) + 0.4);
+        object->velocity.y = (f32) (((f64) (f32) (sp2C % 3) * 0.2) + 0.4);
     }
     temp_a0 = sp2C % 8;
     object->unk_084[0] = D_800E6F30[temp_a0][0];
diff --git a/src/engine/objects/Hedgehog.cpp b/src/engine/objects/Hedgehog.cpp
index ebc5b30bb..f1deb72e0 100644
--- a/src/engine/objects/Hedgehog.cpp
+++ b/src/engine/objects/Hedgehog.cpp
@@ -22,9 +22,9 @@ OHedgehog::OHedgehog(const FVector& pos, const FVector2D& patrolPoint, s16 unk)
     s32 objectId = indexObjectList2[_idx];
     _objectIndex = objectId;
     init_object(objectId, 0);
-    gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] = pos.x * xOrientation;
-    gObjectList[objectId].pos[1] = gObjectList[objectId].surfaceHeight = pos.y + 6.0;
-    gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = pos.z;
+    gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] = pos.x * xOrientation;
+    gObjectList[objectId].pos.y = gObjectList[objectId].surfaceHeight = pos.y + 6.0;
+    gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = pos.z;
     gObjectList[objectId].unk_0D5 = (u8)unk;
     gObjectList[objectId].unk_09C = patrolPoint.x * xOrientation;
     gObjectList[objectId].unk_09E = patrolPoint.z;
@@ -75,7 +75,7 @@ void OHedgehog::func_800555BC(s32 objectIndex, s32 cameraId) {
         camera = &camera1[cameraId];
         OHedgehog::func_8004A870(objectIndex, 0.7f);
         gObjectList[objectIndex].orientation[1] =
-            func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+            func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
         draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation,
                            gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT,
                            (u8*)gObjectList[objectIndex].activeTexture, gObjectList[objectIndex].vertex, 64, 64, 64, 32);
@@ -89,9 +89,9 @@ void OHedgehog::func_8004A870(s32 objectIndex, f32 arg1) {
     if ((is_obj_flag_status_active(objectIndex, 0x00000020) != 0) &&
         (is_obj_flag_status_active(objectIndex, 0x00800000) != 0)) {
         object = &gObjectList[objectIndex];
-        D_80183E50[0] = object->pos[0];
+        D_80183E50[0] = object->pos.x;
         D_80183E50[1] = object->surfaceHeight + 0.8;
-        D_80183E50[2] = object->pos[2];
+        D_80183E50[2] = object->pos.z;
         set_transform_matrix(mtx, object->unk_01C, D_80183E50, 0U, arg1);
         // convert_to_fixed_point_matrix(&gGfxPool->mtxHud[gMatrixHudCount], mtx);
         // gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxHud[gMatrixHudCount++]),
@@ -154,7 +154,7 @@ void OHedgehog::func_80083248(s32 objectIndex) {
         if (is_obj_flag_status_active(objectIndex, 0x00400000) != 0) {
             func_8008861C(objectIndex);
         }
-        gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].surfaceHeight + 6.0;
+        gObjectList[objectIndex].pos.y = gObjectList[objectIndex].surfaceHeight + 6.0;
     }
 }
 
diff --git a/src/engine/objects/HotAirBalloon.cpp b/src/engine/objects/HotAirBalloon.cpp
index 4e337d98e..0a64ab852 100644
--- a/src/engine/objects/HotAirBalloon.cpp
+++ b/src/engine/objects/HotAirBalloon.cpp
@@ -42,9 +42,9 @@ void OHotAirBalloon::Tick() {
             OHotAirBalloon::func_80085534(objectIndex);
             object_calculate_new_pos_offset(objectIndex);
             if (gObjectList[objectIndex].state >= 2) {
-                gActorHotAirBalloonItemBox->pos[0] = gObjectList[objectIndex].pos[0];
-                gActorHotAirBalloonItemBox->pos[1] = gObjectList[objectIndex].pos[1] - 10.0;
-                gActorHotAirBalloonItemBox->pos[2] = gObjectList[objectIndex].pos[2];
+                gActorHotAirBalloonItemBox->pos.x = gObjectList[objectIndex].pos.x;
+                gActorHotAirBalloonItemBox->pos.y = gObjectList[objectIndex].pos.y - 10.0;
+                gActorHotAirBalloonItemBox->pos.z = gObjectList[objectIndex].pos.z;
             }
         }
     }
@@ -74,7 +74,7 @@ void OHotAirBalloon::func_80055CCC(s32 objectIndex, s32 cameraId) {
     camera = &camera1[cameraId];
     if (gObjectList[objectIndex].state >= 2) {
         func_8008A454(objectIndex, cameraId, 0x0000012C);
-        test = gObjectList[objectIndex].pos[1] - gObjectList[objectIndex].surfaceHeight;
+        test = gObjectList[objectIndex].pos.y - gObjectList[objectIndex].surfaceHeight;
         func_8004A6EC(objectIndex, (20.0 / test) + 0.5);
         if (is_obj_index_flag_status_inactive(objectIndex, 0x00100000) != 0) {
             func_80043328(gObjectList[objectIndex].pos, (u16*) gObjectList[objectIndex].direction_angle,
@@ -83,7 +83,7 @@ void OHotAirBalloon::func_80055CCC(s32 objectIndex, s32 cameraId) {
         } else {
             D_80183E80[0] = (s16) gObjectList[objectIndex].direction_angle[0];
             D_80183E80[1] =
-                (s16) (func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos) +
+                (s16) (func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos) +
                        0x8000);
             D_80183E80[2] = (u16) gObjectList[objectIndex].direction_angle[2];
             func_80043328(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
@@ -109,7 +109,7 @@ void OHotAirBalloon::init_hot_air_balloon(s32 objectIndex) {
     func_8008B844(objectIndex);
     func_800886F4(objectIndex);
     func_80086EF0(objectIndex);
-    gObjectList[objectIndex].velocity[1] = -2.0f;
+    gObjectList[objectIndex].velocity.y = -2.0f;
     init_actor_hot_air_balloon_item_box(0.0f, 0.0f, 0.0f);
     object_next_state(objectIndex);
 }
@@ -122,8 +122,8 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
             }
             break;
         case 2:
-            f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
-            if (gObjectList[objectIndex].velocity[1] == 0.0) {
+            f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
+            if (gObjectList[objectIndex].velocity.y == 0.0) {
                 func_80086FD4(objectIndex);
             }
             break;
@@ -131,8 +131,8 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
             func_800871AC(objectIndex, 1);
             break;
         case 4:
-            f32_step_towards(&gObjectList[objectIndex].velocity[1], 1.0f, 0.05f);
-            if (gObjectList[objectIndex].velocity[1] == 1.0) {
+            f32_step_towards(&gObjectList[objectIndex].velocity.y, 1.0f, 0.05f);
+            if (gObjectList[objectIndex].velocity.y == 1.0) {
                 func_80086FD4(objectIndex);
             }
             break;
@@ -140,14 +140,14 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
             func_800871AC(objectIndex, 90);
             break;
         case 6:
-            f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
-            if (gObjectList[objectIndex].velocity[1] == 0.0) {
+            f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
+            if (gObjectList[objectIndex].velocity.y == 0.0) {
                 func_80086FD4(objectIndex);
             }
             break;
         case 7:
-            f32_step_towards(&gObjectList[objectIndex].velocity[1], -1.0f, 0.05f);
-            if (gObjectList[objectIndex].velocity[1] == -1.0) {
+            f32_step_towards(&gObjectList[objectIndex].velocity.y, -1.0f, 0.05f);
+            if (gObjectList[objectIndex].velocity.y == -1.0) {
                 func_80086FD4(objectIndex);
             }
             break;
@@ -155,7 +155,7 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
             func_800871AC(objectIndex, 90);
             break;
         case 9:
-            f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
+            f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
             if (func_80087060(objectIndex, 90) != 0) {
                 func_8008701C(objectIndex, 3);
             }
diff --git a/src/engine/objects/Lakitu.cpp b/src/engine/objects/Lakitu.cpp
index 92f164e95..f40968d05 100644
--- a/src/engine/objects/Lakitu.cpp
+++ b/src/engine/objects/Lakitu.cpp
@@ -103,7 +103,7 @@ void OLakitu::Draw(s32 cameraId) {
     if (is_obj_flag_status_active(objectIndex, 0x00000010) != 0) {
         object = &gObjectList[objectIndex];
         object->orientation[0] = 0;
-        object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+        object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
         object->orientation[2] = 0x8000;
         if (func_80072354(objectIndex, 2) != 0) {
             draw_2d_texture_at(object->pos, object->orientation, object->sizeScaling, (u8*) object->activeTLUT,
@@ -116,8 +116,8 @@ void OLakitu::Draw(s32 cameraId) {
                           (s32) object->textureHeight, (s32) object->textureWidth, (s32) object->textureHeight / 2);
         }
         if (gScreenModeSelection == SCREEN_MODE_1P) {
-            var_f0 = object->pos[0] - camera->pos[0];
-            var_f2 = object->pos[2] - camera->pos[2];
+            var_f0 = object->pos.x - camera->pos.x;
+            var_f2 = object->pos.z - camera->pos.z;
             if (var_f0 < 0.0f) {
                 var_f0 = -var_f0;
             }
@@ -331,9 +331,9 @@ void OLakitu::init_obj_lakitu_checkered_flag(s32 objectIndex, s32 playerIndex) {
     object = &gObjectList[objectIndex];
     object->activeTexture = *gObjectList[objectIndex].textureList;
     object->vertex = vtx;
-    object->pos[2] = 5000.0f;
-    object->pos[1] = 5000.0f;
-    object->pos[0] = 5000.0f;
+    object->pos.z = 5000.0f;
+    object->pos.y = 5000.0f;
+    object->pos.x = 5000.0f;
     object->sizeScaling = 0.15f;
     func_80086F10(objectIndex, 2, &D_800E6834);
     clear_object_flag(objectIndex, 0x00000010);
@@ -595,9 +595,9 @@ void OLakitu::func_8007A060(s32 objectIndex, s32 playerIndex) {
     object = &gObjectList[objectIndex];
     object->activeTexture = *gObjectList[objectIndex].textureList;
     object->vertex = vtx;
-    object->pos[2] = 5000.0f;
-    object->pos[1] = 5000.0f;
-    object->pos[0] = 5000.0f;
+    object->pos.z = 5000.0f;
+    object->pos.y = 5000.0f;
+    object->pos.x = 5000.0f;
     object->sizeScaling = 0.15f;
     clear_object_flag(objectIndex, 0x00000010);
     func_80086F10(objectIndex, 5, &D_800E694C);
@@ -654,9 +654,9 @@ void OLakitu::func_8007A228(s32 objectIndex, s32 playerIndex) {
     object = &gObjectList[objectIndex];
     object->activeTexture = *gObjectList[objectIndex].textureList;
     object->vertex = vtx;
-    object->pos[2] = 5000.0f;
-    object->pos[1] = 5000.0f;
-    object->pos[0] = 5000.0f;
+    object->pos.z = 5000.0f;
+    object->pos.y = 5000.0f;
+    object->pos.x = 5000.0f;
     object->sizeScaling = 0.15f;
     clear_object_flag(objectIndex, 0x00000010);
     func_80086F10(objectIndex, 5, &D_800E694C);
@@ -711,9 +711,9 @@ void OLakitu::func_8007A3F0(s32 objectIndex, s32 arg1) {
     init_texture_object(objectIndex, tlut, sLakituReverseTextures, 72, (u16) 56);
     gObjectList[objectIndex].activeTexture = *gObjectList[objectIndex].textureList;
     gObjectList[objectIndex].vertex = vtx;
-    gObjectList[objectIndex].pos[2] = var;
-    gObjectList[objectIndex].pos[1] = var;
-    gObjectList[objectIndex].pos[0] = var;
+    gObjectList[objectIndex].pos.z = var;
+    gObjectList[objectIndex].pos.y = var;
+    gObjectList[objectIndex].pos.x = var;
     gObjectList[objectIndex].sizeScaling = 0.15f;
     clear_object_flag(objectIndex, 0x00000010);
     func_80086F10(objectIndex, 6, &D_800E69B0);
@@ -766,16 +766,16 @@ void OLakitu::update_object_lakitu_reverse(s32 objectIndex, s32 playerId) {
 void OLakitu::func_8007A66C(s32 objectIndex) {
     Player* player = &gPlayers[_playerId];
     Camera* camera = &cameras[_playerId];
-    u16 rot = 0x8000 - camera->rot[1];
+    u16 rot = 0x8000 - camera->rot.y;
 
-    gObjectList[objectIndex].pos[0] =
-        (player->pos[0] +
+    gObjectList[objectIndex].pos.x =
+        (player->pos.x +
          (coss(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) -
         (sins(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
-    gObjectList[objectIndex].pos[1] =
+    gObjectList[objectIndex].pos.y =
         player->unk_074 + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
-    gObjectList[objectIndex].pos[2] =
-        (player->pos[2] +
+    gObjectList[objectIndex].pos.z =
+        (player->pos.z +
          (sins(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) +
         (coss(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
 }
@@ -783,16 +783,16 @@ void OLakitu::func_8007A66C(s32 objectIndex) {
 void OLakitu::func_8007A778(s32 objectIndex) {
     Player* player = &gPlayers[_playerId];
     Camera* camera = &cameras[_playerId];
-    u16 rot = 0x8000 - camera->rot[1];
+    u16 rot = 0x8000 - camera->rot.y;
     
-    gObjectList[objectIndex].pos[0] =
-        (player->pos[0] +
+    gObjectList[objectIndex].pos.x =
+        (player->pos.x +
          (coss(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) -
         (sins(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
-    gObjectList[objectIndex].pos[1] =
-        player->pos[1] + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
-    gObjectList[objectIndex].pos[2] =
-        (player->pos[2] +
+    gObjectList[objectIndex].pos.y =
+        player->pos.y + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
+    gObjectList[objectIndex].pos.z =
+        (player->pos.z +
          (sins(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) +
         (coss(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
 }
diff --git a/src/engine/objects/Mole.cpp b/src/engine/objects/Mole.cpp
index 06bd5f56c..3055edf44 100644
--- a/src/engine/objects/Mole.cpp
+++ b/src/engine/objects/Mole.cpp
@@ -31,9 +31,9 @@ OMole::OMole(FVector pos, OMoleGroup* group) {
 
     find_unused_obj_index(&_objectIndex);
 
-    gObjectList[_objectIndex].pos[0] = pos.x * xOrientation;
-    gObjectList[_objectIndex].pos[1] = pos.y;
-    gObjectList[_objectIndex].pos[2] = pos.z;
+    gObjectList[_objectIndex].pos.x = pos.x * xOrientation;
+    gObjectList[_objectIndex].pos.y = pos.y;
+    gObjectList[_objectIndex].pos.z = pos.z;
 
     gObjectList[_objectIndex].origin_pos[0] = pos.x * xOrientation;
     gObjectList[_objectIndex].origin_pos[1] = pos.y - 9.0;
@@ -42,8 +42,8 @@ OMole::OMole(FVector pos, OMoleGroup* group) {
     // This is probably the mole particles
     find_unused_obj_index(&_moleIndex);
     init_object(_moleIndex, 0);
-    gObjectList[_moleIndex].pos[0] = pos.x * xOrientation;
-    gObjectList[_moleIndex].pos[2] = pos.z;
+    gObjectList[_moleIndex].pos.x = pos.x * xOrientation;
+    gObjectList[_moleIndex].pos.z = pos.z;
     func_800887C0(_moleIndex);
     gObjectList[_moleIndex].sizeScaling = 0.7f;
 
@@ -77,7 +77,7 @@ void OMole::func_80081790(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.3f, gObjectList[objectIndex].unk_034,
+            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.3f, gObjectList[objectIndex].unk_034,
                               gObjectList[objectIndex].orientation[1], 0x00000032) != 0) {
                 object_next_state(objectIndex);
             }
@@ -183,8 +183,8 @@ void OMole::func_8008153C(s32 objectIndex) {
                 gObjectList[loopObjectIndex].activeTLUT = d_course_moo_moo_farm_mole_dirt;
                 gObjectList[loopObjectIndex].tlutList = mole;
                 gObjectList[loopObjectIndex].sizeScaling = 0.15f;
-                gObjectList[loopObjectIndex].velocity[1] = random_int(0x000AU);
-                gObjectList[loopObjectIndex].velocity[1] = (gObjectList[loopObjectIndex].velocity[1] * 0.1) + 4.8;
+                gObjectList[loopObjectIndex].velocity.y = random_int(0x000AU);
+                gObjectList[loopObjectIndex].velocity.y = (gObjectList[loopObjectIndex].velocity.y * 0.1) + 4.8;
                 gObjectList[loopObjectIndex].unk_034 = random_int(5U);
                 gObjectList[loopObjectIndex].unk_034 = (gObjectList[loopObjectIndex].unk_034 * 0.01) + 0.8;
                 gObjectList[loopObjectIndex].orientation[1] = (0x10000 / sp70) * var_s1;
@@ -219,14 +219,14 @@ void OMole::func_80081D34(s32 objectIndex) {
                 } else {
                     player->soundEffects |= 2;
                 }
-                object->direction_angle[1] = camera->rot[1];
-                object->velocity[1] = (player->unk_094 / 2) + 3.0;
+                object->direction_angle[1] = camera->rot.y;
+                object->velocity.y = (player->unk_094 / 2) + 3.0;
                 object->unk_034 = player->unk_094 + 1.0;
-                if (object->velocity[1] >= 5.0) {
-                    object->velocity[1] = 5.0f;
+                if (object->velocity.y >= 5.0) {
+                    object->velocity.y = 5.0f;
                 }
                 if (object->unk_034 >= 4.0) {
-                    object->velocity[1] = 4.0f;
+                    object->velocity.y = 4.0f;
                 }
             }
         }
@@ -235,7 +235,7 @@ void OMole::func_80081D34(s32 objectIndex) {
         object = &gObjectList[objectIndex];
         clear_object_flag(objectIndex, 0x00000200);
         func_80086F60(objectIndex);
-        set_obj_origin_pos(objectIndex, object->pos[0], object->pos[1], object->pos[2]);
+        set_obj_origin_pos(objectIndex, object->pos.x, object->pos.y, object->pos.z);
         set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
         func_80086EAC(objectIndex, 2, 0x000A);
         func_800726CC(objectIndex, 0x0000000A);
@@ -265,7 +265,7 @@ void OMole::func_80081848(s32 objectIndex) {
     set_obj_direction_angle(objectIndex, 0U, 0U, 0U);
     set_obj_orientation(objectIndex, 0U, 0U, 0x8000U);
     gObjectList[objectIndex].boundingBoxSize = 6;
-    gObjectList[objectIndex].velocity[1] = 4.0f;
+    gObjectList[objectIndex].velocity.y = 4.0f;
     set_object_flag(objectIndex, 0x04000000);
     object_next_state(objectIndex);
 }
@@ -294,10 +294,10 @@ void OMole::func_80081924(s32 objectIndex) {
             break;
         case 10:
             gObjectList[objectIndex].orientation[2] += 0x1000;
-            gObjectList[objectIndex].velocity[1] -= 0.184;
+            gObjectList[objectIndex].velocity.y -= 0.184;
             func_8008751C(objectIndex);
             object_add_velocity_offset_xyz(objectIndex);
-            if (gObjectList[objectIndex].pos[1] <= -10.0) {
+            if (gObjectList[objectIndex].pos.y <= -10.0) {
                 func_80086F60(objectIndex);
             }
             break;
@@ -333,12 +333,12 @@ void OMole::func_800821AC(s32 objectIndex, s32 arg1) {
 void OMole::func_80054E10(s32 objectIndex) {
     if (gObjectList[objectIndex].state > 0) {
         if (is_obj_flag_status_active(objectIndex, 0x00800000) != 0) {
-            D_80183E50[0] = gObjectList[objectIndex].pos[0];
+            D_80183E50[0] = gObjectList[objectIndex].pos.x;
             D_80183E50[1] = gObjectList[objectIndex].surfaceHeight + 0.8;
-            D_80183E50[2] = gObjectList[objectIndex].pos[2];
-            D_80183E70[0] = gObjectList[objectIndex].velocity[0];
-            D_80183E70[1] = gObjectList[objectIndex].velocity[1];
-            D_80183E70[2] = gObjectList[objectIndex].velocity[2];
+            D_80183E50[2] = gObjectList[objectIndex].pos.z;
+            D_80183E70[0] = gObjectList[objectIndex].velocity.x;
+            D_80183E70[1] = gObjectList[objectIndex].velocity.y;
+            D_80183E70[2] = gObjectList[objectIndex].velocity.z;
             func_8004A9B8(gObjectList[objectIndex].sizeScaling);
         }
     }
@@ -362,7 +362,7 @@ void OMole::func_80054D00(s32 objectIndex, s32 cameraId) {
         if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
             D_80183E80[0] = (s16) gObjectList[objectIndex].orientation[0];
             D_80183E80[1] =
-                func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+                func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
             func_80048130(gObjectList[objectIndex].pos, (u16*) D_80183E80, gObjectList[objectIndex].sizeScaling,
                           (u8*) gObjectList[objectIndex].activeTLUT, (u8*)gObjectList[objectIndex].activeTexture,
@@ -384,7 +384,7 @@ if (_idx == 0) {
         if (object->state > 0) {
             func_8008A364(objectIndex, cameraId, 0x2AABU, 0x000000C8);
             if ((is_obj_flag_status_active(objectIndex, VISIBLE) != 0) && (gMatrixHudCount <= MTX_HUD_POOL_SIZE_MAX)) {
-                object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+                object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
                 rsp_set_matrix_gObjectList(objectIndex);
                 gSPDisplayList(gDisplayListHead++, (Gfx*)D_0D006980);
             }
diff --git a/src/engine/objects/Podium.cpp b/src/engine/objects/Podium.cpp
index ec396ca53..b063c252e 100644
--- a/src/engine/objects/Podium.cpp
+++ b/src/engine/objects/Podium.cpp
@@ -121,17 +121,17 @@ void OPodium::func_80086424(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            gObjectList[objectIndex].velocity[1] = 0.75f;
+            gObjectList[objectIndex].velocity.y = 0.75f;
             func_80086FD4(objectIndex);
             break;
         case 2:
             if (gObjectList[objectIndex].offset[1] >= -2.0) {
-                gObjectList[objectIndex].velocity[1] -= 0.1;
+                gObjectList[objectIndex].velocity.y -= 0.1;
             }
             object_add_velocity_offset_y(objectIndex);
             if (gObjectList[objectIndex].offset[1] >= 0.0) {
                 gObjectList[objectIndex].offset[1] = 0.0f;
-                gObjectList[objectIndex].velocity[1] = 0.0f;
+                gObjectList[objectIndex].velocity.y = 0.0f;
                 func_80086F60(objectIndex);
             }
             break;
diff --git a/src/engine/objects/Snowman.cpp b/src/engine/objects/Snowman.cpp
index 12beb9e47..5fcfbc7c3 100644
--- a/src/engine/objects/Snowman.cpp
+++ b/src/engine/objects/Snowman.cpp
@@ -27,9 +27,9 @@ OSnowman::OSnowman(const FVector& pos) {
     gObjectList[_headIndex].origin_pos[0] = pos.x * xOrientation;
     gObjectList[_headIndex].origin_pos[1] = pos.y + 5.0 + 3.0;
     gObjectList[_headIndex].origin_pos[2] = pos.z;
-    gObjectList[_headIndex].pos[0] = pos.x * xOrientation; 
-    gObjectList[_headIndex].pos[1] = pos.y + 5.0 + 3.0;
-    gObjectList[_headIndex].pos[2] = pos.z;
+    gObjectList[_headIndex].pos.x = pos.x * xOrientation; 
+    gObjectList[_headIndex].pos.y = pos.y + 5.0 + 3.0;
+    gObjectList[_headIndex].pos.z = pos.z;
 
     find_unused_obj_index(&_bodyIndex);
     init_object(_bodyIndex, 0);
@@ -38,9 +38,9 @@ OSnowman::OSnowman(const FVector& pos) {
     gObjectList[_bodyIndex].origin_pos[2] = pos.z;
     gObjectList[_bodyIndex].unk_0D5 = 0; // Section Id no longer used.
 
-    gObjectList[_bodyIndex].pos[0] = pos.x * xOrientation; 
-    gObjectList[_bodyIndex].pos[1] = pos.y + 3.0;
-    gObjectList[_bodyIndex].pos[2] = pos.z;
+    gObjectList[_bodyIndex].pos.x = pos.x * xOrientation; 
+    gObjectList[_bodyIndex].pos.y = pos.y + 3.0;
+    gObjectList[_bodyIndex].pos.z = pos.z;
 
     _count++;
 }
@@ -119,7 +119,7 @@ void OSnowman::DrawHead(s32 cameraId) {
         if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
             D_80183E80[0] = (s16) gObjectList[objectIndex].orientation[0];
             D_80183E80[1] =
-                func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+                func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
             if (is_obj_flag_status_active(objectIndex, 0x00000010) != 0) {
                 draw_2d_texture_at(gObjectList[objectIndex].pos, (u16*) D_80183E80,
@@ -157,7 +157,7 @@ void OSnowman::DrawBody(s32 cameraId) {
                 if (object->state > 0) {
                     func_8008A364(objectIndex, cameraId, 0x2AABU, 0x000001F4);
                     if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
-                        object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], sp44->pos);
+                        object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, sp44->pos);
                         rsp_set_matrix_gObjectList(objectIndex);
                         gSPDisplayList(gDisplayListHead++, (Gfx*)D_0D0069E0);
                     }
@@ -311,8 +311,8 @@ void OSnowman::func_80083538(s32 objectIndex, Vec3f arg1, s32 arg2, s32 arg3) {
     object->tlutList = (u8*)d_course_frappe_snowland_snow_tlut;
     object->sizeScaling = random_int(0x0064U);
     object->sizeScaling = (object->sizeScaling * 0.001) + 0.05;
-    object->velocity[1] = random_int(0x0014U);
-    object->velocity[1] = (object->velocity[1] * 0.5) + 2.6;
+    object->velocity.y = random_int(0x0014U);
+    object->velocity.y = (object->velocity.y * 0.5) + 2.6;
     object->unk_034 = random_int(0x000AU);
     object->unk_034 = (object->unk_034 * 0.1) + 4.5;
     object->direction_angle[1] = (arg2 << 0x10) / arg3;
@@ -327,7 +327,7 @@ void OSnowman::func_8008379C(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.74f,
+            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.74f,
                               gObjectList[objectIndex].unk_034, gObjectList[objectIndex].direction_angle[1],
                               0x00000064) != 0) {
                 object_next_state(objectIndex);
diff --git a/src/engine/objects/Thwomp.cpp b/src/engine/objects/Thwomp.cpp
index d3f99a8d9..e8fc3db37 100644
--- a/src/engine/objects/Thwomp.cpp
+++ b/src/engine/objects/Thwomp.cpp
@@ -221,12 +221,12 @@ void OThwomp::func_80080E8C(s32 objectIndex1, s32 objectIndex2, s32 arg2) {
     anAngle = gObjectList[objectIndex2].direction_angle[1];
     thing1 = func_800416D8(temp_v1[1], temp_v1[0], anAngle);
     thing0 = func_80041724(temp_v1[1], temp_v1[0], anAngle);
-    gObjectList[objectIndex1].origin_pos[0] = gObjectList[objectIndex2].pos[0] + thing0;
+    gObjectList[objectIndex1].origin_pos[0] = gObjectList[objectIndex2].pos.x + thing0;
     gObjectList[objectIndex1].origin_pos[1] = gObjectList[objectIndex2].surfaceHeight - 9.0;
-    gObjectList[objectIndex1].origin_pos[2] = gObjectList[objectIndex2].pos[2] + thing1;
+    gObjectList[objectIndex1].origin_pos[2] = gObjectList[objectIndex2].pos.z + thing1;
     anAngle = D_800E597C[arg2] + gObjectList[objectIndex2].direction_angle[1];
-    gObjectList[objectIndex1].velocity[0] = sins(anAngle) * 0.6;
-    gObjectList[objectIndex1].velocity[2] = coss(anAngle) * 0.6;
+    gObjectList[objectIndex1].velocity.x = sins(anAngle) * 0.6;
+    gObjectList[objectIndex1].velocity.z = coss(anAngle) * 0.6;
 }
 #else
 GLOBAL_ASM("asm/non_matchings/update_objects/func_80080E8C.s")
@@ -291,7 +291,7 @@ void OThwomp::func_80074FD8(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.12f,
+            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.12f,
                               gObjectList[objectIndex].unk_034, gObjectList[objectIndex].direction_angle[1],
                               0x00000064) != 0) {
                 object_next_state(objectIndex);
@@ -596,7 +596,7 @@ void OThwomp::func_8007F6C4(s32 objectIndex, s32 playerId) {
     func_800722A4(objectIndex, 8);
     func_80086E70(objectIndex);
     gObjectList[objectIndex].unk_0DD = 2;
-    gObjectList[objectIndex].unk_01C[0] = player->pos[0] - gObjectList[objectIndex].origin_pos[0];
+    gObjectList[objectIndex].unk_01C[0] = player->pos.x - gObjectList[objectIndex].origin_pos[0];
     gObjectList[objectIndex].unk_0D1 = playerId;
 }
 
@@ -713,7 +713,7 @@ void OThwomp::Draw(s32 cameraId) {
             object = &gObjectList[objectIndex];
             if ((object->state >= 2) && (State == MOVE_AND_ROTATE) && (gMatrixHudCount <= MTX_HUD_POOL_SIZE_MAX)) {
                 func_8004B138(0x000000FF, 0x000000FF, 0x000000FF, (s32) object->primAlpha);
-                D_80183E80[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+                D_80183E80[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
                 func_800431B0(object->pos, D_80183E80, object->sizeScaling, (Vtx*)D_0D005AE0);
             }
         }
@@ -932,7 +932,7 @@ void OThwomp::func_8007FA08(s32 objectIndex) {
     } else {
         set_obj_orientation(objectIndex, 0U, 0x4000U, 0U);
     }
-    object->velocity[0] = 0.0f;
+    object->velocity.x = 0.0f;
     object->direction_angle[1] = object->orientation[1];
     object->unk_0DD = 1;
     object->unk_0DF = 8;
@@ -963,25 +963,25 @@ void OThwomp::func_8007FB48(s32 objectIndex) {
             gObjectList[objectIndex].unk_0B0 = 0x00A0;
             gObjectList[objectIndex].offset[0] = 0.0f;
             gObjectList[objectIndex].offset[2] = 0.0f;
-            gObjectList[objectIndex].velocity[2] = 0.0f;
+            gObjectList[objectIndex].velocity.z = 0.0f;
             func_80086FD4(objectIndex);
             break;
         case 2:
-            gObjectList[objectIndex].velocity[0] = player->unk_094 * xOrientation * 1.25;
+            gObjectList[objectIndex].velocity.x = player->unk_094 * xOrientation * 1.25;
             if (gObjectList[objectIndex].unk_048 >= gObjectList[objectIndex].unk_0B0) {
                 if (gObjectList[objectIndex].unk_0B0 == gObjectList[objectIndex].unk_048) {
                     if (D_8018D400 & 1) {
-                        gObjectList[objectIndex].velocity[2] = 1.5f;
+                        gObjectList[objectIndex].velocity.z = 1.5f;
                     } else {
-                        gObjectList[objectIndex].velocity[2] = -1.5f;
+                        gObjectList[objectIndex].velocity.z = -1.5f;
                     }
                 }
-                if (gObjectList[objectIndex].velocity[2] >= 0.0) {
+                if (gObjectList[objectIndex].velocity.z >= 0.0) {
                     if (gObjectList[objectIndex].offset[2] >= 40.0) {
-                        gObjectList[objectIndex].velocity[2] = -1.5f;
+                        gObjectList[objectIndex].velocity.z = -1.5f;
                     }
                 } else if ((f64) gObjectList[objectIndex].offset[2] <= -40.0) {
-                    gObjectList[objectIndex].velocity[2] = 1.5f;
+                    gObjectList[objectIndex].velocity.z = 1.5f;
                 }
             }
             object_add_velocity_offset_xz(objectIndex);
@@ -1223,16 +1223,16 @@ void OThwomp::func_800806BC(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 250.0f, gObjectList[objectIndex].velocity[2]) !=
+            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 250.0f, gObjectList[objectIndex].velocity.z) !=
                 0) {
-                gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
+                gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
                 func_80086FD4(objectIndex);
             }
             break;
         case 2:
-            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity[2]) !=
+            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity.z) !=
                 0) {
-                gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
+                gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
                 func_8008701C(objectIndex, 1);
             }
             break;
@@ -1244,16 +1244,16 @@ void OThwomp::func_8008078C(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (f32_step_towards(&gObjectList[objectIndex].offset[2], -250.0f, gObjectList[objectIndex].velocity[2]) !=
+            if (f32_step_towards(&gObjectList[objectIndex].offset[2], -250.0f, gObjectList[objectIndex].velocity.z) !=
                 0) {
-                gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
+                gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
                 func_80086FD4(objectIndex);
             }
             break;
         case 2:
-            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity[2]) !=
+            if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity.z) !=
                 0) {
-                gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
+                gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
                 func_8008701C(objectIndex, 1);
             }
             break;
@@ -1286,11 +1286,11 @@ void OThwomp::func_80080524(s32 objectIndex) {
     switch (object->primAlpha) { /* irregular */
         case 0:
             object->unk_0DD = 2;
-            object->velocity[2] = -1.0f;
+            object->velocity.z = -1.0f;
             break;
         case 1:
             object->unk_0DD = 2;
-            object->velocity[2] = -1.5f;
+            object->velocity.z = -1.5f;
             break;
     }
     func_800722A4(objectIndex, 0x00000080);
diff --git a/src/engine/objects/TrashBin.cpp b/src/engine/objects/TrashBin.cpp
index c94d0352f..f4d71332e 100644
--- a/src/engine/objects/TrashBin.cpp
+++ b/src/engine/objects/TrashBin.cpp
@@ -80,17 +80,17 @@ void OTrashBin::init_bb_trash_bin(s32 objectIndex) {
     gObjectList[objectIndex].orientation[0] = DEGREES_FLOAT_TO_SHORT(_rot.pitch);
     gObjectList[objectIndex].orientation[1] = DEGREES_FLOAT_TO_SHORT(_rot.yaw);
     gObjectList[objectIndex].orientation[2] = DEGREES_FLOAT_TO_SHORT(_rot.roll);
-    gObjectList[objectIndex].pos[0] = _pos.x;
+    gObjectList[objectIndex].pos.x = _pos.x;
     if (_drawBin) {
         // Position the lid on-top of the box.
         // This might not be the best fix, but this allows the box to be placed on a surface
         // when spawned at 0,0,0
-        gObjectList[objectIndex].pos[0] = _pos.y + 32.0f;
+        gObjectList[objectIndex].pos.x = _pos.y + 32.0f;
     } else {
         // Stock implementation for banshee boardwalk
-        gObjectList[objectIndex].pos[1] = _pos.y;
+        gObjectList[objectIndex].pos.y = _pos.y;
     }
-    gObjectList[objectIndex].pos[2] = _pos.z;
+    gObjectList[objectIndex].pos.z = _pos.z;
     set_obj_velocity(objectIndex, 0.0f, 0.0f, 0.0f);
     gObjectList[objectIndex].type = 0;
     object_next_state(objectIndex);
diff --git a/src/engine/objects/Trophy.cpp b/src/engine/objects/Trophy.cpp
index 9f90b6be1..82882c8a2 100644
--- a/src/engine/objects/Trophy.cpp
+++ b/src/engine/objects/Trophy.cpp
@@ -86,9 +86,9 @@ OTrophy::OTrophy(const FVector& pos, TrophyType trophy, Behaviour bhv) {
     object->origin_pos[0] = _spawnPos.x;
     object->origin_pos[1] = _spawnPos.y;
     object->origin_pos[2] = _spawnPos.z;
-    object->pos[0] = _spawnPos.x;
-    object->pos[1] = _spawnPos.y;
-    object->pos[2] = _spawnPos.z;
+    object->pos.x = _spawnPos.x;
+    object->pos.y = _spawnPos.y;
+    object->pos.z = _spawnPos.z;
 
     _emitter = reinterpret_cast<StarEmitter*>(gWorldInstance.AddEmitter(new StarEmitter()));
 }
@@ -156,12 +156,12 @@ void OTrophy::Tick() { // func_80086D80
                 float yaw = (player->rotation[1] + 0x4000) * (M_PI / 32768.0f);   // Convert degrees to radians
 
                 // Calculate forward direction based on yaw (same as before)
-                float lookAtX = player->pos[0] + cos(yaw);
-                float lookAtZ = player->pos[2] + sin(yaw);
+                float lookAtX = player->pos.x + cos(yaw);
+                float lookAtZ = player->pos.z + sin(yaw);
 
-                float forwardX = lookAtX - player->pos[0];
+                float forwardX = lookAtX - player->pos.x;
                 float forwardY = 0; // Optional: Ignore height changes
-                float forwardZ = lookAtZ - player->pos[2];
+                float forwardZ = lookAtZ - player->pos.z;
 
                 // Normalize the forward vector
                 float length = sqrtf(forwardX * forwardX + forwardZ * forwardZ);
@@ -173,32 +173,32 @@ void OTrophy::Tick() { // func_80086D80
                 float distance = 30.0f;
 
                 // Calculate the object's position in front of the player (same as before)
-                gObjectList[objectIndex].pos[0] = player->pos[0] + forwardX * distance;
-                gObjectList[objectIndex].pos[1] = player->pos[1] + 8.0f;  // Optional height offset
-                gObjectList[objectIndex].pos[2] = player->pos[2] + forwardZ * distance;
+                gObjectList[objectIndex].pos.x = player->pos.x + forwardX * distance;
+                gObjectList[objectIndex].pos.y = player->pos.y + 8.0f;  // Optional height offset
+                gObjectList[objectIndex].pos.z = player->pos.z + forwardZ * distance;
 
                 // Apply more sensitive random movement based on player velocity to simulate floating behavior
                 float velocityFactor = 0.1f; // Increased factor for more sensitivity
-                gObjectList[objectIndex].pos[0] += player->velocity[0] * velocityFactor;
-                gObjectList[objectIndex].pos[1] += player->velocity[1] * velocityFactor; // Optional: Add vertical movement
-                gObjectList[objectIndex].pos[2] += player->velocity[2] * velocityFactor;
+                gObjectList[objectIndex].pos.x += player->velocity.x * velocityFactor;
+                gObjectList[objectIndex].pos.y += player->velocity.y * velocityFactor; // Optional: Add vertical movement
+                gObjectList[objectIndex].pos.z += player->velocity.z * velocityFactor;
 
                 // Increase oscillation for more dynamic movement (sine wave effect)
                 float oscillationSpeed = 4.0f; // Increased speed for quicker oscillations
                 float oscillationAmplitude = 0.4f; // Increased amplitude for more noticeable movement
-                gObjectList[objectIndex].pos[1] += oscillationAmplitude * sinf(oscillationSpeed * gGlobalTimer); // Vertical oscillation based on time
+                gObjectList[objectIndex].pos.y += oscillationAmplitude * sinf(oscillationSpeed * gGlobalTimer); // Vertical oscillation based on time
 
                 // Now use smooth interpolation (lerp) to gradually move the trophy towards its target position
                 float lerpFactor = 0.25f;  // Increased to make the trophy follow the player more quickly
 
-                gObjectList[objectIndex].pos[0] = _oldPos[0] + lerpFactor * (gObjectList[objectIndex].pos[0] - _oldPos[0]);
-                gObjectList[objectIndex].pos[1] = _oldPos[1] + lerpFactor * (gObjectList[objectIndex].pos[1] - _oldPos[1]);
-                gObjectList[objectIndex].pos[2] = _oldPos[2] + lerpFactor * (gObjectList[objectIndex].pos[2] - _oldPos[2]);
+                gObjectList[objectIndex].pos.x = _oldPos[0] + lerpFactor * (gObjectList[objectIndex].pos.x - _oldPos[0]);
+                gObjectList[objectIndex].pos.y = _oldPos[1] + lerpFactor * (gObjectList[objectIndex].pos.y - _oldPos[1]);
+                gObjectList[objectIndex].pos.z = _oldPos[2] + lerpFactor * (gObjectList[objectIndex].pos.z - _oldPos[2]);
 
                 // Save the current position for the next frame
-                _oldPos[0] = gObjectList[objectIndex].pos[0];
-                _oldPos[1] = gObjectList[objectIndex].pos[1];
-                _oldPos[2] = gObjectList[objectIndex].pos[2];
+                _oldPos[0] = gObjectList[objectIndex].pos.x;
+                _oldPos[1] = gObjectList[objectIndex].pos.y;
+                _oldPos[2] = gObjectList[objectIndex].pos.z;
 
             
                 gObjectList[objectIndex].direction_angle[0] += 0x400;
@@ -246,8 +246,8 @@ void OTrophy::Draw(s32 cameraId) {
 
 void OTrophy::func_80086700(s32 objectIndex) {
     gObjectList[objectIndex].sizeScaling = 0.005f;
-    set_obj_origin_pos(objectIndex, gObjectList[indexObjectList2[0]].pos[0],
-                       gObjectList[indexObjectList2[0]].pos[1] + 16.0, gObjectList[indexObjectList2[0]].pos[2]);
+    set_obj_origin_pos(objectIndex, gObjectList[indexObjectList2[0]].pos.x,
+                       gObjectList[indexObjectList2[0]].pos.y + 16.0, gObjectList[indexObjectList2[0]].pos.z);
     set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
     set_obj_direction_angle(objectIndex, 0U, 0U, 0U);
     gObjectList[objectIndex].unk_084[1] = 0x0200;
@@ -268,7 +268,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
         case 2:
             f32_step_towards(&object->sizeScaling, 0.025f, 0.001f);
             func_80087C48(objectIndex, 6.0f, 0.1f, 0x000000C8);
-            if ((f64) object->velocity[1] <= 0.0) {
+            if ((f64) object->velocity.y <= 0.0) {
                 func_8008701C(objectIndex, 3);
             }
             break;
@@ -277,7 +277,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
             break;
         case 4:
             D_801658D6 = 1;
-            object->velocity[1] = -0.4f;
+            object->velocity.y = -0.4f;
             func_80086FD4(objectIndex);
             // object->origin_pos[1] = 90.0f;
             object->offset[1] = 60.0f;
@@ -294,7 +294,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
             break;
         case 5:
             if ((f64) object->offset[1] <= 8.0) {
-                f32_step_towards(&object->velocity[1], -0.1f, -0.01f);
+                f32_step_towards(&object->velocity.y, -0.1f, -0.01f);
             }
             object_add_velocity_offset_y(objectIndex);
             if ((f64) object->offset[1] <= 0.0) {
@@ -338,12 +338,12 @@ void OTrophy::func_80086C14(s32 objectIndex) {
 void OTrophy::func_80086C6C(s32 objectIndex) {
     Vec3f sp24;
 
-    sp24[0] = (gObjectList[objectIndex].pos[0] - 5.0f) + random_int(0x000AU);
-    sp24[2] = (gObjectList[objectIndex].pos[2] - 5.0f) + random_int(0x000AU);
+    sp24[0] = (gObjectList[objectIndex].pos.x - 5.0f) + random_int(0x000AU);
+    sp24[2] = (gObjectList[objectIndex].pos.z - 5.0f) + random_int(0x000AU);
     if (D_801658F4 != 0) {
-        sp24[1] = gObjectList[objectIndex].pos[1] + 14.0;
+        sp24[1] = gObjectList[objectIndex].pos.y + 14.0;
     } else {
-        sp24[1] = gObjectList[objectIndex].pos[1] - 2.0;
+        sp24[1] = gObjectList[objectIndex].pos.y - 2.0;
     }
 
     if (_emitter != nullptr) {
diff --git a/src/engine/particles/StarEmitter.cpp b/src/engine/particles/StarEmitter.cpp
index 242e1a75a..bab33090b 100644
--- a/src/engine/particles/StarEmitter.cpp
+++ b/src/engine/particles/StarEmitter.cpp
@@ -37,14 +37,14 @@ void StarEmitter::Emit(Vec3f arg1, s32 arg2) { // func_80077138
     set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
     switch (arg2) {
         case 0:
-            gObjectList[objectIndex].velocity[1] = -1.0f;
+            gObjectList[objectIndex].velocity.y = -1.0f;
             gObjectList[objectIndex].unk_034 = (f32) ((random_int(0x004BU) * 0.01) + 0.25);
             gObjectList[objectIndex].direction_angle[1] = random_int(0x0040U) << 0xA;
             func_8008751C(objectIndex);
             gObjectList[objectIndex].unk_084[5] = 0x001E;
             break;
         case 1:
-            gObjectList[objectIndex].velocity[1] = 1.5f;
+            gObjectList[objectIndex].velocity.y = 1.5f;
             gObjectList[objectIndex].unk_034 = (f32) ((random_int(0x0064U) * 0.01) + 0.5);
             gObjectList[objectIndex].direction_angle[1] = random_int(0x0040U) << 0xA;
             func_8008751C(objectIndex);
@@ -114,8 +114,8 @@ void StarEmitter::Draw(s32 cameraId) { // func_80054BE8
 }
 
 void StarEmitter::func_80054AFC(s32 objectIndex, Vec3f arg1) {
-    D_80183E80[0] = func_800418E8(gObjectList[objectIndex].pos[2], gObjectList[objectIndex].pos[1], arg1);
-    D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], arg1);
+    D_80183E80[0] = func_800418E8(gObjectList[objectIndex].pos.z, gObjectList[objectIndex].pos.y, arg1);
+    D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, arg1);
     D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
     func_8004B138((s32) gObjectList[objectIndex].unk_084[0], (s32) gObjectList[objectIndex].unk_084[1],
                   (s32) gObjectList[objectIndex].unk_084[2], (s32) gObjectList[objectIndex].primAlpha);
@@ -135,11 +135,11 @@ void StarEmitter::func_80077584(s32 objectIndex) {
 
     object = &gObjectList[objectIndex];
     if ((object->unk_0AE != 0) && (object->unk_0AE == 1) && ((u8) object->unk_0D8 != 0)) {
-        if (object->velocity[1] >= -0.5) {
-            object->velocity[1] -= 0.15;
+        if (object->velocity.y >= -0.5) {
+            object->velocity.y -= 0.15;
         } else {
-            object->velocity[2] = 0.0f;
-            object->velocity[0] = 0.0f;
+            object->velocity.z = 0.0f;
+            object->velocity.x = 0.0f;
         }
     }
     object->orientation[2] += object->unk_084[3];
@@ -161,7 +161,7 @@ void StarEmitter::func_80077450(s32 objectIndex) {
             break;
         case 2:
             f32_step_up_towards(&gObjectList[objectIndex].sizeScaling, 0.1f, 0.01f);
-            if ((gObjectList[objectIndex].pos[1] <= gObjectList[objectIndex].unk_084[5]) &&
+            if ((gObjectList[objectIndex].pos.y <= gObjectList[objectIndex].unk_084[5]) &&
                 (func_80073B00(objectIndex, &gObjectList[objectIndex].primAlpha, 0x000000FF, 0, 0x00000010, 0, 0) !=
                  0)) {
                 func_80086F60(objectIndex);
diff --git a/src/engine/vehicles/Boat.cpp b/src/engine/vehicles/Boat.cpp
index 073974581..224b3ded5 100644
--- a/src/engine/vehicles/Boat.cpp
+++ b/src/engine/vehicles/Boat.cpp
@@ -150,13 +150,13 @@ void ABoat::Tick() {
         Velocity[1] = Position[1] - temp_f28;
         Velocity[2] = Position[2] - temp_f30;
         paddleBoatActor = GET_ACTOR(ActorIndex);
-        paddleBoatActor->pos[0] = Position[0];
-        paddleBoatActor->pos[1] = Position[1];
-        paddleBoatActor->pos[2] = Position[2];
+        paddleBoatActor->pos.x = Position[0];
+        paddleBoatActor->pos.y = Position[1];
+        paddleBoatActor->pos.z = Position[2];
         if (gIsMirrorMode != 0) {
-            paddleBoatActor->rot[1] = -RotY;
+            paddleBoatActor->rot.y = -RotY;
         } else {
-            paddleBoatActor->rot[1] = RotY;
+            paddleBoatActor->rot.y = RotY;
         }
         Velocity[0] = Velocity[0];
         Velocity[1] = Velocity[1];
@@ -173,9 +173,9 @@ void ABoat::VehicleCollision(s32 playerId, Player* player) {
     f32 playerY;
 
     if (!((player->effects & 0x01000000)) && (!(player->effects & HIT_BY_ITEM_EFFECT))) {
-        playerX = player->pos[0];
-        playerY = player->pos[1];
-        playerZ = player->pos[2];
+        playerX = player->pos.x;
+        playerY = player->pos.y;
+        playerZ = player->pos.z;
         if (IsActive == 1) {
             x_diff = playerX - Position[0];
             y_diff = playerY - Position[1];
diff --git a/src/engine/vehicles/Bus.cpp b/src/engine/vehicles/Bus.cpp
index c58cd0a6c..30c442868 100644
--- a/src/engine/vehicles/Bus.cpp
+++ b/src/engine/vehicles/Bus.cpp
@@ -137,19 +137,19 @@ void ABus::Tick() {
     Velocity[1] = Position[1] - sp58;
     Velocity[2] = Position[2] - sp54;
     struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
-    vehicleActor->pos[0] = Position[0];
-    vehicleActor->pos[1] = Position[1];
-    vehicleActor->pos[2] = Position[2];
-    vehicleActor->rot[0] = Rotation[0];
+    vehicleActor->pos.x = Position[0];
+    vehicleActor->pos.y = Position[1];
+    vehicleActor->pos.z = Position[2];
+    vehicleActor->rot.x = Rotation[0];
     if (gIsMirrorMode != 0) {
-        vehicleActor->rot[1] = -Rotation[1];
+        vehicleActor->rot.y = -Rotation[1];
     } else {
-        vehicleActor->rot[1] = Rotation[1];
+        vehicleActor->rot.y = Rotation[1];
     }
-    vehicleActor->rot[2] = Rotation[2];
-    vehicleActor->velocity[0] = Velocity[0];
-    vehicleActor->velocity[1] = Velocity[1];
-    vehicleActor->velocity[2] = Velocity[2];
+    vehicleActor->rot.z = Rotation[2];
+    vehicleActor->velocity.x = Velocity[0];
+    vehicleActor->velocity.y = Velocity[1];
+    vehicleActor->velocity.z = Velocity[2];
 }
 
 void ABus::VehicleCollision(s32 playerId, Player* player) {
@@ -164,9 +164,9 @@ void ABus::VehicleCollision(s32 playerId, Player* player) {
     if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
         !(player->effects & 0x01000000)) {
 
-        spC4 = player->pos[0];
-        spC0 = player->pos[1];
-        spBC = player->pos[2];
+        spC4 = player->pos.x;
+        spC0 = player->pos.y;
+        spBC = player->pos.z;
 
         temp_f12 = spC4 - Position[0];
         temp_f22 = spC0 - Position[1];
diff --git a/src/engine/vehicles/Car.cpp b/src/engine/vehicles/Car.cpp
index 89409df50..847efad0e 100644
--- a/src/engine/vehicles/Car.cpp
+++ b/src/engine/vehicles/Car.cpp
@@ -119,19 +119,19 @@ void ACar::Tick() {
     Velocity[1] = Position[1] - sp58;
     Velocity[2] = Position[2] - sp54;
     struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
-    vehicleActor->pos[0] = Position[0];
-    vehicleActor->pos[1] = Position[1];
-    vehicleActor->pos[2] = Position[2];
-    vehicleActor->rot[0] = Rotation[0];
+    vehicleActor->pos.x = Position[0];
+    vehicleActor->pos.y = Position[1];
+    vehicleActor->pos.z = Position[2];
+    vehicleActor->rot.x = Rotation[0];
     if (gIsMirrorMode != 0) {
-        vehicleActor->rot[1] = -Rotation[1];
+        vehicleActor->rot.y = -Rotation[1];
     } else {
-        vehicleActor->rot[1] = Rotation[1];
+        vehicleActor->rot.y = Rotation[1];
     }
-    vehicleActor->rot[2] = Rotation[2];
-    vehicleActor->velocity[0] = Velocity[0];
-    vehicleActor->velocity[1] = Velocity[1];
-    vehicleActor->velocity[2] = Velocity[2];
+    vehicleActor->rot.z = Rotation[2];
+    vehicleActor->velocity.x = Velocity[0];
+    vehicleActor->velocity.y = Velocity[1];
+    vehicleActor->velocity.z = Velocity[2];
 }
 
 void ACar::Draw(Camera* camera) {
@@ -164,9 +164,9 @@ void ACar::VehicleCollision(s32 playerId, Player* player) {
     if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
         !(player->effects & 0x01000000)) {
 
-        spC4 = player->pos[0];
-        spC0 = player->pos[1];
-        spBC = player->pos[2];
+        spC4 = player->pos.x;
+        spC0 = player->pos.y;
+        spBC = player->pos.z;
 
         temp_f12 = spC4 - Position[0];
         temp_f22 = spC0 - Position[1];
diff --git a/src/engine/vehicles/TankerTruck.cpp b/src/engine/vehicles/TankerTruck.cpp
index 02cd9553b..c7acaace4 100644
--- a/src/engine/vehicles/TankerTruck.cpp
+++ b/src/engine/vehicles/TankerTruck.cpp
@@ -137,19 +137,19 @@ void ATankerTruck::Tick() {
     Velocity[1] = Position[1] - sp58;
     Velocity[2] = Position[2] - sp54;
     struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
-    vehicleActor->pos[0] = Position[0];
-    vehicleActor->pos[1] = Position[1];
-    vehicleActor->pos[2] = Position[2];
-    vehicleActor->rot[0] = Rotation[0];
+    vehicleActor->pos.x = Position[0];
+    vehicleActor->pos.y = Position[1];
+    vehicleActor->pos.z = Position[2];
+    vehicleActor->rot.x = Rotation[0];
     if (gIsMirrorMode != 0) {
-        vehicleActor->rot[1] = -Rotation[1];
+        vehicleActor->rot.y = -Rotation[1];
     } else {
-        vehicleActor->rot[1] = Rotation[1];
+        vehicleActor->rot.y = Rotation[1];
     }
-    vehicleActor->rot[2] = Rotation[2];
-    vehicleActor->velocity[0] = Velocity[0];
-    vehicleActor->velocity[1] = Velocity[1];
-    vehicleActor->velocity[2] = Velocity[2];
+    vehicleActor->rot.z = Rotation[2];
+    vehicleActor->velocity.x = Velocity[0];
+    vehicleActor->velocity.y = Velocity[1];
+    vehicleActor->velocity.z = Velocity[2];
 }
 
 void ATankerTruck::VehicleCollision(s32 playerId, Player* player) {
@@ -164,9 +164,9 @@ void ATankerTruck::VehicleCollision(s32 playerId, Player* player) {
     if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
         !(player->effects & 0x01000000)) {
 
-        spC4 = player->pos[0];
-        spC0 = player->pos[1];
-        spBC = player->pos[2];
+        spC4 = player->pos.x;
+        spC0 = player->pos.y;
+        spBC = player->pos.z;
 
         temp_f12 = spC4 - Position[0];
         temp_f22 = spC0 - Position[1];
diff --git a/src/engine/vehicles/Train.cpp b/src/engine/vehicles/Train.cpp
index a3952742d..78ec1a9f5 100644
--- a/src/engine/vehicles/Train.cpp
+++ b/src/engine/vehicles/Train.cpp
@@ -86,24 +86,24 @@ ATrain::ATrain(ATrain::TenderStatus tender, size_t numCarriages, f32 speed, uint
     f32 origZPos;
 
     tempLocomotive = &Locomotive;
-    origXPos = tempLocomotive->position[0];
-    origZPos = tempLocomotive->position[2];
+    origXPos = tempLocomotive->position.x;
+    origZPos = tempLocomotive->position.z;
     trainCarYRot = update_vehicle_following_waypoint(
         tempLocomotive->position, (s16*) &tempLocomotive->waypointIndex, Speed);
-    tempLocomotive->velocity[0] = tempLocomotive->position[0] - origXPos;
-    tempLocomotive->velocity[2] = tempLocomotive->position[2] - origZPos;
+    tempLocomotive->velocity.x = tempLocomotive->position.x - origXPos;
+    tempLocomotive->velocity.z = tempLocomotive->position.z - origZPos;
     vec3s_set(trainCarRot, 0, trainCarYRot, 0);
     tempLocomotive->actorIndex = add_actor_to_empty_slot(tempLocomotive->position, trainCarRot,
                                                             tempLocomotive->velocity, ACTOR_TRAIN_ENGINE);
 
     tempTender = &Tender;
     if (tempTender->isActive == 1) {
-        origXPos = tempTender->position[0];
-        origZPos = tempTender->position[2];
+        origXPos = tempTender->position.x;
+        origZPos = tempTender->position.z;
         trainCarYRot = update_vehicle_following_waypoint(
             tempTender->position, (s16*) &tempTender->waypointIndex, Speed);
-        tempTender->velocity[0] = tempTender->position[0] - origXPos;
-        tempTender->velocity[2] = tempTender->position[2] - origZPos;
+        tempTender->velocity.x = tempTender->position.x - origXPos;
+        tempTender->velocity.z = tempTender->position.z - origZPos;
         vec3s_set(trainCarRot, 0, trainCarYRot, 0);
         tempTender->actorIndex = add_actor_to_empty_slot(tempTender->position, trainCarRot,
                                                             tempTender->velocity, ACTOR_TRAIN_TENDER);
@@ -112,13 +112,13 @@ ATrain::ATrain(ATrain::TenderStatus tender, size_t numCarriages, f32 speed, uint
     for (size_t i = 0; i < PassengerCars.size(); i++) {
         tempPassengerCar = &PassengerCars[i];
         if (tempPassengerCar->isActive == 1) {
-            origXPos = tempPassengerCar->position[0];
-            origZPos = tempPassengerCar->position[2];
+            origXPos = tempPassengerCar->position.x;
+            origZPos = tempPassengerCar->position.z;
             trainCarYRot = update_vehicle_following_waypoint(tempPassengerCar->position,
                                                                 (s16*) &tempPassengerCar->waypointIndex,
                                                                 Speed);
-            tempPassengerCar->velocity[0] = tempPassengerCar->position[0] - origXPos;
-            tempPassengerCar->velocity[2] = tempPassengerCar->position[2] - origZPos;
+            tempPassengerCar->velocity.x = tempPassengerCar->position.x - origXPos;
+            tempPassengerCar->velocity.z = tempPassengerCar->position.z - origZPos;
             vec3s_set(trainCarRot, 0, trainCarYRot, 0);
             tempPassengerCar->actorIndex =
                 add_actor_to_empty_slot(tempPassengerCar->position, trainCarRot, tempPassengerCar->velocity,
@@ -138,16 +138,16 @@ void ATrain::SyncComponents(TrainCarStuff* trainCar, s16 orientationY) {
 
     //! @todo: Change actorIndex to ptr to TrainCar actor
     trainCarActor = (struct TrainCar*) GET_ACTOR(trainCar->actorIndex);
-    trainCarActor->pos[0] = trainCar->position[0];
-    trainCarActor->pos[1] = trainCar->position[1];
-    trainCarActor->pos[2] = trainCar->position[2];
+    trainCarActor->pos.x = trainCar->position.x;
+    trainCarActor->pos.y = trainCar->position.y;
+    trainCarActor->pos.z = trainCar->position.z;
     if (gIsMirrorMode != 0) {
-        trainCarActor->rot[1] = -orientationY;
+        trainCarActor->rot.y = -orientationY;
     } else {
-        trainCarActor->rot[1] = orientationY;
+        trainCarActor->rot.y = orientationY;
     }
-    trainCarActor->velocity[0] = trainCar->velocity[0];
-    trainCarActor->velocity[2] = trainCar->velocity[2];
+    trainCarActor->velocity.x = trainCar->velocity.x;
+    trainCarActor->velocity.z = trainCar->velocity.z;
 }
 
 void ATrain::Tick() {
@@ -163,14 +163,14 @@ void ATrain::Tick() {
 
     oldWaypointIndex = (u16) Locomotive.waypointIndex;
 
-    temp_f20 = Locomotive.position[0];
-    temp_f22 = Locomotive.position[2];
+    temp_f20 = Locomotive.position.x;
+    temp_f22 = Locomotive.position.z;
 
     orientationYUpdate = update_vehicle_following_waypoint(
         Locomotive.position, (s16*) &Locomotive.waypointIndex, Speed);
 
-    Locomotive.velocity[0] = Locomotive.position[0] - temp_f20;
-    Locomotive.velocity[2] = Locomotive.position[2] - temp_f22;
+    Locomotive.velocity.x = Locomotive.position.x - temp_f20;
+    Locomotive.velocity.z = Locomotive.position.z - temp_f22;
 
     sync_train_components(&Locomotive, orientationYUpdate);
 
@@ -188,9 +188,9 @@ void ATrain::Tick() {
         Locomotive.position, TRAIN_SMOKE_RENDER_DISTANCE, SomeFlags);
     // Renders locomotive smoke on all screens if any player is within range.
     if ((((s16) AnotherSmokeTimer % 5) == 0) && (SomeFlags != 0)) {
-        smokePos[0] = Locomotive.position[0];
-        smokePos[1] = (f32) ((f64) Locomotive.position[1] + 65.0);
-        smokePos[2] = (f32) ((f64) Locomotive.position[2] + 25.0);
+        smokePos[0] = Locomotive.position.x;
+        smokePos[1] = (f32) ((f64) Locomotive.position.y + 65.0);
+        smokePos[2] = (f32) ((f64) Locomotive.position.z + 25.0);
         adjust_position_by_angle(smokePos, Locomotive.position, orientationYUpdate);
         //spawn_train_smoke(Index, smokePos, 1.1f);
         AddSmoke(Index, smokePos, 1.1f);
@@ -199,25 +199,25 @@ void ATrain::Tick() {
     car = &Tender;
 
     if (car->isActive == 1) {
-        temp_f20 = car->position[0];
-        temp_f22 = car->position[2];
+        temp_f20 = car->position.x;
+        temp_f22 = car->position.z;
         orientationYUpdate =
             update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, Speed);
-        car->velocity[0] = car->position[0] - temp_f20;
-        car->velocity[2] = car->position[2] - temp_f22;
+        car->velocity.x = car->position.x - temp_f20;
+        car->velocity.z = car->position.z - temp_f22;
         sync_train_components(car, orientationYUpdate);
     }
 
     for (j = 0; j < PassengerCars.size(); j++) {
         car = &PassengerCars[j];
         if (car->isActive == 1) {
-            temp_f20 = car->position[0];
-            temp_f22 = car->position[2];
+            temp_f20 = car->position.x;
+            temp_f22 = car->position.z;
 
             orientationYUpdate =
                 update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, Speed);
-            car->velocity[0] = car->position[0] - temp_f20;
-            car->velocity[2] = car->position[2] - temp_f22;
+            car->velocity.x = car->position.x - temp_f20;
+            car->velocity.z = car->position.z - temp_f22;
             sync_train_components(car, orientationYUpdate);
         }
     }
@@ -233,21 +233,21 @@ void ATrain::VehicleCollision(s32 playerId, Player* player) {
 
     if (D_801631E0[playerId] != 1) {
         if (!(player->effects & 0x01000000)) {
-            playerPosX = player->pos[0];
-            playerPosZ = player->pos[2];
+            playerPosX = player->pos.x;
+            playerPosZ = player->pos.z;
             trainCar = &Locomotive;
-            x_dist = playerPosX - trainCar->position[0];
-            z_dist = playerPosZ - trainCar->position[2];
+            x_dist = playerPosX - trainCar->position.x;
+            z_dist = playerPosZ - trainCar->position.z;
             if ((x_dist > -100.0) && (x_dist < 100.0)) {
                 if ((z_dist > -100.0) && (z_dist < 100.0)) {
-                    if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                        trainCar->velocity[2], 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                    if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                        trainCar->velocity.z, 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                         player->soundEffects |= REVERSE_SOUND_EFFECT;
                     }
                     trainCar = &Tender;
                     if (trainCar->isActive == 1) {
-                        if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                            trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                        if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                            trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                             player->soundEffects |= REVERSE_SOUND_EFFECT;
                         }
                     }
@@ -256,13 +256,13 @@ void ATrain::VehicleCollision(s32 playerId, Player* player) {
 
             for (size_t i = 0; i < PassengerCars.size(); i++) {
                 trainCar = &PassengerCars[i];
-                x_dist = playerPosX - trainCar->position[0];
-                z_dist = playerPosZ - trainCar->position[2];
+                x_dist = playerPosX - trainCar->position.x;
+                z_dist = playerPosZ - trainCar->position.z;
                 if (trainCar->isActive == 1) {
                     if ((x_dist > -100.0) && (x_dist < 100.0)) {
                         if ((z_dist > -100.0) && (z_dist < 100.0)) {
-                            if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
-                                                trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
+                            if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
+                                                trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
                                 player->soundEffects |= REVERSE_SOUND_EFFECT;
                             }
                         }
diff --git a/src/engine/vehicles/Truck.cpp b/src/engine/vehicles/Truck.cpp
index 585293489..741fb6557 100644
--- a/src/engine/vehicles/Truck.cpp
+++ b/src/engine/vehicles/Truck.cpp
@@ -137,19 +137,19 @@ void ATruck::Tick() {
     Velocity[1] = Position[1] - sp58;
     Velocity[2] = Position[2] - sp54;
     struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
-    vehicleActor->pos[0] = Position[0];
-    vehicleActor->pos[1] = Position[1];
-    vehicleActor->pos[2] = Position[2];
-    vehicleActor->rot[0] = Rotation[0];
+    vehicleActor->pos.x = Position[0];
+    vehicleActor->pos.y = Position[1];
+    vehicleActor->pos.z = Position[2];
+    vehicleActor->rot.x = Rotation[0];
     if (gIsMirrorMode != 0) {
-        vehicleActor->rot[1] = -Rotation[1];
+        vehicleActor->rot.y = -Rotation[1];
     } else {
-        vehicleActor->rot[1] = Rotation[1];
+        vehicleActor->rot.y = Rotation[1];
     }
-    vehicleActor->rot[2] = Rotation[2];
-    vehicleActor->velocity[0] = Velocity[0];
-    vehicleActor->velocity[1] = Velocity[1];
-    vehicleActor->velocity[2] = Velocity[2];
+    vehicleActor->rot.z = Rotation[2];
+    vehicleActor->velocity.x = Velocity[0];
+    vehicleActor->velocity.y = Velocity[1];
+    vehicleActor->velocity.z = Velocity[2];
 }
 
 void ATruck::VehicleCollision(s32 playerId, Player* player) {
@@ -164,9 +164,9 @@ void ATruck::VehicleCollision(s32 playerId, Player* player) {
     if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
         !(player->effects & 0x01000000)) {
 
-        spC4 = player->pos[0];
-        spC0 = player->pos[1];
-        spBC = player->pos[2];
+        spC4 = player->pos.x;
+        spC0 = player->pos.y;
+        spBC = player->pos.z;
 
         temp_f12 = spC4 - Position[0];
         temp_f22 = spC0 - Position[1];
diff --git a/src/enhancements/freecam/freecam.cpp b/src/enhancements/freecam/freecam.cpp
index 86dfef575..8c81e8244 100644
--- a/src/enhancements/freecam/freecam.cpp
+++ b/src/enhancements/freecam/freecam.cpp
@@ -367,9 +367,9 @@ void freecam_keyboard_manager(Camera* camera, Vec3f forwardVector) {
     if (Down) {
         totalMove[1] -= moveSpeed; // Move down
     }
-    freeCam.velocity[0] += totalMove[0];
-    freeCam.velocity[1] += totalMove[1];
-    freeCam.velocity[2] += totalMove[2];
+    freeCam.velocity.x += totalMove[0];
+    freeCam.velocity.y += totalMove[1];
+    freeCam.velocity.z += totalMove[2];
 }
 
 void freecam_update_controller(void) {
@@ -402,8 +402,8 @@ void freecam_render_setup(void) {
                   CM_GetProps()->NearPersp, CM_GetProps()->FarPersp, 1.0f);
     gSPPerspNormalize(gDisplayListHead++, perspNorm);
     gSPMatrix(gDisplayListHead++, (&gGfxPool->mtxPersp[0]), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
-    guLookAt(&gGfxPool->mtxLookAt[0], camera1->pos[0], camera1->pos[1], camera1->pos[2], camera1->lookAt[0],
-             camera1->lookAt[1], camera1->lookAt[2], camera1->up[0], camera1->up[1], camera1->up[2]);
+    guLookAt(&gGfxPool->mtxLookAt[0], camera1->pos.x, camera1->pos.y, camera1->pos.z, camera1->lookAt.x,
+             camera1->lookAt.y, camera1->lookAt.z, camera1->up[0], camera1->up[1], camera1->up[2]);
     gSPMatrix(gDisplayListHead++, (&gGfxPool->mtxLookAt[0]), G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
     mtxf_identity(matrix);
     gSPSetGeometryMode(gDisplayListHead++, G_CULL_BACK);
diff --git a/src/enhancements/freecam/freecam_engine.c b/src/enhancements/freecam/freecam_engine.c
index 350ab192b..bd9db9a20 100644
--- a/src/enhancements/freecam/freecam_engine.c
+++ b/src/enhancements/freecam/freecam_engine.c
@@ -22,58 +22,58 @@ f32 gRotDampValue = 0.96f;
 void freecam_tick(Camera* camera, Vec3f forwardVector) {
 
     // Apply camera movement
-    camera->pos[0] += freeCam.velocity[0] * gDeltaTime;
-    camera->pos[1] += freeCam.velocity[1] * gDeltaTime;
-    camera->pos[2] += freeCam.velocity[2] * gDeltaTime;
+    camera->pos.x += freeCam.velocity.x * gDeltaTime;
+    camera->pos.y += freeCam.velocity.y * gDeltaTime;
+    camera->pos.z += freeCam.velocity.z * gDeltaTime;
 
     // Damp the velocity back to zero over time (camera slowly comes to a stop)
-    freeCam.velocity[0] *= gDampValue;
-    freeCam.velocity[1] *= gDampValue;
-    freeCam.velocity[2] *= gDampValue;
+    freeCam.velocity.x *= gDampValue;
+    freeCam.velocity.y *= gDampValue;
+    freeCam.velocity.z *= gDampValue;
 
     // Apply camera rotation
-    camera->rot[0] += freeCam.rotVelocity[0] * gDeltaTime;
-    camera->rot[1] += freeCam.rotVelocity[1] * gDeltaTime;
-    camera->rot[2] += freeCam.rotVelocity[2] * gDeltaTime;
+    camera->rot.x += freeCam.rotVelocity.x * gDeltaTime;
+    camera->rot.y += freeCam.rotVelocity.y * gDeltaTime;
+    camera->rot.z += freeCam.rotVelocity.z * gDeltaTime;
 
     // Damp the velocity back to zero over time (camera rot slowly comes to a stop)
-    freeCam.rotVelocity[0] *= gRotDampValue;
-    freeCam.rotVelocity[1] *= gRotDampValue;
-    freeCam.rotVelocity[2] *= gRotDampValue;
+    freeCam.rotVelocity.x *= gRotDampValue;
+    freeCam.rotVelocity.y *= gRotDampValue;
+    freeCam.rotVelocity.z *= gRotDampValue;
 
     // Update lookAt
-    camera->lookAt[0] = camera->pos[0] + forwardVector[0];
-    camera->lookAt[1] = camera->pos[1] + forwardVector[1];
-    camera->lookAt[2] = camera->pos[2] + forwardVector[2];
+    camera->lookAt.x = camera->pos.x + forwardVector.x;
+    camera->lookAt.y = camera->pos.y + forwardVector.y;
+    camera->lookAt.z = camera->pos.z + forwardVector.z;
 }
 
 void freecam_calculate_forward_vector_allow_rotation(Camera* camera, Vec3f forwardVector) {
     // Convert yaw from 0-65535 to degrees
-    f32 pitch = (camera->rot[2] / 65535.0f) * 360.0f;
-    f32 yaw = (camera->rot[1] / 65535.0f) * 360.0f;
+    f32 pitch = (camera->rot.z / 65535.0f) * 360.0f;
+    f32 yaw = (camera->rot.y / 65535.0f) * 360.0f;
 
     // Convert degrees to radians
     pitch = pitch * M_PI / 180.0f;
     yaw = yaw * M_PI / 180.0f;
 
     // Calculate the forward vector based on yaw, ignoring pitch to keep height unchanged
-    forwardVector[0] = -sinf(yaw);
-    forwardVector[1] = -sinf(pitch); // Keep the height unchanged
-    forwardVector[2] = cosf(yaw);
+    forwardVector.x = -sinf(yaw);
+    forwardVector.y = -sinf(pitch); // Keep the height unchanged
+    forwardVector.z = cosf(yaw);
 }
 
 f32 gFreecamFollowFactor = 0.7;
 
 void freecam_target_player(Camera* camera, Vec3f forwardVector) {
     // Apply damping to velocity
-    freeCam.velocity[0] *= gDampValue;
-    freeCam.velocity[1] *= gDampValue;
-    freeCam.velocity[2] *= gDampValue;
+    freeCam.velocity.x *= gDampValue;
+    freeCam.velocity.y *= gDampValue;
+    freeCam.velocity.z *= gDampValue;
 
     // Calculate the direction from the player to the camera
-    f32 dirX = gPlayers[fRankIndex].pos[0] - camera->pos[0];
-    f32 dirY = gPlayers[fRankIndex].pos[1] - camera->pos[1];
-    f32 dirZ = gPlayers[fRankIndex].pos[2] - camera->pos[2];
+    f32 dirX = gPlayers[fRankIndex].pos.x - camera->pos.x;
+    f32 dirY = gPlayers[fRankIndex].pos.y - camera->pos.y;
+    f32 dirZ = gPlayers[fRankIndex].pos.z - camera->pos.z;
 
     // Normalize the direction vector (if needed)
     f32 length = sqrtf(dirX * dirX + dirY * dirY + dirZ * dirZ);
@@ -84,33 +84,33 @@ void freecam_target_player(Camera* camera, Vec3f forwardVector) {
     }
 
     // Update the camera's look-at direction
-    camera->lookAt[0] = camera->pos[0] + dirX;
-    camera->lookAt[1] = camera->pos[1] + dirY;
-    camera->lookAt[2] = camera->pos[2] + dirZ;
+    camera->lookAt.x = camera->pos.x + dirX;
+    camera->lookAt.y = camera->pos.y + dirY;
+    camera->lookAt.z = camera->pos.z + dirZ;
 
     // Calculate the forward vector based on the updated look-at direction
-    forwardVector[0] = camera->lookAt[0] - camera->pos[0];
-    forwardVector[1] = camera->lookAt[1] - camera->pos[1];
-    forwardVector[2] = camera->lookAt[2] - camera->pos[2];
+    forwardVector.x = camera->lookAt.x - camera->pos.x;
+    forwardVector.y = camera->lookAt.y - camera->pos.y;
+    forwardVector.z = camera->lookAt.z - camera->pos.z;
 
     // Normalize the forward vector
-    f32 forwardLength = sqrtf(forwardVector[0] * forwardVector[0] + forwardVector[1] * forwardVector[1] +
-                              forwardVector[2] * forwardVector[2]);
+    f32 forwardLength = sqrtf(forwardVector.x * forwardVector.x + forwardVector.y * forwardVector.y +
+                              forwardVector.z * forwardVector.z);
     if (forwardLength > 0.0f) {
-        forwardVector[0] /= forwardLength;
-        forwardVector[1] /= forwardLength;
-        forwardVector[2] /= forwardLength;
+        forwardVector.x /= forwardLength;
+        forwardVector.y /= forwardLength;
+        forwardVector.z /= forwardLength;
     }
 
     // Store or return the forward vector as needed for subsequent movement calculations
-    freeCam.forwardVector[0] = forwardVector[0];
-    freeCam.forwardVector[1] = forwardVector[1];
-    freeCam.forwardVector[2] = forwardVector[2];
+    freeCam.forwardVector.x = forwardVector.x;
+    freeCam.forwardVector.y = forwardVector.y;
+    freeCam.forwardVector.z = forwardVector.z;
 
     // Movement
-    freeCam.velocity[0] += gPlayers[fRankIndex].velocity[0] * gFreecamFollowFactor;
-    freeCam.velocity[1] += gPlayers[fRankIndex].velocity[1] * gFreecamFollowFactor;
-    freeCam.velocity[2] += gPlayers[fRankIndex].velocity[2] * gFreecamFollowFactor;
+    freeCam.velocity.x += gPlayers[fRankIndex].velocity.x * gFreecamFollowFactor;
+    freeCam.velocity.y += gPlayers[fRankIndex].velocity.y * gFreecamFollowFactor;
+    freeCam.velocity.z += gPlayers[fRankIndex].velocity.z * gFreecamFollowFactor;
 }
 
 void freecam_get_player_from_character(s32 characterId) {
diff --git a/src/enhancements/moon_jump.c b/src/enhancements/moon_jump.c
index b3fc44f2a..8094c54e3 100644
--- a/src/enhancements/moon_jump.c
+++ b/src/enhancements/moon_jump.c
@@ -5,8 +5,8 @@
 
 void moon_jump(Player* player, struct Controller* controller) {
     if (controller->button & L_TRIG) {
-        if (player->velocity[1] <= 3.2f) {
-            player->velocity[1] += 0.5f;
+        if (player->velocity.y <= 3.2f) {
+            player->velocity.y += 0.5f;
         }
     }
 }
diff --git a/src/main.c b/src/main.c
index 01b09b7ca..170b19506 100644
--- a/src/main.c
+++ b/src/main.c
@@ -708,7 +708,7 @@ void display_debug_info(void) {
             (gControllerOne->button & B_BUTTON)) {
             D_800DC514 = false;
         }
-        rotY = camera1->rot[1];
+        rotY = camera1->rot.y;
         gDebugPathCount = D_800DC5EC->pathCounter;
 
     if (rotY < 0x2000) {
diff --git a/src/math_util_2.c b/src/math_util_2.c
index 091bf9215..4ab957fcf 100644
--- a/src/math_util_2.c
+++ b/src/math_util_2.c
@@ -454,7 +454,7 @@ bool is_particle_on_screen(Vec3f arg0, Camera* arg1, u16 arg2) {
     }
 
     ret = false;
-    temp_t9 = (get_angle_between_xy(arg1->pos[0], arg0[0], arg1->pos[2], arg0[2]) + (arg2 / 2)) - arg1->rot[1];
+    temp_t9 = (get_angle_between_xy(arg1->pos.x, arg0[0], arg1->pos.z, arg0[2]) + (arg2 / 2)) - arg1->rot.y;
     if ((temp_t9 >= 0) && (arg2 >= temp_t9)) {
         ret = true;
     }
@@ -465,9 +465,9 @@ void func_800419F8(void) {
     Vec3f pos;
     Vec3f vec;
 
-    pos[0] = 0.0f;
-    pos[1] = 0.0f;
-    pos[2] = 120.0f;
+    pos.x = 0.0f;
+    pos.y = 0.0f;
+    pos.z = 120.0f;
     vec3f_rotate_x_y(vec, pos, (s16*) D_80165834);
     D_80165840[0] = vec[0];
     D_80165840[1] = vec[1];
@@ -880,15 +880,15 @@ void mtxf_set_matrix_gObjectList(s32 objectIndex, Mat4 transformMatrix) {
     transformMatrix[0][0] = object->sizeScaling * ((cosY * cosZ) + (sinX * sinY * sinZ));
     transformMatrix[1][0] = object->sizeScaling * ((-cosY * sinZ) + sinX * sinY * cosZ);
     transformMatrix[2][0] = object->sizeScaling * (cosX * sinY);
-    transformMatrix[3][0] = object->pos[0];
+    transformMatrix[3][0] = object->pos.x;
     transformMatrix[0][1] = object->sizeScaling * (cosX * sinZ);
     transformMatrix[1][1] = object->sizeScaling * (cosX * cosZ);
     transformMatrix[2][1] = object->sizeScaling * -sinX;
-    transformMatrix[3][1] = object->pos[1];
+    transformMatrix[3][1] = object->pos.y;
     transformMatrix[0][2] = object->sizeScaling * ((-sinY * cosZ) + (sinX * cosY * sinZ));
     transformMatrix[1][2] = object->sizeScaling * ((sinY * sinZ) + (sinX * cosY * cosZ));
     transformMatrix[2][2] = object->sizeScaling * (cosX * cosY);
-    transformMatrix[3][2] = object->pos[2];
+    transformMatrix[3][2] = object->pos.z;
     transformMatrix[0][3] = 0.0f;
     transformMatrix[1][3] = 0.0f;
     transformMatrix[2][3] = 0.0f;
@@ -961,22 +961,22 @@ UNUSED void vec3f_rotate(Vec3f dest, Vec3f pos, Vec3s rot) {
     f32 sine3;
     f32 cosine3;
 
-    sine1 = sins(rot[0]);
-    cosine1 = coss(rot[0]);
-    sine2 = sins(rot[1]);
-    cosine2 = coss(rot[1]);
-    sine3 = sins(rot[2]);
-    cosine3 = coss(rot[2]);
+    sine1 = sins(rot.x);
+    cosine1 = coss(rot.x);
+    sine2 = sins(rot.y);
+    cosine2 = coss(rot.y);
+    sine3 = sins(rot.z);
+    cosine3 = coss(rot.z);
     // it's a matrix multiplication
-    sp74 = pos[0] * ((cosine2 * cosine3) + ((sine1 * sine2) * sine3));
-    temp_f4 = pos[1] * ((-cosine2 * sine3) + ((sine1 * sine2) * cosine3));
-    temp_f8 = pos[2] * (cosine1 * sine2);
-    sp70 = pos[0] * (cosine1 * sine3);
-    sp64 = pos[1] * (cosine1 * cosine3);
-    sp58 = pos[2] * -sine1;
-    sp6C = pos[0] * ((-sine2 * cosine3) + ((sine1 * cosine2) * sine3));
-    sp60 = pos[1] * ((sine2 * sine3) + ((sine1 * cosine2) * cosine3));
-    sp54 = pos[2] * (cosine1 * cosine2);
+    sp74 = pos.x * ((cosine2 * cosine3) + ((sine1 * sine2) * sine3));
+    temp_f4 = pos.y * ((-cosine2 * sine3) + ((sine1 * sine2) * cosine3));
+    temp_f8 = pos.z * (cosine1 * sine2);
+    sp70 = pos.x * (cosine1 * sine3);
+    sp64 = pos.y * (cosine1 * cosine3);
+    sp58 = pos.z * -sine1;
+    sp6C = pos.x * ((-sine2 * cosine3) + ((sine1 * cosine2) * sine3));
+    sp60 = pos.y * ((sine2 * sine3) + ((sine1 * cosine2) * cosine3));
+    sp54 = pos.z * (cosine1 * cosine2);
     dest[0] = sp74 + temp_f4 + temp_f8;
     dest[1] = sp70 + sp64 + sp58;
     dest[2] = sp6C + sp60 + sp54;
@@ -992,13 +992,13 @@ void vec3f_rotate_x_y(Vec3f dest, Vec3f pos, Vec3s rot) {
     f32 sine2;
     f32 cosine2;
 
-    sp2C = pos[0];
-    sp28 = pos[1];
-    sp24 = pos[2];
-    sine1 = sins(rot[0]);
-    cosine1 = coss(rot[0]);
-    sine2 = sins(rot[1]);
-    cosine2 = coss(rot[1]);
+    sp2C = pos.x;
+    sp28 = pos.y;
+    sp24 = pos.z;
+    sine1 = sins(rot.x);
+    cosine1 = coss(rot.x);
+    sine2 = sins(rot.y);
+    cosine2 = coss(rot.y);
     dest[0] = (sp2C * cosine2) - (sp24 * sine2);
     dest[1] = (sp2C * sine1 * sine2) + (sp28 * cosine1) + (sp24 * sine1 * cosine2);
     dest[2] = ((sp2C * cosine1 * sine2) - (sp28 * sine1)) + (sp24 * cosine1 * cosine2);
diff --git a/src/networking/replication.c b/src/networking/replication.c
index 38e691872..0534250d8 100644
--- a/src/networking/replication.c
+++ b/src/networking/replication.c
@@ -3,7 +3,7 @@
 #include "main.h"
 
 void replicate_player(const char* data) {
-    // gPlayerOne->pos[0];
+    // gPlayerOne->pos.x;
     // send_data_packet(client, PACKET_PLAYER, &gPlayerOne, sizeof(Player));
 }
 
diff --git a/src/player_controller.c b/src/player_controller.c
index df4b794bb..2f3185f91 100644
--- a/src/player_controller.c
+++ b/src/player_controller.c
@@ -725,7 +725,7 @@ void func_8002934C(Player* player, Camera* camera, s8 screenId, s8 playerId) {
     s32 var_t0;
     u16 var_a0;
 
-    player->unk_048[screenId] = atan2s(player->pos[0] - camera->pos[0], player->pos[2] - camera->pos[2]);
+    player->unk_048[screenId] = atan2s(player->pos.x - camera->pos.x, player->pos.z - camera->pos.z);
     player->animFrameSelector[screenId] =
         (u16) ((((player->unk_048[screenId]) + player->rotation[1] + player->unk_0C0))) / 128;
 
@@ -746,9 +746,9 @@ void func_8002934C(Player* player, Camera* camera, s8 screenId, s8 playerId) {
         player->unk_0D4[screenId] = (((func_802B7C40(temp_f0 / temp_f2)) * 0.9));
     } else {
         if (((player->animFrameSelector[screenId]) >= 0) && ((player->animFrameSelector[screenId]) < 0x101)) {
-            var_f0 = player->oldPos[1] - player->pos[1];
+            var_f0 = player->oldPos[1] - player->pos.y;
         } else {
-            var_f0 = player->pos[1] - player->oldPos[1];
+            var_f0 = player->pos.y - player->oldPos[1];
         }
         player->unk_0D4[screenId] = (s16) ((s32) (((f64) func_802B7C40(var_f0 / temp_f2)) * 0.5));
     }
@@ -879,45 +879,45 @@ void func_80029B4C(Player* player, UNUSED f32 arg1, f32 arg2, UNUSED f32 arg3) {
     sp8C[1] = -player->boundingBoxSize;
     sp8C[2] = var_f12 - 2.0f;
     mtxf_translate_vec3f_mat3(sp8C, sp5C);
-    sp80[0] = player->tyres[FRONT_LEFT].pos[0];
-    sp80[1] = player->tyres[FRONT_LEFT].pos[1];
-    sp80[2] = player->tyres[FRONT_LEFT].pos[2];
-    player->tyres[FRONT_LEFT].pos[0] = player->pos[0] + sp8C[0];
-    player->tyres[FRONT_LEFT].pos[1] = player->pos[1] + sp8C[1];
-    player->tyres[FRONT_LEFT].pos[2] = player->pos[2] + sp8C[2];
+    sp80[0] = player->tyres[FRONT_LEFT].pos.x;
+    sp80[1] = player->tyres[FRONT_LEFT].pos.y;
+    sp80[2] = player->tyres[FRONT_LEFT].pos.z;
+    player->tyres[FRONT_LEFT].pos.x = player->pos.x + sp8C[0];
+    player->tyres[FRONT_LEFT].pos.y = player->pos.y + sp8C[1];
+    player->tyres[FRONT_LEFT].pos.z = player->pos.z + sp8C[2];
     player_terrain_collision(player, &player->tyres[FRONT_LEFT], sp80[0], sp80[1], sp80[2]);
     sp8C[0] = (-var_f12) + 3.6;
     sp8C[1] = -player->boundingBoxSize;
     sp8C[2] = var_f12 - 2.0f;
     mtxf_translate_vec3f_mat3(sp8C, sp5C);
-    sp80[0] = player->tyres[FRONT_RIGHT].pos[0];
-    sp80[1] = player->tyres[FRONT_RIGHT].pos[1];
-    sp80[2] = player->tyres[FRONT_RIGHT].pos[2];
-    player->tyres[FRONT_RIGHT].pos[0] = player->pos[0] + sp8C[0];
-    player->tyres[FRONT_RIGHT].pos[1] = player->pos[1] + sp8C[1];
-    player->tyres[FRONT_RIGHT].pos[2] = player->pos[2] + sp8C[2];
+    sp80[0] = player->tyres[FRONT_RIGHT].pos.x;
+    sp80[1] = player->tyres[FRONT_RIGHT].pos.y;
+    sp80[2] = player->tyres[FRONT_RIGHT].pos.z;
+    player->tyres[FRONT_RIGHT].pos.x = player->pos.x + sp8C[0];
+    player->tyres[FRONT_RIGHT].pos.y = player->pos.y + sp8C[1];
+    player->tyres[FRONT_RIGHT].pos.z = player->pos.z + sp8C[2];
     player_terrain_collision(player, &player->tyres[FRONT_RIGHT], sp80[0], sp80[1], sp80[2]);
     sp8C[0] = var_f12 - 2.6;
     sp8C[1] = -player->boundingBoxSize;
     sp8C[2] = (-var_f12) + 4.0f;
     mtxf_translate_vec3f_mat3(sp8C, sp5C);
-    sp80[0] = player->tyres[BACK_LEFT].pos[0];
-    sp80[1] = player->tyres[BACK_LEFT].pos[1];
-    sp80[2] = player->tyres[BACK_LEFT].pos[2];
-    player->tyres[BACK_LEFT].pos[0] = player->pos[0] + sp8C[0];
-    player->tyres[BACK_LEFT].pos[1] = player->pos[1] + sp8C[1];
-    player->tyres[BACK_LEFT].pos[2] = player->pos[2] + sp8C[2];
+    sp80[0] = player->tyres[BACK_LEFT].pos.x;
+    sp80[1] = player->tyres[BACK_LEFT].pos.y;
+    sp80[2] = player->tyres[BACK_LEFT].pos.z;
+    player->tyres[BACK_LEFT].pos.x = player->pos.x + sp8C[0];
+    player->tyres[BACK_LEFT].pos.y = player->pos.y + sp8C[1];
+    player->tyres[BACK_LEFT].pos.z = player->pos.z + sp8C[2];
     player_terrain_collision(player, &player->tyres[BACK_LEFT], sp80[0], sp80[1], sp80[2]);
     sp8C[0] = (-var_f12) + 2.6;
     sp8C[1] = -player->boundingBoxSize;
     sp8C[2] = (-var_f12) + 4.0f;
     mtxf_translate_vec3f_mat3(sp8C, sp5C);
-    sp80[0] = player->tyres[BACK_RIGHT].pos[0];
-    sp80[1] = player->tyres[BACK_RIGHT].pos[1];
-    sp80[2] = player->tyres[BACK_RIGHT].pos[2];
-    player->tyres[BACK_RIGHT].pos[0] = player->pos[0] + sp8C[0];
-    player->tyres[BACK_RIGHT].pos[1] = player->pos[1] + sp8C[1];
-    player->tyres[BACK_RIGHT].pos[2] = player->pos[2] + sp8C[2];
+    sp80[0] = player->tyres[BACK_RIGHT].pos.x;
+    sp80[1] = player->tyres[BACK_RIGHT].pos.y;
+    sp80[2] = player->tyres[BACK_RIGHT].pos.z;
+    player->tyres[BACK_RIGHT].pos.x = player->pos.x + sp8C[0];
+    player->tyres[BACK_RIGHT].pos.y = player->pos.y + sp8C[1];
+    player->tyres[BACK_RIGHT].pos.z = player->pos.z + sp8C[2];
     player_terrain_collision(player, &player->tyres[BACK_RIGHT], sp80[0], sp80[1], sp80[2]);
     if (!(player->effects & 8)) {
         a = (player->tyres[BACK_LEFT].baseHeight + player->tyres[FRONT_LEFT].baseHeight) / 2;
@@ -985,28 +985,28 @@ void func_8002A194(Player* player, f32 arg1, f32 arg2, f32 arg3) {
         var_f20 = (((gCharacterSize[player->characterId] * 18) / 2) * player->size) - 1;
     }
 
-    player->tyres[FRONT_LEFT].pos[2] = (coss(temp_v1 + 0x2000) * var_f20) + arg3;
+    player->tyres[FRONT_LEFT].pos.z = (coss(temp_v1 + 0x2000) * var_f20) + arg3;
     temp_f12 = (sins(temp_v1 + 0x2000) * var_f20) + arg1;
-    player->tyres[FRONT_LEFT].pos[0] = temp_f12;
+    player->tyres[FRONT_LEFT].pos.x = temp_f12;
     player->tyres[FRONT_LEFT].baseHeight =
-        calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_LEFT].pos[2], player->collision.meshIndexZX);
+        calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_LEFT].pos.z, player->collision.meshIndexZX);
 
-    player->tyres[FRONT_RIGHT].pos[2] = (coss(temp_v1 - 0x2000) * var_f20) + arg3;
+    player->tyres[FRONT_RIGHT].pos.z = (coss(temp_v1 - 0x2000) * var_f20) + arg3;
     temp_f12 = (sins(temp_v1 - 0x2000) * var_f20) + arg1;
-    player->tyres[FRONT_RIGHT].pos[0] = temp_f12;
+    player->tyres[FRONT_RIGHT].pos.x = temp_f12;
     player->tyres[FRONT_RIGHT].baseHeight =
-        calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_RIGHT].pos[2], player->collision.meshIndexZX);
+        calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_RIGHT].pos.z, player->collision.meshIndexZX);
 
-    player->tyres[BACK_LEFT].pos[2] = (coss(temp_v1 + 0x6000) * var_f20) + arg3;
+    player->tyres[BACK_LEFT].pos.z = (coss(temp_v1 + 0x6000) * var_f20) + arg3;
     temp_f12 = (sins(temp_v1 + 0x6000) * var_f20) + arg1;
-    player->tyres[BACK_LEFT].pos[0] = temp_f12;
+    player->tyres[BACK_LEFT].pos.x = temp_f12;
     player->tyres[BACK_LEFT].baseHeight =
-        calculate_surface_height(temp_f12, arg2, player->tyres[BACK_LEFT].pos[2], player->collision.meshIndexZX);
+        calculate_surface_height(temp_f12, arg2, player->tyres[BACK_LEFT].pos.z, player->collision.meshIndexZX);
 
-    player->tyres[BACK_RIGHT].pos[2] = (coss(temp_v1 - 0x6000) * var_f20) + arg3;
-    player->tyres[BACK_RIGHT].pos[0] = (sins(temp_v1 - 0x6000) * var_f20) + arg1;
+    player->tyres[BACK_RIGHT].pos.z = (coss(temp_v1 - 0x6000) * var_f20) + arg3;
+    player->tyres[BACK_RIGHT].pos.x = (sins(temp_v1 - 0x6000) * var_f20) + arg1;
     player->tyres[BACK_RIGHT].baseHeight = calculate_surface_height(
-        player->tyres[BACK_LEFT].pos[0], arg2, player->tyres[BACK_LEFT].pos[2], player->collision.meshIndexZX);
+        player->tyres[BACK_LEFT].pos.x, arg2, player->tyres[BACK_LEFT].pos.z, player->collision.meshIndexZX);
 
     if ((player->effects & 8) != 8) {
         player->unk_230 = (player->tyres[BACK_LEFT].baseHeight + player->tyres[FRONT_LEFT].baseHeight) / 2;
@@ -1539,9 +1539,9 @@ void func_8002B9CC(Player* player, s8 arg1, UNUSED s32 arg2) {
             }
         }
     } else {
-        temp_f0 = D_80165070[arg1][0] - player->velocity[0];
-        temp_f2 = D_80165070[arg1][1] - player->velocity[1];
-        temp_f14 = D_80165070[arg1][2] - player->velocity[2];
+        temp_f0 = D_80165070[arg1][0] - player->velocity.x;
+        temp_f2 = D_80165070[arg1][1] - player->velocity.y;
+        temp_f14 = D_80165070[arg1][2] - player->velocity.z;
         if (sqrtf((temp_f0 * temp_f0) + (temp_f2 * temp_f2) + (temp_f14 * temp_f14)) >= 4.2) {
             player->unk_08C /= 4;
             player->currentSpeed /= 4;
@@ -1672,7 +1672,7 @@ void func_8002BF4C(Player* player, s8 arg1) {
         for (i = 0; i < NUM_PLAYERS; i++) {
             playerBorrow = &players[i];
             if (((player != playerBorrow) && ((playerBorrow->type & 0x100) == 0) && (playerBorrow->type & 0x8000)) &&
-                ((var_a2 = func_8001FD78(player, playerBorrow->pos[0], playerBorrow->pos[1], playerBorrow->pos[2]),
+                ((var_a2 = func_8001FD78(player, playerBorrow->pos.x, playerBorrow->pos.y, playerBorrow->pos.z),
                   var_a2 == 1))) {
                 player->unk_0E2 += 1;
                 if (player->unk_0E2 >= 0x3D) {
@@ -1763,18 +1763,18 @@ void func_8002C17C(Player* player, s8 playerId) {
 
 void func_8002C4F8(Player* player, s8 arg1) {
     D_801652A0[arg1] = get_water_level(player);
-    if (player->pos[1] <= D_801652A0[arg1]) {
+    if (player->pos.y <= D_801652A0[arg1]) {
         player->unk_0DE |= 0x0002;
     } else {
         player->unk_0DE &= ~0x0002;
     }
-    if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) {
+    if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) {
         player->unk_0DE |= 1;
         player->unk_0DE &= ~0x0002;
     } else {
         player->unk_0DE &= ~0x0001;
     }
-    if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) {
+    if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) {
         if ((player->unk_0DE & 4) != 4) {
             player->unk_0DE |= 8;
             player->unk_0DE |= 4;
@@ -1792,7 +1792,7 @@ void func_8002C4F8(Player* player, s8 arg1) {
         (GetCourse() == GetRainbowRoad())) {
         player->unk_0DE &= ~0x000C;
     }
-    if ((player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) &&
+    if ((player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) &&
         (player->collision.surfaceDistance[2] >= 600.0f)) {
         player->unk_0CA |= 1;
     }
@@ -1861,7 +1861,7 @@ void func_8002C954(Player* player, s8 playerId, Vec3f arg2) {
     f32 ydist;
     f32 zdist;
 
-    temp_f0 = player->pos[1] - player->unk_074;
+    temp_f0 = player->pos.y - player->unk_074;
 
     if (((((player->effects & 0x10000) != 0x10000) &&
           ((player->effects & BOOST_RAMP_ASPHALT_EFFECT) == BOOST_RAMP_ASPHALT_EFFECT)) ||
@@ -2017,8 +2017,8 @@ void func_8002D028(Player* player, s8 arg1) {
     func_8003680C(player, (s16) temp_t1);
     D_80165020[arg1] = (s16) temp_t1;
 
-    temp_f18 = sqrtf((sp4C[0] - player->pos[0]) * (sp4C[0] - player->pos[0]) +
-                     (sp4C[2] - player->pos[2]) * (sp4C[2] - player->pos[2]));
+    temp_f18 = sqrtf((sp4C[0] - player->pos.x) * (sp4C[0] - player->pos.x) +
+                     (sp4C[2] - player->pos.z) * (sp4C[2] - player->pos.z));
     if (temp_f18 <= 8.0f) {
         adjust_angle(&player->rotation[1], -0x8000, 0x016C);
         if ((player->rotation[1] < (-0x7F41)) || (player->rotation[1] > 0x7F41)) {
@@ -2029,9 +2029,9 @@ void func_8002D028(Player* player, s8 arg1) {
         player->unk_104 = 0;
         player->tyreSpeed = 0;
         player->unk_07C = 0;
-        player->velocity[0] = 0;
-        player->velocity[1] = 0;
-        player->velocity[2] = 0;
+        player->velocity.x = 0;
+        player->velocity.y = 0;
+        player->velocity.z = 0;
         player->unk_0C0 = 0;
         player->unk_078 = 0;
     } else {
@@ -2117,8 +2117,8 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
         spB0 = -1 * player->kartGravity;
         spAC = 0 * (player->unk_064[2] + sp16C[2]);
     }
-    temp_f2_2 = ((player->oldPos[2] - player->pos[2]) * coss(player->rotation[1] + player->unk_0C0)) +
-                (-(player->oldPos[0] - player->pos[0]) * sins(player->rotation[1] + player->unk_0C0));
+    temp_f2_2 = ((player->oldPos[2] - player->pos.z) * coss(player->rotation[1] + player->unk_0C0)) +
+                (-(player->oldPos[0] - player->pos.x) * sins(player->rotation[1] + player->unk_0C0));
     if (temp_f2_2 > 0.1) {
         player->unk_044 |= 8;
     } else {
@@ -2137,9 +2137,9 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
     func_8002C7E4(player, playerId, screenId);
     sp184[2] = func_80030150(player, playerId);
     mtxf_translate_vec3f_mat3(sp184, player->orientationMatrix);
-    sp98[0] = player->velocity[0];
-    sp98[1] = player->velocity[1];
-    sp98[2] = player->velocity[2];
+    sp98[0] = player->velocity.x;
+    sp98[1] = player->velocity.y;
+    sp98[2] = player->velocity.z;
     if (((player->unk_10C < 3) && (((s32) player->unk_256) < 3)) ||
         ((player->effects & BOOST_EFFECT) == BOOST_EFFECT)) {
 
@@ -2181,16 +2181,16 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
         player->unk_044 &= 0xFFEF;
     }
 
-    posX = player->pos[0];
-    posY = player->pos[1];
-    posZ = player->pos[2];
+    posX = player->pos.x;
+    posY = player->pos.y;
+    posZ = player->pos.z;
 
-    player->oldPos[0] = player->pos[0];
-    player->oldPos[2] = player->pos[2];
-    player->oldPos[1] = player->pos[1];
-    nextX = posX + player->velocity[0] + D_8018CE10[playerId].unk_04[0];
-    nextY = posY + player->velocity[1];
-    nextZ = posZ + player->velocity[2] + D_8018CE10[playerId].unk_04[2];
+    player->oldPos[0] = player->pos.x;
+    player->oldPos[2] = player->pos.z;
+    player->oldPos[1] = player->pos.y;
+    nextX = posX + player->velocity.x + D_8018CE10[playerId].unk_04[0];
+    nextY = posY + player->velocity.y;
+    nextZ = posZ + player->velocity.z + D_8018CE10[playerId].unk_04[2];
 
     if (((((player->unk_0CA & 2) != 2) && ((player->unk_0CA & 8) != 8)) &&
          ((player->effects & HIT_EFFECT) != HIT_EFFECT)) &&
@@ -2319,39 +2319,39 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
         sp98[0] = sp98[0] + (-1 * sp98[0]);
         sp98[2] = sp98[2] + (-1 * sp98[2]);
     } else {
-        player->pos[0] = nextX;
-        player->pos[2] = nextZ;
+        player->pos.x = nextX;
+        player->pos.z = nextZ;
     }
-    player->pos[1] = nextY;
+    player->pos.y = nextY;
     if (CVarGetInteger("gNoWallColision", 0)) {
-        player->pos[1] = nextY < CVarGetFloat("gMinHeight", 0.0f) ? CVarGetFloat("gMinHeight", 0.0f) : nextY;
+        player->pos.y = nextY < CVarGetFloat("gMinHeight", 0.0f) ? CVarGetFloat("gMinHeight", 0.0f) : nextY;
     }
     if ((player->type & PLAYER_HUMAN) && (!(player->type & PLAYER_KART_AI))) {
         func_8002BB9C(player, &nextX, &nextZ, screenId, playerId, sp98);
     }
     player->unk_064[0] = sp178[0];
     player->unk_064[2] = sp178[2];
-    player->velocity[0] = sp98[0];
-    player->velocity[1] = sp98[1];
-    player->velocity[2] = sp98[2];
+    player->velocity.x = sp98[0];
+    player->velocity.y = sp98[1];
+    player->velocity.z = sp98[2];
     D_80165070[playerId][0] = sp98[0];
     D_80165070[playerId][1] = sp98[1];
     D_80165070[playerId][2] = sp98[2];
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
             temp = gKartTopSpeedTable[player->characterId] / player->unk_094;
-            player->velocity[0] *= temp;
-            player->velocity[1] *= temp;
-            player->velocity[2] *= temp;
+            player->velocity.x *= temp;
+            player->velocity.y *= temp;
+            player->velocity.z *= temp;
             player->unk_094 = gKartTopSpeedTable[player->characterId];
         }
     }
     if ((player->unk_044 & 1) == 1) {
         if (player->unk_094 > 1) {
             temp = 1 / player->unk_094;
-            player->velocity[0] *= temp;
-            player->velocity[1] *= temp;
-            player->velocity[2] *= temp;
+            player->velocity.x *= temp;
+            player->velocity.y *= temp;
+            player->velocity.z *= temp;
             player->unk_094 = 1;
         }
     }
@@ -2368,13 +2368,13 @@ void set_player_height(Player* player) {
     player->kartHopJerk = 0.0f;
     player->kartHopAcceleration = 0.0f;
     player->kartHopVelocity = 0.0f;
-    player->pos[1] = spawn_actor_on_surface(player->pos[0], D_80164510[player_index] + 10.0f, player->pos[2]) +
+    player->pos.y = spawn_actor_on_surface(player->pos.x, D_80164510[player_index] + 10.0f, player->pos.z) +
                      player->boundingBoxSize;
-    if (((player->pos[1] - D_80164510[player_index]) > 1200.0f) ||
-        ((player->pos[1] - D_80164510[player_index]) < -1200.0f)) {
-        player->pos[1] = player->oldPos[1];
+    if (((player->pos.y - D_80164510[player_index]) > 1200.0f) ||
+        ((player->pos.y - D_80164510[player_index]) < -1200.0f)) {
+        player->pos.y = player->oldPos[1];
     }
-    player->velocity[1] = 0.0f;
+    player->velocity.y = 0.0f;
 }
 
 void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 playerId) {
@@ -2439,9 +2439,9 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
     } else {
         mtxf_translate_vec3f_mat3(spEC, player->orientationMatrix);
     }
-    sp54[0] = player->velocity[0];
-    sp54[1] = player->velocity[1];
-    sp54[2] = player->velocity[2];
+    sp54[0] = player->velocity.x;
+    sp54[1] = player->velocity.y;
+    sp54[2] = player->velocity.z;
     if ((player->unk_10C < 3) && ((player->unk_256) < 3) && ((player->effects & 0x400) != 0x400) &&
         ((player->effects & 0x01000000) != 0x01000000) &&
         ((player->effects & HIT_BY_ITEM_EFFECT) != HIT_BY_ITEM_EFFECT)) {
@@ -2462,17 +2462,17 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
         sp54[1] = 0.0f;
         sp54[2] = 0.0f;
     }
-    posX = player->pos[0];
-    posY = player->pos[1];
-    posZ = player->pos[2];
+    posX = player->pos.x;
+    posY = player->pos.y;
+    posZ = player->pos.z;
 
-    player->oldPos[0] = player->pos[0];
-    player->oldPos[1] = player->pos[1];
-    player->oldPos[2] = player->pos[2];
+    player->oldPos[0] = player->pos.x;
+    player->oldPos[1] = player->pos.y;
+    player->oldPos[2] = player->pos.z;
 
-    spD0 = posX + player->velocity[0] + D_8018CE10[playerId].unk_04[0];
-    spCC = posY + player->velocity[1];
-    spC8 = posZ + player->velocity[2] + D_8018CE10[playerId].unk_04[2];
+    spD0 = posX + player->velocity.x + D_8018CE10[playerId].unk_04[0];
+    spCC = posY + player->velocity.y;
+    spC8 = posZ + player->velocity.z + D_8018CE10[playerId].unk_04[2];
     func_8002AAC0(player);
     spCC += player->kartHopVelocity;
     actor_terrain_collision(&player->collision, player->boundingBoxSize, spD0, spCC, spC8, player->oldPos[0],
@@ -2602,21 +2602,21 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
         sp54[0] = sp54[0] + (-1 * sp54[0]);
         sp54[2] = sp54[2] + (-1 * sp54[2]);
     } else {
-        player->pos[0] = spD0;
-        player->pos[2] = spC8;
+        player->pos.x = spD0;
+        player->pos.z = spC8;
     }
-    player->pos[1] = spCC;
+    player->pos.y = spCC;
     player->unk_064[0] = spE0[0];
     player->unk_064[2] = spE0[2];
-    player->velocity[0] = sp54[0];
-    player->velocity[1] = sp54[1];
-    player->velocity[2] = sp54[2];
+    player->velocity.x = sp54[0];
+    player->velocity.y = sp54[1];
+    player->velocity.z = sp54[2];
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
             temp_f0_6 = gKartTopSpeedTable[player->characterId] / player->unk_094;
-            player->velocity[0] *= temp_f0_6;
-            player->velocity[1] *= temp_f0_6;
-            player->velocity[2] *= temp_f0_6;
+            player->velocity.x *= temp_f0_6;
+            player->velocity.y *= temp_f0_6;
+            player->velocity.z *= temp_f0_6;
             player->unk_094 = gKartTopSpeedTable[player->characterId];
         }
     }
@@ -2655,16 +2655,16 @@ void control_kart_ai_movement(Player* player, UNUSED Camera* camera, s8 arg2, s8
     player->effects &= ~0x8000;
     spF4[2] = func_80030150(player, playerId);
     mtxf_translate_vec3f_mat3(spF4, player->orientationMatrix);
-    sp68[0] = player->velocity[0];
+    sp68[0] = player->velocity.x;
     sp68[1] = 0;
-    sp68[2] = player->velocity[2];
+    sp68[2] = player->velocity.z;
     sp68[0] += (((spF4[0] + sp84) + spD0[0]) - (sp68[0] * (0.12 * player->kartFriction))) / 6000.0;
     sp68[2] += (((spF4[2] + sp7C) + spD0[2]) - (sp68[2] * (0.12 * player->kartFriction))) / 6000.0;
-    player->oldPos[0] = player->pos[0];
+    player->oldPos[0] = player->pos.x;
     player->oldPos[1] = test;
-    player->oldPos[2] = player->pos[2];
-    spCC = player->pos[0] + player->velocity[0];
-    spC4 = player->pos[2] + player->velocity[2];
+    player->oldPos[2] = player->pos.z;
+    spCC = player->pos.x + player->velocity.x;
+    spC4 = player->pos.z + player->velocity.z;
     player->unk_0C0 = 0;
     player->kartHopJerk = 0;
     player->kartHopAcceleration = 0;
@@ -2679,22 +2679,22 @@ void control_kart_ai_movement(Player* player, UNUSED Camera* camera, s8 arg2, s8
     toSqrt = (sp68[0] * sp68[0]) + (sp68[2] * sp68[2]);
     player->unk_22C = player->unk_094;
     player->unk_094 = sqrtf(toSqrt);
-    player->pos[0] = spCC;
-    player->pos[2] = spC4;
-    player->pos[1] = test;
+    player->pos.x = spCC;
+    player->pos.z = spC4;
+    player->pos.y = test;
     player->unk_064[0] = 0;
     player->unk_064[2] = 0;
-    player->velocity[0] = sp68[0];
-    player->velocity[1] = sp68[1];
-    player->velocity[2] = sp68[2];
+    player->velocity.x = sp68[0];
+    player->velocity.y = sp68[1];
+    player->velocity.z = sp68[2];
     D_80165070[playerId][0] = sp68[0];
     D_80165070[playerId][1] = sp68[1];
     D_80165070[playerId][2] = sp68[2];
     if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
         temp_f0_2 = gKartTopSpeedTable[player->characterId] / player->unk_094;
-        player->velocity[0] *= temp_f0_2;
-        player->velocity[1] *= temp_f0_2;
-        player->velocity[2] *= temp_f0_2;
+        player->velocity.x *= temp_f0_2;
+        player->velocity.y *= temp_f0_2;
+        player->velocity.z *= temp_f0_2;
         player->unk_094 = gKartTopSpeedTable[player->characterId];
     }
 }
@@ -2729,25 +2729,25 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
 
     mtxf_translate_vec3f_mat3(spF4, player->orientationMatrix);
 
-    sp68[0] = player->velocity[0];
-    sp68[1] = player->velocity[1];
-    sp68[2] = player->velocity[2];
+    sp68[0] = player->velocity.x;
+    sp68[1] = player->velocity.y;
+    sp68[2] = player->velocity.z;
 
     sp68[0] += (((f64) (spF4[0] + sp84) - (sp68[0] * 780.0)) / 6500.0);
     sp68[2] += (((f64) (spF4[2] + sp7C) - (sp68[2] * 780.0)) / 6500.0);
     sp68[1] += (((f64) (spF4[1] + -1100.0f) - (sp68[1] * 780.0)) / 6500.0);
 
-    spC0 = player->pos[0];
-    sp44 = player->pos[1];
-    spB8 = player->pos[2];
+    spC0 = player->pos.x;
+    sp44 = player->pos.y;
+    spB8 = player->pos.z;
 
-    player->oldPos[0] = player->pos[0];
-    player->oldPos[1] = player->pos[1];
-    player->oldPos[2] = player->pos[2];
+    player->oldPos[0] = player->pos.x;
+    player->oldPos[1] = player->pos.y;
+    player->oldPos[2] = player->pos.z;
 
-    spCC = player->velocity[0] + spC0;
-    spC8 = player->velocity[1] + sp44;
-    spC4 = player->velocity[2] + spB8;
+    spCC = player->velocity.x + spC0;
+    spC8 = player->velocity.y + sp44;
+    spC4 = player->velocity.z + spB8;
 
     func_8002AAC0(player);
 
@@ -2781,17 +2781,17 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
         sp68[0] = sp68[0] + (sp68[0] * -1.0f);
         sp68[2] = sp68[2] + (sp68[2] * -1.0f);
     } else {
-        player->pos[0] = spCC;
-        player->pos[2] = spC4;
+        player->pos.x = spCC;
+        player->pos.z = spC4;
     }
-    player->pos[1] = spC8 - 0.018;
+    player->pos.y = spC8 - 0.018;
 
     player->unk_064[0] = spE8[0];
     player->unk_064[2] = spE8[2];
 
-    player->velocity[0] = sp68[0];
-    player->velocity[1] = sp68[1];
-    player->velocity[2] = sp68[2];
+    player->velocity.x = sp68[0];
+    player->velocity.y = sp68[1];
+    player->velocity.z = sp68[2];
     D_80165070[playerId][0] = sp68[0];
     D_80165070[playerId][1] = sp68[1];
     D_80165070[playerId][2] = sp68[2];
@@ -2799,9 +2799,9 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
             temp_f0_2 = gKartTopSpeedTable[player->characterId] / player->unk_094;
-            player->velocity[0] *= temp_f0_2;
-            player->velocity[1] *= temp_f0_2;
-            player->velocity[2] *= temp_f0_2;
+            player->velocity.x *= temp_f0_2;
+            player->velocity.y *= temp_f0_2;
+            player->velocity.z *= temp_f0_2;
             player->unk_094 = gKartTopSpeedTable[player->characterId];
         }
     }
@@ -4834,9 +4834,9 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
     sp114[2] = player->unk_08C;
     mtxf_translate_vec3f_mat3(sp114, player->orientationMatrix);
 
-    sp88[0] = player->velocity[0];
-    sp88[1] = player->velocity[1];
-    sp88[2] = player->velocity[2];
+    sp88[0] = player->velocity.x;
+    sp88[1] = player->velocity.y;
+    sp88[2] = player->velocity.z;
 
     sp88[0] += ((((((sp114[0] + spA4) + spF0[0])) - (sp88[0] * (0.12 * (player->kartFriction)))) / 6000.0) / 1);
     sp88[2] += ((((((sp114[2] + sp9C) + spF0[2])) - (sp88[2] * (0.12 * (player->kartFriction)))) / 6000.0) / 1);
@@ -4845,17 +4845,17 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
         player->unk_044 &= 0xFFEF;
     }
 
-    posX = player->pos[0];
-    posY = player->pos[1];
-    posZ = player->pos[2];
+    posX = player->pos.x;
+    posY = player->pos.y;
+    posZ = player->pos.z;
 
-    player->oldPos[0] = player->pos[0];
-    player->oldPos[1] = player->pos[1];
-    player->oldPos[2] = player->pos[2];
+    player->oldPos[0] = player->pos.x;
+    player->oldPos[1] = player->pos.y;
+    player->oldPos[2] = player->pos.z;
 
-    spEC = posX + player->velocity[0];
-    spE8 = posY + player->velocity[1];
-    spE4 = posZ + player->velocity[2];
+    spEC = posX + player->velocity.x;
+    spE8 = posY + player->velocity.y;
+    spE4 = posZ + player->velocity.z;
     func_8002AAC0(player);
     spE8 += player->kartHopVelocity;
     spE8 -= 0.02;
@@ -4902,16 +4902,16 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
     player->unk_22C = player->unk_094;
     player->unk_094 = sqrtf(sqrt);
 
-    player->pos[0] = spEC;
-    player->pos[2] = spE4;
-    player->pos[1] = spE8;
+    player->pos.x = spEC;
+    player->pos.z = spE4;
+    player->pos.y = spE8;
 
     player->unk_064[0] = sp108[0];
     player->unk_064[2] = sp108[2];
 
-    player->velocity[0] = sp88[0];
-    player->velocity[1] = sp88[1];
-    player->velocity[2] = sp88[2];
+    player->velocity.x = sp88[0];
+    player->velocity.y = sp88[1];
+    player->velocity.z = sp88[2];
 
     D_80165070[playerId][0] = sp88[0];
     D_80165070[playerId][1] = sp88[1];
@@ -4920,17 +4920,17 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
     if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
         if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
             divOptimize = gKartTopSpeedTable[player->characterId] / player->unk_094;
-            player->velocity[0] *= divOptimize;
-            player->velocity[1] *= divOptimize;
-            player->velocity[2] *= divOptimize;
+            player->velocity.x *= divOptimize;
+            player->velocity.y *= divOptimize;
+            player->velocity.z *= divOptimize;
             player->unk_094 = gKartTopSpeedTable[player->characterId];
         }
     }
     if ((player->unk_044 & 1) == 1) {
         if (player->unk_094 > 1.0f) {
-            player->velocity[0] *= 1.0f / player->unk_094;
-            player->velocity[1] *= 1.0f / player->unk_094;
-            player->velocity[2] *= 1.0f / player->unk_094;
+            player->velocity.x *= 1.0f / player->unk_094;
+            player->velocity.y *= 1.0f / player->unk_094;
+            player->velocity.z *= 1.0f / player->unk_094;
             player->unk_094 = 1.0f;
         }
     }
diff --git a/src/port/Game.cpp b/src/port/Game.cpp
index 2c0ec3a0a..964aeaad3 100644
--- a/src/port/Game.cpp
+++ b/src/port/Game.cpp
@@ -719,7 +719,7 @@ void CM_ActorCollision(Player* player, Actor* actor) {
 }
 
 f32 CM_GetWaterLevel(Vec3f pos, Collision* collision) {
-    FVector fPos = {pos[0], pos[1], pos[2]};
+    FVector fPos = {pos.x, pos.y, pos.z};
     return gWorldInstance.CurrentCourse->GetWaterLevel(fPos, collision);
 }
 
diff --git a/src/port/interpolation/FrameInterpolation.cpp b/src/port/interpolation/FrameInterpolation.cpp
index 9df591f0c..84dd9d5cd 100644
--- a/src/port/interpolation/FrameInterpolation.cpp
+++ b/src/port/interpolation/FrameInterpolation.cpp
@@ -57,8 +57,10 @@ enum class Op {
     MatrixPop,
     MatrixPut,
     MatrixMult,
+    MatrixMultKart,
     MatrixTranslate,
     MatrixScale,
+    MatrixTranslateRotateZYX,
     MatrixRotate1Coord,
     MatrixMult4x4,
     MatrixPosRotXYZ,
@@ -91,9 +93,20 @@ union Data {
         u8 mode;
     } matrix_mult;
 
+    struct {
+        f32* outX;
+        f32* outY;
+        f32* outZ;
+        f32 inX;
+        f32 inY;
+        f32 inZ;
+        u16 theta;
+        u16 phi;
+    } matrix_mult_kart;
+
     struct {
         Mat4* matrix;
-        Vec3fInterp b;
+        Vec3f b;
     } matrix_translate, matrix_scale;
 
     struct {
@@ -121,12 +134,11 @@ union Data {
     } matrix_mult_4x4;
 
     struct {
-        Vec3fInterp pos;
-        Vec3sInterp orientation;
+        Vec3f pos;
+        Vec3s orientation;
     } matrix_pos_rot_xyz;
 
     struct {
-        Mat4* matrix;
         Vec3f translation;
         Vec3s rotation;
     } matrix_translate_rotate_zyx;
@@ -197,6 +209,8 @@ Data& append(Op op) {
 extern "C" {
 extern Mat4* gInterpolationMatrix;
 void mtxf_translate(Mat4, Vec3f);
+void func_80062B18(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY, f32 inZ, u16 theta, u16 phi);
+void mtxf_translate_rotate(Mat4 dest, Vec3f pos, Vec3s orientation);
 }
 
 MtxF* Matrix_GetCurrent() {
@@ -228,14 +242,14 @@ struct InterpolateCtx {
         return w * o + step * n;
     }
 
-    s16 lerp_s16(s16 o, s16 n) {
+    s16 lerp(s16 o, s16 n) {
         return w * o + step * n;
     }
 
     void lerp_vec3f(Vec3f* res, Vec3f* o, Vec3f* n) {
-        *res[0] = lerp(*o[0], *n[0]);
-        *res[1] = lerp(*o[1], *n[1]);
-        *res[2] = lerp(*o[2], *n[2]);
+        res->x = lerp(o->x, n->x);
+        res->y = lerp(o->y, n->y);
+        res->z = lerp(o->z, n->z);
     }
 
     float interpolate_angle(f32 o, f32 n) {
@@ -293,15 +307,15 @@ struct InterpolateCtx {
     }
 
     void interpolate_vecs(Vec3f* res, Vec3f* o, Vec3f* n) {
-        *res[0] = interpolate_angle(*o[0], *n[0]);
-        *res[1] = interpolate_angle(*o[1], *n[1]);
-        *res[2] = interpolate_angle(*o[2], *n[2]);
+        res->x = interpolate_angle(o->x, n->x);
+        res->y = interpolate_angle(o->y, n->y);
+        res->z = interpolate_angle(o->z, n->z);
     }
 
     void interpolate_angles(Vec3s* res, Vec3s* o, Vec3s* n) {
-        *res[0] = interpolate_angle(*o[0], *n[0]);
-        *res[1] = interpolate_angle(*o[1], *n[1]);
-        *res[2] = interpolate_angle(*o[2], *n[2]);
+        res->x = interpolate_angle(o->x, n->x);
+        res->y = interpolate_angle(o->y, n->y);
+        res->z = interpolate_angle(o->z, n->z);
     }
 
     void interpolate_branch(Path* old_path, Path* new_path) {
@@ -347,14 +361,36 @@ struct InterpolateCtx {
                             interpolate_mtxf(&tmp_mtxf, &old_op.matrix_mult.mf, &new_op.matrix_mult.mf);
                             // Matrix_Mult(gInterpolationMatrix, (Matrix*) &tmp_mtxf, new_op.matrix_mult.mode);
                             break;
+                        case Op::MatrixMultKart:
+                        
+                            f32 tempX, tempY, tempZ;
+                            u16 tempTheta, tempPhi;
+                            tempX = lerp(old_op.matrix_mult_kart.inX, new_op.matrix_mult_kart.inX);
+                            tempY = lerp(old_op.matrix_mult_kart.inY, new_op.matrix_mult_kart.inY);
+                            tempZ = lerp(old_op.matrix_mult_kart.inZ, new_op.matrix_mult_kart.inZ);
+                            tempTheta = interpolate_angle((s16) old_op.matrix_mult_kart.theta, (s16) new_op.matrix_mult_kart.theta);
+                            tempPhi = interpolate_angle((s16) old_op.matrix_mult_kart.phi, (s16) new_op.matrix_mult_kart.phi);
+
+                            func_80062B18(old_op.matrix_mult_kart.outX, old_op.matrix_mult_kart.outY, old_op.matrix_mult_kart.outZ, tempX, tempY, tempZ, tempTheta, tempPhi);
+
+                            // Matrix_MultKart(gInterpolationMatrix, (Matrix*) &tmp_mtxf, new_op.matrix_mult.mode);
+                            break;
+                        
+                        case Op::MatrixTranslateRotateZYX:
+                            lerp_vec3f(&tmp_vec3f, &old_op.matrix_translate_rotate_zyx.translation,
+                                &new_op.matrix_translate_rotate_zyx.translation);
+                            interpolate_angles(&tmp_vec3s, &old_op.matrix_translate_rotate_zyx.rotation,
+                                    &new_op.matrix_translate_rotate_zyx.rotation);
+                            mtxf_translate_rotate(*gInterpolationMatrix, tmp_vec3f, tmp_vec3s);
+                            break;
 
                         case Op::MatrixTranslate:
 
                             Vec3f temp;
 
-                            temp[0] = lerp(old_op.matrix_translate.b.x, new_op.matrix_translate.b.x);
-                            temp[1] = lerp(old_op.matrix_translate.b.y, new_op.matrix_translate.b.y);
-                            temp[2] = lerp(old_op.matrix_translate.b.z, new_op.matrix_translate.b.z);
+                            temp.x = lerp(old_op.matrix_translate.b.x, new_op.matrix_translate.b.x);
+                            temp.y = lerp(old_op.matrix_translate.b.y, new_op.matrix_translate.b.y);
+                            temp.z = lerp(old_op.matrix_translate.b.z, new_op.matrix_translate.b.z);
 
                             mtxf_translate(*gInterpolationMatrix, temp);
                             break;
@@ -362,13 +398,13 @@ struct InterpolateCtx {
                             Vec3f tempF;
                             Vec3s tempS;
 
-                            tempF[0] = lerp(old_op.matrix_pos_rot_xyz.pos.x, new_op.matrix_pos_rot_xyz.pos.x);
-                            tempF[1] = lerp(old_op.matrix_pos_rot_xyz.pos.y, new_op.matrix_pos_rot_xyz.pos.y);
-                            tempF[2] = lerp(old_op.matrix_pos_rot_xyz.pos.z, new_op.matrix_pos_rot_xyz.pos.z);
+                            tempF.x = lerp(old_op.matrix_pos_rot_xyz.pos.x, new_op.matrix_pos_rot_xyz.pos.x);
+                            tempF.y = lerp(old_op.matrix_pos_rot_xyz.pos.y, new_op.matrix_pos_rot_xyz.pos.y);
+                            tempF.z = lerp(old_op.matrix_pos_rot_xyz.pos.z, new_op.matrix_pos_rot_xyz.pos.z);
 
-                            tempS[0] = lerp(old_op.matrix_pos_rot_xyz.orientation.x, new_op.matrix_pos_rot_xyz.orientation.x);
-                            tempS[1] = lerp(old_op.matrix_pos_rot_xyz.orientation.y, new_op.matrix_pos_rot_xyz.orientation.y);
-                            tempS[2] = lerp(old_op.matrix_pos_rot_xyz.orientation.z, new_op.matrix_pos_rot_xyz.orientation.z);
+                            tempS.x = lerp(old_op.matrix_pos_rot_xyz.orientation.x, new_op.matrix_pos_rot_xyz.orientation.x);
+                            tempS.y = lerp(old_op.matrix_pos_rot_xyz.orientation.y, new_op.matrix_pos_rot_xyz.orientation.y);
+                            tempS.z = lerp(old_op.matrix_pos_rot_xyz.orientation.z, new_op.matrix_pos_rot_xyz.orientation.z);
 
                             mtxf_pos_rotation_xyz(*gInterpolationMatrix, tempF, tempS);
                             break;
@@ -551,11 +587,24 @@ void FrameInterpolation_RecordMatrixMult(Mat4* matrix, MtxF* mf, u8 mode) {
     append(Op::MatrixMult).matrix_mult = { matrix, *mf, mode };
 }
 
+void FrameInterpolation_RecordMatrixMultKart(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY,
+                                             f32 inZ, u16 theta, u16 phi) {
+    if (!is_recording)
+        return;
+    append(Op::MatrixMultKart).matrix_mult_kart = { outX, outY, outZ, inX, inY, inZ, theta, phi };
+}
+
 void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b) {
     if (!is_recording)
         return;
     
-    append(Op::MatrixTranslate).matrix_translate = { matrix, *((Vec3fInterp*) &b) };
+    append(Op::MatrixTranslate).matrix_translate = { matrix, b };
+}
+
+void FrameInterpolation_RecordMatrixTranslateRotateZYX(Vec3f translation, Vec3s rotation) {
+    if (!is_recording)
+        return;
+    append(Op::MatrixTranslateRotateZYX).matrix_translate_rotate_zyx = { translation, rotation };
 }
 
 void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 x, f32 y, f32 z, u8 mode) {
@@ -572,11 +621,10 @@ void FrameInterpolation_RecordMatrixMultVec3fNoTranslate(Mat4* matrix, Vec3f src
 
 // Make a template for deref
 
-
-void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation) {
+void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation ) {
     if (!is_recording)
         return;
-    append(Op::MatrixPosRotXYZ).matrix_pos_rot_xyz = { *((Vec3fInterp*) &pos), *((Vec3sInterp*) &orientation) };
+    append(Op::MatrixPosRotXYZ).matrix_pos_rot_xyz = { pos, orientation };
 }
 
 void FrameInterpolation_RecordMatrixMultVec3f(Mat4* matrix, Vec3f src, Vec3f dest) {
diff --git a/src/port/interpolation/FrameInterpolation.h b/src/port/interpolation/FrameInterpolation.h
index d2a9a5fe3..d79744714 100644
--- a/src/port/interpolation/FrameInterpolation.h
+++ b/src/port/interpolation/FrameInterpolation.h
@@ -47,6 +47,9 @@ void FrameInterpolation_RecordMatrixPop(Mat4* matrix);
 
 //void FrameInterpolation_RecordMatrixMult(Matrix* matrix, MtxF* mf, u8 mode);
 
+void FrameInterpolation_RecordMatrixMultKart(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY,
+                                             f32 inZ, u16 theta, u16 phi);
+
 void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b);
 
 //void FrameInterpolation_RecordMatrixScale(Matrix* matrix, f32 x, f32 y, f32 z, u8 mode);
diff --git a/src/port/interpolation/matrix.c b/src/port/interpolation/matrix.c
index 5580975a5..8fc14868f 100644
--- a/src/port/interpolation/matrix.c
+++ b/src/port/interpolation/matrix.c
@@ -394,14 +394,14 @@ void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot) {
     xHatP[0] -= originP[0];
     xHatP[1] -= originP[1];
     xHatP[2] -= originP[2];
-    *rot[1] = atan2f(zHatP[0], zHatP[2]);
-    *rot[0] = -atan2f(zHatP[1], sqrtf(SQ(zHatP[0]) + SQ(zHatP[2])));
-    Matrix_RotateX(&invYP, -*rot[0], MTXF_NEW);
-    Matrix_RotateY(&invYP, -*rot[1], MTXF_APPLY);
+    *rot.y = atan2f(zHatP[0], zHatP[2]);
+    *rot.x = -atan2f(zHatP[1], sqrtf(SQ(zHatP[0]) + SQ(zHatP[2])));
+    Matrix_RotateX(&invYP, -*rot.x, MTXF_NEW);
+    Matrix_RotateY(&invYP, -*rot.y, MTXF_APPLY);
     Matrix_MultVec3fNoTranslate(&invYP, &xHatP, &xHat);
-    *rot[0] *= M_RTOD;
-    *rot[1] *= M_RTOD;
-    *rot[2] = atan2f(xHat[1], xHat[0]) * M_RTOD;
+    *rot.x *= M_RTOD;
+    *rot.y *= M_RTOD;
+    *rot.z = atan2f(xHat[1], xHat[0]) * M_RTOD;
 }
 
 // Expresses the rotational part of the transform mtx as Tait-Bryan angles, in the extrinsic XYZ convention used in
@@ -424,14 +424,14 @@ void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) {
     yHatP[0] -= originP[0];
     yHatP[1] -= originP[1];
     yHatP[2] -= originP[2];
-    *rot[2] = atan2f(xHatP[1], xHatP[0]);
-    *rot[1] = -atan2f(xHatP[2], sqrtf(SQ(xHatP[0]) + SQ(xHatP[1])));
-    Matrix_RotateY(&invYZ, -*rot[1], MTXF_NEW);
-    Matrix_RotateZ(&invYZ, -*rot[2], MTXF_APPLY);
+    *rot.z = atan2f(xHatP[1], xHatP[0]);
+    *rot.y = -atan2f(xHatP[2], sqrtf(SQ(xHatP[0]) + SQ(xHatP[1])));
+    Matrix_RotateY(&invYZ, -*rot.y, MTXF_NEW);
+    Matrix_RotateZ(&invYZ, -*rot.z, MTXF_APPLY);
     Matrix_MultVec3fNoTranslate(&invYZ, &yHatP, &yHat);
-    *rot[0] = atan2f(yHat[2], yHat[1]) * M_RTOD;
-    *rot[1] *= M_RTOD;
-    *rot[2] *= M_RTOD;
+    *rot.x = atan2f(yHat[2], yHat[1]) * M_RTOD;
+    *rot.y *= M_RTOD;
+    *rot.z *= M_RTOD;
 }
 
 // Creates a look-at matrix from Eye, At, and Up in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY).
diff --git a/src/port/interpolation/matrix.h b/src/port/interpolation/matrix.h
index f71ef6ab0..f3ab8e744 100644
--- a/src/port/interpolation/matrix.h
+++ b/src/port/interpolation/matrix.h
@@ -10,18 +10,6 @@ typedef struct {
     float b;
 } Color;
 
-typedef struct {
-    float x;
-    float y;
-    float z;
-} Vec3fInterp;
-
-typedef struct {
-    s16 x;
-    s16 y;
-    s16 z;
-} Vec3sInterp;
-
 typedef struct {
     f32 m1; f32 m2; f32 m3; f32 m4;
     f32 m5; f32 m6; f32 m7; f32 m8;
diff --git a/src/port/resource/importers/ActorSpawnDataFactory.cpp b/src/port/resource/importers/ActorSpawnDataFactory.cpp
index a06f18000..eac423b4b 100644
--- a/src/port/resource/importers/ActorSpawnDataFactory.cpp
+++ b/src/port/resource/importers/ActorSpawnDataFactory.cpp
@@ -20,9 +20,9 @@ ResourceFactoryBinaryActorSpawnDataV0::ReadResource(std::shared_ptr<Ship::File>
 
     for (uint32_t i = 0; i < count; i++) {
         ActorSpawnData data;
-        data.pos[0] = reader->ReadInt16();
-        data.pos[1] = reader->ReadInt16();
-        data.pos[2] = reader->ReadInt16();
+        data.pos.x = reader->ReadInt16();
+        data.pos.y = reader->ReadInt16();
+        data.pos.z = reader->ReadInt16();
         data.signedSomeId = reader->ReadInt16();
 
         section->ActorSpawnDataList.push_back(data);
diff --git a/src/port/resource/importers/UnkActorSpawnDataFactory.cpp b/src/port/resource/importers/UnkActorSpawnDataFactory.cpp
index 666aad618..adca2204c 100644
--- a/src/port/resource/importers/UnkActorSpawnDataFactory.cpp
+++ b/src/port/resource/importers/UnkActorSpawnDataFactory.cpp
@@ -20,9 +20,9 @@ ResourceFactoryBinaryUnkActorSpawnDataV0::ReadResource(std::shared_ptr<Ship::Fil
 
     for (uint32_t i = 0; i < count; i++) {
         UnkActorSpawnData data;
-        data.pos[0] = reader->ReadInt16();
-        data.pos[1] = reader->ReadInt16();
-        data.pos[2] = reader->ReadInt16();
+        data.pos.x = reader->ReadInt16();
+        data.pos.y = reader->ReadInt16();
+        data.pos.z = reader->ReadInt16();
         data.someId = reader->ReadInt16();
         data.unk8 = reader->ReadInt16();
 
diff --git a/src/port/ui/Properties.cpp b/src/port/ui/Properties.cpp
index 0368231d9..4b90044be 100644
--- a/src/port/ui/Properties.cpp
+++ b/src/port/ui/Properties.cpp
@@ -66,9 +66,9 @@ namespace Editor {
                     rot[i] = (rot[i] % 65536 + 65536) % 65536;
                 }
 
-                selected->Rot->pitch = static_cast<uint16_t>(rot[0]);
-                selected->Rot->yaw   = static_cast<uint16_t>(rot[1]);
-                selected->Rot->roll  = static_cast<uint16_t>(rot[2]);
+                selected->Rot->pitch = static_cast<uint16_t>(rot.x);
+                selected->Rot->yaw   = static_cast<uint16_t>(rot.y);
+                selected->Rot->roll  = static_cast<uint16_t>(rot.z);
             }
 
             ImGui::SameLine();
diff --git a/src/racing/actors.c b/src/racing/actors.c
index 266bd8d4b..dde9be911 100644
--- a/src/racing/actors.c
+++ b/src/racing/actors.c
@@ -150,16 +150,16 @@ void actor_init(struct Actor* actor, Vec3f startingPos, Vec3s startingRot, Vec3f
             actor->flags |= 0x4000;
             actor->unk_08 = 70.0f;
             actor->boundingBoxSize = 20.0f;
-            actor->velocity[0] = actor->pos[0];
-            actor->velocity[1] = actor->pos[1];
-            actor->velocity[2] = actor->pos[2] + 70.0f;
+            actor->velocity.x = actor->pos.x;
+            actor->velocity.y = actor->pos.y;
+            actor->velocity.z = actor->pos.z + 70.0f;
             actor->model = d_course_yoshi_valley_dl_egg_lod0;
             break;
         case ACTOR_KIWANO_FRUIT:
             actor->state = 0;
-            actor->rot[0] = 0;
-            actor->rot[1] = 0;
-            actor->rot[2] = 0;
+            actor->rot.x = 0;
+            actor->rot.y = 0;
+            actor->rot.z = 0;
             actor->boundingBoxSize = 2.0f;
             actor->model = d_course_dks_jungle_parkway_dl_kiwano_fruit;
             break;
@@ -279,7 +279,7 @@ void actor_init(struct Actor* actor, Vec3f startingPos, Vec3s startingRot, Vec3f
             actor->flags = actor->flags | 0x4000 | 0x1000;
             actor->unk_08 = 0.35f;
             actor->boundingBoxSize = 1.925f;
-            check_bounding_collision(&actor->unk30, 1.925f, actor->pos[0], actor->pos[1], actor->pos[2]);
+            check_bounding_collision(&actor->unk30, 1.925f, actor->pos.x, actor->pos.y, actor->pos.z);
             break;
         case ACTOR_HOT_AIR_BALLOON_ITEM_BOX:
             actor->flags |= 0x4000;
@@ -356,7 +356,7 @@ void func_80297340(Camera* arg0) {
         return;
     }
 
-    if (temp < arg0->pos[2]) {
+    if (temp < arg0->pos.z) {
         if (D_800DC5BC != 0) {
 
             gDPSetFogColor(gDisplayListHead++, D_801625EC, D_801625F4, D_801625F0, 0xFF);
@@ -404,9 +404,9 @@ void func_802976EC(Collision* arg0, Vec3s arg1) {
 }
 
 void func_80297760(struct Actor* arg0, Vec3f arg1) {
-    arg1[0] = arg0->pos[0];
-    arg1[1] = arg0->pos[1];
-    arg1[2] = arg0->pos[2];
+    arg1[0] = arg0->pos.x;
+    arg1[1] = arg0->pos.y;
+    arg1[2] = arg0->pos.z;
     arg1[1] = calculate_surface_height(arg1[0], arg1[1], arg1[2], arg0->unk30.meshIndexZX);
 }
 
@@ -449,13 +449,13 @@ UNUSED void func_80297944(void) {};
 
 void func_8029794C(Vec3f pos, Vec3s rot, f32 scale) {
     Mat4 sp20;
-    pos[1] += 2.0f;
+    pos.y += 2.0f;
 
     mtxf_pos_rotation_xyz(sp20, pos, rot);
     mtxf_scale(sp20, scale);
     if (render_set_position(sp20, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, D_0D007B20);
-        pos[1] -= 2.0f;
+        pos.y -= 2.0f;
     }
 }
 
@@ -477,8 +477,8 @@ void func_802979F8(struct Actor* arg0, UNUSED f32 arg1) {
 
 void update_actor_static_plant(struct Actor* arg0) {
     if (((arg0->flags & 0x800) == 0) && ((arg0->flags & 0x400) != 0)) {
-        arg0->pos[1] = arg0->pos[1] + 4.0f;
-        if (arg0->pos[1] > 800.0f) {
+        arg0->pos.y = arg0->pos.y + 4.0f;
+        if (arg0->pos.y > 800.0f) {
             arg0->flags |= 0x800;
         }
     }
@@ -510,11 +510,11 @@ void render_cows(Camera* camera, Mat4 arg1) {
     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
     var_s5 = NULL;
     var_s1 = var_t1;
-    while (var_s1->pos[0] != END_OF_SPAWN_DATA) {
-        sp88[0] = var_s1->pos[0] * gCourseDirection;
-        sp88[1] = var_s1->pos[1];
-        sp88[2] = var_s1->pos[2];
-        temp_f0 = is_within_render_distance(camera->pos, sp88, camera->rot[1], 0.0f, gCameraZoom[camera - camera1],
+    while (var_s1->pos.x != END_OF_SPAWN_DATA) {
+        sp88[0] = var_s1->pos.x * gCourseDirection;
+        sp88[1] = var_s1->pos.y;
+        sp88[2] = var_s1->pos.z;
+        temp_f0 = is_within_render_distance(camera->pos, sp88, camera->rot.y, 0.0f, gCameraZoom[camera - camera1],
                                             4000000.0f);
         if (temp_f0 > 0.0f) {
             if (temp_f0 < D_8015F704) {
@@ -554,9 +554,9 @@ void render_cows(Camera* camera, Mat4 arg1) {
             temp_s1 = var_s5 - var_t1;
             if ((temp_s1 != D_8015F702) && (D_8015F704 < 160000.0f)) {
                 func_800C99E0(D_8015F708, soundThing);
-                D_8015F708[0] = var_s5->pos[0] * gCourseDirection;
-                D_8015F708[1] = var_s5->pos[1];
-                D_8015F708[2] = var_s5->pos[2];
+                D_8015F708[0] = var_s5->pos.x * gCourseDirection;
+                D_8015F708[1] = var_s5->pos.y;
+                D_8015F708[2] = var_s5->pos.z;
                 D_8015F702 = temp_s1;
                 func_800C98B8(D_8015F708, D_802B91C8, soundThing);
                 D_8015F700 = 0x00F0;
@@ -571,10 +571,10 @@ void evaluate_collision_player_palm_trees(Player* player) {
     Vec3f pos;
     struct UnkActorSpawnData* data = (struct UnkActorSpawnData*) LOAD_ASSET(d_course_dks_jungle_parkway_tree_spawn);
 
-    while (data->pos[0] != END_OF_SPAWN_DATA) {
-        pos[0] = data->pos[0] * gCourseDirection;
-        pos[1] = data->pos[1];
-        pos[2] = data->pos[2];
+    while (data->pos.x != END_OF_SPAWN_DATA) {
+        pos.x = data->pos.x * gCourseDirection;
+        pos.y = data->pos.y;
+        pos.z = data->pos.z;
         if (query_and_resolve_collision_player_actor(player, pos, 5.0f, 40.0f, 0.8f) == COLLISION) {
             if ((player->effects & STAR_EFFECT) != 0) {
                 func_800C98B8(player->pos, player->velocity, SOUND_ARG_LOAD(0x19, 0x01, 0x80, 0x10));
@@ -605,8 +605,8 @@ void evaluate_collision_players_palm_trees(void) {
 void func_80298D10(void) {
     struct UnkActorSpawnData* temp_v1 = (struct UnkActorSpawnData*) LOAD_ASSET(d_course_dks_jungle_parkway_tree_spawn);
 
-    while (temp_v1->pos[0] != END_OF_SPAWN_DATA) {
-        temp_v1->pos[1] = temp_v1->unk8;
+    while (temp_v1->pos.x != END_OF_SPAWN_DATA) {
+        temp_v1->pos.y = temp_v1->unk8;
         temp_v1->someId &= 0xF;
         temp_v1++;
     }
@@ -631,7 +631,7 @@ void render_palm_trees(Camera* camera, Mat4 arg1) {
     gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIDECALA, G_CC_MODULATEIDECALA);
     gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_TEX_EDGE, G_RM_AA_ZB_TEX_EDGE2);
 
-    while (var_s1->pos[0] != END_OF_SPAWN_DATA) {
+    while (var_s1->pos.x != END_OF_SPAWN_DATA) {
         test = var_s1->someId;
         if (test & 0x0800) {
             var_s1++;
@@ -639,16 +639,16 @@ void render_palm_trees(Camera* camera, Mat4 arg1) {
         }
 
         if ((test & 0x0400) && ((gIsGamePaused == 0) || (camera == camera1))) {
-            var_s1->pos[1] += 0xA;
-            if (var_s1->pos[1] >= 0x321) {
+            var_s1->pos.y += 0xA;
+            if (var_s1->pos.y >= 0x321) {
                 var_s1->someId |= 0x0800;
             }
         }
-        spD4[0] = var_s1->pos[0] * gCourseDirection;
-        spD4[1] = var_s1->pos[1];
-        spD4[2] = var_s1->pos[2];
+        spD4[0] = var_s1->pos.x * gCourseDirection;
+        spD4[1] = var_s1->pos.y;
+        spD4[2] = var_s1->pos.z;
 
-        if (is_within_render_distance(camera->pos, spD4, camera->rot[1], 0.0f, gCameraZoom[camera - camera1], var_f22) <
+        if (is_within_render_distance(camera->pos, spD4, camera->rot.y, 0.0f, gCameraZoom[camera - camera1], var_f22) <
                 0.0f &&
             CVarGetInteger("gNoCulling", 0) == 0) {
             var_s1++;
@@ -713,7 +713,7 @@ void render_actor_shell(Camera* camera, Mat4 matrix, struct ShellActor* shell) {
     FrameInterpolation_RecordOpenChild("Shell", TAG_ITEM_ADDR(shell));
 
     f32 temp_f0 =
-        is_within_render_distance(camera->pos, shell->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 490000.0f);
+        is_within_render_distance(camera->pos, shell->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 490000.0f);
     if (CVarGetInteger("gNoCulling", 0) == 1) {
         temp_f0 = CLAMP(temp_f0, 0.0f, 40000.0f);
     }
@@ -735,9 +735,9 @@ void render_actor_shell(Camera* camera, Mat4 matrix, struct ShellActor* shell) {
     temp_t8 = (u16) shell->rotVelocity / 4369; // Give a number between 0-15
     phi_t3 += sp58[temp_t8];                   // Select sprite
 
-    matrix[3][0] = shell->pos[0];
-    matrix[3][1] = (shell->pos[1] - shell->boundingBoxSize) + 1.0f;
-    matrix[3][2] = shell->pos[2];
+    matrix[3][0] = shell->pos.x;
+    matrix[3][1] = (shell->pos.y - shell->boundingBoxSize) + 1.0f;
+    matrix[3][2] = shell->pos.z;
 
     maxObjectsReached = render_set_position(matrix, 0) == 0;
     if (maxObjectsReached) {
@@ -782,15 +782,15 @@ UNUSED void func_8029ABD4(f32* pos, s16 state) {
 }
 
 void func_8029AC18(Camera* camera, Mat4 arg1, struct Actor* arg2) {
-    if (is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
+    if (is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
                                   4000000.0f) < 0 &&
         CVarGetInteger("gNoCulling", 0) == 0) {
         return;
     }
 
-    arg1[3][0] = arg2->pos[0];
-    arg1[3][1] = arg2->pos[1] - arg2->boundingBoxSize;
-    arg1[3][2] = arg2->pos[2];
+    arg1[3][0] = arg2->pos.x;
+    arg1[3][1] = arg2->pos.y - arg2->boundingBoxSize;
+    arg1[3][2] = arg2->pos.z;
 
     if (render_set_position(arg1, 0) != 0) {
         gSPDisplayList(gDisplayListHead++, D_0D001750);
@@ -857,10 +857,10 @@ void spawn_piranha_plants(struct ActorSpawnData* spawnData) {
     vec3f_set(startingVelocity, 0, 0, 0);
     vec3s_set(startingRot, 0, 0, 0);
 
-    while (temp_s0->pos[0] != END_OF_SPAWN_DATA) {
-        startingPos[0] = temp_s0->pos[0] * gCourseDirection;
-        startingPos[1] = temp_s0->pos[1];
-        startingPos[2] = temp_s0->pos[2];
+    while (temp_s0->pos.x != END_OF_SPAWN_DATA) {
+        startingPos[0] = temp_s0->pos.x * gCourseDirection;
+        startingPos[1] = temp_s0->pos.y;
+        startingPos[2] = temp_s0->pos.z;
         temp = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_PIRANHA_PLANT);
         temp_v1 = (struct PiranhaPlant*) CM_GetActor(temp);
         temp_v1->visibilityStates[0] = 0;
@@ -886,15 +886,15 @@ void spawn_palm_trees(struct ActorSpawnData* spawnData) {
     vec3f_set(startingVelocity, 0, 0, 0);
     vec3s_set(startingRot, 0, 0, 0);
 
-    while (temp_s0->pos[0] != END_OF_SPAWN_DATA) {
-        startingPos[0] = temp_s0->pos[0] * gCourseDirection;
-        startingPos[1] = temp_s0->pos[1];
-        startingPos[2] = temp_s0->pos[2];
+    while (temp_s0->pos.x != END_OF_SPAWN_DATA) {
+        startingPos[0] = temp_s0->pos.x * gCourseDirection;
+        startingPos[1] = temp_s0->pos.y;
+        startingPos[2] = temp_s0->pos.z;
         temp = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_PALM_TREE);
         temp_v1 = (struct PalmTree*) CM_GetActor(temp);
 
         temp_v1->variant = temp_s0->someId;
-        check_bounding_collision((Collision*) &temp_v1->unk30, 5.0f, temp_v1->pos[0], temp_v1->pos[1], temp_v1->pos[2]);
+        check_bounding_collision((Collision*) &temp_v1->unk30, 5.0f, temp_v1->pos.x, temp_v1->pos.y, temp_v1->pos.z);
         func_802976EC((Collision*) &temp_v1->unk30, temp_v1->rot);
         temp_s0++;
     }
@@ -922,10 +922,10 @@ void spawn_foliage(struct ActorSpawnData* actor) {
         return;
     }
 
-    while (var_s3->pos[0] != END_OF_SPAWN_DATA) {
-        position[0] = var_s3->pos[0] * gCourseDirection;
-        position[2] = var_s3->pos[2];
-        position[1] = var_s3->pos[1];
+    while (var_s3->pos.x != END_OF_SPAWN_DATA) {
+        position.x = var_s3->pos.x * gCourseDirection;
+        position.z = var_s3->pos.z;
+        position.y = var_s3->pos.y;
 
         if (GetCourse() == GetMarioRaceway()) {
             actorType = 2;
@@ -966,9 +966,9 @@ void spawn_foliage(struct ActorSpawnData* actor) {
         if (gGamestate == CREDITS_SEQUENCE) {
             func_802976D8(temp_s0->rot);
         } else {
-            check_bounding_collision(&temp_s0->unk30, 5.0f, temp_s0->pos[0], temp_s0->pos[1], temp_s0->pos[2]);
+            check_bounding_collision(&temp_s0->unk30, 5.0f, temp_s0->pos.x, temp_s0->pos.y, temp_s0->pos.z);
             if (temp_s0->unk30.surfaceDistance[2] < 0.0f) {
-                temp_s0->pos[1] = calculate_surface_height(temp_s0->pos[0], temp_s0->pos[1], temp_s0->pos[2],
+                temp_s0->pos.y = calculate_surface_height(temp_s0->pos.x, temp_s0->pos.y, temp_s0->pos.z,
                                                            temp_s0->unk30.meshIndexZX);
             }
             func_802976EC(&temp_s0->unk30, temp_s0->rot);
@@ -991,10 +991,10 @@ void spawn_all_item_boxes(struct ActorSpawnData* spawnData) {
     }
 
     vec3f_set(startingVelocity, 0, 0, 0);
-    while (temp_s0->pos[0] != END_OF_SPAWN_DATA) {
-        startingPos[0] = temp_s0->pos[0] * gCourseDirection;
-        startingPos[1] = temp_s0->pos[1];
-        startingPos[2] = temp_s0->pos[2];
+    while (temp_s0->pos.x != END_OF_SPAWN_DATA) {
+        startingPos[0] = temp_s0->pos.x * gCourseDirection;
+        startingPos[1] = temp_s0->pos.y;
+        startingPos[2] = temp_s0->pos.z;
         startingRot[0] = random_u16();
         startingRot[1] = random_u16();
         startingRot[2] = random_u16();
@@ -1008,11 +1008,11 @@ void spawn_all_item_boxes(struct ActorSpawnData* spawnData) {
         CM_GetActor(temp_s1)->unk_08 = temp_f0;
         // itemBox->resetDistance = temp_f0;
 
-        CM_GetActor(temp_s1)->velocity[0] = startingPos[1];
+        CM_GetActor(temp_s1)->velocity.x = startingPos[1];
         // itemBox->origY = startingPos[1];
 
-        CM_GetActor(temp_s1)->pos[1] = temp_f0 - 20.0f;
-        // itemBox->pos[1] = temp_f0 - 20.0f;
+        CM_GetActor(temp_s1)->pos.y = temp_f0 - 20.0f;
+        // itemBox->pos.y = temp_f0 - 20.0f;
 
         temp_s0++;
     }
@@ -1079,10 +1079,10 @@ void spawn_course_actors(void) {
     //         // spawn_piranha_plants(d_course_mario_raceway_piranha_plant_spawns);
     //         // spawn_all_item_boxes(d_course_mario_raceway_item_box_spawns);
     //         // vec3f_set(position, 150.0f, 40.0f, -1300.0f);
-    //         // position[0] *= gCourseDirection;
+    //         // position.x *= gCourseDirection;
     //         // add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
     //         // vec3f_set(position, 2520.0f, 0.0f, 1240.0f);
-    //         // position[0] *= gCourseDirection;
+    //         // position.x *= gCourseDirection;
     //         // actor = GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN));
     //         // actor->flags |= 0x4000;
     //         break;
@@ -1101,7 +1101,7 @@ void spawn_course_actors(void) {
     //         spawn_foliage(d_course_yoshi_valley_tree_spawn);
     //         spawn_all_item_boxes(d_course_yoshi_valley_item_box_spawns);
     //         vec3f_set(position, -2300.0f, 0.0f, 634.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         add_actor_to_empty_slot(position, rotation, velocity, ACTOR_YOSHI_EGG);
     //         break;
     //     case COURSE_FRAPPE_SNOWLAND:
@@ -1135,23 +1135,23 @@ void spawn_course_actors(void) {
     //         spawn_foliage(d_course_kalimari_desert_cactus_spawn);
     //         spawn_all_item_boxes(d_course_kalimari_desert_item_box_spawns);
     //         vec3f_set(position, -1680.0f, 2.0f, 35.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         rrxing = (struct RailroadCrossing*) &gActorList[add_actor_to_empty_slot(position, rotation, velocity,
     //                                                                                 ACTOR_RAILROAD_CROSSING)];
     //         rrxing->crossingId = 1;
     //         vec3f_set(position, -1600.0f, 2.0f, 35.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         rrxing = (struct RailroadCrossing*) &gActorList[add_actor_to_empty_slot(position, rotation, velocity,
     //                                                                                 ACTOR_RAILROAD_CROSSING)];
     //         rrxing->crossingId = 1;
     //         vec3s_set(rotation, 0, -0x2000, 0);
     //         vec3f_set(position, -2459.0f, 2.0f, 2263.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         rrxing = (struct RailroadCrossing*) &gActorList[add_actor_to_empty_slot(position, rotation, velocity,
     //                                                                                 ACTOR_RAILROAD_CROSSING)];
     //         rrxing->crossingId = 0;
     //         vec3f_set(position, -2467.0f, 2.0f, 2375.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         rrxing = (struct RailroadCrossing*) &gActorList[add_actor_to_empty_slot(position, rotation, velocity,
     //                                                                                 ACTOR_RAILROAD_CROSSING)];
     //         rrxing->crossingId = 0;
@@ -1165,13 +1165,13 @@ void spawn_course_actors(void) {
     //     case COURSE_WARIO_STADIUM:
     //         spawn_all_item_boxes(d_course_wario_stadium_item_box_spawns);
     //         vec3f_set(position, -131.0f, 83.0f, 286.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         add_actor_to_empty_slot(position, rotation, velocity, ACTOR_WARIO_SIGN);
     //         vec3f_set(position, -2353.0f, 72.0f, -1608.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         add_actor_to_empty_slot(position, rotation, velocity, ACTOR_WARIO_SIGN);
     //         vec3f_set(position, -2622.0f, 79.0f, 739.0f);
-    //         position[0] *= gCourseDirection;
+    //         position.x *= gCourseDirection;
     //         add_actor_to_empty_slot(position, rotation, velocity, ACTOR_WARIO_SIGN);
     //         break;
     //     case COURSE_BLOCK_FORT:
@@ -1462,21 +1462,21 @@ bool query_and_resolve_collision_player_actor(Player* player, Vec3f pos, f32 min
 
     minDist = player->boundingBoxSize + minDist;
     dist = player->boundingBoxSize + dist;
-    xDist = pos[0] - player->pos[0];
+    xDist = pos.x - player->pos.x;
     if (minDist < xDist) {
         return NO_COLLISION;
     }
     if (xDist < -minDist) {
         return NO_COLLISION;
     }
-    yDist = pos[1] - player->pos[1];
+    yDist = pos.y - player->pos.y;
     if (dist < yDist) {
         return NO_COLLISION;
     }
     if (yDist < -dist) {
         return NO_COLLISION;
     }
-    zDist = pos[2] - player->pos[2];
+    zDist = pos.z - player->pos.z;
     if (minDist < zDist) {
         return NO_COLLISION;
     }
@@ -1492,8 +1492,8 @@ bool query_and_resolve_collision_player_actor(Player* player, Vec3f pos, f32 min
     }
     sqrtDist = sqrtf(dist);
     sp28 = sqrtDist - minDist;
-    xVelocity = player->velocity[0];
-    zVelocity = player->velocity[2];
+    xVelocity = player->velocity.x;
+    zVelocity = player->velocity.z;
     if (player->effects & STAR_EFFECT) {
         return COLLISION;
     }
@@ -1502,10 +1502,10 @@ bool query_and_resolve_collision_player_actor(Player* player, Vec3f pos, f32 min
         if (temp_f0_4 < 0.5f) {
             temp_f0_4 = 0.5f;
         }
-        player->velocity[0] = 0;
-        player->velocity[2] = 0;
-        player->pos[0] += (xVelocity / temp_f0_4) * minDist;
-        player->pos[2] += (zVelocity / temp_f0_4) * minDist;
+        player->velocity.x = 0;
+        player->velocity.z = 0;
+        player->pos.x += (xVelocity / temp_f0_4) * minDist;
+        player->pos.z += (zVelocity / temp_f0_4) * minDist;
     } else {
         player->effects |= 0x8000;
         xDist /= sqrtDist;
@@ -1513,18 +1513,18 @@ bool query_and_resolve_collision_player_actor(Player* player, Vec3f pos, f32 min
         temp_f0_5 = sqrtf((xVelocity * xVelocity) + (zVelocity * zVelocity));
         if (temp_f0_5 < 0.25f) {
             temp_f0_6 = 1.2f;
-            player->pos[0] = pos[0] - (xDist * minDist * temp_f0_6);
-            player->pos[2] = pos[2] - (zDist * minDist * temp_f0_6);
-            player->velocity[0] = 0.0f;
-            player->velocity[2] = 0.0f;
+            player->pos.x = pos.x - (xDist * minDist * temp_f0_6);
+            player->pos.z = pos.z - (zDist * minDist * temp_f0_6);
+            player->velocity.x = 0.0f;
+            player->velocity.z = 0.0f;
             return COLLISION;
         }
         temp_f2_2 = ((xDist * xVelocity) + (zDist * zVelocity)) / temp_f0_5;
         temp_f2_2 = temp_f0_5 * temp_f2_2 * arg4 * 1.3f;
-        player->velocity[0] -= xDist * temp_f2_2;
-        player->velocity[2] -= zDist * temp_f2_2;
-        player->pos[0] += xDist * sp28 * 0.5f;
-        player->pos[2] += zDist * sp28 * 0.5f;
+        player->velocity.x -= xDist * temp_f2_2;
+        player->velocity.z -= zDist * temp_f2_2;
+        player->pos.x += xDist * sp28 * 0.5f;
+        player->pos.z += zDist * sp28 * 0.5f;
     }
     return COLLISION;
 }
@@ -1574,7 +1574,7 @@ bool collision_yoshi_egg(Player* player, struct YoshiValleyEgg* egg) {
     f32 maxDist = 60.0f;
     f32 minDist = 0.0f;
 
-    x_dist = egg->pos[0] - player->pos[0];
+    x_dist = egg->pos.x - player->pos.x;
     if ((x_dist < minDist) && (x_dist < -maxDist)) {
         return false;
     }
@@ -1582,7 +1582,7 @@ bool collision_yoshi_egg(Player* player, struct YoshiValleyEgg* egg) {
         return false;
     }
 
-    z_dist = egg->pos[2] - player->pos[2];
+    z_dist = egg->pos.z - player->pos.z;
     if ((z_dist < minDist) && (z_dist < -maxDist)) {
         return false;
     }
@@ -1596,7 +1596,7 @@ bool collision_yoshi_egg(Player* player, struct YoshiValleyEgg* egg) {
     }
     func_802977B0(player);
 
-    y_dist = player->pos[1] - egg->pos[1];
+    y_dist = player->pos.y - egg->pos.y;
     if (y_dist < minDist) {
         return false;
     }
@@ -1640,21 +1640,21 @@ bool collision_tree(Player* player, struct Actor* actor) {
     f32 temp_f2;
 
     var_f16 = actor->unk_08;
-    x_dist = actor->pos[0] - player->pos[0];
+    x_dist = actor->pos.x - player->pos.x;
     if ((x_dist < 0.0f) && (x_dist < -var_f16)) {
         return false;
     }
     if (var_f16 < x_dist) {
         return false;
     }
-    z_dist = actor->pos[2] - player->pos[2];
+    z_dist = actor->pos.z - player->pos.z;
     if ((z_dist < 0.0f) && (z_dist < -var_f16)) {
         return false;
     }
     if (var_f16 < z_dist) {
         return false;
     }
-    y_dist = player->pos[1] - actor->pos[1];
+    y_dist = player->pos.y - actor->pos.y;
     if (y_dist < 0.0f) {
         return false;
     }
@@ -1670,8 +1670,8 @@ bool collision_tree(Player* player, struct Actor* actor) {
     if (var_f16 < xz_dist) {
         return false;
     }
-    sp48 = player->velocity[0];
-    sp44 = player->velocity[2];
+    sp48 = player->velocity.x;
+    sp44 = player->velocity.z;
     if (player->type & PLAYER_HUMAN) {
         if (player->effects & STAR_EFFECT) {
             actor->flags |= 0x400;
@@ -1686,9 +1686,9 @@ bool collision_tree(Player* player, struct Actor* actor) {
     if (!(player->effects & STAR_EFFECT)) {
         player->effects |= 0x8000;
     }
-    actorPos[0] = actor->pos[0];
-    actorPos[1] = actor->pos[1];
-    actorPos[2] = actor->pos[2];
+    actorPos[0] = actor->pos.x;
+    actorPos[1] = actor->pos.y;
+    actorPos[2] = actor->pos.z;
     if (((GetCourse() == GetMarioRaceway()) || (GetCourse() == GetYoshiValley()) ||
          (GetCourse() == GetRoyalRaceway()) || (GetCourse() == GetLuigiRaceway())) &&
         (player->unk_094 > 1.0f)) {
@@ -1697,28 +1697,28 @@ bool collision_tree(Player* player, struct Actor* actor) {
     if (xz_dist < 0.1f) {
         sqrtf((sp48 * sp48) + (sp44 * sp44));
         if (xz_dist) {}
-        player->velocity[0] = 0;
-        player->velocity[2] = 0;
-        player->pos[0] = actorPos[0] - (x_dist * var_f16 * 1.2f);
-        player->pos[2] = actorPos[2] - (z_dist * var_f16 * 1.2f);
+        player->velocity.x = 0;
+        player->velocity.z = 0;
+        player->pos.x = actorPos[0] - (x_dist * var_f16 * 1.2f);
+        player->pos.z = actorPos[2] - (z_dist * var_f16 * 1.2f);
     } else {
         temp_f0_4 = sqrtf((sp48 * sp48) + (sp44 * sp44));
         x_dist /= xz_dist;
         z_dist /= xz_dist;
         if (temp_f0_4 < 0.25f) {
-            player->pos[0] = actorPos[0] - (x_dist * var_f16 * 1.2f);
-            player->pos[2] = actorPos[2] - (z_dist * var_f16 * 1.2f);
-            player->velocity[0] = 0;
-            player->velocity[2] = 0;
+            player->pos.x = actorPos[0] - (x_dist * var_f16 * 1.2f);
+            player->pos.z = actorPos[2] - (z_dist * var_f16 * 1.2f);
+            player->velocity.x = 0;
+            player->velocity.z = 0;
             return true;
         }
         temp_f12 = ((x_dist * sp48) + (z_dist * sp44)) / temp_f0_4;
         temp_f12 = temp_f0_4 * temp_f12 * 1.5f;
-        player->velocity[0] -= x_dist * temp_f12;
-        player->velocity[2] -= z_dist * temp_f12;
+        player->velocity.x -= x_dist * temp_f12;
+        player->velocity.z -= z_dist * temp_f12;
         temp_f2 = xz_dist - var_f16;
-        player->pos[0] += x_dist * temp_f2 * 0.5f;
-        player->pos[2] += z_dist * temp_f2 * 0.5f;
+        player->pos.x += x_dist * temp_f2 * 0.5f;
+        player->pos.z += z_dist * temp_f2 * 0.5f;
     }
     return true;
 }
@@ -1731,21 +1731,21 @@ bool query_collision_player_vs_actor_item(Player* arg0, struct Actor* arg1) {
     f32 xDist;
 
     temp_f0 = arg0->boundingBoxSize + arg1->boundingBoxSize;
-    xDist = arg1->pos[0] - arg0->pos[0];
+    xDist = arg1->pos.x - arg0->pos.x;
     if (temp_f0 < xDist) {
         return NO_COLLISION;
     }
     if (xDist < -temp_f0) {
         return NO_COLLISION;
     }
-    yDist = arg1->pos[1] - arg0->pos[1];
+    yDist = arg1->pos.y - arg0->pos.y;
     if (temp_f0 < yDist) {
         return NO_COLLISION;
     }
     if (yDist < -temp_f0) {
         return NO_COLLISION;
     }
-    zDist = arg1->pos[2] - arg0->pos[2];
+    zDist = arg1->pos.z - arg0->pos.z;
     if (temp_f0 < zDist) {
         return NO_COLLISION;
     }
@@ -1770,21 +1770,21 @@ bool query_collision_actor_vs_actor(struct Actor* arg0, struct Actor* arg1) {
     f32 dist_x;
 
     temp_f0 = arg0->boundingBoxSize + arg1->boundingBoxSize;
-    dist_x = arg0->pos[0] - arg1->pos[0];
+    dist_x = arg0->pos.x - arg1->pos.x;
     if (temp_f0 < dist_x) {
         return NO_COLLISION;
     }
     if (dist_x < -temp_f0) {
         return NO_COLLISION;
     }
-    dist_y = arg0->pos[1] - arg1->pos[1];
+    dist_y = arg0->pos.y - arg1->pos.y;
     if (temp_f0 < dist_y) {
         return NO_COLLISION;
     }
     if (dist_y < -temp_f0) {
         return NO_COLLISION;
     }
-    dist_z = arg0->pos[2] - arg1->pos[2];
+    dist_z = arg0->pos.z - arg1->pos.z;
     if (temp_f0 < dist_z) {
         return NO_COLLISION;
     }
@@ -1823,7 +1823,7 @@ void destroy_destructable_actor(struct Actor* actor) {
                     banana->flags = -0x8000;
                     banana->unk_04 = 0x003C;
                     banana->state = DESTROYED_BANANA;
-                    banana->velocity[1] = 3.0f;
+                    banana->velocity.y = 3.0f;
                     break;
                 case DROPPED_BANANA:
                 case DESTROYED_BANANA:
@@ -1844,7 +1844,7 @@ void destroy_destructable_actor(struct Actor* actor) {
                         shell->rotAngle = 0;
                         shell->someTimer = 0x003C;
                         shell->state = GREEN_SHELL_HIT_A_RACER;
-                        shell->velocity[1] = 3.0f;
+                        shell->velocity.y = 3.0f;
                         break;
                     case TRIPLE_GREEN_SHELL:
                         triple_shell_actor_collide_with_player(shell, ACTOR_GREEN_SHELL);
@@ -1873,7 +1873,7 @@ void destroy_destructable_actor(struct Actor* actor) {
                         shell->rotAngle = 0;
                         shell->someTimer = 0x003C;
                         shell->state = DESTROYED_SHELL;
-                        shell->velocity[1] = 3.0f;
+                        shell->velocity.y = 3.0f;
                         break;
                     default:
                         break;
@@ -1898,7 +1898,7 @@ void destroy_destructable_actor(struct Actor* actor) {
                         shell->rotAngle = 0;
                         shell->someTimer = 0x003C;
                         shell->state = DESTROYED_SHELL;
-                        shell->velocity[1] = 3.0f;
+                        shell->velocity.y = 3.0f;
                         break;
                     case TRIPLE_RED_SHELL:
                         triple_shell_actor_collide_with_player(shell, ACTOR_RED_SHELL);
@@ -2040,7 +2040,7 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
             if (player->soundEffects & 1) {
                 break;
             }
-            temp_v1 = actor->rot[0];
+            temp_v1 = actor->rot.x;
             if (((temp_lo == temp_v1) && (actor->flags & 0x1000)) ||
                 (query_collision_player_vs_actor_item(player, actor) != COLLISION)) {
                 break;
@@ -2053,8 +2053,8 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
                         func_800C90F4(temp_v1, (owner->characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x06));
                     }
                 } else {
-                    temp_f0 = actor->pos[0] - owner->pos[0];
-                    temp_f2 = actor->pos[2] - owner->pos[2];
+                    temp_f0 = actor->pos.x - owner->pos.x;
+                    temp_f2 = actor->pos.z - owner->pos.z;
                     if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) < 360000.0f) && (temp_lo != temp_v1)) {
                         func_800C90F4(temp_v1, (owner->characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x06));
                     }
@@ -2069,7 +2069,7 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
             if (player->soundEffects & 4) {
                 break;
             }
-            temp_v1 = actor->rot[2];
+            temp_v1 = actor->rot.z;
             if (((temp_lo == temp_v1) && (actor->flags & 0x1000)) ||
                 (query_collision_player_vs_actor_item(player, actor) != COLLISION)) {
                 break;
@@ -2086,7 +2086,7 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
             if (player->soundEffects & 2) {
                 break;
             }
-            temp_v1 = actor->rot[2];
+            temp_v1 = actor->rot.z;
             if (((temp_lo == temp_v1) && (actor->flags & 0x1000)) ||
                 (query_collision_player_vs_actor_item(player, actor) != COLLISION)) {
                 break;
@@ -2104,14 +2104,14 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
             }
             break;
         case ACTOR_RED_SHELL:
-            temp_v1 = actor->rot[2];
+            temp_v1 = actor->rot.z;
             if (player->effects & 0x01000000) {
                 break;
             }
             if (player->soundEffects & 2) {
                 break;
             }
-            temp_v1 = actor->rot[2];
+            temp_v1 = actor->rot.z;
             if (((temp_lo == temp_v1) && (actor->flags & 0x1000)) ||
                 (query_collision_player_vs_actor_item(player, actor) != COLLISION)) {
                 break;
@@ -2160,7 +2160,7 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
                         D_80162DF8 = 1;
                     }
                     if (player->effects & STAR_EFFECT) {
-                        actor->velocity[1] = 10.0f;
+                        actor->velocity.y = 10.0f;
                     } else {
                         apply_hit_sound_effect(player, player - gPlayerOne);
                     }
@@ -2168,11 +2168,11 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
             }
             break;
         case ACTOR_FAKE_ITEM_BOX:
-            temp_v1 = actor->velocity[0];
+            temp_v1 = actor->velocity.x;
             if (player->effects & BOO_EFFECT) {
                 break;
             }
-            temp_v1 = actor->velocity[0];
+            temp_v1 = actor->velocity.x;
             if (((temp_lo == temp_v1) && (actor->flags & 0x1000)) ||
                 (query_collision_player_vs_actor_item(player, actor) != COLLISION)) {
                 break;
@@ -2185,8 +2185,8 @@ void evaluate_collision_between_player_actor(Player* player, struct Actor* actor
                         func_800C90F4(temp_v1, (owner->characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x06));
                     }
                 } else {
-                    temp_f0 = actor->pos[0] - owner->pos[0];
-                    temp_f2 = actor->pos[2] - owner->pos[2];
+                    temp_f0 = actor->pos.x - owner->pos.x;
+                    temp_f2 = actor->pos.z - owner->pos.z;
                     if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) < 360000.0f) && (temp_lo != temp_v1)) {
                         func_800C90F4(temp_v1, (owner->characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x06));
                     }
@@ -2304,7 +2304,7 @@ void evaluate_collision_for_destructible_actors(void) {
                             break;
                         case ACTOR_GREEN_SHELL:
                             if (actor1->type == ACTOR_GREEN_SHELL) {
-                                if (actor1->rot[2] == actor2->rot[2]) {
+                                if (actor1->rot.z == actor2->rot.z) {
                                     continue;
                                 }
                             }
@@ -2312,7 +2312,7 @@ void evaluate_collision_for_destructible_actors(void) {
                             break;
                         case ACTOR_RED_SHELL:
                             if (actor1->type == ACTOR_RED_SHELL) {
-                                if (actor1->rot[2] == actor2->rot[2]) {
+                                if (actor1->rot.z == actor2->rot.z) {
                                     continue;
                                 }
                             }
@@ -2354,9 +2354,9 @@ void init_actor_hot_air_balloon_item_box(f32 x, f32 y, f32 z) {
 
     vec3s_set(rot, 0, 0, 0);
     vec3f_set(velocity, 0, 0, 0);
-    pos[0] = x;
-    pos[1] = y;
-    pos[2] = z;
+    pos.x = x;
+    pos.y = y;
+    pos.z = z;
     id = add_actor_to_empty_slot(pos, rot, velocity, ACTOR_HOT_AIR_BALLOON_ITEM_BOX);
     gActorHotAirBalloonItemBox = CM_GetActor(id);
 }
@@ -2412,8 +2412,8 @@ void render_course_actors(struct UnkStruct_800DC5EC* arg0) {
 
     struct Actor* actor;
     UNUSED Vec3f sp4C = { 0.0f, 5.0f, 10.0f };
-    f32 sp48 = sins(camera->rot[1] - 0x8000); // unk26;
-    f32 temp_f0 = coss(camera->rot[1] - 0x8000);
+    f32 sp48 = sins(camera->rot.y - 0x8000); // unk26;
+    f32 temp_f0 = coss(camera->rot.y - 0x8000);
 
     sBillBoardMtx[0][0] = temp_f0;
     sBillBoardMtx[0][2] = -sp48;
@@ -2552,7 +2552,7 @@ void render_course_actors(struct UnkStruct_800DC5EC* arg0) {
                 render_actor_yoshi_egg(camera, sBillBoardMtx, (struct YoshiValleyEgg*) actor, pathCounter);
                 break;
         }
-        FrameInterpolation_RecordCloseChild(actor, i);
+        FrameInterpolation_RecordCloseChild();
     }
     if (GetCourse() == GetMooMooFarm()) {
         render_cows(camera, sBillBoardMtx);
diff --git a/src/racing/actors_extended.c b/src/racing/actors_extended.c
index 5493a4efa..b07f29cdf 100644
--- a/src/racing/actors_extended.c
+++ b/src/racing/actors_extended.c
@@ -52,7 +52,7 @@ void triple_shell_actor_collide_with_player(struct ShellActor* shell, s32 shellT
 
     shell->flags = 0x8000; // bitflag
     shell->rotAngle = 0;
-    shell->velocity[1] = 3.0f;
+    shell->velocity.y = 3.0f;
     shell->someTimer = 60;
 
     switch (shellType) {
@@ -70,9 +70,9 @@ void triple_shell_actor_collide_with_player(struct ShellActor* shell, s32 shellT
 void func_802B039C(struct BananaActor* banana) {
     banana->state = DROPPED_BANANA;
     banana->unk_04 = 0x00B4;
-    banana->velocity[0] = ((f32) (random_int(0x00C8) - 0x64) * 0.015);
-    banana->velocity[1] = ((f32) random_int(0x00C8)) * 0.015;
-    banana->velocity[2] = ((f32) (random_int(0x00C8) - 0x64) * 0.015);
+    banana->velocity.x = ((f32) (random_int(0x00C8) - 0x64) * 0.015);
+    banana->velocity.y = ((f32) random_int(0x00C8)) * 0.015;
+    banana->velocity.z = ((f32) (random_int(0x00C8) - 0x64) * 0.015);
 }
 
 void func_802B0464(s16 bananaIndex) {
@@ -107,7 +107,7 @@ void destroy_banana_in_banana_bunch(struct BananaActor* banana) {
     banana->flags = -0x8000;
     banana->unk_04 = 0x003C;
     banana->state = DESTROYED_BANANA;
-    banana->velocity[1] = 3.0f;
+    banana->velocity.y = 3.0f;
     temp_v0_2 = (struct BananaBunchParent*) GET_ACTOR(banana->parentIndex);
     temp_v0_2->bananaIndices[0] = -1;
     temp_v0_2->bananaIndices[1] = -1;
@@ -143,9 +143,9 @@ void func_802B0648(struct BananaBunchParent* banana_bunch) {
 
     banana->state = DROPPED_BANANA;
     banana->unk_04 = 0x00B4;
-    banana->velocity[0] = 0.0f;
-    banana->velocity[1] = 1.5f;
-    banana->velocity[2] = 0.0f;
+    banana->velocity.x = 0.0f;
+    banana->velocity.y = 1.5f;
+    banana->velocity.z = 0.0f;
     elderIndex = banana->elderIndex;
     if (elderIndex != -1) {
         ((struct BananaActor*) GET_ACTOR(elderIndex))->youngerIndex = -1;
@@ -195,9 +195,9 @@ void func_802B0788(s16 rawStickY, struct BananaBunchParent* banana_bunch, Player
     }
     vec3f_set(velocity, 0.0f, var_f0, var_f12);
     func_802B64C4(velocity, player->rotation[1] + player->unk_0C0);
-    banana->velocity[0] = velocity[0];
-    banana->velocity[1] = velocity[1];
-    banana->velocity[2] = velocity[2];
+    banana->velocity.x = velocity.x;
+    banana->velocity.y = velocity.y;
+    banana->velocity.z = velocity.z;
 }
 
 s32 func_802B09C0(s16 bananaId) {
@@ -433,9 +433,9 @@ void update_actor_triple_shell(TripleShellParent* parent, s16 shellType) {
                         someVelocity[1] = 0;
                         someVelocity[2] = 8;
                         func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
-                        shell->velocity[0] = someVelocity[0];
-                        shell->velocity[1] = someVelocity[1];
-                        shell->velocity[2] = someVelocity[2];
+                        shell->velocity.x = someVelocity[0];
+                        shell->velocity.y = someVelocity[1];
+                        shell->velocity.z = someVelocity[2];
                         shell->state = MOVING_SHELL;
                         shell->someTimer = 0x001E;
                         func_800C9060(parent->playerId, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x04));
@@ -459,9 +459,9 @@ void update_actor_triple_shell(TripleShellParent* parent, s16 shellType) {
                         someVelocity[1] = 0;
                         someVelocity[2] = 8;
                         func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
-                        shell->velocity[0] = someVelocity[0];
-                        shell->velocity[1] = someVelocity[1];
-                        shell->velocity[2] = someVelocity[2];
+                        shell->velocity.x = someVelocity[0];
+                        shell->velocity.y = someVelocity[1];
+                        shell->velocity.z = someVelocity[2];
                         shell->state = MOVING_SHELL;
                         shell->someTimer = 0x001E;
                         func_800C90F4(parent->playerId,
@@ -485,9 +485,9 @@ void update_actor_triple_shell(TripleShellParent* parent, s16 shellType) {
                         someVelocity[1] = 0;
                         someVelocity[2] = 8;
                         func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
-                        shell->velocity[0] = someVelocity[0];
-                        shell->velocity[1] = someVelocity[1];
-                        shell->velocity[2] = someVelocity[2];
+                        shell->velocity.x = someVelocity[0];
+                        shell->velocity.y = someVelocity[1];
+                        shell->velocity.z = someVelocity[2];
                         shell->state = MOVING_SHELL;
                         shell->someTimer = 0x001E;
                         func_800C9060(parent->playerId, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x04));
@@ -563,9 +563,9 @@ s32 init_triple_shell(TripleShellParent* parent, Player* player, s16 shellType,
     startingPos[1] = -player->boundingBoxSize;
     startingPos[2] = player->boundingBoxSize - 4.0f;
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
 
     actorIndex = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, shellType);
     if (actorIndex < 0) {
@@ -574,10 +574,10 @@ s32 init_triple_shell(TripleShellParent* parent, Player* player, s16 shellType,
     }
 
     shell = (struct ShellActor*) GET_ACTOR(actorIndex);
-    startingPos[0] = player->pos[0];
-    startingPos[1] = player->pos[1];
-    startingPos[2] = player->pos[2];
-    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos[0], shell->pos[1], shell->pos[2],
+    startingPos[0] = player->pos.x;
+    startingPos[1] = player->pos.y;
+    startingPos[2] = player->pos.z;
+    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos.x, shell->pos.y, shell->pos.z,
                             startingPos[0], startingPos[1], startingPos[2]);
     func_802B4E30((struct Actor*) shell);
     shell->flags = 0x9000;
@@ -614,9 +614,9 @@ s32 use_green_shell_item(Player* player) {
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
 
     // move to player position
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
 
     // spawn the shell
     actorIndex = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_GREEN_SHELL);
@@ -625,10 +625,10 @@ s32 use_green_shell_item(Player* player) {
     }
 
     shell = (struct ShellActor*) GET_ACTOR(actorIndex);
-    startingPos[0] = player->pos[0];
-    startingPos[1] = player->pos[1];
-    startingPos[2] = player->pos[2];
-    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos[0], shell->pos[1], shell->pos[2],
+    startingPos[0] = player->pos.x;
+    startingPos[1] = player->pos.y;
+    startingPos[2] = player->pos.z;
+    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos.x, shell->pos.y, shell->pos.z,
                             startingPos[0], startingPos[1], startingPos[2]);
     func_802B4E30((struct Actor*) shell);
     shell->state = HELD_SHELL;
@@ -654,9 +654,9 @@ s32 use_red_shell_item(Player* player) {
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
 
     // move to player position
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
 
     // spawn the shell
     actorIndex = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_RED_SHELL);
@@ -665,10 +665,10 @@ s32 use_red_shell_item(Player* player) {
     }
 
     shell = (struct ShellActor*) GET_ACTOR(actorIndex);
-    startingPos[0] = player->pos[0];
-    startingPos[1] = player->pos[1];
-    startingPos[2] = player->pos[2];
-    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos[0], shell->pos[1], shell->pos[2],
+    startingPos[0] = player->pos.x;
+    startingPos[1] = player->pos.y;
+    startingPos[2] = player->pos.z;
+    actor_terrain_collision(&shell->unk30, shell->boundingBoxSize + 1.0f, shell->pos.x, shell->pos.y, shell->pos.z,
                             startingPos[0], startingPos[1], startingPos[2]);
     func_802B4E30((struct Actor*) shell);
     shell->state = HELD_SHELL;
@@ -701,23 +701,23 @@ void func_802B2914(struct BananaBunchParent* banana_bunch, Player* player, s16 b
     startingPos[1] = -player->boundingBoxSize;
     startingPos[2] = -(player->boundingBoxSize + 4.0f);
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
-    startingVelocity[0] = player->velocity[0];
-    startingVelocity[1] = player->velocity[1];
-    startingVelocity[2] = player->velocity[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
+    startingVelocity[0] = player->velocity.x;
+    startingVelocity[1] = player->velocity.y;
+    startingVelocity[2] = player->velocity.z;
     startingRot[0] = 0;
     startingRot[1] = 0;
     startingRot[2] = 0;
     actorIndex = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_BANANA);
     if (actorIndex >= 0) {
         newBanana = (struct BananaActor*) GET_ACTOR(actorIndex);
-        startingPos[0] = player->pos[0];
-        startingPos[1] = player->pos[1];
-        startingPos[2] = player->pos[2];
-        actor_terrain_collision(&newBanana->unk30, newBanana->boundingBoxSize + 1.0f, newBanana->pos[0],
-                                newBanana->pos[1], newBanana->pos[2], startingPos[0], startingPos[1], startingPos[2]);
+        startingPos[0] = player->pos.x;
+        startingPos[1] = player->pos.y;
+        startingPos[2] = player->pos.z;
+        actor_terrain_collision(&newBanana->unk30, newBanana->boundingBoxSize + 1.0f, newBanana->pos.x,
+                                newBanana->pos.y, newBanana->pos.z, startingPos[0], startingPos[1], startingPos[2]);
         func_802B4E30((struct Actor*) newBanana);
         newBanana->flags = 0x9000;
         newBanana->playerId = player - gPlayerOne;
@@ -783,14 +783,14 @@ s32 use_fake_itembox_item(Player* player) {
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
 
     // move to player position
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
 
     // set the itembox's velocity to the player's velocity
-    startingVelocity[0] = player->velocity[0];
-    startingVelocity[1] = player->velocity[1];
-    startingVelocity[2] = player->velocity[2];
+    startingVelocity[0] = player->velocity.x;
+    startingVelocity[1] = player->velocity.y;
+    startingVelocity[2] = player->velocity.z;
 
     startingRot[0] = 0;
     startingRot[1] = 0;
@@ -831,14 +831,14 @@ s32 use_banana_item(Player* player) {
     mtxf_translate_vec3f_mat3(startingPos, player->orientationMatrix);
 
     // add the player's position to the banana's position
-    startingPos[0] += player->pos[0];
-    startingPos[1] += player->pos[1];
-    startingPos[2] += player->pos[2];
+    startingPos[0] += player->pos.x;
+    startingPos[1] += player->pos.y;
+    startingPos[2] += player->pos.z;
 
     // set the banana's velocity to the player's velocity
-    startingVelocity[0] = player->velocity[0];
-    startingVelocity[1] = player->velocity[1];
-    startingVelocity[2] = player->velocity[2];
+    startingVelocity[0] = player->velocity.x;
+    startingVelocity[1] = player->velocity.y;
+    startingVelocity[2] = player->velocity.z;
     startingRot[0] = 0;
     startingRot[1] = 0;
     startingRot[2] = 0;
@@ -972,18 +972,18 @@ void check_player_use_item(void) {
 
 void func_802B4E30(struct Actor* arg0) {
     if ((arg0->unk30.surfaceDistance[2] < 0.0f) && (arg0->unk30.unk34 == 1)) {
-        arg0->pos[0] -= (arg0->unk30.orientationVector[0] * arg0->unk30.surfaceDistance[2]);
-        arg0->pos[1] -= (arg0->unk30.orientationVector[1] * arg0->unk30.surfaceDistance[2]);
-        arg0->pos[2] -= (arg0->unk30.orientationVector[2] * arg0->unk30.surfaceDistance[2]);
+        arg0->pos.x -= (arg0->unk30.orientationVector[0] * arg0->unk30.surfaceDistance[2]);
+        arg0->pos.y -= (arg0->unk30.orientationVector[1] * arg0->unk30.surfaceDistance[2]);
+        arg0->pos.z -= (arg0->unk30.orientationVector[2] * arg0->unk30.surfaceDistance[2]);
     }
     if ((arg0->unk30.surfaceDistance[0] < 0.0f) && (arg0->unk30.unk30 == 1)) {
-        arg0->pos[0] -= (arg0->unk30.unk48[0] * arg0->unk30.surfaceDistance[0]);
-        arg0->pos[1] -= (arg0->unk30.unk48[1] * arg0->unk30.surfaceDistance[0]);
-        arg0->pos[2] -= (arg0->unk30.unk48[2] * arg0->unk30.surfaceDistance[0]);
+        arg0->pos.x -= (arg0->unk30.unk48[0] * arg0->unk30.surfaceDistance[0]);
+        arg0->pos.y -= (arg0->unk30.unk48[1] * arg0->unk30.surfaceDistance[0]);
+        arg0->pos.z -= (arg0->unk30.unk48[2] * arg0->unk30.surfaceDistance[0]);
     }
     if ((arg0->unk30.surfaceDistance[1] < 0.0f) && (arg0->unk30.unk32 == 1)) {
-        arg0->pos[0] -= (arg0->unk30.unk54[0] * arg0->unk30.surfaceDistance[1]);
-        arg0->pos[1] -= (arg0->unk30.unk54[1] * arg0->unk30.surfaceDistance[1]);
-        arg0->pos[2] -= (arg0->unk30.unk54[2] * arg0->unk30.surfaceDistance[1]);
+        arg0->pos.x -= (arg0->unk30.unk54[0] * arg0->unk30.surfaceDistance[1]);
+        arg0->pos.y -= (arg0->unk30.unk54[1] * arg0->unk30.surfaceDistance[1]);
+        arg0->pos.z -= (arg0->unk30.unk54[2] * arg0->unk30.surfaceDistance[1]);
     }
 }
diff --git a/src/racing/collision.c b/src/racing/collision.c
index a394f0080..88728a41e 100644
--- a/src/racing/collision.c
+++ b/src/racing/collision.c
@@ -464,15 +464,15 @@ f32 calculate_surface_height(f32 x, f32 y, f32 z, u16 index) {
 
 f32 func_802ABEAC(Collision* collision, Vec3f pos) {
     if (collision->unk34 == 1) {
-        return calculate_surface_height(pos[0], pos[1], pos[2], collision->meshIndexZX);
+        return calculate_surface_height(pos.x, pos.y, pos.z, collision->meshIndexZX);
     }
     if (collision->unk30 == 1) {
-        return calculate_surface_height(pos[0], pos[1], pos[2], collision->meshIndexYX);
+        return calculate_surface_height(pos.x, pos.y, pos.z, collision->meshIndexYX);
     }
     if (collision->unk32 == 1) {
-        return calculate_surface_height(pos[0], pos[1], pos[2], collision->meshIndexZY);
+        return calculate_surface_height(pos.x, pos.y, pos.z, collision->meshIndexZY);
     }
-    return pos[1];
+    return pos.y;
 }
 
 void process_shell_collision(Vec3f pos, UNUSED f32 boundingBoxSize, Vec3f velocity, UNUSED f32 unk) {
@@ -490,35 +490,35 @@ void process_shell_collision(Vec3f pos, UNUSED f32 boundingBoxSize, Vec3f veloci
     UNUSED f32 z2;
     f32 scaleFactor;
 
-    x = velocity[0];
-    y = velocity[1];
-    z = velocity[2];
+    x = velocity.x;
+    y = velocity.y;
+    z = velocity.z;
     velocityMagnitude = sqrtf((x * x) + (y * y) + (z * z));
 
     if ((velocityMagnitude > 4.5) || (velocityMagnitude < 3.5)) {
         velocityMagnitude = 4.0f;
     }
 
-    x2 = pos[0];
-    y2 = pos[1];
-    z2 = pos[2];
+    x2 = pos.x;
+    y2 = pos.y;
+    z2 = pos.z;
 
-    dotProduct = (pos[0] * x) + (pos[1] * y) + (pos[2] * z);
-    scaleX = x - dotProduct * pos[0];
-    scaleY = y - dotProduct * pos[1];
-    scaleZ = z - dotProduct * pos[2];
+    dotProduct = (pos.x * x) + (pos.y * y) + (pos.z * z);
+    scaleX = x - dotProduct * pos.x;
+    scaleY = y - dotProduct * pos.y;
+    scaleZ = z - dotProduct * pos.z;
 
-    x = scaleX - dotProduct * pos[0];
-    y = scaleY - dotProduct * pos[1];
-    z = scaleZ - dotProduct * pos[2];
+    x = scaleX - dotProduct * pos.x;
+    y = scaleY - dotProduct * pos.y;
+    z = scaleZ - dotProduct * pos.z;
 
     magnitude = sqrtf((x * x) + (y * y) + (z * z));
 
     scaleFactor = 1.0f / magnitude * velocityMagnitude;
 
-    velocity[0] = x * scaleFactor;
-    velocity[1] = y * scaleFactor;
-    velocity[2] = z * scaleFactor;
+    velocity.x = x * scaleFactor;
+    velocity.y = y * scaleFactor;
+    velocity.z = z * scaleFactor;
 }
 
 void shell_collision(Collision* collision, Vec3f velocity) {
@@ -592,9 +592,9 @@ UNUSED s32 detect_tyre_collision(KartTyre* tyre) {
     collision.surfaceDistance[0] = 1000.0f;
     collision.surfaceDistance[1] = 1000.0f;
     collision.surfaceDistance[2] = 1000.0f;
-    tyreX = tyre->pos[0];
-    tyreY = tyre->pos[1];
-    tyreZ = tyre->pos[2];
+    tyreX = tyre->pos.x;
+    tyreY = tyre->pos.y;
+    tyreZ = tyre->pos.z;
     switch (tyre->surfaceFlags) { /* irregular */
         case 0x80:
             if (check_collision_zy(&collision, 5.0f, tyreX, tyreY, tyreZ, (u16) (s32) tyre->collisionMeshIndex) == 1) {
@@ -2190,15 +2190,15 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
     collision->unk30 = 0;
     collision->unk32 = 0;
     collision->unk34 = 0;
-    tyreX = tyre->pos[0];
-    tyreY = tyre->pos[1];
-    tyreZ = tyre->pos[2];
+    tyreX = tyre->pos.x;
+    tyreY = tyre->pos.y;
+    tyreZ = tyre->pos.z;
     switch (tyre->surfaceFlags) {
         case 0x80:
             if (is_colliding_with_wall1(collision, boundingBoxSize, tyreX, tyreY, tyreZ, tyre->collisionMeshIndex,
                                         tyre2X, tyre2Y, tyre2Z) == 1) {
                 height = calculate_surface_height(tyreX, tyreY, tyreZ, tyre->collisionMeshIndex);
-                if ((!(height > player->pos[1])) && !((player->pos[1] - height) > (2 * boundingBoxSize))) {
+                if ((!(height > player->pos.y)) && !((player->pos.y - height) > (2 * boundingBoxSize))) {
                     tyre->baseHeight = height;
                     subtract_scaled_vector(collision->unk54, collision->surfaceDistance[1], tyre->pos);
                     return 1;
@@ -2209,7 +2209,7 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
             if (is_colliding_with_drivable_surface(collision, boundingBoxSize, tyreX, tyreY, tyreZ,
                                                    tyre->collisionMeshIndex, tyre2X, tyre2Y, tyre2Z) == 1) {
                 height = calculate_surface_height(tyreX, tyreY, tyreZ, tyre->collisionMeshIndex);
-                if (!(player->pos[1] < height) && !((2 * boundingBoxSize) < (player->pos[1] - height))) {
+                if (!(player->pos.y < height) && !((2 * boundingBoxSize) < (player->pos.y - height))) {
                     tyre->baseHeight = height;
                     subtract_scaled_vector(collision->orientationVector, collision->surfaceDistance[2], tyre->pos);
                     return 1;
@@ -2220,7 +2220,7 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
             if (is_colliding_with_wall2(collision, boundingBoxSize, tyreX, tyreY, tyreZ, tyre->collisionMeshIndex,
                                         tyre2X, tyre2Y, tyre2Z) == 1) {
                 height = calculate_surface_height(tyreX, tyreY, tyreZ, tyre->collisionMeshIndex);
-                if (!(player->pos[1] < height) && !((2 * boundingBoxSize) < (player->pos[1] - height))) {
+                if (!(player->pos.y < height) && !((2 * boundingBoxSize) < (player->pos.y - height))) {
                     tyre->baseHeight = height;
                     subtract_scaled_vector(collision->unk48, collision->surfaceDistance[0], tyre->pos);
                     return 1;
@@ -2272,7 +2272,7 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
                                                        tyre2X, tyre2Y, tyre2Z) == 1) {
                     height = calculate_surface_height(tyreX, tyreY, tyreZ, meshIndex);
 
-                    if (!(player->pos[1] < height) && !((2 * boundingBoxSize) < (player->pos[1] - height))) {
+                    if (!(player->pos.y < height) && !((2 * boundingBoxSize) < (player->pos.y - height))) {
                         subtract_scaled_vector(collision->orientationVector, collision->surfaceDistance[2], tyre->pos);
                         tyre->baseHeight = height;
                         tyre->surfaceType = (u8) gCollisionMesh[meshIndex].surfaceType;
@@ -2293,7 +2293,7 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
                     if (is_colliding_with_wall1(collision, boundingBoxSize, tyreX, tyreY, tyreZ, meshIndex, tyre2X,
                                                 tyre2Y, tyre2Z) == 1) {
                         height = calculate_surface_height(tyreX, tyreY, tyreZ, meshIndex);
-                        if (!(player->pos[1] < height) && !((2 * boundingBoxSize) < (player->pos[1] - height))) {
+                        if (!(player->pos.y < height) && !((2 * boundingBoxSize) < (player->pos.y - height))) {
                             tyre->baseHeight = height;
                             subtract_scaled_vector(collision->unk54, collision->surfaceDistance[1], tyre->pos);
                             tyre->baseHeight = calculate_surface_height(tyreX, tyreY, tyreZ, meshIndex);
@@ -2311,7 +2311,7 @@ u16 player_terrain_collision(Player* player, KartTyre* tyre, f32 tyre2X, f32 tyr
                     if (is_colliding_with_wall2(collision, boundingBoxSize, tyreX, tyreY, tyreZ, meshIndex, tyre2X,
                                                 tyre2Y, tyre2Z) == 1) {
                         height = calculate_surface_height(tyreX, tyreY, tyreZ, meshIndex);
-                        if (!(player->pos[1] < height) && !((2 * boundingBoxSize) < (player->pos[1] - height))) {
+                        if (!(player->pos.y < height) && !((2 * boundingBoxSize) < (player->pos.y - height))) {
                             tyre->baseHeight = height;
                             subtract_scaled_vector(collision->unk48, collision->surfaceDistance[0], tyre->pos);
                             tyre->surfaceType = (u8) gCollisionMesh[meshIndex].surfaceType;
diff --git a/src/racing/math_util.c b/src/racing/math_util.c
index 1fb975048..c5afa5139 100644
--- a/src/racing/math_util.c
+++ b/src/racing/math_util.c
@@ -28,11 +28,11 @@ UNUSED s32 func_802B4F60(UNUSED s32 arg0, Vec3f arg1, UNUSED s32 arg2, UNUSED f3
     f32 sp28;
     Vec3f sp1C;
     vec3f_copy_return(sp1C, arg1);
-    sp28 = sp1C[0];
-    sp2C = sp1C[1];
+    sp28 = sp1C.x;
+    sp2C = sp1C.y;
     // wut?
     if (sp2C && sp2C) {};
-    sp2C = ((sp30[0][3] * sp28) + (sp30[1][3] * sp2C) + (sp30[2][3] * sp1C[2])) + sp30[3][3];
+    sp2C = ((sp30[0][3] * sp28) + (sp30[1][3] * sp2C) + (sp30[2][3] * sp1C.z)) + sp30[3][3];
     // double wut?
     if (sp28 && sp28) {};
     mtxf_translate_vec3f_mat4(sp1C, sp30);
@@ -86,17 +86,17 @@ f32 func_802B51E8(Vec3f arg0, Vec3f arg1) {
     f32 sub_z;
     f32 sub_x;
 
-    sub_x = arg1[0] - arg0[0];
-    sub_y = arg1[1] - arg0[1];
-    sub_z = arg1[2] - arg0[2];
+    sub_x = arg1.x - arg0.x;
+    sub_y = arg1.y - arg0.y;
+    sub_z = arg1.z - arg0.z;
     return (sub_x * sub_x) + (sub_y * sub_y) + sub_z + sub_z;
 }
 
 s32 get_angle_between_two_vectors(Vec3f arg0, Vec3f arg1) {
     f32 temp_v1;
     f32 temp_v2;
-    temp_v1 = arg1[0] - arg0[0];
-    temp_v2 = arg1[2] - arg0[2];
+    temp_v1 = arg1.x - arg0.x;
+    temp_v2 = arg1.z - arg0.z;
 
     return atan2s(temp_v1, temp_v2);
 }
@@ -105,22 +105,22 @@ s32 get_angle_between_two_vectors(Vec3f arg0, Vec3f arg1) {
 u32 func_802B5258(Vec3f arg0, Vec3s arg1) {
     f32 temp_v1;
     f32 temp_v2;
-    temp_v1 = arg1[0] - arg0[0];
-    temp_v2 = arg1[2] - arg0[2];
+    temp_v1 = arg1.x - arg0.x;
+    temp_v2 = arg1.z - arg0.z;
 
     return atan2s(temp_v1, temp_v2);
 }
 
 void vec3f_set(Vec3f arg0, f32 arg1, f32 arg2, f32 arg3) {
-    arg0[0] = arg1;
-    arg0[1] = arg2;
-    arg0[2] = arg3;
+    arg0.x = arg1;
+    arg0.y = arg2;
+    arg0.z = arg3;
 }
 
 void vec3s_set(Vec3s arg0, s16 arg1, s16 arg2, s16 arg3) {
-    arg0[0] = arg1;
-    arg0[1] = arg2;
-    arg0[2] = arg3;
+    arg0.x = arg1;
+    arg0.y = arg2;
+    arg0.z = arg3;
 }
 
 // These functions have bogus return values.
@@ -136,23 +136,23 @@ void vec3s_set(Vec3s arg0, s16 arg1, s16 arg2, s16 arg3) {
 #endif
 
 void* vec3f_copy_return(Vec3f dest, Vec3f src) {
-    dest[0] = src[0];
-    dest[1] = src[1];
-    dest[2] = src[2];
+    dest.x = src.x;
+    dest.y = src.y;
+    dest.z = src.z;
     //! @warning function returns address of local variable
     return &dest;
 }
 
 void vec3s_copy(Vec3s dest, Vec3s src) {
-    dest[0] = src[0];
-    dest[1] = src[1];
-    dest[2] = src[2];
+    dest.x = src.x;
+    dest.y = src.y;
+    dest.z = src.z;
 }
 
 UNUSED void* vec3f_set_return(Vec3f dest, f32 x, f32 y, f32 z) {
-    dest[0] = x;
-    dest[1] = y;
-    dest[2] = z;
+    dest.x = x;
+    dest.y = y;
+    dest.z = z;
     return &dest;
 }
 
@@ -191,9 +191,9 @@ void mtxf_identity(Mat4 mtx) {
 // translation vector
 void add_translate_mat4_vec3f(Mat4 mat, Mat4 dest, Vec3f pos) {
     FrameInterpolation_RecordMatrixTranslate(dest, pos);
-    dest[3][0] = mat[3][0] + pos[0];
-    dest[3][1] = mat[3][1] + pos[1];
-    dest[3][2] = mat[3][2] + pos[2];
+    dest[3][0] = mat[3][0] + pos.x;
+    dest[3][1] = mat[3][1] + pos.y;
+    dest[3][2] = mat[3][2] + pos.z;
     dest[3][3] = mat[3][3];
     dest[0][0] = mat[0][0];
     dest[0][1] = mat[0][1];
@@ -218,9 +218,9 @@ void add_translate_mat4_vec3f(Mat4 mat, Mat4 dest, Vec3f pos) {
 
 // Light version of add_translate_mat4_vec3f
 UNUSED void add_translate_mat4_vec3f_lite(Mat4 mat, Mat4 dest, Vec3f pos) {
-    dest[3][0] = mat[3][0] + pos[0];
-    dest[3][1] = mat[3][1] + pos[1];
-    dest[3][2] = mat[3][2] + pos[2];
+    dest[3][0] = mat[3][0] + pos.x;
+    dest[3][1] = mat[3][1] + pos.y;
+    dest[3][2] = mat[3][2] + pos.z;
 }
 
 // create a translation matrix
@@ -497,15 +497,15 @@ void mtxf_pos_rotation_xyz(Mat4 out, Vec3f pos, Vec3s orientation) {
     out[0][0] = (cosine2 * cosine3) + ((sine1 * sine2) * sine3);
     out[1][0] = (-cosine2 * sine3) + ((sine1 * sine2) * cosine3);
     out[2][0] = cosine1 * sine2;
-    out[3][0] = pos[0];
+    out[3][0] = pos.x;
     out[0][1] = cosine1 * sine3;
     out[1][1] = cosine1 * cosine3;
     out[2][1] = -sine1;
-    out[3][1] = pos[1];
+    out[3][1] = pos.y;
     out[0][2] = (-sine2 * cosine3) + ((sine1 * cosine2) * sine3);
     out[1][2] = (sine2 * sine3) + ((sine1 * cosine2) * cosine3);
     out[2][2] = cosine1 * cosine2;
-    out[3][2] = pos[2];
+    out[3][2] = pos.z;
     out[0][3] = 0.0f;
     out[1][3] = 0.0f;
     out[2][3] = 0.0f;
@@ -591,13 +591,13 @@ void mtxf_translate_vec3f_mat3(Vec3f pos, Mat3 mat) {
     f32 new_y;
     f32 new_z;
 
-    new_x = (mat[0][0] * pos[0]) + (mat[0][1] * pos[1]) + (mat[0][2] * pos[2]);
-    new_y = (mat[1][0] * pos[0]) + (mat[1][1] * pos[1]) + (mat[1][2] * pos[2]);
-    new_z = (mat[2][0] * pos[0]) + (mat[2][1] * pos[1]) + (mat[2][2] * pos[2]);
+    new_x = (mat[0][0] * pos.x) + (mat[0][1] * pos.y) + (mat[0][2] * pos.z);
+    new_y = (mat[1][0] * pos.x) + (mat[1][1] * pos.y) + (mat[1][2] * pos.z);
+    new_z = (mat[2][0] * pos.x) + (mat[2][1] * pos.y) + (mat[2][2] * pos.z);
 
-    pos[0] = new_x;
-    pos[1] = new_y;
-    pos[2] = new_z;
+    pos.x = new_x;
+    pos.y = new_y;
+    pos.z = new_z;
 }
 
 // translate the vector with a matrix (with a matrix 4x4)
@@ -606,13 +606,13 @@ void mtxf_translate_vec3f_mat4(Vec3f pos, Mat4 mat) {
     f32 new_y;
     f32 new_z;
 
-    new_x = (mat[0][0] * pos[0]) + (mat[0][1] * pos[1]) + (mat[0][2] * pos[2]);
-    new_y = (mat[1][0] * pos[0]) + (mat[1][1] * pos[1]) + (mat[1][2] * pos[2]);
-    new_z = (mat[2][0] * pos[0]) + (mat[2][1] * pos[1]) + (mat[2][2] * pos[2]);
+    new_x = (mat[0][0] * pos.x) + (mat[0][1] * pos.y) + (mat[0][2] * pos.z);
+    new_y = (mat[1][0] * pos.x) + (mat[1][1] * pos.y) + (mat[1][2] * pos.z);
+    new_z = (mat[2][0] * pos.x) + (mat[2][1] * pos.y) + (mat[2][2] * pos.z);
 
-    pos[0] = new_x;
-    pos[1] = new_y;
-    pos[2] = new_z;
+    pos.x = new_x;
+    pos.y = new_y;
+    pos.z = new_z;
 }
 
 UNUSED void func_802B64B0(UNUSED s32 arg0, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
@@ -1076,17 +1076,17 @@ s16 func_802B7F34(f32 arg0, f32 arg1, f32 arg2, f32 arg3) {
 }
 
 void func_802B7F7C(Vec3f arg0, Vec3f arg1, Vec3s dest) {
-    f32 x1 = arg0[0];
-    f32 y1 = arg0[1];
-    f32 z1 = arg0[2];
+    f32 x1 = arg0.x;
+    f32 y1 = arg0.y;
+    f32 z1 = arg0.z;
 
-    f32 x2 = arg1[0];
-    f32 y2 = arg1[1];
-    f32 z2 = arg1[2];
+    f32 x2 = arg1.x;
+    f32 y2 = arg1.y;
+    f32 z2 = arg1.z;
 
-    dest[1] = func_802B7F34(z1, x1, z2, x2);
-    dest[0] = func_802B7F34(y1, z1, y2, z2);
-    dest[2] = func_802B7F34(x1, y1, x2, y2);
+    dest.y = func_802B7F34(z1, x1, z2, x2);
+    dest.x = func_802B7F34(y1, z1, y2, z2);
+    dest.z = func_802B7F34(x1, y1, x2, y2);
 }
 
 f32 sins(u16 arg0) {
@@ -1207,9 +1207,9 @@ UNUSED void func_802B8414(uintptr_t addr, Mat4 arg1, s16 arg2, s16 arg3, s32 arg
     sp40[0] = 0.0f;
     sp40[1] = 0.0f;
     sp40[2] = 1.0f;
-    sp3C[0] = ((sp40[0] * arg1[0][0]) + (sp40[1] * arg1[1][0]) + (sp40[2] * arg1[2][0])) * 127.0f;
-    sp3C[1] = ((sp40[0] * arg1[0][1]) + (sp40[1] * arg1[1][1]) + (sp40[2] * arg1[2][1])) * 127.0f;
-    sp3C[2] = ((sp40[0] * arg1[0][2]) + (sp40[1] * arg1[1][2]) + (sp40[2] * arg1[2][2])) * 127.0f;
+    sp3C[0] = ((sp40[0] * arg1[0][0]) + (sp40.y * arg1[1][0]) + (sp40.z * arg1[2][0])) * 127.0f;
+    sp3C[1] = ((sp40[0] * arg1[0][1]) + (sp40[1] * arg1[1][1]) + (sp40.z * arg1[2][1])) * 127.0f;
+    sp3C[2] = ((sp40[0] * arg1[0][2]) + (sp40[1] * arg1[1][2]) + (sp40.z * arg1[2][2])) * 127.0f;
     for (var_v0 = 0; var_v0 < arg4; var_v0++, var_s0++) {
         var_s0->l[0].l.dir[0] = sp3C[0];
         var_s0->l[0].l.dir[1] = sp3C[1];
@@ -1238,16 +1238,16 @@ void func_802B8614(Player* arg0) {
     f64 temp_f4;
     f64 temp_f6;
 
-    temp_f6 = (f64) arg0->tyres[FRONT_RIGHT].pos[0];
+    temp_f6 = (f64) arg0->tyres[FRONT_RIGHT].pos.x;
     sp78 = temp_f6;
     sp70 = (f64) arg0->tyres[FRONT_RIGHT].baseHeight;
-    sp68 = (f64) arg0->tyres[FRONT_RIGHT].pos[2];
-    temp_f30 = (f64) arg0->tyres[FRONT_LEFT].pos[0];
+    sp68 = (f64) arg0->tyres[FRONT_RIGHT].pos.z;
+    temp_f30 = (f64) arg0->tyres[FRONT_LEFT].pos.x;
     sp58 = (f64) arg0->tyres[FRONT_LEFT].baseHeight;
-    sp50 = (f64) arg0->tyres[FRONT_LEFT].pos[2];
-    sp48 = (f64) arg0->tyres[BACK_RIGHT].pos[0];
+    sp50 = (f64) arg0->tyres[FRONT_LEFT].pos.z;
+    sp48 = (f64) arg0->tyres[BACK_RIGHT].pos.x;
     sp40 = (f64) arg0->tyres[BACK_RIGHT].baseHeight;
-    temp_f4 = (f64) arg0->tyres[BACK_RIGHT].pos[2];
+    temp_f4 = (f64) arg0->tyres[BACK_RIGHT].pos.z;
     temp_f2 = sp58 - sp70;
     sp38 = temp_f4;
     temp_f12 = temp_f4 - sp50;
diff --git a/src/racing/race_logic.c b/src/racing/race_logic.c
index 4b9cf1af9..293ccd23d 100644
--- a/src/racing/race_logic.c
+++ b/src/racing/race_logic.c
@@ -458,7 +458,7 @@ void start_race(void) {
 }
 
 f32 func_8028EE8C(s32 arg0) {
-    f32 temp_v0 = gPlayers[arg0].pos[2];
+    f32 temp_v0 = gPlayers[arg0].pos.z;
     f32 temp_v1 = gPlayers[arg0].oldPos[2];
     f32 temp_f14 = D_8015F8D0[2] - temp_v0;
     f32 temp_f16 = temp_v1 - D_8015F8D0[2];
@@ -1073,13 +1073,13 @@ void func_802903D8(Player* playerOne, Player* playerTwo) {
     f32 sp24 = gFloatArray802B8790[playerOne->characterId];
     f32 sp20 = gFloatArray802B8790[playerTwo->characterId];
 
-    sp60[0] = playerOne->pos[0] - playerTwo->pos[0];
-    sp60[1] = (playerOne->pos[1] - playerOne->boundingBoxSize) - (playerTwo->pos[1] - playerTwo->boundingBoxSize);
-    sp60[2] = playerOne->pos[2] - playerTwo->pos[2];
+    sp60[0] = playerOne->pos.x - playerTwo->pos.x;
+    sp60[1] = (playerOne->pos.y - playerOne->boundingBoxSize) - (playerTwo->pos.y - playerTwo->boundingBoxSize);
+    sp60[2] = playerOne->pos.z - playerTwo->pos.z;
 
-    sp54[0] = playerTwo->velocity[0] - playerOne->velocity[0];
-    sp54[1] = playerTwo->velocity[1] - playerOne->velocity[1];
-    sp54[2] = playerTwo->velocity[2] - playerOne->velocity[2];
+    sp54[0] = playerTwo->velocity.x - playerOne->velocity.x;
+    sp54[1] = playerTwo->velocity.y - playerOne->velocity.y;
+    sp54[2] = playerTwo->velocity.z - playerOne->velocity.z;
 
     temp_f0 = sqrtf((sp60[0] * sp60[0]) + (sp60[1] * sp60[1]) + (sp60[2] * sp60[2]));
 
@@ -1125,12 +1125,12 @@ void func_802903D8(Player* playerOne, Player* playerTwo) {
     sp60[2] /= temp_f0;
     if (temp_f0_2 < 0.2f) {
         temp_f0 = (playerOne->boundingBoxSize + playerTwo->boundingBoxSize) * 0.55f;
-        playerOne->pos[0] = playerTwo->pos[0] + (sp60[0] * temp_f0);
-        playerOne->pos[1] = playerTwo->pos[1] + (sp60[1] * temp_f0);
-        playerOne->pos[2] = playerTwo->pos[2] + (sp60[2] * temp_f0);
-        playerTwo->pos[0] -= temp_f0 * sp60[0];
-        playerTwo->pos[1] -= temp_f0 * sp60[1];
-        playerTwo->pos[2] -= temp_f0 * sp60[2];
+        playerOne->pos.x = playerTwo->pos.x + (sp60[0] * temp_f0);
+        playerOne->pos.y = playerTwo->pos.y + (sp60[1] * temp_f0);
+        playerOne->pos.z = playerTwo->pos.z + (sp60[2] * temp_f0);
+        playerTwo->pos.x -= temp_f0 * sp60[0];
+        playerTwo->pos.y -= temp_f0 * sp60[1];
+        playerTwo->pos.z -= temp_f0 * sp60[2];
         return;
     } else {
         temp_f16 = ((sp60[0] * sp54[0]) + (sp60[1] * sp54[1]) + (sp60[2] * sp54[2])) / temp_f0_2;
@@ -1138,21 +1138,21 @@ void func_802903D8(Player* playerOne, Player* playerTwo) {
     temp_f0_2 = temp_f0_2 * temp_f16 * 0.85;
     if ((playerOne->effects & 0x200) != 0x200) {
         temp_f2 = (temp_f0_2 * sp20) / sp24;
-        playerOne->velocity[0] += sp60[0] * temp_f2;
-        playerOne->velocity[1] += sp60[1] * temp_f2;
-        playerOne->velocity[2] += sp60[2] * temp_f2;
-        playerOne->pos[0] -= sp60[0] * sp74 * 0.5f;
-        playerOne->pos[1] -= sp60[1] * sp74 * 0.5f;
-        playerOne->pos[2] -= sp60[2] * sp74 * 0.5f;
+        playerOne->velocity.x += sp60[0] * temp_f2;
+        playerOne->velocity.y += sp60[1] * temp_f2;
+        playerOne->velocity.z += sp60[2] * temp_f2;
+        playerOne->pos.x -= sp60[0] * sp74 * 0.5f;
+        playerOne->pos.y -= sp60[1] * sp74 * 0.5f;
+        playerOne->pos.z -= sp60[2] * sp74 * 0.5f;
     }
     if ((playerTwo->effects & 0x200) != 0x200) {
         temp_f2 = (temp_f0_2 * sp24) / sp20;
-        playerTwo->velocity[0] -= sp60[0] * temp_f2;
-        playerTwo->velocity[1] -= sp60[1] * temp_f2;
-        playerTwo->velocity[2] -= sp60[2] * temp_f2;
-        playerTwo->pos[0] += sp60[0] * sp74 * 0.5f;
-        playerTwo->pos[1] += sp60[1] * sp74 * 0.5f;
-        playerTwo->pos[2] += sp60[2] * sp74 * 0.5f;
+        playerTwo->velocity.x -= sp60[0] * temp_f2;
+        playerTwo->velocity.y -= sp60[1] * temp_f2;
+        playerTwo->velocity.z -= sp60[2] * temp_f2;
+        playerTwo->pos.x += sp60[0] * sp74 * 0.5f;
+        playerTwo->pos.y += sp60[1] * sp74 * 0.5f;
+        playerTwo->pos.z += sp60[2] * sp74 * 0.5f;
     }
     if (playerOne->type & PLAYER_HUMAN) {
         func_800C9060((playerOne - gPlayerOne), 0x19008001U);
diff --git a/src/racing/render_courses.c b/src/racing/render_courses.c
index 71b182544..14ef53893 100644
--- a/src/racing/render_courses.c
+++ b/src/racing/render_courses.c
@@ -85,7 +85,7 @@ void render_course_segments(const char* addr[], struct UnkStruct_800DC5EC* arg1)
     s16 temp_v0_3;
     u16 rot;
     if (gIsMirrorMode) {
-        rot = (u16) camera->rot[1];
+        rot = (u16) camera->rot.y;
         if (rot < 0x2000) {
             direction = SOUTH;
         } else if (rot < 0x6000) {
@@ -98,7 +98,7 @@ void render_course_segments(const char* addr[], struct UnkStruct_800DC5EC* arg1)
             direction = SOUTH;
         }
     } else {
-        rot = (u16) camera->rot[1];
+        rot = (u16) camera->rot.y;
         if (rot < 0x2000) {
             direction = SOUTH;
         } else if (rot < 0x6000) {
@@ -212,7 +212,7 @@ void func_8029122C(struct UnkStruct_800DC5EC* arg0, s32 playerId) {
 
     init_rdp();
     pathCounter = (u16) arg0->pathCounter;
-    cameraRot = (u16) arg0->camera->rot[1];
+    cameraRot = (u16) arg0->camera->rot.y;
     playerDirection = arg0->playerDirection;
     switch (playerId) {
         case PLAYER_ONE:
@@ -328,7 +328,7 @@ void func_8029122C(struct UnkStruct_800DC5EC* arg0, s32 playerId) {
     //         render_course_segments(sherbet_land_dls_2, arg0);
 
     //         gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE);
-    //         if ((func_80290C20(arg0->camera) == 1) && (get_water_level(player) < player->pos[1])) {
+    //         if ((func_80290C20(arg0->camera) == 1) && (get_water_level(player) < player->pos.y)) {
     //             gSPSetGeometryMode(gDisplayListHead++, G_ZBUFFER);
     //             gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE);
     //             gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
@@ -762,13 +762,13 @@ void render_banshee_boardwalk(struct UnkStruct_800DC5EC* arg0) {
     // d_course_banshee_boardwalk_packed_dl_540
     gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(0x07000540));
 
-    if (camera->pos[1] < -20.0f) {
+    if (camera->pos.y < -20.0f) {
         // d_course_banshee_boardwalk_packed_dl_6310
         gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(0x07006310));
     }
-    spA8[0] = camera->pos[0];
+    spA8[0] = camera->pos.x;
     spA8[1] = -82.0f;
-    spA8[2] = camera->pos[2];
+    spA8[2] = camera->pos.z;
     mtxf_translate(spCC, spA8);
     render_set_position(spCC, 0);
 
diff --git a/src/racing/skybox_and_splitscreen.c b/src/racing/skybox_and_splitscreen.c
index abc7c23aa..fd7b93a31 100644
--- a/src/racing/skybox_and_splitscreen.c
+++ b/src/racing/skybox_and_splitscreen.c
@@ -842,8 +842,8 @@ void render_screens(s32 mode, s32 cameraId, s32 playerId) {
     gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxPersp[cameraId]),
               G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
 
-    guLookAt(&gGfxPool->mtxLookAt[cameraId], camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0],
-             camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
+    guLookAt(&gGfxPool->mtxLookAt[cameraId], camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x,
+             camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
     if (D_800DC5C8 == 0) {
         gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxLookAt[cameraId]),
                   G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
diff --git a/src/render_objects.c b/src/render_objects.c
index b2de13f7c..bf9f3d355 100644
--- a/src/render_objects.c
+++ b/src/render_objects.c
@@ -1353,9 +1353,9 @@ void func_8004A6EC(s32 objectIndex, f32 scale) {
     if ((is_obj_flag_status_active(objectIndex, 0x00000020) != 0) &&
         (is_obj_flag_status_active(objectIndex, 0x00800000) != 0)) {
         object = &gObjectList[objectIndex];
-        D_80183E50[0] = object->pos[0];
+        D_80183E50[0] = object->pos.x;
         D_80183E50[1] = object->surfaceHeight + 0.8;
-        D_80183E50[2] = object->pos[2];
+        D_80183E50[2] = object->pos.z;
         rsp_set_matrix_transformation(D_80183E50, object->unk_0B8, scale);
         gSPDisplayList(gDisplayListHead++, D_0D007B20);
     }
@@ -1366,9 +1366,9 @@ void func_8004A7AC(s32 objectIndex, f32 arg1) {
 
     if (is_obj_flag_status_active(objectIndex, 0x00000020) != 0) {
         object = &gObjectList[objectIndex];
-        D_80183E50[0] = object->pos[0];
+        D_80183E50[0] = object->pos.x;
         D_80183E50[1] = object->surfaceHeight + 0.8;
-        D_80183E50[2] = object->pos[2];
+        D_80183E50[2] = object->pos.z;
         D_80183E98[0] = 0x4000;
         D_80183E98[1] = 0;
         D_80183E98[2] = 0;
@@ -2775,8 +2775,8 @@ void func_8004F168(s32 arg0, s32 playerId, s32 characterId) {
     Player* player = &gPlayerOne[playerId];
 
     if (player->type & (1 << 15)) {
-        thing0 = player->pos[0] * CM_GetProps()->Minimap.PlayerScaleFactor; // gMinimapPlayerScale;
-        thing1 = player->pos[2] * CM_GetProps()->Minimap.PlayerScaleFactor; // gMinimapPlayerScale;
+        thing0 = player->pos.x * CM_GetProps()->Minimap.PlayerScaleFactor; // gMinimapPlayerScale;
+        thing1 = player->pos.z * CM_GetProps()->Minimap.PlayerScaleFactor; // gMinimapPlayerScale;
 
         if (gPlayerCount == 3) {
             center = ((OTRGetDimensionFromRightEdge(SCREEN_WIDTH) - SCREEN_WIDTH) / 2) +
@@ -3311,9 +3311,9 @@ void func_80050E34(s32 playerId, s32 arg1) {
         gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_portrait_bomb_kart_and_question_mark);
         rsp_load_texture(common_texture_portrait_question_mark, 0x00000020, 0x00000020);
         object = &gObjectList[objectIndex];
-        object->pos[0] = object->offset[0] + ((f32) (spD0 + 0x20));
-        object->pos[1] = object->offset[1] + ((f32) (spC4 + spCC));
-        object->pos[2] = object->offset[2];
+        object->pos.x = object->offset[0] + ((f32) (spD0 + 0x20));
+        object->pos.y = object->offset[1] + ((f32) (spC4 + spCC));
+        object->pos.z = object->offset[2];
         rsp_set_matrix_transformation(object->pos, object->direction_angle, object->sizeScaling);
         gSPDisplayList(gDisplayListHead++, D_0D0069E0);
     } else {
@@ -3327,9 +3327,9 @@ void func_80050E34(s32 playerId, s32 arg1) {
         }
         rsp_load_texture(gPortraitTextures[characterId], 0x00000020, 0x00000020);
         object = &gObjectList[objectIndex];
-        object->pos[0] = object->offset[0] + ((f32) (spD0 + 0x20));
-        object->pos[1] = object->offset[1] + ((f32) (spC4 + spCC));
-        object->pos[2] = object->offset[2];
+        object->pos.x = object->offset[0] + ((f32) (spD0 + 0x20));
+        object->pos.y = object->offset[1] + ((f32) (spC4 + spCC));
+        object->pos.z = object->offset[2];
         rsp_set_matrix_transformation(object->pos, object->direction_angle, object->sizeScaling);
         if (spB8 != 0) {
             gSPDisplayList(gDisplayListHead++, D_0D0069F8);
@@ -3593,9 +3593,9 @@ void func_8005285C(s32 arg0) {
     Player* temp_v0;
 
     temp_v0 = &gPlayerOne[arg0];
-    D_80183E40[0] = temp_v0->pos[0];
-    D_80183E40[1] = temp_v0->pos[1];
-    D_80183E40[2] = temp_v0->pos[2];
+    D_80183E40[0] = temp_v0->pos.x;
+    D_80183E40[1] = temp_v0->pos.y;
+    D_80183E40[2] = temp_v0->pos.z;
     D_80183E80[0] = 0;
     D_80183E80[1] = 0;
     D_80183E80[2] = 0;
@@ -3676,9 +3676,9 @@ void func_80052D70(s32 playerId) {
     temp_v1 = &gPlayerOne[playerId];
     test = gIndexLakituList[playerId];
     if (func_80072320(test, 8) != 0) {
-        D_80183E40[0] = temp_v1->pos[0];
+        D_80183E40[0] = temp_v1->pos.x;
         D_80183E40[1] = temp_v1->unk_074 - 6.5;
-        D_80183E40[2] = temp_v1->pos[2];
+        D_80183E40[2] = temp_v1->pos.z;
         func_800435A0(D_80183E40, (u16*) D_80183E80, 0.02f, d_course_sherbet_land_dl_ice_block, 0x000000FF);
     }
 }
@@ -3710,7 +3710,7 @@ void render_object_train_smoke_particle(s32 objectIndex, s32 cameraId) {
             set_color_render((s32) gObjectList[objectIndex].type, (s32) gObjectList[objectIndex].type,
                              (s32) gObjectList[objectIndex].type, 0, 0, 0, (s32) gObjectList[objectIndex].primAlpha);
             D_80183E80[1] =
-                func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+                func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling, D_0D005AE0);
         }
     }
@@ -3772,7 +3772,7 @@ void render_object_paddle_boat_smoke_particle(s32 objectIndex, s32 cameraId) {
                              gObjectList[objectIndex].unk_0A2, gObjectList[objectIndex].unk_0A2,
                              (s32) gObjectList[objectIndex].primAlpha);
             D_80183E80[1] =
-                func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
+                func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
             func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling, D_0D005AE0);
         }
     }
@@ -3815,7 +3815,7 @@ void render_object_bowser_flame_particle(s32 objectIndex, s32 cameraId) {
         } else {
             func_8004B138(0xFF, (s32) object->type, 0, (s32) object->primAlpha);
         }
-        D_80183E80[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+        D_80183E80[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
         func_800431B0(object->pos, D_80183E80, object->sizeScaling, D_0D005AE0);
     }
 }
@@ -3855,7 +3855,7 @@ void func_8005477C(s32 objectIndex, u8 arg1, Vec3f arg2) {
             default:
                 break;
         }
-        D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], arg2);
+        D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, arg2);
         func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling, D_0D005AE0);
     }
 }
@@ -3903,9 +3903,9 @@ void func_800557B4(s32 objectIndex, u32 arg1, u32 arg2) {
         if (is_obj_flag_status_active(objectIndex, 0x00000020) != 0) {
             if (func_80072320(objectIndex, 4) != 0) {
                 if (arg2 >= arg1) {
-                    sp34[0] = object->pos[0];
-                    sp34[1] = object->pos[1] - 1.0;
-                    sp34[2] = object->pos[2];
+                    sp34[0] = object->pos.x;
+                    sp34[1] = object->pos.y - 1.0;
+                    sp34[2] = object->pos.z;
                     rsp_set_matrix_transformation_inverted_x_y_orientation(sp34, object->orientation,
                                                                            object->sizeScaling);
                     gSPDisplayList(gDisplayListHead++, D_0D0077D0);
@@ -3987,11 +3987,11 @@ void func_800563DC(s32 objectIndex, s32 cameraId, s32 arg2) {
     camera = &camera1[cameraId];
     object = &gObjectList[objectIndex];
     residue = D_801655CC % 4U;
-    D_80183E40[0] = object->pos[0];
-    D_80183E40[1] = object->pos[1] + 1.0;
-    D_80183E40[2] = object->pos[2];
+    D_80183E40[0] = object->pos.x;
+    D_80183E40[1] = object->pos.y + 1.0;
+    D_80183E40[2] = object->pos.z;
     D_80183E80[0] = 0;
-    D_80183E80[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
+    D_80183E80[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
     D_80183E80[2] = 0x8000;
     rsp_set_matrix_transformation(D_80183E40, D_80183E80, 0.2f);
     gSPDisplayList(gDisplayListHead++, D_0D007E98);
@@ -4017,18 +4017,18 @@ void func_8005669C(s32 objectIndex, UNUSED s32 arg1, s32 arg2) {
     gSPDisplayList(gDisplayListHead++, D_0D0079E8);
     func_8004B310(arg2);
     load_texture_block_rgba16_mirror((u8*) D_0D02AA58, 0x00000010, 0x00000010);
-    D_80183E40[1] = gObjectList[objectIndex].pos[1] - 2.0;
-    D_80183E40[0] = gObjectList[objectIndex].pos[0] + 2.0;
-    D_80183E40[2] = gObjectList[objectIndex].pos[2] + 2.0;
+    D_80183E40[1] = gObjectList[objectIndex].pos.y - 2.0;
+    D_80183E40[0] = gObjectList[objectIndex].pos.x + 2.0;
+    D_80183E40[2] = gObjectList[objectIndex].pos.z + 2.0;
     func_800431B0(D_80183E40, D_80183E80, 0.15f, common_vtx_rectangle);
-    D_80183E40[0] = gObjectList[objectIndex].pos[0] + 2.0;
-    D_80183E40[2] = gObjectList[objectIndex].pos[2] - 2.0;
+    D_80183E40[0] = gObjectList[objectIndex].pos.x + 2.0;
+    D_80183E40[2] = gObjectList[objectIndex].pos.z - 2.0;
     func_800431B0(D_80183E40, D_80183E80, 0.15f, common_vtx_rectangle);
-    D_80183E40[0] = gObjectList[objectIndex].pos[0] - 2.0;
-    D_80183E40[2] = gObjectList[objectIndex].pos[2] - 2.0;
+    D_80183E40[0] = gObjectList[objectIndex].pos.x - 2.0;
+    D_80183E40[2] = gObjectList[objectIndex].pos.z - 2.0;
     func_800431B0(D_80183E40, D_80183E80, 0.15f, common_vtx_rectangle);
-    D_80183E40[0] = gObjectList[objectIndex].pos[0] - 2.0;
-    D_80183E40[2] = gObjectList[objectIndex].pos[2] + 2.0;
+    D_80183E40[0] = gObjectList[objectIndex].pos.x - 2.0;
+    D_80183E40[2] = gObjectList[objectIndex].pos.z + 2.0;
     func_800431B0(D_80183E40, D_80183E80, 0.15f, common_vtx_rectangle);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
 }
@@ -4038,9 +4038,9 @@ void func_800568A0(s32 objectIndex, s32 playerId) {
     Player* player;
 
     player = &gPlayerOne[playerId];
-    D_80183E50[0] = gObjectList[objectIndex].pos[0];
+    D_80183E50[0] = gObjectList[objectIndex].pos.x;
     D_80183E50[1] = gObjectList[objectIndex].surfaceHeight + 0.8;
-    D_80183E50[2] = gObjectList[objectIndex].pos[2];
+    D_80183E50[2] = gObjectList[objectIndex].pos.z;
     set_transform_matrix(mtx, player->collision.orientationVector, D_80183E50, 0U, 0.5f);
     // convert_to_fixed_point_matrix(&gGfxPool->mtxHud[gMatrixHudCount], mtx);
     // gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxHud[gMatrixHudCount++]),
@@ -4076,9 +4076,9 @@ void render_battle_bomb_karts(s32 cameraId) {
         if (object->state != 0) {
             temp_s1 = object->primAlpha;
             temp_v0 = &gPlayerOne[payerId];
-            object->pos[0] = temp_v0->pos[0];
-            object->pos[1] = temp_v0->pos[1] - 2.0;
-            object->pos[2] = temp_v0->pos[2];
+            object->pos.x = temp_v0->pos.x;
+            object->pos.y = temp_v0->pos.y - 2.0;
+            object->pos.z = temp_v0->pos.z;
             object->surfaceHeight = temp_v0->unk_074;
             func_800563DC(temp_s0, cameraId, temp_s1);
             func_8005669C(temp_s0, cameraId, temp_s1);
@@ -4182,9 +4182,9 @@ void render_bomb_karts(s32 cameraId) {
         state = var_s1_2->state;
         if (var_s1_2->state != BOMB_STATE_INACTIVE) {
             objectIndex = gIndexObjectBombKart[i];
-            gObjectList[objectIndex].pos[0] = var_s1_2->bombPos[0];
-            gObjectList[objectIndex].pos[1] = var_s1_2->bombPos[1];
-            gObjectList[objectIndex].pos[2] = var_s1_2->bombPos[2];
+            gObjectList[objectIndex].pos.x = var_s1_2->bombPos[0];
+            gObjectList[objectIndex].pos.y = var_s1_2->bombPos[1];
+            gObjectList[objectIndex].pos.z = var_s1_2->bombPos[2];
             temp_s4 = func_8008A364(objectIndex, cameraId, 0x31C4U, 0x000001F4);
             if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
                 set_object_flag(objectIndex, 0x00200000);
diff --git a/src/render_player.c b/src/render_player.c
index 65545ebd7..b448258fa 100644
--- a/src/render_player.c
+++ b/src/render_player.c
@@ -134,16 +134,16 @@ u16 check_player_camera_collision(Player* player, Camera* camera, f32 arg2, f32
             var_v0 = 0x1FFE;
             break;
     }
-    sp4C = (arg2 * coss((camera->rot[1] - var_v0))) + camera->pos[2];
-    sp58 = (arg2 * sins((camera->rot[1] - var_v0))) + camera->pos[0];
-    sp48 = (arg2 * coss((camera->rot[1] + var_v0))) + camera->pos[2];
-    sp54 = (arg2 * sins((camera->rot[1] + var_v0))) + camera->pos[0];
-    sp44 = (arg3 * coss((camera->rot[1] + 0x5FFA))) + camera->pos[2];
-    sp50 = (arg3 * sins((camera->rot[1] + 0x5FFA))) + camera->pos[0];
+    sp4C = (arg2 * coss((camera->rot.y - var_v0))) + camera->pos.z;
+    sp58 = (arg2 * sins((camera->rot.y - var_v0))) + camera->pos.x;
+    sp48 = (arg2 * coss((camera->rot.y + var_v0))) + camera->pos.z;
+    sp54 = (arg2 * sins((camera->rot.y + var_v0))) + camera->pos.x;
+    sp44 = (arg3 * coss((camera->rot.y + 0x5FFA))) + camera->pos.z;
+    sp50 = (arg3 * sins((camera->rot.y + 0x5FFA))) + camera->pos.x;
 
-    sp64 = ((sp4C - player->pos[2]) * (sp54 - player->pos[0])) - ((sp48 - player->pos[2]) * (sp58 - player->pos[0]));
-    sp60 = ((sp48 - player->pos[2]) * (sp50 - player->pos[0])) - ((sp44 - player->pos[2]) * (sp54 - player->pos[0]));
-    sp5C = ((sp44 - player->pos[2]) * (sp58 - player->pos[0])) - ((sp4C - player->pos[2]) * (sp50 - player->pos[0]));
+    sp64 = ((sp4C - player->pos.z) * (sp54 - player->pos.x)) - ((sp48 - player->pos.z) * (sp58 - player->pos.x));
+    sp60 = ((sp48 - player->pos.z) * (sp50 - player->pos.x)) - ((sp44 - player->pos.z) * (sp54 - player->pos.x));
+    sp5C = ((sp44 - player->pos.z) * (sp58 - player->pos.x)) - ((sp4C - player->pos.z) * (sp50 - player->pos.x));
 
     if (((sp64 >= 0) && (sp60 >= 0) && (sp5C >= 0)) || (((sp64) <= 0) && (sp60 <= 0) && (sp5C <= 0))) {
         ret = true;
@@ -165,12 +165,12 @@ u16 func_8001FD78(Player* player, f32 posX, UNUSED f32 arg2, f32 posZ) {
 
     ret = false;
 
-    sp58 = (70.0f * coss(((player->unk_0C0 - player->rotation[1]) - 0x71C))) + player->pos[2];
-    sp64 = (70.0f * sins(((player->unk_0C0 - player->rotation[1]) - 0x71C))) + player->pos[0];
-    sp54 = (70.0f * coss(((player->unk_0C0 - player->rotation[1]) + 0x71C))) + player->pos[2];
-    sp60 = (70.0f * sins(((player->unk_0C0 - player->rotation[1]) + 0x71C))) + player->pos[0];
-    sp50 = (10.0f * coss(((player->unk_0C0 - player->rotation[1]) + 0x1C70))) + player->pos[2];
-    sp5c = (10.0f * sins(((player->unk_0C0 - player->rotation[1]) + 0x1C70))) + player->pos[0];
+    sp58 = (70.0f * coss(((player->unk_0C0 - player->rotation.y) - 0x71C))) + player->pos.z;
+    sp64 = (70.0f * sins(((player->unk_0C0 - player->rotation.y) - 0x71C))) + player->pos.x;
+    sp54 = (70.0f * coss(((player->unk_0C0 - player->rotation.y) + 0x71C))) + player->pos.z;
+    sp60 = (70.0f * sins(((player->unk_0C0 - player->rotation.y) + 0x71C))) + player->pos.x;
+    sp50 = (10.0f * coss(((player->unk_0C0 - player->rotation.y) + 0x1C70))) + player->pos.z;
+    sp5c = (10.0f * sins(((player->unk_0C0 - player->rotation.y) + 0x1C70))) + player->pos.x;
 
     temp_f14 = ((sp58 - posZ) * (sp60 - posX)) - ((sp54 - posZ) * (sp64 - posX));
     thing0 = ((sp54 - posZ) * (sp5c - posX)) - ((sp50 - posZ) * (sp60 - posX));
@@ -266,9 +266,9 @@ void init_render_player(Player* player, Camera* camera, s8 playerId, s8 screenId
 void load_kart_texture_and_render_kart_particle_on_screen_one(void) {
     s16 i;
 
-    load_kart_texture_non_blocking(gPlayersToRenderPlayer[0], gPlayersToRenderPlayerId[0], gPlayersToRenderScreenId[0],
-                                   gPlayersToRenderScreenId[0],
-                                   D_801651D0[gPlayersToRenderScreenId[0]][gPlayersToRenderPlayerId[0]]);
+    load_kart_texture_non_blocking(gPlayersToRenderPlayer.x, gPlayersToRenderPlayerId.x, gPlayersToRenderScreenId.x,
+                                   gPlayersToRenderScreenId.x,
+                                   D_801651D0[gPlayersToRenderScreenId.x][gPlayersToRenderPlayerId.x]);
 
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
 
@@ -328,9 +328,9 @@ void load_kart_texture_and_render_kart_particle_on_screen_one(void) {
 void load_kart_texture_and_render_kart_particle_on_screen_two(void) {
     s16 var_s0;
 
-    load_kart_texture_non_blocking(gPlayersToRenderPlayer[0], gPlayersToRenderPlayerId[0], gPlayersToRenderScreenId[0],
-                                   gPlayersToRenderScreenId[0],
-                                   D_801651D0[gPlayersToRenderScreenId[0]][gPlayersToRenderPlayerId[0]]);
+    load_kart_texture_non_blocking(gPlayersToRenderPlayer.x, gPlayersToRenderPlayerId.x, gPlayersToRenderScreenId.x,
+                                   gPlayersToRenderScreenId.x,
+                                   D_801651D0[gPlayersToRenderScreenId.x][gPlayersToRenderPlayerId.x]);
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
         load_kart_texture_non_blocking(gPlayersToRenderPlayer[var_s0], gPlayersToRenderPlayerId[var_s0],
@@ -388,9 +388,9 @@ void load_kart_texture_and_render_kart_particle_on_screen_two(void) {
 void load_kart_texture_and_render_kart_particle_on_screen_three(void) {
     s16 var_s0;
 
-    load_kart_texture_non_blocking(gPlayersToRenderPlayer[0], gPlayersToRenderPlayerId[0] + 4,
-                                   gPlayersToRenderScreenId[0], gPlayersToRenderScreenId[0] - 2,
-                                   D_801651D0[gPlayersToRenderScreenId[0]][gPlayersToRenderPlayerId[0]]);
+    load_kart_texture_non_blocking(gPlayersToRenderPlayer.x, gPlayersToRenderPlayerId.x + 4,
+                                   gPlayersToRenderScreenId.x, gPlayersToRenderScreenId.x - 2,
+                                   D_801651D0[gPlayersToRenderScreenId.x][gPlayersToRenderPlayerId.x]);
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
         load_kart_texture_non_blocking(gPlayersToRenderPlayer[var_s0], gPlayersToRenderPlayerId[var_s0] + 4,
@@ -448,9 +448,9 @@ void load_kart_texture_and_render_kart_particle_on_screen_three(void) {
 void load_kart_texture_and_render_kart_particle_on_screen_four(void) {
     s16 var_s0;
 
-    load_kart_texture_non_blocking(gPlayersToRenderPlayer[0], gPlayersToRenderPlayerId[0] + 4,
-                                   gPlayersToRenderScreenId[0], gPlayersToRenderScreenId[0] - 2,
-                                   D_801651D0[gPlayersToRenderScreenId[0]][gPlayersToRenderPlayerId[0]]);
+    load_kart_texture_non_blocking(gPlayersToRenderPlayer.x, gPlayersToRenderPlayerId.x + 4,
+                                   gPlayersToRenderScreenId.x, gPlayersToRenderScreenId.x - 2,
+                                   D_801651D0[gPlayersToRenderScreenId.x][gPlayersToRenderPlayerId.x]);
     osRecvMesg(&gDmaMesgQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
     for (var_s0 = 1; var_s0 < gPlayersToRenderCount; var_s0++) {
         load_kart_texture_non_blocking(gPlayersToRenderPlayer[var_s0], gPlayersToRenderPlayerId[var_s0] + 4,
@@ -896,47 +896,47 @@ void func_80021DA8(void) {
 
 void mtxf_translate_rotate(Mat4 dest, Vec3f pos, Vec3s orientation) {
     UNUSED f32 pad[3];
-    f32 sinX = sins(orientation[0]);
-    f32 cosX = coss(orientation[0]);
-    f32 sinY = sins(orientation[1]);
-    f32 cosY = coss(orientation[1]);
-    f32 sinZ = sins(orientation[2]);
-    f32 cosZ = coss(orientation[2]);
+    f32 sinX = sins(orientation.x);
+    f32 cosX = coss(orientation.x);
+    f32 sinY = sins(orientation.y);
+    f32 cosY = coss(orientation.y);
+    f32 sinZ = sins(orientation.z);
+    f32 cosZ = coss(orientation.z);
 
-    dest[0][0] = (cosY * cosZ) + ((sinX * sinY) * sinZ);
-    dest[1][0] = (-cosY * sinZ) + ((sinX * sinY) * cosZ);
-    dest[2][0] = cosX * sinY;
-    dest[3][0] = pos[0];
-    dest[0][1] = cosX * sinZ;
-    dest[1][1] = cosX * cosZ;
-    dest[2][1] = -sinX;
-    dest[3][1] = pos[1];
-    dest[0][2] = (-sinY * cosZ) + ((sinX * cosY) * sinZ);
-    dest[1][2] = (sinY * sinZ) + ((sinX * cosY) * cosZ);
-    dest[2][2] = cosX * cosY;
-    dest[3][2] = pos[2];
-    dest[0][3] = 0.0f;
-    dest[1][3] = 0.0f;
-    dest[2][3] = 0.0f;
+    dest.x.x = (cosY * cosZ) + ((sinX * sinY) * sinZ);
+    dest.y.x = (-cosY * sinZ) + ((sinX * sinY) * cosZ);
+    dest.z.x = cosX * sinY;
+    dest[3].x = pos.x;
+    dest.x.y = cosX * sinZ;
+    dest.y.y = cosX * cosZ;
+    dest.z.y = -sinX;
+    dest[3].y = pos.y;
+    dest.x.z = (-sinY * cosZ) + ((sinX * cosY) * sinZ);
+    dest.y.z = (sinY * sinZ) + ((sinX * cosY) * cosZ);
+    dest.z.z = cosX * cosY;
+    dest[3].z = pos.z;
+    dest.x[3] = 0.0f;
+    dest.y[3] = 0.0f;
+    dest.z[3] = 0.0f;
     dest[3][3] = 1.0f;
 }
 
 UNUSED void func_80021F50(Mat4 arg0, Vec3f arg1) {
-    arg0[3][0] += arg1[0];
-    arg0[3][1] += arg1[1];
-    arg0[3][2] += arg1[2];
+    arg0[3].x += arg1.x;
+    arg0[3].y += arg1.y;
+    arg0[3].z += arg1.z;
 }
 
 void mtxf_scale2(Mat4 arg0, f32 scale) {
-    arg0[0][0] *= scale;
-    arg0[1][0] *= scale;
-    arg0[2][0] *= scale;
-    arg0[0][1] *= scale;
-    arg0[1][1] *= scale;
-    arg0[2][1] *= scale;
-    arg0[0][2] *= scale;
-    arg0[1][2] *= scale;
-    arg0[2][2] *= scale;
+    arg0.x.x *= scale;
+    arg0.y.x *= scale;
+    arg0.z.x *= scale;
+    arg0.x.y *= scale;
+    arg0.y.y *= scale;
+    arg0.z.y *= scale;
+    arg0.x.z *= scale;
+    arg0.y.z *= scale;
+    arg0.z.z *= scale;
 }
 
 /**
@@ -949,21 +949,21 @@ void mtxf_scale2(Mat4 arg0, f32 scale) {
  */
 UNUSED void failed_fixed_point_matrix_conversion(Mtx* dest, Mat4 src) {
     f32 toFixed = 65536.0f;
-    dest->m[0][0] = src[0][0] * toFixed;
-    dest->m[0][1] = src[0][1] * toFixed;
-    dest->m[0][2] = src[0][2] * toFixed;
-    dest->m[0][3] = src[0][3] * toFixed;
-    dest->m[1][0] = src[1][0] * toFixed;
-    dest->m[1][1] = src[1][1] * toFixed;
-    dest->m[1][2] = src[1][2] * toFixed;
-    dest->m[1][3] = src[1][3] * toFixed;
-    dest->m[2][0] = src[2][0] * toFixed;
-    dest->m[2][1] = src[2][1] * toFixed;
-    dest->m[2][2] = src[2][2] * toFixed;
-    dest->m[2][3] = src[2][3] * toFixed;
-    dest->m[3][0] = src[3][0] * toFixed;
-    dest->m[3][1] = src[3][1] * toFixed;
-    dest->m[3][2] = src[3][2] * toFixed;
+    dest->m.x.x = src.x.x * toFixed;
+    dest->m.x.y = src.x.y * toFixed;
+    dest->m.x.z = src.x.z * toFixed;
+    dest->m.x[3] = src.x[3] * toFixed;
+    dest->m.y.x = src.y.x * toFixed;
+    dest->m.y.y = src.y.y * toFixed;
+    dest->m.y.z = src.y.z * toFixed;
+    dest->m.y[3] = src.y[3] * toFixed;
+    dest->m.z.x = src.z.x * toFixed;
+    dest->m.z.y = src.z.y * toFixed;
+    dest->m.z.z = src.z.z * toFixed;
+    dest->m.z[3] = src.z[3] * toFixed;
+    dest->m[3].x = src[3].x * toFixed;
+    dest->m[3].y = src[3].y * toFixed;
+    dest->m[3].z = src[3].z * toFixed;
     dest->m[3][3] = src[3][3] * toFixed;
 }
 
@@ -984,22 +984,22 @@ void convert_to_fixed_point_matrix(Mtx* dest, Mat4 src) {
     guMtxF2L(src, dest);
 #else
     f32 toFixed = 65536.0f; // 2 ^ 16
-    dest->m[0][0] = ((s32) (src[0][0] * toFixed) & 0xFFFF0000) | (((s32) (src[0][1] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[0][1] = ((s32) (src[0][2] * toFixed) & 0xFFFF0000) | (((s32) (src[0][3] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[0][2] = ((s32) (src[1][0] * toFixed) & 0xFFFF0000) | (((s32) (src[1][1] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[0][3] = ((s32) (src[1][2] * toFixed) & 0xFFFF0000) | (((s32) (src[1][3] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[1][0] = ((s32) (src[2][0] * toFixed) & 0xFFFF0000) | (((s32) (src[2][1] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[1][1] = ((s32) (src[2][2] * toFixed) & 0xFFFF0000) | (((s32) (src[2][3] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[1][2] = ((s32) (src[3][0] * toFixed) & 0xFFFF0000) | (((s32) (src[3][1] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[1][3] = ((s32) (src[3][2] * toFixed) & 0xFFFF0000) | (((s32) (src[3][3] * toFixed) >> 0x10) & 0xFFFF);
-    dest->m[2][0] = ((s32) (src[0][0] * toFixed) << 0x10) | ((s32) (src[0][1] * toFixed) & 0xFFFF);
-    dest->m[2][1] = ((s32) (src[0][2] * toFixed) << 0x10) | ((s32) (src[0][3] * toFixed) & 0xFFFF);
-    dest->m[2][2] = ((s32) (src[1][0] * toFixed) << 0x10) | ((s32) (src[1][1] * toFixed) & 0xFFFF);
-    dest->m[2][3] = ((s32) (src[1][2] * toFixed) << 0x10) | ((s32) (src[1][3] * toFixed) & 0xFFFF);
-    dest->m[3][0] = ((s32) (src[2][0] * toFixed) << 0x10) | ((s32) (src[2][1] * toFixed) & 0xFFFF);
-    dest->m[3][1] = ((s32) (src[2][2] * toFixed) << 0x10) | ((s32) (src[2][3] * toFixed) & 0xFFFF);
-    dest->m[3][2] = ((s32) (src[3][0] * toFixed) << 0x10) | ((s32) (src[3][1] * toFixed) & 0xFFFF);
-    dest->m[3][3] = ((s32) (src[3][2] * toFixed) << 0x10) | ((s32) (src[3][3] * toFixed) & 0xFFFF);
+    dest->m.x.x = ((s32) (src.x.x * toFixed) & 0xFFFF0000) | (((s32) (src.x.y * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.x.y = ((s32) (src.x.z * toFixed) & 0xFFFF0000) | (((s32) (src.x[3] * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.x.z = ((s32) (src.y.x * toFixed) & 0xFFFF0000) | (((s32) (src.y.y * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.x[3] = ((s32) (src.y.z * toFixed) & 0xFFFF0000) | (((s32) (src.y[3] * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.y.x = ((s32) (src.z.x * toFixed) & 0xFFFF0000) | (((s32) (src.z.y * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.y.y = ((s32) (src.z.z * toFixed) & 0xFFFF0000) | (((s32) (src.z[3] * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.y.z = ((s32) (src[3].x * toFixed) & 0xFFFF0000) | (((s32) (src[3].y * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.y[3] = ((s32) (src[3].z * toFixed) & 0xFFFF0000) | (((s32) (src[3][3] * toFixed) >> 0x10) & 0xFFFF);
+    dest->m.z.x = ((s32) (src.x.x * toFixed) << 0x10) | ((s32) (src.x.y * toFixed) & 0xFFFF);
+    dest->m.z.y = ((s32) (src.x.z * toFixed) << 0x10) | ((s32) (src.x[3] * toFixed) & 0xFFFF);
+    dest->m.z.z = ((s32) (src.y.x * toFixed) << 0x10) | ((s32) (src.y.y * toFixed) & 0xFFFF);
+    dest->m.z[3] = ((s32) (src.y.z * toFixed) << 0x10) | ((s32) (src.y[3] * toFixed) & 0xFFFF);
+    dest->m[3].x = ((s32) (src.z.x * toFixed) << 0x10) | ((s32) (src.z.y * toFixed) & 0xFFFF);
+    dest->m[3].y = ((s32) (src.z.z * toFixed) << 0x10) | ((s32) (src.z[3] * toFixed) & 0xFFFF);
+    dest->m[3].z = ((s32) (src[3].x * toFixed) << 0x10) | ((s32) (src[3].y * toFixed) & 0xFFFF);
+    dest->m[3][3] = ((s32) (src[3].z * toFixed) << 0x10) | ((s32) (src[3][3] * toFixed) & 0xFFFF);
 #endif
 }
 
@@ -1211,12 +1211,12 @@ void func_80022BC4(Player* player, UNUSED s8 arg1) {
 void func_80022CA8(Player* player, s8 playerId, UNUSED s8 screenId, s8 arg3) {
     s16 temp_v0 = player->unk_DA4;
 
-    D_800DDBB4[playerId][arg3 + 0x0].v.ob[1] = 18 - (temp_v0 * 2.3);
-    D_800DDBB4[playerId][arg3 + 0x1].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x2].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x3].v.ob[1] = 18 - (temp_v0 * 2.3);
-    D_800DDBB4[playerId][arg3 + 0x4].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x7].v.ob[1] = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x0].v.ob.y = 18 - (temp_v0 * 2.3);
+    D_800DDBB4[playerId][arg3 + 0x1].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x2].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x3].v.ob.y = 18 - (temp_v0 * 2.3);
+    D_800DDBB4[playerId][arg3 + 0x4].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x7].v.ob.y = 9 - temp_v0;
 }
 
 /**
@@ -1224,8 +1224,8 @@ void func_80022CA8(Player* player, s8 playerId, UNUSED s8 screenId, s8 arg3) {
  * short period of time. Perhaps does not do anything
  **/
 void func_80022D60(UNUSED Player* player, s8 playerId, UNUSED s8 screenId, s8 arg3) {
-    D_800DDBB4[playerId][arg3].v.ob[1] = 21;
-    D_800DDBB4[playerId][arg3 + 0x3].v.ob[1] = 21;
+    D_800DDBB4[playerId][arg3].v.ob.y = 21;
+    D_800DDBB4[playerId][arg3 + 0x3].v.ob.y = 21;
 }
 
 void func_80022DB4(Player* player, UNUSED s8 arg1) {
@@ -1255,12 +1255,12 @@ void func_80022DB4(Player* player, UNUSED s8 arg1) {
 void func_80022E84(Player* player, s8 playerId, UNUSED s8 screenId, s8 arg3) {
     s16 temp_v0 = player->unk_DB4.unk1E;
 
-    D_800DDBB4[playerId][arg3 + 0x0].v.ob[1] = 18 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x1].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x2].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x3].v.ob[1] = 18 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x4].v.ob[1] = 9 - temp_v0;
-    D_800DDBB4[playerId][arg3 + 0x7].v.ob[1] = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x0].v.ob.y = 18 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x1].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x2].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x3].v.ob.y = 18 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x4].v.ob.y = 9 - temp_v0;
+    D_800DDBB4[playerId][arg3 + 0x7].v.ob.y = 9 - temp_v0;
 }
 
 /**
@@ -1310,7 +1310,7 @@ void render_light_environment_on_player(Player* player, s8 arg1) {
         if (((gNearestWaypointByPlayerId[arg1] >= 0x15) && (gNearestWaypointByPlayerId[arg1] < 0x2A)) ||
             ((gNearestWaypointByPlayerId[arg1] >= 0x14D) && (gNearestWaypointByPlayerId[arg1] < 0x15C)) ||
             ((gNearestWaypointByPlayerId[arg1] >= 0x1D1) && (gNearestWaypointByPlayerId[arg1] < 0x1E4)) ||
-            (player->collision.surfaceDistance[2] >= 500.0f)) { // over lava
+            (player->collision.surfaceDistance.z >= 500.0f)) { // over lava
             change_player_color_effect_rgb(player, arg1, COLOR_LAVA, 0.3f);
             change_player_color_effect_cmy(player, arg1, 0x004040, 0.3f);
             D_80164B80[arg1] = 0;
@@ -1486,8 +1486,8 @@ void render_player_shadow(Player* player, s8 playerId, s8 screenId) {
 
     // @port: Tag the transform.
     FrameInterpolation_RecordOpenChild("Kart Shadow", TAG_ITEM_ADDR(player));
-    temp_t9 = (u16) (player->unk_048[screenId] + player->rotation[1] + player->unk_0C0) / 128; // << 7) & 0xFFFF;
-    spC0 = -player->rotation[1] - player->unk_0C0;
+    temp_t9 = (u16) (player->unk_048[screenId] + player->rotation.y + player->unk_0C0) / 128; // << 7) & 0xFFFF;
+    spC0 = -player->rotation.y - player->unk_0C0;
 
     spB0 = -coss(temp_t9 << 7) * 2;
     spAC = -sins(temp_t9 << 7) * 2;
@@ -1498,30 +1498,30 @@ void render_player_shadow(Player* player, s8 playerId, s8 screenId) {
         ((player->effects & HIT_BY_ITEM_EFFECT) == HIT_BY_ITEM_EFFECT) || ((player->effects & 0x10000) == 0x10000) ||
         ((player->effects & 8) == 8)) {
 
-        var_f2 = (f32) (1.0 - ((f64) player->collision.surfaceDistance[2] * 0.02));
+        var_f2 = (f32) (1.0 - ((f64) player->collision.surfaceDistance.z * 0.02));
         if (var_f2 < 0.0f) {
             var_f2 = 0.0f;
         }
         if (var_f2 > 1.0f) {
             var_f2 = 1.0f;
         }
-        spB4[0] = player->collision.orientationVector[0];
-        spB4[2] = player->collision.orientationVector[2];
-        spB4[1] = player->collision.orientationVector[1];
+        spB4.x = player->collision.orientationVector.x;
+        spB4.z = player->collision.orientationVector.z;
+        spB4.y = player->collision.orientationVector.y;
 
-        spCC[0] = player->pos[0] + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
-        spCC[1] = player->unk_074 + 1.0f;
-        spCC[2] = player->pos[2] + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
+        spCC.x = player->pos.x + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
+        spCC.y = player->unk_074 + 1.0f;
+        spCC.z = player->pos.z + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
         set_transform_matrix(mtx, spB4, spCC, (spC0 + player->unk_042),
                              gCharacterSize[player->characterId] * player->size * var_f2);
     } else {
-        spC4[0] = player->slopeAccel;
-        spC4[1] = spC0;
-        spC4[2] = player->unk_206 * 2;
+        spC4.x = player->slopeAccel;
+        spC4.y = spC0;
+        spC4.z = player->unk_206 * 2;
 
-        spCC[0] = player->pos[0] + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
-        spCC[1] = player->unk_074 + 1.0f;
-        spCC[2] = player->pos[2] + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
+        spCC.x = player->pos.x + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
+        spCC.y = player->unk_074 + 1.0f;
+        spCC.z = player->pos.z + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
         mtxf_translate_rotate(mtx, spCC, spC4);
         mtxf_scale2(mtx, gCharacterSize[player->characterId] * player->size);
     }
@@ -1537,7 +1537,7 @@ void render_player_shadow(Player* player, s8 playerId, s8 screenId) {
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0xFF);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, &D_800E51D0[0], 4, 0);
+    gSPVertex(gDisplayListHead++, &D_800E51D0.x, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gDPLoadTextureBlock(gDisplayListHead++, (D_8018D474 + SOME_TEXTURE_POINTER_MATH), G_IM_FMT_I, G_IM_SIZ_8b, 64, 32,
@@ -1545,7 +1545,7 @@ void render_player_shadow(Player* player, s8 playerId, s8 screenId) {
                         G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0xFF);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, &D_800E5210[0], 4, 0);
+    gSPVertex(gDisplayListHead++, &D_800E5210.x, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1567,19 +1567,19 @@ void render_player_shadow_credits(Player* player, s8 playerId, s8 arg2) {
     UNUSED Vec3f pad3;
     Vec3f sp94 = { 9.0f, 7.0f, 5.0f };
 
-    temp_t9 = (u16) (player->unk_048[arg2] + player->rotation[1] + player->unk_0C0) / 128;
-    spC0 = -player->rotation[1] - player->unk_0C0;
+    temp_t9 = (u16) (player->unk_048[arg2] + player->rotation.y + player->unk_0C0) / 128;
+    spC0 = -player->rotation.y - player->unk_0C0;
 
     spB0 = -coss(temp_t9 << 7) * 3;
     spAC = -sins(temp_t9 << 7) * 3;
 
-    spC4[0] = 0;
-    spC4[1] = spC0;
-    spC4[2] = 0;
+    spC4.x = 0;
+    spC4.y = spC0;
+    spC4.z = 0;
 
-    spCC[0] = player->pos[0] + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
-    spCC[2] = player->pos[2] + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
-    spCC[1] = gObjectList[indexObjectList1[playerId]].pos[1] + sp94[playerId];
+    spCC.x = player->pos.x + ((spB0 * sins(spC0)) + (spAC * coss(spC0)));
+    spCC.z = player->pos.z + ((spB0 * coss(spC0)) - (spAC * sins(spC0)));
+    spCC.y = gObjectList[indexObjectList1[playerId]].pos.y + sp94[playerId];
 
     mtxf_translate_rotate(mtx, spCC, spC4);
     mtxf_scale2(mtx, gCharacterSize[player->characterId] * player->size);
@@ -1596,7 +1596,7 @@ void render_player_shadow_credits(Player* player, s8 playerId, s8 arg2) {
                         G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0x000000D0);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, &D_800E51D0[0], 4, 0);
+    gSPVertex(gDisplayListHead++, &D_800E51D0.x, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gDPLoadTextureBlock(gDisplayListHead++, (D_8018D474 + SOME_TEXTURE_POINTER_MATH), G_IM_FMT_I, G_IM_SIZ_8b, 64, 32,
@@ -1604,7 +1604,7 @@ void render_player_shadow_credits(Player* player, s8 playerId, s8 arg2) {
                         G_TX_NOLOD);
     func_8004B414(0, 0, 0, 0x000000D0);
     gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
-    gSPVertex(gDisplayListHead++, &D_800E5210[0], 4, 0);
+    gSPVertex(gDisplayListHead++, &D_800E5210.x, 4, 0);
 
     gSPDisplayList(gDisplayListHead++, common_square_plain_render);
     gSPTexture(gDisplayListHead++, 1, 1, 0, G_TX_RENDERTILE, G_OFF);
@@ -1623,35 +1623,35 @@ void render_kart(Player* player, s8 playerId, s8 screenId, s8 arg3) {
     s16 thing;
 
     if (player->unk_044 & 0x2000) {
-        sp14C[0] = 0;
-        sp14C[1] = player->unk_048[screenId];
-        sp14C[2] = 0;
+        sp14C.x = 0;
+        sp14C.y = player->unk_048[screenId];
+        sp14C.z = 0;
         func_80062B18(&sp148, &sp144, &sp140, 0.0f, 1.5f, 0.0f, -player->unk_048[screenId], player->unk_050[screenId]);
-        sp154[1] = (player->pos[1] - player->boundingBoxSize) + (sp144 - 2.0);
-        sp154[0] = player->pos[0] + sp148;
-        sp154[2] = player->pos[2] + sp140;
+        sp154.y = (player->pos.y - player->boundingBoxSize) + (sp144 - 2.0);
+        sp154.x = player->pos.x + sp148;
+        sp154.z = player->pos.z + sp140;
     } else {
-        thing = (u16) (player->unk_048[screenId] + player->rotation[1] + player->unk_0C0);
+        thing = (u16) (player->unk_048[screenId] + player->rotation.y + player->unk_0C0);
         temp_v1 = player->unk_0CC[screenId] * sins(thing);
         if ((player->effects & 8) == 8) {
-            sp14C[0] = cameras[screenId].rot[0] - 0x4000;
+            sp14C.x = cameras[screenId].rot.x - 0x4000;
         } else {
-            sp14C[0] = -temp_v1 * 0.8;
+            sp14C.x = -temp_v1 * 0.8;
         }
-        sp14C[1] = player->unk_048[screenId];
-        sp14C[2] = player->unk_050[screenId];
+        sp14C.y = player->unk_048[screenId];
+        sp14C.z = player->unk_050[screenId];
         if (((s32) player->effects & HIT_EFFECT) == HIT_EFFECT) {
             func_80062B18(&sp148, &sp144, &sp140, 0.0f, 8.0f, 0.0f, -player->unk_048[screenId],
                           player->unk_050[screenId]);
-            sp154[1] = (player->pos[1] - player->boundingBoxSize) + player->unk_108;
-            sp154[0] = player->pos[0] + sp148;
-            sp154[2] = player->pos[2] + sp140;
+            sp154.y = (player->pos.y - player->boundingBoxSize) + player->unk_108;
+            sp154.x = player->pos.x + sp148;
+            sp154.z = player->pos.z + sp140;
         } else {
             func_80062B18(&sp148, &sp144, &sp140, 0.0f, 1.5f, 0.0f, -player->unk_048[screenId],
                           player->unk_050[screenId]);
-            sp154[1] = (player->pos[1] - player->boundingBoxSize) + player->unk_108 + (sp144 - 2.0);
-            sp154[0] = player->pos[0] + sp148;
-            sp154[2] = player->pos[2] + sp140;
+            sp154.y = (player->pos.y - player->boundingBoxSize) + player->unk_108 + (sp144 - 2.0);
+            sp154.x = player->pos.x + sp148;
+            sp154.z = player->pos.z + sp140;
         }
     }
 #ifdef AVOID_UB
@@ -1776,14 +1776,14 @@ void render_ghost(Player* player, s8 playerId, s8 screenId, s8 arg3) {
     } else {
         spC2 = 0x0070;
     }
-    thing = (u16) (player->unk_048[screenId] - player->rotation[1]);
-    spD4[0] = (-(s16) (sins(thing) * (0.0f * 0.0f)) * 0.8);
-    spD4[1] = player->unk_048[screenId];
-    spD4[2] = player->unk_050[screenId];
+    thing = (u16) (player->unk_048[screenId] - player->rotation.y);
+    spD4.x = (-(s16) (sins(thing) * (0.0f * 0.0f)) * 0.8);
+    spD4.y = player->unk_048[screenId];
+    spD4.z = player->unk_050[screenId];
     func_80062B18(&spD0, &spCC, &spC8, 0, 1.5f, 0, -player->unk_048[screenId], player->unk_050[screenId]);
-    spDC[1] = (player->pos[1] - player->boundingBoxSize) + (spCC - 2.0);
-    spDC[0] = player->pos[0] + spD0;
-    spDC[2] = player->pos[2] + spC8;
+    spDC.y = (player->pos.y - player->boundingBoxSize) + (spCC - 2.0);
+    spDC.x = player->pos.x + spD0;
+    spDC.z = player->pos.z + spC8;
 #ifdef AVOID_UB
     gPlayerPalette = &gPlayerPalettesList[D_801651D0[screenId][playerId]][screenId][playerId];
 #else
@@ -1839,12 +1839,12 @@ void func_80025DE8(Player* player, s8 playerId, s8 screenId, s8 arg3) {
     Vec3f sp9C;
     Vec3s sp94;
 
-    sp9C[0] = player->pos[0] + (sins(-player->rotation[1]) * -1.5);
-    sp9C[1] = ((player->pos[1] - player->boundingBoxSize) + player->unk_108) + 0.1;
-    sp9C[2] = player->pos[2] + (coss(-player->rotation[1]) * -1.5);
-    sp94[0] = -0x00B6;
-    sp94[1] = player->unk_048[screenId];
-    sp94[2] = player->unk_050[screenId];
+    sp9C.x = player->pos.x + (sins(-player->rotation.y) * -1.5);
+    sp9C.y = ((player->pos.y - player->boundingBoxSize) + player->unk_108) + 0.1;
+    sp9C.z = player->pos.z + (coss(-player->rotation.y) * -1.5);
+    sp94.x = -0x00B6;
+    sp94.y = player->unk_048[screenId];
+    sp94.z = player->unk_050[screenId];
 
     mtxf_translate_rotate(mtx, sp9C, sp94);
     mtxf_scale2(mtx, gCharacterSize[player->characterId] * player->size);
@@ -1884,12 +1884,12 @@ void render_player_ice_reflection(Player* player, s8 playerId, s8 screenId, s8 a
     Vec3f sp9C;
     Vec3s sp94;
 
-    sp94[0] = 0;
-    sp94[1] = player->unk_048[screenId];
-    sp94[2] = player->unk_050[screenId] + 0x8000; // invert Y
-    sp9C[0] = player->pos[0];
-    sp9C[1] = player->unk_074 + (4.0f * player->size);
-    sp9C[2] = player->pos[2];
+    sp94.x = 0;
+    sp94.y = player->unk_048[screenId];
+    sp94.z = player->unk_050[screenId] + 0x8000; // invert Y
+    sp9C.x = player->pos.x;
+    sp9C.y = player->unk_074 + (4.0f * player->size);
+    sp9C.z = player->pos.z;
     if (!(player->unk_002 & (4 << (screenId * 4)))) {
         arg3 = 8;
     } else {
@@ -1926,7 +1926,7 @@ void render_player_ice_reflection(Player* player, s8 playerId, s8 screenId, s8 a
 }
 
 void render_player(Player* player, s8 playerId, s8 screenId) {
-    UNUSED s32 pad[2];
+    UNUSED s32 pad.z;
     s32 temp_t1;
     s32 var_v1;
     OSMesg* sp34;
@@ -1939,7 +1939,7 @@ void render_player(Player* player, s8 playerId, s8 screenId) {
     }
     func_80023BF0(player, playerId, screenId, var_v1);
     temp_t1 = 8 << (screenId * 4);
-    if ((temp_t1 == (player->unk_002 & temp_t1)) && (player->collision.surfaceDistance[2] <= 50.0f) &&
+    if ((temp_t1 == (player->unk_002 & temp_t1)) && (player->collision.surfaceDistance.z <= 50.0f) &&
         (player->surfaceType != ICE)) {
         if ((player->effects & BOO_EFFECT) == BOO_EFFECT) {
             if (playerId == screenId) {
@@ -1956,7 +1956,7 @@ void render_player(Player* player, s8 playerId, s8 screenId) {
     }
     osRecvMesg(&gDmaMesgQueue, (OSMesg*) &sp34, OS_MESG_BLOCK);
     if ((temp_t1 == (player->unk_002 & temp_t1)) && (player->surfaceType == ICE) && ((player->unk_0CA & 1) != 1) &&
-        (player->collision.surfaceDistance[2] <= 30.0f)) {
+        (player->collision.surfaceDistance.z <= 30.0f)) {
         render_player_ice_reflection(player, playerId, screenId, var_v1);
     }
     if (player->boostPower >= 2.0f) {
diff --git a/src/spawn_players.c b/src/spawn_players.c
index 5e623577b..8ae765719 100644
--- a/src/spawn_players.c
+++ b/src/spawn_players.c
@@ -132,10 +132,10 @@ void spawn_player(Player* player, s8 playerIndex, f32 startingRow, f32 startingC
 #undef calc
     }
 
-    player->pos[0] = startingRow;
+    player->pos.x = startingRow;
     ret = spawn_actor_on_surface(startingRow, arg4 + 50.0f, startingColumn) + player->boundingBoxSize;
-    player->pos[2] = startingColumn;
-    player->pos[1] = ret;
+    player->pos.z = startingColumn;
+    player->pos.y = ret;
     player->oldPos[0] = startingRow;
     player->oldPos[1] = ret;
 
@@ -146,9 +146,9 @@ void spawn_player(Player* player, s8 playerIndex, f32 startingRow, f32 startingC
     player->unk_05C = 1.0f;
     player->unk_058 = 0.0f;
     player->unk_060 = 0.0f;
-    player->velocity[0] = 0.0f;
-    player->velocity[1] = 0.0f;
-    player->velocity[2] = 0.0f;
+    player->velocity.x = 0.0f;
+    player->velocity.y = 0.0f;
+    player->velocity.z = 0.0f;
     player->rotation[1] = arg5;
     player->rotation[2] = 0;
     player->unk_0FA = 0;
@@ -338,21 +338,21 @@ void spawn_player(Player* player, s8 playerIndex, f32 startingRow, f32 startingC
     player->collision.meshIndexZY = 0;
     player->collision.meshIndexZX = 0;
 
-    player->tyres[FRONT_LEFT].pos[0] = 0.0f;
-    player->tyres[FRONT_LEFT].pos[1] = 0.0f;
-    player->tyres[FRONT_LEFT].pos[2] = 0.0f;
+    player->tyres[FRONT_LEFT].pos.x = 0.0f;
+    player->tyres[FRONT_LEFT].pos.y = 0.0f;
+    player->tyres[FRONT_LEFT].pos.z = 0.0f;
 
-    player->tyres[FRONT_RIGHT].pos[0] = 0.0f;
-    player->tyres[FRONT_RIGHT].pos[1] = 0.0f;
-    player->tyres[FRONT_RIGHT].pos[2] = 0.0f;
+    player->tyres[FRONT_RIGHT].pos.x = 0.0f;
+    player->tyres[FRONT_RIGHT].pos.y = 0.0f;
+    player->tyres[FRONT_RIGHT].pos.z = 0.0f;
 
-    player->tyres[BACK_LEFT].pos[0] = 0.0f;
-    player->tyres[BACK_LEFT].pos[1] = 0.0f;
-    player->tyres[BACK_LEFT].pos[2] = 0.0f;
+    player->tyres[BACK_LEFT].pos.x = 0.0f;
+    player->tyres[BACK_LEFT].pos.y = 0.0f;
+    player->tyres[BACK_LEFT].pos.z = 0.0f;
 
-    player->tyres[BACK_RIGHT].pos[0] = 0.0f;
-    player->tyres[BACK_RIGHT].pos[1] = 0.0f;
-    player->tyres[BACK_RIGHT].pos[2] = 0.0f;
+    player->tyres[BACK_RIGHT].pos.x = 0.0f;
+    player->tyres[BACK_RIGHT].pos.y = 0.0f;
+    player->tyres[BACK_RIGHT].pos.z = 0.0f;
 
     player->tyres[FRONT_LEFT].baseHeight = 0.0f;
     player->tyres[FRONT_RIGHT].baseHeight = 0.0f;
@@ -1200,19 +1200,19 @@ void func_8003D080(void) {
                 switch (gModeSelection) {
                     case GRAND_PRIX:
                         if (GetCourse() == GetToadsTurnpike()) {
-                            camera_init(0.0f, player->pos[1], D_80165230[7], player->rotation[1], 8, 0);
+                            camera_init(0.0f, player->pos.y, D_80165230[7], player->rotation[1], 8, 0);
                         } else {
-                            camera_init((D_80165210[7] + D_80165210[6]) / 2, player->pos[1], D_80165230[7],
+                            camera_init((D_80165210[7] + D_80165210[6]) / 2, player->pos.y, D_80165230[7],
                                         player->rotation[1], 8, 0);
                         }
                         break;
 
                     case TIME_TRIALS:
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 0);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 0);
                         break;
 
                     default:
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 10, 0);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 10, 0);
                         break;
                 }
                 break;
@@ -1221,45 +1221,45 @@ void func_8003D080(void) {
             case SCREEN_MODE_2P_SPLITSCREEN_VERTICAL:
                 switch (gModeSelection) {
                     case GRAND_PRIX:
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 0);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 0);
                         player++;
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 1);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 1);
                         break;
 
                     case BATTLE:
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 0);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 0);
                         player++;
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 1);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 1);
                         break;
 
                     default:
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 0);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 0);
                         player++;
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 1);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 1);
                         break;
                 }
                 break;
 
             case SCREEN_MODE_3P_4P_SPLITSCREEN:
                 if (gModeSelection == BATTLE) {
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 0);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 0);
                     player++;
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 1);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 1);
                     player++;
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 2);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 2);
                     if (gPlayerCountSelection1 == 4) {
                         player++;
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 9, 3);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 9, 3);
                     }
                 } else {
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 0);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 0);
                     player++;
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 1);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 1);
                     player++;
-                    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 2);
+                    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 2);
                     if (gPlayerCountSelection1 == 4) {
                         player++;
-                        camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 1, 3);
+                        camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 1, 3);
                     }
                 }
                 break;
@@ -1267,24 +1267,24 @@ void func_8003D080(void) {
     } else {
         switch (gActiveScreenMode) {
             case SCREEN_MODE_1P:
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 0);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 0);
                 break;
 
             case SCREEN_MODE_2P_SPLITSCREEN_HORIZONTAL:
             case SCREEN_MODE_2P_SPLITSCREEN_VERTICAL:
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 0);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 0);
                 player++;
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 1);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 1);
                 break;
 
             case SCREEN_MODE_3P_4P_SPLITSCREEN:
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 0);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 0);
                 player++;
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 1);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 1);
                 player++;
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 2);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 2);
                 player++;
-                camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 3);
+                camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 3);
                 break;
         }
     }
@@ -1346,8 +1346,8 @@ void func_8003DB5C(void) {
     Player* player = gPlayerOne;
     s32 playerId;
 
-    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 0);
-    camera_init(player->pos[0], player->pos[1], player->pos[2], player->rotation[1], 3, 1);
+    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 0);
+    camera_init(player->pos.x, player->pos.y, player->pos.z, player->rotation[1], 3, 1);
 
     for (playerId = 0; playerId < NUM_PLAYERS; playerId++, player++) {
         load_kart_palette(player, playerId, 1, 0);
diff --git a/src/update_objects.c b/src/update_objects.c
index 6d2b8a77a..c726e7ec1 100644
--- a/src/update_objects.c
+++ b/src/update_objects.c
@@ -1319,7 +1319,7 @@ void func_800750D8(s32 objectIndex, s32 arg1, Vec3f arg2, s32 arg3, s32 arg4) {
     object->unk_0D5 = arg3;
     object->sizeScaling = ((f64) (f32) sp24 * 0.0005) + 0.05;
     // ALL HAIL THE FAKE MATCH GODS!!!!!
-    object->velocity[1] = ((f64) (f32) temp_v0 * (0.05 * 1.0)) + 2.0;
+    object->velocity.y = ((f64) (f32) temp_v0 * (0.05 * 1.0)) + 2.0;
     object->unk_034 = ((f64) (f32) (temp_v0 % 5) * 0.1) + 1.0;
     object->direction_angle[1] = (arg1 << 0x10) / arg4;
     object->origin_pos[0] = (arg2[0] + (temp_v0 / 2)) - 12.0f;
@@ -1359,10 +1359,10 @@ void init_train_smoke(s32 objectIndex, Vec3f pos, f32 velocity) {
 
     init_object(objectIndex, 0);
     object = &gObjectList[objectIndex];
-    object->origin_pos[0] = pos[0];
-    object->origin_pos[1] = pos[1];
-    object->origin_pos[2] = pos[2];
-    object->velocity[1] = velocity;
+    object->origin_pos[0] = pos.x;
+    object->origin_pos[1] = pos.y;
+    object->origin_pos[2] = pos.z;
+    object->velocity.y = velocity;
     object->type = random_int(0x0064U) + 0x1E;
 }
 
@@ -1404,8 +1404,8 @@ void func_80075714(s32 objectIndex) {
             func_80075698(objectIndex);
             break;
         case 2:
-            gObjectList[objectIndex].velocity[1] -= 0.03;
-            f32_step_up_towards(&gObjectList[objectIndex].offset[1], 100.0f, gObjectList[objectIndex].velocity[1]);
+            gObjectList[objectIndex].velocity.y -= 0.03;
+            f32_step_up_towards(&gObjectList[objectIndex].offset[1], 100.0f, gObjectList[objectIndex].velocity.y);
             func_8007415C(objectIndex, &gObjectList[objectIndex].sizeScaling, 0.55f, 1.0f, 0.1f, 1, 0);
             if (func_80073B00(objectIndex, &gObjectList[objectIndex].primAlpha, 0xFF, 0x1E, 7, 0, 0) != 0) {
                 object_next_state(objectIndex);
@@ -1478,10 +1478,10 @@ void init_ferry_smoke(s32 objectIndex, Vec3f pos, f32 velocity) {
 
     init_object(objectIndex, 0);
     object = &gObjectList[objectIndex];
-    object->origin_pos[0] = pos[0];
-    object->origin_pos[1] = pos[1];
-    object->origin_pos[2] = pos[2];
-    object->velocity[1] = velocity;
+    object->origin_pos[0] = pos.x;
+    object->origin_pos[1] = pos.y;
+    object->origin_pos[2] = pos.z;
+    object->velocity.y = velocity;
     object->type = 0x00FF;
     object->unk_0A2 = 0x0096;
 }
@@ -1525,8 +1525,8 @@ void func_80075B84(s32 objectIndex) {
             func_80075B08(objectIndex);
             break;
         case 2:
-            gObjectList[objectIndex].velocity[1] -= 0.03;
-            f32_step_up_towards(&gObjectList[objectIndex].offset[1], 100.0f, gObjectList[objectIndex].velocity[1]);
+            gObjectList[objectIndex].velocity.y -= 0.03;
+            f32_step_up_towards(&gObjectList[objectIndex].offset[1], 100.0f, gObjectList[objectIndex].velocity.y);
             func_8007415C(objectIndex, &gObjectList[objectIndex].sizeScaling, 0.55f, 1.0f, 0.1f, 1, 0);
             if (func_80073B00(objectIndex, &gObjectList[objectIndex].primAlpha, 0xFF, 0x1E, 7, 0, 0) != 0) {
                 object_next_state(objectIndex);
@@ -1849,7 +1849,7 @@ void func_8007675C(s32 objectIndex, Vec3s arg1, s32 arg2) {
     object->type = 0x00FF;
     object->unk_0A2 = 0x00FF;
     object->unk_034 = 8.0f;
-    object->velocity[1] = 8.0f;
+    object->velocity.y = 8.0f;
     object->unk_048 = arg2;
 }
 
@@ -2109,19 +2109,19 @@ void init_object_leaf_particle(s32 objectIndex, Vec3f arg1, s32 num) {
     if (GetCourse() == GetMarioRaceway()) {
         object_origin_pos_randomize_around_xyz(objectIndex, arg1[0], arg1[1] + 25.0, arg1[2], 0x14, 0x1E, 0x14);
         gObjectList[objectIndex].unk_034 = 1.5f;
-        gObjectList[objectIndex].velocity[1] = 1.5f;
+        gObjectList[objectIndex].velocity.y = 1.5f;
     } else if (GetCourse() == GetYoshiValley()) {
         object_origin_pos_randomize_around_xyz(objectIndex, arg1[0], arg1[1] + 25.0, arg1[2], 0x14, 0x1E, 0x14);
         gObjectList[objectIndex].unk_034 = 2.0f;
-        gObjectList[objectIndex].velocity[1] = 2.0f;
+        gObjectList[objectIndex].velocity.y = 2.0f;
     } else if (GetCourse() == GetRoyalRaceway()) {
         object_origin_pos_randomize_around_xyz(objectIndex, arg1[0], arg1[1] + 30.0, arg1[2], 0x10, 0x28, 0x10);
         gObjectList[objectIndex].unk_034 = 2.0f;
-        gObjectList[objectIndex].velocity[1] = 2.0f;
+        gObjectList[objectIndex].velocity.y = 2.0f;
     } else if (GetCourse() == GetLuigiRaceway()) {
         object_origin_pos_randomize_around_xyz(objectIndex, arg1[0], arg1[1] + 25.0, arg1[2], 0x14, 0x1E, 0x14);
         gObjectList[objectIndex].unk_034 = 1.5f;
-        gObjectList[objectIndex].velocity[1] = 1.0f;
+        gObjectList[objectIndex].velocity.y = 1.0f;
     }
 
     temp_s0 = random_int(0x0010U) << 0xC;
@@ -2180,7 +2180,7 @@ void func_80077B3C(s32 objectIndex) {
 void func_80077BCC(s32 objectIndex) {
     switch (gObjectList[objectIndex].unk_0AE) {
         case 1:
-            func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.2f, gObjectList[objectIndex].unk_034,
+            func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.2f, gObjectList[objectIndex].unk_034,
                           (s16) (s32) gObjectList[objectIndex].direction_angle[1], 0x0000000A);
             break;
         case 2:
@@ -2259,7 +2259,7 @@ void func_80077E20(s32 objectIndex) {
 void func_80077EB8(s32 objectIndex, u16 arg1, Camera* camera) {
     s16 temp_v0;
 
-    temp_v0 = camera->rot[1] - arg1;
+    temp_v0 = camera->rot.y - arg1;
     if ((temp_v0 >= D_8018D210) || (D_8018D208 >= temp_v0)) {
         gObjectList[objectIndex].offset[0] = D_8018D218 + (D_8018D1E8 * (f32) temp_v0);
         set_object_flag(objectIndex, 0x00000010);
@@ -2274,11 +2274,11 @@ void func_80077F64(s32 objectIndex, Camera* camera) {
 
     switch (gObjectList[objectIndex].unk_0AE) { /* irregular */
         case 1:
-            gObjectList[objectIndex].direction_angle[1] = (camera->rot[1] + random_int(0x4000U)) - 0x2000;
+            gObjectList[objectIndex].direction_angle[1] = (camera->rot.y + random_int(0x4000U)) - 0x2000;
             object_origin_pos_randomize_around_y(objectIndex, 0x00B4, 0x0014U);
             rand = random_int(0x0064U);
 
-            gObjectList[objectIndex].velocity[1] = (f32) (-0.75 - (f64) (f32) (rand * 0.01));
+            gObjectList[objectIndex].velocity.y = (f32) (-0.75 - (f64) (f32) (rand * 0.01));
             gObjectList[objectIndex].offset[0] = 0.0f;
             gObjectList[objectIndex].offset[1] = 0.0f;
             func_80086FD4(objectIndex);
@@ -2288,7 +2288,7 @@ void func_80077F64(s32 objectIndex, Camera* camera) {
             object_add_velocity_offset_y(objectIndex);
             object_calculate_new_pos_offset(objectIndex);
             func_8008BFC0(objectIndex);
-            if (gObjectList[objectIndex].pos[1] <= 0.0f) {
+            if (gObjectList[objectIndex].pos.y <= 0.0f) {
                 func_80086FD4(objectIndex);
                 return;
             }
@@ -2361,25 +2361,25 @@ void func_80078288(s32 objectIndex) {
                 sp3A = ((gPlayerOneCopy->unk_094 / 18) * 216) / 2;
                 sp3E = (random_int(0x000FU) - sp3A) + 0x2D;
                 sp3C = random_int(0x012CU) + 0x1E;
-                temp_t6 = camera1->rot[1] + ((s32) (random_int(0x3000U) - 0x1800) / (s16) ((sp3A / 15) + 1));
-                gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos[0] + (sins(temp_t6) * sp3C);
+                temp_t6 = camera1->rot.y + ((s32) (random_int(0x3000U) - 0x1800) / (s16) ((sp3A / 15) + 1));
+                gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos.x + (sins(temp_t6) * sp3C);
                 gObjectList[objectIndex].origin_pos[1] = sp3E + gPlayerOneCopy->unk_074;
-                gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos[2] + (coss(temp_t6) * sp3C);
+                gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos.z + (coss(temp_t6) * sp3C);
                 gObjectList[objectIndex].unk_0C4 = random_int(0x0400U) + 0x100;
                 gObjectList[objectIndex].unk_01C[0] = (f32) (((f32) random_int(0x0064U) * 0.03) + 2.0);
-                gObjectList[objectIndex].velocity[1] = (f32) (-0.3 - (f64) (f32) (random_int(0x0032U) * 0.01));
+                gObjectList[objectIndex].velocity.y = (f32) (-0.3 - (f64) (f32) (random_int(0x0032U) * 0.01));
                 gObjectList[objectIndex].offset[0] = 0.0f;
                 gObjectList[objectIndex].offset[1] = 0.0f;
                 func_80086FD4(objectIndex);
             } else {
                 sp3C = random_int(0x0064U) + 0x28;
-                temp_t6 = camera1->rot[1] + random_int(0x3000U) - 0x1800;
-                gObjectList[objectIndex].origin_pos[0] = camera1->pos[0] + (sins(temp_t6) * sp3C);
-                gObjectList[objectIndex].origin_pos[1] = camera1->pos[1] + 45.0;
-                gObjectList[objectIndex].origin_pos[2] = camera1->pos[2] + (coss(temp_t6) * sp3C);
+                temp_t6 = camera1->rot.y + random_int(0x3000U) - 0x1800;
+                gObjectList[objectIndex].origin_pos[0] = camera1->pos.x + (sins(temp_t6) * sp3C);
+                gObjectList[objectIndex].origin_pos[1] = camera1->pos.y + 45.0;
+                gObjectList[objectIndex].origin_pos[2] = camera1->pos.z + (coss(temp_t6) * sp3C);
                 gObjectList[objectIndex].unk_0C4 = random_int(0x0400U) + 0x100;
                 gObjectList[objectIndex].unk_01C[0] = (f32) (((f32) random_int(0x0064U) * 0.03) + 2.0);
-                gObjectList[objectIndex].velocity[1] = (f32) (-0.6 - (f64) (f32) (random_int(0x0032U) * 0.01));
+                gObjectList[objectIndex].velocity.y = (f32) (-0.6 - (f64) (f32) (random_int(0x0032U) * 0.01));
                 gObjectList[objectIndex].offset[0] = 0.0f;
                 gObjectList[objectIndex].offset[1] = 0.0f;
                 func_80086FD4(objectIndex);
@@ -2391,7 +2391,7 @@ void func_80078288(s32 objectIndex) {
             gObjectList[objectIndex].offset[0] =
                 sins(gObjectList[objectIndex].direction_angle[0]) * gObjectList[objectIndex].unk_01C[0];
             object_calculate_new_pos_offset(objectIndex);
-            if ((f64) gObjectList[objectIndex].pos[1] <= 0.0) {
+            if ((f64) gObjectList[objectIndex].pos.y <= 0.0) {
                 func_80086FD4(objectIndex);
             }
             gObjectList[objectIndex].orientation[1] = angle_between_object_camera(objectIndex, camera1);
@@ -2462,7 +2462,7 @@ void func_800788F8(s32 objectIndex, u16 rot, Camera* camera) {
     const float cullingFactor = OTRGetAspectRatio();
 
     // Calculate object's rotation relative to the camera
-    cameraRot = camera->rot[1] + rot;
+    cameraRot = camera->rot.y + rot;
 
     // Adjust bounds based on the culling factor
     s16 adjustedLowerBound = (s16) (D_8018D210 * cullingFactor);
@@ -3463,7 +3463,7 @@ void wrapper_update_boos(void) {
 
 // Updates the display status on an object based on its relative direction to the camera
 void func_8007C360(s32 objectIndex, Camera* camera) {
-    u16 rot = camera->rot[1];
+    u16 rot = camera->rot.y;
     u16 temp = ((u16) (gObjectList[objectIndex].direction_angle[1] - rot + 0x8000) * 0x24) / 0x10000;
 
     if (temp < 0x13) {
@@ -3479,8 +3479,8 @@ void func_8007C420(s32 objectIndex, Player* player, Camera* camera) {
     f32 x;
     f32 z;
 
-    x = player->pos[0] - gObjectList[objectIndex].pos[0];
-    z = player->pos[2] - gObjectList[objectIndex].pos[2];
+    x = player->pos.x - gObjectList[objectIndex].pos.x;
+    z = player->pos.z - gObjectList[objectIndex].pos.z;
     gObjectList[objectIndex].direction_angle[1] =
         func_800417B4(gObjectList[objectIndex].direction_angle[1], atan2s(x, z));
     func_8007C360(objectIndex, camera);
@@ -3493,9 +3493,9 @@ void func_8007CE0C(s32 objectIndex) {
     init_texture_object(objectIndex, d_course_banshee_boardwalk_boo_tlut, gTextureGhosts, 0x30U, (u16) 0x00000028);
     object = &gObjectList[objectIndex];
     object->textureListIndex = 0x1C;
-    object->pos[0] = 0.0f;
-    object->pos[1] = 0.0f;
-    object->pos[2] = 0.0f;
+    object->pos.x = 0.0f;
+    object->pos.y = 0.0f;
+    object->pos.z = 0.0f;
     object->sizeScaling = 0.15f;
     object_next_state(objectIndex);
     object->primAlpha = 0;
@@ -3503,7 +3503,7 @@ void func_8007CE0C(s32 objectIndex) {
     func_80086EF0(objectIndex);
     object->direction_angle[2] = 0x8000;
     object->direction_angle[1] =
-        atan2s(D_8018CF1C->pos[0] - object->origin_pos[0], D_8018CF1C->pos[2] - object->origin_pos[2]);
+        atan2s(D_8018CF1C->pos.x - object->origin_pos[0], D_8018CF1C->pos.z - object->origin_pos[2]);
 }
 
 void func_8007CEDC(s32 objectIndex) {
@@ -3580,10 +3580,10 @@ void func_8007D070(void) {
                 temp_s3 = random_int(0x1000U) - 0x800;
                 temp_t5 = random_int(0x000FU) - 5;
                 gObjectList[objectIndex].direction_angle[1] = D_8018CF1C->rotation[1] + 0x8000;
-                temp_t2 = (D_8018CF14->rot[1] + temp_s3);
-                gObjectList[objectIndex].origin_pos[0] = D_8018CF1C->pos[0] + (sins(temp_t2) * temp_s2);
+                temp_t2 = (D_8018CF14->rot.y + temp_s3);
+                gObjectList[objectIndex].origin_pos[0] = D_8018CF1C->pos.x + (sins(temp_t2) * temp_s2);
                 gObjectList[objectIndex].origin_pos[1] = temp_t5;
-                gObjectList[objectIndex].origin_pos[2] = D_8018CF1C->pos[2] + (coss(temp_t2) * temp_s2);
+                gObjectList[objectIndex].origin_pos[2] = D_8018CF1C->pos.z + (coss(temp_t2) * temp_s2);
                 gObjectList[objectIndex].spline = &D_800E5D54;
             }
         }
@@ -3593,11 +3593,11 @@ void func_8007D070(void) {
         if (gObjectList[objectIndex].state != 0) {
             func_8007CEDC(objectIndex);
             func_8008B724(objectIndex);
-            gObjectList[objectIndex].pos[0] =
+            gObjectList[objectIndex].pos.x =
                 gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0];
-            gObjectList[objectIndex].pos[1] =
+            gObjectList[objectIndex].pos.y =
                 D_8018CF1C->unk_074 + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
-            gObjectList[objectIndex].pos[2] =
+            gObjectList[objectIndex].pos.z =
                 gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2];
             func_8007C420(objectIndex, D_8018CF1C, D_8018CF14);
             if (is_obj_flag_status_active(objectIndex, 0x00000080) != 0) {
@@ -3752,9 +3752,9 @@ void func_8007E1F4(s32 objectIndex) {
 }
 
 void func_8007E358(s32 objectIndex) {
-    gObjectList[objectIndex].pos[0] = -1371.0f * xOrientation;
-    gObjectList[objectIndex].pos[1] = 31.0f;
-    gObjectList[objectIndex].pos[2] = -217.0f;
+    gObjectList[objectIndex].pos.x = -1371.0f * xOrientation;
+    gObjectList[objectIndex].pos.y = 31.0f;
+    gObjectList[objectIndex].pos.z = -217.0f;
     set_obj_velocity(objectIndex, 0.0f, 0.0f, 0.0f);
     gObjectList[objectIndex].type = 0;
     gObjectList[objectIndex].unk_04C = 0;
@@ -3807,7 +3807,7 @@ void func_80083F18(s32 objectIndex) {
         case 0:
             break;
         case 1:
-            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.12f,
+            if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.12f,
                               gObjectList[objectIndex].unk_034, gObjectList[objectIndex].direction_angle[1],
                               0x00000064) != 0) {
                 object_next_state(objectIndex);
@@ -3832,12 +3832,12 @@ void func_80083FD0(s32 objectIndex, s32 arg1, s32 playerId) {
     object->activeTLUT = d_course_sherbet_land_ice;
     object->tlutList = d_course_sherbet_land_ice;
     object->sizeScaling = ((f32) random_int(0x01F4U) * 0.0002) + 0.04;
-    object->velocity[1] = ((f32) random_int(0x0032U) * 0.05) + 1.0;
+    object->velocity.y = ((f32) random_int(0x0032U) * 0.05) + 1.0;
     object->unk_034 = ((f32) random_int(0x000AU) * 0.1) + 1.0;
     object->direction_angle[1] = D_801657A2 * arg1;
-    object->origin_pos[0] = (sp20->pos[0] + random_int(0x0014U)) - 10.0f;
-    object->origin_pos[1] = (sp20->pos[1] - 10.0) + random_int(0x000AU);
-    object->origin_pos[2] = (sp20->pos[2] + random_int(0x0014U)) - 10.0f;
+    object->origin_pos[0] = (sp20->pos.x + random_int(0x0014U)) - 10.0f;
+    object->origin_pos[1] = (sp20->pos.y - 10.0) + random_int(0x000AU);
+    object->origin_pos[2] = (sp20->pos.z + random_int(0x0014U)) - 10.0f;
 }
 
 void func_8008421C(UNUSED s32 arg0, s32 playerId) {