bind high components and modules

headers/enduro2d/core/input.hpp

@@ -106,8 +106,8 @@ namespace e2d
         input();
         ~input() noexcept final;
 
-        const class mouse& mouse() const noexcept;
-        const class keyboard& keyboard() const noexcept;
+        const mouse& mouse() const noexcept;
+        const keyboard& keyboard() const noexcept;
 
         void post_event(input_char_event evt) noexcept;
         void post_event(move_cursor_event evt) noexcept;

samples/bin/library/scripts/emmy/components/actor.lua

@@ -0,0 +1,8 @@
+---@class actor
+local actor = {
+    ---@type node
+    node = {}
+}
+
+---@type actor
+_G.actor = _G.actor or actor

samples/bin/library/scripts/emmy/components/behaviour.lua

@@ -0,0 +1,22 @@
+---@class behaviour
+local behaviour = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false,
+
+    ---@type table
+    meta = {}
+}
+
+---@overload fun(self: behaviour)
+---@param self behaviour
+function behaviour.enable(self) end
+
+---@overload fun(self: behaviour)
+---@param self behaviour
+function behaviour.disable(self) end
+
+---@type behaviour
+_G.behaviour = _G.behaviour or behaviour

samples/bin/library/scripts/emmy/components/camera.lua

@@ -0,0 +1,31 @@
+---@class camera
+local camera = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false,
+
+    ---@type integer
+    depth = 0,
+
+    ---@type rect
+    viewport = rect.zero(),
+
+    ---@type m4f
+    projection = m4f.identity(),
+
+    ---@type color
+    background = color.white()
+}
+
+---@overload fun(self: camera)
+---@param self camera
+function camera.enable(self) end
+
+---@overload fun(self: camera)
+---@param self camera
+function camera.disable(self) end
+
+---@type camera
+_G.camera = _G.camera or camera

samples/bin/library/scripts/emmy/components/flipbook_player.lua

@@ -0,0 +1,38 @@
+---@class flipbook_player
+local flipbook_player = {
+    ---@type number
+    time = 0,
+
+    ---@type number
+    speed = 1,
+
+    ---@type boolean
+    looped = false,
+
+    ---@type boolean
+    stopped = true,
+
+    ---@type boolean
+    playing = false,
+
+    ---@type str_hash
+    sequence = str_hash.new(),
+
+    ---@type flipbook_asset
+    flipbook = nil
+}
+
+---@overload fun(self: flipbook_player, time: number)
+---@overload fun(self: flipbook_player, sequence: string)
+---@overload fun(self: flipbook_player, sequence: str_hash)
+---@param self flipbook_player
+function flipbook_player.stop(self, ...) end
+
+---@overload fun(self: flipbook_player, time: number)
+---@overload fun(self: flipbook_player, sequence: string)
+---@overload fun(self: flipbook_player, sequence: str_hash)
+---@param self flipbook_player
+function flipbook_player.play(self, ...) end
+
+---@type flipbook_player
+_G.flipbook_player = _G.flipbook_player or flipbook_player

samples/bin/library/scripts/emmy/components/label.lua

@@ -0,0 +1,53 @@
+---@class label
+local label = {
+    ---@type string
+    text = "",
+
+    ---@type font_asset
+    font = nil,
+
+    ---@type color32
+    tint = color32.white(),
+
+    ---@type label_haligns
+    halign = label.haligns.center,
+
+    ---@type label_valigns
+    valign = label.valigns.baseline,
+
+    ---@type number
+    leading = 1,
+
+    ---@type number
+    tracking = 0,
+
+    ---@type number
+    text_width = 0,
+
+    ---@type number
+    glyph_dilate = 0,
+
+    ---@type number
+    outline_width = 0,
+
+    ---@type color32
+    outline_color = color32.white()
+}
+
+---@class label_haligns
+label.haligns = {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+
+---@class label_valigns
+label.valigns = {
+    top = "top",
+    center = "center",
+    bottom = "bottom",
+    baseline = "baseline"
+}
+
+---@type label
+_G.label = _G.label or label

samples/bin/library/scripts/emmy/components/model_renderer.lua

@@ -0,0 +1,8 @@
+---@class model_renderer
+local model_renderer = {
+    ---@type model_asset
+    model = nil
+}
+
+---@type model_renderer
+_G.model_renderer = _G.model_renderer or model_renderer

samples/bin/library/scripts/emmy/components/named.lua

@@ -0,0 +1,8 @@
+---@class named
+local named = {
+    ---@type string
+    name = ""
+}
+
+---@type named
+_G.named = _G.named or named

samples/bin/library/scripts/emmy/components/renderer.lua

@@ -0,0 +1,19 @@
+---@class renderer
+local renderer = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false
+}
+
+---@overload fun(self: renderer)
+---@param self renderer
+function renderer.enable(self) end
+
+---@overload fun(self: renderer)
+---@param self renderer
+function renderer.disable(self) end
+
+---@type renderer
+_G.renderer = _G.renderer or renderer

samples/bin/library/scripts/emmy/components/scene.lua

@@ -0,0 +1,22 @@
+---@class scene
+local scene = {
+    ---@type boolean
+    enabled = true,
+
+    ---@type boolean
+    disabled = false,
+
+    ---@type integer
+    depth = 0
+}
+
+---@overload fun(self: scene)
+---@param self scene
+function scene.enable(self) end
+
+---@overload fun(self: scene)
+---@param self scene
+function scene.disable(self) end
+
+---@type scene
+_G.scene = _G.scene or scene

samples/bin/library/scripts/emmy/components/spine_player.lua

@@ -0,0 +1,226 @@
+---@class spine_player
+local spine_player = {
+    ---@type spine_asset
+    spine = nil
+}
+
+---@param self spine_player
+---@param name string
+---@return boolean
+function spine_player.skin(self, name) end
+
+---@param self spine_player
+---@param slot string
+---@param name string
+---@return boolean
+function spine_player.attachment(self, slot, name) end
+
+---@param self spine_player
+---@param name string
+---@return boolean
+function spine_player.has_skin(self, name) end
+
+---@param self spine_player
+---@param name string
+---@return boolean
+function spine_player.has_animation(self, name) end
+
+---@param self spine_player
+---@param cmd spine_player_command
+function spine_player.add_command(self, cmd) end
+
+-- -----------------------------------------------------------------------------
+--
+-- events
+--
+-- -----------------------------------------------------------------------------
+
+---@alias spine_player_event spine_player_custom_evt | spine_player_end_evt | spine_player_complete_evt
+
+--
+-- custom_evt
+--
+
+---@class spine_player_custom_evt
+spine_player.custom_evt = {
+    ---@type string
+    name = "",
+
+    ---@type integer
+    int_value = 0,
+
+    ---@type number
+    float_value = 0,
+
+    ---@type string
+    string_value = ""
+}
+
+---@param name string
+---@return spine_player_custom_evt
+function spine_player.custom_evt.new(name) end
+
+--
+-- end_evt
+--
+
+---@class spine_player_end_evt
+spine_player.end_evt = {
+    ---@type string
+    message = ""
+}
+
+---@param message string
+---@return spine_player_end_evt
+function spine_player.end_evt.new(message) end
+
+--
+-- complete_evt
+--
+
+---@class spine_player_complete_evt
+spine_player.complete_evt = {
+    ---@type string
+    message = ""
+}
+
+---@param message string
+---@return spine_player_complete_evt
+function spine_player.complete_evt.new(message) end
+
+-- -----------------------------------------------------------------------------
+--
+-- commands
+--
+-- -----------------------------------------------------------------------------
+
+---@alias spine_player_command spine_player_clear_track_cmd | spine_player_set_anim_cmd | spine_player_add_anim_cmd | spine_player_set_empty_anim_cmd | spine_player_add_empty_anim_cmd
+
+--
+-- clear_track_cmd
+--
+
+---@class spine_player_clear_track_cmd
+spine_player.clear_track_cmd = {
+    ---@type integer
+    track = 0
+}
+
+---@param track integer
+---@return spine_player_clear_track_cmd
+function spine_player.clear_track_cmd.new(track) end
+
+--
+-- set_anim_cmd
+--
+
+---@class spine_player_set_anim_cmd
+spine_player.set_anim_cmd = {
+    ---@type integer
+    track = 0,
+
+    ---@type string
+    name = "",
+
+    ---@type boolean
+    loop = false,
+
+    ---@type string
+    end_message = "",
+
+    ---@type string
+    complete_message = ""
+}
+
+---@param track integer
+---@param name string
+---@return spine_player_set_anim_cmd
+function spine_player.set_anim_cmd.new(track, name) end
+
+--
+-- add_anim_cmd
+--
+
+---@class spine_player_add_anim_cmd
+spine_player.add_anim_cmd = {
+    ---@type integer
+    track = 0,
+
+    ---@type string
+    name = "",
+
+    ---@type boolean
+    loop = false,
+
+    ---@type number
+    delay = 0,
+
+    ---@type string
+    end_message = "",
+
+    ---@type string
+    complete_message = ""
+}
+
+---@param track integer
+---@param name string
+---@return spine_player_add_anim_cmd
+function spine_player.add_anim_cmd.new(track, name) end
+
+--
+-- set_empty_anim_cmd
+--
+
+---@class spine_player_set_empty_anim_cmd
+spine_player.set_empty_anim_cmd = {
+    ---@type integer
+    track = 0,
+
+    ---@type number
+    mix_duration = 0,
+
+    ---@type string
+    end_message = "",
+
+    ---@type string
+    complete_message = ""
+}
+
+---@param track integer
+---@return spine_player_set_empty_anim_cmd
+function spine_player.set_empty_anim_cmd.new(track) end
+
+--
+-- add_empty_anim_cmd
+--
+
+---@class spine_player_add_empty_anim_cmd
+spine_player.add_empty_anim_cmd = {
+    ---@type integer
+    track = 0,
+
+    ---@type number
+    delay = 0,
+
+    ---@type number
+    mix_duration = 0,
+
+    ---@type string
+    end_message = "",
+
+    ---@type string
+    complete_message = ""
+}
+
+---@param track integer
+---@return spine_player_add_empty_anim_cmd
+function spine_player.add_empty_anim_cmd.new(track) end
+
+-- -----------------------------------------------------------------------------
+--
+-- globals
+--
+-- -----------------------------------------------------------------------------
+
+---@type spine_player
+_G.spine_player = _G.spine_player or spine_player

