Initial attempt at the prelaunch document

files.cmake

@@ -1485,6 +1485,10 @@ set(DUSK_FILES
         src/dusk/ui/pane.hpp
         src/dusk/ui/popup.cpp
         src/dusk/ui/popup.hpp
+        src/dusk/ui/prelaunch.cpp
+        src/dusk/ui/prelaunch.hpp
+        src/dusk/ui/prelaunch_options.cpp
+        src/dusk/ui/prelaunch_options.hpp
         src/dusk/ui/select_button.cpp
         src/dusk/ui/select_button.hpp
         src/dusk/ui/settings.cpp

res/rml/prelaunch.rcss

@@ -0,0 +1,169 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    width: 100%;
+    height: 100%;
+    font-family: "Fira Sans";
+    font-weight: normal;
+    font-size: 20dp;
+    color: #FFFFFF;
+    background-color: #000000;
+    decorator: image(../prelaunch-bg.png cover left center);
+}
+
+.menu {
+    position: absolute;
+    left: 96dp;
+    top: 50%;
+    transform: translateY(-50%);
+    /* Scale based on a reference screen width, 428/1216 */
+    width: 35.230264vw;
+    min-width: 428dp;
+    max-width: 856dp;
+    height: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 48dp;
+}
+
+.hero {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: flex-start;
+    gap: 8dp;
+}
+
+.hero img {
+    width: 100%;
+}
+
+.eyebrow {
+    font-family: "Alegreya SC";
+    font-size: 32dp;
+}
+
+@media (min-width: 1216dp) {
+    .eyebrow {
+        /* Same logic as .menu, 32/1216 */
+        font-size: 2.631579vw;
+    }
+}
+
+.eyebrow span {
+    font-weight: bold;
+}
+
+#menu-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12dp;
+}
+
+#menu-list button {
+    width: 428dp;
+    height: 54dp;
+    padding: 8dp 16dp;
+    border-radius: 8dp;
+    text-transform: uppercase;
+    font-family: "Fira Sans Condensed";
+    font-size: 32dp;
+    font-weight: normal;
+    cursor: pointer;
+    /* Define a fully transparent gradient as the default state, otherwise a white flash occurs */
+    decorator: horizontal-gradient(#00000000 #00000000);
+}
+
+#menu-list button[anim-done] {
+    transition: decorator color 0.1s linear-in-out;
+}
+
+#menu-list button:hover,
+#menu-list button:focus-visible {
+    color: black;
+    decorator: horizontal-gradient(#FEE685FF #FEE68500);
+}
+
+.disk-status {
+    position: absolute;
+    left: 96dp;
+    bottom: 72dp;
+    display: flex;
+    flex-direction: column;
+    gap: 8dp;
+}
+
+.version-info {
+    position: absolute;
+    right: 96dp;
+    bottom: 72dp;
+    display: flex;
+    flex-direction: column;
+    gap: 8dp;
+    text-align: right;
+}
+
+.status,
+.version {
+    font-size: 24dp;
+}
+
+.status,
+.update {
+    color: #D8F999;
+}
+
+.status[bad] {
+    color: #FFC9C9;
+}
+
+/* TODO: Hidden until an actual update checker is introduced */
+.update {
+    display: none;
+    font-size: 16dp;
+    font-weight: bold;
+    cursor: pointer;
+}
+
+.detail,
+.update span {
+    color: #A6A09B;
+}
+
+/* Startup animation */
+.intro-item {
+    opacity: 0;
+    transform: translateY(10dp);
+    transition: opacity transform 0.3s 0.1s cubic-in-out;
+}
+
+body.animate-in .intro-item {
+    opacity: 1;
+    transform: translateY(0dp);
+}
+
+.delay-0 {
+    transition: opacity transform 0.3s 0.1s cubic-in-out;
+}
+
+.delay-1 {
+    transition: opacity transform 0.3s 0.2s cubic-in-out;
+}
+
+.delay-2 {
+    transition: opacity transform 0.3s 0.3s cubic-in-out;
+}
+
+.delay-3 {
+    transition: opacity transform 0.3s 0.4s cubic-in-out;
+}
+
+.delay-4 {
+    transition: opacity transform 0.3s 0.5s cubic-in-out;
+}
+
+.delay-5 {
+    transition: opacity transform 0.3s 0.6s cubic-in-out;
+}

