ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GPU: Move backend work off CPU thread

This commit is contained in:
Stenzek 2024-12-19 14:29:26 +10:00
parent 831c982f3b
commit 2d659fc3eb
No known key found for this signature in database
59 changed files with 6806 additions and 4955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/common/intrin.h
View File

@ -14,9 +14,9 @@
#define CPU_ARCH_SIMD 1
#define CPU_ARCH_SSE 1
#include <emmintrin.h>
#include <tmmintrin.h>
#include <smmintrin.h>
#include <immintrin.h>
#include <smmintrin.h>
#include <tmmintrin.h>
#if defined(__AVX2__)
#define CPU_ARCH_AVX 1
@ -96,3 +96,40 @@ ALWAYS_INLINE_RELEASE static void MemsetPtrs(T* ptr, T value, u32 count)
for (u32 i = 0; i < remaining_count; i++)
*(dest++) = value;
}
ALWAYS_INLINE static void MultiPause()
{
#if defined(CPU_ARCH_X86) || defined(CPU_ARCH_X64)
_mm_pause();
_mm_pause();
_mm_pause();
_mm_pause();
_mm_pause();
_mm_pause();
_mm_pause();
_mm_pause();
#elif defined(CPU_ARCH_ARM64) && defined(_MSC_VER)
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
__isb(_ARM64_BARRIER_SY);
#elif defined(CPU_ARCH_ARM64) || defined(CPU_ARCH_ARM32)
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
__asm__ __volatile__("isb");
#elif defined(CPU_ARCH_RISCV64)
// Probably wrong... pause is optional :/
asm volatile("fence" ::: "memory");
#else
#pragma warning("Missing implementation")
#endif
}

1
src/common/log_channels.h
View File

@ -27,6 +27,7 @@
X(GPU) \
X(GPUDevice) \
X(GPUDump) \
X(GPUThread) \
X(GPU_SW) \
X(GPU_HW) \
X(GameDatabase) \

7
src/core/CMakeLists.txt
View File

@ -61,10 +61,11 @@ add_library(core
gpu_shadergen.h
gpu_sw.cpp
gpu_sw.h
gpu_sw_backend.cpp
gpu_sw_backend.h
gpu_sw_rasterizer.cpp
gpu_sw_rasterizer.h
gpu_thread.cpp
gpu_thread.h
gpu_thread_commands.h
gpu_types.h
guncon.cpp
guncon.h
@ -73,8 +74,6 @@ add_library(core
gte_types.h
host.cpp
host.h
host_interface_progress_callback.cpp
host_interface_progress_callback.h
hotkeys.cpp
input_types.h
imgui_overlays.cpp

178
src/core/achievements.cpp
View File

@ -9,7 +9,9 @@
#include "bus.h"
#include "cpu_core.h"
#include "fullscreen_ui.h"
#include "gpu_thread.h"
#include "host.h"
#include "imgui_overlays.h"
#include "system.h"
#include "scmversion/scmversion.h"
@ -480,7 +482,9 @@ void Achievements::UpdateGlyphRanges()
std::sort(sorted_codepoints.begin(), sorted_codepoints.end());
// Compact codepoints to ranges.
GPUThread::RunOnThread([sorted_codepoints = std::move(sorted_codepoints)]() {
ImGuiManager::SetEmojiFontRange(ImGuiManager::CompactFontRange(sorted_codepoints));
});
}
bool Achievements::IsActive()
@ -1173,7 +1177,7 @@ void Achievements::ClientLoadGameCallback(int result, const char* error_message,
// ensure fullscreen UI is ready for notifications
if (display_summary)
FullscreenUI::Initialize();
GPUThread::RunOnThread(&FullscreenUI::Initialize);
char url_buf[URL_BUFFER_SIZE];
if (int err = rc_client_game_get_image_url(info, url_buf, std::size(url_buf)); err == RC_OK)
@ -1229,7 +1233,7 @@ void Achievements::ClearGameHash()
void Achievements::DisplayAchievementSummary()
{
if (g_settings.achievements_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_notifications)
{
std::string title;
if (IsHardcoreModeActive())
@ -1254,8 +1258,14 @@ void Achievements::DisplayAchievementSummary()
summary = TRANSLATE_STR("Achievements", "This game has no achievements.");
}
GPUThread::RunOnThread(
[title = std::move(title), summary = std::move(summary), icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification("achievement_summary", ACHIEVEMENT_SUMMARY_NOTIFICATION_TIME, std::move(title),
std::move(summary), s_state.game_icon);
std::move(summary), std::move(icon));
});
}
// Technically not going through the resource API, but since we're passing this to something else, we can't.
@ -1265,12 +1275,16 @@ void Achievements::DisplayAchievementSummary()
void Achievements::DisplayHardcoreDeferredMessage()
{
if (g_settings.achievements_hardcore_mode && !s_state.hardcore_mode && System::IsValid() &&
FullscreenUI::Initialize())
if (g_settings.achievements_hardcore_mode && !s_state.hardcore_mode && System::IsValid())
{
GPUThread::RunOnThread([]() {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::ShowToast(std::string(),
TRANSLATE_STR("Achievements", "Hardcore mode will be enabled on system reset."),
Host::OSD_WARNING_DURATION);
});
}
}
@ -1292,7 +1306,7 @@ void Achievements::HandleUnlockEvent(const rc_client_event_t* event)
INFO_LOG("Achievement {} ({}) for game {} unlocked", cheevo->title, cheevo->id, s_state.game_id);
UpdateGameSummary();
if (g_settings.achievements_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_notifications)
{
std::string title;
if (cheevo->category == RC_CLIENT_ACHIEVEMENT_CATEGORY_UNOFFICIAL)
@ -1302,9 +1316,15 @@ void Achievements::HandleUnlockEvent(const rc_client_event_t* event)
std::string badge_path = GetAchievementBadgePath(cheevo, cheevo->state);
ImGuiFullscreen::AddNotification(fmt::format("achievement_unlock_{}", cheevo->id),
static_cast<float>(g_settings.achievements_notification_duration),
std::move(title), cheevo->description, std::move(badge_path));
GPUThread::RunOnThread([id = cheevo->id, duration = g_settings.achievements_notification_duration,
title = std::move(title), description = std::string(cheevo->description),
badge_path = std::move(badge_path)]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification(fmt::format("achievement_unlock_{}", id), static_cast<float>(duration),
std::move(title), std::move(description), std::move(badge_path));
});
}
if (g_settings.achievements_sound_effects)
@ -1316,7 +1336,7 @@ void Achievements::HandleGameCompleteEvent(const rc_client_event_t* event)
INFO_LOG("Game {} complete", s_state.game_id);
UpdateGameSummary();
if (g_settings.achievements_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_notifications)
{
std::string title = fmt::format(TRANSLATE_FS("Achievements", "Mastered {}"), s_state.game_title);
std::string message = fmt::format(
@ -1325,8 +1345,14 @@ void Achievements::HandleGameCompleteEvent(const rc_client_event_t* event)
s_state.game_summary.num_unlocked_achievements),
TRANSLATE_PLURAL_STR("Achievements", "%n points", "Achievement points", s_state.game_summary.points_unlocked));
GPUThread::RunOnThread(
[title = std::move(title), message = std::move(message), icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification("achievement_mastery", GAME_COMPLETE_NOTIFICATION_TIME, std::move(title),
std::move(message), s_state.game_icon);
std::move(message), std::move(icon));
});
}
}
@ -1334,14 +1360,19 @@ void Achievements::HandleLeaderboardStartedEvent(const rc_client_event_t* event)
{
DEV_LOG("Leaderboard {} ({}) started", event->leaderboard->id, event->leaderboard->title);
if (g_settings.achievements_leaderboard_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_leaderboard_notifications)
{
std::string title = event->leaderboard->title;
std::string message = TRANSLATE_STR("Achievements", "Leaderboard attempt started.");
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", event->leaderboard->id),
LEADERBOARD_STARTED_NOTIFICATION_TIME, std::move(title), std::move(message),
s_state.game_icon);
GPUThread::RunOnThread([id = event->leaderboard->id, title = std::move(title), message = std::move(message),
icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", id), LEADERBOARD_STARTED_NOTIFICATION_TIME,
std::move(title), std::move(message), std::move(icon));
});
}
}
@ -1349,14 +1380,19 @@ void Achievements::HandleLeaderboardFailedEvent(const rc_client_event_t* event)
{
DEV_LOG("Leaderboard {} ({}) failed", event->leaderboard->id, event->leaderboard->title);
if (g_settings.achievements_leaderboard_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_leaderboard_notifications)
{
std::string title = event->leaderboard->title;
std::string message = TRANSLATE_STR("Achievements", "Leaderboard attempt failed.");
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", event->leaderboard->id),
LEADERBOARD_FAILED_NOTIFICATION_TIME, std::move(title), std::move(message),
s_state.game_icon);
GPUThread::RunOnThread([id = event->leaderboard->id, title = std::move(title), message = std::move(message),
icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", id), LEADERBOARD_FAILED_NOTIFICATION_TIME,
std::move(title), std::move(message), std::move(icon));
});
}
}
@ -1364,7 +1400,7 @@ void Achievements::HandleLeaderboardSubmittedEvent(const rc_client_event_t* even
{
DEV_LOG("Leaderboard {} ({}) submitted", event->leaderboard->id, event->leaderboard->title);
if (g_settings.achievements_leaderboard_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_leaderboard_notifications)
{
static const char* value_strings[NUM_RC_CLIENT_LEADERBOARD_FORMATS] = {
TRANSLATE_NOOP("Achievements", "Your Time: {}{}"),
@ -1380,9 +1416,14 @@ void Achievements::HandleLeaderboardSubmittedEvent(const rc_client_event_t* even
event->leaderboard->tracker_value ? event->leaderboard->tracker_value : "Unknown",
g_settings.achievements_spectator_mode ? std::string_view() : TRANSLATE_SV("Achievements", " (Submitting)"));
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", event->leaderboard->id),
static_cast<float>(g_settings.achievements_leaderboard_duration), std::move(title),
std::move(message), s_state.game_icon);
GPUThread::RunOnThread([id = event->leaderboard->id, title = std::move(title), message = std::move(message),
icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", id),
static_cast<float>(g_settings.achievements_leaderboard_duration),
std::move(title), std::move(message), std::move(icon));
});
}
if (g_settings.achievements_sound_effects)
@ -1394,7 +1435,7 @@ void Achievements::HandleLeaderboardScoreboardEvent(const rc_client_event_t* eve
DEV_LOG("Leaderboard {} scoreboard rank {} of {}", event->leaderboard_scoreboard->leaderboard_id,
event->leaderboard_scoreboard->new_rank, event->leaderboard_scoreboard->num_entries);
if (g_settings.achievements_leaderboard_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_leaderboard_notifications)
{
static const char* value_strings[NUM_RC_CLIENT_LEADERBOARD_FORMATS] = {
TRANSLATE_NOOP("Achievements", "Your Time: {} (Best: {})"),
@ -1411,9 +1452,15 @@ void Achievements::HandleLeaderboardScoreboardEvent(const rc_client_event_t* eve
event->leaderboard_scoreboard->submitted_score, event->leaderboard_scoreboard->best_score),
event->leaderboard_scoreboard->new_rank, event->leaderboard_scoreboard->num_entries);
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", event->leaderboard->id),
static_cast<float>(g_settings.achievements_leaderboard_duration), std::move(title),
std::move(message), s_state.game_icon);
GPUThread::RunOnThread([id = event->leaderboard->id, title = std::move(title), message = std::move(message),
icon = s_state.game_icon]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification(fmt::format("leaderboard_{}", id),
static_cast<float>(g_settings.achievements_leaderboard_duration),
std::move(title), std::move(message), std::move(icon));
});
}
}
@ -1543,26 +1590,30 @@ void Achievements::HandleServerDisconnectedEvent(const rc_client_event_t* event)
{
WARNING_LOG("Server disconnected.");
if (FullscreenUI::Initialize())
{
GPUThread::RunOnThread([]() {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::ShowToast(
TRANSLATE_STR("Achievements", "Achievements Disconnected"),
TRANSLATE_STR("Achievements",
"An unlock request could not be completed. We will keep retrying to submit this request."),
Host::OSD_ERROR_DURATION);
}
});
}
void Achievements::HandleServerReconnectedEvent(const rc_client_event_t* event)
{
WARNING_LOG("Server reconnected.");
if (FullscreenUI::Initialize())
{
GPUThread::RunOnThread([]() {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::ShowToast(TRANSLATE_STR("Achievements", "Achievements Reconnected"),
TRANSLATE_STR("Achievements", "All pending unlock requests have completed."),
Host::OSD_INFO_DURATION);
}
});
}
void Achievements::ResetClient()
@ -1640,12 +1691,17 @@ void Achievements::SetHardcoreMode(bool enabled, bool force_display_message)
// new mode
s_state.hardcore_mode = enabled;
if (System::IsValid() && (HasActiveGame() || force_display_message) && FullscreenUI::Initialize())
if (System::IsValid() && (HasActiveGame() || force_display_message))
{
GPUThread::RunOnThread([enabled]() {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::ShowToast(std::string(),
enabled ? TRANSLATE_STR("Achievements", "Hardcore mode is now enabled.") :
TRANSLATE_STR("Achievements", "Hardcore mode is now disabled."),
Host::OSD_INFO_DURATION);
});
}
rc_client_set_hardcore_enabled(s_state.client, enabled);
@ -1687,8 +1743,15 @@ bool Achievements::DoState(StateWrapper& sw)
// before deserializing, otherwise that state's going to get lost.
if (!IsUsingRAIntegration() && s_state.load_game_request)
{
Host::DisplayLoadingScreen("Downloading achievements data...");
// Messy because GPU-thread, but at least it looks pretty.
GPUThread::RunOnThread([]() {
FullscreenUI::OpenLoadingScreen(ImGuiManager::LOGO_IMAGE_NAME,
TRANSLATE_SV("Achievements", "Downloading achievements data..."));
});
s_state.http_downloader->WaitForAllRequests();
GPUThread::RunOnThread([]() { FullscreenUI::CloseLoadingScreen(); });
}
u32 data_size = 0;
@ -1957,7 +2020,7 @@ void Achievements::ShowLoginNotification()
if (!user)
return;
if (g_settings.achievements_notifications && FullscreenUI::Initialize())
if (g_settings.achievements_notifications)
{
std::string badge_path = GetLoggedInUserBadgePath();
std::string title = user->display_name;
@ -1966,8 +2029,14 @@ void Achievements::ShowLoginNotification()
std::string summary = fmt::format(TRANSLATE_FS("Achievements", "Score: {} ({} softcore)\nUnread messages: {}"),
user->score, user->score_softcore, user->num_unread_messages);
GPUThread::RunOnThread(
[title = std::move(title), summary = std::move(summary), badge_path = std::move(badge_path)]() mutable {
if (!FullscreenUI::Initialize())
return;
ImGuiFullscreen::AddNotification("achievements_login", LOGIN_NOTIFICATION_TIME, std::move(title),
std::move(summary), std::move(badge_path));
});
}
}
@ -2066,6 +2135,15 @@ bool Achievements::ConfirmHardcoreModeDisable(const char* trigger)
void Achievements::ConfirmHardcoreModeDisableAsync(const char* trigger, std::function<void(bool)> callback)
{
auto real_callback = [callback = std::move(callback)](bool res) mutable {
// don't run the callback in the middle of rendering the UI
Host::RunOnCPUThread([callback = std::move(callback), res]() {
if (res)
DisableHardcoreMode();
callback(res);
});
};
#ifndef __ANDROID__
#ifdef ENABLE_RAINTEGRATION
if (IsUsingRAIntegration())
@ -2076,34 +2154,32 @@ void Achievements::ConfirmHardcoreModeDisableAsync(const char* trigger, std::fun
}
#endif
GPUThread::RunOnThread([trigger = std::string(trigger), real_callback = std::move(real_callback)]() mutable {
if (!FullscreenUI::Initialize())
{
Host::AddOSDMessage(fmt::format(TRANSLATE_FS("Achievements", "Cannot {} while hardcode mode is active."), trigger),
Host::AddOSDMessage(
fmt::format(TRANSLATE_FS("Achievements", "Cannot {} while hardcode mode is active."), trigger),
Host::OSD_WARNING_DURATION);
callback(false);
real_callback(false);
return;
}
auto real_callback = [callback = std::move(callback)](bool res) mutable {
// don't run the callback in the middle of rendering the UI
Host::RunOnCPUThread([callback = std::move(callback), res]() {
if (res)
DisableHardcoreMode();
callback(res);
});
};
ImGuiFullscreen::OpenConfirmMessageDialog(
TRANSLATE_STR("Achievements", "Confirm Hardcore Mode"),
fmt::format(TRANSLATE_FS("Achievements", "{0} cannot be performed while hardcore mode is active. Do you "
fmt::format(TRANSLATE_FS("Achievements",
"{0} cannot be performed while hardcore mode is active. Do you "
"want to disable hardcore mode? {0} will be cancelled if you select No."),
trigger),
std::move(real_callback), fmt::format(ICON_FA_CHECK " {}", TRANSLATE_SV("Achievements", "Yes")),
fmt::format(ICON_FA_TIMES " {}", TRANSLATE_SV("Achievements", "No")));
});
#else
Host::AddOSDMessage(fmt::format(TRANSLATE_FS("Achievements", "Cannot {} while hardcode mode is active."), trigger),
Host::OSD_WARNING_DURATION);
callback(false);
Host::ConfirmMessageAsync(
TRANSLATE_STR("Achievements", "Confirm Hardcore Mode"),
fmt::format(TRANSLATE_FS("Achievements", "{0} cannot be performed while hardcore mode is active. Do you want to "
"disable hardcore mode? {0} will be cancelled if you select No."),
trigger),
std::move(real_callback));
#endif
}

4
src/core/cdrom.cpp
View File

@ -5,8 +5,8 @@
#include "cdrom_async_reader.h"
#include "cdrom_subq_replacement.h"
#include "dma.h"
#include "fullscreen_ui.h"
#include "host.h"
#include "host_interface_progress_callback.h"
#include "interrupt_controller.h"
#include "settings.h"
#include "spu.h"
@ -999,7 +999,7 @@ bool CDROM::PrecacheMedia()
return false;
}
HostInterfaceProgressCallback callback;
LoadingScreenProgressCallback callback;
if (!s_reader.Precache(&callback))
{
Host::AddOSDMessage(TRANSLATE_STR("OSDMessage", "Precaching CD image failed, it may be unreliable."),

7
src/core/core.vcxproj
View File

@ -40,14 +40,13 @@
<ClCompile Include="gpu_hw_texture_cache.cpp" />
<ClCompile Include="gpu_shadergen.cpp" />
<ClCompile Include="gpu_sw.cpp" />
<ClCompile Include="gpu_sw_backend.cpp" />
<ClCompile Include="gpu_sw_rasterizer.cpp" />
<ClCompile Include="gpu_thread.cpp" />
<ClCompile Include="gte.cpp" />
<ClCompile Include="dma.cpp" />
<ClCompile Include="gpu.cpp" />
<ClCompile Include="gpu_hw.cpp" />
<ClCompile Include="host.cpp" />
<ClCompile Include="host_interface_progress_callback.cpp" />
<ClCompile Include="hotkeys.cpp" />
<ClCompile Include="imgui_overlays.cpp" />
<ClCompile Include="interrupt_controller.cpp" />
@ -119,8 +118,9 @@
<ClInclude Include="gpu_hw_texture_cache.h" />
<ClInclude Include="gpu_shadergen.h" />
<ClInclude Include="gpu_sw.h" />
<ClInclude Include="gpu_sw_backend.h" />
<ClInclude Include="gpu_sw_rasterizer.h" />
<ClInclude Include="gpu_thread.h" />
<ClInclude Include="gpu_thread_commands.h" />
<ClInclude Include="gpu_types.h" />
<ClInclude Include="gte.h" />
<ClInclude Include="cpu_types.h" />
@ -129,7 +129,6 @@
<ClInclude Include="gpu_hw.h" />
<ClInclude Include="gte_types.h" />
<ClInclude Include="host.h" />
<ClInclude Include="host_interface_progress_callback.h" />
<ClInclude Include="imgui_overlays.h" />
<ClInclude Include="input_types.h" />
<ClInclude Include="interrupt_controller.h" />

7
src/core/core.vcxproj.filters
View File

@ -33,13 +33,11 @@
<ClCompile Include="guncon.cpp" />
<ClCompile Include="playstation_mouse.cpp" />
<ClCompile Include="negcon.cpp" />
<ClCompile Include="host_interface_progress_callback.cpp" />
<ClCompile Include="cpu_pgxp.cpp" />
<ClCompile Include="cheats.cpp" />
<ClCompile Include="memory_card_image.cpp" />
<ClCompile Include="analog_joystick.cpp" />
<ClCompile Include="gpu_backend.cpp" />
<ClCompile Include="gpu_sw_backend.cpp" />
<ClCompile Include="multitap.cpp" />
<ClCompile Include="host.cpp" />
<ClCompile Include="game_database.cpp" />
@ -67,6 +65,7 @@
<ClCompile Include="performance_counters.cpp" />
<ClCompile Include="jogcon.cpp" />
<ClCompile Include="pio.cpp" />
<ClCompile Include="gpu_thread.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="types.h" />
@ -102,7 +101,6 @@
<ClInclude Include="guncon.h" />
<ClInclude Include="playstation_mouse.h" />
<ClInclude Include="negcon.h" />
<ClInclude Include="host_interface_progress_callback.h" />
<ClInclude Include="gte_types.h" />
<ClInclude Include="cpu_pgxp.h" />
<ClInclude Include="cpu_core_private.h" />
@ -111,7 +109,6 @@
<ClInclude Include="analog_joystick.h" />
<ClInclude Include="gpu_types.h" />
<ClInclude Include="gpu_backend.h" />
<ClInclude Include="gpu_sw_backend.h" />
<ClInclude Include="multitap.h" />
<ClInclude Include="host.h" />
<ClInclude Include="achievements.h" />
@ -143,6 +140,8 @@
<ClInclude Include="system_private.h" />
<ClInclude Include="jogcon.h" />
<ClInclude Include="pio.h" />
<ClInclude Include="gpu_thread.h" />
<ClInclude Include="gpu_thread_commands.h" />
</ItemGroup>
<ItemGroup>
<None Include="gpu_sw_rasterizer.inl" />

337
src/core/fullscreen_ui.cpp
View File

@ -8,7 +8,9 @@
#include "controller.h"
#include "game_list.h"
#include "gpu.h"
#include "gpu_thread.h"
#include "host.h"
#include "imgui_overlays.h"
#include "settings.h"
#include "system.h"
#include "system_private.h"
@ -203,6 +205,7 @@ struct PostProcessingStageInfo
//////////////////////////////////////////////////////////////////////////
// Main
//////////////////////////////////////////////////////////////////////////
static void UpdateRunIdleState();
static void PauseForMenuOpen(bool set_pause_menu_open);
static bool AreAnyDialogsOpen();
static void ClosePauseMenu();
@ -602,12 +605,12 @@ bool FullscreenUI::Initialize()
s_state.about_window_open = false;
s_state.hotkey_list_cache = InputManager::GetHotkeyList();
if (!System::IsValid())
Host::RunOnCPUThread([]() { Host::OnFullscreenUIStartedOrStopped(true); });
if (!GPUThread::HasGPUBackend() && !GPUThread::IsGPUBackendRequested())
SwitchToLanding();
if (!System::IsRunning())
Host::OnIdleStateChanged();
UpdateRunIdleState();
ForceKeyNavEnabled();
return true;
}
@ -631,6 +634,7 @@ bool FullscreenUI::AreAnyDialogsOpen()
void FullscreenUI::CheckForConfigChanges(const Settings& old_settings)
{
// NOTE: Called on CPU thread.
if (!IsInitialized())
return;
@ -638,35 +642,66 @@ void FullscreenUI::CheckForConfigChanges(const Settings& old_settings)
// That means we're going to be reading achievement state.
if (old_settings.achievements_enabled && !g_settings.achievements_enabled)
{
if (!IsInitialized())
return;
GPUThread::RunOnThread([]() {
if (s_state.current_main_window == MainWindowType::Achievements ||
s_state.current_main_window == MainWindowType::Leaderboards)
{
ReturnToPreviousWindow();
}
});
}
}
void FullscreenUI::UpdateRunIdleState()
{
const bool new_run_idle = HasActiveWindow();
GPUThread::SetRunIdleReason(GPUThread::RunIdleReason::FullscreenUIActive, new_run_idle);
}
void FullscreenUI::OnSystemStarted()
{
// NOTE: Called on CPU thread.
if (!IsInitialized())
return;
GPUThread::RunOnThread([]() {
if (!IsInitialized())
return;
s_state.current_main_window = MainWindowType::None;
QueueResetFocus(FocusResetType::ViewChanged);
}
void FullscreenUI::OnSystemPaused()
{
// noop
UpdateRunIdleState();
});
}
void FullscreenUI::OnSystemResumed()
{
// NOTE: Called on CPU thread.
if (!IsInitialized())
return;
GPUThread::RunOnThread([]() {
if (!IsInitialized())
return;
// get rid of pause menu if we unpaused another way
if (s_state.current_main_window == MainWindowType::PauseMenu)
ClosePauseMenu();
UpdateRunIdleState();
});
}
void FullscreenUI::OnSystemDestroyed()
{
// NOTE: Called on CPU thread.
if (!IsInitialized())
return;
GPUThread::RunOnThread([]() {
if (!IsInitialized())
return;
@ -674,19 +709,31 @@ void FullscreenUI::OnSystemDestroyed()
s_state.was_paused_on_quick_menu_open = false;
s_state.current_pause_submenu = PauseSubMenu::None;
SwitchToLanding();
UpdateRunIdleState();
});
}
void FullscreenUI::OnRunningGameChanged()
{
// NOTE: Called on CPU thread.
if (!IsInitialized())
return;
const std::string& path = System::GetDiscPath();
const std::string& serial = System::GetGameSerial();
std::string subtitle;
if (!serial.empty())
s_state.current_game_subtitle = fmt::format("{0} - {1}", serial, Path::GetFileName(path));
subtitle = fmt::format("{0} - {1}", serial, Path::GetFileName(path));
else
s_state.current_game_subtitle = {};
subtitle = {};
GPUThread::RunOnThread([subtitle = std::move(subtitle)]() mutable {
if (!IsInitialized())
return;
s_state.current_game_subtitle = std::move(subtitle);
});
}
void FullscreenUI::PauseForMenuOpen(bool set_pause_menu_open)
@ -703,6 +750,7 @@ void FullscreenUI::OpenPauseMenu()
if (!System::IsValid())
return;
GPUThread::RunOnThread([]() {
if (!Initialize() || s_state.current_main_window != MainWindowType::None)
return;
@ -711,7 +759,9 @@ void FullscreenUI::OpenPauseMenu()
s_state.current_pause_submenu = PauseSubMenu::None;
QueueResetFocus(FocusResetType::ViewChanged);
ForceKeyNavEnabled();
UpdateRunIdleState();
FixStateIfPaused();
});
}
void FullscreenUI::OpenCheatsMenu()
@ -725,41 +775,39 @@ void FullscreenUI::OpenCheatsMenu()
s_state.settings_page = SettingsPage::Cheats;
PauseForMenuOpen(true);
ForceKeyNavEnabled();
UpdateRunIdleState();
FixStateIfPaused();
}
void FullscreenUI::FixStateIfPaused()
{
if (!System::IsValid() || System::IsRunning())
if (!GPUThread::HasGPUBackend() || System::IsRunning())
return;
// When we're paused, we won't have trickled the key up event for escape yet. Do it now.
ImGui::UpdateInputEvents(false);
Host::OnIdleStateChanged();
Host::RunOnCPUThread([]() {
if (System::IsValid())
{
// Why twice? To clear the "wants keyboard input" flag.
System::InvalidateDisplay();
System::InvalidateDisplay();
}
});
}
void FullscreenUI::ClosePauseMenu()
{
if (!IsInitialized() || !System::IsValid())
if (!System::IsValid())
return;
if (System::GetState() == System::State::Paused && !s_state.was_paused_on_quick_menu_open)
const bool paused = System::IsPaused();
GPUThread::RunOnThread([paused]() {
if (!IsInitialized())
return;
if (paused && !s_state.was_paused_on_quick_menu_open)
Host::RunOnCPUThread([]() { System::PauseSystem(false); });
s_state.current_main_window = MainWindowType::None;
s_state.current_pause_submenu = PauseSubMenu::None;
s_state.pause_menu_was_open = false;
QueueResetFocus(FocusResetType::ViewChanged);
UpdateRunIdleState();
FixStateIfPaused();
});
}
void FullscreenUI::OpenPauseSubMenu(PauseSubMenu submenu)
@ -790,14 +838,21 @@ void FullscreenUI::Shutdown()
s_state.current_game_subtitle = {};
DestroyResources();
ImGuiFullscreen::Shutdown();
if (s_state.initialized)
Host::RunOnCPUThread([]() { Host::OnFullscreenUIStartedOrStopped(false); });
s_state.initialized = false;
s_state.tried_to_initialize = false;
UpdateRunIdleState();
}
void FullscreenUI::Render()
{
if (!s_state.initialized)
{
ImGuiFullscreen::RenderLoadingScreen();
return;
}
ImGuiFullscreen::UploadAsyncTextures();
@ -856,6 +911,8 @@ void FullscreenUI::Render()
ImGuiFullscreen::EndLayout();
ImGuiFullscreen::RenderLoadingScreen();
if (s_state.settings_changed.load(std::memory_order_relaxed))
{
Host::CommitBaseSettingChanges();
@ -889,7 +946,7 @@ void FullscreenUI::Render()
}
}
if (System::IsValid())
if (GPUThread::HasGPUBackend())
Host::RunOnCPUThread([]() { System::ReloadGameSettings(false); });
}
s_state.game_settings_changed.store(false, std::memory_order_release);
@ -908,7 +965,7 @@ void FullscreenUI::InvalidateCoverCache()
void FullscreenUI::ReturnToPreviousWindow()
{
if (System::IsValid() && s_state.pause_menu_was_open)
if (GPUThread::HasGPUBackend() && s_state.pause_menu_was_open)
{
s_state.current_main_window = MainWindowType::PauseMenu;
QueueResetFocus(FocusResetType::ViewChanged);
@ -922,7 +979,8 @@ void FullscreenUI::ReturnToPreviousWindow()
void FullscreenUI::ReturnToMainWindow()
{
ClosePauseMenu();
s_state.current_main_window = System::IsValid() ? MainWindowType::None : MainWindowType::Landing;
s_state.current_main_window = GPUThread::HasGPUBackend() ? MainWindowType::None : MainWindowType::Landing;
UpdateRunIdleState();
FixStateIfPaused();
}
@ -958,9 +1016,14 @@ ImGuiFullscreen::FileSelectorFilters FullscreenUI::GetDiscImageFilters()
void FullscreenUI::DoStartPath(std::string path, std::string state, std::optional<bool> fast_boot)
{
if (System::IsValid())
if (GPUThread::HasGPUBackend())
return;
// Switch to nothing, we'll get called back via OnSystemDestroyed() if startup fails.
s_state.current_main_window = MainWindowType::None;
QueueResetFocus(FocusResetType::ViewChanged);
UpdateRunIdleState();
SystemBootParameters params;
params.filename = std::move(path);
params.save_state = std::move(state);
@ -1155,6 +1218,7 @@ void FullscreenUI::DoChangeDiscFromFile()
void FullscreenUI::DoChangeDisc()
{
Host::RunOnCPUThread([]() {
ImGuiFullscreen::ChoiceDialogOptions options;
if (System::HasMediaSubImages())
@ -1167,6 +1231,7 @@ void FullscreenUI::DoChangeDisc()
for (u32 i = 0; i < count; i++)
options.emplace_back(System::GetMediaSubImageTitle(i), i == current_index);
GPUThread::RunOnThread([options = std::move(options)]() mutable {
auto callback = [](s32 index, const std::string& title, bool checked) {
if (index == 0)
{
@ -1185,6 +1250,7 @@ void FullscreenUI::DoChangeDisc()
OpenChoiceDialog(FSUI_ICONSTR(ICON_FA_COMPACT_DISC, "Select Disc Image"), true, std::move(options),
std::move(callback));
});
return;
}
@ -1208,6 +1274,7 @@ void FullscreenUI::DoChangeDisc()
paths.push_back(glentry->path);
}
GPUThread::RunOnThread([options = std::move(options), paths = std::move(paths)]() mutable {
auto callback = [paths = std::move(paths)](s32 index, const std::string& title, bool checked) {
if (index == 0)
{
@ -1226,17 +1293,20 @@ void FullscreenUI::DoChangeDisc()
OpenChoiceDialog(FSUI_ICONSTR(ICON_FA_COMPACT_DISC, "Select Disc Image"), true, std::move(options),
std::move(callback));
});
return;
}
}
DoChangeDiscFromFile();
GPUThread::RunOnThread([]() { DoChangeDiscFromFile(); });
});
}
void FullscreenUI::DoToggleAnalogMode()
{
// hacky way to toggle analog mode
Host::RunOnCPUThread([]() {
for (u32 i = 0; i < NUM_CONTROLLER_AND_CARD_PORTS; i++)
{
Controller* ctrl = System::GetController(i);
@ -1257,6 +1327,7 @@ void FullscreenUI::DoToggleAnalogMode()
}
}
}
});
}
void FullscreenUI::DoRequestExit()
@ -2857,7 +2928,7 @@ void FullscreenUI::DrawSettingsWindow()
(LayoutScale(LAYOUT_MENU_BUTTON_Y_PADDING) * 2.0f) + LayoutScale(2.0f));
const float bg_alpha =
System::IsValid() ? (s_state.settings_page == SettingsPage::PostProcessing ? 0.50f : 0.90f) : 1.0f;
GPUThread::HasGPUBackend() ? (s_state.settings_page == SettingsPage::PostProcessing ? 0.50f : 0.90f) : 1.0f;
if (BeginFullscreenWindow(ImVec2(0.0f, 0.0f), heading_size, "settings_category",
ImVec4(UIStyle.PrimaryColor.x, UIStyle.PrimaryColor.y, UIStyle.PrimaryColor.z, bg_alpha)))
@ -3802,12 +3873,9 @@ void FullscreenUI::DrawControllerSettingsPage()
&Settings::GetMultitapModeName, &Settings::GetMultitapModeDisplayName, MultitapMode::Count);
// load mtap settings
MultitapMode mtap_mode = g_settings.multitap_mode;
if (IsEditingGameSettings(bsi))
{
mtap_mode = Settings::ParseMultitapModeName(bsi->GetTinyStringValue("ControllerPorts", "MultitapMode", "").c_str())
.value_or(g_settings.multitap_mode);
}
const MultitapMode mtap_mode =
Settings::ParseMultitapModeName(bsi->GetTinyStringValue("ControllerPorts", "MultitapMode", "").c_str())
.value_or(Settings::DEFAULT_MULTITAP_MODE);
const std::array<bool, 2> mtap_enabled = {
{(mtap_mode == MultitapMode::Port1Only || mtap_mode == MultitapMode::BothPorts),
(mtap_mode == MultitapMode::Port2Only || mtap_mode == MultitapMode::BothPorts)}};
@ -4674,7 +4742,7 @@ void FullscreenUI::DrawPostProcessingSettingsPage()
FSUI_CSTR("Reloads the shaders from disk, applying any changes."),
bsi->GetBoolValue("PostProcessing", "Enabled", false)))
{
if (System::IsValid() && PostProcessing::ReloadShaders())
if (GPUThread::HasGPUBackend() && PostProcessing::ReloadShaders())
ShowToast(std::string(), FSUI_STR("Post-processing shaders reloaded."));
}
@ -5110,7 +5178,7 @@ void FullscreenUI::DrawAchievementsSettingsPage()
"cheats, and slowdown functions."),
"Cheevos", "ChallengeMode", false, enabled))
{
if (System::IsValid() && bsi->GetBoolValue("Cheevos", "ChallengeMode", false))
if (GPUThread::HasGPUBackend() && bsi->GetBoolValue("Cheevos", "ChallengeMode", false))
ShowToast(std::string(), FSUI_STR("Hardcore mode will be enabled on next game restart."));
}
DrawToggleSetting(
@ -5272,12 +5340,13 @@ void FullscreenUI::DrawAchievementsLoginWindow()
0, 0, 0);
Host::RunOnCPUThread([username = std::string(username), password = std::string(password)]() {
Error error;
const bool result = Achievements::Login(username.c_str(), password.c_str(), &error);
GPUThread::RunOnThread([result, error = std::move(error)]() {
ImGuiFullscreen::CloseBackgroundProgressDialog(LOGIN_PROGRESS_NAME);
Error error;
if (Achievements::Login(username.c_str(), password.c_str(), &error))
if (result)
{
// TODO-GPU-THREAD: Synchronize access to s_achievements_login_window_open.
actually_close_popup();
return;
}
@ -5295,6 +5364,7 @@ void FullscreenUI::DrawAchievementsLoginWindow()
},
FSUI_ICONSTR(ICON_FA_TIMES, "Close"));
});
});
}
if (ActiveButton(FSUI_ICONSTR(ICON_FA_TIMES, "Cancel"), false, !is_logging_in))
@ -5804,7 +5874,7 @@ void FullscreenUI::DrawPauseMenu()
case PauseSubMenu::None:
{
// NOTE: Menu close must come first, because otherwise VM destruction options will race.
const bool has_game = System::IsValid() && !System::GetGameSerial().empty();
const bool has_game = GPUThread::HasGPUBackend() && !System::GetGameSerial().empty();
if (DefaultActiveButton(FSUI_ICONSTR(ICON_FA_PLAY, "Resume Game"), false) || WantsToCloseMenu())
ClosePauseMenu();
@ -6667,7 +6737,7 @@ void FullscreenUI::DrawGameListWindow()
ImVec2(io.DisplaySize.x, LayoutScale(LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY) +
(LayoutScale(LAYOUT_MENU_BUTTON_Y_PADDING) * 2.0f) + LayoutScale(2.0f));
const float bg_alpha = System::IsValid() ? 0.90f : 1.0f;
const float bg_alpha = GPUThread::HasGPUBackend() ? 0.90f : 1.0f;
if (BeginFullscreenWindow(ImVec2(0.0f, 0.0f), heading_size, "gamelist_view",
MulAlpha(UIStyle.PrimaryColor, bg_alpha)))
@ -7217,7 +7287,7 @@ void FullscreenUI::DrawGameListSettingsWindow()
ImVec2(io.DisplaySize.x, LayoutScale(LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY) +
(LayoutScale(LAYOUT_MENU_BUTTON_Y_PADDING) * 2.0f) + LayoutScale(2.0f));
const float bg_alpha = System::IsValid() ? 0.90f : 1.0f;
const float bg_alpha = GPUThread::HasGPUBackend() ? 0.90f : 1.0f;
if (BeginFullscreenWindow(ImVec2(0.0f, 0.0f), heading_size, "gamelist_view",
MulAlpha(UIStyle.PrimaryColor, bg_alpha)))
@ -7533,22 +7603,25 @@ void FullscreenUI::DrawAboutWindow()
void FullscreenUI::OpenAchievementsWindow()
{
if (!System::IsValid())
return;
if (!Achievements::IsActive())
{
Host::AddKeyedOSDMessage("achievements_disabled", FSUI_STR("Achievements are not enabled."),
Host::OSD_INFO_DURATION);
return;
}
if (!System::IsValid() || !Initialize())
return;
if (!Achievements::HasAchievements() || !Achievements::PrepareAchievementsWindow())
else if (!Achievements::HasAchievements())
{
ShowToast(std::string(), FSUI_STR("This game has no achievements."));
return;
}
GPUThread::RunOnThread([]() {
if (!Initialize() || !Achievements::PrepareAchievementsWindow())
return;
if (s_state.current_main_window != MainWindowType::PauseMenu)
{
PauseForMenuOpen(false);
@ -7557,7 +7630,9 @@ void FullscreenUI::OpenAchievementsWindow()
s_state.current_main_window = MainWindowType::Achievements;
QueueResetFocus(FocusResetType::ViewChanged);
UpdateRunIdleState();
FixStateIfPaused();
});
}
bool FullscreenUI::IsAchievementsWindowOpen()
@ -7567,22 +7642,25 @@ bool FullscreenUI::IsAchievementsWindowOpen()
void FullscreenUI::OpenLeaderboardsWindow()
{
if (!System::IsValid())
return;
if (!Achievements::IsActive())
{
Host::AddKeyedOSDMessage("achievements_disabled", FSUI_STR("Leaderboards are not enabled."),
Host::OSD_INFO_DURATION);
return;
}
if (!System::IsValid() || !Initialize())
return;
if (!Achievements::HasLeaderboards() || !Achievements::PrepareLeaderboardsWindow())
else if (!Achievements::HasLeaderboards())
{
ShowToast(std::string(), FSUI_STR("This game has no leaderboards."));
return;
}
GPUThread::RunOnThread([]() {
if (!Initialize() || !Achievements::PrepareLeaderboardsWindow())
return;
if (s_state.current_main_window != MainWindowType::PauseMenu)
{
PauseForMenuOpen(false);
@ -7591,7 +7669,9 @@ void FullscreenUI::OpenLeaderboardsWindow()
s_state.current_main_window = MainWindowType::Leaderboards;
QueueResetFocus(FocusResetType::ViewChanged);
UpdateRunIdleState();
FixStateIfPaused();
});
}
bool FullscreenUI::IsLeaderboardsWindowOpen()
@ -7601,6 +7681,155 @@ bool FullscreenUI::IsLeaderboardsWindowOpen()
#endif // __ANDROID__
LoadingScreenProgressCallback::LoadingScreenProgressCallback()
: ProgressCallback(), m_open_time(Timer::GetCurrentValue()), m_on_gpu_thread(GPUThread::IsOnThread())
{
}
LoadingScreenProgressCallback::~LoadingScreenProgressCallback()
{
// Did we activate?
if (m_last_progress_percent < 0)
return;
if (!m_on_gpu_thread)
{
GPUThread::RunOnThread([]() {
ImGuiFullscreen::CloseLoadingScreen();
Assert(GPUThread::GetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive));
GPUThread::SetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive, false);
});
}
else
{
// since this was pushing frames, we need to restore the context
GPUThread::Internal::RestoreContextAfterPresent();
}
}
void LoadingScreenProgressCallback::PushState()
{
ProgressCallback::PushState();
}
void LoadingScreenProgressCallback::PopState()
{
ProgressCallback::PopState();
Redraw(true);
}
void LoadingScreenProgressCallback::SetCancellable(bool cancellable)
{
ProgressCallback::SetCancellable(cancellable);
Redraw(true);
}
void LoadingScreenProgressCallback::SetTitle(const std::string_view title)
{
// todo?
}
void LoadingScreenProgressCallback::SetStatusText(const std::string_view text)
{
ProgressCallback::SetStatusText(text);
Redraw(true);
}
void LoadingScreenProgressCallback::SetProgressRange(u32 range)
{
u32 last_range = m_progress_range;
ProgressCallback::SetProgressRange(range);
if (m_progress_range != last_range)
Redraw(false);
}
void LoadingScreenProgressCallback::SetProgressValue(u32 value)
{
u32 lastValue = m_progress_value;
ProgressCallback::SetProgressValue(value);
if (m_progress_value != lastValue)
Redraw(false);
}
void LoadingScreenProgressCallback::Redraw(bool force)
{
if (m_last_progress_percent < 0 &&
Timer::ConvertValueToSeconds(Timer::GetCurrentValue() - m_open_time) < m_open_delay)
{
return;
}
const int percent =
static_cast<int>((static_cast<float>(m_progress_value) / static_cast<float>(m_progress_range)) * 100.0f);
DebugAssert(percent >= 0);
if (percent == m_last_progress_percent && !force)
return;
// activation?
if (m_last_progress_percent < 0 && !m_on_gpu_thread)
{
GPUThread::RunOnThread([]() {
Assert(!GPUThread::GetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive));
GPUThread::SetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive, true);
});
}
m_last_progress_percent = percent;
if (m_on_gpu_thread)
{
ImGuiFullscreen::RenderLoadingScreen(ImGuiManager::LOGO_IMAGE_NAME, m_status_text, 0,
static_cast<s32>(m_progress_range), static_cast<s32>(m_progress_value));
}
else
{
GPUThread::RunOnThread([status_text = SmallString(std::string_view(m_status_text)),
range = static_cast<s32>(m_progress_range), value = static_cast<s32>(m_progress_value)]() {
ImGuiFullscreen::OpenOrUpdateLoadingScreen(ImGuiManager::LOGO_IMAGE_NAME, status_text, 0, range, value);
});
}
}
void LoadingScreenProgressCallback::ModalError(const std::string_view message)
{
ERROR_LOG(message);
Host::ReportErrorAsync("Error", message);
}
bool LoadingScreenProgressCallback::ModalConfirmation(const std::string_view message)
{
INFO_LOG(message);
return Host::ConfirmMessage("Confirm", message);
}
void FullscreenUI::OpenLoadingScreen(std::string_view image, std::string_view message, s32 progress_min /*= -1*/,
s32 progress_max /*= -1*/, s32 progress_value /*= -1*/)
{
Assert(GPUThread::IsOnThread());
Assert(!GPUThread::GetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive));
GPUThread::SetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive, true);
ImGuiFullscreen::OpenOrUpdateLoadingScreen(image, message, progress_min, progress_max, progress_value);
}
void FullscreenUI::UpdateLoadingScreen(std::string_view image, std::string_view message, s32 progress_min /*= -1*/,
s32 progress_max /*= -1*/, s32 progress_value /*= -1*/)
{
Assert(GPUThread::IsOnThread());
Assert(GPUThread::GetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive));
ImGuiFullscreen::OpenOrUpdateLoadingScreen(image, message, progress_min, progress_max, progress_value);
}
void FullscreenUI::CloseLoadingScreen()
{
Assert(GPUThread::IsOnThread());
Assert(GPUThread::GetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive));
ImGuiFullscreen::CloseLoadingScreen();
GPUThread::SetRunIdleReason(GPUThread::RunIdleReason::LoadingScreenActive, false);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Translation String Area
// To avoid having to type T_RANSLATE("FullscreenUI", ...) everywhere, we use the shorter macros at the top

