mirror of
https://github.com/Mr-Wiseguy/Zelda64Recomp.git
synced 2024-12-23 03:21:56 +01:00
1221 lines
56 KiB
C
1221 lines
56 KiB
C
#include "patches.h"
|
|
#include "transform_ids.h"
|
|
#include "buffers.h"
|
|
#include "sys_cfb.h"
|
|
#include "overlays/kaleido_scope/ovl_kaleido_scope/z_kaleido_scope.h"
|
|
|
|
// This moves elements towards the screen edges when increased
|
|
s32 margin_reduction = 8;
|
|
|
|
extern s32 gFramerateDivisor;
|
|
|
|
// 10 times bigger than the game's normal buffers.
|
|
typedef struct {
|
|
GfxMasterList master;
|
|
Gfx polyXluBuffer[0x8000];
|
|
Gfx overlayBuffer[0x4000];
|
|
Gfx workBuffer[0x400];
|
|
Gfx debugBuffer[0x400];
|
|
Gfx polyOpaBuffer[0x33800];
|
|
} BiggerGfxPool;
|
|
|
|
BiggerGfxPool gBiggerGfxPools[2];
|
|
|
|
// @recomp Use the bigger gfx pools and enable RT64 extended GBI mode.
|
|
void Graph_SetNextGfxPool(GraphicsContext* gfxCtx) {
|
|
GfxPool* pool = &gGfxPools[gfxCtx->gfxPoolIdx % 2];
|
|
BiggerGfxPool* bigger_pool = &gBiggerGfxPools[gfxCtx->gfxPoolIdx % 2];
|
|
|
|
gGfxMasterDL = &pool->master;
|
|
gSegments[0x0E] = (uintptr_t)gGfxMasterDL;
|
|
|
|
pool->headMagic = GFXPOOL_HEAD_MAGIC;
|
|
pool->tailMagic = GFXPOOL_TAIL_MAGIC;
|
|
|
|
Graph_InitTHGA(&gfxCtx->polyOpa, bigger_pool->polyOpaBuffer, sizeof(bigger_pool->polyOpaBuffer));
|
|
Graph_InitTHGA(&gfxCtx->polyXlu, bigger_pool->polyXluBuffer, sizeof(bigger_pool->polyXluBuffer));
|
|
Graph_InitTHGA(&gfxCtx->overlay, bigger_pool->overlayBuffer, sizeof(bigger_pool->overlayBuffer));
|
|
Graph_InitTHGA(&gfxCtx->work, bigger_pool->workBuffer, sizeof(bigger_pool->workBuffer));
|
|
Graph_InitTHGA(&gfxCtx->debug, bigger_pool->debugBuffer, sizeof(bigger_pool->debugBuffer));
|
|
|
|
gfxCtx->polyOpaBuffer = bigger_pool->polyOpaBuffer;
|
|
gfxCtx->polyXluBuffer = bigger_pool->polyXluBuffer;
|
|
gfxCtx->overlayBuffer = bigger_pool->overlayBuffer;
|
|
gfxCtx->workBuffer = bigger_pool->workBuffer;
|
|
gfxCtx->debugBuffer = bigger_pool->debugBuffer;
|
|
|
|
gfxCtx->curFrameBuffer = SysCfb_GetFramebuffer(gfxCtx->framebufferIndex % 2);
|
|
gSegments[0x0F] = (uintptr_t)gfxCtx->curFrameBuffer;
|
|
|
|
gfxCtx->zbuffer = SysCfb_GetZBuffer();
|
|
|
|
gSPBranchList(&gGfxMasterDL->disps[0], bigger_pool->polyOpaBuffer);
|
|
gSPBranchList(&gGfxMasterDL->disps[1], bigger_pool->polyXluBuffer);
|
|
gSPBranchList(&gGfxMasterDL->disps[2], bigger_pool->overlayBuffer);
|
|
gSPBranchList(&gGfxMasterDL->disps[3], bigger_pool->workBuffer);
|
|
gSPEndDisplayList(&gGfxMasterDL->disps[4]);
|
|
gSPBranchList(&gGfxMasterDL->debugDisp[0], bigger_pool->debugBuffer);
|
|
|
|
// @recomp Enable RT64 extended GBI mode and set the current framerate
|
|
OPEN_DISPS(gfxCtx);
|
|
gEXEnable(POLY_OPA_DISP++);
|
|
CLOSE_DISPS(gfxCtx);
|
|
}
|
|
|
|
void recomp_crash(const char* err) {
|
|
recomp_printf("%s\n", err);
|
|
// TODO open a message box instead of a hard crash
|
|
*(volatile int*)0 = 0;
|
|
}
|
|
|
|
extern volatile OSTime gRSPGfxTimeTotal;
|
|
extern volatile OSTime gRSPGfxTimeAcc;
|
|
extern volatile OSTime gRSPAudioTimeTotal;
|
|
extern volatile OSTime gRSPAudioTimeAcc;
|
|
extern volatile OSTime gRDPTimeTotal;
|
|
extern volatile OSTime gRDPTimeAcc;
|
|
extern OSTime sGraphPrevUpdateEndTime;
|
|
extern volatile OSTime gGraphUpdatePeriod;
|
|
|
|
|
|
extern int extra_vis;
|
|
|
|
// @recomp Modified to report errors instead of skipping frames.
|
|
/**
|
|
* Run the game state logic, then finalize the gfx buffer
|
|
* and run the graphics task for this frame.
|
|
*/
|
|
void Graph_ExecuteAndDraw(GraphicsContext* gfxCtx, GameState* gameState) {
|
|
u32 problem;
|
|
|
|
gameState->unk_A3 = 0;
|
|
Graph_SetNextGfxPool(gfxCtx);
|
|
|
|
GameState_Update(gameState);
|
|
|
|
OPEN_DISPS(gfxCtx);
|
|
|
|
// @recomp Send the current framerate to RT64, including any extra VI interrupt periods.
|
|
gEXSetRefreshRate(POLY_OPA_DISP++, 60 / (gameState->framerateDivisor + extra_vis));
|
|
|
|
// @recomp Edit billboard groups to skip interpolation if the camera also skipped.
|
|
if (gameState->destroy == Play_Destroy) {
|
|
PlayState* play = (PlayState*)gameState;
|
|
edit_billboard_groups(play);
|
|
}
|
|
|
|
// @recomp Clear the camera skip state.
|
|
clear_camera_skipped();
|
|
|
|
gSPEndDisplayList(WORK_DISP++);
|
|
gSPEndDisplayList(POLY_OPA_DISP++);
|
|
gSPEndDisplayList(POLY_XLU_DISP++);
|
|
gSPEndDisplayList(OVERLAY_DISP++);
|
|
gSPEndDisplayList(DEBUG_DISP++);
|
|
|
|
CLOSE_DISPS(gfxCtx);
|
|
|
|
{
|
|
Gfx* gfx = gGfxMasterDL->taskStart;
|
|
|
|
gSPSegment(gfx++, 0x0E, gGfxMasterDL);
|
|
gSPDisplayList(gfx++, &D_0E000000.disps[3]);
|
|
gSPDisplayList(gfx++, &D_0E000000.disps[0]);
|
|
gSPDisplayList(gfx++, &D_0E000000.disps[1]);
|
|
gSPDisplayList(gfx++, &D_0E000000.disps[2]);
|
|
gSPDisplayList(gfx++, &D_0E000000.debugDisp[0]);
|
|
|
|
gDPPipeSync(gfx++);
|
|
gDPFullSync(gfx++);
|
|
gSPEndDisplayList(gfx++);
|
|
}
|
|
|
|
problem = false;
|
|
|
|
// @recomp Patch all error conditions to print to console and crash the application.
|
|
{
|
|
GfxPool* pool = &gGfxPools[gfxCtx->gfxPoolIdx % 2];
|
|
|
|
if (pool->headMagic != GFXPOOL_HEAD_MAGIC) {
|
|
recomp_crash("GfxPool headMagic integrity check failed!");
|
|
}
|
|
if (pool->tailMagic != GFXPOOL_TAIL_MAGIC) {
|
|
recomp_crash("GfxPool tailMagic integrity check failed!");
|
|
}
|
|
}
|
|
|
|
if (THGA_IsCrash(&gfxCtx->polyOpa)) {
|
|
recomp_crash("gfxCtx->polyOpa overflow!");
|
|
}
|
|
if (THGA_IsCrash(&gfxCtx->polyXlu)) {
|
|
recomp_crash("gfxCtx->polyXlu overflow!");
|
|
}
|
|
if (THGA_IsCrash(&gfxCtx->overlay)) {
|
|
recomp_crash("gfxCtx->overlay overflow!");
|
|
}
|
|
if (THGA_IsCrash(&gfxCtx->work)) {
|
|
recomp_crash("gfxCtx->work overflow!");
|
|
}
|
|
if (THGA_IsCrash(&gfxCtx->debug)) {
|
|
recomp_crash("gfxCtx->debug overflow!");
|
|
}
|
|
|
|
if (!problem) {
|
|
// @recomp Temporarily adjust the framerate divisor to include any extra VI interrupt periods.
|
|
u8 old_divisor = gameState->framerateDivisor;
|
|
gameState->framerateDivisor += extra_vis;
|
|
Graph_TaskSet00(gfxCtx, gameState);
|
|
// @recomp Restore the old framerate divisor.
|
|
gameState->framerateDivisor = old_divisor;
|
|
gfxCtx->gfxPoolIdx++;
|
|
gfxCtx->framebufferIndex++;
|
|
}
|
|
// @recomp Clear any extra VI interrupt periods.
|
|
extra_vis = 0;
|
|
|
|
{
|
|
OSTime time = osGetTime();
|
|
|
|
gRSPGfxTimeTotal = gRSPGfxTimeAcc;
|
|
gRSPAudioTimeTotal = gRSPAudioTimeAcc;
|
|
gRDPTimeTotal = gRDPTimeAcc;
|
|
gRSPGfxTimeAcc = 0;
|
|
gRSPAudioTimeAcc = 0;
|
|
gRDPTimeAcc = 0;
|
|
|
|
if (sGraphPrevUpdateEndTime != 0) {
|
|
gGraphUpdatePeriod = time - sGraphPrevUpdateEndTime;
|
|
}
|
|
sGraphPrevUpdateEndTime = time;
|
|
}
|
|
}
|
|
|
|
extern s16 sPictoState;
|
|
|
|
// Modify interface drawing (rupees, key counter, etc.)
|
|
extern TexturePtr sStoryTextures[];
|
|
extern TexturePtr sStoryTLUTs[];
|
|
|
|
extern Color_RGB16 sRupeeCounterIconPrimColors[];
|
|
extern Color_RGB16 sRupeeCounterIconEnvColors[];
|
|
extern u8 gRupeeCounterIconTex[];
|
|
extern s16 sRupeeDigitsFirst[];
|
|
extern s16 sRupeeDigitsCount[];
|
|
|
|
extern u8 gSmallKeyCounterIconTex[];
|
|
extern u8 gCounterDigit0Tex[];
|
|
extern u8 gGoldSkulltulaCounterIconTex[];
|
|
|
|
extern Color_RGB16 sMinigameCountdownPrimColors[];
|
|
extern TexturePtr sMinigameCountdownTextures[];
|
|
extern s16 sMinigameCountdownTexWidths[];
|
|
|
|
extern u8 gPictoBoxFocusBorderTex[];
|
|
extern u8 gPictoBoxFocusIconTex[];
|
|
extern u8 gPictoBoxFocusTextTex[];
|
|
|
|
static Gfx sScreenFillSetupDL[] = {
|
|
gsDPPipeSync(),
|
|
gsSPClearGeometryMode(G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
|
|
G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH),
|
|
gsDPSetOtherMode(G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE |
|
|
G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_1PRIMITIVE,
|
|
G_AC_NONE | G_ZS_PIXEL | G_RM_CLD_SURF | G_RM_CLD_SURF2),
|
|
gsDPSetCombineMode(G_CC_PRIMITIVE, G_CC_PRIMITIVE),
|
|
gsSPEndDisplayList(),
|
|
};
|
|
|
|
void Interface_DrawAButton(PlayState* play);
|
|
void Interface_DrawBButtonIcons(PlayState* play);
|
|
void Interface_DrawCButtonIcons(PlayState* play);
|
|
void Interface_DrawClock(PlayState* play);
|
|
void Interface_DrawItemButtons(PlayState* play);
|
|
void Interface_DrawMinigameIcons(PlayState* play);
|
|
void Interface_DrawPauseMenuEquippingIcons(PlayState* play);
|
|
void Interface_DrawPerfectLetters(PlayState* play);
|
|
void Interface_DrawTimers(PlayState* play);
|
|
void Interface_SetOrthoView(InterfaceContext* interfaceCtx);
|
|
void Interface_SetVertices(PlayState* play);
|
|
void Magic_DrawMeter(PlayState* play);
|
|
|
|
void Interface_Draw(PlayState* play) {
|
|
s32 pad;
|
|
InterfaceContext* interfaceCtx = &play->interfaceCtx;
|
|
Player* player = GET_PLAYER(play);
|
|
Gfx* gfx;
|
|
s16 sp2CE;
|
|
s16 sp2CC;
|
|
s16 sp2CA;
|
|
s16 sp2C8;
|
|
PauseContext* pauseCtx = &play->pauseCtx;
|
|
f32 minigameCountdownScale;
|
|
s16 counterDigits[4];
|
|
s16 magicAlpha;
|
|
|
|
OPEN_DISPS(play->state.gfxCtx);
|
|
|
|
gSPSegment(OVERLAY_DISP++, 0x02, interfaceCtx->parameterSegment);
|
|
gSPSegment(OVERLAY_DISP++, 0x09, interfaceCtx->doActionSegment);
|
|
gSPSegment(OVERLAY_DISP++, 0x08, interfaceCtx->iconItemSegment);
|
|
gSPSegment(OVERLAY_DISP++, 0x0B, interfaceCtx->mapSegment);
|
|
|
|
if (pauseCtx->debugEditor == DEBUG_EDITOR_NONE) {
|
|
Interface_SetVertices(play);
|
|
// @recomp Adjust any scissors to cover the whole screen
|
|
gEXSetScissorAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_RIGHT, 0, -margin_reduction, -SCREEN_WIDTH, margin_reduction, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
// Draw Grandma's Story
|
|
if (interfaceCtx->storyDmaStatus == STORY_DMA_DONE) {
|
|
gSPSegment(OVERLAY_DISP++, 0x07, interfaceCtx->storySegment);
|
|
Gfx_SetupDL39_Opa(play->state.gfxCtx);
|
|
|
|
gDPSetTextureFilter(POLY_OPA_DISP++, G_TF_POINT);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, pauseCtx->alpha);
|
|
|
|
// Load in Grandma's Story
|
|
gSPLoadUcodeL(OVERLAY_DISP++, gspS2DEX2_fifo);
|
|
gfx = OVERLAY_DISP;
|
|
Prerender_DrawBackground2D(&gfx, sStoryTextures[interfaceCtx->storyType],
|
|
sStoryTLUTs[interfaceCtx->storyType], SCREEN_WIDTH, SCREEN_HEIGHT, 2, 1, 0x8000,
|
|
0x100, 0.0f, 0.0f, 1.0f, 1.0f, 0);
|
|
OVERLAY_DISP = gfx;
|
|
gSPLoadUcode(OVERLAY_DISP++, SysUcode_GetUCode(), SysUcode_GetUCodeData());
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
|
|
// Fill the screen with a black rectangle
|
|
gDPSetRenderMode(OVERLAY_DISP++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, R_STORY_FILL_SCREEN_ALPHA);
|
|
gDPFillRectangle(OVERLAY_DISP++, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
}
|
|
|
|
// @recomp Left align and shift left/up for life meter
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, -margin_reduction * 4, -margin_reduction * 4);
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_LEFT, -margin_reduction * 4, -margin_reduction * 4, -margin_reduction * 4, -margin_reduction * 4);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
LifeMeter_Draw(play);
|
|
|
|
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
|
|
|
|
// @recomp Left align and shift left/down for key count, skulltula count, and rupee count
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, -margin_reduction * 4, margin_reduction * 4);
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_LEFT, -margin_reduction * 4, margin_reduction * 4, -margin_reduction * 4, margin_reduction * 4);
|
|
|
|
// Draw Rupee Icon
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sRupeeCounterIconPrimColors[CUR_UPG_VALUE(UPG_WALLET)].r,
|
|
sRupeeCounterIconPrimColors[CUR_UPG_VALUE(UPG_WALLET)].g,
|
|
sRupeeCounterIconPrimColors[CUR_UPG_VALUE(UPG_WALLET)].b, interfaceCtx->magicAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, sRupeeCounterIconEnvColors[CUR_UPG_VALUE(UPG_WALLET)].r,
|
|
sRupeeCounterIconEnvColors[CUR_UPG_VALUE(UPG_WALLET)].g,
|
|
sRupeeCounterIconEnvColors[CUR_UPG_VALUE(UPG_WALLET)].b, 255);
|
|
OVERLAY_DISP =
|
|
Gfx_DrawTexRectIA8(OVERLAY_DISP, gRupeeCounterIconTex, 16, 16, 26, 206, 16, 16, 1 << 10, 1 << 10);
|
|
|
|
switch (play->sceneId) {
|
|
case SCENE_INISIE_N:
|
|
case SCENE_INISIE_R:
|
|
case SCENE_MITURIN:
|
|
case SCENE_HAKUGIN:
|
|
case SCENE_SEA:
|
|
if (DUNGEON_KEY_COUNT(gSaveContext.mapIndex) >= 0) {
|
|
// Small Key Icon
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 200, 230, 255, interfaceCtx->magicAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 20, 255);
|
|
OVERLAY_DISP = Gfx_DrawTexRectIA8(OVERLAY_DISP, gSmallKeyCounterIconTex, 16, 16, 26, 190, 16, 16,
|
|
1 << 10, 1 << 10);
|
|
|
|
// Small Key Counter
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineLERP(OVERLAY_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE,
|
|
TEXEL0, 0, PRIMITIVE, 0);
|
|
|
|
counterDigits[2] = 0;
|
|
counterDigits[3] = DUNGEON_KEY_COUNT(gSaveContext.mapIndex);
|
|
|
|
while (counterDigits[3] >= 10) {
|
|
counterDigits[2]++;
|
|
counterDigits[3] -= 10;
|
|
}
|
|
|
|
sp2CA = 42;
|
|
|
|
if (counterDigits[2] != 0) {
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, interfaceCtx->magicAlpha);
|
|
|
|
OVERLAY_DISP =
|
|
Gfx_DrawTexRectI8(OVERLAY_DISP, (u8*)gCounterDigit0Tex + (8 * 16 * counterDigits[2]), 8, 16,
|
|
43, 191, 8, 16, 1 << 10, 1 << 10);
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
gSPTextureRectangle(OVERLAY_DISP++, 168, 760, 200, 824, G_TX_RENDERTILE, 0, 0, 1 << 10,
|
|
1 << 10);
|
|
|
|
sp2CA += 8;
|
|
}
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, interfaceCtx->magicAlpha);
|
|
|
|
OVERLAY_DISP = Gfx_DrawTexRectI8(OVERLAY_DISP, (u8*)gCounterDigit0Tex + (8 * 16 * counterDigits[3]),
|
|
8, 16, sp2CA + 1, 191, 8, 16, 1 << 10, 1 << 10);
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
gSPTextureRectangle(OVERLAY_DISP++, sp2CA * 4, 760, (sp2CA * 4) + 0x20, 824, G_TX_RENDERTILE, 0, 0,
|
|
1 << 10, 1 << 10);
|
|
}
|
|
break;
|
|
|
|
case SCENE_KINSTA1:
|
|
case SCENE_KINDAN2:
|
|
// Gold Skulltula Icon
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, 255);
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gGoldSkulltulaCounterIconTex, G_IM_FMT_RGBA, G_IM_SIZ_32b, 24, 24,
|
|
0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
gSPTextureRectangle(OVERLAY_DISP++, 80, 748, 176, 820, G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
|
|
// Gold Skulluta Counter
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineLERP(OVERLAY_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE,
|
|
TEXEL0, 0, PRIMITIVE, 0);
|
|
|
|
counterDigits[2] = 0;
|
|
counterDigits[3] = Inventory_GetSkullTokenCount(play->sceneId);
|
|
|
|
while (counterDigits[3] >= 10) {
|
|
counterDigits[2]++;
|
|
counterDigits[3] -= 10;
|
|
}
|
|
|
|
sp2CA = 42;
|
|
|
|
if (counterDigits[2] != 0) {
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, interfaceCtx->magicAlpha);
|
|
|
|
OVERLAY_DISP = Gfx_DrawTexRectI8(OVERLAY_DISP, (u8*)gCounterDigit0Tex + (8 * 16 * counterDigits[2]),
|
|
8, 16, 43, 191, 8, 16, 1 << 10, 1 << 10);
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
gSPTextureRectangle(OVERLAY_DISP++, 168, 760, 200, 824, G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
|
|
sp2CA += 8;
|
|
}
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, interfaceCtx->magicAlpha);
|
|
|
|
OVERLAY_DISP = Gfx_DrawTexRectI8(OVERLAY_DISP, (u8*)gCounterDigit0Tex + (8 * 16 * counterDigits[3]), 8,
|
|
16, sp2CA + 1, 191, 8, 16, 1 << 10, 1 << 10);
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
gSPTextureRectangle(OVERLAY_DISP++, sp2CA * 4, 760, (sp2CA * 4) + 0x20, 824, G_TX_RENDERTILE, 0, 0,
|
|
1 << 10, 1 << 10);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Rupee Counter
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineLERP(OVERLAY_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE, TEXEL0, 0,
|
|
PRIMITIVE, 0);
|
|
|
|
counterDigits[0] = counterDigits[1] = 0;
|
|
counterDigits[2] = gSaveContext.save.saveInfo.playerData.rupees;
|
|
|
|
if ((counterDigits[2] > 9999) || (counterDigits[2] < 0)) {
|
|
counterDigits[2] &= 0xDDD;
|
|
}
|
|
|
|
while (counterDigits[2] >= 100) {
|
|
counterDigits[0]++;
|
|
counterDigits[2] -= 100;
|
|
}
|
|
|
|
while (counterDigits[2] >= 10) {
|
|
counterDigits[1]++;
|
|
counterDigits[2] -= 10;
|
|
}
|
|
|
|
sp2CC = sRupeeDigitsFirst[CUR_UPG_VALUE(UPG_WALLET)];
|
|
sp2C8 = sRupeeDigitsCount[CUR_UPG_VALUE(UPG_WALLET)];
|
|
|
|
magicAlpha = interfaceCtx->magicAlpha;
|
|
if (magicAlpha > 180) {
|
|
magicAlpha = 180;
|
|
}
|
|
|
|
for (sp2CE = 0, sp2CA = 42; sp2CE < sp2C8; sp2CE++, sp2CC++, sp2CA += 8) {
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, magicAlpha);
|
|
|
|
OVERLAY_DISP = Gfx_DrawTexRectI8(OVERLAY_DISP, (u8*)gCounterDigit0Tex + (8 * 16 * counterDigits[sp2CC]), 8,
|
|
16, sp2CA + 1, 207, 8, 16, 1 << 10, 1 << 10);
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
|
|
if (gSaveContext.save.saveInfo.playerData.rupees == CUR_CAPACITY(UPG_WALLET)) {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 120, 255, 0, interfaceCtx->magicAlpha);
|
|
} else if (gSaveContext.save.saveInfo.playerData.rupees != 0) {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->magicAlpha);
|
|
} else {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 100, 100, 100, interfaceCtx->magicAlpha);
|
|
}
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, sp2CA * 4, 824, (sp2CA * 4) + 0x20, 888, G_TX_RENDERTILE, 0, 0, 1 << 10,
|
|
1 << 10);
|
|
}
|
|
|
|
// @recomp Left align and shift left/up for magic meter
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, -margin_reduction * 4, -margin_reduction * 4);
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_LEFT, -margin_reduction * 4, -margin_reduction * 4, -margin_reduction * 4, -margin_reduction * 4);
|
|
|
|
Magic_DrawMeter(play);
|
|
|
|
// @recomp Draw the D-Pad and its item icons as well as the autosave icon if the game is unpaused.
|
|
if (pauseCtx->state != PAUSE_STATE_MAIN) {
|
|
draw_dpad(play);
|
|
draw_dpad_icons(play);
|
|
draw_autosave_icon(play);
|
|
}
|
|
|
|
// @recomp Right align and shift right/down for minimap
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_RIGHT, G_EX_ORIGIN_RIGHT,
|
|
-(SCREEN_WIDTH - margin_reduction) * 4, margin_reduction * 4,
|
|
-(SCREEN_WIDTH - margin_reduction) * 4, margin_reduction * 4);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_RIGHT, -(SCREEN_WIDTH - margin_reduction) * 4, margin_reduction * 4);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
Minimap_Draw(play);
|
|
|
|
// @recomp Reset viewport alignment for drawing the target reticle
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, 0, 0, 0);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, 0, 0);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
if ((R_PAUSE_BG_PRERENDER_STATE != 2) && (R_PAUSE_BG_PRERENDER_STATE != 3)) {
|
|
Target_Draw(&play->actorCtx.targetCtx, play);
|
|
}
|
|
|
|
// @recomp Right align and shift right/up for equipped items and buttons
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_RIGHT, G_EX_ORIGIN_RIGHT,
|
|
-(SCREEN_WIDTH - margin_reduction) * 4, -margin_reduction * 4,
|
|
-(SCREEN_WIDTH - margin_reduction) * 4, -margin_reduction * 4);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_RIGHT, -(SCREEN_WIDTH - margin_reduction) * 4, -margin_reduction * 4);
|
|
gEXSetScissorAlign(OVERLAY_DISP++, G_EX_ORIGIN_RIGHT, G_EX_ORIGIN_RIGHT, -(SCREEN_WIDTH - margin_reduction), -margin_reduction, -(SCREEN_WIDTH - margin_reduction), -margin_reduction, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
|
|
|
|
Interface_DrawItemButtons(play);
|
|
|
|
if (player->transformation == GET_PLAYER_FORM) {
|
|
Interface_DrawBButtonIcons(play);
|
|
}
|
|
Interface_DrawCButtonIcons(play);
|
|
|
|
Interface_DrawAButton(play);
|
|
|
|
// @recomp Adjust any scissors to cover the whole screen
|
|
gEXSetScissorAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_RIGHT, 0, -margin_reduction, -SCREEN_WIDTH, margin_reduction, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
|
|
// @recomp Move the item being equipped from the center of the screen to the right edge as the timer counts down
|
|
if ((pauseCtx->state == PAUSE_STATE_MAIN) && ((pauseCtx->mainState == PAUSE_MAIN_STATE_EQUIP_ITEM) ||
|
|
(pauseCtx->mainState == PAUSE_MAIN_STATE_EQUIP_MASK))) {
|
|
extern s16 sEquipAnimTimer;
|
|
extern s16 sMaskEquipAnimTimer;
|
|
extern s16 sEquipState;
|
|
extern s16 sMaskEquipState;
|
|
s16 equip_timer = *(s16*)KaleidoManager_GetRamAddr(&sEquipAnimTimer);
|
|
s16 mask_equip_timer = *(s16*)KaleidoManager_GetRamAddr(&sMaskEquipAnimTimer);
|
|
s16 equip_state = *(s16*)KaleidoManager_GetRamAddr(&sEquipState);
|
|
s16 mask_equip_state = *(s16*)KaleidoManager_GetRamAddr(&sMaskEquipState);
|
|
|
|
s16 timer = MIN(equip_timer, mask_equip_timer);
|
|
s32 max_timer = 10;
|
|
|
|
// Prevent the timer from being used to calculate the origin when an arrow effect is taking place.
|
|
if (equip_timer < 10 && equip_state != EQUIP_STATE_MOVE_TO_C_BTN) {
|
|
timer = 10;
|
|
}
|
|
|
|
// Adjust the max timer value if a magic arrow is being equipped.
|
|
if ((pauseCtx->equipTargetItem == ITEM_BOW_FIRE) ||
|
|
(pauseCtx->equipTargetItem == ITEM_BOW_ICE) ||
|
|
(pauseCtx->equipTargetItem == ITEM_BOW_LIGHT)) {
|
|
max_timer = 6;
|
|
}
|
|
|
|
s32 origin = (G_EX_ORIGIN_CENTER - G_EX_ORIGIN_RIGHT) * (timer - 1) / (max_timer - 1) + G_EX_ORIGIN_RIGHT;
|
|
s32 offset = (SCREEN_WIDTH / 2) * (timer - 1) / (max_timer - 1) - SCREEN_WIDTH;
|
|
gEXSetRectAlign(OVERLAY_DISP++, origin, origin, offset * 4, 0, offset * 4, 0);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, origin, offset * 4, 0);
|
|
}
|
|
Interface_DrawPauseMenuEquippingIcons(play);
|
|
|
|
// Draw either the minigame countdown or the three-day clock
|
|
if ((play->pauseCtx.state == PAUSE_STATE_OFF) && (play->pauseCtx.debugEditor == DEBUG_EDITOR_NONE)) {
|
|
if ((interfaceCtx->minigameState != MINIGAME_STATE_NONE) &&
|
|
(interfaceCtx->minigameState < MINIGAME_STATE_NO_COUNTDOWN_SETUP)) {
|
|
// Minigame Countdown
|
|
if (((u32)interfaceCtx->minigameState % 2) == 0) {
|
|
// @recomp Restore normal alignment and reset shift for minigame countdown
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, 0, 0, 0);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, 0, 0);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
sp2CE = (interfaceCtx->minigameState >> 1) - 1;
|
|
minigameCountdownScale = interfaceCtx->minigameCountdownScale / 100.0f;
|
|
|
|
if (sp2CE == 3) {
|
|
interfaceCtx->actionVtx[40 + 0].v.ob[0] = interfaceCtx->actionVtx[40 + 2].v.ob[0] = -20;
|
|
interfaceCtx->actionVtx[40 + 1].v.ob[0] = interfaceCtx->actionVtx[40 + 3].v.ob[0] =
|
|
interfaceCtx->actionVtx[40 + 0].v.ob[0] + 40;
|
|
interfaceCtx->actionVtx[40 + 1].v.tc[0] = interfaceCtx->actionVtx[40 + 3].v.tc[0] = 40 << 5;
|
|
}
|
|
|
|
interfaceCtx->actionVtx[40 + 2].v.tc[1] = interfaceCtx->actionVtx[40 + 3].v.tc[1] = 32 << 5;
|
|
|
|
Gfx_SetupDL42_Overlay(play->state.gfxCtx);
|
|
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
|
|
gDPSetAlphaCompare(OVERLAY_DISP++, G_AC_THRESHOLD);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, sMinigameCountdownPrimColors[sp2CE].r,
|
|
sMinigameCountdownPrimColors[sp2CE].g, sMinigameCountdownPrimColors[sp2CE].b,
|
|
interfaceCtx->minigameCountdownAlpha);
|
|
|
|
Matrix_Translate(0.0f, -40.0f, 0.0f, MTXMODE_NEW);
|
|
Matrix_Scale(minigameCountdownScale, minigameCountdownScale, 0.0f, MTXMODE_APPLY);
|
|
|
|
gSPMatrix(OVERLAY_DISP++, Matrix_NewMtx(play->state.gfxCtx),
|
|
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
|
|
gSPVertex(OVERLAY_DISP++, &interfaceCtx->actionVtx[40], 4, 0);
|
|
|
|
OVERLAY_DISP = Gfx_DrawTexQuadIA8(OVERLAY_DISP, sMinigameCountdownTextures[sp2CE],
|
|
sMinigameCountdownTexWidths[sp2CE], 32, 0);
|
|
}
|
|
} else {
|
|
// @recomp Use normal alignment and shift down for clock
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, margin_reduction * 4, 0, margin_reduction * 4);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, 0, margin_reduction * 4);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
Interface_DrawClock(play);
|
|
}
|
|
}
|
|
|
|
// @recomp Restore normal alignment and reset shift for minigame "Perfect" text
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, 0, 0, 0);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, 0, 0);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
// Draw the letters of minigame perfect
|
|
if (interfaceCtx->perfectLettersOn) {
|
|
Interface_DrawPerfectLetters(play);
|
|
}
|
|
|
|
// @recomp Align left and shift up for minigame icons (carrot icons use an extended gbi texrect to ignore this state).
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, G_EX_ORIGIN_LEFT, 0, -margin_reduction * 4, 0, -margin_reduction * 4);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_LEFT, 0, -margin_reduction * 4);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
|
|
Interface_DrawMinigameIcons(play);
|
|
Interface_DrawTimers(play);
|
|
|
|
// @recomp Restore normal alignment and shift down for minigame countdown or clock
|
|
gEXSetRectAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, 0, 0, 0);
|
|
gEXSetViewportAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, 0, 0);
|
|
gEXSetScissorAlign(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, 0, 0, 0, 0, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
Interface_SetOrthoView(interfaceCtx);
|
|
}
|
|
|
|
// Draw pictograph focus icons
|
|
if (sPictoState == PICTO_BOX_STATE_LENS) {
|
|
|
|
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
|
|
|
|
gDPSetAlphaCompare(OVERLAY_DISP++, G_AC_THRESHOLD);
|
|
gDPSetRenderMode(OVERLAY_DISP++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 155, 255);
|
|
gDPLoadTextureBlock_4b(OVERLAY_DISP++, gPictoBoxFocusBorderTex, G_IM_FMT_IA, 16, 16, 0, G_TX_MIRROR | G_TX_WRAP,
|
|
G_TX_MIRROR | G_TX_WRAP, 4, 4, G_TX_NOLOD, G_TX_NOLOD);
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, R_PICTO_FOCUS_BORDER_TOPLEFT_X << 2, R_PICTO_FOCUS_BORDER_TOPLEFT_Y << 2,
|
|
(R_PICTO_FOCUS_BORDER_TOPLEFT_X << 2) + (16 << 2),
|
|
(R_PICTO_FOCUS_BORDER_TOPLEFT_Y << 2) + (16 << 2), G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
gSPTextureRectangle(OVERLAY_DISP++, R_PICTO_FOCUS_BORDER_TOPRIGHT_X << 2, R_PICTO_FOCUS_BORDER_TOPRIGHT_Y << 2,
|
|
(R_PICTO_FOCUS_BORDER_TOPRIGHT_X << 2) + (16 << 2),
|
|
(R_PICTO_FOCUS_BORDER_TOPRIGHT_Y << 2) + (16 << 2), G_TX_RENDERTILE, 512, 0, 1 << 10,
|
|
1 << 10);
|
|
gSPTextureRectangle(
|
|
OVERLAY_DISP++, R_PICTO_FOCUS_BORDER_BOTTOMLEFT_X << 2, R_PICTO_FOCUS_BORDER_BOTTOMLEFT_Y << 2,
|
|
(R_PICTO_FOCUS_BORDER_BOTTOMLEFT_X << 2) + (16 << 2), (R_PICTO_FOCUS_BORDER_BOTTOMLEFT_Y << 2) + (16 << 2),
|
|
G_TX_RENDERTILE, 0, 512, 1 << 10, 1 << 10);
|
|
gSPTextureRectangle(
|
|
OVERLAY_DISP++, R_PICTO_FOCUS_BORDER_BOTTOMRIGHT_X << 2, R_PICTO_FOCUS_BORDER_BOTTOMRIGHT_Y << 2,
|
|
(R_PICTO_FOCUS_BORDER_BOTTOMRIGHT_X << 2) + (16 << 2),
|
|
(R_PICTO_FOCUS_BORDER_BOTTOMRIGHT_Y << 2) + (16 << 2), G_TX_RENDERTILE, 512, 512, 1 << 10, 1 << 10);
|
|
|
|
gDPLoadTextureBlock_4b(OVERLAY_DISP++, gPictoBoxFocusIconTex, G_IM_FMT_I, 32, 16, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, R_PICTO_FOCUS_ICON_X << 2, R_PICTO_FOCUS_ICON_Y << 2,
|
|
(R_PICTO_FOCUS_ICON_X << 2) + 0x80, (R_PICTO_FOCUS_ICON_Y << 2) + (16 << 2),
|
|
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
|
|
gDPLoadTextureBlock_4b(OVERLAY_DISP++, gPictoBoxFocusTextTex, G_IM_FMT_I, 32, 8, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, R_PICTO_FOCUS_TEXT_X << 2, R_PICTO_FOCUS_TEXT_Y << 2,
|
|
(R_PICTO_FOCUS_TEXT_X << 2) + 0x80, (R_PICTO_FOCUS_TEXT_Y << 2) + 0x20, G_TX_RENDERTILE, 0,
|
|
0, 1 << 10, 1 << 10);
|
|
}
|
|
|
|
// Draw pictograph photo
|
|
if (sPictoState >= PICTO_BOX_STATE_SETUP_PHOTO) {
|
|
if (!(play->actorCtx.flags & ACTORCTX_FLAG_PICTO_BOX_ON)) {
|
|
Play_CompressI8ToI5((play->pictoPhotoI8 != NULL) ? play->pictoPhotoI8 : gWorkBuffer,
|
|
(u8*)gSaveContext.pictoPhotoI5, PICTO_PHOTO_WIDTH * PICTO_PHOTO_HEIGHT);
|
|
|
|
interfaceCtx->unk_222 = interfaceCtx->unk_224 = 0;
|
|
|
|
sPictoState = PICTO_BOX_STATE_OFF;
|
|
gSaveContext.hudVisibility = HUD_VISIBILITY_IDLE;
|
|
Interface_SetHudVisibility(HUD_VISIBILITY_ALL);
|
|
} else {
|
|
s16 pictoRectTop;
|
|
s16 pictoRectLeft;
|
|
|
|
if (sPictoState == PICTO_BOX_STATE_SETUP_PHOTO) {
|
|
sPictoState = PICTO_BOX_STATE_PHOTO;
|
|
Message_StartTextbox(play, 0xF8, NULL);
|
|
Interface_SetHudVisibility(HUD_VISIBILITY_NONE);
|
|
player->stateFlags1 |= PLAYER_STATE1_200;
|
|
}
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetRenderMode(OVERLAY_DISP++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 200, 200, 200, 250);
|
|
gDPFillRectangle(OVERLAY_DISP++, 70, 22, 251, 151);
|
|
|
|
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
|
|
|
|
gDPSetRenderMode(OVERLAY_DISP++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEI_PRIM, G_CC_MODULATEI_PRIM);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 250, 160, 160, 255);
|
|
|
|
// Picture is offset up by 33 pixels to give room for the message box at the bottom
|
|
pictoRectTop = PICTO_PHOTO_TOPLEFT_Y - 33;
|
|
for (sp2CC = 0; sp2CC < (PICTO_PHOTO_HEIGHT / 8); sp2CC++, pictoRectTop += 8) {
|
|
pictoRectLeft = PICTO_PHOTO_TOPLEFT_X;
|
|
gDPLoadTextureBlock(OVERLAY_DISP++,
|
|
(u8*)((play->pictoPhotoI8 != NULL) ? play->pictoPhotoI8 : gWorkBuffer) +
|
|
(0x500 * sp2CC),
|
|
G_IM_FMT_I, G_IM_SIZ_8b, PICTO_PHOTO_WIDTH, 8, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, pictoRectLeft << 2, pictoRectTop << 2,
|
|
(pictoRectLeft + PICTO_PHOTO_WIDTH) << 2, (pictoRectTop << 2) + (8 << 2),
|
|
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Draw over the entire screen (used in gameover)
|
|
if (interfaceCtx->screenFillAlpha != 0) {
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gSPDisplayList(OVERLAY_DISP++, sScreenFillSetupDL);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 0, 0, interfaceCtx->screenFillAlpha);
|
|
gSPDisplayList(OVERLAY_DISP++, D_0E000000.fillRect);
|
|
}
|
|
|
|
CLOSE_DISPS(play->state.gfxCtx);
|
|
}
|
|
|
|
extern u64 gCarrotIconTex[];
|
|
extern u64 gBeaverRingIconTex[];
|
|
extern u64 gSwordTrainingLogIconTex[];
|
|
extern u64 gFishermanMinigameTorchIconTex[];
|
|
extern u64 gArcheryScoreIconTex[];
|
|
extern u16 sMinigameScoreDigits[];
|
|
|
|
// @recomp Patched to draw the carrot icons with an extended gbi texrect so they don't inherit the current origin.
|
|
void Interface_DrawMinigameIcons(PlayState* play) {
|
|
InterfaceContext* interfaceCtx = &play->interfaceCtx;
|
|
s16 i;
|
|
s16 numDigitsDrawn;
|
|
s16 rectX;
|
|
s16 rectY;
|
|
s16 width;
|
|
s16 height;
|
|
|
|
OPEN_DISPS(play->state.gfxCtx);
|
|
|
|
Gfx_SetupDL39_Overlay(play->state.gfxCtx);
|
|
|
|
if ((play->pauseCtx.state == PAUSE_STATE_OFF) && (play->pauseCtx.debugEditor == DEBUG_EDITOR_NONE)) {
|
|
// Carrots rendering if the action corresponds to riding a horse
|
|
if (interfaceCtx->unk_212 == DO_ACTION_FASTER) {
|
|
// Load Carrot Icon
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gCarrotIconTex, G_IM_FMT_RGBA, G_IM_SIZ_32b, 16, 16, 0,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
|
|
rectX = 110;
|
|
rectY = (interfaceCtx->minigameState != MINIGAME_STATE_NONE) ? 200 : 56;
|
|
|
|
// Draw 6 carrots
|
|
for (i = 1; i < 7; i++, rectX += 16) {
|
|
// Carrot Color (based on availability)
|
|
if ((interfaceCtx->numHorseBoosts == 0) || (interfaceCtx->numHorseBoosts < i)) {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 0, 150, 255, interfaceCtx->aAlpha);
|
|
} else {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->aAlpha);
|
|
}
|
|
|
|
// @recomp Draw the carrot icons with an extended gbi texrect, using none as the origin to override the current alignment.
|
|
gEXTextureRectangle(OVERLAY_DISP++, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE, rectX << 2, rectY << 2, (rectX + 16) << 2, (rectY + 16) << 2,
|
|
G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
}
|
|
}
|
|
|
|
if (gSaveContext.minigameStatus == MINIGAME_STATUS_ACTIVE) {
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineLERP(OVERLAY_DISP++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0,
|
|
PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
|
|
width = 24;
|
|
height = 16;
|
|
rectX = 20;
|
|
if (gSaveContext.save.saveInfo.playerData.healthCapacity > 0xA0) {
|
|
rectY = 75; // two rows of hearts
|
|
} else {
|
|
rectY = 67; // one row of hearts
|
|
}
|
|
|
|
if (gSaveContext.save.entrance == ENTRANCE(WATERFALL_RAPIDS, 1)) {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->bAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, 255);
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gBeaverRingIconTex, G_IM_FMT_RGBA, G_IM_SIZ_32b, 24, 16, 0,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
} else if (play->sceneId == SCENE_DOUJOU) {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 140, 50, interfaceCtx->bAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, 255);
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gSwordTrainingLogIconTex, G_IM_FMT_IA, G_IM_SIZ_8b, 24, 16, 0,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
} else if (play->sceneId == SCENE_30GYOSON) {
|
|
width = 16;
|
|
height = 30;
|
|
rectX = 24;
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 100, 75, interfaceCtx->bAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 55, 55, 0, 255);
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gFishermanMinigameTorchIconTex, G_IM_FMT_IA, G_IM_SIZ_8b, 16, 30, 0,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
} else {
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->bAlpha);
|
|
gDPSetEnvColor(OVERLAY_DISP++, 0, 0, 0, 255);
|
|
gDPLoadTextureBlock(OVERLAY_DISP++, gArcheryScoreIconTex, G_IM_FMT_RGBA, G_IM_SIZ_16b, 24, 16, 0,
|
|
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK,
|
|
G_TX_NOLOD, G_TX_NOLOD);
|
|
}
|
|
|
|
gSPTextureRectangle(OVERLAY_DISP++, (rectX << 2), (rectY << 2), ((rectX + width) << 2),
|
|
((rectY + height) << 2), G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetPrimColor(OVERLAY_DISP++, 0, 0, 255, 255, 255, interfaceCtx->bAlpha);
|
|
gDPSetCombineLERP(OVERLAY_DISP++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE, TEXEL0,
|
|
0, PRIMITIVE, 0);
|
|
|
|
if (play->sceneId == SCENE_30GYOSON) {
|
|
rectX += 20;
|
|
if (gSaveContext.save.saveInfo.playerData.healthCapacity > 0xA0) {
|
|
rectY = 87; // two rows of hearts
|
|
} else {
|
|
rectY = 79; // one row of hearts
|
|
}
|
|
} else {
|
|
rectX += 26;
|
|
}
|
|
|
|
for (i = 0, numDigitsDrawn = 0; i < 4; i++) {
|
|
if ((sMinigameScoreDigits[i] != 0) || (numDigitsDrawn != 0) || (i >= 3)) {
|
|
OVERLAY_DISP =
|
|
Gfx_DrawTexRectI8(OVERLAY_DISP, ((u8*)gCounterDigit0Tex + (8 * 16 * sMinigameScoreDigits[i])),
|
|
8, 0x10, rectX, rectY - 2, 9, 0xFA, 0x370, 0x370);
|
|
rectX += 9;
|
|
numDigitsDrawn++;
|
|
}
|
|
}
|
|
|
|
gDPPipeSync(OVERLAY_DISP++);
|
|
gDPSetCombineMode(OVERLAY_DISP++, G_CC_MODULATEIA_PRIM, G_CC_MODULATEIA_PRIM);
|
|
}
|
|
}
|
|
|
|
CLOSE_DISPS(play->state.gfxCtx);
|
|
}
|
|
|
|
|
|
extern s16 sTextboxWidth;
|
|
extern s16 sTextboxHeight;
|
|
extern s16 sTextboxTexWidth;
|
|
extern s16 sTextboxTexHeight;
|
|
extern u64 gOcarinaTrebleClefTex[];
|
|
|
|
// @recomp Patch textboxes to use ortho tris with a matrix so they can be interpolated.
|
|
void Message_DrawTextBox(PlayState* play, Gfx** gfxP) {
|
|
MessageContext* msgCtx = &play->msgCtx;
|
|
Gfx* gfx = *gfxP;
|
|
|
|
gDPPipeSync(gfx++);
|
|
|
|
if (((u32)msgCtx->textBoxType == TEXTBOX_TYPE_0) || (msgCtx->textBoxType == TEXTBOX_TYPE_2) ||
|
|
(msgCtx->textBoxType == TEXTBOX_TYPE_9) || (msgCtx->textBoxType == TEXTBOX_TYPE_A)) {
|
|
gDPSetRenderMode(gfx++, G_RM_CLD_SURF, G_RM_CLD_SURF2);
|
|
} else if (msgCtx->textBoxType == TEXTBOX_TYPE_3) {
|
|
gDPSetAlphaCompare(gfx++, G_AC_THRESHOLD);
|
|
gDPSetRenderMode(gfx++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
|
|
}
|
|
|
|
gDPSetPrimColor(gfx++, 0, 0, msgCtx->textboxColorRed, msgCtx->textboxColorGreen, msgCtx->textboxColorBlue,
|
|
msgCtx->textboxColorAlphaCurrent);
|
|
|
|
if (((u32)msgCtx->textBoxType == TEXTBOX_TYPE_0) || (msgCtx->textBoxType == TEXTBOX_TYPE_2) ||
|
|
(msgCtx->textBoxType == TEXTBOX_TYPE_6) || (msgCtx->textBoxType == TEXTBOX_TYPE_8) ||
|
|
(msgCtx->textBoxType == TEXTBOX_TYPE_9) || (msgCtx->textBoxType == TEXTBOX_TYPE_A)) {
|
|
gDPLoadTextureBlock_4b(gfx++, msgCtx->textboxSegment, G_IM_FMT_I, 128, 64, 0, G_TX_MIRROR | G_TX_WRAP,
|
|
G_TX_NOMIRROR | G_TX_WRAP, 7, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
} else {
|
|
gDPPipeSync(gfx++);
|
|
|
|
if (msgCtx->textBoxType == TEXTBOX_TYPE_3) {
|
|
gDPSetEnvColor(gfx++, 0, 0, 0, 255);
|
|
} else if (msgCtx->textBoxType == TEXTBOX_TYPE_D) {
|
|
gDPSetEnvColor(gfx++, 20, 0, 10, 255);
|
|
} else {
|
|
gDPSetEnvColor(gfx++, 50, 20, 0, 255);
|
|
}
|
|
gDPLoadTextureBlock_4b(gfx++, msgCtx->textboxSegment, G_IM_FMT_IA, 128, 64, 0, G_TX_MIRROR | G_TX_WRAP,
|
|
G_TX_MIRROR | G_TX_WRAP, 7, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
}
|
|
|
|
// @recomp Push the old RDP/RSP params.
|
|
gEXPushProjectionMatrix(gfx++);
|
|
gEXPushGeometryMode(gfx++);
|
|
gEXPushOtherMode(gfx++);
|
|
gEXPushViewport(gfx++);
|
|
gEXMatrixGroupSimple(gfx++, TEXTBOX_TRANSFORM_PROJECTION_ID, G_EX_PUSH, G_MTX_PROJECTION,
|
|
G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_ORDER_LINEAR, G_EX_EDIT_NONE);
|
|
gEXMatrixGroupSimple(gfx++, TEXTBOX_TRANSFORM_ID, G_EX_PUSH, G_MTX_MODELVIEW,
|
|
G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_ORDER_LINEAR, G_EX_EDIT_NONE);
|
|
|
|
// @recomp Set up the RSP params.
|
|
gSPLoadGeometryMode(gfx++, 0);
|
|
gSPTexture(gfx++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
|
|
Vp* textbox_viewport = GRAPH_ALLOC(play->state.gfxCtx, sizeof(Vp));
|
|
|
|
textbox_viewport->vp.vscale[0] = (gCfbWidth / 2) << 2;
|
|
textbox_viewport->vp.vscale[1] = (gCfbHeight / 2) << 2;
|
|
textbox_viewport->vp.vscale[2] = G_MAXZ;
|
|
textbox_viewport->vp.vscale[3] = 0;
|
|
|
|
textbox_viewport->vp.vtrans[0] = (gCfbWidth / 2) << 2;
|
|
textbox_viewport->vp.vtrans[1] = (gCfbHeight / 2) << 2;
|
|
textbox_viewport->vp.vtrans[2] = 0;
|
|
textbox_viewport->vp.vtrans[3] = 0;
|
|
|
|
gSPViewport(gfx++, textbox_viewport);
|
|
|
|
if (msgCtx->textBoxType == TEXTBOX_TYPE_A) {
|
|
gSPTextureRectangle(gfx++, msgCtx->textboxX << 2, (msgCtx->textboxY + 22) << 2,
|
|
(msgCtx->textboxX + msgCtx->unk12008) << 2, (msgCtx->textboxY + 54) << 2, G_TX_RENDERTILE,
|
|
0, 6, msgCtx->unk1200C << 1, 2 << 10);
|
|
} else {
|
|
const s32 base_textbox_width = 256;
|
|
const s32 base_textbox_height = 64;
|
|
|
|
// @recomp Calculate a scale based on the the target size derivatives.
|
|
f32 textbox_scale_x = sTextboxWidth / (f32)base_textbox_width;
|
|
f32 textbox_scale_y = sTextboxHeight / (f32)base_textbox_height;
|
|
|
|
// @recomp Calculate the textbox center.
|
|
f32 textbox_center_x = msgCtx->textboxX + sTextboxWidth / 2.0f;
|
|
f32 textbox_center_y = msgCtx->textboxY + sTextboxHeight / 2.0f;
|
|
|
|
// @recomp Allocate and build the matrices.
|
|
Mtx* textbox_model_matrix = GRAPH_ALLOC(play->state.gfxCtx, sizeof(Mtx));
|
|
Mtx* textbox_proj_matrix = GRAPH_ALLOC(play->state.gfxCtx, sizeof(Mtx));
|
|
guOrtho(textbox_proj_matrix, 0, gCfbWidth, gCfbHeight, 0, -1.0f, 1.0f, 1.0f);
|
|
Mtx_SetTranslateScaleMtx(textbox_model_matrix, textbox_scale_x, textbox_scale_y, 1.0f, textbox_center_x, textbox_center_y, 0.0f);
|
|
|
|
// @recomp Static vertex list for the textboxes.
|
|
static Vtx textbox_verts[4] = {
|
|
{{{-base_textbox_width / 2, -base_textbox_height / 2, 0}, 0, { 0 << 5, 0 << 5}, {0, 0, 0, 0xFF}}},
|
|
{{{ base_textbox_width / 2, -base_textbox_height / 2, 0}, 0, {base_textbox_width << 5, 0 << 5}, {0, 0, 0, 0xFF}}},
|
|
{{{-base_textbox_width / 2, base_textbox_height / 2, 0}, 0, { 0 << 5, base_textbox_height << 5}, {0, 0, 0, 0xFF}}},
|
|
{{{ base_textbox_width / 2, base_textbox_height / 2, 0}, 0, {base_textbox_width << 5, base_textbox_height << 5}, {0, 0, 0, 0xFF}}},
|
|
};
|
|
|
|
// @recomp Loads the matrices, then the verts, and then draw the textbox.
|
|
gSPMatrix(gfx++, textbox_model_matrix, G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
|
|
gSPMatrix(gfx++, textbox_proj_matrix, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
|
|
gSPVertex(gfx++, textbox_verts, 4, 0);
|
|
|
|
// @recomp Use point filtering as this texture doesn't work well with bilerp. Also enable perspective correction for drawing tris.
|
|
gDPSetTextureFilter(gfx++, G_TF_POINT);
|
|
gDPSetTexturePersp(gfx++, G_TP_PERSP);
|
|
gSP2Triangles(gfx++, 0, 1, 3, 0x0, 0, 3, 2, 0x0);
|
|
|
|
// @recomp Restore bilerp filtering, disable perspective correction, and pop the model matrix
|
|
gDPSetTextureFilter(gfx++, G_TF_BILERP);
|
|
gDPSetTexturePersp(gfx++, G_TP_NONE);
|
|
gSPPopMatrix(gfx++, G_MTX_MODELVIEW);
|
|
}
|
|
|
|
// Draw treble clef
|
|
if (msgCtx->textBoxType == TEXTBOX_TYPE_3) {
|
|
gDPPipeSync(gfx++);
|
|
gDPSetCombineLERP(gfx++, 1, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE, 0, 1, 0, PRIMITIVE, 0, TEXEL0, 0, PRIMITIVE,
|
|
0);
|
|
gDPSetPrimColor(gfx++, 0, 0, 255, 100, 0, 255);
|
|
gDPLoadTextureBlock_4b(gfx++, gOcarinaTrebleClefTex, G_IM_FMT_I, 16, 32, 0, G_TX_MIRROR | G_TX_WRAP,
|
|
G_TX_MIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
gSPTextureRectangle(gfx++, 78 << 2, 166 << 2, 94 << 2, 198 << 2, G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
|
|
}
|
|
|
|
// @recomp Restore the old RDP/RSP params.
|
|
gEXPopProjectionMatrix(gfx++);
|
|
gEXPopGeometryMode(gfx++);
|
|
gEXPopOtherMode(gfx++);
|
|
gEXPopViewport(gfx++);
|
|
gSPPopMatrix(gfx++, G_MTX_MODELVIEW);
|
|
gEXPopMatrixGroup(gfx++, G_MTX_MODELVIEW);
|
|
gEXPopMatrixGroup(gfx++, G_MTX_PROJECTION);
|
|
gSPPerspNormalize(gfx++, play->view.perspNorm);
|
|
|
|
*gfxP = gfx++;
|
|
}
|
|
|
|
void View_SetScissor(Gfx** gfx, s32 ulx, s32 uly, s32 lrx, s32 lry);
|
|
|
|
// @recomp Patched to not actually letterbox the scissor. The letterbox effect will be achieved by drawing an overlay on top instead, which
|
|
// will get interpolated unlike a scissor.
|
|
void View_ApplyLetterbox(View* view) {
|
|
s32 letterboxY;
|
|
s32 letterboxX;
|
|
s32 pad1;
|
|
s32 ulx;
|
|
s32 uly;
|
|
s32 lrx;
|
|
s32 lry;
|
|
|
|
OPEN_DISPS(view->gfxCtx);
|
|
|
|
// @recomp Disable letterboxing for the scissor.
|
|
letterboxY = 0; // ShrinkWindow_Letterbox_GetSize();
|
|
|
|
letterboxX = -1; // The following is optimized to varX = 0 but affects codegen
|
|
|
|
if (letterboxX < 0) {
|
|
letterboxX = 0;
|
|
}
|
|
if (letterboxX > (SCREEN_WIDTH / 2)) {
|
|
letterboxX = SCREEN_WIDTH / 2;
|
|
}
|
|
|
|
if (letterboxY < 0) {
|
|
letterboxY = 0;
|
|
} else if (letterboxY > (SCREEN_HEIGHT / 2)) {
|
|
letterboxY = SCREEN_HEIGHT / 2;
|
|
}
|
|
|
|
ulx = view->viewport.leftX + letterboxX;
|
|
uly = view->viewport.topY + letterboxY;
|
|
lrx = view->viewport.rightX - letterboxX;
|
|
lry = view->viewport.bottomY - letterboxY;
|
|
|
|
gDPPipeSync(POLY_OPA_DISP++);
|
|
{
|
|
s32 pad2;
|
|
Gfx* polyOpa;
|
|
|
|
polyOpa = POLY_OPA_DISP;
|
|
View_SetScissor(&polyOpa, ulx, uly, lrx, lry);
|
|
POLY_OPA_DISP = polyOpa;
|
|
}
|
|
|
|
gDPPipeSync(POLY_XLU_DISP++);
|
|
{
|
|
Gfx* polyXlu;
|
|
s32 pad3;
|
|
|
|
polyXlu = POLY_XLU_DISP;
|
|
View_SetScissor(&polyXlu, ulx, uly, lrx, lry);
|
|
POLY_XLU_DISP = polyXlu;
|
|
}
|
|
|
|
CLOSE_DISPS(view->gfxCtx);
|
|
}
|
|
|
|
typedef struct {
|
|
/* 0x0 */ s8 letterboxTarget;
|
|
/* 0x1 */ s8 letterboxSize;
|
|
/* 0x2 */ s8 pillarboxTarget;
|
|
/* 0x3 */ s8 pillarboxSize;
|
|
} ShrinkWindow; // size = 0x4
|
|
|
|
extern ShrinkWindow* sShrinkWindowPtr;
|
|
|
|
// @recomp Replace the rects used to letterbox with ortho tris so they can be interpolated.
|
|
void ShrinkWindow_Draw(GraphicsContext* gfxCtx) {
|
|
Gfx* gfx;
|
|
s8 letterboxSize = sShrinkWindowPtr->letterboxSize;
|
|
s8 pillarboxSize = sShrinkWindowPtr->pillarboxSize;
|
|
|
|
// @recomp Always draw the letterbox tris so that they the matrices can still be interpolated on the first frame they appear.
|
|
// Avoid drawing it at a specific point in the pausing process.
|
|
if (R_PAUSE_BG_PRERENDER_STATE != PAUSE_BG_PRERENDER_PROCESS) { //letterboxSize > 0) {
|
|
OPEN_DISPS(gfxCtx);
|
|
|
|
gfx = OVERLAY_DISP;
|
|
|
|
// @recomp Push the old RDP/RSP params.
|
|
gEXPushProjectionMatrix(gfx++);
|
|
gEXPushGeometryMode(gfx++);
|
|
gEXPushOtherMode(gfx++);
|
|
gEXPushCombineMode(gfx++);
|
|
|
|
// @recomp Set up the new RSP/RDP params.
|
|
gDPSetCycleType(gfx++, G_CYC_1CYCLE);
|
|
gDPSetRenderMode(gfx++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
|
|
gDPSetCombineLERP(gfx++, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1);
|
|
gSPLoadGeometryMode(gfx++, 0);
|
|
|
|
// @recomp Set up the letterbox matrix groups.
|
|
gEXMatrixGroupSimple(gfx++, TEXTBOX_TRANSFORM_PROJECTION_ID, G_EX_PUSH, G_MTX_PROJECTION,
|
|
G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_ORDER_LINEAR, G_EX_EDIT_NONE);
|
|
gEXMatrixGroupSimple(gfx++, TEXTBOX_TRANSFORM_ID, G_EX_PUSH, G_MTX_MODELVIEW,
|
|
G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_COMPONENT_INTERPOLATE, G_EX_ORDER_LINEAR, G_EX_EDIT_NONE);
|
|
|
|
// @recomp Allocate and build the matrices.
|
|
Mtx* ortho_matrix = GRAPH_ALLOC(gfxCtx, sizeof(Mtx));
|
|
Mtx* letterbox_matrix_top = GRAPH_ALLOC(gfxCtx, sizeof(Mtx));
|
|
Mtx* letterbox_matrix_bottom = GRAPH_ALLOC(gfxCtx, sizeof(Mtx));
|
|
|
|
guOrtho(ortho_matrix, -SCREEN_WIDTH / 2, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, -SCREEN_HEIGHT / 2, -1.0f, 1.0f, 1.0f);
|
|
Mtx_SetTranslateScaleMtx(letterbox_matrix_top, 1.0f, 1.0f, 1.0f, 0.0f, -SCREEN_HEIGHT / 2 + letterboxSize, 0.0f);
|
|
Mtx_SetTranslateScaleMtx(letterbox_matrix_bottom, 1.0f, -1.0f, 1.0f, 0.0f, SCREEN_HEIGHT / 2 - letterboxSize, 0.0f);
|
|
gSPMatrix(gfx++, ortho_matrix, G_MTX_PROJECTION | G_MTX_NOPUSH | G_MTX_LOAD);
|
|
|
|
// @recomp Static variable holding the letterbox vertices. The origin is at the edge to make calculating the translation matrix easy.
|
|
static Vtx letterbox_verts[4] = {
|
|
{{{-32000, -120, 0}, 0, {0, 0}, {0, 0, 0, 0xFF}}},
|
|
{{{ 32000, -120, 0}, 0, {0, 0}, {0, 0, 0, 0xFF}}},
|
|
{{{-32000, 0, 0}, 0, {0, 0}, {0, 0, 0, 0xFF}}},
|
|
{{{ 32000, 0, 0}, 0, {0, 0}, {0, 0, 0, 0xFF}}},
|
|
};
|
|
|
|
// @recomp Draw the top letterbox element.
|
|
gSPMatrix(gfx++, letterbox_matrix_top, G_MTX_MODELVIEW | G_MTX_PUSH | G_MTX_LOAD);
|
|
gSPVertex(gfx++, letterbox_verts, 4, 0);
|
|
gSP2Triangles(gfx++, 0, 1, 3, 0x0, 0, 3, 2, 0x0);
|
|
|
|
// @recomp Draw the bottom letterbox element.
|
|
gSPMatrix(gfx++, letterbox_matrix_bottom, G_MTX_MODELVIEW | G_MTX_NOPUSH | G_MTX_LOAD);
|
|
gSPVertex(gfx++, letterbox_verts, 4, 0);
|
|
gSP2Triangles(gfx++, 0, 3, 1, 0x0, 0, 2, 3, 0x0);
|
|
|
|
// @recomp Restore the old RDP/RSP params.
|
|
gEXPopProjectionMatrix(gfx++);
|
|
gEXPopGeometryMode(gfx++);
|
|
gEXPopOtherMode(gfx++);
|
|
gEXPopCombineMode(gfx++);
|
|
gSPPopMatrix(gfx++, G_MTX_MODELVIEW);
|
|
gEXPopMatrixGroup(gfx++, G_MTX_MODELVIEW);
|
|
gEXPopMatrixGroup(gfx++, G_MTX_PROJECTION);
|
|
|
|
OVERLAY_DISP = gfx++;
|
|
|
|
CLOSE_DISPS(gfxCtx);
|
|
}
|
|
|
|
if (pillarboxSize > 0) {
|
|
OPEN_DISPS(gfxCtx);
|
|
|
|
gfx = OVERLAY_DISP;
|
|
|
|
gDPPipeSync(gfx++);
|
|
gDPSetCycleType(gfx++, G_CYC_FILL);
|
|
gDPSetRenderMode(gfx++, G_RM_NOOP, G_RM_NOOP2);
|
|
gDPSetFillColor(gfx++, (GPACK_RGBA5551(0, 0, 0, 1) << 16) | GPACK_RGBA5551(0, 0, 0, 1));
|
|
|
|
gDPFillRectangle(gfx++, 0, 0, pillarboxSize - 1, gScreenHeight - 1);
|
|
gDPFillRectangle(gfx++, gScreenWidth - pillarboxSize, 0, gScreenWidth - 1, gScreenHeight - 1);
|
|
|
|
gDPPipeSync(gfx++);
|
|
gDPSetCycleType(gfx++, G_CYC_1CYCLE);
|
|
gDPSetRenderMode(gfx++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
|
|
gDPSetPrimColor(gfx++, 0, 0, 0, 0, 0, 0);
|
|
|
|
gDPFillRectangle(gfx++, pillarboxSize, 0, pillarboxSize + 2, gScreenHeight);
|
|
gDPFillRectangle(gfx++, gScreenWidth - pillarboxSize - 2, 0, gScreenWidth - pillarboxSize, gScreenHeight);
|
|
|
|
gDPPipeSync(gfx++);
|
|
OVERLAY_DISP = gfx++;
|
|
|
|
CLOSE_DISPS(gfxCtx);
|
|
}
|
|
}
|
|
|
|
extern u64 gSceneTitleCardGradientTex[];
|
|
|
|
// @recomp Patch the scene title card (the one with purple background when entering a new scene)
|
|
// to not glitch out on the right edge, which is hidden by overscan on N64.
|
|
void Message_DrawSceneTitleCard(PlayState* play, Gfx** gfxP) {
|
|
MessageContext* msgCtx = &play->msgCtx;
|
|
Gfx* gfx;
|
|
|
|
gfx = *gfxP;
|
|
Gfx_SetupDL39_Ptr(&gfx);
|
|
|
|
gDPSetCombineLERP(gfx++, PRIMITIVE, ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0, PRIMITIVE,
|
|
ENVIRONMENT, TEXEL0, ENVIRONMENT, TEXEL0, 0, PRIMITIVE, 0);
|
|
gDPSetTextureFilter(gfx++, G_TF_BILERP);
|
|
gDPSetAlphaDither(gfx++, G_AD_NOTPATTERN);
|
|
gDPSetPrimColor(gfx++, 0, 0, 0, 0, 0, msgCtx->textboxColorAlphaCurrent);
|
|
gDPSetEnvColor(gfx++, 140, 40, 160, 255);
|
|
gDPLoadTextureBlock(gfx++, gSceneTitleCardGradientTex, G_IM_FMT_I, G_IM_SIZ_8b, 64, 1, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
|
G_TX_NOMIRROR | G_TX_WRAP, 6, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
|
|
// @recomp Decrease dsdx from the original 204 to 200 in order to hide the glitching on the right edge.
|
|
gSPTextureRectangle(gfx++, 0, XREG(77) << 2, 320 << 2, (XREG(77) + XREG(76)) << 2, G_TX_RENDERTILE, 0, 0, 200,
|
|
1 << 10);
|
|
gDPPipeSync(gfx++);
|
|
gDPSetCombineLERP(gfx++, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0, 0, 0, 0, PRIMITIVE, TEXEL0, 0, PRIMITIVE, 0);
|
|
gDPSetEnvColor(gfx++, 0, 0, 0, 255);
|
|
|
|
if ((msgCtx->currentTextId < 0x1BB2) || (msgCtx->currentTextId >= 0x1BB7)) {
|
|
msgCtx->unk11FF8 = XREG(75);
|
|
}
|
|
msgCtx->unk11FFA = XREG(74);
|
|
Message_DrawTextNES(play, &gfx, 0);
|
|
*gfxP = gfx++;
|
|
}
|