src/dusk/ui/prelaunch.cpp

@@ -0,0 +1,230 @@
+#include "prelaunch.hpp"
+
+#include "dusk/config.hpp"
+#include "dusk/file_select.hpp"
+#include "dusk/iso_validate.hpp"
+#include "dusk/main.h"
+#include "dusk/ui/prelaunch_options.hpp"
+#include "version.h"
+
+#include <aurora/lib/window.hpp>
+#include <SDL3/SDL_dialog.h>
+#include <SDL3/SDL_filesystem.h>
+
+namespace dusk::ui {
+namespace {
+
+const Rml::String kDocumentSource = R"RML(
+<rml>
+<head>
+    <link type="text/rcss" href="res/rml/prelaunch.rcss" />
+</head>
+<body>
+    <div class="menu">
+        <div class="hero intro-item delay-0">
+            <div class="eyebrow"><span>Twilit Realm</span> presents</div>
+            <img src="res/logo-mascot.png" />
+        </div>
+        <div id="menu-list" />
+    </div>
+    <div class="disk-status intro-item delay-4">
+        <span id="status" class="status" />
+        <span id="detail" class="detail" />
+    </div>
+    <div class="version-info intro-item delay-5">
+        <div class="version">Version <span id="version-text"></span></div>
+        <div class="update"><span>Update available!</span> Download</div>
+    </div>
+</body>
+</rml>
+)RML";
+
+static constexpr std::array<SDL_DialogFileFilter, 2> kDiscFileFilters{{
+    {"Game Disc Images", "iso;gcm;ciso;gcz;nfs;rvz;wbfs;wia;tgc"},
+    {"All Files", "*"},
+}};
+
+void file_dialog_callback(void*, const char* path, const char* error) {
+    auto& state = prelaunch_state();
+    if (error != nullptr) {
+        return;
+    }
+    if (path == nullptr) {
+        return;
+    }
+
+    state.selectedIsoPath = path;
+    state.errorString.clear();
+    refresh_path_state();
+    getSettings().backend.isoPath.setValue(state.selectedIsoPath);
+    config::Save();
+}
+
+}  // namespace
+
+PrelaunchState sPrelaunchState;
+
+PrelaunchState& prelaunch_state() noexcept {
+    return sPrelaunchState;
+}
+
+void refresh_path_state() noexcept {
+    auto& state = prelaunch_state();
+    state.isPal = !state.selectedIsoPath.empty() && iso::isPal(state.selectedIsoPath.c_str());
+}
+
+void ensure_initialized() noexcept {
+    auto& state = prelaunch_state();
+    if (state.initialized) {
+        return;
+    }
+
+    state.selectedIsoPath = getSettings().backend.isoPath;
+    state.initialGraphicsBackend = getSettings().backend.graphicsBackend;
+    state.errorString.clear();
+    state.initialized = true;
+    refresh_path_state();
+}
+
+bool is_selected_path_valid() noexcept {
+    return !prelaunch_state().selectedIsoPath.empty() && SDL_GetPathInfo(prelaunch_state().selectedIsoPath.c_str(), nullptr);
+}
+
+void open_iso_picker() noexcept {
+    ensure_initialized();
+    ShowFileSelect(&file_dialog_callback, nullptr, aurora::window::get_sdl_window(),
+        kDiscFileFilters.data(), static_cast<int>(kDiscFileFilters.size()), nullptr, false);
+}
+
+void apply_intro_animation(Rml::Element* element, const char* delay_class) {
+    if (element == nullptr || delay_class == nullptr) {
+        return;
+    }
+    element->SetClass("intro-item", true);
+    element->SetClass(delay_class, true);
+}
+
+Prelaunch::Prelaunch() : Document(kDocumentSource) {
+    ensure_initialized();
+
+    if (auto* menuList = mDocument->GetElementById("menu-list")) {
+        const bool hasValidPath = is_selected_path_valid();
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, hasValidPath ? "Start Game" : "Select Disk Image"));
+        mMenuButtons.back()->on_pressed([this] {
+            if (!is_selected_path_valid()) {
+                open_iso_picker();
+                return;
+            }
+            pop_document();
+            IsGameLaunched = true;
+        });
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-1");
+
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Options"));
+        mMenuButtons.back()->on_pressed([] { push_document(std::make_unique<PrelaunchOptions>());});
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-2");
+
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Quit To Desktop"));
+        mMenuButtons.back()->on_pressed([] { IsRunning = false; });
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-3");
+    }
+
+    listen(Rml::EventId::Keydown, [this](Rml::Event& event) {
+        const auto cmd = map_nav_event(event);
+
+        int direction = 0;
+        if (cmd == NavCommand::Down) {
+            direction = 1;
+        } else if (cmd == NavCommand::Up) {
+            direction = -1;
+        } else {
+            return;
+        }
+        auto* target = event.GetTargetElement();
+        int focusedButton = -1;
+        for (size_t i = 0; i < mMenuButtons.size(); ++i) {
+            if (mMenuButtons[i]->contains(target)) {
+                focusedButton = i;
+                break;
+            }
+        }
+        if (focusedButton == -1) {
+            return;
+        }
+        int i = focusedButton + direction;
+        while (i >= 0 && i < mMenuButtons.size()) {
+            if (mMenuButtons[i]->focus()) {
+                event.StopPropagation();
+                break;
+            }
+            i += direction;
+        }
+    });
+
+    mDiscStatus = mDocument->GetElementById("status");
+    mDiscDetail = mDocument->GetElementById("detail");
+    mVersion = mDocument->GetElementById("version-text");
+
+    listen(mDocument, Rml::EventId::Transitionend, [this](Rml::Event& event) {
+        auto* target = event.GetTargetElement();
+        if (target != nullptr && target->GetTagName() == "button") {
+            target->SetClass("anim-done", true);
+        }
+    });
+}
+
+void Prelaunch::update() {
+    ensure_initialized();
+    refresh_path_state();
+
+    if (!mEntranceAnimationStarted && mDocument != nullptr) {
+        mDocument->SetClass("animate-in", true);
+        mEntranceAnimationStarted = true;
+    }
+
+    auto& state = prelaunch_state();
+    const bool hasValidPath = is_selected_path_valid();
+    if (hasValidPath && getSettings().backend.skipPreLaunchUI) {
+        pop_document();
+        IsGameLaunched = true;
+    }
+
+    if (!mMenuButtons.empty()) {
+        mMenuButtons[0]->set_text(hasValidPath ? "Start Game" : "Select Disk Image");
+    }
+    if (mDiscStatus != nullptr) {
+        if (hasValidPath) {
+            mDiscStatus->RemoveAttribute("bad");
+            mDiscStatus->SetInnerRML("Disc Ready");
+        } else {
+            mDiscStatus->SetAttribute("bad", "");
+            mDiscStatus->SetInnerRML("Disk Not Found");
+        }
+    }
+    if (mDiscDetail != nullptr) {
+        if (hasValidPath) {
+            mDiscDetail->SetProperty(Rml::PropertyId::Display, Rml::Style::Display::Block);
+            mDiscDetail->SetInnerRML(prelaunch_state().isPal ? "GameCube • PAL" : "GameCube • USA");
+        } else {
+            mDiscDetail->SetProperty(Rml::PropertyId::Display, Rml::Style::Display::None);
+        }
+    }
+    if (mVersion != nullptr) {
+        mVersion->SetInnerRML(escape(DUSK_WC_DESCRIBE));
+    }
+
+    Document::update();
+}
+
+bool Prelaunch::focus() {
+    if (mMenuButtons.empty()) {
+        return false;
+    }
+    return mMenuButtons[0]->focus();
+}
+
+bool Prelaunch::handle_nav_command(Rml::Event& event, NavCommand cmd) {
+    return Document::handle_nav_command(event, cmd);
+}
+
+}  // namespace dusk::ui