39
src/core/fullscreen_ui.h
View File

@ -21,7 +21,6 @@ bool IsInitialized();
bool HasActiveWindow();
void CheckForConfigChanges(const Settings& old_settings);
void OnSystemStarted();
void OnSystemPaused();
void OnSystemResumed();
void OnSystemDestroyed();
void OnRunningGameChanged();
@ -43,13 +42,51 @@ void Render();
void InvalidateCoverCache();
void TimeToPrintableString(SmallStringBase* str, time_t t);
void OpenLoadingScreen(std::string_view image, std::string_view message, s32 progress_min = -1, s32 progress_max = -1,
s32 progress_value = -1);
void UpdateLoadingScreen(std::string_view image, std::string_view message, s32 progress_min = -1, s32 progress_max = -1,
s32 progress_value = -1);
void CloseLoadingScreen();
} // namespace FullscreenUI
class LoadingScreenProgressCallback final : public ProgressCallback
{
public:
LoadingScreenProgressCallback();
~LoadingScreenProgressCallback() override;
ALWAYS_INLINE void SetOpenDelay(float delay) { m_open_delay = delay; }
void PushState() override;
void PopState() override;
void SetCancellable(bool cancellable) override;
void SetTitle(const std::string_view title) override;
void SetStatusText(const std::string_view text) override;
void SetProgressRange(u32 range) override;
void SetProgressValue(u32 value) override;
void ModalError(const std::string_view message) override;
bool ModalConfirmation(const std::string_view message) override;
private:
void Redraw(bool force);
u64 m_open_time = 0;
float m_open_delay = 1.0f;
s32 m_last_progress_percent = -1;
bool m_on_gpu_thread = false;
};
// Host UI triggers from Big Picture mode.
namespace Host {
#ifndef __ANDROID__
/// Called whenever fullscreen UI starts/stops.
void OnFullscreenUIStartedOrStopped(bool started);
/// Requests shut down and exit of the hosting application. This may not actually exit,
/// if the user cancels the shutdown confirmation.
void RequestExitApplication(bool allow_confirm);

1342
src/core/gpu.cpp
View File

File diff suppressed because it is too large Load Diff

182
src/core/gpu.h
View File

@ -39,17 +39,18 @@ enum class PacketType : u8;
class Recorder;
class Player;
} // namespace GPUDump
struct Settings;
namespace Threading {
class Thread;
}
class GPUBackend;
struct Settings;
namespace System {
struct MemorySaveState;
}
class GPU
struct GPUBackendCommand;
struct GPUBackendDrawCommand;
class GPU final
{
public:
enum class BlitterState : u8
@ -66,7 +67,6 @@ public:
DOT_TIMER_INDEX = 0,
HBLANK_TIMER_INDEX = 1,
MAX_RESOLUTION_SCALE = 32,
DEINTERLACE_BUFFER_COUNT = 4,
DRAWING_AREA_COORD_MASK = 1023,
};
@ -92,26 +92,15 @@ public:
// Base class constructor.
GPU();
virtual ~GPU();
~GPU();
virtual const Threading::Thread* GetSWThread() const = 0;
virtual bool IsHardwareRenderer() const = 0;
virtual bool Initialize(Error* error);
virtual void Reset(bool clear_vram);
virtual bool DoState(StateWrapper& sw, bool update_display);
virtual bool DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display);
// Graphics API state reset/restore - call when drawing the UI etc.
// TODO: replace with "invalidate cached state"
virtual void RestoreDeviceContext();
void Initialize();
void Reset(bool clear_vram);
bool DoState(StateWrapper& sw, bool update_display);
void DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display);
// Render statistics debug window.
void DrawDebugStateWindow(float scale);
void GetStatsString(SmallStringBase& str);
void GetMemoryStatsString(SmallStringBase& str);
void ResetStatistics();
void UpdateStatistics(u32 frame_count);
void CPUClockChanged();
@ -175,31 +164,26 @@ public:
void SynchronizeCRTC();
/// Recompile shaders/recreate framebuffers when needed.
virtual void UpdateSettings(const Settings& old_settings);
/// Returns the current resolution scale.
virtual u32 GetResolutionScale() const;
/// Updates the resolution scale when it's set to automatic.
virtual void UpdateResolutionScale();
void UpdateSettings(const Settings& old_settings);
/// Returns the full display resolution of the GPU, including padding.
std::tuple<u32, u32> GetFullDisplayResolution() const;
/// Computes clamped drawing area.
static GSVector4i GetClampedDrawingArea(const GPUDrawingArea& drawing_area);
float ComputeHorizontalFrequency() const;
float ComputeVerticalFrequency() const;
float ComputeDisplayAspectRatio() const;
float ComputeSourceAspectRatio() const;
float ComputePixelAspectRatio() const;
/// Computes aspect ratio correction, i.e. the scale to apply to the source aspect ratio to preserve
/// the original pixel aspect ratio regardless of how much cropping has been applied.
float ComputeAspectRatioCorrection() const;
/// Applies the pixel aspect ratio to a given size, preserving the larger dimension.
void ApplyPixelAspectRatioToSize(float* width, float* height) const;
static std::unique_ptr<GPU> CreateHardwareRenderer();
static std::unique_ptr<GPU> CreateSoftwareRenderer();
static void ApplyPixelAspectRatioToSize(float par, float* width, float* height);
// Converts window coordinates into horizontal ticks and scanlines. Returns false if out of range. Used for lightguns.
void ConvertScreenCoordinatesToDisplayCoordinates(float window_x, float window_y, float* display_x,
@ -231,38 +215,17 @@ public:
// Dumps raw VRAM to a file.
bool DumpVRAMToFile(const char* filename);
// Ensures all buffered vertices are drawn.
virtual void FlushRender() = 0;
// Queues the current frame for presentation. Should only be used with runahead.
void QueuePresentCurrentFrame();
/// Helper function for computing the draw rectangle in a larger window.
void CalculateDrawRect(s32 window_width, s32 window_height, bool apply_rotation, bool apply_aspect_ratio,
GSVector4i* display_rect, GSVector4i* draw_rect) const;
static void CalculateDrawRect(u32 window_width, u32 window_height, u32 crtc_display_width, u32 crtc_display_height,
s32 display_origin_left, s32 display_origin_top, u32 display_vram_width,
u32 display_vram_height, DisplayRotation rotation, DisplayAlignment alignment,
float pixel_aspect_ratio, bool stretch_vertically, bool integer_scale,
GSVector4i* display_rect, GSVector4i* draw_rect);
/// Helper function for computing screenshot bounds.
void CalculateScreenshotSize(DisplayScreenshotMode mode, u32* width, u32* height, GSVector4i* display_rect,
GSVector4i* draw_rect) const;
/// Helper function to save current display texture to PNG.
bool WriteDisplayTextureToFile(std::string path);
/// Renders the display, optionally with postprocessing to the specified image.
bool RenderScreenshotToBuffer(u32 width, u32 height, const GSVector4i display_rect, const GSVector4i draw_rect,
bool postfx, Image* out_image);
/// Helper function to save screenshot to PNG.
bool RenderScreenshotToFile(std::string path, DisplayScreenshotMode mode, u8 quality, bool compress_on_thread,
bool show_osd_message);
/// Draws the current display texture, with any post-processing.
GPUDevice::PresentResult PresentDisplay();
/// Sends the current frame to media capture.
bool SendDisplayToMediaCapture(MediaCapture* cap);
/// Reads the CLUT from the specified coordinates, accounting for wrap-around.
static void ReadCLUT(u16* dest, GPUTexturePaletteReg reg, bool clut_is_8bit);
protected:
private:
TickCount CRTCTicksToSystemTicks(TickCount crtc_ticks, TickCount fractional_ticks) const;
TickCount SystemTicksToCRTCTicks(TickCount sysclk_ticks, TickCount* fractional_ticks) const;
@ -273,16 +236,6 @@ protected:
}
ALWAYS_INLINE static constexpr TickCount SystemTicksToGPUTicks(TickCount sysclk_ticks) { return sysclk_ticks << 1; }
static constexpr std::tuple<u8, u8> UnpackTexcoord(u16 texcoord)
{
return std::make_tuple(static_cast<u8>(texcoord), static_cast<u8>(texcoord >> 8));
}
static constexpr std::tuple<u8, u8, u8> UnpackColorRGB24(u32 rgb24)
{
return std::make_tuple(static_cast<u8>(rgb24), static_cast<u8>(rgb24 >> 8), static_cast<u8>(rgb24 >> 16));
}
static bool DumpVRAMToFile(const char* filename, u32 width, u32 height, u32 stride, const void* buffer,
bool remove_alpha);
@ -302,10 +255,10 @@ protected:
void UpdateGPUIdle();
/// Returns 0 if the currently-displayed field is on odd lines (1,3,5,...) or 1 if even (2,4,6,...).
ALWAYS_INLINE u32 GetInterlacedDisplayField() const { return ZeroExtend32(m_crtc_state.interlaced_field); }
ALWAYS_INLINE u8 GetInterlacedDisplayField() const { return m_crtc_state.interlaced_field; }
/// Returns 0 if the currently-displayed field is on an even line in VRAM, otherwise 1.
ALWAYS_INLINE u32 GetActiveLineLSB() const { return ZeroExtend32(m_crtc_state.active_line_lsb); }
ALWAYS_INLINE u8 GetActiveLineLSB() const { return m_crtc_state.active_line_lsb; }
/// Updates drawing area that's suitablef or clamping.
void SetClampedDrawingArea();
@ -340,16 +293,13 @@ protected:
void InvalidateCLUT();
bool IsCLUTValid() const;
// Rendering in the backend
virtual void ReadVRAM(u32 x, u32 y, u32 width, u32 height) = 0;
virtual void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color) = 0;
virtual void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask) = 0;
virtual void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height) = 0;
virtual void DispatchRenderCommand() = 0;
virtual void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) = 0;
virtual void UpdateDisplay() = 0;
virtual void DrawRendererStats();
virtual void OnBufferSwapped();
void ReadVRAM(u16 x, u16 y, u16 width, u16 height);
void UpdateVRAM(u16 x, u16 y, u16 width, u16 height, const void* data, bool set_mask, bool check_mask);
void UpdateDisplay(bool submit_frame);
void PrepareForDraw();
void FinishPolyline();
void FillDrawCommand(GPUBackendDrawCommand* RESTRICT cmd, GPURenderCommand rc) const;
ALWAYS_INLINE_RELEASE void AddDrawTriangleTicks(GSVector2i v1, GSVector2i v2, GSVector2i v3, bool shaded,
bool textured, bool semitransparent)
@ -446,14 +396,10 @@ protected:
u32 texture_window_value;
// decoded values
// TODO: Make this a command
GPUTextureWindow texture_window;
bool texture_x_flip;
bool texture_y_flip;
bool texture_page_changed;
ALWAYS_INLINE bool IsTexturePageChanged() const { return texture_page_changed; }
ALWAYS_INLINE void SetTexturePageChanged() { texture_page_changed = true; }
ALWAYS_INLINE void ClearTexturePageChangedFlag() { texture_page_changed = false; }
} m_draw_mode = {};
GPUDrawingArea m_drawing_area = {};
@ -587,65 +533,7 @@ protected:
TickCount m_max_run_ahead = 128;
u32 m_fifo_size = 128;
void ClearDisplayTexture();
void SetDisplayTexture(GPUTexture* texture, GPUTexture* depth_texture, s32 view_x, s32 view_y, s32 view_width,
s32 view_height);
GPUDevice::PresentResult RenderDisplay(GPUTexture* target, const GSVector4i display_rect, const GSVector4i draw_rect,
bool postfx);
bool Deinterlace(u32 field, u32 line_skip);
bool DeinterlaceExtractField(u32 dst_bufidx, GPUTexture* src, u32 x, u32 y, u32 width, u32 height, u32 line_skip);
bool DeinterlaceSetTargetSize(u32 width, u32 height, bool preserve);
void DestroyDeinterlaceTextures();
bool ApplyChromaSmoothing();
u32 m_current_deinterlace_buffer = 0;
std::unique_ptr<GPUPipeline> m_deinterlace_pipeline;
std::unique_ptr<GPUPipeline> m_deinterlace_extract_pipeline;
std::array<std::unique_ptr<GPUTexture>, DEINTERLACE_BUFFER_COUNT> m_deinterlace_buffers;
std::unique_ptr<GPUTexture> m_deinterlace_texture;
std::unique_ptr<GPUPipeline> m_chroma_smoothing_pipeline;
std::unique_ptr<GPUTexture> m_chroma_smoothing_texture;
std::unique_ptr<GPUPipeline> m_display_pipeline;
GPUTexture* m_display_texture = nullptr;
GPUTexture* m_display_depth_buffer = nullptr;
s32 m_display_texture_view_x = 0;
s32 m_display_texture_view_y = 0;
s32 m_display_texture_view_width = 0;
s32 m_display_texture_view_height = 0;
struct Counters
{
u32 num_reads;
u32 num_writes;
u32 num_copies;
u32 num_vertices;
u32 num_primitives;
// u32 num_read_texture_updates;
// u32 num_ubo_updates;
};
struct Stats : Counters
{
size_t host_buffer_streamed;
u32 host_num_draws;
u32 host_num_barriers;
u32 host_num_render_passes;
u32 host_num_copies;
u32 host_num_downloads;
u32 host_num_uploads;
};
Counters m_counters = {};
Stats m_stats = {};
private:
bool CompileDisplayPipelines(bool display, bool deinterlace, bool chroma_smoothing, Error* error);
using GP0CommandHandler = bool (GPU::*)();
using GP0CommandHandlerTable = std::array<GP0CommandHandler, 256>;
static GP0CommandHandlerTable GenerateGP0CommandHandlerTable();

1626
src/core/gpu_backend.cpp
View File

File diff suppressed because it is too large Load Diff

234
src/core/gpu_backend.h
View File

@ -3,7 +3,9 @@
#pragma once
#include "gpu_types.h"
#include "gpu_thread_commands.h"
#include "util/gpu_device.h"
#include "common/heap_array.h"
#include "common/threading.h"
@ -12,85 +14,193 @@
#include <condition_variable>
#include <memory>
#include <mutex>
#include <tuple>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4324) // warning C4324: 'GPUBackend': structure was padded due to alignment specifier
#endif
class Error;
class SmallStringBase;
class GPUFramebuffer;
class GPUPipeline;
struct Settings;
class StateWrapper;
namespace System {
struct MemorySaveState;
}
// DESIGN NOTE: Only static methods should be called on the CPU thread.
// You specifically don't have a global pointer available for this reason.
class GPUBackend
{
public:
static GPUThreadCommand* NewClearVRAMCommand();
static GPUThreadCommand* NewClearDisplayCommand();
static GPUBackendUpdateDisplayCommand* NewUpdateDisplayCommand();
static GPUBackendSubmitFrameCommand* NewSubmitFrameCommand();
static GPUThreadCommand* NewClearCacheCommand();
static GPUThreadCommand* NewBufferSwappedCommand();
static GPUBackendReadVRAMCommand* NewReadVRAMCommand();
static GPUBackendFillVRAMCommand* NewFillVRAMCommand();
static GPUBackendUpdateVRAMCommand* NewUpdateVRAMCommand(u32 num_words);
static GPUBackendCopyVRAMCommand* NewCopyVRAMCommand();
static GPUBackendSetDrawingAreaCommand* NewSetDrawingAreaCommand();
static GPUBackendUpdateCLUTCommand* NewUpdateCLUTCommand();
static GPUBackendDrawPolygonCommand* NewDrawPolygonCommand(u32 num_vertices);
static GPUBackendDrawPrecisePolygonCommand* NewDrawPrecisePolygonCommand(u32 num_vertices);
static GPUBackendDrawRectangleCommand* NewDrawRectangleCommand();
static GPUBackendDrawLineCommand* NewDrawLineCommand(u32 num_vertices);
static void PushCommand(GPUThreadCommand* cmd);
static void PushCommandAndWakeThread(GPUThreadCommand* cmd);
static void PushCommandAndSync(GPUThreadCommand* cmd, bool spin);
static void SyncGPUThread(bool spin);
static bool IsUsingHardwareBackend();
static std::unique_ptr<GPUBackend> CreateHardwareBackend();
static std::unique_ptr<GPUBackend> CreateSoftwareBackend();
static bool RenderScreenshotToBuffer(u32 width, u32 height, bool postfx, Image* out_image);
static void RenderScreenshotToFile(const std::string_view path, DisplayScreenshotMode mode, u8 quality,
bool compress_on_thread, bool show_osd_message);
static bool BeginQueueFrame();
static void WaitForOneQueuedFrame();
static u32 GetQueuedFrameCount();
static bool AllocateMemorySaveStates(std::span<System::MemorySaveState> states, Error* error);
public:
GPUBackend();
virtual ~GPUBackend();
ALWAYS_INLINE const Threading::Thread* GetThread() const { return m_use_gpu_thread ? &m_gpu_thread : nullptr; }
ALWAYS_INLINE bool IsUsingThread() const { return m_use_gpu_thread; }
virtual bool Initialize(bool upload_vram, Error* error);
virtual bool Initialize(bool use_thread);
virtual void Reset();
virtual void Shutdown();
virtual void UpdateSettings(const Settings& old_settings);
void SetThreadEnabled(bool use_thread);
/// Returns the current resolution scale.
virtual u32 GetResolutionScale() const = 0;
GPUBackendFillVRAMCommand* NewFillVRAMCommand();
GPUBackendUpdateVRAMCommand* NewUpdateVRAMCommand(u32 num_words);
GPUBackendCopyVRAMCommand* NewCopyVRAMCommand();
GPUBackendSetDrawingAreaCommand* NewSetDrawingAreaCommand();
GPUBackendUpdateCLUTCommand* NewUpdateCLUTCommand();
GPUBackendDrawPolygonCommand* NewDrawPolygonCommand(u32 num_vertices);
GPUBackendDrawRectangleCommand* NewDrawRectangleCommand();
GPUBackendDrawLineCommand* NewDrawLineCommand(u32 num_vertices);
/// Updates the resolution scale when it's set to automatic.
virtual void UpdateResolutionScale() = 0;
void PushCommand(GPUBackendCommand* cmd);
void Sync(bool allow_sleep);
// Graphics API state reset/restore - call when drawing the UI etc.
// TODO: replace with "invalidate cached state"
virtual void RestoreDeviceContext() = 0;
/// Processes all pending GPU commands.
void RunGPULoop();
/// Main command handler for GPU thread.
void HandleCommand(const GPUThreadCommand* cmd);
/// Draws the current display texture, with any post-processing.
GPUDevice::PresentResult PresentDisplay();
/// Helper function to save current display texture to PNG. Used for regtest.
bool WriteDisplayTextureToFile(std::string filename);
/// Helper function for computing screenshot bounds.
void CalculateScreenshotSize(DisplayScreenshotMode mode, u32* width, u32* height, GSVector4i* display_rect,
GSVector4i* draw_rect) const;
void GetStatsString(SmallStringBase& str) const;
void GetMemoryStatsString(SmallStringBase& str) const;
void ResetStatistics();
void UpdateStatistics(u32 frame_count);
protected:
void* AllocateCommand(GPUBackendCommandType command, u32 size);
u32 GetPendingCommandSize() const;
void WakeGPUThread();
void StartGPUThread();
void StopGPUThread();
virtual void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, GPUBackendCommandParameters params) = 0;
virtual void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data,
GPUBackendCommandParameters params) = 0;
virtual void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height,
GPUBackendCommandParameters params) = 0;
virtual void DrawPolygon(const GPUBackendDrawPolygonCommand* cmd) = 0;
virtual void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd) = 0;
virtual void DrawLine(const GPUBackendDrawLineCommand* cmd) = 0;
virtual void FlushRender() = 0;
virtual void DrawingAreaChanged(const GPUDrawingArea& new_drawing_area, const GSVector4i clamped_drawing_area) = 0;
virtual void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) = 0;
void HandleCommand(const GPUBackendCommand* cmd);
Threading::KernelSemaphore m_sync_semaphore;
std::atomic_bool m_gpu_thread_sleeping{false};
std::atomic_bool m_gpu_loop_done{false};
Threading::Thread m_gpu_thread;
bool m_use_gpu_thread = false;
std::mutex m_sync_mutex;
std::condition_variable m_sync_cpu_thread_cv;
std::condition_variable m_wake_gpu_thread_cv;
bool m_sync_done = false;
enum : u32
{
COMMAND_QUEUE_SIZE = 4 * 1024 * 1024,
THRESHOLD_TO_WAKE_GPU = 256
DEINTERLACE_BUFFER_COUNT = 4,
};
FixedHeapArray<u8, COMMAND_QUEUE_SIZE> m_command_fifo_data;
alignas(HOST_CACHE_LINE_SIZE) std::atomic<u32> m_command_fifo_read_ptr{0};
alignas(HOST_CACHE_LINE_SIZE) std::atomic<u32> m_command_fifo_write_ptr{0};
virtual void ReadVRAM(u32 x, u32 y, u32 width, u32 height) = 0;
virtual void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, bool interlaced_rendering,
u8 interlaced_display_field) = 0;
virtual void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask) = 0;
virtual void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height, bool set_mask,
bool check_mask) = 0;
virtual void DrawPolygon(const GPUBackendDrawPolygonCommand* cmd) = 0;
virtual void DrawPrecisePolygon(const GPUBackendDrawPrecisePolygonCommand* cmd) = 0;
virtual void DrawSprite(const GPUBackendDrawRectangleCommand* cmd) = 0;
virtual void DrawLine(const GPUBackendDrawLineCommand* cmd) = 0;
virtual void DrawingAreaChanged() = 0;
virtual void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) = 0;
virtual void ClearCache() = 0;
virtual void OnBufferSwapped() = 0;
virtual void ClearVRAM() = 0;
virtual void UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd) = 0;
virtual void LoadState(const GPUBackendLoadStateCommand* cmd) = 0;
virtual bool AllocateMemorySaveState(System::MemorySaveState& mss, Error* error) = 0;
virtual void DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss) = 0;
/// Ensures all pending draws are flushed to the host GPU.
virtual void FlushRender() = 0;
/// Helper function for computing the draw rectangle in a larger window.
void CalculateDrawRect(s32 window_width, s32 window_height, bool apply_rotation, bool apply_aspect_ratio,
GSVector4i* display_rect, GSVector4i* draw_rect) const;
/// Renders the display, optionally with postprocessing to the specified image.
bool RenderScreenshotToBuffer(u32 width, u32 height, const GSVector4i display_rect, const GSVector4i draw_rect,
bool postfx, Image* out_image);
bool CompileDisplayPipelines(bool display, bool deinterlace, bool chroma_smoothing, Error* error);
void HandleUpdateDisplayCommand(const GPUBackendUpdateDisplayCommand* cmd);
void HandleSubmitFrameCommand(const GPUBackendFramePresentationParameters* cmd);
void ClearDisplay();
void ClearDisplayTexture();
void SetDisplayTexture(GPUTexture* texture, GPUTexture* depth_buffer, s32 view_x, s32 view_y, s32 view_width,
s32 view_height);
GPUDevice::PresentResult RenderDisplay(GPUTexture* target, const GSVector4i display_rect, const GSVector4i draw_rect,
bool postfx);
/// Sends the current frame to media capture.
void SendDisplayToMediaCapture(MediaCapture* cap);
bool Deinterlace(u32 field, u32 line_skip);
bool DeinterlaceExtractField(u32 dst_bufidx, GPUTexture* src, u32 x, u32 y, u32 width, u32 height, u32 line_skip);
bool DeinterlaceSetTargetSize(u32 width, u32 height, bool preserve);
void DestroyDeinterlaceTextures();
bool ApplyChromaSmoothing();
s32 m_display_width = 0;
s32 m_display_height = 0;
s32 m_display_origin_left = 0;
s32 m_display_origin_top = 0;
s32 m_display_vram_width = 0;
s32 m_display_vram_height = 0;
float m_display_pixel_aspect_ratio = 1.0f;
u32 m_current_deinterlace_buffer = 0;
std::unique_ptr<GPUPipeline> m_deinterlace_pipeline;
std::unique_ptr<GPUPipeline> m_deinterlace_extract_pipeline;
std::array<std::unique_ptr<GPUTexture>, DEINTERLACE_BUFFER_COUNT> m_deinterlace_buffers;
std::unique_ptr<GPUTexture> m_deinterlace_texture;
std::unique_ptr<GPUPipeline> m_chroma_smoothing_pipeline;
std::unique_ptr<GPUTexture> m_chroma_smoothing_texture;
std::unique_ptr<GPUPipeline> m_display_pipeline;
GPUTexture* m_display_texture = nullptr;
GPUTexture* m_display_depth_buffer = nullptr;
s32 m_display_texture_view_x = 0;
s32 m_display_texture_view_y = 0;
s32 m_display_texture_view_width = 0;
s32 m_display_texture_view_height = 0;
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif
namespace Host {
/// Called at the end of the frame, before presentation.
void FrameDoneOnGPUThread(GPUBackend* gpu_backend, u32 frame_number);
} // namespace Host

