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

GPU: Add separate scaling and FMV scaling options

Browse Source
pull/3514/head
Stenzek 2 months ago
parent 006de3a6df
commit 7a359e54be
No known key found for this signature in database
13 changed files with 153 additions and 61 deletions
Show Stats Download Patch File Download Diff File

5
src/core/fullscreen_ui.cpp
Unescape Escape View File

@ -5459,6 +5459,11 @@ void FullscreenUI::DrawGraphicsSettingsPage()
"Display", "Scaling", Settings::DEFAULT_DISPLAY_SCALING, &Settings::ParseDisplayScaling,
&Settings::GetDisplayScalingName, &Settings::GetDisplayScalingDisplayName, DisplayScalingMode::Count);
DrawEnumSetting(bsi, FSUI_ICONVSTR(ICON_FA_VIDEO, "FMV Scaling"),
FSUI_VSTR("Determines the scaling algorithm used when 24-bit content is active, typically FMVs."),
"Display", "Scaling24Bit", Settings::DEFAULT_DISPLAY_SCALING, &Settings::ParseDisplayScaling,
&Settings::GetDisplayScalingName, &Settings::GetDisplayScalingDisplayName, DisplayScalingMode::Count);
DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_ARROWS_LEFT_RIGHT_TO_LINE, "Widescreen Rendering"),
FSUI_VSTR("Increases the field of view from 4:3 to the chosen display aspect ratio in 3D games."),
"GPU", "WidescreenHack", false);

2
src/core/gpu.cpp
Unescape Escape View File

@ -2011,7 +2011,7 @@ u8 GPU::CalculateAutomaticResolutionScale() const
m_crtc_state.display_height, m_crtc_state.display_origin_left, m_crtc_state.display_origin_top,
m_crtc_state.display_vram_width, m_crtc_state.display_vram_height, g_settings.display_rotation,
g_settings.display_alignment, g_settings.gpu_show_vram ? 1.0f : ComputePixelAspectRatio(),
g_settings.IsUsingIntegerDisplayScaling(), &display_rect, &draw_rect);
g_settings.IsUsingIntegerDisplayScaling(false), &display_rect, &draw_rect);
// We use the draw rect to determine scaling. This way we match the resolution as best we can, regardless of the
// anamorphic aspect ratio.

15
src/core/gpu_backend.cpp
Unescape Escape View File

