Move instance implementations to LuaScriptInstance

gilzoide · gilzoide · commit 20d6d4344b49 · 2025-03-04T21:21:26.000-03:00
diff --git a/src/LuaFunction.cpp b/src/LuaFunction.cpp
@@ -73,7 +73,7 @@ Variant LuaFunction::invoke_method(LuaScriptInstance *self, const Variant **args
 	error.error = GDEXTENSION_CALL_OK;
 
 	lua_State *L = lua_object.lua_state();
-	sol::stack::push(L, self);
+	std::ignore = to_lua(L, self);
 	for (int i = 0; i < arg_count; i++) {
 		std::ignore = to_lua(L, *args[i]);
 	}
diff --git a/src/script-language/LuaScript.cpp b/src/script-language/LuaScript.cpp
@@ -130,7 +130,14 @@ String LuaScript::_get_class_icon_path() const {
 }
 
 bool LuaScript::_has_method(const StringName &p_method) const {
-	return methods.has(p_method);
+	if (metatable.is_valid()) {
+		Variant value = metatable->get_value(p_method);
+		LuaFunction *method = Object::cast_to<LuaFunction>(value);
+		return method != nullptr;
+	}
+	else {
+		return false;
+	}
 }
 
 bool LuaScript::_has_static_method(const StringName &p_method) const {
@@ -171,7 +178,13 @@ ScriptLanguage *LuaScript::_get_language() const {
 }
 
 bool LuaScript::_has_script_signal(const StringName &p_signal) const {
-	return signals.has(p_signal);
+	if (metatable.is_valid()) {
+		Variant value = metatable->get_value(p_signal);
+		return value.get_type() == Variant::Type::SIGNAL;
+	}
+	else {
+		return false;
+	}
 }
 
 TypedArray<Dictionary> LuaScript::_get_script_signal_list() const {
@@ -241,89 +254,8 @@ Variant LuaScript::_new(const Variant **args, GDExtensionInt arg_count, GDExtens
 	return new_instance;
 }
 
-bool LuaScript::_instance_set(LuaScriptInstance *instance, const StringName& p_name, const Variant& p_value) const {
-	if (const Ref<LuaFunction> *_set = methods.getptr("_set"); _set && _set->is_valid()) {
-		Variant result = _set->ptr()->call_method(instance, p_name, p_value);
-		if (LuaError *lua_error = Object::cast_to<LuaError>(result)) {
-			ERR_FAIL_V_MSG(false, lua_error->get_message());
-		}
-		return true;
-	}
-
-	if (const LuaScriptProperty *lua_prop = properties.getptr(p_name)) {
-		if (lua_prop->setter.is_valid()) {
-			lua_prop->setter->call_method(instance, p_value);
-		}
-		else {
-			instance->properties[p_name] = p_value;
-		}
-		return true;
-	}
-	else {
-		return false;
-	}
-}
-
-bool LuaScript::_instance_get(LuaScriptInstance *instance, const StringName& p_name, Variant& p_value) const {
-	if (const Ref<LuaFunction> *_get = methods.getptr("_get"); _get && _get->is_valid()) {
-		p_value = _get->ptr()->call_method(instance, p_name);
-		if (LuaError *lua_error = Object::cast_to<LuaError>(p_value)) {
-			ERR_FAIL_V_MSG(false, lua_error->get_message());
-		}
-		if (p_value != Variant()) {
-			return true;
-		}
-	}
-
-	if (const LuaScriptProperty *lua_prop = properties.getptr(p_name)) {
-		if (lua_prop->getter.is_valid()) {
-			p_value = lua_prop->getter->call_method(instance);
-		}
-		else {
-			p_value = instance->properties.get(p_name, lua_prop->default_value);
-		}
-		return true;
-	}
-	else if (instance->properties.has(p_name)) {
-		p_value = instance->properties[p_name];
-		return true;
-	}
-	else {
-		return false;
-	}
-}
-
-Variant LuaScript::_instance_call(LuaScriptInstance *instance, const StringName& p_name, const Variant **p_args, GDExtensionInt p_argument_count, GDExtensionCallError& r_error) const {
-	if (const Ref<LuaFunction> *method = methods.getptr(p_name)) {
-		return method->ptr()->invoke_method(instance, p_args, p_argument_count, r_error);
-	}
-	else {
-		r_error.error = GDEXTENSION_CALL_ERROR_INVALID_METHOD;
-	}
-	return {};
-}
-
-void LuaScript::_instance_notification(LuaScriptInstance *instance, int32_t what, GDExtensionBool reversed) const {
-	if (const Ref<LuaFunction> *method = methods.getptr("_notification")) {
-		Variant result = method->ptr()->call_method(instance, what, reversed);
-		if (LuaError *lua_error = Object::cast_to<LuaError>(result)) {
-			ERR_FAIL_MSG(lua_error->get_message());
-		}
-	}
-}
-
-bool LuaScript::_instance_tostring(LuaScriptInstance *instance, String& str) const {
-	if (const Ref<LuaFunction> *method = methods.getptr("__tostring")) {
-		Variant result = method->ptr()->call_method(instance);
-		if (LuaError *lua_error = Object::cast_to<LuaError>(result)) {
-			ERR_FAIL_V_MSG(false, lua_error->get_message());
-		}
-		str = result;
-		return true;
-	}
-	else {
-		return false;
-	}
+Ref<LuaTable> LuaScript::get_metatable() {
+	return metatable;
 }
 
 void LuaScript::_bind_methods() {
@@ -341,53 +273,12 @@ void LuaScript::process_script_result(const Variant& result) {
 	}
 
 	metatable.reference_ptr(table);
-	methods.clear();
-	properties.clear();
-	signals.clear();
-	if (!metatable.is_valid()) {
-		return;
-	}
 
-	for (Variant key : *table) {
-		if (key == "extends") {
-			StringName class_name = table->get_value(key);
-			if (!ClassDB::class_exists(class_name)) {
-				WARN_PRINT(String("Specified base class '%s' does not exist. Unsetting 'extends'") % Array::make(class_name));
-				table->set_value(key, Variant());
-			}
-			// skip, not considered property
-			continue;
-		}
-
-		// skip special keys, they are not considered properties
-		if (key.in(Array::make("class_name", "icon", "tool"))) {
-			continue;
-		}
-
-		// methods, signals and properties must have string key
-		if (key.get_type() != Variant::STRING && key.get_type() != Variant::STRING_NAME) {
-			continue;
-		}
-
-		Variant value = table->get_value(key);
-		switch (value.get_type()) {
-			case Variant::SIGNAL:
-				signals[key] = value;
-				break;
-
-			case Variant::OBJECT:
-				if (LuaFunction *method = Object::cast_to<LuaFunction>(value)) {
-					methods[key].reference_ptr(method);
-				}
-				// fallthrough
-			default:
-				// TODO: add support for property metadata
-				properties[key] = LuaScriptProperty {
-					.type = value.get_type(),
-					.default_value = value,
-				};
-				break;
-		}
+	// Remove "extends" field if it's invalid
+	Variant base_class = table->get_value("extends");
+	if (base_class && !ClassDB::class_exists(base_class)) {
+		WARN_PRINT(String("Specified base class '%s' does not exist. Unsetting 'extends'") % Array::make(base_class));
+		table->set_value("extends", Variant());
 	}
 }
 
diff --git a/src/script-language/LuaScript.hpp b/src/script-language/LuaScript.hpp
@@ -87,23 +87,14 @@ class LuaScript : public ScriptExtension {
 
 	// Script methods
 	Variant _new(const Variant **args, GDExtensionInt arg_count, GDExtensionCallError &error);
-
-	// Methods called by ScriptInstance
-	bool _instance_set(LuaScriptInstance *instance, const StringName& p_name, const Variant& p_value) const;
-	bool _instance_get(LuaScriptInstance *instance, const StringName& p_name, Variant& p_value) const;
-	Variant _instance_call(LuaScriptInstance *instance, const StringName& p_name, const Variant **p_args, GDExtensionInt p_argument_count, GDExtensionCallError& r_error) const;
-	void _instance_notification(LuaScriptInstance *instance, int32_t what, GDExtensionBool reversed) const;
-	bool _instance_tostring(LuaScriptInstance *instance, String& str) const;
+	Ref<LuaTable> get_metatable();
 
 protected:
 	static void _bind_methods();
 	virtual String _to_string() const;
 
 	String source_code;
 	Ref<LuaTable> metatable;
-	HashMap<StringName, Ref<LuaFunction>> methods;
-	HashMap<StringName, LuaScriptProperty> properties;
-	HashMap<StringName, Signal> signals;
 
 private:
 	void process_script_result(const Variant& result);
diff --git a/src/script-language/LuaScriptInstance.cpp b/src/script-language/LuaScriptInstance.cpp
@@ -32,7 +32,7 @@ namespace luagdextension {
 LuaScriptInstance::LuaScriptInstance(Object *owner, Ref<LuaScript> script)
 	: owner(owner)
 	, script(script)
-	, properties()
+	, data(LuaScriptLanguage::get_singleton()->get_lua_state()->create_table())
 {
 	known_instances.insert(owner, this);
 }
@@ -42,11 +42,28 @@ LuaScriptInstance::~LuaScriptInstance() {
 }
 
 GDExtensionBool set_func(LuaScriptInstance *p_instance, const StringName *p_name, const Variant *p_value) {
-	return p_instance->script->_instance_set(p_instance, *p_name, p_value);
+	if (ClassDB::class_set_property(p_instance->owner, *p_name, *p_value) == OK) {
+		return true;
+	}
+
+	p_instance->data->set_value(*p_name, *p_value);
+	return true;
 }
 
 GDExtensionBool get_func(LuaScriptInstance *p_instance, const StringName *p_name, Variant *p_value) {
-	return p_instance->script->_instance_get(p_instance, *p_name, *p_value);
+	// access own data
+	if (auto data_value = p_instance->data->try_get_value(*p_name)) {
+		*p_value = *data_value;
+		return true;
+	}
+
+	// fallback to value in script
+	if (auto script_value = p_instance->script->get_metatable()->try_get_value(*p_name)) {
+		*p_value = *script_value;
+		return true;
+	}
+
+	return false;
 }
 
 GDExtensionScriptInstanceGetPropertyList get_property_list_func;
@@ -56,7 +73,7 @@ GDExtensionScriptInstanceGetClassCategory get_class_category_func;
 GDExtensionScriptInstancePropertyCanRevert property_can_revert_func;
 GDExtensionScriptInstancePropertyGetRevert property_get_revert_func;
 
-void *get_owner_func(LuaScriptInstance *p_instance) {
+Object *get_owner_func(LuaScriptInstance *p_instance) {
 	return p_instance->owner;
 }
 
@@ -73,15 +90,31 @@ GDExtensionBool has_method_func(LuaScriptInstance *p_instance, const StringName
 GDExtensionScriptInstanceGetMethodArgumentCount get_method_argument_count_func;
 
 void call_func(LuaScriptInstance *p_instance, const StringName *p_method, const Variant **p_args, GDExtensionInt p_argument_count, Variant *r_return, GDExtensionCallError *r_error) {
-	*r_return = p_instance->script->_instance_call(p_instance, *p_method, p_args, p_argument_count, *r_error);
+	Variant value = p_instance->script->get_metatable()->get_value(*p_method);
+	if (LuaFunction *method = Object::cast_to<LuaFunction>(value)) {
+		*r_return = method->invoke_method(p_instance, p_args, p_argument_count, *r_error);
+	}
+	else {
+		r_error->error = GDEXTENSION_CALL_ERROR_INVALID_METHOD;
+	}
 }
 
 void notification_func(LuaScriptInstance *p_instance, int32_t p_what, GDExtensionBool p_reversed) {
-	p_instance->script->_instance_notification(p_instance, p_what, p_reversed);
+	Variant value = p_instance->script->get_metatable()->get_value("_notification");
+	if (LuaFunction *method = Object::cast_to<LuaFunction>(value)) {
+		method->call_method(p_instance, p_what, p_reversed);
+	}
 }
 
 void to_string_func(LuaScriptInstance *p_instance, GDExtensionBool *r_is_valid, String *r_out) {
-	*r_is_valid = p_instance->script->_instance_tostring(p_instance, *r_out);
+	Variant value = p_instance->script->get_metatable()->get_value("_to_string");
+	if (LuaFunction *method = Object::cast_to<LuaFunction>(value)) {
+		*r_out = method->call_method(p_instance);
+		*r_is_valid = true;
+	}
+	else {
+		*r_is_valid = false;
+	}
 }
 
 void refcount_incremented_func(LuaScriptInstance *) {
diff --git a/src/script-language/LuaScriptInstance.hpp b/src/script-language/LuaScriptInstance.hpp
@@ -22,7 +22,6 @@
 #ifndef __LUA_SCRIPT_INSTANCE_HPP__
 #define __LUA_SCRIPT_INSTANCE_HPP__
 
-#include <godot_cpp/classes/object.hpp>
 #include <godot_cpp/classes/ref.hpp>
 #include <godot_cpp/templates/hash_map.hpp>
 
@@ -31,6 +30,7 @@ using namespace godot;
 namespace luagdextension {
 
 class LuaScript;
+class LuaTable;
 
 struct LuaScriptInstance {
 	LuaScriptInstance(Object *owner, Ref<LuaScript> script);
@@ -41,7 +41,7 @@ struct LuaScriptInstance {
 
 	Object *owner;
 	Ref<LuaScript> script;
-	Dictionary properties;
+	Ref<LuaTable> data;
 
 private:
 	static HashMap<Object *, LuaScriptInstance *> known_instances;
diff --git a/src/utils/convert_godot_lua.cpp b/src/utils/convert_godot_lua.cpp
@@ -27,6 +27,7 @@
 #include "../LuaLightUserdata.hpp"
 #include "../LuaTable.hpp"
 #include "../LuaUserdata.hpp"
+#include "../script-language/LuaScriptInstance.hpp"
 #include "Class.hpp"
 #include "DictionaryIterator.hpp"
 #include "VariantArguments.hpp"
@@ -176,6 +177,10 @@ sol::stack_object to_lua(lua_State *lua_state, const Variant& value) {
 	return sol::stack_object(lua_state, -1);
 }
 
+sol::stack_object to_lua(lua_State *lua_state, LuaScriptInstance *value) {
+	return to_lua(lua_state, value->data);
+}
+
 Array to_array(const sol::variadic_args& args) {
 	Array arr;
 	for (auto it : args) {
diff --git a/src/utils/convert_godot_lua.hpp b/src/utils/convert_godot_lua.hpp
@@ -31,6 +31,7 @@ using namespace godot;
 namespace luagdextension {
 
 class LuaTable;
+class LuaScriptInstance;
 
 Variant to_variant(const sol::object& object);
 Variant to_variant(const sol::stack_object& object);
@@ -39,6 +40,7 @@ Variant to_variant(const sol::protected_function_result& function_result);
 Variant to_variant(const sol::load_result& load_result);
 Variant to_variant(lua_State *L, int index);
 sol::stack_object to_lua(lua_State *lua_state, const Variant& value);
+sol::stack_object to_lua(lua_State *lua_state, LuaScriptInstance *value);
 
 Array to_array(const sol::variadic_args& args);
 Array to_array(const sol::table& table);

Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ Variant LuaFunction::invoke_method(LuaScriptInstance self, const Variant *args`
`73`	`73`	`error.error = GDEXTENSION_CALL_OK;`
`74`	`74`
`75`	`75`	`lua_State *L = lua_object.lua_state();`
`76`		`- sol::stack::push(L, self);`
	`76`	`+ std::ignore = to_lua(L, self);`
`77`	`77`	`for (int i = 0; i < arg_count; i++) {`
`78`	`78`	`std::ignore = to_lua(L, *args[i]);`
`79`	`79`	`}`