dahjah/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2026-03-26 20:38:33 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge 35ab5e1bb2 into 9b6bc7c1b4

Browse Source
This commit is contained in:
BehroozRezvani 2026-03-25 21:58:56 +03:00 committed by GitHub
commit f31d3f8c68
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 132 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rpcs3/Emu/RSX/GL/GLOverlays.cpp
View File

@ -399,6 +399,10 @@ namespace gl
void ui_overlay_renderer::run(gl::command_context& cmd_, const areau& viewport, GLuint target, rsx::overlays::overlay& ui, bool flip_vertically)
{
ui.set_render_viewport(
static_cast<u16>(std::min<u32>(viewport.width(), std::numeric_limits<u16>::max())),
static_cast<u16>(std::min<u32>(viewport.height(), std::numeric_limits<u16>::max()))
);
const auto ui_scale = color4f(static_cast<f32>(ui.virtual_width), static_cast<f32>(ui.virtual_height), 1.f, 1.f);
const auto ui_viewport = color4f(static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()), static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1));

4
rpcs3/Emu/RSX/GL/GLPresent.cpp
View File

@ -317,9 +317,11 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
// Lock to avoid modification during run-update chain
std::lock_guard lock(*m_overlay_manager);
const areau display_area = {0, 0, static_cast<u32>(m_frame->client_width()), static_cast<u32>(m_frame->client_height())};
for (const auto& view : m_overlay_manager->get_views())
{
m_ui_renderer.run(cmd, aspect_ratio, target, *view.get(), flip_vertically);
const areau render_area = view->use_window_space ? display_area : aspect_ratio;
m_ui_renderer.run(cmd, render_area, target, *view.get(), flip_vertically);
}
}
};

5
rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
View File

@ -252,10 +252,11 @@ namespace rsx
add_dropdown(&g_cfg.video.perf_overlay.position, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_POSITION);
add_checkbox(&g_cfg.video.perf_overlay.center_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_X);
add_checkbox(&g_cfg.video.perf_overlay.center_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_Y);
add_unsigned_slider(&g_cfg.video.perf_overlay.margin_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_X, " px", 1);
add_unsigned_slider(&g_cfg.video.perf_overlay.margin_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y, " px", 1);
add_float_slider(&g_cfg.video.perf_overlay.margin_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_X, " %", 0.25f);
add_float_slider(&g_cfg.video.perf_overlay.margin_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y, " %", 0.25f);
add_unsigned_slider(&g_cfg.video.perf_overlay.font_size, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE, " px", 1);
add_unsigned_slider(&g_cfg.video.perf_overlay.opacity, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY, " %", 1);
add_checkbox(&g_cfg.video.perf_overlay.perf_overlay_use_window_space, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE);
apply_layout();
}

69
rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
View File