src/dusk/ui/prelaunch.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "button.hpp"
+#include "document.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace dusk::ui {
+
+class Prelaunch : public Document {
+public:
+    Prelaunch();
+
+    void update() override;
+    bool focus() override;
+
+protected:
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+private:
+    bool mEntranceAnimationStarted = false;
+    std::vector<std::unique_ptr<Button>> mMenuButtons;
+    Rml::Element* mDiscStatus = nullptr;
+    Rml::Element* mDiscDetail = nullptr;
+    Rml::Element* mVersion = nullptr;
+};
+
+class PrelaunchOptions;
+
+struct PrelaunchState {
+    std::string selectedIsoPath;
+    std::string errorString;
+    std::string initialGraphicsBackend;
+    bool isPal = false;
+    bool initialized = false;
+};
+
+PrelaunchState& prelaunch_state() noexcept;
+void ensure_initialized() noexcept;
+void refresh_path_state() noexcept;
+bool is_selected_path_valid() noexcept;
+void open_iso_picker() noexcept;
+
+}  // namespace dusk::ui

src/dusk/ui/prelaunch_options.cpp

@@ -0,0 +1,263 @@
+#include "prelaunch_options.hpp"
+
+#include "dusk/config.hpp"
+#include "dusk/settings.h"
+#include "pane.hpp"
+#include "prelaunch.hpp"
+
+namespace dusk::ui {
+namespace {
+
+static constexpr std::array<const char*, 5> kLanguageNames = {
+    "English", "German", "French", "Spanish", "Italian",
+};
+
+// TODO: Copied from ImGui prelaunch. Needs a refactor?
+bool try_parse_backend(std::string_view backend, AuroraBackend& outBackend) {
+    if (backend == "auto") {
+        outBackend = BACKEND_AUTO;
+        return true;
+    }
+    if (backend == "d3d11") {
+        outBackend = BACKEND_D3D11;
+        return true;
+    }
+    if (backend == "d3d12") {
+        outBackend = BACKEND_D3D12;
+        return true;
+    }
+    if (backend == "metal") {
+        outBackend = BACKEND_METAL;
+        return true;
+    }
+    if (backend == "vulkan") {
+        outBackend = BACKEND_VULKAN;
+        return true;
+    }
+    if (backend == "opengl") {
+        outBackend = BACKEND_OPENGL;
+        return true;
+    }
+    if (backend == "opengles") {
+        outBackend = BACKEND_OPENGLES;
+        return true;
+    }
+    if (backend == "webgpu") {
+        outBackend = BACKEND_WEBGPU;
+        return true;
+    }
+    if (backend == "null") {
+        outBackend = BACKEND_NULL;
+        return true;
+    }
+
+    return false;
+}
+
+std::string_view backend_name(AuroraBackend backend) {
+    switch (backend) {
+    default:
+        return "Auto";
+    case BACKEND_D3D12:
+        return "D3D12";
+    case BACKEND_D3D11:
+        return "D3D11";
+    case BACKEND_METAL:
+        return "Metal";
+    case BACKEND_VULKAN:
+        return "Vulkan";
+    case BACKEND_OPENGL:
+        return "OpenGL";
+    case BACKEND_OPENGLES:
+        return "OpenGL ES";
+    case BACKEND_WEBGPU:
+        return "WebGPU";
+    case BACKEND_NULL:
+        return "Null";
+    }
+}
+
+std::string_view backend_id(AuroraBackend backend) {
+    switch (backend) {
+    default:
+        return "auto";
+    case BACKEND_D3D12:
+        return "d3d12";
+    case BACKEND_D3D11:
+        return "d3d11";
+    case BACKEND_METAL:
+        return "metal";
+    case BACKEND_VULKAN:
+        return "vulkan";
+    case BACKEND_OPENGL:
+        return "opengl";
+    case BACKEND_OPENGLES:
+        return "opengles";
+    case BACKEND_WEBGPU:
+        return "webgpu";
+    case BACKEND_NULL:
+        return "null";
+    }
+}
+
+std::vector<AuroraBackend> available_backends() {
+    std::vector<AuroraBackend> backends;
+    backends.emplace_back(BACKEND_AUTO);
+    size_t backendCount = 0;
+    const AuroraBackend* raw = aurora_get_available_backends(&backendCount);
+    for (size_t i = 0; i < backendCount; ++i) {
+        // Do not expose NULL or D3D11
+        if (raw[i] != BACKEND_NULL || raw[i] == BACKEND_D3D11) {
+            backends.emplace_back(raw[i]);
+        }
+    }
+    return backends;
+}
+
+class LanguageSelect final : public SelectButton {
+public:
+    explicit LanguageSelect(Rml::Element* parent) : SelectButton(parent, Props{.key = "Language"}) {}
+
+    void update() override {
+        ensure_initialized();
+        refresh_path_state();
+
+        const bool validPath = is_selected_path_valid();
+        const bool ntscDiscLocked = validPath && !prelaunch_state().isPal;
+
+        if (ntscDiscLocked) {
+            if (getSettings().game.language.getValue() != GameLanguage::English) {
+                getSettings().game.language.setValue(GameLanguage::English);
+                config::Save();
+            }
+            set_disabled(true);
+        } else {
+            set_disabled(false);
+        }
+
+        const auto lang = getSettings().game.language.getValue();
+        auto value = static_cast<u8>(lang);
+        if (value >= kLanguageNames.size()) {
+            getSettings().game.language.setValue(GameLanguage::English);
+            config::Save();
+            value = static_cast<u8>(getSettings().game.language.getValue());
+        }
+        set_value_label(kLanguageNames[value]);
+        SelectButton::update();
+    }
+
+protected:
+    bool handle_nav_command(NavCommand cmd) override {
+        if (disabled()) {
+            return false;
+        }
+        if (cmd != NavCommand::Confirm && cmd != NavCommand::Left && cmd != NavCommand::Right) {
+            return false;
+        }
+
+        constexpr int n = static_cast<int>(kLanguageNames.size());
+        int idx = static_cast<int>(getSettings().game.language.getValue());
+        const int dir = (cmd == NavCommand::Left) ? -1 : 1;
+        idx = ((idx + dir) % n + n) % n;
+        getSettings().game.language.setValue(static_cast<GameLanguage>(idx));
+        config::Save();
+        return true;
+    }
+};
+
+class BackendSelect final : public SelectButton {
+public:
+    explicit BackendSelect(Rml::Element* parent) : SelectButton(parent, Props{.key = "Graphics Backend"}) {}
+
+    void update() override {
+        AuroraBackend configuredBackend = BACKEND_AUTO;
+        const auto configuredId = getSettings().backend.graphicsBackend.getValue();
+        if (!try_parse_backend(configuredId, configuredBackend)) {
+            configuredBackend = BACKEND_AUTO;
+        }
+        // Do not expose NULL or D3D11
+        if (configuredBackend == BACKEND_NULL || configuredBackend == BACKEND_D3D11) {
+            getSettings().backend.graphicsBackend.setValue("auto");
+            config::Save();
+            configuredBackend = BACKEND_AUTO;
+        }
+
+        const auto backend = getSettings().backend.graphicsBackend.getValue();
+        Rml::String value = backend_name(configuredBackend).data();
+        if (backend != prelaunch_state().initialGraphicsBackend) {
+            value += " (restart required)";
+        }
+        set_value_label(value);
+        SelectButton::update();
+    }
+
+protected:
+    bool handle_nav_command(NavCommand cmd) override {
+        if (cmd != NavCommand::Confirm && cmd != NavCommand::Left && cmd != NavCommand::Right) {
+            return false;
+        }
+
+        const auto backends = available_backends();
+        const int n = static_cast<int>(backends.size());
+        if (n <= 0) {
+            return false;
+        }
+
+        AuroraBackend configuredBackend = BACKEND_AUTO;
+        const auto configuredId = getSettings().backend.graphicsBackend.getValue();
+        if (!try_parse_backend(configuredId, configuredBackend)) {
+            configuredBackend = BACKEND_AUTO;
+        }
+
+        int idx = 0;
+        for (int i = 0; i < n; ++i) {
+            if (backends[static_cast<size_t>(i)] == configuredBackend) {
+                idx = i;
+                break;
+            }
+        }
+
+        const int dir = (cmd == NavCommand::Left) ? -1 : 1;
+        idx = ((idx + dir) % n + n) % n;
+        getSettings().backend.graphicsBackend.setValue(std::string(backend_id(backends[static_cast<size_t>(idx)])));
+        config::Save();
+        return true;
+    }
+};
+
+class SaveTypeSelect final : public SelectButton {
+public:
+    explicit SaveTypeSelect(Rml::Element* parent) : SelectButton(parent, Props{.key = "Save File Type"}) {}
+
+    void update() override {
+        const CARDFileType cft = static_cast<CARDFileType>(getSettings().backend.cardFileType.getValue());
+        set_value_label(cft == CARD_GCIFOLDER ? "GCI Folder" : "Card Image");
+        SelectButton::update();
+    }
+
+protected:
+    bool handle_nav_command(NavCommand cmd) override {
+        if (cmd != NavCommand::Confirm && cmd != NavCommand::Left && cmd != NavCommand::Right) {
+            return false;
+        }
+
+        CARDFileType cft = static_cast<CARDFileType>(getSettings().backend.cardFileType.getValue());
+        const CARDFileType newValue = cft == CARD_GCIFOLDER ? CARD_RAWIMAGE : CARD_GCIFOLDER;
+        getSettings().backend.cardFileType.setValue(newValue);
+        config::Save();
+        return true;
+    }
+};
+
+}  // namespace
+
+PrelaunchOptions::PrelaunchOptions() {
+    add_tab("Options", [this](Rml::Element* content) {
+        auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
+        leftPane.add_child<LanguageSelect>();
+        leftPane.add_child<BackendSelect>();
+        leftPane.add_child<SaveTypeSelect>();
+    });
+}
+
+}  // namespace dusk::ui

