Funexpected patches to official 3.2.3.

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "modules/spine"]
+	path = modules/spine
+	url = git@github.com:funexpected/godot-spine-module.git
+[submodule "modules/flash"]
+	path = modules/flash
+	url = git@github.com:funexpected/godot-flash-module.git
+[submodule "executables"]
+	path = executables
+	url = git@github.com:funexpected/godot.executables.git

core/bind/core_bind.cpp

@@ -108,6 +108,10 @@ PoolStringArray _ResourceLoader::get_dependencies(const String &p_path) {
 	return ret;
 };
 
+PoolStringArray _ResourceLoader::get_cached_resource_pathes() {
+	return ResourceLoader::get_cached_resource_pathes();
+}
+
 #ifndef DISABLE_DEPRECATED
 bool _ResourceLoader::has(const String &p_path) {
 	WARN_PRINTS("ResourceLoader.has() is deprecated, please replace it with the equivalent has_cached() or the new exists().");
@@ -132,6 +136,7 @@ void _ResourceLoader::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_recognized_extensions_for_type", "type"), &_ResourceLoader::get_recognized_extensions_for_type);
 	ClassDB::bind_method(D_METHOD("set_abort_on_missing_resources", "abort"), &_ResourceLoader::set_abort_on_missing_resources);
 	ClassDB::bind_method(D_METHOD("get_dependencies", "path"), &_ResourceLoader::get_dependencies);
+	ClassDB::bind_method(D_METHOD("get_cached_resource_pathes"), &_ResourceLoader::get_cached_resource_pathes);
 	ClassDB::bind_method(D_METHOD("has_cached", "path"), &_ResourceLoader::has_cached);
 	ClassDB::bind_method(D_METHOD("exists", "path", "type_hint"), &_ResourceLoader::exists, DEFVAL(""));
 #ifndef DISABLE_DEPRECATED
@@ -1643,6 +1648,11 @@ bool _Geometry::point_is_inside_triangle(const Vector2 &s, const Vector2 &a, con
 	return Geometry::is_point_in_triangle(s, a, b, c);
 }
 
+bool _Geometry::point_is_inside_polygon(const Vector2 &point, const Vector<Vector2> &polygon) const{
+
+	return Geometry::is_point_in_polygon(point, polygon);
+}
+
 PoolVector<Vector3> _Geometry::segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius) {
 
 	PoolVector<Vector3> r;
@@ -1866,6 +1876,7 @@ void _Geometry::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("segment_intersects_cylinder", "from", "to", "height", "radius"), &_Geometry::segment_intersects_cylinder);
 	ClassDB::bind_method(D_METHOD("segment_intersects_convex", "from", "to", "planes"), &_Geometry::segment_intersects_convex);
 	ClassDB::bind_method(D_METHOD("point_is_inside_triangle", "point", "a", "b", "c"), &_Geometry::point_is_inside_triangle);
+	ClassDB::bind_method(D_METHOD("point_is_inside_polygon", "point", "polygon"), &_Geometry::point_is_inside_polygon);
 
 	ClassDB::bind_method(D_METHOD("is_polygon_clockwise", "polygon"), &_Geometry::is_polygon_clockwise);
 	ClassDB::bind_method(D_METHOD("is_point_in_polygon", "point", "polygon"), &_Geometry::is_point_in_polygon);
@@ -3158,6 +3169,10 @@ Object *_Engine::get_singleton_object(const String &p_name) const {
 	return Engine::get_singleton()->get_singleton_object(p_name);
 }
 
+void _Engine::add_global_constant(const String &p_name, const Variant &p_value) const {
+	Engine::get_singleton()->add_global_constant(p_name, p_value);
+}
+
 void _Engine::set_editor_hint(bool p_enabled) {
 
 	Engine::get_singleton()->set_editor_hint(p_enabled);
@@ -3200,6 +3215,8 @@ void _Engine::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("has_singleton", "name"), &_Engine::has_singleton);
 	ClassDB::bind_method(D_METHOD("get_singleton", "name"), &_Engine::get_singleton_object);
 
+	ClassDB::bind_method(D_METHOD("add_global_constant", "name", "value"), &_Engine::add_global_constant);
+
 	ClassDB::bind_method(D_METHOD("set_editor_hint", "enabled"), &_Engine::set_editor_hint);
 	ClassDB::bind_method(D_METHOD("is_editor_hint"), &_Engine::is_editor_hint);
 

core/bind/core_bind.h