486
src/core/gpu_commands.cpp
View File

@ -1,13 +1,17 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "cpu_pgxp.h"
#include "gpu.h"
#include "gpu_backend.h"
#include "gpu_dump.h"
#include "gpu_hw_texture_cache.h"
#include "gpu_thread_commands.h"
#include "interrupt_controller.h"
#include "system.h"
#include "common/assert.h"
#include "common/gsvector_formatter.h"
#include "common/log.h"
#include "common/string_util.h"
@ -93,7 +97,7 @@ void GPU::TryExecuteCommands()
// drop terminator
m_fifo.RemoveOne();
DEBUG_LOG("Drawing poly-line with {} vertices", GetPolyLineVertexCount());
DispatchRenderCommand();
FinishPolyline();
m_blit_buffer.clear();
EndCommand();
continue;
@ -200,8 +204,8 @@ bool GPU::HandleNOPCommand()
bool GPU::HandleClearCacheCommand()
{
DEBUG_LOG("GP0 clear cache");
m_draw_mode.SetTexturePageChanged();
InvalidateCLUT();
GPUBackend::PushCommand(GPUBackend::NewClearCacheCommand());
m_fifo.RemoveOne();
AddCommandTicks(1);
EndCommand();
@ -248,8 +252,6 @@ bool GPU::HandleSetDrawingAreaTopLeftCommand()
DEBUG_LOG("Set drawing area top-left: ({}, {})", left, top);
if (m_drawing_area.left != left || m_drawing_area.top != top)
{
FlushRender();
m_drawing_area.left = left;
m_drawing_area.top = top;
m_drawing_area_changed = true;
@ -270,8 +272,6 @@ bool GPU::HandleSetDrawingAreaBottomRightCommand()
DEBUG_LOG("Set drawing area bottom-right: ({}, {})", right, bottom);
if (m_drawing_area.right != right || m_drawing_area.bottom != bottom)
{
FlushRender();
m_drawing_area.right = right;
m_drawing_area.bottom = bottom;
m_drawing_area_changed = true;
@ -291,8 +291,6 @@ bool GPU::HandleSetDrawingOffsetCommand()
DEBUG_LOG("Set drawing offset ({}, {})", x, y);
if (m_drawing_offset.x != x || m_drawing_offset.y != y)
{
FlushRender();
m_drawing_offset.x = x;
m_drawing_offset.y = y;
}
@ -308,11 +306,7 @@ bool GPU::HandleSetMaskBitCommand()
constexpr u32 gpustat_mask = (1 << 11) | (1 << 12);
const u32 gpustat_bits = (param & 0x03) << 11;
if ((m_GPUSTAT.bits & gpustat_mask) != gpustat_bits)
{
FlushRender();
m_GPUSTAT.bits = (m_GPUSTAT.bits & ~gpustat_mask) | gpustat_bits;
}
DEBUG_LOG("Set mask bit {} {}", BoolToUInt32(m_GPUSTAT.set_mask_while_drawing),
BoolToUInt32(m_GPUSTAT.check_mask_before_draw));
@ -321,6 +315,35 @@ bool GPU::HandleSetMaskBitCommand()
return true;
}
void GPU::PrepareForDraw()
{
if (m_drawing_area_changed)
{
m_drawing_area_changed = false;
GPUBackendSetDrawingAreaCommand* cmd = GPUBackend::NewSetDrawingAreaCommand();
cmd->new_area = m_drawing_area;
GPUBackend::PushCommand(cmd);
}
}
void GPU::FillDrawCommand(GPUBackendDrawCommand* RESTRICT cmd, GPURenderCommand rc) const
{
cmd->interlaced_rendering = IsInterlacedRenderingEnabled();
cmd->active_line_lsb = ConvertToBoolUnchecked(m_crtc_state.active_line_lsb);
cmd->check_mask_before_draw = m_GPUSTAT.check_mask_before_draw;
cmd->set_mask_while_drawing = m_GPUSTAT.set_mask_while_drawing;
cmd->texture_enable = rc.IsTexturingEnabled();
cmd->raw_texture_enable = rc.raw_texture_enable;
cmd->transparency_enable = rc.transparency_enable;
cmd->shading_enable = rc.shading_enable;
cmd->quad_polygon = rc.quad_polygon;
cmd->dither_enable = rc.IsDitheringEnabled() && m_draw_mode.mode_reg.dither_enable;
cmd->draw_mode.bits = m_draw_mode.mode_reg.bits;
cmd->palette.bits = m_draw_mode.palette_reg.bits;
cmd->window = m_draw_mode.texture_window;
}
bool GPU::HandleRenderPolygonCommand()
{
const GPURenderCommand rc{FifoPeek(0)};
@ -346,6 +369,7 @@ bool GPU::HandleRenderPolygonCommand()
words_per_vertex, setup_ticks);
// set draw state up
// TODO: Get rid of SetTexturePalette() and just fill it as needed
if (rc.texture_enable)
{
const u16 texpage_attribute = Truncate16((rc.shading_enable ? FifoPeek(5) : FifoPeek(4)) >> 16);
@ -355,12 +379,233 @@ bool GPU::HandleRenderPolygonCommand()
UpdateCLUTIfNeeded(m_draw_mode.mode_reg.texture_mode, m_draw_mode.palette_reg);
}
m_counters.num_vertices += num_vertices;
m_counters.num_primitives++;
m_render_command.bits = rc.bits;
m_fifo.RemoveOne();
DispatchRenderCommand();
PrepareForDraw();
if (g_settings.gpu_pgxp_enable)
{
GPUBackendDrawPrecisePolygonCommand* RESTRICT cmd = GPUBackend::NewDrawPrecisePolygonCommand(num_vertices);
FillDrawCommand(cmd, rc);
cmd->num_vertices = Truncate16(num_vertices);
const u32 first_color = rc.color_for_first_vertex;
const bool shaded = rc.shading_enable;
const bool textured = rc.texture_enable;
bool valid_w = g_settings.gpu_pgxp_texture_correction;
for (u32 i = 0; i < num_vertices; i++)
{
GPUBackendDrawPrecisePolygonCommand::Vertex* RESTRICT vert = &cmd->vertices[i];
vert->color = (shaded && i > 0) ? (FifoPop() & UINT32_C(0x00FFFFFF)) : first_color;
const u64 maddr_and_pos = m_fifo.Pop();
const GPUVertexPosition vp{Truncate32(maddr_and_pos)};
vert->native_x = m_drawing_offset.x + vp.x;
vert->native_y = m_drawing_offset.y + vp.y;
vert->texcoord = textured ? Truncate16(FifoPop()) : 0;
valid_w &= CPU::PGXP::GetPreciseVertex(Truncate32(maddr_and_pos >> 32), vp.bits, vert->native_x, vert->native_y,
m_drawing_offset.x, m_drawing_offset.y, &vert->x, &vert->y, &vert->w);
}
cmd->valid_w = valid_w;
if (!valid_w)
{
if (g_settings.gpu_pgxp_disable_2d)
{
// NOTE: This reads uninitialized data, but it's okay, it doesn't get used.
for (u32 i = 0; i < num_vertices; i++)
{
GPUBackendDrawPrecisePolygonCommand::Vertex& v = cmd->vertices[i];
GSVector2::store<false>(&v.x, GSVector2(GSVector2i::load<false>(&v.native_x)));
v.w = 1.0f;
}
}
else
{
for (u32 i = 0; i < num_vertices; i++)
cmd->vertices[i].w = 1.0f;
}
}
// Cull polygons which are too large.
const GSVector2 v0f = GSVector2::load<false>(&cmd->vertices[0].x);
const GSVector2 v1f = GSVector2::load<false>(&cmd->vertices[1].x);
const GSVector2 v2f = GSVector2::load<false>(&cmd->vertices[2].x);
const GSVector2 min_pos_12 = v1f.min(v2f);
const GSVector2 max_pos_12 = v1f.max(v2f);
const GSVector4i draw_rect_012 = GSVector4i(GSVector4(min_pos_12.min(v0f)).upld(GSVector4(max_pos_12.max(v0f))))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
const bool first_tri_culled =
(draw_rect_012.width() > MAX_PRIMITIVE_WIDTH || draw_rect_012.height() > MAX_PRIMITIVE_HEIGHT ||
!draw_rect_012.rintersects(m_clamped_drawing_area));
if (first_tri_culled)
{
// TODO: GPU events... somehow.
DEBUG_LOG("Culling off-screen/too-large polygon: {},{} {},{} {},{}", cmd->vertices[0].native_x,
cmd->vertices[0].native_y, cmd->vertices[1].native_x, cmd->vertices[1].native_y,
cmd->vertices[2].native_x, cmd->vertices[2].native_y);
if (!rc.quad_polygon)
{
EndCommand();
return true;
}
}
else
{
AddDrawTriangleTicks(GSVector2i::load<false>(&cmd->vertices[0].native_x),
GSVector2i::load<false>(&cmd->vertices[1].native_x),
GSVector2i::load<false>(&cmd->vertices[2].native_x), rc.shading_enable, rc.texture_enable,
rc.transparency_enable);
}
// quads
if (rc.quad_polygon)
{
const GSVector2 v3f = GSVector2::load<false>(&cmd->vertices[3].x);
const GSVector4i draw_rect_123 = GSVector4i(GSVector4(min_pos_12.min(v3f)).upld(GSVector4(max_pos_12.max(v3f))))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
// Cull polygons which are too large.
const bool second_tri_culled =
(draw_rect_123.width() > MAX_PRIMITIVE_WIDTH || draw_rect_123.height() > MAX_PRIMITIVE_HEIGHT ||
!draw_rect_123.rintersects(m_clamped_drawing_area));
if (second_tri_culled)
{
DEBUG_LOG("Culling off-screen/too-large polygon (quad second half): {},{} {},{} {},{}",
cmd->vertices[2].native_x, cmd->vertices[2].native_y, cmd->vertices[1].native_x,
cmd->vertices[1].native_y, cmd->vertices[0].native_x, cmd->vertices[0].native_y);
if (first_tri_culled)
{
EndCommand();
return true;
}
// Remove second part of quad.
// NOTE: Culling this way results in subtle differences with UV clamping, since the fourth vertex is no
// longer considered in the range. This is mainly apparent when the UV gradient is zero. Seems like it
// generally looks better this way, so I'm keeping it.
cmd->size = GPUThreadCommand::AlignCommandSize(sizeof(GPUBackendDrawPrecisePolygonCommand) +
3 * sizeof(GPUBackendDrawPrecisePolygonCommand::Vertex));
cmd->num_vertices = 3;
}
else
{
AddDrawTriangleTicks(GSVector2i::load<false>(&cmd->vertices[2].native_x),
GSVector2i::load<false>(&cmd->vertices[1].native_x),
GSVector2i::load<false>(&cmd->vertices[3].native_x), rc.shading_enable, rc.texture_enable,
rc.transparency_enable);
// If first part was culled, move the second part to the first.
if (first_tri_culled)
{
std::memcpy(&cmd->vertices[0], &cmd->vertices[2], sizeof(GPUBackendDrawPrecisePolygonCommand::Vertex));
std::memcpy(&cmd->vertices[2], &cmd->vertices[3], sizeof(GPUBackendDrawPrecisePolygonCommand::Vertex));
cmd->size = GPUThreadCommand::AlignCommandSize(sizeof(GPUBackendDrawPrecisePolygonCommand) +
3 * sizeof(GPUBackendDrawPrecisePolygonCommand::Vertex));
cmd->num_vertices = 3;
}
}
}
GPUBackend::PushCommand(cmd);
}
else
{
GPUBackendDrawPolygonCommand* RESTRICT cmd = GPUBackend::NewDrawPolygonCommand(num_vertices);
FillDrawCommand(cmd, rc);
cmd->num_vertices = Truncate16(num_vertices);
const u32 first_color = rc.color_for_first_vertex;
const bool shaded = rc.shading_enable;
const bool textured = rc.texture_enable;
for (u32 i = 0; i < num_vertices; i++)
{
GPUBackendDrawPolygonCommand::Vertex* RESTRICT vert = &cmd->vertices[i];
vert->color = (shaded && i > 0) ? (FifoPop() & UINT32_C(0x00FFFFFF)) : first_color;
const u64 maddr_and_pos = m_fifo.Pop();
const GPUVertexPosition vp{Truncate32(maddr_and_pos)};
vert->x = m_drawing_offset.x + vp.x;
vert->y = m_drawing_offset.y + vp.y;
vert->texcoord = textured ? Truncate16(FifoPop()) : 0;
}
// Cull polygons which are too large.
const GSVector2i v0 = GSVector2i::load<false>(&cmd->vertices[0].x);
const GSVector2i v1 = GSVector2i::load<false>(&cmd->vertices[1].x);
const GSVector2i v2 = GSVector2i::load<false>(&cmd->vertices[2].x);
const GSVector2i min_pos_12 = v1.min_s32(v2);
const GSVector2i max_pos_12 = v1.max_s32(v2);
const GSVector4i draw_rect_012 =
GSVector4i::xyxy(min_pos_12.min_s32(v0), max_pos_12.max_s32(v0)).add32(GSVector4i::cxpr(0, 0, 1, 1));
const bool first_tri_culled =
(draw_rect_012.width() > MAX_PRIMITIVE_WIDTH || draw_rect_012.height() > MAX_PRIMITIVE_HEIGHT ||
!draw_rect_012.rintersects(m_clamped_drawing_area));
if (first_tri_culled)
{
DEBUG_LOG("Culling off-screen/too-large polygon: {},{} {},{} {},{}", cmd->vertices[0].x, cmd->vertices[0].y,
cmd->vertices[1].x, cmd->vertices[1].y, cmd->vertices[2].x, cmd->vertices[2].y);
if (!rc.quad_polygon)
{
EndCommand();
return true;
}
}
else
{
AddDrawTriangleTicks(v0, v1, v2, rc.shading_enable, rc.texture_enable, rc.transparency_enable);
}
// quads
if (rc.quad_polygon)
{
const GSVector2i v3 = GSVector2i::load<false>(&cmd->vertices[3].x);
const GSVector4i draw_rect_123 = GSVector4i(min_pos_12.min_s32(v3))
.upl64(GSVector4i(max_pos_12.max_s32(v3)))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
// Cull polygons which are too large.
const bool second_tri_culled =
(draw_rect_123.width() > MAX_PRIMITIVE_WIDTH || draw_rect_123.height() > MAX_PRIMITIVE_HEIGHT ||
!draw_rect_123.rintersects(m_clamped_drawing_area));
if (second_tri_culled)
{
DEBUG_LOG("Culling too-large polygon (quad second half): {},{} {},{} {},{}", cmd->vertices[2].x,
cmd->vertices[2].y, cmd->vertices[1].x, cmd->vertices[1].y, cmd->vertices[0].x, cmd->vertices[0].y);
if (first_tri_culled)
{
EndCommand();
return true;
}
// Remove second part of quad.
cmd->size = GPUThreadCommand::AlignCommandSize(sizeof(GPUBackendDrawPolygonCommand) +
3 * sizeof(GPUBackendDrawPolygonCommand::Vertex));
cmd->num_vertices = 3;
}
else
{
AddDrawTriangleTicks(v2, v1, v3, rc.shading_enable, rc.texture_enable, rc.transparency_enable);
// If first part was culled, move the second part to the first.
if (first_tri_culled)
{
std::memcpy(&cmd->vertices[0], &cmd->vertices[2], sizeof(GPUBackendDrawPolygonCommand::Vertex));
std::memcpy(&cmd->vertices[2], &cmd->vertices[3], sizeof(GPUBackendDrawPolygonCommand::Vertex));
cmd->size = GPUThreadCommand::AlignCommandSize(sizeof(GPUBackendDrawPolygonCommand) +
3 * sizeof(GPUBackendDrawPolygonCommand::Vertex));
cmd->num_vertices = 3;
}
}
}
GPUBackend::PushCommand(cmd);
}
EndCommand();
return true;
}
@ -389,12 +634,65 @@ bool GPU::HandleRenderRectangleCommand()
rc.transparency_enable ? "semi-transparent" : "opaque", rc.texture_enable ? "textured" : "non-textured",
rc.shading_enable ? "shaded" : "monochrome", total_words, setup_ticks);
m_counters.num_vertices++;
m_counters.num_primitives++;
m_render_command.bits = rc.bits;
m_fifo.RemoveOne();
DispatchRenderCommand();
PrepareForDraw();
GPUBackendDrawRectangleCommand* cmd = GPUBackend::NewDrawRectangleCommand();
FillDrawCommand(cmd, rc);
cmd->color = rc.color_for_first_vertex;
const GPUVertexPosition vp{FifoPop()};
cmd->x = TruncateGPUVertexPosition(m_drawing_offset.x + vp.x);
cmd->y = TruncateGPUVertexPosition(m_drawing_offset.y + vp.y);
if (rc.texture_enable)
{
const u32 texcoord_and_palette = FifoPop();
cmd->palette.bits = Truncate16(texcoord_and_palette >> 16);
cmd->texcoord = Truncate16(texcoord_and_palette);
}
else
{
cmd->palette.bits = 0;
cmd->texcoord = 0;
}
switch (rc.rectangle_size)
{
case GPUDrawRectangleSize::R1x1:
cmd->width = 1;
cmd->height = 1;
break;
case GPUDrawRectangleSize::R8x8:
cmd->width = 8;
cmd->height = 8;
break;
case GPUDrawRectangleSize::R16x16:
cmd->width = 16;
cmd->height = 16;
break;
default:
{
const u32 width_and_height = FifoPop();
cmd->width = static_cast<u16>(width_and_height & VRAM_WIDTH_MASK);
cmd->height = static_cast<u16>((width_and_height >> 16) & VRAM_HEIGHT_MASK);
}
break;
}
const GSVector4i rect = GSVector4i(cmd->x, cmd->y, cmd->x + cmd->width, cmd->y + cmd->height);
const GSVector4i clamped_rect = m_clamped_drawing_area.rintersect(rect);
if (clamped_rect.rempty()) [[unlikely]]
{
DEBUG_LOG("Culling off-screen rectangle {}", rect);
EndCommand();
return true;
}
AddDrawRectangleTicks(clamped_rect, rc.texture_enable, rc.transparency_enable);
GPUBackend::PushCommand(cmd);
EndCommand();
return true;
}
@ -411,12 +709,55 @@ bool GPU::HandleRenderLineCommand()
TRACE_LOG("Render {} {} line ({} total words)", rc.transparency_enable ? "semi-transparent" : "opaque",
rc.shading_enable ? "shaded" : "monochrome", total_words);
m_counters.num_vertices += 2;
m_counters.num_primitives++;
m_render_command.bits = rc.bits;
m_fifo.RemoveOne();
DispatchRenderCommand();
PrepareForDraw();
GPUBackendDrawLineCommand* cmd = GPUBackend::NewDrawLineCommand(2);
FillDrawCommand(cmd, rc);
cmd->palette.bits = 0;
if (rc.shading_enable)
{
cmd->vertices[0].color = rc.color_for_first_vertex;
const GPUVertexPosition start_pos{FifoPop()};
cmd->vertices[0].x = m_drawing_offset.x + start_pos.x;
cmd->vertices[0].y = m_drawing_offset.y + start_pos.y;
cmd->vertices[1].color = FifoPop() & UINT32_C(0x00FFFFFF);
const GPUVertexPosition end_pos{FifoPop()};
cmd->vertices[1].x = m_drawing_offset.x + end_pos.x;
cmd->vertices[1].y = m_drawing_offset.y + end_pos.y;
}
else
{
cmd->vertices[0].color = rc.color_for_first_vertex;
cmd->vertices[1].color = rc.color_for_first_vertex;
const GPUVertexPosition start_pos{FifoPop()};
cmd->vertices[0].x = m_drawing_offset.x + start_pos.x;
cmd->vertices[0].y = m_drawing_offset.y + start_pos.y;
const GPUVertexPosition end_pos{FifoPop()};
cmd->vertices[1].x = m_drawing_offset.x + end_pos.x;
cmd->vertices[1].y = m_drawing_offset.y + end_pos.y;
}
const GSVector2i v0 = GSVector2i::load<false>(&cmd->vertices[0].x);
const GSVector2i v1 = GSVector2i::load<false>(&cmd->vertices[1].x);
const GSVector4i rect = GSVector4i::xyxy(v0.min_s32(v1), v0.max_s32(v1)).add32(GSVector4i::cxpr(0, 0, 1, 1));
const GSVector4i clamped_rect = rect.rintersect(m_clamped_drawing_area);
if (rect.width() > MAX_PRIMITIVE_WIDTH || rect.height() > MAX_PRIMITIVE_HEIGHT || clamped_rect.rempty())
{
DEBUG_LOG("Culling too-large/off-screen line: {},{} - {},{}", cmd->vertices[0].y, cmd->vertices[0].y,
cmd->vertices[1].x, cmd->vertices[1].y);
EndCommand();
return true;
}
AddDrawLineTicks(clamped_rect, rc.shading_enable);
GPUBackend::PushCommand(cmd);
EndCommand();
return true;
}
@ -453,6 +794,64 @@ bool GPU::HandleRenderPolyLineCommand()
return true;
}
void GPU::FinishPolyline()
{
PrepareForDraw();
const u32 num_vertices = GetPolyLineVertexCount();
DebugAssert(num_vertices >= 2);
GPUBackendDrawLineCommand* cmd = GPUBackend::NewDrawLineCommand((num_vertices - 1) * 2);
FillDrawCommand(cmd, m_render_command);
u32 buffer_pos = 0;
const GPUVertexPosition start_vp{m_blit_buffer[buffer_pos++]};
const GSVector2i draw_offset = GSVector2i::load<false>(&m_drawing_offset.x);
GSVector2i start_pos = GSVector2i(start_vp.x, start_vp.y).add32(draw_offset);
u32 start_color = m_render_command.color_for_first_vertex;
const bool shaded = m_render_command.shading_enable;
u32 out_vertex_count = 0;
for (u32 i = 1; i < num_vertices; i++)
{
const u32 end_color =
shaded ? (m_blit_buffer[buffer_pos++] & UINT32_C(0x00FFFFFF)) : m_render_command.color_for_first_vertex;
const GPUVertexPosition vp{m_blit_buffer[buffer_pos++]};
const GSVector2i end_pos = GSVector2i(vp.x, vp.y).add32(draw_offset);
const GSVector4i rect =
GSVector4i::xyxy(start_pos.min_s32(end_pos), start_pos.max_s32(end_pos)).add32(GSVector4i::cxpr(0, 0, 1, 1));
const GSVector4i clamped_rect = rect.rintersect(m_clamped_drawing_area);
if (rect.width() > MAX_PRIMITIVE_WIDTH || rect.height() > MAX_PRIMITIVE_HEIGHT || clamped_rect.rempty())
{
DEBUG_LOG("Culling too-large/off-screen line: {},{} - {},{}", start_pos.x, start_pos.y, end_pos.x, end_pos.y);
}
else
{
AddDrawLineTicks(clamped_rect, m_render_command.shading_enable);
GPUBackendDrawLineCommand::Vertex* out_vertex = &cmd->vertices[out_vertex_count];
out_vertex_count += 2;
GSVector2i::store<false>(&out_vertex[0].x, start_pos);
out_vertex[0].color = start_color;
GSVector2i::store<false>(&out_vertex[1].x, end_pos);
out_vertex[1].color = end_color;
}
start_pos = end_pos;
start_color = end_color;
}
if (out_vertex_count > 0)
{
DebugAssert(out_vertex_count <= cmd->num_vertices);
cmd->num_vertices = Truncate16(out_vertex_count);
GPUBackend::PushCommand(cmd);
}
}
bool GPU::HandleFillRectangleCommand()
{
CHECK_COMMAND_SIZE(3);
@ -460,8 +859,6 @@ bool GPU::HandleFillRectangleCommand()
if (IsInterlacedRenderingEnabled() && IsCRTCScanlinePending())
SynchronizeCRTC();
FlushRender();
const u32 color = FifoPop() & 0x00FFFFFF;
const u32 dst_x = FifoPeek() & 0x3F0;
const u32 dst_y = (FifoPop() >> 16) & VRAM_HEIGHT_MASK;
@ -471,9 +868,18 @@ bool GPU::HandleFillRectangleCommand()
DEBUG_LOG("Fill VRAM rectangle offset=({},{}), size=({},{})", dst_x, dst_y, width, height);
if (width > 0 && height > 0)
FillVRAM(dst_x, dst_y, width, height, color);
{
GPUBackendFillVRAMCommand* cmd = GPUBackend::NewFillVRAMCommand();
cmd->x = static_cast<u16>(dst_x);
cmd->y = static_cast<u16>(dst_y);
cmd->width = static_cast<u16>(width);
cmd->height = static_cast<u16>(height);
cmd->color = color;
cmd->interlaced_rendering = IsInterlacedRenderingEnabled();
cmd->active_line_lsb = m_crtc_state.active_line_lsb;
GPUBackend::PushCommand(cmd);
}
m_counters.num_writes++;
AddCommandTicks(46 + ((width / 8) + 9) * height);
EndCommand();
return true;
@ -523,8 +929,6 @@ void GPU::FinishVRAMWrite()
if (IsInterlacedRenderingEnabled() && IsCRTCScanlinePending())
SynchronizeCRTC();
FlushRender();
if (m_blit_remaining_words == 0)
{
if (g_settings.debugging.dump_cpu_to_vram_copies)
@ -557,18 +961,18 @@ void GPU::FinishVRAMWrite()
const u8* blit_ptr = reinterpret_cast<const u8*>(m_blit_buffer.data());
if (transferred_full_rows > 0)
{
UpdateVRAM(m_vram_transfer.x, m_vram_transfer.y, m_vram_transfer.width, transferred_full_rows, blit_ptr,
m_GPUSTAT.set_mask_while_drawing, m_GPUSTAT.check_mask_before_draw);
UpdateVRAM(m_vram_transfer.x, m_vram_transfer.y, m_vram_transfer.width, static_cast<u16>(transferred_full_rows),
blit_ptr, m_GPUSTAT.set_mask_while_drawing, m_GPUSTAT.check_mask_before_draw);
blit_ptr += (ZeroExtend32(m_vram_transfer.width) * transferred_full_rows) * sizeof(u16);
}
if (transferred_width_last_row > 0)
{
UpdateVRAM(m_vram_transfer.x, m_vram_transfer.y + transferred_full_rows, transferred_width_last_row, 1, blit_ptr,
m_GPUSTAT.set_mask_while_drawing, m_GPUSTAT.check_mask_before_draw);
UpdateVRAM(m_vram_transfer.x, static_cast<u16>(m_vram_transfer.y + transferred_full_rows),
static_cast<u16>(transferred_width_last_row), 1, blit_ptr, m_GPUSTAT.set_mask_while_drawing,
m_GPUSTAT.check_mask_before_draw);
}
}
m_counters.num_writes++;
m_blit_buffer.clear();
m_vram_transfer = {};
m_blitter_state = BlitterState::Idle;
@ -588,9 +992,6 @@ bool GPU::HandleCopyRectangleVRAMToCPUCommand()
m_vram_transfer.width, m_vram_transfer.height);
DebugAssert(m_vram_transfer.col == 0 && m_vram_transfer.row == 0);
// all rendering should be done first...
FlushRender();
// ensure VRAM shadow is up to date
ReadVRAM(m_vram_transfer.x, m_vram_transfer.y, m_vram_transfer.width, m_vram_transfer.height);
@ -602,7 +1003,6 @@ bool GPU::HandleCopyRectangleVRAMToCPUCommand()
}
// switch to pixel-by-pixel read state
m_counters.num_reads++;
m_blitter_state = BlitterState::ReadingVRAM;
m_command_total_words = 0;
@ -633,10 +1033,16 @@ bool GPU::HandleCopyRectangleVRAMToVRAMCommand()
width == 0 || height == 0 || (src_x == dst_x && src_y == dst_y && !m_GPUSTAT.set_mask_while_drawing);
if (!skip_copy)
{
m_counters.num_copies++;
FlushRender();
CopyVRAM(src_x, src_y, dst_x, dst_y, width, height);
GPUBackendCopyVRAMCommand* cmd = GPUBackend::NewCopyVRAMCommand();
cmd->src_x = static_cast<u16>(src_x);
cmd->src_y = static_cast<u16>(src_y);
cmd->dst_x = static_cast<u16>(dst_x);
cmd->dst_y = static_cast<u16>(dst_y);
cmd->width = static_cast<u16>(width);
cmd->height = static_cast<u16>(height);
cmd->check_mask_before_draw = m_GPUSTAT.check_mask_before_draw;
cmd->set_mask_while_drawing = m_GPUSTAT.set_mask_while_drawing;
GPUBackend::PushCommand(cmd);
}
AddCommandTicks(width * height * 2);

1402
src/core/gpu_hw.cpp
View File

File diff suppressed because it is too large Load Diff

95
src/core/gpu_hw.h
View File

@ -3,7 +3,7 @@
#pragma once
#include "gpu.h"
#include "gpu_backend.h"
#include "gpu_hw_texture_cache.h"
#include "util/gpu_device.h"
@ -21,7 +21,9 @@ class GPU_SW_Backend;
struct GPUBackendCommand;
struct GPUBackendDrawCommand;
class GPU_HW final : public GPU
// TODO: Move to cpp
// TODO: Rename to GPUHWBackend, preserved to avoid conflicts.
class GPU_HW final : public GPUBackend
{
public:
enum class BatchRenderMode : u8
@ -63,22 +65,41 @@ public:
GPU_HW();
~GPU_HW() override;
const Threading::Thread* GetSWThread() const override;
bool IsHardwareRenderer() const override;
bool Initialize(bool upload_vram, Error* error) override;
bool Initialize(Error* error) override;
void Reset(bool clear_vram) override;
bool DoState(StateWrapper& sw, bool update_display) override;
bool DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display) override;
u32 GetResolutionScale() const override;
void RestoreDeviceContext() override;
protected:
void UpdateSettings(const Settings& old_settings) override;
u32 GetResolutionScale() const override;
void UpdateResolutionScale() override;
void UpdateDisplay() override;
void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, bool interlaced_rendering, u8 active_line_lsb) override;
void ReadVRAM(u32 x, u32 y, u32 width, u32 height) override;
void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask) override;
void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height, bool set_mask,
bool check_mask) override;
void ClearCache() override;
void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) override;
void OnBufferSwapped() override;
void DrawPolygon(const GPUBackendDrawPolygonCommand* cmd) override;
void DrawPrecisePolygon(const GPUBackendDrawPrecisePolygonCommand* cmd) override;
void DrawSprite(const GPUBackendDrawRectangleCommand* cmd) override;
void DrawLine(const GPUBackendDrawLineCommand* cmd) override;
void FlushRender() override;
void DrawingAreaChanged() override;
void ClearVRAM() override;
void LoadState(const GPUBackendLoadStateCommand* cmd) override;
bool AllocateMemorySaveState(System::MemorySaveState& mss, Error* error) override;
void DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss) override;
void UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd) override;
private:
enum : u32
@ -87,6 +108,7 @@ private:
MAX_VERTICES_FOR_RECTANGLE = 6 * (((MAX_PRIMITIVE_WIDTH + (TEXTURE_PAGE_WIDTH - 1)) / TEXTURE_PAGE_WIDTH) + 1u) *
(((MAX_PRIMITIVE_HEIGHT + (TEXTURE_PAGE_HEIGHT - 1)) / TEXTURE_PAGE_HEIGHT) + 1u),
NUM_TEXTURE_MODES = static_cast<u32>(BatchTextureMode::MaxCount),
INVALID_DRAW_MODE_BITS = 0xFFFFFFFFu,
};
enum : u8
{
@ -165,8 +187,6 @@ private:
bool CompileResolutionDependentPipelines(Error* error);
bool CompileDownsamplePipelines(Error* error);
void LoadVertices();
void PrintSettingsToLog();
void CheckSettings();
@ -185,8 +205,10 @@ private:
u32 CalculateResolutionScale() const;
GPUDownsampleMode GetDownsampleMode(u32 resolution_scale) const;
bool ShouldDrawWithSoftwareRenderer() const;
bool IsUsingMultisampling() const;
bool IsUsingDownsampling() const;
bool IsUsingDownsampling(const GPUBackendUpdateDisplayCommand* cmd) const;
void SetFullVRAMDirtyRectangle();
void ClearVRAMDirtyRectangle();
@ -196,12 +218,15 @@ private:
void AddUnclampedDrawnRectangle(const GSVector4i rect);
void SetTexPageChangedOnOverlap(const GSVector4i update_rect);
void CheckForTexPageOverlap(GSVector4i uv_rect);
void CheckForTexPageOverlap(const GPUBackendDrawCommand* cmd, GSVector4i uv_rect);
bool ShouldCheckForTexPageOverlap() const;
bool IsFlushed() const;
void EnsureVertexBufferSpace(u32 required_vertices, u32 required_indices);
void EnsureVertexBufferSpaceForCurrentCommand();
void EnsureVertexBufferSpaceForCommand(const GPUBackendDrawCommand* cmd);
void PrepareDraw(const GPUBackendDrawCommand* cmd);
void FinishPolygonDraw(const GPUBackendDrawCommand* cmd, std::array<BatchVertex, 4>& vertices, u32 num_vertices,
bool is_precise, bool is_3d);
void ResetBatchVertexDepth();
/// Returns the value to be written to the depth buffer for the current operation for mask bit emulation.
@ -213,20 +238,6 @@ private:
/// Returns true if the draw is going to use shader blending/framebuffer fetch.
bool NeedsShaderBlending(GPUTransparencyMode transparency, BatchTextureMode texture, bool check_mask) const;
void FillBackendCommandParameters(GPUBackendCommand* cmd) const;
void FillDrawCommand(GPUBackendDrawCommand* cmd, GPURenderCommand rc) const;
void UpdateSoftwareRenderer(bool copy_vram_from_hw);
void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color) override;
void ReadVRAM(u32 x, u32 y, u32 width, u32 height) override;
void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask) override;
void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height) override;
void DispatchRenderCommand() override;
void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) override;
void FlushRender() override;
void DrawRendererStats() override;
void OnBufferSwapped() override;
void UpdateVRAMOnGPU(u32 x, u32 y, u32 width, u32 height, const void* data, u32 data_pitch, bool set_mask,
bool check_mask, const GSVector4i bounds);
bool BlitVRAMReplacementTexture(GPUTexture* tex, u32 dst_x, u32 dst_y, u32 width, u32 height);
@ -235,17 +246,17 @@ private:
void DrawLine(const GSVector4 bounds, u32 col0, u32 col1, float depth);
/// Handles quads with flipped texture coordinate directions.
void HandleFlippedQuadTextureCoordinates(BatchVertex* vertices);
void HandleFlippedQuadTextureCoordinates(const GPUBackendDrawCommand* cmd, BatchVertex* vertices);
bool IsPossibleSpritePolygon(const BatchVertex* vertices) const;
bool ExpandLineTriangles(BatchVertex* vertices);
/// Computes polygon U/V boundaries, and for overlap with the current texture page.
void ComputePolygonUVLimits(BatchVertex* vertices, u32 num_vertices);
void ComputePolygonUVLimits(const GPUBackendDrawCommand* cmd, BatchVertex* vertices, u32 num_vertices);
/// Sets the depth test flag for PGXP depth buffering.
void SetBatchDepthBuffer(bool enabled);
void CheckForDepthClear(const BatchVertex* vertices, u32 num_vertices);
void SetBatchSpriteMode(bool enabled);
void SetBatchDepthBuffer(const GPUBackendDrawCommand* cmd, bool enabled);
void CheckForDepthClear(const GPUBackendDrawCommand* cmd, const BatchVertex* vertices, u32 num_vertices);
void SetBatchSpriteMode(const GPUBackendDrawCommand* cmd, bool enabled);
void UpdateDownsamplingLevels();
@ -263,8 +274,6 @@ private:
std::unique_ptr<GPUTextureBuffer> m_vram_upload_buffer;
std::unique_ptr<GPUTexture> m_vram_write_texture;
std::unique_ptr<GPU_SW_Backend> m_sw_renderer;
BatchVertex* m_batch_vertex_ptr = nullptr;
u16* m_batch_index_ptr = nullptr;
u32 m_batch_base_vertex = 0;
@ -306,18 +315,32 @@ private:
u8 m_texpage_dirty = 0;
bool m_batch_ubo_dirty = true;
bool m_drawing_area_changed = true;
BatchConfig m_batch;
// Changed state
BatchUBOData m_batch_ubo_data = {};
// Bounding box of VRAM area that the GPU has drawn into.
GSVector4i m_clamped_drawing_area = {};
GSVector4i m_vram_dirty_draw_rect = INVALID_RECT;
GSVector4i m_vram_dirty_write_rect = INVALID_RECT; // TODO: Don't use in TC mode, should be kept at zero.
GSVector4i m_current_uv_rect = INVALID_RECT;
GSVector4i m_current_draw_rect = INVALID_RECT;
alignas(8) s32 m_current_texture_page_offset[2] = {};
union
{
struct
{
// NOTE: Only the texture-related bits should be used here, the others are not validated.
GPUDrawModeReg mode_reg;
GPUTexturePaletteReg palette_reg;
};
u32 bits = INVALID_DRAW_MODE_BITS;
} m_draw_mode = {};
std::unique_ptr<GPUPipeline> m_wireframe_pipeline;
// [wrapped][interlaced]