@ -6,6 +6,7 @@
#include "Emu/Cell/PPUThread.h"
#include <algorithm>
#include <cmath>
#include <utility>
#include "util/cpu_stats.hpp"
@ -93,7 +94,6 @@ namespace rsx
{
// left, top, right, bottom
const areau padding { m_padding, m_padding - std::min<u32>(4, m_padding), m_padding, m_padding };
const positionu margin { m_margin_x, m_margin_y };
positionu pos;
u16 graph_width = 0;
@ -116,6 +116,26 @@ namespace rsx
graph_height += m_padding;
}
const u16 overlay_width = std::max(m_body.w, graph_width);
const u16 overlay_height = static_cast<u16>(m_body.h + graph_height);
const auto percent_to_margin_px = [](f32 margin_percent, u16 virtual_size, u16 overlay_size) -> u32
{
if (overlay_size >= virtual_size)
{
return 0;
}
const u32 max_margin = virtual_size - overlay_size;
const u32 margin_px = static_cast<u32>(std::lround((std::clamp(margin_percent, 0.0f, 100.0f) / 100.0f) * max_margin));
return std::min(margin_px, max_margin);
};
const positionu margin
{
percent_to_margin_px(m_margin_x, m_virtual_width, overlay_width),
percent_to_margin_px(m_margin_y, m_virtual_height, overlay_height)
};
switch (m_quadrant)
{
case screen_quadrant::top_left:
@ -123,27 +143,27 @@ namespace rsx
pos.y = margin.y;
break;
case screen_quadrant::top_right:
pos.x = virtual_width - std::max(m_body.w, graph_width) - margin.x;
pos.x = m_virtual_width - overlay_width - margin.x;
pos.y = margin.y;
break;
case screen_quadrant::bottom_left:
pos.x = margin.x;
pos.y = virtual_height - m_body.h - graph_height - margin.y;
pos.y = m_virtual_height - overlay_height - margin.y;
break;
case screen_quadrant::bottom_right:
pos.x = virtual_width - std::max(m_body.w, graph_width) - margin.x;
pos.y = virtual_height - m_body.h - graph_height - margin.y;
pos.x = m_virtual_width - overlay_width - margin.x;
pos.y = m_virtual_height - overlay_height - margin.y;
break;
}
if (m_center_x)
{
pos.x = (virtual_width - std::max(m_body.w, graph_width)) / 2;
pos.x = overlay_width >= m_virtual_width ? 0 : (m_virtual_width - overlay_width) / 2;
}
if (m_center_y)
{
pos.y = (virtual_height - m_body.h - graph_height) / 2;
pos.y = overlay_height >= m_virtual_height ? 0 : (m_virtual_height - overlay_height) / 2;
}
elm.set_pos(pos.x, pos.y);
@ -381,7 +401,7 @@ namespace rsx
m_force_repaint = true;
}
void perf_metrics_overlay::set_margins(u32 margin_x, u32 margin_y, bool center_x, bool center_y)
void perf_metrics_overlay::set_margins(f32 margin_x, f32 margin_y, bool center_x, bool center_y)
{
if (m_margin_x == margin_x && m_margin_y == margin_y && m_center_x == center_x && m_center_y == center_y)
return;
@ -431,6 +451,38 @@ namespace rsx
m_force_update = true;
}
void perf_metrics_overlay::set_render_viewport(u16 width, u16 height)
{
u16 new_virtual_width = virtual_width;
u16 new_virtual_height = virtual_height;
if (use_window_space && width > 0 && height > 0)
{
const double scale_x = static_cast<double>(width) / virtual_width;
const double scale_y = static_cast<double>(height) / virtual_height;
const double scale = std::min(scale_x, scale_y);
new_virtual_width = static_cast<u16>(std::min<u32>(
static_cast<u32>(std::lround(width / scale)),
std::numeric_limits<u16>::max()));
new_virtual_height = static_cast<u16>(std::min<u32>(
static_cast<u32>(std::lround(height / scale)),
std::numeric_limits<u16>::max()));
}
if (m_virtual_width == new_virtual_width && m_virtual_height == new_virtual_height)
return;
m_virtual_width = new_virtual_width;
m_virtual_height = new_virtual_height;
if (m_is_initialised)
{
reset_transforms();
}
}
void perf_metrics_overlay::update(u64 /*timestamp_us*/)
{
const auto elapsed_update = m_update_timer.GetElapsedTimeInMilliSec();
@ -897,6 +949,7 @@ namespace rsx
perf_overlay->set_font(perf_settings.font);
perf_overlay->set_font_size(perf_settings.font_size);
perf_overlay->set_margins(perf_settings.margin_x, perf_settings.margin_y, perf_settings.center_x.get(), perf_settings.center_y.get());
perf_overlay->use_window_space = perf_settings.perf_overlay_use_window_space.get();
perf_overlay->set_opacity(perf_settings.opacity / 100.f);
perf_overlay->set_body_colors(perf_settings.color_body, perf_settings.background_body);
perf_overlay->set_title_colors(perf_settings.color_title, perf_settings.background_title);

11
rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h
View File

@ -37,10 +37,12 @@ namespace rsx
u32 m_frames{};
std::string m_font{};
u16 m_font_size{};
u32 m_margin_x{}; // horizontal distance to the screen border relative to the screen_quadrant in px
u32 m_margin_y{}; // vertical distance to the screen border relative to the screen_quadrant in px
f32 m_margin_x{}; // horizontal distance to the screen border relative to the screen_quadrant in percent of the window width
f32 m_margin_y{}; // vertical distance to the screen border relative to the screen_quadrant in percent of the window height
u32 m_padding{}; // space between overlay elements
f32 m_opacity{}; // 0..1
u16 m_virtual_width{virtual_width};
u16 m_virtual_height{virtual_height};
bool m_center_x{}; // center the overlay horizontally
bool m_center_y{}; // center the overlay vertically
@ -96,11 +98,14 @@ namespace rsx
void set_update_interval(u32 update_interval);
void set_font(std::string font);
void set_font_size(u16 font_size);
void set_margins(u32 margin_x, u32 margin_y, bool center_x, bool center_y);
void set_margins(f32 margin_x, f32 margin_y, bool center_x, bool center_y);
void set_opacity(f32 opacity);
void set_body_colors(std::string color, std::string background);
void set_title_colors(std::string color, std::string background);
void force_next_update();
void set_render_viewport(u16 width, u16 height) override;
u16 get_virtual_width() const override { return m_virtual_width; }
u16 get_virtual_height() const override { return m_virtual_height; }
void update(u64 timestamp_us) override;

4
rpcs3/Emu/RSX/Overlays/overlays.h
View File

@ -46,6 +46,7 @@ namespace rsx
static constexpr u16 virtual_width = 1280;
static constexpr u16 virtual_height = 720;
bool use_window_space = false;
u32 min_refresh_duration_us = 16600;
atomic_t<bool> visible = false;
@ -57,6 +58,9 @@ namespace rsx
virtual compiled_resource get_compiled() = 0;
void refresh() const;
virtual u16 get_virtual_width() const { return virtual_width; }
virtual u16 get_virtual_height() const { return virtual_height; }
virtual void set_render_viewport(u16 /*width*/, u16 /*height*/) {}
};
// Interactable UI element

