From 05589b721e11f1f908bb24b57e84965ace7e3e96 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 13 Feb 2024 18:16:18 +0300
Subject: [PATCH 1/7] lua: gui library (WIP)

---
 res/layouts/inventory.xml               |  9 ++-
 res/layouts/inventory.xml.lua           | 11 ++--
 res/modules/document.lua                | 22 +++++++
 res/scripts/stdlib.lua                  | 20 +++++++
 src/frontend/UiDocument.cpp             |  8 +++
 src/frontend/UiDocument.h               |  1 +
 src/frontend/gui/UINode.cpp             |  4 ++
 src/frontend/gui/UINode.h               |  1 +
 src/logic/scripting/LuaState.cpp        |  4 +-
 src/logic/scripting/{ => api}/api_lua.h | 38 ++++++------
 src/logic/scripting/api/libgui.cpp      | 77 +++++++++++++++++++++++++
 src/logic/scripting/api/libgui.h        | 15 +++++
 src/logic/scripting/lua_util.h          | 75 ++++++++++++++++++++++++
 src/logic/scripting/scripting.cpp       |  2 +
 14 files changed, 262 insertions(+), 25 deletions(-)
 create mode 100644 res/modules/document.lua
 rename src/logic/scripting/{ => api}/api_lua.h (95%)
 create mode 100644 src/logic/scripting/api/libgui.cpp
 create mode 100644 src/logic/scripting/api/libgui.h

diff --git a/res/layouts/inventory.xml b/res/layouts/inventory.xml
index c33d57d6..1ef2b20f 100644
--- a/res/layouts/inventory.xml
+++ b/res/layouts/inventory.xml
@@ -1,3 +1,10 @@
-<inventory color="#1F1F1FE0" size="400,0">
+<inventory color="#1F1F1FE0" size="0,400">
     <slots-grid rows="4" count="40" sharefunc="inventory_share_func"/>
+    <button id="btn" 
+            coord="8,300" 
+            size="140,30" 
+            z-index="1" 
+            onclick="document.btn.text = tostring(time.uptime())">
+            -----
+    </button>
 </inventory>
diff --git a/res/layouts/inventory.xml.lua b/res/layouts/inventory.xml.lua
index 532b9ee5..dfcd39a5 100644
--- a/res/layouts/inventory.xml.lua
+++ b/res/layouts/inventory.xml.lua
@@ -1,9 +1,12 @@
-function on_open(inv)
-    print("OPEN", inv)
+local Document = require("core:document")
+document = Document.new(DOC_NAME)
+
+function on_open(invid)
+    print("OPEN", invid)
 end
 
-function on_close(inv)
-    print("CLOSE", inv)
+function on_close(invid)
+    print("CLOSE", invid)
 end
 
 function inventory_share_func(invid, slotid)
diff --git a/res/modules/document.lua b/res/modules/document.lua
new file mode 100644
index 00000000..02877064
--- /dev/null
+++ b/res/modules/document.lua
@@ -0,0 +1,22 @@
+local Element = {}
+function Element.new(docname, name)
+    return setmetatable({docname=docname, name=name}, {
+        __index=function(self, k)
+            return gui.getattr(self.docname, self.name, k)
+        end,
+        __newindex=function(self, k, v)
+            gui.setattr(self.docname, self.name, k, v)
+        end
+    })
+end
+
+local Document = {}
+function Document.new(docname)
+    return setmetatable({name=docname}, {
+        __index=function(self, k)
+            return Element.new(self.name, k)
+        end
+    })
+end
+
+return Document
diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua
index 09d28f55..e2644f02 100644
--- a/res/scripts/stdlib.lua
+++ b/res/scripts/stdlib.lua
@@ -91,3 +91,23 @@ end
 function pack.is_installed(packid)
     return file.isfile(packid..":package.json")
 end
+
+vec2_mt = {}
+function vec2_mt.__tostring(self)
+    return "vec2("..self[1]..", "..self[2]..")"
+end
+
+vec3_mt = {}
+function vec3_mt.__tostring(self)
+    return "vec3("..self[1]..", "..self[2]..", "..self[3]..")"
+end
+
+vec4_mt = {}
+function vec4_mt.__tostring(self)
+    return "vec4("..self[1]..", "..self[2]..", "..self[3]..", "..self[4]..")"
+end
+
+color_mt = {}
+function color_mt.__tostring(self)
+    return "rgba("..self[1]..", "..self[2]..", "..self[3]..", "..self[4]..")"
+end
\ No newline at end of file
diff --git a/src/frontend/UiDocument.cpp b/src/frontend/UiDocument.cpp
index 9df8f123..301c1f7c 100644
--- a/src/frontend/UiDocument.cpp
+++ b/src/frontend/UiDocument.cpp
@@ -30,6 +30,14 @@ const std::shared_ptr<gui::UINode> UiDocument::getRoot() const {
     return root;
 }
 
+const std::shared_ptr<gui::UINode> UiDocument::get(const std::string& id) const {
+    auto found = map.find(id);
+    if (found == map.end()) {
+        return nullptr;
+    }
+    return found->second;
+}
+
 const uidocscript& UiDocument::getScript() const {
     return script;
 }
diff --git a/src/frontend/UiDocument.h b/src/frontend/UiDocument.h
index 7668a414..8dad5cb0 100644
--- a/src/frontend/UiDocument.h
+++ b/src/frontend/UiDocument.h
@@ -43,6 +43,7 @@ public:
     const std::string& getId() const;
     const uinodes_map& getMap() const;
     const std::shared_ptr<gui::UINode> getRoot() const;
+    const std::shared_ptr<gui::UINode> get(const std::string& id) const;
     const uidocscript& getScript() const;
     int getEnvironment() const;
     /* Collect map of all uinodes having identifiers */
diff --git a/src/frontend/gui/UINode.cpp b/src/frontend/gui/UINode.cpp
index 95e8e4b7..1a726cc8 100644
--- a/src/frontend/gui/UINode.cpp
+++ b/src/frontend/gui/UINode.cpp
@@ -110,6 +110,10 @@ void UINode::setCoord(glm::vec2 coord) {
     this->coord = coord;
 }
 
+glm::vec2 UINode::getCoord() const {
+    return coord;
+}
+
 glm::vec2 UINode::getSize() const {
     return size;
 }
