diff --git a/include/z64.h b/include/z64.h
index 67b2b19f84..1d139f6ca2 100644
--- a/include/z64.h
+++ b/include/z64.h
@@ -840,80 +840,6 @@ typedef struct {
     /* 0x000C */ ObjectStatus status[OBJECT_EXCHANGE_BANK_MAX];
 } ObjectContext; // size = 0x518
 
-typedef struct {
-    /* 0x00 */ Gfx* opa;
-    /* 0x04 */ Gfx* xlu;
-} PolygonDlist; // size = 0x8
-
-typedef struct {
-    /* 0x00 */ u8    type;
-} PolygonBase;
-
-typedef struct {
-    /* 0x00 */ PolygonBase base;
-    /* 0x01 */ u8    num; // number of dlist entries
-    /* 0x04 */ void* start;
-    /* 0x08 */ void* end;
-} PolygonType0; // size = 0xC
-
-typedef struct {
-    /* 0x00 */ u16   unk_00;
-    /* 0x02 */ u8    id;
-    /* 0x04 */ u32   source;
-    /* 0x08 */ u32   unk_0C;
-    /* 0x0C */ u32   tlut;
-    /* 0x10 */ u16   width;
-    /* 0x12 */ u16   height;
-    /* 0x14 */ u8    fmt;
-    /* 0x15 */ u8    siz;
-    /* 0x16 */ u16   mode0;
-    /* 0x18 */ u16   tlutCount;
-} BgImage; // size = 0x1C
-
-typedef struct {
-    /* 0x00 */ PolygonBase base;
-    /* 0x01 */ u8    format; // 1 = single, 2 = multi
-    /* 0x04 */ Gfx*  dlist;
-    union {
-        struct {
-            /* 0x08 */ void* source;
-            /* 0x0C */ u32   unk_0C;
-            /* 0x10 */ void* tlut;
-            /* 0x14 */ u16   width;
-            /* 0x16 */ u16   height;
-            /* 0x18 */ u8    fmt;
-            /* 0x19 */ u8    siz;
-            /* 0x1A */ u16   mode0;
-            /* 0x1C */ u16   tlutCount;
-        } single;
-        struct {
-            /* 0x08 */ u8    count;
-            /* 0x0C */ BgImage* list;
-        } multi;
-    };
-} PolygonType1;
-
-typedef struct {
-    /* 0x00 */ Vec3s pos;
-    /* 0x06 */ s16   unk_06;
-    /* 0x08 */ Gfx*  opa;
-    /* 0x0C */ Gfx*  xlu;
-} PolygonDlist2; // size = 0x8
-
-typedef struct {
-    /* 0x00 */ PolygonBase base;
-    /* 0x01 */ u8    num; // number of dlist entries
-    /* 0x04 */ void* start;
-    /* 0x08 */ void* end;
-} PolygonType2; // size = 0xC
-
-typedef union {
-    PolygonBase  base;
-    PolygonType0 polygon0;
-    PolygonType1 polygon1;
-    PolygonType2 polygon2;
-} MeshHeader; // "Ground Shape"
-
 typedef enum {
     /* 0 */ LENS_MODE_HIDE_ACTORS, // lens actors are visible by default, and hidden by using lens (for example, fake walls)
     /* 1 */ LENS_MODE_SHOW_ACTORS // lens actors are invisible by default, and shown by using lens (for example, invisible enemies)
@@ -1097,29 +1023,6 @@ typedef struct {
     /* 0x24C */ s32   (*isDone)(void* transition);
 } TransitionContext; // size = 0x250
 
-typedef struct {
-    /* 0x00 */ s16   id;
-    /* 0x02 */ Vec3s pos;
-    /* 0x08 */ Vec3s rot;
-    /* 0x0E */ s16   params;
-} ActorEntry; // size = 0x10
-
-typedef struct {
-    struct {
-        s8 room;    // Room to switch to
-        s8 effects; // How the camera reacts during the transition
-    } /* 0x00 */ sides[2]; // 0 = front, 1 = back
-    /* 0x04 */ s16   id;
-    /* 0x06 */ Vec3s pos;
-    /* 0x0C */ s16   rotY;
-    /* 0x0E */ s16   params;
-} TransitionActorEntry; // size = 0x10
-
-typedef struct {
-    /* 0x00 */ u8 spawn;
-    /* 0x01 */ u8 room;
-} EntranceEntry;
-
 typedef struct {
     /* 0x00 */ u8* readBuff;
 } SramContext; // size = 0x4
diff --git a/include/z64scene.h b/include/z64scene.h
index 98691db6cd..c6900d483f 100644
--- a/include/z64scene.h
+++ b/include/z64scene.h
@@ -1,6 +1,8 @@
 #ifndef Z64SCENE_H
 #define Z64SCENE_H
 
+#include "z64.h"
+
 #include "command_macros_base.h"
 
 typedef struct {
@@ -17,6 +19,148 @@ typedef struct {
     /* 0x13 */ u8  unk_13;
 } SceneTableEntry; // size = 0x14
 
+typedef struct {
+    /* 0x00 */ s16   id;
+    /* 0x02 */ Vec3s pos;
+    /* 0x08 */ Vec3s rot;
+    /* 0x0E */ s16   params;
+} ActorEntry; // size = 0x10
+
+typedef struct {
+    struct {
+        s8 room;    // Room to switch to
+        s8 effects; // How the camera reacts during the transition
+    } /* 0x00 */ sides[2]; // 0 = front, 1 = back
+    /* 0x04 */ s16   id;
+    /* 0x06 */ Vec3s pos;
+    /* 0x0C */ s16   rotY;
+    /* 0x0E */ s16   params;
+} TransitionActorEntry; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ u8 spawn;
+    /* 0x01 */ u8 room;
+} EntranceEntry;
+
+typedef struct {
+    /* 0x00 */ u8 ambientColor[3];
+    /* 0x03 */ s8 diffuseDir1[3];
+    /* 0x06 */ u8 diffuseColor1[3];
+    /* 0x09 */ s8 diffuseDir2[3];
+    /* 0x0C */ u8 diffuseColor2[3];
+    /* 0x0F */ u8 fogColor[3];
+    /* 0x12 */ u16 fogNear;
+    /* 0x14 */ u16 fogFar;
+} LightSettings; // size = 0x16
+
+typedef struct {
+    /* 0x00 */ u8 count; // number of points in the path
+    /* 0x04 */ Vec3s* points; // Segment Address to the array of points
+} Path; // size = 0x8
+
+// Mesh headers
+
+typedef enum {
+    /* 0 */ MESH_HEADER_TYPE_0,
+    /* 1 */ MESH_HEADER_TYPE_1,
+    /* 2 */ MESH_HEADER_TYPE_2,
+    /* 3 */ MESH_HEADER_TYPE_MAX
+} MeshHeaderType;
+
+typedef struct {
+    /* 0x00 */ u8 type;
+} MeshHeaderBase; // size = 0x01
+
+typedef struct {
+    /* 0x00 */ Gfx* opa;
+    /* 0x04 */ Gfx* xlu;
+} MeshHeader01Entry; // size = 0x08
+
+typedef struct {
+    /* 0x00 */ MeshHeaderBase base;
+    /* 0x01 */ u8 numEntries;
+    /* 0x04 */ MeshHeader01Entry* entries;
+    /* 0x08 */ MeshHeader01Entry* entriesEnd;
+} MeshHeader0; // size = 0x0C
+
+typedef enum {
+    /* 1 */ MESH_HEADER1_FORMAT_SINGLE = 1,
+    /* 2 */ MESH_HEADER1_FORMAT_MULTI
+} MeshHeader1Format;
+
+typedef struct {
+    /* 0x00 */ MeshHeaderBase base;
+    /* 0x01 */ u8    format; // MeshHeader1Format
+    /* 0x04 */ MeshHeader01Entry* entry;
+} MeshHeader1Base; // size = 0x08
+
+typedef struct {
+    /* 0x00 */ MeshHeader1Base base;
+    /* 0x08 */ void* source;
+    /* 0x0C */ u32   unk_0C;
+    /* 0x10 */ void* tlut;
+    /* 0x14 */ u16   width;
+    /* 0x16 */ u16   height;
+    /* 0x18 */ u8    fmt;
+    /* 0x19 */ u8    siz;
+    /* 0x1A */ u16   mode0;
+    /* 0x1C */ u16   tlutCount;
+} MeshHeader1Single; // size = 0x20
+
+typedef struct {
+    /* 0x00 */ u16   unk_00;
+    /* 0x02 */ u8    id;
+    /* 0x04 */ u32   source;
+    /* 0x08 */ u32   unk_0C;
+    /* 0x0C */ u32   tlut;
+    /* 0x10 */ u16   width;
+    /* 0x12 */ u16   height;
+    /* 0x14 */ u8    fmt;
+    /* 0x15 */ u8    siz;
+    /* 0x16 */ u16   mode0;
+    /* 0x18 */ u16   tlutCount;
+} BgImage; // size = 0x1C
+
+typedef struct {
+    /* 0x00 */ MeshHeader1Base base;
+    /* 0x08 */ u8    count;
+    /* 0x0C */ BgImage* list;
+} MeshHeader1Multi; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ Vec3s pos;
+    /* 0x06 */ s16 unk_06;
+    /* 0x08 */ Gfx* opa;
+    /* 0x0C */ Gfx* xlu;
+} MeshHeader2Entry; // size = 0x10
+
+typedef struct {
+    /* 0x00 */ MeshHeaderBase base;
+    /* 0x01 */ u8 numEntries;
+    /* 0x04 */ MeshHeader2Entry* entries;
+    /* 0x08 */ MeshHeader2Entry* entriesEnd;
+} MeshHeader2; // size = 0x0C
+
+typedef union {
+    MeshHeaderBase base;
+    MeshHeader0 meshHeader0;
+    MeshHeader1Base meshHeader1Base;
+    MeshHeader1Single meshHeader1Single;
+    MeshHeader1Multi meshHeader1Multi;
+    MeshHeader2 meshHeader2;
+} MeshHeader; // "Ground Shape"
+
+// TODO update ZAPD
+typedef MeshHeader01Entry PolygonDlist;
+typedef MeshHeader0 PolygonType0;
+typedef MeshHeader2Entry PolygonDlist2;
+typedef MeshHeader2 PolygonType2;
+
+#define ROOM_DRAW_OPA (1 << 0)
+#define ROOM_DRAW_XLU (1 << 1)
+
+// Scene commands
+
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
@@ -25,14 +169,14 @@ typedef struct {
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ ActorEntry* data;
 } SCmdSpawnList;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ ActorEntry* data;
 } SCmdActorList;
 
 typedef struct {
@@ -44,13 +188,13 @@ typedef struct {
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ CollisionHeader* data;
 } SCmdColHeader;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ RomFile* data;
 } SCmdRoomList;
 
 typedef struct {
@@ -66,7 +210,7 @@ typedef struct {
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ EntranceEntry* data;
 } SCmdEntranceList;
 
 typedef struct {
@@ -84,37 +228,37 @@ typedef struct {
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ MeshHeaderBase* data;
 } SCmdMesh;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ s16* data;
 } SCmdObjectList;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ LightInfo* data;
 } SCmdLightList;
 
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ Path* data;
 } SCmdPathList;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ TransitionActorEntry* data;
 } SCmdTransiActorList;
 
 typedef struct {
     /* 0x00 */ u8  code;
-    /* 0x01 */ u8  num;
-    /* 0x04 */ void* segment;
+    /* 0x01 */ u8  length;
+    /* 0x04 */ EnvLightSettings* data;
 } SCmdLightSettingList;
 
 typedef struct {
@@ -123,7 +267,7 @@ typedef struct {
     /* 0x02 */ char pad[2];
     /* 0x04 */ u8  hour;
     /* 0x05 */ u8  min;
-    /* 0x06 */ u8  unk_06;
+    /* 0x06 */ u8  timeSpeed;
 } SCmdTimeSettings;
 
 typedef struct {
@@ -131,16 +275,16 @@ typedef struct {
     /* 0x01 */ u8  data1;
     /* 0x02 */ char pad[2];
     /* 0x04 */ u8  skyboxId;
-    /* 0x05 */ u8  unk_05;
-    /* 0x06 */ u8  unk_06;
+    /* 0x05 */ u8  skyboxConfig;
+    /* 0x06 */ u8  envLightMode;
 } SCmdSkyboxSettings;
 
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
     /* 0x02 */ char pad[2];
-    /* 0x04 */ u8  unk_04;
-    /* 0x05 */ u8  unk_05;
+    /* 0x04 */ u8  skyboxDisabled;
+    /* 0x05 */ u8  sunMoonDisabled;
 } SCmdSkyboxDisables;
 
 typedef struct {
@@ -152,7 +296,7 @@ typedef struct {
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ s16* data;
 } SCmdExitList;
 
 typedef struct {
@@ -173,13 +317,13 @@ typedef struct {
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ void* data;
 } SCmdCutsceneData;
 
 typedef struct {
     /* 0x00 */ u8  code;
     /* 0x01 */ u8  data1;
-    /* 0x04 */ void* segment;
+    /* 0x04 */ void* data;
 } SCmdAltHeaders;
 
 typedef struct {
@@ -188,91 +332,6 @@ typedef struct {
     /* 0x04 */ u32 area;
 } SCmdMiscSettings;
 
-typedef struct {
-    u8 headerType;
-} MeshHeaderBase;
-
-typedef struct {
-    MeshHeaderBase base;
-    u8 numEntries;
-    Gfx* dListStart;
-    Gfx* dListEnd;
-} MeshHeader0;
-
-typedef struct {
-    Gfx* opaqueDList;
-    Gfx* translucentDList;
-} MeshEntry0;
-
-typedef struct {
-    MeshHeaderBase base;
-    u8 format;
-    u32 entryRecord;
-} MeshHeader1Base;
-
-typedef struct {
-    MeshHeader1Base base;
-    void* imagePtr; // 0x08
-    u32 unknown; // 0x0C
-    u32 unknown2; // 0x10
-    u16 bgWidth; // 0x14
-    u16 bgHeight; // 0x16
-    u8 imageFormat; // 0x18
-    u8 imageSize; // 0x19
-    u16 imagePal; // 0x1A
-    u16 imageFlip; // 0x1C
-} MeshHeader1Single;
-
-typedef struct {
-    MeshHeader1Base base;
-    u8 bgCnt;
-    void* bgRecordPtr;
-} MeshHeader1Multi;
-
-typedef struct {
-    u16 unknown; // 0x00
-    s8 bgID; // 0x02
-    void* imagePtr; // 0x04
-    u32 unknown2; // 0x08
-    u32 unknown3; // 0x0C
-    u16 bgWidth; // 0x10
-    u16 bgHeight; // 0x12
-    u8 imageFmt; // 0x14
-    u8 imageSize; // 0x15
-    u16 imagePal; // 0x16
-    u16 imageFlip; // 0x18
-} BackgroundRecord;
-
-typedef struct {
-    s16 playerXMax, playerZMax;
-    s16 playerXMin, playerZMin;
-    Gfx* opaqueDList;
-    Gfx* translucentDList;
-} MeshEntry2;
-
-typedef struct {
-    MeshHeaderBase base;
-    u8 numEntries;
-    Gfx* dListStart;
-    Gfx* dListEnd;
-} MeshHeader2;
-
-typedef struct {
-    /* 0x00 */ u8 ambientColor[3];
-    /* 0x03 */ s8 diffuseDir1[3];
-    /* 0x06 */ u8 diffuseColor1[3];
-    /* 0x09 */ s8 diffuseDir2[3];
-    /* 0x0C */ u8 diffuseColor2[3];
-    /* 0x0F */ u8 fogColor[3];
-    /* 0x12 */ u16 fogNear;
-    /* 0x14 */ u16 fogFar;
-} LightSettings; // size = 0x16
-
-typedef struct {
-    /* 0x00 */ u8 count; // number of points in the path
-    /* 0x04 */ Vec3s* points; // Segment Address to the array of points
-} Path; // size = 0x8
-
 typedef union {
     SCmdBase              base;
     SCmdSpawnList         spawnList;
@@ -475,11 +534,11 @@ typedef enum {
 #define SCENE_CMD_ENV_LIGHT_SETTINGS(numLightSettings, lightSettingsList) \
     { SCENE_CMD_ID_LIGHT_SETTINGS_LIST, numLightSettings, CMD_PTR(lightSettingsList) }
 
-#define SCENE_CMD_TIME_SETTINGS(hour, min, speed) \
-    { SCENE_CMD_ID_TIME_SETTINGS, 0, CMD_BBBB(hour, min, speed, 0) }
+#define SCENE_CMD_TIME_SETTINGS(hour, min, timeSpeed) \
+    { SCENE_CMD_ID_TIME_SETTINGS, 0, CMD_BBBB(hour, min, timeSpeed, 0) }
 
-#define SCENE_CMD_SKYBOX_SETTINGS(skyboxId, weather, isIndoors) \
-    { SCENE_CMD_ID_SKYBOX_SETTINGS, 0, CMD_BBBB(skyboxId, weather, isIndoors, 0) }
+#define SCENE_CMD_SKYBOX_SETTINGS(skyboxId, skyboxConfig, envLightMode) \
+    { SCENE_CMD_ID_SKYBOX_SETTINGS, 0, CMD_BBBB(skyboxId, skyboxConfig, envLightMode, 0) }
 
 #define SCENE_CMD_SKYBOX_DISABLES(disableSky, disableSunMoon) \
     { SCENE_CMD_ID_SKYBOX_DISABLES, 0, CMD_BBBB(disableSky, disableSunMoon, 0, 0) }
diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index 5425743640..6f9face0d8 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 ae65bcc5f7..adc59ebc4a 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 92bcbc1c04..5cd56d40d0 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 8c63346c5e..01e4b9a594 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