print_n_panic/Microtransactions64
0
0
Fork 0
mirror of https://github.com/Print-and-Panic/Microtransactions64.git synced 2026-01-21 10:17:19 -08:00
Code Issues Packages Projects Releases Wiki Activity

Remove OBJECTS_REJ and clean up core render func (By Fazana) (#735)

Browse Source 
* crowd pleaser

* Fix debug boxes

* fix comments

* renamed temp graphics head to be consistent

---------

Co-authored-by: Fazana <52551480+FazanaJ@users.noreply.github.com>
This commit is contained in:
arthurtilly
2023-12-16 02:48:32 +13:00
committed by GitHub
parent 76dae5e8dd
commit 9fc928ed70
11 changed files with 75 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/config/config_safeguards.h
View File

@@ -49,26 +49,6 @@
#undef BETTER_REVERB
#endif
/*****************
* config_graphics.h
*/
#ifndef F3DEX_GBI_2
#undef OBJECTS_REJ // OBJECTS_REJ requires f3dex2.
#endif // !F3DEX_GBI_2
#ifndef F3DEX_GBI_SHARED
#undef OBJECTS_REJ // Non F3DEX-based ucodes do NOT support ucode switching.
#endif // !F3DEX_GBI_SHARED
#ifdef OBJECTS_REJ
// Enable required ucodes.
#define F3DEX2_REJ_GBI
#define F3DLX2_REJ_GBI
#endif // OBJECTS_REJ
/*****************
* config_debug.h
*/

2
include/object_constants.h
View File

@@ -49,8 +49,6 @@ enum ObjFlags {
OBJ_FLAG_PERSISTENT_RESPAWN = (1 << 14), // 0x00004000
OBJ_FLAG_VELOCITY_PLATFORM = (1 << 15), // 0x00008000
OBJ_FLAG_DONT_CALC_COLL_DIST = (1 << 16), // 0x00010000
OBJ_FLAG_UCODE_SMALL = (1 << 17), // 0x00020000
OBJ_FLAG_UCODE_LARGE = (1 << 18), // 0x00040000
OBJ_FLAG_SILHOUETTE = (1 << 19), // 0x00080000
OBJ_FLAG_OCCLUDE_SILHOUETTE = (1 << 20), // 0x00100000
OBJ_FLAG_OPACITY_FROM_CAMERA_DIST = (1 << 21), // 0x00200000

3
include/types.h
View File

@@ -248,9 +248,6 @@ struct GraphNodeObject {
/*0x4C*/ struct SpawnInfo *spawnInfo;
/*0x50*/ Mat4 *throwMatrix; // matrix ptr
/*0x54*/ Vec3f cameraToObject;
#ifdef OBJECTS_REJ
u16 ucode;
#endif
};
struct ObjectNode {

13
src/engine/behavior_script.c
View File

@@ -50,11 +50,6 @@ void obj_update_gfx_pos_and_angle(struct Object *obj) {
#define OBJ_OPACITY_LENGTH 512.0f
void obj_set_opacity_from_cam_dist(struct Object *obj) {
s32 opacityDist = ((-obj->header.gfx.cameraToObject[2] - OBJ_OPACITY_NEAR) * (256.0f / OBJ_OPACITY_LENGTH));
#ifdef OBJECTS_REJ
if (opacityDist > 0) {
obj->header.gfx.ucode = GRAPH_NODE_UCODE_REJ;
}
#endif
obj->oOpacity = CLAMP(opacityDist, 0x00, 0xFF);
}
#undef OBJ_OPACITY_NEAR
@@ -910,14 +905,6 @@ void cur_obj_update(void) {
COND_BIT((objFlags & OBJ_FLAG_OCCLUDE_SILHOUETTE), o->header.gfx.node.flags, GRAPH_RENDER_OCCLUDE_SILHOUETTE);
#endif
#ifdef OBJECTS_REJ
if ((objFlags & OBJ_FLAG_SILHOUETTE) || (objFlags & OBJ_FLAG_UCODE_SMALL)) {
o->header.gfx.ucode = GRAPH_NODE_UCODE_REJ;
} else {
o->header.gfx.ucode = GRAPH_NODE_UCODE_DEFAULT;
}
#endif
#ifdef OBJ_OPACITY_BY_CAM_DIST
if (objFlags & OBJ_FLAG_OPACITY_FROM_CAMERA_DIST) {
obj_set_opacity_from_cam_dist(o);

13
src/engine/graph_node.h
View File

@@ -9,15 +9,6 @@
#include "geo_commands.h"
#include "game/memory.h"
// UCode indices for listHeads & listTails
enum GraphNodeUCodes {
GRAPH_NODE_UCODE_DEFAULT,
#ifdef OBJECTS_REJ
GRAPH_NODE_UCODE_REJ,
#endif
GRAPH_NODE_NUM_UCODES,
};
enum GraphRenderFlags {
GRAPH_RENDER_ACTIVE = (1 << 0), // 0x0001
GRAPH_RENDER_CHILDREN_FIRST = (1 << 1), // 0x0002
@@ -156,8 +147,8 @@ struct DisplayListNode {
*/
struct GraphNodeMasterList {
/*0x00*/ struct GraphNode node;
/*0x14*/ struct DisplayListNode *listHeads[GRAPH_NODE_NUM_UCODES][LAYER_COUNT];
/*0x34*/ struct DisplayListNode *listTails[GRAPH_NODE_NUM_UCODES][LAYER_COUNT];
/*0x14*/ struct DisplayListNode *listHeads[LAYER_COUNT];
/*0x34*/ struct DisplayListNode *listTails[LAYER_COUNT];
};
/** Simply used as a parent to group multiple children.

53
src/game/debug_box.c
View File

@@ -263,15 +263,9 @@ void iterate_surfaces_envbox(Vtx *verts) {
}
// VERTCOUNT = The highest number divisible by 6, which is less than the maximum vertex buffer divided by 2.
// The vertex buffer is 64 if OBJECTS_REJ is enabled, 32 otherwise.
//! TODO: Why can this only use half of the vertex buffer?
#ifdef OBJECTS_REJ
#define VERTCOUNT 30
#else
#define VERTCOUNT 12
#endif // OBJECTS_REJ
void visual_surface_display(Vtx *verts, s32 iteration) {
void visual_surface_display(Gfx **gfx, Vtx *verts, s32 iteration) {
s32 vts = (iteration ? gVisualOffset : gVisualSurfaceCount);
s32 vtl = 0;
s32 count = VERTCOUNT;
@@ -280,13 +274,13 @@ void visual_surface_display(Vtx *verts, s32 iteration) {
while (vts > 0) {
if (count == VERTCOUNT) {
ntx = MIN(VERTCOUNT, vts);
gSPVertex(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(verts + (gVisualSurfaceCount - vts)), ntx, 0);
gSPVertex((*gfx)++, VIRTUAL_TO_PHYSICAL(verts + (gVisualSurfaceCount - vts)), ntx, 0);
count = 0;
vtl = VERTCOUNT;
}
if (vtl >= 6) {
gSP2Triangles(gDisplayListHead++, (count + 0),
gSP2Triangles((*gfx)++, (count + 0),
(count + 1),
(count + 2), 0x0,
(count + 3),
@@ -296,7 +290,7 @@ void visual_surface_display(Vtx *verts, s32 iteration) {
vtl -= 6;
count += 6;
} else if (vtl >= 3) {
gSP1Triangle(gDisplayListHead++, (count + 0),
gSP1Triangle((*gfx)++, (count + 0),
(count + 1),
(count + 2), 0x0);
vts -= 3;
@@ -343,7 +337,7 @@ s32 iterate_surface_count(s32 x, s32 z) {
return j;
}
void visual_surface_loop(void) {
void visual_surface_loop(Gfx **gfx) {
if (!gSurfaceNodesAllocated
|| !gSurfacesAllocated
|| !gMarioState->marioObj) {
@@ -358,19 +352,20 @@ void visual_surface_loop(void) {
return;
}
gSPDisplayList(gDisplayListHead++, dl_visual_surface);
gSPDisplayList((*gfx)++, dl_visual_surface);
iterate_surfaces_visual(gMarioState->pos[0], gMarioState->pos[2], verts);
visual_surface_display(verts, 0);
visual_surface_display(gfx, verts, 0);
gDPPipeSync((*gfx)++);
iterate_surfaces_envbox(verts);
gDPSetRenderMode(gDisplayListHead++, G_RM_ZB_XLU_SURF, G_RM_NOOP2);
gDPSetRenderMode((*gfx)++, G_RM_ZB_XLU_SURF, G_RM_NOOP2);
visual_surface_display(verts, 1);
visual_surface_display(gfx, verts, 1);
gSPDisplayList(gDisplayListHead++, dl_debug_box_end);
gSPDisplayList((*gfx)++, dl_debug_box_end);
}
/**
@@ -388,9 +383,6 @@ static void append_debug_box(Vec3f center, Vec3f bounds, s16 yaw, s32 type) {
sBoxes[sNumBoxes].yaw = yaw;
sBoxes[sNumBoxes].color = sCurBoxColor;
sBoxes[sNumBoxes].type = type;
if (!(sBoxes[sNumBoxes].type & (DEBUG_UCODE_REJ | DEBUG_UCODE_DEFAULT))) {
sBoxes[sNumBoxes].type |= DEBUG_UCODE_DEFAULT;
}
++sNumBoxes;
}
}
@@ -448,7 +440,7 @@ void debug_box_pos_rot(Vec3f pMin, Vec3f pMax, s16 yaw, s32 type) {
append_debug_box(center, bounds, yaw, type);
}
static void render_box(int index) {
static void render_box(Gfx **gfx, int index) {
struct DebugBox *box = &sBoxes[index];
s32 color = box->color;
Mat4 mtxFloat;
@@ -477,20 +469,20 @@ static void render_box(int index) {
mtxf_to_mtx(mtx, mtxFloat);
// Load the calculated matrix
gSPMatrix(gDisplayListHead++, mtx, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
gSPMatrix((*gfx)++, mtx, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
// Set env color to the color of this box
gDPSetColor(gDisplayListHead++, G_SETENVCOLOR, color);
gDPSetColor((*gfx)++, G_SETENVCOLOR, color);
if (box->type & DEBUG_SHAPE_BOX) {
gSPDisplayList(gDisplayListHead++, dl_debug_box_verts);
gSPDisplayList((*gfx)++, dl_debug_box_verts);
}
if (box->type & DEBUG_SHAPE_CYLINDER) {
gSPDisplayList(gDisplayListHead++, dl_debug_cylinder_verts);
gSPDisplayList((*gfx)++, dl_debug_cylinder_verts);
}
}
void render_debug_boxes(s32 type) {
void render_debug_boxes(Gfx **gfx) {
s32 i;
debug_box_color(DBG_BOX_DEF_COLOR);
@@ -498,17 +490,14 @@ void render_debug_boxes(s32 type) {
if (sNumBoxes == 0) return;
if (gAreaUpdateCounter < 3) return;
gSPDisplayList(gDisplayListHead++, dl_debug_box_begin);
gSPDisplayList((*gfx)++, dl_debug_box_begin);
for (i = 0; i < sNumBoxes; ++i) {
if ((type & DEBUG_UCODE_DEFAULT) && (sBoxes[i].type & DEBUG_UCODE_DEFAULT)) render_box(i);
if ((type & DEBUG_UCODE_REJ ) && (sBoxes[i].type & DEBUG_UCODE_REJ )) render_box(i);
render_box(gfx, i);
}
if (type & DEBUG_BOX_CLEAR) {
sNumBoxes = 0;
}
gSPDisplayList(gDisplayListHead++, dl_debug_box_end);
sNumBoxes = 0;
gSPDisplayList((*gfx)++, dl_debug_box_end);
}
#endif

12
src/game/debug_box.h
View File

@@ -19,13 +19,7 @@
enum DebugBoxFlags {
DEBUG_SHAPE_BOX = (1 << 0), // 0x01
DEBUG_SHAPE_CYLINDER = (1 << 1), // 0x02
DEBUG_UCODE_DEFAULT = (1 << 2), // 0x04
#ifdef OBJECTS_REJ
DEBUG_UCODE_REJ = (1 << 3), // 0x08
#else
DEBUG_UCODE_REJ = DEBUG_UCODE_DEFAULT,
#endif
DEBUG_BOX_CLEAR = (1 << 4), // 0x10
DEBUG_BOX_CLEAR = (1 << 2), // 0x04
};
extern u8 hitboxView;
@@ -39,8 +33,8 @@ void debug_box_rot(Vec3f center, Vec3f bounds, s16 yaw, s32 type);
void debug_box_pos(Vec3f pMin, Vec3f pMax, s32 type);
void debug_box_pos_rot(Vec3f pMin, Vec3f pMax, s16 yaw, s32 type);
void render_debug_boxes(s32 type);
extern void visual_surface_loop(void);
void render_debug_boxes(Gfx **gfx);
extern void visual_surface_loop(Gfx **gfx);
#endif

4
src/game/game_init.c
View File

@@ -277,11 +277,7 @@ void create_gfx_task_structure(void) {
gGfxSPTask->task.t.type = M_GFXTASK;
gGfxSPTask->task.t.ucode_boot = rspbootTextStart;
gGfxSPTask->task.t.ucode_boot_size = ((u8 *) rspbootTextEnd - (u8 *) rspbootTextStart);
#if defined(F3DEX_GBI_SHARED) && defined(OBJECTS_REJ)
gGfxSPTask->task.t.flags = (OS_TASK_LOADABLE | OS_TASK_DP_WAIT);
#else
gGfxSPTask->task.t.flags = 0x0;
#endif
#ifdef L3DEX2_ALONE
gGfxSPTask->task.t.ucode = gspL3DEX2_fifoTextStart;
gGfxSPTask->task.t.ucode_data = gspL3DEX2_fifoDataStart;

198
src/game/rendering_graph_node.c
View File

@@ -195,76 +195,10 @@ static const Gfx dl_silhouette_end[] = {
struct RenderPhase {
u8 startLayer;
u8 endLayer;
#ifdef OBJECTS_REJ
u8 ucode;
#endif
};
static struct RenderPhase sRenderPhases[] = {
#ifdef OBJECTS_REJ
#if SILHOUETTE
// Silhouette, .rej
[RENDER_PHASE_ZEX_BEFORE_SILHOUETTE] = {
.startLayer = LAYER_FIRST,
.endLayer = LAYER_LAST_BEFORE_SILHOUETTE,
.ucode = GRAPH_NODE_UCODE_DEFAULT
},
[RENDER_PHASE_REJ_ZB] = {
.startLayer = LAYER_ZB_FIRST,
.endLayer = LAYER_LAST_BEFORE_SILHOUETTE,
.ucode = GRAPH_NODE_UCODE_REJ
},
[RENDER_PHASE_REJ_SILHOUETTE] = {
.startLayer = LAYER_SILHOUETTE_FIRST,
.endLayer = LAYER_SILHOUETTE_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
[RENDER_PHASE_REJ_NON_SILHOUETTE] = {
.startLayer = LAYER_SILHOUETTE_FIRST,
.endLayer = LAYER_SILHOUETTE_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
[RENDER_PHASE_REJ_OCCLUDE_SILHOUETTE] = {
.startLayer = LAYER_OCCLUDE_SILHOUETTE_FIRST,
.endLayer = LAYER_OCCLUDE_SILHOUETTE_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
[RENDER_PHASE_ZEX_AFTER_SILHOUETTE] = {
.startLayer = LAYER_OCCLUDE_SILHOUETTE_FIRST,
.endLayer = LAYER_LAST,
.ucode = GRAPH_NODE_UCODE_DEFAULT
},
[RENDER_PHASE_REJ_NON_ZB] = {
.startLayer = LAYER_NON_ZB_FIRST,
.endLayer = LAYER_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
#else
// No silhouette, .rej
[RENDER_PHASE_ZEX_BG] = {
.startLayer = LAYER_FIRST,
.endLayer = LAYER_FIRST,
.ucode = GRAPH_NODE_UCODE_DEFAULT
},
[RENDER_PHASE_REJ_ZB] = {
.startLayer = LAYER_ZB_FIRST,
.endLayer = LAYER_ZB_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
[RENDER_PHASE_ZEX_ALL] = {
.startLayer = LAYER_ZB_FIRST,
.endLayer = LAYER_LAST,
.ucode = GRAPH_NODE_UCODE_DEFAULT
},
[RENDER_PHASE_REJ_NON_ZB] = {
.startLayer = LAYER_NON_ZB_FIRST,
.endLayer = LAYER_LAST,
.ucode = GRAPH_NODE_UCODE_REJ
},
#endif
#else
#if SILHOUETTE
// Silhouette, no .rej
#if SILHOUETTE
[RENDER_PHASE_ZEX_BEFORE_SILHOUETTE] = {
.startLayer = LAYER_FIRST,
.endLayer = LAYER_LAST_BEFORE_SILHOUETTE,
@@ -289,46 +223,16 @@ static struct RenderPhase sRenderPhases[] = {
.startLayer = LAYER_OCCLUDE_SILHOUETTE_FIRST,
.endLayer = LAYER_LAST,
},
#else
// No silhouette, no .rej
#else
[RENDER_PHASE_ZEX_ALL] = {
.startLayer = LAYER_FIRST,
.endLayer = LAYER_LAST,
},
#endif
#endif
};
extern const Gfx init_rsp[];
#ifdef OBJECTS_REJ
void switch_ucode(s32 ucode) {
// Set the ucode and RCP settings
switch (ucode) {
default: // GRAPH_NODE_UCODE_DEFAULT
case GRAPH_NODE_UCODE_DEFAULT:
gSPLoadUcodeL(gDisplayListHead++, gspF3DZEX2_NoN_PosLight_fifo); // F3DZEX2_PosLight
// Reload the necessary RSP settings
gSPDisplayList(gDisplayListHead++, init_rsp);
break;
case GRAPH_NODE_UCODE_REJ:
// Use .rej Microcode, skip sub-pixel processing on console
if (gEmulator & EMU_CONSOLE) {
gSPLoadUcodeL(gDisplayListHead++, gspF3DLX2_Rej_fifo); // F3DLX2_Rej
} else {
gSPLoadUcodeL(gDisplayListHead++, gspF3DEX2_Rej_fifo); // F3DEX2_Rej
}
// Reload the necessary RSP settings
gSPDisplayList(gDisplayListHead++, init_rsp);
// Set the clip ratio (see init_rsp)
gSPClipRatio(gDisplayListHead++, FRUSTRATIO_2);
break;
}
}
#endif
#define UPPER_FIXED(x) ((int)((unsigned int)((x) * 0x10000) >> 16))
#define LOWER_FIXED(x) ((int)((unsigned int)((x) * 0x10000) & 0xFFFF))
@@ -357,67 +261,65 @@ void geo_process_master_list_sub(struct GraphNodeMasterList *node) {
s32 currLayer = LAYER_FIRST;
s32 startLayer = LAYER_FIRST;
s32 endLayer = LAYER_LAST;
s32 ucode = GRAPH_NODE_UCODE_DEFAULT;
s32 phaseIndex = RENDER_PHASE_FIRST;
s32 enableZBuffer = (node->node.flags & GRAPH_RENDER_Z_BUFFER) != 0;
s32 finalPhase = enableZBuffer ? RENDER_PHASE_END : 1;
struct RenderModeContainer *mode1List = &renderModeTable_1Cycle[enableZBuffer];
struct RenderModeContainer *mode2List = &renderModeTable_2Cycle[enableZBuffer];
Gfx *tempGfxHead = gDisplayListHead;
// Loop through the render phases
for (phaseIndex = RENDER_PHASE_FIRST; phaseIndex < RENDER_PHASE_END; phaseIndex++) {
// Get the render phase information.
renderPhase = &sRenderPhases[phaseIndex];
startLayer = renderPhase->startLayer;
endLayer = renderPhase->endLayer;
#ifdef OBJECTS_REJ
ucode = renderPhase->ucode;
// Set the ucode for the current render phase
switch_ucode(ucode);
gSPLookAt(gDisplayListHead++, gCurLookAt);
#endif
for (phaseIndex = RENDER_PHASE_FIRST; phaseIndex < finalPhase; phaseIndex++) {
if (enableZBuffer) {
// Get the render phase information.
renderPhase = &sRenderPhases[phaseIndex];
startLayer = renderPhase->startLayer;
endLayer = renderPhase->endLayer;
// Enable z buffer.
gDPPipeSync(gDisplayListHead++);
gSPSetGeometryMode(gDisplayListHead++, G_ZBUFFER);
gDPPipeSync(tempGfxHead++);
gSPSetGeometryMode(tempGfxHead++, G_ZBUFFER);
} else {
startLayer = LAYER_FORCE;
endLayer = LAYER_TRANSPARENT;
}
// Iterate through the layers on the current render phase.
for (currLayer = startLayer; currLayer <= endLayer; currLayer++) {
// Set 'currList' to the first DisplayListNode on the current layer.
currList = node->listHeads[ucode][currLayer];
currList = node->listHeads[currLayer];
#if defined(DISABLE_AA) || !SILHOUETTE
// Set the render mode for the current layer.
gDPSetRenderMode(gDisplayListHead++, mode1List->modes[currLayer],
gDPSetRenderMode(tempGfxHead++, mode1List->modes[currLayer],
mode2List->modes[currLayer]);
#else
if (phaseIndex == RENDER_PHASE_NON_SILHOUETTE) {
// To properly cover the silhouette, disable AA.
// The silhouette model does not have AA due to the hack used to prevent triangle overlap.
gDPSetRenderMode(gDisplayListHead++, (mode1List->modes[currLayer] & ~IM_RD),
gDPSetRenderMode(tempGfxHead++, (mode1List->modes[currLayer] & ~IM_RD),
(mode2List->modes[currLayer] & ~IM_RD));
} else {
// Set the render mode for the current dl.
gDPSetRenderMode(gDisplayListHead++, mode1List->modes[currLayer],
gDPSetRenderMode(tempGfxHead++, mode1List->modes[currLayer],
mode2List->modes[currLayer]);
}
#endif
// Iterate through all the displaylists on the current layer.
while (currList != NULL) {
// Add the display list's transformation to the master list.
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(currList->transform),
gSPMatrix(tempGfxHead++, VIRTUAL_TO_PHYSICAL(currList->transform),
(G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH));
#if SILHOUETTE
if (phaseIndex == RENDER_PHASE_SILHOUETTE) {
// Add the current display list to the master list, with silhouette F3D.
gSPDisplayList(gDisplayListHead++, dl_silhouette_begin);
gSPDisplayList(gDisplayListHead++, currList->displayList);
gSPDisplayList(gDisplayListHead++, dl_silhouette_end);
gSPDisplayList(tempGfxHead++, dl_silhouette_begin);
gSPDisplayList(tempGfxHead++, currList->displayList);
gSPDisplayList(tempGfxHead++, dl_silhouette_end);
} else {
// Add the current display list to the master list.
gSPDisplayList(gDisplayListHead++, currList->displayList);
gSPDisplayList(tempGfxHead++, currList->displayList);
}
#else
// Add the current display list to the master list.
gSPDisplayList(gDisplayListHead++, currList->displayList);
gSPDisplayList(tempGfxHead++, currList->displayList);
#endif
// Move to the next DisplayListNode.
currList = currList->next;
@@ -427,21 +329,17 @@ void geo_process_master_list_sub(struct GraphNodeMasterList *node) {
if (enableZBuffer) {
// Disable z buffer.
gDPPipeSync(gDisplayListHead++);
gSPClearGeometryMode(gDisplayListHead++, G_ZBUFFER);
}
#ifdef OBJECTS_REJ
#if defined(F3DEX_GBI_2) && defined(VISUAL_DEBUG)
if (hitboxView) render_debug_boxes(DEBUG_UCODE_REJ);
#endif
switch_ucode(GRAPH_NODE_UCODE_DEFAULT);
#endif
gDPPipeSync(tempGfxHead++);
gSPClearGeometryMode(tempGfxHead++, G_ZBUFFER);
#ifdef VISUAL_DEBUG
if ( hitboxView) render_debug_boxes(DEBUG_UCODE_DEFAULT | DEBUG_BOX_CLEAR);
// Load the world scale identity matrix
gSPMatrix(gDisplayListHead++, &identityMatrixWorldScale, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
if (surfaceView) visual_surface_loop();
// Load the world scale identity matrix
gSPMatrix(tempGfxHead++, &identityMatrixWorldScale, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
if (surfaceView) visual_surface_loop(&tempGfxHead);
render_debug_boxes(&tempGfxHead);
#endif
}
gDisplayListHead = tempGfxHead;
}
/**
@@ -450,16 +348,11 @@ void geo_process_master_list_sub(struct GraphNodeMasterList *node) {
* render modes of layers.
*/
void geo_append_display_list(void *displayList, s32 layer) {
s32 ucode = GRAPH_NODE_UCODE_DEFAULT;
#ifdef F3DEX_GBI_2
gSPLookAt(gDisplayListHead++, gCurLookAt);
#endif
#if defined(OBJECTS_REJ) || SILHOUETTE
#if SILHOUETTE
if (gCurGraphNodeObject != NULL) {
#ifdef OBJECTS_REJ
ucode = gCurGraphNodeObject->ucode;
#endif
#if SILHOUETTE
if (gCurGraphNodeObject->node.flags & GRAPH_RENDER_SILHOUETTE) {
switch (layer) {
case LAYER_OPAQUE: layer = LAYER_SILHOUETTE_OPAQUE; break;
@@ -472,7 +365,6 @@ void geo_append_display_list(void *displayList, s32 layer) {
case LAYER_ALPHA: layer = LAYER_OCCLUDE_SILHOUETTE_ALPHA; break;
}
}
#endif // SILHOUETTE
}
#endif // F3DEX_GBI_2 || SILHOUETTE
if (gCurGraphNodeMasterList != NULL) {
@@ -482,12 +374,12 @@ void geo_append_display_list(void *displayList, s32 layer) {
listNode->transform = gMatStackFixed[gMatStackIndex];
listNode->displayList = displayList;
listNode->next = NULL;
if (gCurGraphNodeMasterList->listHeads[ucode][layer] == NULL) {
gCurGraphNodeMasterList->listHeads[ucode][layer] = listNode;
if (gCurGraphNodeMasterList->listHeads[layer] == NULL) {
gCurGraphNodeMasterList->listHeads[layer] = listNode;
} else {
gCurGraphNodeMasterList->listTails[ucode][layer]->next = listNode;
gCurGraphNodeMasterList->listTails[layer]->next = listNode;
}
gCurGraphNodeMasterList->listTails[ucode][layer] = listNode;
gCurGraphNodeMasterList->listTails[layer] = listNode;
}
}
@@ -512,14 +404,12 @@ static void append_dl_and_return(struct GraphNodeDisplayList *node) {
* Process the master list node.
*/
void geo_process_master_list(struct GraphNodeMasterList *node) {
s32 ucode, layer;
s32 layer;
if (gCurGraphNodeMasterList == NULL && node->node.children != NULL) {
gCurGraphNodeMasterList = node;
for (ucode = 0; ucode < GRAPH_NODE_NUM_UCODES; ucode++) {
for (layer = LAYER_FIRST; layer < LAYER_COUNT; layer++) {
node->listHeads[ucode][layer] = NULL;
}
for (layer = LAYER_FIRST; layer < LAYER_COUNT; layer++) {
node->listHeads[layer] = NULL;
}
geo_process_node_and_siblings(node->node.children);
geo_process_master_list_sub(gCurGraphNodeMasterList);
@@ -1128,16 +1018,16 @@ void visualise_object_hitbox(struct Object *node) {
debug_box_color(COLOR_RGBA32_DEBUG_HITBOX);
}
debug_box(bnds1, bnds2, (DEBUG_SHAPE_CYLINDER | DEBUG_UCODE_REJ));
debug_box(bnds1, bnds2, (DEBUG_SHAPE_CYLINDER));
vec3f_set(bnds1, node->oPosX, (node->oPosY - node->hitboxDownOffset), node->oPosZ);
vec3f_set(bnds2, node->hurtboxRadius, node->hurtboxHeight, node->hurtboxRadius);
debug_box_color(COLOR_RGBA32_DEBUG_HURTBOX);
debug_box(bnds1, bnds2, (DEBUG_SHAPE_CYLINDER | DEBUG_UCODE_REJ));
debug_box(bnds1, bnds2, (DEBUG_SHAPE_CYLINDER));
} else {
vec3f_set(bnds1, node->oPosX, (node->oPosY - 15), node->oPosZ);
vec3f_set(bnds2, 30, 30, 30);
debug_box_color(COLOR_RGBA32_DEBUG_POSITION);
debug_box(bnds1, bnds2, (DEBUG_SHAPE_BOX | DEBUG_UCODE_REJ));
debug_box(bnds1, bnds2, (DEBUG_SHAPE_BOX));
}
}
#endif

36
src/game/rendering_graph_node.h
View File

@@ -15,6 +15,9 @@ extern struct GraphNodeHeldObject *gCurGraphNodeHeldObject;
extern u16 gAreaUpdateCounter;
extern Vec3f globalLightDirection;
#define GRAPH_ROOT_PERSP 0
#define GRAPH_ROOT_ORTHO 1
enum AnimType {
// after processing an object, the type is reset to this
ANIM_TYPE_NONE,
@@ -41,34 +44,7 @@ struct RenderModeContainer {
u32 modes[LAYER_COUNT];
};
#ifdef OBJECTS_REJ
#if SILHOUETTE
// Silhouette, .rej
enum RenderPhases {
RENDER_PHASE_ZEX_BEFORE_SILHOUETTE,
RENDER_PHASE_REJ_ZB,
RENDER_PHASE_REJ_SILHOUETTE,
RENDER_PHASE_REJ_NON_SILHOUETTE,
RENDER_PHASE_REJ_OCCLUDE_SILHOUETTE,
RENDER_PHASE_ZEX_AFTER_SILHOUETTE,
RENDER_PHASE_REJ_NON_ZB,
RENDER_PHASE_END,
};
#define RENDER_PHASE_SILHOUETTE RENDER_PHASE_REJ_SILHOUETTE
#define RENDER_PHASE_NON_SILHOUETTE RENDER_PHASE_REJ_NON_SILHOUETTE
#else
// No silhouette, .rej
enum RenderPhases {
RENDER_PHASE_ZEX_BG,
RENDER_PHASE_REJ_ZB,
RENDER_PHASE_ZEX_ALL,
RENDER_PHASE_REJ_NON_ZB,
RENDER_PHASE_END,
};
#endif
#else
#if SILHOUETTE
// Silhouette, no .rej
#if SILHOUETTE
enum RenderPhases {
RENDER_PHASE_ZEX_BEFORE_SILHOUETTE,
RENDER_PHASE_ZEX_SILHOUETTE,
@@ -79,13 +55,11 @@ struct RenderModeContainer {
};
#define RENDER_PHASE_SILHOUETTE RENDER_PHASE_ZEX_SILHOUETTE
#define RENDER_PHASE_NON_SILHOUETTE RENDER_PHASE_ZEX_NON_SILHOUETTE
#else
// No silhouette, no .rej
#else
enum RenderPhases {
RENDER_PHASE_ZEX_ALL,
RENDER_PHASE_END,
};
#endif
#endif
#if SILHOUETTE

3
src/game/spawn_object.c
View File

@@ -188,9 +188,6 @@ struct Object *allocate_object(struct ObjectNode *objList) {
obj->oRoom = -1;
obj->header.gfx.node.flags &= ~GRAPH_RENDER_INVISIBLE;
#ifdef OBJECTS_REJ
obj->header.gfx.ucode = GRAPH_NODE_UCODE_REJ;
#endif
vec3_same(obj->header.gfx.pos, -10000.0f);
obj->header.gfx.throwMatrix = NULL;
#ifdef PUPPYLIGHTS