140
src/core/gpu_hw_texture_cache.cpp
View File

@ -5,11 +5,14 @@
#include "gpu_hw.h"
#include "gpu_hw_shadergen.h"
#include "gpu_sw_rasterizer.h"
#include "gpu_thread.h"
#include "host.h"
#include "imgui_overlays.h"
#include "settings.h"
#include "system.h"
#include "util/gpu_device.h"
#include "util/imgui_fullscreen.h"
#include "util/imgui_manager.h"
#include "util/state_wrapper.h"
@ -50,6 +53,9 @@ static constexpr const GSVector4i& INVALID_RECT = GPU_HW::INVALID_RECT;
static constexpr const GPUTexture::Format REPLACEMENT_TEXTURE_FORMAT = GPUTexture::Format::RGBA8;
static constexpr const char LOCAL_CONFIG_FILENAME[] = "config.yaml";
static constexpr u32 STATE_PALETTE_RECORD_SIZE =
sizeof(GSVector4i) + sizeof(SourceKey) + sizeof(PaletteRecordFlags) + sizeof(HashType) + sizeof(u16) * MAX_CLUT_SIZE;
// Has to be public because it's referenced in Source.
struct HashCacheEntry
{
@ -518,6 +524,7 @@ struct GPUTextureCacheState
GPUTexture::Format hash_cache_texture_format = GPUTexture::Format::Unknown;
HashCache hash_cache;
GPU_HW* hw_backend = nullptr; // TODO:FIXME: remove me
/// List of candidates for purging when the hash cache gets too large.
std::vector<std::pair<HashCache::iterator, s32>> hash_cache_purge_list;
@ -529,7 +536,6 @@ struct GPUTextureCacheState
std::unique_ptr<GPUPipeline> replacement_draw_pipeline; // copies alpha as-is
std::unique_ptr<GPUPipeline> replacement_semitransparent_draw_pipeline; // inverts alpha (i.e. semitransparent)
std::string game_id;
VRAMReplacementMap vram_replacements;
// TODO: Combine these into one map?
@ -555,26 +561,28 @@ ALIGN_TO_CACHE_LINE GPUTextureCacheState s_state;
bool GPUTextureCache::ShouldTrackVRAMWrites()
{
if (!g_settings.gpu_texture_cache)
if (!g_gpu_settings.gpu_texture_cache)
return false;
#ifdef ALWAYS_TRACK_VRAM_WRITES
return true;
#else
return (IsDumpingVRAMWriteTextures() ||
(g_settings.texture_replacements.enable_texture_replacements && HasVRAMWriteTextureReplacements()));
(g_gpu_settings.texture_replacements.enable_texture_replacements && HasVRAMWriteTextureReplacements()));
#endif
}
bool GPUTextureCache::IsDumpingVRAMWriteTextures()
{
return (g_settings.texture_replacements.dump_textures && !s_state.config.dump_texture_pages);
return (g_gpu_settings.texture_replacements.dump_textures && !s_state.config.dump_texture_pages);
}
bool GPUTextureCache::Initialize()
bool GPUTextureCache::Initialize(GPU_HW* backend)
{
s_state.hw_backend = backend;
SetHashCacheTextureFormat();
LoadLocalConfiguration(false, false);
ReloadTextureReplacements(false);
UpdateVRAMTrackingState();
if (!CompilePipelines())
return false;
@ -588,7 +596,7 @@ void GPUTextureCache::UpdateSettings(bool use_texture_cache, const Settings& old
{
UpdateVRAMTrackingState();
if (g_settings.texture_replacements.enable_texture_replacements !=
if (g_gpu_settings.texture_replacements.enable_texture_replacements !=
old_settings.texture_replacements.enable_texture_replacements)
{
Invalidate();
@ -602,9 +610,9 @@ void GPUTextureCache::UpdateSettings(bool use_texture_cache, const Settings& old
// Reload textures if configuration changes.
const bool old_replacement_scale_linear_filter = s_state.config.replacement_scale_linear_filter;
if (LoadLocalConfiguration(false, false) ||
g_settings.texture_replacements.enable_texture_replacements !=
g_gpu_settings.texture_replacements.enable_texture_replacements !=
old_settings.texture_replacements.enable_texture_replacements ||
g_settings.texture_replacements.enable_vram_write_replacements !=
g_gpu_settings.texture_replacements.enable_vram_write_replacements !=
old_settings.texture_replacements.enable_vram_write_replacements)
{
if (use_texture_cache)
@ -620,6 +628,37 @@ void GPUTextureCache::UpdateSettings(bool use_texture_cache, const Settings& old
}
}
bool GPUTextureCache::GetStateSize(StateWrapper& sw, u32* size)
{
if (sw.GetVersion() < 73)
{
*size = 0;
return true;
}
const size_t start = sw.GetPosition();
if (!sw.DoMarker("GPUTextureCache")) [[unlikely]]
return false;
u32 num_vram_writes = 0;
sw.Do(&num_vram_writes);
for (u32 i = 0; i < num_vram_writes; i++)
{
sw.SkipBytes(sizeof(GSVector4i) * 2 + sizeof(HashType));
u32 num_palette_records = 0;
sw.Do(&num_palette_records);
sw.SkipBytes(num_palette_records * STATE_PALETTE_RECORD_SIZE);
}
if (sw.HasError()) [[unlikely]]
return false;
*size = static_cast<u32>(sw.GetPosition() - start);
return true;
}
bool GPUTextureCache::DoState(StateWrapper& sw, bool skip)
{
if (sw.GetVersion() < 73)
@ -668,7 +707,7 @@ bool GPUTextureCache::DoState(StateWrapper& sw, bool skip)
sw.Do(&num_palette_records);
// Skip palette records if we're not dumping now.
if (g_settings.texture_replacements.dump_textures)
if (g_gpu_settings.texture_replacements.dump_textures)
{
vrw->palette_records.reserve(num_palette_records);
for (u32 j = 0; j < num_palette_records; j++)
@ -760,6 +799,7 @@ void GPUTextureCache::Shutdown()
s_state.hash_cache_purge_list = {};
s_state.temp_vram_write_list = {};
s_state.track_vram_writes = false;
s_state.hw_backend = nullptr;
for (auto it = s_state.gpu_replacement_image_cache.begin(); it != s_state.gpu_replacement_image_cache.end();)
{
@ -773,7 +813,6 @@ void GPUTextureCache::Shutdown()
s_state.vram_write_texture_replacements.clear();
s_state.texture_page_texture_replacements.clear();
s_state.dumped_textures.clear();
s_state.game_id = {};
}
void GPUTextureCache::SetHashCacheTextureFormat()
@ -791,7 +830,7 @@ void GPUTextureCache::SetHashCacheTextureFormat()
bool GPUTextureCache::CompilePipelines()
{
if (!g_settings.texture_replacements.enable_texture_replacements)
if (!g_gpu_settings.texture_replacements.enable_texture_replacements)
return true;
GPUPipeline::GraphicsConfig plconfig = {};
@ -1390,7 +1429,7 @@ const GPUTextureCache::Source* GPUTextureCache::ReturnSource(Source* source, con
source->from_hash_cache->last_used_frame = System::GetFrameNumber();
// TODO: Cache var.
if (g_settings.texture_replacements.dump_textures)
if (g_gpu_settings.texture_replacements.dump_textures)
{
source->active_uv_rect = source->active_uv_rect.runion(uv_rect);
source->palette_record_flags |= flags;
@ -1548,7 +1587,7 @@ void GPUTextureCache::DestroySource(Source* src, bool remove_from_hash_cache)
{
GL_INS_FMT("Invalidate source {}", SourceToString(src));
if (g_settings.texture_replacements.dump_textures && !src->active_uv_rect.eq(INVALID_RECT))
if (g_gpu_settings.texture_replacements.dump_textures && !src->active_uv_rect.eq(INVALID_RECT))
{
if (!s_state.config.dump_texture_pages)
{
@ -1950,7 +1989,7 @@ void GPUTextureCache::RemoveVRAMWrite(VRAMWrite* entry)
void GPUTextureCache::DumpTexturesFromVRAMWrite(VRAMWrite* entry)
{
if (g_settings.texture_replacements.dump_textures && !s_state.config.dump_texture_pages)
if (g_gpu_settings.texture_replacements.dump_textures && !s_state.config.dump_texture_pages)
{
for (const VRAMWrite::PaletteRecord& prec : entry->palette_records)
{
@ -2200,7 +2239,7 @@ GPUTextureCache::HashCacheEntry* GPUTextureCache::LookupHashCache(SourceKey key,
DecodeTexture(key.page, key.palette, key.mode, entry.texture.get());
if (g_settings.texture_replacements.enable_texture_replacements)
if (g_gpu_settings.texture_replacements.enable_texture_replacements)
ApplyTextureReplacements(key, tex_hash, pal_hash, &entry);
s_state.hash_cache_memory_usage += entry.texture->GetVRAMUsage();
@ -2603,12 +2642,8 @@ size_t GPUTextureCache::DumpedTextureKeyHash::operator()(const DumpedTextureKey&
return hash;
}
void GPUTextureCache::SetGameID(std::string game_id)
void GPUTextureCache::GameSerialChanged()
{
if (s_state.game_id == game_id)
return;
s_state.game_id = game_id;
ReloadTextureReplacements(false);
}
@ -2625,7 +2660,8 @@ GPUTexture* GPUTextureCache::GetVRAMReplacement(u32 width, u32 height, const voi
bool GPUTextureCache::ShouldDumpVRAMWrite(u32 width, u32 height)
{
return (g_settings.texture_replacements.dump_vram_writes && width >= s_state.config.vram_write_dump_width_threshold &&
return (g_gpu_settings.texture_replacements.dump_vram_writes &&
width >= s_state.config.vram_write_dump_width_threshold &&
height >= s_state.config.vram_write_dump_height_threshold);
}
@ -2716,7 +2752,7 @@ void GPUTextureCache::DumpTexture(TextureReplacementType type, u32 offset_x, u32
};
// skip if dumped already
if (!g_settings.texture_replacements.dump_replaced_textures)
if (!g_gpu_settings.texture_replacements.dump_replaced_textures)
{
const TextureReplacementMap& map = (type == TextureReplacementType::TextureFromPage) ?
s_state.texture_page_texture_replacements :
@ -2942,7 +2978,7 @@ bool GPUTextureCache::HasValidReplacementExtension(const std::string_view path)
void GPUTextureCache::FindTextureReplacements(bool load_vram_write_replacements, bool load_texture_replacements)
{
if (s_state.game_id.empty())
if (GPUThread::GetGameSerial().empty())
return;
FileSystem::FindResultsArray files;
@ -3015,23 +3051,23 @@ void GPUTextureCache::FindTextureReplacements(bool load_vram_write_replacements,
}
}
if (g_settings.texture_replacements.enable_texture_replacements)
if (g_gpu_settings.texture_replacements.enable_texture_replacements)
{
INFO_LOG("Found {} replacement upload textures for '{}'", s_state.vram_write_texture_replacements.size(),
s_state.game_id);
GPUThread::GetGameSerial());
INFO_LOG("Found {} replacement page textures for '{}'", s_state.texture_page_texture_replacements.size(),
s_state.game_id);
GPUThread::GetGameSerial());
}
if (g_settings.texture_replacements.enable_vram_write_replacements)
INFO_LOG("Found {} replacement VRAM for '{}'", s_state.vram_replacements.size(), s_state.game_id);
if (g_gpu_settings.texture_replacements.enable_vram_write_replacements)
INFO_LOG("Found {} replacement VRAM for '{}'", s_state.vram_replacements.size(), GPUThread::GetGameSerial());
}
void GPUTextureCache::LoadTextureReplacementAliases(const ryml::ConstNodeRef& root,
bool load_vram_write_replacement_aliases,
bool load_texture_replacement_aliases)
{
if (s_state.game_id.empty())
if (GPUThread::GetGameSerial().empty())
return;
const std::string source_dir = GetTextureReplacementDirectory();
@ -3107,17 +3143,19 @@ void GPUTextureCache::LoadTextureReplacementAliases(const ryml::ConstNodeRef& ro
}
}
if (g_settings.texture_replacements.enable_texture_replacements)
if (g_gpu_settings.texture_replacements.enable_texture_replacements)
{
INFO_LOG("Found {} replacement upload textures after applying aliases for '{}'",
s_state.vram_write_texture_replacements.size(), s_state.game_id);
s_state.vram_write_texture_replacements.size(), GPUThread::GetGameSerial());
INFO_LOG("Found {} replacement page textures after applying aliases for '{}'",
s_state.texture_page_texture_replacements.size(), s_state.game_id);
s_state.texture_page_texture_replacements.size(), GPUThread::GetGameSerial());
}
if (g_settings.texture_replacements.enable_vram_write_replacements)
if (g_gpu_settings.texture_replacements.enable_vram_write_replacements)
{
INFO_LOG("Found {} replacement VRAM after applying aliases for '{}'", s_state.vram_replacements.size(),
s_state.game_id);
GPUThread::GetGameSerial());
}
}
const GPUTextureCache::TextureReplacementImage* GPUTextureCache::GetTextureReplacementImage(const std::string& path)
@ -3241,8 +3279,8 @@ void GPUTextureCache::PreloadReplacementTextures()
#define UPDATE_PROGRESS() \
if (last_update_time.GetTimeSeconds() >= UPDATE_INTERVAL) \
{ \
Host::DisplayLoadingScreen("Preloading replacement textures...", 0, static_cast<int>(total_textures), \
static_cast<int>(num_textures_loaded)); \
ImGuiFullscreen::RenderLoadingScreen(ImGuiManager::LOGO_IMAGE_NAME, "Preloading replacement textures...", 0, \
static_cast<int>(total_textures), static_cast<int>(num_textures_loaded)); \
last_update_time.Reset(); \
}
@ -3269,10 +3307,10 @@ void GPUTextureCache::PreloadReplacementTextures()
bool GPUTextureCache::EnsureGameDirectoryExists()
{
if (s_state.game_id.empty())
if (GPUThread::GetGameSerial().empty())
return false;
const std::string game_directory = Path::Combine(EmuFolders::Textures, s_state.game_id);
const std::string game_directory = Path::Combine(EmuFolders::Textures, GPUThread::GetGameSerial());
if (FileSystem::DirectoryExists(game_directory.c_str()))
return true;
@ -3309,12 +3347,13 @@ bool GPUTextureCache::EnsureGameDirectoryExists()
std::string GPUTextureCache::GetTextureReplacementDirectory()
{
std::string dir = Path::Combine(
EmuFolders::Textures, SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "replacements", s_state.game_id));
std::string dir =
Path::Combine(EmuFolders::Textures,
SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "replacements", GPUThread::GetGameSerial()));
if (!FileSystem::DirectoryExists(dir.c_str()))
{
// Check for the old directory structure without a replacements subdirectory.
std::string altdir = Path::Combine(EmuFolders::Textures, s_state.game_id);
std::string altdir = Path::Combine(EmuFolders::Textures, GPUThread::GetGameSerial());
if (FileSystem::DirectoryExists(altdir.c_str()))
WARNING_LOG("Using deprecated texture replacement directory {}", altdir);
dir = std::move(altdir);
@ -3326,7 +3365,7 @@ std::string GPUTextureCache::GetTextureReplacementDirectory()
std::string GPUTextureCache::GetTextureDumpDirectory()
{
return Path::Combine(EmuFolders::Textures,
SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "dumps", s_state.game_id));
SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "dumps", GPUThread::GetGameSerial()));
}
GPUTextureCache::VRAMReplacementName GPUTextureCache::GetVRAMWriteHash(u32 width, u32 height, const void* pixels)
@ -3354,14 +3393,15 @@ bool GPUTextureCache::LoadLocalConfiguration(bool load_vram_write_replacement_al
const Settings::TextureReplacementSettings::Configuration old_config = s_state.config;
// load settings from ini
s_state.config = g_settings.texture_replacements.config;
s_state.config = g_gpu_settings.texture_replacements.config;
if (s_state.game_id.empty())
const std::string& game_serial = GPUThread::GetGameSerial();
if (game_serial.empty())
return (s_state.config != old_config);
const std::optional<std::string> ini_data = FileSystem::ReadFileToString(
Path::Combine(EmuFolders::Textures,
SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "{}", s_state.game_id, LOCAL_CONFIG_FILENAME))
SmallString::from_format("{}" FS_OSPATH_SEPARATOR_STR "{}", game_serial, LOCAL_CONFIG_FILENAME))
.c_str());
if (!ini_data.has_value() || ini_data->empty())
return (s_state.config != old_config);
@ -3430,15 +3470,15 @@ void GPUTextureCache::ReloadTextureReplacements(bool show_info)
s_state.vram_write_texture_replacements.clear();
s_state.texture_page_texture_replacements.clear();
const bool load_vram_write_replacements = (g_settings.texture_replacements.enable_vram_write_replacements);
const bool load_vram_write_replacements = (g_gpu_settings.texture_replacements.enable_vram_write_replacements);
const bool load_texture_replacements =
(g_settings.gpu_texture_cache && g_settings.texture_replacements.enable_texture_replacements);
(g_gpu_settings.gpu_texture_cache && g_gpu_settings.texture_replacements.enable_texture_replacements);
if (load_vram_write_replacements || load_texture_replacements)
FindTextureReplacements(load_vram_write_replacements, load_texture_replacements);
LoadLocalConfiguration(load_vram_write_replacements, load_texture_replacements);
if (g_settings.texture_replacements.preload_textures)
if (g_gpu_settings.texture_replacements.preload_textures)
PreloadReplacementTextures();
PurgeUnreferencedTexturesFromCache();
@ -3596,5 +3636,5 @@ void GPUTextureCache::ApplyTextureReplacements(SourceKey key, HashType tex_hash,
g_gpu_device->RecycleTexture(std::move(entry->texture));
entry->texture = std::move(replacement_tex);
g_gpu->RestoreDeviceContext();
s_state.hw_backend->RestoreDeviceContext();
}

8
src/core/gpu_hw_texture_cache.h
View File

@ -10,6 +10,7 @@ class GPUTexture;
class StateWrapper;
struct Settings;
class GPU_HW;
//////////////////////////////////////////////////////////////////////////
// Texture Cache
@ -102,9 +103,12 @@ struct Source
TListNode<Source> hash_cache_ref;
};
bool Initialize();
bool Initialize(GPU_HW* backend);
void UpdateSettings(bool use_texture_cache, const Settings& old_settings);
bool GetStateSize(StateWrapper& sw, u32* size);
bool DoState(StateWrapper& sw, bool skip);
void Shutdown();
void Invalidate();
@ -124,7 +128,7 @@ bool AreSourcePagesDrawn(SourceKey key, const GSVector4i rect);
void Compact();
void SetGameID(std::string game_id);
void GameSerialChanged();
void ReloadTextureReplacements(bool show_info);
// VRAM Write Replacements

535
src/core/gpu_sw.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "gpu_sw.h"
#include "gpu_hw_texture_cache.h"
#include "gpu.h"
#include "gpu_sw_rasterizer.h"
#include "settings.h"
#include "system.h"
#include "system_private.h"
#include "util/gpu_device.h"
#include "util/state_wrapper.h"
#include "common/align.h"
#include "common/assert.h"
#include "common/gsvector.h"
#include "common/gsvector_formatter.h"
#include "common/intrin.h"
#include "common/log.h"
#include <algorithm>
@ -21,25 +21,16 @@ LOG_CHANNEL(GPU);
GPU_SW::GPU_SW() = default;
GPU_SW::~GPU_SW()
GPU_SW::~GPU_SW() = default;
u32 GPU_SW::GetResolutionScale() const
{
g_gpu_device->RecycleTexture(std::move(m_upload_texture));
m_backend.Shutdown();
return 1u;
}
const Threading::Thread* GPU_SW::GetSWThread() const
bool GPU_SW::Initialize(bool upload_vram, Error* error)
{
return m_backend.GetThread();
}
bool GPU_SW::IsHardwareRenderer() const
{
return false;
}
bool GPU_SW::Initialize(Error* error)
{
if (!GPU::Initialize(error) || !m_backend.Initialize(g_settings.gpu_use_thread))
if (!GPUBackend::Initialize(upload_vram, error))
return false;
static constexpr const std::array formats_for_16bit = {GPUTexture::Format::RGB5A1, GPUTexture::Format::A1BGR5,
@ -56,41 +47,133 @@ bool GPU_SW::Initialize(Error* error)
// RGBA8 will always be supported, hence we'll find one.
INFO_LOG("Using {} format for 16-bit display", GPUTexture::GetFormatName(m_16bit_display_format));
Assert(m_16bit_display_format != GPUTexture::Format::Unknown);
// if we're using "new" vram, clear it out here
if (!upload_vram)
std::memset(g_vram, 0, sizeof(g_vram));
return true;
}
bool GPU_SW::DoState(StateWrapper& sw, bool update_display)
void GPU_SW::ClearVRAM()
{
// need to ensure the worker thread is done
m_backend.Sync(true);
// ignore the host texture for software mode, since we want to save vram here
if (!GPU::DoState(sw, update_display))
return false;
// need to still call the TC, to toss any data in the state
return GPUTextureCache::DoState(sw, true);
std::memset(g_vram, 0, sizeof(g_vram));
std::memset(g_gpu_clut, 0, sizeof(g_gpu_clut));
}
bool GPU_SW::DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display)
void GPU_SW::UpdateResolutionScale()
{
m_backend.Sync(true);
sw.DoBytes(g_vram, VRAM_WIDTH * VRAM_HEIGHT * sizeof(u16));
return GPU::DoMemoryState(sw, mss, update_display);
}
void GPU_SW::Reset(bool clear_vram)
void GPU_SW::LoadState(const GPUBackendLoadStateCommand* cmd)
{
GPU::Reset(clear_vram);
m_backend.Reset();
std::memcpy(g_vram, cmd->vram_data, sizeof(g_vram));
std::memcpy(g_gpu_clut, cmd->clut_data, sizeof(g_gpu_clut));
}
void GPU_SW::UpdateSettings(const Settings& old_settings)
bool GPU_SW::AllocateMemorySaveState(System::MemorySaveState& mss, Error* error)
{
mss.gpu_state_data.resize(sizeof(g_vram) + sizeof(g_gpu_clut));
return true;
}
void GPU_SW::DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss)
{
sw.DoBytes(g_vram, sizeof(g_vram));
sw.DoBytes(g_gpu_clut, sizeof(g_gpu_clut));
DebugAssert(!sw.HasError());
}
void GPU_SW::ReadVRAM(u32 x, u32 y, u32 width, u32 height)
{
}
void GPU_SW::FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, bool interlaced_rendering, u8 active_line_lsb)
{
GPU_SW_Rasterizer::FillVRAM(x, y, width, height, color, interlaced_rendering, active_line_lsb);
}
void GPU_SW::UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask)
{
GPU_SW_Rasterizer::WriteVRAM(x, y, width, height, data, set_mask, check_mask);
}
void GPU_SW::CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height, bool set_mask, bool check_mask)
{
GPU_SW_Rasterizer::CopyVRAM(src_x, src_y, dst_x, dst_y, width, height, set_mask, check_mask);
}
void GPU_SW::DrawPolygon(const GPUBackendDrawPolygonCommand* cmd)
{
const GPU_SW_Rasterizer::DrawTriangleFunction DrawFunction = GPU_SW_Rasterizer::GetDrawTriangleFunction(
cmd->shading_enable, cmd->texture_enable, cmd->raw_texture_enable, cmd->transparency_enable);
DrawFunction(cmd, &cmd->vertices[0], &cmd->vertices[1], &cmd->vertices[2]);
if (cmd->num_vertices > 3)
DrawFunction(cmd, &cmd->vertices[2], &cmd->vertices[1], &cmd->vertices[3]);
}
void GPU_SW::DrawPrecisePolygon(const GPUBackendDrawPrecisePolygonCommand* cmd)
{
const GPU_SW_Rasterizer::DrawTriangleFunction DrawFunction = GPU_SW_Rasterizer::GetDrawTriangleFunction(
cmd->shading_enable, cmd->texture_enable, cmd->raw_texture_enable, cmd->transparency_enable);
// Need to cut out the irrelevant bits.
// TODO: In _theory_ we could use the fixed-point parts here.
GPUBackendDrawPolygonCommand::Vertex vertices[4];
for (u32 i = 0; i < cmd->num_vertices; i++)
{
const GPUBackendDrawPrecisePolygonCommand::Vertex& src = cmd->vertices[i];
vertices[i] = GPUBackendDrawPolygonCommand::Vertex{
.x = src.native_x, .y = src.native_y, .color = src.color, .texcoord = src.texcoord};
}
DrawFunction(cmd, &vertices[0], &vertices[1], &vertices[2]);
if (cmd->num_vertices > 3)
DrawFunction(cmd, &vertices[2], &vertices[1], &vertices[3]);
}
void GPU_SW::DrawSprite(const GPUBackendDrawRectangleCommand* cmd)
{
const GPU_SW_Rasterizer::DrawRectangleFunction DrawFunction =
GPU_SW_Rasterizer::GetDrawRectangleFunction(cmd->texture_enable, cmd->raw_texture_enable, cmd->transparency_enable);
DrawFunction(cmd);
}
void GPU_SW::DrawLine(const GPUBackendDrawLineCommand* cmd)
{
const GPU_SW_Rasterizer::DrawLineFunction DrawFunction =
GPU_SW_Rasterizer::GetDrawLineFunction(cmd->shading_enable, cmd->transparency_enable);
for (u16 i = 0; i < cmd->num_vertices; i += 2)
DrawFunction(cmd, &cmd->vertices[i], &cmd->vertices[i + 1]);
}
void GPU_SW::DrawingAreaChanged()
{
// GPU_SW_Rasterizer::g_drawing_area set by base class.
}
void GPU_SW::ClearCache()
{
}
void GPU_SW::UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit)
{
GPU_SW_Rasterizer::UpdateCLUT(reg, clut_is_8bit);
}
void GPU_SW::OnBufferSwapped()
{
}
void GPU_SW::FlushRender()
{
}
void GPU_SW::RestoreDeviceContext()
{
GPU::UpdateSettings(old_settings);
if (g_settings.gpu_use_thread != old_settings.gpu_use_thread)
m_backend.SetThreadEnabled(g_settings.gpu_use_thread);
}
GPUTexture* GPU_SW::GetDisplayTexture(u32 width, u32 height, GPUTexture::Format format)
@ -271,32 +354,28 @@ bool GPU_SW::CopyOut(u32 src_x, u32 src_y, u32 skip_x, u32 width, u32 height, u3
}
}
void GPU_SW::UpdateDisplay()
void GPU_SW::UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd)
{
// fill display texture
m_backend.Sync(true);
if (!g_settings.debugging.show_vram)
{
if (IsDisplayDisabled())
if (cmd->display_disabled)
{
ClearDisplayTexture();
return;
}
const bool is_24bit = m_GPUSTAT.display_area_color_depth_24;
const bool interlaced = IsInterlacedDisplayEnabled();
const u32 field = GetInterlacedDisplayField();
const u32 vram_offset_x = is_24bit ? m_crtc_state.regs.X : m_crtc_state.display_vram_left;
const u32 vram_offset_y =
m_crtc_state.display_vram_top + ((interlaced && m_GPUSTAT.vertical_resolution) ? field : 0);
const u32 skip_x = is_24bit ? (m_crtc_state.display_vram_left - m_crtc_state.regs.X) : 0;
const u32 read_width = m_crtc_state.display_vram_width;
const u32 read_height = interlaced ? (m_crtc_state.display_vram_height / 2) : m_crtc_state.display_vram_height;
const bool is_24bit = cmd->display_24bit;
const bool interlaced = cmd->interlaced_display_enabled;
const u32 field = BoolToUInt32(cmd->interlaced_display_field);
const u32 vram_offset_x = is_24bit ? cmd->X : cmd->display_vram_left;
const u32 vram_offset_y = cmd->display_vram_top + ((interlaced && cmd->interlaced_display_interleaved) ? field : 0);
const u32 skip_x = is_24bit ? (cmd->display_vram_left - cmd->X) : 0;
const u32 read_width = cmd->display_vram_width;
const u32 read_height = interlaced ? (cmd->display_vram_height / 2) : cmd->display_vram_height;
if (IsInterlacedDisplayEnabled())
if (cmd->interlaced_display_enabled)
{
const u32 line_skip = m_GPUSTAT.vertical_resolution;
const u32 line_skip = cmd->interlaced_display_interleaved;
if (CopyOut(vram_offset_x, vram_offset_y, skip_x, read_width, read_height, line_skip, is_24bit))
{
SetDisplayTexture(m_upload_texture.get(), nullptr, 0, 0, read_width, read_height);
@ -328,347 +407,7 @@ void GPU_SW::UpdateDisplay()
}
}
void GPU_SW::FillBackendCommandParameters(GPUBackendCommand* cmd) const
{
cmd->params.bits = 0;
cmd->params.check_mask_before_draw = m_GPUSTAT.check_mask_before_draw;
cmd->params.set_mask_while_drawing = m_GPUSTAT.set_mask_while_drawing;
cmd->params.active_line_lsb = m_crtc_state.active_line_lsb;
cmd->params.interlaced_rendering = IsInterlacedRenderingEnabled();
}
void GPU_SW::FillDrawCommand(GPUBackendDrawCommand* cmd, GPURenderCommand rc) const
{
FillBackendCommandParameters(cmd);
cmd->rc.bits = rc.bits;
cmd->draw_mode.bits = m_draw_mode.mode_reg.bits;
cmd->draw_mode.dither_enable = rc.IsDitheringEnabled() && cmd->draw_mode.dither_enable;
cmd->palette.bits = m_draw_mode.palette_reg.bits;
cmd->window = m_draw_mode.texture_window;
}
void GPU_SW::DispatchRenderCommand()
{
if (m_drawing_area_changed)
{
GPUBackendSetDrawingAreaCommand* cmd = m_backend.NewSetDrawingAreaCommand();
cmd->new_area = m_drawing_area;
GSVector4i::store<false>(cmd->new_clamped_area, m_clamped_drawing_area);
m_backend.PushCommand(cmd);
m_drawing_area_changed = false;
}
const GPURenderCommand rc{m_render_command.bits};
switch (rc.primitive)
{
case GPUPrimitive::Polygon:
{
const u32 num_vertices = rc.quad_polygon ? 4 : 3;
GPUBackendDrawPolygonCommand* cmd = m_backend.NewDrawPolygonCommand(num_vertices);
FillDrawCommand(cmd, rc);
std::array<GSVector2i, 4> positions;
const u32 first_color = rc.color_for_first_vertex;
const bool shaded = rc.shading_enable;
const bool textured = rc.texture_enable;
for (u32 i = 0; i < num_vertices; i++)
{
GPUBackendDrawPolygonCommand::Vertex* vert = &cmd->vertices[i];
vert->color = (shaded && i > 0) ? (FifoPop() & UINT32_C(0x00FFFFFF)) : first_color;
const u64 maddr_and_pos = m_fifo.Pop();
const GPUVertexPosition vp{Truncate32(maddr_and_pos)};
vert->x = m_drawing_offset.x + vp.x;
vert->y = m_drawing_offset.y + vp.y;
vert->texcoord = textured ? Truncate16(FifoPop()) : 0;
positions[i] = GSVector2i::load<false>(&vert->x);
}
// Cull polygons which are too large.
const GSVector2i min_pos_12 = positions[1].min_s32(positions[2]);
const GSVector2i max_pos_12 = positions[1].max_s32(positions[2]);
const GSVector4i draw_rect_012 = GSVector4i(min_pos_12.min_s32(positions[0]))
.upl64(GSVector4i(max_pos_12.max_s32(positions[0])))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
const bool first_tri_culled =
(draw_rect_012.width() > MAX_PRIMITIVE_WIDTH || draw_rect_012.height() > MAX_PRIMITIVE_HEIGHT ||
!m_clamped_drawing_area.rintersects(draw_rect_012));
if (first_tri_culled)
{
DEBUG_LOG("Culling off-screen/too-large polygon: {},{} {},{} {},{}", cmd->vertices[0].x, cmd->vertices[0].y,
cmd->vertices[1].x, cmd->vertices[1].y, cmd->vertices[2].x, cmd->vertices[2].y);
if (!rc.quad_polygon)
return;
}
else
{
AddDrawTriangleTicks(positions[0], positions[1], positions[2], rc.shading_enable, rc.texture_enable,
rc.transparency_enable);
}
// quads
if (rc.quad_polygon)
{
const GSVector4i draw_rect_123 = GSVector4i(min_pos_12.min_s32(positions[3]))
.upl64(GSVector4i(max_pos_12.max_s32(positions[3])))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
// Cull polygons which are too large.
const bool second_tri_culled =
(draw_rect_123.width() > MAX_PRIMITIVE_WIDTH || draw_rect_123.height() > MAX_PRIMITIVE_HEIGHT ||
!m_clamped_drawing_area.rintersects(draw_rect_123));
if (second_tri_culled)
{
DEBUG_LOG("Culling too-large polygon (quad second half): {},{} {},{} {},{}", cmd->vertices[2].x,
cmd->vertices[2].y, cmd->vertices[1].x, cmd->vertices[1].y, cmd->vertices[0].x, cmd->vertices[0].y);
if (first_tri_culled)
return;
}
else
{
AddDrawTriangleTicks(positions[2], positions[1], positions[3], rc.shading_enable, rc.texture_enable,
rc.transparency_enable);
}
}
m_backend.PushCommand(cmd);
}
break;
case GPUPrimitive::Rectangle:
{
GPUBackendDrawRectangleCommand* cmd = m_backend.NewDrawRectangleCommand();
FillDrawCommand(cmd, rc);
cmd->color = rc.color_for_first_vertex;
const GPUVertexPosition vp{FifoPop()};
cmd->x = TruncateGPUVertexPosition(m_drawing_offset.x + vp.x);
cmd->y = TruncateGPUVertexPosition(m_drawing_offset.y + vp.y);
if (rc.texture_enable)
{
const u32 texcoord_and_palette = FifoPop();
cmd->palette.bits = Truncate16(texcoord_and_palette >> 16);
cmd->texcoord = Truncate16(texcoord_and_palette);
}
else
{
cmd->palette.bits = 0;
cmd->texcoord = 0;
}
switch (rc.rectangle_size)
{
case GPUDrawRectangleSize::R1x1:
cmd->width = 1;
cmd->height = 1;
break;
case GPUDrawRectangleSize::R8x8:
cmd->width = 8;
cmd->height = 8;
break;
case GPUDrawRectangleSize::R16x16:
cmd->width = 16;
cmd->height = 16;
break;
default:
{
const u32 width_and_height = FifoPop();
cmd->width = static_cast<u16>(width_and_height & VRAM_WIDTH_MASK);
cmd->height = static_cast<u16>((width_and_height >> 16) & VRAM_HEIGHT_MASK);
}
break;
}
const GSVector4i rect = GSVector4i(cmd->x, cmd->y, cmd->x + cmd->width, cmd->y + cmd->height);
const GSVector4i clamped_rect = m_clamped_drawing_area.rintersect(rect);
if (clamped_rect.rempty()) [[unlikely]]
{
DEBUG_LOG("Culling off-screen rectangle {}", rect);
return;
}
AddDrawRectangleTicks(clamped_rect, rc.texture_enable, rc.transparency_enable);
m_backend.PushCommand(cmd);
}
break;
case GPUPrimitive::Line:
{
if (!rc.polyline)
{
GPUBackendDrawLineCommand* cmd = m_backend.NewDrawLineCommand(2);
FillDrawCommand(cmd, rc);
cmd->palette.bits = 0;
if (rc.shading_enable)
{
cmd->vertices[0].color = rc.color_for_first_vertex;
const GPUVertexPosition start_pos{FifoPop()};
cmd->vertices[0].x = m_drawing_offset.x + start_pos.x;
cmd->vertices[0].y = m_drawing_offset.y + start_pos.y;
cmd->vertices[1].color = FifoPop() & UINT32_C(0x00FFFFFF);
const GPUVertexPosition end_pos{FifoPop()};
cmd->vertices[1].x = m_drawing_offset.x + end_pos.x;
cmd->vertices[1].y = m_drawing_offset.y + end_pos.y;
}
else
{
cmd->vertices[0].color = rc.color_for_first_vertex;
cmd->vertices[1].color = rc.color_for_first_vertex;
const GPUVertexPosition start_pos{FifoPop()};
cmd->vertices[0].x = m_drawing_offset.x + start_pos.x;
cmd->vertices[0].y = m_drawing_offset.y + start_pos.y;
const GPUVertexPosition end_pos{FifoPop()};
cmd->vertices[1].x = m_drawing_offset.x + end_pos.x;
cmd->vertices[1].y = m_drawing_offset.y + end_pos.y;
}
const GSVector4i v0 = GSVector4i::loadl<false>(&cmd->vertices[0].x);
const GSVector4i v1 = GSVector4i::loadl<false>(&cmd->vertices[1].x);
const GSVector4i rect = v0.min_s32(v1).xyxy(v0.max_s32(v1)).add32(GSVector4i::cxpr(0, 0, 1, 1));
const GSVector4i clamped_rect = rect.rintersect(m_clamped_drawing_area);
if (rect.width() > MAX_PRIMITIVE_WIDTH || rect.height() > MAX_PRIMITIVE_HEIGHT || clamped_rect.rempty())
{
DEBUG_LOG("Culling too-large/off-screen line: {},{} - {},{}", cmd->vertices[0].y, cmd->vertices[0].y,
cmd->vertices[1].x, cmd->vertices[1].y);
return;
}
AddDrawLineTicks(clamped_rect, rc.shading_enable);
m_backend.PushCommand(cmd);
}
else
{
const u32 num_vertices = GetPolyLineVertexCount();
GPUBackendDrawLineCommand* cmd = m_backend.NewDrawLineCommand((num_vertices - 1) * 2);
FillDrawCommand(cmd, m_render_command);
u32 buffer_pos = 0;
const GPUVertexPosition start_vp{m_blit_buffer[buffer_pos++]};
const GSVector2i draw_offset = GSVector2i::load<false>(&m_drawing_offset.x);
GSVector2i start_pos = GSVector2i(start_vp.x, start_vp.y).add32(draw_offset);
u32 start_color = m_render_command.color_for_first_vertex;
const bool shaded = m_render_command.shading_enable;
u32 out_vertex_count = 0;
for (u32 i = 1; i < num_vertices; i++)
{
const u32 end_color =
shaded ? (m_blit_buffer[buffer_pos++] & UINT32_C(0x00FFFFFF)) : m_render_command.color_for_first_vertex;
const GPUVertexPosition vp{m_blit_buffer[buffer_pos++]};
const GSVector2i end_pos = GSVector2i(vp.x, vp.y).add32(draw_offset);
const GSVector4i rect = GSVector4i::xyxy(start_pos.min_s32(end_pos), start_pos.max_s32(end_pos))
.add32(GSVector4i::cxpr(0, 0, 1, 1));
const GSVector4i clamped_rect = rect.rintersect(m_clamped_drawing_area);
if (rect.width() > MAX_PRIMITIVE_WIDTH || rect.height() > MAX_PRIMITIVE_HEIGHT || clamped_rect.rempty())
{
DEBUG_LOG("Culling too-large/off-screen line: {},{} - {},{}", cmd->vertices[i - 1].x,
cmd->vertices[i - 1].y, cmd->vertices[i].x, cmd->vertices[i].y);
}
else
{
AddDrawLineTicks(clamped_rect, rc.shading_enable);
GPUBackendDrawLineCommand::Vertex* out_vertex = &cmd->vertices[out_vertex_count];
out_vertex_count += 2;
GSVector2i::store<false>(&out_vertex[0].x, start_pos);
out_vertex[0].color = start_color;
GSVector2i::store<false>(&out_vertex[1].x, end_pos);
out_vertex[1].color = end_color;
}
start_pos = end_pos;
start_color = end_color;
}
if (out_vertex_count > 0)
{
DebugAssert(out_vertex_count <= cmd->num_vertices);
cmd->num_vertices = Truncate16(out_vertex_count);
m_backend.PushCommand(cmd);
}
}
}
break;
default:
UnreachableCode();
break;
}
}
void GPU_SW::ReadVRAM(u32 x, u32 y, u32 width, u32 height)
{
m_backend.Sync(false);
}
void GPU_SW::FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color)
{
GPUBackendFillVRAMCommand* cmd = m_backend.NewFillVRAMCommand();
FillBackendCommandParameters(cmd);
cmd->x = static_cast<u16>(x);
cmd->y = static_cast<u16>(y);
cmd->width = static_cast<u16>(width);
cmd->height = static_cast<u16>(height);
cmd->color = color;
m_backend.PushCommand(cmd);
}
void GPU_SW::UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask)
{
const u32 num_words = width * height;
GPUBackendUpdateVRAMCommand* cmd = m_backend.NewUpdateVRAMCommand(num_words);
FillBackendCommandParameters(cmd);
cmd->params.set_mask_while_drawing = set_mask;
cmd->params.check_mask_before_draw = check_mask;
cmd->x = static_cast<u16>(x);
cmd->y = static_cast<u16>(y);
cmd->width = static_cast<u16>(width);
cmd->height = static_cast<u16>(height);
std::memcpy(cmd->data, data, sizeof(u16) * num_words);
m_backend.PushCommand(cmd);
}
void GPU_SW::CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height)
{
GPUBackendCopyVRAMCommand* cmd = m_backend.NewCopyVRAMCommand();
FillBackendCommandParameters(cmd);
cmd->src_x = static_cast<u16>(src_x);
cmd->src_y = static_cast<u16>(src_y);
cmd->dst_x = static_cast<u16>(dst_x);
cmd->dst_y = static_cast<u16>(dst_y);
cmd->width = static_cast<u16>(width);
cmd->height = static_cast<u16>(height);
m_backend.PushCommand(cmd);
}
void GPU_SW::FlushRender()
{
}
void GPU_SW::UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit)
{
GPUBackendUpdateCLUTCommand* cmd = m_backend.NewUpdateCLUTCommand();
FillBackendCommandParameters(cmd);
cmd->reg.bits = reg.bits;
cmd->clut_is_8bit = clut_is_8bit;
m_backend.PushCommand(cmd);
}
std::unique_ptr<GPU> GPU::CreateSoftwareRenderer()
std::unique_ptr<GPUBackend> GPUBackend::CreateSoftwareBackend()
{
return std::make_unique<GPU_SW>();
}

65
src/core/gpu_sw.h
View File

@ -4,7 +4,7 @@
#pragma once
#include "gpu.h"
#include "gpu_sw_backend.h"
#include "gpu_backend.h"
#include "util/gpu_device.h"
@ -12,36 +12,51 @@
#include <memory>
namespace Threading {
class Thread;
}
class GPUTexture;
class GPU_SW final : public GPU
// TODO: Move to cpp
// TODO: Rename to GPUSWBackend, preserved to avoid conflicts.
class GPU_SW final : public GPUBackend
{
public:
GPU_SW();
~GPU_SW() override;
ALWAYS_INLINE const GPU_SW_Backend& GetBackend() const { return m_backend; }
bool Initialize(bool upload_vram, Error* error) override;
const Threading::Thread* GetSWThread() const override;
bool IsHardwareRenderer() const override;
void RestoreDeviceContext() override;
bool Initialize(Error* error) override;
bool DoState(StateWrapper& sw, bool update_display) override;
bool DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display) override;
void Reset(bool clear_vram) override;
void UpdateSettings(const Settings& old_settings) override;
u32 GetResolutionScale() const override;
protected:
void ReadVRAM(u32 x, u32 y, u32 width, u32 height) override;
void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color) override;
void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, bool interlaced_rendering, u8 active_line_lsb) override;
void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask) override;
void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height) override;
void FlushRender() override;
void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height, bool set_mask,
bool check_mask) override;
void DrawPolygon(const GPUBackendDrawPolygonCommand* cmd) override;
void DrawPrecisePolygon(const GPUBackendDrawPrecisePolygonCommand* cmd) override;
void DrawLine(const GPUBackendDrawLineCommand* cmd) override;
void DrawSprite(const GPUBackendDrawRectangleCommand* cmd) override;
void DrawingAreaChanged() override;
void ClearCache() override;
void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) override;
void OnBufferSwapped() override;
void UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd) override;
void ClearVRAM() override;
void FlushRender() override;
void UpdateResolutionScale() override;
void LoadState(const GPUBackendLoadStateCommand* cmd) override;
bool AllocateMemorySaveState(System::MemorySaveState& mss, Error* error) override;
void DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss) override;
private:
static constexpr GPUTexture::Format FORMAT_FOR_24BIT = GPUTexture::Format::RGBA8; // RGBA8 always supported.
template<GPUTexture::Format display_format>
bool CopyOut15Bit(u32 src_x, u32 src_y, u32 width, u32 height, u32 line_skip);
@ -50,21 +65,9 @@ protected:
bool CopyOut(u32 src_x, u32 src_y, u32 skip_x, u32 width, u32 height, u32 line_skip, bool is_24bit);
void UpdateDisplay() override;
void DispatchRenderCommand() override;
void FillBackendCommandParameters(GPUBackendCommand* cmd) const;
void FillDrawCommand(GPUBackendDrawCommand* cmd, GPURenderCommand rc) const;
private:
static constexpr GPUTexture::Format FORMAT_FOR_24BIT = GPUTexture::Format::RGBA8; // RGBA8 always supported.
GPUTexture* GetDisplayTexture(u32 width, u32 height, GPUTexture::Format format);
FixedHeapArray<u8, GPU_MAX_DISPLAY_WIDTH * GPU_MAX_DISPLAY_HEIGHT * sizeof(u32)> m_upload_buffer;
GPUTexture::Format m_16bit_display_format = GPUTexture::Format::Unknown;
std::unique_ptr<GPUTexture> m_upload_texture;
GPU_SW_Backend m_backend;
};

