Merge pull request #157 from gilzoide/feature/method-bind-callable

Convert Variant and LuaScriptInstance method binds to Callable

Author: gilzoide

CHANGELOG.md

@@ -27,6 +27,13 @@
   + In "Always Evaluate" behavior, Lua code will always be evaluated
   + In "Don't Load" behavior, Lua code will not be loaded nor evaluated at all
   + Note that only evaluated scripts can be attached to Godot Objects.
+- Variant and `LuaScriptInstance` methods are now converted to Callable, so they can be more easily passed to Godot APIs such as `Signal.connect`
+  ```lua
+  -- Before this change, we had to manually instantiate Callable
+  some_signal:connect(Callable(self, "method_name"))
+  -- Now we can pass the method directly
+  some_signal:connect(self.method_name)
+  ```
 
 ### Fixed
 - Fixed cyclic references from `LuaScriptInstance` <-> `LuaState`, avoiding leaks of `LuaScript`s

README.md

@@ -67,6 +67,9 @@ local LuaBouncingLogo = {
 function LuaBouncingLogo:_ready()
 	self.position = self:get_viewport():get_size() / 2
 	self.movement = Vector2(self.linear_velocity, 0):rotated(deg_to_rad(self.initial_angle))
+
+	-- To connect a signal in Lua, you can use the method name just like in GDScript
+	self.bounced:connect(self._on_bounced)
 end
 
 -- Called every frame. 'delta' is the elapsed time since the previous frame.
@@ -80,6 +83,10 @@ function LuaBouncingLogo:_process(delta)
 	self.position = self.position + self.movement * delta
 end
 
+function LuaBouncingLogo:_on_bounced()
+	print("Bounced =D")
+end
+
 -- Return the metadata table for the script to be usable by Godot objects
 return LuaBouncingLogo
 ```

src/luaopen/variant.cpp

@@ -31,10 +31,10 @@
 #include "../utils/IndexedIterator.hpp"
 #include "../utils/ObjectIterator.hpp"
 #include "../utils/VariantType.hpp"
-#include "../utils/MethodBindByName.hpp"
 #include "../utils/convert_godot_lua.hpp"
 #include "../utils/convert_godot_std.hpp"
 #include "../utils/function_wrapper.hpp"
+#include "../utils/method_bind_impl.hpp"
 #include "../utils/string_names.hpp"
 
 using namespace godot;
@@ -88,7 +88,7 @@ sol::object variant__index(sol::this_state state, const Variant& variant, const
 			return to_lua(state, variant.get_named(string_name, is_valid));
 		}
 		else if (variant.has_method(string_name)) {
-			return sol::make_object(state, MethodBindByName(string_name));
+			return sol::make_object(state, VariantMethodBind(variant, string_name));
 		}
 	}
 
@@ -226,7 +226,7 @@ extern "C" int luaopen_godot_variant(lua_State *L) {
 		sol::meta_function::to_string, &Variant::stringify
 	);
 
-	MethodBindByName::register_usertype(state);
+	VariantMethodBind::register_usertype(state);
 	VariantType::register_usertype(state);
 
 	state.set("typeof", &variant_get_type);

src/script-language/LuaScriptInstance.cpp

@@ -31,10 +31,10 @@
 #include "../LuaError.hpp"
 #include "../LuaFunction.hpp"
 #include "../LuaTable.hpp"
-#include "../utils/MethodBindByName.hpp"
 #include "../utils/VariantArguments.hpp"
 #include "../utils/convert_godot_lua.hpp"
 #include "../utils/function_wrapper.hpp"
+#include "../utils/method_bind_impl.hpp"
 #include "../utils/string_names.hpp"
 
 namespace luagdextension {
@@ -328,7 +328,7 @@ static int lua_index(lua_State *L) {
 		if (LuaScriptInstance *instance = LuaScriptInstance::find_instance(self)) {
 			StringName key_name = key.as<StringName>();
 			if (instance->owner->has_method(key_name)) {
-				sol::stack::push(L, MethodBindByName(key_name));
+				sol::stack::push(L, LuaScriptInstanceMethodBind(instance, key_name));
 			}
 			else {
 				Variant value = instance->owner->get(key_name);
@@ -368,14 +368,16 @@ static int lua_to_string(lua_State *L) {
 }
 
 void LuaScriptInstance::register_lua(lua_State *L) {
-	metatable = sol::state_view(L).create_table_with(
+	sol::state_view state(L);
+	metatable = state.create_table_with(
 		"__index", lua_index,
 		"__newindex", lua_newindex,
 		"__tostring", lua_to_string,
 		"__metatable", "LuaScriptInstance"
 	);
 	rawget = wrap_function(L, _rawget);
 	rawset = wrap_function(L, _rawset);
+	LuaScriptInstanceMethodBind::register_usertype(state);
 }
 
 void LuaScriptInstance::unregister_lua(lua_State *L) {

src/utils/Class.cpp

@@ -21,8 +21,8 @@
  */
 #include "Class.hpp"
 
-#include "MethodBindByName.hpp"
 #include "convert_godot_lua.hpp"
+#include "method_bind_impl.hpp"
 #include "string_names.hpp"
 
 #include <godot_cpp/classes/class_db_singleton.hpp>
@@ -50,16 +50,6 @@ sol::optional<int64_t> Class::get_constant(const StringName& name) const {
 	}
 }
 
-sol::optional<MethodBindByName> Class::get_method(const StringName& name) const {
-	ClassDBSingleton *class_db = ClassDBSingleton::get_singleton();
-	if (class_db->class_has_method(class_name, name)) {
-		return MethodBindByName(name);
-	}
-	else {
-		return sol::nullopt;
-	}
-}
-
 Variant Class::construct(sol::this_state state, const sol::variadic_args& args) const {
 	auto class_db = ClassDBSingleton::get_singleton();
 	if (!class_db->can_instantiate(class_name)) {
@@ -87,8 +77,8 @@ static sol::object __index(sol::this_state state, const Class& cls, sol::stack_o
 		if (auto constant = cls.get_constant(name)) {
 			return sol::make_object(state, *constant);
 		}
-		else if (auto static_method = cls.get_method(name)) {
-			return sol::make_object(state, *static_method);
+		else if (ClassDBSingleton::get_singleton()->class_has_method(cls.get_name(), name)) {
+			return sol::make_object(state, ClassMethodBind(cls, name));
 		}
 	}
 	return sol::nil;
@@ -100,6 +90,7 @@ void Class::register_usertype(sol::state_view& state) {
 		sol::meta_function::index, &__index,
 		sol::meta_function::to_string, &Class::get_name
 	);
+	ClassMethodBind::register_usertype(state);
 }
 
 }

src/utils/Class.hpp

@@ -30,8 +30,6 @@ using namespace godot;
 
 namespace luagdextension {
 
-class MethodBindByName;
-
 /**
  * Object that represents Godot classes in Lua
  */
@@ -44,7 +42,6 @@ class Class {
 
 	const StringName& get_name() const;
 	sol::optional<int64_t> get_constant(const StringName& name) const;
-	sol::optional<MethodBindByName> get_method(const StringName& name) const;
 
 	Variant construct(sol::this_state state, const sol::variadic_args& args) const;
 

src/utils/MethodBindByName.cpp

@@ -22,9 +22,9 @@
 #include "VariantType.hpp"
 
 #include "Class.hpp"
-#include "MethodBindByName.hpp"
 #include "VariantArguments.hpp"
 #include "convert_godot_lua.hpp"
+#include "method_bind_impl.hpp"
 
 #include <godot_cpp/classes/node.hpp>
 #include <godot_cpp/classes/resource.hpp>
@@ -173,7 +173,7 @@ sol::object VariantType::__index(sol::this_state L, const VariantType& type, con
 		StringName method = key.as<StringName>();
 		Variant empty = type.construct_default();
 		if (empty.has_method(method)) {
-			return sol::make_object(L, MethodBindByName(method));
+			return sol::make_object(L, VariantTypeMethodBind(type, method));
 		}
 	}
 	else if (auto subtype = key.as<sol::optional<VariantType>>()) {
@@ -206,6 +206,7 @@ void VariantType::register_usertype(sol::state_view& state) {
 		sol::meta_function::call, &VariantType::construct,
 		sol::meta_function::to_string, &VariantType::to_string
 	);
+	VariantTypeMethodBind::register_usertype(state);
 }
 
 std::tuple<Variant::Type, StringName, Variant> VariantType::subtype_to_constructor_args(const Variant& subtype) {

src/utils/MethodBindByName.hpp

@@ -34,6 +34,7 @@
 #include "convert_godot_std.hpp"
 #include "extra_utility_functions.hpp"
 #include "load_fileaccess.hpp"
+#include "method_bind_impl.hpp"
 #include "stack_top_checker.hpp"
 
 #include <godot_cpp/core/error_macros.hpp>
@@ -79,6 +80,14 @@ Variant to_variant(const sol::basic_object<ref_t>& object) {
 				Class& cls = object.template as<Class&>();
 				return cls.get_name();
 			}
+			else if (object.template is<VariantMethodBind>()) {
+				VariantMethodBind& method_bind = object.template as<VariantMethodBind&>();
+				return method_bind.to_callable();
+			}
+			else if (object.template is<LuaScriptInstanceMethodBind>()) {
+				LuaScriptInstanceMethodBind& method_bind = object.template as<LuaScriptInstanceMethodBind&>();
+				return method_bind.to_callable();
+			}
 			else {
 				return LuaObject::wrap_object<LuaUserdata>(object);
 			}