samples/bin/library/scripts/emmy/components/sprite_renderer.lua

@@ -0,0 +1,25 @@
+---@class sprite_renderer
+local sprite_renderer = {
+    ---@type color32
+    tint = color32.white(),
+
+    ---@type sprite_renderer_blendings
+    blending = sprite_renderer.blendings.normal,
+
+    ---@type boolean
+    filtering = true,
+
+    ---@type sprite_asset
+    sprite = nil
+}
+
+---@class sprite_renderer_blendings
+sprite_renderer.blendings = {
+    normal = "normal",
+    additive = "additive",
+    multiply = "multiply",
+    screen = "screen"
+}
+
+---@type sprite_renderer
+_G.sprite_renderer = _G.sprite_renderer or sprite_renderer

samples/bin/library/scripts/emmy/core/debug.lua

@@ -2,17 +2,21 @@
 local debug = {
 }
 
+---@param self debug
 ---@param message string
-function debug:trace(message) end
+function debug.trace(self, message) end
 
+---@param self debug
 ---@param message string
-function debug:warning(message) end
+function debug.warning(self, message) end
 
+---@param self debug
 ---@param message string
-function debug:error(message) end
+function debug.error(self, message) end
 
+---@param self debug
 ---@param message string
-function debug:fatal(message) end
+function debug.fatal(self, message) end
 
 ---@type debug
 _G.the_debug = _G.the_debug or debug

samples/bin/library/scripts/emmy/core/engine.lua

@@ -6,10 +6,10 @@ local engine = {
     ---@type number
     delta_time = 0,
 
-    ---@type number
+    ---@type integer
     frame_rate = 0,
 
-    ---@type number
+    ---@type integer
     frame_count = 0,
 
     ---@type number

samples/bin/library/scripts/emmy/core/input.lua

@@ -1,10 +1,10 @@
 ---@class input
 local input = {
     ---@type mouse
-    mouse = {},
+    mouse = nil,
 
     ---@type keyboard
-    keyboard = {}
+    keyboard = nil
 }
 
 ---@type input

samples/bin/library/scripts/emmy/core/keyboard.lua

@@ -22,17 +22,20 @@ local keyboard = {
     just_released_keys = {}
 }
 
+---@param self keyboard
 ---@param key string
 ---@return boolean
-function keyboard:is_key_pressed(key) end
+function keyboard.is_key_pressed(self, key) end
 
+---@param self keyboard
 ---@param key string
 ---@return boolean
-function keyboard:is_key_just_pressed(key) end
+function keyboard.is_key_just_pressed(self, key) end
 
+---@param self keyboard
 ---@param key string
 ---@return boolean
-function keyboard:is_key_just_released(key) end
+function keyboard.is_key_just_released(self, key) end
 
 ---@type keyboard
 _G.the_keyboard = _G.the_keyboard or keyboard

samples/bin/library/scripts/emmy/core/mouse.lua

@@ -25,17 +25,20 @@ local mouse = {
     just_released_buttons = {}
 }
 
+---@param self mouse
 ---@param button string
 ---@return boolean
-function mouse:is_button_pressed(button) end
+function mouse.is_button_pressed(self, button) end
 
+---@param self mouse
 ---@param button string
 ---@return boolean
-function mouse:is_button_just_pressed(button) end
+function mouse.is_button_just_pressed(self, button) end
 
+---@param self mouse
 ---@param button string
 ---@return boolean
-function mouse:is_button_just_released(button) end
+function mouse.is_button_just_released(self, button) end
 
 ---@type mouse
 _G.the_mouse = _G.the_mouse or mouse

samples/bin/library/scripts/emmy/core/window.lua

@@ -34,13 +34,17 @@ local window = {
     should_close = false
 }
 
-function window:hide() end
+---@param self window
+function window.hide(self) end
 
-function window:show() end
+---@param self window
+function window.show(self) end
 
-function window:restore() end
+---@param self window
+function window.restore(self) end
 
-function window:minimize() end
+---@param self window
+function window.minimize(self) end
 
 ---@type window
 _G.the_window = _G.the_window or window

samples/bin/library/scripts/emmy/high/gobject.lua

@@ -0,0 +1,47 @@
+---@class gobject
+local gobject = {
+    ---@type boolean
+    alive = true,
+
+    ---@type boolean
+    valid = true,
+
+    ---@type actor
+    actor = nil,
+
+    ---@type behaviour
+    behaviour = nil,
+
+    ---@type camera
+    camera = nil,
+
+    ---@type flipbook_player
+    flipbook_player = nil,
+
+    ---@type label
+    label = nil,
+
+    ---@type model_renderer
+    model_renderer = nil,
+
+    ---@type named
+    named = nil,
+
+    ---@type renderer
+    renderer = nil,
+
+    ---@type scene
+    scene = nil,
+
+    ---@type spine_player
+    spine_player = nil,
+
+    ---@type sprite_renderer
+    sprite_renderer = nil
+}
+
+---@param self gobject
+function gobject.destroy(self) end
+
+---@type gobject
+_G.gobject = _G.gobject or gobject

samples/bin/library/scripts/emmy/high/node.lua

@@ -0,0 +1,113 @@
+---@class node
+local node = {
+    ---@type t3f
+    transform = t3f.identity(),
+
+    ---@type v3f
+    translation = v3f.zero(),
+
+    ---@type q4f
+    rotation = q4f.identity(),
+
+    ---@type v3f
+    scale = v3f.unit(),
+
+    ---@type m4f
+    local_matrix = m4f.identity(),
+
+    ---@type m4f
+    world_matrix = m4f.identity(),
+
+    ---@type node
+    root = nil,
+
+    ---@type node
+    parent = nil,
+
+    ---@type integer
+    child_count = 0,
+
+    ---@type integer
+    child_count_recursive = 0,
+
+    ---@type node
+    first_child = nil,
+
+    ---@type node
+    last_child = nil,
+
+    ---@type node
+    prev_sibling = nil,
+
+    ---@type node
+    next_sibling = nil
+}
+
+---@param self node
+---@return boolean
+function node.remove_from_parent(self) end
+
+---@param self node
+---@return integer
+function node.remove_all_children(self) end
+
+---@param self node
+---@param child node
+---@return boolean
+function node.add_child(self, child) end
+
+---@param self node
+---@param child node
+---@return boolean
+function node.add_child_to_back(self, child) end
+
+---@param self node
+---@param child node
+---@return boolean
+function node.add_child_to_front(self, child) end
+
+---@param self node
+---@param before node
+---@param child node
+---@return boolean
+function node.add_child_before(self, before, child) end
+
+---@param self node
+---@param after node
+---@param child node
+---@return boolean
+function node.add_child_after(self, after, child) end
+
+---@param self node
+---@param sibling node
+---@return boolean
+function node.add_sibling_before(self, sibling) end
+
+---@param self node
+---@param sibling node
+---@return boolean
+function node.add_sibling_after(self, sibling) end
+
+---@param self node
+---@param child node
+---@return boolean
+function node.remove_child(self, child) end
+
+---@param self node
+---@return boolean
+function node.send_backward(self) end
+
+---@param self node
+---@return boolean
+function node.bring_to_back(self) end
+
+---@param self node
+---@return boolean
+function node.send_forward(self) end
+
+---@param self node
+---@return boolean
+function node.bring_to_front(self) end
+
+---@type node
+_G.node = _G.node or node

samples/bin/library/scripts/emmy/high/world.lua

@@ -0,0 +1,15 @@
+---@class world
+local world = {
+}
+
+---@overload fun(): gobject
+---@overload fun(prefab: prefab): gobject
+---@overload fun(parent: node): gobject
+---@overload fun(prefab: prefab, parent: node): gobject
+---@overload fun(parent: node, transform: t3f): gobject
+---@overload fun(prefab: prefab, parent: node, transform: t3f): gobject
+---@return gobject
+function world:instantiate(...) end
+
+---@type world
+_G.the_world = _G.the_world or world

sources/enduro2d/high/bindings/core_binds/dbgui_binds.cpp

@@ -13,8 +13,12 @@ namespace e2d::bindings::core
             sol::no_constructor,
 
             "visible", sol::property(
-                &dbgui::visible,
-                &dbgui::toggle_visible)
+                [](const dbgui& d) -> bool {
+                    return d.visible();
+                },
+                [](dbgui& d, bool yesno){
+                    d.toggle_visible(yesno);
+                })
         );
     }
 }