88
src/core/gpu_sw_backend.cpp
View File

@ -1,88 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "gpu_sw_backend.h"
#include "gpu.h"
#include "gpu_sw_rasterizer.h"
#include "system.h"
#include "util/gpu_device.h"
#include <algorithm>
GPU_SW_Backend::GPU_SW_Backend() = default;
GPU_SW_Backend::~GPU_SW_Backend() = default;
bool GPU_SW_Backend::Initialize(bool use_thread)
{
return GPUBackend::Initialize(use_thread);
}
void GPU_SW_Backend::Reset()
{
GPUBackend::Reset();
}
void GPU_SW_Backend::DrawPolygon(const GPUBackendDrawPolygonCommand* cmd)
{
const GPURenderCommand rc{cmd->rc.bits};
const GPU_SW_Rasterizer::DrawTriangleFunction DrawFunction = GPU_SW_Rasterizer::GetDrawTriangleFunction(
rc.shading_enable, rc.texture_enable, rc.raw_texture_enable, rc.transparency_enable);
DrawFunction(cmd, &cmd->vertices[0], &cmd->vertices[1], &cmd->vertices[2]);
if (rc.quad_polygon)
DrawFunction(cmd, &cmd->vertices[2], &cmd->vertices[1], &cmd->vertices[3]);
}
void GPU_SW_Backend::DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
{
const GPURenderCommand rc{cmd->rc.bits};
const GPU_SW_Rasterizer::DrawRectangleFunction DrawFunction =
GPU_SW_Rasterizer::GetDrawRectangleFunction(rc.texture_enable, rc.raw_texture_enable, rc.transparency_enable);
DrawFunction(cmd);
}
void GPU_SW_Backend::DrawLine(const GPUBackendDrawLineCommand* cmd)
{
const GPU_SW_Rasterizer::DrawLineFunction DrawFunction =
GPU_SW_Rasterizer::GetDrawLineFunction(cmd->rc.shading_enable, cmd->rc.transparency_enable);
for (u16 i = 1; i < cmd->num_vertices; i += 2)
DrawFunction(cmd, &cmd->vertices[i - 1], &cmd->vertices[i]);
}
void GPU_SW_Backend::FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, GPUBackendCommandParameters params)
{
GPU_SW_Rasterizer::FillVRAM(x, y, width, height, color, params.interlaced_rendering, params.active_line_lsb);
}
void GPU_SW_Backend::UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data,
GPUBackendCommandParameters params)
{
GPU_SW_Rasterizer::WriteVRAM(x, y, width, height, data, params.set_mask_while_drawing, params.check_mask_before_draw);
}
void GPU_SW_Backend::CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height,
GPUBackendCommandParameters params)
{
GPU_SW_Rasterizer::CopyVRAM(src_x, src_y, dst_x, dst_y, width, height, params.set_mask_while_drawing,
params.check_mask_before_draw);
}
void GPU_SW_Backend::UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit)
{
GPU::ReadCLUT(g_gpu_clut, reg, clut_is_8bit);
}
void GPU_SW_Backend::DrawingAreaChanged(const GPUDrawingArea& new_drawing_area, const GSVector4i clamped_drawing_area)
{
GPU_SW_Rasterizer::g_drawing_area = new_drawing_area;
}
void GPU_SW_Backend::FlushRender()
{
}

32
src/core/gpu_sw_backend.h
View File

@ -1,32 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once
#include "gpu.h"
#include "gpu_backend.h"
#include <array>
class GPU_SW_Backend final : public GPUBackend
{
public:
GPU_SW_Backend();
~GPU_SW_Backend() override;
bool Initialize(bool use_thread) override;
void Reset() override;
protected:
void FillVRAM(u32 x, u32 y, u32 width, u32 height, u32 color, GPUBackendCommandParameters params) override;
void UpdateVRAM(u32 x, u32 y, u32 width, u32 height, const void* data, GPUBackendCommandParameters params) override;
void CopyVRAM(u32 src_x, u32 src_y, u32 dst_x, u32 dst_y, u32 width, u32 height,
GPUBackendCommandParameters params) override;
void DrawPolygon(const GPUBackendDrawPolygonCommand* cmd) override;
void DrawLine(const GPUBackendDrawLineCommand* cmd) override;
void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd) override;
void DrawingAreaChanged(const GPUDrawingArea& new_drawing_area, const GSVector4i clamped_drawing_area) override;
void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit) override;
void FlushRender() override;
};

25
src/core/gpu_sw_rasterizer.cpp
View File

