Merge branch 'main' into feature/fill-classes-singletons

Author: gilzoide

.github/workflows/build.yml

@@ -273,4 +273,6 @@ jobs:
           path: |
             LICENSE
             addons/lua-gdextension/**
+            addons/lua-gdextension/build/.gdignore
+          include-hidden-files: true
 

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
-## [Unreleased](https://github.com/gilzoide/lua-gdextension/compare/0.5.0...HEAD)
+## [Unreleased](https://github.com/gilzoide/lua-gdextension/compare/0.6.0...HEAD)
+### Changed
+- Opening `GODOT_CLASSES` now registers all classes at once instead of setting up a lazy getter in `_G`'s metatable
+- Opening `GODOT_SINGLETONS` now registers all singletons at once instead of setting up a lazy getter in `_G`'s metatable
+
+
+
+## [0.6.0](https://github.com/gilzoide/lua-gdextension/releases/tag/0.6.0)
 ### Added
 - Support for constructing typed arrays in Lua using the idiom `Array[some_type]()`
 - Support for constructing typed dictionaries in Lua using the idiom `Dictionary[key_type][value_type]()`
@@ -27,8 +34,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.
-- Opening `GODOT_CLASSES` now registers all classes at once instead of setting up a lazy getter in `_G`'s metatable
-- Opening `GODOT_SINGLETONS` now registers all singletons at once instead of setting up a lazy getter in `_G`'s metatable
+- 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
@@ -40,6 +52,11 @@
 - Convert null Object Variants (`<Object#null>`) to `nil` when passing them to Lua
 - Convert freed Object Variants (`<Freed Object>`) to `nil` when passing them to Lua
 - Fixed `LuaJIT core/library version mismatch` errors in LuaJIT builds
+- `LuaScriptResourceFormatLoader::_load` now respects the cache mode, fixing "Another resource is loaded from path 'res://...' (possible cyclic resource inclusion)." errors
+- Error messages from Lua code using the wrong stack index
+- Crashes when passing Lua primitives to `typeof`, `Variant.is`, `Variant.get_type`, `Variant.booleanize`, `Variant.duplicate`, `Variant.get_type_name`, `Variant.hash`, `Variant.recursive_hash` and `Variant.hash_compare`
+- The `addons/lua-gdextension/build/.gdignore` file was added to the distributed build.
+  This fixes import errors when opening the Godot editor with the LuaJIT build.
 
 
 ## [0.5.0](https://github.com/gilzoide/lua-gdextension/releases/tag/0.5.0)

README.md

@@ -1,6 +1,6 @@
 # Lua GDExtension
-[![Godot Asset Library page](https://img.shields.io/static/v1?logo=godotengine&label=asset%20library%20%28Lua%205.4%29&color=478CBF&message=0.5.0)](https://godotengine.org/asset-library/asset/2330)
-[![Godot Asset Library page](https://img.shields.io/static/v1?logo=godotengine&label=asset%20library%20%28LuaJIT%29&color=478CBF&message=0.5.0)](https://godotengine.org/asset-library/asset/2330)
+[![Godot Asset Library page](https://img.shields.io/static/v1?logo=godotengine&label=asset%20library%20%28Lua%205.4%29&color=478CBF&message=0.6.0)](https://godotengine.org/asset-library/asset/2330)
+[![Godot Asset Library page](https://img.shields.io/static/v1?logo=godotengine&label=asset%20library%20%28LuaJIT%29&color=478CBF&message=0.6.0)](https://godotengine.org/asset-library/asset/2330)
 [![Build and Test workflow](https://github.com/gilzoide/lua-gdextension/actions/workflows/build.yml/badge.svg)](https://github.com/gilzoide/lua-gdextension/actions/workflows/build.yml)
 
 <img src="addons/lua-gdextension/icon.png" alt="Lua GDExtension icon" width="150" height="150"/>
@@ -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
 ```

addons/lua-gdextension/plugin.cfg

@@ -3,5 +3,5 @@
 name="Lua GDExtension"
 description="Tools for Lua GDExtension: REPL tab"
 author="gilzoide"
-version="0.5.0"
+version="0.6.0"
 script="plugin.gd"

doc_classes/LuaFunction.xml

@@ -26,7 +26,7 @@
 				[codeblocks]
 				[gdscript]
 				var lua_state = LuaState.new()
-				var add_function = lua_state.load_string("return function(a, b) return a + b end")
+				var add_function = lua_state.do_string("return function(a, b) return a + b end")
 				# Call function using invoke
 				var result = add_function.invoke(1, 2)
 				print(result) # Prints 3
@@ -45,7 +45,7 @@
 				[codeblocks]
 				[gdscript]
 				var lua_state = LuaState.new()
-				var add_function = lua_state.load_string("return function(a, b) return a + b end")
+				var add_function = lua_state.do_string("return function(a, b) return a + b end")
 				# Call function using invokev
 				var result = add_function.invokev([1, 2])
 				print(result) # Prints 3

src/LuaError.cpp

@@ -75,7 +75,7 @@ String LuaError::extract_message(const sol::load_result& load_result) {
 }
 
 String LuaError::extract_message(const sol::protected_function_result& function_result) {
-	return luaL_tolstring(function_result.lua_state(), function_result.stack_index(), NULL);
+	return luaL_tolstring(function_result.lua_state(), function_result.stack_index() + function_result.return_count() - 1, NULL);
 }
 
 }

src/luaopen/variant.cpp

@@ -31,9 +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;
@@ -87,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));
 		}
 	}
 
@@ -132,11 +133,12 @@ std::tuple<sol::object, sol::object> variant__pairs(sol::this_state state, const
 	return ObjectIterator::object_pairs(state, variant);
 }
 
-VariantType variant_get_type(const Variant& variant) {
-	return VariantType(variant.get_type());
+VariantType variant_get_type(const sol::stack_object& self) {
+	return VariantType(to_variant(self).get_type());
 }
 
-bool variant_is(const Variant& variant, const sol::stack_object& type) {
+bool variant_is(const sol::stack_object& self, const sol::stack_object& type) {
+	Variant variant = to_variant(self);
 	if (type.get_type() == sol::type::nil) {
 		return variant.get_type() == Variant::NIL;
 	}
@@ -186,15 +188,15 @@ extern "C" int luaopen_godot_variant(lua_State *L) {
 			Variant(double v),
 			Variant(const char *v)
 		>(),
-		"booleanize", &Variant::booleanize,
-		"duplicate", &Variant::duplicate,
+		"booleanize", wrap_function(L, +[](const Variant& v) { return v.booleanize(); }),
+		"duplicate", wrap_function(L, +[](const Variant& self) { return self.duplicate(); }),
 		"call", &variant_call,
 		"pcall", &variant_pcall,
 		"get_type", &variant_get_type,
-		"get_type_name", &get_type_name,
-		"hash", &Variant::hash,
-		"recursive_hash", &Variant::recursive_hash,
-		"hash_compare", &Variant::hash_compare,
+		"get_type_name", wrap_function(L, &get_type_name),
+		"hash", wrap_function(L, +[](const Variant& self) { return self.hash(); }),
+		"recursive_hash", wrap_function(L, +[](const Variant& self, int recursion_count) { return self.recursive_hash(recursion_count); }),
+		"hash_compare", wrap_function(L, +[](const Variant& self, const Variant& other) { return self.hash_compare(other); }),
 		"is", &variant_is,
 		// comparison
 		sol::meta_function::equal_to, &evaluate_binary_operator<Variant::OP_EQUAL>,
@@ -224,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/script-language/LuaScriptResourceFormatLoader.cpp

@@ -26,7 +26,6 @@
 #include "LuaScript.hpp"
 #include "LuaScriptLanguage.hpp"
 #include "LuaScriptResourceFormatLoader.hpp"
-#include "../LuaTable.hpp"
 
 namespace luagdextension {
 
@@ -54,8 +53,31 @@ bool LuaScriptResourceFormatLoader::_exists(const String &p_path) const {
 }
 
 Variant LuaScriptResourceFormatLoader::_load(const String &p_path, const String &p_original_path, bool p_use_sub_threads, int32_t p_cache_mode) const {
-	Ref<LuaScript> script(LuaScriptLanguage::get_singleton()->_create_script());
-	script->set_path(p_original_path);
+	Ref<LuaScript> script;
+	script.instantiate();
+
+	switch (p_cache_mode) {
+		case ResourceFormatLoader::CACHE_MODE_IGNORE:
+		case ResourceFormatLoader::CACHE_MODE_IGNORE_DEEP:
+			break;
+
+		case ResourceFormatLoader::CACHE_MODE_REUSE: {
+			Ref<LuaScript> existing_script = ResourceLoader::get_singleton()->get_cached_ref(p_path);
+			if (existing_script.is_null()) {
+				script->set_path(p_original_path);
+			}
+			else {
+				script = existing_script;
+			}
+			break;
+		}
+
+		case ResourceFormatLoader::CACHE_MODE_REPLACE:
+		case ResourceFormatLoader::CACHE_MODE_REPLACE_DEEP:
+			script->take_over_path(p_original_path);
+			break;
+	}
+
 	script->set_source_code(FileAccess::get_file_as_string(p_path));
 	Error status = script->reload();
 	if (status == OK) {

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);
 }
 
 }