6
rpcs3/Emu/RSX/VK/VKOverlays.cpp
View File

@ -628,7 +628,11 @@ namespace vk
void ui_overlay_renderer::run(vk::command_buffer& cmd, const areau& viewport, vk::framebuffer* target, VkRenderPass render_pass,
vk::data_heap& upload_heap, rsx::overlays::overlay& ui)
{
m_scale_offset = color4f(ui.virtual_width, ui.virtual_height, 1.f, 1.f);
ui.set_render_viewport(
static_cast<u16>(std::min<u32>(viewport.width(), std::numeric_limits<u16>::max())),
static_cast<u16>(std::min<u32>(viewport.height(), std::numeric_limits<u16>::max()))
);
m_scale_offset = color4f(ui.get_virtual_width(), ui.get_virtual_height(), 1.f, 1.f);
m_viewport = { { static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1) }, { static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()) } };
std::vector<vk::image_view*> image_views

4
rpcs3/Emu/RSX/VK/VKPresent.cpp
View File

@ -663,9 +663,11 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
auto ui_renderer = vk::get_overlay_pass<vk::ui_overlay_renderer>();
std::lock_guard lock(*m_overlay_manager);
const areau display_area = {0, 0, static_cast<u32>(m_swapchain_dims.width), static_cast<u32>(m_swapchain_dims.height)};
for (const auto& view : m_overlay_manager->get_views())
{
ui_renderer->run(*m_current_command_buffer, area, fbo, single_target_pass, m_texture_upload_buffer_ring_info, *view.get());
const areau render_area = view->use_window_space ? display_area : area;
ui_renderer->run(*m_current_command_buffer, render_area, fbo, single_target_pass, m_texture_upload_buffer_ring_info, *view.get());
}
};

1
rpcs3/Emu/localized_string_id.h
View File

@ -270,6 +270,7 @@ enum class localized_string_id
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY,
HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE,
HOME_MENU_SETTINGS_DEBUG,
HOME_MENU_SETTINGS_DEBUG_OVERLAY,
HOME_MENU_SETTINGS_DEBUG_INPUT_OVERLAY,

5
rpcs3/Emu/system_config.h
View File

