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

Settings: Force Frame Timings => Force Video Timing 

Also drop from GameDB, an override doesn't make sense here anyway,
due to the low success rate with the enhancement.
This commit is contained in:
Stenzek 2024-09-03 19:06:26 +10:00
parent 3030b0e067
commit d561348d2e
No known key found for this signature in database
12 changed files with 97 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/core/fullscreen_ui.cpp
View File

@ -4270,11 +4270,11 @@ void FullscreenUI::DrawDisplaySettingsPage()
"Display", "Scaling", Settings::DEFAULT_DISPLAY_SCALING, &Settings::ParseDisplayScaling,
&Settings::GetDisplayScalingName, &Settings::GetDisplayScalingDisplayName, DisplayScalingMode::Count);
DrawEnumSetting(
bsi, FSUI_CSTR("Force Frame Timings"),
FSUI_CSTR("Utilizes the chosen frame timing regardless of the active region."),
"GPU", "ForceFrameTimings", Settings::DEFAULT_FORCE_FRAME_TIMINGS_MODE, &Settings::ParseForceFrameTimings,
&Settings::GetForceFrameTimingsName, &Settings::GetForceFrameTimingsDisplayName, ForceFrameTimingsMode::Count);
DrawEnumSetting(bsi, FSUI_CSTR("Force Video Timing"),
FSUI_CSTR("Utilizes the chosen video timing regardless of the game's setting."), "GPU",
"ForceVideoTiming", Settings::DEFAULT_FORCE_VIDEO_TIMING_MODE, &Settings::ParseForceVideoTimingName,
&Settings::GetForceVideoTimingName, &Settings::GetForceVideoTimingDisplayName,
ForceVideoTimingMode::Count);
if (is_hardware)
{
@ -5693,7 +5693,6 @@ void FullscreenUI::DrawSaveStateSelector(bool is_loading)
if (IsFocusResetFromWindowChange())
ImGui::SetNextWindowScroll(ImVec2(0.0f, 0.0f));
if (ImGui::BeginChild("state_list",
ImVec2(io.DisplaySize.x, io.DisplaySize.y - LayoutScale(LAYOUT_FOOTER_HEIGHT) - heading_size.y),
false, ImGuiWindowFlags_NavFlattened))
@ -7427,8 +7426,7 @@ TRANSLATE_NOOP("FullscreenUI", "File Size");
TRANSLATE_NOOP("FullscreenUI", "File Size: %.2f MB");
TRANSLATE_NOOP("FullscreenUI", "File Title");
TRANSLATE_NOOP("FullscreenUI", "Force 4:3 For FMVs");
TRANSLATE_NOOP("FullscreenUI", "Force NTSC Timings");
TRANSLATE_NOOP("FullscreenUI", "Forces PAL games to run at NTSC timings, i.e. 60hz. Some PAL games will run at their \"normal\" speeds, while others will break.");
TRANSLATE_NOOP("FullscreenUI", "Force Video Timing");
TRANSLATE_NOOP("FullscreenUI", "Forces a full rescan of all games previously identified.");
TRANSLATE_NOOP("FullscreenUI", "Forces blending to be done in the shader at 16-bit precision, when not using true color. Non-trivial performance impact, and unnecessary for most games.");
TRANSLATE_NOOP("FullscreenUI", "Forces the use of FIFO over Mailbox presentation, i.e. double buffering instead of triple buffering. Usually results in worse frame pacing.");
@ -7802,7 +7800,9 @@ TRANSLATE_NOOP("FullscreenUI", "Uses native resolution coordinates for 2D polygo
TRANSLATE_NOOP("FullscreenUI", "Uses perspective-correct interpolation for colors, which can improve visuals in some games.");
TRANSLATE_NOOP("FullscreenUI", "Uses perspective-correct interpolation for texture coordinates, straightening out warped textures.");
TRANSLATE_NOOP("FullscreenUI", "Uses screen positions to resolve PGXP data. May improve visuals in some games.");
TRANSLATE_NOOP("FullscreenUI", "Utilizes the chosen video timing regardless of the game's setting.");
TRANSLATE_NOOP("FullscreenUI", "Value: {} | Default: {} | Minimum: {} | Maximum: {}");
TRANSLATE_NOOP("FullscreenUI", "Version: %s");
TRANSLATE_NOOP("FullscreenUI", "Vertex Cache");
TRANSLATE_NOOP("FullscreenUI", "Vertical Sync (VSync)");
TRANSLATE_NOOP("FullscreenUI", "WARNING: Your game is still saving to the memory card. Continuing to {0} may IRREVERSIBLY DESTROY YOUR MEMORY CARD. We recommend resuming your game and waiting 5 seconds for it to finish saving.\n\nDo you want to {0} anyway?");
@ -7829,6 +7829,5 @@ TRANSLATE_NOOP("FullscreenUI", "{} Frames");
TRANSLATE_NOOP("FullscreenUI", "{} deleted.");
TRANSLATE_NOOP("FullscreenUI", "{} does not exist.");
TRANSLATE_NOOP("FullscreenUI", "{} is not a valid disc image.");
TRANSLATE_NOOP("FullscreenUI", "Version: %s");
// TRANSLATION-STRING-AREA-END
#endif

12
src/core/game_database.cpp
View File

@ -38,7 +38,7 @@ namespace GameDatabase {
enum : u32
{
GAME_DATABASE_CACHE_SIGNATURE = 0x45434C48,
GAME_DATABASE_CACHE_VERSION = 14,
GAME_DATABASE_CACHE_VERSION = 15,
};
static Entry* GetMutableEntry(std::string_view serial);
@ -76,7 +76,6 @@ static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Tr
"DisableTextureFiltering",
"DisableSpriteTextureFiltering",
"DisableScaledDithering",
"DisableForceFrameTimings",
"DisableWidescreen",
"DisablePGXP",
"DisablePGXPCulling",
@ -106,7 +105,6 @@ static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Tr
TRANSLATE_NOOP("GameDatabase", "Disable Texture Filtering"),
TRANSLATE_NOOP("GameDatabase", "Disable Sprite Texture Filtering"),
TRANSLATE_NOOP("GameDatabase", "Disable Scaled Dithering"),
TRANSLATE_NOOP("GameDatabase", "Disable Force Frame Timings"),
TRANSLATE_NOOP("GameDatabase", "Disable Widescreen"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP"),
TRANSLATE_NOOP("GameDatabase", "Disable PGXP Culling"),
@ -591,14 +589,6 @@ void GameDatabase::Entry::ApplySettings(Settings& settings, bool display_osd_mes
settings.gpu_widescreen_hack = false;
}
if (HasTrait(Trait::DisableForceFrameTimings))
{
if (display_osd_messages && settings.gpu_force_frame_timings != ForceFrameTimingsMode::Disabled)
APPEND_MESSAGE(TRANSLATE_SV("GameDatabase", "Force frame timings disabled."));
settings.gpu_force_frame_timings = ForceFrameTimingsMode::Disabled;
}
if (HasTrait(Trait::DisablePGXP))
{
if (display_osd_messages && settings.gpu_pgxp_enable)

1
src/core/game_database.h
View File

@ -40,7 +40,6 @@ enum class Trait : u32
DisableTextureFiltering,
DisableSpriteTextureFiltering,
DisableScaledDithering,
DisableForceFrameTimings,
DisableWidescreen,
DisablePGXP,
DisablePGXPCulling,

10
src/core/gpu.cpp
View File

@ -88,7 +88,7 @@ GPU::~GPU()
bool GPU::Initialize()
{
m_force_progressive_scan = g_settings.gpu_disable_interlacing;
m_force_frame_timings = g_settings.gpu_force_frame_timings;
m_force_frame_timings = g_settings.gpu_force_video_timing;
s_crtc_tick_event.Activate();
m_fifo_size = g_settings.gpu_fifo_size;
m_max_run_ahead = g_settings.gpu_max_run_ahead;
@ -119,9 +119,9 @@ void GPU::UpdateSettings(const Settings& old_settings)
m_fifo_size = g_settings.gpu_fifo_size;
m_max_run_ahead = g_settings.gpu_max_run_ahead;
if (m_force_frame_timings != g_settings.gpu_force_frame_timings)
if (m_force_frame_timings != g_settings.gpu_force_video_timing)
{
m_force_frame_timings = g_settings.gpu_force_frame_timings;
m_force_frame_timings = g_settings.gpu_force_video_timing;
m_console_is_pal = System::IsPALRegion();
UpdateCRTCConfig();
}
@ -637,7 +637,7 @@ void GPU::UpdateCRTCConfig()
cs.vertical_display_start = std::min<u16>(cs.regs.Y1, cs.vertical_total);
cs.vertical_display_end = std::min<u16>(cs.regs.Y2, cs.vertical_total);
if (m_GPUSTAT.pal_mode && m_force_frame_timings == ForceFrameTimingsMode::NTSC)
if (m_GPUSTAT.pal_mode && m_force_frame_timings == ForceVideoTimingMode::NTSC)
{
// scale to NTSC parameters
cs.horizontal_display_start =
@ -655,7 +655,7 @@ void GPU::UpdateCRTCConfig()
cs.horizontal_total = NTSC_TICKS_PER_LINE;
cs.current_tick_in_scanline %= NTSC_TICKS_PER_LINE;
}
else if (!m_GPUSTAT.pal_mode && m_force_frame_timings == ForceFrameTimingsMode::PAL)
else if (!m_GPUSTAT.pal_mode && m_force_frame_timings == ForceVideoTimingMode::PAL)
{
// scale to PAL parameters
cs.horizontal_display_start =

2
src/core/gpu.h
View File

@ -505,7 +505,7 @@ protected:
bool m_set_texture_disable_mask = false;
bool m_drawing_area_changed = false;
bool m_force_progressive_scan = false;
ForceFrameTimingsMode m_force_frame_timings = ForceFrameTimingsMode::Disabled;
ForceVideoTimingMode m_force_frame_timings = ForceVideoTimingMode::Disabled;
struct CRTCState
{

4
src/core/imgui_overlays.cpp
View File

@ -444,9 +444,9 @@ void ImGuiManager::DrawEnhancementsOverlay()
}
if (g_settings.gpu_disable_interlacing)
text.append(" ForceProg");
if (g_settings.gpu_force_frame_timings == ForceFrameTimingsMode::NTSC && System::GetRegion() == ConsoleRegion::PAL)
if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::NTSC && System::GetRegion() == ConsoleRegion::PAL)
text.append(" PAL60");
if (g_settings.gpu_force_frame_timings == ForceFrameTimingsMode::PAL && System::GetRegion() != ConsoleRegion::PAL)
if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::PAL && System::GetRegion() != ConsoleRegion::PAL)
text.append(" NTSC50");
if (g_settings.gpu_texture_filter != GPUTextureFilter::Nearest)
{

108
src/core/settings.cpp
View File

@ -231,10 +231,10 @@ void Settings::Load(SettingsInterface& si, SettingsInterface& controller_si)
si.GetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(DEFAULT_GPU_WIREFRAME_MODE)).c_str())
.value_or(DEFAULT_GPU_WIREFRAME_MODE);
gpu_disable_interlacing = si.GetBoolValue("GPU", "DisableInterlacing", true);
gpu_force_frame_timings =
ParseForceFrameTimings(
si.GetStringValue("GPU", "ForceFrameTimings", GetForceFrameTimingsName(DEFAULT_FORCE_FRAME_TIMINGS_MODE)).c_str())
.value_or(DEFAULT_FORCE_FRAME_TIMINGS_MODE);
gpu_force_video_timing =
ParseForceVideoTimingName(
si.GetStringValue("GPU", "ForceVideoTiming", GetForceVideoTimingName(DEFAULT_FORCE_VIDEO_TIMING_MODE)).c_str())
.value_or(DEFAULT_FORCE_VIDEO_TIMING_MODE);
gpu_widescreen_hack = si.GetBoolValue("GPU", "WidescreenHack", false);
display_24bit_chroma_smoothing = si.GetBoolValue("GPU", "ChromaSmoothing24Bit", false);
gpu_pgxp_enable = si.GetBoolValue("GPU", "PGXPEnable", false);
@ -540,7 +540,7 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
si.SetUIntValue("GPU", "DownsampleScale", gpu_downsample_scale);
si.SetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(gpu_wireframe_mode));
si.SetBoolValue("GPU", "DisableInterlacing", gpu_disable_interlacing);
si.SetStringValue("GPU", "ForceFrameTimings", GetForceFrameTimingsName(gpu_force_frame_timings));
si.SetStringValue("GPU", "ForceVideoTiming", GetForceVideoTimingName(gpu_force_video_timing));
si.SetBoolValue("GPU", "WidescreenHack", gpu_widescreen_hack);
si.SetBoolValue("GPU", "ChromaSmoothing24Bit", display_24bit_chroma_smoothing);
si.SetBoolValue("GPU", "PGXPEnable", gpu_pgxp_enable);
@ -749,7 +749,7 @@ void Settings::FixIncompatibleSettings(bool display_osd_messages)
g_settings.gpu_sprite_texture_filter = GPUTextureFilter::Nearest;
g_settings.gpu_line_detect_mode = GPULineDetectMode::Disabled;
g_settings.gpu_disable_interlacing = false;
g_settings.gpu_force_frame_timings = ForceFrameTimingsMode::Disabled;
g_settings.gpu_force_video_timing = ForceVideoTimingMode::Disabled;
g_settings.gpu_widescreen_hack = false;
g_settings.gpu_pgxp_enable = false;
g_settings.display_24bit_chroma_smoothing = false;
@ -933,12 +933,12 @@ std::optional<LOGLEVEL> Settings::ParseLogLevelName(const char* str)
const char* Settings::GetLogLevelName(LOGLEVEL level)
{
return s_log_level_names[static_cast<int>(level)];
return s_log_level_names[static_cast<size_t>(level)];
}
const char* Settings::GetLogLevelDisplayName(LOGLEVEL level)
{
return Host::TranslateToCString("LogLevel", s_log_level_display_names[static_cast<int>(level)]);
return Host::TranslateToCString("LogLevel", s_log_level_display_names[static_cast<size_t>(level)]);
}
static constexpr const std::array s_console_region_names = {"Auto", "NTSC-J", "NTSC-U", "PAL"};
@ -962,12 +962,12 @@ std::optional<ConsoleRegion> Settings::ParseConsoleRegionName(const char* str)
const char* Settings::GetConsoleRegionName(ConsoleRegion region)
{
return s_console_region_names[static_cast<int>(region)];
return s_console_region_names[static_cast<size_t>(region)];
}
const char* Settings::GetConsoleRegionDisplayName(ConsoleRegion region)
{
return Host::TranslateToCString("ConsoleRegion", s_console_region_display_names[static_cast<int>(region)]);
return Host::TranslateToCString("ConsoleRegion", s_console_region_display_names[static_cast<size_t>(region)]);
}
static constexpr const std::array s_disc_region_names = {"NTSC-J", "NTSC-U", "PAL", "Other", "Non-PS1"};
@ -992,12 +992,12 @@ std::optional<DiscRegion> Settings::ParseDiscRegionName(const char* str)
const char* Settings::GetDiscRegionName(DiscRegion region)
{
return s_disc_region_names[static_cast<int>(region)];
return s_disc_region_names[static_cast<size_t>(region)];
}
const char* Settings::GetDiscRegionDisplayName(DiscRegion region)
{
return Host::TranslateToCString("DiscRegion", s_disc_region_display_names[static_cast<int>(region)]);
return Host::TranslateToCString("DiscRegion", s_disc_region_display_names[static_cast<size_t>(region)]);
}
static constexpr const std::array s_cpu_execution_mode_names = {"Interpreter", "CachedInterpreter", "Recompiler",
@ -1111,12 +1111,12 @@ std::optional<GPURenderer> Settings::ParseRendererName(const char* str)
const char* Settings::GetRendererName(GPURenderer renderer)
{
return s_gpu_renderer_names[static_cast<int>(renderer)];
return s_gpu_renderer_names[static_cast<size_t>(renderer)];
}
const char* Settings::GetRendererDisplayName(GPURenderer renderer)
{
return Host::TranslateToCString("GPURenderer", s_gpu_renderer_display_names[static_cast<int>(renderer)]);
return Host::TranslateToCString("GPURenderer", s_gpu_renderer_display_names[static_cast<size_t>(renderer)]);
}
RenderAPI Settings::GetRenderAPIForRenderer(GPURenderer renderer)
@ -1219,7 +1219,7 @@ const char* Settings::GetTextureFilterName(GPUTextureFilter filter)
const char* Settings::GetTextureFilterDisplayName(GPUTextureFilter filter)
{
return Host::TranslateToCString("GPUTextureFilter", s_texture_filter_display_names[static_cast<int>(filter)]);
return Host::TranslateToCString("GPUTextureFilter", s_texture_filter_display_names[static_cast<size_t>(filter)]);
}
static constexpr const std::array s_line_detect_mode_names = {
@ -1281,12 +1281,12 @@ std::optional<GPUDownsampleMode> Settings::ParseDownsampleModeName(const char* s
const char* Settings::GetDownsampleModeName(GPUDownsampleMode mode)
{
return s_downsample_mode_names[static_cast<int>(mode)];
return s_downsample_mode_names[static_cast<size_t>(mode)];
}
const char* Settings::GetDownsampleModeDisplayName(GPUDownsampleMode mode)
{
return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<int>(mode)]);
return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_wireframe_mode_names = {"Disabled", "OverlayWireframe", "OnlyWireframe"};
@ -1310,12 +1310,12 @@ std::optional<GPUWireframeMode> Settings::ParseGPUWireframeMode(const char* str)
const char* Settings::GetGPUWireframeModeName(GPUWireframeMode mode)
{
return s_wireframe_mode_names[static_cast<int>(mode)];
return s_wireframe_mode_names[static_cast<size_t>(mode)];
}
const char* Settings::GetGPUWireframeModeDisplayName(GPUWireframeMode mode)
{
return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<int>(mode)]);
return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_display_deinterlacing_mode_names = {
@ -1347,13 +1347,13 @@ std::optional<DisplayDeinterlacingMode> Settings::ParseDisplayDeinterlacingMode(
const char* Settings::GetDisplayDeinterlacingModeName(DisplayDeinterlacingMode mode)
{
return s_display_deinterlacing_mode_names[static_cast<int>(mode)];
return s_display_deinterlacing_mode_names[static_cast<size_t>(mode)];
}
const char* Settings::GetDisplayDeinterlacingModeDisplayName(DisplayDeinterlacingMode mode)
{
return Host::TranslateToCString("DisplayDeinterlacingMode",
s_display_deinterlacing_mode_display_names[static_cast<int>(mode)]);
s_display_deinterlacing_mode_display_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_display_crop_mode_names = {"None", "Overscan", "Borders"};
@ -1377,12 +1377,12 @@ std::optional<DisplayCropMode> Settings::ParseDisplayCropMode(const char* str)
const char* Settings::GetDisplayCropModeName(DisplayCropMode crop_mode)
{
return s_display_crop_mode_names[static_cast<int>(crop_mode)];
return s_display_crop_mode_names[static_cast<size_t>(crop_mode)];
}
const char* Settings::GetDisplayCropModeDisplayName(DisplayCropMode crop_mode)
{
return Host::TranslateToCString("DisplayCropMode", s_display_crop_mode_display_names[static_cast<int>(crop_mode)]);
return Host::TranslateToCString("DisplayCropMode", s_display_crop_mode_display_names[static_cast<size_t>(crop_mode)]);
}
static constexpr const std::array s_display_aspect_ratio_names = {
@ -1419,12 +1419,12 @@ std::optional<DisplayAspectRatio> Settings::ParseDisplayAspectRatio(const char*
const char* Settings::GetDisplayAspectRatioName(DisplayAspectRatio ar)
{
return s_display_aspect_ratio_names[static_cast<int>(ar)];
return s_display_aspect_ratio_names[static_cast<size_t>(ar)];
}
const char* Settings::GetDisplayAspectRatioDisplayName(DisplayAspectRatio ar)
{
return Host::TranslateToCString("DisplayAspectRatio", s_display_aspect_ratio_names[static_cast<int>(ar)]);
return Host::TranslateToCString("DisplayAspectRatio", s_display_aspect_ratio_names[static_cast<size_t>(ar)]);
}
float Settings::GetDisplayAspectRatioValue() const
@ -1434,7 +1434,7 @@ float Settings::GetDisplayAspectRatioValue() const
case DisplayAspectRatio::MatchWindow:
{
if (!g_gpu_device)
return s_display_aspect_ratio_values[static_cast<int>(DEFAULT_DISPLAY_ASPECT_RATIO)];
return s_display_aspect_ratio_values[static_cast<size_t>(DEFAULT_DISPLAY_ASPECT_RATIO)];
return static_cast<float>(g_gpu_device->GetWindowWidth()) / static_cast<float>(g_gpu_device->GetWindowHeight());
}
@ -1447,7 +1447,7 @@ float Settings::GetDisplayAspectRatioValue() const
default:
{
return s_display_aspect_ratio_values[static_cast<int>(display_aspect_ratio)];
return s_display_aspect_ratio_values[static_cast<size_t>(display_aspect_ratio)];
}
}
}
@ -1473,12 +1473,13 @@ std::optional<DisplayAlignment> Settings::ParseDisplayAlignment(const char* str)
const char* Settings::GetDisplayAlignmentName(DisplayAlignment alignment)
{
return s_display_alignment_names[static_cast<int>(alignment)];
return s_display_alignment_names[static_cast<size_t>(alignment)];
}
const char* Settings::GetDisplayAlignmentDisplayName(DisplayAlignment alignment)
{
return Host::TranslateToCString("DisplayAlignment", s_display_alignment_display_names[static_cast<int>(alignment)]);
return Host::TranslateToCString("DisplayAlignment",
s_display_alignment_display_names[static_cast<size_t>(alignment)]);
}
static constexpr const std::array s_display_rotation_names = {"Normal", "Rotate90", "Rotate180", "Rotate270"};
@ -1505,29 +1506,44 @@ std::optional<DisplayRotation> Settings::ParseDisplayRotation(const char* str)
const char* Settings::GetDisplayRotationName(DisplayRotation rotation)
{
return s_display_rotation_names[static_cast<int>(rotation)];
return s_display_rotation_names[static_cast<size_t>(rotation)];
}
const char* Settings::GetDisplayRotationDisplayName(DisplayRotation rotation)
{
return Host::TranslateToCString("Settings", s_display_rotation_display_names[static_cast<size_t>(rotation)]);
}
static constexpr const std::array s_display_force_frame_timings_names = {
"Disabled", "NTSC", "PAL"
static constexpr const std::array s_display_force_video_timings_names = {
TRANSLATE_NOOP("Settings", "Disabled"),
"NTSC",
"PAL",
};
std::optional<ForceFrameTimingsMode> Settings::ParseForceFrameTimings(const char* str)
std::optional<ForceVideoTimingMode> Settings::ParseForceVideoTimingName(const char* str)
{
int index = 0;
for (const char* name : s_display_force_frame_timings_names)
for (const char* name : s_display_force_video_timings_names)
{
if (StringUtil::Strcasecmp(name, str) == 0)
return static_cast<ForceFrameTimingsMode>(index);
return static_cast<ForceVideoTimingMode>(index);
index++;
}
return std::nullopt;
}
const char* Settings::GetForceVideoTimingName(ForceVideoTimingMode mode)
{
return s_display_force_video_timings_names[static_cast<size_t>(mode)];
}
const char* Settings::GetForceVideoTimingDisplayName(ForceVideoTimingMode mode)
{
return Host::TranslateToCString("Settings", s_display_force_video_timings_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_display_scaling_names = {
"Nearest", "NearestInteger", "BilinearSmooth", "BilinearSharp", "BilinearInteger",
};
@ -1555,22 +1571,12 @@ std::optional<DisplayScalingMode> Settings::ParseDisplayScaling(const char* str)
const char* Settings::GetDisplayScalingName(DisplayScalingMode mode)
{
return s_display_scaling_names[static_cast<int>(mode)];
return s_display_scaling_names[static_cast<size_t>(mode)];
}
const char* Settings::GetDisplayScalingDisplayName(DisplayScalingMode mode)
{
return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<int>(mode)]);
}
const char* Settings::GetForceFrameTimingsName(ForceFrameTimingsMode mode)
{
return s_display_force_frame_timings_names[static_cast<int>(mode)];
}
const char* Settings::GetForceFrameTimingsDisplayName(ForceFrameTimingsMode mode)
{
return Host::TranslateToCString("ForceFrameTimingsMode", s_display_force_frame_timings_names[static_cast<int>(mode)]);
return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_display_exclusive_fullscreen_mode_names = {
@ -1600,13 +1606,13 @@ std::optional<DisplayExclusiveFullscreenControl> Settings::ParseDisplayExclusive
const char* Settings::GetDisplayExclusiveFullscreenControlName(DisplayExclusiveFullscreenControl mode)
{
return s_display_exclusive_fullscreen_mode_names[static_cast<int>(mode)];
return s_display_exclusive_fullscreen_mode_names[static_cast<size_t>(mode)];
}
const char* Settings::GetDisplayExclusiveFullscreenControlDisplayName(DisplayExclusiveFullscreenControl mode)
{
return Host::TranslateToCString("Settings",
s_display_exclusive_fullscreen_mode_display_names[static_cast<int>(mode)]);
s_display_exclusive_fullscreen_mode_display_names[static_cast<size_t>(mode)]);
}
static constexpr const std::array s_display_screenshot_mode_names = {
@ -1715,12 +1721,12 @@ std::optional<MemoryCardType> Settings::ParseMemoryCardTypeName(const char* str)
const char* Settings::GetMemoryCardTypeName(MemoryCardType type)
{
return s_memory_card_type_names[static_cast<int>(type)];
return s_memory_card_type_names[static_cast<size_t>(type)];
}
const char* Settings::GetMemoryCardTypeDisplayName(MemoryCardType type)
{
return Host::TranslateToCString("MemoryCardType", s_memory_card_type_display_names[static_cast<int>(type)]);
return Host::TranslateToCString("MemoryCardType", s_memory_card_type_display_names[static_cast<size_t>(type)]);
}
std::string Settings::GetDefaultSharedMemoryCardName(u32 slot)

10
src/core/settings.h
View File

@ -132,7 +132,7 @@ struct Settings
bool gpu_pgxp_preserve_proj_fp : 1 = false;
bool gpu_pgxp_depth_buffer : 1 = false;
bool gpu_pgxp_disable_2d : 1 = false;
ForceFrameTimingsMode gpu_force_frame_timings = DEFAULT_FORCE_FRAME_TIMINGS_MODE;
ForceVideoTimingMode gpu_force_video_timing = DEFAULT_FORCE_VIDEO_TIMING_MODE;
GPUTextureFilter gpu_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
GPUTextureFilter gpu_sprite_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
GPULineDetectMode gpu_line_detect_mode = DEFAULT_GPU_LINE_DETECT_MODE;
@ -434,9 +434,9 @@ struct Settings
static const char* GetDisplayScalingName(DisplayScalingMode mode);
static const char* GetDisplayScalingDisplayName(DisplayScalingMode mode);
static std::optional<ForceFrameTimingsMode> ParseForceFrameTimings(const char* str);
static const char* GetForceFrameTimingsName(ForceFrameTimingsMode mode);
static const char* GetForceFrameTimingsDisplayName(ForceFrameTimingsMode mode);
static std::optional<ForceVideoTimingMode> ParseForceVideoTimingName(const char* str);
static const char* GetForceVideoTimingName(ForceVideoTimingMode mode);
static const char* GetForceVideoTimingDisplayName(ForceVideoTimingMode mode);
static std::optional<DisplayExclusiveFullscreenControl> ParseDisplayExclusiveFullscreenControl(const char* str);
static const char* GetDisplayExclusiveFullscreenControlName(DisplayExclusiveFullscreenControl mode);
@ -496,7 +496,7 @@ struct Settings
static constexpr DisplayAlignment DEFAULT_DISPLAY_ALIGNMENT = DisplayAlignment::Center;
static constexpr DisplayRotation DEFAULT_DISPLAY_ROTATION = DisplayRotation::Normal;
static constexpr DisplayScalingMode DEFAULT_DISPLAY_SCALING = DisplayScalingMode::BilinearSmooth;
static constexpr ForceFrameTimingsMode DEFAULT_FORCE_FRAME_TIMINGS_MODE = ForceFrameTimingsMode::Disabled;
static constexpr ForceVideoTimingMode DEFAULT_FORCE_VIDEO_TIMING_MODE = ForceVideoTimingMode::Disabled;
static constexpr DisplayExclusiveFullscreenControl DEFAULT_DISPLAY_EXCLUSIVE_FULLSCREEN_CONTROL =
DisplayExclusiveFullscreenControl::Automatic;
static constexpr DisplayScreenshotMode DEFAULT_DISPLAY_SCREENSHOT_MODE = DisplayScreenshotMode::ScreenResolution;

4
src/core/system.cpp
View File

@ -4304,7 +4304,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
g_settings.gpu_sprite_texture_filter != old_settings.gpu_sprite_texture_filter ||
g_settings.gpu_line_detect_mode != old_settings.gpu_line_detect_mode ||
g_settings.gpu_disable_interlacing != old_settings.gpu_disable_interlacing ||
g_settings.gpu_force_frame_timings != old_settings.gpu_force_frame_timings ||
g_settings.gpu_force_video_timing != old_settings.gpu_force_video_timing ||
g_settings.gpu_downsample_mode != old_settings.gpu_downsample_mode ||
g_settings.gpu_downsample_scale != old_settings.gpu_downsample_scale ||
g_settings.gpu_wireframe_mode != old_settings.gpu_wireframe_mode ||
@ -4531,7 +4531,7 @@ void System::WarnAboutUnsafeSettings()
TinyString(TRANSLATE_SV("System", "Instant")) :
TinyString::from_format("{}x", g_settings.cdrom_seek_speedup)));
}
if (g_settings.gpu_force_frame_timings != ForceFrameTimingsMode::Disabled)
if (g_settings.gpu_force_video_timing != ForceVideoTimingMode::Disabled)
{
append(ICON_FA_TV, TRANSLATE_SV("System", "Force frame timings is enabled. Games may run at incorrect speeds."));
}

2
src/core/types.h
View File

@ -276,7 +276,7 @@ enum class SaveStateCompressionMode : u8
Count,
};
enum class ForceFrameTimingsMode : u8
enum class ForceVideoTimingMode : u8
{
Disabled,
NTSC,

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

@ -74,9 +74,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.displayScaling, "Display", "Scaling",
&Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
Settings::DEFAULT_DISPLAY_SCALING);
SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.forceFrameTimings, "GPU", "ForceFrameTimings",
&Settings::ParseForceFrameTimings, &Settings::GetForceFrameTimingsName,
Settings::DEFAULT_FORCE_FRAME_TIMINGS_MODE);
SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.forceVideoTiming, "GPU", "ForceVideoTiming",
&Settings::ParseForceVideoTimingName, &Settings::GetForceVideoTimingName,
Settings::DEFAULT_FORCE_VIDEO_TIMING_MODE);
SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.gpuDownsampleScale, "GPU", "DownsampleScale", 1);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.trueColor, "GPU", "TrueColor", false);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.disableInterlacing, "GPU", "DisableInterlacing", true);
@ -84,7 +84,7 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.pgxpDepthBuffer, "GPU", "PGXPDepthBuffer", false);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.force43For24Bit, "Display", "Force4_3For24Bit", false);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.chromaSmoothingFor24Bit, "GPU", "ChromaSmoothing24Bit", false);
connect(m_ui.renderer, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&GraphicsSettingsWidget::updateRendererDependentOptions);
connect(m_ui.textureFiltering, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
@ -108,8 +108,6 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
!m_dialog->hasGameTrait(GameDatabase::Trait::ForceInterlacing));
SettingWidgetBinder::SetAvailability(m_ui.widescreenHack,
!m_dialog->hasGameTrait(GameDatabase::Trait::DisableWidescreen));
SettingWidgetBinder::SetAvailability(m_ui.forceFrameTimings,
!m_dialog->hasGameTrait(GameDatabase::Trait::DisableForceFrameTimings));
// Advanced Tab
@ -339,11 +337,11 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
m_ui.displayScaling, tr("Scaling"), tr("Bilinear (Smooth)"),
tr("Determines how the emulated console's output is upscaled or downscaled to your monitor's resolution."));
dialog->registerWidgetHelp(
m_ui.forceFrameTimings, tr("Force Frame Timings"), tr("Disabled"),
tr("Utilizes the chosen frame timing regardless of the active region. "
"This feature can be used to force PAL games to run at 60Hz and NTSC games to run at 50Hz. "
"For most games which have a speed tied to the framerate, this will result in the game running approximately 17% faster or slower. "
"For variable frame rate games, it may not affect the speed."));
m_ui.forceVideoTiming, tr("Force Video Timing"), tr("Disabled"),
tr("Utilizes the chosen frame timing regardless of the active region. This feature can be used to force PAL games "
"to run at 60Hz and NTSC games to run at 50Hz. For most games which have a speed tied to the framerate, this "
"will result in the game running approximately 17% faster or slower. For variable frame rate games, it may not "
"affect the speed."));
dialog->registerWidgetHelp(
m_ui.trueColor, tr("True Color Rendering"), tr("Checked"),
tr("Forces the precision of colours output to the console's framebuffer to use the full 8 bits of precision per "
@ -658,13 +656,12 @@ void GraphicsSettingsWidget::setupAdditionalUi()
QString::fromUtf8(Settings::GetDisplayScalingDisplayName(static_cast<DisplayScalingMode>(i))));
}
for (u32 i = 0; i < static_cast<u32>(ForceFrameTimingsMode::Count); i++)
for (u32 i = 0; i < static_cast<u32>(ForceVideoTimingMode::Count); i++)
{
m_ui.forceFrameTimings->addItem(
QString::fromUtf8(Settings::GetForceFrameTimingsName(static_cast<ForceFrameTimingsMode>(i))));
m_ui.forceVideoTiming->addItem(
QString::fromUtf8(Settings::GetForceVideoTimingName(static_cast<ForceVideoTimingMode>(i))));
}
// Advanced Tab
for (u32 i = 0; i < static_cast<u32>(DisplayExclusiveFullscreenControl::Count); i++)

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

@ -268,14 +268,14 @@
<widget class="QComboBox" name="spriteTextureFiltering"/>
</item>
<item row="8" column="0">
<widget class="QLabel" name="forceFrameTimingsLabel">
<widget class="QLabel" name="forceVideoTimingLabel">
<property name="text">
<string>Force Frame Timings:</string>
<string>Force Video Timing:</string>
</property>
</widget>
</item>
<item row="8" column="1">
<widget class="QComboBox" name="forceFrameTimings"/>
<widget class="QComboBox" name="forceVideoTiming"/>
</item>
</layout>
</widget>