1 files changed, 102 insertions, 6 deletions
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 <unordered_map>
 #include <QBuffer>
 #include <QByteArray>
 #include <QHBoxLayout>
@@ -13,10 +14,12 @@
 #include <QPixmap>
 #include <QProgressBar>
 #include <QStyleOption>
-#include <QWindow>
+#include <QTime>
+#include <QtConcurrent/QtConcurrentRun>
 #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<Ui::LoadingScreen>()) {
+    : QWidget(parent), ui(std::make_unique<Ui::LoadingScreen>()),
+      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<VideoCore::LoadCallbackStage>();
+
+    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<QByteArray>(reinterpret_cast<char*>(buffer.data()), buffer.size());
         backing_buf = std::make_unique<QBuffer>(backing_mem.get());
         backing_buf->open(QIODevice::ReadOnly);
-        animation = std::make_unique<QMovie>(backing_buf.get(), QByteArray("GIF"));
+        animation = std::make_unique<QMovie>(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<milliseconds>(now - slow_shader_start);
+        if (diff > seconds{1}) {
+            auto eta_mseconds =
+                static_cast<long>(static_cast<double>(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<long>(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) {