citra-emu
/
citra-nightly
Archived
1
0
Fork 0
Code

framebuffer_layout.cpp mini refactor (#7300) 

* framebuffer_layout.cpp: simplify FrameLayoutFromResolutionScale

- upright_screen seems to only be swapped width and height calculation, so it is replaced with std::swap
- Get rid of call to GetCardboardSettings, The FrameLayoutFromResolutionScale function is used for Screenshots and Video Dumping where we dont need 3D effects

* framebuffer_layout.cpp: Combine SideFrameLayout and MobileLandscapeFrameLayout into variants of LargeFrameLayout

* framebuffer_layout.{cpp,h}: rename maxRectangle to MaxRectangle, plus

minor documentation update

* clang-format
This commit is contained in:
SachinVin 2024-01-02 14:22:03 +05:30 committed by GitHub
parent 7dd9174d31
commit 9b147d3f9c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 194 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/core/frontend/emu_window.cpp
View File

@ -173,8 +173,7 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) {
TouchPressed(framebuffer_x, framebuffer_y); TouchPressed(framebuffer_x, framebuffer_y);
} }
void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height, void EmuWindow::UpdateCurrentFramebufferLayout(u32 width, u32 height, bool is_portrait_mode) {
bool is_portrait_mode) {
Layout::FramebufferLayout layout; Layout::FramebufferLayout layout;
// If in portrait mode, only the MobilePortrait option really makes sense // If in portrait mode, only the MobilePortrait option really makes sense
@ -200,7 +199,8 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
layout = layout =
Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(), Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue(), Settings::values.upright_screen.GetValue(),
Settings::values.large_screen_proportion.GetValue()); Settings::values.large_screen_proportion.GetValue(),
Layout::VerticalAlignment::Bottom);
break; break;
case Settings::LayoutOption::HybridScreen: case Settings::LayoutOption::HybridScreen:
layout = layout =
@ -208,8 +208,10 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
Settings::values.upright_screen.GetValue()); Settings::values.upright_screen.GetValue());
break; break;
case Settings::LayoutOption::SideScreen: case Settings::LayoutOption::SideScreen:
layout = Layout::SideFrameLayout(width, height, Settings::values.swap_screen.GetValue(), layout =
Settings::values.upright_screen.GetValue()); Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue(), 1.0f,
Layout::VerticalAlignment::Bottom);
break; break;
#ifndef ANDROID #ifndef ANDROID
case Settings::LayoutOption::SeparateWindows: case Settings::LayoutOption::SeparateWindows:
@ -222,8 +224,9 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height,
Settings::values.swap_screen.GetValue()); Settings::values.swap_screen.GetValue());
break; break;
case Settings::LayoutOption::MobileLandscape: case Settings::LayoutOption::MobileLandscape:
layout = Layout::MobileLandscapeFrameLayout( layout =
width, height, Settings::values.swap_screen.GetValue(), 2.25f, false); Layout::LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
false, 2.25f, Layout::VerticalAlignment::Top);
break; break;
case Settings::LayoutOption::Default: case Settings::LayoutOption::Default:
default: default:

293
src/core/frontend/framebuffer_layout.cpp
View File

