Add canvas UI node

src/logic/scripting/lua/libs/libgui.cpp

@@ -3,6 +3,7 @@
 #include "engine/Engine.hpp"
 #include "frontend/locale.hpp"
 #include "graphics/ui/elements/Button.hpp"
+#include "graphics/ui/elements/Canvas.hpp"
 #include "graphics/ui/elements/CheckBox.hpp"
 #include "graphics/ui/elements/Image.hpp"
 #include "graphics/ui/elements/InventoryView.hpp"
@@ -323,6 +324,13 @@ static int p_get_src(UINode* node, lua::State* L) {
     return 0;
 }
 
+static int p_get_data(UINode* node, lua::State* L) {
+    if (auto canvas = dynamic_cast<Canvas*>(node)) {
+        return lua::newuserdata<lua::LuaCanvas>(L, canvas->texture());
+    }
+    return 0;
+}
+
 static int p_get_add(UINode* node, lua::State* L) {
     if (dynamic_cast<Container*>(node)) {
         return lua::pushcfunction(L, lua::wrap<l_container_add>);
@@ -464,6 +472,7 @@ static int l_gui_getattr(lua::State* L) {
             {"inventory", p_get_inventory},
             {"focused", p_get_focused},
             {"cursor", p_get_cursor},
+            {"data", p_get_data},
         };
     auto func = getters.find(attr);
     if (func != getters.end()) {

src/logic/scripting/lua/lua_custom_types.hpp

@@ -8,6 +8,8 @@
 struct fnl_state;
 class Heightmap;
 class VoxelFragment;
+class Texture;
+class ImageData;
 
 namespace lua {
     class Userdata {
@@ -90,4 +92,25 @@ namespace lua {
         inline static std::string TYPENAME = "VoxelFragment";
     };
     static_assert(!std::is_abstract<LuaVoxelFragment>());
+
+    class LuaCanvas : public Userdata {
+    public:
+        explicit LuaCanvas(std::shared_ptr<Texture> inTexture);
+        ~LuaCanvas() override = default;
+
+        const std::string& getTypeName() const override {
+            return TYPENAME;
+        }
+
+        [[nodiscard]] Texture& texture() const { return *mTexture; }
+
+        [[nodiscard]] ImageData& data() const { return *mData; }
+
+        static int createMetatable(lua::State*);
+        inline static std::string TYPENAME = "Canvas";
+    private:
+        std::shared_ptr<Texture> mTexture;
+        std::unique_ptr<ImageData> mData;
+    };
+    static_assert(!std::is_abstract<LuaCanvas>());
 }

src/logic/scripting/lua/lua_engine.cpp

@@ -115,6 +115,7 @@ void lua::init_state(State* L, StateType stateType) {
     newusertype<LuaBytearray>(L);
     newusertype<LuaHeightmap>(L);
     newusertype<LuaVoxelFragment>(L);
+    newusertype<LuaCanvas>(L);
 }
 
 void lua::initialize(const EnginePaths& paths, const CoreParameters& params) {

src/logic/scripting/lua/lua_util.hpp

@@ -274,7 +274,7 @@ namespace lua {
     inline int newuserdata(lua::State* L, Args&&... args) {
         const auto& found = usertypeNames.find(typeid(T));
         void* ptr = lua_newuserdata(L, sizeof(T));
-        new (ptr) T(args...);
+        new (ptr) T(std::forward<Args>(args)...);
 
         if (found == usertypeNames.end()) {
             log_error(

src/logic/scripting/lua/usertypes/lua_type_canvas.cpp

@@ -0,0 +1,140 @@
+#include <unordered_map>
+
+#include "graphics/core/ImageData.hpp"
+#include "graphics/core/Texture.hpp"
+#include "logic/scripting/lua/lua_custom_types.hpp"
+#include "logic/scripting/lua/lua_util.hpp"
+
+using namespace lua;
+
+LuaCanvas::LuaCanvas(std::shared_ptr<Texture> inTexture)
+    : mTexture(std::move(inTexture)) {
+    mData = mTexture->readData();
+}
+
+union RGBA {
+    uint8_t rgba[4];
+    uint32_t raw;
+};
+
+static RGBA* get_at(const ImageData& data, uint index) {
+    if (index >= data.getWidth() * data.getHeight()) {
+        return nullptr;
+    }
+    return reinterpret_cast<RGBA*>(data.getData() + index * sizeof(RGBA));
+}
+
+static RGBA* get_at(const ImageData& data, uint x, uint y) {
+    return get_at(data, y * data.getWidth() + x);
+}
+
+static RGBA* get_at(State* L, uint x, uint y) {
+    if (auto texture = touserdata<LuaCanvas>(L, 1)) {
+        return get_at(texture->data(), x, y);
+    }
+    return nullptr;
+}
+
+static int l_at(State* L) {
+    auto x = static_cast<uint>(tonumber(L, 2));
+    auto y = static_cast<uint>(tonumber(L, 3));
+
+    if (auto pixel = get_at(L, x, y)) {
+        return pushnumber(L, pixel->raw);
+    }
+
+    return 0;
+}
+
+static int l_set(State* L) {
+    auto x = static_cast<uint>(tonumber(L, 2));
+    auto y = static_cast<uint>(tonumber(L, 3));
+
+    if (auto pixel = get_at(L, x, y)) {
+        switch (gettop(L)) {
+            case 4:
+                pixel->raw = static_cast<uint>(tonumber(L, 4));
+                return 1;
+            case 6:
+                pixel->rgba[0] = static_cast<ubyte>(tonumber(L, 4));
+                pixel->rgba[1] = static_cast<ubyte>(tonumber(L, 5));
+                pixel->rgba[2] = static_cast<ubyte>(tonumber(L, 6));
+                pixel->rgba[3] = 255;
+                return 1;
+            case 7:
+                pixel->rgba[0] = static_cast<ubyte>(tonumber(L, 4));
+                pixel->rgba[1] = static_cast<ubyte>(tonumber(L, 5));
+                pixel->rgba[2] = static_cast<ubyte>(tonumber(L, 6));
+                pixel->rgba[3] = static_cast<ubyte>(tonumber(L, 7));
+                return 1;
+            default:
+                return 0;
+        }
+    }
+
+    return 0;
+}
+
+static int l_update(State* L) {
+    if (auto texture = touserdata<LuaCanvas>(L, 1)) {
+        texture->texture().reload(texture->data());
+    }
+    return 0;
+}
+
+static std::unordered_map<std::string, lua_CFunction> methods {
+    {"at", lua::wrap<l_at>},
+    {"set", lua::wrap<l_set>},
+    {"update", lua::wrap<l_update>}
+};
+
+static int l_meta_index(State* L) {
+    auto texture = touserdata<LuaCanvas>(L, 1);
+    if (texture == nullptr) {
+        return 0;
+    }
+    auto& data = texture->data();
+    if (isnumber(L, 2)) {
+        if (auto pixel = get_at(data, static_cast<uint>(tonumber(L, 2)))) {
+            return pushinteger(L, pixel->raw);
+        }
+    }
+    if (isstring(L, 2)) {
+        auto name = tostring(L, 2);
+        if (!strcmp(name, "width")) {
+            return pushinteger(L, data.getWidth());
+        }
+        if (!strcmp(name, "height")) {
+            return pushinteger(L, data.getHeight());
+        }
+        if (auto func = methods.find(tostring(L, 2)); func != methods.end()) {
+            return pushcfunction(L, func->second);
+        }
+    }
+    return 0;
+}
+
+static int l_meta_newindex(State* L) {
+    auto texture = touserdata<LuaCanvas>(L, 1);
+    if (texture == nullptr) {
+        return 0;
+    }
+    auto& data = texture->data();
+    if (isnumber(L, 2) && isnumber(L, 3)) {
+        if (auto pixel = get_at(data, static_cast<uint>(tonumber(L, 2)))) {
+            pixel->raw = static_cast<uint>(tonumber(L, 3));
+            return 1;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+int LuaCanvas::createMetatable(State* L) {
+    createtable(L, 0, 3);
+    pushcfunction(L, lua::wrap<l_meta_index>);
+    setfield(L, "__index");
+    pushcfunction(L, lua::wrap<l_meta_newindex>);
+    setfield(L, "__newindex");
+    return 1;
+}