@ -209,8 +209,8 @@ struct cfg_root : cfg::node
cfg::uint<4, 36> font_size{ this, "Font size (px)", 10, true };
cfg::_enum<screen_quadrant> position{ this, "Position", screen_quadrant::top_left, true };
cfg::string font{ this, "Font", "n023055ms.ttf", true };
cfg::uint<0, 1280> margin_x{ this, "Horizontal Margin (px)", 50, true }; // horizontal distance to the screen border relative to the screen_quadrant in px
cfg::uint<0, 720> margin_y{ this, "Vertical Margin (px)", 50, true }; // vertical distance to the screen border relative to the screen_quadrant in px
cfg::_float<0, 100> margin_x{ this, "Horizontal Margin (%)", 4, true }; // horizontal distance to the window border relative to the screen_quadrant in percent of the window width
cfg::_float<0, 100> margin_y{ this, "Vertical Margin (%)", 7, true }; // vertical distance to the window border relative to the screen_quadrant in percent of the window height
cfg::_bool center_x{ this, "Center Horizontally", false, true };
cfg::_bool center_y{ this, "Center Vertically", false, true };
cfg::uint<0, 100> opacity{ this, "Opacity (%)", 70, true };
@ -218,6 +218,7 @@ struct cfg_root : cfg::node
cfg::string background_body{ this, "Body Background (hex)", "#002339FF", true };
cfg::string color_title{ this, "Title Color (hex)", "#F26C24FF", true };
cfg::string background_title{ this, "Title Background (hex)", "#00000000", true };
cfg::_bool perf_overlay_use_window_space{this, "Use Window Space", false, true};
} perf_overlay{ this };

6
rpcs3/rpcs3qt/emu_settings_type.h
View File

@ -127,6 +127,7 @@ enum class emu_settings_type
PerfOverlayMarginY,
PerfOverlayCenterX,
PerfOverlayCenterY,
PerfOverlayUseWindowSpace,
// Shader Loading Dialog
ShaderLoadBgEnabled,
@ -338,10 +339,11 @@ inline static const std::map<emu_settings_type, cfg_location> settings_location
{ emu_settings_type::PerfOverlayUpdateInterval, { "Video", "Performance Overlay", "Metrics update interval (ms)" } },
{ emu_settings_type::PerfOverlayFontSize, { "Video", "Performance Overlay", "Font size (px)" } },
{ emu_settings_type::PerfOverlayOpacity, { "Video", "Performance Overlay", "Opacity (%)" } },
{ emu_settings_type::PerfOverlayMarginX, { "Video", "Performance Overlay", "Horizontal Margin (px)" } },
{ emu_settings_type::PerfOverlayMarginY, { "Video", "Performance Overlay", "Vertical Margin (px)" } },
{ emu_settings_type::PerfOverlayMarginX, { "Video", "Performance Overlay", "Horizontal Margin (%)" } },
{ emu_settings_type::PerfOverlayMarginY, { "Video", "Performance Overlay", "Vertical Margin (%)" } },
{ emu_settings_type::PerfOverlayCenterX, { "Video", "Performance Overlay", "Center Horizontally" } },
{ emu_settings_type::PerfOverlayCenterY, { "Video", "Performance Overlay", "Center Vertically" } },
{ emu_settings_type::PerfOverlayUseWindowSpace, { "Video", "Performance Overlay", "Use Window Space"}},
// Shader Loading Dialog
{ emu_settings_type::ShaderLoadBgEnabled, { "Video", "Shader Loading Dialog", "Allow custom background" } },

1
rpcs3/rpcs3qt/localized_emu.h
View File

@ -290,6 +290,7 @@ private:
case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y: return tr("Vertical Margin", "Performance Overlay");
case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE: return tr("Font Size", "Performance Overlay");
case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY: return tr("Opacity", "Performance Overlay");
case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE: return tr("Use Window Space", "Performance Overlay");
case localized_string_id::HOME_MENU_SETTINGS_DEBUG: return tr("Debug");
case localized_string_id::HOME_MENU_SETTINGS_DEBUG_OVERLAY: return tr("Debug Overlay", "Debug");
case localized_string_id::HOME_MENU_SETTINGS_DEBUG_INPUT_OVERLAY: return tr("Input Debug Overlay", "Debug");

8
rpcs3/rpcs3qt/settings_dialog.cpp
View File

