From e8bd6b1fcc5abd4813cda08b4921c94ada89509d Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sat, 19 Jan 2019 21:03:26 -0700 Subject: [PATCH 01/11] QT: Upgrade the Loading Bar to look much better --- src/video_core/rasterizer_interface.h | 9 +++ src/yuzu/loading_screen.cpp | 108 ++++++++++++++++++++++++-- src/yuzu/loading_screen.h | 26 ++++++- src/yuzu/loading_screen.ui | 71 +++++++++++++++-- 4 files changed, 202 insertions(+), 12 deletions(-) diff --git a/src/video_core/rasterizer_interface.h b/src/video_core/rasterizer_interface.h index 06fc59dbe8..b2c74afde1 100644 --- a/src/video_core/rasterizer_interface.h +++ b/src/video_core/rasterizer_interface.h @@ -4,6 +4,7 @@ #pragma once +#include #include "common/common_types.h" #include "video_core/engines/fermi_2d.h" #include "video_core/gpu.h" @@ -11,6 +12,14 @@ namespace VideoCore { +enum class LoadCallbackStage { + Prepare, + Raw, + Binary, + Complete, +}; +using DiskResourceLoadCallback = std::function; + class RasterizerInterface { public: virtual ~RasterizerInterface() {} diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 0f3c4bb6cb..617b8c858a 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -2,6 +2,7 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include #include #include #include @@ -13,10 +14,12 @@ #include #include #include -#include +#include +#include #include "common/logging/log.h" #include "core/loader/loader.h" #include "ui_loading_screen.h" +#include "video_core/rasterizer_interface.h" #include "yuzu/loading_screen.h" // Mingw seems to not have QMovie at all. If QMovie is missing then use a single frame instead of an @@ -26,10 +29,63 @@ #endif LoadingScreen::LoadingScreen(QWidget* parent) - : QWidget(parent), ui(std::make_unique()) { + : QWidget(parent), ui(std::make_unique()), + previous_stage(VideoCore::LoadCallbackStage::Complete) { ui->setupUi(this); - // Progress bar is hidden until we have a use for it. - ui->progress_bar->hide(); + + connect(this, &LoadingScreen::LoadProgress, this, &LoadingScreen::OnLoadProgress, + Qt::QueuedConnection); + qRegisterMetaType(); + + stage_translations = { + {VideoCore::LoadCallbackStage::Prepare, tr("Loading...")}, + {VideoCore::LoadCallbackStage::Raw, tr("Preparing Shaders %1 / %2")}, + {VideoCore::LoadCallbackStage::Binary, tr("Loading Shaders %1 / %2")}, + {VideoCore::LoadCallbackStage::Complete, tr("Launching...")}, + }; + progressbar_style = { + {VideoCore::LoadCallbackStage::Prepare, + R"( +QProgressBar { + background-color: black; +} +QProgressBar::chunk { + background-color: white; +})"}, + {VideoCore::LoadCallbackStage::Raw, + R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #0ab9e6; +})"}, + {VideoCore::LoadCallbackStage::Binary, + R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #ff3c28; +})"}, + {VideoCore::LoadCallbackStage::Complete, + R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #ff3c28; +})"}, + }; } LoadingScreen::~LoadingScreen() = default; @@ -46,7 +102,7 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { std::make_unique(reinterpret_cast(buffer.data()), buffer.size()); backing_buf = std::make_unique(backing_mem.get()); backing_buf->open(QIODevice::ReadOnly); - animation = std::make_unique(backing_buf.get(), QByteArray("GIF")); + animation = std::make_unique(backing_buf.get(), QByteArray()); animation->start(); ui->banner->setMovie(animation.get()); #endif @@ -57,14 +113,54 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { map.loadFromData(buffer.data(), buffer.size()); ui->logo->setPixmap(map); } + + OnLoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 100); } -void LoadingScreen::OnLoadProgress(std::size_t value, std::size_t total) { +void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, + std::size_t total) { + using namespace std::chrono; + auto now = high_resolution_clock::now(); + // reset the timer if the stage changes + if (stage != previous_stage) { + ui->progress_bar->setStyleSheet(progressbar_style[stage]); + previous_stage = stage; + // reset back to fast shader compiling since the stage changed + slow_shader_compile_start = false; + } + // update the max of the progress bar if the number of shaders change if (total != previous_total) { ui->progress_bar->setMaximum(total); previous_total = total; } + + QString estimate; + // If theres a drastic slowdown in the rate, then display an estimate + if (now - previous_time > milliseconds{20}) { + if (!slow_shader_compile_start) { + slow_shader_start = high_resolution_clock::now(); + slow_shader_compile_start = true; + slow_shader_first_value = value; + } + // only calculate an estimate time after a second has passed since stage change + auto diff = duration_cast(now - slow_shader_start); + if (diff > seconds{1}) { + auto eta_mseconds = + static_cast(static_cast(total - slow_shader_first_value) / + (value - slow_shader_first_value) * diff.count()); + estimate = + tr("Estimated Time %1") + .arg(QTime(0, 0, 0, 0) + .addMSecs(std::max(eta_mseconds - diff.count() + 1000, 1000)) + .toString("mm:ss")); + } + } + + // update labels and progress bar + ui->stage->setText(stage_translations[stage].arg(value).arg(total)); + ui->value->setText(estimate); ui->progress_bar->setValue(value); + previous_time = now; } void LoadingScreen::paintEvent(QPaintEvent* event) { diff --git a/src/yuzu/loading_screen.h b/src/yuzu/loading_screen.h index 2a6cf11421..9370ede693 100644 --- a/src/yuzu/loading_screen.h +++ b/src/yuzu/loading_screen.h @@ -4,7 +4,9 @@ #pragma once +#include #include +#include #include #if !QT_CONFIG(movie) @@ -19,6 +21,10 @@ namespace Ui { class LoadingScreen; } +namespace VideoCore { +enum class LoadCallbackStage; +} + class QBuffer; class QByteArray; class QMovie; @@ -39,11 +45,14 @@ public: /// used resources such as the logo and banner. void Clear(); + void OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total); + // In order to use a custom widget with a stylesheet, you need to override the paintEvent // See https://wiki.qt.io/How_to_Change_the_Background_Color_of_QWidget void paintEvent(QPaintEvent* event) override; - void OnLoadProgress(std::size_t value, std::size_t total); +signals: + void LoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total); private: #ifndef YUZU_QT_MOVIE_MISSING @@ -53,4 +62,19 @@ private: #endif std::unique_ptr ui; std::size_t previous_total = 0; + VideoCore::LoadCallbackStage previous_stage; + + // Definitions for the differences in text and styling for each stage + std::unordered_map progressbar_style; + std::unordered_map stage_translations; + + // newly generated shaders are added to the end of the file, so when loading and compiling + // shaders, it will start quickly but end slow if new shaders were added since previous launch. + // These variables are used to detect the change in speed so we can generate an ETA + bool slow_shader_compile_start = false; + std::chrono::high_resolution_clock::time_point slow_shader_start; + std::chrono::high_resolution_clock::time_point previous_time; + std::size_t slow_shader_first_value = 0; }; + +Q_DECLARE_METATYPE(VideoCore::LoadCallbackStage); diff --git a/src/yuzu/loading_screen.ui b/src/yuzu/loading_screen.ui index 00579b6709..35d50741e1 100644 --- a/src/yuzu/loading_screen.ui +++ b/src/yuzu/loading_screen.ui @@ -43,20 +43,81 @@ - - - + + + 15 + + + QLayout::SetNoConstraint + + + + + + 0 + 0 + + - font-size: 26px; + background-color: black; color: white; +font: 75 20pt "Arial"; + + + Loading Shaders 387 / 1628 + + + + + + + + 0 + 0 + + + + + 500 + 40 + + + + QProgressBar { +color: white; +border: 2px solid white; +outline-color: black; +border-radius: 20px; +} +QProgressBar::chunk { +background-color: white; +border-radius: 15px; +} - 0 + 50 + + + false Loading Shaders %v out of %m + + + + + + + background-color: black; color: white; +font: 75 15pt "Arial"; + + + Stage 1 of 2. Estimate Time 5m 4s + + + From 63783db1b3ad50b8b7d4448ebb3195db7706742c Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sun, 20 Jan 2019 15:09:14 -0700 Subject: [PATCH 02/11] Hide progress bar on Prepare step --- src/yuzu/loading_screen.cpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 617b8c858a..530f5173ca 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -46,12 +46,8 @@ LoadingScreen::LoadingScreen(QWidget* parent) progressbar_style = { {VideoCore::LoadCallbackStage::Prepare, R"( -QProgressBar { - background-color: black; -} -QProgressBar::chunk { - background-color: white; -})"}, +QProgressBar {} +QProgressBar::chunk {})"}, {VideoCore::LoadCallbackStage::Raw, R"( QProgressBar { @@ -114,7 +110,7 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { ui->logo->setPixmap(map); } - OnLoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 100); + OnLoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0); } void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, @@ -124,6 +120,11 @@ void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size // reset the timer if the stage changes if (stage != previous_stage) { ui->progress_bar->setStyleSheet(progressbar_style[stage]); + if (stage == VideoCore::LoadCallbackStage::Prepare) { + ui->progress_bar->hide(); + } else { + ui->progress_bar->show(); + } previous_stage = stage; // reset back to fast shader compiling since the stage changed slow_shader_compile_start = false; From 4bce57b1495aec153041da0cb5bd5be8f518aea8 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sun, 20 Jan 2019 18:20:21 -0700 Subject: [PATCH 03/11] Move progress bar style into constexpr strings --- src/yuzu/loading_screen.cpp | 78 +++++++++++++++++++------------------ 1 file changed, 41 insertions(+), 37 deletions(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 530f5173ca..608ab6f023 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -28,6 +28,43 @@ #include #endif +constexpr const char* PROGRESSBAR_STYLE_PREPARE = R"( +QProgressBar {} +QProgressBar::chunk {})"; + +constexpr const char* PROGRESSBAR_STYLE_RAW = R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #0ab9e6; +})"; + +constexpr const char* PROGRESSBAR_STYLE_BINARY = R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #ff3c28; +})"; + +constexpr const char* PROGRESSBAR_STYLE_COMPLETE = R"( +QProgressBar { + background-color: black; + border: 2px solid white; + border-radius: 4px; + padding: 2px; +} +QProgressBar::chunk { + background-color: #ff3c28; +})"; + LoadingScreen::LoadingScreen(QWidget* parent) : QWidget(parent), ui(std::make_unique()), previous_stage(VideoCore::LoadCallbackStage::Complete) { @@ -44,43 +81,10 @@ LoadingScreen::LoadingScreen(QWidget* parent) {VideoCore::LoadCallbackStage::Complete, tr("Launching...")}, }; progressbar_style = { - {VideoCore::LoadCallbackStage::Prepare, - R"( -QProgressBar {} -QProgressBar::chunk {})"}, - {VideoCore::LoadCallbackStage::Raw, - R"( -QProgressBar { - background-color: black; - border: 2px solid white; - border-radius: 4px; - padding: 2px; -} -QProgressBar::chunk { - background-color: #0ab9e6; -})"}, - {VideoCore::LoadCallbackStage::Binary, - R"( -QProgressBar { - background-color: black; - border: 2px solid white; - border-radius: 4px; - padding: 2px; -} -QProgressBar::chunk { - background-color: #ff3c28; -})"}, - {VideoCore::LoadCallbackStage::Complete, - R"( -QProgressBar { - background-color: black; - border: 2px solid white; - border-radius: 4px; - padding: 2px; -} -QProgressBar::chunk { - background-color: #ff3c28; -})"}, + {VideoCore::LoadCallbackStage::Prepare, PROGRESSBAR_STYLE_PREPARE}, + {VideoCore::LoadCallbackStage::Raw, PROGRESSBAR_STYLE_RAW}, + {VideoCore::LoadCallbackStage::Binary, PROGRESSBAR_STYLE_BINARY}, + {VideoCore::LoadCallbackStage::Complete, PROGRESSBAR_STYLE_COMPLETE}, }; } From 56541b1ae5078ed0b47fefb963d38b46c3f7858b Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sun, 20 Jan 2019 18:22:29 -0700 Subject: [PATCH 04/11] Prevent estimated time from flashing after slow shader compilation starts --- src/yuzu/loading_screen.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 608ab6f023..ffa7f5bb26 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -141,7 +141,7 @@ void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size QString estimate; // If theres a drastic slowdown in the rate, then display an estimate - if (now - previous_time > milliseconds{20}) { + if (now - previous_time > milliseconds{50} || slow_shader_compile_start) { if (!slow_shader_compile_start) { slow_shader_start = high_resolution_clock::now(); slow_shader_compile_start = true; From ea73ffe202e44ed45191eea10bbecbf35e158f32 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sun, 20 Jan 2019 18:40:25 -0700 Subject: [PATCH 05/11] Rename step 1 and step 2 to be a little more descriptive --- src/video_core/rasterizer_interface.h | 4 ++-- src/yuzu/loading_screen.cpp | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/video_core/rasterizer_interface.h b/src/video_core/rasterizer_interface.h index b2c74afde1..ff53108482 100644 --- a/src/video_core/rasterizer_interface.h +++ b/src/video_core/rasterizer_interface.h @@ -14,8 +14,8 @@ namespace VideoCore { enum class LoadCallbackStage { Prepare, - Raw, - Binary, + Decompile, + Build, Complete, }; using DiskResourceLoadCallback = std::function; diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index ffa7f5bb26..9ce6068634 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -32,7 +32,7 @@ constexpr const char* PROGRESSBAR_STYLE_PREPARE = R"( QProgressBar {} QProgressBar::chunk {})"; -constexpr const char* PROGRESSBAR_STYLE_RAW = R"( +constexpr const char* PROGRESSBAR_STYLE_DECOMPILE = R"( QProgressBar { background-color: black; border: 2px solid white; @@ -43,7 +43,7 @@ QProgressBar::chunk { background-color: #0ab9e6; })"; -constexpr const char* PROGRESSBAR_STYLE_BINARY = R"( +constexpr const char* PROGRESSBAR_STYLE_BUILD = R"( QProgressBar { background-color: black; border: 2px solid white; @@ -76,14 +76,14 @@ LoadingScreen::LoadingScreen(QWidget* parent) stage_translations = { {VideoCore::LoadCallbackStage::Prepare, tr("Loading...")}, - {VideoCore::LoadCallbackStage::Raw, tr("Preparing Shaders %1 / %2")}, - {VideoCore::LoadCallbackStage::Binary, tr("Loading Shaders %1 / %2")}, + {VideoCore::LoadCallbackStage::Decompile, tr("Preparing Shaders %1 / %2")}, + {VideoCore::LoadCallbackStage::Build, tr("Loading Shaders %1 / %2")}, {VideoCore::LoadCallbackStage::Complete, tr("Launching...")}, }; progressbar_style = { {VideoCore::LoadCallbackStage::Prepare, PROGRESSBAR_STYLE_PREPARE}, - {VideoCore::LoadCallbackStage::Raw, PROGRESSBAR_STYLE_RAW}, - {VideoCore::LoadCallbackStage::Binary, PROGRESSBAR_STYLE_BINARY}, + {VideoCore::LoadCallbackStage::Decompile, PROGRESSBAR_STYLE_DECOMPILE}, + {VideoCore::LoadCallbackStage::Build, PROGRESSBAR_STYLE_BUILD}, {VideoCore::LoadCallbackStage::Complete, PROGRESSBAR_STYLE_COMPLETE}, }; } From 636cc2a4964f99bfa2d5ca12baf10357cf80ba8d Mon Sep 17 00:00:00 2001 From: James Rowe Date: Sun, 20 Jan 2019 19:14:14 -0700 Subject: [PATCH 06/11] Change the background color of Stage Complete to yuzu blue --- src/yuzu/loading_screen.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 9ce6068634..ae4d4a2496 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -56,7 +56,7 @@ QProgressBar::chunk { constexpr const char* PROGRESSBAR_STYLE_COMPLETE = R"( QProgressBar { - background-color: black; + background-color: #0ab9e6; border: 2px solid white; border-radius: 4px; padding: 2px; From aa427bb2a752fc413d4452f1fea1190cdb2039b1 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Mon, 21 Jan 2019 08:50:23 -0700 Subject: [PATCH 07/11] Remove blue box around loading screen --- src/yuzu/main.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp index 68bfa23ab1..f1effb857c 100644 --- a/src/yuzu/main.cpp +++ b/src/yuzu/main.cpp @@ -904,7 +904,6 @@ void GMainWindow::BootGame(const QString& filename) { loading_screen->Prepare(Core::System::GetInstance().GetAppLoader()); loading_screen->show(); - loading_screen->setFocus(); emulation_running = true; if (ui.action_Fullscreen->isChecked()) { From 3740adb6f582963e50afba0a248163e3a37dd659 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Mon, 21 Jan 2019 08:51:37 -0700 Subject: [PATCH 08/11] Set Minimum Size to the same as renderwindow --- src/yuzu/loading_screen.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index ae4d4a2496..63c547b490 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -69,6 +69,7 @@ LoadingScreen::LoadingScreen(QWidget* parent) : QWidget(parent), ui(std::make_unique()), previous_stage(VideoCore::LoadCallbackStage::Complete) { ui->setupUi(this); + setMinimumSize(1280, 720); connect(this, &LoadingScreen::LoadProgress, this, &LoadingScreen::OnLoadProgress, Qt::QueuedConnection); From 3ca0af8bb3dfd7c67320a842db8eabe198058bd6 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Mon, 21 Jan 2019 09:20:16 -0700 Subject: [PATCH 09/11] Add fade out effect to the loading screen --- src/yuzu/loading_screen.cpp | 27 +++++ src/yuzu/loading_screen.h | 12 +++ src/yuzu/loading_screen.ui | 201 ++++++++++++++++++++---------------- src/yuzu/main.cpp | 12 ++- 4 files changed, 158 insertions(+), 94 deletions(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 63c547b490..76ef86b8c2 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -13,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -71,6 +73,25 @@ LoadingScreen::LoadingScreen(QWidget* parent) ui->setupUi(this); setMinimumSize(1280, 720); + // Create a fade out effect to hide this loading screen widget. + // When fading opacity, it will fade to the parent widgets background color, which is why we + // create an internal widget named fade_widget that we use the effect on, while keeping the + // loading screen widget's background color black. This way we can create a fade to black effect + opacity_effect = new QGraphicsOpacityEffect(this); + opacity_effect->setOpacity(1); + ui->fade_parent->setGraphicsEffect(opacity_effect); + fadeout_animation = std::make_unique(opacity_effect, "opacity"); + fadeout_animation->setDuration(500); + fadeout_animation->setStartValue(1); + fadeout_animation->setEndValue(0); + fadeout_animation->setEasingCurve(QEasingCurve::OutBack); + + // After the fade completes, hide the widget and reset the opacity + connect(fadeout_animation.get(), &QPropertyAnimation::finished, [this] { + hide(); + opacity_effect->setOpacity(1); + emit Hidden(); + }); connect(this, &LoadingScreen::LoadProgress, this, &LoadingScreen::OnLoadProgress, Qt::QueuedConnection); qRegisterMetaType(); @@ -115,9 +136,14 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { ui->logo->setPixmap(map); } + slow_shader_compile_start = false; OnLoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0); } +void LoadingScreen::OnLoadComplete() { + fadeout_animation->start(QPropertyAnimation::KeepWhenStopped); +} + void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total) { using namespace std::chrono; @@ -125,6 +151,7 @@ void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size // reset the timer if the stage changes if (stage != previous_stage) { ui->progress_bar->setStyleSheet(progressbar_style[stage]); + // Hide the progress bar during the prepare stage if (stage == VideoCore::LoadCallbackStage::Prepare) { ui->progress_bar->hide(); } else { diff --git a/src/yuzu/loading_screen.h b/src/yuzu/loading_screen.h index 9370ede693..091e58eb7b 100644 --- a/src/yuzu/loading_screen.h +++ b/src/yuzu/loading_screen.h @@ -27,7 +27,9 @@ enum class LoadCallbackStage; class QBuffer; class QByteArray; +class QGraphicsOpacityEffect; class QMovie; +class QPropertyAnimation; class LoadingScreen : public QWidget { Q_OBJECT @@ -45,14 +47,21 @@ public: /// used resources such as the logo and banner. void Clear(); + /// Slot used to update the status of the progress bar void OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total); + /// Hides the LoadingScreen with a fade out effect + void OnLoadComplete(); + // In order to use a custom widget with a stylesheet, you need to override the paintEvent // See https://wiki.qt.io/How_to_Change_the_Background_Color_of_QWidget void paintEvent(QPaintEvent* event) override; signals: void LoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value, std::size_t total); + /// Signals that this widget is completely hidden now and should be replaced with the other + /// widget + void Hidden(); private: #ifndef YUZU_QT_MOVIE_MISSING @@ -64,6 +73,9 @@ private: std::size_t previous_total = 0; VideoCore::LoadCallbackStage previous_stage; + QGraphicsOpacityEffect* opacity_effect = nullptr; + std::unique_ptr fadeout_animation = nullptr; + // Definitions for the differences in text and styling for each stage std::unordered_map progressbar_style; std::unordered_map stage_translations; diff --git a/src/yuzu/loading_screen.ui b/src/yuzu/loading_screen.ui index 35d50741e1..a67d273fd7 100644 --- a/src/yuzu/loading_screen.ui +++ b/src/yuzu/loading_screen.ui @@ -30,59 +30,77 @@ 0 - - - - - - Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop - - - 30 - - - - - - - 15 - - - QLayout::SetNoConstraint - - - - - - 0 - 0 - - - - background-color: black; color: white; + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + + + Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop + + + 30 + + + + + + + 15 + + + QLayout::SetNoConstraint + + + + + + 0 + 0 + + + + background-color: black; color: white; font: 75 20pt "Arial"; - - - Loading Shaders 387 / 1628 - - - - - - - - 0 - 0 - - - - - 500 - 40 - - - - QProgressBar { + + + Loading Shaders 387 / 1628 + + + + + + + + 0 + 0 + + + + + 500 + 40 + + + + QProgressBar { color: white; border: 2px solid white; outline-color: black; @@ -92,45 +110,48 @@ QProgressBar::chunk { background-color: white; border-radius: 15px; } - - - 50 - - - false - - - Loading Shaders %v out of %m - - - - - - - - - - background-color: black; color: white; + + + 50 + + + false + + + Loading Shaders %v out of %m + + + + + + + + + + background-color: black; color: white; font: 75 15pt "Arial"; - - - Stage 1 of 2. Estimate Time 5m 4s - - - - - - - - - background-color: black; - - - - - - 30 - + + + Stage 1 of 2. Estimate Time 5m 4s + + + + + + + + + background-color: black; + + + + + + 30 + + + + diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp index f1effb857c..2c3e27c2e7 100644 --- a/src/yuzu/main.cpp +++ b/src/yuzu/main.cpp @@ -415,6 +415,13 @@ void GMainWindow::InitializeWidgets() { loading_screen = new LoadingScreen(this); loading_screen->hide(); ui.horizontalLayout->addWidget(loading_screen); + connect(loading_screen, &LoadingScreen::Hidden, [&] { + loading_screen->Clear(); + if (emulation_running) { + render_window->show(); + render_window->setFocus(); + } + }); // Create status bar message_label = new QLabel(); @@ -1513,10 +1520,7 @@ void GMainWindow::OnStopGame() { } void GMainWindow::OnLoadComplete() { - loading_screen->hide(); - loading_screen->Clear(); - render_window->show(); - render_window->setFocus(); + loading_screen->OnLoadComplete(); } void GMainWindow::OnMenuReportCompatibility() { From 372245e0b52a738148a9291fbe448e3c61fa07bd Mon Sep 17 00:00:00 2001 From: James Rowe Date: Mon, 21 Jan 2019 09:39:45 -0700 Subject: [PATCH 10/11] Fix mingw compile error and warnings --- src/yuzu/loading_screen.cpp | 10 +++++----- src/yuzu/loading_screen.h | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 76ef86b8c2..8ac7f50595 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -120,8 +120,8 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { map.loadFromData(buffer.data(), buffer.size()); ui->banner->setPixmap(map); #else - backing_mem = - std::make_unique(reinterpret_cast(buffer.data()), buffer.size()); + backing_mem = std::make_unique(reinterpret_cast(buffer.data()), + static_cast(buffer.size())); backing_buf = std::make_unique(backing_mem.get()); backing_buf->open(QIODevice::ReadOnly); animation = std::make_unique(backing_buf.get(), QByteArray()); @@ -132,7 +132,7 @@ void LoadingScreen::Prepare(Loader::AppLoader& loader) { } if (loader.ReadLogo(buffer) == Loader::ResultStatus::Success) { QPixmap map; - map.loadFromData(buffer.data(), buffer.size()); + map.loadFromData(buffer.data(), static_cast(buffer.size())); ui->logo->setPixmap(map); } @@ -163,7 +163,7 @@ void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size } // update the max of the progress bar if the number of shaders change if (total != previous_total) { - ui->progress_bar->setMaximum(total); + ui->progress_bar->setMaximum(static_cast(total)); previous_total = total; } @@ -192,7 +192,7 @@ void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size // update labels and progress bar ui->stage->setText(stage_translations[stage].arg(value).arg(total)); ui->value->setText(estimate); - ui->progress_bar->setValue(value); + ui->progress_bar->setValue(static_cast(value)); previous_time = now; } diff --git a/src/yuzu/loading_screen.h b/src/yuzu/loading_screen.h index 091e58eb7b..801d08e1ad 100644 --- a/src/yuzu/loading_screen.h +++ b/src/yuzu/loading_screen.h @@ -74,7 +74,7 @@ private: VideoCore::LoadCallbackStage previous_stage; QGraphicsOpacityEffect* opacity_effect = nullptr; - std::unique_ptr fadeout_animation = nullptr; + std::unique_ptr fadeout_animation; // Definitions for the differences in text and styling for each stage std::unordered_map progressbar_style; From 3049ea45d3f1621e48714022a195f6a2971dce56 Mon Sep 17 00:00:00 2001 From: James Rowe Date: Mon, 21 Jan 2019 10:28:32 -0700 Subject: [PATCH 11/11] Change const char* to const char[] --- src/yuzu/loading_screen.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/yuzu/loading_screen.cpp b/src/yuzu/loading_screen.cpp index 8ac7f50595..907aac4f1d 100644 --- a/src/yuzu/loading_screen.cpp +++ b/src/yuzu/loading_screen.cpp @@ -30,11 +30,11 @@ #include #endif -constexpr const char* PROGRESSBAR_STYLE_PREPARE = R"( +constexpr const char PROGRESSBAR_STYLE_PREPARE[] = R"( QProgressBar {} QProgressBar::chunk {})"; -constexpr const char* PROGRESSBAR_STYLE_DECOMPILE = R"( +constexpr const char PROGRESSBAR_STYLE_DECOMPILE[] = R"( QProgressBar { background-color: black; border: 2px solid white; @@ -45,7 +45,7 @@ QProgressBar::chunk { background-color: #0ab9e6; })"; -constexpr const char* PROGRESSBAR_STYLE_BUILD = R"( +constexpr const char PROGRESSBAR_STYLE_BUILD[] = R"( QProgressBar { background-color: black; border: 2px solid white; @@ -56,7 +56,7 @@ QProgressBar::chunk { background-color: #ff3c28; })"; -constexpr const char* PROGRESSBAR_STYLE_COMPLETE = R"( +constexpr const char PROGRESSBAR_STYLE_COMPLETE[] = R"( QProgressBar { background-color: #0ab9e6; border: 2px solid white;