@ -38,6 +38,31 @@ CopyVRAMFunction CopyVRAM = nullptr;
GPUDrawingArea g_drawing_area = {};
} // namespace GPU_SW_Rasterizer
void GPU_SW_Rasterizer::UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit)
{
const u16* const src_row = &g_vram[reg.GetYBase() * VRAM_WIDTH];
const u32 start_x = reg.GetXBase();
if (!clut_is_8bit)
{
// Wraparound can't happen in 4-bit mode.
std::memcpy(g_gpu_clut, &src_row[start_x], sizeof(u16) * 16);
}
else
{
if ((start_x + 256) > VRAM_WIDTH) [[unlikely]]
{
const u32 end = VRAM_WIDTH - start_x;
const u32 start = 256 - end;
std::memcpy(g_gpu_clut, &src_row[start_x], sizeof(u16) * end);
std::memcpy(g_gpu_clut + end, src_row, sizeof(u16) * start);
}
else
{
std::memcpy(g_gpu_clut, &src_row[start_x], sizeof(u16) * 256);
}
}
}
// Default scalar implementation definitions.
namespace GPU_SW_Rasterizer::Scalar {
namespace {

7
src/core/gpu_sw_rasterizer.h
View File

@ -4,6 +4,7 @@
#pragma once
#include "gpu.h"
#include "gpu_thread_commands.h"
#include "gpu_types.h"
#include "common/intrin.h"
@ -18,13 +19,15 @@ static constexpr u32 DITHER_LUT_SIZE = 512;
using DitherLUT = std::array<std::array<std::array<u8, DITHER_LUT_SIZE>, DITHER_MATRIX_SIZE>, DITHER_MATRIX_SIZE>;
extern const DitherLUT g_dither_lut;
// TODO: Pack in struct
extern GPUDrawingArea g_drawing_area;
extern void UpdateCLUT(GPUTexturePaletteReg reg, bool clut_is_8bit);
using DrawRectangleFunction = void (*)(const GPUBackendDrawRectangleCommand* cmd);
typedef const DrawRectangleFunction DrawRectangleFunctionTable[2][2][2];
using DrawTriangleFunction = void (*)(const GPUBackendDrawPolygonCommand* cmd,
const GPUBackendDrawPolygonCommand::Vertex* v0,
using DrawTriangleFunction = void (*)(const GPUBackendDrawCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0,
const GPUBackendDrawPolygonCommand::Vertex* v1,
const GPUBackendDrawPolygonCommand::Vertex* v2);
typedef const DrawTriangleFunction DrawTriangleFunctionTable[2][2][2][2];

45
src/core/gpu_sw_rasterizer.inl
View File

@ -129,7 +129,7 @@ template<bool texture_enable, bool raw_texture_enable, bool transparency_enable>
}
else
{
const bool dithering_enable = cmd->draw_mode.dither_enable;
const bool dithering_enable = cmd->dither_enable;
const u32 dither_y = (dithering_enable) ? (y & 3u) : 2u;
const u32 dither_x = (dithering_enable) ? (x & 3u) : 3u;
@ -143,7 +143,7 @@ template<bool texture_enable, bool raw_texture_enable, bool transparency_enable>
}
else
{
const bool dithering_enable = cmd->draw_mode.dither_enable;
const bool dithering_enable = cmd->dither_enable;
const u32 dither_y = (dithering_enable) ? (y & 3u) : 2u;
const u32 dither_x = (dithering_enable) ? (x & 3u) : 3u;
@ -215,12 +215,12 @@ template<bool texture_enable, bool raw_texture_enable, bool transparency_enable>
}
}
const u16 mask_and = cmd->params.GetMaskAND();
const u16 mask_and = cmd->GetMaskAND();
if ((bg_color & mask_and) != 0)
return;
DebugAssert(static_cast<u32>(x) < VRAM_WIDTH && static_cast<u32>(y) < VRAM_HEIGHT);
SetPixel(static_cast<u32>(x), static_cast<u32>(y), color | cmd->params.GetMaskOR());
SetPixel(static_cast<u32>(x), static_cast<u32>(y), color | cmd->GetMaskOR());
}
#ifndef USE_VECTOR
@ -237,7 +237,8 @@ static void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
{
const s32 y = origin_y + static_cast<s32>(offset_y);
if (y < static_cast<s32>(g_drawing_area.top) || y > static_cast<s32>(g_drawing_area.bottom) ||
(cmd->params.interlaced_rendering && cmd->params.active_line_lsb == (Truncate8(static_cast<u32>(y)) & 1u)))
(cmd->interlaced_rendering &&
cmd->active_line_lsb == ConvertToBoolUnchecked(Truncate8(static_cast<u32>(y)) & 1u)))
{
continue;
}
@ -488,8 +489,8 @@ struct PixelVectors
clip_left = GSVectorNi(g_drawing_area.left);
clip_right = GSVectorNi(g_drawing_area.right);
mask_and = GSVectorNi(cmd->params.GetMaskAND());
mask_or = GSVectorNi(cmd->params.GetMaskOR());
mask_and = GSVectorNi(cmd->GetMaskAND());
mask_or = GSVectorNi(cmd->GetMaskOR());
if constexpr (texture_enable)
{
@ -717,7 +718,8 @@ static void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
{
const s32 y = origin_y + static_cast<s32>(offset_y);
if (y >= static_cast<s32>(g_drawing_area.top) && y <= static_cast<s32>(g_drawing_area.bottom) &&
(!cmd->params.interlaced_rendering || cmd->params.active_line_lsb != (Truncate8(static_cast<u32>(y)) & 1u)))
(!cmd->interlaced_rendering ||
cmd->active_line_lsb != ConvertToBoolUnchecked(Truncate8(static_cast<u32>(y)) & 1u)))
{
const s32 draw_y = (y & VRAM_HEIGHT_MASK);
@ -817,7 +819,8 @@ static void DrawLine(const GPUBackendDrawLineCommand* cmd, const GPUBackendDrawL
const s32 x = unfp_xy(curx);
const s32 y = unfp_xy(cury);
if ((!cmd->params.interlaced_rendering || cmd->params.active_line_lsb != (Truncate8(static_cast<u32>(y)) & 1u)) &&
if ((!cmd->interlaced_rendering ||
cmd->active_line_lsb != ConvertToBoolUnchecked(Truncate8(static_cast<u32>(y)) & 1u)) &&
x >= static_cast<s32>(g_drawing_area.left) && x <= static_cast<s32>(g_drawing_area.right) &&
y >= static_cast<s32>(g_drawing_area.top) && y <= static_cast<s32>(g_drawing_area.bottom))
{
@ -968,7 +971,7 @@ struct TrianglePart
#ifndef USE_VECTOR
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
static void DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound, UVStepper uv,
static void DrawSpan(const GPUBackendDrawCommand* cmd, s32 y, s32 x_start, s32 x_bound, UVStepper uv,
const UVSteps& uvstep, RGBStepper rgb, const RGBSteps& rgbstep)
{
s32 width = x_bound - x_start;
@ -1008,7 +1011,7 @@ static void DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start
}
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCommand* cmd, const TrianglePart& tp,
ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* cmd, const TrianglePart& tp,
const UVStepper& uv, const UVSteps& uvstep, const RGBStepper& rgb,
const RGBSteps& rgbstep)
{
@ -1051,7 +1054,8 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCo
lrgb.StepY<true>(rgbstep);
if (y > static_cast<s32>(g_drawing_area.bottom) ||
(cmd->params.interlaced_rendering && cmd->params.active_line_lsb == (static_cast<u32>(current_y) & 1u)))
(cmd->interlaced_rendering &&
cmd->active_line_lsb == ConvertToBoolUnchecked(static_cast<u32>(current_y) & 1u)))
{
continue;
}
@ -1082,7 +1086,8 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCo
break;
}
if (y >= static_cast<s32>(g_drawing_area.top) &&
(!cmd->params.interlaced_rendering || cmd->params.active_line_lsb != (static_cast<u32>(current_y) & 1u)))
(!cmd->interlaced_rendering ||
cmd->active_line_lsb != ConvertToBoolUnchecked(static_cast<u32>(current_y) & 1u)))
{
DrawSpan<shading_enable, texture_enable, raw_texture_enable, transparency_enable>(
cmd, y & VRAM_HEIGHT_MASK, unfp_xy(left_x), unfp_xy(right_x), luv, uvstep, lrgb, rgbstep);
@ -1145,7 +1150,7 @@ struct TriangleVectors : PixelVectors<texture_enable>
} // namespace
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawPolygonCommand* cmd, s32 y, s32 x_start, s32 x_bound,
ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawCommand* cmd, s32 y, s32 x_start, s32 x_bound,
UVStepper uv, const UVSteps& uvstep, RGBStepper rgb, const RGBSteps& rgbstep,
const TriangleVectors<shading_enable, texture_enable>& tv)
{
@ -1195,7 +1200,7 @@ ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawPolygonCommand* c
dv = GSVectorNi::zero();
}
const GSVectorNi dither = cmd->draw_mode.dither_enable ?
const GSVectorNi dither = cmd->dither_enable ?
GSVectorNi::broadcast128<false>(
&VECTOR_DITHER_MATRIX[static_cast<u32>(y) & 3][(static_cast<u32>(current_x) & 3) * 2]) :
GSVectorNi::zero();
@ -1250,7 +1255,7 @@ ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawPolygonCommand* c
}
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCommand* cmd, const TrianglePart& tp,
ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* cmd, const TrianglePart& tp,
const UVStepper& uv, const UVSteps& uvstep, const RGBStepper& rgb,
const RGBSteps& rgbstep)
{
@ -1295,7 +1300,8 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCo
lrgb.StepY<true>(rgbstep);
if (y > static_cast<s32>(g_drawing_area.bottom) ||
(cmd->params.interlaced_rendering && cmd->params.active_line_lsb == (static_cast<u32>(current_y) & 1u)))
(cmd->interlaced_rendering &&
cmd->active_line_lsb == ConvertToBoolUnchecked(static_cast<u32>(current_y) & 1u)))
{
continue;
}
@ -1328,7 +1334,8 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCo
break;
}
if (y >= static_cast<s32>(g_drawing_area.top) &&
(!cmd->params.interlaced_rendering || cmd->params.active_line_lsb != (static_cast<u32>(current_y) & 1u)))
(!cmd->interlaced_rendering ||
cmd->active_line_lsb != ConvertToBoolUnchecked(static_cast<u32>(current_y) & 1u)))
{
DrawSpan<shading_enable, texture_enable, raw_texture_enable, transparency_enable>(
cmd, y & VRAM_HEIGHT_MASK, unfp_xy(left_x), unfp_xy(right_x), luv, uvstep, lrgb, rgbstep, tv);
@ -1349,7 +1356,7 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawPolygonCo
#endif // USE_VECTOR
template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
static void DrawTriangle(const GPUBackendDrawPolygonCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0,
static void DrawTriangle(const GPUBackendDrawCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0,
const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v2)
{
#ifdef CHECK_VECTOR

1363
src/core/gpu_thread.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

106
src/core/gpu_thread.h Normal file
View File

@ -0,0 +1,106 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once
#include "common/types.h"
#include <functional>
#include <optional>
class Error;
struct WindowInfo;
namespace Threading {
class ThreadHandle;
}
enum class RenderAPI : u8;
enum class GPUVSyncMode : u8;
enum class GPURenderer : u8;
enum class GPUBackendCommandType : u8;
class GPUBackend;
struct GPUThreadCommand;
struct GPUBackendUpdateDisplayCommand;
namespace GPUThread {
using AsyncCallType = std::function<void()>;
using AsyncBackendCallType = std::function<void(GPUBackend*)>;
enum class RunIdleReason : u8
{
NoGPUBackend = (1 << 0),
SystemPaused = (1 << 1),
FullscreenUIActive = (1 << 2),
LoadingScreenActive = (1 << 3),
};
/// Starts Big Picture UI.
bool StartFullscreenUI(bool fullscreen, Error* error);
bool IsFullscreenUIRequested();
void StopFullscreenUI();
/// Backend control.
std::optional<GPURenderer> GetRequestedRenderer();
bool CreateGPUBackend(std::string serial, GPURenderer renderer, bool upload_vram, bool fullscreen,
bool force_recreate_device, Error* error);
void DestroyGPUBackend();
bool HasGPUBackend();
bool IsGPUBackendRequested();
void SetGameSerial(std::string serial);
/// Re-presents the current frame. Call when things like window resizes happen to re-display
/// the current frame with the correct proportions. Should only be called from the CPU thread.
void PresentCurrentFrame();
/// Handles fullscreen transitions and such.
void UpdateDisplayWindow(bool fullscreen);
/// Called when the window is resized.
void ResizeDisplayWindow(s32 width, s32 height, float scale);
/// Access to main window size from CPU thread.
const WindowInfo& GetRenderWindowInfo();
void UpdateSettings(bool gpu_settings_changed, bool device_settings_changed);
bool IsOnThread();
bool IsUsingThread();
void RunOnThread(AsyncCallType func);
void RunOnBackend(AsyncBackendCallType func, bool sync, bool spin_or_wake);
void SetVSync(GPUVSyncMode mode, bool allow_present_throttle);
// Should only be called on the GPU thread.
bool GetRunIdleReason(RunIdleReason reason);
void SetRunIdleReason(RunIdleReason reason, bool enabled);
bool IsRunningIdle();
bool IsSystemPaused();
const std::string& GetGameSerial();
GPUThreadCommand* AllocateCommand(GPUBackendCommandType command, u32 size);
void PushCommand(GPUThreadCommand* cmd);
void PushCommandAndWakeThread(GPUThreadCommand* cmd);
void PushCommandAndSync(GPUThreadCommand* cmd, bool spin);
void SyncGPUThread(bool spin);
// NOTE: Only called by GPUBackend
namespace Internal {
const Threading::ThreadHandle& GetThreadHandle();
void ProcessStartup();
void SetThreadEnabled(bool enabled);
void DoRunIdle();
void RequestShutdown();
void GPUThreadEntryPoint();
void PresentFrame(bool allow_skip_present, u64 present_time);
void RestoreContextAfterPresent();
} // namespace Internal
} // namespace GPUThread
namespace Host {
/// Called when the pause state changes, or fullscreen UI opens.
void OnGPUThreadRunIdleChanged(bool is_active);
} // namespace Host

324
src/core/gpu_thread_commands.h Normal file
View File

@ -0,0 +1,324 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once
#include "gpu_types.h"
#include "common/align.h"
#include <functional>
#include <string>
#include <vector>
class Error;
enum class GPUVSyncMode : u8;
class MediaCapture;
class StateWrapper;
class GPUBackend;
namespace System {
struct MemorySaveState;
}
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4200) // warning C4200: nonstandard extension used: zero-sized array in struct/union
#endif
enum class GPUBackendCommandType : u8
{
Wraparound,
AsyncCall,
AsyncBackendCall,
Reconfigure,
Shutdown,
ClearVRAM,
ClearDisplay,
UpdateDisplay,
SubmitFrame,
BufferSwapped,
LoadState,
LoadMemoryState,
SaveMemoryState,
ReadVRAM,
FillVRAM,
UpdateVRAM,
CopyVRAM,
SetDrawingArea,
UpdateCLUT,
ClearCache,
DrawPolygon,
DrawPrecisePolygon,
DrawRectangle,
DrawLine,
};
struct GPUThreadCommand
{
u32 size;
GPUBackendCommandType type;
static constexpr u32 AlignCommandSize(u32 size)
{
// Ensure size is a multiple of 8 (minimum data size) so we don't end up with an unaligned command.
// NOTE: If we ever end up putting vectors in the command packets, this should be raised.
constexpr u32 COMMAND_QUEUE_ALLOCATION_ALIGNMENT = 8;
return Common::AlignUpPow2(size, COMMAND_QUEUE_ALLOCATION_ALIGNMENT);
}
};
struct GPUThreadReconfigureCommand : public GPUThreadCommand
{
Error* error_ptr;
bool* out_result;
std::string game_serial;
std::optional<GPURenderer> renderer;
std::optional<bool> fullscreen;
std::optional<bool> start_fullscreen_ui;
GPUVSyncMode vsync_mode;
bool allow_present_throttle;
bool force_recreate_device;
bool upload_vram;
};
struct GPUThreadAsyncCallCommand : public GPUThreadCommand
{
GPUThreadAsyncCallCommand(std::function<void()> func_) : func(std::move(func_)) {}
std::function<void()> func;
};
struct GPUThreadAsyncBackendCallCommand : public GPUThreadCommand
{
GPUThreadAsyncBackendCallCommand(std::function<void(GPUBackend*)> func_) : func(std::move(func_)) {}
std::function<void(GPUBackend*)> func;
};
struct GPUBackendLoadStateCommand : public GPUThreadCommand
{
u16 vram_data[VRAM_WIDTH * VRAM_HEIGHT];
u16 clut_data[GPU_CLUT_SIZE];
u32 texture_cache_state_version;
u32 texture_cache_state_size;
u8 texture_cache_state[0]; // texture_cache_state_size
};
struct GPUBackendDoMemoryStateCommand : public GPUThreadCommand
{
System::MemorySaveState* memory_save_state;
};
struct GPUBackendFramePresentationParameters
{
u32 frame_number;
u32 internal_frame_number;
u64 present_time;
MediaCapture* media_capture;
union
{
u8 bits;
BitField<u16, bool, 0, 1> allow_present_skip;
BitField<u16, bool, 1, 1> present_frame;
BitField<u16, bool, 2, 1> update_performance_counters;
};
};
struct GPUBackendUpdateDisplayCommand : public GPUThreadCommand
{
u16 display_width;
u16 display_height;
u16 display_origin_left;
u16 display_origin_top;
u16 display_vram_left;
u16 display_vram_top;
u16 display_vram_width;
u16 display_vram_height;
float display_pixel_aspect_ratio;
u16 X; // TODO: Can we get rid of this?
bool interlaced_display_enabled : 1;
bool interlaced_display_field : 1;
bool interlaced_display_interleaved : 1;
bool display_24bit : 1;
bool display_disabled : 1;
bool submit_frame : 1;
bool : 2;
GPUBackendFramePresentationParameters frame;
};
// Only used for runahead.
struct GPUBackendSubmitFrameCommand : public GPUThreadCommand
{
GPUBackendFramePresentationParameters frame;
};
struct GPUBackendReadVRAMCommand : public GPUThreadCommand
{
u16 x;
u16 y;
u16 width;
u16 height;
};
struct GPUBackendFillVRAMCommand : public GPUThreadCommand
{
u16 x;
u16 y;
u16 width;
u16 height;
u32 color;
bool interlaced_rendering;
u8 active_line_lsb;
};
struct GPUBackendUpdateVRAMCommand : public GPUThreadCommand
{
u16 x;
u16 y;
u16 width;
u16 height;
bool set_mask_while_drawing;
bool check_mask_before_draw;
u16 data[0];
};
struct GPUBackendCopyVRAMCommand : public GPUThreadCommand
{
u16 src_x;
u16 src_y;
u16 dst_x;
u16 dst_y;
u16 width;
u16 height;
bool set_mask_while_drawing;
bool check_mask_before_draw;
};
struct GPUBackendSetDrawingAreaCommand : public GPUThreadCommand
{
GPUDrawingArea new_area;
};
struct GPUBackendUpdateCLUTCommand : public GPUThreadCommand
{
GPUTexturePaletteReg reg;
bool clut_is_8bit;
};
struct GPUBackendDrawCommand : public GPUThreadCommand
{
bool interlaced_rendering : 1;
/// Returns 0 if the currently-displayed field is on an even line in VRAM, otherwise 1.
bool active_line_lsb : 1;
bool set_mask_while_drawing : 1;
bool check_mask_before_draw : 1;
bool texture_enable : 1;
bool raw_texture_enable : 1;
bool transparency_enable : 1;
bool shading_enable : 1;
bool quad_polygon : 1;
bool dither_enable : 1;
bool valid_w : 1; // only used for precise polygons
// During transfer/render operations, if ((dst_pixel & mask_and) == 0) { pixel = src_pixel | mask_or }
ALWAYS_INLINE u16 GetMaskAND() const { return check_mask_before_draw ? 0x8000 : 0x0000; }
ALWAYS_INLINE u16 GetMaskOR() const { return set_mask_while_drawing ? 0x8000 : 0x0000; }
u16 num_vertices;
GPUDrawModeReg draw_mode;
GPUTexturePaletteReg palette;
GPUTextureWindow window;
};
struct GPUBackendDrawPolygonCommand : public GPUBackendDrawCommand
{
struct Vertex
{
s32 x, y;
union
{
struct
{
u8 r, g, b, a;
};
u32 color;
};
union
{
struct
{
u8 u, v;
};
u16 texcoord;
};
};
Vertex vertices[0];
};
struct GPUBackendDrawPrecisePolygonCommand : public GPUBackendDrawCommand
{
GPUBackendDrawCommand params;
struct Vertex
{
float x, y, w;
s32 native_x, native_y;
u32 color;
u16 texcoord;
};
Vertex vertices[0];
};
struct GPUBackendDrawRectangleCommand : public GPUBackendDrawCommand
{
u16 width, height;
u16 texcoord;
s32 x, y;
u32 color;
};
struct GPUBackendDrawLineCommand : public GPUBackendDrawCommand
{
u16 num_vertices;
struct Vertex
{
s32 x, y;
union
{
struct
{
u8 r, g, b, a;
};
u32 color;
};
ALWAYS_INLINE void Set(s32 x_, s32 y_, u32 color_)
{
x = x_;
y = y_;
color = color_;
}
};
Vertex vertices[0];
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif

187
src/core/gpu_types.h
View File

@ -12,7 +12,6 @@
#include "common/gsvector.h"
#include <array>
#include <string>
enum : u32
{
@ -405,12 +404,17 @@ union GPUTexturePaletteReg
ALWAYS_INLINE constexpr u32 GetYBase() const { return static_cast<u32>(y); }
};
struct GPUTextureWindow
union GPUTextureWindow
{
struct
{
u8 and_x;
u8 and_y;
u8 or_x;
u8 or_y;
};
u32 bits;
ALWAYS_INLINE bool operator==(const GPUTextureWindow& rhs) const
{
@ -541,182 +545,3 @@ static constexpr s32 DITHER_MATRIX[DITHER_MATRIX_SIZE][DITHER_MATRIX_SIZE] = {{-
{+2, -2, +3, -1}, // row 1
{-3, +1, -4, +0}, // row 2
{+3, -1, +2, -2}}; // row 3
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4200) // warning C4200: nonstandard extension used: zero-sized array in struct/union
#endif
enum class GPUBackendCommandType : u8
{
Wraparound,
Sync,
FillVRAM,
UpdateVRAM,
CopyVRAM,
SetDrawingArea,
UpdateCLUT,
DrawPolygon,
DrawRectangle,
DrawLine,
};
union GPUBackendCommandParameters
{
u8 bits;
BitField<u8, bool, 0, 1> interlaced_rendering;
/// Returns 0 if the currently-displayed field is on an even line in VRAM, otherwise 1.
BitField<u8, u8, 1, 1> active_line_lsb;
BitField<u8, bool, 2, 1> set_mask_while_drawing;
BitField<u8, bool, 3, 1> check_mask_before_draw;
// During transfer/render operations, if ((dst_pixel & mask_and) == 0) { pixel = src_pixel | mask_or }
u16 GetMaskAND() const
{
// return check_mask_before_draw ? 0x8000 : 0x0000;
return Truncate16((bits << 12) & 0x8000);
}
u16 GetMaskOR() const
{
// return set_mask_while_drawing ? 0x8000 : 0x0000;
return Truncate16((bits << 13) & 0x8000);
}
};
struct GPUBackendCommand
{
u32 size;
GPUBackendCommandType type;
GPUBackendCommandParameters params;
};
struct GPUBackendSyncCommand : public GPUBackendCommand
{
bool allow_sleep;
};
struct GPUBackendFillVRAMCommand : public GPUBackendCommand
{
u16 x;
u16 y;
u16 width;
u16 height;
u32 color;
};
struct GPUBackendUpdateVRAMCommand : public GPUBackendCommand
{
u16 x;
u16 y;
u16 width;
u16 height;
u16 data[0];
};
struct GPUBackendCopyVRAMCommand : public GPUBackendCommand
{
u16 src_x;
u16 src_y;
u16 dst_x;
u16 dst_y;
u16 width;
u16 height;
};
struct GPUBackendSetDrawingAreaCommand : public GPUBackendCommand
{
GPUDrawingArea new_area;
s32 new_clamped_area[4];
};
struct GPUBackendUpdateCLUTCommand : public GPUBackendCommand
{
GPUTexturePaletteReg reg;
bool clut_is_8bit;
};
struct GPUBackendDrawCommand : public GPUBackendCommand
{
GPUDrawModeReg draw_mode;
GPURenderCommand rc;
GPUTexturePaletteReg palette;
GPUTextureWindow window;
};
struct GPUBackendDrawPolygonCommand : public GPUBackendDrawCommand
{
u16 num_vertices;
struct Vertex
{
s32 x, y;
union
{
struct
{
u8 r, g, b, a;
};
u32 color;
};
union
{
struct
{
u8 u, v;
};
u16 texcoord;
};
ALWAYS_INLINE void Set(s32 x_, s32 y_, u32 color_, u16 texcoord_)
{
x = x_;
y = y_;
color = color_;
texcoord = texcoord_;
}
};
Vertex vertices[0];
};
struct GPUBackendDrawRectangleCommand : public GPUBackendDrawCommand
{
s32 x, y;
u16 width, height;
u16 texcoord;
u32 color;
};
struct GPUBackendDrawLineCommand : public GPUBackendDrawCommand
{
u16 num_vertices;
struct Vertex
{
s32 x, y;
union
{
struct
{
u8 r, g, b, a;
};
u32 color;
};
ALWAYS_INLINE void Set(s32 x_, s32 y_, u32 color_)
{
x = x_;
y = y_;
color = color_;
}
};
Vertex vertices[0];
};
#ifdef _MSC_VER
#pragma warning(pop)
#endif

184
src/core/host.cpp
View File

@ -2,19 +2,13 @@
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "host.h"
#include "fullscreen_ui.h"
#include "gpu.h"
#include "imgui_overlays.h"
#include "shader_cache_version.h"
#include "system.h"
#include "system_private.h"
#include "scmversion/scmversion.h"
#include "util/compress_helpers.h"
#include "util/gpu_device.h"
#include "util/imgui_manager.h"
#include "util/input_manager.h"
#include "common/assert.h"
#include "common/error.h"
@ -342,181 +336,3 @@ std::string Host::GetHTTPUserAgent()
{
return fmt::format("DuckStation for {} ({}) {}", TARGET_OS_STR, CPU_ARCH_STR, g_scm_tag_str);
}
bool Host::CreateGPUDevice(RenderAPI api, bool fullscreen, Error* error)
{
DebugAssert(!g_gpu_device);
INFO_LOG("Trying to create a {} GPU device...", GPUDevice::RenderAPIToString(api));
g_gpu_device = GPUDevice::CreateDeviceForAPI(api);
std::optional<GPUDevice::ExclusiveFullscreenMode> fullscreen_mode;
if (fullscreen && g_gpu_device && g_gpu_device->SupportsExclusiveFullscreen())
{
fullscreen_mode =
GPUDevice::ExclusiveFullscreenMode::Parse(Host::GetTinyStringSettingValue("GPU", "FullscreenMode", ""));
}
std::optional<bool> exclusive_fullscreen_control;
if (g_settings.display_exclusive_fullscreen_control != DisplayExclusiveFullscreenControl::Automatic)
{
exclusive_fullscreen_control =
(g_settings.display_exclusive_fullscreen_control == DisplayExclusiveFullscreenControl::Allowed);
}
u32 disabled_features = 0;
if (g_settings.gpu_disable_dual_source_blend)
disabled_features |= GPUDevice::FEATURE_MASK_DUAL_SOURCE_BLEND;
if (g_settings.gpu_disable_framebuffer_fetch)
disabled_features |= GPUDevice::FEATURE_MASK_FRAMEBUFFER_FETCH;
if (g_settings.gpu_disable_texture_buffers)
disabled_features |= GPUDevice::FEATURE_MASK_TEXTURE_BUFFERS;
if (g_settings.gpu_disable_memory_import)
disabled_features |= GPUDevice::FEATURE_MASK_MEMORY_IMPORT;
if (g_settings.gpu_disable_raster_order_views)
disabled_features |= GPUDevice::FEATURE_MASK_RASTER_ORDER_VIEWS;
if (g_settings.gpu_disable_compute_shaders)
disabled_features |= GPUDevice::FEATURE_MASK_COMPUTE_SHADERS;
if (g_settings.gpu_disable_compressed_textures)
disabled_features |= GPUDevice::FEATURE_MASK_COMPRESSED_TEXTURES;
// Don't dump shaders on debug builds for Android, users will complain about storage...
#if !defined(__ANDROID__) || defined(_DEBUG)
const std::string_view shader_dump_directory(EmuFolders::DataRoot);
#else
const std::string_view shader_dump_directory;
#endif
Error create_error;
std::optional<WindowInfo> wi;
if (!g_gpu_device ||
!(wi = Host::AcquireRenderWindow(api, fullscreen, fullscreen_mode.has_value(), &create_error)).has_value() ||
!g_gpu_device->Create(
g_settings.gpu_adapter, static_cast<GPUDevice::FeatureMask>(disabled_features), shader_dump_directory,
g_settings.gpu_disable_shader_cache ? std::string_view() : std::string_view(EmuFolders::Cache),
SHADER_CACHE_VERSION, g_settings.gpu_use_debug_device, wi.value(), System::GetEffectiveVSyncMode(),
System::ShouldAllowPresentThrottle(), fullscreen_mode.has_value() ? &fullscreen_mode.value() : nullptr,
exclusive_fullscreen_control, &create_error))
{
ERROR_LOG("Failed to create GPU device: {}", create_error.GetDescription());
if (g_gpu_device)
g_gpu_device->Destroy();
g_gpu_device.reset();
if (wi.has_value())
Host::ReleaseRenderWindow();
Error::SetStringFmt(
error,
TRANSLATE_FS("System", "Failed to create render device:\n\n{0}\n\nThis may be due to your GPU not supporting the "
"chosen renderer ({1}), or because your graphics drivers need to be updated."),
create_error.GetDescription(), GPUDevice::RenderAPIToString(api));
return false;
}
if (!ImGuiManager::Initialize(g_settings.display_osd_scale / 100.0f, g_settings.display_osd_margin, &create_error))
{
ERROR_LOG("Failed to initialize ImGuiManager: {}", create_error.GetDescription());
Error::SetStringFmt(error, "Failed to initialize ImGuiManager: {}", create_error.GetDescription());
g_gpu_device->Destroy();
g_gpu_device.reset();
Host::ReleaseRenderWindow();
return false;
}
InputManager::SetDisplayWindowSize(ImGuiManager::GetWindowWidth(), ImGuiManager::GetWindowHeight());
return true;
}
void Host::UpdateDisplayWindow(bool fullscreen)
{
if (!g_gpu_device)
return;
const GPUVSyncMode vsync_mode = System::GetEffectiveVSyncMode();
const bool allow_present_throttle = System::ShouldAllowPresentThrottle();
std::optional<GPUDevice::ExclusiveFullscreenMode> fullscreen_mode;
if (fullscreen && g_gpu_device->SupportsExclusiveFullscreen())
{
fullscreen_mode =
GPUDevice::ExclusiveFullscreenMode::Parse(Host::GetTinyStringSettingValue("GPU", "FullscreenMode", ""));
}
std::optional<bool> exclusive_fullscreen_control;
if (g_settings.display_exclusive_fullscreen_control != DisplayExclusiveFullscreenControl::Automatic)
{
exclusive_fullscreen_control =
(g_settings.display_exclusive_fullscreen_control == DisplayExclusiveFullscreenControl::Allowed);
}
g_gpu_device->DestroyMainSwapChain();
Error error;
std::optional<WindowInfo> wi =
Host::AcquireRenderWindow(g_gpu_device->GetRenderAPI(), fullscreen, fullscreen_mode.has_value(), &error);
if (!wi.has_value())
{
Host::ReportFatalError("Failed to get render window after update", error.GetDescription());
return;
}
// if surfaceless, just leave it
if (wi->IsSurfaceless())
{
DEV_LOG("Switching to surfaceless device");
if (!g_gpu_device->SwitchToSurfacelessRendering(&error))
ERROR_LOG("Failed to switch to surfaceless, rendering commands may fail: {}", error.GetDescription());
return;
}
if (!g_gpu_device->RecreateMainSwapChain(wi.value(), vsync_mode, allow_present_throttle,
fullscreen_mode.has_value() ? &fullscreen_mode.value() : nullptr,
exclusive_fullscreen_control, &error))
{
Host::ReportFatalError("Failed to change window after update", error.GetDescription());
return;
}
const float f_width = static_cast<float>(g_gpu_device->GetMainSwapChain()->GetWidth());
const float f_height = static_cast<float>(g_gpu_device->GetMainSwapChain()->GetHeight());
ImGuiManager::WindowResized(f_width, f_height);
InputManager::SetDisplayWindowSize(f_width, f_height);
System::DisplayWindowResized();
}
void Host::ResizeDisplayWindow(s32 width, s32 height, float scale)
{
if (!g_gpu_device || !g_gpu_device->HasMainSwapChain())
return;
DEV_LOG("Display window resized to {}x{}", width, height);
Error error;
if (!g_gpu_device->GetMainSwapChain()->ResizeBuffers(width, height, scale, &error))
{
ERROR_LOG("Failed to resize main swap chain: {}", error.GetDescription());
UpdateDisplayWindow(Host::IsFullscreen());
return;
}
const float f_width = static_cast<float>(g_gpu_device->GetMainSwapChain()->GetWidth());
const float f_height = static_cast<float>(g_gpu_device->GetMainSwapChain()->GetHeight());
ImGuiManager::WindowResized(f_width, f_height);
InputManager::SetDisplayWindowSize(f_width, f_height);
System::DisplayWindowResized();
}
void Host::ReleaseGPUDevice()
{
if (!g_gpu_device)
return;
ImGuiManager::DestroyAllDebugWindows();
ImGuiManager::DestroyOverlayTextures();
FullscreenUI::Shutdown();
ImGuiManager::Shutdown();
INFO_LOG("Destroying {} GPU device...", GPUDevice::RenderAPIToString(g_gpu_device->GetRenderAPI()));
g_gpu_device->Destroy();
g_gpu_device.reset();
Host::ReleaseRenderWindow();
}

19
src/core/host.h
View File

@ -75,10 +75,6 @@ std::span<const std::pair<const char*, const char*>> GetAvailableLanguageList();
/// Refreshes the UI when the language is changed.
bool ChangeLanguage(const char* new_language);
/// Displays a loading screen with the logo, rendered with ImGui. Use when executing possibly-time-consuming tasks
/// such as compiling shaders when starting up.
void DisplayLoadingScreen(const char* message, int progress_min = -1, int progress_max = -1, int progress_value = -1);
/// Safely executes a function on the VM thread.
void RunOnCPUThread(std::function<void()> function, bool block = false);
@ -96,21 +92,6 @@ bool IsFullscreen();
/// Alters fullscreen state of hosting application.
void SetFullscreen(bool enabled);
/// Attempts to create the rendering device backend.
bool CreateGPUDevice(RenderAPI api, bool fullscreen, Error* error);
/// Handles fullscreen transitions and such.
void UpdateDisplayWindow(bool fullscreen);
/// Called when the window is resized.
void ResizeDisplayWindow(s32 width, s32 height, float scale);
/// Destroys any active rendering device.
void ReleaseGPUDevice();
/// Called at the end of the frame, before presentation.
void FrameDone();
namespace Internal {
/// Returns true if the host should use portable mode.

88
src/core/host_interface_progress_callback.cpp
View File

@ -1,88 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "host_interface_progress_callback.h"
#include "host.h"
#include "common/log.h"
LOG_CHANNEL(Host);
HostInterfaceProgressCallback::HostInterfaceProgressCallback() : ProgressCallback()
{
}
void HostInterfaceProgressCallback::PushState()
{
ProgressCallback::PushState();
}
void HostInterfaceProgressCallback::PopState()
{
ProgressCallback::PopState();
Redraw(true);
}
void HostInterfaceProgressCallback::SetCancellable(bool cancellable)
{
ProgressCallback::SetCancellable(cancellable);
Redraw(true);
}
void HostInterfaceProgressCallback::SetTitle(const std::string_view title)
{
// todo?
}
void HostInterfaceProgressCallback::SetStatusText(const std::string_view text)
{
ProgressCallback::SetStatusText(text);
Redraw(true);
}
void HostInterfaceProgressCallback::SetProgressRange(u32 range)
{
u32 last_range = m_progress_range;
ProgressCallback::SetProgressRange(range);
if (m_progress_range != last_range)
Redraw(false);
}
void HostInterfaceProgressCallback::SetProgressValue(u32 value)
{
u32 lastValue = m_progress_value;
ProgressCallback::SetProgressValue(value);
if (m_progress_value != lastValue)
Redraw(false);
}
void HostInterfaceProgressCallback::Redraw(bool force)
{
if (m_last_progress_percent < 0 && m_open_time.GetTimeSeconds() < m_open_delay)
return;
const int percent =
static_cast<int>((static_cast<float>(m_progress_value) / static_cast<float>(m_progress_range)) * 100.0f);
if (percent == m_last_progress_percent && !force)
return;
m_last_progress_percent = percent;
Host::DisplayLoadingScreen(m_status_text.c_str(), 0, static_cast<int>(m_progress_range),
static_cast<int>(m_progress_value));
}
void HostInterfaceProgressCallback::ModalError(const std::string_view message)
{
ERROR_LOG(message);
Host::ReportErrorAsync("Error", message);
}
bool HostInterfaceProgressCallback::ModalConfirmation(const std::string_view message)
{
INFO_LOG(message);
return Host::ConfirmMessage("Confirm", message);
}

34
src/core/host_interface_progress_callback.h
View File

@ -1,34 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once
#include "common/progress_callback.h"
#include "common/timer.h"
class HostInterfaceProgressCallback final : public ProgressCallback
{
public:
HostInterfaceProgressCallback();
ALWAYS_INLINE void SetOpenDelay(float delay) { m_open_delay = delay; }
void PushState() override;
void PopState() override;
void SetCancellable(bool cancellable) override;
void SetTitle(const std::string_view title) override;
void SetStatusText(const std::string_view text) override;
void SetProgressRange(u32 range) override;
void SetProgressValue(u32 value) override;
void ModalError(const std::string_view message) override;
bool ModalConfirmation(const std::string_view message) override;
private:
void Redraw(bool force);
Timer m_open_time;
float m_open_delay = 1.0f;
int m_last_progress_percent = -1;
};

34
src/core/hotkeys.cpp
View File

@ -8,6 +8,7 @@
#include "fullscreen_ui.h"
#include "gpu.h"
#include "gpu_hw_texture_cache.h"
#include "gpu_thread.h"
#include "host.h"
#include "imgui_overlays.h"
#include "settings.h"
@ -59,8 +60,7 @@ static void HotkeyModifyResolutionScale(s32 increment)
if (System::IsValid())
{
System::ClearMemorySaveStates(true);
g_gpu->RestoreDeviceContext();
g_gpu->UpdateSettings(old_settings);
GPUThread::UpdateSettings(true, false);
}
}
@ -377,10 +377,9 @@ DEFINE_HOTKEY("TogglePGXP", TRANSLATE_NOOP("Hotkeys", "Graphics"), TRANSLATE_NOO
{
System::ClearMemorySaveStates(true);
Settings old_settings = g_settings;
g_settings.gpu_pgxp_enable = !g_settings.gpu_pgxp_enable;
g_gpu->RestoreDeviceContext();
g_gpu->UpdateSettings(old_settings);
GPUThread::UpdateSettings(true, false);
Host::AddKeyedOSDMessage("TogglePGXP",
g_settings.gpu_pgxp_enable ?
TRANSLATE_STR("OSDMessage", "PGXP is now enabled.") :
@ -427,13 +426,18 @@ DEFINE_HOTKEY("ToggleInternalPostProcessing", TRANSLATE_NOOP("Hotkeys", "Graphic
DEFINE_HOTKEY("ReloadPostProcessingShaders", TRANSLATE_NOOP("Hotkeys", "Graphics"),
TRANSLATE_NOOP("Hotkeys", "Reload Post Processing Shaders"), [](s32 pressed) {
if (!pressed && System::IsValid())
{
GPUThread::RunOnThread([]() {
if (GPUThread::HasGPUBackend())
PostProcessing::ReloadShaders();
});
}
})
DEFINE_HOTKEY("ReloadTextureReplacements", TRANSLATE_NOOP("Hotkeys", "Graphics"),
TRANSLATE_NOOP("Hotkeys", "Reload Texture Replacements"), [](s32 pressed) {
if (!pressed && System::IsValid())
GPUTextureCache::ReloadTextureReplacements(true);
GPUThread::RunOnThread([]() { GPUTextureCache::ReloadTextureReplacements(true); });
})
DEFINE_HOTKEY("ToggleWidescreen", TRANSLATE_NOOP("Hotkeys", "Graphics"), TRANSLATE_NOOP("Hotkeys", "Toggle Widescreen"),
@ -451,11 +455,9 @@ DEFINE_HOTKEY("TogglePGXPDepth", TRANSLATE_NOOP("Hotkeys", "Graphics"),
System::ClearMemorySaveStates(true);
const Settings old_settings = g_settings;
g_settings.gpu_pgxp_depth_buffer = !g_settings.gpu_pgxp_depth_buffer;
GPUThread::UpdateSettings(true, false);
g_gpu->RestoreDeviceContext();
g_gpu->UpdateSettings(old_settings);
Host::AddKeyedOSDMessage("TogglePGXPDepth",
g_settings.gpu_pgxp_depth_buffer ?
TRANSLATE_STR("OSDMessage", "PGXP Depth Buffer is now enabled.") :
@ -473,11 +475,9 @@ DEFINE_HOTKEY("TogglePGXPCPU", TRANSLATE_NOOP("Hotkeys", "Graphics"), TRANSLATE_
System::ClearMemorySaveStates(true);
const Settings old_settings = g_settings;
// GPU thread is unchanged
g_settings.gpu_pgxp_cpu = !g_settings.gpu_pgxp_cpu;
g_gpu->RestoreDeviceContext();
g_gpu->UpdateSettings(old_settings);
Host::AddKeyedOSDMessage("TogglePGXPCPU",
g_settings.gpu_pgxp_cpu ?
TRANSLATE_STR("OSDMessage", "PGXP CPU mode is now enabled.") :
@ -587,29 +587,31 @@ DEFINE_HOTKEY("AudioVolumeDown", TRANSLATE_NOOP("Hotkeys", "Audio"), TRANSLATE_N
DEFINE_HOTKEY("LoadSelectedSaveState", TRANSLATE_NOOP("Hotkeys", "Save States"),
TRANSLATE_NOOP("Hotkeys", "Load From Selected Slot"), [](s32 pressed) {
if (!pressed)
Host::RunOnCPUThread(SaveStateSelectorUI::LoadCurrentSlot);
GPUThread::RunOnThread(SaveStateSelectorUI::LoadCurrentSlot);
})
DEFINE_HOTKEY("SaveSelectedSaveState", TRANSLATE_NOOP("Hotkeys", "Save States"),
TRANSLATE_NOOP("Hotkeys", "Save To Selected Slot"), [](s32 pressed) {
if (!pressed)
Host::RunOnCPUThread(SaveStateSelectorUI::SaveCurrentSlot);
GPUThread::RunOnThread(SaveStateSelectorUI::SaveCurrentSlot);
})
DEFINE_HOTKEY("SelectPreviousSaveStateSlot", TRANSLATE_NOOP("Hotkeys", "Save States"),
TRANSLATE_NOOP("Hotkeys", "Select Previous Save Slot"), [](s32 pressed) {
if (!pressed)
Host::RunOnCPUThread([]() { SaveStateSelectorUI::SelectPreviousSlot(true); });
GPUThread::RunOnThread([]() { SaveStateSelectorUI::SelectPreviousSlot(true); });
})
DEFINE_HOTKEY("SelectNextSaveStateSlot", TRANSLATE_NOOP("Hotkeys", "Save States"),
TRANSLATE_NOOP("Hotkeys", "Select Next Save Slot"), [](s32 pressed) {
if (!pressed)
Host::RunOnCPUThread([]() { SaveStateSelectorUI::SelectNextSlot(true); });
GPUThread::RunOnThread([]() { SaveStateSelectorUI::SelectNextSlot(true); });
})
DEFINE_HOTKEY("SaveStateAndSelectNextSlot", TRANSLATE_NOOP("Hotkeys", "Save States"),
TRANSLATE_NOOP("Hotkeys", "Save State and Select Next Slot"), [](s32 pressed) {
if (!pressed && System::IsValid())
{
GPUThread::RunOnThread([]() {
SaveStateSelectorUI::SaveCurrentSlot();
SaveStateSelectorUI::SelectNextSlot(false);
});
}
})

197
src/core/imgui_overlays.cpp
View File

@ -9,6 +9,8 @@
#include "dma.h"
#include "fullscreen_ui.h"
#include "gpu.h"
#include "gpu_backend.h"
#include "gpu_thread.h"
#include "host.h"
#include "mdec.h"
#include "performance_counters.h"
@ -70,10 +72,10 @@ struct DebugWindowInfo
} // namespace
static void FormatProcessorStat(SmallStringBase& text, double usage, double time);
static void DrawPerformanceOverlay(float& position_y, float scale, float margin, float spacing);
static void DrawPerformanceOverlay(const GPUBackend* gpu, float& position_y, float scale, float margin, float spacing);
static void DrawMediaCaptureOverlay(float& position_y, float scale, float margin, float spacing);
static void DrawFrameTimeOverlay(float& position_y, float scale, float margin, float spacing);
static void DrawEnhancementsOverlay();
static void DrawEnhancementsOverlay(const GPUBackend* gpu);
static void DrawInputsOverlay();
#ifndef __ANDROID__
@ -119,93 +121,22 @@ static std::tuple<float, float> GetMinMax(std::span<const float> values)
return std::tie(min, max);
}
void Host::DisplayLoadingScreen(const char* message, int progress_min /*= -1*/, int progress_max /*= -1*/,
int progress_value /*= -1*/)
bool ImGuiManager::AreAnyDebugWindowsEnabled(const SettingsInterface& si)
{
if (!g_gpu_device || !g_gpu_device->HasMainSwapChain())
#ifndef __ANDROID__
const bool block_all = Achievements::IsHardcoreModeActive();
if (block_all)
return false;
for (size_t i = 0; i < NUM_DEBUG_WINDOWS; i++)
{
INFO_LOG("{}: {}/{}", message, progress_value, progress_max);
return;
const DebugWindowInfo& info = s_debug_window_info[i];
if (si.GetBoolValue(DEBUG_WINDOW_CONFIG_SECTION, info.name, false))
return true;
}
#endif
const auto& io = ImGui::GetIO();
const float scale = ImGuiManager::GetGlobalScale();
const float width = (400.0f * scale);
const bool has_progress = (progress_min < progress_max);
// eat the last imgui frame, it might've been partially rendered by the caller.
ImGui::EndFrame();
ImGui::NewFrame();
const float logo_width = 260.0f * scale;
const float logo_height = 260.0f * scale;
ImGui::SetNextWindowSize(ImVec2(logo_width, logo_height), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) - (50.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.5f));
if (ImGui::Begin("LoadingScreenLogo", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing |
ImGuiWindowFlags_NoBackground))
{
GPUTexture* tex = ImGuiFullscreen::GetCachedTexture("images/duck.png");
if (tex)
ImGui::Image(tex, ImVec2(logo_width, logo_height));
}
ImGui::End();
const float padding_and_rounding = 18.0f * scale;
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, padding_and_rounding);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding_and_rounding, padding_and_rounding));
ImGui::SetNextWindowSize(ImVec2(width, (has_progress ? 90.0f : 55.0f) * scale), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) + (100.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.0f));
if (ImGui::Begin("LoadingScreen", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing))
{
if (has_progress)
{
ImGui::TextUnformatted(message);
TinyString buf;
buf.format("{}/{}", progress_value, progress_max);
const ImVec2 prog_size = ImGui::CalcTextSize(buf.c_str(), buf.end_ptr());
ImGui::SameLine();
ImGui::SetCursorPosX(width - padding_and_rounding - prog_size.x);
ImGui::TextUnformatted(buf.c_str(), buf.end_ptr());
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 5.0f);
ImGui::ProgressBar(static_cast<float>(progress_value) / static_cast<float>(progress_max - progress_min),
ImVec2(-1.0f, 0.0f), "");
INFO_LOG("{}: {}", message, buf);
}
else
{
const ImVec2 text_size(ImGui::CalcTextSize(message));
ImGui::SetCursorPosX((width - text_size.x) / 2.0f);
ImGui::TextUnformatted(message);
INFO_LOG(message);
}
}
ImGui::End();
ImGui::PopStyleVar(2);
ImGui::EndFrame();
// TODO: Glass effect or something.
GPUSwapChain* swap_chain = g_gpu_device->GetMainSwapChain();
if (g_gpu_device->BeginPresent(swap_chain) == GPUDevice::PresentResult::OK)
{
g_gpu_device->RenderImGui(swap_chain);
g_gpu_device->EndPresent(swap_chain, false);
}
ImGui::NewFrame();
return false;
}
bool ImGuiManager::UpdateDebugWindowConfig()
@ -284,26 +215,28 @@ void ImGuiManager::DestroyAllDebugWindows()
#endif
}
void ImGuiManager::RenderTextOverlays()
void ImGuiManager::RenderTextOverlays(const GPUBackend* gpu)
{
const System::State state = System::GetState();
if (state != System::State::Shutdown)
{
// Don't draw anything with loading screen open, it'll be nonsensical.
if (ImGuiFullscreen::IsLoadingScreenOpen())
return;
const bool paused = GPUThread::IsSystemPaused();
const float scale = ImGuiManager::GetGlobalScale();
const float f_margin = ImGuiManager::GetScreenMargin() * scale;
const float margin = ImCeil(ImGuiManager::GetScreenMargin() * scale);
const float spacing = ImCeil(5.0f * scale);
float position_y = ImFloor(f_margin);
DrawPerformanceOverlay(position_y, scale, margin, spacing);
DrawPerformanceOverlay(gpu, position_y, scale, margin, spacing);
DrawFrameTimeOverlay(position_y, scale, margin, spacing);
DrawMediaCaptureOverlay(position_y, scale, margin, spacing);
if (g_settings.display_show_enhancements && state != System::State::Paused)
DrawEnhancementsOverlay();
if (g_gpu_settings.display_show_enhancements && !paused)
DrawEnhancementsOverlay(gpu);
if (g_settings.display_show_inputs && state != System::State::Paused)
if (g_gpu_settings.display_show_inputs && !paused)
DrawInputsOverlay();
}
}
void ImGuiManager::FormatProcessorStat(SmallStringBase& text, double usage, double time)
@ -317,12 +250,13 @@ void ImGuiManager::FormatProcessorStat(SmallStringBase& text, double usage, doub
text.append_format("{:.1f}% ({:.2f}ms)", usage, time);
}
void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float margin, float spacing)
void ImGuiManager::DrawPerformanceOverlay(const GPUBackend* gpu, float& position_y, float scale, float margin,
float spacing)
{
if (!(g_settings.display_show_fps || g_settings.display_show_speed || g_settings.display_show_gpu_stats ||
g_settings.display_show_resolution || g_settings.display_show_cpu_usage ||
(g_settings.display_show_status_indicators &&
(System::IsPaused() || System::IsFastForwardEnabled() || System::IsTurboEnabled()))))
if (!(g_gpu_settings.display_show_fps || g_gpu_settings.display_show_speed || g_gpu_settings.display_show_gpu_stats ||
g_gpu_settings.display_show_resolution || g_gpu_settings.display_show_cpu_usage ||
(g_gpu_settings.display_show_status_indicators &&
(GPUThread::IsSystemPaused() || System::IsFastForwardEnabled() || System::IsTurboEnabled()))))
{
return;
}
@ -352,9 +286,9 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
if (state == System::State::Running)
{
const float speed = PerformanceCounters::GetEmulationSpeed();
if (g_settings.display_show_fps)
if (g_gpu_settings.display_show_fps)
text.append_format("G: {:.2f} | V: {:.2f}", PerformanceCounters::GetFPS(), PerformanceCounters::GetVPS());
if (g_settings.display_show_speed)
if (g_gpu_settings.display_show_speed)
{
text.append_format("{}{}%", text.empty() ? "" : " | ", static_cast<u32>(std::round(speed)));
@ -377,19 +311,19 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
DRAW_LINE(fixed_font, text, color);
}
if (g_settings.display_show_gpu_stats)
if (g_gpu_settings.display_show_gpu_stats)
{
g_gpu->GetStatsString(text);
gpu->GetStatsString(text);
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
g_gpu->GetMemoryStatsString(text);
gpu->GetMemoryStatsString(text);
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
}
if (g_settings.display_show_resolution)
if (g_gpu_settings.display_show_resolution)
{
const u32 resolution_scale = g_gpu->GetResolutionScale();
const auto [display_width, display_height] = g_gpu->GetFullDisplayResolution(); // wrong
const u32 resolution_scale = gpu->GetResolutionScale();
const auto [display_width, display_height] = g_gpu->GetFullDisplayResolution(); // NOTE: Racey read.
const bool interlaced = g_gpu->IsInterlacedDisplayEnabled();
const bool pal = g_gpu->IsInPALMode();
text.format("{}x{} {} {} [{}x]", display_width * resolution_scale, display_height * resolution_scale,
@ -397,13 +331,13 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
}
if (g_settings.display_show_latency_stats)
if (g_gpu_settings.display_show_latency_stats)
{
System::FormatLatencyStats(text);
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
}
if (g_settings.display_show_cpu_usage)
if (g_gpu_settings.display_show_cpu_usage)
{
text.format("{:.2f}ms | {:.2f}ms | {:.2f}ms", PerformanceCounters::GetMinimumFrameTime(),
PerformanceCounters::GetAverageFrameTime(), PerformanceCounters::GetMaximumFrameTime());
@ -454,11 +388,11 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
PerformanceCounters::GetCPUThreadAverageTime());
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
if (g_gpu->GetSWThread())
if (g_gpu_settings.gpu_use_thread)
{
text.assign("SW: ");
FormatProcessorStat(text, PerformanceCounters::GetSWThreadUsage(),
PerformanceCounters::GetSWThreadAverageTime());
text.assign("RNDR: ");
FormatProcessorStat(text, PerformanceCounters::GetGPUThreadUsage(),
PerformanceCounters::GetGPUThreadAverageTime());
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
}
@ -472,14 +406,14 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
#endif
}
if (g_settings.display_show_gpu_usage && g_gpu_device->IsGPUTimingEnabled())
if (g_gpu_settings.display_show_gpu_usage && g_gpu_device->IsGPUTimingEnabled())
{
text.assign("GPU: ");
FormatProcessorStat(text, PerformanceCounters::GetGPUUsage(), PerformanceCounters::GetGPUAverageTime());
DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
}
if (g_settings.display_show_status_indicators)
if (g_gpu_settings.display_show_status_indicators)
{
const bool rewinding = System::IsRewinding();
if (rewinding || System::IsFastForwardEnabled() || System::IsTurboEnabled())
@ -489,7 +423,7 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
}
}
}
else if (g_settings.display_show_status_indicators && state == System::State::Paused &&
else if (g_gpu_settings.display_show_status_indicators && state == System::State::Paused &&
!FullscreenUI::HasActiveWindow())
{
text.assign(ICON_EMOJI_PAUSE);
@ -499,12 +433,12 @@ void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float
#undef DRAW_LINE
}
void ImGuiManager::DrawEnhancementsOverlay()
void ImGuiManager::DrawEnhancementsOverlay(const GPUBackend* gpu)
{
LargeString text;
text.append_format("{} {}-{}", Settings::GetConsoleRegionName(System::GetRegion()),
GPUDevice::RenderAPIToString(g_gpu_device->GetRenderAPI()),
g_gpu->IsHardwareRenderer() ? "HW" : "SW");
GPUBackend::IsUsingHardwareBackend() ? "HW" : "SW");
if (g_settings.rewind_enable)
text.append_format(" RW={}/{}", g_settings.rewind_save_frequency, g_settings.rewind_save_slots);
@ -626,7 +560,7 @@ void ImGuiManager::DrawMediaCaptureOverlay(float& position_y, float scale, float
void ImGuiManager::DrawFrameTimeOverlay(float& position_y, float scale, float margin, float spacing)
{
if (!g_settings.display_show_frame_times || System::IsPaused())
if (!g_settings.display_show_frame_times || GPUThread::IsSystemPaused())
return;
const float shadow_offset = std::ceil(1.0f * scale);
@ -864,8 +798,6 @@ bool SaveStateSelectorUI::IsOpen()
void SaveStateSelectorUI::Open(float open_time /* = DEFAULT_OPEN_TIME */)
{
const std::string& serial = System::GetGameSerial();
s_state.open_time = 0.0f;
s_state.close_time = open_time;
@ -876,7 +808,7 @@ void SaveStateSelectorUI::Open(float open_time /* = DEFAULT_OPEN_TIME */)
s_state.placeholder_texture = ImGuiFullscreen::LoadTexture("no-save.png");
s_state.is_open = true;
RefreshList(serial);
RefreshList();
RefreshHotkeyLegend();
}
@ -889,7 +821,7 @@ void SaveStateSelectorUI::Close()
s_state.next_legend = {};
}
void SaveStateSelectorUI::RefreshList(const std::string& serial)
void SaveStateSelectorUI::RefreshList()
{
for (ListEntry& entry : s_state.slots)
{
@ -898,9 +830,7 @@ void SaveStateSelectorUI::RefreshList(const std::string& serial)
}
s_state.slots.clear();
if (System::IsShutdown())
return;
const std::string& serial = GPUThread::GetGameSerial();
if (!serial.empty())
{
for (s32 i = 1; i <= System::PER_GAME_SAVE_STATE_SLOTS; i++)
@ -956,6 +886,7 @@ void SaveStateSelectorUI::Clear()
void SaveStateSelectorUI::ClearList()
{
DebugAssert(GPUThread::IsOnThread());
for (ListEntry& li : s_state.slots)
{
if (li.preview_texture)
@ -1001,7 +932,7 @@ void SaveStateSelectorUI::SelectNextSlot(bool open_selector)
s_state.current_slot++;
if (s_state.current_slot >= total_slots)
{
if (!System::GetGameSerial().empty())
if (!GPUThread::GetGameSerial().empty())
s_state.current_slot_global ^= true;
s_state.current_slot -= total_slots;
}
@ -1024,7 +955,7 @@ void SaveStateSelectorUI::SelectPreviousSlot(bool open_selector)
s_state.current_slot--;
if (s_state.current_slot < 0)
{
if (!System::GetGameSerial().empty())
if (!GPUThread::GetGameSerial().empty())
s_state.current_slot_global ^= true;
s_state.current_slot +=
s_state.current_slot_global ? System::GLOBAL_SAVE_STATE_SLOTS : System::PER_GAME_SAVE_STATE_SLOTS;
@ -1245,7 +1176,7 @@ std::string SaveStateSelectorUI::GetCurrentSlotPath()
std::string filename;
if (!s_state.current_slot_global)
{
if (const std::string& serial = System::GetGameSerial(); !serial.empty())
if (const std::string& serial = GPUThread::GetGameSerial(); !serial.empty())
filename = System::GetGameSaveStateFileName(serial, s_state.current_slot + 1);
}
else
@ -1258,10 +1189,13 @@ std::string SaveStateSelectorUI::GetCurrentSlotPath()
void SaveStateSelectorUI::LoadCurrentSlot()
{
DebugAssert(GPUThread::IsOnThread());
if (std::string path = GetCurrentSlotPath(); !path.empty())
{
if (FileSystem::FileExists(path.c_str()))
{
Host::RunOnCPUThread([path = std::move(path)]() {
Error error;
if (!System::LoadState(path.c_str(), &error, true))
{
@ -1270,6 +1204,7 @@ void SaveStateSelectorUI::LoadCurrentSlot()
GetCurrentSlot(), error.GetDescription()),
Host::OSD_ERROR_DURATION);
}
});
}
else
{
@ -1289,6 +1224,7 @@ void SaveStateSelectorUI::SaveCurrentSlot()
{
if (std::string path = GetCurrentSlotPath(); !path.empty())
{
Host::RunOnCPUThread([path = std::move(path)]() {
Error error;
if (!System::SaveState(std::move(path), &error, g_settings.create_save_state_backups, false))
{
@ -1297,6 +1233,7 @@ void SaveStateSelectorUI::SaveCurrentSlot()
GetCurrentSlot(), error.GetDescription()),
Host::OSD_ERROR_DURATION);
}
});
}
Close();
@ -1323,7 +1260,7 @@ void SaveStateSelectorUI::ShowSlotOSDMessage()
void ImGuiManager::RenderOverlayWindows()
{
const System::State state = System::GetState();
if (state != System::State::Shutdown)
if (state == System::State::Paused || state == System::State::Running)
{
if (SaveStateSelectorUI::s_state.is_open)
SaveStateSelectorUI::Draw();

13
src/core/imgui_overlays.h
View File

@ -7,14 +7,23 @@
#include <string>
class SettingsInterface;
class GPUBackend;
namespace ImGuiManager {
void RenderTextOverlays();
static constexpr const char* LOGO_IMAGE_NAME = "images/duck.png";
void RenderTextOverlays(const GPUBackend* gpu);
bool AreAnyDebugWindowsEnabled(const SettingsInterface& si);
void RenderDebugWindows();
bool UpdateDebugWindowConfig();
void DestroyAllDebugWindows();
void RenderOverlayWindows();
void DestroyOverlayTextures();
} // namespace ImGuiManager
namespace SaveStateSelectorUI {
@ -23,7 +32,7 @@ static constexpr float DEFAULT_OPEN_TIME = 7.5f;
bool IsOpen();
void Open(float open_time = DEFAULT_OPEN_TIME);
void RefreshList(const std::string& serial);
void RefreshList();
void Clear();
void ClearList();
void Close();

48
src/core/performance_counters.cpp
View File

@ -3,6 +3,8 @@
#include "performance_counters.h"
#include "gpu.h"
#include "gpu_backend.h"
#include "gpu_thread.h"
#include "system.h"
#include "system_private.h"
@ -45,9 +47,9 @@ struct State
float cpu_thread_usage;
float cpu_thread_time;
u64 last_sw_time;
float sw_thread_usage;
float sw_thread_time;
u64 last_gpu_thread_time;
float gpu_thread_usage;
float gpu_thread_time;
float average_gpu_time;
float accumulated_gpu_time;
@ -105,14 +107,14 @@ float PerformanceCounters::GetCPUThreadAverageTime()
return s_state.cpu_thread_time;
}
float PerformanceCounters::GetSWThreadUsage()
float PerformanceCounters::GetGPUThreadUsage()
{
return s_state.sw_thread_usage;
return s_state.gpu_thread_usage;
}
float PerformanceCounters::GetSWThreadAverageTime()
float PerformanceCounters::GetGPUThreadAverageTime()
{
return s_state.sw_thread_time;
return s_state.gpu_thread_time;
}
float PerformanceCounters::GetGPUUsage()
@ -150,17 +152,16 @@ void PerformanceCounters::Reset()
s_state.last_frame_number = System::GetFrameNumber();
s_state.last_internal_frame_number = System::GetInternalFrameNumber();
s_state.last_cpu_time = System::GetCPUThreadHandle().GetCPUTime();
if (const Threading::Thread* sw_thread = g_gpu->GetSWThread(); sw_thread)
s_state.last_sw_time = sw_thread->GetCPUTime();
else
s_state.last_sw_time = 0;
s_state.last_gpu_thread_time = GPUThread::Internal::GetThreadHandle().GetCPUTime();
s_state.average_frame_time_accumulator = 0.0f;
s_state.minimum_frame_time_accumulator = 0.0f;
s_state.maximum_frame_time_accumulator = 0.0f;
std::atomic_thread_fence(std::memory_order_release);
}
void PerformanceCounters::Update(u32 frame_number, u32 internal_frame_number)
void PerformanceCounters::Update(GPUBackend* gpu, u32 frame_number, u32 internal_frame_number)
{
const Timer::Value now_ticks = Timer::GetCurrentValue();
@ -177,7 +178,7 @@ void PerformanceCounters::Update(u32 frame_number, u32 internal_frame_number)
// update fps counter
const Timer::Value ticks_diff = now_ticks - s_state.last_update_time;
const float time = static_cast<float>(Timer::ConvertValueToSeconds(ticks_diff));
if (time < PERFORMANCE_COUNTER_UPDATE_INTERVAL)
if (time < PERFORMANCE_COUNTER_UPDATE_INTERVAL || s_state.last_frame_number == frame_number)
return;
s_state.last_update_time = now_ticks;
@ -202,18 +203,17 @@ void PerformanceCounters::Update(u32 frame_number, u32 internal_frame_number)
s_state.fps = static_cast<float>(internal_frames_run) / time;
s_state.speed = (s_state.vps / System::GetVideoFrameRate()) * 100.0f;
const Threading::Thread* sw_thread = g_gpu->GetSWThread();
const u64 cpu_time = System::GetCPUThreadHandle().GetCPUTime();
const u64 sw_time = sw_thread ? sw_thread->GetCPUTime() : 0;
const u64 gpu_thread_time = GPUThread::Internal::GetThreadHandle().GetCPUTime();
const u64 cpu_delta = cpu_time - s_state.last_cpu_time;
const u64 sw_delta = sw_time - s_state.last_sw_time;
const u64 gpu_thread_delta = gpu_thread_time - s_state.last_gpu_thread_time;
s_state.last_cpu_time = cpu_time;
s_state.last_sw_time = sw_time;
s_state.last_gpu_thread_time = gpu_thread_time;
s_state.cpu_thread_usage = static_cast<float>(static_cast<double>(cpu_delta) * pct_divider);
s_state.cpu_thread_time = static_cast<float>(static_cast<double>(cpu_delta) * time_divider);
s_state.sw_thread_usage = static_cast<float>(static_cast<double>(sw_delta) * pct_divider);
s_state.sw_thread_time = static_cast<float>(static_cast<double>(sw_delta) * time_divider);
s_state.gpu_thread_usage = static_cast<float>(static_cast<double>(gpu_thread_delta) * pct_divider);
s_state.gpu_thread_time = static_cast<float>(static_cast<double>(gpu_thread_delta) * time_divider);
if (MediaCapture* cap = System::GetMediaCapture())
cap->UpdateCaptureThreadUsage(pct_divider, time_divider);
@ -228,13 +228,13 @@ void PerformanceCounters::Update(u32 frame_number, u32 internal_frame_number)
s_state.presents_since_last_update = 0;
if (g_settings.display_show_gpu_stats)
g_gpu->UpdateStatistics(frames_run);
gpu->UpdateStatistics(frames_run);
VERBOSE_LOG("FPS: {:.2f} VPS: {:.2f} CPU: {:.2f} GPU: {:.2f} Avg: {:.2f}ms Min: {:.2f}ms Max: {:.2f}ms", s_state.fps,
s_state.vps, s_state.cpu_thread_usage, s_state.gpu_usage, s_state.average_frame_time,
s_state.minimum_frame_time, s_state.maximum_frame_time);
VERBOSE_LOG("FPS: {:.2f} VPS: {:.2f} CPU: {:.2f} RNDR: {:.2f} GPU: {:.2f} Avg: {:.2f}ms Min: {:.2f}ms Max: {:.2f}ms",
s_state.fps, s_state.vps, s_state.cpu_thread_usage, s_state.gpu_thread_usage, s_state.gpu_usage,
s_state.average_frame_time, s_state.minimum_frame_time, s_state.maximum_frame_time);
Host::OnPerformanceCountersUpdated();
Host::OnPerformanceCountersUpdated(gpu);
}
void PerformanceCounters::AccumulateGPUTime()

8
src/core/performance_counters.h
View File

@ -5,6 +5,8 @@
#include "common/types.h"
class GPUBackend;
namespace PerformanceCounters
{
static constexpr u32 NUM_FRAME_TIME_SAMPLES = 150;
@ -18,8 +20,8 @@ float GetMinimumFrameTime();
float GetMaximumFrameTime();
float GetCPUThreadUsage();
float GetCPUThreadAverageTime();
float GetSWThreadUsage();
float GetSWThreadAverageTime();
float GetGPUThreadUsage();
float GetGPUThreadAverageTime();
float GetGPUUsage();
float GetGPUAverageTime();
const FrameTimeHistory& GetFrameTimeHistory();
@ -27,7 +29,7 @@ u32 GetFrameTimeHistoryPos();
void Clear();
void Reset();
void Update(u32 frame_number, u32 internal_frame_number);
void Update(GPUBackend* gpu, u32 frame_number, u32 internal_frame_number);
void AccumulateGPUTime();
} // namespace Host

30
src/core/settings.cpp
View File

@ -5,6 +5,7 @@
#include "achievements.h"
#include "controller.h"
#include "host.h"
#include "imgui_overlays.h"
#include "system.h"
#include "util/gpu_device.h"
@ -28,7 +29,8 @@
LOG_CHANNEL(Settings);
Settings g_settings;
ALIGN_TO_CACHE_LINE Settings g_settings;
ALIGN_TO_CACHE_LINE Settings g_gpu_settings;
const char* SettingInfo::StringDefaultValue() const
{
@ -206,6 +208,7 @@ void Settings::Load(const SettingsInterface& si, const SettingsInterface& contro
gpu_disable_compressed_textures = si.GetBoolValue("GPU", "DisableCompressedTextures", false);
gpu_per_sample_shading = si.GetBoolValue("GPU", "PerSampleShading", false);
gpu_use_thread = si.GetBoolValue("GPU", "UseThread", true);
gpu_max_queued_frames = static_cast<u8>(si.GetUIntValue("GPU", "MaxQueuedFrames", DEFAULT_GPU_MAX_QUEUED_FRAMES));
gpu_use_software_renderer_for_readbacks = si.GetBoolValue("GPU", "UseSoftwareRendererForReadbacks", false);
gpu_true_color = si.GetBoolValue("GPU", "TrueColor", true);
gpu_scaled_dithering = si.GetBoolValue("GPU", "ScaledDithering", true);
@ -554,6 +557,7 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
}
si.SetBoolValue("GPU", "PerSampleShading", gpu_per_sample_shading);
si.SetUIntValue("GPU", "MaxQueuedFrames", gpu_max_queued_frames);
si.SetBoolValue("GPU", "UseThread", gpu_use_thread);
si.SetBoolValue("GPU", "UseSoftwareRendererForReadbacks", gpu_use_software_renderer_for_readbacks);
si.SetBoolValue("GPU", "TrueColor", gpu_true_color);
@ -950,7 +954,7 @@ std::string Settings::TextureReplacementSettings::Configuration::ExportToYAML(bo
comment_str, replacement_scale_linear_filter); // ReplacementScaleLinearFilter
}
void Settings::FixIncompatibleSettings(bool display_osd_messages)
void Settings::FixIncompatibleSettings(const SettingsInterface& si, bool display_osd_messages)
{
if (g_settings.disable_all_enhancements)
{
@ -1022,6 +1026,13 @@ void Settings::FixIncompatibleSettings(bool display_osd_messages)
(g_settings.gpu_renderer != GPURenderer::Software && g_settings.gpu_texture_cache);
g_settings.texture_replacements.enable_vram_write_replacements &= (g_settings.gpu_renderer != GPURenderer::Software);
// GPU thread should be disabled if any debug windows are active, since they will be racing to read CPU thread state.
if (g_settings.gpu_use_thread && g_settings.gpu_max_queued_frames > 0 && ImGuiManager::AreAnyDebugWindowsEnabled(si))
{
WARNING_LOG("Setting maximum queued frames to 0 because one or more debug windows are enabled.");
g_settings.gpu_max_queued_frames = 0;
}
#ifndef ENABLE_MMAP_FASTMEM
if (g_settings.cpu_fastmem_mode == CPUFastmemMode::MMap)
{
@ -1081,6 +1092,21 @@ void Settings::FixIncompatibleSettings(bool display_osd_messages)
}
}
bool Settings::AreGPUDeviceSettingsChanged(const Settings& old_settings) const
{
return (gpu_use_debug_device != old_settings.gpu_use_debug_device ||
gpu_disable_shader_cache != old_settings.gpu_disable_shader_cache ||
gpu_disable_dual_source_blend != old_settings.gpu_disable_dual_source_blend ||
gpu_disable_framebuffer_fetch != old_settings.gpu_disable_framebuffer_fetch ||
gpu_disable_texture_buffers != old_settings.gpu_disable_texture_buffers ||
gpu_disable_texture_copy_to_self != old_settings.gpu_disable_texture_copy_to_self ||
gpu_disable_memory_import != old_settings.gpu_disable_memory_import ||
gpu_disable_raster_order_views != old_settings.gpu_disable_raster_order_views ||
gpu_disable_compute_shaders != old_settings.gpu_disable_compute_shaders ||
gpu_disable_compressed_textures != old_settings.gpu_disable_compressed_textures ||
display_exclusive_fullscreen_control != old_settings.display_exclusive_fullscreen_control);
}
void Settings::SetDefaultLogConfig(SettingsInterface& si)
{
si.SetStringValue("Logging", "LogLevel", GetLogLevelName(DEFAULT_LOG_LEVEL));

13
src/core/settings.h
View File

@ -98,6 +98,7 @@ struct Settings
std::string gpu_adapter;
u8 gpu_resolution_scale = 1;
u8 gpu_multisamples = 1;
u8 gpu_max_queued_frames = DEFAULT_GPU_MAX_QUEUED_FRAMES;
bool gpu_use_thread : 1 = true;
bool gpu_use_software_renderer_for_readbacks : 1 = false;
bool gpu_use_debug_device : 1 = false;
@ -378,7 +379,9 @@ struct Settings
void Save(SettingsInterface& si, bool ignore_base) const;
static void Clear(SettingsInterface& si);
void FixIncompatibleSettings(bool display_osd_messages);
void FixIncompatibleSettings(const SettingsInterface& si, bool display_osd_messages);
bool AreGPUDeviceSettingsChanged(const Settings& old_settings) const;
/// Initializes configuration.
static void SetDefaultLogConfig(SettingsInterface& si);
@ -565,13 +568,19 @@ struct Settings
static constexpr bool DEFAULT_SAVE_STATE_BACKUPS = true;
static constexpr bool DEFAULT_FAST_BOOT_VALUE = false;
static constexpr u16 DEFAULT_GDB_SERVER_PORT = 2345;
// TODO: Maybe lower? But that means fast CPU threads would always stall, could be a problem for power management.
static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 2;
#else
static constexpr bool DEFAULT_SAVE_STATE_BACKUPS = false;
static constexpr bool DEFAULT_FAST_BOOT_VALUE = true;
static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 3;
#endif
};
extern Settings g_settings;
// TODO: Use smaller copy for GPU thread copy.
ALIGN_TO_CACHE_LINE extern Settings g_settings; // CPU thread copy.
ALIGN_TO_CACHE_LINE extern Settings g_gpu_settings; // GPU thread copy.
namespace EmuFolders {
extern std::string AppRoot;

1046
src/core/system.cpp
View File

File diff suppressed because it is too large Load Diff

10
src/core/system.h
View File

@ -165,7 +165,6 @@ std::unique_ptr<INISettingsInterface> GetGameSettingsInterface(const GameDatabas
std::string GetInputProfilePath(std::string_view name);
State GetState();
void SetState(State new_state);
bool IsRunning();
bool IsPaused();
bool IsShutdown();
@ -384,7 +383,7 @@ s32 GetAudioOutputVolume();
void UpdateVolume();
/// Saves a screenshot to the specified file. If no file name is provided, one will be generated automatically.
bool SaveScreenshot(const char* path = nullptr, DisplayScreenshotMode mode = g_settings.display_screenshot_mode,
void SaveScreenshot(const char* path = nullptr, DisplayScreenshotMode mode = g_settings.display_screenshot_mode,
DisplayScreenshotFormat format = g_settings.display_screenshot_format,
u8 quality = g_settings.display_screenshot_quality, bool compress_on_thread = true);
@ -400,7 +399,6 @@ MediaCapture* GetMediaCapture();
/// Media capture (video and/or audio). If no path is provided, one will be generated automatically.
bool StartMediaCapture(std::string path = {});
bool StartMediaCapture(std::string path, bool capture_video, bool capture_audio);
void StopMediaCapture();
/// Toggle Widescreen Hack and Aspect Ratio
@ -413,15 +411,11 @@ void ToggleSoftwareRendering();
/// If the scale is set to 0, the internal resolution will be used, otherwise it is treated as a multiplier to 1x.
void RequestDisplaySize(float scale = 0.0f);
/// Renders the display.
bool PresentDisplay(bool explicit_present, u64 present_time);
void InvalidateDisplay();
//////////////////////////////////////////////////////////////////////////
// Memory Save States (Rewind and Runahead)
//////////////////////////////////////////////////////////////////////////
void CalculateRewindMemoryUsage(u32 num_saves, u32 resolution_scale, u64* ram_usage, u64* vram_usage);
void ClearMemorySaveStates(bool deallocate_resources);
void ClearMemorySaveStates(bool reallocate_resources);
void SetRunaheadReplayFlag();
/// Shared socket multiplexer, used by PINE/GDB/etc.

26
src/core/system_private.h
View File

@ -7,26 +7,32 @@
#include <functional>
class GPUBackend;
struct GPUBackendFramePresentationParameters;
namespace System {
/// Memory save states - only for internal use.
struct MemorySaveState
{
std::unique_ptr<GPUTexture> vram_texture;
DynamicHeapArray<u8> state_data;
size_t state_size;
std::unique_ptr<GPUTexture> vram_texture;
DynamicHeapArray<u8> gpu_state_data;
size_t gpu_state_size;
};
MemorySaveState& AllocateMemoryState();
MemorySaveState& GetFirstMemoryState();
MemorySaveState& PopMemoryState();
bool AllocateMemoryStates(size_t state_count);
void FreeMemoryStateTextures();
void FreeMemoryStateStorage();
void LoadMemoryState(MemorySaveState& mss, bool update_display);
bool SaveMemoryState(MemorySaveState& mss);
/// Returns the maximum size of a save state, considering the current configuration.
size_t GetMaxSaveStateSize();
void SaveMemoryState(MemorySaveState& mss);
bool IsRunaheadActive();
void IncrementFrameNumber();
void IncrementInternalFrameNumber();
void FrameDone();
@ -35,6 +41,10 @@ void FrameDone();
GPUVSyncMode GetEffectiveVSyncMode();
bool ShouldAllowPresentThrottle();
/// Retrieves timing information for frame presentation on the GPU thread.
/// Returns false if this frame should not be presented or the command buffer flushed.
bool GetFramePresentationParameters(GPUBackendFramePresentationParameters* frame);
/// Call when host display size changes.
void DisplayWindowResized();
@ -65,6 +75,7 @@ void IdlePollUpdate();
/// Task threads, asynchronous work which will block system shutdown.
void QueueTaskOnThread(std::function<void()> task);
void RemoveSelfFromTaskThreads();
void JoinTaskThreads();
} // namespace System
@ -91,11 +102,8 @@ void OnSystemPaused();
/// Called when the VM is resumed after being paused.
void OnSystemResumed();
/// Called when the pause state changes, or fullscreen UI opens.
void OnIdleStateChanged();
/// Called when performance metrics are updated, approximately once a second.
void OnPerformanceCountersUpdated();
void OnPerformanceCountersUpdated(const GPUBackend* gpu_backend);
/// Provided by the host; called when the running executable changes.
void OnGameChanged(const std::string& disc_path, const std::string& game_serial, const std::string& game_name);

6
src/duckstation-qt/debuggerwindow.cpp
View File

@ -241,14 +241,14 @@ void DebuggerWindow::onBreakpointListItemChanged(QTreeWidgetItem* item, int colu
void DebuggerWindow::onStepIntoActionTriggered()
{
Assert(System::IsPaused());
Assert(QtHost::IsSystemPaused());
saveCurrentState();
g_emu_thread->singleStepCPU();
}
void DebuggerWindow::onStepOverActionTriggered()
{
Assert(System::IsPaused());
Assert(QtHost::IsSystemPaused());
if (!CPU::AddStepOverBreakpoint())
{
onStepIntoActionTriggered();
@ -262,7 +262,7 @@ void DebuggerWindow::onStepOverActionTriggered()
void DebuggerWindow::onStepOutActionTriggered()
{
Assert(System::IsPaused());
Assert(QtHost::IsSystemPaused());
if (!CPU::AddStepOutBreakpoint())
{
QMessageBox::critical(this, tr("Debugger"), tr("Failed to add step-out breakpoint, are you in a valid function?"));

17
src/duckstation-qt/graphicssettingswidget.cpp
View File

@ -293,6 +293,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
// Debugging Tab
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.gpuThread, "GPU", "UseThread", true);
SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.maxQueuedFrames, "GPU", "MaxQueuedFrames",
Settings::DEFAULT_GPU_MAX_QUEUED_FRAMES);
connect(m_ui.gpuThread, &QCheckBox::checkStateChanged, this, &GraphicsSettingsWidget::onGPUThreadChanged);
SettingWidgetBinder::BindWidgetToEnumSetting(
sif, m_ui.gpuDumpCompressionMode, "GPU", "DumpCompressionMode", &Settings::ParseGPUDumpCompressionMode,
@ -325,6 +328,7 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
onMediaCaptureVideoEnabledChanged();
onEnableTextureCacheChanged();
onEnableAnyTextureReplacementsChanged();
onGPUThreadChanged();
onShowDebugSettingsChanged(QtHost::ShouldShowDebugOptions());
// Rendering Tab
@ -610,8 +614,8 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
tr("Draws a wireframe outline of the triangles rendered by the console's GPU, either as a "
"replacement or an overlay."));
dialog->registerWidgetHelp(m_ui.gpuThread, tr("Threaded Rendering"), tr("Checked"),
tr("Uses a second thread for drawing graphics. Currently only available for the software "
"renderer, but can provide a significant speed improvement, and is safe to use."));
tr("Uses a second thread for drawing graphics. Provides a significant speed improvement "
"particularly with the software renderer, and is safe to use."));
dialog->registerWidgetHelp(
m_ui.useDebugDevice, tr("Use Debug Device"), tr("Unchecked"),
@ -819,8 +823,6 @@ void GraphicsSettingsWidget::updateRendererDependentOptions()
m_ui.blitSwapChain->setEnabled(render_api == RenderAPI::D3D11);
#endif
m_ui.gpuThread->setEnabled(!is_hardware);
m_ui.exclusiveFullscreenLabel->setEnabled(render_api == RenderAPI::D3D11 || render_api == RenderAPI::D3D12 ||
render_api == RenderAPI::Vulkan);
m_ui.exclusiveFullscreenControl->setEnabled(render_api == RenderAPI::Vulkan);
@ -1181,6 +1183,13 @@ void GraphicsSettingsWidget::onEnableAnyTextureReplacementsChanged()
m_ui.preloadTextureReplacements->setEnabled(any_replacements_enabled);
}
void GraphicsSettingsWidget::onGPUThreadChanged()
{
const bool enabled = m_dialog->getEffectiveBoolValue("GPU", "UseThread", true);
m_ui.maxQueuedFrames->setEnabled(enabled);
m_ui.maxQueuedFramesLabel->setEnabled(enabled);
}
void GraphicsSettingsWidget::onTextureReplacementOptionsClicked()
{
QDialog dlg(QtUtils::GetRootWidget(this));

2
src/duckstation-qt/graphicssettingswidget.h
View File

@ -44,6 +44,8 @@ private Q_SLOTS:
void onEnableAnyTextureReplacementsChanged();
void onTextureReplacementOptionsClicked();
void onGPUThreadChanged();
private:
static constexpr int TAB_INDEX_RENDERING = 0;
static constexpr int TAB_INDEX_ADVANCED = 1;

18
src/duckstation-qt/graphicssettingswidget.ui
View File

@ -1286,12 +1286,30 @@
<item row="1" column="0" colspan="2">
<layout class="QGridLayout" name="gridLayout_4">
<item row="0" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_7" stretch="1,0,0">
<item>
<widget class="QCheckBox" name="gpuThread">
<property name="text">
<string>Threaded Rendering</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="maxQueuedFramesLabel">
<property name="text">
<string>Max Queued Frames:</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="maxQueuedFrames">
<property name="maximum">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>

10
src/duckstation-qt/mainwindow.cpp
View File

@ -85,6 +85,7 @@ static bool s_use_central_widget = false;
// UI thread VM validity.
static bool s_system_valid = false;
static bool s_system_paused = false;
static bool s_fullscreen_ui_started = false;
static std::atomic_uint32_t s_system_locked{false};
static QString s_current_game_title;
static QString s_current_game_serial;
@ -764,7 +765,7 @@ void MainWindow::recreate()
{
g_emu_thread->setSurfaceless(false);
g_main_window->updateEmulationActions(false, System::IsValid(), Achievements::IsHardcoreModeActive());
g_main_window->onFullscreenUIStateChange(g_emu_thread->isRunningFullscreenUI());
g_main_window->onFullscreenUIStartedOrStopped(s_fullscreen_ui_started);
}
if (controller_settings_window_pos.has_value())
@ -1258,8 +1259,9 @@ void MainWindow::onStartFullscreenUITriggered()
g_emu_thread->startFullscreenUI();
}
void MainWindow::onFullscreenUIStateChange(bool running)
void MainWindow::onFullscreenUIStartedOrStopped(bool running)
{
s_fullscreen_ui_started = running;
m_ui.actionStartFullscreenUI->setText(running ? tr("Stop Big Picture Mode") : tr("Start Big Picture Mode"));
m_ui.actionStartFullscreenUI2->setText(running ? tr("Exit Big Picture") : tr("Big Picture"));
}
@ -2046,7 +2048,7 @@ void MainWindow::connectSignals()
connect(g_emu_thread, &EmuThread::mediaCaptureStarted, this, &MainWindow::onMediaCaptureStarted);
connect(g_emu_thread, &EmuThread::mediaCaptureStopped, this, &MainWindow::onMediaCaptureStopped);
connect(g_emu_thread, &EmuThread::mouseModeRequested, this, &MainWindow::onMouseModeRequested);
connect(g_emu_thread, &EmuThread::fullscreenUIStateChange, this, &MainWindow::onFullscreenUIStateChange);
connect(g_emu_thread, &EmuThread::fullscreenUIStartedOrStopped, this, &MainWindow::onFullscreenUIStartedOrStopped);
connect(g_emu_thread, &EmuThread::achievementsLoginRequested, this, &MainWindow::onAchievementsLoginRequested);
connect(g_emu_thread, &EmuThread::achievementsChallengeModeChanged, this,
&MainWindow::onAchievementsChallengeModeChanged);
@ -2503,7 +2505,7 @@ bool MainWindow::requestShutdown(bool allow_confirm /* = true */, bool allow_sav
// reshow the main window during display updates, because otherwise fullscreen transitions and renderer switches
// would briefly show and then hide the main window. So instead, we do it on shutdown, here. Except if we're in
// batch mode, when we're going to exit anyway.
if (!isRenderingToMain() && isHidden() && !QtHost::InBatchMode() && !g_emu_thread->isRunningFullscreenUI())
if (!isRenderingToMain() && isHidden() && !QtHost::InBatchMode() && !s_fullscreen_ui_started)
updateWindowState(true);
// Now we can actually shut down the VM.

2
src/duckstation-qt/mainwindow.h
View File

@ -168,7 +168,7 @@ private Q_SLOTS:
void onCheatsActionTriggered();
void onCheatsMenuAboutToShow();
void onStartFullscreenUITriggered();
void onFullscreenUIStateChange(bool running);
void onFullscreenUIStartedOrStopped(bool running);
void onRemoveDiscActionTriggered();
void onScanForNewGamesTriggered();
void onViewToolbarActionToggled(bool checked);

170
src/duckstation-qt/qthost.cpp
View File

@ -19,7 +19,9 @@
#include "core/game_list.h"
#include "core/gdb_server.h"
#include "core/gpu.h"
#include "core/gpu_backend.h"
#include "core/gpu_hw_texture_cache.h"
#include "core/gpu_thread.h"
#include "core/host.h"
#include "core/imgui_overlays.h"
#include "core/memory_card.h"
@ -223,7 +225,6 @@ bool QtHost::SaveGameSettings(SettingsInterface* sif, bool delete_if_empty)
INISettingsInterface* ini = static_cast<INISettingsInterface*>(sif);
Error error;
// if there's no keys, just toss the whole thing out
if (delete_if_empty && ini->IsEmpty())
{
@ -576,13 +577,8 @@ void Host::LoadSettings(const SettingsInterface& si, std::unique_lock<std::mutex
void EmuThread::checkForSettingsChanges(const Settings& old_settings)
{
if (g_main_window)
{
QMetaObject::invokeMethod(g_main_window, &MainWindow::checkForSettingChanges, Qt::QueuedConnection);
if (System::IsValid())
updatePerformanceCounters();
}
// don't mess with fullscreen while locked
if (!QtHost::IsSystemLocked())
{
@ -591,7 +587,7 @@ void EmuThread::checkForSettingsChanges(const Settings& old_settings)
{
m_is_rendering_to_main = render_to_main;
if (g_gpu_device)
Host::UpdateDisplayWindow(m_is_fullscreen);
GPUThread::UpdateDisplayWindow(m_is_fullscreen);
}
}
}
@ -730,33 +726,24 @@ void EmuThread::startFullscreenUI()
return;
}
if (System::IsValid())
if (System::IsValid() || m_is_fullscreen_ui_started)
return;
// we want settings loaded so we choose the correct renderer
// this also sorts out input sources.
System::LoadSettings(false);
m_is_rendering_to_main = shouldRenderToMain();
m_run_fullscreen_ui = true;
// borrow the game start fullscreen flag
const bool start_fullscreen =
(s_start_fullscreen_ui_fullscreen || Host::GetBaseBoolSettingValue("Main", "StartFullscreen", false));
Error error;
if (!Host::CreateGPUDevice(Settings::GetRenderAPIForRenderer(g_settings.gpu_renderer), start_fullscreen, &error) ||
!FullscreenUI::Initialize())
if (!GPUThread::StartFullscreenUI(start_fullscreen, &error))
{
Host::ReportErrorAsync("Error", error.GetDescription());
m_run_fullscreen_ui = false;
return;
}
emit fullscreenUIStateChange(true);
// poll more frequently so we don't lose events
stopBackgroundControllerPollTimer();
startBackgroundControllerPollTimer();
}
void EmuThread::stopFullscreenUI()
@ -771,18 +758,8 @@ void EmuThread::stopFullscreenUI()
return;
}
setFullscreen(false, true);
if (m_run_fullscreen_ui)
{
m_run_fullscreen_ui = false;
emit fullscreenUIStateChange(false);
}
if (!g_gpu_device)
return;
Host::ReleaseGPUDevice();
if (m_is_fullscreen_ui_started)
GPUThread::StopFullscreenUI();
}
void EmuThread::bootSystem(std::shared_ptr<SystemBootParameters> params)
@ -889,7 +866,7 @@ void EmuThread::onDisplayWindowMouseWheelEvent(const QPoint& delta_angle)
void EmuThread::onDisplayWindowResized(int width, int height, float scale)
{
Host::ResizeDisplayWindow(width, height, scale);
GPUThread::ResizeDisplayWindow(width, height, scale);
}
void EmuThread::redrawDisplayWindow()
@ -900,10 +877,10 @@ void EmuThread::redrawDisplayWindow()
return;
}
if (!g_gpu_device || System::IsShutdown())
if (System::IsShutdown())
return;
System::InvalidateDisplay();
GPUThread::PresentCurrentFrame();
}
void EmuThread::toggleFullscreen()
@ -931,7 +908,7 @@ void EmuThread::setFullscreen(bool fullscreen, bool allow_render_to_main)
m_is_fullscreen = fullscreen;
m_is_rendering_to_main = allow_render_to_main && shouldRenderToMain();
Host::UpdateDisplayWindow(fullscreen);
GPUThread::UpdateDisplayWindow(fullscreen);
}
bool Host::IsFullscreen()
@ -960,7 +937,7 @@ void EmuThread::setSurfaceless(bool surfaceless)
return;
m_is_surfaceless = surfaceless;
Host::UpdateDisplayWindow(false);
GPUThread::UpdateDisplayWindow(false);
}
void EmuThread::requestDisplaySize(float scale)
@ -1017,6 +994,7 @@ void Host::OnSystemStarting()
void Host::OnSystemStarted()
{
g_emu_thread->stopBackgroundControllerPollTimer();
g_emu_thread->wakeThread();
emit g_emu_thread->systemStarted();
}
@ -1034,6 +1012,7 @@ void Host::OnSystemResumed()
g_emu_thread->setSurfaceless(false);
emit g_emu_thread->systemResumed();
g_emu_thread->wakeThread();
g_emu_thread->stopBackgroundControllerPollTimer();
}
@ -1045,9 +1024,14 @@ void Host::OnSystemDestroyed()
emit g_emu_thread->systemDestroyed();
}
void Host::OnIdleStateChanged()
void Host::OnFullscreenUIStartedOrStopped(bool started)
{
g_emu_thread->wakeThread();
g_emu_thread->setFullscreenUIStarted(started);
}
void Host::OnGPUThreadRunIdleChanged(bool is_active)
{
g_emu_thread->setGPUThreadRunIdle(is_active);
}
void EmuThread::reloadInputSources()
@ -1291,7 +1275,12 @@ void EmuThread::reloadPostProcessingShaders()
}
if (System::IsValid())
{
GPUThread::RunOnThread([]() {
if (GPUThread::HasGPUBackend())
PostProcessing::ReloadShaders();
});
}
}
void EmuThread::updatePostProcessingSettings()
@ -1303,7 +1292,12 @@ void EmuThread::updatePostProcessingSettings()
}
if (System::IsValid())
{
GPUThread::RunOnThread([]() {
if (GPUThread::HasGPUBackend())
PostProcessing::UpdateSettings();
});
}
}
void EmuThread::clearInputBindStateFromSource(InputBindingKey key)
@ -1326,7 +1320,7 @@ void EmuThread::reloadTextureReplacements()
}
if (System::IsValid())
GPUTextureCache::ReloadTextureReplacements(true);
GPUThread::RunOnThread([]() { GPUTextureCache::ReloadTextureReplacements(true); });
}
void EmuThread::captureGPUFrameDump()
@ -1679,6 +1673,7 @@ void Host::DestroyAuxiliaryRenderWindow(AuxiliaryRenderWindowHandle handle, s32*
*height = size.height();
// eat all pending events, to make sure we're not going to write input events back to a dead pointer
if (g_emu_thread->isCurrentThread())
g_emu_thread->getEventLoop()->processEvents(QEventLoop::AllEvents);
}
@ -1699,10 +1694,12 @@ void EmuThread::processAuxiliaryRenderWindowInputEvent(void* userdata, quint32 e
quint32 param3)
{
DebugAssert(isCurrentThread());
GPUThread::RunOnThread([userdata, event, param1, param2, param3]() {
ImGuiManager::ProcessAuxiliaryRenderWindowInputEvent(userdata, static_cast<Host::AuxiliaryRenderWindowEvent>(event),
Host::AuxiliaryRenderWindowEventParam{.uint_param = param1},
Host::AuxiliaryRenderWindowEventParam{.uint_param = param2},
Host::AuxiliaryRenderWindowEventParam{.uint_param = param3});
});
}
void EmuThread::doBackgroundControllerPoll()
@ -1731,7 +1728,7 @@ void EmuThread::startBackgroundControllerPollTimer()
return;
u32 poll_interval = BACKGROUND_CONTROLLER_POLLING_INTERVAL;
if (FullscreenUI::IsInitialized())
if (m_gpu_thread_run_idle)
poll_interval = FULLSCREEN_UI_CONTROLLER_POLLING_INTERVAL;
if (GDBServer::HasAnyClients())
poll_interval = GDB_SERVER_POLLING_INTERVAL;
@ -1747,6 +1744,37 @@ void EmuThread::stopBackgroundControllerPollTimer()
m_background_controller_polling_timer->stop();
}
void EmuThread::setGPUThreadRunIdle(bool active)
{
if (!isCurrentThread())
{
QMetaObject::invokeMethod(this, "setGPUThreadRunIdle", Qt::QueuedConnection, Q_ARG(bool, active));
return;
}
m_gpu_thread_run_idle = active;
// break out of the event loop if we're not executing a system
if (active && !g_settings.gpu_use_thread && !System::IsRunning())
m_event_loop->quit();
// adjust the timer speed to pick up controller input faster
if (!m_background_controller_polling_timer->isActive())
return;
g_emu_thread->stopBackgroundControllerPollTimer();
g_emu_thread->startBackgroundControllerPollTimer();
}
void EmuThread::setFullscreenUIStarted(bool started)
{
if (m_is_fullscreen_ui_started == started)
return;
m_is_fullscreen_ui_started = started;
emit fullscreenUIStartedOrStopped(started);
}
void EmuThread::start()
{
AssertMsg(!g_emu_thread, "Emu thread does not exist");
@ -1776,8 +1804,6 @@ void EmuThread::stopInThread()
void EmuThread::run()
{
Threading::SetNameOfCurrentThread("CPU Thread");
m_event_loop = new QEventLoop();
m_started_semaphore.release();
@ -1796,6 +1822,9 @@ void EmuThread::run()
createBackgroundControllerPollTimer();
startBackgroundControllerPollTimer();
// kick off GPU thread
Threading::Thread gpu_thread(&EmuThread::gpuThreadEntryPoint);
// main loop
while (!m_shutdown_flag)
{
@ -1803,24 +1832,17 @@ void EmuThread::run()
{
System::Execute();
}
else if (!GPUThread::IsUsingThread() && GPUThread::IsRunningIdle())
{
g_emu_thread->getEventLoop()->processEvents(QEventLoop::AllEvents);
// have to double-check the condition after processing events, because the events could shut us down
if (!GPUThread::IsUsingThread() && GPUThread::IsRunningIdle())
GPUThread::Internal::DoRunIdle();
}
else
{
// we want to keep rendering the UI when paused and fullscreen UI is enabled
if (!FullscreenUI::HasActiveWindow() && !System::IsRunning())
{
// wait until we have a system before running
m_event_loop->exec();
continue;
}
m_event_loop->processEvents(QEventLoop::AllEvents);
System::IdlePollUpdate();
if (g_gpu_device && g_gpu_device->HasMainSwapChain())
{
System::PresentDisplay(false, 0);
if (!g_gpu_device->GetMainSwapChain()->IsVSyncModeBlocking())
g_gpu_device->GetMainSwapChain()->ThrottlePresentation();
}
}
}
@ -1828,13 +1850,25 @@ void EmuThread::run()
System::ShutdownSystem(false);
destroyBackgroundControllerPollTimer();
// tell GPU thread to exit
GPUThread::Internal::RequestShutdown();
gpu_thread.Join();
// and tidy up everything left
System::CPUThreadShutdown();
// move back to UI thread
moveToThread(m_ui_thread);
}
void Host::FrameDone()
void EmuThread::gpuThreadEntryPoint()
{
Threading::SetNameOfCurrentThread("GPU Thread");
GPUThread::Internal::GPUThreadEntryPoint();
}
void Host::FrameDoneOnGPUThread(GPUBackend* gpu_backend, u32 frame_number)
{
}
@ -1949,7 +1983,7 @@ void Host::OnInputDeviceConnected(std::string_view identifier, std::string_view
{
emit g_emu_thread->onInputDeviceConnected(std::string(identifier), std::string(device_name));
if (System::IsValid() || g_emu_thread->isRunningFullscreenUI())
if (System::IsValid() || GPUThread::IsFullscreenUIRequested())
{
Host::AddIconOSDMessage(fmt::format("ControllerConnected{}", identifier), ICON_FA_GAMEPAD,
fmt::format(TRANSLATE_FS("QtHost", "Controller {} connected."), identifier),
@ -1975,7 +2009,7 @@ void Host::OnInputDeviceDisconnected(InputBindingKey key, std::string_view ident
Host::AddIconOSDMessage(fmt::format("ControllerConnected{}", identifier), ICON_FA_GAMEPAD, std::move(message),
Host::OSD_WARNING_DURATION);
}
else if (System::IsValid() || g_emu_thread->isRunningFullscreenUI())
else if (System::IsValid() || GPUThread::IsFullscreenUIRequested())
{
Host::AddIconOSDMessage(fmt::format("ControllerConnected{}", identifier), ICON_FA_GAMEPAD,
fmt::format(TRANSLATE_FS("QtHost", "Controller {} disconnected."), identifier),
@ -2037,16 +2071,16 @@ void Host::ReleaseRenderWindow()
g_emu_thread->releaseRenderWindow();
}
void EmuThread::updatePerformanceCounters()
void EmuThread::updatePerformanceCounters(const GPUBackend* gpu_backend)
{
const RenderAPI render_api = g_gpu_device ? g_gpu_device->GetRenderAPI() : RenderAPI::None;
const bool hardware_renderer = g_gpu && g_gpu->IsHardwareRenderer();
const RenderAPI render_api = g_gpu_device->GetRenderAPI();
const bool hardware_renderer = GPUBackend::IsUsingHardwareBackend();
u32 render_width = 0;
u32 render_height = 0;
if (g_gpu)
if (gpu_backend)
{
const u32 render_scale = g_gpu->GetResolutionScale();
const u32 render_scale = gpu_backend->GetResolutionScale();
std::tie(render_width, render_height) = g_gpu->GetFullDisplayResolution();
render_width *= render_scale;
render_height *= render_scale;
@ -2110,9 +2144,9 @@ void EmuThread::resetPerformanceCounters()
Q_ARG(const QString&, blank));
}
void Host::OnPerformanceCountersUpdated()
void Host::OnPerformanceCountersUpdated(const GPUBackend* gpu_backend)
{
g_emu_thread->updatePerformanceCounters();
g_emu_thread->updatePerformanceCounters(gpu_backend);
}
void Host::OnGameChanged(const std::string& disc_path, const std::string& game_serial, const std::string& game_name)
@ -2209,8 +2243,8 @@ std::optional<WindowInfo> Host::GetTopLevelWindowInfo()
EmuThread::SystemLock EmuThread::pauseAndLockSystem()
{
const bool was_fullscreen = System::IsValid() && isFullscreen();
const bool was_paused = System::IsPaused();
const bool was_fullscreen = QtHost::IsSystemValid() && isFullscreen();
const bool was_paused = QtHost::IsSystemPaused();
// We use surfaceless rather than switching out of fullscreen, because
// we're paused, so we're not going to be rendering anyway.

17
src/duckstation-qt/qthost.h
View File

@ -44,6 +44,8 @@ class INISettingsInterface;
enum class RenderAPI : u8;
class GPUDevice;
class GPUBackend;
class MainWindow;
class DisplayWidget;
@ -93,7 +95,6 @@ public:
ALWAYS_INLINE bool isFullscreen() const { return m_is_fullscreen; }
ALWAYS_INLINE bool isRenderingToMain() const { return m_is_rendering_to_main; }
ALWAYS_INLINE bool isSurfaceless() const { return m_is_surfaceless; }
ALWAYS_INLINE bool isRunningFullscreenUI() const { return m_run_fullscreen_ui; }
std::optional<WindowInfo> acquireRenderWindow(RenderAPI render_api, bool fullscreen, bool exclusive_fullscreen,
Error* error);
@ -102,6 +103,7 @@ public:
void startBackgroundControllerPollTimer();
void stopBackgroundControllerPollTimer();
void setFullscreenUIStarted(bool started);
void wakeThread();
bool shouldRenderToMain() const;
@ -109,7 +111,7 @@ public:
void bootOrLoadState(std::string path);
void updatePerformanceCounters();
void updatePerformanceCounters(const GPUBackend* gpu_backend);
void resetPerformanceCounters();
/// Locks the system by pausing it, while a popup dialog is displayed.
@ -147,7 +149,7 @@ Q_SIGNALS:
void runningGameChanged(const QString& filename, const QString& game_serial, const QString& game_title);
void inputProfileLoaded();
void mouseModeRequested(bool relative, bool hide_cursor);
void fullscreenUIStateChange(bool running);
void fullscreenUIStartedOrStopped(bool running);
void achievementsLoginRequested(Achievements::LoginRequestReason reason);
void achievementsRefreshed(quint32 id, const QString& game_info_string);
void achievementsChallengeModeChanged(bool enabled);
@ -210,6 +212,7 @@ public Q_SLOTS:
void clearInputBindStateFromSource(InputBindingKey key);
void reloadTextureReplacements();
void captureGPUFrameDump();
void setGPUThreadRunIdle(bool active);
private Q_SLOTS:
void stopInThread();
@ -227,23 +230,23 @@ protected:
void run() override;
private:
using InputButtonHandler = std::function<void(bool)>;
using InputAxisHandler = std::function<void(float)>;
void createBackgroundControllerPollTimer();
void destroyBackgroundControllerPollTimer();
void confirmActionIfMemoryCardBusy(const QString& action, bool cancel_resume_on_accept,
std::function<void(bool)> callback) const;
static void gpuThreadEntryPoint();
QThread* m_ui_thread;
QSemaphore m_started_semaphore;
QEventLoop* m_event_loop = nullptr;
QTimer* m_background_controller_polling_timer = nullptr;
bool m_shutdown_flag = false;
bool m_run_fullscreen_ui = false;
bool m_is_rendering_to_main = false;
bool m_is_fullscreen = false;
bool m_is_fullscreen_ui_started = false;
bool m_gpu_thread_run_idle = false;
bool m_is_surfaceless = false;
bool m_save_state_on_shutdown = false;

37
src/duckstation-regtest/regtest_host.cpp
View File

@ -5,7 +5,8 @@
#include "core/controller.h"
#include "core/fullscreen_ui.h"
#include "core/game_list.h"
#include "core/gpu.h"
#include "core/gpu_backend.h"
#include "core/gpu_thread.h"
#include "core/host.h"
#include "core/system.h"
#include "core/system_private.h"
@ -46,9 +47,11 @@ static void HookSignals();
static bool SetFolders();
static bool SetNewDataRoot(const std::string& filename);
static std::string GetFrameDumpFilename(u32 frame);
static void GPUThreadEntryPoint();
} // namespace RegTestHost
static std::unique_ptr<MemorySettingsInterface> s_base_settings_interface;
static Threading::Thread s_gpu_thread;
static u32 s_frames_to_run = 60 * 60;
static u32 s_frames_remaining = 0;
@ -281,12 +284,17 @@ void Host::OnSystemResumed()
//
}
void Host::OnIdleStateChanged()
void Host::OnGPUThreadRunIdleChanged(bool is_active)
{
//
}
void Host::OnPerformanceCountersUpdated()
void Host::OnFullscreenUIStartedOrStopped(bool started)
{
//
}
void Host::OnPerformanceCountersUpdated(const GPUBackend* gpu_backend)
{
//
}
@ -375,14 +383,10 @@ void Host::DestroyAuxiliaryRenderWindow(AuxiliaryRenderWindowHandle handle, s32*
{
}
void Host::FrameDone()
void Host::FrameDoneOnGPUThread(GPUBackend* gpu_backend, u32 frame_number)
{
const u32 frame = System::GetFrameNumber();
if (s_frame_dump_interval > 0 && (s_frame_dump_interval == 1 || (frame % s_frame_dump_interval) == 0))
{
std::string dump_filename(RegTestHost::GetFrameDumpFilename(frame));
g_gpu->WriteDisplayTextureToFile(std::move(dump_filename));
}
if (s_frame_dump_interval > 0 && (s_frame_dump_interval == 1 || (frame_number % s_frame_dump_interval) == 0))
gpu_backend->WriteDisplayTextureToFile(RegTestHost::GetFrameDumpFilename(frame_number));
}
void Host::OpenURL(std::string_view url)
@ -508,6 +512,12 @@ void RegTestHost::HookSignals()
std::signal(SIGTERM, SignalHandler);
}
void RegTestHost::GPUThreadEntryPoint()
{
Threading::SetNameOfCurrentThread("CPU Thread");
GPUThread::Internal::GPUThreadEntryPoint();
}
void RegTestHost::InitializeEarlyConsole()
{
const bool was_console_enabled = Log::IsConsoleOutputEnabled();
@ -773,6 +783,7 @@ int main(int argc, char* argv[])
}
RegTestHost::HookSignals();
s_gpu_thread.Start(&RegTestHost::GPUThreadEntryPoint);
Error error;
int result = -1;
@ -813,6 +824,12 @@ int main(int argc, char* argv[])
result = 0;
cleanup:
if (s_gpu_thread.Joinable())
{
GPUThread::Internal::RequestShutdown();
s_gpu_thread.Join();
}
System::CPUThreadShutdown();
System::ProcessShutdown();
return result;

11
src/util/gpu_device.cpp
View File

@ -385,6 +385,17 @@ const char* GPUDevice::ShaderLanguageToString(GPUShaderLanguage language)
}
}
const char* GPUDevice::VSyncModeToString(GPUVSyncMode mode)
{
static constexpr std::array<const char*, static_cast<size_t>(GPUVSyncMode::Count)> vsync_modes = {{
"Disabled",
"FIFO",
"Mailbox",
}};
return vsync_modes[static_cast<size_t>(mode)];
}
bool GPUDevice::IsSameRenderAPI(RenderAPI lhs, RenderAPI rhs)
{
return (lhs == rhs || ((lhs == RenderAPI::OpenGL || lhs == RenderAPI::OpenGLES) &&

3
src/util/gpu_device.h
View File

@ -657,6 +657,9 @@ public:
/// Returns a string representing the specified language.
static const char* ShaderLanguageToString(GPUShaderLanguage language);
/// Returns a string representing the specified vsync mode.
static const char* VSyncModeToString(GPUVSyncMode mode);
/// Returns a new device for the specified API.
static std::unique_ptr<GPUDevice> CreateDeviceForAPI(RenderAPI api);

148
src/util/imgui_fullscreen.cpp
View File

@ -52,6 +52,8 @@ static void DrawChoiceDialog();
static void DrawInputDialog();
static void DrawMessageDialog();
static void DrawBackgroundProgressDialogs(ImVec2& position, float spacing);
static void DrawLoadingScreen(std::string_view image, std::string_view message, s32 progress_min, s32 progress_max,
s32 progress_value, bool is_persistent);
static void DrawNotifications(ImVec2& position, float spacing);
static void DrawToast();
static bool MenuButtonFrame(const char* str_id, bool enabled, float height, bool* visible, bool* hovered, ImRect* bb,
@ -171,6 +173,13 @@ struct ALIGN_TO_CACHE_LINE UIState
std::vector<BackgroundProgressDialogData> background_progress_dialogs;
std::mutex background_progress_lock;
std::string loading_screen_image;
std::string loading_screen_message;
s32 loading_screen_min = 0;
s32 loading_screen_max = 0;
s32 loading_screen_value = 0;
bool loading_screen_open = false;
};
} // namespace
@ -2916,6 +2925,145 @@ void ImGuiFullscreen::DrawBackgroundProgressDialogs(ImVec2& position, float spac
ImGui::PopStyleColor(2);
}
void ImGuiFullscreen::RenderLoadingScreen(std::string_view image, std::string_view message, s32 progress_min /*= -1*/,
s32 progress_max /*= -1*/, s32 progress_value /*= -1*/)
{
if (progress_min < progress_max)
INFO_LOG("{}: {}/{}", message, progress_value, progress_max);
if (!g_gpu_device || !g_gpu_device->HasMainSwapChain())
return;
// eat the last imgui frame, it might've been partially rendered by the caller.
ImGui::EndFrame();
ImGui::NewFrame();
DrawLoadingScreen(image, message, progress_min, progress_max, progress_value, false);
ImGui::EndFrame();
GPUSwapChain* swap_chain = g_gpu_device->GetMainSwapChain();
if (g_gpu_device->BeginPresent(swap_chain) == GPUDevice::PresentResult::OK)
{
g_gpu_device->RenderImGui(swap_chain);
g_gpu_device->EndPresent(swap_chain, false);
}
ImGui::NewFrame();
}
void ImGuiFullscreen::OpenOrUpdateLoadingScreen(std::string_view image, std::string_view message,
s32 progress_min /*= -1*/, s32 progress_max /*= -1*/,
s32 progress_value /*= -1*/)
{
if (s_state.loading_screen_image != image)
s_state.loading_screen_image = image;
if (s_state.loading_screen_message != message)
s_state.loading_screen_message = message;
s_state.loading_screen_min = progress_min;
s_state.loading_screen_max = progress_max;
s_state.loading_screen_value = progress_value;
s_state.loading_screen_open = true;
}
bool ImGuiFullscreen::IsLoadingScreenOpen()
{
return s_state.loading_screen_open;
}
void ImGuiFullscreen::RenderLoadingScreen()
{
if (!s_state.loading_screen_open)
return;
DrawLoadingScreen(s_state.loading_screen_image, s_state.loading_screen_message, s_state.loading_screen_min,
s_state.loading_screen_max, s_state.loading_screen_value, true);
}
void ImGuiFullscreen::CloseLoadingScreen()
{
s_state.loading_screen_image = {};
s_state.loading_screen_message = {};
s_state.loading_screen_min = 0;
s_state.loading_screen_max = 0;
s_state.loading_screen_value = 0;
s_state.loading_screen_open = false;
}
void ImGuiFullscreen::DrawLoadingScreen(std::string_view image, std::string_view message, s32 progress_min,
s32 progress_max, s32 progress_value, bool is_persistent)
{
const auto& io = ImGui::GetIO();
const float scale = ImGuiManager::GetGlobalScale();
const float width = (400.0f * scale);
const bool has_progress = (progress_min < progress_max);
const float logo_width = 260.0f * scale;
const float logo_height = 260.0f * scale;
ImGui::SetNextWindowSize(ImVec2(logo_width, logo_height), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) - (50.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.5f));
if (ImGui::Begin("LoadingScreenLogo", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing |
ImGuiWindowFlags_NoBackground))
{
GPUTexture* tex = GetCachedTexture(image);
if (tex)
ImGui::Image(tex, ImVec2(logo_width, logo_height));
}
ImGui::End();
const float padding_and_rounding = 18.0f * scale;
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, padding_and_rounding);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(padding_and_rounding, padding_and_rounding));
ImGui::SetNextWindowSize(ImVec2(width, ((has_progress || is_persistent) ? 90.0f : 55.0f) * scale), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(io.DisplaySize.x * 0.5f, (io.DisplaySize.y * 0.5f) + (100.0f * scale)),
ImGuiCond_Always, ImVec2(0.5f, 0.0f));
if (ImGui::Begin("LoadingScreen", nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing))
{
if (has_progress || is_persistent)
{
if (!message.empty())
ImGui::TextUnformatted(message.data(), message.data() + message.size());
if (has_progress)
{
TinyString buf;
buf.format("{}/{}", progress_value, progress_max);
const ImVec2 prog_size = ImGui::CalcTextSize(buf.c_str(), buf.end_ptr());
ImGui::SameLine();
ImGui::SetCursorPosX(width - padding_and_rounding - prog_size.x);
ImGui::TextUnformatted(buf.c_str(), buf.end_ptr());
}
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 5.0f);
ImGui::ProgressBar(has_progress ?
(static_cast<float>(progress_value) / static_cast<float>(progress_max - progress_min)) :
static_cast<float>(-ImGui::GetTime()),
ImVec2(-1.0f, 0.0f), "");
}
else
{
if (!message.empty())
{
const ImVec2 text_size(ImGui::CalcTextSize(message.data(), message.data() + message.size()));
ImGui::SetCursorPosX((width - text_size.x) / 2.0f);
ImGui::TextUnformatted(message.data(), message.data() + message.size());
}
}
}
ImGui::End();
ImGui::PopStyleVar(2);
}
//////////////////////////////////////////////////////////////////////////
// Notifications
//////////////////////////////////////////////////////////////////////////

12
src/util/imgui_fullscreen.h
View File

@ -327,6 +327,18 @@ void UpdateBackgroundProgressDialog(const char* str_id, std::string message, s32
void CloseBackgroundProgressDialog(const char* str_id);
bool IsBackgroundProgressDialogOpen(const char* str_id);
/// Displays a loading screen with the logo, rendered with ImGui. Use when executing possibly-time-consuming tasks
/// such as compiling shaders when starting up.
void RenderLoadingScreen(std::string_view image, std::string_view message, s32 progress_min = -1, s32 progress_max = -1,
s32 progress_value = -1);
void OpenOrUpdateLoadingScreen(std::string_view image, std::string_view message, s32 progress_min = -1,
s32 progress_max = -1, s32 progress_value = -1);
bool IsLoadingScreenOpen();
void CloseLoadingScreen();
/// Renders a previously-configured loading screen.
void RenderLoadingScreen();
void AddNotification(std::string key, float duration, std::string title, std::string text, std::string image_path);
void ClearNotifications();

6
src/util/postprocessing.cpp
View File

@ -12,7 +12,7 @@
// TODO: Remove me
#include "core/host.h"
#include "core/host_interface_progress_callback.h"
#include "core/fullscreen_ui.h"
#include "core/settings.h"
#include "IconsFontAwesome5.h"
@ -406,7 +406,7 @@ void PostProcessing::Chain::LoadStages()
return;
Error error;
HostInterfaceProgressCallback progress;
LoadingScreenProgressCallback progress;
progress.SetProgressRange(stage_count);
for (u32 i = 0; i < stage_count; i++)
@ -476,7 +476,7 @@ void PostProcessing::Chain::UpdateSettings(std::unique_lock<std::mutex>& setting
m_stages.resize(stage_count);
HostInterfaceProgressCallback progress;
LoadingScreenProgressCallback progress;
progress.SetProgressRange(stage_count);
const GPUTexture::Format prev_format = m_target_format;

3
src/util/postprocessing_shader_fx.cpp
View File

@ -7,6 +7,7 @@
#include "shadergen.h"
// TODO: Remove me
#include "core/gpu_thread.h"
#include "core/host.h"
#include "core/settings.h"
@ -72,7 +73,7 @@ static std::tuple<std::unique_ptr<reshadefx::codegen>, GPUShaderLanguage> Create
}
// Should have a GPU device and be on the GPU thread.
Assert(g_gpu_device);
Assert(GPUThread::IsOnThread() && g_gpu_device);
const bool debug_info = g_gpu_device->IsDebugDevice();
const RenderAPI rapi = g_gpu_device->GetRenderAPI();

2
src/util/state_wrapper.h
View File

@ -34,6 +34,8 @@ public:
ALWAYS_INLINE bool IsReading() const { return (m_mode == Mode::Read); }
ALWAYS_INLINE bool IsWriting() const { return (m_mode == Mode::Write); }
ALWAYS_INLINE u32 GetVersion() const { return m_version; }
ALWAYS_INLINE const u8* GetData() const { return m_data; }
ALWAYS_INLINE size_t GetDataSize() const { return m_size; }
ALWAYS_INLINE size_t GetPosition() const { return m_pos; }
ALWAYS_INLINE void SetPosition(size_t pos) { m_pos = pos; }