diff --git a/src/frontend/gui/UINode.h b/src/frontend/gui/UINode.h
index 1e195932..45d6ca8b 100644
--- a/src/frontend/gui/UINode.h
+++ b/src/frontend/gui/UINode.h
@@ -112,6 +112,7 @@ namespace gui {
         /* Calculate screen position of the element */
         virtual glm::vec2 calcCoord() const;
         virtual void setCoord(glm::vec2 coord);
+        glm::vec2 getCoord() const;
         virtual glm::vec2 getSize() const;
         virtual void setSize(glm::vec2 size);
         virtual void refresh() {};
diff --git a/src/logic/scripting/LuaState.cpp b/src/logic/scripting/LuaState.cpp
index 246f4647..8a42e42a 100644
--- a/src/logic/scripting/LuaState.cpp
+++ b/src/logic/scripting/LuaState.cpp
@@ -1,6 +1,7 @@
 #include "LuaState.h"
 
-#include "api_lua.h"
+#include "api/api_lua.h"
+#include "api/libgui.h"
 #include "../../util/stringutil.h"
 
 lua::luaerror::luaerror(const std::string& message) : std::runtime_error(message) {
@@ -98,6 +99,7 @@ void lua::LuaState::createFuncs() {
     openlib("item", itemlib, 0);
     openlib("time", timelib, 0);
     openlib("file", filelib, 0);
+    openlib("gui", guilib, 0);
 
     addfunc("print", l_print);
 
diff --git a/src/logic/scripting/api_lua.h b/src/logic/scripting/api/api_lua.h
similarity index 95%
rename from src/logic/scripting/api_lua.h
rename to src/logic/scripting/api/api_lua.h
index 2bb3a2aa..812498cf 100644
--- a/src/logic/scripting/api_lua.h
+++ b/src/logic/scripting/api/api_lua.h
@@ -1,29 +1,29 @@
 #ifndef LOGIC_SCRIPTING_API_LUA_H_
 #define LOGIC_SCRIPTING_API_LUA_H_
 
-#include "scripting.h"
-#include "lua_util.h"
+#include "../scripting.h"
+#include "../lua_util.h"
 
 #include <glm/glm.hpp>
 #include <iostream>
 
-#include "../../files/files.h"
-#include "../../physics/Hitbox.h"
-#include "../../objects/Player.h"
-#include "../../world/Level.h"
-#include "../../world/World.h"
-#include "../../content/Content.h"
-#include "../../voxels/Block.h"
-#include "../../voxels/Chunks.h"
-#include "../../voxels/voxel.h"
-#include "../../items/ItemDef.h"
-#include "../../items/ItemStack.h"
-#include "../../items/Inventory.h"
-#include "../../items/Inventories.h"
-#include "../../lighting/Lighting.h"
-#include "../../logic/BlocksController.h"
-#include "../../window/Window.h"
-#include "../../engine.h"
+#include "../../../files/files.h"
+#include "../../../physics/Hitbox.h"
+#include "../../../objects/Player.h"
+#include "../../../world/Level.h"
+#include "../../../world/World.h"
+#include "../../../content/Content.h"
+#include "../../../voxels/Block.h"
+#include "../../../voxels/Chunks.h"
+#include "../../../voxels/voxel.h"
+#include "../../../items/ItemDef.h"
+#include "../../../items/ItemStack.h"
+#include "../../../items/Inventory.h"
+#include "../../../items/Inventories.h"
+#include "../../../lighting/Lighting.h"
+#include "../../../logic/BlocksController.h"
+#include "../../../window/Window.h"
+#include "../../../engine.h"
 
 /* == file library == */
 static int l_file_resolve(lua_State* L) {
diff --git a/src/logic/scripting/api/libgui.cpp b/src/logic/scripting/api/libgui.cpp
new file mode 100644
index 00000000..b9889fb0
--- /dev/null
+++ b/src/logic/scripting/api/libgui.cpp
@@ -0,0 +1,77 @@
+#include "libgui.h"
+
+#include <iostream>
+#include "../scripting.h"
+#include "../lua_util.h"
+
+#include "../../../engine.h"
+#include "../../../assets/Assets.h"
+#include "../../../frontend/gui/UINode.h"
+#include "../../../frontend/gui/controls.h"
+#include "../../../frontend/UiDocument.h"
+#include "../../../util/stringutil.h"
+
+static gui::UINode* getDocumentNode(lua_State* L, const std::string& name, const std::string& nodeName) {
+    auto doc = scripting::engine->getAssets()->getLayout(name);
+    if (doc == nullptr) {
+        luaL_error(L, "document '%s' not found", name.c_str());
+    }
+    auto node = doc->get(nodeName);
+    if (node == nullptr) {
+        luaL_error(L, "document '%s' has no element with id '%s'", name.c_str(), nodeName.c_str());
+    }
+    return node.get();
+}
+
+static bool getattr(lua_State* L, gui::Button* button, const std::string& attr) {
+    if (button == nullptr)
+        return false;
+    if (attr == "text") {
+        lua_pushstring(L, util::wstr2str_utf8(button->getText()).c_str());
+        return true;
+    }
+    return false;
+}
+
+static bool setattr(lua_State* L, gui::Button* button, const std::string& attr) {
+    if (button == nullptr)
+        return false;
+    if (attr == "text") {
+        button->setText(util::str2wstr_utf8(lua_tostring(L, 4)));
+        return true;
+    }
+    return false;
+}
+
+int l_gui_getattr(lua_State* L) {
+    auto docname = lua_tostring(L, 1);
+    auto element = lua_tostring(L, 2);
+    const std::string attr = lua_tostring(L, 3);
+    auto node = getDocumentNode(L, docname, element);
+
+    if (attr == "color") {
+        return lua::pushcolor_arr(L, node->getColor());
+    } else if (attr == "coord") {
+        return lua::pushvec2_arr(L, node->getCoord());
+    } else if (attr == "size") {
+        return lua::pushvec2_arr(L, node->getSize());
+    }
+
+    if (getattr(L, dynamic_cast<gui::Button*>(node), attr))
+        return 1;
+
+    return 0;
+}
+
+int l_gui_setattr(lua_State* L) {
+    auto docname = lua_tostring(L, 1);
+    auto element = lua_tostring(L, 2);
+    const std::string attr = lua_tostring(L, 3);
+
+    auto node = getDocumentNode(L, docname, element);
+
+    if (setattr(L, dynamic_cast<gui::Button*>(node), attr))
+        return 0;
+
+    return 0;
+}
diff --git a/src/logic/scripting/api/libgui.h b/src/logic/scripting/api/libgui.h
new file mode 100644
index 00000000..6b83e223
--- /dev/null
+++ b/src/logic/scripting/api/libgui.h
@@ -0,0 +1,15 @@
+#ifndef LOGIC_SCRIPTING_API_LIBGUI_H_
+#define LOGIC_SCRIPTING_API_LIBGUI_H_
+
+#include <lua.hpp>
+
+extern int l_gui_getattr(lua_State* L);
+extern int l_gui_setattr(lua_State* L);
+
+static const luaL_Reg guilib [] = {
+    {"getattr", l_gui_getattr},
+    {"setattr", l_gui_setattr},
+    {NULL, NULL}
+};
+
+#endif // LOGIC_SCRIPTING_API_LIBGUI_H_
diff --git a/src/logic/scripting/lua_util.h b/src/logic/scripting/lua_util.h
index 2ad5c9e2..95761bde 100644
--- a/src/logic/scripting/lua_util.h
+++ b/src/logic/scripting/lua_util.h
@@ -2,6 +2,8 @@
 #define LOGIC_SCRIPTING_LUA_UTIL_H_
 
 #include <lua.hpp>
+#include <glm/glm.hpp>
+#include "LuaState.h"
 
 namespace lua {
     inline int pushivec3(lua_State* L, luaint x, luaint y, luaint z) {
@@ -10,6 +12,79 @@ namespace lua {
         lua_pushinteger(L, z);
         return 3;
     }
+
+    inline int pushvec3(lua_State* L, glm::vec3 vec) {
+        lua_pushnumber(L, vec.x);
+        lua_pushnumber(L, vec.y);
+        lua_pushnumber(L, vec.z);
+        return 3;
+    }
+
+    inline int pushvec4(lua_State* L, glm::vec4 vec) {
+        lua_pushnumber(L, vec.x);
+        lua_pushnumber(L, vec.y);
+        lua_pushnumber(L, vec.z);
+        lua_pushnumber(L, vec.w);
+        return 4;
+    }
+
+    inline int pushvec2_arr(lua_State* L, glm::vec2 vec) {
+        lua_createtable(L, 2, 0);
+        lua_getglobal(L, "vec2_mt");
+        lua_setmetatable(L, -2);
+
+        lua_pushnumber(L, vec.x);
+        lua_rawseti(L, -2, 1);
+        lua_pushnumber(L, vec.y);
+        lua_rawseti(L, -2, 2);
+        return 1;
+    }
+
+    inline int pushvec3_arr(lua_State* L, glm::vec3 vec) {
+        lua_createtable(L, 3, 0);
+        lua_getglobal(L, "vec3_mt");
+        lua_setmetatable(L, -2);
+
+        lua_pushnumber(L, vec.x);
+        lua_rawseti(L, -2, 1);
+        lua_pushnumber(L, vec.y);
+        lua_rawseti(L, -2, 2);
+        lua_pushnumber(L, vec.z);
+        lua_rawseti(L, -2, 3);
+        return 1;
+    }
+
+    inline int pushvec4_arr(lua_State* L, glm::vec4 vec) {
+        lua_createtable(L, 4, 0);
+        lua_getglobal(L, "vec4_mt");
+        lua_setmetatable(L, -2);
+
+        lua_pushnumber(L, vec.x);
+        lua_rawseti(L, -2, 1);
+        lua_pushnumber(L, vec.y);
+        lua_rawseti(L, -2, 2);
+        lua_pushnumber(L, vec.z);
+        lua_rawseti(L, -2, 3);
+        lua_pushnumber(L, vec.w);
+        lua_rawseti(L, -2, 4);
+        return 1;
+    }
+
+    inline int pushcolor_arr(lua_State* L, glm::vec4 vec) {
+        lua_createtable(L, 4, 0);
+        lua_getglobal(L, "color_mt");
+        lua_setmetatable(L, -2);
+
+        lua_pushinteger(L, vec.x*255);
+        lua_rawseti(L, -2, 1);
+        lua_pushinteger(L, vec.y*255);
+        lua_rawseti(L, -2, 2);
+        lua_pushinteger(L, vec.z*255);
+        lua_rawseti(L, -2, 3);
+        lua_pushinteger(L, vec.w*255);
+        lua_rawseti(L, -2, 4);
+        return 1;
+    }
 }
 
 #endif // LOGIC_SCRIPTING_LUA_UTIL_H_
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index 9daf7c77..e4be8adf 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -16,6 +16,7 @@
 #include "../../engine.h"
 #include "LuaState.h"
 #include "../../util/stringutil.h"
+#include "../../util/timeutil.h"
 
 using namespace scripting;
 
@@ -245,6 +246,7 @@ bool scripting::on_item_break_block(Player* player, const ItemDef* item, int x,
 }
 
 void scripting::on_ui_open(UiDocument* layout, Inventory* inventory) {
+    timeutil::ScopeLogTimer log(555);
     std::string name = layout->getId()+".open";
     if (state->getglobal(name)) {
         state->pushinteger(inventory->getId());

From ef0d4d69e4de0967c5536bf8b0d2b8affbaeb452 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 13 Feb 2024 20:54:33 +0300
Subject: [PATCH 2/7] auto document variable in ui-document lua script

---
 res/layouts/inventory.xml.lua      |  3 ---
 res/modules/document.lua           | 22 ----------------------
 res/scripts/stdlib.lua             | 25 ++++++++++++++++++++++++-
 src/logic/scripting/api/libgui.cpp | 24 ++++++++++++++++++++++++
 src/logic/scripting/scripting.cpp  | 11 ++++++++++-
 5 files changed, 58 insertions(+), 27 deletions(-)

diff --git a/res/layouts/inventory.xml.lua b/res/layouts/inventory.xml.lua
index dfcd39a5..c5cd5791 100644
--- a/res/layouts/inventory.xml.lua
+++ b/res/layouts/inventory.xml.lua
@@ -1,6 +1,3 @@
-local Document = require("core:document")
-document = Document.new(DOC_NAME)
-
 function on_open(invid)
     print("OPEN", invid)
 end
diff --git a/res/modules/document.lua b/res/modules/document.lua
index 02877064..e69de29b 100644
--- a/res/modules/document.lua
+++ b/res/modules/document.lua
@@ -1,22 +0,0 @@
-local Element = {}
-function Element.new(docname, name)
-    return setmetatable({docname=docname, name=name}, {
-        __index=function(self, k)
-            return gui.getattr(self.docname, self.name, k)
-        end,
-        __newindex=function(self, k, v)
-            gui.setattr(self.docname, self.name, k, v)
-        end
-    })
-end
-
-local Document = {}
-function Document.new(docname)
-    return setmetatable({name=docname}, {
-        __index=function(self, k)
-            return Element.new(self.name, k)
-        end
-    })
-end
-
-return Document
diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua
index e2644f02..b8dcfb47 100644
--- a/res/scripts/stdlib.lua
+++ b/res/scripts/stdlib.lua
@@ -110,4 +110,27 @@ end
 color_mt = {}
 function color_mt.__tostring(self)
     return "rgba("..self[1]..", "..self[2]..", "..self[3]..", "..self[4]..")"
-end
\ No newline at end of file
+end
+
+-- class designed for simple UI-nodes access via properties syntax
+local Element = {}
+function Element.new(docname, name)
+    return setmetatable({docname=docname, name=name}, {
+        __index=function(self, k)
+            return gui.getattr(self.docname, self.name, k)
+        end,
+        __newindex=function(self, k, v)
+            gui.setattr(self.docname, self.name, k, v)
+        end
+    })
+end
+
+-- the engine automatically creates an instance for every ui document (layout)
+Document = {}
+function Document.new(docname)
+    return setmetatable({name=docname}, {
+        __index=function(self, k)
+            return Element.new(self.name, k)
+        end
+    })
+end
diff --git a/src/logic/scripting/api/libgui.cpp b/src/logic/scripting/api/libgui.cpp
index b9889fb0..362d45d4 100644
--- a/src/logic/scripting/api/libgui.cpp
+++ b/src/logic/scripting/api/libgui.cpp
@@ -33,6 +33,16 @@ static bool getattr(lua_State* L, gui::Button* button, const std::string& attr)
     return false;
 }
 
+static bool getattr(lua_State* L, gui::Label* label, const std::string& attr) {
+    if (label == nullptr)
+        return false;
+    if (attr == "text") {
+        lua_pushstring(L, util::wstr2str_utf8(label->getText()).c_str());
+        return true;
+    }
+    return false;
+}
+
 static bool setattr(lua_State* L, gui::Button* button, const std::string& attr) {
     if (button == nullptr)
         return false;
@@ -43,6 +53,16 @@ static bool setattr(lua_State* L, gui::Button* button, const std::string& attr)
     return false;
 }
 
+static bool setattr(lua_State* L, gui::Label* label, const std::string& attr) {
+    if (label == nullptr)
+        return false;
+    if (attr == "text") {
+        label->setText(util::str2wstr_utf8(lua_tostring(L, 4)));
+        return true;
+    }
+    return false;
+}
+
 int l_gui_getattr(lua_State* L) {
     auto docname = lua_tostring(L, 1);
     auto element = lua_tostring(L, 2);
@@ -59,6 +79,8 @@ int l_gui_getattr(lua_State* L) {
 
     if (getattr(L, dynamic_cast<gui::Button*>(node), attr))
         return 1;
+    if (getattr(L, dynamic_cast<gui::Label*>(node), attr))
+        return 1;
 
     return 0;
 }
@@ -72,6 +94,8 @@ int l_gui_setattr(lua_State* L) {
 
     if (setattr(L, dynamic_cast<gui::Button*>(node), attr))
         return 0;
+    if (setattr(L, dynamic_cast<gui::Label*>(node), attr))
+        return 0;
 
     return 0;
 }
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index e4be8adf..826c3971 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -130,6 +130,16 @@ std::unique_ptr<Environment> scripting::create_doc_environment(int parent, const
     state->setfield("DOC_ENV");
     state->pushstring(name.c_str());
     state->setfield("DOC_NAME");
+    
+    if (state->getglobal("Document")) {
+        if (state->getfield("new")) {
+            state->pushstring(name.c_str());
+            if (state->callNoThrow(1)) {
+                state->setfield("document", -3);
+            }
+        }
+        state->pop();
+    }
     state->pop();
     return std::make_unique<Environment>(id);
 }
@@ -246,7 +256,6 @@ bool scripting::on_item_break_block(Player* player, const ItemDef* item, int x,
 }
 
 void scripting::on_ui_open(UiDocument* layout, Inventory* inventory) {
-    timeutil::ScopeLogTimer log(555);
     std::string name = layout->getId()+".open";
     if (state->getglobal(name)) {
         state->pushinteger(inventory->getId());

From c6bd52eed2589a75f900bc76b5c37c3897ab8d61 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 14 Feb 2024 00:31:45 +0300
Subject: [PATCH 3/7] gui: more xml and lua support

---
 res/layouts/inventory.xml         | 32 ++++++++++++++-----
 res/layouts/inventory.xml.lua     |  4 +++
 src/delegates.h                   |  2 ++
 src/engine.cpp                    |  4 +++
 src/engine.h                      |  1 +
 src/frontend/gui/controls.h       |  3 --
 src/frontend/gui/gui_xml.cpp      | 30 +++++++++++++++++-
 src/logic/scripting/api/api_lua.h |  6 ++++
 src/logic/scripting/scripting.cpp | 52 ++++++++++++++++++++-----------
 src/logic/scripting/scripting.h   |  6 ++++
 10 files changed, 110 insertions(+), 30 deletions(-)

diff --git a/res/layouts/inventory.xml b/res/layouts/inventory.xml
index 1ef2b20f..416778b6 100644
--- a/res/layouts/inventory.xml
+++ b/res/layouts/inventory.xml
@@ -1,10 +1,26 @@
-<inventory color="#1F1F1FE0" size="0,400">
+<inventory color="#1F1F1FE0" size="0,600">
     <slots-grid rows="4" count="40" sharefunc="inventory_share_func"/>
-    <button id="btn" 
-            coord="8,300" 
-            size="140,30" 
-            z-index="1" 
-            onclick="document.btn.text = tostring(time.uptime())">
-            -----
-    </button>
+    <panel coord="10,230" padding="4,4,4,4" size="300,100">
+        <label>fps: 62 / 59</label>
+        <label>meshes: 4143</label>
+        <label>frustum-culling: on</label>
+        <label>chunks: 3206 visible: 1153</label>
+        <label>block: 0 0 (core:air)</label>
+        <label>seed: 42</label>
+        <container size="200,30">
+            <label size="100,30">x:</label>
+            <textbox coord="40,0">4321.40</textbox>
+        </container>
+        <container size="200,30">
+            <label size="100,30">y:</label>
+            <textbox coord="40,0">120.0</textbox>
+        </container>
+        <container size="200,30">
+            <label size="100,30">z:</label>
+            <textbox coord="40,0">-424.10</textbox>
+        </container>
+        <label>time: 19:50</label>
+        <trackbar min="0.0" max="1.0" step="0.005f" track-width="8" consumer="time_change"/>
+        <trackbar min="0.0" max="1.0" step="0.005f" value="0.5" track-width="8"/>
+    </panel>
 </inventory>
diff --git a/res/layouts/inventory.xml.lua b/res/layouts/inventory.xml.lua
index c5cd5791..2386812c 100644
--- a/res/layouts/inventory.xml.lua
+++ b/res/layouts/inventory.xml.lua
@@ -9,3 +9,7 @@ end
 function inventory_share_func(invid, slotid)
     inventory.set(invid, slotid, 0, 0)
 end
+
+function time_change(x)
+    world.set_day_time(x)
+end
diff --git a/src/delegates.h b/src/delegates.h
index 61360464..c938cd02 100644
--- a/src/delegates.h
+++ b/src/delegates.h
@@ -8,5 +8,7 @@ using runnable = std::function<void()>;
 using stringconsumer = std::function<void(const std::string&)>;
 using wstringsupplier = std::function<std::wstring()>;
 using wstringconsumer = std::function<void(const std::wstring&)>;
+using doublesupplier = std::function<double()>;
+using doubleconsumer = std::function<void(double)>;
 
 #endif // DELEGATES_H_
diff --git a/src/engine.cpp b/src/engine.cpp
index d1e85eeb..80d9114a 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -208,6 +208,10 @@ void Engine::loadAllPacks() {
 	ContentPack::scan(paths, contentPacks);
 }
 
+double Engine::getDelta() const {
+    return delta;
+}
+
 void Engine::setScreen(std::shared_ptr<Screen> screen) {
 	this->screen = screen;
 }
diff --git a/src/engine.h b/src/engine.h
index 1532e84b..90ffc8b5 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -63,6 +63,7 @@ public:
     void loadContent();
     void loadWorldContent(const fs::path& folder);
 	void loadAllPacks();
+    double getDelta() const;
 
     std::shared_ptr<Screen> getScreen();
 };
diff --git a/src/frontend/gui/controls.h b/src/frontend/gui/controls.h
index ae07b4d7..80e7d42f 100644
--- a/src/frontend/gui/controls.h
+++ b/src/frontend/gui/controls.h
@@ -17,9 +17,6 @@ class Batch2D;
 class Assets;
 
 namespace gui {
-    using doublesupplier = std::function<double()>;
-    using doubleconsumer = std::function<void(double)>;
-
     using boolsupplier = std::function<bool()>;
     using boolconsumer = std::function<void(bool)>;
 
diff --git a/src/frontend/gui/gui_xml.cpp b/src/frontend/gui/gui_xml.cpp
index 2721b5c1..43daee3b 100644
--- a/src/frontend/gui/gui_xml.cpp
+++ b/src/frontend/gui/gui_xml.cpp
@@ -124,6 +124,13 @@ static std::shared_ptr<UINode> readContainer(UiXmlReader& reader, xml::xmlelemen
     return container;
 }
 
+static std::shared_ptr<UINode> readPanel(UiXmlReader& reader, xml::xmlelement element) {
+    float interval = element->attr("interval", "2").asFloat();
+    auto panel = std::make_shared<Panel>(glm::vec2(), glm::vec4(), interval);
+    _readPanel(reader, element, *panel);
+    return panel;
+}
+
 static std::shared_ptr<UINode> readButton(UiXmlReader& reader, xml::xmlelement element) {
     std::wstring text = readAndProcessInnerText(element);
     auto button = std::make_shared<Button>(text, glm::vec4(0.0f), nullptr);
@@ -156,7 +163,7 @@ static std::shared_ptr<UINode> readTextBox(UiXmlReader& reader, xml::xmlelement
         auto consumer = scripting::create_wstring_consumer(
             reader.getEnvironment().getId(),
             element->attr("consumer").getText(),
-            reader.getFilename()+"lua"
+            reader.getFilename()+".lua"
         );
         textbox->textConsumer(consumer);
     }
@@ -171,13 +178,34 @@ static std::shared_ptr<UINode> readImage(UiXmlReader& reader, xml::xmlelement el
     return image;
 }
 
+static std::shared_ptr<UINode> readTrackBar(UiXmlReader& reader, xml::xmlelement element) {
+    float min = element->attr("min", "0.0").asFloat();
+    float max = element->attr("max", "1.0").asFloat();
+    float def = element->attr("value", "0.0").asFloat();
+    float step = element->attr("step", "1.0").asFloat();
+    int trackWidth = element->attr("track-width", "1.0").asInt();
+    auto bar = std::make_shared<TrackBar>(min, max, def, step, trackWidth);
+    _readUINode(element, *bar);
+    if (element->has("consumer")) {
+        auto consumer = scripting::create_number_consumer(
+            reader.getEnvironment().getId(),
+            element->attr("consumer").getText(),
+            reader.getFilename()+".lua"
+        );
+        bar->consumer(consumer);
+    }
+    return bar;
+}
+
 UiXmlReader::UiXmlReader(const scripting::Environment& env, AssetsLoader& assetsLoader) 
 : env(env), assetsLoader(assetsLoader)
 {
     add("image", readImage);
     add("label", readLabel);
+    add("panel", readPanel);
     add("button", readButton);
     add("textbox", readTextBox);
+    add("trackbar", readTrackBar);
     add("container", readContainer);
 }
 
diff --git a/src/logic/scripting/api/api_lua.h b/src/logic/scripting/api/api_lua.h
index 812498cf..43b639cd 100644
--- a/src/logic/scripting/api/api_lua.h
+++ b/src/logic/scripting/api/api_lua.h
@@ -108,8 +108,14 @@ static int l_time_uptime(lua_State* L) {
     return 1;
 }
 
+static int l_time_delta(lua_State* L) {
+    lua_pushnumber(L, scripting::engine->getDelta());
+    return 1;
+}
+
 static const luaL_Reg timelib [] = {
     {"uptime", l_time_uptime},
+    {"delta", l_time_delta},
     {NULL, NULL}
 };
  
diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index 826c3971..727e6941 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -70,21 +70,42 @@ runnable scripting::create_runnable(
     };
 }
 
+static bool processCallback(
+    int env,
+    const std::string& src,
+    const std::string& file
+) {
+    try {
+        return state->eval(env, src, file) != 0;
+    } catch (lua::luaerror err) {
+        std::cerr << err.what() << std::endl;
+        return false;
+    }
+}
+
 wstringconsumer scripting::create_wstring_consumer(
     int env,
     const std::string& src,
     const std::string& file
 ) {
     return [=](const std::wstring& x){
-        try {
-            if (state->eval(env, src, file) == 0)
-                return;
-        } catch (lua::luaerror err) {
-            std::cerr << err.what() << std::endl;
-            return;
+        if (processCallback(env, src, file)) {
+            state->pushstring(util::wstr2str_utf8(x));
+            state->callNoThrow(1);
+        }
+    };
+}
+
+doubleconsumer scripting::create_number_consumer(
+    int env,
+    const std::string& src,
+    const std::string& file
+) {
+    return [=](double x){
+        if (processCallback(env, src, file)) {
+            state->pushnumber(x);
+            state->callNoThrow(1);
         }
-        state->pushstring(util::wstr2str_utf8(x));
-        state->callNoThrow(1);
     };
 }
 
@@ -94,17 +115,12 @@ int_array_consumer scripting::create_int_array_consumer(
     const std::string& file
 ) {
     return [=](const int arr[], size_t len){
-        try {
-            if (state->eval(env, src, file) == 0)
-                return;
-        } catch (lua::luaerror err) {
-            std::cerr << err.what() << std::endl;
-            return;
+        if (processCallback(env, src, file)) {
+            for (uint i = 0; i < len; i++) {
+                state->pushinteger(arr[i]);
+            }
+            state->callNoThrow(len);
         }
-        for (uint i = 0; i < len; i++) {
-            state->pushinteger(arr[i]);
-        }
-        state->callNoThrow(len);
     };
 }
 
diff --git a/src/logic/scripting/scripting.h b/src/logic/scripting/scripting.h
index b99af39f..033e29a4 100644
--- a/src/logic/scripting/scripting.h
+++ b/src/logic/scripting/scripting.h
@@ -55,6 +55,12 @@ namespace scripting {
         const std::string& file="<string>"
     );
 
+    doubleconsumer create_number_consumer(
+        int env,
+        const std::string& src,
+        const std::string& file="<string>"
+    );
+
     int_array_consumer create_int_array_consumer(
         int env,
         const std::string& src, 

From 2aa49c74704a706f0fd4b46ede9ab4d70466284a Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 14 Feb 2024 01:19:24 +0300
Subject: [PATCH 4/7] minor refactor

---
 src/delegates.h               |   3 +
 src/frontend/gui/controls.cpp | 135 +++++++++++++++++-----------------
 src/frontend/gui/controls.h   |  53 ++++++-------
 src/frontend/gui/gui_xml.cpp  |   2 +-
 src/frontend/gui/panels.cpp   |  69 +++++++++--------
 src/frontend/gui/panels.h     |   6 +-
 src/frontend/hud.cpp          |  21 +++---
 src/frontend/menu.cpp         |  28 +++----
 8 files changed, 155 insertions(+), 162 deletions(-)

diff --git a/src/delegates.h b/src/delegates.h
index c938cd02..7698c59a 100644
--- a/src/delegates.h
+++ b/src/delegates.h
@@ -10,5 +10,8 @@ using wstringsupplier = std::function<std::wstring()>;
 using wstringconsumer = std::function<void(const std::wstring&)>;
 using doublesupplier = std::function<double()>;
 using doubleconsumer = std::function<void(double)>;
+using boolsupplier = std::function<bool()>;
+using boolconsumer = std::function<void(bool)>;
+using wstringchecker = std::function<bool(const std::wstring&)>;
 
 #endif // DELEGATES_H_
diff --git a/src/frontend/gui/controls.cpp b/src/frontend/gui/controls.cpp
index d79a2cd8..e2dc7003 100644
--- a/src/frontend/gui/controls.cpp
+++ b/src/frontend/gui/controls.cpp
@@ -10,24 +10,20 @@
 #include "../../util/stringutil.h"
 #include "GUI.h"
 
-using glm::vec2;
-using glm::vec3;
-using glm::vec4;
-
 using namespace gui;
 
 Label::Label(std::string text, std::string fontName) 
-     : UINode(vec2(), vec2(text.length() * 8, 15)), 
+     : UINode(glm::vec2(), glm::vec2(text.length() * 8, 15)), 
        text(util::str2wstr_utf8(text)), 
-       fontName_(fontName) {
+       fontName(fontName) {
     setInteractive(false);
 }
 
 
 Label::Label(std::wstring text, std::string fontName) 
-     : UINode(vec2(), vec2(text.length() * 8, 15)), 
+     : UINode(glm::vec2(), glm::vec2(text.length() * 8, 15)), 
        text(text), 
-       fontName_(fontName) {
+       fontName(fontName) {
     setInteractive(false);
 }
 
@@ -46,14 +42,14 @@ void Label::draw(const GfxContext* pctx, Assets* assets) {
 
     auto batch = pctx->getBatch2D();
     batch->color = getColor();
-    Font* font = assets->getFont(fontName_);
-    vec2 size = getSize();
-    vec2 newsize = vec2(
+    Font* font = assets->getFont(fontName);
+    glm::vec2 size = getSize();
+    glm::vec2 newsize (
         font->calcWidth(text), 
         font->getLineHeight()+font->getYOffset()
     );
 
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     switch (align) {
         case Align::left:
             break;
@@ -74,13 +70,13 @@ Label* Label::textSupplier(wstringsupplier supplier) {
 }
 
 // ================================= Image ====================================
-Image::Image(std::string texture, vec2 size) : UINode(vec2(), size), texture(texture) {
+Image::Image(std::string texture, glm::vec2 size) : UINode(glm::vec2(), size), texture(texture) {
     setInteractive(false);
 }
 
 void Image::draw(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
-    vec4 color = getColor();
+    glm::vec2 coord = calcCoord();
+    glm::vec4 color = getColor();
     auto batch = pctx->getBatch2D();
     batch->texture(assets->getTexture(texture));
     batch->color = color;
@@ -90,10 +86,11 @@ void Image::draw(const GfxContext* pctx, Assets* assets) {
 
 // ================================= Button ===================================
 Button::Button(std::shared_ptr<UINode> content, glm::vec4 padding)
-    : Panel(vec2(), padding, 0) {
-    vec4 margin = getMargin();
-    setSize(content->getSize()+vec2(padding[0]+padding[2]+margin[0]+margin[2],
-                                    padding[1]+padding[3]+margin[1]+margin[3]));
+    : Panel(glm::vec2(), padding, 0) {
+    glm::vec4 margin = getMargin();
+    setSize(content->getSize()+
+            glm::vec2(padding[0]+padding[2]+margin[0]+margin[2],
+                      padding[1]+padding[3]+margin[1]+margin[3]));
     add(content);
     setScrollable(false);
     setHoverColor(glm::vec4(0.05f, 0.1f, 0.15f, 0.75f));
@@ -102,13 +99,13 @@ Button::Button(std::shared_ptr<UINode> content, glm::vec4 padding)
 
 Button::Button(
     std::wstring text, 
-    vec4 padding, 
+    glm::vec4 padding, 
     onaction action,
-    vec2 size
+    glm::vec2 size
 ) : Panel(size, padding, 0) 
 {
     if (size.y < 0.0f) {
-        size = vec2(
+        size = glm::vec2(
             glm::max(padding.x + padding.z + text.length()*8, size.x),
             glm::max(padding.y + padding.w + 16, size.y)
         );
@@ -122,7 +119,7 @@ Button::Button(
 
     label = std::make_shared<Label>(text);
     label->setAlign(Align::center);
-    label->setSize(size-vec2(padding.z+padding.x, padding.w+padding.y));
+    label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
     label->setInteractive(false);
     add(label);
     setHoverColor(glm::vec4(0.05f, 0.1f, 0.15f, 0.75f));
@@ -151,12 +148,12 @@ Button* Button::textSupplier(wstringsupplier supplier) {
 void Button::refresh() {
     Panel::refresh();
     if (label) {
-        label->setSize(size-vec2(padding.z+padding.x, padding.w+padding.y));
+        label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
     }
 }
 
 void Button::drawBackground(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
     batch->color = (isPressed() ? pressedColor : (hover ? hoverColor : color));
@@ -165,7 +162,7 @@ void Button::drawBackground(const GfxContext* pctx, Assets* assets) {
 
 void Button::mouseRelease(GUI* gui, int x, int y) {
     UINode::mouseRelease(gui, x, y);
-    if (isInside(vec2(x, y))) {
+    if (isInside(glm::vec2(x, y))) {
         for (auto callback : actions) {
             callback(gui);
         }
@@ -192,13 +189,13 @@ Align Button::getTextAlign() const {
 }
 
 // ============================== RichButton ==================================
-RichButton::RichButton(vec2 size) : Container(vec2(), size) {
+RichButton::RichButton(glm::vec2 size) : Container(glm::vec2(), size) {
     setHoverColor(glm::vec4(0.05f, 0.1f, 0.15f, 0.75f));
 }
 
 void RichButton::mouseRelease(GUI* gui, int x, int y) {
     UINode::mouseRelease(gui, x, y);
-    if (isInside(vec2(x, y))) {
+    if (isInside(glm::vec2(x, y))) {
         for (auto callback : actions) {
             callback(gui);
         }
@@ -211,7 +208,7 @@ RichButton* RichButton::listenAction(onaction action) {
 }
 
 void RichButton::drawBackground(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
     batch->color = (isPressed() ? pressedColor : (hover ? hoverColor : color));
@@ -219,18 +216,18 @@ void RichButton::drawBackground(const GfxContext* pctx, Assets* assets) {
 }
 
 // ================================ TextBox ===================================
-TextBox::TextBox(std::wstring placeholder, vec4 padding) 
-    : Panel(vec2(200,32), padding, 0), 
+TextBox::TextBox(std::wstring placeholder, glm::vec4 padding) 
+    : Panel(glm::vec2(200,32), padding, 0), 
       input(L""),
       placeholder(placeholder) {
     label = std::make_shared<Label>(L"");
-    label->setSize(size-vec2(padding.z+padding.x, padding.w+padding.y));
+    label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
     add(label);
     setHoverColor(glm::vec4(0.05f, 0.1f, 0.2f, 0.75f));
 }
 
 void TextBox::drawBackground(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
 
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
@@ -253,10 +250,10 @@ void TextBox::drawBackground(const GfxContext* pctx, Assets* assets) {
     }
 
     if (input.empty()) {
-        label->setColor(vec4(0.5f));
+        label->setColor(glm::vec4(0.5f));
         label->setText(placeholder);
     } else {
-        label->setColor(vec4(1.0f));
+        label->setColor(glm::vec4(1.0f));
         label->setText(input);
     }
     setScrollable(false);
@@ -297,7 +294,7 @@ void TextBox::focus(GUI* gui) {
 
 void TextBox::refresh() {
     Panel::refresh();
-    label->setSize(size-vec2(padding.z+padding.x, padding.w+padding.y));
+    label->setSize(size-glm::vec2(padding.z+padding.x, padding.w+padding.y));
 }
 
 void TextBox::keyPressed(int key) {
@@ -322,7 +319,7 @@ void TextBox::keyPressed(int key) {
     }
 }
 
-std::shared_ptr<UINode> TextBox::getAt(vec2 pos, std::shared_ptr<UINode> self) {
+std::shared_ptr<UINode> TextBox::getAt(glm::vec2 pos, std::shared_ptr<UINode> self) {
     return UINode::getAt(pos, self);
 }
 
@@ -349,8 +346,8 @@ void TextBox::setText(std::wstring value) {
 }
 
 // ============================== InputBindBox ================================
-InputBindBox::InputBindBox(Binding& binding, vec4 padding) 
-    : Panel(vec2(100,32), padding, 0),
+InputBindBox::InputBindBox(Binding& binding, glm::vec4 padding) 
+    : Panel(glm::vec2(100,32), padding, 0),
       binding(binding) {
     label = std::make_shared<Label>(L"");
     add(label);
@@ -358,7 +355,7 @@ InputBindBox::InputBindBox(Binding& binding, vec4 padding)
 }
 
 void InputBindBox::drawBackground(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
     batch->color = (isFocused() ? focusedColor : (hover ? hoverColor : color));
@@ -386,20 +383,20 @@ TrackBar::TrackBar(double min,
                    double value, 
                    double step, 
                    int trackWidth)
-    : UINode(vec2(), vec2(26)), 
+    : UINode(glm::vec2(), glm::vec2(26)), 
       min(min), 
       max(max), 
       value(value), 
       step(step), 
       trackWidth(trackWidth) {
-    setColor(vec4(0.f, 0.f, 0.f, 0.4f));
+    setColor(glm::vec4(0.f, 0.f, 0.f, 0.4f));
 }
 
 void TrackBar::draw(const GfxContext* pctx, Assets* assets) {
-    if (supplier_) {
-        value = supplier_();
+    if (supplier) {
+        value = supplier();
     }
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
     batch->color = (hover ? hoverColor : color);
@@ -413,16 +410,16 @@ void TrackBar::draw(const GfxContext* pctx, Assets* assets) {
     batch->rect(coord.x + width * t, coord.y, actualWidth, size.y);
 }
 
-void TrackBar::supplier(doublesupplier supplier) {
-    this->supplier_ = supplier;
+void TrackBar::setSupplier(doublesupplier supplier) {
+    this->supplier = supplier;
 }
 
-void TrackBar::consumer(doubleconsumer consumer) {
-    this->consumer_ = consumer;
+void TrackBar::setConsumer(doubleconsumer consumer) {
+    this->consumer = consumer;
 }
 
 void TrackBar::mouseMove(GUI*, int x, int y) {
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     value = x;
     value -= coord.x;
     value = (value)/size.x * (max-min+trackWidth*step);
@@ -430,56 +427,56 @@ void TrackBar::mouseMove(GUI*, int x, int y) {
     value = (value > max) ? max : value;
     value = (value < min) ? min : value;
     value = (int)(value / step) * step;
-    if (consumer_) {
-        consumer_(value);
+    if (consumer) {
+        consumer(value);
     }
 }
 
 // ================================ CheckBox ==================================
-CheckBox::CheckBox(bool checked) : UINode(vec2(), vec2(32.0f)), checked_(checked) {
-    setColor(vec4(0.0f, 0.0f, 0.0f, 0.5f));
+CheckBox::CheckBox(bool checked) : UINode(glm::vec2(), glm::vec2(32.0f)), checked(checked) {
+    setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.5f));
 }
 
 void CheckBox::draw(const GfxContext* pctx, Assets* assets) {
-    if (supplier_) {
-        checked_ = supplier_();
+    if (supplier) {
+        checked = supplier();
     }
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
-    batch->color = checked_ ? checkColor : (hover ? hoverColor : color);
+    batch->color = checked ? checkColor : (hover ? hoverColor : color);
     batch->rect(coord.x, coord.y, size.x, size.y);
 }
 
 void CheckBox::mouseRelease(GUI*, int x, int y) {
-    checked_ = !checked_;
-    if (consumer_) {
-        consumer_(checked_);
+    checked = !checked;
+    if (consumer) {
+        consumer(checked);
     }
 }
 
-void CheckBox::supplier(boolsupplier supplier) {
-    supplier_ = supplier;
+void CheckBox::setSupplier(boolsupplier supplier) {
+    this->supplier = supplier;
 }
 
-void CheckBox::consumer(boolconsumer consumer) {
-    consumer_ = consumer;
+void CheckBox::setConsumer(boolconsumer consumer) {
+    this->consumer = consumer;
 }
 
-CheckBox* CheckBox::checked(bool flag) {
-    checked_ = flag;
+CheckBox* CheckBox::setChecked(bool flag) {
+    checked = flag;
     return this;
 }
 
 FullCheckBox::FullCheckBox(std::wstring text, glm::vec2 size, bool checked)
     : Panel(size), 
       checkbox(std::make_shared<CheckBox>(checked)){
-    setColor(vec4(0.0f));
+    setColor(glm::vec4(0.0f));
     setOrientation(Orientation::horizontal);
 
     add(checkbox);
 
     auto label = std::make_shared<Label>(text); 
-    label->setMargin(vec4(5.f, 5.f, 0.f, 0.f));
+    label->setMargin(glm::vec4(5.f, 5.f, 0.f, 0.f));
     add(label);
 }
diff --git a/src/frontend/gui/controls.h b/src/frontend/gui/controls.h
index 80e7d42f..954a3905 100644
--- a/src/frontend/gui/controls.h
+++ b/src/frontend/gui/controls.h
@@ -17,15 +17,10 @@ class Batch2D;
 class Assets;
 
 namespace gui {
-    using boolsupplier = std::function<bool()>;
-    using boolconsumer = std::function<void(bool)>;
-
-    using wstringchecker = std::function<bool(const std::wstring&)>;
-
     class Label : public UINode {
     protected:
         std::wstring text;
-        std::string fontName_;
+        std::string fontName;
         wstringsupplier supplier = nullptr;
     public:
         Label(std::string text, std::string fontName="normal");
@@ -145,8 +140,8 @@ namespace gui {
     protected:
         glm::vec4 hoverColor {0.01f, 0.02f, 0.03f, 0.5f};
         glm::vec4 trackColor {1.0f, 1.0f, 1.0f, 0.4f};
-        doublesupplier supplier_ = nullptr;
-        doubleconsumer consumer_ = nullptr;
+        doublesupplier supplier = nullptr;
+        doubleconsumer consumer = nullptr;
         double min;
         double max;
         double value;
@@ -160,8 +155,8 @@ namespace gui {
                  int trackWidth=1);
         virtual void draw(const GfxContext* pctx, Assets* assets) override;
 
-        virtual void supplier(doublesupplier supplier);
-        virtual void consumer(doubleconsumer consumer);
+        virtual void setSupplier(doublesupplier supplier);
+        virtual void setConsumer(doubleconsumer consumer);
 
         virtual void mouseMove(GUI*, int x, int y) override;
     };
@@ -170,9 +165,9 @@ namespace gui {
     protected:
         glm::vec4 hoverColor {0.05f, 0.1f, 0.2f, 0.75f};
         glm::vec4 checkColor {1.0f, 1.0f, 1.0f, 0.4f};
-        boolsupplier supplier_ = nullptr;
-        boolconsumer consumer_ = nullptr;
-        bool checked_ = false;
+        boolsupplier supplier = nullptr;
+        boolconsumer consumer = nullptr;
+        bool checked = false;
     public:
         CheckBox(bool checked=false);
 
@@ -180,15 +175,15 @@ namespace gui {
 
         virtual void mouseRelease(GUI*, int x, int y) override;
 
-        virtual void supplier(boolsupplier supplier);
-        virtual void consumer(boolconsumer consumer);
+        virtual void setSupplier(boolsupplier supplier);
+        virtual void setConsumer(boolconsumer consumer);
 
-        virtual CheckBox* checked(bool flag);
+        virtual CheckBox* setChecked(bool flag);
 
-        virtual bool checked() const {
-            if (supplier_)
-                return supplier_();
-            return checked_;
+        virtual bool isChecked() const {
+            if (supplier)
+                return supplier();
+            return checked;
         }
     };
 
@@ -198,22 +193,22 @@ namespace gui {
     public:
         FullCheckBox(std::wstring text, glm::vec2 size, bool checked=false);
 
-        virtual void supplier(boolsupplier supplier) {
-            checkbox->supplier(supplier);
+        virtual void setSupplier(boolsupplier supplier) {
+            checkbox->setSupplier(supplier);
         }
 
-        virtual void consumer(boolconsumer consumer) {
-            checkbox->consumer(consumer);
+        virtual void setConsumer(boolconsumer consumer) {
+            checkbox->setConsumer(consumer);
         }
 
-        virtual void checked(bool flag) {
-            checkbox->checked(flag);
+        virtual void setChecked(bool flag) {
+            checkbox->setChecked(flag);
         }
 
-        virtual bool checked() const {
-            return checkbox->checked();
+        virtual bool isChecked() const {
+            return checkbox->isChecked();
         }
     };
 }
 
-#endif // FRONTEND_GUI_CONTROLS_H_
\ No newline at end of file
+#endif // FRONTEND_GUI_CONTROLS_H_
diff --git a/src/frontend/gui/gui_xml.cpp b/src/frontend/gui/gui_xml.cpp
index 43daee3b..c4965d24 100644
--- a/src/frontend/gui/gui_xml.cpp
+++ b/src/frontend/gui/gui_xml.cpp
@@ -192,7 +192,7 @@ static std::shared_ptr<UINode> readTrackBar(UiXmlReader& reader, xml::xmlelement
             element->attr("consumer").getText(),
             reader.getFilename()+".lua"
         );
-        bar->consumer(consumer);
+        bar->setConsumer(consumer);
     }
     return bar;
 }
diff --git a/src/frontend/gui/panels.cpp b/src/frontend/gui/panels.cpp
index cb71367f..2a65903b 100644
--- a/src/frontend/gui/panels.cpp
+++ b/src/frontend/gui/panels.cpp
@@ -9,15 +9,12 @@
 
 using namespace gui;
 
-using glm::vec2;
-using glm::vec4;
-
-Container::Container(vec2 coord, vec2 size) : UINode(coord, size) {
+Container::Container(glm::vec2 coord, glm::vec2 size) : UINode(coord, size) {
     actualLength = size.y;
     setColor(glm::vec4());
 }
 
-std::shared_ptr<UINode> Container::getAt(vec2 pos, std::shared_ptr<UINode> self) {
+std::shared_ptr<UINode> Container::getAt(glm::vec2 pos, std::shared_ptr<UINode> self) {
     if (!interactive) {
         return nullptr;
     }
@@ -79,8 +76,8 @@ void Container::setScrollable(bool flag) {
 }
 
 void Container::draw(const GfxContext* pctx, Assets* assets) {
-    vec2 coord = calcCoord();
-    vec2 size = getSize();
+    glm::vec2 coord = calcCoord();
+    glm::vec2 size = getSize();
     drawBackground(pctx, assets);
 
     auto batch = pctx->getBatch2D();
@@ -88,7 +85,7 @@ void Container::draw(const GfxContext* pctx, Assets* assets) {
     batch->render();
     {
         GfxContext ctx = pctx->sub();
-        ctx.scissors(vec4(coord.x, coord.y, size.x, size.y));
+        ctx.scissors(glm::vec4(coord.x, coord.y, size.x, size.y));
         for (auto node : nodes) {
             if (node->isVisible())
                 node->draw(pctx, assets);
@@ -100,7 +97,7 @@ void Container::draw(const GfxContext* pctx, Assets* assets) {
 void Container::drawBackground(const GfxContext* pctx, Assets* assets) {
     if (color.a <= 0.0f)
         return;
-    vec2 coord = calcCoord();
+    glm::vec2 coord = calcCoord();
 
     auto batch = pctx->getBatch2D();
     batch->texture(nullptr);
@@ -154,11 +151,11 @@ const std::vector<std::shared_ptr<UINode>>& Container::getNodes() const {
     return nodes;
 }
 
-Panel::Panel(vec2 size, glm::vec4 padding, float interval)
-    : Container(vec2(), size), 
+Panel::Panel(glm::vec2 size, glm::vec4 padding, float interval)
+    : Container(glm::vec2(), size), 
       padding(padding), 
       interval(interval) {
-    setColor(vec4(0.0f, 0.0f, 0.0f, 0.75f));
+    setColor(glm::vec4(0.0f, 0.0f, 0.0f, 0.75f));
 }
 
 Panel::~Panel() {
@@ -183,9 +180,9 @@ glm::vec4 Panel::getPadding() const {
 
 void Panel::cropToContent() {
     if (maxLength > 0.0f) {
-        setSize(vec2(getSize().x, glm::min(maxLength, actualLength)));
+        setSize(glm::vec2(getSize().x, glm::min(maxLength, actualLength)));
     } else {
-        setSize(vec2(getSize().x, actualLength));
+        setSize(glm::vec2(getSize().x, actualLength));
     }
 }
 
@@ -199,21 +196,21 @@ void Panel::refresh() {
     UINode::refresh();
     float x = padding.x;
     float y = padding.y;
-    vec2 size = getSize();
+    glm::vec2 size = getSize();
     if (orientation == Orientation::vertical) {
         float maxw = size.x;
         for (auto& node : nodes) {
-            vec2 nodesize = node->getSize();
-            const vec4 margin = node->getMargin();
+            glm::vec2 nodesize = node->getSize();
+            const glm::vec4 margin = node->getMargin();
             y += margin.y;
             
             float ex = x + margin.x;
-            node->setCoord(vec2(ex, y));
+            node->setCoord(glm::vec2(ex, y));
             y += nodesize.y + margin.w + interval;
 
             float width = size.x - padding.x - padding.z - margin.x - margin.z;
             if (node->isResizing()) {
-                node->setSize(vec2(width, nodesize.y));
+                node->setSize(glm::vec2(width, nodesize.y));
             }
             node->refresh();
             maxw = fmax(maxw, ex+node->getSize().x+margin.z+padding.z);
@@ -222,10 +219,10 @@ void Panel::refresh() {
     } else {
         float maxh = size.y;
         for (auto& node : nodes) {
-            vec2 nodesize = node->getSize();
-            const vec4 margin = node->getMargin();
+            glm::vec2 nodesize = node->getSize();
+            const glm::vec4 margin = node->getMargin();
             x += margin.x;
-            node->setCoord(vec2(x, y+margin.y));
+            node->setCoord(glm::vec2(x, y+margin.y));
             x += nodesize.x + margin.z + interval;
             
             node->refresh();
@@ -243,7 +240,7 @@ Orientation Panel::getOrientation() const {
     return orientation;
 }
 
-PagesControl::PagesControl() : Container(vec2(), vec2(1)){
+PagesControl::PagesControl() : Container(glm::vec2(), glm::vec2(1)){
 }
 
 bool PagesControl::has(std::string name) {
@@ -259,16 +256,16 @@ void PagesControl::setPage(std::string name, bool history) {
     if (found == pages.end()) {
         throw std::runtime_error("no page found");
     }
-    if (current_.panel) {
-        Container::remove(current_.panel);
+    if (current.panel) {
+        Container::remove(current.panel);
     }
     if (history) {
-        pageStack.push(curname_);
+        pageStack.push(curname);
     }
-    curname_ = name;
-    current_ = found->second;
-    Container::add(current_.panel);
-    setSize(current_.panel->getSize());
+    curname = name;
+    current = found->second;
+    Container::add(current.panel);
+    setSize(current.panel->getSize());
 }
 
 void PagesControl::back() {
@@ -279,8 +276,8 @@ void PagesControl::back() {
     setPage(name, false);
 }
 
-Page& PagesControl::current() {
-    return current_;
+Page& PagesControl::getCurrent() {
+    return current;
 }
 
 void PagesControl::clearHistory() {
@@ -289,9 +286,9 @@ void PagesControl::clearHistory() {
 
 void PagesControl::reset() {
     clearHistory();
-    if (current_.panel) {
-        curname_ = "";
-        Container::remove(current_.panel);
-        current_ = Page{nullptr};
+    if (current.panel) {
+        curname = "";
+        Container::remove(current.panel);
+        current = Page{nullptr};
     }
 }
diff --git a/src/frontend/gui/panels.h b/src/frontend/gui/panels.h
index 72d0e8cb..6056cb49 100644
--- a/src/frontend/gui/panels.h
+++ b/src/frontend/gui/panels.h
@@ -94,8 +94,8 @@ namespace gui {
     protected:
         std::unordered_map<std::string, Page> pages;
         std::stack<std::string> pageStack;
-        Page current_;
-        std::string curname_ = "";
+        Page current;
+        std::string curname = "";
     public:
         PagesControl();
 
@@ -106,7 +106,7 @@ namespace gui {
         void clearHistory();
         void reset();
     
-        Page& current();
+        Page& getCurrent();
     };
 }
 #endif // FRONTEND_GUI_PANELS_H_
\ No newline at end of file
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index 6c663285..c0286eed 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -100,13 +100,13 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
     }));
 
     for (int ax = 0; ax < 3; ax++){
-        auto sub = std::make_shared<Panel>(vec2(10, 27), vec4(0.0f));
-        sub->setOrientation(Orientation::horizontal);
+        auto sub = std::make_shared<Container>(vec2(), vec2(250, 27));
 
         std::wstring str = L"x: ";
         str[0] += ax;
         auto label = std::make_shared<Label>(str);
         label->setMargin(vec4(2, 3, 2, 3));
+        label->setSize(vec2(20, 27));
         sub->add(label);
         sub->setColor(vec4(0.0f));
 
@@ -128,8 +128,9 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
             Hitbox* hitbox = level->player->hitbox.get();
             box->setText(std::to_wstring(int(hitbox->position[ax])));
         });
+        box->setSize(vec2(230, 27));
 
-        sub->add(box);
+        sub->add(box, vec2(20, 0));
         panel->add(sub);
     }
     panel->add(create_label([=](){
@@ -143,24 +144,24 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
     }));
     {
         auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 1.0f, 0.005f, 8);
-        bar->supplier([=]() {return level->world->daytime;});
-        bar->consumer([=](double val) {level->world->daytime = val;});
+        bar->setSupplier([=]() {return level->world->daytime;});
+        bar->setConsumer([=](double val) {level->world->daytime = val;});
         panel->add(bar);
     }
     {
         auto bar = std::make_shared<TrackBar>(0.0f, 1.0f, 0.0f, 0.005f, 8);
-        bar->supplier([=]() {return WorldRenderer::fog;});
-        bar->consumer([=](double val) {WorldRenderer::fog = val;});
+        bar->setSupplier([=]() {return WorldRenderer::fog;});
+        bar->setConsumer([=](double val) {WorldRenderer::fog = val;});
         panel->add(bar);
     }
     {
         auto checkbox = std::make_shared<FullCheckBox>(
             L"Show Chunk Borders", vec2(400, 24)
         );
-        checkbox->supplier([=]() {
+        checkbox->setSupplier([=]() {
             return engine->getSettings().debug.showChunkBorders;
         });
-        checkbox->consumer([=](bool checked) {
+        checkbox->setConsumer([=](bool checked) {
             engine->getSettings().debug.showChunkBorders = checked;
         });
         panel->add(checkbox);
@@ -291,7 +292,7 @@ void HudRenderer::update(bool visible) {
     if (!visible && inventoryOpen) {
         closeInventory();
     }
-    if (pause && menu->current().panel == nullptr) {
+    if (pause && menu->getCurrent().panel == nullptr) {
         pause = false;
     }
     if (Events::jpressed(keycode::ESCAPE) && !gui->isFocusCaught()) {
diff --git a/src/frontend/menu.cpp b/src/frontend/menu.cpp
index 83bc2640..87b18957 100644
--- a/src/frontend/menu.cpp
+++ b/src/frontend/menu.cpp
@@ -472,10 +472,10 @@ void create_controls_panel(Engine* engine) {
         }));
 
         auto trackbar = std::make_shared<TrackBar>(0.1, 10.0, 2.0, 0.1, 4);
-        trackbar->supplier([=]() {
+        trackbar->setSupplier([=]() {
             return engine->getSettings().camera.sensitivity;
         });
-        trackbar->consumer([=](double value) {
+        trackbar->setConsumer([=](double value) {
             engine->getSettings().camera.sensitivity = value;
         });
         panel->add(trackbar);
@@ -512,10 +512,10 @@ void create_settings_panel(Engine* engine) {
         }));
 
         auto trackbar = std::make_shared<TrackBar>(3, 66, 10, 1, 3);
-        trackbar->supplier([=]() {
+        trackbar->setSupplier([=]() {
             return engine->getSettings().chunks.loadDistance;
         });
-        trackbar->consumer([=](double value) {
+        trackbar->setConsumer([=](double value) {
             engine->getSettings().chunks.loadDistance = static_cast<uint>(value);
         });
         panel->add(trackbar);
@@ -528,10 +528,10 @@ void create_settings_panel(Engine* engine) {
         }));
 
         auto trackbar = std::make_shared<TrackBar>(1, 32, 10, 1, 1);
-        trackbar->supplier([=]() {
+        trackbar->setSupplier([=]() {
             return engine->getSettings().chunks.loadSpeed;
         });
-        trackbar->consumer([=](double value) {
+        trackbar->setConsumer([=](double value) {
             engine->getSettings().chunks.loadSpeed = static_cast<uint>(value);
         });
         panel->add(trackbar);
@@ -545,10 +545,10 @@ void create_settings_panel(Engine* engine) {
         }));
 
         auto trackbar = std::make_shared<TrackBar>(1.0, 6.0, 1.0, 0.1, 2);
-        trackbar->supplier([=]() {
+        trackbar->setSupplier([=]() {
             return engine->getSettings().graphics.fogCurve;
         });
-        trackbar->consumer([=](double value) {
+        trackbar->setConsumer([=](double value) {
             engine->getSettings().graphics.fogCurve = value;
         });
         panel->add(trackbar);
@@ -561,10 +561,10 @@ void create_settings_panel(Engine* engine) {
         }));
 
         auto trackbar = std::make_shared<TrackBar>(30.0, 120.0, 90, 1, 4);
-        trackbar->supplier([=]() {
+        trackbar->setSupplier([=]() {
             return engine->getSettings().camera.fov;
         });
-        trackbar->consumer([=](double value) {
+        trackbar->setConsumer([=](double value) {
             engine->getSettings().camera.fov = value;
         });
         panel->add(trackbar);
@@ -574,10 +574,10 @@ void create_settings_panel(Engine* engine) {
         auto checkbox = std::make_shared<FullCheckBox>(
             langs::get(L"V-Sync", L"settings"), vec2(400, 32)
         );
-        checkbox->supplier([=]() {
+        checkbox->setSupplier([=]() {
             return engine->getSettings().display.swapInterval != 0;
         });
-        checkbox->consumer([=](bool checked) {
+        checkbox->setConsumer([=](bool checked) {
             engine->getSettings().display.swapInterval = checked;
         });
         panel->add(checkbox);
@@ -587,10 +587,10 @@ void create_settings_panel(Engine* engine) {
         auto checkbox = std::make_shared<FullCheckBox>(
             langs::get(L"Backlight", L"settings"), vec2(400, 32)
         );
-        checkbox->supplier([=]() {
+        checkbox->setSupplier([=]() {
             return engine->getSettings().graphics.backlight;
         });
-        checkbox->consumer([=](bool checked) {
+        checkbox->setConsumer([=](bool checked) {
             engine->getSettings().graphics.backlight = checked;
         });
         panel->add(checkbox);

From 98a6c825b191917395b1ffc3a7a81a1412a9106a Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 14 Feb 2024 01:23:14 +0300
Subject: [PATCH 5/7] warning fix

---
 src/logic/scripting/scripting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/logic/scripting/scripting.cpp b/src/logic/scripting/scripting.cpp
index 727e6941..2c18fc36 100644
--- a/src/logic/scripting/scripting.cpp
+++ b/src/logic/scripting/scripting.cpp
@@ -77,7 +77,7 @@ static bool processCallback(
 ) {
     try {
         return state->eval(env, src, file) != 0;
-    } catch (lua::luaerror err) {
+    } catch (lua::luaerror& err) {
         std::cerr << err.what() << std::endl;
         return false;
     }

From 1145267308594c1a51e20c5298b82b1b6574c255 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 14 Feb 2024 01:37:10 +0300
Subject: [PATCH 6/7] lua api refactor

---
 src/logic/scripting/LuaState.cpp    |   2 +
 src/logic/scripting/api/api_lua.cpp | 493 ++++++++++++++++++++++++++
 src/logic/scripting/api/api_lua.h   | 518 +++-------------------------
 3 files changed, 539 insertions(+), 474 deletions(-)
 create mode 100644 src/logic/scripting/api/api_lua.cpp

diff --git a/src/logic/scripting/LuaState.cpp b/src/logic/scripting/LuaState.cpp
index 8a42e42a..7a81e237 100644
--- a/src/logic/scripting/LuaState.cpp
+++ b/src/logic/scripting/LuaState.cpp
@@ -1,5 +1,7 @@
 #include "LuaState.h"
 
+#include <iostream>
+#include "lua_util.h"
 #include "api/api_lua.h"
 #include "api/libgui.h"
 #include "../../util/stringutil.h"
diff --git a/src/logic/scripting/api/api_lua.cpp b/src/logic/scripting/api/api_lua.cpp
new file mode 100644
index 00000000..27878066
--- /dev/null
+++ b/src/logic/scripting/api/api_lua.cpp
@@ -0,0 +1,493 @@
+#include "api_lua.h"
+
+#include "../scripting.h"
+#include "../lua_util.h"
+
+#include <glm/glm.hpp>
+#include <iostream>
+
+#include "../../../files/files.h"
+#include "../../../physics/Hitbox.h"
+#include "../../../objects/Player.h"
+#include "../../../world/Level.h"
+#include "../../../world/World.h"
+#include "../../../content/Content.h"
+#include "../../../voxels/Block.h"
+#include "../../../voxels/Chunks.h"
+#include "../../../voxels/voxel.h"
+#include "../../../items/ItemDef.h"
+#include "../../../items/ItemStack.h"
+#include "../../../items/Inventory.h"
+#include "../../../items/Inventories.h"
+#include "../../../lighting/Lighting.h"
+#include "../../../logic/BlocksController.h"
+#include "../../../window/Window.h"
+#include "../../../engine.h"
+
+/* == file library == */
+int l_file_resolve(lua_State* L) {
+    std::string path = lua_tostring(L, 1);
+    fs::path resolved = scripting::engine->getPaths()->resolve(path);
+    lua_pushstring(L, resolved.u8string().c_str());
+    return 1;
+}
+
+int l_file_read(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    if (fs::is_regular_file(path)) {
+        lua_pushstring(L, files::read_string(path).c_str());
+        return 1;
+    }
+    return luaL_error(L, "file does not exists '%s'", path.u8string().c_str());
+}
+
+int l_file_write(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    const char* text = lua_tostring(L, 2);
+    files::write_string(path, text);
+    return 1;    
+}
+
+int l_file_exists(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    lua_pushboolean(L, fs::exists(path));
+    return 1;
+}
+
+int l_file_isfile(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    lua_pushboolean(L, fs::is_regular_file(path));
+    return 1;
+}
+
+int l_file_isdir(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    lua_pushboolean(L, fs::is_directory(path));
+    return 1;
+}
+
+int l_file_length(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    if (fs::exists(path)){
+        lua_pushinteger(L, fs::file_size(path));
+    } else {
+        lua_pushinteger(L, -1);
+    }
+    return 1;
+}
+
+int l_file_mkdir(lua_State* L) {
+    auto paths = scripting::engine->getPaths();
+    fs::path path = paths->resolve(lua_tostring(L, 1));
+    lua_pushboolean(L, fs::create_directory(path));
+    return 1;    
+}
+
+/* == time library == */
+int l_time_uptime(lua_State* L) {
+    lua_pushnumber(L, Window::time());
+    return 1;
+}
+
+int l_time_delta(lua_State* L) {
+    lua_pushnumber(L, scripting::engine->getDelta());
+    return 1;
+}
+
+/* == pack library == */
+int l_pack_get_folder(lua_State* L) {
+    std::string packName = lua_tostring(L, 1);
+    if (packName == "core") {
+        auto folder = scripting::engine->getPaths()
+                                       ->getResources().u8string()+"/";
+        lua_pushstring(L, folder.c_str());
+        return 1;
+    }
+    for (auto& pack : scripting::engine->getContentPacks()) {
+        if (pack.id == packName) {
+            lua_pushstring(L, (pack.folder.u8string()+"/").c_str());
+            return 1;
+        }
+    }
+    lua_pushstring(L, "");
+    return 1;
+}
+
+/* == world library == */
+int l_world_get_total_time(lua_State* L) {
+    lua_pushnumber(L, scripting::level->world->totalTime);
+    return 1;
+}
+
+int l_world_get_day_time(lua_State* L) {
+    lua_pushnumber(L, scripting::level->world->daytime);
+    return 1;
+}
+
+int l_world_set_day_time(lua_State* L) {
+    double value = lua_tonumber(L, 1);
+    scripting::level->world->daytime = fmod(value, 1.0);
+    return 0;
+}
+
+int l_world_get_seed(lua_State* L) {
+    lua_pushinteger(L, scripting::level->world->getSeed());
+    return 1;
+}
+
+/* == player library ==*/
+int l_player_get_pos(lua_State* L) {
+    int playerid = lua_tointeger(L, 1);
+    if (playerid != 1)
+        return 0;
+    glm::vec3 pos = scripting::level->player->hitbox->position;
+    lua_pushnumber(L, pos.x);
+    lua_pushnumber(L, pos.y);
+    lua_pushnumber(L, pos.z);
+    return 3;
+}
+
+int l_player_get_rot(lua_State* L) {
+    int playerid = lua_tointeger(L, 1);
+    if (playerid != 1)
+        return 0;
+    glm::vec2 rot = scripting::level->player->cam;
+    lua_pushnumber(L, rot.x);
+    lua_pushnumber(L, rot.y);
+    return 2;
+}
+
+int l_player_set_rot(lua_State* L) {
+    int playerid = lua_tointeger(L, 1);
+    if (playerid != 1)
+        return 0;
+    lua::luanumber x = lua_tonumber(L, 2);
+    lua::luanumber y = lua_tonumber(L, 3);
+    glm::vec2& cam = scripting::level->player->cam;
+    cam.x = x;
+    cam.y = y;
+    return 0;
+}
+
+int l_player_set_pos(lua_State* L) {
+    int playerid = lua_tointeger(L, 1);
+    if (playerid != 1)
+        return 0;
+    lua::luanumber x = lua_tonumber(L, 2);
+    lua::luanumber y = lua_tonumber(L, 3);
+    lua::luanumber z = lua_tonumber(L, 4);
+    scripting::level->player->hitbox->position = glm::vec3(x, y, z);
+    return 0;
+}
+
+int l_player_get_inv(lua_State* L) {
+    int playerid = lua_tointeger(L, 1);
+    if (playerid != 1)
+        return 0;
+    Player* player = scripting::level->player;
+    lua_pushinteger(L, player->getInventory()->getId());
+    lua_pushinteger(L, player->getChosenSlot());
+    return 2;
+}
+
+static void validate_itemid(lua_State* L, itemid_t id) {
+    if (id >= scripting::indices->countItemDefs()) {
+        luaL_error(L, "invalid item id");
+    }
+}
+
+/* == inventory library == */
+int l_inventory_get(lua_State* L) {
+    lua::luaint invid = lua_tointeger(L, 1);
+    lua::luaint slotid = lua_tointeger(L, 2);
+    auto inv = scripting::level->inventories->get(invid);
+    if (inv == nullptr) {
+        luaL_error(L, "inventory does not exists in runtime: %d", invid);
+    }
+    if (slotid < 0 || uint64_t(slotid) >= inv->size()) {
+        luaL_error(L, "slot index is out of range [0, inventory.size(invid)]");
+    }
+    ItemStack& item = inv->getSlot(slotid);
+    lua_pushinteger(L, item.getItemId());
+    lua_pushinteger(L, item.getCount());
+    return 2;
+}
+
+int l_inventory_set(lua_State* L) {
+    lua::luaint invid = lua_tointeger(L, 1);
+    lua::luaint slotid = lua_tointeger(L, 2);
+    lua::luaint itemid = lua_tointeger(L, 3);
+    lua::luaint count = lua_tointeger(L, 4);
+    validate_itemid(L, itemid);
+
+    auto inv = scripting::level->inventories->get(invid);
+    if (inv == nullptr) {
+        luaL_error(L, "inventory does not exists in runtime: %d", invid);
+    }
+    if (slotid < 0 || uint64_t(slotid) >= inv->size()) {
+        luaL_error(L, "slot index is out of range [0, inventory.size(invid)]");
+    }
+    ItemStack& item = inv->getSlot(slotid);
+    item.set(ItemStack(itemid, count));
+    return 0;
+}
+
+int l_inventory_size(lua_State* L) {
+    lua::luaint invid = lua_tointeger(L, 1);
+    auto inv = scripting::level->inventories->get(invid);
+    if (inv == nullptr) {
+        luaL_error(L, "inventory does not exists in runtime: %d", invid);
+    }
+    lua_pushinteger(L, inv->size());
+    return 1;
+}
+
+int l_inventory_add(lua_State* L) {
+    lua::luaint invid = lua_tointeger(L, 1);
+    lua::luaint itemid = lua_tointeger(L, 2);
+    lua::luaint count = lua_tointeger(L, 3);
+    validate_itemid(L, itemid);
+
+    auto inv = scripting::level->inventories->get(invid);
+    if (inv == nullptr) {
+        luaL_error(L, "inventory does not exists in runtime: %d", invid);
+    }
+    ItemStack item(itemid, count);
+    inv->move(item, scripting::indices);
+    lua_pushinteger(L, item.getCount());
+    return 1;
+}
+
+int l_inventory_get_block(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    int64_t id = scripting::blocks->createBlockInventory(x, y, z);
+    lua_pushinteger(L, id);
+    return 1;
+}
+
+/* == item library == */
+int l_item_name(lua_State* L) {
+    auto indices = scripting::content->getIndices();
+    lua::luaint id = lua_tointeger(L, 1);
+    if (id < 0 || size_t(id) >= indices->countItemDefs()) {
+        return 0;
+    }
+    auto def = indices->getItemDef(id);
+    lua_pushstring(L, def->name.c_str());
+    return 1;
+}
+
+int l_item_index(lua_State* L) {
+    auto name = lua_tostring(L, 1);
+    lua_pushinteger(L, scripting::content->requireItem(name).rt.id);
+    return 1;
+}
+
+int l_item_stack_size(lua_State* L) {
+    auto indices = scripting::content->getIndices();
+    lua::luaint id = lua_tointeger(L, 1);
+    if (id < 0 || size_t(id) >= indices->countItemDefs()) {
+        return 0;
+    }
+    auto def = indices->getItemDef(id);
+    lua_pushinteger(L, def->stackSize);
+    return 1;
+}
+
+int l_item_defs_count(lua_State* L) {
+    lua_pushinteger(L, scripting::indices->countItemDefs());
+    return 1;
+}
+
+/* == blocks-related functions == */
+int l_block_name(lua_State* L) {
+    auto indices = scripting::content->getIndices();
+    lua::luaint id = lua_tointeger(L, 1);
+    if (id < 0 || size_t(id) >= indices->countBlockDefs()) {
+        return 0;
+    }
+    auto def = indices->getBlockDef(id);
+    lua_pushstring(L, def->name.c_str());
+    return 1;
+}
+
+int l_is_solid_at(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+
+    lua_pushboolean(L, scripting::level->chunks->isSolidBlock(x, y, z));
+    return 1;
+}
+
+int l_blocks_count(lua_State* L) {
+    lua_pushinteger(L, scripting::indices->countBlockDefs());
+    return 1;
+}
+
+int l_block_index(lua_State* L) {
+    auto name = lua_tostring(L, 1);
+    lua_pushinteger(L, scripting::content->requireBlock(name).rt.id);
+    return 1;
+}
+
+int l_set_block(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    lua::luaint id = lua_tointeger(L, 4);    
+    lua::luaint states = lua_tointeger(L, 5);
+    bool noupdate = lua_toboolean(L, 6);
+    if (id < 0 || size_t(id) >= scripting::indices->countBlockDefs()) {
+        return 0;
+    }
+    scripting::level->chunks->set(x, y, z, id, states);
+    scripting::level->lighting->onBlockSet(x,y,z, id);
+    if (!noupdate)
+        scripting::blocks->updateSides(x, y, z);
+    return 0;
+}
+
+int l_get_block(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    int id = vox == nullptr ? -1 : vox->id;
+    lua_pushinteger(L, id);
+    return 1;
+}
+
+int l_get_block_x(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr) {
+        return lua::pushivec3(L, 1, 0, 0);
+    }
+    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua::pushivec3(L, 1, 0, 0);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
+        return lua::pushivec3(L, rot.axisX.x, rot.axisX.y, rot.axisX.z);
+    }
+}
+
+int l_get_block_y(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr) {
+        return lua::pushivec3(L, 0, 1, 0);
+    }
+    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua::pushivec3(L, 0, 1, 0);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
+        return lua::pushivec3(L, rot.axisY.x, rot.axisY.y, rot.axisY.z);
+    }
+}
+
+int l_get_block_z(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr) {
+        return lua::pushivec3(L, 0, 0, 1);
+    }
+    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
+    if (!def->rotatable) {
+        return lua::pushivec3(L, 0, 0, 1);
+    } else {
+        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
+        return lua::pushivec3(L, rot.axisZ.x, rot.axisZ.y, rot.axisZ.z);
+    }
+}
+
+int l_get_block_states(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    int states = vox == nullptr ? 0 : vox->states;
+    lua_pushinteger(L, states);
+    return 1;
+}
+
+int l_get_block_user_bits(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    lua::luaint offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
+    lua::luaint bits = lua_tointeger(L, 5);
+
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr) {
+        lua_pushinteger(L, 0);
+        return 1;
+    }
+    uint mask = ((1 << bits) - 1) << offset;
+    uint data = (vox->states & mask) >> offset;
+    lua_pushinteger(L, data);
+    return 1;
+}
+
+int l_set_block_user_bits(lua_State* L) {
+    lua::luaint x = lua_tointeger(L, 1);
+    lua::luaint y = lua_tointeger(L, 2);
+    lua::luaint z = lua_tointeger(L, 3);
+    lua::luaint offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
+    lua::luaint bits = lua_tointeger(L, 5);
+
+    uint mask = ((1 << bits) - 1) << offset;
+    lua::luaint value = (lua_tointeger(L, 6) << offset) & mask;
+    
+    voxel* vox = scripting::level->chunks->get(x, y, z);
+    if (vox == nullptr) {
+        return 0;
+    }
+    vox->states = (vox->states & (~mask)) | value;
+    return 0;
+}
+
+int l_is_replaceable_at(lua_State* L) {
+    int x = lua_tointeger(L, 1);
+    int y = lua_tointeger(L, 2);
+    int z = lua_tointeger(L, 3);
+
+    lua_pushboolean(L, scripting::level->chunks->isReplaceableBlock(x, y, z));
+    return 1;
+}
+
+int l_print(lua_State* L) {
+    int n = lua_gettop(L);  /* number of arguments */
+    lua_getglobal(L, "tostring");
+    for (int i=1; i<=n; i++) {
+        lua_pushvalue(L, -1);  /* function to be called */
+        lua_pushvalue(L, i);   /* value to print */
+        lua_call(L, 1, 1);
+        const char* s = lua_tostring(L, -1);  /* get result */
+        if (s == NULL)
+            return luaL_error(L, LUA_QL("tostring") " must return a string to "
+                                 LUA_QL("print"));
+        if (i > 1)
+            std::cout << "\t";
+        std::cout << s;
+        lua_pop(L, 1);  /* pop result */
+    }
+    std::cout << std::endl;
+    return 0;
+}
diff --git a/src/logic/scripting/api/api_lua.h b/src/logic/scripting/api/api_lua.h
index 43b639cd..d6a59bfb 100644
--- a/src/logic/scripting/api/api_lua.h
+++ b/src/logic/scripting/api/api_lua.h
@@ -1,94 +1,17 @@
 #ifndef LOGIC_SCRIPTING_API_LUA_H_
 #define LOGIC_SCRIPTING_API_LUA_H_
 
-#include "../scripting.h"
-#include "../lua_util.h"
-
-#include <glm/glm.hpp>
-#include <iostream>
-
-#include "../../../files/files.h"
-#include "../../../physics/Hitbox.h"
-#include "../../../objects/Player.h"
-#include "../../../world/Level.h"
-#include "../../../world/World.h"
-#include "../../../content/Content.h"
-#include "../../../voxels/Block.h"
-#include "../../../voxels/Chunks.h"
-#include "../../../voxels/voxel.h"
-#include "../../../items/ItemDef.h"
-#include "../../../items/ItemStack.h"
-#include "../../../items/Inventory.h"
-#include "../../../items/Inventories.h"
-#include "../../../lighting/Lighting.h"
-#include "../../../logic/BlocksController.h"
-#include "../../../window/Window.h"
-#include "../../../engine.h"
+#include <lua.hpp>
 
 /* == file library == */
-static int l_file_resolve(lua_State* L) {
-    std::string path = lua_tostring(L, 1);
-    fs::path resolved = scripting::engine->getPaths()->resolve(path);
-    lua_pushstring(L, resolved.u8string().c_str());
-    return 1;
-}
-
-static int l_file_read(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    if (fs::is_regular_file(path)) {
-        lua_pushstring(L, files::read_string(path).c_str());
-        return 1;
-    }
-    return luaL_error(L, "file does not exists '%s'", path.u8string().c_str());
-}
-
-static int l_file_write(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    const char* text = lua_tostring(L, 2);
-    files::write_string(path, text);
-    return 1;    
-}
-
-static int l_file_exists(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    lua_pushboolean(L, fs::exists(path));
-    return 1;
-}
-
-static int l_file_isfile(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    lua_pushboolean(L, fs::is_regular_file(path));
-    return 1;
-}
-
-static int l_file_isdir(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    lua_pushboolean(L, fs::is_directory(path));
-    return 1;
-}
-
-static int l_file_length(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    if (fs::exists(path)){
-        lua_pushinteger(L, fs::file_size(path));
-    } else {
-        lua_pushinteger(L, -1);
-    }
-    return 1;
-}
-
-static int l_file_mkdir(lua_State* L) {
-    auto paths = scripting::engine->getPaths();
-    fs::path path = paths->resolve(lua_tostring(L, 1));
-    lua_pushboolean(L, fs::create_directory(path));
-    return 1;    
-}
+extern int l_file_resolve(lua_State* L);
+extern int l_file_read(lua_State* L);
+extern int l_file_write(lua_State* L);
+extern int l_file_exists(lua_State* L);
+extern int l_file_isfile(lua_State* L);
+extern int l_file_isdir(lua_State* L);
+extern int l_file_length(lua_State* L);
+extern int l_file_mkdir(lua_State* L);
 
 static const luaL_Reg filelib [] = {
     {"resolve", l_file_resolve},
@@ -103,15 +26,8 @@ static const luaL_Reg filelib [] = {
 };
 
 /* == time library == */
-static int l_time_uptime(lua_State* L) {
-    lua_pushnumber(L, Window::time());
-    return 1;
-}
-
-static int l_time_delta(lua_State* L) {
-    lua_pushnumber(L, scripting::engine->getDelta());
-    return 1;
-}
+extern int l_time_uptime(lua_State* L);
+extern int l_time_delta(lua_State* L);
 
 static const luaL_Reg timelib [] = {
     {"uptime", l_time_uptime},
@@ -120,23 +36,7 @@ static const luaL_Reg timelib [] = {
 };
  
 /* == pack library == */
-static int l_pack_get_folder(lua_State* L) {
-    std::string packName = lua_tostring(L, 1);
-    if (packName == "core") {
-        auto folder = scripting::engine->getPaths()
-                                       ->getResources().u8string()+"/";
-        lua_pushstring(L, folder.c_str());
-        return 1;
-    }
-    for (auto& pack : scripting::engine->getContentPacks()) {
-        if (pack.id == packName) {
-            lua_pushstring(L, (pack.folder.u8string()+"/").c_str());
-            return 1;
-        }
-    }
-    lua_pushstring(L, "");
-    return 1;
-}
+extern int l_pack_get_folder(lua_State* L);
 
 static const luaL_Reg packlib [] = {
     {"get_folder", l_pack_get_folder},
@@ -144,26 +44,10 @@ static const luaL_Reg packlib [] = {
 };
 
 /* == world library == */
-static int l_world_get_total_time(lua_State* L) {
-    lua_pushnumber(L, scripting::level->world->totalTime);
-    return 1;
-}
-
-static int l_world_get_day_time(lua_State* L) {
-    lua_pushnumber(L, scripting::level->world->daytime);
-    return 1;
-}
-
-static int l_world_set_day_time(lua_State* L) {
-    double value = lua_tonumber(L, 1);
-    scripting::level->world->daytime = fmod(value, 1.0);
-    return 0;
-}
-
-static int l_world_get_seed(lua_State* L) {
-    lua_pushinteger(L, scripting::level->world->getSeed());
-    return 1;
-}
+extern int l_world_get_total_time(lua_State* L);
+extern int l_world_get_day_time(lua_State* L);
+extern int l_world_set_day_time(lua_State* L);
+extern int l_world_get_seed(lua_State* L);
 
 static const luaL_Reg worldlib [] = {
     {"get_total_time", l_world_get_total_time},
@@ -174,59 +58,11 @@ static const luaL_Reg worldlib [] = {
 };
 
 /* == player library ==*/
-static int l_player_get_pos(lua_State* L) {
-    int playerid = lua_tointeger(L, 1);
-    if (playerid != 1)
-        return 0;
-    glm::vec3 pos = scripting::level->player->hitbox->position;
-    lua_pushnumber(L, pos.x);
-    lua_pushnumber(L, pos.y);
-    lua_pushnumber(L, pos.z);
-    return 3;
-}
-
-static int l_player_get_rot(lua_State* L) {
-    int playerid = lua_tointeger(L, 1);
-    if (playerid != 1)
-        return 0;
-    glm::vec2 rot = scripting::level->player->cam;
-    lua_pushnumber(L, rot.x);
-    lua_pushnumber(L, rot.y);
-    return 2;
-}
-
-static int l_player_set_rot(lua_State* L) {
-    int playerid = lua_tointeger(L, 1);
-    if (playerid != 1)
-        return 0;
-    lua::luanumber x = lua_tonumber(L, 2);
-    lua::luanumber y = lua_tonumber(L, 3);
-    glm::vec2& cam = scripting::level->player->cam;
-    cam.x = x;
-    cam.y = y;
-    return 0;
-}
-
-static int l_player_set_pos(lua_State* L) {
-    int playerid = lua_tointeger(L, 1);
-    if (playerid != 1)
-        return 0;
-    lua::luanumber x = lua_tonumber(L, 2);
-    lua::luanumber y = lua_tonumber(L, 3);
-    lua::luanumber z = lua_tonumber(L, 4);
-    scripting::level->player->hitbox->position = glm::vec3(x, y, z);
-    return 0;
-}
-
-static int l_player_get_inv(lua_State* L) {
-    int playerid = lua_tointeger(L, 1);
-    if (playerid != 1)
-        return 0;
-    Player* player = scripting::level->player;
-    lua_pushinteger(L, player->getInventory()->getId());
-    lua_pushinteger(L, player->getChosenSlot());
-    return 2;
-}
+extern int l_player_get_pos(lua_State* L);
+extern int l_player_get_rot(lua_State* L);
+extern int l_player_set_rot(lua_State* L);
+extern int l_player_set_pos(lua_State* L);
+extern int l_player_get_inv(lua_State* L);
 
 static const luaL_Reg playerlib [] = {
     {"get_pos", l_player_get_pos},
@@ -237,82 +73,12 @@ static const luaL_Reg playerlib [] = {
     {NULL, NULL}
 };
 
-static void validate_itemid(lua_State* L, itemid_t id) {
-    if (id >= scripting::indices->countItemDefs()) {
-        luaL_error(L, "invalid item id");
-    }
-}
-
 /* == inventory library == */
-static int l_inventory_get(lua_State* L) {
-    lua::luaint invid = lua_tointeger(L, 1);
-    lua::luaint slotid = lua_tointeger(L, 2);
-    auto inv = scripting::level->inventories->get(invid);
-    if (inv == nullptr) {
-        luaL_error(L, "inventory does not exists in runtime: %d", invid);
-    }
-    if (slotid < 0 || uint64_t(slotid) >= inv->size()) {
-        luaL_error(L, "slot index is out of range [0, inventory.size(invid)]");
-    }
-    ItemStack& item = inv->getSlot(slotid);
-    lua_pushinteger(L, item.getItemId());
-    lua_pushinteger(L, item.getCount());
-    return 2;
-}
-
-static int l_inventory_set(lua_State* L) {
-    lua::luaint invid = lua_tointeger(L, 1);
-    lua::luaint slotid = lua_tointeger(L, 2);
-    lua::luaint itemid = lua_tointeger(L, 3);
-    lua::luaint count = lua_tointeger(L, 4);
-    validate_itemid(L, itemid);
-
-    auto inv = scripting::level->inventories->get(invid);
-    if (inv == nullptr) {
-        luaL_error(L, "inventory does not exists in runtime: %d", invid);
-    }
-    if (slotid < 0 || uint64_t(slotid) >= inv->size()) {
-        luaL_error(L, "slot index is out of range [0, inventory.size(invid)]");
-    }
-    ItemStack& item = inv->getSlot(slotid);
-    item.set(ItemStack(itemid, count));
-    return 0;
-}
-
-static int l_inventory_size(lua_State* L) {
-    lua::luaint invid = lua_tointeger(L, 1);
-    auto inv = scripting::level->inventories->get(invid);
-    if (inv == nullptr) {
-        luaL_error(L, "inventory does not exists in runtime: %d", invid);
-    }
-    lua_pushinteger(L, inv->size());
-    return 1;
-}
-
-static int l_inventory_add(lua_State* L) {
-    lua::luaint invid = lua_tointeger(L, 1);
-    lua::luaint itemid = lua_tointeger(L, 2);
-    lua::luaint count = lua_tointeger(L, 3);
-    validate_itemid(L, itemid);
-
-    auto inv = scripting::level->inventories->get(invid);
-    if (inv == nullptr) {
-        luaL_error(L, "inventory does not exists in runtime: %d", invid);
-    }
-    ItemStack item(itemid, count);
-    inv->move(item, scripting::indices);
-    lua_pushinteger(L, item.getCount());
-    return 1;
-}
-
-static int l_inventory_get_block(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    int64_t id = scripting::blocks->createBlockInventory(x, y, z);
-    lua_pushinteger(L, id);
-    return 1;
-}
+extern int l_inventory_get(lua_State* L);
+extern int l_inventory_set(lua_State* L);
+extern int l_inventory_size(lua_State* L);
+extern int l_inventory_add(lua_State* L);
+extern int l_inventory_get_block(lua_State* L);
 
 static const luaL_Reg inventorylib [] = {
     {"get", l_inventory_get},
@@ -324,38 +90,10 @@ static const luaL_Reg inventorylib [] = {
 };
 
 /* == item library == */
-static int l_item_name(lua_State* L) {
-    auto indices = scripting::content->getIndices();
-    lua::luaint id = lua_tointeger(L, 1);
-    if (id < 0 || size_t(id) >= indices->countItemDefs()) {
-        return 0;
-    }
-    auto def = indices->getItemDef(id);
-    lua_pushstring(L, def->name.c_str());
-    return 1;
-}
-
-static int l_item_index(lua_State* L) {
-    auto name = lua_tostring(L, 1);
-    lua_pushinteger(L, scripting::content->requireItem(name).rt.id);
-    return 1;
-}
-
-static int l_item_stack_size(lua_State* L) {
-    auto indices = scripting::content->getIndices();
-    lua::luaint id = lua_tointeger(L, 1);
-    if (id < 0 || size_t(id) >= indices->countItemDefs()) {
-        return 0;
-    }
-    auto def = indices->getItemDef(id);
-    lua_pushinteger(L, def->stackSize);
-    return 1;
-}
-
-static int l_item_defs_count(lua_State* L) {
-    lua_pushinteger(L, scripting::indices->countItemDefs());
-    return 1;
-}
+extern int l_item_name(lua_State* L);
+extern int l_item_index(lua_State* L);
+extern int l_item_stack_size(lua_State* L);
+extern int l_item_defs_count(lua_State* L);
 
 static const luaL_Reg itemlib [] = {
     {"index", l_item_index},
@@ -366,189 +104,21 @@ static const luaL_Reg itemlib [] = {
 };
 
 /* == blocks-related functions == */
-static int l_block_name(lua_State* L) {
-    auto indices = scripting::content->getIndices();
-    lua::luaint id = lua_tointeger(L, 1);
-    if (id < 0 || size_t(id) >= indices->countBlockDefs()) {
-        return 0;
-    }
-    auto def = indices->getBlockDef(id);
-    lua_pushstring(L, def->name.c_str());
-    return 1;
-}
-
-static int l_is_solid_at(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-
-    lua_pushboolean(L, scripting::level->chunks->isSolidBlock(x, y, z));
-    return 1;
-}
-
-static int l_blocks_count(lua_State* L) {
-    lua_pushinteger(L, scripting::indices->countBlockDefs());
-    return 1;
-}
-
-static int l_block_index(lua_State* L) {
-    auto name = lua_tostring(L, 1);
-    lua_pushinteger(L, scripting::content->requireBlock(name).rt.id);
-    return 1;
-}
-
-static int l_set_block(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    lua::luaint id = lua_tointeger(L, 4);    
-    lua::luaint states = lua_tointeger(L, 5);
-    bool noupdate = lua_toboolean(L, 6);
-    if (id < 0 || size_t(id) >= scripting::indices->countBlockDefs()) {
-        return 0;
-    }
-    scripting::level->chunks->set(x, y, z, id, states);
-    scripting::level->lighting->onBlockSet(x,y,z, id);
-    if (!noupdate)
-        scripting::blocks->updateSides(x, y, z);
-    return 0;
-}
-
-static int l_get_block(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    int id = vox == nullptr ? -1 : vox->id;
-    lua_pushinteger(L, id);
-    return 1;
-}
-
-static int l_get_block_x(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return lua::pushivec3(L, 1, 0, 0);
-    }
-    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua::pushivec3(L, 1, 0, 0);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua::pushivec3(L, rot.axisX.x, rot.axisX.y, rot.axisX.z);
-    }
-}
-
-static int l_get_block_y(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return lua::pushivec3(L, 0, 1, 0);
-    }
-    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua::pushivec3(L, 0, 1, 0);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua::pushivec3(L, rot.axisY.x, rot.axisY.y, rot.axisY.z);
-    }
-}
-
-static int l_get_block_z(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return lua::pushivec3(L, 0, 0, 1);
-    }
-    auto def = scripting::level->content->getIndices()->getBlockDef(vox->id);
-    if (!def->rotatable) {
-        return lua::pushivec3(L, 0, 0, 1);
-    } else {
-        const CoordSystem& rot = def->rotations.variants[vox->rotation()];
-        return lua::pushivec3(L, rot.axisZ.x, rot.axisZ.y, rot.axisZ.z);
-    }
-}
-
-static int l_get_block_states(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    int states = vox == nullptr ? 0 : vox->states;
-    lua_pushinteger(L, states);
-    return 1;
-}
-
-static int l_get_block_user_bits(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    lua::luaint offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
-    lua::luaint bits = lua_tointeger(L, 5);
-
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        lua_pushinteger(L, 0);
-        return 1;
-    }
-    uint mask = ((1 << bits) - 1) << offset;
-    uint data = (vox->states & mask) >> offset;
-    lua_pushinteger(L, data);
-    return 1;
-}
-
-static int l_set_block_user_bits(lua_State* L) {
-    lua::luaint x = lua_tointeger(L, 1);
-    lua::luaint y = lua_tointeger(L, 2);
-    lua::luaint z = lua_tointeger(L, 3);
-    lua::luaint offset = lua_tointeger(L, 4) + VOXEL_USER_BITS_OFFSET;
-    lua::luaint bits = lua_tointeger(L, 5);
-
-    uint mask = ((1 << bits) - 1) << offset;
-    lua::luaint value = (lua_tointeger(L, 6) << offset) & mask;
-    
-    voxel* vox = scripting::level->chunks->get(x, y, z);
-    if (vox == nullptr) {
-        return 0;
-    }
-    vox->states = (vox->states & (~mask)) | value;
-    return 0;
-}
-
-static int l_is_replaceable_at(lua_State* L) {
-    int x = lua_tointeger(L, 1);
-    int y = lua_tointeger(L, 2);
-    int z = lua_tointeger(L, 3);
-
-    lua_pushboolean(L, scripting::level->chunks->isReplaceableBlock(x, y, z));
-    return 1;
-}
+extern int l_block_name(lua_State* L);
+extern int l_is_solid_at(lua_State* L);
+extern int l_blocks_count(lua_State* L);
+extern int l_block_index(lua_State* L);
+extern int l_set_block(lua_State* L);
+extern int l_get_block(lua_State* L);
+extern int l_get_block_x(lua_State* L);
+extern int l_get_block_y(lua_State* L);
+extern int l_get_block_z(lua_State* L);
+extern int l_get_block_states(lua_State* L);
+extern int l_get_block_user_bits(lua_State* L);
+extern int l_set_block_user_bits(lua_State* L);
+extern int l_is_replaceable_at(lua_State* L);
 
 // Modified version of luaB_print from lbaselib.c
-static int l_print(lua_State* L) {
-    int n = lua_gettop(L);  /* number of arguments */
-    lua_getglobal(L, "tostring");
-    for (int i=1; i<=n; i++) {
-        lua_pushvalue(L, -1);  /* function to be called */
-        lua_pushvalue(L, i);   /* value to print */
-        lua_call(L, 1, 1);
-        const char* s = lua_tostring(L, -1);  /* get result */
-        if (s == NULL)
-            return luaL_error(L, LUA_QL("tostring") " must return a string to "
-                                 LUA_QL("print"));
-        if (i > 1)
-            std::cout << "\t";
-        std::cout << s;
-        lua_pop(L, 1);  /* pop result */
-    }
-    std::cout << std::endl;
-    return 0;
-}
+extern int l_print(lua_State* L);
 
 #endif // LOGIC_SCRIPTING_API_LUA_H_

From ef81a024c9393c3a86e5a0a8d172400b03921f38 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Wed, 14 Feb 2024 04:38:34 +0300
Subject: [PATCH 7/7] new crosshair + minor refactor

---
 res/textures/gui/crosshair.png | Bin 0 -> 5272 bytes
 src/assets/AssetsLoader.cpp    |   1 +
 src/frontend/hud.cpp           |  92 ++++++++++++++++++++-------------
 src/frontend/hud.h             |   1 +
 src/window/Window.cpp          |   3 ++
 src/window/Window.h            |   2 +-
 6 files changed, 61 insertions(+), 38 deletions(-)
 create mode 100644 res/textures/gui/crosshair.png

diff --git a/res/textures/gui/crosshair.png b/res/textures/gui/crosshair.png
new file mode 100644
index 0000000000000000000000000000000000000000..7010266b7391ef330630308eed616ef505c3f49f
GIT binary patch
literal 5272
zcmeHKYgiN479GlM5h}heDp)KrqE=;+nPl>m02WZ9L{dNmtSysygsFL%1QPIC5h<cp
zD<Ghjq81h3T2S!~C~8GOtzL@tQL3U~RebPSD*`<UsBmxp_}%vYGWn9soU`{jd#}Cr
zIhn=EX_H-DhPglx<SGvd3J1RfY@a^wfN!tIoj3$J>XIX)&EdF(WiaY#Mnkd8Nd}5V
zSs5CFtUop8#bi~E?wkH|!V*shxzBa6&!%yr?;k#1c(tIpptd!)sB)z%Ov;-alhXH<
zb$GTqapqKfzlcOnH5q=tTjJKY`reF~u*A=0UwPf<?a#U(88KjN^40mVzO7ti;*8w=
zac)OFiW5UG{<`>X|F%S;$*_UXu2|=l{s<4D);1guxRlqZ+SfYIIpK2K=P`@#iE0*Y
zqS`QH+vPFjE~h@z$%v>$MRx|K)Lzcc6@0MjiPC%rjoLe^?B+k559Ad+uF8n7R<_UD
zIDXvijFvOaxw(0P!TK!EvmHD0#aD`o!#itAN(t{DAH`ZCZt9BtThN2c_R`zGeVP$@
ziug!fcMD1$%-J-1Wc^akFa40rs59~Dv#tj0ICN`V?2YQTK3*uZaD1&Z=iNvja75$n
z?3g+FVA>{mF*d;Q#3gIU58H=(246mQe|l}S^+3(e^N;8US3I^JLrz*78z=2Lik$Ry
zsjjX4cmyYNwI&TcT{GrlK-#Iyi@OK?iz)r_=2n(FoqK!W=@89T#l`YZa{`9Of1wH}
z^BOv>9Z7MkNC-f-v!KtmFBo~qJ8M;Dh~v7{b8}KQq(X~W!zV78u`G_@&AO3OIdyt!
zK<J9XRSSa7ZFbfa4=I1-7uV^nuMZp*|6oL#d-(1Zfs2RD>x-UrQ-9<m&n|Kc4;>p*
zwPn?s(zx?ktEurZ#oxxKdzz|pO`Ny=-t`%Jc-A`Ql$@>q{xLvM7rEnB?67@dkKsM_
z;U&2<n}66__<3u6L}|g?OV;C2KRq9^Z~w-ceTQ=v>=3R@_rfbP)0g>H$?ugvD?Adg
ztp8`lA&L{`@P*jMrOpM7-k~%!`ld(ag`gByID0k!$tR-^oUW!Sw)9D59VhFO202bF
z`!20wXrlLo^YZ&6bt|6_7A56*D$Lxhw$u0C-|Oces2zAY?3d835&3@A`l!mP=k@JP
z&1*-0a<6k+`lR9Jugmb3)rCK|Yrd-Siftva{>y$S-0S~c>&D=-TV%B(WoH|Qn)+{+
zd7Qa+VZz*7*D?z~{W%E_J8$ZE|F_m-YwkXbnLA<mt^&WMHyTTx)VsF7x3}r1bMGZR
zJF0nhc!Rd|=~_Qei@N!7^wHs&rAtqV;AiWiKAo<3wp&^d(Hgm+(`!CcR@J8?e|2YG
zhpTn)mDqmm`#T`WA&m(PRLTPbUvwVmxBPjTvXJ9Sw=cpXHnOKXO~??F@!$AlED?V;
zc!_evMVB4YRfk*qufe>>a+asguBcdhV(Y@CB|H1=Ol3WFyneS~Llb+{wLG`jO6xBV
z{b~>0esFDG%DK%*&7EOR*j3?$(`l<}b}U&xqfgUh2+iP?d?}GnsVF^qe@pfqPHoBa
zwvO$70zJxN4LZv^zGty0qe!G(_}FhwS`L}>G~Zgi;oU+0##s-aE;F5{7N{pxhb9+@
zKlB+gA-Xv(iYK@}_WI_n%`3U2EJ~uEQ#VdfcW}&nT)b<SkLjDbK3UO~gS<18%0Q37
z^%)m-W~)XhZaaH*?*29J`;9BM^_{f*?a1{L6Wbf+KbX5O3O62`>M|zf{?JpuXE>~%
zwJyez-$I;X3ZM#g!xVknHrKdY*{#Vlm%i`dc)9#U!pw*#DQAYqHJx6exRjH+C+$NA
ztAC-s%3)z?K+76YX`N)6S4!WSaS4u|o^KTfSAFtZk|pf+m5zH%O^ef%UyXSN`pXyy
z>es-4oiJJvDkbz<4o>P-6vwJHfSnS8eEqEkoS03SSt?4+=w$4cLuG6hL(14Q1PVl9
z2&CefkYpnjkvuJuNS;kdNVdP9i?3A*0JM}DXIZrxok?nyvF*50aBUmrvRQT$^K2PA
zTA^eG>Wvf&<6s;F4z@ChJhq<;%hyQK((s^3-4NhT#*R0e4N@-GVzF>6e2(6z=Asgb
zgp2UFJRS@zU{jLLj9X!yX`~IJ3nPd!5k|&fX7oCi4HH-C6U;I;8_cs_#HTeV6ffa*
zrfwDhA6zSL;G!IatJQLQdYH_?i2$TKpg;96MS=r`8%~+@2}XhnPNa0^kv$<u;-$YK
z!KksPLlRs{LurAj39O3tT5_^np?v9Kqd?7Q4R$X;b}vgaL%$-cS8TQ!dpbP>0q!qx
zds)B8-EIu56bfmOo=C8TCl8XbZR<-(J;9LDu1kav;uy|@#e`4*V<?XgOL!y&lPa1Z
z2%(S^V^j|)xz1$9bp&OD0^l45;Ls|H=94rI(=;W5F)@O|IKf9@k%Yi`DgnYnL_`mW
zFe3w0iEDaBWrHFC6sn?72?b&hpr{JQ5CA0>;55ur;Q|UH`4lY@*r7;5I!SNT;-H+2
z7FSbTgHCOqun{husFcgtJPz_|M5)2eG;olyLm6Fy_0>cqqopFuxQ$Izgowl<OejY9
z7+;7<UKvGEMiWq?4HHE;{4QKuS)?EtKrC+4DFCp0fLx@3MhZ9Ujgfl2M#i><#IkwX
z<<0W#DoO}r0v1U&#dm8yf|}EH*VO_V#y-Vj*<~xmiLOOVcp^pG7Xp4=Q$#$jQ&XV7
zy9M=PocWVtp*YQ_L}Co4_(CC!kzxU?B18yG3k9H#DjrD-{{!8mr_C1JNKI6OOhGn4
zK=y1{AK0lJ+dCFZJZ0kv;bAbsgHbFJL8TZb<x9pRd?|vkxqp9(ltjW8^Kl6*=3_XF
zNrWocrbL*+35qWkig~nv-#h64HARr0NQ(R)QzTK5N<xyL(J+*TF%?e)<DijY5sxBq
z5~am_QI{BBYUD3SQ4H$WyNbSC+ur;_x4zu}Qg)X?kIfuZziSK}65!0?zC3igWnpWE
zzwy=GQGeqK0Q$`$uf^{hy57+BS`56F@f&r$q3g96crD{M>iWy*a(VUGO6kCVSqpe5
zJy||m4IXIUQB9p31a;cp>y8v<gAr##NQ?=B-u<WT;{dJ6cL#$`X1OBRsp+kL4x=Gm
zc}IUR#FYn4j1-?C;@mGb_`5Yk91q$u%25xUNEs+8S9-g9c${~1``Y(Hywts4bBYRr
YTz+?l>SG3G09QyJJS}MFhjFQY0HU|Nj{pDw

literal 0
HcmV?d00001

diff --git a/src/assets/AssetsLoader.cpp b/src/assets/AssetsLoader.cpp
index c03ebf4b..2298904a 100644
--- a/src/assets/AssetsLoader.cpp
+++ b/src/assets/AssetsLoader.cpp
@@ -76,6 +76,7 @@ void AssetsLoader::addDefaults(AssetsLoader& loader, const Content* content) {
         loader.add(ASSET_SHADER, SHADERS_FOLDER"/skybox_gen", "skybox_gen");
         loader.add(ASSET_TEXTURE, TEXTURES_FOLDER"/misc/moon.png", "misc/moon");
         loader.add(ASSET_TEXTURE, TEXTURES_FOLDER"/misc/sun.png", "misc/sun");
+        loader.add(ASSET_TEXTURE, TEXTURES_FOLDER"/gui/crosshair.png", "gui/crosshair");
 
         addLayouts(0, "core", loader.getPaths()->getMainRoot()/fs::path("layouts"), loader);
         for (auto& pack : content->getPacks()) {
diff --git a/src/frontend/hud.cpp b/src/frontend/hud.cpp
index c0286eed..d54b1d99 100644
--- a/src/frontend/hud.cpp
+++ b/src/frontend/hud.cpp
@@ -49,9 +49,6 @@
 #include "../items/Inventory.h"
 #include "../logic/scripting/scripting.h"
 
-using glm::vec2;
-using glm::vec3;
-using glm::vec4;
 using namespace gui;
 
 static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
@@ -63,13 +60,13 @@ static std::shared_ptr<Label> create_label(wstringsupplier supplier) {
 std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
     auto level = frontend->getLevel();
 
-    auto panel = std::make_shared<Panel>(vec2(250, 200), vec4(5.0f), 2.0f);
+    auto panel = std::make_shared<Panel>(glm::vec2(250, 200), glm::vec4(5.0f), 2.0f);
     panel->listenInterval(0.5f, [this]() {
         fpsString = std::to_wstring(fpsMax)+L" / "+std::to_wstring(fpsMin);
         fpsMin = fps;
         fpsMax = fps;
     });
-    panel->setCoord(vec2(10, 10));
+    panel->setCoord(glm::vec2(10, 10));
     panel->add(create_label([this](){ return L"fps: "+this->fpsString;}));
     panel->add(create_label([](){
         return L"meshes: " + std::to_wstring(Mesh::meshesCount);
@@ -100,15 +97,15 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
     }));
 
     for (int ax = 0; ax < 3; ax++){
-        auto sub = std::make_shared<Container>(vec2(), vec2(250, 27));
+        auto sub = std::make_shared<Container>(glm::vec2(), glm::vec2(250, 27));
 
         std::wstring str = L"x: ";
         str[0] += ax;
         auto label = std::make_shared<Label>(str);
-        label->setMargin(vec4(2, 3, 2, 3));
-        label->setSize(vec2(20, 27));
+        label->setMargin(glm::vec4(2, 3, 2, 3));
+        label->setSize(glm::vec2(20, 27));
         sub->add(label);
-        sub->setColor(vec4(0.0f));
+        sub->setColor(glm::vec4(0.0f));
 
         // Coord input
         auto box = std::make_shared<TextBox>(L"");
@@ -118,7 +115,7 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
         });
         box->textConsumer([=](std::wstring text) {
             try {
-                vec3 position = level->player->hitbox->position;
+                glm::vec3 position = level->player->hitbox->position;
                 position[ax] = std::stoi(text);
                 level->player->teleport(position);
             } catch (std::invalid_argument& _){
@@ -128,9 +125,9 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
             Hitbox* hitbox = level->player->hitbox.get();
             box->setText(std::to_wstring(int(hitbox->position[ax])));
         });
-        box->setSize(vec2(230, 27));
+        box->setSize(glm::vec2(230, 27));
 
-        sub->add(box, vec2(20, 0));
+        sub->add(box, glm::vec2(20, 0));
         panel->add(sub);
     }
     panel->add(create_label([=](){
@@ -156,7 +153,7 @@ std::shared_ptr<UINode> HudRenderer::createDebugPanel(Engine* engine) {
     }
     {
         auto checkbox = std::make_shared<FullCheckBox>(
-            L"Show Chunk Borders", vec2(400, 24)
+            L"Show Chunk Borders", glm::vec2(400, 24)
         );
         checkbox->setSupplier([=]() {
             return engine->getSettings().debug.showChunkBorders;
@@ -237,7 +234,7 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend)
 
     contentAccess = createContentAccess();
     contentAccessPanel = std::make_shared<Panel>(
-        contentAccess->getSize(), vec4(0.0f), 0.0f
+        contentAccess->getSize(), glm::vec4(0.0f), 0.0f
     );
     contentAccessPanel->setColor(glm::vec4());
     contentAccessPanel->add(contentAccess);
@@ -247,8 +244,9 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend)
     darkOverlay = std::make_unique<Panel>(glm::vec2(4000.0f));
     darkOverlay->setColor(glm::vec4(0, 0, 0, 0.5f));
     darkOverlay->setZIndex(-1);
+    darkOverlay->setVisible(false);
 
-    uicamera = std::make_unique<Camera>(vec3(), 1);
+    uicamera = std::make_unique<Camera>(glm::vec3(), 1);
     uicamera->perspective = false;
     uicamera->flipped = true;
 
@@ -265,6 +263,7 @@ HudRenderer::HudRenderer(Engine* engine, LevelFrontend* frontend)
 }
 
 HudRenderer::~HudRenderer() {
+    // removing all controlled ui
     gui->remove(grabbedItemView);
     if (inventoryView) {
         gui->remove(inventoryView);
@@ -287,23 +286,20 @@ void HudRenderer::update(bool visible) {
     auto menu = gui->getMenu();
 
     debugPanel->setVisible(player->debug && visible);
-    menu->setVisible(pause);
 
     if (!visible && inventoryOpen) {
         closeInventory();
     }
     if (pause && menu->getCurrent().panel == nullptr) {
-        pause = false;
+        setPause(false);
     }
     if (Events::jpressed(keycode::ESCAPE) && !gui->isFocusCaught()) {
         if (pause) {
-            pause = false;
-            menu->reset();
+            setPause(false);
         } else if (inventoryOpen) {
             closeInventory();
         } else {
-            pause = true;
-            menu->setPage("pause");
+            setPause(true);
         }
     }
     if (visible && Events::jactive(BIND_HUD_INVENTORY)) {
@@ -319,9 +315,9 @@ void HudRenderer::update(bool visible) {
         Events::toggleCursor();
     }
 
-    vec2 invSize = contentAccessPanel->getSize();
+    glm::vec2 invSize = contentAccessPanel->getSize();
     contentAccessPanel->setVisible(inventoryOpen);
-    contentAccessPanel->setSize(vec2(invSize.x, Window::height));
+    contentAccessPanel->setSize(glm::vec2(invSize.x, Window::height));
     hotbarView->setVisible(visible);
 
     for (int i = keycode::NUM_1; i <= keycode::NUM_9; i++) {
@@ -340,10 +336,11 @@ void HudRenderer::update(bool visible) {
         }
         player->setChosenSlot(slot);
     }
-
-    darkOverlay->setVisible(pause);
 }
 
+/** 
+ * Show inventory on the screen and turn on inventory mode blocking movement
+ */
 void HudRenderer::openInventory() {
     auto level = frontend->getLevel();
     auto player = level->player;
@@ -359,6 +356,9 @@ void HudRenderer::openInventory() {
     gui->add(inventoryView);
 }
 
+/**
+ * Hide inventory and turn off inventory mode
+ */
 void HudRenderer::closeInventory() {
     scripting::on_ui_close(inventoryDocument, inventoryView->getInventory().get());
     inventoryOpen = false;
@@ -371,13 +371,12 @@ void HudRenderer::closeInventory() {
 
 void HudRenderer::draw(const GfxContext& ctx){
     auto level = frontend->getLevel();
+    auto player = level->player;
 
     const Viewport& viewport = ctx.getViewport();
     const uint width = viewport.getWidth();
     const uint height = viewport.getHeight();
 
-    Player* player = level->player;
-
     uicamera->setFov(height);
 
     auto batch = ctx.getBatch2D();
@@ -391,16 +390,21 @@ void HudRenderer::draw(const GfxContext& ctx){
     hotbarView->setSelected(player->getChosenSlot());
 
     // Crosshair
-    batch->begin();
     if (!pause && Events::_cursor_locked && !level->player->debug) {
-        batch->lineWidth(2);
-        batch->line(width/2, height/2-6, width/2, height/2+6, 0.2f, 0.2f, 0.2f, 1.0f);
-        batch->line(width/2+6, height/2, width/2-6, height/2, 0.2f, 0.2f, 0.2f, 1.0f);
-        batch->line(width/2-5, height/2-5, width/2+5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
-        batch->line(width/2+5, height/2-5, width/2-5, height/2+5, 0.9f, 0.9f, 0.9f, 1.0f);
+        GfxContext chctx = ctx.sub();
+        chctx.blendMode(blendmode::inversion);
+        batch->texture(assets->getTexture("gui/crosshair"));
+        int chsize = 16;
+        batch->rect(
+            (width-chsize)/2, (height-chsize)/2, 
+            chsize, chsize, 0,0, 1,1, 1,1,1,1
+        );
+        batch->render();
     }
 
+    // Delta-time visualizer
     if (level->player->debug) {
+        batch->texture(nullptr);
         const int dmwidth = 256;
         const float dmscale = 4000.0f;
         static float deltameter[dmwidth]{};
@@ -417,15 +421,13 @@ void HudRenderer::draw(const GfxContext& ctx){
 
     if (inventoryOpen) {
         float caWidth = contentAccess->getSize().x;
+        contentAccessPanel->setCoord(glm::vec2(width-caWidth, 0));
+
         glm::vec2 invSize = inventoryView->getSize();
-
-        float width = viewport.getWidth();
-
         inventoryView->setCoord(glm::vec2(
             glm::min(width/2-invSize.x/2, width-caWidth-10-invSize.x), 
             height/2-invSize.y/2
         ));
-        contentAccessPanel->setCoord(glm::vec2(width-caWidth, 0));
     }
     grabbedItemView->setCoord(glm::vec2(Events::cursor));
     batch->render();
@@ -438,3 +440,19 @@ bool HudRenderer::isInventoryOpen() const {
 bool HudRenderer::isPause() const {
     return pause;
 }
+
+void HudRenderer::setPause(bool pause) {
+    if (this->pause == pause) {
+        return;
+    }
+    this->pause = pause;
+    
+    auto menu = gui->getMenu();
+    if (pause) {
+        menu->setPage("pause");
+    } else {
+        menu->reset();
+    }
+    darkOverlay->setVisible(pause);
+    menu->setVisible(pause);
+}
diff --git a/src/frontend/hud.h b/src/frontend/hud.h
index f9d12b6a..bb5a3897 100644
--- a/src/frontend/hud.h
+++ b/src/frontend/hud.h
@@ -64,6 +64,7 @@ public:
 
 	bool isInventoryOpen() const;
 	bool isPause() const;
+    void setPause(bool pause);
 
     void openInventory();
     void closeInventory();
diff --git a/src/window/Window.cpp b/src/window/Window.cpp
index b140dbaa..b18405ae 100644
--- a/src/window/Window.cpp
+++ b/src/window/Window.cpp
@@ -175,6 +175,9 @@ void Window::setBlendMode(blendmode mode) {
         case blendmode::addition:
             glBlendFunc(GL_SRC_ALPHA, GL_ONE);
             break;
+        case blendmode::inversion:
+            glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);
+            break;
     }
 }
 
diff --git a/src/window/Window.h b/src/window/Window.h
index 96bd210a..751c2058 100644
--- a/src/window/Window.h
+++ b/src/window/Window.h
@@ -15,7 +15,7 @@ struct DisplaySettings;
 struct GLFWmonitor;
 
 enum class blendmode {
-    normal, addition
+    normal, addition, inversion
 };
 
 class Window {