The-Homebrew-Cloud/Zelda64Recomp
2
0
Fork 0
mirror of https://github.com/Mr-Wiseguy/Zelda64Recomp.git synced 2024-07-20 21:35:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Enable relevant RT64 enhancements, fix pause background corruption if song of soaring was played before ever pausing

Browse Source
This commit is contained in:
Mr-Wiseguy 2024-02-04 22:55:15 -05:00
parent 3326a1bcce
commit 958808acb0
7 changed files with 90 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/rt64_layer.h
View File

@ -14,6 +14,7 @@ namespace ultramodern {
RT64::Application* RT64Init(uint8_t* rom, uint8_t* rdram, ultramodern::WindowHandle window_handle);
void RT64UpdateConfig(RT64::Application* application, const ultramodern::GraphicsConfig& old_config, const ultramodern::GraphicsConfig& new_config);
void RT64EnableInstantPresent(RT64::Application* application);
void RT64SendDL(uint8_t* rdram, const OSTask* task);
void RT64UpdateScreen(uint32_t vi_origin);
void RT64ChangeWindow();

80
patches/fixes.c
View File

@ -31,8 +31,6 @@ s16 KaleidoScope_SetPageVertices(PlayState* play, Vtx* vtx, s16 vtxPage, s16 num
s32 cur_y;
u32 row;
gSegments[0x0D] = OS_K0_TO_PHYSICAL(play->pauseCtx.iconItemLangSegment);
cur_y = PAGE_BG_HEIGHT / 2;
// 2 verts per row plus 2 extra verts at the start and the end.
@ -74,10 +72,10 @@ s16 KaleidoScope_SetPageVertices(PlayState* play, Vtx* vtx, s16 vtxPage, s16 num
// These are overlay symbols, so their addresses need to be offset to get their actual loaded vram address.
// TODO remove this once the recompiler is able to handle overlay symbols automatically for patch functions.
s16** sVtxPageQuadsXRelocated = (s16**)((u8*)&sVtxPageQuadsX[0] + gKaleidoMgrOverlayTable[0].offset);
s16** sVtxPageQuadsWidthRelocated = (s16**)((u8*)&sVtxPageQuadsWidth[0] + gKaleidoMgrOverlayTable[0].offset);
s16** sVtxPageQuadsYRelocated = (s16**)((u8*)&sVtxPageQuadsY[0] + gKaleidoMgrOverlayTable[0].offset);
s16** sVtxPageQuadsHeightRelocated = (s16**)((u8*)&sVtxPageQuadsHeight[0] + gKaleidoMgrOverlayTable[0].offset);
s16** sVtxPageQuadsXRelocated = (s16**)KaleidoManager_GetRamAddr(sVtxPageQuadsX);
s16** sVtxPageQuadsWidthRelocated = (s16**)KaleidoManager_GetRamAddr(sVtxPageQuadsWidth);
s16** sVtxPageQuadsYRelocated = (s16**)KaleidoManager_GetRamAddr(sVtxPageQuadsY);
s16** sVtxPageQuadsHeightRelocated = (s16**)KaleidoManager_GetRamAddr(sVtxPageQuadsHeight);
s16 k = 60;
@ -128,8 +126,7 @@ typedef u8 bg_image_t[(2 + PAGE_BG_WIDTH) * (2 + PAGE_BG_HEIGHT)];
#define BG_IMAGE_COUNT 4
TexturePtr* bg_pointers[BG_IMAGE_COUNT];
bg_image_t bg_images[BG_IMAGE_COUNT];
u32 bg_image_count = 0;
bg_image_t bg_images[BG_IMAGE_COUNT] __attribute__((aligned(8)));
void assemble_image(TexturePtr* textures, bg_image_t* image_out) {
u8* pixels_out_start = *image_out;
@ -165,6 +162,58 @@ void assemble_image(TexturePtr* textures, bg_image_t* image_out) {
}
}
static bool assembled_kaleido_images = false;
extern TexturePtr sMaskPageBgTextures[];
extern TexturePtr sItemPageBgTextures[];
extern TexturePtr sMapPageBgTextures[];
extern TexturePtr sQuestPageBgTextures[];
extern void (*sKaleidoScopeUpdateFunc)(PlayState* play);
extern void (*sKaleidoScopeDrawFunc)(PlayState* play);
extern void KaleidoScope_Update(PlayState* play);
extern void KaleidoScope_Draw(PlayState* play);
void KaleidoUpdateWrapper(PlayState* play) {
KaleidoScope_Update(play);
}
void KaleidoDrawWrapper(PlayState* play) {
// @recomp Update the background image pointers to reflect the overlay's load address.
bg_pointers[0] = KaleidoManager_GetRamAddr(sMaskPageBgTextures);
bg_pointers[1] = KaleidoManager_GetRamAddr(sItemPageBgTextures);
bg_pointers[2] = KaleidoManager_GetRamAddr(sMapPageBgTextures);
bg_pointers[3] = KaleidoManager_GetRamAddr(sQuestPageBgTextures);
KaleidoScope_Draw(play);
// @recomp Check if this is the first time kaleido has been drawn. If so, assemble the background textures
// into the full seamless image.
if (!assembled_kaleido_images) {
assembled_kaleido_images = true;
// Record the old value for segments 0x08 and 0x0D, then update them with the correct values so that segmented addresses
// can be converted in assemble_image.
uintptr_t old_segment_08 = gSegments[0x08];
uintptr_t old_segment_0D = gSegments[0x0D];
gSegments[0x08] = OS_K0_TO_PHYSICAL(play->pauseCtx.iconItemSegment);
gSegments[0x0D] = OS_K0_TO_PHYSICAL(play->pauseCtx.iconItemLangSegment);
assemble_image(KaleidoManager_GetRamAddr(sMaskPageBgTextures), &bg_images[0]);
assemble_image(KaleidoManager_GetRamAddr(sItemPageBgTextures), &bg_images[1]);
assemble_image(KaleidoManager_GetRamAddr(sMapPageBgTextures), &bg_images[2]);
assemble_image(KaleidoManager_GetRamAddr(sQuestPageBgTextures), &bg_images[3]);
gSegments[0x08] = old_segment_08;
gSegments[0x0D] = old_segment_0D;
}
}
void KaleidoScopeCall_Init(PlayState* play) {
// @recomp Set the update and draw func pointers to the wrappers instead of the actual functions.
sKaleidoScopeUpdateFunc = KaleidoUpdateWrapper;
sKaleidoScopeDrawFunc = KaleidoDrawWrapper;
KaleidoSetup_Init(play);
}
// @recomp patched to fix bilerp seams.
Gfx* KaleidoScope_DrawPageSections(Gfx* gfx, Vtx* vertices, TexturePtr* textures) {
s32 i;
@ -172,24 +221,17 @@ Gfx* KaleidoScope_DrawPageSections(Gfx* gfx, Vtx* vertices, TexturePtr* textures
bg_image_t* cur_image = NULL;
// Check if this texture set has already been assembled into an image.
// Check if this texture set has been assembled into a full image.
u32 image_index;
for (image_index = 0; image_index < bg_image_count; image_index++) {
for (image_index = 0; image_index < BG_IMAGE_COUNT; image_index++) {
if (bg_pointers[image_index] == textures) {
cur_image = &bg_images[image_index];
break;
}
}
// If no image was found and there's a free image slot, assemble the image.
if (cur_image == NULL && image_index < BG_IMAGE_COUNT) {
assemble_image(textures, &bg_images[image_index]);
bg_pointers[image_index] = textures;
cur_image = &bg_images[image_index];
bg_image_count++;
}
if (cur_image == NULL) {
// No image was found and there are no free slots.
// No image was found.
return gfx;
}

2
patches/input.c
View File

@ -24,7 +24,7 @@ s32 func_80847190(PlayState* play, Player* this, s32 arg2) {
static float filtered_gyro_x, filtered_gyro_y;
static int applied_gyro_x, applied_gyro_y;
const float filter_factor = 0.50f;
const float filter_factor = 0.00f;
// TODO remappable gyro reset button
if (play->state.input[0].press.button & BTN_L) {

13
patches/ui_patches.c
View File

@ -394,17 +394,16 @@ void Interface_Draw(PlayState* play) {
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 (gKaleidoMgrOverlayTable[0].loadedRamAddr != NULL) {
// These are overlay symbols, so their addresses need to be offset to get their actual loaded vram address.
// TODO remove this once the recompiler is able to handle overlay symbols automatically for patch functions.
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*)((u8*)&sEquipAnimTimer + gKaleidoMgrOverlayTable[0].offset);
s16 mask_equip_timer = *(s16*)((u8*)&sMaskEquipAnimTimer + gKaleidoMgrOverlayTable[0].offset);
s16 equip_state = *(s16*)((u8*)&sEquipState + gKaleidoMgrOverlayTable[0].offset);
s16 mask_equip_state = *(s16*)((u8*)&sMaskEquipState + gKaleidoMgrOverlayTable[0].offset);
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;

2
src/game/config.cpp
View File

@ -114,7 +114,7 @@ void recomp::reset_graphics_options() {
new_config.wm_option = ultramodern::WindowMode::Windowed;
new_config.ar_option = RT64::UserConfiguration::AspectRatio::Expand;
new_config.msaa_option = RT64::UserConfiguration::Antialiasing::MSAA4X;
new_config.rr_option = RT64::UserConfiguration::RefreshRate::Original;
new_config.rr_option = RT64::UserConfiguration::RefreshRate::Display;
new_config.rr_manual_value = 60;
ultramodern::set_graphics_config(new_config);
}

14
src/recomp/rt64_layer.cpp
View File

@ -201,6 +201,13 @@ RT64::Application* RT64Init(uint8_t* rom, uint8_t* rdram, ultramodern::WindowHan
device_max_msaa = compute_max_supported_aa(common_sample_counts);
// Force gbi depth branches to prevent LODs from kicking in.
ret->enhancementConfig.f3dex.forceBranch = true;
// Scale LODs based on the output resolution.
ret->enhancementConfig.textureLOD.scale = true;
ret->updateEnhancementConfig();
return ret;
}
@ -260,6 +267,13 @@ void RT64UpdateConfig(RT64::Application* application, const ultramodern::Graphic
}
}
void RT64EnableInstantPresent(RT64::Application* application) {
// Enable the present early presentation mode for minimal latency.
application->enhancementConfig.presentation.mode = RT64::EnhancementConfiguration::Presentation::Mode::PresentEarly;
application->updateEnhancementConfig();
}
RT64::UserConfiguration::Antialiasing RT64MaxMSAA() {
return device_max_msaa;
}

6
ultramodern/events.cpp
View File

@ -268,6 +268,7 @@ ultramodern::GraphicsConfig ultramodern::get_graphics_config() {
}
void gfx_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_ready, ultramodern::WindowHandle window_handle) {
bool enabled_instant_present = false;
using namespace std::chrono_literals;
ultramodern::set_native_thread_name("Gfx Thread");
@ -293,6 +294,11 @@ void gfx_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_read
if (events_context.action_queue.wait_dequeue_timed(action, 1ms)) {
// Determine the action type and act on it
if (const auto* task_action = std::get_if<SpTaskAction>(&action)) {
// Turn on instant present if the game has been started and it hasn't been turned on yet.
if (ultramodern::is_game_started() && !enabled_instant_present) {
RT64EnableInstantPresent(application);
enabled_instant_present = true;
}
// Tell the game that the RSP completed instantly. This will allow it to queue other task types, but it won't
// start another graphics task until the RDP is also complete. Games usually preserve the RSP inputs until the RDP
// is finished as well, so sending this early shouldn't be an issue in most cases.