hipnosuer
/
Zuma
forked from ShuriZma/suyu
1
0
Fork 0
Code Pull Requests Activity

Merge pull request #1753 from jroweboy/frame_layouts 

Support additional screen layouts.
This commit is contained in:
bunnei 2016-11-15 19:57:08 -05:00 committed by GitHub
parent 3b4f134c08 793339b73a
commit 5a31552764
19 changed files with 373 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/citra/config.cpp
View File

@ -72,6 +72,11 @@ void Config::ReadValues() {
Settings::values.bg_green = (float)sdl2_config->GetReal("Renderer", "bg_green", 1.0);
Settings::values.bg_blue = (float)sdl2_config->GetReal("Renderer", "bg_blue", 1.0);
// Layout
Settings::values.layout_option =
static_cast<Settings::LayoutOption>(sdl2_config->GetInteger("Layout", "layout_option", 0));
Settings::values.swap_screen = sdl2_config->GetBoolean("Layout", "swap_screen", false);
// Audio
Settings::values.sink_id = sdl2_config->Get("Audio", "output_engine", "auto");
Settings::values.enable_audio_stretching =

10
src/citra/default_ini.h
View File

@ -63,6 +63,16 @@ use_scaled_resolution =
# 0 (default): Off, 1: On
use_vsync =
[Layout]
# Layout for the screen inside the render window.
# 0 (default): Default Top Bottom Screen, 1: Single Screen Only, 2: Large Screen Small Screen
layout_option =
# Swaps the prominent screen with the other screen.
# For example, if Single Screen is chosen, setting this to 1 will display the bottom screen instead of the top screen.
# 0 (default): Top Screen is prominent, 1: Bottom Screen is prominent
swap_screen =
# The clear color for the renderer. What shows up on the sides of the bottom screen.
# Must be in range of 0.0-1.0. Defaults to 1.0 for all.
bg_red =

5
src/citra/emu_window/emu_window_sdl2.cpp
View File

@ -46,11 +46,8 @@ bool EmuWindow_SDL2::IsOpen() const {
void EmuWindow_SDL2::OnResize() {
int width, height;
SDL_GetWindowSize(render_window, &width, &height);
NotifyFramebufferLayoutChanged(
EmuWindow::FramebufferLayout::DefaultScreenLayout(width, height));
UpdateCurrentFramebufferLayout(width, height);
}
EmuWindow_SDL2::EmuWindow_SDL2() {

4
src/citra_qt/bootmanager.cpp
View File

@ -161,9 +161,7 @@ void GRenderWindow::OnFramebufferSizeChanged() {
qreal pixelRatio = windowPixelRatio();
unsigned width = child->QPaintDevice::width() * pixelRatio;
unsigned height = child->QPaintDevice::height() * pixelRatio;
NotifyFramebufferLayoutChanged(
EmuWindow::FramebufferLayout::DefaultScreenLayout(width, height));
UpdateCurrentFramebufferLayout(width, height);
}
void GRenderWindow::BackupGeometry() {

11
src/citra_qt/config.cpp
View File

@ -54,6 +54,12 @@ void Config::ReadValues() {
Settings::values.bg_blue = qt_config->value("bg_blue", 1.0).toFloat();
qt_config->endGroup();
qt_config->beginGroup("Layout");
Settings::values.layout_option =
static_cast<Settings::LayoutOption>(qt_config->value("layout_option").toInt());
Settings::values.swap_screen = qt_config->value("swap_screen", false).toBool();
qt_config->endGroup();
qt_config->beginGroup("Audio");
Settings::values.sink_id = qt_config->value("output_engine", "auto").toString().toStdString();
Settings::values.enable_audio_stretching =
@ -155,6 +161,11 @@ void Config::SaveValues() {
qt_config->setValue("bg_blue", (double)Settings::values.bg_blue);
qt_config->endGroup();
qt_config->beginGroup("Layout");
qt_config->setValue("layout_option", static_cast<int>(Settings::values.layout_option));
qt_config->setValue("swap_screen", Settings::values.swap_screen);
qt_config->endGroup();
qt_config->beginGroup("Audio");
qt_config->setValue("output_engine", QString::fromStdString(Settings::values.sink_id));
qt_config->setValue("enable_audio_stretching", Settings::values.enable_audio_stretching);

1
src/citra_qt/configure_dialog.cpp
View File

@ -23,4 +23,5 @@ void ConfigureDialog::applyConfiguration() {
ui->graphicsTab->applyConfiguration();
ui->audioTab->applyConfiguration();
ui->debugTab->applyConfiguration();
Settings::Apply();
}

5
src/citra_qt/configure_graphics.cpp
View File

@ -23,6 +23,8 @@ void ConfigureGraphics::setConfiguration() {
ui->toggle_shader_jit->setChecked(Settings::values.use_shader_jit);
ui->toggle_scaled_resolution->setChecked(Settings::values.use_scaled_resolution);
ui->toggle_vsync->setChecked(Settings::values.use_vsync);
ui->layout_combobox->setCurrentIndex(static_cast<int>(Settings::values.layout_option));
ui->swap_screen->setChecked(Settings::values.swap_screen);
}
void ConfigureGraphics::applyConfiguration() {
@ -30,5 +32,8 @@ void ConfigureGraphics::applyConfiguration() {
Settings::values.use_shader_jit = ui->toggle_shader_jit->isChecked();
Settings::values.use_scaled_resolution = ui->toggle_scaled_resolution->isChecked();
Settings::values.use_vsync = ui->toggle_vsync->isChecked();
Settings::values.layout_option =
static_cast<Settings::LayoutOption>(ui->layout_combobox->currentIndex());
Settings::values.swap_screen = ui->swap_screen->isChecked();
Settings::Apply();
}

125
src/citra_qt/configure_graphics.ui
View File

@ -22,39 +22,89 @@
<string>Graphics</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QCheckBox" name="toggle_hw_renderer">
<property name="text">
<string>Enable hardware renderer</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_shader_jit">
<property name="text">
<string>Enable shader JIT</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_scaled_resolution">
<property name="text">
<string>Enable scaled resolution</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_vsync">
<property name="text">
<string>Enable V-Sync</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_hw_renderer">
<property name="text">
<string>Enable hardware renderer</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_shader_jit">
<property name="text">
<string>Enable shader JIT</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_scaled_resolution">
<property name="text">
<string>Enable scaled resolution</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="toggle_vsync">
<property name="text">
<string>Enable V-Sync</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="groupBox2">
<property name="title">
<string>Layout</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label1">
<property name="text">
<string>Screen Layout:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="layout_combobox">
<item>
<property name="text">
<string notr="true">Default</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">Single Screen</string>
</property>
</item>
<item>
<property name="text">
<string notr="true">Large Screen</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="swap_screen">
<property name="text">
<string>Swap Screens</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
@ -71,22 +121,5 @@
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>toggle_gdbstub</sender>
<signal>toggled(bool)</signal>
<receiver>gdbport_spinbox</receiver>
<slot>setEnabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>84</x>
<y>157</y>
</hint>
<hint type="destinationlabel">
<x>342</x>
<y>158</y>
</hint>
</hints>
</connection>
</connections>
<connections/>
</ui>

8
src/citra_qt/main.cpp
View File

@ -196,6 +196,7 @@ GMainWindow::GMainWindow() : config(new Config()), emu_thread(nullptr) {
// Setup hotkeys
RegisterHotkey("Main Window", "Load File", QKeySequence::Open);
RegisterHotkey("Main Window", "Swap Screens", QKeySequence::NextChild);
RegisterHotkey("Main Window", "Start Emulation");
LoadHotkeys();
@ -203,6 +204,8 @@ GMainWindow::GMainWindow() : config(new Config()), emu_thread(nullptr) {
SLOT(OnMenuLoadFile()));
connect(GetHotkey("Main Window", "Start Emulation", this), SIGNAL(activated()), this,
SLOT(OnStartGame()));
connect(GetHotkey("Main Window", "Swap Screens", this), SIGNAL(activated()), this,
SLOT(OnSwapScreens()));
std::string window_title =
Common::StringFromFormat("Citra | %s-%s", Common::g_scm_branch, Common::g_scm_desc);
@ -550,6 +553,11 @@ void GMainWindow::OnConfigure() {
}
}
void GMainWindow::OnSwapScreens() {
Settings::values.swap_screen = !Settings::values.swap_screen;
Settings::Apply();
}
void GMainWindow::OnCreateGraphicsSurfaceViewer() {
auto graphicsSurfaceViewerWidget = new GraphicsSurfaceWidget(Pica::g_debug_context, this);
addDockWidget(Qt::RightDockWidgetArea, graphicsSurfaceViewerWidget);

1
src/citra_qt/main.h
View File

@ -105,6 +105,7 @@ private slots:
/// Called whenever a user selects the "File->Select Game List Root" menu item
void OnMenuSelectGameListRoot();
void OnMenuRecentFile();
void OnSwapScreens();
void OnConfigure();
void OnDisplayTitleBars(bool);
void ToggleWindowMode();

2
src/common/CMakeLists.txt
View File

@ -5,6 +5,7 @@ set(SRCS
break_points.cpp
emu_window.cpp
file_util.cpp
framebuffer_layout.cpp
hash.cpp
key_map.cpp
logging/filter.cpp
@ -35,6 +36,7 @@ set(HEADERS
common_types.h
emu_window.h
file_util.h
framebuffer_layout.h
hash.h
key_map.h
linear_disk_cache.h

68
src/common/emu_window.cpp
View File

@ -40,7 +40,7 @@ void EmuWindow::CirclePadUpdated(float x, float y) {
* @param framebuffer_y Framebuffer y-coordinate to check
* @return True if the coordinates are within the touchpad, otherwise false
*/
static bool IsWithinTouchscreen(const EmuWindow::FramebufferLayout& layout, unsigned framebuffer_x,
static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigned framebuffer_x,
unsigned framebuffer_y) {
return (
framebuffer_y >= layout.bottom_screen.top && framebuffer_y < layout.bottom_screen.bottom &&
@ -89,57 +89,19 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
TouchPressed(framebuffer_x, framebuffer_y);
}
EmuWindow::FramebufferLayout EmuWindow::FramebufferLayout::DefaultScreenLayout(unsigned width,
unsigned height) {
// When hiding the widget, the function receives a size of 0
if (width == 0)
width = 1;
if (height == 0)
height = 1;
EmuWindow::FramebufferLayout res = {width, height, {}, {}};
float window_aspect_ratio = static_cast<float>(height) / width;
float emulation_aspect_ratio =
static_cast<float>(VideoCore::kScreenTopHeight * 2) / VideoCore::kScreenTopWidth;
if (window_aspect_ratio > emulation_aspect_ratio) {
// Window is narrower than the emulation content => apply borders to the top and bottom
int viewport_height = static_cast<int>(std::round(emulation_aspect_ratio * width));
res.top_screen.left = 0;
res.top_screen.right = res.top_screen.left + width;
res.top_screen.top = (height - viewport_height) / 2;
res.top_screen.bottom = res.top_screen.top + viewport_height / 2;
int bottom_width = static_cast<int>(
(static_cast<float>(VideoCore::kScreenBottomWidth) / VideoCore::kScreenTopWidth) *
(res.top_screen.right - res.top_screen.left));
int bottom_border = ((res.top_screen.right - res.top_screen.left) - bottom_width) / 2;
res.bottom_screen.left = bottom_border;
res.bottom_screen.right = res.bottom_screen.left + bottom_width;
res.bottom_screen.top = res.top_screen.bottom;
res.bottom_screen.bottom = res.bottom_screen.top + viewport_height / 2;
} else {
// Otherwise, apply borders to the left and right sides of the window.
int viewport_width = static_cast<int>(std::round(height / emulation_aspect_ratio));
res.top_screen.left = (width - viewport_width) / 2;
res.top_screen.right = res.top_screen.left + viewport_width;
res.top_screen.top = 0;
res.top_screen.bottom = res.top_screen.top + height / 2;
int bottom_width = static_cast<int>(
(static_cast<float>(VideoCore::kScreenBottomWidth) / VideoCore::kScreenTopWidth) *
(res.top_screen.right - res.top_screen.left));
int bottom_border = ((res.top_screen.right - res.top_screen.left) - bottom_width) / 2;
res.bottom_screen.left = res.top_screen.left + bottom_border;
res.bottom_screen.right = res.bottom_screen.left + bottom_width;
res.bottom_screen.top = res.top_screen.bottom;
res.bottom_screen.bottom = res.bottom_screen.top + height / 2;
void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) {
Layout::FramebufferLayout layout;
switch (Settings::values.layout_option) {
case Settings::LayoutOption::SingleScreen:
layout = Layout::SingleFrameLayout(width, height, Settings::values.swap_screen);
break;
case Settings::LayoutOption::LargeScreen:
layout = Layout::LargeFrameLayout(width, height, Settings::values.swap_screen);
break;
case Settings::LayoutOption::Default:
default:
layout = Layout::DefaultFrameLayout(width, height, Settings::values.swap_screen);
break;
}
return res;
NotifyFramebufferLayoutChanged(layout);
}

30
src/common/emu_window.h
View File

@ -7,6 +7,7 @@
#include <tuple>
#include <utility>
#include "common/common_types.h"
#include "common/framebuffer_layout.h"
#include "common/math_util.h"
#include "core/hle/service/hid/hid.h"
@ -38,23 +39,6 @@ public:
std::pair<unsigned, unsigned> min_client_area_size;
};
/// Describes the layout of the window framebuffer (size and top/bottom screen positions)
struct FramebufferLayout {
/**
* Factory method for constructing a default FramebufferLayout
* @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
static FramebufferLayout DefaultScreenLayout(unsigned width, unsigned height);
unsigned width;
unsigned height;
MathUtil::Rectangle<unsigned> top_screen;
MathUtil::Rectangle<unsigned> bottom_screen;
};
/// Swap buffers to display the next frame
virtual void SwapBuffers() = 0;
@ -211,10 +195,16 @@ public:
* Gets the framebuffer layout (width, height, and screen regions)
* @note This method is thread-safe
*/
const FramebufferLayout& GetFramebufferLayout() const {
const Layout::FramebufferLayout& GetFramebufferLayout() const {
return framebuffer_layout;
}
/**
* Convenience method to update the current frame layout
* Read from the current settings to determine which layout to use.
*/
void UpdateCurrentFramebufferLayout(unsigned width, unsigned height);
protected:
EmuWindow() {
// TODO: Find a better place to set this.
@ -250,7 +240,7 @@ protected:
* Update framebuffer layout with the given parameter.
* @note EmuWindow implementations will usually use this in window resize event handlers.
*/
void NotifyFramebufferLayoutChanged(const FramebufferLayout& layout) {
void NotifyFramebufferLayoutChanged(const Layout::FramebufferLayout& layout) {
framebuffer_layout = layout;
}
@ -274,7 +264,7 @@ private:
// By default, ignore this request and do nothing.
}
FramebufferLayout framebuffer_layout; ///< Current framebuffer layout
Layout::FramebufferLayout framebuffer_layout; ///< Current framebuffer layout
unsigned client_area_width; ///< Current client width, should be set by window impl.
unsigned client_area_height; ///< Current client height, should be set by window impl.

138
src/common/framebuffer_layout.cpp Normal file
View File

@ -0,0 +1,138 @@
// Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <cmath>
#include "common/assert.h"
#include "common/framebuffer_layout.h"
#include "video_core/video_core.h"
namespace Layout {
static const float TOP_SCREEN_ASPECT_RATIO =
static_cast<float>(VideoCore::kScreenTopHeight) / VideoCore::kScreenTopWidth;
static const float BOT_SCREEN_ASPECT_RATIO =
static_cast<float>(VideoCore::kScreenBottomHeight) / VideoCore::kScreenBottomWidth;
// Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
template <class T>
static MathUtil::Rectangle<T> maxRectangle(MathUtil::Rectangle<T> window_area,
float screen_aspect_ratio) {
float scale = std::min(static_cast<float>(window_area.GetWidth()),
window_area.GetHeight() / screen_aspect_ratio);
return MathUtil::Rectangle<T>{0, 0, static_cast<T>(std::round(scale)),
static_cast<T>(std::round(scale * screen_aspect_ratio))};
}
FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height, bool swapped) {
ASSERT(width > 0);
ASSERT(height > 0);
FramebufferLayout res{width, height, true, true, {}, {}};
// Default layout gives equal screen sizes to the top and bottom screen
MathUtil::Rectangle<unsigned> screen_window_area{0, 0, width, height / 2};
MathUtil::Rectangle<unsigned> top_screen =
maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
MathUtil::Rectangle<unsigned> bot_screen =
maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
float window_aspect_ratio = static_cast<float>(height) / width;
// both screens height are taken into account by multiplying by 2
float emulation_aspect_ratio = TOP_SCREEN_ASPECT_RATIO * 2;
if (window_aspect_ratio < emulation_aspect_ratio) {
// Apply borders to the left and right sides of the window.
top_screen =
top_screen.TranslateX((screen_window_area.GetWidth() - top_screen.GetWidth()) / 2);
bot_screen =
bot_screen.TranslateX((screen_window_area.GetWidth() - bot_screen.GetWidth()) / 2);
} else {
// Window is narrower than the emulation content => apply borders to the top and bottom
// Recalculate the bottom screen to account for the width difference between top and bottom
screen_window_area = {0, 0, width, top_screen.GetHeight()};
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
bot_screen = bot_screen.TranslateX((top_screen.GetWidth() - bot_screen.GetWidth()) / 2);
if (swapped) {
bot_screen = bot_screen.TranslateY(height / 2 - bot_screen.GetHeight());
} else {
top_screen = top_screen.TranslateY(height / 2 - top_screen.GetHeight());
}
}
// Move the top screen to the bottom if we are swapped.
res.top_screen = swapped ? top_screen.TranslateY(height / 2) : top_screen;
res.bottom_screen = swapped ? bot_screen : bot_screen.TranslateY(height / 2);
return res;
}
FramebufferLayout SingleFrameLayout(unsigned width, unsigned height, bool swapped) {
ASSERT(width > 0);
ASSERT(height > 0);
// The drawing code needs at least somewhat valid values for both screens
// so just calculate them both even if the other isn't showing.
FramebufferLayout res{width, height, !swapped, swapped, {}, {}};
MathUtil::Rectangle<unsigned> screen_window_area{0, 0, width, height};
MathUtil::Rectangle<unsigned> top_screen =
maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
MathUtil::Rectangle<unsigned> bot_screen =
maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
float window_aspect_ratio = static_cast<float>(height) / width;
float emulation_aspect_ratio = (swapped) ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO;
if (window_aspect_ratio < emulation_aspect_ratio) {
top_screen =
top_screen.TranslateX((screen_window_area.GetWidth() - top_screen.GetWidth()) / 2);
bot_screen =
bot_screen.TranslateX((screen_window_area.GetWidth() - bot_screen.GetWidth()) / 2);
} else {
top_screen = top_screen.TranslateY((height - top_screen.GetHeight()) / 2);
bot_screen = bot_screen.TranslateY((height - bot_screen.GetHeight()) / 2);
}
res.top_screen = top_screen;
res.bottom_screen = bot_screen;
return res;
}
FramebufferLayout LargeFrameLayout(unsigned width, unsigned height, bool swapped) {
ASSERT(width > 0);
ASSERT(height > 0);
FramebufferLayout res{width, height, true, true, {}, {}};
// Split the window into two parts. Give 4x width to the main screen and 1x width to the small
// To do that, find the total emulation box and maximize that based on window size
float window_aspect_ratio = static_cast<float>(height) / width;
float emulation_aspect_ratio =
swapped
? VideoCore::kScreenBottomHeight * 4 /
(VideoCore::kScreenBottomWidth * 4.0f + VideoCore::kScreenTopWidth)
: VideoCore::kScreenTopHeight * 4 /
(VideoCore::kScreenTopWidth * 4.0f + VideoCore::kScreenBottomWidth);
float large_screen_aspect_ratio = swapped ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO;
float small_screen_aspect_ratio = swapped ? TOP_SCREEN_ASPECT_RATIO : BOT_SCREEN_ASPECT_RATIO;
MathUtil::Rectangle<unsigned> screen_window_area{0, 0, width, height};
MathUtil::Rectangle<unsigned> total_rect =
maxRectangle(screen_window_area, emulation_aspect_ratio);
MathUtil::Rectangle<unsigned> large_screen =
maxRectangle(total_rect, large_screen_aspect_ratio);
MathUtil::Rectangle<unsigned> fourth_size_rect = total_rect.Scale(.25f);
MathUtil::Rectangle<unsigned> small_screen =
maxRectangle(fourth_size_rect, small_screen_aspect_ratio);
if (window_aspect_ratio < emulation_aspect_ratio) {
large_screen =
large_screen.TranslateX((screen_window_area.GetWidth() - total_rect.GetWidth()) / 2);
} else {
large_screen = large_screen.TranslateY((height - total_rect.GetHeight()) / 2);
}
// Shift the small screen to the bottom right corner
small_screen =
small_screen.TranslateX(large_screen.right)
.TranslateY(large_screen.GetHeight() + large_screen.top - small_screen.GetHeight());
res.top_screen = swapped ? small_screen : large_screen;
res.bottom_screen = swapped ? large_screen : small_screen;
return res;
}
}

47
src/common/framebuffer_layout.h Normal file
View File

@ -0,0 +1,47 @@
// Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include "common/math_util.h"
namespace Layout {
/// Describes the layout of the window framebuffer (size and top/bottom screen positions)
struct FramebufferLayout {
unsigned width;
unsigned height;
bool top_screen_enabled;
bool bottom_screen_enabled;
MathUtil::Rectangle<unsigned> top_screen;
MathUtil::Rectangle<unsigned> bottom_screen;
};
/**
* Factory method for constructing a default FramebufferLayout
* @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be displayed above the top screen
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height, bool is_swapped);
/**
* Factory method for constructing a FramebufferLayout with only the top or bottom screen
* @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be displayed (and the top won't be displayed)
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
FramebufferLayout SingleFrameLayout(unsigned width, unsigned height, bool is_swapped);
/**
* Factory method for constructing a Frame with the a 4x size Top screen with a 1x size bottom
* screen on the right
* This is useful in particular because it matches well with a 1920x1080 resolution monitor
* @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be the large display
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
FramebufferLayout LargeFrameLayout(unsigned width, unsigned height, bool is_swapped);
}

10
src/common/math_util.h
View File

@ -38,6 +38,16 @@ struct Rectangle {
T GetHeight() const {
return std::abs(static_cast<typename std::make_signed<T>::type>(bottom - top));
}
Rectangle<T> TranslateX(const T x) const {
return Rectangle{left + x, top, right + x, bottom};
}
Rectangle<T> TranslateY(const T y) const {
return Rectangle{left, top + y, right, bottom + y};
}
Rectangle<T> Scale(const float s) const {
return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
static_cast<T>(top + GetHeight() * s)};
}
};
} // namespace MathUtil

7
src/core/settings.cpp
View File

@ -7,6 +7,8 @@
#include "settings.h"
#include "video_core/video_core.h"
#include "common/emu_window.h"
namespace Settings {
Values values = {};
@ -20,6 +22,11 @@ void Apply() {
VideoCore::g_shader_jit_enabled = values.use_shader_jit;
VideoCore::g_scaled_resolution_enabled = values.use_scaled_resolution;
if (VideoCore::g_emu_window) {
auto layout = VideoCore::g_emu_window->GetFramebufferLayout();
VideoCore::g_emu_window->UpdateCurrentFramebufferLayout(layout.width, layout.height);
}
AudioCore::SelectSink(values.sink_id);
AudioCore::EnableStretching(values.enable_audio_stretching);
}

11
src/core/settings.h
View File

@ -10,7 +10,15 @@
namespace Settings {
enum class LayoutOption {
Default,
SingleScreen,
LargeScreen,
Custom,
};
namespace NativeInput {
enum Values {
// directly mapped keys
A,
@ -84,6 +92,9 @@ struct Values {
bool use_scaled_resolution;
bool use_vsync;
LayoutOption layout_option;
bool swap_screen;
float bg_red;
float bg_green;
float bg_blue;

17
src/video_core/renderer_opengl/renderer_opengl.cpp
View File

@ -390,6 +390,8 @@ void RendererOpenGL::DrawSingleScreenRotated(const ScreenInfo& screen_info, floa
*/
void RendererOpenGL::DrawScreens() {
auto layout = render_window->GetFramebufferLayout();
const auto& top_screen = layout.top_screen;
const auto& bottom_screen = layout.bottom_screen;
glViewport(0, 0, layout.width, layout.height);
glClear(GL_COLOR_BUFFER_BIT);
@ -403,12 +405,15 @@ void RendererOpenGL::DrawScreens() {
glActiveTexture(GL_TEXTURE0);
glUniform1i(uniform_color_texture, 0);
DrawSingleScreenRotated(screen_infos[0], (float)layout.top_screen.left,
(float)layout.top_screen.top, (float)layout.top_screen.GetWidth(),
(float)layout.top_screen.GetHeight());
DrawSingleScreenRotated(screen_infos[1], (float)layout.bottom_screen.left,
(float)layout.bottom_screen.top, (float)layout.bottom_screen.GetWidth(),
(float)layout.bottom_screen.GetHeight());
if (layout.top_screen_enabled) {
DrawSingleScreenRotated(screen_infos[0], (float)top_screen.left, (float)top_screen.top,
(float)top_screen.GetWidth(), (float)top_screen.GetHeight());
}
if (layout.bottom_screen_enabled) {
DrawSingleScreenRotated(screen_infos[1], (float)bottom_screen.left,
(float)bottom_screen.top, (float)bottom_screen.GetWidth(),
(float)bottom_screen.GetHeight());
}
m_current_frame++;
}