@ -544,9 +544,10 @@ void GPUBackend::HandleCommand(const GPUThreadCommand* cmd)
void GPUBackend::HandleUpdateDisplayCommand(const GPUBackendUpdateDisplayCommand* cmd)
{
// Height has to be doubled because we halved it on the GPU side.
m_presenter.SetDisplayParameters(
cmd->display_width, cmd->display_height, cmd->display_origin_left, cmd->display_origin_top, cmd->display_vram_width,
cmd->display_vram_height << BoolToUInt32(cmd->interlaced_display_enabled), cmd->display_pixel_aspect_ratio);
m_presenter.SetDisplayParameters(cmd->display_width, cmd->display_height, cmd->display_origin_left,
cmd->display_origin_top, cmd->display_vram_width,
cmd->display_vram_height << BoolToUInt32(cmd->interlaced_display_enabled),
cmd->display_pixel_aspect_ratio, cmd->display_24bit);
UpdateDisplay(cmd);
if (cmd->submit_frame)
@ -585,7 +586,8 @@ void GPUBackend::GetStatsString(SmallStringBase& str) const
{
if (g_gpu_settings.gpu_pgxp_depth_buffer)
{
str.format("\x02{}{} HW | \x01{}\x02 P | \x01{}\x02 DC | \x01{}\x02 B | \x01{}\x02 RP | \x01{}\x02 RB | \x01{}\x02 C | \x01{}\x02 W | \x01{}\x02 DBC",
str.format("\x02{}{} HW | \x01{}\x02 P | \x01{}\x02 DC | \x01{}\x02 B | \x01{}\x02 RP | \x01{}\x02 RB | "
"\x01{}\x02 C | \x01{}\x02 W | \x01{}\x02 DBC",
GPUDevice::RenderAPIToString(g_gpu_device->GetRenderAPI()), g_gpu_settings.gpu_use_thread ? "-MT" : "",
s_stats.num_primitives, s_stats.host_num_draws, s_stats.host_num_barriers,
s_stats.host_num_render_passes, s_stats.host_num_downloads, s_stats.num_copies, s_stats.num_writes,
@ -593,7 +595,8 @@ void GPUBackend::GetStatsString(SmallStringBase& str) const
}
else
{
str.format("\x02{}{} HW | \x01{}\x02 P | \x01{}\x02 DC | \x01{}\x02 B | \x01{}\x02 RP | \x01{}\x02 RB | \x01{}\x02 C | \x01{}\x02 W",
str.format("\x02{}{} HW | \x01{}\x02 P | \x01{}\x02 DC | \x01{}\x02 B | \x01{}\x02 RP | \x01{}\x02 RB | "
"\x01{}\x02 C | \x01{}\x02 W",
GPUDevice::RenderAPIToString(g_gpu_device->GetRenderAPI()), g_gpu_settings.gpu_use_thread ? "-MT" : "",
s_stats.num_primitives, s_stats.host_num_draws, s_stats.host_num_barriers,
s_stats.host_num_render_passes, s_stats.host_num_downloads, s_stats.num_copies, s_stats.num_writes);
@ -680,7 +683,7 @@ bool GPUBackend::RenderScreenshotToBuffer(u32 width, u32 height, bool postfx, bo
// Crop it if border overlay isn't enabled.
GSVector4i draw_rect, display_rect;
backend->GetPresenter().CalculateDrawRect(static_cast<s32>(width), static_cast<s32>(height), apply_aspect_ratio,
false, &display_rect, &draw_rect);
false, false, &display_rect, &draw_rect);
image_width = static_cast<u32>(display_rect.width());
image_height = static_cast<u32>(display_rect.height());
}

104
src/core/gpu_presenter.cpp
Unescape Escape View File

@ -71,6 +71,7 @@ bool GPUPresenter::Initialize(Error* error)
bool GPUPresenter::UpdateSettings(const GPUSettings& old_settings, Error* error)
{
if (g_gpu_settings.display_scaling != old_settings.display_scaling ||
g_gpu_settings.display_scaling_24bit != old_settings.display_scaling_24bit ||
g_gpu_settings.display_deinterlacing_mode != old_settings.display_deinterlacing_mode ||
g_gpu_settings.display_24bit_chroma_smoothing != old_settings.display_24bit_chroma_smoothing)
{
@ -79,7 +80,8 @@ bool GPUPresenter::UpdateSettings(const GPUSettings& old_settings, Error* error)
DestroyDeinterlaceTextures();
if (!CompileDisplayPipelines(
g_gpu_settings.display_scaling != old_settings.display_scaling,
g_gpu_settings.display_scaling != old_settings.display_scaling ||
g_gpu_settings.display_scaling_24bit != old_settings.display_scaling_24bit,
g_gpu_settings.display_deinterlacing_mode != old_settings.display_deinterlacing_mode,
g_gpu_settings.display_24bit_chroma_smoothing != old_settings.display_24bit_chroma_smoothing, error))
{
@ -121,30 +123,34 @@ bool GPUPresenter::CompileDisplayPipelines(bool display, bool deinterlace, bool
GL_OBJECT_NAME(vso, "Display Vertex Shader");
std::string fs;
switch (g_gpu_settings.display_scaling)
{
case DisplayScalingMode::BilinearSharp:
fs = shadergen.GenerateDisplaySharpBilinearFragmentShader();
break;
case DisplayScalingMode::BilinearSmooth:
case DisplayScalingMode::BilinearInteger:
fs = shadergen.GenerateDisplayFragmentShader(true, false);
break;
case DisplayScalingMode::Lanczos:
fs = shadergen.GenerateDisplayLanczosFragmentShader();
break;
static constexpr auto compile_display_shader = [](const GPUShaderGen& shadergen, std::string& fs,
DisplayScalingMode mode, Error* error) {
switch (mode)
{
case DisplayScalingMode::BilinearSharp:
fs = shadergen.GenerateDisplaySharpBilinearFragmentShader();
break;
case DisplayScalingMode::BilinearSmooth:
case DisplayScalingMode::BilinearInteger:
fs = shadergen.GenerateDisplayFragmentShader(true, false);
break;
case DisplayScalingMode::Lanczos:
fs = shadergen.GenerateDisplayLanczosFragmentShader();
break;
case DisplayScalingMode::Nearest:
case DisplayScalingMode::NearestInteger:
default:
fs = shadergen.GenerateDisplayFragmentShader(false, true);
break;
}
case DisplayScalingMode::Nearest:
case DisplayScalingMode::NearestInteger:
default:
fs = shadergen.GenerateDisplayFragmentShader(false, true);
break;
}
return g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), fs, error);
};
std::unique_ptr<GPUShader> fso =
g_gpu_device->CreateShader(GPUShaderStage::Fragment, shadergen.GetLanguage(), fs, error);
std::unique_ptr<GPUShader> fso = compile_display_shader(shadergen, fs, g_settings.display_scaling, error);
if (!fso)
return false;
GL_OBJECT_NAME_FMT(fso, "Display Fragment Shader [{}]",
@ -157,6 +163,26 @@ bool GPUPresenter::CompileDisplayPipelines(bool display, bool deinterlace, bool
GL_OBJECT_NAME_FMT(m_display_pipeline, "Display Pipeline [{}]",
Settings::GetDisplayScalingName(g_gpu_settings.display_scaling));
std::unique_ptr<GPUShader> fso_24bit;
if (g_gpu_settings.display_scaling_24bit != g_gpu_settings.display_scaling)
{
fso_24bit = compile_display_shader(shadergen, fs, g_settings.display_scaling_24bit, error);
if (!fso_24bit)
return false;
GL_OBJECT_NAME_FMT(fso_24bit, "Display Fragment Shader 24bit [{}]",
Settings::GetDisplayScalingName(g_gpu_settings.display_scaling_24bit));
plconfig.fragment_shader = fso_24bit.get();
if (!(m_display_24bit_pipeline = g_gpu_device->CreatePipeline(plconfig, error)))
return false;
GL_OBJECT_NAME_FMT(m_display_24bit_pipeline, "Display Pipeline 24bit [{}]",
Settings::GetDisplayScalingName(g_gpu_settings.display_scaling_24bit));
}
else
{
m_display_24bit_pipeline.reset();
}
std::unique_ptr<GPUShader> copy_fso = g_gpu_device->CreateShader(
GPUShaderStage::Fragment, shadergen.GetLanguage(), shadergen.GenerateCopyFragmentShader(false), error);
if (!copy_fso)
@ -212,6 +238,15 @@ bool GPUPresenter::CompileDisplayPipelines(bool display, bool deinterlace, bool
GL_OBJECT_NAME_FMT(m_display_blend_pipeline, "Display Pipeline [Blended, {}]",
Settings::GetDisplayScalingName(g_gpu_settings.display_scaling));
if (g_gpu_settings.display_scaling_24bit != g_gpu_settings.display_scaling)
{
plconfig.fragment_shader = fso_24bit.get();
if (!(m_display_24bit_blend_pipeline = g_gpu_device->CreatePipeline(plconfig, error)))
return false;
GL_OBJECT_NAME_FMT(m_display_24bit_blend_pipeline, "Display Pipeline 24bit [Blended, {}]",
Settings::GetDisplayScalingName(g_gpu_settings.display_scaling_24bit));
}
plconfig.fragment_shader = copy_fso.get();
if (!(m_present_copy_blend_pipeline = g_gpu_device->CreatePipeline(plconfig, error)))
return false;
@ -222,6 +257,7 @@ bool GPUPresenter::CompileDisplayPipelines(bool display, bool deinterlace, bool
m_border_overlay_pipeline.reset();
m_present_clear_pipeline.reset();
m_display_blend_pipeline.reset();
m_display_24bit_blend_pipeline.reset();
m_present_copy_blend_pipeline.reset();
}
}
@ -359,7 +395,7 @@ void GPUPresenter::ClearDisplayTexture()
void GPUPresenter::SetDisplayParameters(u16 display_width, u16 display_height, u16 display_origin_left,
u16 display_origin_top, u16 display_vram_width, u16 display_vram_height,
float display_pixel_aspect_ratio)
float display_pixel_aspect_ratio, bool display_24bit)
{
m_display_width = display_width;
m_display_height = display_height;
@ -368,6 +404,7 @@ void GPUPresenter::SetDisplayParameters(u16 display_width, u16 display_height, u
m_display_vram_width = display_vram_width;
m_display_vram_height = display_vram_height;
m_display_pixel_aspect_ratio = display_pixel_aspect_ratio;
m_display_texture_24bit = display_24bit;
}
void GPUPresenter::SetDisplayTexture(GPUTexture* texture, s32 view_x, s32 view_y, s32 view_width, s32 view_height)
@ -402,6 +439,7 @@ GPUDevice::PresentResult GPUPresenter::RenderDisplay(GPUTexture* target, const G
const WindowInfo::PreRotation prerotation = target ? WindowInfo::PreRotation::Identity : swap_chain->GetPreRotation();
const GSVector2i final_target_size = target ? target->GetSizeVec() : swap_chain->GetPostRotatedSizeVec();
const bool is_vram_view = g_gpu_settings.gpu_show_vram;
const bool integer_scale = g_gpu_settings.IsUsingIntegerDisplayScaling(m_display_texture_24bit);
const bool have_overlay = (postfx && !is_vram_view && HasBorderOverlay());
const bool have_prerotation = (prerotation != WindowInfo::PreRotation::Identity);
GL_INS(have_overlay ? "Overlay is ENABLED" : "Overlay is disabled");
@ -429,8 +467,8 @@ GPUDevice::PresentResult GPUPresenter::RenderDisplay(GPUTexture* target, const G
GSVector4i(GSVector4(m_border_overlay_display_rect) * GSVector4::xyxy(scale)).add32(overlay_rect.xyxy());
// Draw to the overlay area instead of the whole screen. Always align in center, we align the overlay instead.
CalculateDrawRect(overlay_display_rect.width(), overlay_display_rect.height(), apply_aspect_ratio, false,
&display_rect, &draw_rect);
CalculateDrawRect(overlay_display_rect.width(), overlay_display_rect.height(), apply_aspect_ratio, integer_scale,
false, &display_rect, &draw_rect);
// Apply overlay area offset.
display_rect = display_rect.add32(overlay_display_rect.xyxy());
@ -438,7 +476,7 @@ GPUDevice::PresentResult GPUPresenter::RenderDisplay(GPUTexture* target, const G
}
else
{
CalculateDrawRect(target_size.x, target_size.y, apply_aspect_ratio, true, &display_rect, &draw_rect);
CalculateDrawRect(target_size.x, target_size.y, apply_aspect_ratio, integer_scale, true, &display_rect, &draw_rect);
}
// There's a bunch of scenarios where we need to use intermediate buffers.
@ -660,7 +698,7 @@ void GPUPresenter::DrawDisplay(const GSVector2i target_size, const GSVector2i fi
const GSVector2 display_texture_size = GSVector2(m_display_texture->GetSizeVec());
switch (g_gpu_settings.display_scaling)
switch (m_display_texture_24bit ? g_gpu_settings.display_scaling_24bit : g_gpu_settings.display_scaling)
{
case DisplayScalingMode::Nearest:
case DisplayScalingMode::NearestInteger:
@ -697,7 +735,10 @@ void GPUPresenter::DrawDisplay(const GSVector2i target_size, const GSVector2i fi
break;
}
g_gpu_device->SetPipeline(dst_alpha_blend ? m_display_blend_pipeline.get() : m_display_pipeline.get());
if (m_display_texture_24bit && m_display_24bit_pipeline)
g_gpu_device->SetPipeline(dst_alpha_blend ? m_display_24bit_blend_pipeline.get() : m_display_24bit_pipeline.get());
else
g_gpu_device->SetPipeline(dst_alpha_blend ? m_display_blend_pipeline.get() : m_display_pipeline.get());
g_gpu_device->SetTextureSampler(
0, m_display_texture, texture_filter_linear ? g_gpu_device->GetLinearSampler() : g_gpu_device->GetNearestSampler());
@ -1001,10 +1042,9 @@ bool GPUPresenter::ApplyChromaSmoothing()
return true;
}
void GPUPresenter::CalculateDrawRect(s32 window_width, s32 window_height, bool apply_aspect_ratio, bool apply_alignment,
GSVector4i* display_rect, GSVector4i* draw_rect) const
void GPUPresenter::CalculateDrawRect(s32 window_width, s32 window_height, bool apply_aspect_ratio, bool integer_scale,
bool apply_alignment, GSVector4i* display_rect, GSVector4i* draw_rect) const
{
const bool integer_scale = g_gpu_settings.IsUsingIntegerDisplayScaling();
const bool show_vram = g_gpu_settings.gpu_show_vram;
const u32 display_width = show_vram ? VRAM_WIDTH : m_display_width;
const u32 display_height = show_vram ? VRAM_HEIGHT : m_display_height;

10
src/core/gpu_presenter.h
Unescape Escape View File

@ -54,14 +54,15 @@ public:
void ClearDisplay();
void ClearDisplayTexture();
void SetDisplayParameters(u16 display_width, u16 display_height, u16 display_origin_left, u16 display_origin_top,
u16 display_vram_width, u16 display_vram_height, float display_pixel_aspect_ratio);
u16 display_vram_width, u16 display_vram_height, float display_pixel_aspect_ratio,
bool display_24bit);
void SetDisplayTexture(GPUTexture* texture, s32 view_x, s32 view_y, s32 view_width, s32 view_height);
bool Deinterlace(u32 field);
bool ApplyChromaSmoothing();
/// Helper function for computing the draw rectangle in a larger window.
void CalculateDrawRect(s32 window_width, s32 window_height, bool apply_aspect_ratio, bool apply_alignment,
GSVector4i* display_rect, GSVector4i* draw_rect) const;
void CalculateDrawRect(s32 window_width, s32 window_height, bool apply_aspect_ratio, bool integer_scale,
bool apply_alignment, GSVector4i* display_rect, GSVector4i* draw_rect) const;
/// Helper function for computing screenshot bounds.
GSVector2i CalculateScreenshotSize(DisplayScreenshotMode mode) const;
@ -143,6 +144,7 @@ private:
std::unique_ptr<GPUTexture> m_chroma_smoothing_texture;
std::unique_ptr<GPUPipeline> m_display_pipeline;
std::unique_ptr<GPUPipeline> m_display_24bit_pipeline;
GPUTexture* m_display_texture = nullptr;
s32 m_display_texture_view_x = 0;
s32 m_display_texture_view_y = 0;
@ -151,6 +153,7 @@ private:
u32 m_skipped_present_count = 0;
GPUTexture::Format m_present_format = GPUTexture::Format::Unknown;
bool m_display_texture_24bit = false;
bool m_border_overlay_alpha_blend = false;
bool m_border_overlay_destination_alpha_blend = false;
@ -162,6 +165,7 @@ private:
std::unique_ptr<GPUPipeline> m_border_overlay_pipeline;
std::unique_ptr<GPUPipeline> m_present_clear_pipeline;
std::unique_ptr<GPUPipeline> m_display_blend_pipeline;
std::unique_ptr<GPUPipeline> m_display_24bit_blend_pipeline;
std::unique_ptr<GPUPipeline> m_present_copy_blend_pipeline;
GSVector4i m_border_overlay_display_rect = GSVector4i::zero();

5
src/core/settings.cpp
Unescape Escape View File

@ -322,6 +322,10 @@ void Settings::Load(const SettingsInterface& si, const SettingsInterface& contro
display_scaling =
ParseDisplayScaling(si.GetStringValue("Display", "Scaling", GetDisplayScalingName(DEFAULT_DISPLAY_SCALING)).c_str())
.value_or(DEFAULT_DISPLAY_SCALING);
display_scaling_24bit =
ParseDisplayScaling(
si.GetStringValue("Display", "Scaling24Bit", GetDisplayScalingName(DEFAULT_DISPLAY_SCALING)).c_str())
.value_or(DEFAULT_DISPLAY_SCALING);
display_exclusive_fullscreen_control =
ParseDisplayExclusiveFullscreenControl(
si.GetStringValue("Display", "ExclusiveFullscreenControl",
@ -674,6 +678,7 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
si.SetStringValue("Display", "Alignment", GetDisplayAlignmentName(display_alignment));
si.SetStringValue("Display", "Rotation", GetDisplayRotationName(display_rotation));
si.SetStringValue("Display", "Scaling", GetDisplayScalingName(display_scaling));
si.SetStringValue("Display", "Scaling24Bit", GetDisplayScalingName(display_scaling_24bit));
si.SetBoolValue("Display", "OptimalFramePacing", display_optimal_frame_pacing);
si.SetBoolValue("Display", "PreFrameSleep", display_pre_frame_sleep);
si.SetBoolValue("Display", "SkipPresentingDuplicateFrames", display_skip_presenting_duplicate_frames);

9
src/core/settings.h
Unescape Escape View File

@ -66,7 +66,6 @@ struct GPUSettings
GPURenderer gpu_renderer = DEFAULT_GPU_RENDERER;
u8 gpu_resolution_scale = 1;
u8 gpu_multisamples = 1;
u8 gpu_max_queued_frames = DEFAULT_GPU_MAX_QUEUED_FRAMES;
ForceVideoTimingMode gpu_force_video_timing = DEFAULT_FORCE_VIDEO_TIMING_MODE;
GPUTextureFilter gpu_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
@ -82,6 +81,7 @@ struct GPUSettings
DisplayAlignment display_alignment = DEFAULT_DISPLAY_ALIGNMENT;
DisplayRotation display_rotation = DEFAULT_DISPLAY_ROTATION;
DisplayScalingMode display_scaling = DEFAULT_DISPLAY_SCALING;
DisplayScalingMode display_scaling_24bit = DEFAULT_DISPLAY_SCALING;
DisplayExclusiveFullscreenControl display_exclusive_fullscreen_control = DEFAULT_DISPLAY_EXCLUSIVE_FULLSCREEN_CONTROL;
DisplayScreenshotMode display_screenshot_mode = DEFAULT_DISPLAY_SCREENSHOT_MODE;
DisplayScreenshotFormat display_screenshot_format = DEFAULT_DISPLAY_SCREENSHOT_FORMAT;
@ -93,6 +93,7 @@ struct GPUSettings
s8 display_line_start_offset = 0;
s8 display_line_end_offset = 0;
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;
@ -227,10 +228,10 @@ struct GPUSettings
return (gpu_dithering_mode == GPUDitheringMode::Scaled ||
gpu_dithering_mode == GPUDitheringMode::ScaledShaderBlend);
}
ALWAYS_INLINE bool IsUsingIntegerDisplayScaling() const
ALWAYS_INLINE bool IsUsingIntegerDisplayScaling(bool is_24bit) const
{
return (display_scaling == DisplayScalingMode::NearestInteger ||
display_scaling == DisplayScalingMode::BilinearInteger);
const DisplayScalingMode mode = is_24bit ? display_scaling_24bit : display_scaling;
return (mode == DisplayScalingMode::NearestInteger || mode == DisplayScalingMode::BilinearInteger);
}
ALWAYS_INLINE bool UsingPGXPCPUMode() const { return gpu_pgxp_enable && gpu_pgxp_cpu; }

1
src/core/system.cpp
Unescape Escape View File

@ -4596,6 +4596,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
g_settings.display_24bit_chroma_smoothing != old_settings.display_24bit_chroma_smoothing ||
g_settings.display_aspect_ratio != old_settings.display_aspect_ratio ||
g_settings.display_scaling != old_settings.display_scaling ||
g_settings.display_scaling_24bit != old_settings.display_scaling_24bit ||
g_settings.display_alignment != old_settings.display_alignment ||
g_settings.display_rotation != old_settings.display_rotation ||
g_settings.display_deinterlacing_mode != old_settings.display_deinterlacing_mode ||

6
src/duckstation-qt/graphicssettingswidget.cpp
Unescape Escape View File

@ -97,6 +97,10 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
SettingWidgetBinder::BindWidgetToEnumSetting(
sif, m_ui.displayScaling, "Display", "Scaling", &Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
&Settings::GetDisplayScalingDisplayName, Settings::DEFAULT_DISPLAY_SCALING, DisplayScalingMode::Count);
SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.displayScaling24Bit, "Display", "Scaling24Bit",
&Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
&Settings::GetDisplayScalingDisplayName,
Settings::DEFAULT_DISPLAY_SCALING, DisplayScalingMode::Count);
SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.gpuDownsampleScale, "GPU", "DownsampleScale", 1);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.pgxpEnable, "GPU", "PGXPEnable", false);
SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.pgxpDepthBuffer, "GPU", "PGXPDepthBuffer", false);
@ -417,6 +421,8 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
dialog->registerWidgetHelp(
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.displayScaling24Bit, tr("FMV Scaling"), tr("Bilinear (Smooth)"),
tr("Determines the scaling algorithm used when 24-bit content is active, typically FMVs."));
dialog->registerWidgetHelp(
m_ui.widescreenHack, tr("Widescreen Rendering"), tr("Unchecked"),
tr("Scales vertex positions in screen-space to a widescreen aspect ratio, essentially "

20
src/duckstation-qt/graphicssettingswidget.ui
Unescape Escape View File

@ -7,7 +7,7 @@
<x>0</x>
<y>0</y>
<width>655</width>
<height>538</height>
<height>511</height>
</rect>
</property>
<property name="windowTitle">
@ -207,6 +207,9 @@
</item>
</layout>
</item>
<item row="7" column="1">
<widget class="QComboBox" name="displayCropMode"/>
</item>
<item row="7" column="0">
<widget class="QLabel" name="label_7">
<property name="text">
@ -214,9 +217,6 @@
</property>
</widget>
</item>
<item row="7" column="1">
<widget class="QComboBox" name="displayCropMode"/>
</item>
<item row="8" column="0">
<widget class="QLabel" name="label_8">
<property name="text">
@ -227,7 +227,17 @@
<item row="8" column="1">
<widget class="QComboBox" name="displayScaling"/>
</item>
<item row="9" column="0" colspan="2">
<item row="9" column="0">
<widget class="QLabel" name="label_9">
<property name="text">
<string>FMV Scaling:</string>
</property>
</widget>
</item>
<item row="9" column="1">
<widget class="QComboBox" name="displayScaling24Bit"/>
</item>
<item row="10" column="0" colspan="2">
<layout class="QGridLayout" name="gridLayout_2">
<item row="2" column="0">
<widget class="QCheckBox" name="force43For24Bit">

2
src/duckstation-qt/settingswindow.ui
Unescape Escape View File

@ -7,7 +7,7 @@
<x>0</x>
<y>0</y>
<width>785</width>
<height>655</height>
<height>676</height>
</rect>
</property>
<property name="sizePolicy">

7
src/duckstation-qt/setupwizarddialog.cpp
Unescape Escape View File

@ -562,6 +562,13 @@ void SetupWizardDialog::setupGraphicsPage(bool initial)
&Settings::GetDisplayScalingDisplayName,
Settings::DEFAULT_DISPLAY_SCALING, DisplayScalingMode::Count);
SettingWidgetBinder::DisconnectWidget(m_ui.displayScaling24Bit);
m_ui.displayScaling24Bit->clear();
SettingWidgetBinder::BindWidgetToEnumSetting(nullptr, m_ui.displayScaling24Bit, "Display", "Scaling24Bit",
&Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
&Settings::GetDisplayScalingDisplayName,
Settings::DEFAULT_DISPLAY_SCALING, DisplayScalingMode::Count);
if (initial)
{
SettingWidgetBinder::BindWidgetToBoolSetting(nullptr, m_ui.pgxpEnable, "GPU", "PGXPEnable", false);

28
src/duckstation-qt/setupwizarddialog.ui
Unescape Escape View File

@ -881,30 +881,40 @@
</property>
</widget>
</item>
<item row="7" column="0" colspan="2">
<item row="8" column="0" colspan="2">
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="1">
<widget class="QCheckBox" name="widescreenHack">
<item row="0" column="0">
<widget class="QCheckBox" name="pgxpEnable">
<property name="toolTip">
<string>Scales vertex positions in screen-space to a widescreen aspect ratio, essentially increasing the field of view from 4:3 to the chosen display aspect ratio in 3D games. &lt;b&gt;&lt;u&gt;May not be compatible with all games.&lt;/u&gt;&lt;/b&gt;</string>
<string>Reduces &quot;wobbly&quot; polygons and &quot;warping&quot; textures that are common in PS1 games. &lt;strong&gt;May not be compatible with all games.&lt;/strong&gt;</string>
</property>
<property name="text">
<string>Widescreen Rendering</string>
<string>PGXP Geometry Correction</string>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QCheckBox" name="pgxpEnable">
<item row="0" column="1">
<widget class="QCheckBox" name="widescreenHack">
<property name="toolTip">
<string>Reduces &quot;wobbly&quot; polygons and &quot;warping&quot; textures that are common in PS1 games. &lt;strong&gt;May not be compatible with all games.&lt;/strong&gt;</string>
<string>Scales vertex positions in screen-space to a widescreen aspect ratio, essentially increasing the field of view from 4:3 to the chosen display aspect ratio in 3D games. &lt;b&gt;&lt;u&gt;May not be compatible with all games.&lt;/u&gt;&lt;/b&gt;</string>
</property>
<property name="text">
<string>PGXP Geometry Correction</string>
<string>Widescreen Rendering</string>
</property>
</widget>
</item>
</layout>
</item>
<item row="7" column="0">
<widget class="QLabel" name="label_22">
<property name="text">
<string>FMV Scaling:</string>
</property>
</widget>
</item>
<item row="7" column="1">
<widget class="QComboBox" name="displayScaling24Bit"/>
</item>
</layout>
</item>
<item>

Write Preview
Loading…
Cancel
Save