From 5a8c6990bf24bce79a5b29a43780830ef3d5f463 Mon Sep 17 00:00:00 2001 From: BreadFish64 Date: Tue, 21 Apr 2020 22:36:16 -0500 Subject: [PATCH 1/7] memory: fix memory leak related to un-freed shared memory --- src/core/core.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/core/core.cpp b/src/core/core.cpp index 901151eec..c376a908b 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -554,6 +554,8 @@ void System::Shutdown(bool is_deserializing) { room_member->SendGameInfo(game_info); } + memory.reset(); + LOG_DEBUG(Core, "Shutdown OK"); } From e8f57d7e3c710f840fc841441e58ebaa4ee097d8 Mon Sep 17 00:00:00 2001 From: bunnei Date: Sat, 20 Jul 2019 22:59:38 -0400 Subject: [PATCH 2/7] android: frontend: Add MobileLandscape layout profile for mobile devices. --- src/core/frontend/emu_window.cpp | 7 ++ src/core/frontend/framebuffer_layout.cpp | 92 ++++++++++++++++++++++++ src/core/frontend/framebuffer_layout.h | 23 ++++++ src/core/settings.h | 8 +++ 4 files changed, 130 insertions(+) diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp index 44502858d..2a954c554 100644 --- a/src/core/frontend/emu_window.cpp +++ b/src/core/frontend/emu_window.cpp @@ -169,6 +169,13 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) layout = Layout::SideFrameLayout(width, height, Settings::values.swap_screen, Settings::values.upright_screen); break; + case Settings::LayoutOption::MobilePortrait: + layout = Layout::MobilePortraitFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::MobileLandscape: + layout = Layout::MobileLandscapeFrameLayout(width, height, Settings::values.swap_screen, + 2.25f, false); + break; case Settings::LayoutOption::Default: default: layout = Layout::DefaultFrameLayout(width, height, Settings::values.swap_screen, diff --git a/src/core/frontend/framebuffer_layout.cpp b/src/core/frontend/framebuffer_layout.cpp index 71dce24be..7e2df617c 100644 --- a/src/core/frontend/framebuffer_layout.cpp +++ b/src/core/frontend/framebuffer_layout.cpp @@ -117,6 +117,82 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool swapped, bool u return res; } +FramebufferLayout MobilePortraitFrameLayout(u32 width, u32 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 + Common::Rectangle screen_window_area{0, 0, width, height / 2}; + Common::Rectangle top_screen = maxRectangle(screen_window_area, TOP_SCREEN_ASPECT_RATIO); + Common::Rectangle bot_screen = maxRectangle(screen_window_area, BOT_SCREEN_ASPECT_RATIO); + + float window_aspect_ratio = static_cast(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 + // Recalculate the bottom screen to account for the width difference between top and bottom + + bot_screen = bot_screen.TranslateX((top_screen.GetWidth() - bot_screen.GetWidth()) / 2); + } + + // Move the top screen to the bottom if we are swapped. + res.top_screen = swapped ? top_screen.TranslateY(bot_screen.GetHeight()) : top_screen; + res.bottom_screen = swapped ? bot_screen : bot_screen.TranslateY(top_screen.GetHeight()); + + 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(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 screen_window_area{0, 0, width, height}; + Common::Rectangle total_rect = maxRectangle(screen_window_area, emulation_aspect_ratio); + Common::Rectangle large_screen = maxRectangle(total_rect, large_screen_aspect_ratio); + Common::Rectangle fourth_size_rect = total_rect.Scale(1.f / scale_factor); + Common::Rectangle 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.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) { ASSERT(width > 0); ASSERT(height > 0); @@ -346,6 +422,22 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) { layout = SideFrameLayout(width, height, Settings::values.swap_screen, Settings::values.upright_screen); break; + case Settings::LayoutOption::MobilePortrait: + width = Core::kScreenTopWidth * res_scale; + height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * res_scale; + layout = MobilePortraitFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::MobileLandscape: + if (Settings::values.swap_screen) { + width = (Core::kScreenBottomWidth + Core::kScreenTopWidth / 2.25f) * res_scale; + height = Core::kScreenBottomHeight * res_scale; + } else { + width = (Core::kScreenTopWidth + Core::kScreenBottomWidth / 2.25f) * res_scale; + height = Core::kScreenTopHeight * res_scale; + } + layout = MobileLandscapeFrameLayout(width, height, Settings::values.swap_screen, 2.25f, + false); + break; case Settings::LayoutOption::Default: default: if (Settings::values.upright_screen) { diff --git a/src/core/frontend/framebuffer_layout.h b/src/core/frontend/framebuffer_layout.h index ad3ff2724..ddbe86a2b 100644 --- a/src/core/frontend/framebuffer_layout.h +++ b/src/core/frontend/framebuffer_layout.h @@ -35,6 +35,29 @@ struct FramebufferLayout { */ FramebufferLayout DefaultFrameLayout(u32 width, u32 height, bool is_swapped, bool upright); +/** + * Factory method for constructing a mobile portrait 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 mobile portrait screen regions initialized + */ +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 * @param width Window framebuffer width in pixels diff --git a/src/core/settings.h b/src/core/settings.h index af41b9a02..c42bab9f7 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -24,6 +24,14 @@ enum class LayoutOption { SingleScreen, LargeScreen, SideScreen, + + // Similiar to default, but better for mobile devices in portrait mode. Top screen in clamped to + // the top of the frame, and the bottom screen is enlarged to match the top screen. + MobilePortrait, + + // Similiar to LargeScreen, but better for mobile devices in landscape mode. The screens are + // clamped to the top of the frame, and the bottom screen is a bit bigger. + MobileLandscape, }; enum class MicInputType { From b7a156f7c8b5353b6b457b7b8c64dd1851ad0df2 Mon Sep 17 00:00:00 2001 From: bunnei Date: Mon, 22 Jul 2019 14:58:54 -0400 Subject: [PATCH 3/7] android: frontend: Track screen layout separately for orientation. android framebuffer --- src/core/frontend/emu_window.cpp | 9 ++++++++- src/core/frontend/emu_window.h | 3 ++- src/core/settings.cpp | 2 ++ src/video_core/renderer_base.cpp | 4 ++-- src/video_core/renderer_base.h | 2 +- 5 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp index 2a954c554..73909b09c 100644 --- a/src/core/frontend/emu_window.cpp +++ b/src/core/frontend/emu_window.cpp @@ -145,7 +145,8 @@ void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) { TouchPressed(framebuffer_x, framebuffer_y); } -void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) { +void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height, + bool is_portrait_mode) { Layout::FramebufferLayout layout; const auto layout_option = Settings::values.layout_option; const auto min_size = @@ -156,6 +157,12 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) } else { width = std::max(width, min_size.first); height = std::max(height, min_size.second); + + // If in portrait mode, only the MobilePortrait option really makes sense + const Settings::LayoutOption layout_option = is_portrait_mode + ? Settings::LayoutOption::MobilePortrait + : Settings::values.layout_option; + switch (layout_option) { case Settings::LayoutOption::SingleScreen: layout = Layout::SingleFrameLayout(width, height, Settings::values.swap_screen, diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h index efaa25d9f..65ee25bc9 100644 --- a/src/core/frontend/emu_window.h +++ b/src/core/frontend/emu_window.h @@ -159,7 +159,8 @@ public: * 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); + void UpdateCurrentFramebufferLayout(unsigned width, unsigned height, + bool is_portrait_mode = {}); std::unique_ptr mailbox = nullptr; diff --git a/src/core/settings.cpp b/src/core/settings.cpp index 855307ba5..a63f23b07 100644 --- a/src/core/settings.cpp +++ b/src/core/settings.cpp @@ -33,9 +33,11 @@ void Apply() { VideoCore::g_hw_shader_accurate_mul = values.shaders_accurate_mul; VideoCore::g_use_disk_shader_cache = values.use_disk_shader_cache; +#ifndef ANDROID if (VideoCore::g_renderer) { VideoCore::g_renderer->UpdateCurrentFramebufferLayout(); } +#endif VideoCore::g_renderer_bg_color_update_requested = true; VideoCore::g_renderer_sampler_update_requested = true; diff --git a/src/video_core/renderer_base.cpp b/src/video_core/renderer_base.cpp index 48a3601c2..353550dee 100644 --- a/src/video_core/renderer_base.cpp +++ b/src/video_core/renderer_base.cpp @@ -11,9 +11,9 @@ RendererBase::RendererBase(Frontend::EmuWindow& window) : render_window{window} {} RendererBase::~RendererBase() = default; -void RendererBase::UpdateCurrentFramebufferLayout() { +void RendererBase::UpdateCurrentFramebufferLayout(bool is_portrait_mode) { const Layout::FramebufferLayout& layout = render_window.GetFramebufferLayout(); - render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height); + render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height, is_portrait_mode); } void RendererBase::RefreshRasterizerSetting() { diff --git a/src/video_core/renderer_base.h b/src/video_core/renderer_base.h index ba49d3f28..9322742cf 100644 --- a/src/video_core/renderer_base.h +++ b/src/video_core/renderer_base.h @@ -38,7 +38,7 @@ public: virtual void CleanupVideoDumping() = 0; /// Updates the framebuffer layout of the contained render window handle. - void UpdateCurrentFramebufferLayout(); + void UpdateCurrentFramebufferLayout(bool is_portrait_mode = {}); // Getter/setter functions: // ------------------------ From da3a9bfc968c51f214c127a56e2acef73f024a2c Mon Sep 17 00:00:00 2001 From: bunnei Date: Sat, 24 Aug 2019 16:56:17 -0400 Subject: [PATCH 4/7] core: Reset cpu_core after kernel. - Fixes a crash on Android. core.cpp: check if video_dumper is created before trying to shut it down --- src/core/core.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core/core.cpp b/src/core/core.cpp index c376a908b..95e4035bd 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -541,11 +541,11 @@ void System::Shutdown(bool is_deserializing) { archive_manager.reset(); service_manager.reset(); dsp_core.reset(); - cpu_cores.clear(); kernel.reset(); + cpu_cores.clear(); timing.reset(); - if (video_dumper->IsDumping()) { + if (video_dumper && video_dumper->IsDumping()) { video_dumper->StopDumping(); } From 60235827c5a6d7ccf9fe5517c1a2357a12c1b28d Mon Sep 17 00:00:00 2001 From: SutandoTsukai181 <52977072+SutandoTsukai181@users.noreply.github.com> Date: Wed, 10 Jun 2020 13:44:21 +0300 Subject: [PATCH 5/7] Add Cardboard VR Based on hrydgard/ppsspp/pull/12449 --- src/core/frontend/emu_window.cpp | 30 +++++-- src/core/frontend/framebuffer_layout.cpp | 83 +++++++++++++++++++ src/core/frontend/framebuffer_layout.h | 16 ++++ src/core/settings.h | 13 ++- .../renderer_opengl/renderer_opengl.cpp | 38 +++++++++ 5 files changed, 174 insertions(+), 6 deletions(-) diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp index 73909b09c..22eba7c0b 100644 --- a/src/core/frontend/emu_window.cpp +++ b/src/core/frontend/emu_window.cpp @@ -73,6 +73,14 @@ static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigne framebuffer_x < layout.bottom_screen.right / 2) || (framebuffer_x >= (layout.bottom_screen.left / 2) + (layout.width / 2) && framebuffer_x < (layout.bottom_screen.right / 2) + (layout.width / 2)))); + } else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + return (framebuffer_y >= layout.bottom_screen.top && + framebuffer_y < layout.bottom_screen.bottom && + ((framebuffer_x >= layout.bottom_screen.left && + framebuffer_x < layout.bottom_screen.right) || + (framebuffer_x >= layout.cardboard.bottom_screen_right_eye + (layout.width / 2) && + framebuffer_x < layout.cardboard.bottom_screen_right_eye + + layout.bottom_screen.GetWidth() + (layout.width / 2)))); } else { return (framebuffer_y >= layout.bottom_screen.top && framebuffer_y < layout.bottom_screen.bottom && @@ -82,9 +90,14 @@ static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigne } std::tuple EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) const { - if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) { - if (new_x >= framebuffer_layout.width / 2) + if (new_x >= framebuffer_layout.width / 2) { + if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) new_x -= framebuffer_layout.width / 2; + else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) + new_x -= + (framebuffer_layout.width / 2) - (framebuffer_layout.cardboard.user_x_shift * 2); + } + if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) { new_x = std::max(new_x, framebuffer_layout.bottom_screen.left / 2); new_x = std::min(new_x, framebuffer_layout.bottom_screen.right / 2 - 1); } else { @@ -102,9 +115,13 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) return; - if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide && - framebuffer_x >= framebuffer_layout.width / 2) - framebuffer_x -= framebuffer_layout.width / 2; + if (framebuffer_x >= framebuffer_layout.width / 2) { + if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) + framebuffer_x -= framebuffer_layout.width / 2; + else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) + framebuffer_x -= + (framebuffer_layout.width / 2) - (framebuffer_layout.cardboard.user_x_shift * 2); + } std::lock_guard guard(touch_state->mutex); if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) { touch_state->touch_x = @@ -191,6 +208,9 @@ void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height, } UpdateMinimumWindowSize(min_size); } + if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + layout = Layout::GetCardboardSettings(layout); + } NotifyFramebufferLayoutChanged(layout); } diff --git a/src/core/frontend/framebuffer_layout.cpp b/src/core/frontend/framebuffer_layout.cpp index 7e2df617c..62bf9f34b 100644 --- a/src/core/frontend/framebuffer_layout.cpp +++ b/src/core/frontend/framebuffer_layout.cpp @@ -452,9 +452,92 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) { break; } } + if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + layout = Layout::GetCardboardSettings(layout); + } return layout; } +FramebufferLayout GetCardboardSettings(FramebufferLayout layout) { + FramebufferLayout newLayout = layout; + float top_screen_left = 0; + float top_screen_top = 0; + float bottom_screen_left = 0; + float bottom_screen_top = 0; + + float cardboardScreenScale = Settings::values.cardboard_screen_size / 100.0f; + float top_screen_width = layout.top_screen.GetWidth() / 2.0f * cardboardScreenScale; + float top_screen_height = layout.top_screen.GetHeight() / 2.0f * cardboardScreenScale; + float bottom_screen_width = layout.bottom_screen.GetWidth() / 2.0f * cardboardScreenScale; + float bottom_screen_height = layout.bottom_screen.GetHeight() / 2.0f * cardboardScreenScale; + bool is_swapped = Settings::values.swap_screen; + bool is_portrait = layout.height > layout.width; + + float cardboardScreenWidth; + float cardboardScreenHeight; + switch (Settings::values.layout_option) { + case Settings::LayoutOption::MobileLandscape: + case Settings::LayoutOption::SideScreen: + // If orientation is portrait, only use MobilePortrait + if (!is_portrait) { + cardboardScreenWidth = top_screen_width + bottom_screen_width; + cardboardScreenHeight = is_swapped ? bottom_screen_height : top_screen_height; + if (is_swapped) + top_screen_left += bottom_screen_width; + else + bottom_screen_left += top_screen_width; + break; + } else { + [[fallthrough]]; + } + case Settings::LayoutOption::SingleScreen: + default: + if (!is_portrait) { + // Default values when using LayoutOption::SingleScreen + cardboardScreenWidth = is_swapped ? bottom_screen_width : top_screen_width; + cardboardScreenHeight = is_swapped ? bottom_screen_height : top_screen_height; + break; + } else { + [[fallthrough]]; + } + case Settings::LayoutOption::MobilePortrait: + cardboardScreenWidth = top_screen_width; + cardboardScreenHeight = top_screen_height + bottom_screen_height; + bottom_screen_left += (top_screen_width - bottom_screen_width) / 2.0f; + if (is_swapped) + top_screen_top += bottom_screen_height; + else + bottom_screen_top += top_screen_height; + break; + } + float cardboardMaxXShift = (layout.width / 2.0f - cardboardScreenWidth) / 2.0f; + float cardboardUserXShift = (Settings::values.cardboard_x_shift / 100.0f) * cardboardMaxXShift; + float cardboardMaxYShift = ((float)layout.height - cardboardScreenHeight) / 2.0f; + float cardboardUserYShift = (Settings::values.cardboard_y_shift / 100.0f) * cardboardMaxYShift; + + // Center the screens and apply user Y shift + newLayout.top_screen.left = top_screen_left + cardboardMaxXShift; + newLayout.top_screen.top = top_screen_top + cardboardMaxYShift + cardboardUserYShift; + newLayout.bottom_screen.left = bottom_screen_left + cardboardMaxXShift; + newLayout.bottom_screen.top = bottom_screen_top + cardboardMaxYShift + cardboardUserYShift; + + // Set the X coordinates for the right eye and apply user X shift + newLayout.cardboard.top_screen_right_eye = newLayout.top_screen.left - cardboardUserXShift; + newLayout.top_screen.left += cardboardUserXShift; + newLayout.cardboard.bottom_screen_right_eye = + newLayout.bottom_screen.left - cardboardUserXShift; + newLayout.bottom_screen.left += cardboardUserXShift; + newLayout.cardboard.user_x_shift = cardboardUserXShift; + + // Update right/bottom instead of passing new variables for width/height + newLayout.top_screen.right = newLayout.top_screen.left + top_screen_width; + newLayout.top_screen.bottom = newLayout.top_screen.top + top_screen_height; + newLayout.bottom_screen.right = newLayout.bottom_screen.left + bottom_screen_width; + newLayout.bottom_screen.bottom = newLayout.bottom_screen.top + bottom_screen_height; + + return newLayout; +} + std::pair GetMinimumSizeFromLayout(Settings::LayoutOption layout, bool upright_screen) { unsigned min_width, min_height; diff --git a/src/core/frontend/framebuffer_layout.h b/src/core/frontend/framebuffer_layout.h index ddbe86a2b..a5699a0d2 100644 --- a/src/core/frontend/framebuffer_layout.h +++ b/src/core/frontend/framebuffer_layout.h @@ -9,6 +9,13 @@ namespace Layout { +/// Describes the horizontal coordinates for the right eye screen when using Cardboard VR +struct CardboardSettings { + float top_screen_right_eye; + float bottom_screen_right_eye; + float user_x_shift; +}; + /// Describes the layout of the window framebuffer (size and top/bottom screen positions) struct FramebufferLayout { u32 width; @@ -19,6 +26,8 @@ struct FramebufferLayout { Common::Rectangle bottom_screen; bool is_rotated = true; + CardboardSettings cardboard; + /** * Returns the ration of pixel size of the top screen, compared to the native size of the 3DS * screen. @@ -104,6 +113,13 @@ FramebufferLayout CustomFrameLayout(u32 width, u32 height); */ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale); +/** + * Convenience method for transforming a frame layout when using Cardboard VR + * @param layout frame layout to transform + * @return layout transformed with the user cardboard settings + */ +FramebufferLayout GetCardboardSettings(FramebufferLayout layout); + std::pair GetMinimumSizeFromLayout(Settings::LayoutOption layout, bool upright_screen); diff --git a/src/core/settings.h b/src/core/settings.h index c42bab9f7..6030c0868 100644 --- a/src/core/settings.h +++ b/src/core/settings.h @@ -40,7 +40,14 @@ enum class MicInputType { Static, }; -enum class StereoRenderOption { Off, SideBySide, Anaglyph, Interlaced, ReverseInterlaced }; +enum class StereoRenderOption { + Off, + SideBySide, + Anaglyph, + Interlaced, + ReverseInterlaced, + CardboardVR +}; namespace NativeButton { enum Values { @@ -190,6 +197,10 @@ struct Values { StereoRenderOption render_3d; std::atomic factor_3d; + int cardboard_screen_size; + int cardboard_x_shift; + int cardboard_y_shift; + bool filter_mode; std::string pp_shader_name; diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp index 0d048e8c5..4829a5b08 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.cpp +++ b/src/video_core/renderer_opengl/renderer_opengl.cpp @@ -1016,6 +1016,16 @@ void RendererOpenGL::DrawScreens(const Layout::FramebufferLayout& layout, bool f ((float)top_screen.left / 2) + ((float)layout.width / 2), (float)top_screen.top, (float)top_screen.GetWidth() / 2, (float)top_screen.GetHeight()); + } else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + DrawSingleScreenRotated(screen_infos[0], layout.top_screen.left, + layout.top_screen.top, layout.top_screen.GetWidth(), + layout.top_screen.GetHeight()); + glUniform1i(uniform_layer, 1); + DrawSingleScreenRotated(screen_infos[1], + layout.cardboard.top_screen_right_eye + + ((float)layout.width / 2), + layout.top_screen.top, layout.top_screen.GetWidth(), + layout.top_screen.GetHeight()); } else if (stereo_single_screen) { DrawSingleScreenStereoRotated( screen_infos[0], screen_infos[1], (float)top_screen.left, (float)top_screen.top, @@ -1033,6 +1043,14 @@ void RendererOpenGL::DrawScreens(const Layout::FramebufferLayout& layout, bool f ((float)top_screen.left / 2) + ((float)layout.width / 2), (float)top_screen.top, (float)top_screen.GetWidth() / 2, (float)top_screen.GetHeight()); + } else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + DrawSingleScreen(screen_infos[0], layout.top_screen.left, layout.top_screen.top, + layout.top_screen.GetWidth(), layout.top_screen.GetHeight()); + glUniform1i(uniform_layer, 1); + DrawSingleScreen(screen_infos[1], + layout.cardboard.top_screen_right_eye + ((float)layout.width / 2), + layout.top_screen.top, layout.top_screen.GetWidth(), + layout.top_screen.GetHeight()); } else if (stereo_single_screen) { DrawSingleScreenStereo(screen_infos[0], screen_infos[1], (float)top_screen.left, (float)top_screen.top, (float)top_screen.GetWidth(), @@ -1056,6 +1074,16 @@ void RendererOpenGL::DrawScreens(const Layout::FramebufferLayout& layout, bool f screen_infos[2], ((float)bottom_screen.left / 2) + ((float)layout.width / 2), (float)bottom_screen.top, (float)bottom_screen.GetWidth() / 2, (float)bottom_screen.GetHeight()); + } else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + DrawSingleScreenRotated(screen_infos[2], layout.bottom_screen.left, + layout.bottom_screen.top, layout.bottom_screen.GetWidth(), + layout.bottom_screen.GetHeight()); + glUniform1i(uniform_layer, 1); + DrawSingleScreenRotated(screen_infos[2], + layout.cardboard.bottom_screen_right_eye + + ((float)layout.width / 2), + layout.bottom_screen.top, layout.bottom_screen.GetWidth(), + layout.bottom_screen.GetHeight()); } else if (stereo_single_screen) { DrawSingleScreenStereoRotated(screen_infos[2], screen_infos[2], (float)bottom_screen.left, (float)bottom_screen.top, @@ -1076,6 +1104,16 @@ void RendererOpenGL::DrawScreens(const Layout::FramebufferLayout& layout, bool f ((float)bottom_screen.left / 2) + ((float)layout.width / 2), (float)bottom_screen.top, (float)bottom_screen.GetWidth() / 2, (float)bottom_screen.GetHeight()); + } else if (Settings::values.render_3d == Settings::StereoRenderOption::CardboardVR) { + DrawSingleScreen(screen_infos[2], layout.bottom_screen.left, + layout.bottom_screen.top, layout.bottom_screen.GetWidth(), + layout.bottom_screen.GetHeight()); + glUniform1i(uniform_layer, 1); + DrawSingleScreen(screen_infos[2], + layout.cardboard.bottom_screen_right_eye + + ((float)layout.width / 2), + layout.bottom_screen.top, layout.bottom_screen.GetWidth(), + layout.bottom_screen.GetHeight()); } else if (stereo_single_screen) { DrawSingleScreenStereo(screen_infos[2], screen_infos[2], (float)bottom_screen.left, (float)bottom_screen.top, (float)bottom_screen.GetWidth(), From 666787bf4d923d14fd64377dc2f915f592f9994b Mon Sep 17 00:00:00 2001 From: SachinVin Date: Sat, 30 May 2020 18:58:34 +0530 Subject: [PATCH 6/7] core/frontend/emu_window: return true when TouchPressed is consumed --- src/core/frontend/emu_window.cpp | 5 +++-- src/core/frontend/emu_window.h | 3 ++- src/core/frontend/input.h | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp index 22eba7c0b..ff9ec53e2 100644 --- a/src/core/frontend/emu_window.cpp +++ b/src/core/frontend/emu_window.cpp @@ -111,9 +111,9 @@ std::tuple EmuWindow::ClipToTouchScreen(unsigned new_x, unsi return std::make_tuple(new_x, new_y); } -void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { +bool EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) - return; + return false; if (framebuffer_x >= framebuffer_layout.width / 2) { if (Settings::values.render_3d == Settings::StereoRenderOption::SideBySide) @@ -143,6 +143,7 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { } touch_state->touch_pressed = true; + return true; } void EmuWindow::TouchReleased() { diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h index 65ee25bc9..326563655 100644 --- a/src/core/frontend/emu_window.h +++ b/src/core/frontend/emu_window.h @@ -115,8 +115,9 @@ public: * Signal that a touch pressed event has occurred (e.g. mouse click pressed) * @param framebuffer_x Framebuffer x-coordinate that was pressed * @param framebuffer_y Framebuffer y-coordinate that was pressed + * @returns True if the coordinates are within the touchpad, otherwise false */ - void TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y); + bool TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y); /// Signal that a touch released event has occurred (e.g. mouse click released) void TouchReleased(); diff --git a/src/core/frontend/input.h b/src/core/frontend/input.h index d7cb94b93..a1cc8d66a 100644 --- a/src/core/frontend/input.h +++ b/src/core/frontend/input.h @@ -76,7 +76,7 @@ void UnregisterFactory(const std::string& name) { } /** - * Create an input device from given paramters. + * Create an input device from given parameters. * @tparam InputDeviceType the type of input devices to create * @param params a serialized ParamPackage string contains all parameters for creating the device */ From 1079f61260101fdc451bfa151577e71c6332c8a4 Mon Sep 17 00:00:00 2001 From: SachinVin Date: Sat, 27 Nov 2021 23:05:22 +0530 Subject: [PATCH 7/7] Android:file_util.cpp: remove unnecessary ROOT_DIR --- src/common/file_util.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp index 46401bc19..7b360967b 100644 --- a/src/common/file_util.cpp +++ b/src/common/file_util.cpp @@ -696,8 +696,8 @@ void SetUserPath(const std::string& path) { g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP); g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP); #elif ANDROID - if (FileUtil::Exists(ROOT_DIR DIR_SEP SDCARD_DIR)) { - user_path = ROOT_DIR DIR_SEP SDCARD_DIR DIR_SEP EMU_DATA_DIR DIR_SEP; + if (FileUtil::Exists(DIR_SEP SDCARD_DIR)) { + user_path = DIR_SEP SDCARD_DIR DIR_SEP EMU_DATA_DIR DIR_SEP; g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP); g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP); }