@ -30,7 +30,7 @@ u32 FramebufferLayout::GetScalingRatio() const {
// Finds the largest size subrectangle contained in window area that is confined to the aspect ratio // Finds the largest size subrectangle contained in window area that is confined to the aspect ratio
template <class T> template <class T>
static Common::Rectangle<T> maxRectangle(Common::Rectangle<T> window_area, static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
float screen_aspect_ratio) { float screen_aspect_ratio) {
float scale = std::min(static_cast<float>(window_area.GetWidth()), float scale = std::min(static_cast<float>(window_area.GetWidth()),
window_area.GetHeight() / screen_aspect_ratio); window_area.GetHeight() / screen_aspect_ratio);
@ -50,15 +50,15 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
if (upright) { if (upright) {
// Default layout gives equal screen sizes to the top and bottom screen // Default layout gives equal screen sizes to the top and bottom screen
screen_window_area = {0, 0, width / 2, height}; screen_window_area = {0, 0, width / 2, height};
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO); top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
// both screens width are taken into account by dividing by 2 // both screens width are taken into account by dividing by 2
emulation_aspect_ratio = TOP_SCREEN_UPRIGHT_ASPECT_RATIO / 2; emulation_aspect_ratio = TOP_SCREEN_UPRIGHT_ASPECT_RATIO / 2;
} else { } else {
// Default layout gives equal screen sizes to the top and bottom screen // Default layout gives equal screen sizes to the top and bottom screen
screen_window_area = {0, 0, width, height / 2}; screen_window_area = {0, 0, width, height / 2};
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO); top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
// both screens height are taken into account by multiplying by 2 // both screens height are taken into account by multiplying by 2
emulation_aspect_ratio = TOP_SCREEN_ASPECT_RATIO * 2; emulation_aspect_ratio = TOP_SCREEN_ASPECT_RATIO * 2;
} }
@ -71,7 +71,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
// Recalculate the bottom screen to account for the height difference between right and // Recalculate the bottom screen to account for the height difference between right and
// left // left
screen_window_area = {0, 0, top_screen.GetWidth(), height}; screen_window_area = {0, 0, top_screen.GetWidth(), height};
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
bot_screen = bot_screen =
bot_screen.TranslateY((top_screen.GetHeight() - bot_screen.GetHeight()) / 2); bot_screen.TranslateY((top_screen.GetHeight() - bot_screen.GetHeight()) / 2);
if (swapped) { if (swapped) {
@ -96,7 +96,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u
// Recalculate the bottom screen to account for the width difference between top and // Recalculate the bottom screen to account for the width difference between top and
// bottom // bottom
screen_window_area = {0, 0, width, top_screen.GetHeight()}; screen_window_area = {0, 0, width, top_screen.GetHeight()};
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
bot_screen = bot_screen.TranslateX((top_screen.GetWidth() - bot_screen.GetWidth()) / 2); bot_screen = bot_screen.TranslateX((top_screen.GetWidth() - bot_screen.GetWidth()) / 2);
if (swapped) { if (swapped) {
bot_screen = bot_screen.TranslateY(height / 2 - bot_screen.GetHeight()); bot_screen = bot_screen.TranslateY(height / 2 - bot_screen.GetHeight());
@ -124,8 +124,8 @@ FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool swapped)
FramebufferLayout res{width, height, true, true, {}, {}}; FramebufferLayout res{width, height, true, true, {}, {}};
// Default layout gives equal screen sizes to the top and bottom screen // Default layout gives equal screen sizes to the top and bottom screen
Common::Rectangle<u32> screen_window_area{0, 0, width, height / 2}; Common::Rectangle<u32> screen_window_area{0, 0, width, height / 2};
Common::Rectangle<u32> top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO); Common::Rectangle<u32> top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
Common::Rectangle<u32> bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO); Common::Rectangle<u32> bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
float window_aspect_ratio = static_cast<float>(height) / width; float window_aspect_ratio = static_cast<float>(height) / width;
// both screens height are taken into account by multiplying by 2 // both screens height are taken into account by multiplying by 2
@ -151,48 +151,6 @@ FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool swapped)
return res; return res;
} }
FramebufferLayout MobileLandscapeFrameLayout(u32 width, u32 height, bool swapped,
float scale_factor, bool center_vertical) {
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 ? Core::kScreenBottomHeight * scale_factor /
(Core::kScreenBottomWidth * scale_factor + Core::kScreenTopWidth)
: Core::kScreenTopHeight * scale_factor /
(Core::kScreenTopWidth * scale_factor + Core::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;
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, emulation_aspect_ratio);
Common::Rectangle<u32> large_screen = maxRectangle(total_rect, large_screen_aspect_ratio);
Common::Rectangle<u32> fourth_size_rect = total_rect.Scale(1.f / scale_factor);
Common::Rectangle<u32> 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 if (center_vertical) {
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);
if (center_vertical) {
small_screen = small_screen.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;
}
FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool upright) { FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool upright) {
ASSERT(width > 0); ASSERT(width > 0);
ASSERT(height > 0); ASSERT(height > 0);
@ -205,13 +163,13 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool up
Common::Rectangle<u32> bot_screen; Common::Rectangle<u32> bot_screen;
float emulation_aspect_ratio; float emulation_aspect_ratio;
if (upright) { if (upright) {
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO); top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_UPRIGHT_ASPECT_RATIO);
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_UPRIGHT_ASPECT_RATIO);
emulation_aspect_ratio = emulation_aspect_ratio =
(swapped) ? BOT_SCREEN_UPRIGHT_ASPECT_RATIO : TOP_SCREEN_UPRIGHT_ASPECT_RATIO; (swapped) ? BOT_SCREEN_UPRIGHT_ASPECT_RATIO : TOP_SCREEN_UPRIGHT_ASPECT_RATIO;
} else { } else {
top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO); top_screen = MaxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO);
bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO); bot_screen = MaxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO);
emulation_aspect_ratio = (swapped) ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO; emulation_aspect_ratio = (swapped) ? BOT_SCREEN_ASPECT_RATIO : TOP_SCREEN_ASPECT_RATIO;
} }
@ -232,7 +190,7 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool swapped, bool up
} }
FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upright, FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upright,
float scale_factor) { float scale_factor, VerticalAlignment vertical_alignment) {
ASSERT(width > 0); ASSERT(width > 0);
ASSERT(height > 0); ASSERT(height > 0);
@ -274,10 +232,10 @@ FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upr
} }
Common::Rectangle<u32> screen_window_area{0, 0, width, height}; Common::Rectangle<u32> screen_window_area{0, 0, width, height};
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, emulation_aspect_ratio); Common::Rectangle<u32> total_rect = MaxRectangle(screen_window_area, emulation_aspect_ratio);
Common::Rectangle<u32> large_screen = maxRectangle(total_rect, large_screen_aspect_ratio); Common::Rectangle<u32> large_screen = MaxRectangle(total_rect, large_screen_aspect_ratio);
Common::Rectangle<u32> fourth_size_rect = total_rect.Scale(1.f / scale_factor); Common::Rectangle<u32> scaled_rect = total_rect.Scale(1.f / scale_factor);
Common::Rectangle<u32> small_screen = maxRectangle(fourth_size_rect, small_screen_aspect_ratio); Common::Rectangle<u32> small_screen = MaxRectangle(scaled_rect, small_screen_aspect_ratio);
if (window_aspect_ratio < emulation_aspect_ratio) { if (window_aspect_ratio < emulation_aspect_ratio) {
large_screen = large_screen.TranslateX((width - total_rect.GetWidth()) / 2); large_screen = large_screen.TranslateX((width - total_rect.GetWidth()) / 2);
@ -286,13 +244,46 @@ FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool swapped, bool upr
} }
if (upright) { if (upright) {
large_screen = large_screen.TranslateY(small_screen.GetHeight()); large_screen = large_screen.TranslateY(small_screen.GetHeight());
small_screen = small_screen.TranslateX(large_screen.right - small_screen.GetWidth()) small_screen = small_screen.TranslateY(large_screen.top - small_screen.GetHeight());
.TranslateY(large_screen.top - small_screen.GetHeight()); switch (vertical_alignment) {
} else { case VerticalAlignment::Top:
// Shift the small screen to the top right corner
small_screen = small_screen.TranslateX(large_screen.left);
break;
case VerticalAlignment::Middle:
// Shift the small screen to the center right
small_screen = small_screen.TranslateX(
((large_screen.GetWidth() - small_screen.GetWidth()) / 2) + large_screen.left);
break;
case VerticalAlignment::Bottom:
// Shift the small screen to the bottom right corner // Shift the small screen to the bottom right corner
small_screen = small_screen = small_screen.TranslateX(large_screen.right - small_screen.GetWidth());
small_screen.TranslateX(large_screen.right) break;
.TranslateY(large_screen.GetHeight() + large_screen.top - small_screen.GetHeight()); default:
UNREACHABLE();
break;
}
} else {
small_screen = small_screen.TranslateX(large_screen.right);
switch (vertical_alignment) {
case VerticalAlignment::Top:
// Shift the small screen to the top right corner
small_screen = small_screen.TranslateY(large_screen.top);
break;
case VerticalAlignment::Middle:
// Shift the small screen to the center right
small_screen = small_screen.TranslateY(
((large_screen.GetHeight() - small_screen.GetHeight()) / 2) + large_screen.top);
break;
case VerticalAlignment::Bottom:
// Shift the small screen to the bottom right corner
small_screen = small_screen.TranslateY(large_screen.bottom - small_screen.GetHeight());
break;
default:
UNREACHABLE();
break;
}
} }
res.top_screen = swapped ? small_screen : large_screen; res.top_screen = swapped ? small_screen : large_screen;
res.bottom_screen = swapped ? large_screen : small_screen; res.bottom_screen = swapped ? large_screen : small_screen;
@ -331,11 +322,11 @@ FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool u
} }
Common::Rectangle<u32> screen_window_area{0, 0, width, height}; Common::Rectangle<u32> screen_window_area{0, 0, width, height};
Common::Rectangle<u32> total_rect = maxRectangle(screen_window_area, hybrid_area_aspect_ratio); Common::Rectangle<u32> total_rect = MaxRectangle(screen_window_area, hybrid_area_aspect_ratio);
Common::Rectangle<u32> large_main_screen = maxRectangle(total_rect, main_screen_aspect_ratio); Common::Rectangle<u32> large_main_screen = MaxRectangle(total_rect, main_screen_aspect_ratio);
Common::Rectangle<u32> side_rect = total_rect.Scale(1.f / scale_factor); Common::Rectangle<u32> side_rect = total_rect.Scale(1.f / scale_factor);
Common::Rectangle<u32> small_top_screen = maxRectangle(side_rect, top_screen_aspect_ratio); Common::Rectangle<u32> small_top_screen = MaxRectangle(side_rect, top_screen_aspect_ratio);
Common::Rectangle<u32> small_bottom_screen = maxRectangle(side_rect, bot_screen_aspect_ratio); Common::Rectangle<u32> small_bottom_screen = MaxRectangle(side_rect, bot_screen_aspect_ratio);
if (window_aspect_ratio < hybrid_area_aspect_ratio) { if (window_aspect_ratio < hybrid_area_aspect_ratio) {
large_main_screen = large_main_screen.TranslateX((width - total_rect.GetWidth()) / 2); large_main_screen = large_main_screen.TranslateX((width - total_rect.GetWidth()) / 2);
@ -373,54 +364,6 @@ FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool u
return res; return res;
} }
FramebufferLayout SideFrameLayout(u32 width, u32 height, bool swapped, bool upright) {
ASSERT(width > 0);
ASSERT(height > 0);
FramebufferLayout res{width, height, true, true, {}, {}, !upright};
// Aspect ratio of both screens side by side
float emulation_aspect_ratio =
upright ? static_cast<float>(Core::kScreenTopWidth + Core::kScreenBottomWidth) /
Core::kScreenTopHeight
: static_cast<float>(Core::kScreenTopHeight) /
(Core::kScreenTopWidth + Core::kScreenBottomWidth);
float window_aspect_ratio = static_cast<float>(height) / width;
Common::Rectangle<u32> screen_window_area{0, 0, width, height};
// Find largest Rectangle that can fit in the window size with the given aspect ratio
Common::Rectangle<u32> screen_rect = maxRectangle(screen_window_area, emulation_aspect_ratio);
// Find sizes of top and bottom screen
Common::Rectangle<u32> top_screen =
upright ? maxRectangle(screen_rect, TOP_SCREEN_UPRIGHT_ASPECT_RATIO)
: maxRectangle(screen_rect, TOP_SCREEN_ASPECT_RATIO);
Common::Rectangle<u32> bot_screen =
upright ? maxRectangle(screen_rect, BOT_SCREEN_UPRIGHT_ASPECT_RATIO)
: maxRectangle(screen_rect, BOT_SCREEN_ASPECT_RATIO);
if (window_aspect_ratio < emulation_aspect_ratio) {
// Apply borders to the left and right sides of the window.
u32 shift_horizontal = (screen_window_area.GetWidth() - screen_rect.GetWidth()) / 2;
top_screen = top_screen.TranslateX(shift_horizontal);
bot_screen = bot_screen.TranslateX(shift_horizontal);
} else {
// Window is narrower than the emulation content => apply borders to the top and bottom
u32 shift_vertical = (screen_window_area.GetHeight() - screen_rect.GetHeight()) / 2;
top_screen = top_screen.TranslateY(shift_vertical);
bot_screen = bot_screen.TranslateY(shift_vertical);
}
if (upright) {
// Leave the top screen at the top if we are swapped.
res.top_screen = swapped ? top_screen : top_screen.TranslateY(bot_screen.GetHeight());
res.bottom_screen = swapped ? bot_screen.TranslateY(top_screen.GetHeight()) : bot_screen;
} else {
// Move the top screen to the right if we are swapped.
res.top_screen = swapped ? top_screen.TranslateX(bot_screen.GetWidth()) : top_screen;
res.bottom_screen = swapped ? bot_screen : bot_screen.TranslateX(top_screen.GetWidth());
}
return res;
}
FramebufferLayout SeparateWindowsLayout(u32 width, u32 height, bool is_secondary, bool upright) { FramebufferLayout SeparateWindowsLayout(u32 width, u32 height, bool is_secondary, bool upright) {
// When is_secondary is true, we disable the top screen, and enable the bottom screen. // When is_secondary is true, we disable the top screen, and enable the bottom screen.
// The same logic is found in the SingleFrameLayout using the is_swapped bool. // The same logic is found in the SingleFrameLayout using the is_swapped bool.
@ -454,14 +397,14 @@ FramebufferLayout CustomFrameLayout(u32 width, u32 height, bool is_swapped) {
} }
FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale, bool is_secondary) { FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale, bool is_secondary) {
FramebufferLayout layout;
if (Settings::values.custom_layout.GetValue() == true) { if (Settings::values.custom_layout.GetValue() == true) {
layout = CustomFrameLayout(std::max(Settings::values.custom_top_right.GetValue(), return CustomFrameLayout(std::max(Settings::values.custom_top_right.GetValue(),
Settings::values.custom_bottom_right.GetValue()), Settings::values.custom_bottom_right.GetValue()),
std::max(Settings::values.custom_top_bottom.GetValue(), std::max(Settings::values.custom_top_bottom.GetValue(),
Settings::values.custom_bottom_bottom.GetValue()), Settings::values.custom_bottom_bottom.GetValue()),
Settings::values.swap_screen.GetValue()); Settings::values.swap_screen.GetValue());
} else { }
int width, height; int width, height;
switch (Settings::values.layout_option.GetValue()) { switch (Settings::values.layout_option.GetValue()) {
case Settings::LayoutOption::SingleScreen: case Settings::LayoutOption::SingleScreen:
@ -470,15 +413,6 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale, bool is_secondar
#endif #endif
{ {
const bool swap_screens = is_secondary || Settings::values.swap_screen.GetValue(); const bool swap_screens = is_secondary || Settings::values.swap_screen.GetValue();
if (Settings::values.upright_screen.GetValue()) {
if (swap_screens) {
width = Core::kScreenBottomHeight * res_scale;
height = Core::kScreenBottomWidth * res_scale;
} else {
width = Core::kScreenTopHeight * res_scale;
height = Core::kScreenTopWidth * res_scale;
}
} else {
if (swap_screens) { if (swap_screens) {
width = Core::kScreenBottomWidth * res_scale; width = Core::kScreenBottomWidth * res_scale;
height = Core::kScreenBottomHeight * res_scale; height = Core::kScreenBottomHeight * res_scale;
@ -486,99 +420,80 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale, bool is_secondar
width = Core::kScreenTopWidth * res_scale; width = Core::kScreenTopWidth * res_scale;
height = Core::kScreenTopHeight * res_scale; height = Core::kScreenTopHeight * res_scale;
} }
}
layout = SingleFrameLayout(width, height, swap_screens,
Settings::values.upright_screen.GetValue());
break;
}
case Settings::LayoutOption::LargeScreen:
if (Settings::values.upright_screen.GetValue()) { if (Settings::values.upright_screen.GetValue()) {
if (Settings::values.swap_screen.GetValue()) { std::swap(width, height);
width = Core::kScreenBottomHeight * res_scale;
height =
(Core::kScreenBottomWidth +
static_cast<int>(Core::kScreenTopWidth /
Settings::values.large_screen_proportion.GetValue())) *
res_scale;
} else {
width = Core::kScreenTopHeight * res_scale;
height =
(Core::kScreenTopWidth +
static_cast<int>(Core::kScreenBottomWidth /
Settings::values.large_screen_proportion.GetValue())) *
res_scale;
} }
} else { return SingleFrameLayout(width, height, swap_screens,
Settings::values.upright_screen.GetValue());
}
case Settings::LayoutOption::LargeScreen:
if (Settings::values.swap_screen.GetValue()) { if (Settings::values.swap_screen.GetValue()) {
width = (Core::kScreenBottomWidth + width = (Core::kScreenBottomWidth +
Core::kScreenTopWidth / Core::kScreenTopWidth /
static_cast<int>( static_cast<int>(Settings::values.large_screen_proportion.GetValue())) *
Settings::values.large_screen_proportion.GetValue())) *
res_scale; res_scale;
height = Core::kScreenBottomHeight * res_scale; height = Core::kScreenBottomHeight * res_scale;
} else { } else {
width = (Core::kScreenTopWidth + width = (Core::kScreenTopWidth +
Core::kScreenBottomWidth / Core::kScreenBottomWidth /
static_cast<int>( static_cast<int>(Settings::values.large_screen_proportion.GetValue())) *
Settings::values.large_screen_proportion.GetValue())) *
res_scale; res_scale;
height = Core::kScreenTopHeight * res_scale; height = Core::kScreenTopHeight * res_scale;
} }
}
layout = LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue(),
Settings::values.large_screen_proportion.GetValue());
break;
case Settings::LayoutOption::SideScreen:
if (Settings::values.upright_screen.GetValue()) { if (Settings::values.upright_screen.GetValue()) {
width = Core::kScreenTopHeight * res_scale; std::swap(width, height);
height = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale; }
} else { return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue(),
Settings::values.large_screen_proportion.GetValue(),
VerticalAlignment::Bottom);
case Settings::LayoutOption::SideScreen:
width = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale; width = (Core::kScreenTopWidth + Core::kScreenBottomWidth) * res_scale;
height = Core::kScreenTopHeight * res_scale; height = Core::kScreenTopHeight * res_scale;
if (Settings::values.upright_screen.GetValue()) {
std::swap(width, height);
} }
layout = SideFrameLayout(width, height, Settings::values.swap_screen.GetValue(), return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue()); Settings::values.upright_screen.GetValue(), 1,
break; VerticalAlignment::Middle);
case Settings::LayoutOption::MobilePortrait: case Settings::LayoutOption::MobilePortrait:
width = Core::kScreenTopWidth * res_scale; width = Core::kScreenTopWidth * res_scale;
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale; height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
layout = return MobilePortraitFrameLayout(width, height, Settings::values.swap_screen.GetValue());
MobilePortraitFrameLayout(width, height, Settings::values.swap_screen.GetValue());
break; case Settings::LayoutOption::MobileLandscape: {
case Settings::LayoutOption::MobileLandscape: constexpr float large_screen_proportion = 2.25f;
if (Settings::values.swap_screen.GetValue()) { if (Settings::values.swap_screen.GetValue()) {
width = width = (Core::kScreenBottomWidth +
(Core::kScreenBottomWidth + static_cast<int>(Core::kScreenTopWidth / 2.25f)) * static_cast<int>(Core::kScreenTopWidth / large_screen_proportion)) *
res_scale; res_scale;
height = Core::kScreenBottomHeight * res_scale; height = Core::kScreenBottomHeight * res_scale;
} else { } else {
width = width = (Core::kScreenTopWidth +
(Core::kScreenTopWidth + static_cast<int>(Core::kScreenBottomWidth / 2.25f)) * static_cast<int>(Core::kScreenBottomWidth / large_screen_proportion)) *
res_scale; res_scale;
height = Core::kScreenTopHeight * res_scale; height = Core::kScreenTopHeight * res_scale;
} }
layout = MobileLandscapeFrameLayout( return LargeFrameLayout(width, height, Settings::values.swap_screen.GetValue(), false,
width, height, Settings::values.swap_screen.GetValue(), 2.25f, false); large_screen_proportion, VerticalAlignment::Top);
break; }
case Settings::LayoutOption::Default: case Settings::LayoutOption::Default:
default: default:
if (Settings::values.upright_screen.GetValue()) {
width = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
height = Core::kScreenTopWidth * res_scale;
} else {
width = Core::kScreenTopWidth * res_scale; width = Core::kScreenTopWidth * res_scale;
height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale; height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale;
if (Settings::values.upright_screen.GetValue()) {
std::swap(width, height);
} }
layout = DefaultFrameLayout(width, height, Settings::values.swap_screen.GetValue(), return DefaultFrameLayout(width, height, Settings::values.swap_screen.GetValue(),
Settings::values.upright_screen.GetValue()); Settings::values.upright_screen.GetValue());
break;
} }
} UNREACHABLE();
if (Settings::values.render_3d.GetValue() == Settings::StereoRenderOption::CardboardVR) {
layout = Layout::GetCardboardSettings(layout);
}
return layout;
} }
FramebufferLayout GetCardboardSettings(const FramebufferLayout& layout) { FramebufferLayout GetCardboardSettings(const FramebufferLayout& layout) {

60
src/core/frontend/framebuffer_layout.h
View File

@ -20,6 +20,31 @@ enum class DisplayOrientation {
PortraitFlipped, // 3DS rotated 270 degrees counter-clockwise PortraitFlipped, // 3DS rotated 270 degrees counter-clockwise
}; };
/// Describes the vertical alignment of the top and bottom screens in LargeFrameLayout
/// Top
/// +-------------+-----+
/// | | |
/// | +-----+
/// | |
/// +-------------+
/// Middle
/// +-------------+
/// | +-----+
/// | | |
/// | +-----+
/// +-------------+
/// Bottom
/// +-------------+
/// | |
/// | +-----+
/// | | |
/// +-------------+-----+
enum class VerticalAlignment {
Top,
Middle,
Bottom,
};
/// Describes the horizontal coordinates for the right eye screen when using Cardboard VR /// Describes the horizontal coordinates for the right eye screen when using Cardboard VR
struct CardboardSettings { struct CardboardSettings {
u32 top_screen_right_eye; u32 top_screen_right_eye;
@ -43,7 +68,7 @@ struct FramebufferLayout {
CardboardSettings cardboard; CardboardSettings cardboard;
/** /**
* Returns the ration of pixel size of the top screen, compared to the native size of the 3DS * Returns the ratio of pixel size of the top screen, compared to the native size of the 3DS
* screen. * screen.
*/ */
u32 GetScalingRatio() const; u32 GetScalingRatio() const;
@ -54,6 +79,7 @@ struct FramebufferLayout {
* @param width Window framebuffer width in pixels * @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels * @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be displayed above the top screen * @param is_swapped if true, the bottom screen will be displayed above the top screen
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
* @return Newly created FramebufferLayout object with default screen regions initialized * @return Newly created FramebufferLayout object with default screen regions initialized
*/ */
FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, bool upright); FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
@ -67,25 +93,12 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, boo
*/ */
FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 height, bool is_swapped); FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 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
* @param scale_factor Scale factor to use for bottom screen with respect to top screen
* @param center_vertical When true, centers the top and bottom screens vertically
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
FramebufferLayout MobileLandscapeFrameLayout(u32 width, u32 height, bool is_swapped,
float scale_factor, bool center_vertical);
/** /**
* Factory method for constructing a FramebufferLayout with only the top or bottom screen * Factory method for constructing a FramebufferLayout with only the top or bottom screen
* @param width Window framebuffer width in pixels * @param width Window framebuffer width in pixels
* @param height Window framebuffer height 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) * @param is_swapped if true, the bottom screen will be displayed (and the top won't be displayed)
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
* @return Newly created FramebufferLayout object with default screen regions initialized * @return Newly created FramebufferLayout object with default screen regions initialized
*/ */
FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool is_swapped, bool upright); FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
@ -97,32 +110,25 @@ FramebufferLayout SingleFrameLayout(u32 width, u32 height, bool is_swapped, bool
* @param width Window framebuffer width in pixels * @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels * @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be the large display * @param is_swapped if true, the bottom screen will be the large display
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
* @param scale_factor The ratio between the large screen with respect to the smaller screen * @param scale_factor The ratio between the large screen with respect to the smaller screen
* @param vertical_alignment The vertical alignment of the smaller screen relative to the larger
* screen
* @return Newly created FramebufferLayout object with default screen regions initialized * @return Newly created FramebufferLayout object with default screen regions initialized
*/ */
FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool is_swapped, bool upright, FramebufferLayout LargeFrameLayout(u32 width, u32 height, bool is_swapped, bool upright,
float scale_factor); float scale_factor, VerticalAlignment vertical_alignment);
/** /**
* Factory method for constructing a frame with 2.5 times bigger top screen on the right, * Factory method for constructing a frame with 2.5 times bigger top screen on the right,
* and 1x top and bottom screen on the left * and 1x top and bottom screen on the left
* @param width Window framebuffer width in pixels * @param width Window framebuffer width in pixels
* @param height Window framebuffer height in pixels * @param height Window framebuffer height in pixels
* @param is_swapped if true, the bottom screen will be the large display * @param is_swapped if true, the bottom screen will be the large display
* @param upright if true, the screens will be rotated 90 degrees anti-clockwise
* @return Newly created FramebufferLayout object with default screen regions initialized * @return Newly created FramebufferLayout object with default screen regions initialized
*/ */
FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool upright); FramebufferLayout HybridScreenLayout(u32 width, u32 height, bool swapped, bool upright);
/**
* Factory method for constructing a Frame with the Top screen and bottom
* screen side by side
* This is useful for devices with small screens, like the GPDWin
* @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 left display
* @return Newly created FramebufferLayout object with default screen regions initialized
*/
FramebufferLayout SideFrameLayout(u32 width, u32 height, bool is_swapped, bool upright);
/** /**
* Factory method for constructing a Frame with the Top screen and bottom * Factory method for constructing a Frame with the Top screen and bottom
* screen on separate windows * screen on separate windows