mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-02-04 11:14:21 +00:00
Code Issues Projects Releases Wiki Activity

commit to naming things

Browse source
This commit is contained in:
Dragorn421 2022-06-16 18:37:04 +02:00
parent c45bc8ae7a
commit 6ee11e021b
No known key found for this signature in database
GPG key ID: 32B53D2D16FC4118
4 changed files with 121 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
include/z64scene.h
View file

@ -61,9 +61,9 @@ typedef struct {
// Mesh headers // Mesh headers
typedef enum { typedef enum {
/* 0 */ MESH_HEADER_TYPE_0, /* 0 */ MESH_HEADER_TYPE_ALL,
/* 1 */ MESH_HEADER_TYPE_1, /* 1 */ MESH_HEADER_TYPE_PRERENDER,
/* 2 */ MESH_HEADER_TYPE_2, /* 2 */ MESH_HEADER_TYPE_CULL,
/* 3 */ MESH_HEADER_TYPE_MAX /* 3 */ MESH_HEADER_TYPE_MAX
} MeshHeaderType; } MeshHeaderType;
@ -74,28 +74,28 @@ typedef struct {
typedef struct { typedef struct {
/* 0x00 */ Gfx* opa; /* 0x00 */ Gfx* opa;
/* 0x04 */ Gfx* xlu; /* 0x04 */ Gfx* xlu;
} MeshHeader01Entry; // size = 0x08 } MeshHeaderDListsEntry; // size = 0x08
typedef struct { typedef struct {
/* 0x00 */ MeshHeaderBase base; /* 0x00 */ MeshHeaderBase base;
/* 0x01 */ u8 numEntries; /* 0x01 */ u8 numEntries;
/* 0x04 */ MeshHeader01Entry* entries; /* 0x04 */ MeshHeaderDListsEntry* entries;
/* 0x08 */ MeshHeader01Entry* entriesEnd; /* 0x08 */ MeshHeaderDListsEntry* entriesEnd;
} MeshHeader0; // size = 0x0C } MeshHeaderAll; // size = 0x0C
typedef enum { typedef enum {
/* 1 */ MESH_HEADER1_FORMAT_SINGLE = 1, /* 1 */ MESH_HEADER_PRERENDER_FORMAT_SINGLE = 1,
/* 2 */ MESH_HEADER1_FORMAT_MULTI /* 2 */ MESH_HEADER_PRERENDER_FORMAT_MULTI
} MeshHeader1Format; } MeshHeaderPrerenderFormat;
typedef struct { typedef struct {
/* 0x00 */ MeshHeaderBase base; /* 0x00 */ MeshHeaderBase base;
/* 0x01 */ u8 format; // MeshHeader1Format /* 0x01 */ u8 format; // MeshHeaderPrerenderFormat
/* 0x04 */ MeshHeader01Entry* entry; /* 0x04 */ MeshHeaderDListsEntry* entry;
} MeshHeader1Base; // size = 0x08 } MeshHeaderPrerenderBase; // size = 0x08
typedef struct { typedef struct {
/* 0x00 */ MeshHeader1Base base; /* 0x00 */ MeshHeaderPrerenderBase base;
/* 0x08 */ void* source; /* 0x08 */ void* source;
/* 0x0C */ u32 unk_0C; /* 0x0C */ u32 unk_0C;
/* 0x10 */ void* tlut; /* 0x10 */ void* tlut;
@ -105,7 +105,7 @@ typedef struct {
/* 0x19 */ u8 siz; /* 0x19 */ u8 siz;
/* 0x1A */ u16 tlutMode; /* 0x1A */ u16 tlutMode;
/* 0x1C */ u16 tlutCount; /* 0x1C */ u16 tlutCount;
} MeshHeader1Single; // size = 0x20 } MeshHeaderPrerenderSingle; // size = 0x20
typedef struct { typedef struct {
/* 0x00 */ u16 unk_00; /* 0x00 */ u16 unk_00;
@ -122,41 +122,43 @@ typedef struct {
} BgImage; // size = 0x1C } BgImage; // size = 0x1C
typedef struct { typedef struct {
/* 0x00 */ MeshHeader1Base base; /* 0x00 */ MeshHeaderPrerenderBase base;
/* 0x08 */ u8 count; /* 0x08 */ u8 count;
/* 0x0C */ BgImage* list; /* 0x0C */ BgImage* list;
} MeshHeader1Multi; // size = 0x10 } MeshHeaderPrerenderMulti; // size = 0x10
typedef struct { typedef struct {
/* 0x00 */ Vec3s pos; /* 0x00 */ Vec3s pos;
/* 0x06 */ s16 radius; /* 0x06 */ s16 radius;
/* 0x08 */ Gfx* opa; /* 0x08 */ Gfx* opa;
/* 0x0C */ Gfx* xlu; /* 0x0C */ Gfx* xlu;
} MeshHeader2Entry; // size = 0x10 } MeshHeaderCullEntry; // size = 0x10
#define MESH_HEADER2_MAX_ENTRIES 64 #define MESH_HEADER_CULL_MAX_ENTRIES 64
typedef struct { typedef struct {
/* 0x00 */ MeshHeaderBase base; /* 0x00 */ MeshHeaderBase base;
/* 0x01 */ u8 numEntries; /* 0x01 */ u8 numEntries;
/* 0x04 */ MeshHeader2Entry* entries; /* 0x04 */ MeshHeaderCullEntry* entries;
/* 0x08 */ MeshHeader2Entry* entriesEnd; /* 0x08 */ MeshHeaderCullEntry* entriesEnd;
} MeshHeader2; // size = 0x0C } MeshHeaderCull; // size = 0x0C
typedef union { typedef union {
MeshHeaderBase base; MeshHeaderBase base;
MeshHeader0 meshHeader0; MeshHeaderAll all;
MeshHeader1Base meshHeader1Base; MeshHeaderPrerenderBase prerenderBase;
MeshHeader1Single meshHeader1Single; MeshHeaderPrerenderSingle prerenderSingle;
MeshHeader1Multi meshHeader1Multi; MeshHeaderPrerenderMulti prerenderMulti;
MeshHeader2 meshHeader2; MeshHeaderCull cull;
} MeshHeader; // "Ground Shape" } MeshHeader; // "Ground Shape"
// TODO update ZAPD // TODO update ZAPD
typedef MeshHeader01Entry PolygonDlist; typedef MeshHeaderDListsEntry PolygonDlist;
typedef MeshHeader0 PolygonType0; typedef MeshHeaderAll PolygonType0;
typedef MeshHeader2Entry PolygonDlist2; typedef MeshHeaderPrerenderSingle MeshHeader1Single;
typedef MeshHeader2 PolygonType2; typedef MeshHeaderPrerenderMulti MeshHeader1Multi;
typedef MeshHeaderCullEntry PolygonDlist2;
typedef MeshHeaderCull PolygonType2;
#define ROOM_DRAW_OPA (1 << 0) #define ROOM_DRAW_OPA (1 << 0)
#define ROOM_DRAW_XLU (1 << 1) #define ROOM_DRAW_XLU (1 << 1)

2
src/code/z_camera.c
View file

@ -6948,7 +6948,7 @@ void func_80057FC4(Camera* camera) {
if (camera != &camera->play->mainCamera) { if (camera != &camera->play->mainCamera) {
camera->prevSetting = camera->setting = CAM_SET_FREE0; camera->prevSetting = camera->setting = CAM_SET_FREE0;
camera->unk_14C &= ~0x4; camera->unk_14C &= ~0x4;
} else if (camera->play->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) { } else if (camera->play->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_PRERENDER) {
switch (camera->play->roomCtx.curRoom.behaviorType1) { switch (camera->play->roomCtx.curRoom.behaviorType1) {
case ROOM_BEHAVIOR_TYPE1_1: case ROOM_BEHAVIOR_TYPE1_1:
Camera_ChangeDoorCam(camera, NULL, -99, 0, 0, 18, 10); Camera_ChangeDoorCam(camera, NULL, -99, 0, 0, 18, 10);

2
src/code/z_play.c
View file

@ -1808,7 +1808,7 @@ void Play_TriggerRespawn(PlayState* this) {
} }
s32 func_800C0CB8(PlayState* this) { s32 func_800C0CB8(PlayState* this) {
return (this->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_1) && (YREG(15) != 0x20) && return (this->roomCtx.curRoom.meshHeader->base.type != MESH_HEADER_TYPE_PRERENDER) && (YREG(15) != 0x20) &&
(YREG(15) != 0x30) && (YREG(15) != 0x40) && (this->sceneNum != SCENE_HAIRAL_NIWA); (YREG(15) != 0x30) && (YREG(15) != 0x40) && (this->sceneNum != SCENE_HAIRAL_NIWA);
} }

170
src/code/z_room.c
View file

@ -1,9 +1,9 @@
#include "global.h" #include "global.h"
#include "vt.h" #include "vt.h"
void Room_Draw0(PlayState* play, Room* room, u32 flags); void Room_DrawAllMeshes(PlayState* play, Room* room, u32 flags);
void Room_Draw2(PlayState* play, Room* room, u32 flags); void Room_DrawCullMeshes(PlayState* play, Room* room, u32 flags);
void Room_Draw1(PlayState* play, Room* room, u32 flags); void Room_DrawPrerender(PlayState* play, Room* room, u32 flags);
Vec3f D_801270A0 = { 0.0f, 0.0f, 0.0f }; Vec3f D_801270A0 = { 0.0f, 0.0f, 0.0f };
@ -23,18 +23,18 @@ Gfx D_801270B0[] = {
}; };
void (*sRoomDrawHandlers[MESH_HEADER_TYPE_MAX])(PlayState* play, Room* room, u32 flags) = { void (*sRoomDrawHandlers[MESH_HEADER_TYPE_MAX])(PlayState* play, Room* room, u32 flags) = {
Room_Draw0, // MESH_HEADER_TYPE_0 Room_DrawAllMeshes, // MESH_HEADER_TYPE_ALL
Room_Draw1, // MESH_HEADER_TYPE_1 Room_DrawPrerender, // MESH_HEADER_TYPE_PRERENDER
Room_Draw2, // MESH_HEADER_TYPE_2 Room_DrawCullMeshes, // MESH_HEADER_TYPE_CULL
}; };
void func_80095AA0(PlayState* play, Room* room, Input* input, s32 arg3) { void func_80095AA0(PlayState* play, Room* room, Input* input, s32 arg3) {
} }
void Room_Draw0(PlayState* play, Room* room, u32 flags) { void Room_DrawAllMeshes(PlayState* play, Room* room, u32 flags) {
s32 i; s32 i;
MeshHeader0* meshHeader0; MeshHeaderAll* meshHeaderAll;
MeshHeader01Entry* meshHeader0Entry; MeshHeaderDListsEntry* dListsEntry;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 193); OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 193);
@ -52,47 +52,47 @@ void Room_Draw0(PlayState* play, Room* room, u32 flags) {
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
} }
meshHeader0 = &room->meshHeader->meshHeader0; meshHeaderAll = &room->meshHeader->all;
meshHeader0Entry = SEGMENTED_TO_VIRTUAL(meshHeader0->entries); dListsEntry = SEGMENTED_TO_VIRTUAL(meshHeaderAll->entries);
for (i = 0; i < meshHeader0->numEntries; i++) { for (i = 0; i < meshHeaderAll->numEntries; i++) {
if ((flags & ROOM_DRAW_OPA) && (meshHeader0Entry->opa != NULL)) { if ((flags & ROOM_DRAW_OPA) && (dListsEntry->opa != NULL)) {
gSPDisplayList(POLY_OPA_DISP++, meshHeader0Entry->opa); gSPDisplayList(POLY_OPA_DISP++, dListsEntry->opa);
} }
if ((flags & ROOM_DRAW_XLU) && (meshHeader0Entry->xlu != NULL)) { if ((flags & ROOM_DRAW_XLU) && (dListsEntry->xlu != NULL)) {
gSPDisplayList(POLY_XLU_DISP++, meshHeader0Entry->xlu); gSPDisplayList(POLY_XLU_DISP++, dListsEntry->xlu);
} }
meshHeader0Entry++; dListsEntry++;
} }
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 239); CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 239);
} }
typedef struct MeshHeader2EntryLinked { typedef struct MeshHeaderCullEntryLinked {
/* 0x00 */ MeshHeader2Entry* meshHeader2Entry; /* 0x00 */ MeshHeaderCullEntry* entry;
/* 0x04 */ f32 startZ; /* 0x04 */ f32 startZ;
/* 0x08 */ struct MeshHeader2EntryLinked* prev; /* 0x08 */ struct MeshHeaderCullEntryLinked* prev;
/* 0x0C */ struct MeshHeader2EntryLinked* next; /* 0x0C */ struct MeshHeaderCullEntryLinked* next;
} MeshHeader2EntryLinked; // size = 0x10 } MeshHeaderCullEntryLinked; // size = 0x10
void Room_Draw2(PlayState* play, Room* room, u32 flags) { void Room_DrawCullMeshes(PlayState* play, Room* room, u32 flags) {
MeshHeader2* meshHeader2; MeshHeaderCull* meshHeaderCull;
MeshHeader2Entry* meshHeader2Entry; MeshHeaderCullEntry* meshHeaderCullEntry;
MeshHeader2EntryLinked linkedEntriesBuffer[MESH_HEADER2_MAX_ENTRIES]; MeshHeaderCullEntryLinked linkedEntriesBuffer[MESH_HEADER_CULL_MAX_ENTRIES];
MeshHeader2EntryLinked* head = NULL; MeshHeaderCullEntryLinked* head = NULL;
MeshHeader2EntryLinked* tail = NULL; MeshHeaderCullEntryLinked* tail = NULL;
MeshHeader2EntryLinked* iter; MeshHeaderCullEntryLinked* iter;
s32 pad; s32 pad;
MeshHeader2EntryLinked* insert; MeshHeaderCullEntryLinked* insert;
s32 j; s32 j;
s32 i; s32 i;
Vec3f pos; Vec3f pos;
Vec3f projectedPos; Vec3f projectedPos;
f32 projectedW; f32 projectedW;
s32 pad2; s32 pad2;
MeshHeader2Entry* meshHeader2Entries; MeshHeaderCullEntry* meshHeaderCullEntries;
MeshHeader2Entry* meshHeader2EntryIter; MeshHeaderCullEntry* meshHeaderCullEntryIter;
f32 entryStartZ; f32 entryStartZ;
OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 287); OPEN_DISPS(play->state.gfxCtx, "../z_room.c", 287);
@ -113,35 +113,35 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
} }
meshHeader2 = &room->meshHeader->meshHeader2; meshHeaderCull = &room->meshHeader->cull;
meshHeader2Entry = SEGMENTED_TO_VIRTUAL(meshHeader2->entries); meshHeaderCullEntry = SEGMENTED_TO_VIRTUAL(meshHeaderCull->entries);
insert = linkedEntriesBuffer; insert = linkedEntriesBuffer;
ASSERT(meshHeader2->numEntries <= ARRAY_COUNT(linkedEntriesBuffer), "polygon2->num <= SHAPE_SORT_MAX", ASSERT(meshHeaderCull->numEntries <= ARRAY_COUNT(linkedEntriesBuffer), "polygon2->num <= SHAPE_SORT_MAX",
"../z_room.c", 317); "../z_room.c", 317);
meshHeader2Entries = meshHeader2Entry; meshHeaderCullEntries = meshHeaderCullEntry;
// Pick and sort entries by depth // Pick and sort entries by depth
for (i = 0; i < meshHeader2->numEntries; i++, meshHeader2Entry++) { for (i = 0; i < meshHeaderCull->numEntries; i++, meshHeaderCullEntry++) {
// Project the entry position, to get the depth it is at. // Project the entry position, to get the depth it is at.
pos.x = meshHeader2Entry->pos.x; pos.x = meshHeaderCullEntry->pos.x;
pos.y = meshHeader2Entry->pos.y; pos.y = meshHeaderCullEntry->pos.y;
pos.z = meshHeader2Entry->pos.z; pos.z = meshHeaderCullEntry->pos.z;
SkinMatrix_Vec3fMtxFMultXYZW(&play->viewProjectionMtxF, &pos, &projectedPos, &projectedW); SkinMatrix_Vec3fMtxFMultXYZW(&play->viewProjectionMtxF, &pos, &projectedPos, &projectedW);
// If the entry isn't fully before the rendered depth range // If the entry isn't fully before the rendered depth range
if (-(f32)meshHeader2Entry->radius < projectedPos.z) { if (-(f32)meshHeaderCullEntry->radius < projectedPos.z) {
// Compute the depth at which this entry starts // Compute the depth at which this entry starts
entryStartZ = projectedPos.z - meshHeader2Entry->radius; entryStartZ = projectedPos.z - meshHeaderCullEntry->radius;
// If the entry isn't fully after the rendered depth range // If the entry isn't fully after the rendered depth range
if (entryStartZ < play->lightCtx.fogFar) { if (entryStartZ < play->lightCtx.fogFar) {
// This entry will be rendered // This entry will be rendered
insert->meshHeader2Entry = meshHeader2Entry; insert->entry = meshHeaderCullEntry;
insert->startZ = entryStartZ; insert->startZ = entryStartZ;
// Insert into the linked list, ordered by ascending start depth // Insert into the linked list, ordered by ascending start depth
@ -179,21 +179,22 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
} }
} }
R_MESH2_NUM_ALL_ENTRIES = meshHeader2->numEntries & 0xFFFF & 0xFFFF & 0xFFFF; // if this is real then I might not be // if this is real then I might not be
R_MESH2_NUM_ALL_ENTRIES = meshHeaderCull->numEntries & 0xFFFF & 0xFFFF & 0xFFFF;
// Draw entries, from nearest to furthest // Draw entries, from nearest to furthest
for (i = 1; head != NULL; head = head->next, i++) { for (i = 1; head != NULL; head = head->next, i++) {
Gfx* displayList; Gfx* displayList;
meshHeader2Entry = head->meshHeader2Entry; meshHeaderCullEntry = head->entry;
if (R_MESH2_DEBUG_MODE != 0) { if (R_MESH2_DEBUG_MODE != 0) {
// Debug mode drawing // Debug mode drawing
// This loop does nothing // This loop does nothing
meshHeader2EntryIter = meshHeader2Entries; meshHeaderCullEntryIter = meshHeaderCullEntries;
for (j = 0; j < meshHeader2->numEntries; j++, meshHeader2EntryIter++) { for (j = 0; j < meshHeaderCull->numEntries; j++, meshHeaderCullEntryIter++) {
if (meshHeader2Entry == meshHeader2EntryIter) { if (meshHeaderCullEntry == meshHeaderCullEntryIter) {
break; break;
} }
} }
@ -201,14 +202,14 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
if (((R_MESH2_DEBUG_MODE == 1) && (R_MESH2_DEBUG_DRAW_TARGET >= i)) || if (((R_MESH2_DEBUG_MODE == 1) && (R_MESH2_DEBUG_DRAW_TARGET >= i)) ||
((R_MESH2_DEBUG_MODE == 2) && (R_MESH2_DEBUG_DRAW_TARGET == i))) { ((R_MESH2_DEBUG_MODE == 2) && (R_MESH2_DEBUG_DRAW_TARGET == i))) {
if (flags & ROOM_DRAW_OPA) { if (flags & ROOM_DRAW_OPA) {
displayList = meshHeader2Entry->opa; displayList = meshHeaderCullEntry->opa;
if (displayList != NULL) { if (displayList != NULL) {
gSPDisplayList(POLY_OPA_DISP++, displayList); gSPDisplayList(POLY_OPA_DISP++, displayList);
} }
} }
if (flags & ROOM_DRAW_XLU) { if (flags & ROOM_DRAW_XLU) {
displayList = meshHeader2Entry->xlu; displayList = meshHeaderCullEntry->xlu;
if (displayList != NULL) { if (displayList != NULL) {
gSPDisplayList(POLY_XLU_DISP++, displayList); gSPDisplayList(POLY_XLU_DISP++, displayList);
} }
@ -216,14 +217,14 @@ void Room_Draw2(PlayState* play, Room* room, u32 flags) {
} }
} else { } else {
if (flags & ROOM_DRAW_OPA) { if (flags & ROOM_DRAW_OPA) {
displayList = meshHeader2Entry->opa; displayList = meshHeaderCullEntry->opa;
if (displayList != NULL) { if (displayList != NULL) {
gSPDisplayList(POLY_OPA_DISP++, displayList); gSPDisplayList(POLY_OPA_DISP++, displayList);
} }
} }
if (flags & ROOM_DRAW_XLU) { if (flags & ROOM_DRAW_XLU) {
displayList = meshHeader2Entry->xlu; displayList = meshHeaderCullEntry->xlu;
if (displayList != NULL) { if (displayList != NULL) {
gSPDisplayList(POLY_XLU_DISP++, displayList); gSPDisplayList(POLY_XLU_DISP++, displayList);
} }
@ -332,11 +333,11 @@ void Room_DrawBackground2D(Gfx** gfxP, void* tex, void* tlut, u16 width, u16 hei
*gfxP = gfx; *gfxP = gfx;
} }
void Room_Draw1Single(PlayState* play, Room* room, u32 flags) { void Room_DrawPrerenderSingle(PlayState* play, Room* room, u32 flags) {
Camera* activeCam; Camera* activeCam;
Gfx* gfx; Gfx* gfx;
MeshHeader1Single* meshHeader1Single; MeshHeaderPrerenderSingle* meshHeaderPrerenderSingle;
MeshHeader01Entry* meshHeader1Entry; MeshHeaderDListsEntry* dListsEntry;
u32 isFixedCamera; u32 isFixedCamera;
u32 drawBg; u32 drawBg;
u32 drawOpa; u32 drawOpa;
@ -346,11 +347,11 @@ void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
activeCam = GET_ACTIVE_CAM(play); activeCam = GET_ACTIVE_CAM(play);
isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED); isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
meshHeader1Single = &room->meshHeader->meshHeader1Single; meshHeaderPrerenderSingle = &room->meshHeader->prerenderSingle;
meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Single->base.entry); dListsEntry = SEGMENTED_TO_VIRTUAL(meshHeaderPrerenderSingle->base.entry);
drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && (meshHeader1Single->source != NULL) && !(SREG(25) & 1); drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && (meshHeaderPrerenderSingle->source != NULL) && !(SREG(25) & 1);
drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2); drawOpa = (flags & ROOM_DRAW_OPA) && (dListsEntry->opa != NULL) && !(SREG(25) & 2);
drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4); drawXlu = (flags & ROOM_DRAW_XLU) && (dListsEntry->xlu != NULL) && !(SREG(25) & 4);
if (drawOpa || drawBg) { if (drawOpa || drawBg) {
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment); gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
@ -358,7 +359,7 @@ void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
if (drawOpa) { if (drawOpa) {
Gfx_SetupDL_25Opa(play->state.gfxCtx); Gfx_SetupDL_25Opa(play->state.gfxCtx);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa); gSPDisplayList(POLY_OPA_DISP++, dListsEntry->opa);
} }
if (drawBg) { if (drawBg) {
@ -369,9 +370,10 @@ void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
gfx = POLY_OPA_DISP; gfx = POLY_OPA_DISP;
Camera_GetSkyboxOffset(&offset, activeCam); Camera_GetSkyboxOffset(&offset, activeCam);
Room_DrawBackground2D(&gfx, meshHeader1Single->source, meshHeader1Single->tlut, Room_DrawBackground2D(&gfx, meshHeaderPrerenderSingle->source, meshHeaderPrerenderSingle->tlut,
meshHeader1Single->width, meshHeader1Single->height, meshHeader1Single->fmt, meshHeaderPrerenderSingle->width, meshHeaderPrerenderSingle->height,
meshHeader1Single->siz, meshHeader1Single->tlutMode, meshHeader1Single->tlutCount, meshHeaderPrerenderSingle->fmt, meshHeaderPrerenderSingle->siz,
meshHeaderPrerenderSingle->tlutMode, meshHeaderPrerenderSingle->tlutCount,
(offset.x + offset.z) * 1.2f + offset.y * 0.6f, (offset.x + offset.z) * 1.2f + offset.y * 0.6f,
offset.y * 2.4f + (offset.x + offset.z) * 0.3f); offset.y * 2.4f + (offset.x + offset.z) * 0.3f);
POLY_OPA_DISP = gfx; POLY_OPA_DISP = gfx;
@ -385,13 +387,13 @@ void Room_Draw1Single(PlayState* play, Room* room, u32 flags) {
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment); gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
Gfx_SetupDL_25Xlu(play->state.gfxCtx); Gfx_SetupDL_25Xlu(play->state.gfxCtx);
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu); gSPDisplayList(POLY_XLU_DISP++, dListsEntry->xlu);
} }
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 691); CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 691);
} }
BgImage* Room_GetMultiBackgroundImage(MeshHeader1Multi* meshHeader1Multi, PlayState* play) { BgImage* Room_GetMultiBackgroundImage(MeshHeaderPrerenderMulti* meshHeaderPrerenderMulti, PlayState* play) {
Camera* activeCam = GET_ACTIVE_CAM(play); Camera* activeCam = GET_ACTIVE_CAM(play);
s32 index; s32 index;
s16 newIndex; s16 newIndex;
@ -408,8 +410,8 @@ BgImage* Room_GetMultiBackgroundImage(MeshHeader1Multi* meshHeader1Multi, PlaySt
player = GET_PLAYER(play); player = GET_PLAYER(play);
player->actor.params = (player->actor.params & 0xFF00) | index; player->actor.params = (player->actor.params & 0xFF00) | index;
bgImage = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->list); bgImage = SEGMENTED_TO_VIRTUAL(meshHeaderPrerenderMulti->list);
for (i = 0; i < meshHeader1Multi->count; i++) { for (i = 0; i < meshHeaderPrerenderMulti->count; i++) {
if (bgImage->index == index) { if (bgImage->index == index) {
return bgImage; return bgImage;
} }
@ -423,12 +425,12 @@ BgImage* Room_GetMultiBackgroundImage(MeshHeader1Multi* meshHeader1Multi, PlaySt
return NULL; return NULL;
} }
void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) { void Room_DrawPrerenderMulti(PlayState* play, Room* room, u32 flags) {
Camera* activeCam; Camera* activeCam;
Gfx* gfx; Gfx* gfx;
MeshHeader1Multi* meshHeader1Multi; MeshHeaderPrerenderMulti* meshHeaderPrerenderMulti;
BgImage* bgImage; BgImage* bgImage;
MeshHeader01Entry* meshHeader1Entry; MeshHeaderDListsEntry* dListsEntry;
u32 isFixedCamera; u32 isFixedCamera;
u32 drawBg; u32 drawBg;
u32 drawOpa; u32 drawOpa;
@ -438,14 +440,14 @@ void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
activeCam = GET_ACTIVE_CAM(play); activeCam = GET_ACTIVE_CAM(play);
isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED); isFixedCamera = (activeCam->setting == CAM_SET_PREREND_FIXED);
meshHeader1Multi = &room->meshHeader->meshHeader1Multi; meshHeaderPrerenderMulti = &room->meshHeader->prerenderMulti;
meshHeader1Entry = SEGMENTED_TO_VIRTUAL(meshHeader1Multi->base.entry); dListsEntry = SEGMENTED_TO_VIRTUAL(meshHeaderPrerenderMulti->base.entry);
bgImage = Room_GetMultiBackgroundImage(meshHeader1Multi, play); bgImage = Room_GetMultiBackgroundImage(meshHeaderPrerenderMulti, play);
drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && (bgImage->source != NULL) && !(SREG(25) & 1); drawBg = (flags & ROOM_DRAW_OPA) && isFixedCamera && (bgImage->source != NULL) && !(SREG(25) & 1);
drawOpa = (flags & ROOM_DRAW_OPA) && (meshHeader1Entry->opa != NULL) && !(SREG(25) & 2); drawOpa = (flags & ROOM_DRAW_OPA) && (dListsEntry->opa != NULL) && !(SREG(25) & 2);
drawXlu = (flags & ROOM_DRAW_XLU) && (meshHeader1Entry->xlu != NULL) && !(SREG(25) & 4); drawXlu = (flags & ROOM_DRAW_XLU) && (dListsEntry->xlu != NULL) && !(SREG(25) & 4);
if (drawOpa || drawBg) { if (drawOpa || drawBg) {
gSPSegment(POLY_OPA_DISP++, 0x03, room->segment); gSPSegment(POLY_OPA_DISP++, 0x03, room->segment);
@ -453,7 +455,7 @@ void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
if (drawOpa) { if (drawOpa) {
Gfx_SetupDL_25Opa(play->state.gfxCtx); Gfx_SetupDL_25Opa(play->state.gfxCtx);
gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_OPA_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_OPA_DISP++, meshHeader1Entry->opa); gSPDisplayList(POLY_OPA_DISP++, dListsEntry->opa);
} }
if (drawBg) { if (drawBg) {
@ -479,19 +481,19 @@ void Room_Draw1Multi(PlayState* play, Room* room, u32 flags) {
gSPSegment(POLY_XLU_DISP++, 0x03, room->segment); gSPSegment(POLY_XLU_DISP++, 0x03, room->segment);
Gfx_SetupDL_25Xlu(play->state.gfxCtx); Gfx_SetupDL_25Xlu(play->state.gfxCtx);
gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD); gSPMatrix(POLY_XLU_DISP++, &gMtxClear, G_MTX_MODELVIEW | G_MTX_LOAD);
gSPDisplayList(POLY_XLU_DISP++, meshHeader1Entry->xlu); gSPDisplayList(POLY_XLU_DISP++, dListsEntry->xlu);
} }
CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 819); CLOSE_DISPS(play->state.gfxCtx, "../z_room.c", 819);
} }
void Room_Draw1(PlayState* play, Room* room, u32 flags) { void Room_DrawPrerender(PlayState* play, Room* room, u32 flags) {
MeshHeader1Base* meshHeader1Base = &room->meshHeader->meshHeader1Base; MeshHeaderPrerenderBase* meshHeaderPrerenderBase = &room->meshHeader->prerenderBase;
if (meshHeader1Base->format == MESH_HEADER1_FORMAT_SINGLE) { if (meshHeaderPrerenderBase->format == MESH_HEADER_PRERENDER_FORMAT_SINGLE) {
Room_Draw1Single(play, room, flags); Room_DrawPrerenderSingle(play, room, flags);
} else if (meshHeader1Base->format == MESH_HEADER1_FORMAT_MULTI) { } else if (meshHeaderPrerenderBase->format == MESH_HEADER_PRERENDER_FORMAT_MULTI) {
Room_Draw1Multi(play, room, flags); Room_DrawPrerenderMulti(play, room, flags);
} else { } else {
LogUtils_HungupThread("../z_room.c", 841); LogUtils_HungupThread("../z_room.c", 841);
} }