sources/enduro2d/high/bindings/core_binds/engine_binds.cpp

@@ -12,11 +12,25 @@ namespace e2d::bindings::core
         l.new_usertype<engine>("engine",
             sol::no_constructor,
 
-            "time", sol::property(&engine::time),
-            "delta_time", sol::property(&engine::delta_time),
-            "frame_rate", sol::property(&engine::frame_rate),
-            "frame_count", sol::property(&engine::frame_count),
-            "realtime_time", sol::property(&engine::realtime_time)
+            "time", sol::property([](const engine& e) -> f32 {
+                return e.time();
+            }),
+
+            "delta_time", sol::property([](const engine& e) -> f32 {
+                return e.delta_time();
+            }),
+
+            "frame_rate", sol::property([](const engine& e) -> u32 {
+                return e.frame_rate();
+            }),
+
+            "frame_count", sol::property([](const engine& e) -> u32 {
+                return e.frame_count();
+            }),
+
+            "realtime_time", sol::property([](const engine& e) -> f32 {
+                return e.realtime_time();
+            })
         );
     }
 }

sources/enduro2d/high/bindings/core_binds/input_binds.cpp

@@ -39,26 +39,39 @@ namespace e2d::bindings::core
         l.new_usertype<input>("input",
             sol::no_constructor,
 
-            "mouse", sol::property(&input::mouse),
-            "keyboard", sol::property(&input::keyboard)
+            "mouse", sol::property([](const input& i) -> const mouse& {
+                return i.mouse();
+            }),
+
+            "keyboard", sol::property([](const input& i) -> const keyboard& {
+                return i.keyboard();
+            })
         );
 
         l.new_usertype<mouse>("mouse",
             sol::no_constructor,
 
-            "cursor_pos", sol::property([](const mouse& m){
+            "cursor_pos", sol::property([](const mouse& m) -> v2f {
                 return m.cursor_pos();
             }),
 
-            "scroll_delta", sol::property([](const mouse& m){
+            "scroll_delta", sol::property([](const mouse& m) -> v2f {
                 return m.scroll_delta();
             }),
 
-            "is_any_button_pressed", sol::property(&mouse::is_any_button_pressed),
-            "is_any_button_just_pressed", sol::property(&mouse::is_any_button_just_pressed),
-            "is_any_button_just_released", sol::property(&mouse::is_any_button_just_released),
+            "is_any_button_pressed", sol::property([](const mouse& m) -> bool {
+                return m.is_any_button_pressed();
+            }),
 
-            "is_button_pressed", [](const mouse& m, const char* n){
+            "is_any_button_just_pressed", sol::property([](const mouse& m) -> bool {
+                return m.is_any_button_just_pressed();
+            }),
+
+            "is_any_button_just_released", sol::property([](const mouse& m) -> bool {
+                return m.is_any_button_just_released();
+            }),
+
+            "is_button_pressed", [](const mouse& m, str_view n) -> bool {
                 mouse_button btn = mouse_button::unknown;
                 if ( parse_mouse_button(n, btn) ) {
                     return m.is_button_pressed(btn);
@@ -70,7 +83,7 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "is_button_just_pressed", [](const mouse& m, const char* n){
+            "is_button_just_pressed", [](const mouse& m, str_view n) -> bool {
                 mouse_button btn = mouse_button::unknown;
                 if ( parse_mouse_button(n, btn) ) {
                     return m.is_button_just_pressed(btn);
@@ -82,7 +95,7 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "is_button_just_released", [](const mouse& m, const char* n){
+            "is_button_just_released", [](const mouse& m, str_view n) -> bool {
                 mouse_button btn = mouse_button::unknown;
                 if ( parse_mouse_button(n, btn) ) {
                     return m.is_button_just_released(btn);
@@ -94,15 +107,15 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "pressed_buttons", sol::property([](const mouse& m){
+            "pressed_buttons", sol::property([](const mouse& m) -> vector<str> {
                 return convert_buttons_to_strings(m.pressed_buttons());
             }),
 
-            "just_pressed_buttons", sol::property([](const mouse& m){
+            "just_pressed_buttons", sol::property([](const mouse& m) -> vector<str> {
                 return convert_buttons_to_strings(m.just_pressed_buttons());
             }),
 
-            "just_released_buttons", sol::property([](const mouse& m){
+            "just_released_buttons", sol::property([](const mouse& m) -> vector<str> {
                 return convert_buttons_to_strings(m.just_released_buttons());
             })
         );
@@ -110,15 +123,23 @@ namespace e2d::bindings::core
         l.new_usertype<keyboard>("keyboard",
             sol::no_constructor,
 
-            "input_text", sol::property([](const keyboard& k){
+            "input_text", sol::property([](const keyboard& k) -> str {
                 return make_utf8(k.input_text());
             }),
 
-            "is_any_key_pressed", sol::property(&keyboard::is_any_key_pressed),
-            "is_any_key_just_pressed", sol::property(&keyboard::is_any_key_just_pressed),
-            "is_any_key_just_released", sol::property(&keyboard::is_any_key_just_released),
+            "is_any_key_pressed", sol::property([](const keyboard& k) -> bool {
+                return k.is_any_key_pressed();
+            }),
 
-            "is_key_pressed", [](const keyboard& k, const char* n){
+            "is_any_key_just_pressed", sol::property([](const keyboard& k) -> bool {
+                return k.is_any_key_just_pressed();
+            }),
+
+            "is_any_key_just_released", sol::property([](const keyboard& k) -> bool {
+                return k.is_any_key_just_released();
+            }),
+
+            "is_key_pressed", [](const keyboard& k, str_view n) -> bool {
                 keyboard_key key = keyboard_key::unknown;
                 if ( parse_keyboard_key(n, key) ) {
                     return k.is_key_pressed(key);
@@ -130,7 +151,7 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "is_key_just_pressed", [](const keyboard& k, const char* n){
+            "is_key_just_pressed", [](const keyboard& k, str_view n) -> bool {
                 keyboard_key key = keyboard_key::unknown;
                 if ( parse_keyboard_key(n, key) ) {
                     return k.is_key_just_pressed(key);
@@ -142,7 +163,7 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "is_key_just_released", [](const keyboard& k, const char* n){
+            "is_key_just_released", [](const keyboard& k, str_view n) -> bool {
                 keyboard_key key = keyboard_key::unknown;
                 if ( parse_keyboard_key(n, key) ) {
                     return k.is_key_just_released(key);
@@ -154,15 +175,15 @@ namespace e2d::bindings::core
                 return false;
             },
 
-            "pressed_keys", sol::property([](const keyboard& k){
+            "pressed_keys", sol::property([](const keyboard& k) -> vector<str> {
                 return convert_keys_to_strings(k.pressed_keys());
             }),
 
-            "just_pressed_keys", sol::property([](const keyboard& k){
+            "just_pressed_keys", sol::property([](const keyboard& k) -> vector<str> {
                 return convert_keys_to_strings(k.just_pressed_keys());
             }),
 
-            "just_released_keys", sol::property([](const keyboard& k){
+            "just_released_keys", sol::property([](const keyboard& k) -> vector<str> {
                 return convert_keys_to_strings(k.just_released_keys());
             })
         );

sources/enduro2d/high/bindings/core_binds/window_binds.cpp

@@ -12,19 +12,45 @@ namespace e2d::bindings::core
         l.new_usertype<window>("window",
             sol::no_constructor,
 
-            "hide", &window::hide,
-            "show", &window::show,
-            "restore", &window::restore,
-            "minimize", &window::minimize,
+            "hide", [](window& w) {
+                w.hide();
+            },
 
-            "enabled", sol::property(&window::enabled),
-            "visible", sol::property(&window::visible),
-            "focused", sol::property(&window::focused),
-            "minimized", sol::property(&window::minimized),
+            "show", [](window& w) {
+                w.show();
+            },
+
+            "restore", [](window& w) {
+                w.restore();
+            },
+
+            "minimize", [](window& w) {
+                w.minimize();
+            },
+
+            "enabled", sol::property([](const window& w) -> bool {
+                return w.enabled();
+            }),
+
+            "visible", sol::property([](const window& w) -> bool {
+                return w.visible();
+            }),
+
+            "focused", sol::property([](const window& w) -> bool {
+                return w.focused();
+            }),
+
+            "minimized", sol::property([](const window& w) -> bool {
+                return w.minimized();
+            }),
 
             "fullscreen", sol::property(
-                &window::fullscreen,
-                &window::toggle_fullscreen),
+                [](const window& w) -> bool {
+                    return w.fullscreen();
+                },
+                [](window& w, bool yesno){
+                    w.toggle_fullscreen(yesno);
+                }),
 
             "cursor_hidden", sol::property(
                 &window::is_cursor_hidden,
@@ -36,25 +62,33 @@ namespace e2d::bindings::core
                     }
                 }),
 
-            "real_size", sol::property([](const window& w){
+            "real_size", sol::property([](const window& w) -> v2f {
                 return w.real_size().cast_to<f32>();
             }),
 
-            "virtual_size", sol::property([](const window& w){
+            "virtual_size", sol::property([](const window& w) -> v2f {
                 return w.virtual_size().cast_to<f32>();
             }),
 
-            "framebuffer_size", sol::property([](const window& w){
+            "framebuffer_size", sol::property([](const window& w) -> v2f {
                 return w.framebuffer_size().cast_to<f32>();
             }),
 
             "title", sol::property(
-                &window::title,
-                &window::set_title),
+                [](const window& w) -> str {
+                    return w.title();
+                },
+                [](window& w, str_view t){
+                    w.set_title(t);
+                }),
 
             "should_close", sol::property(
-                &window::should_close,
-                &window::set_should_close)
+                [](const window& w) -> bool {
+                    return w.should_close();
+                },
+                [](window& w, bool yesno){
+                    w.set_should_close(yesno);
+                })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/actor_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,10 +12,12 @@
 namespace e2d::bindings::high
 {
     void bind_actor(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<actor>>("actor",
-            "node", sol::property([](const gcomponent<actor>& a){ return a->node(); })
+        l.new_usertype<gcomponent<actor>>("actor",
+            sol::no_constructor,
+
+            "node", sol::property([](gcomponent<actor>& c) -> node_iptr {
+                return c->node();
+            })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/behaviour_binds.cpp

@@ -1,23 +1,58 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
 #include <enduro2d/high/gobject.hpp>
 #include <enduro2d/high/components/behaviour.hpp>
+#include <enduro2d/high/components/disabled.hpp>
 
 namespace e2d::bindings::high
 {
     void bind_behaviour(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<behaviour>>("behaviour",
-            "meta", sol::property(
-                [](const gcomponent<behaviour>& b){ return b->meta(); },
-                [](gcomponent<behaviour>& b, sol::table v){ b->meta(std::move(v)); })
+        l.new_usertype<gcomponent<behaviour>>("behaviour",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<behaviour>& c){
+                c.owner().component<disabled<behaviour>>().remove();
+            },
+
+            "disable", [](gcomponent<behaviour>& c){
+                c.owner().component<disabled<behaviour>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<behaviour>& c) -> bool {
+                    return !c.owner().component<disabled<behaviour>>().exists();
+                },
+                [](gcomponent<behaviour>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<behaviour>>().remove();
+                    } else {
+                        c.owner().component<disabled<behaviour>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<behaviour>& c) -> bool {
+                    return c.owner().component<disabled<behaviour>>().exists();
+                },
+                [](gcomponent<behaviour>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<behaviour>>().ensure();
+                    } else {
+                        c.owner().component<disabled<behaviour>>().remove();
+                    }
+                }
+            ),
+
+            "meta", sol::property([](const gcomponent<behaviour>& c) -> sol::table {
+                return c->meta();
+            })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/camera_binds.cpp

@@ -1,35 +1,86 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
 #include <enduro2d/high/gobject.hpp>
 #include <enduro2d/high/components/camera.hpp>
+#include <enduro2d/high/components/disabled.hpp>
 
 namespace e2d::bindings::high
 {
     void bind_camera(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<camera>>("camera",
+        l.new_usertype<gcomponent<camera>>("camera",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<camera>& c){
+                c.owner().component<disabled<camera>>().remove();
+            },
+
+            "disable", [](gcomponent<camera>& c){
+                c.owner().component<disabled<camera>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<camera>& c) -> bool {
+                    return !c.owner().component<disabled<camera>>().exists();
+                },
+                [](gcomponent<camera>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<camera>>().remove();
+                    } else {
+                        c.owner().component<disabled<camera>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<camera>& c) -> bool {
+                    return c.owner().component<disabled<camera>>().exists();
+                },
+                [](gcomponent<camera>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<camera>>().ensure();
+                    } else {
+                        c.owner().component<disabled<camera>>().remove();
+                    }
+                }
+            ),
+
             "depth", sol::property(
-                [](const gcomponent<camera>& b){ return b->depth(); },
-                [](gcomponent<camera>& b, i32 v){ b->depth(v); }),
+                [](const gcomponent<camera>& c) -> i32 {
+                    return c->depth();
+                },
+                [](gcomponent<camera>& c, i32 v){
+                    c->depth(v);
+                }),
+
             "viewport", sol::property(
-                [](const gcomponent<camera>& b){ return b->viewport().cast_to<f32>(); },
-                [](gcomponent<camera>& b, const b2f& v){ b->viewport(v.cast_to<u32>()); }),
+                [](const gcomponent<camera>& c) -> b2f {
+                    return c->viewport().cast_to<f32>();
+                },
+                [](gcomponent<camera>& c, const b2f& v){
+                    c->viewport(v.cast_to<u32>());
+                }),
+
             "projection", sol::property(
-                [](const gcomponent<camera>& b){ return b->projection(); },
-                [](gcomponent<camera>& b, const m4f& v){ b->projection(v); }),
-            "target", sol::property(
-                [](const gcomponent<camera>& b){ return b->target(); },
-                [](gcomponent<camera>& b, const render_target_ptr& v){ b->target(v); }),
+                [](const gcomponent<camera>& c) -> m4f {
+                    return c->projection();
+                },
+                [](gcomponent<camera>& c, const m4f& v){
+                    c->projection(v);
+                }),
+
             "background", sol::property(
-                [](const gcomponent<camera>& b){ return b->background(); },
-                [](gcomponent<camera>& b, const color& v){ b->background(v); })
+                [](const gcomponent<camera>& c) -> color {
+                    return c->background();
+                },
+                [](gcomponent<camera>& c, const color& v){
+                    c->background(v);
+                })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/flipbook_player_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,37 +12,74 @@
 namespace e2d::bindings::high
 {
     void bind_flipbook_player(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<flipbook_player>>("flipbook_player",
+        l.new_usertype<gcomponent<flipbook_player>>("flipbook_player",
+            sol::no_constructor,
+
             "time", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->time(); },
-                [](gcomponent<flipbook_player>& b, f32 v){ b->time(v); }),
+                [](const gcomponent<flipbook_player>& c) -> f32 {
+                    return c->time();
+                },
+                [](gcomponent<flipbook_player>& c, f32 v){
+                    c->time(v);
+                }),
+
             "speed", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->speed(); },
-                [](gcomponent<flipbook_player>& b, f32 v){ b->speed(v); }),
+                [](const gcomponent<flipbook_player>& c) -> f32 {
+                    return c->speed();
+                },
+                [](gcomponent<flipbook_player>& c, f32 v){
+                    c->speed(v);
+                }),
+
             "looped", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->looped(); },
-                [](gcomponent<flipbook_player>& b, bool v){ b->looped(v); }),
+                [](const gcomponent<flipbook_player>& c) -> bool {
+                    return c->looped();
+                },
+                [](gcomponent<flipbook_player>& c, bool v){
+                    c->looped(v);
+                }),
+
             "stopped", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->stopped(); },
-                [](gcomponent<flipbook_player>& b, bool v){ b->stopped(v); }),
+                [](const gcomponent<flipbook_player>& c) -> bool {
+                    return c->stopped();
+                },
+                [](gcomponent<flipbook_player>& c, bool v){
+                    c->stopped(v);
+                }),
+
             "playing", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->playing(); },
-                [](gcomponent<flipbook_player>& b, bool v){ b->playing(v); }),
+                [](const gcomponent<flipbook_player>& c) -> bool {
+                    return c->playing();
+                },
+                [](gcomponent<flipbook_player>& c, bool v) {
+                    c->playing(v);
+                }),
+
             "sequence", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->sequence(); },
-                [](gcomponent<flipbook_player>& b, str_hash v){ b->sequence(v); }),
+                [](const gcomponent<flipbook_player>& c) -> str_hash {
+                    return c->sequence();
+                },
+                [](gcomponent<flipbook_player>& c, str_hash v){
+                    c->sequence(v);
+                }),
+
             "flipbook", sol::property(
-                [](const gcomponent<flipbook_player>& b){ return b->flipbook(); },
-                [](gcomponent<flipbook_player>& b, const flipbook_asset::ptr& v){ b->flipbook(v); }),
+                [](const gcomponent<flipbook_player>& c) -> flipbook_asset::ptr {
+                    return c->flipbook();
+                },
+                [](gcomponent<flipbook_player>& c, const flipbook_asset::ptr& v){
+                    c->flipbook(v);
+                }),
 
             "stop", sol::overload(
-                [](gcomponent<flipbook_player>& b, f32 v){ b->stop(v); },
-                [](gcomponent<flipbook_player>& b, str_hash v){ b->stop(v); }),
+                [](gcomponent<flipbook_player>& c, f32 v){ c->stop(v); },
+                [](gcomponent<flipbook_player>& c, str_view v){ c->stop(v); },
+                [](gcomponent<flipbook_player>& c, str_hash v){ c->stop(v); }),
+
             "play", sol::overload(
-                [](gcomponent<flipbook_player>& b, f32 v){ b->play(v); },
-                [](gcomponent<flipbook_player>& b, str_hash v){ b->play(v); })
+                [](gcomponent<flipbook_player>& c, f32 v){ c->play(v); },
+                [](gcomponent<flipbook_player>& c, str_view v){ c->play(v); },
+                [](gcomponent<flipbook_player>& c, str_hash v){ c->play(v); })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/label_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,102 +12,111 @@
 namespace e2d::bindings::high
 {
     void bind_label(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<label>>("label",
+        l.new_usertype<gcomponent<label>>("label",
+            sol::no_constructor,
+
             "text", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->text();
+                [](const gcomponent<label>& c) -> str {
+                    return c->text();
                 },
-                [](gcomponent<label>& l, str v){
-                    l->text(std::move(v));
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, str_view v){
+                    c->text(str(v));
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "font", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->font();
+                [](const gcomponent<label>& c) -> font_asset::ptr {
+                    return c->font();
                 },
-                [](gcomponent<label>& l, const font_asset::ptr& v){
-                    l->font(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, const font_asset::ptr& v){
+                    c->font(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "tint", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->tint();
+                [](const gcomponent<label>& c) -> color32 {
+                    return c->tint();
                 },
-                [](gcomponent<label>& l, const color32& v){
-                    l->tint(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, const color32& v){
+                    c->tint(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "halign", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->halign();
+                [](const gcomponent<label>& c) -> label::haligns {
+                    return c->halign();
                 },
-                [](gcomponent<label>& l, label::haligns v){
-                    l->halign(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, label::haligns v){
+                    c->halign(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "valign", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->valign();
+                [](const gcomponent<label>& c) -> label::valigns {
+                    return c->valign();
                 },
-                [](gcomponent<label>& l, label::valigns v){
-                    l->valign(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, label::valigns v){
+                    c->valign(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "leading", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->leading();
+                [](const gcomponent<label>& c) -> f32 {
+                    return c->leading();
                 },
-                [](gcomponent<label>& l, f32 v){
-                    l->leading(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, f32 v){
+                    c->leading(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "tracking", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->tracking();
+                [](const gcomponent<label>& c) -> f32 {
+                    return c->tracking();
                 },
-                [](gcomponent<label>& l, f32 v){
-                    l->tracking(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, f32 v){
+                    c->tracking(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "text_width", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->text_width();
+                [](const gcomponent<label>& c) -> f32 {
+                    return c->text_width();
                 },
-                [](gcomponent<label>& l, f32 v){
-                    l->text_width(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, f32 v){
+                    c->text_width(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "glyph_dilate", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->glyph_dilate();
+                [](const gcomponent<label>& c) -> f32 {
+                    return c->glyph_dilate();
                 },
-                [](gcomponent<label>& l, f32 v){
-                    l->glyph_dilate(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, f32 v){
+                    c->glyph_dilate(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "outline_width", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->outline_width();
+                [](const gcomponent<label>& c) -> f32 {
+                    return c->outline_width();
                 },
-                [](gcomponent<label>& l, f32 v){
-                    l->outline_width(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, f32 v){
+                    c->outline_width(v);
+                    c.owner().component<label::dirty>().ensure();
                 }),
+
             "outline_color", sol::property(
-                [](const gcomponent<label>& l){
-                    return l->outline_color();
+                [](const gcomponent<label>& c) -> color32 {
+                    return c->outline_color();
                 },
-                [](gcomponent<label>& l, const color32& v){
-                    l->outline_color(v);
-                    l.owner().component<label::dirty>().assign();
+                [](gcomponent<label>& c, const color32& v){
+                    c->outline_color(v);
+                    c.owner().component<label::dirty>().ensure();
                 })
         );
 
     #define LABEL_HALIGN_PAIR(x) {#x, label::haligns::x},
-        l["e2d"].get_or_create<sol::table>()
-        ["label"].get_or_create<sol::table>()
+        l["label"].get_or_create<sol::table>()
         .new_enum<label::haligns>("haligns", {
             LABEL_HALIGN_PAIR(left)
             LABEL_HALIGN_PAIR(center)
@@ -116,8 +125,7 @@ namespace e2d::bindings::high
     #undef LABEL_HALIGN_PAIR
 
     #define LABEL_VALIGN_PAIR(x) {#x, label::valigns::x},
-        l["e2d"].get_or_create<sol::table>()
-        ["label"].get_or_create<sol::table>()
+        l["label"].get_or_create<sol::table>()
         .new_enum<label::valigns>("valigns", {
             LABEL_VALIGN_PAIR(top)
             LABEL_VALIGN_PAIR(center)

sources/enduro2d/high/bindings/high_binds/components/model_renderer_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,12 +12,16 @@
 namespace e2d::bindings::high
 {
     void bind_model_renderer(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<model_renderer>>("model_renderer",
+        l.new_usertype<gcomponent<model_renderer>>("model_renderer",
+            sol::no_constructor,
+
             "model", sol::property(
-                [](const gcomponent<model_renderer>& l){ return l->model(); },
-                [](gcomponent<model_renderer>& l, const model_asset::ptr& v){ l->model(v); })
+                [](const gcomponent<model_renderer>& c) -> model_asset::ptr {
+                    return c->model();
+                },
+                [](gcomponent<model_renderer>& c, const model_asset::ptr& v){
+                    c->model(v);
+                })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/named_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,12 +12,16 @@
 namespace e2d::bindings::high
 {
     void bind_named(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<named>>("named",
+        l.new_usertype<gcomponent<named>>("named",
+            sol::no_constructor,
+
             "name", sol::property(
-                [](const gcomponent<named>& c){ return c->name(); },
-                [](gcomponent<named>& c, str v){ c->name(std::move(v)); })
+                [](const gcomponent<named>& c) -> str {
+                    return c->name();
+                },
+                [](gcomponent<named>& c, str_view v){
+                    c->name(str(v));
+                })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/renderer_binds.cpp

@@ -1,19 +1,54 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
 #include <enduro2d/high/gobject.hpp>
+#include <enduro2d/high/components/disabled.hpp>
 #include <enduro2d/high/components/renderer.hpp>
 
 namespace e2d::bindings::high
 {
     void bind_renderer(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<renderer>>("renderer");
+        l.new_usertype<gcomponent<renderer>>("renderer",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<renderer>& c){
+                c.owner().component<disabled<renderer>>().remove();
+            },
+
+            "disable", [](gcomponent<renderer>& c){
+                c.owner().component<disabled<renderer>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<renderer>& c) -> bool {
+                    return !c.owner().component<disabled<renderer>>().exists();
+                },
+                [](gcomponent<renderer>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<renderer>>().remove();
+                    } else {
+                        c.owner().component<disabled<renderer>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<renderer>& c) -> bool {
+                    return c.owner().component<disabled<renderer>>().exists();
+                },
+                [](gcomponent<renderer>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<renderer>>().ensure();
+                    } else {
+                        c.owner().component<disabled<renderer>>().remove();
+                    }
+                }
+            )
+        );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/scene_binds.cpp

@@ -1,23 +1,62 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
 #include <enduro2d/high/gobject.hpp>
+#include <enduro2d/high/components/disabled.hpp>
 #include <enduro2d/high/components/scene.hpp>
 
 namespace e2d::bindings::high
 {
     void bind_scene(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<scene>>("scene",
+        l.new_usertype<gcomponent<scene>>("scene",
+            sol::no_constructor,
+
+            "enable", [](gcomponent<scene>& c){
+                c.owner().component<disabled<scene>>().remove();
+            },
+
+            "disable", [](gcomponent<scene>& c){
+                c.owner().component<disabled<scene>>().ensure();
+            },
+
+            "enabled", sol::property(
+                [](const gcomponent<scene>& c) -> bool {
+                    return !c.owner().component<disabled<scene>>().exists();
+                },
+                [](gcomponent<scene>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<scene>>().remove();
+                    } else {
+                        c.owner().component<disabled<scene>>().ensure();
+                    }
+                }
+            ),
+
+            "disabled", sol::property(
+                [](const gcomponent<scene>& c) -> bool {
+                    return c.owner().component<disabled<scene>>().exists();
+                },
+                [](gcomponent<scene>& c, bool yesno){
+                    if ( yesno ) {
+                        c.owner().component<disabled<scene>>().ensure();
+                    } else {
+                        c.owner().component<disabled<scene>>().remove();
+                    }
+                }
+            ),
+
             "depth", sol::property(
-                [](const gcomponent<scene>& b){ return b->depth(); },
-                [](gcomponent<scene>& b, i32 v){ b->depth(v); })
+                [](const gcomponent<scene>& c) -> i32 {
+                    return c->depth();
+                },
+                [](gcomponent<scene>& c, i32 v){
+                    c->depth(v);
+                })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/spine_player_binds.cpp

@@ -1,167 +1,278 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
 #include <enduro2d/high/gobject.hpp>
+#include <enduro2d/high/components/commands.hpp>
 #include <enduro2d/high/components/spine_player.hpp>
-#include <enduro2d/high/components/spine_player_cmd.hpp>
-#include <enduro2d/high/components/spine_player_evt.hpp>
 
 namespace e2d::bindings::high
 {
     void bind_spine_player(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<spine_player>>("spine_player",
+        l.new_usertype<gcomponent<spine_player>>("spine_player",
+            sol::no_constructor,
+
             "spine", sol::property(
-                [](const gcomponent<spine_player>& sp){ return sp->spine(); },
-                [](gcomponent<spine_player>& sp, const spine_asset::ptr& v){ sp->spine(v); }),
+                [](const gcomponent<spine_player>& c) -> spine_asset::ptr {
+                    return c->spine();
+                },
+                [](gcomponent<spine_player>& c, const spine_asset::ptr& v){
+                    c->spine(v);
+                }),
 
-            "skin", [](gcomponent<spine_player>& sp, const char* name){
-                sp->skin(name);
+            "skin", [](gcomponent<spine_player>& c, str_view name) -> bool {
+                return c->skin(name);
             },
 
-            "attachment", [](gcomponent<spine_player>& sp, const char* slot, const char* name){
-                sp->attachment(slot, name);
+            "attachment", [](gcomponent<spine_player>& c, str_view slot, str_view name) -> bool {
+                return c->attachment(slot, name);
             },
 
-            "has_skin", [](const gcomponent<spine_player>& sp, const char* name){
-                return sp->has_skin(name);
+            "has_skin", [](const gcomponent<spine_player>& c, str_view name){
+                return c->has_skin(name);
             },
 
-            "has_animation", [](const gcomponent<spine_player>& sp, const char* name){
-                return sp->has_animation(name);
+            "has_animation", [](const gcomponent<spine_player>& c, str_view name){
+                return c->has_animation(name);
             },
 
-            "add_command", [](gcomponent<spine_player>& sp, spine_player_cmd::command cmd){
-                sp.owner().component<spine_player_cmd>().ensure().add_command(std::move(cmd));
+            "add_command", [](
+                gcomponent<spine_player>& c,
+                spine_player_commands::command cmd)
+            {
+                c.owner()
+                .component<commands<spine_player_commands::command>>()
+                .ensure()
+                .add(std::move(cmd));
             }
         );
 
-        //
-        // commands
-        //
-
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_cmd::clear_track_cmd>("clear_track_cmd",
-            sol::constructors<spine_player_cmd::clear_track_cmd(u32)>(),
-            "track", sol::property(&spine_player_cmd::clear_track_cmd::track)
-        );
-
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_cmd::set_anim_cmd>("set_anim_cmd",
-            sol::constructors<spine_player_cmd::set_anim_cmd(u32,str)>(),
-            "track", sol::property(&spine_player_cmd::set_anim_cmd::track),
-            "name", sol::property(&spine_player_cmd::set_anim_cmd::name),
-
-            "loop", sol::property(
-                sol::resolve<bool()const>(&spine_player_cmd::set_anim_cmd::loop),
-                sol::resolve<spine_player_cmd::set_anim_cmd&(bool)>(&spine_player_cmd::set_anim_cmd::loop)),
-            "end_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::set_anim_cmd::end_message),
-                sol::resolve<spine_player_cmd::set_anim_cmd&(str)>(&spine_player_cmd::set_anim_cmd::end_message)),
-            "complete_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::set_anim_cmd::complete_message),
-                sol::resolve<spine_player_cmd::set_anim_cmd&(str)>(&spine_player_cmd::set_anim_cmd::complete_message))
-        );
-
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_cmd::add_anim_cmd>("add_anim_cmd",
-            sol::constructors<spine_player_cmd::add_anim_cmd(u32,str)>(),
-            "track", sol::property(&spine_player_cmd::add_anim_cmd::track),
-            "name", sol::property(&spine_player_cmd::add_anim_cmd::name),
-
-            "loop", sol::property(
-                sol::resolve<bool()const>(&spine_player_cmd::add_anim_cmd::loop),
-                sol::resolve<spine_player_cmd::add_anim_cmd&(bool)>(&spine_player_cmd::add_anim_cmd::loop)),
-            "delay", sol::property(
-                sol::resolve<secf()const>(&spine_player_cmd::add_anim_cmd::delay),
-                sol::resolve<spine_player_cmd::add_anim_cmd&(secf)>(&spine_player_cmd::add_anim_cmd::delay)),
-            "end_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::add_anim_cmd::end_message),
-                sol::resolve<spine_player_cmd::add_anim_cmd&(str)>(&spine_player_cmd::add_anim_cmd::end_message)),
-            "complete_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::add_anim_cmd::complete_message),
-                sol::resolve<spine_player_cmd::add_anim_cmd&(str)>(&spine_player_cmd::add_anim_cmd::complete_message))
-        );
-
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_cmd::set_empty_anim_cmd>("set_empty_anim_cmd",
-            sol::constructors<spine_player_cmd::set_empty_anim_cmd(u32)>(),
-            "track", sol::property(&spine_player_cmd::set_empty_anim_cmd::track),
-
-            "mix_duration", sol::property(
-                sol::resolve<secf()const>(&spine_player_cmd::set_empty_anim_cmd::mix_duration),
-                sol::resolve<spine_player_cmd::set_empty_anim_cmd&(secf)>(&spine_player_cmd::set_empty_anim_cmd::mix_duration)),
-            "end_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::set_empty_anim_cmd::end_message),
-                sol::resolve<spine_player_cmd::set_empty_anim_cmd&(str)>(&spine_player_cmd::set_empty_anim_cmd::end_message)),
-            "complete_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::set_empty_anim_cmd::complete_message),
-                sol::resolve<spine_player_cmd::set_empty_anim_cmd&(str)>(&spine_player_cmd::set_empty_anim_cmd::complete_message))
-        );
-
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_cmd::add_empty_anim_cmd>("add_empty_anim_cmd",
-            sol::constructors<spine_player_cmd::add_empty_anim_cmd(u32)>(),
-            "track", sol::property(&spine_player_cmd::add_empty_anim_cmd::track),
-
-            "delay", sol::property(
-                sol::resolve<secf()const>(&spine_player_cmd::add_empty_anim_cmd::delay),
-                sol::resolve<spine_player_cmd::add_empty_anim_cmd&(secf)>(&spine_player_cmd::add_empty_anim_cmd::delay)),
-            "mix_duration", sol::property(
-                sol::resolve<secf()const>(&spine_player_cmd::add_empty_anim_cmd::mix_duration),
-                sol::resolve<spine_player_cmd::add_empty_anim_cmd&(secf)>(&spine_player_cmd::add_empty_anim_cmd::mix_duration)),
-            "end_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::add_empty_anim_cmd::end_message),
-                sol::resolve<spine_player_cmd::add_empty_anim_cmd&(str)>(&spine_player_cmd::add_empty_anim_cmd::end_message)),
-            "complete_message", sol::property(
-                sol::resolve<const str&()const>(&spine_player_cmd::add_empty_anim_cmd::complete_message),
-                sol::resolve<spine_player_cmd::add_empty_anim_cmd&(str)>(&spine_player_cmd::add_empty_anim_cmd::complete_message))
-        );
-
         //
         // events
         //
 
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_evt::custom_evt>("custom_evt",
-            sol::constructors<spine_player_evt::custom_evt(str_hash)>(),
-            "name", sol::property(&spine_player_evt::custom_evt::name),
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_events::custom_evt>("custom_evt",
+            sol::constructors<
+                spine_player_events::custom_evt(str)>(),
+
+            "name", sol::property(
+                [](const spine_player_events::custom_evt& c) -> str {
+                    return c.name();
+                }),
 
             "int_value", sol::property(
-                sol::resolve<i32()const>(&spine_player_evt::custom_evt::int_value),
-                sol::resolve<spine_player_evt::custom_evt&(i32)>(&spine_player_evt::custom_evt::int_value)),
+                [](const spine_player_events::custom_evt& c) -> i32 {
+                    return c.int_value();
+                },
+                sol::resolve<spine_player_events::custom_evt&(i32)>(
+                    &spine_player_events::custom_evt::int_value)),
+
             "float_value", sol::property(
-                sol::resolve<f32()const>(&spine_player_evt::custom_evt::float_value),
-                sol::resolve<spine_player_evt::custom_evt&(f32)>(&spine_player_evt::custom_evt::float_value)),
+                [](const spine_player_events::custom_evt& c) -> f32 {
+                    return c.float_value();
+                },
+                sol::resolve<spine_player_events::custom_evt&(f32)>(
+                    &spine_player_events::custom_evt::float_value)),
+
             "string_value", sol::property(
-                sol::resolve<const str&()const>(&spine_player_evt::custom_evt::string_value),
-                sol::resolve<spine_player_evt::custom_evt&(str)>(&spine_player_evt::custom_evt::string_value))
+                [](const spine_player_events::custom_evt& c) -> str {
+                    return c.string_value();
+                },
+                sol::resolve<spine_player_events::custom_evt&(str)>(
+                    &spine_player_events::custom_evt::string_value))
         );
 
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_evt::end_evt>("end_evt",
-            sol::constructors<spine_player_evt::end_evt(str)>(),
-            "message", sol::property(&spine_player_evt::end_evt::message)
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_events::end_evt>("end_evt",
+            sol::constructors<
+                spine_player_events::end_evt(str)>(),
+
+            "message", sol::property(
+                [](const spine_player_events::end_evt& c) -> str {
+                    return c.message();
+                })
         );
 
-        l["e2d"].get_or_create<sol::table>()
-        ["spine_player"].get_or_create<sol::table>()
-        .new_usertype<spine_player_evt::complete_evt>("complete_evt",
-            sol::constructors<spine_player_evt::complete_evt(str)>(),
-            "message", sol::property(&spine_player_evt::complete_evt::message)
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_events::complete_evt>("complete_evt",
+            sol::constructors<
+                spine_player_events::complete_evt(str)>(),
+
+            "message", sol::property(
+                [](const spine_player_events::complete_evt& c) -> str {
+                    return c.message();
+                })
+        );
+
+        //
+        // commands
+        //
+
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_commands::clear_track_cmd>("clear_track_cmd",
+            sol::constructors<
+                spine_player_commands::clear_track_cmd(u32)>(),
+
+            "track", sol::property(
+                [](const spine_player_commands::clear_track_cmd& c) -> u32 {
+                    return c.track();
+                })
+        );
+
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_commands::set_anim_cmd>("set_anim_cmd",
+            sol::constructors<
+                spine_player_commands::set_anim_cmd(u32,str)>(),
+
+            "track", sol::property(
+                [](const spine_player_commands::set_anim_cmd& c) -> u32 {
+                    return c.track();
+                }),
+
+            "name", sol::property(
+                [](const spine_player_commands::set_anim_cmd& c) -> str {
+                    return c.name();
+                }),
+
+            "loop", sol::property(
+                [](const spine_player_commands::set_anim_cmd& c) -> bool {
+                    return c.loop();
+                },
+                sol::resolve<spine_player_commands::set_anim_cmd&(bool)>(
+                    &spine_player_commands::set_anim_cmd::loop)),
+
+            "end_message", sol::property(
+                [](const spine_player_commands::set_anim_cmd& c) -> str {
+                    return c.end_message();
+                },
+                sol::resolve<spine_player_commands::set_anim_cmd&(str)>(
+                    &spine_player_commands::set_anim_cmd::end_message)),
+
+            "complete_message", sol::property(
+                [](const spine_player_commands::set_anim_cmd& c) -> str {
+                    return c.complete_message();
+                },
+                sol::resolve<spine_player_commands::set_anim_cmd&(str)>(
+                    &spine_player_commands::set_anim_cmd::complete_message))
+        );
+
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_commands::add_anim_cmd>("add_anim_cmd",
+            sol::constructors<
+                spine_player_commands::add_anim_cmd(u32,str)>(),
+
+            "track", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> u32 {
+                    return c.track();
+                }),
+
+            "name", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> str {
+                    return c.name();
+                }),
+
+            "loop", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> bool {
+                    return c.loop();
+                },
+                sol::resolve<spine_player_commands::add_anim_cmd&(bool)>(
+                    &spine_player_commands::add_anim_cmd::loop)),
+
+            "delay", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> f32 {
+                    return c.delay();
+                },
+                sol::resolve<spine_player_commands::add_anim_cmd&(f32)>(
+                    &spine_player_commands::add_anim_cmd::delay)),
+
+            "end_message", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> str {
+                    return c.end_message();
+                },
+                sol::resolve<spine_player_commands::add_anim_cmd&(str)>(
+                    &spine_player_commands::add_anim_cmd::end_message)),
+
+            "complete_message", sol::property(
+                [](const spine_player_commands::add_anim_cmd& c) -> str {
+                    return c.complete_message();
+                },
+                sol::resolve<spine_player_commands::add_anim_cmd&(str)>(
+                    &spine_player_commands::add_anim_cmd::complete_message))
+        );
+
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_commands::set_empty_anim_cmd>("set_empty_anim_cmd",
+            sol::constructors<
+                spine_player_commands::set_empty_anim_cmd(u32)>(),
+
+            "track", sol::property(
+                [](const spine_player_commands::set_empty_anim_cmd& c) -> u32 {
+                    return c.track();
+                }),
+
+            "mix_duration", sol::property(
+                [](const spine_player_commands::set_empty_anim_cmd& c) -> f32 {
+                    return c.mix_duration();
+                },
+                sol::resolve<spine_player_commands::set_empty_anim_cmd&(f32)>(
+                    &spine_player_commands::set_empty_anim_cmd::mix_duration)),
+
+            "end_message", sol::property(
+                [](const spine_player_commands::set_empty_anim_cmd& c) -> str {
+                    return c.end_message();
+                },
+                sol::resolve<spine_player_commands::set_empty_anim_cmd&(str)>(
+                    &spine_player_commands::set_empty_anim_cmd::end_message)),
+
+            "complete_message", sol::property(
+                [](const spine_player_commands::set_empty_anim_cmd& c) -> str {
+                    return c.complete_message();
+                },
+                sol::resolve<spine_player_commands::set_empty_anim_cmd&(str)>(
+                    &spine_player_commands::set_empty_anim_cmd::complete_message))
+        );
+
+        l["spine_player"].get_or_create<sol::table>()
+        .new_usertype<spine_player_commands::add_empty_anim_cmd>("add_empty_anim_cmd",
+            sol::constructors<spine_player_commands::add_empty_anim_cmd(u32)>(),
+
+            "track", sol::property(
+                [](const spine_player_commands::add_empty_anim_cmd& c) -> u32 {
+                    return c.track();
+                }),
+
+            "delay", sol::property(
+                [](const spine_player_commands::add_empty_anim_cmd& c) -> f32 {
+                    return c.delay();
+                },
+                sol::resolve<spine_player_commands::add_empty_anim_cmd&(f32)>(
+                    &spine_player_commands::add_empty_anim_cmd::delay)),
+
+            "mix_duration", sol::property(
+                [](const spine_player_commands::add_empty_anim_cmd& c) -> f32 {
+                    return c.mix_duration();
+                },
+                sol::resolve<spine_player_commands::add_empty_anim_cmd&(f32)>(
+                    &spine_player_commands::add_empty_anim_cmd::mix_duration)),
+
+            "end_message", sol::property(
+                [](const spine_player_commands::add_empty_anim_cmd& c) -> str {
+                    return c.end_message();
+                },
+                sol::resolve<spine_player_commands::add_empty_anim_cmd&(str)>(
+                    &spine_player_commands::add_empty_anim_cmd::end_message)),
+
+            "complete_message", sol::property(
+                [](const spine_player_commands::add_empty_anim_cmd& c) -> str {
+                    return c.complete_message();
+                },
+                sol::resolve<spine_player_commands::add_empty_anim_cmd&(str)>(
+                    &spine_player_commands::add_empty_anim_cmd::complete_message))
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/components/sprite_renderer_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "../_high_binds.hpp"
 
@@ -12,26 +12,44 @@
 namespace e2d::bindings::high
 {
     void bind_sprite_renderer(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["components"].get_or_create<sol::table>()
-        .new_usertype<gcomponent<sprite_renderer>>("sprite_renderer",
+        l.new_usertype<gcomponent<sprite_renderer>>("sprite_renderer",
+            sol::no_constructor,
+
             "tint", sol::property(
-                [](const gcomponent<sprite_renderer>& l){ return l->tint(); },
-                [](gcomponent<sprite_renderer>& l, const color32& v){ l->tint(v); }),
+                [](const gcomponent<sprite_renderer>& c) -> color32 {
+                    return c->tint();
+                },
+                [](gcomponent<sprite_renderer>& c, const color32& v){
+                    c->tint(v);
+                }),
+
             "blending", sol::property(
-                [](const gcomponent<sprite_renderer>& l){ return l->blending(); },
-                [](gcomponent<sprite_renderer>& l, sprite_renderer::blendings v){ l->blending(v); }),
+                [](const gcomponent<sprite_renderer>& c) -> sprite_renderer::blendings {
+                    return c->blending();
+                },
+                [](gcomponent<sprite_renderer>& c, sprite_renderer::blendings v){
+                    c->blending(v);
+                }),
+
             "filtering", sol::property(
-                [](const gcomponent<sprite_renderer>& l){ return l->filtering(); },
-                [](gcomponent<sprite_renderer>& l, bool v){ l->filtering(v); }),
+                [](const gcomponent<sprite_renderer>& c) -> bool {
+                    return c->filtering();
+                },
+                [](gcomponent<sprite_renderer>& c, bool v){
+                    c->filtering(v);
+                }),
+
             "sprite", sol::property(
-                [](const gcomponent<sprite_renderer>& l){ return l->sprite(); },
-                [](gcomponent<sprite_renderer>& l, const sprite_asset::ptr& v){ l->sprite(v); })
+                [](const gcomponent<sprite_renderer>& c) -> sprite_asset::ptr {
+                    return c->sprite();
+                },
+                [](gcomponent<sprite_renderer>& c, const sprite_asset::ptr& v){
+                    c->sprite(v);
+                })
         );
 
     #define SPRITE_RENDERER_BLENDINGS_PAIR(x) {#x, sprite_renderer::blendings::x},
-        l["e2d"].get_or_create<sol::table>()
-        ["sprite_renderer"].get_or_create<sol::table>()
+        l["sprite_renderer"].get_or_create<sol::table>()
         .new_enum<sprite_renderer::blendings>("blendings", {
             SPRITE_RENDERER_BLENDINGS_PAIR(normal)
             SPRITE_RENDERER_BLENDINGS_PAIR(additive)

sources/enduro2d/high/bindings/high_binds/gobject_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "_high_binds.hpp"
 
@@ -23,13 +23,20 @@
 namespace e2d::bindings::high
 {
     void bind_gobject(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["high"].get_or_create<sol::table>()
-        .new_usertype<gobject>("gobject",
-            "alive", sol::property(&gobject::alive),
-            "valid", sol::property(&gobject::valid),
+        l.new_usertype<gobject>("gobject",
+            sol::no_constructor,
 
-            "destroy", &gobject::destroy,
+            "alive", sol::property([](const gobject& go) -> bool {
+                return go.alive();
+            }),
+
+            "valid", sol::property([](const gobject& go) -> bool {
+                return go.valid();
+            }),
+
+            "destroy", [](gobject& go){
+                go.destroy();
+            },
 
             "actor", sol::property([](gobject& go){ return component_wrapper<actor>{go}; }),
             "behaviour", sol::property([](gobject& go){ return component_wrapper<behaviour>{go}; }),

sources/enduro2d/high/bindings/high_binds/luasol_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "_high_binds.hpp"
 
@@ -11,8 +11,7 @@
 namespace e2d::bindings::high
 {
     void bind_luasol(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["high"].get_or_create<sol::table>()
-        .new_usertype<luasol>("luasol");
+        l.new_usertype<luasol>("luasol",
+            sol::no_constructor);
     }
 }

sources/enduro2d/high/bindings/high_binds/node_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "_high_binds.hpp"
 
@@ -11,65 +11,115 @@
 namespace e2d::bindings::high
 {
     void bind_node(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["high"].get_or_create<sol::table>()
-        .new_usertype<node>("node",
+        l.new_usertype<node>("node",
+            sol::no_constructor,
+
             "owner", sol::property(
-                [](const node& n){ return n.owner(); }),
+                [](const node& n) -> gobject {
+                    return n.owner();
+                }),
 
             "transform", sol::property(
-                [](const node& n){ return n.transform(); },
+                [](const node& n) -> t3f { return n.transform(); },
                 sol::resolve<void(const t3f&)>(&node::transform)),
+
             "translation", sol::property(
-                [](const node& n){ return n.translation(); },
+                [](const node& n) -> v3f { return n.translation(); },
                 sol::resolve<void(const v3f&)>(&node::translation)),
+
             "rotation", sol::property(
-                [](const node& n){ return n.rotation(); },
+                [](const node& n) -> q4f { return n.rotation(); },
                 sol::resolve<void(const q4f&)>(&node::rotation)),
+
             "scale", sol::property(
-                [](const node& n){ return n.scale(); },
+                [](const node& n) -> v3f { return n.scale(); },
                 sol::resolve<void(const v3f&)>(&node::scale)),
 
             "local_matrix", sol::property(
-                [](const node& n){ return n.local_matrix(); }),
+                [](const node& n) -> m4f { return n.local_matrix(); }),
+
             "world_matrix", sol::property(
-                [](const node& n){ return n.world_matrix(); }),
+                [](const node& n) -> m4f { return n.world_matrix(); }),
 
             "root", sol::property(
-                [](const node& n){ return n.root(); }),
-            "parent", sol::property(
-                [](const node& n){ return n.parent(); }),
+                [](node& n) -> node_iptr { return n.root(); }),
 
-            "remove_from_parent", &node::remove_from_parent,
-            "remove_all_children", &node::remove_all_children,
+            "parent", sol::property(
+                [](node& n) -> node_iptr { return n.parent(); }),
+
+            "remove_from_parent", [](node& n) -> bool {
+                return n.remove_from_parent();
+            },
+
+            "remove_all_children", [](node& n) -> std::size_t {
+                return n.remove_all_children();
+            },
 
             "child_count", sol::property(
-                [](const node& n){ return n.child_count(); }),
+                [](const node& n) -> std::size_t { return n.child_count(); }),
+
             "child_count_recursive", sol::property(
-                [](const node& n){ return n.child_count_recursive(); }),
+                [](const node& n) -> std::size_t { return n.child_count_recursive(); }),
 
-            "add_child", &node::add_child,
-            "add_child_to_back", &node::add_child_to_back,
-            "add_child_to_front", &node::add_child_to_front,
-            "add_child_before", &node::add_child_before,
-            "add_child_after", &node::add_child_after,
-            "add_sibling_before", &node::add_sibling_before,
-            "add_sibling_after", &node::add_sibling_after,
-            "remove_child", &node::remove_child,
+            "add_child", [](node& n, const node_iptr& c) -> bool {
+                return n.add_child(c);
+            },
 
-            "send_backward", &node::send_backward,
-            "bring_to_back", &node::bring_to_back,
-            "send_forward", &node::send_forward,
-            "bring_to_front", &node::bring_to_front,
+            "add_child_to_back", [](node& n, const node_iptr& c) -> bool {
+                return n.add_child_to_back(c);
+            },
+
+            "add_child_to_front", [](node& n, const node_iptr& c) -> bool {
+                return n.add_child_to_front(c);
+            },
+
+            "add_child_before", [](node& n, const node_iptr& b, const node_iptr& c) -> bool {
+                return n.add_child_before(b, c);
+            },
+
+            "add_child_after", [](node& n, const node_iptr& a, const node_iptr& c) -> bool {
+                return n.add_child_after(a, c);
+            },
+
+            "add_sibling_before", [](node& n, const node_iptr& s) -> bool {
+                return n.add_sibling_before(s);
+            },
+
+            "add_sibling_after", [](node& n, const node_iptr& s) -> bool {
+                return n.add_sibling_after(s);
+            },
+
+            "remove_child", [](node& n, const node_iptr& c) -> bool {
+                return n.remove_child(c);
+            },
+
+            "send_backward", [](node& n) -> bool {
+                return n.send_backward();
+            },
+
+            "bring_to_back", [](node& n) -> bool {
+                return n.bring_to_back();
+            },
+
+            "send_forward", [](node& n) -> bool {
+                return n.send_forward();
+            },
+
+            "bring_to_front", [](node& n) -> bool {
+                return n.bring_to_front();
+            },
 
             "first_child", sol::property(
-                [](const node& n){ return n.first_child(); }),
+                [](node& n) -> node_iptr { return n.first_child(); }),
+
             "last_child", sol::property(
-                [](const node& n){ return n.last_child(); }),
+                [](node& n) -> node_iptr { return n.last_child(); }),
+
             "prev_sibling", sol::property(
-                [](const node& n){ return n.prev_sibling(); }),
+                [](node& n) -> node_iptr { return n.prev_sibling(); }),
+
             "next_sibling", sol::property(
-                [](const node& n){ return n.next_sibling(); })
+                [](node& n) -> node_iptr { return n.next_sibling(); })
         );
     }
 }

sources/enduro2d/high/bindings/high_binds/world_binds.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include "_high_binds.hpp"
 
@@ -11,8 +11,29 @@
 namespace e2d::bindings::high
 {
     void bind_world(sol::state& l) {
-        l["e2d"].get_or_create<sol::table>()
-        ["high"].get_or_create<sol::table>()
-        .new_usertype<world>("world");
+        l.new_usertype<world>("world",
+            sol::no_constructor,
+
+            "instantiate", sol::overload(
+                [](world& w) -> gobject {
+                    return w.instantiate();
+                },
+                [](world& w, const prefab& prefab) -> gobject {
+                    return w.instantiate(prefab);
+                },
+                [](world& w, const node_iptr& parent) -> gobject {
+                    return w.instantiate(parent);
+                },
+                [](world& w, const prefab& prefab, const node_iptr& parent) -> gobject {
+                    return w.instantiate(prefab, parent);
+                },
+                [](world& w, const node_iptr& parent, const t3f& transform) -> gobject {
+                    return w.instantiate(parent, transform);
+                },
+                [](world& w, const prefab& prefab, const node_iptr& parent, const t3f& transform) -> gobject {
+                    return w.instantiate(prefab, parent, transform);
+                }
+            )
+        );
     }
 }

sources/enduro2d/high/gobject.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
-* This file is part of the "Enduro2D"
-* For conditions of distribution and use, see copyright notice in LICENSE.md
-* Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
-******************************************************************************/
+ * This file is part of the "Enduro2D"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
 
 #include <enduro2d/high/gobject.hpp>