refactor: add GUI instance reference to UI nodes

src/frontend/UiDocument.cpp

@@ -54,6 +54,7 @@ scriptenv UiDocument::getEnvironment() const {
 }
 
 std::unique_ptr<UiDocument> UiDocument::read(
+    gui::GUI& gui,
     const scriptenv& penv,
     const std::string& name,
     const io::path& file,
@@ -66,7 +67,7 @@ std::unique_ptr<UiDocument> UiDocument::read(
         ? scripting::create_doc_environment(scripting::get_root_environment(), name)
         : scripting::create_doc_environment(penv, name);
 
-    gui::UiXmlReader reader(env);
+    gui::UiXmlReader reader(gui, env);
     auto view = reader.readXML(file.string(), *xmldoc->getRoot());
     view->setId("root");
     uidocscript script {};
@@ -80,8 +81,7 @@ std::unique_ptr<UiDocument> UiDocument::read(
 }
 
 std::shared_ptr<gui::UINode> UiDocument::readElement(
-    const io::path& file, const std::string& fileName
+    gui::GUI& gui, const io::path& file, const std::string& fileName
 ) {
-    auto document = read(nullptr, file.name(), file, fileName);
-    return document->getRoot();
+    return read(gui, nullptr, file.name(), file, fileName)->getRoot();
 }

src/frontend/UiDocument.hpp

@@ -9,6 +9,7 @@
 #include "io/fwd.hpp"
 
 namespace gui {
+    class GUI;
     class UINode;
 }
 
@@ -45,12 +46,13 @@ public:
     scriptenv getEnvironment() const;
 
     static std::unique_ptr<UiDocument> read(
+        gui::GUI&,
         const scriptenv& parent_env,
         const std::string& name,
         const io::path& file,
         const std::string& fileName
     );
     static std::shared_ptr<gui::UINode> readElement(
-        const io::path& file, const std::string& fileName
+        gui::GUI&, const io::path& file, const std::string& fileName
     );
 };

src/frontend/debug_panel.cpp

@@ -35,8 +35,8 @@
 
 using namespace gui;
 
-static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
-    auto label = std::make_shared<Label>(L"-");
+static std::shared_ptr<Label> create_label(GUI& gui, wstringsupplier supplier) {
+    auto label = std::make_shared<Label>(gui, L"-");
     label->textSupplier(std::move(supplier));
     return label;
 }
@@ -50,7 +50,10 @@ std::shared_ptr<UINode> create_debug_panel(
     Player& player,
     bool allowDebugCheats
 ) {
-    auto panel = std::make_shared<Panel>(glm::vec2(300, 200), glm::vec4(5.0f), 2.0f);
+    auto& gui = engine.getGUI();
+    auto panel = std::make_shared<Panel>(
+        gui, glm::vec2(300, 200), glm::vec4(5.0f), 2.0f
+    );
     panel->setId("hud.debug-panel");
     panel->setPos(glm::vec2(10, 10));
 
@@ -87,48 +90,48 @@ std::shared_ptr<UINode> create_debug_panel(
         lastTotalUpload = totalUpload;
     });
 
-    panel->add(create_label([]() { return L"fps: "+fpsString;}));
+    panel->add(create_label(gui, []() { return L"fps: "+fpsString;}));
    
-    panel->add(create_label([]() {
+    panel->add(create_label(gui, []() {
         return L"meshes: " + std::to_wstring(Mesh::meshesCount);
     }));
-    panel->add(create_label([]() {
+    panel->add(create_label(gui, []() {
         int drawCalls = Mesh::drawCalls;
         Mesh::drawCalls = 0;
         return L"draw-calls: " + std::to_wstring(drawCalls);
     }));
-    panel->add(create_label([]() {
+    panel->add(create_label(gui, []() {
         return L"speakers: " + std::to_wstring(audio::count_speakers())+
                L" streams: " + std::to_wstring(audio::count_streams());
     }));
-    panel->add(create_label([]() {
+    panel->add(create_label(gui, []() {
         return L"lua-stack: " + std::to_wstring(scripting::get_values_on_stack());
     }));
-    panel->add(create_label([]() { return netSpeedString; }));
-    panel->add(create_label([&engine]() {
+    panel->add(create_label(gui, []() { return netSpeedString; }));
+    panel->add(create_label(gui, [&engine]() {
         auto& settings = engine.getSettings();
         bool culling = settings.graphics.frustumCulling.get();
         return L"frustum-culling: "+std::wstring(culling ? L"on" : L"off");
     }));
-    panel->add(create_label([=]() {
+    panel->add(create_label(gui, [=]() {
         return L"particles: " +
                std::to_wstring(ParticlesRenderer::visibleParticles) +
                L" emitters: " +
                std::to_wstring(ParticlesRenderer::aliveEmitters);
     }));
-    panel->add(create_label([&]() {
+    panel->add(create_label(gui, [&]() {
         return L"chunks: "+std::to_wstring(level.chunks->size())+
                L" visible: "+std::to_wstring(ChunksRenderer::visibleChunks);
     }));
-    panel->add(create_label([&]() {
+    panel->add(create_label(gui, [&]() {
         return L"entities: "+std::to_wstring(level.entities->size())+L" next: "+
                std::to_wstring(level.entities->peekNextID());
     }));
-    panel->add(create_label([&]() {
+    panel->add(create_label(gui, [&]() {
         return L"players: "+std::to_wstring(level.players->size())+L" local: "+
                std::to_wstring(player.getId());
     }));
-    panel->add(create_label([&]() -> std::wstring {
+    panel->add(create_label(gui, [&]() -> std::wstring {
         const auto& vox = player.selection.vox;
         std::wstringstream stream;
         stream << "r:" << vox.state.rotation << " s:"
@@ -141,7 +144,7 @@ std::shared_ptr<UINode> create_debug_panel(
                    L" "+stream.str();
         }
     }));
-    panel->add(create_label([&]() -> std::wstring {
+    panel->add(create_label(gui, [&]() -> std::wstring {
         const auto& selection = player.selection;
         const auto& vox = selection.vox;
         if (vox.id == BLOCK_VOID) {
@@ -151,7 +154,7 @@ std::shared_ptr<UINode> create_debug_panel(
                L" y: " + std::to_wstring(selection.actualPosition.y) +
                L" z: " + std::to_wstring(selection.actualPosition.z);
     }));
-    panel->add(create_label([&]() {
+    panel->add(create_label(gui, [&]() {
         auto eid = player.getSelectedEntity();
         if (eid == ENTITY_NONE) {
             return std::wstring {L"entity: -"};
@@ -162,7 +165,7 @@ std::shared_ptr<UINode> create_debug_panel(
             return std::wstring {L"entity: error (invalid UID)"};
         }
     }));
-    panel->add(create_label([&](){
+    panel->add(create_label(gui, [&](){
         auto indices = level.content.getIndices();
         if (auto def = indices->blocks.get(player.selection.vox.id)) {
             return L"name: " + util::str2wstr_utf8(def->name);
@@ -170,23 +173,23 @@ std::shared_ptr<UINode> create_debug_panel(
             return std::wstring {L"name: void"};
         }
     }));
-    panel->add(create_label([&](){
+    panel->add(create_label(gui, [&](){
         return L"seed: "+std::to_wstring(level.getWorld()->getSeed());
     }));
 
     for (int ax = 0; ax < 3; ax++) {
-        auto sub = std::make_shared<Container>(glm::vec2(250, 27));
+        auto sub = std::make_shared<Container>(gui, glm::vec2(250, 27));
 
         std::wstring str = L"x: ";
         str[0] += ax;
-        auto label = std::make_shared<Label>(str);
+        auto label = std::make_shared<Label>(gui, str);
         label->setMargin(glm::vec4(2, 3, 2, 3));
         label->setSize(glm::vec2(20, 27));
         sub->add(label);
         sub->setColor(glm::vec4(0.0f));
 
         // Coord input
-        auto box = std::make_shared<TextBox>(L"");
+        auto box = std::make_shared<TextBox>(gui, L"");
         auto boxRef = box.get();
         box->setTextSupplier([&player, ax]() {
             return util::to_wstring(player.getPosition()[ax], 2);
@@ -212,7 +215,7 @@ std::shared_ptr<UINode> create_debug_panel(
         panel->add(sub);
     }
     auto& worldInfo = level.getWorld()->getInfo();
-    panel->add(create_label([&](){
+    panel->add(create_label(gui, [&](){
         int hour, minute, second;
         timeutil::from_value(worldInfo.daytime, hour, minute, second);
 
@@ -222,20 +225,20 @@ std::shared_ptr<UINode> create_debug_panel(
         return L"time: "+timeString;
     }));
     if (allowDebugCheats) {
-        auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 1.0f, 0.005f, 8);
+        auto bar = std::make_shared<TrackBar>(gui, 0.0f, 1.0f, 1.0f, 0.005f, 8);
         bar->setSupplier([&]() {return worldInfo.daytime;});
         bar->setConsumer([&](double val) {worldInfo.daytime = val;});
         panel->add(bar);
     }
     if (allowDebugCheats) {
-        auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 0.0f, 0.005f, 8);
+        auto bar = std::make_shared<TrackBar>(gui, 0.0f, 1.0f, 0.0f, 0.005f, 8);
         bar->setSupplier([&]() {return worldInfo.fog;});
         bar->setConsumer([&](double val) {worldInfo.fog = val;});
         panel->add(bar);
     }
     {
         auto checkbox = std::make_shared<FullCheckBox>(
-            L"Show Chunk Borders", glm::vec2(400, 24)
+            gui, L"Show Chunk Borders", glm::vec2(400, 24)
         );
         checkbox->setSupplier([=]() {
             return WorldRenderer::showChunkBorders;
@@ -247,7 +250,7 @@ std::shared_ptr<UINode> create_debug_panel(
     }
     {
         auto checkbox = std::make_shared<FullCheckBox>(
-            L"Show Hitboxes", glm::vec2(400, 24)
+            gui, L"Show Hitboxes", glm::vec2(400, 24)
         );
         checkbox->setSupplier([=]() {
             return WorldRenderer::showEntitiesDebug;
@@ -259,7 +262,7 @@ std::shared_ptr<UINode> create_debug_panel(
     }
     {
         auto checkbox = std::make_shared<FullCheckBox>(
-            L"Show Generator Minimap", glm::vec2(400, 24)
+            gui, L"Show Generator Minimap", glm::vec2(400, 24)
         );
         checkbox->setSupplier([=]() {
             return Hud::showGeneratorMinimap;

src/frontend/hud.cpp

@@ -126,7 +126,7 @@ std::shared_ptr<InventoryView> Hud::createContentAccess() {
         inventory->getSlot(player.getChosenSlot()).set(item);
     });
 
-    InventoryBuilder builder;
+    InventoryBuilder builder(gui);
     builder.addGrid(8, itemsCount-1, glm::vec2(), glm::vec4(8, 8, 12, 8), true, slotLayout);
     auto view = builder.build();
     view->bind(accessInventory, &content);
@@ -139,7 +139,7 @@ std::shared_ptr<InventoryView> Hud::createHotbar() {
     auto& content = frontend.getLevel().content;
 
     SlotLayout slotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr);
-    InventoryBuilder builder;
+    InventoryBuilder builder(gui);
     builder.addGrid(10, 10, glm::vec2(), glm::vec4(4), true, slotLayout);
     auto view = builder.build();
     view->setId("hud.hotbar");
@@ -153,8 +153,10 @@ static constexpr uint WORLDGEN_IMG_SIZE = 128U;
 
 Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
     : engine(engine),
+      input(engine.getInput()),
       assets(*engine.getAssets()),
-      gui(*engine.getGUI()),
+      gui(engine.getGUI()),
+      menu(*engine.getGUI().getMenu()),
       frontend(frontend),
       player(player),
       debugImgWorldGen(std::make_unique<ImageData>(
@@ -163,7 +165,7 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
     contentAccess = createContentAccess();
     contentAccess->setId("hud.content-access");
     contentAccessPanel = std::make_shared<Panel>(
-        contentAccess->getSize(), glm::vec4(0.0f), 0.0f
+        gui, contentAccess->getSize(), glm::vec4(0.0f), 0.0f
     );
     contentAccessPanel->setColor(glm::vec4());
     contentAccessPanel->add(contentAccess);
@@ -172,6 +174,7 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
 
     hotbarView = createHotbar();
     darkOverlay = guiutil::create(
+        gui,
         "<container size='4000' color='#00000080' z-index='-1' visible='false'/>"
     );
 
@@ -183,13 +186,13 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
         engine, frontend.getLevel(), player, allowDebugCheats
     );
     debugPanel->setZIndex(2);
+
     gui.add(debugPanel);
-    
     gui.add(darkOverlay);
     gui.add(hotbarView);
     gui.add(contentAccessPanel);
 
-    auto dplotter = std::make_shared<Plotter>(350, 250, 2000, 16);
+    auto dplotter = std::make_shared<Plotter>(gui, 350, 250, 2000, 16);
     dplotter->setGravity(Gravity::bottom_right);
     dplotter->setInteractive(false);
     add(HudElement(HudElementMode::PERMANENT, nullptr, dplotter, true));
@@ -197,9 +200,10 @@ Hud::Hud(Engine& engine, LevelFrontend& frontend, Player& player)
     assets.store(Texture::from(debugImgWorldGen.get()), DEBUG_WORLDGEN_IMAGE);
 
     debugMinimap = guiutil::create(
-            "<image src='"+DEBUG_WORLDGEN_IMAGE+
+        gui,
+        "<image src='" + DEBUG_WORLDGEN_IMAGE +
             "' pos='0' size='256' gravity='top-right' margin='0,20,0,0'/>"
-        );
+    );
     add(HudElement(HudElementMode::PERMANENT, nullptr, debugMinimap, true));
 }
 
@@ -223,11 +227,11 @@ void Hud::cleanup() {
 }
 
 void Hud::processInput(bool visible) {
-    auto menu = gui.getMenu();
-    if (!Window::isFocused() && !menu->hasOpenPage() && !isInventoryOpen()) {
+    if (!Window::isFocused() && !menu.hasOpenPage() && !isInventoryOpen()) {
         setPause(true);
     }
-    if (!pause && visible && Events::jactive(BIND_HUD_INVENTORY)) {
+    const auto& bindings = input.getBindings();
+    if (!pause && visible && bindings.jactive(BIND_HUD_INVENTORY)) {
         if (inventoryOpen) {
             closeInventory();
         } else {
@@ -240,9 +244,10 @@ void Hud::processInput(bool visible) {
 }
 
 void Hud::updateHotbarControl() {
-    if (!inventoryOpen && Events::scroll) {
+    int scroll = input.getScroll();
+    if (!inventoryOpen && scroll) {
         int slot = player.getChosenSlot();
-        slot = (slot - Events::scroll) % 10;
+        slot = (slot - scroll) % 10;
         if (slot < 0) {
             slot += 10;
         }
@@ -253,11 +258,11 @@ void Hud::updateHotbarControl() {
         i <= static_cast<int>(keycode::NUM_9); 
         i++
     ) {
-        if (Events::jpressed(static_cast<keycode>(i))) {
+        if (input.jpressed(static_cast<keycode>(i))) {
             player.setChosenSlot(i - static_cast<int>(keycode::NUM_1));
         }
     }
-    if (Events::jpressed(keycode::NUM_0)) {
+    if (input.jpressed(keycode::NUM_0)) {
         player.setChosenSlot(9);
     }
 }
@@ -311,7 +316,6 @@ void Hud::updateWorldGenDebug() {
 
 void Hud::update(bool visible) {
     const auto& chunks = *player.chunks;
-    const auto& menu = gui.getMenu();
 
     debugPanel->setVisible(
         debug && visible && !(inventoryOpen && inventoryView == nullptr)
@@ -320,13 +324,13 @@ void Hud::update(bool visible) {
     if (!visible && inventoryOpen) {
         closeInventory();
     }
-    if (pause && !menu->hasOpenPage()) {
+    if (pause && !menu.hasOpenPage()) {
         setPause(false);
     }
     if (!gui.isFocusCaught()) {
         processInput(visible);
     }
-    if ((menu->hasOpenPage() || inventoryOpen) == Events::isCursorLocked()) {
+    if ((menu.hasOpenPage() || inventoryOpen) == input.getCursor().locked) {
         Events::toggleCursor();
     }
 
@@ -447,6 +451,7 @@ void Hud::showExchangeSlot() {
     auto& content = level.content;
     exchangeSlotInv = level.inventories->createVirtual(1);
     exchangeSlot = std::make_shared<SlotView>(
+        gui,
         SlotLayout(-1, glm::vec2(), false, false, nullptr, nullptr, nullptr)
     );
     exchangeSlot->bind(exchangeSlotInv->getId(), exchangeSlotInv->getSlot(0), &content);
@@ -590,11 +595,10 @@ void Hud::draw(const DrawContext& ctx){
     const Viewport& viewport = ctx.getViewport();
     const uint width = viewport.getWidth();
     const uint height = viewport.getHeight();
-    auto menu = gui.getMenu();
 
-    bool is_menu_open = menu->hasOpenPage();
+    bool is_menu_open = menu.hasOpenPage();
     darkOverlay->setVisible(is_menu_open);
-    menu->setVisible(is_menu_open);
+    menu.setVisible(is_menu_open);
 
     updateElementsPosition(viewport);
 
@@ -663,7 +667,7 @@ void Hud::updateElementsPosition(const Viewport& viewport) {
         }
     }
     if (exchangeSlot != nullptr) {
-        exchangeSlot->setPos(glm::vec2(Events::cursor));
+        exchangeSlot->setPos(input.getCursor().pos);
     }
     hotbarView->setPos(glm::vec2(width/2, height-65));
     hotbarView->setSelected(player.getChosenSlot());
@@ -689,12 +693,11 @@ void Hud::setPause(bool pause) {
         closeInventory();
     }
     
-    const auto& menu = gui.getMenu();
-    if (!pause && menu->hasOpenPage()) {
-        menu->reset();
+    if (!pause && menu.hasOpenPage()) {
+        menu.reset();
     }
-    if (pause && !menu->hasOpenPage()) {
-        menu->setPage("pause");
+    if (pause && !menu.hasOpenPage()) {
+        menu.setPage("pause");
     }
 }
 
@@ -730,9 +733,8 @@ void Hud::setDebugCheats(bool flag) {
 
 void Hud::setAllowPause(bool flag) {
     if (pause) {
-        auto menu = gui.getMenu();
         setPause(false);
-        menu->setPage("pause", true);
+        menu.setPage("pause", true);
     }
     allowPause = flag;
 }

src/frontend/hud.hpp

@@ -20,9 +20,11 @@ class UiDocument;
 class DrawContext;
 class Viewport;
 class ImageData;
+class Input;
 
 namespace gui {
     class GUI;
+    class Menu;
     class UINode;
     class Panel;
     class Container;
@@ -71,9 +73,11 @@ public:
 
 class Hud : public util::ObjectsKeeper {
     Engine& engine;
+    Input& input;
     Assets& assets;
-    std::unique_ptr<Camera> uicamera;
     gui::GUI& gui;
+    gui::Menu& menu;
+    std::unique_ptr<Camera> uicamera;
     LevelFrontend& frontend;
     Player& player;
 

src/frontend/menu.cpp

@@ -1,35 +1,35 @@
 #include "menu.hpp"
 
-#include "locale.hpp"
-#include "UiDocument.hpp"
-#include "screens/MenuScreen.hpp"
-
-#include "delegates.hpp"
-#include "engine/Engine.hpp"
-#include "data/dv.hpp"
-#include "interfaces/Task.hpp"
-#include "io/engine_paths.hpp"
-#include "graphics/ui/elements/Menu.hpp"
-#include "graphics/ui/gui_util.hpp"
-#include "graphics/ui/GUI.hpp"
-#include "logic/scripting/scripting.hpp"
-#include "settings.hpp"
-#include "coders/commons.hpp"
-#include "util/stringutil.hpp"
-
 #include <filesystem>
 #include <glm/glm.hpp>
 
+#include "UiDocument.hpp"
+#include "coders/commons.hpp"
+#include "data/dv.hpp"
+#include "delegates.hpp"
+#include "engine/Engine.hpp"
+#include "graphics/ui/GUI.hpp"
+#include "graphics/ui/elements/Menu.hpp"
+#include "graphics/ui/gui_util.hpp"
+#include "interfaces/Task.hpp"
+#include "io/engine_paths.hpp"
+#include "locale.hpp"
+#include "logic/scripting/scripting.hpp"
+#include "screens/MenuScreen.hpp"
+#include "settings.hpp"
+#include "util/stringutil.hpp"
+
+
 namespace fs = std::filesystem;
 using namespace gui;
 
-void menus::create_version_label(Engine& engine) {
-    auto gui = engine.getGUI();
-    auto text = ENGINE_VERSION_STRING+" debug build";
-    gui->add(guiutil::create(
-        "<label z-index='1000' color='#FFFFFF80' gravity='top-right' margin='4'>"
-        +text+
-        "</label>"
+void menus::create_version_label(gui::GUI& gui) {
+    auto text = ENGINE_VERSION_STRING + " debug build";
+    gui.add(guiutil::create(
+        gui,
+        "<label z-index='1000' color='#FFFFFF80' gravity='top-right' "
+        "margin='4'>" +
+        text + "</label>"
     ));
 }
 
@@ -44,14 +44,16 @@ bool menus::call(Engine& engine, runnable func) {
         engine.setScreen(std::make_shared<MenuScreen>(engine));
         // could not to find or read pack
         guiutil::alert(
-            engine, langs::get(L"error.pack-not-found")+L": "+
-            util::str2wstr_utf8(error.getPackId())
+            engine,
+            langs::get(L"error.pack-not-found") + L": " +
+                util::str2wstr_utf8(error.getPackId())
         );
         return false;
     } catch (const assetload::error& error) {
         engine.setScreen(std::make_shared<MenuScreen>(engine));
         guiutil::alert(
-            engine, langs::get(L"Assets Load Error", L"menu")+L":\n"+
+            engine,
+            langs::get(L"Assets Load Error", L"menu") + L":\n" +
             util::str2wstr_utf8(error.what())
         );
         return false;
@@ -62,20 +64,27 @@ bool menus::call(Engine& engine, runnable func) {
     } catch (const std::runtime_error& error) {
         engine.setScreen(std::make_shared<MenuScreen>(engine));
         guiutil::alert(
-            engine, langs::get(L"Content Error", L"menu")+L":\n"+
+            engine,
+            langs::get(L"Content Error", L"menu") + L":\n" +
             util::str2wstr_utf8(error.what())
         );
         return false;
     }
 }
 
-UiDocument* menus::show(Engine& engine, const std::string& name, std::vector<dv::value> args) {
-    auto menu = engine.getGUI()->getMenu();
-    auto file = engine.getResPaths()->find("layouts/"+name+".xml");
-    auto fullname = "core:layouts/"+name;
+UiDocument* menus::show(
+    Engine& engine, const std::string& name, std::vector<dv::value> args
+) {
+    auto menu = engine.getGUI().getMenu();
+    auto file = engine.getResPaths()->find("layouts/" + name + ".xml");
+    auto fullname = "core:layouts/" + name;
 
     auto documentPtr = UiDocument::read(
-        scripting::get_root_environment(), fullname, file, "core:layouts/"+name
+        engine.getGUI(),
+        scripting::get_root_environment(),
+        fullname,
+        file,
+        "core:layouts/" + name
     );
     auto document = documentPtr.get();
     engine.getAssets()->store(std::move(documentPtr), fullname);
@@ -85,18 +94,20 @@ UiDocument* menus::show(Engine& engine, const std::string& name, std::vector<dv:
     return document;
 }
 
-void menus::show_process_panel(Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text) {
+void menus::show_process_panel(
+    Engine& engine, const std::shared_ptr<Task>& task, const std::wstring& text
+) {
     uint initialWork = task->getWorkTotal();
 
-    auto menu = engine.getGUI()->getMenu();
+    auto menu = engine.getGUI().getMenu();
     menu->reset();
-    auto doc = menus::show(engine, "process", {
-        util::wstr2str_utf8(langs::get(text))
-    });
-    std::dynamic_pointer_cast<Container>(doc->getRoot())->listenInterval(0.01f, [=]() {
-        task->update();
+    auto doc =
+        menus::show(engine, "process", {util::wstr2str_utf8(langs::get(text))});
+    std::dynamic_pointer_cast<Container>(doc->getRoot())
+        ->listenInterval(0.01f, [=]() {
+            task->update();
 
-        uint tasksDone = task->getWorkDone();
-        scripting::on_ui_progress(doc, tasksDone, initialWork);
-    });
+            uint tasksDone = task->getWorkDone();
+            scripting::on_ui_progress(doc, tasksDone, initialWork);
+        });
 }

src/frontend/menu.hpp

@@ -14,7 +14,7 @@ class UiDocument;
 
 namespace menus {
     /// @brief Create development version label at the top-right screen corner
-    void create_version_label(Engine& engine);
+    void create_version_label(gui::GUI& gui);
 
     UiDocument* show(
         Engine& engine, 

src/frontend/screens/LevelScreen.cpp

@@ -6,7 +6,7 @@
 #include "core_defs.hpp"
 #include "debug/Logger.hpp"
 #include "engine/Engine.hpp"
-#include "io/io.hpp"
+#include "frontend/ContentGfxCache.hpp"
 #include "frontend/LevelFrontend.hpp"
 #include "frontend/hud.hpp"
 #include "graphics/core/DrawContext.hpp"
@@ -17,8 +17,7 @@
 #include "graphics/render/WorldRenderer.hpp"
 #include "graphics/ui/GUI.hpp"
 #include "graphics/ui/elements/Menu.hpp"
-#include "graphics/ui/GUI.hpp"
-#include "frontend/ContentGfxCache.hpp"
+#include "io/io.hpp"
 #include "logic/LevelController.hpp"
 #include "logic/PlayerController.hpp"
 #include "logic/scripting/scripting.hpp"
@@ -43,24 +42,23 @@ LevelScreen::LevelScreen(
 )
     : Screen(engine),
       world(*levelPtr->getWorld()),
-      postProcessing(std::make_unique<PostProcessing>()) {
+      postProcessing(std::make_unique<PostProcessing>()),
+      gui(engine.getGUI()),
+      input(engine.getInput()) {
     Level* level = levelPtr.get();
 
     auto& settings = engine.getSettings();
     auto& assets = *engine.getAssets();
-    auto menu = engine.getGUI()->getMenu();
+    auto menu = engine.getGUI().getMenu();
     menu->reset();
 
     auto player = level->players->get(localPlayer);
     assert(player != nullptr);
-    
+
     controller =
         std::make_unique<LevelController>(&engine, std::move(levelPtr), player);
     playerController = std::make_unique<PlayerController>(
-        settings,
-        *level,
-        *player,
-        *controller->getBlocksController()
+        settings, *level, *player, *controller->getBlocksController()
     );
 
     frontend = std::make_unique<LevelFrontend>(
@@ -87,7 +85,7 @@ LevelScreen::LevelScreen(
     keepAlive(settings.camera.fov.observe([=](double value) {
         player->fpCamera->setFov(glm::radians(value));
     }));
-    keepAlive(Events::getBinding(BIND_CHUNKS_RELOAD).onactived.add([=](){
+    keepAlive(input.addCallback(BIND_CHUNKS_RELOAD, [=]() {
         player->chunks->saveAndClear();
         renderer->clear();
         return false;
@@ -178,13 +176,14 @@ void LevelScreen::saveWorldPreview() {
 
 void LevelScreen::updateHotkeys() {
     auto& settings = engine.getSettings();
-    if (Events::jpressed(keycode::O)) {
+
+    if (input.jpressed(keycode::O)) {
         settings.graphics.frustumCulling.toggle();
     }
-    if (Events::jpressed(keycode::F1)) {
+    if (input.jpressed(keycode::F1)) {
         hudVisible = !hudVisible;
     }
-    if (Events::jpressed(keycode::F3)) {
+    if (input.jpressed(keycode::F3)) {
         debug = !debug;
         hud->setDebug(debug);
         renderer->setDebug(debug);
@@ -199,19 +198,16 @@ void LevelScreen::updateAudio() {
     audio::get_channel("regular")->setPaused(paused);
     audio::get_channel("ambient")->setPaused(paused);
     glm::vec3 velocity {};
-    if (auto hitbox = player->getHitbox())  {
+    if (auto hitbox = player->getHitbox()) {
         velocity = hitbox->velocity;
     }
     audio::set_listener(
-        camera->position, 
-        velocity,
-        camera->dir, 
-        glm::vec3(0, 1, 0)
+        camera->position, velocity, camera->dir, glm::vec3(0, 1, 0)
     );
 }
 
 void LevelScreen::update(float delta) {
-    auto& gui = *engine.getGUI();
+    auto& gui = engine.getGUI();
     
     if (!gui.isFocusCaught()) {
         updateHotkeys();
@@ -225,10 +221,10 @@ void LevelScreen::update(float delta) {
     if (!paused) {
         world.updateTimers(delta);
         animator->update(delta);
-        playerController->update(delta, !inputLocked);
+        playerController->update(delta, inputLocked ? nullptr : &engine.getInput());
     }
     controller->update(glm::min(delta, 0.2f), paused);
-    playerController->postUpdate(delta, !inputLocked, paused);
+    playerController->postUpdate(delta, inputLocked ? nullptr : &engine.getInput(), paused);
 
     hud->update(hudVisible);
 

src/frontend/screens/LevelScreen.hpp

@@ -16,6 +16,11 @@ class ContentPackRuntime;
 class Decorator;
 class Level;
 class World;
+class Input;
+
+namespace gui {
+    class GUI;
+}
 
 class LevelScreen : public Screen {
     World& world;
@@ -27,6 +32,8 @@ class LevelScreen : public Screen {
     std::unique_ptr<PostProcessing> postProcessing;
     std::unique_ptr<Decorator> decorator;
     std::unique_ptr<Hud> hud;
+    gui::GUI& gui;
+    Input& input;
 
     void saveWorldPreview();
 

src/frontend/screens/MenuScreen.cpp

@@ -13,7 +13,7 @@
 MenuScreen::MenuScreen(Engine& engine) : Screen(engine) {
     engine.resetContent();
     
-    auto menu = engine.getGUI()->getMenu();
+    auto menu = engine.getGUI().getMenu();
     menu->reset();
     menu->setPage("main");
 
@@ -22,8 +22,7 @@ MenuScreen::MenuScreen(Engine& engine) : Screen(engine) {
     uicamera->flipped = true;
 }
 
-MenuScreen::~MenuScreen() {
-}
+MenuScreen::~MenuScreen() = default;
 
 void MenuScreen::update(float delta) {
 }