@@ -55,6 +55,7 @@ class _ResourceLoader : public Object {
 	PoolVector<String> get_recognized_extensions_for_type(const String &p_type);
 	void set_abort_on_missing_resources(bool p_abort);
 	PoolStringArray get_dependencies(const String &p_path);
+	PoolStringArray get_cached_resource_pathes();
 #ifndef DISABLE_DEPRECATED
 	bool has(const String &p_path);
 #endif // DISABLE_DEPRECATED
@@ -408,6 +409,7 @@ class _Geometry : public Object {
 	Variant ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2);
 	Variant segment_intersects_triangle(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2);
 	bool point_is_inside_triangle(const Vector2 &s, const Vector2 &a, const Vector2 &b, const Vector2 &c) const;
+	bool point_is_inside_polygon(const Vector2 &point, const Vector<Vector2> &polygon) const;
 
 	PoolVector<Vector3> segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius);
 	PoolVector<Vector3> segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, float p_height, float p_radius);
@@ -781,6 +783,8 @@ class _Engine : public Object {
 	bool has_singleton(const String &p_name) const;
 	Object *get_singleton_object(const String &p_name) const;
 
+	void add_global_constant(const String &p_name, const Variant &p_value) const;
+
 	void set_editor_hint(bool p_enabled);
 	bool is_editor_hint() const;
 

core/custom_error_handler.cpp

@@ -0,0 +1,26 @@
+#include "core/custom_error_handler.h"
+#include "core/script_language.h"
+
+void CustomErrorHandler::_handle_error(void *p_self, const char *p_func, const char *p_file, int p_line, const char *p_error, const char *p_errorexp, ErrorHandlerType p_type) {
+    CustomErrorHandler *self = (CustomErrorHandler*)p_self;
+
+    if (p_type == ERR_HANDLER_SCRIPT) {
+        self->handle_error(p_func, p_file, p_line, p_error, p_errorexp);
+    }
+}
+
+void CustomErrorHandler::handle_error(const String &p_func, const String &p_file, int p_line, const String &p_error, const String &p_errorexp) {
+    if (get_script_instance() && get_script_instance()->has_method("handle_error")) {
+		get_script_instance()->call("handle_error", p_func, p_file, p_line, p_error, p_errorexp);
+    }
+}
+
+CustomErrorHandler::CustomErrorHandler() {
+    eh.userdata = this;
+    eh.errfunc = _handle_error;
+    add_error_handler(&eh);
+}
+
+CustomErrorHandler::~CustomErrorHandler() {
+    remove_error_handler(&eh);
+}

core/custom_error_handler.h

@@ -0,0 +1,18 @@
+#ifndef ERROR_HANDLER_H
+#define ERROR_HANDLER_H
+
+#include "core/object.h"
+
+class CustomErrorHandler : public Object {
+
+    GDCLASS(CustomErrorHandler, Object);
+    ErrorHandlerList eh;
+    static void _handle_error(void *p_self, const char *p_func, const char *p_file, int p_line, const char *p_error, const char *p_errorexp, ErrorHandlerType p_type);
+
+public:
+    void handle_error(const String &p_func, const String &p_file, int p_line, const String &p_error, const String &p_errorexp);
+    CustomErrorHandler();
+    ~CustomErrorHandler();
+};
+
+#endif

core/engine.cpp

@@ -35,6 +35,7 @@
 #include "core/license.gen.h"
 #include "core/version.h"
 #include "core/version_hash.gen.h"
+#include "core/io/resource_loader.h"
 
 void Engine::set_iterations_per_second(int p_ips) {
 
@@ -210,6 +211,59 @@ void Engine::get_singletons(List<Singleton> *p_singletons) {
 		p_singletons->push_back(E->get());
 }
 
+void Engine::add_global_constant(const String &p_name, const Variant &p_value) const {
+	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+		ScriptServer::get_language(i)->add_global_constant(p_name, p_value);
+	}
+}
+
+void Engine::add_custom_error_handlers() {
+	String custom_error_handler_base_class = CustomErrorHandler::get_class_static();
+	List<StringName> global_classes;
+	ScriptServer::get_global_class_list(&global_classes);
+
+	for (List<StringName>::Element *E = global_classes.front(); E; E = E->next()) {
+
+		StringName class_name = E->get();
+		StringName base_class = ScriptServer::get_global_class_native_base(class_name);
+
+		if (base_class == custom_error_handler_base_class) {
+			String path = ScriptServer::get_global_class_path(class_name);
+			add_custom_error_handler(path);
+		}
+	}
+}
+
+void Engine::add_custom_error_handler(const String &p_path) {
+	for (List<CustomErrorHandler *>::Element *E = custom_error_handlers.front(); E; E = E->next()) {
+		if (E->get()->get_script_instance() && E->get()->get_script_instance()->get_script()->get_path() == p_path) {
+			return;
+		}
+	}
+	Ref<Resource> res = ResourceLoader::load(p_path);
+	if (res.is_null()) return;
+	if (!res->is_class("Script")) return;
+
+	Ref<Script> script = res;
+	StringName base_type = script->get_instance_base_type();
+	bool valid_type = ClassDB::is_parent_class(base_type, CustomErrorHandler::get_class_static());
+	ERR_FAIL_COND_MSG(!valid_type, "Script does not inherit a CustomErrorHandler: " + p_path + ".");
+
+	Object *obj = ClassDB::instance(base_type);
+	ERR_FAIL_COND_MSG(obj == NULL, "Cannot instance script as custom error handler, expected 'CustomErrorHandler' inheritance, got: " + String(base_type) + ".");
+
+	CustomErrorHandler *handler = Object::cast_to<CustomErrorHandler>(obj);
+	handler->set_script(script.get_ref_ptr());
+	custom_error_handlers.push_back(handler);
+}
+
+void Engine::remove_custom_error_handlers() {
+	for (List<CustomErrorHandler *>::Element *E = custom_error_handlers.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	custom_error_handlers.clear();
+}
+
 Engine *Engine::singleton = NULL;
 
 Engine *Engine::get_singleton() {

core/engine.h

@@ -31,6 +31,7 @@
 #ifndef ENGINE_H
 #define ENGINE_H
 
+#include "core/custom_error_handler.h"
 #include "core/list.h"
 #include "core/os/main_loop.h"
 #include "core/ustring.h"
@@ -69,6 +70,7 @@ class Engine {
 	bool _in_physics;
 
 	List<Singleton> singletons;
+	List<CustomErrorHandler *> custom_error_handlers;
 	Map<StringName, Object *> singleton_ptrs;
 
 	bool editor_hint;
@@ -109,6 +111,11 @@ class Engine {
 	bool has_singleton(const String &p_name) const;
 	Object *get_singleton_object(const String &p_name) const;
 
+	void add_global_constant(const String &p_name, const Variant &p_value) const;
+	void add_custom_error_handlers();
+	void add_custom_error_handler(const String &p_path);
+	void remove_custom_error_handlers();
+
 	_FORCE_INLINE_ bool get_use_pixel_snap() const { return _pixel_snap; }
 
 #ifdef TOOLS_ENABLED

core/io/resource_importer.h

@@ -99,6 +99,7 @@ class ResourceImporter : public Reference {
 public:
 	virtual String get_importer_name() const = 0;
 	virtual String get_visible_name() const = 0;
+	virtual int get_importer_version() const { return 0; }
 	virtual void get_recognized_extensions(List<String> *p_extensions) const = 0;
 	virtual String get_save_extension() const = 0;
 	virtual String get_resource_type() const = 0;

core/io/resource_loader.cpp

@@ -275,6 +275,7 @@ RES ResourceLoader::_load(const String &p_path, const String &p_original_path, c
 		return res;
 	}
 
+	print_line(String("Failed to load resource from '") + p_path + "'.");
 	ERR_FAIL_COND_V_MSG(found, RES(),
 			vformat("Failed loading resource: %s. Make sure resources have been imported by opening the project in the editor at least once.", p_path));
 
@@ -923,6 +924,16 @@ void ResourceLoader::clear_path_remaps() {
 	path_remaps.clear();
 }
 
+PoolStringArray ResourceLoader::get_cached_resource_pathes() {
+	PoolStringArray result;
+	List<String> keys;
+	ResourceCache::resources.get_key_list(&keys);
+	for (List<String>::Element *E = keys.front(); E; E = E->next()) {
+		result.push_back(E->get());
+	}
+	return result;
+}
+
 void ResourceLoader::set_load_callback(ResourceLoadedCallback p_callback) {
 	_loaded_callback = p_callback;
 }

core/io/resource_loader.h

@@ -189,6 +189,8 @@ class ResourceLoader {
 	static void load_translation_remaps();
 	static void clear_translation_remaps();
 
+	static PoolStringArray get_cached_resource_pathes();
+
 	static void set_load_callback(ResourceLoadedCallback p_callback);
 	static ResourceLoaderImport import;
 

core/object.cpp

@@ -634,7 +634,7 @@ void Object::get_property_list(List<PropertyInfo> *p_list, bool p_reversed) cons
 #ifdef TOOLS_ENABLED
 		p_list->push_back(PropertyInfo(Variant::NIL, "Script", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
 #endif
-		p_list->push_back(PropertyInfo(Variant::OBJECT, "script", PROPERTY_HINT_RESOURCE_TYPE, "Script", PROPERTY_USAGE_DEFAULT));
+		p_list->push_back(PropertyInfo(Variant::OBJECT, "script", PROPERTY_HINT_RESOURCE_TYPE, "Script", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_ALWAYS_SHARE_ON_DUPLICATE));
 	}
 	if (!metadata.empty()) {
 		p_list->push_back(PropertyInfo(Variant::DICTIONARY, "__meta__", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
@@ -700,6 +700,46 @@ Variant Object::_call_deferred_bind(const Variant **p_args, int p_argcount, Vari
 	return Variant();
 }
 
+Variant Object::_call_multilevel_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	if (p_argcount < 1) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = 0;
+		return Variant();
+	}
+
+	if (p_args[0]->get_type() != Variant::STRING) {
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+		r_error.argument = 0;
+		r_error.expected = Variant::STRING;
+		return Variant();
+	}
+	r_error.error = Variant::CallError::CALL_OK;
+
+	StringName method = *p_args[0];
+	call_multilevel(method, &p_args[1], p_argcount - 1);
+	return Variant();
+}
+
+Variant Object::_call_multilevel_reversed_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	if (p_argcount < 1) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = 0;
+		return Variant();
+	}
+
+	if (p_args[0]->get_type() != Variant::STRING) {
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+		r_error.argument = 0;
+		r_error.expected = Variant::STRING;
+		return Variant();
+	}
+	r_error.error = Variant::CallError::CALL_OK;
+
+	StringName method = *p_args[0];
+	call_multilevel_reversed(method, &p_args[1], p_argcount - 1);
+	return Variant();
+}
+
 #ifdef DEBUG_ENABLED
 static void _test_call_error(const StringName &p_func, const Variant::CallError &error) {
 
@@ -1752,9 +1792,26 @@ void Object::_bind_methods() {
 		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call_deferred", &Object::_call_deferred_bind, mi, varray(), false);
 	}
 
+	{
+		MethodInfo mi;
+		mi.name = "call_multilevel";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "method"));
+
+		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call_multilevel", &Object::_call_multilevel_bind, mi);
+	}
+
+	{
+		MethodInfo mi;
+		mi.name = "call_multilevel_reversed";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "method"));
+
+		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call_multilevel_reversed", &Object::_call_multilevel_reversed_bind, mi);
+	}
+
 	ClassDB::bind_method(D_METHOD("set_deferred", "property", "value"), &Object::set_deferred);
 
 	ClassDB::bind_method(D_METHOD("callv", "method", "arg_array"), &Object::callv);
+	//ClassDB::bind_method(D_METHOD)
 
 	ClassDB::bind_method(D_METHOD("has_method", "method"), &Object::has_method);
 

core/object.h

@@ -128,6 +128,7 @@ enum PropertyUsageFlags {
 	PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT = 1 << 23,
 	PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT = 1 << 24,
 	PROPERTY_USAGE_KEYING_INCREMENTS = 1 << 25, // Used in inspector to increment property when keyed in animation player
+	PROPERTY_USAGE_ALWAYS_SHARE_ON_DUPLICATE = 1 << 26, // If the object is duplicated this property will never be duplicated
 
 	PROPERTY_USAGE_DEFAULT = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_NETWORK,
 	PROPERTY_USAGE_DEFAULT_INTL = PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_NETWORK | PROPERTY_USAGE_INTERNATIONALIZED,
@@ -558,6 +559,8 @@ class Object {
 
 	Variant _call_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 	Variant _call_deferred_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	Variant _call_multilevel_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	Variant _call_multilevel_reversed_bind(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 
 	virtual const StringName *_get_class_namev() const {
 		if (!_class_name)

core/os/input.cpp

@@ -123,6 +123,8 @@ void Input::_bind_methods() {
 	BIND_ENUM_CONSTANT(CURSOR_HELP);
 
 	ADD_SIGNAL(MethodInfo("joy_connection_changed", PropertyInfo(Variant::INT, "device"), PropertyInfo(Variant::BOOL, "connected")));
+	ADD_SIGNAL(MethodInfo("keyboard_height_changed", PropertyInfo(Variant::INT, "height")));
+	ADD_SIGNAL(MethodInfo("keyboard_hidden"));
 }
 
 void Input::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {

core/os/input.h

@@ -117,6 +117,9 @@ class Input : public Object {
 	virtual void action_press(const StringName &p_action, float p_strength = 1.f) = 0;
 	virtual void action_release(const StringName &p_action) = 0;
 
+	virtual void keyboard_hidden() = 0;
+	virtual void virtual_keyboard_height_changed(int p_height) = 0;
+
 	void get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const;
 
 	virtual bool is_emulating_touch_from_mouse() const = 0;