@ -1875,6 +1875,9 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
});
ui->perfOverlayMarginY->setEnabled(!ui->perfOverlayCenterY->isChecked());
m_emu_settings->EnhanceCheckBox(ui->perfOverlayUseWindowSpace, emu_settings_type::PerfOverlayUseWindowSpace);
SubscribeTooltip(ui->perfOverlayUseWindowSpace, tooltips.settings.perf_overlay_use_window_space);
m_emu_settings->EnhanceCheckBox(ui->perfOverlayFramerateGraphEnabled, emu_settings_type::PerfOverlayFramerateGraphEnabled);
SubscribeTooltip(ui->perfOverlayFramerateGraphEnabled, tooltips.settings.perf_overlay_framerate_graph_enabled);
@ -1901,6 +1904,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
ui->perfOverlayMarginY->setEnabled(enabled && !ui->perfOverlayCenterY->isChecked());
ui->perfOverlayCenterX->setEnabled(enabled);
ui->perfOverlayCenterY->setEnabled(enabled);
ui->perfOverlayUseWindowSpace->setEnabled(enabled);
ui->perfOverlayFramerateGraphEnabled->setEnabled(enabled);
ui->perfOverlayFrametimeGraphEnabled->setEnabled(enabled);
ui->perf_overlay_framerate_datapoints->setEnabled(enabled);
@ -1946,10 +1950,10 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
// SpinBoxes
m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginX, emu_settings_type::PerfOverlayMarginX, "", tr("px", "Performance overlay margin x"));
m_emu_settings->EnhanceDoubleSpinBox(ui->perfOverlayMarginX, emu_settings_type::PerfOverlayMarginX, "", tr("%", "Performance overlay margin x"));
SubscribeTooltip(ui->perfOverlayMarginX, tooltips.settings.perf_overlay_margin_x);
m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginY, emu_settings_type::PerfOverlayMarginY, "", tr("px", "Performance overlay margin y"));
m_emu_settings->EnhanceDoubleSpinBox(ui->perfOverlayMarginY, emu_settings_type::PerfOverlayMarginY, "", tr("%", "Performance overlay margin y"));
SubscribeTooltip(ui->perfOverlayMarginY, tooltips.settings.perf_overlay_margin_y);
// Global settings (gui_settings)

25
rpcs3/rpcs3qt/settings_dialog.ui
View File

@ -3524,7 +3524,14 @@
</widget>
</item>
<item>
<widget class="QSpinBox" name="perfOverlayMarginX"/>
<widget class="QDoubleSpinBox" name="perfOverlayMarginX">
<property name="decimals">
<number>1</number>
</property>
<property name="singleStep">
<double>0.5</double>
</property>
</widget>
</item>
</layout>
</item>
@ -3545,10 +3552,24 @@
</widget>
</item>
<item>
<widget class="QSpinBox" name="perfOverlayMarginY"/>
<widget class="QDoubleSpinBox" name="perfOverlayMarginY">
<property name="decimals">
<number>1</number>
</property>
<property name="singleStep">
<double>0.5</double>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="perfOverlayUseWindowSpace">
<property name="text">
<string>Use Window Space</string>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="perf_overlay_update_interval" native="true">
<layout class="QVBoxLayout" name="layout_perf_overlay_update_interval">

5
rpcs3/rpcs3qt/tooltips.h
View File

@ -169,10 +169,11 @@ public:
const QString perf_overlay_update_interval = tr("Sets the time interval in which the performance overlay is being updated (measured in milliseconds).\nSetting this to 16 milliseconds will refresh the performance overlay at roughly 60Hz.\nThe performance overlay refresh rate does not affect the frame graph statistics and can only be as fast as the current game allows.");
const QString perf_overlay_font_size = tr("Sets the font size of the performance overlay (measured in pixels).");
const QString perf_overlay_opacity = tr("Sets the opacity of the performance overlay (measured in %).");
const QString perf_overlay_margin_x = tr("Sets the horizontal distance to the screen border relative to the screen quadrant (measured in pixels).");
const QString perf_overlay_margin_y = tr("Sets the vertical distance to the screen border relative to the screen quadrant (measured in pixels).");
const QString perf_overlay_margin_x = tr("Sets the horizontal distance to the screen border relative to the screen quadrant (measured in %).");
const QString perf_overlay_margin_y = tr("Sets the vertical distance to the screen border relative to the screen quadrant (measured in %).");
const QString perf_overlay_center_x = tr("Centers the performance overlay horizontally and overrides the horizontal margin.");
const QString perf_overlay_center_y = tr("Centers the performance overlay vertically and overrides the vertical margin.");
const QString perf_overlay_use_window_space = tr("Position overlay relative to the full window surface, enabling placement outside game's render area.");
const QString shader_load_bg_enabled = tr("Shows a background image during the native shader loading dialog/loading screen.\nBy default the used image will be <gamedir>/PS3_GAME/PIC1.PNG.");
const QString shader_load_bg_darkening = tr("Changes the background image darkening effect strength of the native shader loading dialog.\nThis may be used to improve readability and/or aesthetics.");