src/dusk/ui/prelaunch_options.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "window.hpp"
+
+namespace dusk::ui {
+
+class PrelaunchOptions : public Window {
+public:
+    PrelaunchOptions();
+};
+
+}  // namespace dusk::ui

src/dusk/ui/ui.cpp

@@ -39,6 +39,8 @@ bool initialize() noexcept {
     load_font("FiraSans-Regular.ttf", true);
     load_font("FiraSansCondensed-Regular.ttf");
     load_font("FiraSansCondensed-Bold.ttf");
+    load_font("AlegreyaSC-Regular.ttf");
+    load_font("AlegreyaSC-Bold.ttf");
 
     sInitialized = true;
     return true;

src/m_Do/m_Do_main.cpp

@@ -59,6 +59,7 @@
 #include "dusk/ui/ui.hpp"
 #include "dusk/ui/editor.hpp"
 #include "dusk/ui/popup.hpp"
+#include "dusk/ui/prelaunch.hpp"
 #include "dusk/ui/settings.hpp"
 #include "version.h"
 
@@ -161,8 +162,9 @@ bool launchUILoop() {
             continue;
         }
 
-        dusk::g_imguiConsole.PreDraw();
+        dusk::ui::update();
 
+        dusk::g_imguiConsole.PreDraw();
         dusk::g_imguiConsole.PostDraw();
 
         aurora_end_frame();
@@ -588,7 +590,6 @@ int game_main(int argc, char* argv[]) {
     dusk::audio::SetEnableReverb(dusk::getSettings().audio.enableReverb);
 
     dusk::ui::initialize();
-    dusk::ui::push_document(std::make_unique<dusk::ui::Popup>(), false);
 
     std::string dvd_path;
     bool dvd_opened = false;
@@ -606,6 +607,8 @@ int game_main(int argc, char* argv[]) {
     }
 
     if (!dvd_opened) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);
+
         // pre game launch ui main loop
         if (!launchUILoop()) {
             dusk::ShutdownCrashReporting();
@@ -627,6 +630,8 @@ int game_main(int argc, char* argv[]) {
         }
     }
 
+    dusk::ui::push_document(std::make_unique<dusk::ui::Popup>(), false);
+
     dusk::version::init();
     LanguageInit();