Doc pass on scene & room headers (#1240)

* Doc pass on scene & room headers

* Remove comments on room draw handlers

* `struct ActorEntry` -> `ActorEntry`

4 files changed, 122 insertions, 128 deletions

diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index 542574364..6f9face0d 100644
--- a/src/code/z_camera.c
+++ b/src/code/z_camera.c
@@ -6948,7 +6948,7 @@ void func_80057FC4(Camera* camera) {
     if (camera != &camera->play->mainCamera) {
         camera->prevSetting = camera->setting = CAM_SET_FREE0;
         camera->unk_14C &= ~0x4;
-    } else if (camera->play->roomCtx.curRoom.meshHeader->base.type != 1) {
+    } else if (camera->play->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) {
         switch (camera->play->roomCtx.curRoom.behaviorType1) {
             case ROOM_BEHAVIOR_TYPE1_1:
                 Camera_ChangeDoorCam(camera, NULL, -99, 0, 0, 18, 10);
diff --git a/src/code/z_play.c b/src/code/z_play.c
index ae65bcc5f..adc59ebc4 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -1197,7 +1197,7 @@ void Play_Draw(PlayState* this) {
                 POLY_OPA_DISP = sp84;
                 goto Play_Draw_DrawOverlayElements;
             } else {
-                s32 sp80;
+                s32 roomDrawFlags;
 
                 if ((HREG(80) != 10) || (HREG(83) != 0)) {
                     if (this->skyboxId && (this->skyboxId != SKYBOX_UNSET_1D) && !this->envCtx.skyboxDisabled) {
@@ -1236,13 +1236,13 @@ void Play_Draw(PlayState* this) {
                 if ((HREG(80) != 10) || (HREG(84) != 0)) {
                     if (VREG(94) == 0) {
                         if (HREG(80) != 10) {
-                            sp80 = 3;
+                            roomDrawFlags = ROOM_DRAW_OPA | ROOM_DRAW_XLU;
                         } else {
-                            sp80 = HREG(84);
+                            roomDrawFlags = HREG(84);
                         }
                         Scene_Draw(this);
-                        Room_Draw(this, &this->roomCtx.curRoom, sp80 & 3);
-                        Room_Draw(this, &this->roomCtx.prevRoom, sp80 & 3);
+                        Room_Draw(this, &this->roomCtx.curRoom, roomDrawFlags & (ROOM_DRAW_OPA | ROOM_DRAW_XLU));
+                        Room_Draw(this, &this->roomCtx.prevRoom, roomDrawFlags & (ROOM_DRAW_OPA | ROOM_DRAW_XLU));
                     }
                 }
 
@@ -1808,8 +1808,8 @@ void Play_TriggerRespawn(PlayState* this) {
 }
 
 s32 func_800C0CB8(PlayState* this) {
-    return (this->roomCtx.curRoom.meshHeader->base.type != 1) && (YREG(15) != 0x20) && (YREG(15) != 0x30) &&
-           (YREG(15) != 0x40) && (this->sceneNum != SCENE_HAIRAL_NIWA);
+    return (this->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) && (YREG(15) != 0x20) &&
+           (YREG(15) != 0x30) && (YREG(15) != 0x40) && (this->sceneNum != SCENE_HAIRAL_NIWA);
 }
 
 s32 FrameAdvance_IsEnabled(PlayState* this) {
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 92bcbc1c0..5cd56d40d 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -1,9 +1,9 @@
 #include "global.h"
 #include "vt.h"
 
-void func_80095AB4(PlayState* play, Room* room, u32 flags);
-void func_80095D04(PlayState* play, Room* room, u32 flags);
-void func_80096F6C(PlayState* play, Room* room, u32 flags);
+void Room_Draw0(PlayState* play, Room* room, u32 flags);
+void Room_Draw2(PlayState* play, Room* room, u32 flags);
+void Room_Draw1(PlayState* play, Room* room, u32 flags);
 
 Vec3f D_801270A0 = { 0.0f, 0.0f, 0.0f };
 
@@ -22,49 +22,48 @@ Gfx D_801270B0[] = {
     gsSPEndDisplayList(),
 };
 
-void (*sRoomDrawHandlers[])(PlayState* play, Room* room, u32 flags) = {
-    func_80095AB4,
-    func_80096F6C,
-    func_80095D04,
+void (*sRoomDrawHandlers[MESH_HEADER_TYPE_MAX])(PlayState* play, Room* room, u32 flags) = {
+    Room_Draw0,
+    Room_Draw1,
+    Room_Draw2,
 };
 
 void func_80095AA0(PlayState* play, Room* room, Input* arg2, UNK_TYPE arg3) {
 }
 
-// Room Draw Polygon Type 0
-void func_80095AB4(PlayState* play, Room* room, u32 flags) {
+void Room_Draw0(PlayState* play, Room* room, u32 flags) {
     s32 i;
-    PolygonType0* polygon0;
-    PolygonDlist* polygonDlist;
+    MeshHeader0* meshHeader0;
+    MeshHeader01Entry* meshHeader0Entry;
 
     OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 193);
 
-    if (flags & 1) {
+    if (flags & ROOM_DRAW_OPA) {
         func_800342EC(&D_801270A0, play);
         gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
         func_80093C80(play);
         gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
-    if (flags & 2) {
+    if (flags & ROOM_DRAW_XLU) {
         func_8003435C(&D_801270A0, play);
         gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
         Gfx_SetupDL_25Xlu(play->state.gfxCtx);
         gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
-    polygon0 = &room->meshHeader->polygon0;
-    polygonDlist = SEGMENTED_TO_VIRTUAL(polygon0->start);
-    for (i = 0; i < polygon0->num; i++) {
-        if ((flags & 1) && (polygonDlist->opa != NULL)) {
-            gSPDisplayList(POLY_OPA_DISP++, polygonDlist->opa);
+    meshHeader0 = &room->meshHeader->meshHeader0;
+    meshHeader0Entry = SEGMENTED_TO_VIRTUAL(meshHeader0->entries);
+    for (i = 0; i < meshHeader0->numEntries; i++) {
+        if ((flags & ROOM_DRAW_OPA) && (meshHeader0Entry->opa != NULL)) {
+            gSPDisplayList(POLY_OPA_DISP++, meshHeader0Entry->opa);
         }
 
-        if ((flags & 2) && (polygonDlist->xlu != NULL)) {
-            gSPDisplayList(POLY_XLU_DISP++, polygonDlist->xlu);
+        if ((flags & ROOM_DRAW_XLU) && (meshHeader0Entry->xlu != NULL)) {
+            gSPDisplayList(POLY_XLU_DISP++, meshHeader0Entry->xlu);
         }
 
-        polygonDlist++;
+        meshHeader0Entry++;
     }
 
     CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 239);
@@ -73,16 +72,15 @@ void func_80095AB4(PlayState* play, Room* room, u32 flags) {
 #define SHAPE_SORT_MAX 64
 
 typedef struct struct_80095D04 {
-    /* 0x00 */ PolygonDlist2* unk_00;
+    /* 0x00 */ MeshHeader2Entry* unk_00;
     /* 0x04 */ f32 unk_04;
     /* 0x08 */ struct struct_80095D04* unk_08;
     /* 0x0C */ struct struct_80095D04* unk_0C;
 } struct_80095D04; // size = 0x10
 
-// Room Draw Polygon Type 2
-void func_80095D04(PlayState* play, Room* room, u32 flags) {
-    PolygonType2* polygon2;
-    PolygonDlist2* polygonDlist;
+void Room_Draw2(PlayState* play, Room* room, u32 flags) {
+    MeshHeader2* meshHeader2;
+    MeshHeader2Entry* meshHeader2Entry;
     struct_80095D04 spB8[SHAPE_SORT_MAX];
     struct_80095D04* spB4 = NULL;
     struct_80095D04* spB0 = NULL;
@@ -95,41 +93,41 @@ void func_80095D04(PlayState* play, Room* room, u32 flags) {
     Vec3f projectedPos;
     f32 projectedW;
     s32 pad2;
-    PolygonDlist2* polygonDlistFirst;
-    PolygonDlist2* polygonDlistIter;
+    MeshHeader2Entry* meshHeader2Entries;
+    MeshHeader2Entry* meshHeader2EntryIter;
     f32 temp_f2;
 
     OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 287);
-    if (flags & 1) {
+    if (flags & ROOM_DRAW_OPA) {
         func_800342EC(&D_801270A0, play);
         gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
         func_80093C80(play);
         gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
     if (1) {}
-    if (flags & 2) {
+    if (flags & ROOM_DRAW_XLU) {
         func_8003435C(&D_801270A0, play);
         gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
         Gfx_SetupDL_25Xlu(play->state.gfxCtx);
         gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
     }
 
-    polygon2 = &room->meshHeader->polygon2;
-    polygonDlist = SEGMENTED_TO_VIRTUAL(polygon2->start);
+    meshHeader2 = &room->meshHeader->meshHeader2;
+    meshHeader2Entry = SEGMENTED_TO_VIRTUAL(meshHeader2->entries);
     spA4 = spB8;
 
-    ASSERT(polygon2->num <= SHAPE_SORT_MAX, "polygon2->num <= SHAPE_SORT_MAX", "../z_room.c", 317);
-    polygonDlistFirst = polygonDlist;
+    ASSERT(meshHeader2->numEntries <= SHAPE_SORT_MAX, "polygon2->num <= SHAPE_SORT_MAX", "../z_room.c", 317);
+    meshHeader2Entries = meshHeader2Entry;
 
-    for (i = 0; i < polygon2->num; i++, polygonDlist++) {
-        pos.x = polygonDlist->pos.x;
-        pos.y = polygonDlist->pos.y;
-        pos.z = polygonDlist->pos.z;
+    for (i = 0; i < meshHeader2->numEntries; i++, meshHeader2Entry++) {
+        pos.x = meshHeader2Entry->pos.x;
+        pos.y = meshHeader2Entry->pos.y;
+        pos.z = meshHeader2Entry->pos.z;
         SkinMatrix_Vec3fMtxFMultXYZW(&play->viewProjectionMtxF, &pos, &projectedPos, &projectedW);
-        if (-(f32)polygonDlist->unk_06 < projectedPos.z) {
-            temp_f2 = projectedPos.z - polygonDlist->unk_06;
+        if (-(f32)meshHeader2Entry->unk_06 < projectedPos.z) {
+            temp_f2 = projectedPos.z - meshHeader2Entry->unk_06;
             if (temp_f2 < play->lightCtx.fogFar) {
-                spA4->unk_00 = polygonDlist;
+                spA4->unk_00 = meshHeader2Entry;
                 spA4->unk_04 = temp_f2;
                 iter = spB4;
                 if (iter == NULL) {
@@ -164,45 +162,45 @@ void func_80095D04(PlayState* play, Room* room, u32 flags) {
         }
     }
 
-    iREG(87) = polygon2->num & 0xFFFF & 0xFFFF & 0xFFFF; // if this is real then I might not be
+    iREG(87) = meshHeader2->numEntries & 0xFFFF & 0xFFFF & 0xFFFF; // if this is real then I might not be
 
     for (i = 1; spB4 != NULL; spB4 = spB4->unk_0C, i++) {
         Gfx* displayList;
 
-        polygonDlist = spB4->unk_00;
+        meshHeader2Entry = spB4->unk_00;
         if (iREG(86) != 0) {
-            polygonDlistIter = polygonDlistFirst;
-            for (j = 0; j < polygon2->num; j++, polygonDlistIter++) {
-                if (polygonDlist == polygonDlistIter) {
+            meshHeader2EntryIter = meshHeader2Entries;
+            for (j = 0; j < meshHeader2->numEntries; j++, meshHeader2EntryIter++) {
+                if (meshHeader2Entry == meshHeader2EntryIter) {
                     break; // This loop does nothing?
                 }
             }
 
             if (((iREG(86) == 1) && (iREG(89) >= i)) || ((iREG(86) == 2) && (iREG(89) == i))) {
-                if (flags & 1) {
-                    displayList = polygonDlist->opa;
+                if (flags & ROOM_DRAW_OPA) {
+                    displayList = meshHeader2Entry->opa;
                     if (displayList != NULL) {
                         gSPDisplayList(POLY_OPA_DISP++, displayList);
                     }
                 }
 
-                if (flags & 2) {
-                    displayList = polygonDlist->xlu;
+                if (flags & ROOM_DRAW_XLU) {
+                    displayList = meshHeader2Entry->xlu;
                     if (displayList != NULL) {
                         gSPDisplayList(POLY_XLU_DISP++, displayList);
                     }
                 }
             }
         } else {
-            if (flags & 1) {
-                displayList = polygonDlist->opa;
+            if (flags & ROOM_DRAW_OPA) {
+                displayList = meshHeader2Entry->opa;
                 if (displayList != NULL) {
                     gSPDisplayList(POLY_OPA_DISP++, displayList);
                 }
             }
 
-            if (flags & 2) {
-                displayList = polygonDlist->xlu;
+            if (flags & ROOM_DRAW_XLU) {
+                displayList = meshHeader2Entry->xlu;
                 if (displayList != NULL) {
                     gSPDisplayList(POLY_XLU_DISP++, displayList);
                 }
@@ -305,12 +303,11 @@ void func_8009638C(Gfx** displayList, void* source, void* tlut, u16 width, u16 h
     *displayList = displayListHead;
 }
 
-// Room Draw Polygon Type 1 - Single Format
-void func_80096680(PlayState* play, Room* room, u32 flags) {
+void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
     Camera* activeCam;
     Gfx* spA8;
-    PolygonType1* polygon1;
-    PolygonDlist* polygonDlist;
+    MeshHeader1Single* meshHeader1Single;
+    MeshHeader01Entry* meshHeader1Entry;
     u32 isFixedCamera;
     u32 drawBg;
     u32 drawOpa;
@@ -320,11 +317,11 @@ void func_80096680(PlayState* play, Room* room, u32 flags) {
 
     activeCam = GET_ACTIVE_CAM(play);
     isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
-    polygon1 = &room->meshHeader->polygon1;
-    polygonDlist = SEGMENTED_TO_VIRTUAL(polygon1->dlist);
-    drawBg = (flags & 1) && isFixedCamera && polygon1->single.source && !(SREG(25) & 1);
-    drawOpa = (flags & 1) && (polygonDlist->opa != NULL) && !(SREG(25) & 2);
-    drawXlu = (flags & 2) && (polygonDlist->xlu != NULL) && !(SREG(25) & 4);
+    meshHeader1Single = &room->meshHeader->meshHeader1Single;
+    meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Single->base.entry);
+    drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && meshHeader1Single->source && !(SREG(25) & 1);
+    drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2);
+    drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4);
 
     if (drawOpa || drawBg) {
         gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
@@ -332,7 +329,7 @@ void func_80096680(PlayState* play, Room* room, u32 flags) {
         if (drawOpa) {
             Gfx_SetupDL_25Opa(play->state.gfxCtx);
             gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
-            gSPDisplayList(POLY_OPA_DISP++, polygonDlist->opa);
+            gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa);
         }
 
         if (drawBg) {
@@ -342,9 +339,9 @@ void func_80096680(PlayState* play, Room* room, u32 flags) {
                 Vec3f sp60;
                 spA8 = POLY_OPA_DISP;
                 Camera_GetSkyboxOffset(&sp60, activeCam);
-                func_8009638C(&spA8, polygon1->single.source, polygon1->single.tlut, polygon1->single.width,
-                              polygon1->single.height, polygon1->single.fmt, polygon1->single.siz,
-                              polygon1->single.mode0, polygon1->single.tlutCount,
+                func_8009638C(&spA8, meshHeader1Single->source, meshHeader1Single->tlut, meshHeader1Single->width,
+                              meshHeader1Single->height, meshHeader1Single->fmt, meshHeader1Single->siz,
+                              meshHeader1Single->mode0, meshHeader1Single->tlutCount,
                               (sp60.x + sp60.z) * 1.2f + sp60.y * 0.6f, sp60.y * 2.4f + (sp60.x + sp60.z) * 0.3f);
                 POLY_OPA_DISP = spA8;
             }
@@ -357,13 +354,13 @@ void func_80096680(PlayState* play, Room* room, u32 flags) {
         gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
         Gfx_SetupDL_25Xlu(play->state.gfxCtx);
         gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
-        gSPDisplayList(POLY_XLU_DISP++, polygonDlist->xlu);
+        gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu);
     }
 
     CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 691);
 }
 
-BgImage* func_80096A74(PolygonType1* polygon1, PlayState* play) {
+BgImage* func_80096A74(MeshHeader1Multi* meshHeader1Multi, PlayState* play) {
     Camera* activeCam = GET_ACTIVE_CAM(play);
     s32 camDataIdx;
     s16 camDataIdx2;
@@ -381,8 +378,8 @@ BgImage* func_80096A74(PolygonType1* polygon1, PlayState* play) {
     player = GET_PLAYER(play);
     player->actor.params = (player->actor.params & 0xFF00) | camDataIdx;
 
-    bgImage = SEGMENTED_TO_VIRTUAL(polygon1->multi.list);
-    for (i = 0; i < polygon1->multi.count; i++) {
+    bgImage = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->list);
+    for (i = 0; i < meshHeader1Multi->count; i++) {
         if (bgImage->id == camDataIdx) {
             return bgImage;
         }
@@ -396,13 +393,12 @@ BgImage* func_80096A74(PolygonType1* polygon1, PlayState* play) {
     return NULL;
 }
 
-// Room Draw Polygon Type 1 - Multi Format
-void func_80096B6C(PlayState* play, Room* room, u32 flags) {
+void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
     Camera* activeCam;
     Gfx* gfx;
-    PolygonType1* polygon1;
+    MeshHeader1Multi* meshHeader1Multi;
     BgImage* bgImage;
-    PolygonDlist* polygonDlist;
+    MeshHeader01Entry* meshHeader1Entry;
     u32 isFixedCamera;
     u32 drawBg;
     u32 drawOpa;
@@ -412,12 +408,12 @@ void func_80096B6C(PlayState* play, Room* room, u32 flags) {
 
     activeCam = GET_ACTIVE_CAM(play);
     isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
-    polygon1 = &room->meshHeader->polygon1;
-    polygonDlist = SEGMENTED_TO_VIRTUAL(polygon1->dlist);
-    bgImage = func_80096A74(polygon1, play);
-    drawBg = (flags & 1) && isFixedCamera && bgImage->source && !(SREG(25) & 1);
-    drawOpa = (flags & 1) && (polygonDlist->opa != NULL) && !(SREG(25) & 2);
-    drawXlu = (flags & 2) && (polygonDlist->xlu != NULL) && !(SREG(25) & 4);
+    meshHeader1Multi = &room->meshHeader->meshHeader1Multi;
+    meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->base.entry);
+    bgImage = func_80096A74(meshHeader1Multi, play);
+    drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && bgImage->source && !(SREG(25) & 1);
+    drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2);
+    drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4);
 
     if (drawOpa || drawBg) {
         gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
@@ -425,7 +421,7 @@ void func_80096B6C(PlayState* play, Room* room, u32 flags) {
         if (drawOpa) {
             Gfx_SetupDL_25Opa(play->state.gfxCtx);
             gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
-            gSPDisplayList(POLY_OPA_DISP++, polygonDlist->opa);
+            gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa);
         }
 
         if (drawBg) {
@@ -451,20 +447,19 @@ void func_80096B6C(PlayState* play, Room* room, u32 flags) {
         gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
         Gfx_SetupDL_25Xlu(play->state.gfxCtx);
         gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
-        gSPDisplayList(POLY_XLU_DISP++, polygonDlist->xlu);
+        gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu);
     }
 
     CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 819);
 }
 
-// Room Draw Polygon Type 1
-void func_80096F6C(PlayState* play, Room* room, u32 flags) {
-    PolygonType1* polygon1 = &room->meshHeader->polygon1;
+void Room_Draw1(PlayState* play, Room* room, u32 flags) {
+    MeshHeader1Base* meshHeader1Base = &room->meshHeader->meshHeader1Base;
 
-    if (polygon1->format == 1) {
-        func_80096680(play, room, flags);
-    } else if (polygon1->format == 2) {
-        func_80096B6C(play, room, flags);
+    if (meshHeader1Base->format == MESH_HEADER1_FORMAT_SINGLE) {
+        Room_Draw1Single(play, room, flags);
+    } else if (meshHeader1Base->format == MESH_HEADER1_FORMAT_MULTI) {
+        Room_Draw1Multi(play, room, flags);
     } else {
         LogUtils_HungupThread("../z_room.c", 841);
     }
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index 8c63346c5..01e4b9a59 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -184,7 +184,7 @@ s32 Scene_ExecuteCommands(PlayState* play, SceneCmd* sceneCmd) {
 
 void Scene_CommandSpawnList(PlayState* play, SceneCmd* cmd) {
     ActorEntry* linkEntry = play->linkActorEntry =
-        (ActorEntry*)SEGMENTED_TO_VIRTUAL(cmd->spawnList.segment) + play->setupEntranceList[play->curSpawn].spawn;
+        (ActorEntry*)SEGMENTED_TO_VIRTUAL(cmd->spawnList.data) + play->setupEntranceList[play->curSpawn].spawn;
     s16 linkObjectId;
 
     play->linkAgeOnLoad = ((void)0, gSaveContext.linkAge);
@@ -196,8 +196,8 @@ void Scene_CommandSpawnList(PlayState* play, SceneCmd* cmd) {
 }
 
 void Scene_CommandActorList(PlayState* play, SceneCmd* cmd) {
-    play->numSetupActors = cmd->actorList.num;
-    play->setupActorList = SEGMENTED_TO_VIRTUAL(cmd->actorList.segment);
+    play->numSetupActors = cmd->actorList.length;
+    play->setupActorList = SEGMENTED_TO_VIRTUAL(cmd->actorList.data);
 }
 
 void Scene_CommandUnused2(PlayState* play, SceneCmd* cmd) {
@@ -205,7 +205,7 @@ void Scene_CommandUnused2(PlayState* play, SceneCmd* cmd) {
 }
 
 void Scene_CommandCollisionHeader(PlayState* play, SceneCmd* cmd) {
-    CollisionHeader* colHeader = SEGMENTED_TO_VIRTUAL(cmd->colHeader.segment);
+    CollisionHeader* colHeader = SEGMENTED_TO_VIRTUAL(cmd->colHeader.data);
 
     colHeader->vtxList = SEGMENTED_TO_VIRTUAL(colHeader->vtxList);
     colHeader->polyList = SEGMENTED_TO_VIRTUAL(colHeader->polyList);
@@ -217,12 +217,12 @@ void Scene_CommandCollisionHeader(PlayState* play, SceneCmd* cmd) {
 }
 
 void Scene_CommandRoomList(PlayState* play, SceneCmd* cmd) {
-    play->numRooms = cmd->roomList.num;
-    play->roomList = SEGMENTED_TO_VIRTUAL(cmd->roomList.segment);
+    play->numRooms = cmd->roomList.length;
+    play->roomList = SEGMENTED_TO_VIRTUAL(cmd->roomList.data);
 }
 
 void Scene_CommandEntranceList(PlayState* play, SceneCmd* cmd) {
-    play->setupEntranceList = SEGMENTED_TO_VIRTUAL(cmd->entranceList.segment);
+    play->setupEntranceList = SEGMENTED_TO_VIRTUAL(cmd->entranceList.data);
 }
 
 void Scene_CommandSpecialFiles(PlayState* play, SceneCmd* cmd) {
@@ -244,7 +244,7 @@ void Scene_CommandRoomBehavior(PlayState* play, SceneCmd* cmd) {
 }
 
 void Scene_CommandMeshHeader(PlayState* play, SceneCmd* cmd) {
-    play->roomCtx.curRoom.meshHeader = SEGMENTED_TO_VIRTUAL(cmd->mesh.segment);
+    play->roomCtx.curRoom.meshHeader = SEGMENTED_TO_VIRTUAL(cmd->mesh.data);
 }
 
 void Scene_CommandObjectList(PlayState* play, SceneCmd* cmd) {
@@ -254,7 +254,7 @@ void Scene_CommandObjectList(PlayState* play, SceneCmd* cmd) {
     ObjectStatus* status;
     ObjectStatus* status2;
     ObjectStatus* firstStatus;
-    s16* objectEntry = SEGMENTED_TO_VIRTUAL(cmd->objectList.segment);
+    s16* objectEntry = SEGMENTED_TO_VIRTUAL(cmd->objectList.data);
     void* nextPtr;
 
     k = 0;
@@ -281,10 +281,10 @@ void Scene_CommandObjectList(PlayState* play, SceneCmd* cmd) {
         status++;
     }
 
-    ASSERT(cmd->objectList.num <= OBJECT_EXCHANGE_BANK_MAX, "scene_info->object_bank.num <= OBJECT_EXCHANGE_BANK_MAX",
-           "../z_scene.c", 705);
+    ASSERT(cmd->objectList.length <= OBJECT_EXCHANGE_BANK_MAX,
+           "scene_info->object_bank.num <= OBJECT_EXCHANGE_BANK_MAX", "../z_scene.c", 705);
 
-    while (k < cmd->objectList.num) {
+    while (k < cmd->objectList.length) {
         nextPtr = func_800982FC(&play->objectCtx, i, *objectEntry);
         if (i < OBJECT_EXCHANGE_BANK_MAX - 1) {
             firstStatus[i + 1].segment = nextPtr;
@@ -299,21 +299,21 @@ void Scene_CommandObjectList(PlayState* play, SceneCmd* cmd) {
 
 void Scene_CommandLightList(PlayState* play, SceneCmd* cmd) {
     s32 i;
-    LightInfo* lightInfo = SEGMENTED_TO_VIRTUAL(cmd->lightList.segment);
+    LightInfo* lightInfo = SEGMENTED_TO_VIRTUAL(cmd->lightList.data);
 
-    for (i = 0; i < cmd->lightList.num; i++) {
+    for (i = 0; i < cmd->lightList.length; i++) {
         LightContext_InsertLight(play, &play->lightCtx, lightInfo);
         lightInfo++;
     }
 }
 
 void Scene_CommandPathList(PlayState* play, SceneCmd* cmd) {
-    play->setupPathList = SEGMENTED_TO_VIRTUAL(cmd->pathList.segment);
+    play->setupPathList = SEGMENTED_TO_VIRTUAL(cmd->pathList.data);
 }
 
 void Scene_CommandTransitionActorList(PlayState* play, SceneCmd* cmd) {
-    play->transiActorCtx.numActors = cmd->transiActorList.num;
-    play->transiActorCtx.list = SEGMENTED_TO_VIRTUAL(cmd->transiActorList.segment);
+    play->transiActorCtx.numActors = cmd->transiActorList.length;
+    play->transiActorCtx.list = SEGMENTED_TO_VIRTUAL(cmd->transiActorList.data);
 }
 
 void TransitionActor_InitContext(GameState* state, TransitionActorContext* transiActorCtx) {
@@ -321,19 +321,19 @@ void TransitionActor_InitContext(GameState* state, TransitionActorContext* trans
 }
 
 void Scene_CommandLightSettingsList(PlayState* play, SceneCmd* cmd) {
-    play->envCtx.numLightSettings = cmd->lightSettingList.num;
-    play->envCtx.lightSettingsList = SEGMENTED_TO_VIRTUAL(cmd->lightSettingList.segment);
+    play->envCtx.numLightSettings = cmd->lightSettingList.length;
+    play->envCtx.lightSettingsList = SEGMENTED_TO_VIRTUAL(cmd->lightSettingList.data);
 }
 
 void Scene_CommandSkyboxSettings(PlayState* play, SceneCmd* cmd) {
     play->skyboxId = cmd->skyboxSettings.skyboxId;
-    play->envCtx.skyboxConfig = play->envCtx.changeSkyboxNextConfig = cmd->skyboxSettings.unk_05;
-    play->envCtx.lightMode = cmd->skyboxSettings.unk_06;
+    play->envCtx.skyboxConfig = play->envCtx.changeSkyboxNextConfig = cmd->skyboxSettings.skyboxConfig;
+    play->envCtx.lightMode = cmd->skyboxSettings.envLightMode;
 }
 
 void Scene_CommandSkyboxDisables(PlayState* play, SceneCmd* cmd) {
-    play->envCtx.skyboxDisabled = cmd->skyboxDisables.unk_04;
-    play->envCtx.sunMoonDisabled = cmd->skyboxDisables.unk_05;
+    play->envCtx.skyboxDisabled = cmd->skyboxDisables.skyboxDisabled;
+    play->envCtx.sunMoonDisabled = cmd->skyboxDisables.sunMoonDisabled;
 }
 
 void Scene_CommandTimeSettings(PlayState* play, SceneCmd* cmd) {
@@ -342,8 +342,8 @@ void Scene_CommandTimeSettings(PlayState* play, SceneCmd* cmd) {
             ((cmd->timeSettings.hour + (cmd->timeSettings.min / 60.0f)) * 60.0f) / ((f32)(24 * 60) / 0x10000);
     }
 
-    if (cmd->timeSettings.unk_06 != 0xFF) {
-        play->envCtx.sceneTimeSpeed = cmd->timeSettings.unk_06;
+    if (cmd->timeSettings.timeSpeed != 0xFF) {
+        play->envCtx.sceneTimeSpeed = cmd->timeSettings.timeSpeed;
     } else {
         play->envCtx.sceneTimeSpeed = 0;
     }
@@ -386,7 +386,7 @@ void Scene_CommandWindSettings(PlayState* play, SceneCmd* cmd) {
 }
 
 void Scene_CommandExitList(PlayState* play, SceneCmd* cmd) {
-    play->setupExitList = SEGMENTED_TO_VIRTUAL(cmd->exitList.segment);
+    play->setupExitList = SEGMENTED_TO_VIRTUAL(cmd->exitList.data);
 }
 
 void Scene_CommandUndefined9(PlayState* play, SceneCmd* cmd) {
@@ -414,7 +414,7 @@ void Scene_CommandAlternateHeaderList(PlayState* play, SceneCmd* cmd) {
     osSyncPrintf("\n[ZU]sceneset counter=[%X]", ((void)0, gSaveContext.sceneSetupIndex));
 
     if (gSaveContext.sceneSetupIndex != 0) {
-        altHeader = ((SceneCmd**)SEGMENTED_TO_VIRTUAL(cmd->altHeaders.segment))[gSaveContext.sceneSetupIndex - 1];
+        altHeader = ((SceneCmd**)SEGMENTED_TO_VIRTUAL(cmd->altHeaders.data))[gSaveContext.sceneSetupIndex - 1];
 
         if (1) {}
 
@@ -426,8 +426,7 @@ void Scene_CommandAlternateHeaderList(PlayState* play, SceneCmd* cmd) {
             osSyncPrintf("\nげぼはっ！ 指定されたデータがないでええっす！");
 
             if (gSaveContext.sceneSetupIndex == 3) {
-                altHeader =
-                    ((SceneCmd**)SEGMENTED_TO_VIRTUAL(cmd->altHeaders.segment))[gSaveContext.sceneSetupIndex - 2];
+                altHeader = ((SceneCmd**)SEGMENTED_TO_VIRTUAL(cmd->altHeaders.data))[gSaveContext.sceneSetupIndex - 2];
 
                 // "Using adult day data there!"
                 osSyncPrintf("\nそこで、大人の昼データを使用するでええっす！！");
@@ -443,7 +442,7 @@ void Scene_CommandAlternateHeaderList(PlayState* play, SceneCmd* cmd) {
 
 void Scene_CommandCutsceneData(PlayState* play, SceneCmd* cmd) {
     osSyncPrintf("\ngame_play->demo_play.data=[%x]", play->csCtx.segment);
-    play->csCtx.segment = SEGMENTED_TO_VIRTUAL(cmd->cutsceneData.segment);
+    play->csCtx.segment = SEGMENTED_TO_VIRTUAL(cmd->cutsceneData.data);
 }
 
 // Camera & World Map Area